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    2011 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 "target.h"
  97 #include "optabs.h"
  98 #include "insn-codes.h"
  99 #include "rtlhooks-def.h"
 100 /* Include output.h for dump_file.  */
 101 #include "output.h"
 102 #include "params.h"
 103 #include "timevar.h"
 104 #include "tree-pass.h"
 105 #include "df.h"
 106 #include "cgraph.h"
 107
 108 /* Number of attempts to combine instructions in this function.  */
 109
 110 static int combine_attempts;
 111
 112 /* Number of attempts that got as far as substitution in this function.  */
 113
 114 static int combine_merges;
 115
 116 /* Number of instructions combined with added SETs in this function.  */
 117
 118 static int combine_extras;
 119
 120 /* Number of instructions combined in this function.  */
 121
 122 static int combine_successes;
 123
 124 /* Totals over entire compilation.  */
 125
 126 static int total_attempts, total_merges, total_extras, total_successes;
 127
 128 /* combine_instructions may try to replace the right hand side of the
 129    second instruction with the value of an associated REG_EQUAL note
 130    before throwing it at try_combine.  That is problematic when there
 131    is a REG_DEAD note for a register used in the old right hand side
 132    and can cause distribute_notes to do wrong things.  This is the
 133    second instruction if it has been so modified, null otherwise.  */
 134
 135 static rtx i2mod;
 136
 137 /* When I2MOD is nonnull, this is a copy of the old right hand side.  */
 138
 139 static rtx i2mod_old_rhs;
 140
 141 /* When I2MOD is nonnull, this is a copy of the new right hand side.  */
 142
 143 static rtx i2mod_new_rhs;
 144 \f
 145 typedef struct reg_stat_struct {
 146   /* Record last point of death of (hard or pseudo) register n.  */
 147   rtx                           last_death;
 148
 149   /* Record last point of modification of (hard or pseudo) register n.  */
 150   rtx                           last_set;
 151
 152   /* The next group of fields allows the recording of the last value assigned
 153      to (hard or pseudo) register n.  We use this information to see if an
 154      operation being processed is redundant given a prior operation performed
 155      on the register.  For example, an `and' with a constant is redundant if
 156      all the zero bits are already known to be turned off.
 157
 158      We use an approach similar to that used by cse, but change it in the
 159      following ways:
 160
 161      (1) We do not want to reinitialize at each label.
 162      (2) It is useful, but not critical, to know the actual value assigned
 163          to a register.  Often just its form is helpful.
 164
 165      Therefore, we maintain the following fields:
 166
 167      last_set_value             the last value assigned
 168      last_set_label             records the value of label_tick when the
 169                                 register was assigned
 170      last_set_table_tick        records the value of label_tick when a
 171                                 value using the register is assigned
 172      last_set_invalid           set to nonzero when it is not valid
 173                                 to use the value of this register in some
 174                                 register's value
 175
 176      To understand the usage of these tables, it is important to understand
 177      the distinction between the value in last_set_value being valid and
 178      the register being validly contained in some other expression in the
 179      table.
 180
 181      (The next two parameters are out of date).
 182
 183      reg_stat[i].last_set_value is valid if it is nonzero, and either
 184      reg_n_sets[i] is 1 or reg_stat[i].last_set_label == label_tick.
 185
 186      Register I may validly appear in any expression returned for the value
 187      of another register if reg_n_sets[i] is 1.  It may also appear in the
 188      value for register J if reg_stat[j].last_set_invalid is zero, or
 189      reg_stat[i].last_set_label < reg_stat[j].last_set_label.
 190
 191      If an expression is found in the table containing a register which may
 192      not validly appear in an expression, the register is replaced by
 193      something that won't match, (clobber (const_int 0)).  */
 194
 195   /* Record last value assigned to (hard or pseudo) register n.  */
 196
 197   rtx                           last_set_value;
 198
 199   /* Record the value of label_tick when an expression involving register n
 200      is placed in last_set_value.  */
 201
 202   int                           last_set_table_tick;
 203
 204   /* Record the value of label_tick when the value for register n is placed in
 205      last_set_value.  */
 206
 207   int                           last_set_label;
 208
 209   /* These fields are maintained in parallel with last_set_value and are
 210      used to store the mode in which the register was last set, the bits
 211      that were known to be zero when it was last set, and the number of
 212      sign bits copies it was known to have when it was last set.  */
 213
 214   unsigned HOST_WIDE_INT        last_set_nonzero_bits;
 215   char                          last_set_sign_bit_copies;
 216   ENUM_BITFIELD(machine_mode)   last_set_mode : 8;
 217
 218   /* Set nonzero if references to register n in expressions should not be
 219      used.  last_set_invalid is set nonzero when this register is being
 220      assigned to and last_set_table_tick == label_tick.  */
 221
 222   char                          last_set_invalid;
 223
 224   /* Some registers that are set more than once and used in more than one
 225      basic block are nevertheless always set in similar ways.  For example,
 226      a QImode register may be loaded from memory in two places on a machine
 227      where byte loads zero extend.
 228
 229      We record in the following fields if a register has some leading bits
 230      that are always equal to the sign bit, and what we know about the
 231      nonzero bits of a register, specifically which bits are known to be
 232      zero.
 233
 234      If an entry is zero, it means that we don't know anything special.  */
 235
 236   unsigned char                 sign_bit_copies;
 237
 238   unsigned HOST_WIDE_INT        nonzero_bits;
 239
 240   /* Record the value of the label_tick when the last truncation
 241      happened.  The field truncated_to_mode is only valid if
 242      truncation_label == label_tick.  */
 243
 244   int                           truncation_label;
 245
 246   /* Record the last truncation seen for this register.  If truncation
 247      is not a nop to this mode we might be able to save an explicit
 248      truncation if we know that value already contains a truncated
 249      value.  */
 250
 251   ENUM_BITFIELD(machine_mode)   truncated_to_mode : 8;
 252 } reg_stat_type;
 253
 254 DEF_VEC_O(reg_stat_type);
 255 DEF_VEC_ALLOC_O(reg_stat_type,heap);
 256
 257 static VEC(reg_stat_type,heap) *reg_stat;
 258
 259 /* Record the luid of the last insn that invalidated memory
 260    (anything that writes memory, and subroutine calls, but not pushes).  */
 261
 262 static int mem_last_set;
 263
 264 /* Record the luid of the last CALL_INSN
 265    so we can tell whether a potential combination crosses any calls.  */
 266
 267 static int last_call_luid;
 268
 269 /* When `subst' is called, this is the insn that is being modified
 270    (by combining in a previous insn).  The PATTERN of this insn
 271    is still the old pattern partially modified and it should not be
 272    looked at, but this may be used to examine the successors of the insn
 273    to judge whether a simplification is valid.  */
 274
 275 static rtx subst_insn;
 276
 277 /* This is the lowest LUID that `subst' is currently dealing with.
 278    get_last_value will not return a value if the register was set at or
 279    after this LUID.  If not for this mechanism, we could get confused if
 280    I2 or I1 in try_combine were an insn that used the old value of a register
 281    to obtain a new value.  In that case, we might erroneously get the
 282    new value of the register when we wanted the old one.  */
 283
 284 static int subst_low_luid;
 285
 286 /* This contains any hard registers that are used in newpat; reg_dead_at_p
 287    must consider all these registers to be always live.  */
 288
 289 static HARD_REG_SET newpat_used_regs;
 290
 291 /* This is an insn to which a LOG_LINKS entry has been added.  If this
 292    insn is the earlier than I2 or I3, combine should rescan starting at
 293    that location.  */
 294
 295 static rtx added_links_insn;
 296
 297 /* Basic block in which we are performing combines.  */
 298 static basic_block this_basic_block;
 299 static bool optimize_this_for_speed_p;
 300
 301 \f
 302 /* Length of the currently allocated uid_insn_cost array.  */
 303
 304 static int max_uid_known;
 305
 306 /* The following array records the insn_rtx_cost for every insn
 307    in the instruction stream.  */
 308
 309 static int *uid_insn_cost;
 310
 311 /* The following array records the LOG_LINKS for every insn in the
 312    instruction stream as an INSN_LIST rtx.  */
 313
 314 static rtx *uid_log_links;
 315
 316 #define INSN_COST(INSN)         (uid_insn_cost[INSN_UID (INSN)])
 317 #define LOG_LINKS(INSN)         (uid_log_links[INSN_UID (INSN)])
 318
 319 /* Incremented for each basic block.  */
 320
 321 static int label_tick;
 322
 323 /* Reset to label_tick for each extended basic block in scanning order.  */
 324
 325 static int label_tick_ebb_start;
 326
 327 /* Mode used to compute significance in reg_stat[].nonzero_bits.  It is the
 328    largest integer mode that can fit in HOST_BITS_PER_WIDE_INT.  */
 329
 330 static enum machine_mode nonzero_bits_mode;
 331
 332 /* Nonzero when reg_stat[].nonzero_bits and reg_stat[].sign_bit_copies can
 333    be safely used.  It is zero while computing them and after combine has
 334    completed.  This former test prevents propagating values based on
 335    previously set values, which can be incorrect if a variable is modified
 336    in a loop.  */
 337
 338 static int nonzero_sign_valid;
 339
 340 \f
 341 /* Record one modification to rtl structure
 342    to be undone by storing old_contents into *where.  */
 343
 344 enum undo_kind { UNDO_RTX, UNDO_INT, UNDO_MODE };
 345
 346 struct undo
 347 {
 348   struct undo *next;
 349   enum undo_kind kind;
 350   union { rtx r; int i; enum machine_mode m; } old_contents;
 351   union { rtx *r; int *i; } where;
 352 };
 353
 354 /* Record a bunch of changes to be undone, up to MAX_UNDO of them.
 355    num_undo says how many are currently recorded.
 356
 357    other_insn is nonzero if we have modified some other insn in the process
 358    of working on subst_insn.  It must be verified too.  */
 359
 360 struct undobuf
 361 {
 362   struct undo *undos;
 363   struct undo *frees;
 364   rtx other_insn;
 365 };
 366
 367 static struct undobuf undobuf;
 368
 369 /* Number of times the pseudo being substituted for
 370    was found and replaced.  */
 371
 372 static int n_occurrences;
 373
 374 static rtx reg_nonzero_bits_for_combine (const_rtx, enum machine_mode, const_rtx,
 375                                          enum machine_mode,
 376                                          unsigned HOST_WIDE_INT,
 377                                          unsigned HOST_WIDE_INT *);
 378 static rtx reg_num_sign_bit_copies_for_combine (const_rtx, enum machine_mode, const_rtx,
 379                                                 enum machine_mode,
 380                                                 unsigned int, unsigned int *);
 381 static void do_SUBST (rtx *, rtx);
 382 static void do_SUBST_INT (int *, int);
 383 static void init_reg_last (void);
 384 static void setup_incoming_promotions (rtx);
 385 static void set_nonzero_bits_and_sign_copies (rtx, const_rtx, void *);
 386 static int cant_combine_insn_p (rtx);
 387 static int can_combine_p (rtx, rtx, rtx, rtx, rtx, rtx, rtx *, rtx *);
 388 static int combinable_i3pat (rtx, rtx *, rtx, rtx, rtx, int, int, rtx *);
 389 static int contains_muldiv (rtx);
 390 static rtx try_combine (rtx, rtx, rtx, rtx, int *);
 391 static void undo_all (void);
 392 static void undo_commit (void);
 393 static rtx *find_split_point (rtx *, rtx, bool);
 394 static rtx subst (rtx, rtx, rtx, int, int);
 395 static rtx combine_simplify_rtx (rtx, enum machine_mode, int);
 396 static rtx simplify_if_then_else (rtx);
 397 static rtx simplify_set (rtx);
 398 static rtx simplify_logical (rtx);
 399 static rtx expand_compound_operation (rtx);
 400 static const_rtx expand_field_assignment (const_rtx);
 401 static rtx make_extraction (enum machine_mode, rtx, HOST_WIDE_INT,
 402                             rtx, unsigned HOST_WIDE_INT, int, int, int);
 403 static rtx extract_left_shift (rtx, int);
 404 static rtx make_compound_operation (rtx, enum rtx_code);
 405 static int get_pos_from_mask (unsigned HOST_WIDE_INT,
 406                               unsigned HOST_WIDE_INT *);
 407 static rtx canon_reg_for_combine (rtx, rtx);
 408 static rtx force_to_mode (rtx, enum machine_mode,
 409                           unsigned HOST_WIDE_INT, int);
 410 static rtx if_then_else_cond (rtx, rtx *, rtx *);
 411 static rtx known_cond (rtx, enum rtx_code, rtx, rtx);
 412 static int rtx_equal_for_field_assignment_p (rtx, rtx);
 413 static rtx make_field_assignment (rtx);
 414 static rtx apply_distributive_law (rtx);
 415 static rtx distribute_and_simplify_rtx (rtx, int);
 416 static rtx simplify_and_const_int_1 (enum machine_mode, rtx,
 417                                      unsigned HOST_WIDE_INT);
 418 static rtx simplify_and_const_int (rtx, enum machine_mode, rtx,
 419                                    unsigned HOST_WIDE_INT);
 420 static int merge_outer_ops (enum rtx_code *, HOST_WIDE_INT *, enum rtx_code,
 421                             HOST_WIDE_INT, enum machine_mode, int *);
 422 static rtx simplify_shift_const_1 (enum rtx_code, enum machine_mode, rtx, int);
 423 static rtx simplify_shift_const (rtx, enum rtx_code, enum machine_mode, rtx,
 424                                  int);
 425 static int recog_for_combine (rtx *, rtx, rtx *);
 426 static rtx gen_lowpart_for_combine (enum machine_mode, rtx);
 427 static enum rtx_code simplify_comparison (enum rtx_code, rtx *, rtx *);
 428 static void update_table_tick (rtx);
 429 static void record_value_for_reg (rtx, rtx, rtx);
 430 static void check_promoted_subreg (rtx, rtx);
 431 static void record_dead_and_set_regs_1 (rtx, const_rtx, void *);
 432 static void record_dead_and_set_regs (rtx);
 433 static int get_last_value_validate (rtx *, rtx, int, int);
 434 static rtx get_last_value (const_rtx);
 435 static int use_crosses_set_p (const_rtx, int);
 436 static void reg_dead_at_p_1 (rtx, const_rtx, void *);
 437 static int reg_dead_at_p (rtx, rtx);
 438 static void move_deaths (rtx, rtx, int, rtx, rtx *);
 439 static int reg_bitfield_target_p (rtx, rtx);
 440 static void distribute_notes (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
 441 static void distribute_links (rtx);
 442 static void mark_used_regs_combine (rtx);
 443 static void record_promoted_value (rtx, rtx);
 444 static int unmentioned_reg_p_1 (rtx *, void *);
 445 static bool unmentioned_reg_p (rtx, rtx);
 446 static int record_truncated_value (rtx *, void *);
 447 static void record_truncated_values (rtx *, void *);
 448 static bool reg_truncated_to_mode (enum machine_mode, const_rtx);
 449 static rtx gen_lowpart_or_truncate (enum machine_mode, rtx);
 450 \f
 451
 452 /* It is not safe to use ordinary gen_lowpart in combine.
 453    See comments in gen_lowpart_for_combine.  */
 454 #undef RTL_HOOKS_GEN_LOWPART
 455 #define RTL_HOOKS_GEN_LOWPART              gen_lowpart_for_combine
 456
 457 /* Our implementation of gen_lowpart never emits a new pseudo.  */
 458 #undef RTL_HOOKS_GEN_LOWPART_NO_EMIT
 459 #define RTL_HOOKS_GEN_LOWPART_NO_EMIT      gen_lowpart_for_combine
 460
 461 #undef RTL_HOOKS_REG_NONZERO_REG_BITS
 462 #define RTL_HOOKS_REG_NONZERO_REG_BITS     reg_nonzero_bits_for_combine
 463
 464 #undef RTL_HOOKS_REG_NUM_SIGN_BIT_COPIES
 465 #define RTL_HOOKS_REG_NUM_SIGN_BIT_COPIES  reg_num_sign_bit_copies_for_combine
 466
 467 #undef RTL_HOOKS_REG_TRUNCATED_TO_MODE
 468 #define RTL_HOOKS_REG_TRUNCATED_TO_MODE    reg_truncated_to_mode
 469
 470 static const struct rtl_hooks combine_rtl_hooks = RTL_HOOKS_INITIALIZER;
 471
 472 \f
 473 /* Try to split PATTERN found in INSN.  This returns NULL_RTX if
 474    PATTERN can not be split.  Otherwise, it returns an insn sequence.
 475    This is a wrapper around split_insns which ensures that the
 476    reg_stat vector is made larger if the splitter creates a new
 477    register.  */
 478
 479 static rtx
 480 combine_split_insns (rtx pattern, rtx insn)
 481 {
 482   rtx ret;
 483   unsigned int nregs;
 484
 485   ret = split_insns (pattern, insn);
 486   nregs = max_reg_num ();
 487   if (nregs > VEC_length (reg_stat_type, reg_stat))
 488     VEC_safe_grow_cleared (reg_stat_type, heap, reg_stat, nregs);
 489   return ret;
 490 }
 491
 492 /* This is used by find_single_use to locate an rtx in LOC that
 493    contains exactly one use of DEST, which is typically either a REG
 494    or CC0.  It returns a pointer to the innermost rtx expression
 495    containing DEST.  Appearances of DEST that are being used to
 496    totally replace it are not counted.  */
 497
 498 static rtx *
 499 find_single_use_1 (rtx dest, rtx *loc)
 500 {
 501   rtx x = *loc;
 502   enum rtx_code code = GET_CODE (x);
 503   rtx *result = NULL;
 504   rtx *this_result;
 505   int i;
 506   const char *fmt;
 507
 508   switch (code)
 509     {
 510     case CONST_INT:
 511     case CONST:
 512     case LABEL_REF:
 513     case SYMBOL_REF:
 514     case CONST_DOUBLE:
 515     case CONST_VECTOR:
 516     case CLOBBER:
 517       return 0;
 518
 519     case SET:
 520       /* If the destination is anything other than CC0, PC, a REG or a SUBREG
 521          of a REG that occupies all of the REG, the insn uses DEST if
 522          it is mentioned in the destination or the source.  Otherwise, we
 523          need just check the source.  */
 524       if (GET_CODE (SET_DEST (x)) != CC0
 525           && GET_CODE (SET_DEST (x)) != PC
 526           && !REG_P (SET_DEST (x))
 527           && ! (GET_CODE (SET_DEST (x)) == SUBREG
 528                 && REG_P (SUBREG_REG (SET_DEST (x)))
 529                 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
 530                       + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
 531                     == ((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
 532                          + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
 533         break;
 534
 535       return find_single_use_1 (dest, &SET_SRC (x));
 536
 537     case MEM:
 538     case SUBREG:
 539       return find_single_use_1 (dest, &XEXP (x, 0));
 540
 541     default:
 542       break;
 543     }
 544
 545   /* If it wasn't one of the common cases above, check each expression and
 546      vector of this code.  Look for a unique usage of DEST.  */
 547
 548   fmt = GET_RTX_FORMAT (code);
 549   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 550     {
 551       if (fmt[i] == 'e')
 552         {
 553           if (dest == XEXP (x, i)
 554               || (REG_P (dest) && REG_P (XEXP (x, i))
 555                   && REGNO (dest) == REGNO (XEXP (x, i))))
 556             this_result = loc;
 557           else
 558             this_result = find_single_use_1 (dest, &XEXP (x, i));
 559
 560           if (result == NULL)
 561             result = this_result;
 562           else if (this_result)
 563             /* Duplicate usage.  */
 564             return NULL;
 565         }
 566       else if (fmt[i] == 'E')
 567         {
 568           int j;
 569
 570           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 571             {
 572               if (XVECEXP (x, i, j) == dest
 573                   || (REG_P (dest)
 574                       && REG_P (XVECEXP (x, i, j))
 575                       && REGNO (XVECEXP (x, i, j)) == REGNO (dest)))
 576                 this_result = loc;
 577               else
 578                 this_result = find_single_use_1 (dest, &XVECEXP (x, i, j));
 579
 580               if (result == NULL)
 581                 result = this_result;
 582               else if (this_result)
 583                 return NULL;
 584             }
 585         }
 586     }
 587
 588   return result;
 589 }
 590
 591
 592 /* See if DEST, produced in INSN, is used only a single time in the
 593    sequel.  If so, return a pointer to the innermost rtx expression in which
 594    it is used.
 595
 596    If PLOC is nonzero, *PLOC is set to the insn containing the single use.
 597
 598    If DEST is cc0_rtx, we look only at the next insn.  In that case, we don't
 599    care about REG_DEAD notes or LOG_LINKS.
 600
 601    Otherwise, we find the single use by finding an insn that has a
 602    LOG_LINKS pointing at INSN and has a REG_DEAD note for DEST.  If DEST is
 603    only referenced once in that insn, we know that it must be the first
 604    and last insn referencing DEST.  */
 605
 606 static rtx *
 607 find_single_use (rtx dest, rtx insn, rtx *ploc)
 608 {
 609   basic_block bb;
 610   rtx next;
 611   rtx *result;
 612   rtx link;
 613
 614 #ifdef HAVE_cc0
 615   if (dest == cc0_rtx)
 616     {
 617       next = NEXT_INSN (insn);
 618       if (next == 0
 619           || (!NONJUMP_INSN_P (next) && !JUMP_P (next)))
 620         return 0;
 621
 622       result = find_single_use_1 (dest, &PATTERN (next));
 623       if (result && ploc)
 624         *ploc = next;
 625       return result;
 626     }
 627 #endif
 628
 629   if (!REG_P (dest))
 630     return 0;
 631
 632   bb = BLOCK_FOR_INSN (insn);
 633   for (next = NEXT_INSN (insn);
 634        next && BLOCK_FOR_INSN (next) == bb;
 635        next = NEXT_INSN (next))
 636     if (INSN_P (next) && dead_or_set_p (next, dest))
 637       {
 638         for (link = LOG_LINKS (next); link; link = XEXP (link, 1))
 639           if (XEXP (link, 0) == insn)
 640             break;
 641
 642         if (link)
 643           {
 644             result = find_single_use_1 (dest, &PATTERN (next));
 645             if (ploc)
 646               *ploc = next;
 647             return result;
 648           }
 649       }
 650
 651   return 0;
 652 }
 653 \f
 654 /* Substitute NEWVAL, an rtx expression, into INTO, a place in some
 655    insn.  The substitution can be undone by undo_all.  If INTO is already
 656    set to NEWVAL, do not record this change.  Because computing NEWVAL might
 657    also call SUBST, we have to compute it before we put anything into
 658    the undo table.  */
 659
 660 static void
 661 do_SUBST (rtx *into, rtx newval)
 662 {
 663   struct undo *buf;
 664   rtx oldval = *into;
 665
 666   if (oldval == newval)
 667     return;
 668
 669   /* We'd like to catch as many invalid transformations here as
 670      possible.  Unfortunately, there are way too many mode changes
 671      that are perfectly valid, so we'd waste too much effort for
 672      little gain doing the checks here.  Focus on catching invalid
 673      transformations involving integer constants.  */
 674   if (GET_MODE_CLASS (GET_MODE (oldval)) == MODE_INT
 675       && CONST_INT_P (newval))
 676     {
 677       /* Sanity check that we're replacing oldval with a CONST_INT
 678          that is a valid sign-extension for the original mode.  */
 679       gcc_assert (INTVAL (newval)
 680                   == trunc_int_for_mode (INTVAL (newval), GET_MODE (oldval)));
 681
 682       /* Replacing the operand of a SUBREG or a ZERO_EXTEND with a
 683          CONST_INT is not valid, because after the replacement, the
 684          original mode would be gone.  Unfortunately, we can't tell
 685          when do_SUBST is called to replace the operand thereof, so we
 686          perform this test on oldval instead, checking whether an
 687          invalid replacement took place before we got here.  */
 688       gcc_assert (!(GET_CODE (oldval) == SUBREG
 689                     && CONST_INT_P (SUBREG_REG (oldval))));
 690       gcc_assert (!(GET_CODE (oldval) == ZERO_EXTEND
 691                     && CONST_INT_P (XEXP (oldval, 0))));
 692     }
 693
 694   if (undobuf.frees)
 695     buf = undobuf.frees, undobuf.frees = buf->next;
 696   else
 697     buf = XNEW (struct undo);
 698
 699   buf->kind = UNDO_RTX;
 700   buf->where.r = into;
 701   buf->old_contents.r = oldval;
 702   *into = newval;
 703
 704   buf->next = undobuf.undos, undobuf.undos = buf;
 705 }
 706
 707 #define SUBST(INTO, NEWVAL)     do_SUBST(&(INTO), (NEWVAL))
 708
 709 /* Similar to SUBST, but NEWVAL is an int expression.  Note that substitution
 710    for the value of a HOST_WIDE_INT value (including CONST_INT) is
 711    not safe.  */
 712
 713 static void
 714 do_SUBST_INT (int *into, int newval)
 715 {
 716   struct undo *buf;
 717   int oldval = *into;
 718
 719   if (oldval == newval)
 720     return;
 721
 722   if (undobuf.frees)
 723     buf = undobuf.frees, undobuf.frees = buf->next;
 724   else
 725     buf = XNEW (struct undo);
 726
 727   buf->kind = UNDO_INT;
 728   buf->where.i = into;
 729   buf->old_contents.i = oldval;
 730   *into = newval;
 731
 732   buf->next = undobuf.undos, undobuf.undos = buf;
 733 }
 734
 735 #define SUBST_INT(INTO, NEWVAL)  do_SUBST_INT(&(INTO), (NEWVAL))
 736
 737 /* Similar to SUBST, but just substitute the mode.  This is used when
 738    changing the mode of a pseudo-register, so that any other
 739    references to the entry in the regno_reg_rtx array will change as
 740    well.  */
 741
 742 static void
 743 do_SUBST_MODE (rtx *into, enum machine_mode newval)
 744 {
 745   struct undo *buf;
 746   enum machine_mode oldval = GET_MODE (*into);
 747
 748   if (oldval == newval)
 749     return;
 750
 751   if (undobuf.frees)
 752     buf = undobuf.frees, undobuf.frees = buf->next;
 753   else
 754     buf = XNEW (struct undo);
 755
 756   buf->kind = UNDO_MODE;
 757   buf->where.r = into;
 758   buf->old_contents.m = oldval;
 759   adjust_reg_mode (*into, newval);
 760
 761   buf->next = undobuf.undos, undobuf.undos = buf;
 762 }
 763
 764 #define SUBST_MODE(INTO, NEWVAL)  do_SUBST_MODE(&(INTO), (NEWVAL))
 765 \f
 766 /* Subroutine of try_combine.  Determine whether the combine replacement
 767    patterns NEWPAT, NEWI2PAT and NEWOTHERPAT are cheaper according to
 768    insn_rtx_cost that the original instruction sequence I0, I1, I2, I3 and
 769    undobuf.other_insn.  Note that I1 and/or NEWI2PAT may be NULL_RTX.
 770    NEWOTHERPAT and undobuf.other_insn may also both be NULL_RTX.  This
 771    function returns false, if the costs of all instructions can be
 772    estimated, and the replacements are more expensive than the original
 773    sequence.  */
 774
 775 static bool
 776 combine_validate_cost (rtx i0, rtx i1, rtx i2, rtx i3, rtx newpat,
 777                        rtx newi2pat, rtx newotherpat)
 778 {
 779   int i0_cost, i1_cost, i2_cost, i3_cost;
 780   int new_i2_cost, new_i3_cost;
 781   int old_cost, new_cost;
 782
 783   /* Lookup the original insn_rtx_costs.  */
 784   i2_cost = INSN_COST (i2);
 785   i3_cost = INSN_COST (i3);
 786
 787   if (i1)
 788     {
 789       i1_cost = INSN_COST (i1);
 790       if (i0)
 791         {
 792           i0_cost = INSN_COST (i0);
 793           old_cost = (i0_cost > 0 && i1_cost > 0 && i2_cost > 0 && i3_cost > 0
 794                       ? i0_cost + i1_cost + i2_cost + i3_cost : 0);
 795         }
 796       else
 797         {
 798           old_cost = (i1_cost > 0 && i2_cost > 0 && i3_cost > 0
 799                       ? i1_cost + i2_cost + i3_cost : 0);
 800           i0_cost = 0;
 801         }
 802     }
 803   else
 804     {
 805       old_cost = (i2_cost > 0 && i3_cost > 0) ? i2_cost + i3_cost : 0;
 806       i1_cost = i0_cost = 0;
 807     }
 808
 809   /* Calculate the replacement insn_rtx_costs.  */
 810   new_i3_cost = insn_rtx_cost (newpat, optimize_this_for_speed_p);
 811   if (newi2pat)
 812     {
 813       new_i2_cost = insn_rtx_cost (newi2pat, optimize_this_for_speed_p);
 814       new_cost = (new_i2_cost > 0 && new_i3_cost > 0)
 815                  ? new_i2_cost + new_i3_cost : 0;
 816     }
 817   else
 818     {
 819       new_cost = new_i3_cost;
 820       new_i2_cost = 0;
 821     }
 822
 823   if (undobuf.other_insn)
 824     {
 825       int old_other_cost, new_other_cost;
 826
 827       old_other_cost = INSN_COST (undobuf.other_insn);
 828       new_other_cost = insn_rtx_cost (newotherpat, optimize_this_for_speed_p);
 829       if (old_other_cost > 0 && new_other_cost > 0)
 830         {
 831           old_cost += old_other_cost;
 832           new_cost += new_other_cost;
 833         }
 834       else
 835         old_cost = 0;
 836     }
 837
 838   /* Disallow this recombination if both new_cost and old_cost are
 839      greater than zero, and new_cost is greater than old cost.  */
 840   if (old_cost > 0
 841       && new_cost > old_cost)
 842     {
 843       if (dump_file)
 844         {
 845           if (i0)
 846             {
 847               fprintf (dump_file,
 848                        "rejecting combination of insns %d, %d, %d and %d\n",
 849                        INSN_UID (i0), INSN_UID (i1), INSN_UID (i2),
 850                        INSN_UID (i3));
 851               fprintf (dump_file, "original costs %d + %d + %d + %d = %d\n",
 852                        i0_cost, i1_cost, i2_cost, i3_cost, old_cost);
 853             }
 854           else if (i1)
 855             {
 856               fprintf (dump_file,
 857                        "rejecting combination of insns %d, %d and %d\n",
 858                        INSN_UID (i1), INSN_UID (i2), INSN_UID (i3));
 859               fprintf (dump_file, "original costs %d + %d + %d = %d\n",
 860                        i1_cost, i2_cost, i3_cost, old_cost);
 861             }
 862           else
 863             {
 864               fprintf (dump_file,
 865                        "rejecting combination of insns %d and %d\n",
 866                        INSN_UID (i2), INSN_UID (i3));
 867               fprintf (dump_file, "original costs %d + %d = %d\n",
 868                        i2_cost, i3_cost, old_cost);
 869             }
 870
 871           if (newi2pat)
 872             {
 873               fprintf (dump_file, "replacement costs %d + %d = %d\n",
 874                        new_i2_cost, new_i3_cost, new_cost);
 875             }
 876           else
 877             fprintf (dump_file, "replacement cost %d\n", new_cost);
 878         }
 879
 880       return false;
 881     }
 882
 883   /* Update the uid_insn_cost array with the replacement costs.  */
 884   INSN_COST (i2) = new_i2_cost;
 885   INSN_COST (i3) = new_i3_cost;
 886   if (i1)
 887     INSN_COST (i1) = 0;
 888
 889   return true;
 890 }
 891
 892
 893 /* Delete any insns that copy a register to itself.  */
 894
 895 static void
 896 delete_noop_moves (void)
 897 {
 898   rtx insn, next;
 899   basic_block bb;
 900
 901   FOR_EACH_BB (bb)
 902     {
 903       for (insn = BB_HEAD (bb); insn != NEXT_INSN (BB_END (bb)); insn = next)
 904         {
 905           next = NEXT_INSN (insn);
 906           if (INSN_P (insn) && noop_move_p (insn))
 907             {
 908               if (dump_file)
 909                 fprintf (dump_file, "deleting noop move %d\n", INSN_UID (insn));
 910
 911               delete_insn_and_edges (insn);
 912             }
 913         }
 914     }
 915 }
 916
 917 \f
 918 /* Fill in log links field for all insns.  */
 919
 920 static void
 921 create_log_links (void)
 922 {
 923   basic_block bb;
 924   rtx *next_use, insn;
 925   df_ref *def_vec, *use_vec;
 926
 927   next_use = XCNEWVEC (rtx, max_reg_num ());
 928
 929   /* Pass through each block from the end, recording the uses of each
 930      register and establishing log links when def is encountered.
 931      Note that we do not clear next_use array in order to save time,
 932      so we have to test whether the use is in the same basic block as def.
 933
 934      There are a few cases below when we do not consider the definition or
 935      usage -- these are taken from original flow.c did. Don't ask me why it is
 936      done this way; I don't know and if it works, I don't want to know.  */
 937
 938   FOR_EACH_BB (bb)
 939     {
 940       FOR_BB_INSNS_REVERSE (bb, insn)
 941         {
 942           if (!NONDEBUG_INSN_P (insn))
 943             continue;
 944
 945           /* Log links are created only once.  */
 946           gcc_assert (!LOG_LINKS (insn));
 947
 948           for (def_vec = DF_INSN_DEFS (insn); *def_vec; def_vec++)
 949             {
 950               df_ref def = *def_vec;
 951               int regno = DF_REF_REGNO (def);
 952               rtx use_insn;
 953
 954               if (!next_use[regno])
 955                 continue;
 956
 957               /* Do not consider if it is pre/post modification in MEM.  */
 958               if (DF_REF_FLAGS (def) & DF_REF_PRE_POST_MODIFY)
 959                 continue;
 960
 961               /* Do not make the log link for frame pointer.  */
 962               if ((regno == FRAME_POINTER_REGNUM
 963                    && (! reload_completed || frame_pointer_needed))
 964 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
 965                   || (regno == HARD_FRAME_POINTER_REGNUM
 966                       && (! reload_completed || frame_pointer_needed))
 967 #endif
 968 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
 969                   || (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
 970 #endif
 971                   )
 972                 continue;
 973
 974               use_insn = next_use[regno];
 975               if (BLOCK_FOR_INSN (use_insn) == bb)
 976                 {
 977                   /* flow.c claimed:
 978
 979                      We don't build a LOG_LINK for hard registers contained
 980                      in ASM_OPERANDs.  If these registers get replaced,
 981                      we might wind up changing the semantics of the insn,
 982                      even if reload can make what appear to be valid
 983                      assignments later.  */
 984                   if (regno >= FIRST_PSEUDO_REGISTER
 985                       || asm_noperands (PATTERN (use_insn)) < 0)
 986                     {
 987                       /* Don't add duplicate links between instructions.  */
 988                       rtx links;
 989                       for (links = LOG_LINKS (use_insn); links;
 990                            links = XEXP (links, 1))
 991                         if (insn == XEXP (links, 0))
 992                           break;
 993
 994                       if (!links)
 995                         LOG_LINKS (use_insn) =
 996                           alloc_INSN_LIST (insn, LOG_LINKS (use_insn));
 997                     }
 998                 }
 999               next_use[regno] = NULL_RTX;
1000             }
1001
1002           for (use_vec = DF_INSN_USES (insn); *use_vec; use_vec++)
1003             {
1004               df_ref use = *use_vec;
1005               int regno = DF_REF_REGNO (use);
1006
1007               /* Do not consider the usage of the stack pointer
1008                  by function call.  */
1009               if (DF_REF_FLAGS (use) & DF_REF_CALL_STACK_USAGE)
1010                 continue;
1011
1012               next_use[regno] = insn;
1013             }
1014         }
1015     }
1016
1017   free (next_use);
1018 }
1019
1020 /* Clear LOG_LINKS fields of insns.  */
1021
1022 static void
1023 clear_log_links (void)
1024 {
1025   rtx insn;
1026
1027   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1028     if (INSN_P (insn))
1029       free_INSN_LIST_list (&LOG_LINKS (insn));
1030 }
1031
1032 /* Walk the LOG_LINKS of insn B to see if we find a reference to A.  Return
1033    true if we found a LOG_LINK that proves that A feeds B.  This only works
1034    if there are no instructions between A and B which could have a link
1035    depending on A, since in that case we would not record a link for B.
1036    We also check the implicit dependency created by a cc0 setter/user
1037    pair.  */
1038
1039 static bool
1040 insn_a_feeds_b (rtx a, rtx b)
1041 {
1042   rtx links;
1043   for (links = LOG_LINKS (b); links; links = XEXP (links, 1))
1044     if (XEXP (links, 0) == a)
1045       return true;
1046 #ifdef HAVE_cc0
1047   if (sets_cc0_p (a))
1048     return true;
1049 #endif
1050   return false;
1051 }
1052 \f
1053 /* Main entry point for combiner.  F is the first insn of the function.
1054    NREGS is the first unused pseudo-reg number.
1055
1056    Return nonzero if the combiner has turned an indirect jump
1057    instruction into a direct jump.  */
1058 static int
1059 combine_instructions (rtx f, unsigned int nregs)
1060 {
1061   rtx insn, next;
1062 #ifdef HAVE_cc0
1063   rtx prev;
1064 #endif
1065   rtx links, nextlinks;
1066   rtx first;
1067   basic_block last_bb;
1068
1069   int new_direct_jump_p = 0;
1070
1071   for (first = f; first && !INSN_P (first); )
1072     first = NEXT_INSN (first);
1073   if (!first)
1074     return 0;
1075
1076   combine_attempts = 0;
1077   combine_merges = 0;
1078   combine_extras = 0;
1079   combine_successes = 0;
1080
1081   rtl_hooks = combine_rtl_hooks;
1082
1083   VEC_safe_grow_cleared (reg_stat_type, heap, reg_stat, nregs);
1084
1085   init_recog_no_volatile ();
1086
1087   /* Allocate array for insn info.  */
1088   max_uid_known = get_max_uid ();
1089   uid_log_links = XCNEWVEC (rtx, max_uid_known + 1);
1090   uid_insn_cost = XCNEWVEC (int, max_uid_known + 1);
1091
1092   nonzero_bits_mode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
1093
1094   /* Don't use reg_stat[].nonzero_bits when computing it.  This can cause
1095      problems when, for example, we have j <<= 1 in a loop.  */
1096
1097   nonzero_sign_valid = 0;
1098   label_tick = label_tick_ebb_start = 1;
1099
1100   /* Scan all SETs and see if we can deduce anything about what
1101      bits are known to be zero for some registers and how many copies
1102      of the sign bit are known to exist for those registers.
1103
1104      Also set any known values so that we can use it while searching
1105      for what bits are known to be set.  */
1106
1107   setup_incoming_promotions (first);
1108   /* Allow the entry block and the first block to fall into the same EBB.
1109      Conceptually the incoming promotions are assigned to the entry block.  */
1110   last_bb = ENTRY_BLOCK_PTR;
1111
1112   create_log_links ();
1113   FOR_EACH_BB (this_basic_block)
1114     {
1115       optimize_this_for_speed_p = optimize_bb_for_speed_p (this_basic_block);
1116       last_call_luid = 0;
1117       mem_last_set = -1;
1118
1119       label_tick++;
1120       if (!single_pred_p (this_basic_block)
1121           || single_pred (this_basic_block) != last_bb)
1122         label_tick_ebb_start = label_tick;
1123       last_bb = this_basic_block;
1124
1125       FOR_BB_INSNS (this_basic_block, insn)
1126         if (INSN_P (insn) && BLOCK_FOR_INSN (insn))
1127           {
1128             subst_low_luid = DF_INSN_LUID (insn);
1129             subst_insn = insn;
1130
1131             note_stores (PATTERN (insn), set_nonzero_bits_and_sign_copies,
1132                          insn);
1133             record_dead_and_set_regs (insn);
1134
1135 #ifdef AUTO_INC_DEC
1136             for (links = REG_NOTES (insn); links; links = XEXP (links, 1))
1137               if (REG_NOTE_KIND (links) == REG_INC)
1138                 set_nonzero_bits_and_sign_copies (XEXP (links, 0), NULL_RTX,
1139                                                   insn);
1140 #endif
1141
1142             /* Record the current insn_rtx_cost of this instruction.  */
1143             if (NONJUMP_INSN_P (insn))
1144               INSN_COST (insn) = insn_rtx_cost (PATTERN (insn),
1145                                                 optimize_this_for_speed_p);
1146             if (dump_file)
1147               fprintf(dump_file, "insn_cost %d: %d\n",
1148                     INSN_UID (insn), INSN_COST (insn));
1149           }
1150     }
1151
1152   nonzero_sign_valid = 1;
1153
1154   /* Now scan all the insns in forward order.  */
1155   label_tick = label_tick_ebb_start = 1;
1156   init_reg_last ();
1157   setup_incoming_promotions (first);
1158   last_bb = ENTRY_BLOCK_PTR;
1159
1160   FOR_EACH_BB (this_basic_block)
1161     {
1162       optimize_this_for_speed_p = optimize_bb_for_speed_p (this_basic_block);
1163       last_call_luid = 0;
1164       mem_last_set = -1;
1165
1166       label_tick++;
1167       if (!single_pred_p (this_basic_block)
1168           || single_pred (this_basic_block) != last_bb)
1169         label_tick_ebb_start = label_tick;
1170       last_bb = this_basic_block;
1171
1172       rtl_profile_for_bb (this_basic_block);
1173       for (insn = BB_HEAD (this_basic_block);
1174            insn != NEXT_INSN (BB_END (this_basic_block));
1175            insn = next ? next : NEXT_INSN (insn))
1176         {
1177           next = 0;
1178           if (NONDEBUG_INSN_P (insn))
1179             {
1180               /* See if we know about function return values before this
1181                  insn based upon SUBREG flags.  */
1182               check_promoted_subreg (insn, PATTERN (insn));
1183
1184               /* See if we can find hardregs and subreg of pseudos in
1185                  narrower modes.  This could help turning TRUNCATEs
1186                  into SUBREGs.  */
1187               note_uses (&PATTERN (insn), record_truncated_values, NULL);
1188
1189               /* Try this insn with each insn it links back to.  */
1190
1191               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1192                 if ((next = try_combine (insn, XEXP (links, 0), NULL_RTX,
1193                                          NULL_RTX, &new_direct_jump_p)) != 0)
1194                   goto retry;
1195
1196               /* Try each sequence of three linked insns ending with this one.  */
1197
1198               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1199                 {
1200                   rtx link = XEXP (links, 0);
1201
1202                   /* If the linked insn has been replaced by a note, then there
1203                      is no point in pursuing this chain any further.  */
1204                   if (NOTE_P (link))
1205                     continue;
1206
1207                   for (nextlinks = LOG_LINKS (link);
1208                        nextlinks;
1209                        nextlinks = XEXP (nextlinks, 1))
1210                     if ((next = try_combine (insn, link, XEXP (nextlinks, 0),
1211                                              NULL_RTX,
1212                                              &new_direct_jump_p)) != 0)
1213                       goto retry;
1214                 }
1215
1216 #ifdef HAVE_cc0
1217               /* Try to combine a jump insn that uses CC0
1218                  with a preceding insn that sets CC0, and maybe with its
1219                  logical predecessor as well.
1220                  This is how we make decrement-and-branch insns.
1221                  We need this special code because data flow connections
1222                  via CC0 do not get entered in LOG_LINKS.  */
1223
1224               if (JUMP_P (insn)
1225                   && (prev = prev_nonnote_insn (insn)) != 0
1226                   && NONJUMP_INSN_P (prev)
1227                   && sets_cc0_p (PATTERN (prev)))
1228                 {
1229                   if ((next = try_combine (insn, prev, NULL_RTX, NULL_RTX,
1230                                            &new_direct_jump_p)) != 0)
1231                     goto retry;
1232
1233                   for (nextlinks = LOG_LINKS (prev); nextlinks;
1234                        nextlinks = XEXP (nextlinks, 1))
1235                     if ((next = try_combine (insn, prev, XEXP (nextlinks, 0),
1236                                              NULL_RTX,
1237                                              &new_direct_jump_p)) != 0)
1238                       goto retry;
1239                 }
1240
1241               /* Do the same for an insn that explicitly references CC0.  */
1242               if (NONJUMP_INSN_P (insn)
1243                   && (prev = prev_nonnote_insn (insn)) != 0
1244                   && NONJUMP_INSN_P (prev)
1245                   && sets_cc0_p (PATTERN (prev))
1246                   && GET_CODE (PATTERN (insn)) == SET
1247                   && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (insn))))
1248                 {
1249                   if ((next = try_combine (insn, prev, NULL_RTX, NULL_RTX,
1250                                            &new_direct_jump_p)) != 0)
1251                     goto retry;
1252
1253                   for (nextlinks = LOG_LINKS (prev); nextlinks;
1254                        nextlinks = XEXP (nextlinks, 1))
1255                     if ((next = try_combine (insn, prev, XEXP (nextlinks, 0),
1256                                              NULL_RTX,
1257                                              &new_direct_jump_p)) != 0)
1258                       goto retry;
1259                 }
1260
1261               /* Finally, see if any of the insns that this insn links to
1262                  explicitly references CC0.  If so, try this insn, that insn,
1263                  and its predecessor if it sets CC0.  */
1264               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1265                 if (NONJUMP_INSN_P (XEXP (links, 0))
1266                     && GET_CODE (PATTERN (XEXP (links, 0))) == SET
1267                     && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (XEXP (links, 0))))
1268                     && (prev = prev_nonnote_insn (XEXP (links, 0))) != 0
1269                     && NONJUMP_INSN_P (prev)
1270                     && sets_cc0_p (PATTERN (prev))
1271                     && (next = try_combine (insn, XEXP (links, 0),
1272                                             prev, NULL_RTX,
1273                                             &new_direct_jump_p)) != 0)
1274                   goto retry;
1275 #endif
1276
1277               /* Try combining an insn with two different insns whose results it
1278                  uses.  */
1279               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1280                 for (nextlinks = XEXP (links, 1); nextlinks;
1281                      nextlinks = XEXP (nextlinks, 1))
1282                   if ((next = try_combine (insn, XEXP (links, 0),
1283                                            XEXP (nextlinks, 0), NULL_RTX,
1284                                            &new_direct_jump_p)) != 0)
1285                     goto retry;
1286
1287               /* Try four-instruction combinations.  */
1288               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1289                 {
1290                   rtx next1;
1291                   rtx link = XEXP (links, 0);
1292
1293                   /* If the linked insn has been replaced by a note, then there
1294                      is no point in pursuing this chain any further.  */
1295                   if (NOTE_P (link))
1296                     continue;
1297
1298                   for (next1 = LOG_LINKS (link); next1; next1 = XEXP (next1, 1))
1299                     {
1300                       rtx link1 = XEXP (next1, 0);
1301                       if (NOTE_P (link1))
1302                         continue;
1303                       /* I0 -> I1 -> I2 -> I3.  */
1304                       for (nextlinks = LOG_LINKS (link1); nextlinks;
1305                            nextlinks = XEXP (nextlinks, 1))
1306                         if ((next = try_combine (insn, link, link1,
1307                                                  XEXP (nextlinks, 0),
1308                                                  &new_direct_jump_p)) != 0)
1309                           goto retry;
1310                       /* I0, I1 -> I2, I2 -> I3.  */
1311                       for (nextlinks = XEXP (next1, 1); nextlinks;
1312                            nextlinks = XEXP (nextlinks, 1))
1313                         if ((next = try_combine (insn, link, link1,
1314                                                  XEXP (nextlinks, 0),
1315                                                  &new_direct_jump_p)) != 0)
1316                           goto retry;
1317                     }
1318
1319                   for (next1 = XEXP (links, 1); next1; next1 = XEXP (next1, 1))
1320                     {
1321                       rtx link1 = XEXP (next1, 0);
1322                       if (NOTE_P (link1))
1323                         continue;
1324                       /* I0 -> I2; I1, I2 -> I3.  */
1325                       for (nextlinks = LOG_LINKS (link); nextlinks;
1326                            nextlinks = XEXP (nextlinks, 1))
1327                         if ((next = try_combine (insn, link, link1,
1328                                                  XEXP (nextlinks, 0),
1329                                                  &new_direct_jump_p)) != 0)
1330                           goto retry;
1331                       /* I0 -> I1; I1, I2 -> I3.  */
1332                       for (nextlinks = LOG_LINKS (link1); nextlinks;
1333                            nextlinks = XEXP (nextlinks, 1))
1334                         if ((next = try_combine (insn, link, link1,
1335                                                  XEXP (nextlinks, 0),
1336                                                  &new_direct_jump_p)) != 0)
1337                           goto retry;
1338                     }
1339                 }
1340
1341               /* Try this insn with each REG_EQUAL note it links back to.  */
1342               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1343                 {
1344                   rtx set, note;
1345                   rtx temp = XEXP (links, 0);
1346                   if ((set = single_set (temp)) != 0
1347                       && (note = find_reg_equal_equiv_note (temp)) != 0
1348                       && (note = XEXP (note, 0), GET_CODE (note)) != EXPR_LIST
1349                       /* Avoid using a register that may already been marked
1350                          dead by an earlier instruction.  */
1351                       && ! unmentioned_reg_p (note, SET_SRC (set))
1352                       && (GET_MODE (note) == VOIDmode
1353                           ? SCALAR_INT_MODE_P (GET_MODE (SET_DEST (set)))
1354                           : GET_MODE (SET_DEST (set)) == GET_MODE (note)))
1355                     {
1356                       /* Temporarily replace the set's source with the
1357                          contents of the REG_EQUAL note.  The insn will
1358                          be deleted or recognized by try_combine.  */
1359                       rtx orig = SET_SRC (set);
1360                       SET_SRC (set) = note;
1361                       i2mod = temp;
1362                       i2mod_old_rhs = copy_rtx (orig);
1363                       i2mod_new_rhs = copy_rtx (note);
1364                       next = try_combine (insn, i2mod, NULL_RTX, NULL_RTX,
1365                                           &new_direct_jump_p);
1366                       i2mod = NULL_RTX;
1367                       if (next)
1368                         goto retry;
1369                       SET_SRC (set) = orig;
1370                     }
1371                 }
1372
1373               if (!NOTE_P (insn))
1374                 record_dead_and_set_regs (insn);
1375
1376             retry:
1377               ;
1378             }
1379         }
1380     }
1381
1382   default_rtl_profile ();
1383   clear_log_links ();
1384   clear_bb_flags ();
1385   new_direct_jump_p |= purge_all_dead_edges ();
1386   delete_noop_moves ();
1387
1388   /* Clean up.  */
1389   free (uid_log_links);
1390   free (uid_insn_cost);
1391   VEC_free (reg_stat_type, heap, reg_stat);
1392
1393   {
1394     struct undo *undo, *next;
1395     for (undo = undobuf.frees; undo; undo = next)
1396       {
1397         next = undo->next;
1398         free (undo);
1399       }
1400     undobuf.frees = 0;
1401   }
1402
1403   total_attempts += combine_attempts;
1404   total_merges += combine_merges;
1405   total_extras += combine_extras;
1406   total_successes += combine_successes;
1407
1408   nonzero_sign_valid = 0;
1409   rtl_hooks = general_rtl_hooks;
1410
1411   /* Make recognizer allow volatile MEMs again.  */
1412   init_recog ();
1413
1414   return new_direct_jump_p;
1415 }
1416
1417 /* Wipe the last_xxx fields of reg_stat in preparation for another pass.  */
1418
1419 static void
1420 init_reg_last (void)
1421 {
1422   unsigned int i;
1423   reg_stat_type *p;
1424
1425   FOR_EACH_VEC_ELT (reg_stat_type, reg_stat, i, p)
1426     memset (p, 0, offsetof (reg_stat_type, sign_bit_copies));
1427 }
1428 \f
1429 /* Set up any promoted values for incoming argument registers.  */
1430
1431 static void
1432 setup_incoming_promotions (rtx first)
1433 {
1434   tree arg;
1435   bool strictly_local = false;
1436
1437   for (arg = DECL_ARGUMENTS (current_function_decl); arg;
1438        arg = DECL_CHAIN (arg))
1439     {
1440       rtx x, reg = DECL_INCOMING_RTL (arg);
1441       int uns1, uns3;
1442       enum machine_mode mode1, mode2, mode3, mode4;
1443
1444       /* Only continue if the incoming argument is in a register.  */
1445       if (!REG_P (reg))
1446         continue;
1447
1448       /* Determine, if possible, whether all call sites of the current
1449          function lie within the current compilation unit.  (This does
1450          take into account the exporting of a function via taking its
1451          address, and so forth.)  */
1452       strictly_local = cgraph_local_info (current_function_decl)->local;
1453
1454       /* The mode and signedness of the argument before any promotions happen
1455          (equal to the mode of the pseudo holding it at that stage).  */
1456       mode1 = TYPE_MODE (TREE_TYPE (arg));
1457       uns1 = TYPE_UNSIGNED (TREE_TYPE (arg));
1458
1459       /* The mode and signedness of the argument after any source language and
1460          TARGET_PROMOTE_PROTOTYPES-driven promotions.  */
1461       mode2 = TYPE_MODE (DECL_ARG_TYPE (arg));
1462       uns3 = TYPE_UNSIGNED (DECL_ARG_TYPE (arg));
1463
1464       /* The mode and signedness of the argument as it is actually passed,
1465          after any TARGET_PROMOTE_FUNCTION_ARGS-driven ABI promotions.  */
1466       mode3 = promote_function_mode (DECL_ARG_TYPE (arg), mode2, &uns3,
1467                                      TREE_TYPE (cfun->decl), 0);
1468
1469       /* The mode of the register in which the argument is being passed.  */
1470       mode4 = GET_MODE (reg);
1471
1472       /* Eliminate sign extensions in the callee when:
1473          (a) A mode promotion has occurred;  */
1474       if (mode1 == mode3)
1475         continue;
1476       /* (b) The mode of the register is the same as the mode of
1477              the argument as it is passed; */
1478       if (mode3 != mode4)
1479         continue;
1480       /* (c) There's no language level extension;  */
1481       if (mode1 == mode2)
1482         ;
1483       /* (c.1) All callers are from the current compilation unit.  If that's
1484          the case we don't have to rely on an ABI, we only have to know
1485          what we're generating right now, and we know that we will do the
1486          mode1 to mode2 promotion with the given sign.  */
1487       else if (!strictly_local)
1488         continue;
1489       /* (c.2) The combination of the two promotions is useful.  This is
1490          true when the signs match, or if the first promotion is unsigned.
1491          In the later case, (sign_extend (zero_extend x)) is the same as
1492          (zero_extend (zero_extend x)), so make sure to force UNS3 true.  */
1493       else if (uns1)
1494         uns3 = true;
1495       else if (uns3)
1496         continue;
1497
1498       /* Record that the value was promoted from mode1 to mode3,
1499          so that any sign extension at the head of the current
1500          function may be eliminated.  */
1501       x = gen_rtx_CLOBBER (mode1, const0_rtx);
1502       x = gen_rtx_fmt_e ((uns3 ? ZERO_EXTEND : SIGN_EXTEND), mode3, x);
1503       record_value_for_reg (reg, first, x);
1504     }
1505 }
1506
1507 /* Called via note_stores.  If X is a pseudo that is narrower than
1508    HOST_BITS_PER_WIDE_INT and is being set, record what bits are known zero.
1509
1510    If we are setting only a portion of X and we can't figure out what
1511    portion, assume all bits will be used since we don't know what will
1512    be happening.
1513
1514    Similarly, set how many bits of X are known to be copies of the sign bit
1515    at all locations in the function.  This is the smallest number implied
1516    by any set of X.  */
1517
1518 static void
1519 set_nonzero_bits_and_sign_copies (rtx x, const_rtx set, void *data)
1520 {
1521   rtx insn = (rtx) data;
1522   unsigned int num;
1523
1524   if (REG_P (x)
1525       && REGNO (x) >= FIRST_PSEUDO_REGISTER
1526       /* If this register is undefined at the start of the file, we can't
1527          say what its contents were.  */
1528       && ! REGNO_REG_SET_P
1529            (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x))
1530       && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
1531     {
1532       reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
1533
1534       if (set == 0 || GET_CODE (set) == CLOBBER)
1535         {
1536           rsp->nonzero_bits = GET_MODE_MASK (GET_MODE (x));
1537           rsp->sign_bit_copies = 1;
1538           return;
1539         }
1540
1541       /* If this register is being initialized using itself, and the
1542          register is uninitialized in this basic block, and there are
1543          no LOG_LINKS which set the register, then part of the
1544          register is uninitialized.  In that case we can't assume
1545          anything about the number of nonzero bits.
1546
1547          ??? We could do better if we checked this in
1548          reg_{nonzero_bits,num_sign_bit_copies}_for_combine.  Then we
1549          could avoid making assumptions about the insn which initially
1550          sets the register, while still using the information in other
1551          insns.  We would have to be careful to check every insn
1552          involved in the combination.  */
1553
1554       if (insn
1555           && reg_referenced_p (x, PATTERN (insn))
1556           && !REGNO_REG_SET_P (DF_LR_IN (BLOCK_FOR_INSN (insn)),
1557                                REGNO (x)))
1558         {
1559           rtx link;
1560
1561           for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
1562             {
1563               if (dead_or_set_p (XEXP (link, 0), x))
1564                 break;
1565             }
1566           if (!link)
1567             {
1568               rsp->nonzero_bits = GET_MODE_MASK (GET_MODE (x));
1569               rsp->sign_bit_copies = 1;
1570               return;
1571             }
1572         }
1573
1574       /* If this is a complex assignment, see if we can convert it into a
1575          simple assignment.  */
1576       set = expand_field_assignment (set);
1577
1578       /* If this is a simple assignment, or we have a paradoxical SUBREG,
1579          set what we know about X.  */
1580
1581       if (SET_DEST (set) == x
1582           || (GET_CODE (SET_DEST (set)) == SUBREG
1583               && (GET_MODE_SIZE (GET_MODE (SET_DEST (set)))
1584                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (set)))))
1585               && SUBREG_REG (SET_DEST (set)) == x))
1586         {
1587           rtx src = SET_SRC (set);
1588
1589 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
1590           /* If X is narrower than a word and SRC is a non-negative
1591              constant that would appear negative in the mode of X,
1592              sign-extend it for use in reg_stat[].nonzero_bits because some
1593              machines (maybe most) will actually do the sign-extension
1594              and this is the conservative approach.
1595
1596              ??? For 2.5, try to tighten up the MD files in this regard
1597              instead of this kludge.  */
1598
1599           if (GET_MODE_BITSIZE (GET_MODE (x)) < BITS_PER_WORD
1600               && CONST_INT_P (src)
1601               && INTVAL (src) > 0
1602               && 0 != (UINTVAL (src)
1603                        & ((unsigned HOST_WIDE_INT) 1
1604                           << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
1605             src = GEN_INT (UINTVAL (src)
1606                            | ((unsigned HOST_WIDE_INT) (-1)
1607                               << GET_MODE_BITSIZE (GET_MODE (x))));
1608 #endif
1609
1610           /* Don't call nonzero_bits if it cannot change anything.  */
1611           if (rsp->nonzero_bits != ~(unsigned HOST_WIDE_INT) 0)
1612             rsp->nonzero_bits |= nonzero_bits (src, nonzero_bits_mode);
1613           num = num_sign_bit_copies (SET_SRC (set), GET_MODE (x));
1614           if (rsp->sign_bit_copies == 0
1615               || rsp->sign_bit_copies > num)
1616             rsp->sign_bit_copies = num;
1617         }
1618       else
1619         {
1620           rsp->nonzero_bits = GET_MODE_MASK (GET_MODE (x));
1621           rsp->sign_bit_copies = 1;
1622         }
1623     }
1624 }
1625 \f
1626 /* See if INSN can be combined into I3.  PRED, PRED2, SUCC and SUCC2 are
1627    optionally insns that were previously combined into I3 or that will be
1628    combined into the merger of INSN and I3.  The order is PRED, PRED2,
1629    INSN, SUCC, SUCC2, I3.
1630
1631    Return 0 if the combination is not allowed for any reason.
1632
1633    If the combination is allowed, *PDEST will be set to the single
1634    destination of INSN and *PSRC to the single source, and this function
1635    will return 1.  */
1636
1637 static int
1638 can_combine_p (rtx insn, rtx i3, rtx pred ATTRIBUTE_UNUSED,
1639                rtx pred2 ATTRIBUTE_UNUSED, rtx succ, rtx succ2,
1640                rtx *pdest, rtx *psrc)
1641 {
1642   int i;
1643   const_rtx set = 0;
1644   rtx src, dest;
1645   rtx p;
1646 #ifdef AUTO_INC_DEC
1647   rtx link;
1648 #endif
1649   bool all_adjacent = true;
1650
1651   if (succ)
1652     {
1653       if (succ2)
1654         {
1655           if (next_active_insn (succ2) != i3)
1656             all_adjacent = false;
1657           if (next_active_insn (succ) != succ2)
1658             all_adjacent = false;
1659         }
1660       else if (next_active_insn (succ) != i3)
1661         all_adjacent = false;
1662       if (next_active_insn (insn) != succ)
1663         all_adjacent = false;
1664     }
1665   else if (next_active_insn (insn) != i3)
1666     all_adjacent = false;
1667
1668   /* Can combine only if previous insn is a SET of a REG, a SUBREG or CC0.
1669      or a PARALLEL consisting of such a SET and CLOBBERs.
1670
1671      If INSN has CLOBBER parallel parts, ignore them for our processing.
1672      By definition, these happen during the execution of the insn.  When it
1673      is merged with another insn, all bets are off.  If they are, in fact,
1674      needed and aren't also supplied in I3, they may be added by
1675      recog_for_combine.  Otherwise, it won't match.
1676
1677      We can also ignore a SET whose SET_DEST is mentioned in a REG_UNUSED
1678      note.
1679
1680      Get the source and destination of INSN.  If more than one, can't
1681      combine.  */
1682
1683   if (GET_CODE (PATTERN (insn)) == SET)
1684     set = PATTERN (insn);
1685   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1686            && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
1687     {
1688       for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
1689         {
1690           rtx elt = XVECEXP (PATTERN (insn), 0, i);
1691
1692           switch (GET_CODE (elt))
1693             {
1694             /* This is important to combine floating point insns
1695                for the SH4 port.  */
1696             case USE:
1697               /* Combining an isolated USE doesn't make sense.
1698                  We depend here on combinable_i3pat to reject them.  */
1699               /* The code below this loop only verifies that the inputs of
1700                  the SET in INSN do not change.  We call reg_set_between_p
1701                  to verify that the REG in the USE does not change between
1702                  I3 and INSN.
1703                  If the USE in INSN was for a pseudo register, the matching
1704                  insn pattern will likely match any register; combining this
1705                  with any other USE would only be safe if we knew that the
1706                  used registers have identical values, or if there was
1707                  something to tell them apart, e.g. different modes.  For
1708                  now, we forgo such complicated tests and simply disallow
1709                  combining of USES of pseudo registers with any other USE.  */
1710               if (REG_P (XEXP (elt, 0))
1711                   && GET_CODE (PATTERN (i3)) == PARALLEL)
1712                 {
1713                   rtx i3pat = PATTERN (i3);
1714                   int i = XVECLEN (i3pat, 0) - 1;
1715                   unsigned int regno = REGNO (XEXP (elt, 0));
1716
1717                   do
1718                     {
1719                       rtx i3elt = XVECEXP (i3pat, 0, i);
1720
1721                       if (GET_CODE (i3elt) == USE
1722                           && REG_P (XEXP (i3elt, 0))
1723                           && (REGNO (XEXP (i3elt, 0)) == regno
1724                               ? reg_set_between_p (XEXP (elt, 0),
1725                                                    PREV_INSN (insn), i3)
1726                               : regno >= FIRST_PSEUDO_REGISTER))
1727                         return 0;
1728                     }
1729                   while (--i >= 0);
1730                 }
1731               break;
1732
1733               /* We can ignore CLOBBERs.  */
1734             case CLOBBER:
1735               break;
1736
1737             case SET:
1738               /* Ignore SETs whose result isn't used but not those that
1739                  have side-effects.  */
1740               if (find_reg_note (insn, REG_UNUSED, SET_DEST (elt))
1741                   && insn_nothrow_p (insn)
1742                   && !side_effects_p (elt))
1743                 break;
1744
1745               /* If we have already found a SET, this is a second one and
1746                  so we cannot combine with this insn.  */
1747               if (set)
1748                 return 0;
1749
1750               set = elt;
1751               break;
1752
1753             default:
1754               /* Anything else means we can't combine.  */
1755               return 0;
1756             }
1757         }
1758
1759       if (set == 0
1760           /* If SET_SRC is an ASM_OPERANDS we can't throw away these CLOBBERs,
1761              so don't do anything with it.  */
1762           || GET_CODE (SET_SRC (set)) == ASM_OPERANDS)
1763         return 0;
1764     }
1765   else
1766     return 0;
1767
1768   if (set == 0)
1769     return 0;
1770
1771   set = expand_field_assignment (set);
1772   src = SET_SRC (set), dest = SET_DEST (set);
1773
1774   /* Don't eliminate a store in the stack pointer.  */
1775   if (dest == stack_pointer_rtx
1776       /* Don't combine with an insn that sets a register to itself if it has
1777          a REG_EQUAL note.  This may be part of a LIBCALL sequence.  */
1778       || (rtx_equal_p (src, dest) && find_reg_note (insn, REG_EQUAL, NULL_RTX))
1779       /* Can't merge an ASM_OPERANDS.  */
1780       || GET_CODE (src) == ASM_OPERANDS
1781       /* Can't merge a function call.  */
1782       || GET_CODE (src) == CALL
1783       /* Don't eliminate a function call argument.  */
1784       || (CALL_P (i3)
1785           && (find_reg_fusage (i3, USE, dest)
1786               || (REG_P (dest)
1787                   && REGNO (dest) < FIRST_PSEUDO_REGISTER
1788                   && global_regs[REGNO (dest)])))
1789       /* Don't substitute into an incremented register.  */
1790       || FIND_REG_INC_NOTE (i3, dest)
1791       || (succ && FIND_REG_INC_NOTE (succ, dest))
1792       || (succ2 && FIND_REG_INC_NOTE (succ2, dest))
1793       /* Don't substitute into a non-local goto, this confuses CFG.  */
1794       || (JUMP_P (i3) && find_reg_note (i3, REG_NON_LOCAL_GOTO, NULL_RTX))
1795       /* Make sure that DEST is not used after SUCC but before I3.  */
1796       || (!all_adjacent
1797           && ((succ2
1798                && (reg_used_between_p (dest, succ2, i3)
1799                    || reg_used_between_p (dest, succ, succ2)))
1800               || (!succ2 && succ && reg_used_between_p (dest, succ, i3))))
1801       /* Make sure that the value that is to be substituted for the register
1802          does not use any registers whose values alter in between.  However,
1803          If the insns are adjacent, a use can't cross a set even though we
1804          think it might (this can happen for a sequence of insns each setting
1805          the same destination; last_set of that register might point to
1806          a NOTE).  If INSN has a REG_EQUIV note, the register is always
1807          equivalent to the memory so the substitution is valid even if there
1808          are intervening stores.  Also, don't move a volatile asm or
1809          UNSPEC_VOLATILE across any other insns.  */
1810       || (! all_adjacent
1811           && (((!MEM_P (src)
1812                 || ! find_reg_note (insn, REG_EQUIV, src))
1813                && use_crosses_set_p (src, DF_INSN_LUID (insn)))
1814               || (GET_CODE (src) == ASM_OPERANDS && MEM_VOLATILE_P (src))
1815               || GET_CODE (src) == UNSPEC_VOLATILE))
1816       /* Don't combine across a CALL_INSN, because that would possibly
1817          change whether the life span of some REGs crosses calls or not,
1818          and it is a pain to update that information.
1819          Exception: if source is a constant, moving it later can't hurt.
1820          Accept that as a special case.  */
1821       || (DF_INSN_LUID (insn) < last_call_luid && ! CONSTANT_P (src)))
1822     return 0;
1823
1824   /* DEST must either be a REG or CC0.  */
1825   if (REG_P (dest))
1826     {
1827       /* If register alignment is being enforced for multi-word items in all
1828          cases except for parameters, it is possible to have a register copy
1829          insn referencing a hard register that is not allowed to contain the
1830          mode being copied and which would not be valid as an operand of most
1831          insns.  Eliminate this problem by not combining with such an insn.
1832
1833          Also, on some machines we don't want to extend the life of a hard
1834          register.  */
1835
1836       if (REG_P (src)
1837           && ((REGNO (dest) < FIRST_PSEUDO_REGISTER
1838                && ! HARD_REGNO_MODE_OK (REGNO (dest), GET_MODE (dest)))
1839               /* Don't extend the life of a hard register unless it is
1840                  user variable (if we have few registers) or it can't
1841                  fit into the desired register (meaning something special
1842                  is going on).
1843                  Also avoid substituting a return register into I3, because
1844                  reload can't handle a conflict with constraints of other
1845                  inputs.  */
1846               || (REGNO (src) < FIRST_PSEUDO_REGISTER
1847                   && ! HARD_REGNO_MODE_OK (REGNO (src), GET_MODE (src)))))
1848         return 0;
1849     }
1850   else if (GET_CODE (dest) != CC0)
1851     return 0;
1852
1853
1854   if (GET_CODE (PATTERN (i3)) == PARALLEL)
1855     for (i = XVECLEN (PATTERN (i3), 0) - 1; i >= 0; i--)
1856       if (GET_CODE (XVECEXP (PATTERN (i3), 0, i)) == CLOBBER)
1857         {
1858           /* Don't substitute for a register intended as a clobberable
1859              operand.  */
1860           rtx reg = XEXP (XVECEXP (PATTERN (i3), 0, i), 0);
1861           if (rtx_equal_p (reg, dest))
1862             return 0;
1863
1864           /* If the clobber represents an earlyclobber operand, we must not
1865              substitute an expression containing the clobbered register.
1866              As we do not analyze the constraint strings here, we have to
1867              make the conservative assumption.  However, if the register is
1868              a fixed hard reg, the clobber cannot represent any operand;
1869              we leave it up to the machine description to either accept or
1870              reject use-and-clobber patterns.  */
1871           if (!REG_P (reg)
1872               || REGNO (reg) >= FIRST_PSEUDO_REGISTER
1873               || !fixed_regs[REGNO (reg)])
1874             if (reg_overlap_mentioned_p (reg, src))
1875               return 0;
1876         }
1877
1878   /* If INSN contains anything volatile, or is an `asm' (whether volatile
1879      or not), reject, unless nothing volatile comes between it and I3 */
1880
1881   if (GET_CODE (src) == ASM_OPERANDS || volatile_refs_p (src))
1882     {
1883       /* Make sure neither succ nor succ2 contains a volatile reference.  */
1884       if (succ2 != 0 && volatile_refs_p (PATTERN (succ2)))
1885         return 0;
1886       if (succ != 0 && volatile_refs_p (PATTERN (succ)))
1887         return 0;
1888       /* We'll check insns between INSN and I3 below.  */
1889     }
1890
1891   /* If INSN is an asm, and DEST is a hard register, reject, since it has
1892      to be an explicit register variable, and was chosen for a reason.  */
1893
1894   if (GET_CODE (src) == ASM_OPERANDS
1895       && REG_P (dest) && REGNO (dest) < FIRST_PSEUDO_REGISTER)
1896     return 0;
1897
1898   /* If there are any volatile insns between INSN and I3, reject, because
1899      they might affect machine state.  */
1900
1901   for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p))
1902     if (INSN_P (p) && p != succ && p != succ2 && volatile_insn_p (PATTERN (p)))
1903       return 0;
1904
1905   /* If INSN contains an autoincrement or autodecrement, make sure that
1906      register is not used between there and I3, and not already used in
1907      I3 either.  Neither must it be used in PRED or SUCC, if they exist.
1908      Also insist that I3 not be a jump; if it were one
1909      and the incremented register were spilled, we would lose.  */
1910
1911 #ifdef AUTO_INC_DEC
1912   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1913     if (REG_NOTE_KIND (link) == REG_INC
1914         && (JUMP_P (i3)
1915             || reg_used_between_p (XEXP (link, 0), insn, i3)
1916             || (pred != NULL_RTX
1917                 && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (pred)))
1918             || (pred2 != NULL_RTX
1919                 && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (pred2)))
1920             || (succ != NULL_RTX
1921                 && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (succ)))
1922             || (succ2 != NULL_RTX
1923                 && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (succ2)))
1924             || reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i3))))
1925       return 0;
1926 #endif
1927
1928 #ifdef HAVE_cc0
1929   /* Don't combine an insn that follows a CC0-setting insn.
1930      An insn that uses CC0 must not be separated from the one that sets it.
1931      We do, however, allow I2 to follow a CC0-setting insn if that insn
1932      is passed as I1; in that case it will be deleted also.
1933      We also allow combining in this case if all the insns are adjacent
1934      because that would leave the two CC0 insns adjacent as well.
1935      It would be more logical to test whether CC0 occurs inside I1 or I2,
1936      but that would be much slower, and this ought to be equivalent.  */
1937
1938   p = prev_nonnote_insn (insn);
1939   if (p && p != pred && NONJUMP_INSN_P (p) && sets_cc0_p (PATTERN (p))
1940       && ! all_adjacent)
1941     return 0;
1942 #endif
1943
1944   /* If we get here, we have passed all the tests and the combination is
1945      to be allowed.  */
1946
1947   *pdest = dest;
1948   *psrc = src;
1949
1950   return 1;
1951 }
1952 \f
1953 /* LOC is the location within I3 that contains its pattern or the component
1954    of a PARALLEL of the pattern.  We validate that it is valid for combining.
1955
1956    One problem is if I3 modifies its output, as opposed to replacing it
1957    entirely, we can't allow the output to contain I2DEST, I1DEST or I0DEST as
1958    doing so would produce an insn that is not equivalent to the original insns.
1959
1960    Consider:
1961
1962          (set (reg:DI 101) (reg:DI 100))
1963          (set (subreg:SI (reg:DI 101) 0) <foo>)
1964
1965    This is NOT equivalent to:
1966
1967          (parallel [(set (subreg:SI (reg:DI 100) 0) <foo>)
1968                     (set (reg:DI 101) (reg:DI 100))])
1969
1970    Not only does this modify 100 (in which case it might still be valid
1971    if 100 were dead in I2), it sets 101 to the ORIGINAL value of 100.
1972
1973    We can also run into a problem if I2 sets a register that I1
1974    uses and I1 gets directly substituted into I3 (not via I2).  In that
1975    case, we would be getting the wrong value of I2DEST into I3, so we
1976    must reject the combination.  This case occurs when I2 and I1 both
1977    feed into I3, rather than when I1 feeds into I2, which feeds into I3.
1978    If I1_NOT_IN_SRC is nonzero, it means that finding I1 in the source
1979    of a SET must prevent combination from occurring.  The same situation
1980    can occur for I0, in which case I0_NOT_IN_SRC is set.
1981
1982    Before doing the above check, we first try to expand a field assignment
1983    into a set of logical operations.
1984
1985    If PI3_DEST_KILLED is nonzero, it is a pointer to a location in which
1986    we place a register that is both set and used within I3.  If more than one
1987    such register is detected, we fail.
1988
1989    Return 1 if the combination is valid, zero otherwise.  */
1990
1991 static int
1992 combinable_i3pat (rtx i3, rtx *loc, rtx i2dest, rtx i1dest, rtx i0dest,
1993                   int i1_not_in_src, int i0_not_in_src, rtx *pi3dest_killed)
1994 {
1995   rtx x = *loc;
1996
1997   if (GET_CODE (x) == SET)
1998     {
1999       rtx set = x ;
2000       rtx dest = SET_DEST (set);
2001       rtx src = SET_SRC (set);
2002       rtx inner_dest = dest;
2003       rtx subdest;
2004
2005       while (GET_CODE (inner_dest) == STRICT_LOW_PART
2006              || GET_CODE (inner_dest) == SUBREG
2007              || GET_CODE (inner_dest) == ZERO_EXTRACT)
2008         inner_dest = XEXP (inner_dest, 0);
2009
2010       /* Check for the case where I3 modifies its output, as discussed
2011          above.  We don't want to prevent pseudos from being combined
2012          into the address of a MEM, so only prevent the combination if
2013          i1 or i2 set the same MEM.  */
2014       if ((inner_dest != dest &&
2015            (!MEM_P (inner_dest)
2016             || rtx_equal_p (i2dest, inner_dest)
2017             || (i1dest && rtx_equal_p (i1dest, inner_dest))
2018             || (i0dest && rtx_equal_p (i0dest, inner_dest)))
2019            && (reg_overlap_mentioned_p (i2dest, inner_dest)
2020                || (i1dest && reg_overlap_mentioned_p (i1dest, inner_dest))
2021                || (i0dest && reg_overlap_mentioned_p (i0dest, inner_dest))))
2022
2023           /* This is the same test done in can_combine_p except we can't test
2024              all_adjacent; we don't have to, since this instruction will stay
2025              in place, thus we are not considering increasing the lifetime of
2026              INNER_DEST.
2027
2028              Also, if this insn sets a function argument, combining it with
2029              something that might need a spill could clobber a previous
2030              function argument; the all_adjacent test in can_combine_p also
2031              checks this; here, we do a more specific test for this case.  */
2032
2033           || (REG_P (inner_dest)
2034               && REGNO (inner_dest) < FIRST_PSEUDO_REGISTER
2035               && (! HARD_REGNO_MODE_OK (REGNO (inner_dest),
2036                                         GET_MODE (inner_dest))))
2037           || (i1_not_in_src && reg_overlap_mentioned_p (i1dest, src))
2038           || (i0_not_in_src && reg_overlap_mentioned_p (i0dest, src)))
2039         return 0;
2040
2041       /* If DEST is used in I3, it is being killed in this insn, so
2042          record that for later.  We have to consider paradoxical
2043          subregs here, since they kill the whole register, but we
2044          ignore partial subregs, STRICT_LOW_PART, etc.
2045          Never add REG_DEAD notes for the FRAME_POINTER_REGNUM or the
2046          STACK_POINTER_REGNUM, since these are always considered to be
2047          live.  Similarly for ARG_POINTER_REGNUM if it is fixed.  */
2048       subdest = dest;
2049       if (GET_CODE (subdest) == SUBREG
2050           && (GET_MODE_SIZE (GET_MODE (subdest))
2051               >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (subdest)))))
2052         subdest = SUBREG_REG (subdest);
2053       if (pi3dest_killed
2054           && REG_P (subdest)
2055           && reg_referenced_p (subdest, PATTERN (i3))
2056           && REGNO (subdest) != FRAME_POINTER_REGNUM
2057 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
2058           && REGNO (subdest) != HARD_FRAME_POINTER_REGNUM
2059 #endif
2060 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
2061           && (REGNO (subdest) != ARG_POINTER_REGNUM
2062               || ! fixed_regs [REGNO (subdest)])
2063 #endif
2064           && REGNO (subdest) != STACK_POINTER_REGNUM)
2065         {
2066           if (*pi3dest_killed)
2067             return 0;
2068
2069           *pi3dest_killed = subdest;
2070         }
2071     }
2072
2073   else if (GET_CODE (x) == PARALLEL)
2074     {
2075       int i;
2076
2077       for (i = 0; i < XVECLEN (x, 0); i++)
2078         if (! combinable_i3pat (i3, &XVECEXP (x, 0, i), i2dest, i1dest, i0dest,
2079                                 i1_not_in_src, i0_not_in_src, pi3dest_killed))
2080           return 0;
2081     }
2082
2083   return 1;
2084 }
2085 \f
2086 /* Return 1 if X is an arithmetic expression that contains a multiplication
2087    and division.  We don't count multiplications by powers of two here.  */
2088
2089 static int
2090 contains_muldiv (rtx x)
2091 {
2092   switch (GET_CODE (x))
2093     {
2094     case MOD:  case DIV:  case UMOD:  case UDIV:
2095       return 1;
2096
2097     case MULT:
2098       return ! (CONST_INT_P (XEXP (x, 1))
2099                 && exact_log2 (UINTVAL (XEXP (x, 1))) >= 0);
2100     default:
2101       if (BINARY_P (x))
2102         return contains_muldiv (XEXP (x, 0))
2103             || contains_muldiv (XEXP (x, 1));
2104
2105       if (UNARY_P (x))
2106         return contains_muldiv (XEXP (x, 0));
2107
2108       return 0;
2109     }
2110 }
2111 \f
2112 /* Determine whether INSN can be used in a combination.  Return nonzero if
2113    not.  This is used in try_combine to detect early some cases where we
2114    can't perform combinations.  */
2115
2116 static int
2117 cant_combine_insn_p (rtx insn)
2118 {
2119   rtx set;
2120   rtx src, dest;
2121
2122   /* If this isn't really an insn, we can't do anything.
2123      This can occur when flow deletes an insn that it has merged into an
2124      auto-increment address.  */
2125   if (! INSN_P (insn))
2126     return 1;
2127
2128   /* Never combine loads and stores involving hard regs that are likely
2129      to be spilled.  The register allocator can usually handle such
2130      reg-reg moves by tying.  If we allow the combiner to make
2131      substitutions of likely-spilled regs, reload might die.
2132      As an exception, we allow combinations involving fixed regs; these are
2133      not available to the register allocator so there's no risk involved.  */
2134
2135   set = single_set (insn);
2136   if (! set)
2137     return 0;
2138   src = SET_SRC (set);
2139   dest = SET_DEST (set);
2140   if (GET_CODE (src) == SUBREG)
2141     src = SUBREG_REG (src);
2142   if (GET_CODE (dest) == SUBREG)
2143     dest = SUBREG_REG (dest);
2144   if (REG_P (src) && REG_P (dest)
2145       && ((HARD_REGISTER_P (src)
2146            && ! TEST_HARD_REG_BIT (fixed_reg_set, REGNO (src))
2147            && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (src))))
2148           || (HARD_REGISTER_P (dest)
2149               && ! TEST_HARD_REG_BIT (fixed_reg_set, REGNO (dest))
2150               && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (dest))))))
2151     return 1;
2152
2153   return 0;
2154 }
2155
2156 struct likely_spilled_retval_info
2157 {
2158   unsigned regno, nregs;
2159   unsigned mask;
2160 };
2161
2162 /* Called via note_stores by likely_spilled_retval_p.  Remove from info->mask
2163    hard registers that are known to be written to / clobbered in full.  */
2164 static void
2165 likely_spilled_retval_1 (rtx x, const_rtx set, void *data)
2166 {
2167   struct likely_spilled_retval_info *const info =
2168     (struct likely_spilled_retval_info *) data;
2169   unsigned regno, nregs;
2170   unsigned new_mask;
2171
2172   if (!REG_P (XEXP (set, 0)))
2173     return;
2174   regno = REGNO (x);
2175   if (regno >= info->regno + info->nregs)
2176     return;
2177   nregs = hard_regno_nregs[regno][GET_MODE (x)];
2178   if (regno + nregs <= info->regno)
2179     return;
2180   new_mask = (2U << (nregs - 1)) - 1;
2181   if (regno < info->regno)
2182     new_mask >>= info->regno - regno;
2183   else
2184     new_mask <<= regno - info->regno;
2185   info->mask &= ~new_mask;
2186 }
2187
2188 /* Return nonzero iff part of the return value is live during INSN, and
2189    it is likely spilled.  This can happen when more than one insn is needed
2190    to copy the return value, e.g. when we consider to combine into the
2191    second copy insn for a complex value.  */
2192
2193 static int
2194 likely_spilled_retval_p (rtx insn)
2195 {
2196   rtx use = BB_END (this_basic_block);
2197   rtx reg, p;
2198   unsigned regno, nregs;
2199   /* We assume here that no machine mode needs more than
2200      32 hard registers when the value overlaps with a register
2201      for which TARGET_FUNCTION_VALUE_REGNO_P is true.  */
2202   unsigned mask;
2203   struct likely_spilled_retval_info info;
2204
2205   if (!NONJUMP_INSN_P (use) || GET_CODE (PATTERN (use)) != USE || insn == use)
2206     return 0;
2207   reg = XEXP (PATTERN (use), 0);
2208   if (!REG_P (reg) || !targetm.calls.function_value_regno_p (REGNO (reg)))
2209     return 0;
2210   regno = REGNO (reg);
2211   nregs = hard_regno_nregs[regno][GET_MODE (reg)];
2212   if (nregs == 1)
2213     return 0;
2214   mask = (2U << (nregs - 1)) - 1;
2215
2216   /* Disregard parts of the return value that are set later.  */
2217   info.regno = regno;
2218   info.nregs = nregs;
2219   info.mask = mask;
2220   for (p = PREV_INSN (use); info.mask && p != insn; p = PREV_INSN (p))
2221     if (INSN_P (p))
2222       note_stores (PATTERN (p), likely_spilled_retval_1, &info);
2223   mask = info.mask;
2224
2225   /* Check if any of the (probably) live return value registers is
2226      likely spilled.  */
2227   nregs --;
2228   do
2229     {
2230       if ((mask & 1 << nregs)
2231           && targetm.class_likely_spilled_p (REGNO_REG_CLASS (regno + nregs)))
2232         return 1;
2233     } while (nregs--);
2234   return 0;
2235 }
2236
2237 /* Adjust INSN after we made a change to its destination.
2238
2239    Changing the destination can invalidate notes that say something about
2240    the results of the insn and a LOG_LINK pointing to the insn.  */
2241
2242 static void
2243 adjust_for_new_dest (rtx insn)
2244 {
2245   /* For notes, be conservative and simply remove them.  */
2246   remove_reg_equal_equiv_notes (insn);
2247
2248   /* The new insn will have a destination that was previously the destination
2249      of an insn just above it.  Call distribute_links to make a LOG_LINK from
2250      the next use of that destination.  */
2251   distribute_links (gen_rtx_INSN_LIST (VOIDmode, insn, NULL_RTX));
2252
2253   df_insn_rescan (insn);
2254 }
2255
2256 /* Return TRUE if combine can reuse reg X in mode MODE.
2257    ADDED_SETS is nonzero if the original set is still required.  */
2258 static bool
2259 can_change_dest_mode (rtx x, int added_sets, enum machine_mode mode)
2260 {
2261   unsigned int regno;
2262
2263   if (!REG_P(x))
2264     return false;
2265
2266   regno = REGNO (x);
2267   /* Allow hard registers if the new mode is legal, and occupies no more
2268      registers than the old mode.  */
2269   if (regno < FIRST_PSEUDO_REGISTER)
2270     return (HARD_REGNO_MODE_OK (regno, mode)
2271             && (hard_regno_nregs[regno][GET_MODE (x)]
2272                 >= hard_regno_nregs[regno][mode]));
2273
2274   /* Or a pseudo that is only used once.  */
2275   return (REG_N_SETS (regno) == 1 && !added_sets
2276           && !REG_USERVAR_P (x));
2277 }
2278
2279
2280 /* Check whether X, the destination of a set, refers to part of
2281    the register specified by REG.  */
2282
2283 static bool
2284 reg_subword_p (rtx x, rtx reg)
2285 {
2286   /* Check that reg is an integer mode register.  */
2287   if (!REG_P (reg) || GET_MODE_CLASS (GET_MODE (reg)) != MODE_INT)
2288     return false;
2289
2290   if (GET_CODE (x) == STRICT_LOW_PART
2291       || GET_CODE (x) == ZERO_EXTRACT)
2292     x = XEXP (x, 0);
2293
2294   return GET_CODE (x) == SUBREG
2295          && SUBREG_REG (x) == reg
2296          && GET_MODE_CLASS (GET_MODE (x)) == MODE_INT;
2297 }
2298
2299 #ifdef AUTO_INC_DEC
2300 /* Replace auto-increment addressing modes with explicit operations to access
2301    the same addresses without modifying the corresponding registers.  */
2302
2303 static rtx
2304 cleanup_auto_inc_dec (rtx src, enum machine_mode mem_mode)
2305 {
2306   rtx x = src;
2307   const RTX_CODE code = GET_CODE (x);
2308   int i;
2309   const char *fmt;
2310
2311   switch (code)
2312     {
2313     case REG:
2314     case CONST_INT:
2315     case CONST_DOUBLE:
2316     case CONST_FIXED:
2317     case CONST_VECTOR:
2318     case SYMBOL_REF:
2319     case CODE_LABEL:
2320     case PC:
2321     case CC0:
2322     case SCRATCH:
2323       /* SCRATCH must be shared because they represent distinct values.  */
2324       return x;
2325     case CLOBBER:
2326       if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
2327         return x;
2328       break;
2329
2330     case CONST:
2331       if (shared_const_p (x))
2332         return x;
2333       break;
2334
2335     case MEM:
2336       mem_mode = GET_MODE (x);
2337       break;
2338
2339     case PRE_INC:
2340     case PRE_DEC:
2341       gcc_assert (mem_mode != VOIDmode && mem_mode != BLKmode);
2342       return gen_rtx_PLUS (GET_MODE (x),
2343                            cleanup_auto_inc_dec (XEXP (x, 0), mem_mode),
2344                            GEN_INT (code == PRE_INC
2345                                     ? GET_MODE_SIZE (mem_mode)
2346                                     : -GET_MODE_SIZE (mem_mode)));
2347
2348     case POST_INC:
2349     case POST_DEC:
2350     case PRE_MODIFY:
2351     case POST_MODIFY:
2352       return cleanup_auto_inc_dec (code == PRE_MODIFY
2353                                    ? XEXP (x, 1) : XEXP (x, 0),
2354                                    mem_mode);
2355
2356     default:
2357       break;
2358     }
2359
2360   /* Copy the various flags, fields, and other information.  We assume
2361      that all fields need copying, and then clear the fields that should
2362      not be copied.  That is the sensible default behavior, and forces
2363      us to explicitly document why we are *not* copying a flag.  */
2364   x = shallow_copy_rtx (x);
2365
2366   /* We do not copy the USED flag, which is used as a mark bit during
2367      walks over the RTL.  */
2368   RTX_FLAG (x, used) = 0;
2369
2370   /* We do not copy FRAME_RELATED for INSNs.  */
2371   if (INSN_P (x))
2372     RTX_FLAG (x, frame_related) = 0;
2373
2374   fmt = GET_RTX_FORMAT (code);
2375   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2376     if (fmt[i] == 'e')
2377       XEXP (x, i) = cleanup_auto_inc_dec (XEXP (x, i), mem_mode);
2378     else if (fmt[i] == 'E' || fmt[i] == 'V')
2379       {
2380         int j;
2381         XVEC (x, i) = rtvec_alloc (XVECLEN (x, i));
2382         for (j = 0; j < XVECLEN (x, i); j++)
2383           XVECEXP (x, i, j)
2384             = cleanup_auto_inc_dec (XVECEXP (src, i, j), mem_mode);
2385       }
2386
2387   return x;
2388 }
2389 #endif
2390
2391 /* Auxiliary data structure for propagate_for_debug_stmt.  */
2392
2393 struct rtx_subst_pair
2394 {
2395   rtx to;
2396   bool adjusted;
2397 };
2398
2399 /* DATA points to an rtx_subst_pair.  Return the value that should be
2400    substituted.  */
2401
2402 static rtx
2403 propagate_for_debug_subst (rtx from, const_rtx old_rtx, void *data)
2404 {
2405   struct rtx_subst_pair *pair = (struct rtx_subst_pair *)data;
2406
2407   if (!rtx_equal_p (from, old_rtx))
2408     return NULL_RTX;
2409   if (!pair->adjusted)
2410     {
2411       pair->adjusted = true;
2412 #ifdef AUTO_INC_DEC
2413       pair->to = cleanup_auto_inc_dec (pair->to, VOIDmode);
2414 #else
2415       pair->to = copy_rtx (pair->to);
2416 #endif
2417       pair->to = make_compound_operation (pair->to, SET);
2418       return pair->to;
2419     }
2420   return copy_rtx (pair->to);
2421 }
2422
2423 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
2424    and LAST.  */
2425
2426 static void
2427 propagate_for_debug (rtx insn, rtx last, rtx dest, rtx src)
2428 {
2429   rtx next, loc;
2430
2431   struct rtx_subst_pair p;
2432   p.to = src;
2433   p.adjusted = false;
2434
2435   next = NEXT_INSN (insn);
2436   while (next != last)
2437     {
2438       insn = next;
2439       next = NEXT_INSN (insn);
2440       if (DEBUG_INSN_P (insn))
2441         {
2442           loc = simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn),
2443                                          dest, propagate_for_debug_subst, &p);
2444           if (loc == INSN_VAR_LOCATION_LOC (insn))
2445             continue;
2446           INSN_VAR_LOCATION_LOC (insn) = loc;
2447           df_insn_rescan (insn);
2448         }
2449     }
2450 }
2451
2452 /* Delete the unconditional jump INSN and adjust the CFG correspondingly.
2453    Note that the INSN should be deleted *after* removing dead edges, so
2454    that the kept edge is the fallthrough edge for a (set (pc) (pc))
2455    but not for a (set (pc) (label_ref FOO)).  */
2456
2457 static void
2458 update_cfg_for_uncondjump (rtx insn)
2459 {
2460   basic_block bb = BLOCK_FOR_INSN (insn);
2461   bool at_end = (BB_END (bb) == insn);
2462
2463   if (at_end)
2464     purge_dead_edges (bb);
2465
2466   delete_insn (insn);
2467   if (at_end && EDGE_COUNT (bb->succs) == 1)
2468     {
2469       rtx insn;
2470
2471       single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
2472
2473       /* Remove barriers from the footer if there are any.  */
2474       for (insn = bb->il.rtl->footer; insn; insn = NEXT_INSN (insn))
2475         if (BARRIER_P (insn))
2476           {
2477             if (PREV_INSN (insn))
2478               NEXT_INSN (PREV_INSN (insn)) = NEXT_INSN (insn);
2479             else
2480               bb->il.rtl->footer = NEXT_INSN (insn);
2481             if (NEXT_INSN (insn))
2482               PREV_INSN (NEXT_INSN (insn)) = PREV_INSN (insn);
2483           }
2484         else if (LABEL_P (insn))
2485           break;
2486     }
2487 }
2488
2489 /* Try to combine the insns I0, I1 and I2 into I3.
2490    Here I0, I1 and I2 appear earlier than I3.
2491    I0 and I1 can be zero; then we combine just I2 into I3, or I1 and I2 into
2492    I3.
2493
2494    If we are combining more than two insns and the resulting insn is not
2495    recognized, try splitting it into two insns.  If that happens, I2 and I3
2496    are retained and I1/I0 are pseudo-deleted by turning them into a NOTE.
2497    Otherwise, I0, I1 and I2 are pseudo-deleted.
2498
2499    Return 0 if the combination does not work.  Then nothing is changed.
2500    If we did the combination, return the insn at which combine should
2501    resume scanning.
2502
2503    Set NEW_DIRECT_JUMP_P to a nonzero value if try_combine creates a
2504    new direct jump instruction.  */
2505
2506 static rtx
2507 try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p)
2508 {
2509   /* New patterns for I3 and I2, respectively.  */
2510   rtx newpat, newi2pat = 0;
2511   rtvec newpat_vec_with_clobbers = 0;
2512   int substed_i2 = 0, substed_i1 = 0, substed_i0 = 0;
2513   /* Indicates need to preserve SET in I0, I1 or I2 in I3 if it is not
2514      dead.  */
2515   int added_sets_0, added_sets_1, added_sets_2;
2516   /* Total number of SETs to put into I3.  */
2517   int total_sets;
2518   /* Nonzero if I2's or I1's body now appears in I3.  */
2519   int i2_is_used = 0, i1_is_used = 0;
2520   /* INSN_CODEs for new I3, new I2, and user of condition code.  */
2521   int insn_code_number, i2_code_number = 0, other_code_number = 0;
2522   /* Contains I3 if the destination of I3 is used in its source, which means
2523      that the old life of I3 is being killed.  If that usage is placed into
2524      I2 and not in I3, a REG_DEAD note must be made.  */
2525   rtx i3dest_killed = 0;
2526   /* SET_DEST and SET_SRC of I2, I1 and I0.  */
2527   rtx i2dest = 0, i2src = 0, i1dest = 0, i1src = 0, i0dest = 0, i0src = 0;
2528   /* Copy of SET_SRC of I1, if needed.  */
2529   rtx i1src_copy = 0;
2530   /* Set if I2DEST was reused as a scratch register.  */
2531   bool i2scratch = false;
2532   /* The PATTERNs of I0, I1, and I2, or a copy of them in certain cases.  */
2533   rtx i0pat = 0, i1pat = 0, i2pat = 0;
2534   /* Indicates if I2DEST or I1DEST is in I2SRC or I1_SRC.  */
2535   int i2dest_in_i2src = 0, i1dest_in_i1src = 0, i2dest_in_i1src = 0;
2536   int i0dest_in_i0src = 0, i1dest_in_i0src = 0, i2dest_in_i0src = 0;
2537   int i2dest_killed = 0, i1dest_killed = 0, i0dest_killed = 0;
2538   int i1_feeds_i2_n = 0, i0_feeds_i2_n = 0, i0_feeds_i1_n = 0;
2539   /* Notes that must be added to REG_NOTES in I3 and I2.  */
2540   rtx new_i3_notes, new_i2_notes;
2541   /* Notes that we substituted I3 into I2 instead of the normal case.  */
2542   int i3_subst_into_i2 = 0;
2543   /* Notes that I1, I2 or I3 is a MULT operation.  */
2544   int have_mult = 0;
2545   int swap_i2i3 = 0;
2546   int changed_i3_dest = 0;
2547
2548   int maxreg;
2549   rtx temp;
2550   rtx link;
2551   rtx other_pat = 0;
2552   rtx new_other_notes;
2553   int i;
2554
2555   /* Only try four-insn combinations when there's high likelihood of
2556      success.  Look for simple insns, such as loads of constants or
2557      binary operations involving a constant.  */
2558   if (i0)
2559     {
2560       int i;
2561       int ngood = 0;
2562       int nshift = 0;
2563
2564       if (!flag_expensive_optimizations)
2565         return 0;
2566
2567       for (i = 0; i < 4; i++)
2568         {
2569           rtx insn = i == 0 ? i0 : i == 1 ? i1 : i == 2 ? i2 : i3;
2570           rtx set = single_set (insn);
2571           rtx src;
2572           if (!set)
2573             continue;
2574           src = SET_SRC (set);
2575           if (CONSTANT_P (src))
2576             {
2577               ngood += 2;
2578               break;
2579             }
2580           else if (BINARY_P (src) && CONSTANT_P (XEXP (src, 1)))
2581             ngood++;
2582           else if (GET_CODE (src) == ASHIFT || GET_CODE (src) == ASHIFTRT
2583                    || GET_CODE (src) == LSHIFTRT)
2584             nshift++;
2585         }
2586       if (ngood < 2 && nshift < 2)
2587         return 0;
2588     }
2589
2590   /* Exit early if one of the insns involved can't be used for
2591      combinations.  */
2592   if (cant_combine_insn_p (i3)
2593       || cant_combine_insn_p (i2)
2594       || (i1 && cant_combine_insn_p (i1))
2595       || (i0 && cant_combine_insn_p (i0))
2596       || likely_spilled_retval_p (i3))
2597     return 0;
2598
2599   combine_attempts++;
2600   undobuf.other_insn = 0;
2601
2602   /* Reset the hard register usage information.  */
2603   CLEAR_HARD_REG_SET (newpat_used_regs);
2604
2605   if (dump_file && (dump_flags & TDF_DETAILS))
2606     {
2607       if (i0)
2608         fprintf (dump_file, "\nTrying %d, %d, %d -> %d:\n",
2609                  INSN_UID (i0), INSN_UID (i1), INSN_UID (i2), INSN_UID (i3));
2610       else if (i1)
2611         fprintf (dump_file, "\nTrying %d, %d -> %d:\n",
2612                  INSN_UID (i1), INSN_UID (i2), INSN_UID (i3));
2613       else
2614         fprintf (dump_file, "\nTrying %d -> %d:\n",
2615                  INSN_UID (i2), INSN_UID (i3));
2616     }
2617
2618   /* If multiple insns feed into one of I2 or I3, they can be in any
2619      order.  To simplify the code below, reorder them in sequence.  */
2620   if (i0 && DF_INSN_LUID (i0) > DF_INSN_LUID (i2))
2621     temp = i2, i2 = i0, i0 = temp;
2622   if (i0 && DF_INSN_LUID (i0) > DF_INSN_LUID (i1))
2623     temp = i1, i1 = i0, i0 = temp;
2624   if (i1 && DF_INSN_LUID (i1) > DF_INSN_LUID (i2))
2625     temp = i1, i1 = i2, i2 = temp;
2626
2627   added_links_insn = 0;
2628
2629   /* First check for one important special case that the code below will
2630      not handle.  Namely, the case where I1 is zero, I2 is a PARALLEL
2631      and I3 is a SET whose SET_SRC is a SET_DEST in I2.  In that case,
2632      we may be able to replace that destination with the destination of I3.
2633      This occurs in the common code where we compute both a quotient and
2634      remainder into a structure, in which case we want to do the computation
2635      directly into the structure to avoid register-register copies.
2636
2637      Note that this case handles both multiple sets in I2 and also cases
2638      where I2 has a number of CLOBBERs inside the PARALLEL.
2639
2640      We make very conservative checks below and only try to handle the
2641      most common cases of this.  For example, we only handle the case
2642      where I2 and I3 are adjacent to avoid making difficult register
2643      usage tests.  */
2644
2645   if (i1 == 0 && NONJUMP_INSN_P (i3) && GET_CODE (PATTERN (i3)) == SET
2646       && REG_P (SET_SRC (PATTERN (i3)))
2647       && REGNO (SET_SRC (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
2648       && find_reg_note (i3, REG_DEAD, SET_SRC (PATTERN (i3)))
2649       && GET_CODE (PATTERN (i2)) == PARALLEL
2650       && ! side_effects_p (SET_DEST (PATTERN (i3)))
2651       /* If the dest of I3 is a ZERO_EXTRACT or STRICT_LOW_PART, the code
2652          below would need to check what is inside (and reg_overlap_mentioned_p
2653          doesn't support those codes anyway).  Don't allow those destinations;
2654          the resulting insn isn't likely to be recognized anyway.  */
2655       && GET_CODE (SET_DEST (PATTERN (i3))) != ZERO_EXTRACT
2656       && GET_CODE (SET_DEST (PATTERN (i3))) != STRICT_LOW_PART
2657       && ! reg_overlap_mentioned_p (SET_SRC (PATTERN (i3)),
2658                                     SET_DEST (PATTERN (i3)))
2659       && next_active_insn (i2) == i3)
2660     {
2661       rtx p2 = PATTERN (i2);
2662
2663       /* Make sure that the destination of I3,
2664          which we are going to substitute into one output of I2,
2665          is not used within another output of I2.  We must avoid making this:
2666          (parallel [(set (mem (reg 69)) ...)
2667                     (set (reg 69) ...)])
2668          which is not well-defined as to order of actions.
2669          (Besides, reload can't handle output reloads for this.)
2670
2671          The problem can also happen if the dest of I3 is a memory ref,
2672          if another dest in I2 is an indirect memory ref.  */
2673       for (i = 0; i < XVECLEN (p2, 0); i++)
2674         if ((GET_CODE (XVECEXP (p2, 0, i)) == SET
2675              || GET_CODE (XVECEXP (p2, 0, i)) == CLOBBER)
2676             && reg_overlap_mentioned_p (SET_DEST (PATTERN (i3)),
2677                                         SET_DEST (XVECEXP (p2, 0, i))))
2678           break;
2679
2680       if (i == XVECLEN (p2, 0))
2681         for (i = 0; i < XVECLEN (p2, 0); i++)
2682           if (GET_CODE (XVECEXP (p2, 0, i)) == SET
2683               && SET_DEST (XVECEXP (p2, 0, i)) == SET_SRC (PATTERN (i3)))
2684             {
2685               combine_merges++;
2686
2687               subst_insn = i3;
2688               subst_low_luid = DF_INSN_LUID (i2);
2689
2690               added_sets_2 = added_sets_1 = added_sets_0 = 0;
2691               i2src = SET_SRC (XVECEXP (p2, 0, i));
2692               i2dest = SET_DEST (XVECEXP (p2, 0, i));
2693               i2dest_killed = dead_or_set_p (i2, i2dest);
2694
2695               /* Replace the dest in I2 with our dest and make the resulting
2696                  insn the new pattern for I3.  Then skip to where we validate
2697                  the pattern.  Everything was set up above.  */
2698               SUBST (SET_DEST (XVECEXP (p2, 0, i)), SET_DEST (PATTERN (i3)));
2699               newpat = p2;
2700               i3_subst_into_i2 = 1;
2701               goto validate_replacement;
2702             }
2703     }
2704
2705   /* If I2 is setting a pseudo to a constant and I3 is setting some
2706      sub-part of it to another constant, merge them by making a new
2707      constant.  */
2708   if (i1 == 0
2709       && (temp = single_set (i2)) != 0
2710       && (CONST_INT_P (SET_SRC (temp))
2711           || GET_CODE (SET_SRC (temp)) == CONST_DOUBLE)
2712       && GET_CODE (PATTERN (i3)) == SET
2713       && (CONST_INT_P (SET_SRC (PATTERN (i3)))
2714           || GET_CODE (SET_SRC (PATTERN (i3))) == CONST_DOUBLE)
2715       && reg_subword_p (SET_DEST (PATTERN (i3)), SET_DEST (temp)))
2716     {
2717       rtx dest = SET_DEST (PATTERN (i3));
2718       int offset = -1;
2719       int width = 0;
2720
2721       if (GET_CODE (dest) == ZERO_EXTRACT)
2722         {
2723           if (CONST_INT_P (XEXP (dest, 1))
2724               && CONST_INT_P (XEXP (dest, 2)))
2725             {
2726               width = INTVAL (XEXP (dest, 1));
2727               offset = INTVAL (XEXP (dest, 2));
2728               dest = XEXP (dest, 0);
2729               if (BITS_BIG_ENDIAN)
2730                 offset = GET_MODE_BITSIZE (GET_MODE (dest)) - width - offset;
2731             }
2732         }
2733       else
2734         {
2735           if (GET_CODE (dest) == STRICT_LOW_PART)
2736             dest = XEXP (dest, 0);
2737           width = GET_MODE_BITSIZE (GET_MODE (dest));
2738           offset = 0;
2739         }
2740
2741       if (offset >= 0)
2742         {
2743           /* If this is the low part, we're done.  */
2744           if (subreg_lowpart_p (dest))
2745             ;
2746           /* Handle the case where inner is twice the size of outer.  */
2747           else if (GET_MODE_BITSIZE (GET_MODE (SET_DEST (temp)))
2748                    == 2 * GET_MODE_BITSIZE (GET_MODE (dest)))
2749             offset += GET_MODE_BITSIZE (GET_MODE (dest));
2750           /* Otherwise give up for now.  */
2751           else
2752             offset = -1;
2753         }
2754
2755       if (offset >= 0
2756           && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (temp)))
2757               <= HOST_BITS_PER_DOUBLE_INT))
2758         {
2759           double_int m, o, i;
2760           rtx inner = SET_SRC (PATTERN (i3));
2761           rtx outer = SET_SRC (temp);
2762
2763           o = rtx_to_double_int (outer);
2764           i = rtx_to_double_int (inner);
2765
2766           m = double_int_mask (width);
2767           i = double_int_and (i, m);
2768           m = double_int_lshift (m, offset, HOST_BITS_PER_DOUBLE_INT, false);
2769           i = double_int_lshift (i, offset, HOST_BITS_PER_DOUBLE_INT, false);
2770           o = double_int_ior (double_int_and_not (o, m), i);
2771
2772           combine_merges++;
2773           subst_insn = i3;
2774           subst_low_luid = DF_INSN_LUID (i2);
2775           added_sets_2 = added_sets_1 = added_sets_0 = 0;
2776           i2dest = SET_DEST (temp);
2777           i2dest_killed = dead_or_set_p (i2, i2dest);
2778
2779           /* Replace the source in I2 with the new constant and make the
2780              resulting insn the new pattern for I3.  Then skip to where we
2781              validate the pattern.  Everything was set up above.  */
2782           SUBST (SET_SRC (temp),
2783                  immed_double_int_const (o, GET_MODE (SET_DEST (temp))));
2784
2785           newpat = PATTERN (i2);
2786
2787           /* The dest of I3 has been replaced with the dest of I2.  */
2788           changed_i3_dest = 1;
2789           goto validate_replacement;
2790         }
2791     }
2792
2793 #ifndef HAVE_cc0
2794   /* If we have no I1 and I2 looks like:
2795         (parallel [(set (reg:CC X) (compare:CC OP (const_int 0)))
2796                    (set Y OP)])
2797      make up a dummy I1 that is
2798         (set Y OP)
2799      and change I2 to be
2800         (set (reg:CC X) (compare:CC Y (const_int 0)))
2801
2802      (We can ignore any trailing CLOBBERs.)
2803
2804      This undoes a previous combination and allows us to match a branch-and-
2805      decrement insn.  */
2806
2807   if (i1 == 0 && GET_CODE (PATTERN (i2)) == PARALLEL
2808       && XVECLEN (PATTERN (i2), 0) >= 2
2809       && GET_CODE (XVECEXP (PATTERN (i2), 0, 0)) == SET
2810       && (GET_MODE_CLASS (GET_MODE (SET_DEST (XVECEXP (PATTERN (i2), 0, 0))))
2811           == MODE_CC)
2812       && GET_CODE (SET_SRC (XVECEXP (PATTERN (i2), 0, 0))) == COMPARE
2813       && XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 1) == const0_rtx
2814       && GET_CODE (XVECEXP (PATTERN (i2), 0, 1)) == SET
2815       && REG_P (SET_DEST (XVECEXP (PATTERN (i2), 0, 1)))
2816       && rtx_equal_p (XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 0),
2817                       SET_SRC (XVECEXP (PATTERN (i2), 0, 1))))
2818     {
2819       for (i = XVECLEN (PATTERN (i2), 0) - 1; i >= 2; i--)
2820         if (GET_CODE (XVECEXP (PATTERN (i2), 0, i)) != CLOBBER)
2821           break;
2822
2823       if (i == 1)
2824         {
2825           /* We make I1 with the same INSN_UID as I2.  This gives it
2826              the same DF_INSN_LUID for value tracking.  Our fake I1 will
2827              never appear in the insn stream so giving it the same INSN_UID
2828              as I2 will not cause a problem.  */
2829
2830           i1 = gen_rtx_INSN (VOIDmode, INSN_UID (i2), NULL_RTX, i2,
2831                              BLOCK_FOR_INSN (i2), XVECEXP (PATTERN (i2), 0, 1),
2832                              INSN_LOCATOR (i2), -1, NULL_RTX);
2833
2834           SUBST (PATTERN (i2), XVECEXP (PATTERN (i2), 0, 0));
2835           SUBST (XEXP (SET_SRC (PATTERN (i2)), 0),
2836                  SET_DEST (PATTERN (i1)));
2837         }
2838     }
2839 #endif
2840
2841   /* Verify that I2 and I1 are valid for combining.  */
2842   if (! can_combine_p (i2, i3, i0, i1, NULL_RTX, NULL_RTX, &i2dest, &i2src)
2843       || (i1 && ! can_combine_p (i1, i3, i0, NULL_RTX, i2, NULL_RTX,
2844                                  &i1dest, &i1src))
2845       || (i0 && ! can_combine_p (i0, i3, NULL_RTX, NULL_RTX, i1, i2,
2846                                  &i0dest, &i0src)))
2847     {
2848       undo_all ();
2849       return 0;
2850     }
2851
2852   /* Record whether I2DEST is used in I2SRC and similarly for the other
2853      cases.  Knowing this will help in register status updating below.  */
2854   i2dest_in_i2src = reg_overlap_mentioned_p (i2dest, i2src);
2855   i1dest_in_i1src = i1 && reg_overlap_mentioned_p (i1dest, i1src);
2856   i2dest_in_i1src = i1 && reg_overlap_mentioned_p (i2dest, i1src);
2857   i0dest_in_i0src = i0 && reg_overlap_mentioned_p (i0dest, i0src);
2858   i1dest_in_i0src = i0 && reg_overlap_mentioned_p (i1dest, i0src);
2859   i2dest_in_i0src = i0 && reg_overlap_mentioned_p (i2dest, i0src);
2860   i2dest_killed = dead_or_set_p (i2, i2dest);
2861   i1dest_killed = i1 && dead_or_set_p (i1, i1dest);
2862   i0dest_killed = i0 && dead_or_set_p (i0, i0dest);
2863
2864   /* For the earlier insns, determine which of the subsequent ones they
2865      feed.  */
2866   i1_feeds_i2_n = i1 && insn_a_feeds_b (i1, i2);
2867   i0_feeds_i1_n = i0 && insn_a_feeds_b (i0, i1);
2868   i0_feeds_i2_n = (i0 && (!i0_feeds_i1_n ? insn_a_feeds_b (i0, i2)
2869                           : (!reg_overlap_mentioned_p (i1dest, i0dest)
2870                              && reg_overlap_mentioned_p (i0dest, i2src))));
2871
2872   /* Ensure that I3's pattern can be the destination of combines.  */
2873   if (! combinable_i3pat (i3, &PATTERN (i3), i2dest, i1dest, i0dest,
2874                           i1 && i2dest_in_i1src && !i1_feeds_i2_n,
2875                           i0 && ((i2dest_in_i0src && !i0_feeds_i2_n)
2876                                  || (i1dest_in_i0src && !i0_feeds_i1_n)),
2877                           &i3dest_killed))
2878     {
2879       undo_all ();
2880       return 0;
2881     }
2882
2883   /* See if any of the insns is a MULT operation.  Unless one is, we will
2884      reject a combination that is, since it must be slower.  Be conservative
2885      here.  */
2886   if (GET_CODE (i2src) == MULT
2887       || (i1 != 0 && GET_CODE (i1src) == MULT)
2888       || (i0 != 0 && GET_CODE (i0src) == MULT)
2889       || (GET_CODE (PATTERN (i3)) == SET
2890           && GET_CODE (SET_SRC (PATTERN (i3))) == MULT))
2891     have_mult = 1;
2892
2893   /* If I3 has an inc, then give up if I1 or I2 uses the reg that is inc'd.
2894      We used to do this EXCEPT in one case: I3 has a post-inc in an
2895      output operand.  However, that exception can give rise to insns like
2896         mov r3,(r3)+
2897      which is a famous insn on the PDP-11 where the value of r3 used as the
2898      source was model-dependent.  Avoid this sort of thing.  */
2899
2900 #if 0
2901   if (!(GET_CODE (PATTERN (i3)) == SET
2902         && REG_P (SET_SRC (PATTERN (i3)))
2903         && MEM_P (SET_DEST (PATTERN (i3)))
2904         && (GET_CODE (XEXP (SET_DEST (PATTERN (i3)), 0)) == POST_INC
2905             || GET_CODE (XEXP (SET_DEST (PATTERN (i3)), 0)) == POST_DEC)))
2906     /* It's not the exception.  */
2907 #endif
2908 #ifdef AUTO_INC_DEC
2909     for (link = REG_NOTES (i3); link; link = XEXP (link, 1))
2910       if (REG_NOTE_KIND (link) == REG_INC
2911           && (reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i2))
2912               || (i1 != 0
2913                   && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i1)))))
2914         {
2915           undo_all ();
2916           return 0;
2917         }
2918 #endif
2919
2920   /* See if the SETs in I1 or I2 need to be kept around in the merged
2921      instruction: whenever the value set there is still needed past I3.
2922      For the SETs in I2, this is easy: we see if I2DEST dies or is set in I3.
2923
2924      For the SET in I1, we have two cases:  If I1 and I2 independently
2925      feed into I3, the set in I1 needs to be kept around if I1DEST dies
2926      or is set in I3.  Otherwise (if I1 feeds I2 which feeds I3), the set
2927      in I1 needs to be kept around unless I1DEST dies or is set in either
2928      I2 or I3.  The same consideration applies to I0.  */
2929
2930   added_sets_2 = !dead_or_set_p (i3, i2dest);
2931
2932   if (i1)
2933     added_sets_1 = !(dead_or_set_p (i3, i1dest)
2934                      || (i1_feeds_i2_n && dead_or_set_p (i2, i1dest)));
2935   else
2936     added_sets_1 = 0;
2937
2938   if (i0)
2939     added_sets_0 =  !(dead_or_set_p (i3, i0dest)
2940                       || (i0_feeds_i2_n && dead_or_set_p (i2, i0dest))
2941                       || (i0_feeds_i1_n && dead_or_set_p (i1, i0dest)));
2942   else
2943     added_sets_0 = 0;
2944
2945   /* We are about to copy insns for the case where they need to be kept
2946      around.  Check that they can be copied in the merged instruction.  */
2947
2948   if (targetm.cannot_copy_insn_p
2949       && ((added_sets_2 && targetm.cannot_copy_insn_p (i2))
2950           || (i1 && added_sets_1 && targetm.cannot_copy_insn_p (i1))
2951           || (i0 && added_sets_0 && targetm.cannot_copy_insn_p (i0))))
2952     {
2953       undo_all ();
2954       return 0;
2955     }
2956
2957   /* If the set in I2 needs to be kept around, we must make a copy of
2958      PATTERN (I2), so that when we substitute I1SRC for I1DEST in
2959      PATTERN (I2), we are only substituting for the original I1DEST, not into
2960      an already-substituted copy.  This also prevents making self-referential
2961      rtx.  If I2 is a PARALLEL, we just need the piece that assigns I2SRC to
2962      I2DEST.  */
2963
2964   if (added_sets_2)
2965     {
2966       if (GET_CODE (PATTERN (i2)) == PARALLEL)
2967         i2pat = gen_rtx_SET (VOIDmode, i2dest, copy_rtx (i2src));
2968       else
2969         i2pat = copy_rtx (PATTERN (i2));
2970     }
2971
2972   if (added_sets_1)
2973     {
2974       if (GET_CODE (PATTERN (i1)) == PARALLEL)
2975         i1pat = gen_rtx_SET (VOIDmode, i1dest, copy_rtx (i1src));
2976       else
2977         i1pat = copy_rtx (PATTERN (i1));
2978     }
2979
2980   if (added_sets_0)
2981     {
2982       if (GET_CODE (PATTERN (i0)) == PARALLEL)
2983         i0pat = gen_rtx_SET (VOIDmode, i0dest, copy_rtx (i0src));
2984       else
2985         i0pat = copy_rtx (PATTERN (i0));
2986     }
2987
2988   combine_merges++;
2989
2990   /* Substitute in the latest insn for the regs set by the earlier ones.  */
2991
2992   maxreg = max_reg_num ();
2993
2994   subst_insn = i3;
2995
2996 #ifndef HAVE_cc0
2997   /* Many machines that don't use CC0 have insns that can both perform an
2998      arithmetic operation and set the condition code.  These operations will
2999      be represented as a PARALLEL with the first element of the vector
3000      being a COMPARE of an arithmetic operation with the constant zero.
3001      The second element of the vector will set some pseudo to the result
3002      of the same arithmetic operation.  If we simplify the COMPARE, we won't
3003      match such a pattern and so will generate an extra insn.   Here we test
3004      for this case, where both the comparison and the operation result are
3005      needed, and make the PARALLEL by just replacing I2DEST in I3SRC with
3006      I2SRC.  Later we will make the PARALLEL that contains I2.  */
3007
3008   if (i1 == 0 && added_sets_2 && GET_CODE (PATTERN (i3)) == SET
3009       && GET_CODE (SET_SRC (PATTERN (i3))) == COMPARE
3010       && XEXP (SET_SRC (PATTERN (i3)), 1) == const0_rtx
3011       && rtx_equal_p (XEXP (SET_SRC (PATTERN (i3)), 0), i2dest))
3012     {
3013 #ifdef SELECT_CC_MODE
3014       rtx *cc_use;
3015       enum machine_mode compare_mode;
3016 #endif
3017
3018       newpat = PATTERN (i3);
3019       SUBST (XEXP (SET_SRC (newpat), 0), i2src);
3020
3021       i2_is_used = 1;
3022
3023 #ifdef SELECT_CC_MODE
3024       /* See if a COMPARE with the operand we substituted in should be done
3025          with the mode that is currently being used.  If not, do the same
3026          processing we do in `subst' for a SET; namely, if the destination
3027          is used only once, try to replace it with a register of the proper
3028          mode and also replace the COMPARE.  */
3029       if (undobuf.other_insn == 0
3030           && (cc_use = find_single_use (SET_DEST (newpat), i3,
3031                                         &undobuf.other_insn))
3032           && ((compare_mode = SELECT_CC_MODE (GET_CODE (*cc_use),
3033                                               i2src, const0_rtx))
3034               != GET_MODE (SET_DEST (newpat))))
3035         {
3036           if (can_change_dest_mode (SET_DEST (newpat), added_sets_2,
3037                                     compare_mode))
3038             {
3039               unsigned int regno = REGNO (SET_DEST (newpat));
3040               rtx new_dest;
3041
3042               if (regno < FIRST_PSEUDO_REGISTER)
3043                 new_dest = gen_rtx_REG (compare_mode, regno);
3044               else
3045                 {
3046                   SUBST_MODE (regno_reg_rtx[regno], compare_mode);
3047                   new_dest = regno_reg_rtx[regno];
3048                 }
3049
3050               SUBST (SET_DEST (newpat), new_dest);
3051               SUBST (XEXP (*cc_use, 0), new_dest);
3052               SUBST (SET_SRC (newpat),
3053                      gen_rtx_COMPARE (compare_mode, i2src, const0_rtx));
3054             }
3055           else
3056             undobuf.other_insn = 0;
3057         }
3058 #endif
3059     }
3060   else
3061 #endif
3062     {
3063       /* It is possible that the source of I2 or I1 may be performing
3064          an unneeded operation, such as a ZERO_EXTEND of something
3065          that is known to have the high part zero.  Handle that case
3066          by letting subst look at the innermost one of them.
3067
3068          Another way to do this would be to have a function that tries
3069          to simplify a single insn instead of merging two or more
3070          insns.  We don't do this because of the potential of infinite
3071          loops and because of the potential extra memory required.
3072          However, doing it the way we are is a bit of a kludge and
3073          doesn't catch all cases.
3074
3075          But only do this if -fexpensive-optimizations since it slows
3076          things down and doesn't usually win.
3077
3078          This is not done in the COMPARE case above because the
3079          unmodified I2PAT is used in the PARALLEL and so a pattern
3080          with a modified I2SRC would not match.  */
3081
3082       if (flag_expensive_optimizations)
3083         {
3084           /* Pass pc_rtx so no substitutions are done, just
3085              simplifications.  */
3086           if (i1)
3087             {
3088               subst_low_luid = DF_INSN_LUID (i1);
3089               i1src = subst (i1src, pc_rtx, pc_rtx, 0, 0);
3090             }
3091           else
3092             {
3093               subst_low_luid = DF_INSN_LUID (i2);
3094               i2src = subst (i2src, pc_rtx, pc_rtx, 0, 0);
3095             }
3096         }
3097
3098       n_occurrences = 0;                /* `subst' counts here */
3099       subst_low_luid = DF_INSN_LUID (i2);
3100
3101       /* If I1 feeds into I2 and I1DEST is in I1SRC, we need to make a unique
3102          copy of I2SRC each time we substitute it, in order to avoid creating
3103          self-referential RTL when we will be substituting I1SRC for I1DEST
3104          later.  Likewise if I0 feeds into I2, either directly or indirectly
3105          through I1, and I0DEST is in I0SRC.  */
3106       newpat = subst (PATTERN (i3), i2dest, i2src, 0,
3107                       (i1_feeds_i2_n && i1dest_in_i1src)
3108                       || ((i0_feeds_i2_n || (i0_feeds_i1_n && i1_feeds_i2_n))
3109                           && i0dest_in_i0src));
3110       substed_i2 = 1;
3111
3112       /* Record whether I2's body now appears within I3's body.  */
3113       i2_is_used = n_occurrences;
3114     }
3115
3116   /* If we already got a failure, don't try to do more.  Otherwise, try to
3117      substitute I1 if we have it.  */
3118
3119   if (i1 && GET_CODE (newpat) != CLOBBER)
3120     {
3121       /* Check that an autoincrement side-effect on I1 has not been lost.
3122          This happens if I1DEST is mentioned in I2 and dies there, and
3123          has disappeared from the new pattern.  */
3124       if ((FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
3125            && i1_feeds_i2_n
3126            && dead_or_set_p (i2, i1dest)
3127            && !reg_overlap_mentioned_p (i1dest, newpat))
3128            /* Before we can do this substitution, we must redo the test done
3129               above (see detailed comments there) that ensures I1DEST isn't
3130               mentioned in any SETs in NEWPAT that are field assignments.  */
3131           || !combinable_i3pat (NULL_RTX, &newpat, i1dest, NULL_RTX, NULL_RTX,
3132                                 0, 0, 0))
3133         {
3134           undo_all ();
3135           return 0;
3136         }
3137
3138       n_occurrences = 0;
3139       subst_low_luid = DF_INSN_LUID (i1);
3140
3141       /* If I0 feeds into I1 and I0DEST is in I0SRC, we need to make a unique
3142          copy of I1SRC each time we substitute it, in order to avoid creating
3143          self-referential RTL when we will be substituting I0SRC for I0DEST
3144          later.  */
3145       newpat = subst (newpat, i1dest, i1src, 0,
3146                       i0_feeds_i1_n && i0dest_in_i0src);
3147       substed_i1 = 1;
3148
3149       /* Record whether I1's body now appears within I3's body.  */
3150       i1_is_used = n_occurrences;
3151     }
3152
3153   /* Likewise for I0 if we have it.  */
3154
3155   if (i0 && GET_CODE (newpat) != CLOBBER)
3156     {
3157       if ((FIND_REG_INC_NOTE (i0, NULL_RTX) != 0
3158            && ((i0_feeds_i2_n && dead_or_set_p (i2, i0dest))
3159                || (i0_feeds_i1_n && dead_or_set_p (i1, i0dest)))
3160            && !reg_overlap_mentioned_p (i0dest, newpat))
3161           || !combinable_i3pat (NULL_RTX, &newpat, i0dest, NULL_RTX, NULL_RTX,
3162                                 0, 0, 0))
3163         {
3164           undo_all ();
3165           return 0;
3166         }
3167
3168       /* If the following substitution will modify I1SRC, make a copy of it
3169          for the case where it is substituted for I1DEST in I2PAT later.  */
3170       if (i0_feeds_i1_n && added_sets_2 && i1_feeds_i2_n)
3171         i1src_copy = copy_rtx (i1src);
3172
3173       n_occurrences = 0;
3174       subst_low_luid = DF_INSN_LUID (i0);
3175       newpat = subst (newpat, i0dest, i0src, 0, 0);
3176       substed_i0 = 1;
3177     }
3178
3179   /* Fail if an autoincrement side-effect has been duplicated.  Be careful
3180      to count all the ways that I2SRC and I1SRC can be used.  */
3181   if ((FIND_REG_INC_NOTE (i2, NULL_RTX) != 0
3182        && i2_is_used + added_sets_2 > 1)
3183       || (i1 != 0 && FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
3184           && (i1_is_used + added_sets_1 + (added_sets_2 && i1_feeds_i2_n)
3185               > 1))
3186       || (i0 != 0 && FIND_REG_INC_NOTE (i0, NULL_RTX) != 0
3187           && (n_occurrences + added_sets_0
3188               + (added_sets_1 && i0_feeds_i1_n)
3189               + (added_sets_2 && i0_feeds_i2_n)
3190               > 1))
3191       /* Fail if we tried to make a new register.  */
3192       || max_reg_num () != maxreg
3193       /* Fail if we couldn't do something and have a CLOBBER.  */
3194       || GET_CODE (newpat) == CLOBBER
3195       /* Fail if this new pattern is a MULT and we didn't have one before
3196          at the outer level.  */
3197       || (GET_CODE (newpat) == SET && GET_CODE (SET_SRC (newpat)) == MULT
3198           && ! have_mult))
3199     {
3200       undo_all ();
3201       return 0;
3202     }
3203
3204   /* If the actions of the earlier insns must be kept
3205      in addition to substituting them into the latest one,
3206      we must make a new PARALLEL for the latest insn
3207      to hold additional the SETs.  */
3208
3209   if (added_sets_0 || added_sets_1 || added_sets_2)
3210     {
3211       int extra_sets = added_sets_0 + added_sets_1 + added_sets_2;
3212       combine_extras++;
3213
3214       if (GET_CODE (newpat) == PARALLEL)
3215         {
3216           rtvec old = XVEC (newpat, 0);
3217           total_sets = XVECLEN (newpat, 0) + extra_sets;
3218           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
3219           memcpy (XVEC (newpat, 0)->elem, &old->elem[0],
3220                   sizeof (old->elem[0]) * old->num_elem);
3221         }
3222       else
3223         {
3224           rtx old = newpat;
3225           total_sets = 1 + extra_sets;
3226           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
3227           XVECEXP (newpat, 0, 0) = old;
3228         }
3229
3230       if (added_sets_0)
3231         XVECEXP (newpat, 0, --total_sets) = i0pat;
3232
3233       if (added_sets_1)
3234         {
3235           rtx t = i1pat;
3236           if (i0_feeds_i1_n)
3237             t = subst (t, i0dest, i0src, 0, 0);
3238
3239           XVECEXP (newpat, 0, --total_sets) = t;
3240         }
3241       if (added_sets_2)
3242         {
3243           rtx t = i2pat;
3244           if (i1_feeds_i2_n)
3245             t = subst (t, i1dest, i1src_copy ? i1src_copy : i1src, 0,
3246                        i0_feeds_i1_n && i0dest_in_i0src);
3247           if ((i0_feeds_i1_n && i1_feeds_i2_n) || i0_feeds_i2_n)
3248             t = subst (t, i0dest, i0src, 0, 0);
3249
3250           XVECEXP (newpat, 0, --total_sets) = t;
3251         }
3252     }
3253
3254  validate_replacement:
3255
3256   /* Note which hard regs this insn has as inputs.  */
3257   mark_used_regs_combine (newpat);
3258
3259   /* If recog_for_combine fails, it strips existing clobbers.  If we'll
3260      consider splitting this pattern, we might need these clobbers.  */
3261   if (i1 && GET_CODE (newpat) == PARALLEL
3262       && GET_CODE (XVECEXP (newpat, 0, XVECLEN (newpat, 0) - 1)) == CLOBBER)
3263     {
3264       int len = XVECLEN (newpat, 0);
3265
3266       newpat_vec_with_clobbers = rtvec_alloc (len);
3267       for (i = 0; i < len; i++)
3268         RTVEC_ELT (newpat_vec_with_clobbers, i) = XVECEXP (newpat, 0, i);
3269     }
3270
3271   /* Is the result of combination a valid instruction?  */
3272   insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3273
3274   /* If the result isn't valid, see if it is a PARALLEL of two SETs where
3275      the second SET's destination is a register that is unused and isn't
3276      marked as an instruction that might trap in an EH region.  In that case,
3277      we just need the first SET.   This can occur when simplifying a divmod
3278      insn.  We *must* test for this case here because the code below that
3279      splits two independent SETs doesn't handle this case correctly when it
3280      updates the register status.
3281
3282      It's pointless doing this if we originally had two sets, one from
3283      i3, and one from i2.  Combining then splitting the parallel results
3284      in the original i2 again plus an invalid insn (which we delete).
3285      The net effect is only to move instructions around, which makes
3286      debug info less accurate.
3287
3288      Also check the case where the first SET's destination is unused.
3289      That would not cause incorrect code, but does cause an unneeded
3290      insn to remain.  */
3291
3292   if (insn_code_number < 0
3293       && !(added_sets_2 && i1 == 0)
3294       && GET_CODE (newpat) == PARALLEL
3295       && XVECLEN (newpat, 0) == 2
3296       && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
3297       && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
3298       && asm_noperands (newpat) < 0)
3299     {
3300       rtx set0 = XVECEXP (newpat, 0, 0);
3301       rtx set1 = XVECEXP (newpat, 0, 1);
3302
3303       if (((REG_P (SET_DEST (set1))
3304             && find_reg_note (i3, REG_UNUSED, SET_DEST (set1)))
3305            || (GET_CODE (SET_DEST (set1)) == SUBREG
3306                && find_reg_note (i3, REG_UNUSED, SUBREG_REG (SET_DEST (set1)))))
3307           && insn_nothrow_p (i3)
3308           && !side_effects_p (SET_SRC (set1)))
3309         {
3310           newpat = set0;
3311           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3312         }
3313
3314       else if (((REG_P (SET_DEST (set0))
3315                  && find_reg_note (i3, REG_UNUSED, SET_DEST (set0)))
3316                 || (GET_CODE (SET_DEST (set0)) == SUBREG
3317                     && find_reg_note (i3, REG_UNUSED,
3318                                       SUBREG_REG (SET_DEST (set0)))))
3319                && insn_nothrow_p (i3)
3320                && !side_effects_p (SET_SRC (set0)))
3321         {
3322           newpat = set1;
3323           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3324
3325           if (insn_code_number >= 0)
3326             changed_i3_dest = 1;
3327         }
3328     }
3329
3330   /* If we were combining three insns and the result is a simple SET
3331      with no ASM_OPERANDS that wasn't recognized, try to split it into two
3332      insns.  There are two ways to do this.  It can be split using a
3333      machine-specific method (like when you have an addition of a large
3334      constant) or by combine in the function find_split_point.  */
3335
3336   if (i1 && insn_code_number < 0 && GET_CODE (newpat) == SET
3337       && asm_noperands (newpat) < 0)
3338     {
3339       rtx parallel, m_split, *split;
3340
3341       /* See if the MD file can split NEWPAT.  If it can't, see if letting it
3342          use I2DEST as a scratch register will help.  In the latter case,
3343          convert I2DEST to the mode of the source of NEWPAT if we can.  */
3344
3345       m_split = combine_split_insns (newpat, i3);
3346
3347       /* We can only use I2DEST as a scratch reg if it doesn't overlap any
3348          inputs of NEWPAT.  */
3349
3350       /* ??? If I2DEST is not safe, and I1DEST exists, then it would be
3351          possible to try that as a scratch reg.  This would require adding
3352          more code to make it work though.  */
3353
3354       if (m_split == 0 && ! reg_overlap_mentioned_p (i2dest, newpat))
3355         {
3356           enum machine_mode new_mode = GET_MODE (SET_DEST (newpat));
3357
3358           /* First try to split using the original register as a
3359              scratch register.  */
3360           parallel = gen_rtx_PARALLEL (VOIDmode,
3361                                        gen_rtvec (2, newpat,
3362                                                   gen_rtx_CLOBBER (VOIDmode,
3363                                                                    i2dest)));
3364           m_split = combine_split_insns (parallel, i3);
3365
3366           /* If that didn't work, try changing the mode of I2DEST if
3367              we can.  */
3368           if (m_split == 0
3369               && new_mode != GET_MODE (i2dest)
3370               && new_mode != VOIDmode
3371               && can_change_dest_mode (i2dest, added_sets_2, new_mode))
3372             {
3373               enum machine_mode old_mode = GET_MODE (i2dest);
3374               rtx ni2dest;
3375
3376               if (REGNO (i2dest) < FIRST_PSEUDO_REGISTER)
3377                 ni2dest = gen_rtx_REG (new_mode, REGNO (i2dest));
3378               else
3379                 {
3380                   SUBST_MODE (regno_reg_rtx[REGNO (i2dest)], new_mode);
3381                   ni2dest = regno_reg_rtx[REGNO (i2dest)];
3382                 }
3383
3384               parallel = (gen_rtx_PARALLEL
3385                           (VOIDmode,
3386                            gen_rtvec (2, newpat,
3387                                       gen_rtx_CLOBBER (VOIDmode,
3388                                                        ni2dest))));
3389               m_split = combine_split_insns (parallel, i3);
3390
3391               if (m_split == 0
3392                   && REGNO (i2dest) >= FIRST_PSEUDO_REGISTER)
3393                 {
3394                   struct undo *buf;
3395
3396                   adjust_reg_mode (regno_reg_rtx[REGNO (i2dest)], old_mode);
3397                   buf = undobuf.undos;
3398                   undobuf.undos = buf->next;
3399                   buf->next = undobuf.frees;
3400                   undobuf.frees = buf;
3401                 }
3402             }
3403
3404           i2scratch = m_split != 0;
3405         }
3406
3407       /* If recog_for_combine has discarded clobbers, try to use them
3408          again for the split.  */
3409       if (m_split == 0 && newpat_vec_with_clobbers)
3410         {
3411           parallel = gen_rtx_PARALLEL (VOIDmode, newpat_vec_with_clobbers);
3412           m_split = combine_split_insns (parallel, i3);
3413         }
3414
3415       if (m_split && NEXT_INSN (m_split) == NULL_RTX)
3416         {
3417           m_split = PATTERN (m_split);
3418           insn_code_number = recog_for_combine (&m_split, i3, &new_i3_notes);
3419           if (insn_code_number >= 0)
3420             newpat = m_split;
3421         }
3422       else if (m_split && NEXT_INSN (NEXT_INSN (m_split)) == NULL_RTX
3423                && (next_real_insn (i2) == i3
3424                    || ! use_crosses_set_p (PATTERN (m_split), DF_INSN_LUID (i2))))
3425         {
3426           rtx i2set, i3set;
3427           rtx newi3pat = PATTERN (NEXT_INSN (m_split));
3428           newi2pat = PATTERN (m_split);
3429
3430           i3set = single_set (NEXT_INSN (m_split));
3431           i2set = single_set (m_split);
3432
3433           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3434
3435           /* If I2 or I3 has multiple SETs, we won't know how to track
3436              register status, so don't use these insns.  If I2's destination
3437              is used between I2 and I3, we also can't use these insns.  */
3438
3439           if (i2_code_number >= 0 && i2set && i3set
3440               && (next_real_insn (i2) == i3
3441                   || ! reg_used_between_p (SET_DEST (i2set), i2, i3)))
3442             insn_code_number = recog_for_combine (&newi3pat, i3,
3443                                                   &new_i3_notes);
3444           if (insn_code_number >= 0)
3445             newpat = newi3pat;
3446
3447           /* It is possible that both insns now set the destination of I3.
3448              If so, we must show an extra use of it.  */
3449
3450           if (insn_code_number >= 0)
3451             {
3452               rtx new_i3_dest = SET_DEST (i3set);
3453               rtx new_i2_dest = SET_DEST (i2set);
3454
3455               while (GET_CODE (new_i3_dest) == ZERO_EXTRACT
3456                      || GET_CODE (new_i3_dest) == STRICT_LOW_PART
3457                      || GET_CODE (new_i3_dest) == SUBREG)
3458                 new_i3_dest = XEXP (new_i3_dest, 0);
3459
3460               while (GET_CODE (new_i2_dest) == ZERO_EXTRACT
3461                      || GET_CODE (new_i2_dest) == STRICT_LOW_PART
3462                      || GET_CODE (new_i2_dest) == SUBREG)
3463                 new_i2_dest = XEXP (new_i2_dest, 0);
3464
3465               if (REG_P (new_i3_dest)
3466                   && REG_P (new_i2_dest)
3467                   && REGNO (new_i3_dest) == REGNO (new_i2_dest))
3468                 INC_REG_N_SETS (REGNO (new_i2_dest), 1);
3469             }
3470         }
3471
3472       /* If we can split it and use I2DEST, go ahead and see if that
3473          helps things be recognized.  Verify that none of the registers
3474          are set between I2 and I3.  */
3475       if (insn_code_number < 0
3476           && (split = find_split_point (&newpat, i3, false)) != 0
3477 #ifdef HAVE_cc0
3478           && REG_P (i2dest)
3479 #endif
3480           /* We need I2DEST in the proper mode.  If it is a hard register
3481              or the only use of a pseudo, we can change its mode.
3482              Make sure we don't change a hard register to have a mode that
3483              isn't valid for it, or change the number of registers.  */
3484           && (GET_MODE (*split) == GET_MODE (i2dest)
3485               || GET_MODE (*split) == VOIDmode
3486               || can_change_dest_mode (i2dest, added_sets_2,
3487                                        GET_MODE (*split)))
3488           && (next_real_insn (i2) == i3
3489               || ! use_crosses_set_p (*split, DF_INSN_LUID (i2)))
3490           /* We can't overwrite I2DEST if its value is still used by
3491              NEWPAT.  */
3492           && ! reg_referenced_p (i2dest, newpat))
3493         {
3494           rtx newdest = i2dest;
3495           enum rtx_code split_code = GET_CODE (*split);
3496           enum machine_mode split_mode = GET_MODE (*split);
3497           bool subst_done = false;
3498           newi2pat = NULL_RTX;
3499
3500           i2scratch = true;
3501
3502           /* *SPLIT may be part of I2SRC, so make sure we have the
3503              original expression around for later debug processing.
3504              We should not need I2SRC any more in other cases.  */
3505           if (MAY_HAVE_DEBUG_INSNS)
3506             i2src = copy_rtx (i2src);
3507           else
3508             i2src = NULL;
3509
3510           /* Get NEWDEST as a register in the proper mode.  We have already
3511              validated that we can do this.  */
3512           if (GET_MODE (i2dest) != split_mode && split_mode != VOIDmode)
3513             {
3514               if (REGNO (i2dest) < FIRST_PSEUDO_REGISTER)
3515                 newdest = gen_rtx_REG (split_mode, REGNO (i2dest));
3516               else
3517                 {
3518                   SUBST_MODE (regno_reg_rtx[REGNO (i2dest)], split_mode);
3519                   newdest = regno_reg_rtx[REGNO (i2dest)];
3520                 }
3521             }
3522
3523           /* If *SPLIT is a (mult FOO (const_int pow2)), convert it to
3524              an ASHIFT.  This can occur if it was inside a PLUS and hence
3525              appeared to be a memory address.  This is a kludge.  */
3526           if (split_code == MULT
3527               && CONST_INT_P (XEXP (*split, 1))
3528               && INTVAL (XEXP (*split, 1)) > 0
3529               && (i = exact_log2 (UINTVAL (XEXP (*split, 1)))) >= 0)
3530             {
3531               SUBST (*split, gen_rtx_ASHIFT (split_mode,
3532                                              XEXP (*split, 0), GEN_INT (i)));
3533               /* Update split_code because we may not have a multiply
3534                  anymore.  */
3535               split_code = GET_CODE (*split);
3536             }
3537
3538 #ifdef INSN_SCHEDULING
3539           /* If *SPLIT is a paradoxical SUBREG, when we split it, it should
3540              be written as a ZERO_EXTEND.  */
3541           if (split_code == SUBREG && MEM_P (SUBREG_REG (*split)))
3542             {
3543 #ifdef LOAD_EXTEND_OP
3544               /* Or as a SIGN_EXTEND if LOAD_EXTEND_OP says that that's
3545                  what it really is.  */
3546               if (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (*split)))
3547                   == SIGN_EXTEND)
3548                 SUBST (*split, gen_rtx_SIGN_EXTEND (split_mode,
3549                                                     SUBREG_REG (*split)));
3550               else
3551 #endif
3552                 SUBST (*split, gen_rtx_ZERO_EXTEND (split_mode,
3553                                                     SUBREG_REG (*split)));
3554             }
3555 #endif
3556
3557           /* Attempt to split binary operators using arithmetic identities.  */
3558           if (BINARY_P (SET_SRC (newpat))
3559               && split_mode == GET_MODE (SET_SRC (newpat))
3560               && ! side_effects_p (SET_SRC (newpat)))
3561             {
3562               rtx setsrc = SET_SRC (newpat);
3563               enum machine_mode mode = GET_MODE (setsrc);
3564               enum rtx_code code = GET_CODE (setsrc);
3565               rtx src_op0 = XEXP (setsrc, 0);
3566               rtx src_op1 = XEXP (setsrc, 1);
3567
3568               /* Split "X = Y op Y" as "Z = Y; X = Z op Z".  */
3569               if (rtx_equal_p (src_op0, src_op1))
3570                 {
3571                   newi2pat = gen_rtx_SET (VOIDmode, newdest, src_op0);
3572                   SUBST (XEXP (setsrc, 0), newdest);
3573                   SUBST (XEXP (setsrc, 1), newdest);
3574                   subst_done = true;
3575                 }
3576               /* Split "((P op Q) op R) op S" where op is PLUS or MULT.  */
3577               else if ((code == PLUS || code == MULT)
3578                        && GET_CODE (src_op0) == code
3579                        && GET_CODE (XEXP (src_op0, 0)) == code
3580                        && (INTEGRAL_MODE_P (mode)
3581                            || (FLOAT_MODE_P (mode)
3582                                && flag_unsafe_math_optimizations)))
3583                 {
3584                   rtx p = XEXP (XEXP (src_op0, 0), 0);
3585                   rtx q = XEXP (XEXP (src_op0, 0), 1);
3586                   rtx r = XEXP (src_op0, 1);
3587                   rtx s = src_op1;
3588
3589                   /* Split both "((X op Y) op X) op Y" and
3590                      "((X op Y) op Y) op X" as "T op T" where T is
3591                      "X op Y".  */
3592                   if ((rtx_equal_p (p,r) && rtx_equal_p (q,s))
3593                        || (rtx_equal_p (p,s) && rtx_equal_p (q,r)))
3594                     {
3595                       newi2pat = gen_rtx_SET (VOIDmode, newdest,
3596                                               XEXP (src_op0, 0));
3597                       SUBST (XEXP (setsrc, 0), newdest);
3598                       SUBST (XEXP (setsrc, 1), newdest);
3599                       subst_done = true;
3600                     }
3601                   /* Split "((X op X) op Y) op Y)" as "T op T" where
3602                      T is "X op Y".  */
3603                   else if (rtx_equal_p (p,q) && rtx_equal_p (r,s))
3604                     {
3605                       rtx tmp = simplify_gen_binary (code, mode, p, r);
3606                       newi2pat = gen_rtx_SET (VOIDmode, newdest, tmp);
3607                       SUBST (XEXP (setsrc, 0), newdest);
3608                       SUBST (XEXP (setsrc, 1), newdest);
3609                       subst_done = true;
3610                     }
3611                 }
3612             }
3613
3614           if (!subst_done)
3615             {
3616               newi2pat = gen_rtx_SET (VOIDmode, newdest, *split);
3617               SUBST (*split, newdest);
3618             }
3619
3620           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3621
3622           /* recog_for_combine might have added CLOBBERs to newi2pat.
3623              Make sure NEWPAT does not depend on the clobbered regs.  */
3624           if (GET_CODE (newi2pat) == PARALLEL)
3625             for (i = XVECLEN (newi2pat, 0) - 1; i >= 0; i--)
3626               if (GET_CODE (XVECEXP (newi2pat, 0, i)) == CLOBBER)
3627                 {
3628                   rtx reg = XEXP (XVECEXP (newi2pat, 0, i), 0);
3629                   if (reg_overlap_mentioned_p (reg, newpat))
3630                     {
3631                       undo_all ();
3632                       return 0;
3633                     }
3634                 }
3635
3636           /* If the split point was a MULT and we didn't have one before,
3637              don't use one now.  */
3638           if (i2_code_number >= 0 && ! (split_code == MULT && ! have_mult))
3639             insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3640         }
3641     }
3642
3643   /* Check for a case where we loaded from memory in a narrow mode and
3644      then sign extended it, but we need both registers.  In that case,
3645      we have a PARALLEL with both loads from the same memory location.
3646      We can split this into a load from memory followed by a register-register
3647      copy.  This saves at least one insn, more if register allocation can
3648      eliminate the copy.
3649
3650      We cannot do this if the destination of the first assignment is a
3651      condition code register or cc0.  We eliminate this case by making sure
3652      the SET_DEST and SET_SRC have the same mode.
3653
3654      We cannot do this if the destination of the second assignment is
3655      a register that we have already assumed is zero-extended.  Similarly
3656      for a SUBREG of such a register.  */
3657
3658   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
3659            && GET_CODE (newpat) == PARALLEL
3660            && XVECLEN (newpat, 0) == 2
3661            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
3662            && GET_CODE (SET_SRC (XVECEXP (newpat, 0, 0))) == SIGN_EXTEND
3663            && (GET_MODE (SET_DEST (XVECEXP (newpat, 0, 0)))
3664                == GET_MODE (SET_SRC (XVECEXP (newpat, 0, 0))))
3665            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
3666            && rtx_equal_p (SET_SRC (XVECEXP (newpat, 0, 1)),
3667                            XEXP (SET_SRC (XVECEXP (newpat, 0, 0)), 0))
3668            && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
3669                                    DF_INSN_LUID (i2))
3670            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
3671            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
3672            && ! (temp = SET_DEST (XVECEXP (newpat, 0, 1)),
3673                  (REG_P (temp)
3674                   && VEC_index (reg_stat_type, reg_stat,
3675                                 REGNO (temp))->nonzero_bits != 0
3676                   && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
3677                   && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
3678                   && (VEC_index (reg_stat_type, reg_stat,
3679                                  REGNO (temp))->nonzero_bits
3680                       != GET_MODE_MASK (word_mode))))
3681            && ! (GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) == SUBREG
3682                  && (temp = SUBREG_REG (SET_DEST (XVECEXP (newpat, 0, 1))),
3683                      (REG_P (temp)
3684                       && VEC_index (reg_stat_type, reg_stat,
3685                                     REGNO (temp))->nonzero_bits != 0
3686                       && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
3687                       && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
3688                       && (VEC_index (reg_stat_type, reg_stat,
3689                                      REGNO (temp))->nonzero_bits
3690                           != GET_MODE_MASK (word_mode)))))
3691            && ! reg_overlap_mentioned_p (SET_DEST (XVECEXP (newpat, 0, 1)),
3692                                          SET_SRC (XVECEXP (newpat, 0, 1)))
3693            && ! find_reg_note (i3, REG_UNUSED,
3694                                SET_DEST (XVECEXP (newpat, 0, 0))))
3695     {
3696       rtx ni2dest;
3697
3698       newi2pat = XVECEXP (newpat, 0, 0);
3699       ni2dest = SET_DEST (XVECEXP (newpat, 0, 0));
3700       newpat = XVECEXP (newpat, 0, 1);
3701       SUBST (SET_SRC (newpat),
3702              gen_lowpart (GET_MODE (SET_SRC (newpat)), ni2dest));
3703       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3704
3705       if (i2_code_number >= 0)
3706         insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3707
3708       if (insn_code_number >= 0)
3709         swap_i2i3 = 1;
3710     }
3711
3712   /* Similarly, check for a case where we have a PARALLEL of two independent
3713      SETs but we started with three insns.  In this case, we can do the sets
3714      as two separate insns.  This case occurs when some SET allows two
3715      other insns to combine, but the destination of that SET is still live.  */
3716
3717   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
3718            && GET_CODE (newpat) == PARALLEL
3719            && XVECLEN (newpat, 0) == 2
3720            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
3721            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != ZERO_EXTRACT
3722            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != STRICT_LOW_PART
3723            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
3724            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
3725            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
3726            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 1)),
3727                                   XVECEXP (newpat, 0, 0))
3728            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 0)),
3729                                   XVECEXP (newpat, 0, 1))
3730            && ! (contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 0)))
3731                  && contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 1)))))
3732     {
3733       /* Normally, it doesn't matter which of the two is done first,
3734          but the one that references cc0 can't be the second, and
3735          one which uses any regs/memory set in between i2 and i3 can't
3736          be first.  */
3737       if (!use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
3738                               DF_INSN_LUID (i2))
3739 #ifdef HAVE_cc0
3740           && !reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 0))
3741 #endif
3742          )
3743         {
3744           newi2pat = XVECEXP (newpat, 0, 1);
3745           newpat = XVECEXP (newpat, 0, 0);
3746         }
3747       else if (!use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 0)),
3748                                    DF_INSN_LUID (i2))
3749 #ifdef HAVE_cc0
3750                && !reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 1))
3751 #endif
3752               )
3753         {
3754           newi2pat = XVECEXP (newpat, 0, 0);
3755           newpat = XVECEXP (newpat, 0, 1);
3756         }
3757       else
3758         {
3759           undo_all ();
3760           return 0;
3761         }
3762
3763       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3764
3765       if (i2_code_number >= 0)
3766         {
3767           /* recog_for_combine might have added CLOBBERs to newi2pat.
3768              Make sure NEWPAT does not depend on the clobbered regs.  */
3769           if (GET_CODE (newi2pat) == PARALLEL)
3770             {
3771               for (i = XVECLEN (newi2pat, 0) - 1; i >= 0; i--)
3772                 if (GET_CODE (XVECEXP (newi2pat, 0, i)) == CLOBBER)
3773                   {
3774                     rtx reg = XEXP (XVECEXP (newi2pat, 0, i), 0);
3775                     if (reg_overlap_mentioned_p (reg, newpat))
3776                       {
3777                         undo_all ();
3778                         return 0;
3779                       }
3780                   }
3781             }
3782
3783           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3784         }
3785     }
3786
3787   /* If it still isn't recognized, fail and change things back the way they
3788      were.  */
3789   if ((insn_code_number < 0
3790        /* Is the result a reasonable ASM_OPERANDS?  */
3791        && (! check_asm_operands (newpat) || added_sets_1 || added_sets_2)))
3792     {
3793       undo_all ();
3794       return 0;
3795     }
3796
3797   /* If we had to change another insn, make sure it is valid also.  */
3798   if (undobuf.other_insn)
3799     {
3800       CLEAR_HARD_REG_SET (newpat_used_regs);
3801
3802       other_pat = PATTERN (undobuf.other_insn);
3803       other_code_number = recog_for_combine (&other_pat, undobuf.other_insn,
3804                                              &new_other_notes);
3805
3806       if (other_code_number < 0 && ! check_asm_operands (other_pat))
3807         {
3808           undo_all ();
3809           return 0;
3810         }
3811     }
3812
3813 #ifdef HAVE_cc0
3814   /* If I2 is the CC0 setter and I3 is the CC0 user then check whether
3815      they are adjacent to each other or not.  */
3816   {
3817     rtx p = prev_nonnote_insn (i3);
3818     if (p && p != i2 && NONJUMP_INSN_P (p) && newi2pat
3819         && sets_cc0_p (newi2pat))
3820       {
3821         undo_all ();
3822         return 0;
3823       }
3824   }
3825 #endif
3826
3827   /* Only allow this combination if insn_rtx_costs reports that the
3828      replacement instructions are cheaper than the originals.  */
3829   if (!combine_validate_cost (i0, i1, i2, i3, newpat, newi2pat, other_pat))
3830     {
3831       undo_all ();
3832       return 0;
3833     }
3834
3835   if (MAY_HAVE_DEBUG_INSNS)
3836     {
3837       struct undo *undo;
3838
3839       for (undo = undobuf.undos; undo; undo = undo->next)
3840         if (undo->kind == UNDO_MODE)
3841           {
3842             rtx reg = *undo->where.r;
3843             enum machine_mode new_mode = GET_MODE (reg);
3844             enum machine_mode old_mode = undo->old_contents.m;
3845
3846             /* Temporarily revert mode back.  */
3847             adjust_reg_mode (reg, old_mode);
3848
3849             if (reg == i2dest && i2scratch)
3850               {
3851                 /* If we used i2dest as a scratch register with a
3852                    different mode, substitute it for the original
3853                    i2src while its original mode is temporarily
3854                    restored, and then clear i2scratch so that we don't
3855                    do it again later.  */
3856                 propagate_for_debug (i2, i3, reg, i2src);
3857                 i2scratch = false;
3858                 /* Put back the new mode.  */
3859                 adjust_reg_mode (reg, new_mode);
3860               }
3861             else
3862               {
3863                 rtx tempreg = gen_raw_REG (old_mode, REGNO (reg));
3864                 rtx first, last;
3865
3866                 if (reg == i2dest)
3867                   {
3868                     first = i2;
3869                     last = i3;
3870                   }
3871                 else
3872                   {
3873                     first = i3;
3874                     last = undobuf.other_insn;
3875                     gcc_assert (last);
3876                   }
3877
3878                 /* We're dealing with a reg that changed mode but not
3879                    meaning, so we want to turn it into a subreg for
3880                    the new mode.  However, because of REG sharing and
3881                    because its mode had already changed, we have to do
3882                    it in two steps.  First, replace any debug uses of
3883                    reg, with its original mode temporarily restored,
3884                    with this copy we have created; then, replace the
3885                    copy with the SUBREG of the original shared reg,
3886                    once again changed to the new mode.  */
3887                 propagate_for_debug (first, last, reg, tempreg);
3888                 adjust_reg_mode (reg, new_mode);
3889                 propagate_for_debug (first, last, tempreg,
3890                                      lowpart_subreg (old_mode, reg, new_mode));
3891               }
3892           }
3893     }
3894
3895   /* If we will be able to accept this, we have made a
3896      change to the destination of I3.  This requires us to
3897      do a few adjustments.  */
3898
3899   if (changed_i3_dest)
3900     {
3901       PATTERN (i3) = newpat;
3902       adjust_for_new_dest (i3);
3903     }
3904
3905   /* We now know that we can do this combination.  Merge the insns and
3906      update the status of registers and LOG_LINKS.  */
3907
3908   if (undobuf.other_insn)
3909     {
3910       rtx note, next;
3911
3912       PATTERN (undobuf.other_insn) = other_pat;
3913
3914       /* If any of the notes in OTHER_INSN were REG_UNUSED, ensure that they
3915          are still valid.  Then add any non-duplicate notes added by
3916          recog_for_combine.  */
3917       for (note = REG_NOTES (undobuf.other_insn); note; note = next)
3918         {
3919           next = XEXP (note, 1);
3920
3921           if (REG_NOTE_KIND (note) == REG_UNUSED
3922               && ! reg_set_p (XEXP (note, 0), PATTERN (undobuf.other_insn)))
3923             remove_note (undobuf.other_insn, note);
3924         }
3925
3926       distribute_notes (new_other_notes, undobuf.other_insn,
3927                         undobuf.other_insn, NULL_RTX, NULL_RTX, NULL_RTX,
3928                         NULL_RTX);
3929     }
3930
3931   if (swap_i2i3)
3932     {
3933       rtx insn;
3934       rtx link;
3935       rtx ni2dest;
3936
3937       /* I3 now uses what used to be its destination and which is now
3938          I2's destination.  This requires us to do a few adjustments.  */
3939       PATTERN (i3) = newpat;
3940       adjust_for_new_dest (i3);
3941
3942       /* We need a LOG_LINK from I3 to I2.  But we used to have one,
3943          so we still will.
3944
3945          However, some later insn might be using I2's dest and have
3946          a LOG_LINK pointing at I3.  We must remove this link.
3947          The simplest way to remove the link is to point it at I1,
3948          which we know will be a NOTE.  */
3949
3950       /* newi2pat is usually a SET here; however, recog_for_combine might
3951          have added some clobbers.  */
3952       if (GET_CODE (newi2pat) == PARALLEL)
3953         ni2dest = SET_DEST (XVECEXP (newi2pat, 0, 0));
3954       else
3955         ni2dest = SET_DEST (newi2pat);
3956
3957       for (insn = NEXT_INSN (i3);
3958            insn && (this_basic_block->next_bb == EXIT_BLOCK_PTR
3959                     || insn != BB_HEAD (this_basic_block->next_bb));
3960            insn = NEXT_INSN (insn))
3961         {
3962           if (INSN_P (insn) && reg_referenced_p (ni2dest, PATTERN (insn)))
3963             {
3964               for (link = LOG_LINKS (insn); link;
3965                    link = XEXP (link, 1))
3966                 if (XEXP (link, 0) == i3)
3967                   XEXP (link, 0) = i1;
3968
3969               break;
3970             }
3971         }
3972     }
3973
3974   {
3975     rtx i3notes, i2notes, i1notes = 0, i0notes = 0;
3976     rtx i3links, i2links, i1links = 0, i0links = 0;
3977     rtx midnotes = 0;
3978     int from_luid;
3979     unsigned int regno;
3980     /* Compute which registers we expect to eliminate.  newi2pat may be setting
3981        either i3dest or i2dest, so we must check it.  Also, i1dest may be the
3982        same as i3dest, in which case newi2pat may be setting i1dest.  */
3983     rtx elim_i2 = ((newi2pat && reg_set_p (i2dest, newi2pat))
3984                    || i2dest_in_i2src || i2dest_in_i1src || i2dest_in_i0src
3985                    || !i2dest_killed
3986                    ? 0 : i2dest);
3987     rtx elim_i1 = (i1 == 0 || i1dest_in_i1src || i1dest_in_i0src
3988                    || (newi2pat && reg_set_p (i1dest, newi2pat))
3989                    || !i1dest_killed
3990                    ? 0 : i1dest);
3991     rtx elim_i0 = (i0 == 0 || i0dest_in_i0src
3992                    || (newi2pat && reg_set_p (i0dest, newi2pat))
3993                    || !i0dest_killed
3994                    ? 0 : i0dest);
3995
3996     /* Get the old REG_NOTES and LOG_LINKS from all our insns and
3997        clear them.  */
3998     i3notes = REG_NOTES (i3), i3links = LOG_LINKS (i3);
3999     i2notes = REG_NOTES (i2), i2links = LOG_LINKS (i2);
4000     if (i1)
4001       i1notes = REG_NOTES (i1), i1links = LOG_LINKS (i1);
4002     if (i0)
4003       i0notes = REG_NOTES (i0), i0links = LOG_LINKS (i0);
4004
4005     /* Ensure that we do not have something that should not be shared but
4006        occurs multiple times in the new insns.  Check this by first
4007        resetting all the `used' flags and then copying anything is shared.  */
4008
4009     reset_used_flags (i3notes);
4010     reset_used_flags (i2notes);
4011     reset_used_flags (i1notes);
4012     reset_used_flags (i0notes);
4013     reset_used_flags (newpat);
4014     reset_used_flags (newi2pat);
4015     if (undobuf.other_insn)
4016       reset_used_flags (PATTERN (undobuf.other_insn));
4017
4018     i3notes = copy_rtx_if_shared (i3notes);
4019     i2notes = copy_rtx_if_shared (i2notes);
4020     i1notes = copy_rtx_if_shared (i1notes);
4021     i0notes = copy_rtx_if_shared (i0notes);
4022     newpat = copy_rtx_if_shared (newpat);
4023     newi2pat = copy_rtx_if_shared (newi2pat);
4024     if (undobuf.other_insn)
4025       reset_used_flags (PATTERN (undobuf.other_insn));
4026
4027     INSN_CODE (i3) = insn_code_number;
4028     PATTERN (i3) = newpat;
4029
4030     if (CALL_P (i3) && CALL_INSN_FUNCTION_USAGE (i3))
4031       {
4032         rtx call_usage = CALL_INSN_FUNCTION_USAGE (i3);
4033
4034         reset_used_flags (call_usage);
4035         call_usage = copy_rtx (call_usage);
4036
4037         if (substed_i2)
4038           {
4039             /* I2SRC must still be meaningful at this point.  Some splitting
4040                operations can invalidate I2SRC, but those operations do not
4041                apply to calls.  */
4042             gcc_assert (i2src);
4043             replace_rtx (call_usage, i2dest, i2src);
4044           }
4045
4046         if (substed_i1)
4047           replace_rtx (call_usage, i1dest, i1src);
4048         if (substed_i0)
4049           replace_rtx (call_usage, i0dest, i0src);
4050
4051         CALL_INSN_FUNCTION_USAGE (i3) = call_usage;
4052       }
4053
4054     if (undobuf.other_insn)
4055       INSN_CODE (undobuf.other_insn) = other_code_number;
4056
4057     /* We had one special case above where I2 had more than one set and
4058        we replaced a destination of one of those sets with the destination
4059        of I3.  In that case, we have to update LOG_LINKS of insns later
4060        in this basic block.  Note that this (expensive) case is rare.
4061
4062        Also, in this case, we must pretend that all REG_NOTEs for I2
4063        actually came from I3, so that REG_UNUSED notes from I2 will be
4064        properly handled.  */
4065
4066     if (i3_subst_into_i2)
4067       {
4068         for (i = 0; i < XVECLEN (PATTERN (i2), 0); i++)
4069           if ((GET_CODE (XVECEXP (PATTERN (i2), 0, i)) == SET
4070                || GET_CODE (XVECEXP (PATTERN (i2), 0, i)) == CLOBBER)
4071               && REG_P (SET_DEST (XVECEXP (PATTERN (i2), 0, i)))
4072               && SET_DEST (XVECEXP (PATTERN (i2), 0, i)) != i2dest
4073               && ! find_reg_note (i2, REG_UNUSED,
4074                                   SET_DEST (XVECEXP (PATTERN (i2), 0, i))))
4075             for (temp = NEXT_INSN (i2);
4076                  temp && (this_basic_block->next_bb == EXIT_BLOCK_PTR
4077                           || BB_HEAD (this_basic_block) != temp);
4078                  temp = NEXT_INSN (temp))
4079               if (temp != i3 && INSN_P (temp))
4080                 for (link = LOG_LINKS (temp); link; link = XEXP (link, 1))
4081                   if (XEXP (link, 0) == i2)
4082                     XEXP (link, 0) = i3;
4083
4084         if (i3notes)
4085           {
4086             rtx link = i3notes;
4087             while (XEXP (link, 1))
4088               link = XEXP (link, 1);
4089             XEXP (link, 1) = i2notes;
4090           }
4091         else
4092           i3notes = i2notes;
4093         i2notes = 0;
4094       }
4095
4096     LOG_LINKS (i3) = 0;
4097     REG_NOTES (i3) = 0;
4098     LOG_LINKS (i2) = 0;
4099     REG_NOTES (i2) = 0;
4100
4101     if (newi2pat)
4102       {
4103         if (MAY_HAVE_DEBUG_INSNS && i2scratch)
4104           propagate_for_debug (i2, i3, i2dest, i2src);
4105         INSN_CODE (i2) = i2_code_number;
4106         PATTERN (i2) = newi2pat;
4107       }
4108     else
4109       {
4110         if (MAY_HAVE_DEBUG_INSNS && i2src)
4111           propagate_for_debug (i2, i3, i2dest, i2src);
4112         SET_INSN_DELETED (i2);
4113       }
4114
4115     if (i1)
4116       {
4117         LOG_LINKS (i1) = 0;
4118         REG_NOTES (i1) = 0;
4119         if (MAY_HAVE_DEBUG_INSNS)
4120           propagate_for_debug (i1, i3, i1dest, i1src);
4121         SET_INSN_DELETED (i1);
4122       }
4123
4124     if (i0)
4125       {
4126         LOG_LINKS (i0) = 0;
4127         REG_NOTES (i0) = 0;
4128         if (MAY_HAVE_DEBUG_INSNS)
4129           propagate_for_debug (i0, i3, i0dest, i0src);
4130         SET_INSN_DELETED (i0);
4131       }
4132
4133     /* Get death notes for everything that is now used in either I3 or
4134        I2 and used to die in a previous insn.  If we built two new
4135        patterns, move from I1 to I2 then I2 to I3 so that we get the
4136        proper movement on registers that I2 modifies.  */
4137
4138     if (i0)
4139       from_luid = DF_INSN_LUID (i0);
4140     else if (i1)
4141       from_luid = DF_INSN_LUID (i1);
4142     else
4143       from_luid = DF_INSN_LUID (i2);
4144     if (newi2pat)
4145       move_deaths (newi2pat, NULL_RTX, from_luid, i2, &midnotes);
4146     move_deaths (newpat, newi2pat, from_luid, i3, &midnotes);
4147
4148     /* Distribute all the LOG_LINKS and REG_NOTES from I1, I2, and I3.  */
4149     if (i3notes)
4150       distribute_notes (i3notes, i3, i3, newi2pat ? i2 : NULL_RTX,
4151                         elim_i2, elim_i1, elim_i0);
4152     if (i2notes)
4153       distribute_notes (i2notes, i2, i3, newi2pat ? i2 : NULL_RTX,
4154                         elim_i2, elim_i1, elim_i0);
4155     if (i1notes)
4156       distribute_notes (i1notes, i1, i3, newi2pat ? i2 : NULL_RTX,
4157                         elim_i2, elim_i1, elim_i0);
4158     if (i0notes)
4159       distribute_notes (i0notes, i0, i3, newi2pat ? i2 : NULL_RTX,
4160                         elim_i2, elim_i1, elim_i0);
4161     if (midnotes)
4162       distribute_notes (midnotes, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4163                         elim_i2, elim_i1, elim_i0);
4164
4165     /* Distribute any notes added to I2 or I3 by recog_for_combine.  We
4166        know these are REG_UNUSED and want them to go to the desired insn,
4167        so we always pass it as i3.  */
4168
4169     if (newi2pat && new_i2_notes)
4170       distribute_notes (new_i2_notes, i2, i2, NULL_RTX, NULL_RTX, NULL_RTX,
4171                         NULL_RTX);
4172
4173     if (new_i3_notes)
4174       distribute_notes (new_i3_notes, i3, i3, NULL_RTX, NULL_RTX, NULL_RTX,
4175                         NULL_RTX);
4176
4177     /* If I3DEST was used in I3SRC, it really died in I3.  We may need to
4178        put a REG_DEAD note for it somewhere.  If NEWI2PAT exists and sets
4179        I3DEST, the death must be somewhere before I2, not I3.  If we passed I3
4180        in that case, it might delete I2.  Similarly for I2 and I1.
4181        Show an additional death due to the REG_DEAD note we make here.  If
4182        we discard it in distribute_notes, we will decrement it again.  */
4183
4184     if (i3dest_killed)
4185       {
4186         if (newi2pat && reg_set_p (i3dest_killed, newi2pat))
4187           distribute_notes (alloc_reg_note (REG_DEAD, i3dest_killed,
4188                                             NULL_RTX),
4189                             NULL_RTX, i2, NULL_RTX, elim_i2, elim_i1, elim_i0);
4190         else
4191           distribute_notes (alloc_reg_note (REG_DEAD, i3dest_killed,
4192                                             NULL_RTX),
4193                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4194                             elim_i2, elim_i1, elim_i0);
4195       }
4196
4197     if (i2dest_in_i2src)
4198       {
4199         rtx new_note = alloc_reg_note (REG_DEAD, i2dest, NULL_RTX);
4200         if (newi2pat && reg_set_p (i2dest, newi2pat))
4201           distribute_notes (new_note,  NULL_RTX, i2, NULL_RTX, NULL_RTX,
4202                             NULL_RTX, NULL_RTX);
4203         else
4204           distribute_notes (new_note, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4205                             NULL_RTX, NULL_RTX, NULL_RTX);
4206       }
4207
4208     if (i1dest_in_i1src)
4209       {
4210         rtx new_note = alloc_reg_note (REG_DEAD, i1dest, NULL_RTX);
4211         if (newi2pat && reg_set_p (i1dest, newi2pat))
4212           distribute_notes (new_note, NULL_RTX, i2, NULL_RTX, NULL_RTX,
4213                             NULL_RTX, NULL_RTX);
4214         else
4215           distribute_notes (new_note, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4216                             NULL_RTX, NULL_RTX, NULL_RTX);
4217       }
4218
4219     if (i0dest_in_i0src)
4220       {
4221         rtx new_note = alloc_reg_note (REG_DEAD, i0dest, NULL_RTX);
4222         if (newi2pat && reg_set_p (i0dest, newi2pat))
4223           distribute_notes (new_note, NULL_RTX, i2, NULL_RTX, NULL_RTX,
4224                             NULL_RTX, NULL_RTX);
4225         else
4226           distribute_notes (new_note, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4227                             NULL_RTX, NULL_RTX, NULL_RTX);
4228       }
4229
4230     distribute_links (i3links);
4231     distribute_links (i2links);
4232     distribute_links (i1links);
4233     distribute_links (i0links);
4234
4235     if (REG_P (i2dest))
4236       {
4237         rtx link;
4238         rtx i2_insn = 0, i2_val = 0, set;
4239
4240         /* The insn that used to set this register doesn't exist, and
4241            this life of the register may not exist either.  See if one of
4242            I3's links points to an insn that sets I2DEST.  If it does,
4243            that is now the last known value for I2DEST. If we don't update
4244            this and I2 set the register to a value that depended on its old
4245            contents, we will get confused.  If this insn is used, thing
4246            will be set correctly in combine_instructions.  */
4247
4248         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
4249           if ((set = single_set (XEXP (link, 0))) != 0
4250               && rtx_equal_p (i2dest, SET_DEST (set)))
4251             i2_insn = XEXP (link, 0), i2_val = SET_SRC (set);
4252
4253         record_value_for_reg (i2dest, i2_insn, i2_val);
4254
4255         /* If the reg formerly set in I2 died only once and that was in I3,
4256            zero its use count so it won't make `reload' do any work.  */
4257         if (! added_sets_2
4258             && (newi2pat == 0 || ! reg_mentioned_p (i2dest, newi2pat))
4259             && ! i2dest_in_i2src)
4260           {
4261             regno = REGNO (i2dest);
4262             INC_REG_N_SETS (regno, -1);
4263           }
4264       }
4265
4266     if (i1 && REG_P (i1dest))
4267       {
4268         rtx link;
4269         rtx i1_insn = 0, i1_val = 0, set;
4270
4271         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
4272           if ((set = single_set (XEXP (link, 0))) != 0
4273               && rtx_equal_p (i1dest, SET_DEST (set)))
4274             i1_insn = XEXP (link, 0), i1_val = SET_SRC (set);
4275
4276         record_value_for_reg (i1dest, i1_insn, i1_val);
4277
4278         regno = REGNO (i1dest);
4279         if (! added_sets_1 && ! i1dest_in_i1src)
4280           INC_REG_N_SETS (regno, -1);
4281       }
4282
4283     if (i0 && REG_P (i0dest))
4284       {
4285         rtx link;
4286         rtx i0_insn = 0, i0_val = 0, set;
4287
4288         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
4289           if ((set = single_set (XEXP (link, 0))) != 0
4290               && rtx_equal_p (i0dest, SET_DEST (set)))
4291             i0_insn = XEXP (link, 0), i0_val = SET_SRC (set);
4292
4293         record_value_for_reg (i0dest, i0_insn, i0_val);
4294
4295         regno = REGNO (i0dest);
4296         if (! added_sets_0 && ! i0dest_in_i0src)
4297           INC_REG_N_SETS (regno, -1);
4298       }
4299
4300     /* Update reg_stat[].nonzero_bits et al for any changes that may have
4301        been made to this insn.  The order of
4302        set_nonzero_bits_and_sign_copies() is important.  Because newi2pat
4303        can affect nonzero_bits of newpat */
4304     if (newi2pat)
4305       note_stores (newi2pat, set_nonzero_bits_and_sign_copies, NULL);
4306     note_stores (newpat, set_nonzero_bits_and_sign_copies, NULL);
4307   }
4308
4309   if (undobuf.other_insn != NULL_RTX)
4310     {
4311       if (dump_file)
4312         {
4313           fprintf (dump_file, "modifying other_insn ");
4314           dump_insn_slim (dump_file, undobuf.other_insn);
4315         }
4316       df_insn_rescan (undobuf.other_insn);
4317     }
4318
4319   if (i0 && !(NOTE_P(i0) && (NOTE_KIND (i0) == NOTE_INSN_DELETED)))
4320     {
4321       if (dump_file)
4322         {
4323           fprintf (dump_file, "modifying insn i1 ");
4324           dump_insn_slim (dump_file, i0);
4325         }
4326       df_insn_rescan (i0);
4327     }
4328
4329   if (i1 && !(NOTE_P(i1) && (NOTE_KIND (i1) == NOTE_INSN_DELETED)))
4330     {
4331       if (dump_file)
4332         {
4333           fprintf (dump_file, "modifying insn i1 ");
4334           dump_insn_slim (dump_file, i1);
4335         }
4336       df_insn_rescan (i1);
4337     }
4338
4339   if (i2 && !(NOTE_P(i2) && (NOTE_KIND (i2) == NOTE_INSN_DELETED)))
4340     {
4341       if (dump_file)
4342         {
4343           fprintf (dump_file, "modifying insn i2 ");
4344           dump_insn_slim (dump_file, i2);
4345         }
4346       df_insn_rescan (i2);
4347     }
4348
4349   if (i3 && !(NOTE_P(i3) && (NOTE_KIND (i3) == NOTE_INSN_DELETED)))
4350     {
4351       if (dump_file)
4352         {
4353           fprintf (dump_file, "modifying insn i3 ");
4354           dump_insn_slim (dump_file, i3);
4355         }
4356       df_insn_rescan (i3);
4357     }
4358
4359   /* Set new_direct_jump_p if a new return or simple jump instruction
4360      has been created.  Adjust the CFG accordingly.  */
4361
4362   if (returnjump_p (i3) || any_uncondjump_p (i3))
4363     {
4364       *new_direct_jump_p = 1;
4365       mark_jump_label (PATTERN (i3), i3, 0);
4366       update_cfg_for_uncondjump (i3);
4367     }
4368
4369   if (undobuf.other_insn != NULL_RTX
4370       && (returnjump_p (undobuf.other_insn)
4371           || any_uncondjump_p (undobuf.other_insn)))
4372     {
4373       *new_direct_jump_p = 1;
4374       update_cfg_for_uncondjump (undobuf.other_insn);
4375     }
4376
4377   /* A noop might also need cleaning up of CFG, if it comes from the
4378      simplification of a jump.  */
4379   if (GET_CODE (newpat) == SET
4380       && SET_SRC (newpat) == pc_rtx
4381       && SET_DEST (newpat) == pc_rtx)
4382     {
4383       *new_direct_jump_p = 1;
4384       update_cfg_for_uncondjump (i3);
4385     }
4386
4387   if (undobuf.other_insn != NULL_RTX
4388       && GET_CODE (PATTERN (undobuf.other_insn)) == SET
4389       && SET_SRC (PATTERN (undobuf.other_insn)) == pc_rtx
4390       && SET_DEST (PATTERN (undobuf.other_insn)) == pc_rtx)
4391     {
4392       *new_direct_jump_p = 1;
4393       update_cfg_for_uncondjump (undobuf.other_insn);
4394     }
4395
4396   combine_successes++;
4397   undo_commit ();
4398
4399   if (added_links_insn
4400       && (newi2pat == 0 || DF_INSN_LUID (added_links_insn) < DF_INSN_LUID (i2))
4401       && DF_INSN_LUID (added_links_insn) < DF_INSN_LUID (i3))
4402     return added_links_insn;
4403   else
4404     return newi2pat ? i2 : i3;
4405 }
4406 \f
4407 /* Undo all the modifications recorded in undobuf.  */
4408
4409 static void
4410 undo_all (void)
4411 {
4412   struct undo *undo, *next;
4413
4414   for (undo = undobuf.undos; undo; undo = next)
4415     {
4416       next = undo->next;
4417       switch (undo->kind)
4418         {
4419         case UNDO_RTX:
4420           *undo->where.r = undo->old_contents.r;
4421           break;
4422         case UNDO_INT:
4423           *undo->where.i = undo->old_contents.i;
4424           break;
4425         case UNDO_MODE:
4426           adjust_reg_mode (*undo->where.r, undo->old_contents.m);
4427           break;
4428         default:
4429           gcc_unreachable ();
4430         }
4431
4432       undo->next = undobuf.frees;
4433       undobuf.frees = undo;
4434     }
4435
4436   undobuf.undos = 0;
4437 }
4438
4439 /* We've committed to accepting the changes we made.  Move all
4440    of the undos to the free list.  */
4441
4442 static void
4443 undo_commit (void)
4444 {
4445   struct undo *undo, *next;
4446
4447   for (undo = undobuf.undos; undo; undo = next)
4448     {
4449       next = undo->next;
4450       undo->next = undobuf.frees;
4451       undobuf.frees = undo;
4452     }
4453   undobuf.undos = 0;
4454 }
4455 \f
4456 /* Find the innermost point within the rtx at LOC, possibly LOC itself,
4457    where we have an arithmetic expression and return that point.  LOC will
4458    be inside INSN.
4459
4460    try_combine will call this function to see if an insn can be split into
4461    two insns.  */
4462
4463 static rtx *
4464 find_split_point (rtx *loc, rtx insn, bool set_src)
4465 {
4466   rtx x = *loc;
4467   enum rtx_code code = GET_CODE (x);
4468   rtx *split;
4469   unsigned HOST_WIDE_INT len = 0;
4470   HOST_WIDE_INT pos = 0;
4471   int unsignedp = 0;
4472   rtx inner = NULL_RTX;
4473
4474   /* First special-case some codes.  */
4475   switch (code)
4476     {
4477     case SUBREG:
4478 #ifdef INSN_SCHEDULING
4479       /* If we are making a paradoxical SUBREG invalid, it becomes a split
4480          point.  */
4481       if (MEM_P (SUBREG_REG (x)))
4482         return loc;
4483 #endif
4484       return find_split_point (&SUBREG_REG (x), insn, false);
4485
4486     case MEM:
4487 #ifdef HAVE_lo_sum
4488       /* If we have (mem (const ..)) or (mem (symbol_ref ...)), split it
4489          using LO_SUM and HIGH.  */
4490       if (GET_CODE (XEXP (x, 0)) == CONST
4491           || GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
4492         {
4493           enum machine_mode address_mode
4494             = targetm.addr_space.address_mode (MEM_ADDR_SPACE (x));
4495
4496           SUBST (XEXP (x, 0),
4497                  gen_rtx_LO_SUM (address_mode,
4498                                  gen_rtx_HIGH (address_mode, XEXP (x, 0)),
4499                                  XEXP (x, 0)));
4500           return &XEXP (XEXP (x, 0), 0);
4501         }
4502 #endif
4503
4504       /* If we have a PLUS whose second operand is a constant and the
4505          address is not valid, perhaps will can split it up using
4506          the machine-specific way to split large constants.  We use
4507          the first pseudo-reg (one of the virtual regs) as a placeholder;
4508          it will not remain in the result.  */
4509       if (GET_CODE (XEXP (x, 0)) == PLUS
4510           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
4511           && ! memory_address_addr_space_p (GET_MODE (x), XEXP (x, 0),
4512                                             MEM_ADDR_SPACE (x)))
4513         {
4514           rtx reg = regno_reg_rtx[FIRST_PSEUDO_REGISTER];
4515           rtx seq = combine_split_insns (gen_rtx_SET (VOIDmode, reg,
4516                                                       XEXP (x, 0)),
4517                                          subst_insn);
4518
4519           /* This should have produced two insns, each of which sets our
4520              placeholder.  If the source of the second is a valid address,
4521              we can make put both sources together and make a split point
4522              in the middle.  */
4523
4524           if (seq
4525               && NEXT_INSN (seq) != NULL_RTX
4526               && NEXT_INSN (NEXT_INSN (seq)) == NULL_RTX
4527               && NONJUMP_INSN_P (seq)
4528               && GET_CODE (PATTERN (seq)) == SET
4529               && SET_DEST (PATTERN (seq)) == reg
4530               && ! reg_mentioned_p (reg,
4531                                     SET_SRC (PATTERN (seq)))
4532               && NONJUMP_INSN_P (NEXT_INSN (seq))
4533               && GET_CODE (PATTERN (NEXT_INSN (seq))) == SET
4534               && SET_DEST (PATTERN (NEXT_INSN (seq))) == reg
4535               && memory_address_addr_space_p
4536                    (GET_MODE (x), SET_SRC (PATTERN (NEXT_INSN (seq))),
4537                     MEM_ADDR_SPACE (x)))
4538             {
4539               rtx src1 = SET_SRC (PATTERN (seq));
4540               rtx src2 = SET_SRC (PATTERN (NEXT_INSN (seq)));
4541
4542               /* Replace the placeholder in SRC2 with SRC1.  If we can
4543                  find where in SRC2 it was placed, that can become our
4544                  split point and we can replace this address with SRC2.
4545                  Just try two obvious places.  */
4546
4547               src2 = replace_rtx (src2, reg, src1);
4548               split = 0;
4549               if (XEXP (src2, 0) == src1)
4550                 split = &XEXP (src2, 0);
4551               else if (GET_RTX_FORMAT (GET_CODE (XEXP (src2, 0)))[0] == 'e'
4552                        && XEXP (XEXP (src2, 0), 0) == src1)
4553                 split = &XEXP (XEXP (src2, 0), 0);
4554
4555               if (split)
4556                 {
4557                   SUBST (XEXP (x, 0), src2);
4558                   return split;
4559                 }
4560             }
4561
4562           /* If that didn't work, perhaps the first operand is complex and
4563              needs to be computed separately, so make a split point there.
4564              This will occur on machines that just support REG + CONST
4565              and have a constant moved through some previous computation.  */
4566
4567           else if (!OBJECT_P (XEXP (XEXP (x, 0), 0))
4568                    && ! (GET_CODE (XEXP (XEXP (x, 0), 0)) == SUBREG
4569                          && OBJECT_P (SUBREG_REG (XEXP (XEXP (x, 0), 0)))))
4570             return &XEXP (XEXP (x, 0), 0);
4571         }
4572
4573       /* If we have a PLUS whose first operand is complex, try computing it
4574          separately by making a split there.  */
4575       if (GET_CODE (XEXP (x, 0)) == PLUS
4576           && ! memory_address_addr_space_p (GET_MODE (x), XEXP (x, 0),
4577                                             MEM_ADDR_SPACE (x))
4578           && ! OBJECT_P (XEXP (XEXP (x, 0), 0))
4579           && ! (GET_CODE (XEXP (XEXP (x, 0), 0)) == SUBREG
4580                 && OBJECT_P (SUBREG_REG (XEXP (XEXP (x, 0), 0)))))
4581         return &XEXP (XEXP (x, 0), 0);
4582       break;
4583
4584     case SET:
4585 #ifdef HAVE_cc0
4586       /* If SET_DEST is CC0 and SET_SRC is not an operand, a COMPARE, or a
4587          ZERO_EXTRACT, the most likely reason why this doesn't match is that
4588          we need to put the operand into a register.  So split at that
4589          point.  */
4590
4591       if (SET_DEST (x) == cc0_rtx
4592           && GET_CODE (SET_SRC (x)) != COMPARE
4593           && GET_CODE (SET_SRC (x)) != ZERO_EXTRACT
4594           && !OBJECT_P (SET_SRC (x))
4595           && ! (GET_CODE (SET_SRC (x)) == SUBREG
4596                 && OBJECT_P (SUBREG_REG (SET_SRC (x)))))
4597         return &SET_SRC (x);
4598 #endif
4599
4600       /* See if we can split SET_SRC as it stands.  */
4601       split = find_split_point (&SET_SRC (x), insn, true);
4602       if (split && split != &SET_SRC (x))
4603         return split;
4604
4605       /* See if we can split SET_DEST as it stands.  */
4606       split = find_split_point (&SET_DEST (x), insn, false);
4607       if (split && split != &SET_DEST (x))
4608         return split;
4609
4610       /* See if this is a bitfield assignment with everything constant.  If
4611          so, this is an IOR of an AND, so split it into that.  */
4612       if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
4613           && (GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)))
4614               <= HOST_BITS_PER_WIDE_INT)
4615           && CONST_INT_P (XEXP (SET_DEST (x), 1))
4616           && CONST_INT_P (XEXP (SET_DEST (x), 2))
4617           && CONST_INT_P (SET_SRC (x))
4618           && ((INTVAL (XEXP (SET_DEST (x), 1))
4619                + INTVAL (XEXP (SET_DEST (x), 2)))
4620               <= GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0))))
4621           && ! side_effects_p (XEXP (SET_DEST (x), 0)))
4622         {
4623           HOST_WIDE_INT pos = INTVAL (XEXP (SET_DEST (x), 2));
4624           unsigned HOST_WIDE_INT len = INTVAL (XEXP (SET_DEST (x), 1));
4625           unsigned HOST_WIDE_INT src = INTVAL (SET_SRC (x));
4626           rtx dest = XEXP (SET_DEST (x), 0);
4627           enum machine_mode mode = GET_MODE (dest);
4628           unsigned HOST_WIDE_INT mask
4629             = ((unsigned HOST_WIDE_INT) 1 << len) - 1;
4630           rtx or_mask;
4631
4632           if (BITS_BIG_ENDIAN)
4633             pos = GET_MODE_BITSIZE (mode) - len - pos;
4634
4635           or_mask = gen_int_mode (src << pos, mode);
4636           if (src == mask)
4637             SUBST (SET_SRC (x),
4638                    simplify_gen_binary (IOR, mode, dest, or_mask));
4639           else
4640             {
4641               rtx negmask = gen_int_mode (~(mask << pos), mode);
4642               SUBST (SET_SRC (x),
4643                      simplify_gen_binary (IOR, mode,
4644                                           simplify_gen_binary (AND, mode,
4645                                                                dest, negmask),
4646                                           or_mask));
4647             }
4648
4649           SUBST (SET_DEST (x), dest);
4650
4651           split = find_split_point (&SET_SRC (x), insn, true);
4652           if (split && split != &SET_SRC (x))
4653             return split;
4654         }
4655
4656       /* Otherwise, see if this is an operation that we can split into two.
4657          If so, try to split that.  */
4658       code = GET_CODE (SET_SRC (x));
4659
4660       switch (code)
4661         {
4662         case AND:
4663           /* If we are AND'ing with a large constant that is only a single
4664              bit and the result is only being used in a context where we
4665              need to know if it is zero or nonzero, replace it with a bit
4666              extraction.  This will avoid the large constant, which might
4667              have taken more than one insn to make.  If the constant were
4668              not a valid argument to the AND but took only one insn to make,
4669              this is no worse, but if it took more than one insn, it will
4670              be better.  */
4671
4672           if (CONST_INT_P (XEXP (SET_SRC (x), 1))
4673               && REG_P (XEXP (SET_SRC (x), 0))
4674               && (pos = exact_log2 (UINTVAL (XEXP (SET_SRC (x), 1)))) >= 7
4675               && REG_P (SET_DEST (x))
4676               && (split = find_single_use (SET_DEST (x), insn, (rtx*) 0)) != 0
4677               && (GET_CODE (*split) == EQ || GET_CODE (*split) == NE)
4678               && XEXP (*split, 0) == SET_DEST (x)
4679               && XEXP (*split, 1) == const0_rtx)
4680             {
4681               rtx extraction = make_extraction (GET_MODE (SET_DEST (x)),
4682                                                 XEXP (SET_SRC (x), 0),
4683                                                 pos, NULL_RTX, 1, 1, 0, 0);
4684               if (extraction != 0)
4685                 {
4686                   SUBST (SET_SRC (x), extraction);
4687                   return find_split_point (loc, insn, false);
4688                 }
4689             }
4690           break;
4691
4692         case NE:
4693           /* If STORE_FLAG_VALUE is -1, this is (NE X 0) and only one bit of X
4694              is known to be on, this can be converted into a NEG of a shift.  */
4695           if (STORE_FLAG_VALUE == -1 && XEXP (SET_SRC (x), 1) == const0_rtx
4696               && GET_MODE (SET_SRC (x)) == GET_MODE (XEXP (SET_SRC (x), 0))
4697               && 1 <= (pos = exact_log2
4698                        (nonzero_bits (XEXP (SET_SRC (x), 0),
4699                                       GET_MODE (XEXP (SET_SRC (x), 0))))))
4700             {
4701               enum machine_mode mode = GET_MODE (XEXP (SET_SRC (x), 0));
4702
4703               SUBST (SET_SRC (x),
4704                      gen_rtx_NEG (mode,
4705                                   gen_rtx_LSHIFTRT (mode,
4706                                                     XEXP (SET_SRC (x), 0),
4707                                                     GEN_INT (pos))));
4708
4709               split = find_split_point (&SET_SRC (x), insn, true);
4710               if (split && split != &SET_SRC (x))
4711                 return split;
4712             }
4713           break;
4714
4715         case SIGN_EXTEND:
4716           inner = XEXP (SET_SRC (x), 0);
4717
4718           /* We can't optimize if either mode is a partial integer
4719              mode as we don't know how many bits are significant
4720              in those modes.  */
4721           if (GET_MODE_CLASS (GET_MODE (inner)) == MODE_PARTIAL_INT
4722               || GET_MODE_CLASS (GET_MODE (SET_SRC (x))) == MODE_PARTIAL_INT)
4723             break;
4724
4725           pos = 0;
4726           len = GET_MODE_BITSIZE (GET_MODE (inner));
4727           unsignedp = 0;
4728           break;
4729
4730         case SIGN_EXTRACT:
4731         case ZERO_EXTRACT:
4732           if (CONST_INT_P (XEXP (SET_SRC (x), 1))
4733               && CONST_INT_P (XEXP (SET_SRC (x), 2)))
4734             {
4735               inner = XEXP (SET_SRC (x), 0);
4736               len = INTVAL (XEXP (SET_SRC (x), 1));
4737               pos = INTVAL (XEXP (SET_SRC (x), 2));
4738
4739               if (BITS_BIG_ENDIAN)
4740                 pos = GET_MODE_BITSIZE (GET_MODE (inner)) - len - pos;
4741               unsignedp = (code == ZERO_EXTRACT);
4742             }
4743           break;
4744
4745         default:
4746           break;
4747         }
4748
4749       if (len && pos >= 0 && pos + len <= GET_MODE_BITSIZE (GET_MODE (inner)))
4750         {
4751           enum machine_mode mode = GET_MODE (SET_SRC (x));
4752
4753           /* For unsigned, we have a choice of a shift followed by an
4754              AND or two shifts.  Use two shifts for field sizes where the
4755              constant might be too large.  We assume here that we can
4756              always at least get 8-bit constants in an AND insn, which is
4757              true for every current RISC.  */
4758
4759           if (unsignedp && len <= 8)
4760             {
4761               SUBST (SET_SRC (x),
4762                      gen_rtx_AND (mode,
4763                                   gen_rtx_LSHIFTRT
4764                                   (mode, gen_lowpart (mode, inner),
4765                                    GEN_INT (pos)),
4766                                   GEN_INT (((unsigned HOST_WIDE_INT) 1 << len)
4767                                            - 1)));
4768
4769               split = find_split_point (&SET_SRC (x), insn, true);
4770               if (split && split != &SET_SRC (x))
4771                 return split;
4772             }
4773           else
4774             {
4775               SUBST (SET_SRC (x),
4776                      gen_rtx_fmt_ee
4777                      (unsignedp ? LSHIFTRT : ASHIFTRT, mode,
4778                       gen_rtx_ASHIFT (mode,
4779                                       gen_lowpart (mode, inner),
4780                                       GEN_INT (GET_MODE_BITSIZE (mode)
4781                                                - len - pos)),
4782                       GEN_INT (GET_MODE_BITSIZE (mode) - len)));
4783
4784               split = find_split_point (&SET_SRC (x), insn, true);
4785               if (split && split != &SET_SRC (x))
4786                 return split;
4787             }
4788         }
4789
4790       /* See if this is a simple operation with a constant as the second
4791          operand.  It might be that this constant is out of range and hence
4792          could be used as a split point.  */
4793       if (BINARY_P (SET_SRC (x))
4794           && CONSTANT_P (XEXP (SET_SRC (x), 1))
4795           && (OBJECT_P (XEXP (SET_SRC (x), 0))
4796               || (GET_CODE (XEXP (SET_SRC (x), 0)) == SUBREG
4797                   && OBJECT_P (SUBREG_REG (XEXP (SET_SRC (x), 0))))))
4798         return &XEXP (SET_SRC (x), 1);
4799
4800       /* Finally, see if this is a simple operation with its first operand
4801          not in a register.  The operation might require this operand in a
4802          register, so return it as a split point.  We can always do this
4803          because if the first operand were another operation, we would have
4804          already found it as a split point.  */
4805       if ((BINARY_P (SET_SRC (x)) || UNARY_P (SET_SRC (x)))
4806           && ! register_operand (XEXP (SET_SRC (x), 0), VOIDmode))
4807         return &XEXP (SET_SRC (x), 0);
4808
4809       return 0;
4810
4811     case AND:
4812     case IOR:
4813       /* We write NOR as (and (not A) (not B)), but if we don't have a NOR,
4814          it is better to write this as (not (ior A B)) so we can split it.
4815          Similarly for IOR.  */
4816       if (GET_CODE (XEXP (x, 0)) == NOT && GET_CODE (XEXP (x, 1)) == NOT)
4817         {
4818           SUBST (*loc,
4819                  gen_rtx_NOT (GET_MODE (x),
4820                               gen_rtx_fmt_ee (code == IOR ? AND : IOR,
4821                                               GET_MODE (x),
4822                                               XEXP (XEXP (x, 0), 0),
4823                                               XEXP (XEXP (x, 1), 0))));
4824           return find_split_point (loc, insn, set_src);
4825         }
4826
4827       /* Many RISC machines have a large set of logical insns.  If the
4828          second operand is a NOT, put it first so we will try to split the
4829          other operand first.  */
4830       if (GET_CODE (XEXP (x, 1)) == NOT)
4831         {
4832           rtx tem = XEXP (x, 0);
4833           SUBST (XEXP (x, 0), XEXP (x, 1));
4834           SUBST (XEXP (x, 1), tem);
4835         }
4836       break;
4837
4838     case PLUS:
4839     case MINUS:
4840       /* Canonicalization can produce (minus A (mult B C)), where C is a
4841          constant.  It may be better to try splitting (plus (mult B -C) A)
4842          instead if this isn't a multiply by a power of two.  */
4843       if (set_src && code == MINUS && GET_CODE (XEXP (x, 1)) == MULT
4844           && GET_CODE (XEXP (XEXP (x, 1), 1)) == CONST_INT
4845           && exact_log2 (INTVAL (XEXP (XEXP (x, 1), 1))) < 0)
4846         {
4847           enum machine_mode mode = GET_MODE (x);
4848           unsigned HOST_WIDE_INT this_int = INTVAL (XEXP (XEXP (x, 1), 1));
4849           HOST_WIDE_INT other_int = trunc_int_for_mode (-this_int, mode);
4850           SUBST (*loc, gen_rtx_PLUS (mode, gen_rtx_MULT (mode,
4851                                                          XEXP (XEXP (x, 1), 0),
4852                                                          GEN_INT (other_int)),
4853                                      XEXP (x, 0)));
4854           return find_split_point (loc, insn, set_src);
4855         }
4856
4857       /* Split at a multiply-accumulate instruction.  However if this is
4858          the SET_SRC, we likely do not have such an instruction and it's
4859          worthless to try this split.  */
4860       if (!set_src && GET_CODE (XEXP (x, 0)) == MULT)
4861         return loc;
4862
4863     default:
4864       break;
4865     }
4866
4867   /* Otherwise, select our actions depending on our rtx class.  */
4868   switch (GET_RTX_CLASS (code))
4869     {
4870     case RTX_BITFIELD_OPS:              /* This is ZERO_EXTRACT and SIGN_EXTRACT.  */
4871     case RTX_TERNARY:
4872       split = find_split_point (&XEXP (x, 2), insn, false);
4873       if (split)
4874         return split;
4875       /* ... fall through ...  */
4876     case RTX_BIN_ARITH:
4877     case RTX_COMM_ARITH:
4878     case RTX_COMPARE:
4879     case RTX_COMM_COMPARE:
4880       split = find_split_point (&XEXP (x, 1), insn, false);
4881       if (split)
4882         return split;
4883       /* ... fall through ...  */
4884     case RTX_UNARY:
4885       /* Some machines have (and (shift ...) ...) insns.  If X is not
4886          an AND, but XEXP (X, 0) is, use it as our split point.  */
4887       if (GET_CODE (x) != AND && GET_CODE (XEXP (x, 0)) == AND)
4888         return &XEXP (x, 0);
4889
4890       split = find_split_point (&XEXP (x, 0), insn, false);
4891       if (split)
4892         return split;
4893       return loc;
4894
4895     default:
4896       /* Otherwise, we don't have a split point.  */
4897       return 0;
4898     }
4899 }
4900 \f
4901 /* Throughout X, replace FROM with TO, and return the result.
4902    The result is TO if X is FROM;
4903    otherwise the result is X, but its contents may have been modified.
4904    If they were modified, a record was made in undobuf so that
4905    undo_all will (among other things) return X to its original state.
4906
4907    If the number of changes necessary is too much to record to undo,
4908    the excess changes are not made, so the result is invalid.
4909    The changes already made can still be undone.
4910    undobuf.num_undo is incremented for such changes, so by testing that
4911    the caller can tell whether the result is valid.
4912
4913    `n_occurrences' is incremented each time FROM is replaced.
4914
4915    IN_DEST is nonzero if we are processing the SET_DEST of a SET.
4916
4917    UNIQUE_COPY is nonzero if each substitution must be unique.  We do this
4918    by copying if `n_occurrences' is nonzero.  */
4919
4920 static rtx
4921 subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
4922 {
4923   enum rtx_code code = GET_CODE (x);
4924   enum machine_mode op0_mode = VOIDmode;
4925   const char *fmt;
4926   int len, i;
4927   rtx new_rtx;
4928
4929 /* Two expressions are equal if they are identical copies of a shared
4930    RTX or if they are both registers with the same register number
4931    and mode.  */
4932
4933 #define COMBINE_RTX_EQUAL_P(X,Y)                        \
4934   ((X) == (Y)                                           \
4935    || (REG_P (X) && REG_P (Y)   \
4936        && REGNO (X) == REGNO (Y) && GET_MODE (X) == GET_MODE (Y)))
4937
4938   if (! in_dest && COMBINE_RTX_EQUAL_P (x, from))
4939     {
4940       n_occurrences++;
4941       return (unique_copy && n_occurrences > 1 ? copy_rtx (to) : to);
4942     }
4943
4944   /* If X and FROM are the same register but different modes, they
4945      will not have been seen as equal above.  However, the log links code
4946      will make a LOG_LINKS entry for that case.  If we do nothing, we
4947      will try to rerecognize our original insn and, when it succeeds,
4948      we will delete the feeding insn, which is incorrect.
4949
4950      So force this insn not to match in this (rare) case.  */
4951   if (! in_dest && code == REG && REG_P (from)
4952       && reg_overlap_mentioned_p (x, from))
4953     return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
4954
4955   /* If this is an object, we are done unless it is a MEM or LO_SUM, both
4956      of which may contain things that can be combined.  */
4957   if (code != MEM && code != LO_SUM && OBJECT_P (x))
4958     return x;
4959
4960   /* It is possible to have a subexpression appear twice in the insn.
4961      Suppose that FROM is a register that appears within TO.
4962      Then, after that subexpression has been scanned once by `subst',
4963      the second time it is scanned, TO may be found.  If we were
4964      to scan TO here, we would find FROM within it and create a
4965      self-referent rtl structure which is completely wrong.  */
4966   if (COMBINE_RTX_EQUAL_P (x, to))
4967     return to;
4968
4969   /* Parallel asm_operands need special attention because all of the
4970      inputs are shared across the arms.  Furthermore, unsharing the
4971      rtl results in recognition failures.  Failure to handle this case
4972      specially can result in circular rtl.
4973
4974      Solve this by doing a normal pass across the first entry of the
4975      parallel, and only processing the SET_DESTs of the subsequent
4976      entries.  Ug.  */
4977
4978   if (code == PARALLEL
4979       && GET_CODE (XVECEXP (x, 0, 0)) == SET
4980       && GET_CODE (SET_SRC (XVECEXP (x, 0, 0))) == ASM_OPERANDS)
4981     {
4982       new_rtx = subst (XVECEXP (x, 0, 0), from, to, 0, unique_copy);
4983
4984       /* If this substitution failed, this whole thing fails.  */
4985       if (GET_CODE (new_rtx) == CLOBBER
4986           && XEXP (new_rtx, 0) == const0_rtx)
4987         return new_rtx;
4988
4989       SUBST (XVECEXP (x, 0, 0), new_rtx);
4990
4991       for (i = XVECLEN (x, 0) - 1; i >= 1; i--)
4992         {
4993           rtx dest = SET_DEST (XVECEXP (x, 0, i));
4994
4995           if (!REG_P (dest)
4996               && GET_CODE (dest) != CC0
4997               && GET_CODE (dest) != PC)
4998             {
4999               new_rtx = subst (dest, from, to, 0, unique_copy);
5000
5001               /* If this substitution failed, this whole thing fails.  */
5002               if (GET_CODE (new_rtx) == CLOBBER
5003                   && XEXP (new_rtx, 0) == const0_rtx)
5004                 return new_rtx;
5005
5006               SUBST (SET_DEST (XVECEXP (x, 0, i)), new_rtx);
5007             }
5008         }
5009     }
5010   else
5011     {
5012       len = GET_RTX_LENGTH (code);
5013       fmt = GET_RTX_FORMAT (code);
5014
5015       /* We don't need to process a SET_DEST that is a register, CC0,
5016          or PC, so set up to skip this common case.  All other cases
5017          where we want to suppress replacing something inside a
5018          SET_SRC are handled via the IN_DEST operand.  */
5019       if (code == SET
5020           && (REG_P (SET_DEST (x))
5021               || GET_CODE (SET_DEST (x)) == CC0
5022               || GET_CODE (SET_DEST (x)) == PC))
5023         fmt = "ie";
5024
5025       /* Get the mode of operand 0 in case X is now a SIGN_EXTEND of a
5026          constant.  */
5027       if (fmt[0] == 'e')
5028         op0_mode = GET_MODE (XEXP (x, 0));
5029
5030       for (i = 0; i < len; i++)
5031         {
5032           if (fmt[i] == 'E')
5033             {
5034               int j;
5035               for (j = XVECLEN (x, i) - 1; j >= 0; j--)
5036                 {
5037                   if (COMBINE_RTX_EQUAL_P (XVECEXP (x, i, j), from))
5038                     {
5039                       new_rtx = (unique_copy && n_occurrences
5040                              ? copy_rtx (to) : to);
5041                       n_occurrences++;
5042                     }
5043                   else
5044                     {
5045                       new_rtx = subst (XVECEXP (x, i, j), from, to, 0,
5046                                    unique_copy);
5047
5048                       /* If this substitution failed, this whole thing
5049                          fails.  */
5050                       if (GET_CODE (new_rtx) == CLOBBER
5051                           && XEXP (new_rtx, 0) == const0_rtx)
5052                         return new_rtx;
5053                     }
5054
5055                   SUBST (XVECEXP (x, i, j), new_rtx);
5056                 }
5057             }
5058           else if (fmt[i] == 'e')
5059             {
5060               /* If this is a register being set, ignore it.  */
5061               new_rtx = XEXP (x, i);
5062               if (in_dest
5063                   && i == 0
5064                   && (((code == SUBREG || code == ZERO_EXTRACT)
5065                        && REG_P (new_rtx))
5066                       || code == STRICT_LOW_PART))
5067                 ;
5068
5069               else if (COMBINE_RTX_EQUAL_P (XEXP (x, i), from))
5070                 {
5071                   /* In general, don't install a subreg involving two
5072                      modes not tieable.  It can worsen register
5073                      allocation, and can even make invalid reload
5074                      insns, since the reg inside may need to be copied
5075                      from in the outside mode, and that may be invalid
5076                      if it is an fp reg copied in integer mode.
5077
5078                      We allow two exceptions to this: It is valid if
5079                      it is inside another SUBREG and the mode of that
5080                      SUBREG and the mode of the inside of TO is
5081                      tieable and it is valid if X is a SET that copies
5082                      FROM to CC0.  */
5083
5084                   if (GET_CODE (to) == SUBREG
5085                       && ! MODES_TIEABLE_P (GET_MODE (to),
5086                                             GET_MODE (SUBREG_REG (to)))
5087                       && ! (code == SUBREG
5088                             && MODES_TIEABLE_P (GET_MODE (x),
5089                                                 GET_MODE (SUBREG_REG (to))))
5090 #ifdef HAVE_cc0
5091                       && ! (code == SET && i == 1 && XEXP (x, 0) == cc0_rtx)
5092 #endif
5093                       )
5094                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
5095
5096 #ifdef CANNOT_CHANGE_MODE_CLASS
5097                   if (code == SUBREG
5098                       && REG_P (to)
5099                       && REGNO (to) < FIRST_PSEUDO_REGISTER
5100                       && REG_CANNOT_CHANGE_MODE_P (REGNO (to),
5101                                                    GET_MODE (to),
5102                                                    GET_MODE (x)))
5103                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
5104 #endif
5105
5106                   new_rtx = (unique_copy && n_occurrences ? copy_rtx (to) : to);
5107                   n_occurrences++;
5108                 }
5109               else
5110                 /* If we are in a SET_DEST, suppress most cases unless we
5111                    have gone inside a MEM, in which case we want to
5112                    simplify the address.  We assume here that things that
5113                    are actually part of the destination have their inner
5114                    parts in the first expression.  This is true for SUBREG,
5115                    STRICT_LOW_PART, and ZERO_EXTRACT, which are the only
5116                    things aside from REG and MEM that should appear in a
5117                    SET_DEST.  */
5118                 new_rtx = subst (XEXP (x, i), from, to,
5119                              (((in_dest
5120                                 && (code == SUBREG || code == STRICT_LOW_PART
5121                                     || code == ZERO_EXTRACT))
5122                                || code == SET)
5123                               && i == 0), unique_copy);
5124
5125               /* If we found that we will have to reject this combination,
5126                  indicate that by returning the CLOBBER ourselves, rather than
5127                  an expression containing it.  This will speed things up as
5128                  well as prevent accidents where two CLOBBERs are considered
5129                  to be equal, thus producing an incorrect simplification.  */
5130
5131               if (GET_CODE (new_rtx) == CLOBBER && XEXP (new_rtx, 0) == const0_rtx)
5132                 return new_rtx;
5133
5134               if (GET_CODE (x) == SUBREG
5135                   && (CONST_INT_P (new_rtx)
5136                       || GET_CODE (new_rtx) == CONST_DOUBLE))
5137                 {
5138                   enum machine_mode mode = GET_MODE (x);
5139
5140                   x = simplify_subreg (GET_MODE (x), new_rtx,
5141                                        GET_MODE (SUBREG_REG (x)),
5142                                        SUBREG_BYTE (x));
5143                   if (! x)
5144                     x = gen_rtx_CLOBBER (mode, const0_rtx);
5145                 }
5146               else if (CONST_INT_P (new_rtx)
5147                        && GET_CODE (x) == ZERO_EXTEND)
5148                 {
5149                   x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
5150                                                 new_rtx, GET_MODE (XEXP (x, 0)));
5151                   gcc_assert (x);
5152                 }
5153               else
5154                 SUBST (XEXP (x, i), new_rtx);
5155             }
5156         }
5157     }
5158
5159   /* Check if we are loading something from the constant pool via float
5160      extension; in this case we would undo compress_float_constant
5161      optimization and degenerate constant load to an immediate value.  */
5162   if (GET_CODE (x) == FLOAT_EXTEND
5163       && MEM_P (XEXP (x, 0))
5164       && MEM_READONLY_P (XEXP (x, 0)))
5165     {
5166       rtx tmp = avoid_constant_pool_reference (x);
5167       if (x != tmp)
5168         return x;
5169     }
5170
5171   /* Try to simplify X.  If the simplification changed the code, it is likely
5172      that further simplification will help, so loop, but limit the number
5173      of repetitions that will be performed.  */
5174
5175   for (i = 0; i < 4; i++)
5176     {
5177       /* If X is sufficiently simple, don't bother trying to do anything
5178          with it.  */
5179       if (code != CONST_INT && code != REG && code != CLOBBER)
5180         x = combine_simplify_rtx (x, op0_mode, in_dest);
5181
5182       if (GET_CODE (x) == code)
5183         break;
5184
5185       code = GET_CODE (x);
5186
5187       /* We no longer know the original mode of operand 0 since we
5188          have changed the form of X)  */
5189       op0_mode = VOIDmode;
5190     }
5191
5192   return x;
5193 }
5194 \f
5195 /* Simplify X, a piece of RTL.  We just operate on the expression at the
5196    outer level; call `subst' to simplify recursively.  Return the new
5197    expression.
5198
5199    OP0_MODE is the original mode of XEXP (x, 0).  IN_DEST is nonzero
5200    if we are inside a SET_DEST.  */
5201
5202 static rtx
5203 combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int in_dest)
5204 {
5205   enum rtx_code code = GET_CODE (x);
5206   enum machine_mode mode = GET_MODE (x);
5207   rtx temp;
5208   int i;
5209
5210   /* If this is a commutative operation, put a constant last and a complex
5211      expression first.  We don't need to do this for comparisons here.  */
5212   if (COMMUTATIVE_ARITH_P (x)
5213       && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
5214     {
5215       temp = XEXP (x, 0);
5216       SUBST (XEXP (x, 0), XEXP (x, 1));
5217       SUBST (XEXP (x, 1), temp);
5218     }
5219
5220   /* If this is a simple operation applied to an IF_THEN_ELSE, try
5221      applying it to the arms of the IF_THEN_ELSE.  This often simplifies
5222      things.  Check for cases where both arms are testing the same
5223      condition.
5224
5225      Don't do anything if all operands are very simple.  */
5226
5227   if ((BINARY_P (x)
5228        && ((!OBJECT_P (XEXP (x, 0))
5229             && ! (GET_CODE (XEXP (x, 0)) == SUBREG
5230                   && OBJECT_P (SUBREG_REG (XEXP (x, 0)))))
5231            || (!OBJECT_P (XEXP (x, 1))
5232                && ! (GET_CODE (XEXP (x, 1)) == SUBREG
5233                      && OBJECT_P (SUBREG_REG (XEXP (x, 1)))))))
5234       || (UNARY_P (x)
5235           && (!OBJECT_P (XEXP (x, 0))
5236                && ! (GET_CODE (XEXP (x, 0)) == SUBREG
5237                      && OBJECT_P (SUBREG_REG (XEXP (x, 0)))))))
5238     {
5239       rtx cond, true_rtx, false_rtx;
5240
5241       cond = if_then_else_cond (x, &true_rtx, &false_rtx);
5242       if (cond != 0
5243           /* If everything is a comparison, what we have is highly unlikely
5244              to be simpler, so don't use it.  */
5245           && ! (COMPARISON_P (x)
5246                 && (COMPARISON_P (true_rtx) || COMPARISON_P (false_rtx))))
5247         {
5248           rtx cop1 = const0_rtx;
5249           enum rtx_code cond_code = simplify_comparison (NE, &cond, &cop1);
5250
5251           if (cond_code == NE && COMPARISON_P (cond))
5252             return x;
5253
5254           /* Simplify the alternative arms; this may collapse the true and
5255              false arms to store-flag values.  Be careful to use copy_rtx
5256              here since true_rtx or false_rtx might share RTL with x as a
5257              result of the if_then_else_cond call above.  */
5258           true_rtx = subst (copy_rtx (true_rtx), pc_rtx, pc_rtx, 0, 0);
5259           false_rtx = subst (copy_rtx (false_rtx), pc_rtx, pc_rtx, 0, 0);
5260
5261           /* If true_rtx and false_rtx are not general_operands, an if_then_else
5262              is unlikely to be simpler.  */
5263           if (general_operand (true_rtx, VOIDmode)
5264               && general_operand (false_rtx, VOIDmode))
5265             {
5266               enum rtx_code reversed;
5267
5268               /* Restarting if we generate a store-flag expression will cause
5269                  us to loop.  Just drop through in this case.  */
5270
5271               /* If the result values are STORE_FLAG_VALUE and zero, we can
5272                  just make the comparison operation.  */
5273               if (true_rtx == const_true_rtx && false_rtx == const0_rtx)
5274                 x = simplify_gen_relational (cond_code, mode, VOIDmode,
5275                                              cond, cop1);
5276               else if (true_rtx == const0_rtx && false_rtx == const_true_rtx
5277                        && ((reversed = reversed_comparison_code_parts
5278                                         (cond_code, cond, cop1, NULL))
5279                            != UNKNOWN))
5280                 x = simplify_gen_relational (reversed, mode, VOIDmode,
5281                                              cond, cop1);
5282
5283               /* Likewise, we can make the negate of a comparison operation
5284                  if the result values are - STORE_FLAG_VALUE and zero.  */
5285               else if (CONST_INT_P (true_rtx)
5286                        && INTVAL (true_rtx) == - STORE_FLAG_VALUE
5287                        && false_rtx == const0_rtx)
5288                 x = simplify_gen_unary (NEG, mode,
5289                                         simplify_gen_relational (cond_code,
5290                                                                  mode, VOIDmode,
5291                                                                  cond, cop1),
5292                                         mode);
5293               else if (CONST_INT_P (false_rtx)
5294                        && INTVAL (false_rtx) == - STORE_FLAG_VALUE
5295                        && true_rtx == const0_rtx
5296                        && ((reversed = reversed_comparison_code_parts
5297                                         (cond_code, cond, cop1, NULL))
5298                            != UNKNOWN))
5299                 x = simplify_gen_unary (NEG, mode,
5300                                         simplify_gen_relational (reversed,
5301                                                                  mode, VOIDmode,
5302                                                                  cond, cop1),
5303                                         mode);
5304               else
5305                 return gen_rtx_IF_THEN_ELSE (mode,
5306                                              simplify_gen_relational (cond_code,
5307                                                                       mode,
5308                                                                       VOIDmode,
5309                                                                       cond,
5310                                                                       cop1),
5311                                              true_rtx, false_rtx);
5312
5313               code = GET_CODE (x);
5314               op0_mode = VOIDmode;
5315             }
5316         }
5317     }
5318
5319   /* Try to fold this expression in case we have constants that weren't
5320      present before.  */
5321   temp = 0;
5322   switch (GET_RTX_CLASS (code))
5323     {
5324     case RTX_UNARY:
5325       if (op0_mode == VOIDmode)
5326         op0_mode = GET_MODE (XEXP (x, 0));
5327       temp = simplify_unary_operation (code, mode, XEXP (x, 0), op0_mode);
5328       break;
5329     case RTX_COMPARE:
5330     case RTX_COMM_COMPARE:
5331       {
5332         enum machine_mode cmp_mode = GET_MODE (XEXP (x, 0));
5333         if (cmp_mode == VOIDmode)
5334           {
5335             cmp_mode = GET_MODE (XEXP (x, 1));
5336             if (cmp_mode == VOIDmode)
5337               cmp_mode = op0_mode;
5338           }
5339         temp = simplify_relational_operation (code, mode, cmp_mode,
5340                                               XEXP (x, 0), XEXP (x, 1));
5341       }
5342       break;
5343     case RTX_COMM_ARITH:
5344     case RTX_BIN_ARITH:
5345       temp = simplify_binary_operation (code, mode, XEXP (x, 0), XEXP (x, 1));
5346       break;
5347     case RTX_BITFIELD_OPS:
5348     case RTX_TERNARY:
5349       temp = simplify_ternary_operation (code, mode, op0_mode, XEXP (x, 0),
5350                                          XEXP (x, 1), XEXP (x, 2));
5351       break;
5352     default:
5353       break;
5354     }
5355
5356   if (temp)
5357     {
5358       x = temp;
5359       code = GET_CODE (temp);
5360       op0_mode = VOIDmode;
5361       mode = GET_MODE (temp);
5362     }
5363
5364   /* First see if we can apply the inverse distributive law.  */
5365   if (code == PLUS || code == MINUS
5366       || code == AND || code == IOR || code == XOR)
5367     {
5368       x = apply_distributive_law (x);
5369       code = GET_CODE (x);
5370       op0_mode = VOIDmode;
5371     }
5372
5373   /* If CODE is an associative operation not otherwise handled, see if we
5374      can associate some operands.  This can win if they are constants or
5375      if they are logically related (i.e. (a & b) & a).  */
5376   if ((code == PLUS || code == MINUS || code == MULT || code == DIV
5377        || code == AND || code == IOR || code == XOR
5378        || code == SMAX || code == SMIN || code == UMAX || code == UMIN)
5379       && ((INTEGRAL_MODE_P (mode) && code != DIV)
5380           || (flag_associative_math && FLOAT_MODE_P (mode))))
5381     {
5382       if (GET_CODE (XEXP (x, 0)) == code)
5383         {
5384           rtx other = XEXP (XEXP (x, 0), 0);
5385           rtx inner_op0 = XEXP (XEXP (x, 0), 1);
5386           rtx inner_op1 = XEXP (x, 1);
5387           rtx inner;
5388
5389           /* Make sure we pass the constant operand if any as the second
5390              one if this is a commutative operation.  */
5391           if (CONSTANT_P (inner_op0) && COMMUTATIVE_ARITH_P (x))
5392             {
5393               rtx tem = inner_op0;
5394               inner_op0 = inner_op1;
5395               inner_op1 = tem;
5396             }
5397           inner = simplify_binary_operation (code == MINUS ? PLUS
5398                                              : code == DIV ? MULT
5399                                              : code,
5400                                              mode, inner_op0, inner_op1);
5401
5402           /* For commutative operations, try the other pair if that one
5403              didn't simplify.  */
5404           if (inner == 0 && COMMUTATIVE_ARITH_P (x))
5405             {
5406               other = XEXP (XEXP (x, 0), 1);
5407               inner = simplify_binary_operation (code, mode,
5408                                                  XEXP (XEXP (x, 0), 0),
5409                                                  XEXP (x, 1));
5410             }
5411
5412           if (inner)
5413             return simplify_gen_binary (code, mode, other, inner);
5414         }
5415     }
5416
5417   /* A little bit of algebraic simplification here.  */
5418   switch (code)
5419     {
5420     case MEM:
5421       /* Ensure that our address has any ASHIFTs converted to MULT in case
5422          address-recognizing predicates are called later.  */
5423       temp = make_compound_operation (XEXP (x, 0), MEM);
5424       SUBST (XEXP (x, 0), temp);
5425       break;
5426
5427     case SUBREG:
5428       if (op0_mode == VOIDmode)
5429         op0_mode = GET_MODE (SUBREG_REG (x));
5430
5431       /* See if this can be moved to simplify_subreg.  */
5432       if (CONSTANT_P (SUBREG_REG (x))
5433           && subreg_lowpart_offset (mode, op0_mode) == SUBREG_BYTE (x)
5434              /* Don't call gen_lowpart if the inner mode
5435                 is VOIDmode and we cannot simplify it, as SUBREG without
5436                 inner mode is invalid.  */
5437           && (GET_MODE (SUBREG_REG (x)) != VOIDmode
5438               || gen_lowpart_common (mode, SUBREG_REG (x))))
5439         return gen_lowpart (mode, SUBREG_REG (x));
5440
5441       if (GET_MODE_CLASS (GET_MODE (SUBREG_REG (x))) == MODE_CC)
5442         break;
5443       {
5444         rtx temp;
5445         temp = simplify_subreg (mode, SUBREG_REG (x), op0_mode,
5446                                 SUBREG_BYTE (x));
5447         if (temp)
5448           return temp;
5449       }
5450
5451       /* Don't change the mode of the MEM if that would change the meaning
5452          of the address.  */
5453       if (MEM_P (SUBREG_REG (x))
5454           && (MEM_VOLATILE_P (SUBREG_REG (x))
5455               || mode_dependent_address_p (XEXP (SUBREG_REG (x), 0))))
5456         return gen_rtx_CLOBBER (mode, const0_rtx);
5457
5458       /* Note that we cannot do any narrowing for non-constants since
5459          we might have been counting on using the fact that some bits were
5460          zero.  We now do this in the SET.  */
5461
5462       break;
5463
5464     case NEG:
5465       temp = expand_compound_operation (XEXP (x, 0));
5466
5467       /* For C equal to the width of MODE minus 1, (neg (ashiftrt X C)) can be
5468          replaced by (lshiftrt X C).  This will convert
5469          (neg (sign_extract X 1 Y)) to (zero_extract X 1 Y).  */
5470
5471       if (GET_CODE (temp) == ASHIFTRT
5472           && CONST_INT_P (XEXP (temp, 1))
5473           && INTVAL (XEXP (temp, 1)) == GET_MODE_BITSIZE (mode) - 1)
5474         return simplify_shift_const (NULL_RTX, LSHIFTRT, mode, XEXP (temp, 0),
5475                                      INTVAL (XEXP (temp, 1)));
5476
5477       /* If X has only a single bit that might be nonzero, say, bit I, convert
5478          (neg X) to (ashiftrt (ashift X C-I) C-I) where C is the bitsize of
5479          MODE minus 1.  This will convert (neg (zero_extract X 1 Y)) to
5480          (sign_extract X 1 Y).  But only do this if TEMP isn't a register
5481          or a SUBREG of one since we'd be making the expression more
5482          complex if it was just a register.  */
5483
5484       if (!REG_P (temp)
5485           && ! (GET_CODE (temp) == SUBREG
5486                 && REG_P (SUBREG_REG (temp)))
5487           && (i = exact_log2 (nonzero_bits (temp, mode))) >= 0)
5488         {
5489           rtx temp1 = simplify_shift_const
5490             (NULL_RTX, ASHIFTRT, mode,
5491              simplify_shift_const (NULL_RTX, ASHIFT, mode, temp,
5492                                    GET_MODE_BITSIZE (mode) - 1 - i),
5493              GET_MODE_BITSIZE (mode) - 1 - i);
5494
5495           /* If all we did was surround TEMP with the two shifts, we
5496              haven't improved anything, so don't use it.  Otherwise,
5497              we are better off with TEMP1.  */
5498           if (GET_CODE (temp1) != ASHIFTRT
5499               || GET_CODE (XEXP (temp1, 0)) != ASHIFT
5500               || XEXP (XEXP (temp1, 0), 0) != temp)
5501             return temp1;
5502         }
5503       break;
5504
5505     case TRUNCATE:
5506       /* We can't handle truncation to a partial integer mode here
5507          because we don't know the real bitsize of the partial
5508          integer mode.  */
5509       if (GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
5510         break;
5511
5512       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
5513         SUBST (XEXP (x, 0),
5514                force_to_mode (XEXP (x, 0), GET_MODE (XEXP (x, 0)),
5515                               GET_MODE_MASK (mode), 0));
5516
5517       /* We can truncate a constant value and return it.  */
5518       if (CONST_INT_P (XEXP (x, 0)))
5519         return gen_int_mode (INTVAL (XEXP (x, 0)), mode);
5520
5521       /* Similarly to what we do in simplify-rtx.c, a truncate of a register
5522          whose value is a comparison can be replaced with a subreg if
5523          STORE_FLAG_VALUE permits.  */
5524       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5525           && (STORE_FLAG_VALUE & ~GET_MODE_MASK (mode)) == 0
5526           && (temp = get_last_value (XEXP (x, 0)))
5527           && COMPARISON_P (temp))
5528         return gen_lowpart (mode, XEXP (x, 0));
5529       break;
5530
5531     case CONST:
5532       /* (const (const X)) can become (const X).  Do it this way rather than
5533          returning the inner CONST since CONST can be shared with a
5534          REG_EQUAL note.  */
5535       if (GET_CODE (XEXP (x, 0)) == CONST)
5536         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
5537       break;
5538
5539 #ifdef HAVE_lo_sum
5540     case LO_SUM:
5541       /* Convert (lo_sum (high FOO) FOO) to FOO.  This is necessary so we
5542          can add in an offset.  find_split_point will split this address up
5543          again if it doesn't match.  */
5544       if (GET_CODE (XEXP (x, 0)) == HIGH
5545           && rtx_equal_p (XEXP (XEXP (x, 0), 0), XEXP (x, 1)))
5546         return XEXP (x, 1);
5547       break;
5548 #endif
5549
5550     case PLUS:
5551       /* (plus (xor (and <foo> (const_int pow2 - 1)) <c>) <-c>)
5552          when c is (const_int (pow2 + 1) / 2) is a sign extension of a
5553          bit-field and can be replaced by either a sign_extend or a
5554          sign_extract.  The `and' may be a zero_extend and the two
5555          <c>, -<c> constants may be reversed.  */
5556       if (GET_CODE (XEXP (x, 0)) == XOR
5557           && CONST_INT_P (XEXP (x, 1))
5558           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
5559           && INTVAL (XEXP (x, 1)) == -INTVAL (XEXP (XEXP (x, 0), 1))
5560           && ((i = exact_log2 (UINTVAL (XEXP (XEXP (x, 0), 1)))) >= 0
5561               || (i = exact_log2 (UINTVAL (XEXP (x, 1)))) >= 0)
5562           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5563           && ((GET_CODE (XEXP (XEXP (x, 0), 0)) == AND
5564                && CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 0), 1))
5565                && (UINTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1))
5566                    == ((unsigned HOST_WIDE_INT) 1 << (i + 1)) - 1))
5567               || (GET_CODE (XEXP (XEXP (x, 0), 0)) == ZERO_EXTEND
5568                   && (GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (XEXP (x, 0), 0), 0)))
5569                       == (unsigned int) i + 1))))
5570         return simplify_shift_const
5571           (NULL_RTX, ASHIFTRT, mode,
5572            simplify_shift_const (NULL_RTX, ASHIFT, mode,
5573                                  XEXP (XEXP (XEXP (x, 0), 0), 0),
5574                                  GET_MODE_BITSIZE (mode) - (i + 1)),
5575            GET_MODE_BITSIZE (mode) - (i + 1));
5576
5577       /* If only the low-order bit of X is possibly nonzero, (plus x -1)
5578          can become (ashiftrt (ashift (xor x 1) C) C) where C is
5579          the bitsize of the mode - 1.  This allows simplification of
5580          "a = (b & 8) == 0;"  */
5581       if (XEXP (x, 1) == constm1_rtx
5582           && !REG_P (XEXP (x, 0))
5583           && ! (GET_CODE (XEXP (x, 0)) == SUBREG
5584                 && REG_P (SUBREG_REG (XEXP (x, 0))))
5585           && nonzero_bits (XEXP (x, 0), mode) == 1)
5586         return simplify_shift_const (NULL_RTX, ASHIFTRT, mode,
5587            simplify_shift_const (NULL_RTX, ASHIFT, mode,
5588                                  gen_rtx_XOR (mode, XEXP (x, 0), const1_rtx),
5589                                  GET_MODE_BITSIZE (mode) - 1),
5590            GET_MODE_BITSIZE (mode) - 1);
5591
5592       /* If we are adding two things that have no bits in common, convert
5593          the addition into an IOR.  This will often be further simplified,
5594          for example in cases like ((a & 1) + (a & 2)), which can
5595          become a & 3.  */
5596
5597       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5598           && (nonzero_bits (XEXP (x, 0), mode)
5599               & nonzero_bits (XEXP (x, 1), mode)) == 0)
5600         {
5601           /* Try to simplify the expression further.  */
5602           rtx tor = simplify_gen_binary (IOR, mode, XEXP (x, 0), XEXP (x, 1));
5603           temp = combine_simplify_rtx (tor, mode, in_dest);
5604
5605           /* If we could, great.  If not, do not go ahead with the IOR
5606              replacement, since PLUS appears in many special purpose
5607              address arithmetic instructions.  */
5608           if (GET_CODE (temp) != CLOBBER && temp != tor)
5609             return temp;
5610         }
5611       break;
5612
5613     case MINUS:
5614       /* (minus <foo> (and <foo> (const_int -pow2))) becomes
5615          (and <foo> (const_int pow2-1))  */
5616       if (GET_CODE (XEXP (x, 1)) == AND
5617           && CONST_INT_P (XEXP (XEXP (x, 1), 1))
5618           && exact_log2 (-UINTVAL (XEXP (XEXP (x, 1), 1))) >= 0
5619           && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
5620         return simplify_and_const_int (NULL_RTX, mode, XEXP (x, 0),
5621                                        -INTVAL (XEXP (XEXP (x, 1), 1)) - 1);
5622       break;
5623
5624     case MULT:
5625       /* If we have (mult (plus A B) C), apply the distributive law and then
5626          the inverse distributive law to see if things simplify.  This
5627          occurs mostly in addresses, often when unrolling loops.  */
5628
5629       if (GET_CODE (XEXP (x, 0)) == PLUS)
5630         {
5631           rtx result = distribute_and_simplify_rtx (x, 0);
5632           if (result)
5633             return result;
5634         }
5635
5636       /* Try simplify a*(b/c) as (a*b)/c.  */
5637       if (FLOAT_MODE_P (mode) && flag_associative_math
5638           && GET_CODE (XEXP (x, 0)) == DIV)
5639         {
5640           rtx tem = simplify_binary_operation (MULT, mode,
5641                                                XEXP (XEXP (x, 0), 0),
5642                                                XEXP (x, 1));
5643           if (tem)
5644             return simplify_gen_binary (DIV, mode, tem, XEXP (XEXP (x, 0), 1));
5645         }
5646       break;
5647
5648     case UDIV:
5649       /* If this is a divide by a power of two, treat it as a shift if
5650          its first operand is a shift.  */
5651       if (CONST_INT_P (XEXP (x, 1))
5652           && (i = exact_log2 (UINTVAL (XEXP (x, 1)))) >= 0
5653           && (GET_CODE (XEXP (x, 0)) == ASHIFT
5654               || GET_CODE (XEXP (x, 0)) == LSHIFTRT
5655               || GET_CODE (XEXP (x, 0)) == ASHIFTRT
5656               || GET_CODE (XEXP (x, 0)) == ROTATE
5657               || GET_CODE (XEXP (x, 0)) == ROTATERT))
5658         return simplify_shift_const (NULL_RTX, LSHIFTRT, mode, XEXP (x, 0), i);
5659       break;
5660
5661     case EQ:  case NE:
5662     case GT:  case GTU:  case GE:  case GEU:
5663     case LT:  case LTU:  case LE:  case LEU:
5664     case UNEQ:  case LTGT:
5665     case UNGT:  case UNGE:
5666     case UNLT:  case UNLE:
5667     case UNORDERED: case ORDERED:
5668       /* If the first operand is a condition code, we can't do anything
5669          with it.  */
5670       if (GET_CODE (XEXP (x, 0)) == COMPARE
5671           || (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) != MODE_CC
5672               && ! CC0_P (XEXP (x, 0))))
5673         {
5674           rtx op0 = XEXP (x, 0);
5675           rtx op1 = XEXP (x, 1);
5676           enum rtx_code new_code;
5677
5678           if (GET_CODE (op0) == COMPARE)
5679             op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
5680
5681           /* Simplify our comparison, if possible.  */
5682           new_code = simplify_comparison (code, &op0, &op1);
5683
5684           /* If STORE_FLAG_VALUE is 1, we can convert (ne x 0) to simply X
5685              if only the low-order bit is possibly nonzero in X (such as when
5686              X is a ZERO_EXTRACT of one bit).  Similarly, we can convert EQ to
5687              (xor X 1) or (minus 1 X); we use the former.  Finally, if X is
5688              known to be either 0 or -1, NE becomes a NEG and EQ becomes
5689              (plus X 1).
5690
5691              Remove any ZERO_EXTRACT we made when thinking this was a
5692              comparison.  It may now be simpler to use, e.g., an AND.  If a
5693              ZERO_EXTRACT is indeed appropriate, it will be placed back by
5694              the call to make_compound_operation in the SET case.  */
5695
5696           if (STORE_FLAG_VALUE == 1
5697               && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5698               && op1 == const0_rtx
5699               && mode == GET_MODE (op0)
5700               && nonzero_bits (op0, mode) == 1)
5701             return gen_lowpart (mode,
5702                                 expand_compound_operation (op0));
5703
5704           else if (STORE_FLAG_VALUE == 1
5705                    && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5706                    && op1 == const0_rtx
5707                    && mode == GET_MODE (op0)
5708                    && (num_sign_bit_copies (op0, mode)
5709                        == GET_MODE_BITSIZE (mode)))
5710             {
5711               op0 = expand_compound_operation (op0);
5712               return simplify_gen_unary (NEG, mode,
5713                                          gen_lowpart (mode, op0),
5714                                          mode);
5715             }
5716
5717           else if (STORE_FLAG_VALUE == 1
5718                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5719                    && op1 == const0_rtx
5720                    && mode == GET_MODE (op0)
5721                    && nonzero_bits (op0, mode) == 1)
5722             {
5723               op0 = expand_compound_operation (op0);
5724               return simplify_gen_binary (XOR, mode,
5725                                           gen_lowpart (mode, op0),
5726                                           const1_rtx);
5727             }
5728
5729           else if (STORE_FLAG_VALUE == 1
5730                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5731                    && op1 == const0_rtx
5732                    && mode == GET_MODE (op0)
5733                    && (num_sign_bit_copies (op0, mode)
5734                        == GET_MODE_BITSIZE (mode)))
5735             {
5736               op0 = expand_compound_operation (op0);
5737               return plus_constant (gen_lowpart (mode, op0), 1);
5738             }
5739
5740           /* If STORE_FLAG_VALUE is -1, we have cases similar to
5741              those above.  */
5742           if (STORE_FLAG_VALUE == -1
5743               && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5744               && op1 == const0_rtx
5745               && (num_sign_bit_copies (op0, mode)
5746                   == GET_MODE_BITSIZE (mode)))
5747             return gen_lowpart (mode,
5748                                 expand_compound_operation (op0));
5749
5750           else if (STORE_FLAG_VALUE == -1
5751                    && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5752                    && op1 == const0_rtx
5753                    && mode == GET_MODE (op0)
5754                    && nonzero_bits (op0, mode) == 1)
5755             {
5756               op0 = expand_compound_operation (op0);
5757               return simplify_gen_unary (NEG, mode,
5758                                          gen_lowpart (mode, op0),
5759                                          mode);
5760             }
5761
5762           else if (STORE_FLAG_VALUE == -1
5763                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5764                    && op1 == const0_rtx
5765                    && mode == GET_MODE (op0)
5766                    && (num_sign_bit_copies (op0, mode)
5767                        == GET_MODE_BITSIZE (mode)))
5768             {
5769               op0 = expand_compound_operation (op0);
5770               return simplify_gen_unary (NOT, mode,
5771                                          gen_lowpart (mode, op0),
5772                                          mode);
5773             }
5774
5775           /* If X is 0/1, (eq X 0) is X-1.  */
5776           else if (STORE_FLAG_VALUE == -1
5777                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5778                    && op1 == const0_rtx
5779                    && mode == GET_MODE (op0)
5780                    && nonzero_bits (op0, mode) == 1)
5781             {
5782               op0 = expand_compound_operation (op0);
5783               return plus_constant (gen_lowpart (mode, op0), -1);
5784             }
5785
5786           /* If STORE_FLAG_VALUE says to just test the sign bit and X has just
5787              one bit that might be nonzero, we can convert (ne x 0) to
5788              (ashift x c) where C puts the bit in the sign bit.  Remove any
5789              AND with STORE_FLAG_VALUE when we are done, since we are only
5790              going to test the sign bit.  */
5791           if (new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5792               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5793               && ((STORE_FLAG_VALUE & GET_MODE_MASK (mode))
5794                   == (unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (mode) - 1))
5795               && op1 == const0_rtx
5796               && mode == GET_MODE (op0)
5797               && (i = exact_log2 (nonzero_bits (op0, mode))) >= 0)
5798             {
5799               x = simplify_shift_const (NULL_RTX, ASHIFT, mode,
5800                                         expand_compound_operation (op0),
5801                                         GET_MODE_BITSIZE (mode) - 1 - i);
5802               if (GET_CODE (x) == AND && XEXP (x, 1) == const_true_rtx)
5803                 return XEXP (x, 0);
5804               else
5805                 return x;
5806             }
5807
5808           /* If the code changed, return a whole new comparison.  */
5809           if (new_code != code)
5810             return gen_rtx_fmt_ee (new_code, mode, op0, op1);
5811
5812           /* Otherwise, keep this operation, but maybe change its operands.
5813              This also converts (ne (compare FOO BAR) 0) to (ne FOO BAR).  */
5814           SUBST (XEXP (x, 0), op0);
5815           SUBST (XEXP (x, 1), op1);
5816         }
5817       break;
5818
5819     case IF_THEN_ELSE:
5820       return simplify_if_then_else (x);
5821
5822     case ZERO_EXTRACT:
5823     case SIGN_EXTRACT:
5824     case ZERO_EXTEND:
5825     case SIGN_EXTEND:
5826       /* If we are processing SET_DEST, we are done.  */
5827       if (in_dest)
5828         return x;
5829
5830       return expand_compound_operation (x);
5831
5832     case SET:
5833       return simplify_set (x);
5834
5835     case AND:
5836     case IOR:
5837       return simplify_logical (x);
5838
5839     case ASHIFT:
5840     case LSHIFTRT:
5841     case ASHIFTRT:
5842     case ROTATE:
5843     case ROTATERT:
5844       /* If this is a shift by a constant amount, simplify it.  */
5845       if (CONST_INT_P (XEXP (x, 1)))
5846         return simplify_shift_const (x, code, mode, XEXP (x, 0),
5847                                      INTVAL (XEXP (x, 1)));
5848
5849       else if (SHIFT_COUNT_TRUNCATED && !REG_P (XEXP (x, 1)))
5850         SUBST (XEXP (x, 1),
5851                force_to_mode (XEXP (x, 1), GET_MODE (XEXP (x, 1)),
5852                               ((unsigned HOST_WIDE_INT) 1
5853                                << exact_log2 (GET_MODE_BITSIZE (GET_MODE (x))))
5854                               - 1,
5855                               0));
5856       break;
5857
5858     default:
5859       break;
5860     }
5861
5862   return x;
5863 }
5864 \f
5865 /* Simplify X, an IF_THEN_ELSE expression.  Return the new expression.  */
5866
5867 static rtx
5868 simplify_if_then_else (rtx x)
5869 {
5870   enum machine_mode mode = GET_MODE (x);
5871   rtx cond = XEXP (x, 0);
5872   rtx true_rtx = XEXP (x, 1);
5873   rtx false_rtx = XEXP (x, 2);
5874   enum rtx_code true_code = GET_CODE (cond);
5875   int comparison_p = COMPARISON_P (cond);
5876   rtx temp;
5877   int i;
5878   enum rtx_code false_code;
5879   rtx reversed;
5880
5881   /* Simplify storing of the truth value.  */
5882   if (comparison_p && true_rtx == const_true_rtx && false_rtx == const0_rtx)
5883     return simplify_gen_relational (true_code, mode, VOIDmode,
5884                                     XEXP (cond, 0), XEXP (cond, 1));
5885
5886   /* Also when the truth value has to be reversed.  */
5887   if (comparison_p
5888       && true_rtx == const0_rtx && false_rtx == const_true_rtx
5889       && (reversed = reversed_comparison (cond, mode)))
5890     return reversed;
5891
5892   /* Sometimes we can simplify the arm of an IF_THEN_ELSE if a register used
5893      in it is being compared against certain values.  Get the true and false
5894      comparisons and see if that says anything about the value of each arm.  */
5895
5896   if (comparison_p
5897       && ((false_code = reversed_comparison_code (cond, NULL))
5898           != UNKNOWN)
5899       && REG_P (XEXP (cond, 0)))
5900     {
5901       HOST_WIDE_INT nzb;
5902       rtx from = XEXP (cond, 0);
5903       rtx true_val = XEXP (cond, 1);
5904       rtx false_val = true_val;
5905       int swapped = 0;
5906
5907       /* If FALSE_CODE is EQ, swap the codes and arms.  */
5908
5909       if (false_code == EQ)
5910         {
5911           swapped = 1, true_code = EQ, false_code = NE;
5912           temp = true_rtx, true_rtx = false_rtx, false_rtx = temp;
5913         }
5914
5915       /* If we are comparing against zero and the expression being tested has
5916          only a single bit that might be nonzero, that is its value when it is
5917          not equal to zero.  Similarly if it is known to be -1 or 0.  */
5918
5919       if (true_code == EQ && true_val == const0_rtx
5920           && exact_log2 (nzb = nonzero_bits (from, GET_MODE (from))) >= 0)
5921         {
5922           false_code = EQ;
5923           false_val = GEN_INT (trunc_int_for_mode (nzb, GET_MODE (from)));
5924         }
5925       else if (true_code == EQ && true_val == const0_rtx
5926                && (num_sign_bit_copies (from, GET_MODE (from))
5927                    == GET_MODE_BITSIZE (GET_MODE (from))))
5928         {
5929           false_code = EQ;
5930           false_val = constm1_rtx;
5931         }
5932
5933       /* Now simplify an arm if we know the value of the register in the
5934          branch and it is used in the arm.  Be careful due to the potential
5935          of locally-shared RTL.  */
5936
5937       if (reg_mentioned_p (from, true_rtx))
5938         true_rtx = subst (known_cond (copy_rtx (true_rtx), true_code,
5939                                       from, true_val),
5940                       pc_rtx, pc_rtx, 0, 0);
5941       if (reg_mentioned_p (from, false_rtx))
5942         false_rtx = subst (known_cond (copy_rtx (false_rtx), false_code,
5943                                    from, false_val),
5944                        pc_rtx, pc_rtx, 0, 0);
5945
5946       SUBST (XEXP (x, 1), swapped ? false_rtx : true_rtx);
5947       SUBST (XEXP (x, 2), swapped ? true_rtx : false_rtx);
5948
5949       true_rtx = XEXP (x, 1);
5950       false_rtx = XEXP (x, 2);
5951       true_code = GET_CODE (cond);
5952     }
5953
5954   /* If we have (if_then_else FOO (pc) (label_ref BAR)) and FOO can be
5955      reversed, do so to avoid needing two sets of patterns for
5956      subtract-and-branch insns.  Similarly if we have a constant in the true
5957      arm, the false arm is the same as the first operand of the comparison, or
5958      the false arm is more complicated than the true arm.  */
5959
5960   if (comparison_p
5961       && reversed_comparison_code (cond, NULL) != UNKNOWN
5962       && (true_rtx == pc_rtx
5963           || (CONSTANT_P (true_rtx)
5964               && !CONST_INT_P (false_rtx) && false_rtx != pc_rtx)
5965           || true_rtx == const0_rtx
5966           || (OBJECT_P (true_rtx) && !OBJECT_P (false_rtx))
5967           || (GET_CODE (true_rtx) == SUBREG && OBJECT_P (SUBREG_REG (true_rtx))
5968               && !OBJECT_P (false_rtx))
5969           || reg_mentioned_p (true_rtx, false_rtx)
5970           || rtx_equal_p (false_rtx, XEXP (cond, 0))))
5971     {
5972       true_code = reversed_comparison_code (cond, NULL);
5973       SUBST (XEXP (x, 0), reversed_comparison (cond, GET_MODE (cond)));
5974       SUBST (XEXP (x, 1), false_rtx);
5975       SUBST (XEXP (x, 2), true_rtx);
5976
5977       temp = true_rtx, true_rtx = false_rtx, false_rtx = temp;
5978       cond = XEXP (x, 0);
5979
5980       /* It is possible that the conditional has been simplified out.  */
5981       true_code = GET_CODE (cond);
5982       comparison_p = COMPARISON_P (cond);
5983     }
5984
5985   /* If the two arms are identical, we don't need the comparison.  */
5986
5987   if (rtx_equal_p (true_rtx, false_rtx) && ! side_effects_p (cond))
5988     return true_rtx;
5989
5990   /* Convert a == b ? b : a to "a".  */
5991   if (true_code == EQ && ! side_effects_p (cond)
5992       && !HONOR_NANS (mode)
5993       && rtx_equal_p (XEXP (cond, 0), false_rtx)
5994       && rtx_equal_p (XEXP (cond, 1), true_rtx))
5995     return false_rtx;
5996   else if (true_code == NE && ! side_effects_p (cond)
5997            && !HONOR_NANS (mode)
5998            && rtx_equal_p (XEXP (cond, 0), true_rtx)
5999            && rtx_equal_p (XEXP (cond, 1), false_rtx))
6000     return true_rtx;
6001
6002   /* Look for cases where we have (abs x) or (neg (abs X)).  */
6003
6004   if (GET_MODE_CLASS (mode) == MODE_INT
6005       && comparison_p
6006       && XEXP (cond, 1) == const0_rtx
6007       && GET_CODE (false_rtx) == NEG
6008       && rtx_equal_p (true_rtx, XEXP (false_rtx, 0))
6009       && rtx_equal_p (true_rtx, XEXP (cond, 0))
6010       && ! side_effects_p (true_rtx))
6011     switch (true_code)
6012       {
6013       case GT:
6014       case GE:
6015         return simplify_gen_unary (ABS, mode, true_rtx, mode);
6016       case LT:
6017       case LE:
6018         return
6019           simplify_gen_unary (NEG, mode,
6020                               simplify_gen_unary (ABS, mode, true_rtx, mode),
6021                               mode);
6022       default:
6023         break;
6024       }
6025
6026   /* Look for MIN or MAX.  */
6027
6028   if ((! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations)
6029       && comparison_p
6030       && rtx_equal_p (XEXP (cond, 0), true_rtx)
6031       && rtx_equal_p (XEXP (cond, 1), false_rtx)
6032       && ! side_effects_p (cond))
6033     switch (true_code)
6034       {
6035       case GE:
6036       case GT:
6037         return simplify_gen_binary (SMAX, mode, true_rtx, false_rtx);
6038       case LE:
6039       case LT:
6040         return simplify_gen_binary (SMIN, mode, true_rtx, false_rtx);
6041       case GEU:
6042       case GTU:
6043         return simplify_gen_binary (UMAX, mode, true_rtx, false_rtx);
6044       case LEU:
6045       case LTU:
6046         return simplify_gen_binary (UMIN, mode, true_rtx, false_rtx);
6047       default:
6048         break;
6049       }
6050
6051   /* If we have (if_then_else COND (OP Z C1) Z) and OP is an identity when its
6052      second operand is zero, this can be done as (OP Z (mult COND C2)) where
6053      C2 = C1 * STORE_FLAG_VALUE. Similarly if OP has an outer ZERO_EXTEND or
6054      SIGN_EXTEND as long as Z is already extended (so we don't destroy it).
6055      We can do this kind of thing in some cases when STORE_FLAG_VALUE is
6056      neither 1 or -1, but it isn't worth checking for.  */
6057
6058   if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
6059       && comparison_p
6060       && GET_MODE_CLASS (mode) == MODE_INT
6061       && ! side_effects_p (x))
6062     {
6063       rtx t = make_compound_operation (true_rtx, SET);
6064       rtx f = make_compound_operation (false_rtx, SET);
6065       rtx cond_op0 = XEXP (cond, 0);
6066       rtx cond_op1 = XEXP (cond, 1);
6067       enum rtx_code op = UNKNOWN, extend_op = UNKNOWN;
6068       enum machine_mode m = mode;
6069       rtx z = 0, c1 = NULL_RTX;
6070
6071       if ((GET_CODE (t) == PLUS || GET_CODE (t) == MINUS
6072            || GET_CODE (t) == IOR || GET_CODE (t) == XOR
6073            || GET_CODE (t) == ASHIFT
6074            || GET_CODE (t) == LSHIFTRT || GET_CODE (t) == ASHIFTRT)
6075           && rtx_equal_p (XEXP (t, 0), f))
6076         c1 = XEXP (t, 1), op = GET_CODE (t), z = f;
6077
6078       /* If an identity-zero op is commutative, check whether there
6079          would be a match if we swapped the operands.  */
6080       else if ((GET_CODE (t) == PLUS || GET_CODE (t) == IOR
6081                 || GET_CODE (t) == XOR)
6082                && rtx_equal_p (XEXP (t, 1), f))
6083         c1 = XEXP (t, 0), op = GET_CODE (t), z = f;
6084       else if (GET_CODE (t) == SIGN_EXTEND
6085                && (GET_CODE (XEXP (t, 0)) == PLUS
6086                    || GET_CODE (XEXP (t, 0)) == MINUS
6087                    || GET_CODE (XEXP (t, 0)) == IOR
6088                    || GET_CODE (XEXP (t, 0)) == XOR
6089                    || GET_CODE (XEXP (t, 0)) == ASHIFT
6090                    || GET_CODE (XEXP (t, 0)) == LSHIFTRT
6091                    || GET_CODE (XEXP (t, 0)) == ASHIFTRT)
6092                && GET_CODE (XEXP (XEXP (t, 0), 0)) == SUBREG
6093                && subreg_lowpart_p (XEXP (XEXP (t, 0), 0))
6094                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 0)), f)
6095                && (num_sign_bit_copies (f, GET_MODE (f))
6096                    > (unsigned int)
6097                      (GET_MODE_BITSIZE (mode)
6098                       - GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (t, 0), 0))))))
6099         {
6100           c1 = XEXP (XEXP (t, 0), 1); z = f; op = GET_CODE (XEXP (t, 0));
6101           extend_op = SIGN_EXTEND;
6102           m = GET_MODE (XEXP (t, 0));
6103         }
6104       else if (GET_CODE (t) == SIGN_EXTEND
6105                && (GET_CODE (XEXP (t, 0)) == PLUS
6106                    || GET_CODE (XEXP (t, 0)) == IOR
6107                    || GET_CODE (XEXP (t, 0)) == XOR)
6108                && GET_CODE (XEXP (XEXP (t, 0), 1)) == SUBREG
6109                && subreg_lowpart_p (XEXP (XEXP (t, 0), 1))
6110                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 1)), f)
6111                && (num_sign_bit_copies (f, GET_MODE (f))
6112                    > (unsigned int)
6113                      (GET_MODE_BITSIZE (mode)
6114                       - GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (t, 0), 1))))))
6115         {
6116           c1 = XEXP (XEXP (t, 0), 0); z = f; op = GET_CODE (XEXP (t, 0));
6117           extend_op = SIGN_EXTEND;
6118           m = GET_MODE (XEXP (t, 0));
6119         }
6120       else if (GET_CODE (t) == ZERO_EXTEND
6121                && (GET_CODE (XEXP (t, 0)) == PLUS
6122                    || GET_CODE (XEXP (t, 0)) == MINUS
6123                    || GET_CODE (XEXP (t, 0)) == IOR
6124                    || GET_CODE (XEXP (t, 0)) == XOR
6125                    || GET_CODE (XEXP (t, 0)) == ASHIFT
6126                    || GET_CODE (XEXP (t, 0)) == LSHIFTRT
6127                    || GET_CODE (XEXP (t, 0)) == ASHIFTRT)
6128                && GET_CODE (XEXP (XEXP (t, 0), 0)) == SUBREG
6129                && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
6130                && subreg_lowpart_p (XEXP (XEXP (t, 0), 0))
6131                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 0)), f)
6132                && ((nonzero_bits (f, GET_MODE (f))
6133                     & ~GET_MODE_MASK (GET_MODE (XEXP (XEXP (t, 0), 0))))
6134                    == 0))
6135         {
6136           c1 = XEXP (XEXP (t, 0), 1); z = f; op = GET_CODE (XEXP (t, 0));
6137           extend_op = ZERO_EXTEND;
6138           m = GET_MODE (XEXP (t, 0));
6139         }
6140       else if (GET_CODE (t) == ZERO_EXTEND
6141                && (GET_CODE (XEXP (t, 0)) == PLUS
6142                    || GET_CODE (XEXP (t, 0)) == IOR
6143                    || GET_CODE (XEXP (t, 0)) == XOR)
6144                && GET_CODE (XEXP (XEXP (t, 0), 1)) == SUBREG
6145                && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
6146                && subreg_lowpart_p (XEXP (XEXP (t, 0), 1))
6147                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 1)), f)
6148                && ((nonzero_bits (f, GET_MODE (f))
6149                     & ~GET_MODE_MASK (GET_MODE (XEXP (XEXP (t, 0), 1))))
6150                    == 0))
6151         {
6152           c1 = XEXP (XEXP (t, 0), 0); z = f; op = GET_CODE (XEXP (t, 0));
6153           extend_op = ZERO_EXTEND;
6154           m = GET_MODE (XEXP (t, 0));
6155         }
6156
6157       if (z)
6158         {
6159           temp = subst (simplify_gen_relational (true_code, m, VOIDmode,
6160                                                  cond_op0, cond_op1),
6161                         pc_rtx, pc_rtx, 0, 0);
6162           temp = simplify_gen_binary (MULT, m, temp,
6163                                       simplify_gen_binary (MULT, m, c1,
6164                                                            const_true_rtx));
6165           temp = subst (temp, pc_rtx, pc_rtx, 0, 0);
6166           temp = simplify_gen_binary (op, m, gen_lowpart (m, z), temp);
6167
6168           if (extend_op != UNKNOWN)
6169             temp = simplify_gen_unary (extend_op, mode, temp, m);
6170
6171           return temp;
6172         }
6173     }
6174
6175   /* If we have (if_then_else (ne A 0) C1 0) and either A is known to be 0 or
6176      1 and C1 is a single bit or A is known to be 0 or -1 and C1 is the
6177      negation of a single bit, we can convert this operation to a shift.  We
6178      can actually do this more generally, but it doesn't seem worth it.  */
6179
6180   if (true_code == NE && XEXP (cond, 1) == const0_rtx
6181       && false_rtx == const0_rtx && CONST_INT_P (true_rtx)
6182       && ((1 == nonzero_bits (XEXP (cond, 0), mode)
6183            && (i = exact_log2 (UINTVAL (true_rtx))) >= 0)
6184           || ((num_sign_bit_copies (XEXP (cond, 0), mode)
6185                == GET_MODE_BITSIZE (mode))
6186               && (i = exact_log2 (-UINTVAL (true_rtx))) >= 0)))
6187     return
6188       simplify_shift_const (NULL_RTX, ASHIFT, mode,
6189                             gen_lowpart (mode, XEXP (cond, 0)), i);
6190
6191   /* (IF_THEN_ELSE (NE REG 0) (0) (8)) is REG for nonzero_bits (REG) == 8.  */
6192   if (true_code == NE && XEXP (cond, 1) == const0_rtx
6193       && false_rtx == const0_rtx && CONST_INT_P (true_rtx)
6194       && GET_MODE (XEXP (cond, 0)) == mode
6195       && (UINTVAL (true_rtx) & GET_MODE_MASK (mode))
6196           == nonzero_bits (XEXP (cond, 0), mode)
6197       && (i = exact_log2 (UINTVAL (true_rtx) & GET_MODE_MASK (mode))) >= 0)
6198     return XEXP (cond, 0);
6199
6200   return x;
6201 }
6202 \f
6203 /* Simplify X, a SET expression.  Return the new expression.  */
6204
6205 static rtx
6206 simplify_set (rtx x)
6207 {
6208   rtx src = SET_SRC (x);
6209   rtx dest = SET_DEST (x);
6210   enum machine_mode mode
6211     = GET_MODE (src) != VOIDmode ? GET_MODE (src) : GET_MODE (dest);
6212   rtx other_insn;
6213   rtx *cc_use;
6214
6215   /* (set (pc) (return)) gets written as (return).  */
6216   if (GET_CODE (dest) == PC && GET_CODE (src) == RETURN)
6217     return src;
6218
6219   /* Now that we know for sure which bits of SRC we are using, see if we can
6220      simplify the expression for the object knowing that we only need the
6221      low-order bits.  */
6222
6223   if (GET_MODE_CLASS (mode) == MODE_INT
6224       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
6225     {
6226       src = force_to_mode (src, mode, ~(unsigned HOST_WIDE_INT) 0, 0);
6227       SUBST (SET_SRC (x), src);
6228     }
6229
6230   /* If we are setting CC0 or if the source is a COMPARE, look for the use of
6231      the comparison result and try to simplify it unless we already have used
6232      undobuf.other_insn.  */
6233   if ((GET_MODE_CLASS (mode) == MODE_CC
6234        || GET_CODE (src) == COMPARE
6235        || CC0_P (dest))
6236       && (cc_use = find_single_use (dest, subst_insn, &other_insn)) != 0
6237       && (undobuf.other_insn == 0 || other_insn == undobuf.other_insn)
6238       && COMPARISON_P (*cc_use)
6239       && rtx_equal_p (XEXP (*cc_use, 0), dest))
6240     {
6241       enum rtx_code old_code = GET_CODE (*cc_use);
6242       enum rtx_code new_code;
6243       rtx op0, op1, tmp;
6244       int other_changed = 0;
6245       enum machine_mode compare_mode = GET_MODE (dest);
6246
6247       if (GET_CODE (src) == COMPARE)
6248         op0 = XEXP (src, 0), op1 = XEXP (src, 1);
6249       else
6250         op0 = src, op1 = CONST0_RTX (GET_MODE (src));
6251
6252       tmp = simplify_relational_operation (old_code, compare_mode, VOIDmode,
6253                                            op0, op1);
6254       if (!tmp)
6255         new_code = old_code;
6256       else if (!CONSTANT_P (tmp))
6257         {
6258           new_code = GET_CODE (tmp);
6259           op0 = XEXP (tmp, 0);
6260           op1 = XEXP (tmp, 1);
6261         }
6262       else
6263         {
6264           rtx pat = PATTERN (other_insn);
6265           undobuf.other_insn = other_insn;
6266           SUBST (*cc_use, tmp);
6267
6268           /* Attempt to simplify CC user.  */
6269           if (GET_CODE (pat) == SET)
6270             {
6271               rtx new_rtx = simplify_rtx (SET_SRC (pat));
6272               if (new_rtx != NULL_RTX)
6273                 SUBST (SET_SRC (pat), new_rtx);
6274             }
6275
6276           /* Convert X into a no-op move.  */
6277           SUBST (SET_DEST (x), pc_rtx);
6278           SUBST (SET_SRC (x), pc_rtx);
6279           return x;
6280         }
6281
6282       /* Simplify our comparison, if possible.  */
6283       new_code = simplify_comparison (new_code, &op0, &op1);
6284
6285 #ifdef SELECT_CC_MODE
6286       /* If this machine has CC modes other than CCmode, check to see if we
6287          need to use a different CC mode here.  */
6288       if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
6289         compare_mode = GET_MODE (op0);
6290       else
6291         compare_mode = SELECT_CC_MODE (new_code, op0, op1);
6292
6293 #ifndef HAVE_cc0
6294       /* If the mode changed, we have to change SET_DEST, the mode in the
6295          compare, and the mode in the place SET_DEST is used.  If SET_DEST is
6296          a hard register, just build new versions with the proper mode.  If it
6297          is a pseudo, we lose unless it is only time we set the pseudo, in
6298          which case we can safely change its mode.  */
6299       if (compare_mode != GET_MODE (dest))
6300         {
6301           if (can_change_dest_mode (dest, 0, compare_mode))
6302             {
6303               unsigned int regno = REGNO (dest);
6304               rtx new_dest;
6305
6306               if (regno < FIRST_PSEUDO_REGISTER)
6307                 new_dest = gen_rtx_REG (compare_mode, regno);
6308               else
6309                 {
6310                   SUBST_MODE (regno_reg_rtx[regno], compare_mode);
6311                   new_dest = regno_reg_rtx[regno];
6312                 }
6313
6314               SUBST (SET_DEST (x), new_dest);
6315               SUBST (XEXP (*cc_use, 0), new_dest);
6316               other_changed = 1;
6317
6318               dest = new_dest;
6319             }
6320         }
6321 #endif  /* cc0 */
6322 #endif  /* SELECT_CC_MODE */
6323
6324       /* If the code changed, we have to build a new comparison in
6325          undobuf.other_insn.  */
6326       if (new_code != old_code)
6327         {
6328           int other_changed_previously = other_changed;
6329           unsigned HOST_WIDE_INT mask;
6330           rtx old_cc_use = *cc_use;
6331
6332           SUBST (*cc_use, gen_rtx_fmt_ee (new_code, GET_MODE (*cc_use),
6333                                           dest, const0_rtx));
6334           other_changed = 1;
6335
6336           /* If the only change we made was to change an EQ into an NE or
6337              vice versa, OP0 has only one bit that might be nonzero, and OP1
6338              is zero, check if changing the user of the condition code will
6339              produce a valid insn.  If it won't, we can keep the original code
6340              in that insn by surrounding our operation with an XOR.  */
6341
6342           if (((old_code == NE && new_code == EQ)
6343                || (old_code == EQ && new_code == NE))
6344               && ! other_changed_previously && op1 == const0_rtx
6345               && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
6346               && exact_log2 (mask = nonzero_bits (op0, GET_MODE (op0))) >= 0)
6347             {
6348               rtx pat = PATTERN (other_insn), note = 0;
6349
6350               if ((recog_for_combine (&pat, other_insn, &note) < 0
6351                    && ! check_asm_operands (pat)))
6352                 {
6353                   *cc_use = old_cc_use;
6354                   other_changed = 0;
6355
6356                   op0 = simplify_gen_binary (XOR, GET_MODE (op0),
6357                                              op0, GEN_INT (mask));
6358                 }
6359             }
6360         }
6361
6362       if (other_changed)
6363         undobuf.other_insn = other_insn;
6364
6365       /* Otherwise, if we didn't previously have a COMPARE in the
6366          correct mode, we need one.  */
6367       if (GET_CODE (src) != COMPARE || GET_MODE (src) != compare_mode)
6368         {
6369           SUBST (SET_SRC (x), gen_rtx_COMPARE (compare_mode, op0, op1));
6370           src = SET_SRC (x);
6371         }
6372       else if (GET_MODE (op0) == compare_mode && op1 == const0_rtx)
6373         {
6374           SUBST (SET_SRC (x), op0);
6375           src = SET_SRC (x);
6376         }
6377       /* Otherwise, update the COMPARE if needed.  */
6378       else if (XEXP (src, 0) != op0 || XEXP (src, 1) != op1)
6379         {
6380           SUBST (SET_SRC (x), gen_rtx_COMPARE (compare_mode, op0, op1));
6381           src = SET_SRC (x);
6382         }
6383     }
6384   else
6385     {
6386       /* Get SET_SRC in a form where we have placed back any
6387          compound expressions.  Then do the checks below.  */
6388       src = make_compound_operation (src, SET);
6389       SUBST (SET_SRC (x), src);
6390     }
6391
6392   /* If we have (set x (subreg:m1 (op:m2 ...) 0)) with OP being some operation,
6393      and X being a REG or (subreg (reg)), we may be able to convert this to
6394      (set (subreg:m2 x) (op)).
6395
6396      We can always do this if M1 is narrower than M2 because that means that
6397      we only care about the low bits of the result.
6398
6399      However, on machines without WORD_REGISTER_OPERATIONS defined, we cannot
6400      perform a narrower operation than requested since the high-order bits will
6401      be undefined.  On machine where it is defined, this transformation is safe
6402      as long as M1 and M2 have the same number of words.  */
6403
6404   if (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)
6405       && !OBJECT_P (SUBREG_REG (src))
6406       && (((GET_MODE_SIZE (GET_MODE (src)) + (UNITS_PER_WORD - 1))
6407            / UNITS_PER_WORD)
6408           == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (src)))
6409                + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
6410 #ifndef WORD_REGISTER_OPERATIONS
6411       && (GET_MODE_SIZE (GET_MODE (src))
6412         < GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))
6413 #endif
6414 #ifdef CANNOT_CHANGE_MODE_CLASS
6415       && ! (REG_P (dest) && REGNO (dest) < FIRST_PSEUDO_REGISTER
6416             && REG_CANNOT_CHANGE_MODE_P (REGNO (dest),
6417                                          GET_MODE (SUBREG_REG (src)),
6418                                          GET_MODE (src)))
6419 #endif
6420       && (REG_P (dest)
6421           || (GET_CODE (dest) == SUBREG
6422               && REG_P (SUBREG_REG (dest)))))
6423     {
6424       SUBST (SET_DEST (x),
6425              gen_lowpart (GET_MODE (SUBREG_REG (src)),
6426                                       dest));
6427       SUBST (SET_SRC (x), SUBREG_REG (src));
6428
6429       src = SET_SRC (x), dest = SET_DEST (x);
6430     }
6431
6432 #ifdef HAVE_cc0
6433   /* If we have (set (cc0) (subreg ...)), we try to remove the subreg
6434      in SRC.  */
6435   if (dest == cc0_rtx
6436       && GET_CODE (src) == SUBREG
6437       && subreg_lowpart_p (src)
6438       && (GET_MODE_BITSIZE (GET_MODE (src))
6439           < GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (src)))))
6440     {
6441       rtx inner = SUBREG_REG (src);
6442       enum machine_mode inner_mode = GET_MODE (inner);
6443
6444       /* Here we make sure that we don't have a sign bit on.  */
6445       if (GET_MODE_BITSIZE (inner_mode) <= HOST_BITS_PER_WIDE_INT
6446           && (nonzero_bits (inner, inner_mode)
6447               < ((unsigned HOST_WIDE_INT) 1
6448                  << (GET_MODE_BITSIZE (GET_MODE (src)) - 1))))
6449         {
6450           SUBST (SET_SRC (x), inner);
6451           src = SET_SRC (x);
6452         }
6453     }
6454 #endif
6455
6456 #ifdef LOAD_EXTEND_OP
6457   /* If we have (set FOO (subreg:M (mem:N BAR) 0)) with M wider than N, this
6458      would require a paradoxical subreg.  Replace the subreg with a
6459      zero_extend to avoid the reload that would otherwise be required.  */
6460
6461   if (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)
6462       && INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (src)))
6463       && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (src))) != UNKNOWN
6464       && SUBREG_BYTE (src) == 0
6465       && (GET_MODE_SIZE (GET_MODE (src))
6466           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))
6467       && MEM_P (SUBREG_REG (src)))
6468     {
6469       SUBST (SET_SRC (x),
6470              gen_rtx_fmt_e (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (src))),
6471                             GET_MODE (src), SUBREG_REG (src)));
6472
6473       src = SET_SRC (x);
6474     }
6475 #endif
6476
6477   /* If we don't have a conditional move, SET_SRC is an IF_THEN_ELSE, and we
6478      are comparing an item known to be 0 or -1 against 0, use a logical
6479      operation instead. Check for one of the arms being an IOR of the other
6480      arm with some value.  We compute three terms to be IOR'ed together.  In
6481      practice, at most two will be nonzero.  Then we do the IOR's.  */
6482
6483   if (GET_CODE (dest) != PC
6484       && GET_CODE (src) == IF_THEN_ELSE
6485       && GET_MODE_CLASS (GET_MODE (src)) == MODE_INT
6486       && (GET_CODE (XEXP (src, 0)) == EQ || GET_CODE (XEXP (src, 0)) == NE)
6487       && XEXP (XEXP (src, 0), 1) == const0_rtx
6488       && GET_MODE (src) == GET_MODE (XEXP (XEXP (src, 0), 0))
6489 #ifdef HAVE_conditional_move
6490       && ! can_conditionally_move_p (GET_MODE (src))
6491 #endif
6492       && (num_sign_bit_copies (XEXP (XEXP (src, 0), 0),
6493                                GET_MODE (XEXP (XEXP (src, 0), 0)))
6494           == GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (src, 0), 0))))
6495       && ! side_effects_p (src))
6496     {
6497       rtx true_rtx = (GET_CODE (XEXP (src, 0)) == NE
6498                       ? XEXP (src, 1) : XEXP (src, 2));
6499       rtx false_rtx = (GET_CODE (XEXP (src, 0)) == NE
6500                    ? XEXP (src, 2) : XEXP (src, 1));
6501       rtx term1 = const0_rtx, term2, term3;
6502
6503       if (GET_CODE (true_rtx) == IOR
6504           && rtx_equal_p (XEXP (true_rtx, 0), false_rtx))
6505         term1 = false_rtx, true_rtx = XEXP (true_rtx, 1), false_rtx = const0_rtx;
6506       else if (GET_CODE (true_rtx) == IOR
6507                && rtx_equal_p (XEXP (true_rtx, 1), false_rtx))
6508         term1 = false_rtx, true_rtx = XEXP (true_rtx, 0), false_rtx = const0_rtx;
6509       else if (GET_CODE (false_rtx) == IOR
6510                && rtx_equal_p (XEXP (false_rtx, 0), true_rtx))
6511         term1 = true_rtx, false_rtx = XEXP (false_rtx, 1), true_rtx = const0_rtx;
6512       else if (GET_CODE (false_rtx) == IOR
6513                && rtx_equal_p (XEXP (false_rtx, 1), true_rtx))
6514         term1 = true_rtx, false_rtx = XEXP (false_rtx, 0), true_rtx = const0_rtx;
6515
6516       term2 = simplify_gen_binary (AND, GET_MODE (src),
6517                                    XEXP (XEXP (src, 0), 0), true_rtx);
6518       term3 = simplify_gen_binary (AND, GET_MODE (src),
6519                                    simplify_gen_unary (NOT, GET_MODE (src),
6520                                                        XEXP (XEXP (src, 0), 0),
6521                                                        GET_MODE (src)),
6522                                    false_rtx);
6523
6524       SUBST (SET_SRC (x),
6525              simplify_gen_binary (IOR, GET_MODE (src),
6526                                   simplify_gen_binary (IOR, GET_MODE (src),
6527                                                        term1, term2),
6528                                   term3));
6529
6530       src = SET_SRC (x);
6531     }
6532
6533   /* If either SRC or DEST is a CLOBBER of (const_int 0), make this
6534      whole thing fail.  */
6535   if (GET_CODE (src) == CLOBBER && XEXP (src, 0) == const0_rtx)
6536     return src;
6537   else if (GET_CODE (dest) == CLOBBER && XEXP (dest, 0) == const0_rtx)
6538     return dest;
6539   else
6540     /* Convert this into a field assignment operation, if possible.  */
6541     return make_field_assignment (x);
6542 }
6543 \f
6544 /* Simplify, X, and AND, IOR, or XOR operation, and return the simplified
6545    result.  */
6546
6547 static rtx
6548 simplify_logical (rtx x)
6549 {
6550   enum machine_mode mode = GET_MODE (x);
6551   rtx op0 = XEXP (x, 0);
6552   rtx op1 = XEXP (x, 1);
6553
6554   switch (GET_CODE (x))
6555     {
6556     case AND:
6557       /* We can call simplify_and_const_int only if we don't lose
6558          any (sign) bits when converting INTVAL (op1) to
6559          "unsigned HOST_WIDE_INT".  */
6560       if (CONST_INT_P (op1)
6561           && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
6562               || INTVAL (op1) > 0))
6563         {
6564           x = simplify_and_const_int (x, mode, op0, INTVAL (op1));
6565           if (GET_CODE (x) != AND)
6566             return x;
6567
6568           op0 = XEXP (x, 0);
6569           op1 = XEXP (x, 1);
6570         }
6571
6572       /* If we have any of (and (ior A B) C) or (and (xor A B) C),
6573          apply the distributive law and then the inverse distributive
6574          law to see if things simplify.  */
6575       if (GET_CODE (op0) == IOR || GET_CODE (op0) == XOR)
6576         {
6577           rtx result = distribute_and_simplify_rtx (x, 0);
6578           if (result)
6579             return result;
6580         }
6581       if (GET_CODE (op1) == IOR || GET_CODE (op1) == XOR)
6582         {
6583           rtx result = distribute_and_simplify_rtx (x, 1);
6584           if (result)
6585             return result;
6586         }
6587       break;
6588
6589     case IOR:
6590       /* If we have (ior (and A B) C), apply the distributive law and then
6591          the inverse distributive law to see if things simplify.  */
6592
6593       if (GET_CODE (op0) == AND)
6594         {
6595           rtx result = distribute_and_simplify_rtx (x, 0);
6596           if (result)
6597             return result;
6598         }
6599
6600       if (GET_CODE (op1) == AND)
6601         {
6602           rtx result = distribute_and_simplify_rtx (x, 1);
6603           if (result)
6604             return result;
6605         }
6606       break;
6607
6608     default:
6609       gcc_unreachable ();
6610     }
6611
6612   return x;
6613 }
6614 \f
6615 /* We consider ZERO_EXTRACT, SIGN_EXTRACT, and SIGN_EXTEND as "compound
6616    operations" because they can be replaced with two more basic operations.
6617    ZERO_EXTEND is also considered "compound" because it can be replaced with
6618    an AND operation, which is simpler, though only one operation.
6619
6620    The function expand_compound_operation is called with an rtx expression
6621    and will convert it to the appropriate shifts and AND operations,
6622    simplifying at each stage.
6623
6624    The function make_compound_operation is called to convert an expression
6625    consisting of shifts and ANDs into the equivalent compound expression.
6626    It is the inverse of this function, loosely speaking.  */
6627
6628 static rtx
6629 expand_compound_operation (rtx x)
6630 {
6631   unsigned HOST_WIDE_INT pos = 0, len;
6632   int unsignedp = 0;
6633   unsigned int modewidth;
6634   rtx tem;
6635
6636   switch (GET_CODE (x))
6637     {
6638     case ZERO_EXTEND:
6639       unsignedp = 1;
6640     case SIGN_EXTEND:
6641       /* We can't necessarily use a const_int for a multiword mode;
6642          it depends on implicitly extending the value.
6643          Since we don't know the right way to extend it,
6644          we can't tell whether the implicit way is right.
6645
6646          Even for a mode that is no wider than a const_int,
6647          we can't win, because we need to sign extend one of its bits through
6648          the rest of it, and we don't know which bit.  */
6649       if (CONST_INT_P (XEXP (x, 0)))
6650         return x;
6651
6652       /* Return if (subreg:MODE FROM 0) is not a safe replacement for
6653          (zero_extend:MODE FROM) or (sign_extend:MODE FROM).  It is for any MEM
6654          because (SUBREG (MEM...)) is guaranteed to cause the MEM to be
6655          reloaded. If not for that, MEM's would very rarely be safe.
6656
6657          Reject MODEs bigger than a word, because we might not be able
6658          to reference a two-register group starting with an arbitrary register
6659          (and currently gen_lowpart might crash for a SUBREG).  */
6660
6661       if (GET_MODE_SIZE (GET_MODE (XEXP (x, 0))) > UNITS_PER_WORD)
6662         return x;
6663
6664       /* Reject MODEs that aren't scalar integers because turning vector
6665          or complex modes into shifts causes problems.  */
6666
6667       if (! SCALAR_INT_MODE_P (GET_MODE (XEXP (x, 0))))
6668         return x;
6669
6670       len = GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)));
6671       /* If the inner object has VOIDmode (the only way this can happen
6672          is if it is an ASM_OPERANDS), we can't do anything since we don't
6673          know how much masking to do.  */
6674       if (len == 0)
6675         return x;
6676
6677       break;
6678
6679     case ZERO_EXTRACT:
6680       unsignedp = 1;
6681
6682       /* ... fall through ...  */
6683
6684     case SIGN_EXTRACT:
6685       /* If the operand is a CLOBBER, just return it.  */
6686       if (GET_CODE (XEXP (x, 0)) == CLOBBER)
6687         return XEXP (x, 0);
6688
6689       if (!CONST_INT_P (XEXP (x, 1))
6690           || !CONST_INT_P (XEXP (x, 2))
6691           || GET_MODE (XEXP (x, 0)) == VOIDmode)
6692         return x;
6693
6694       /* Reject MODEs that aren't scalar integers because turning vector
6695          or complex modes into shifts causes problems.  */
6696
6697       if (! SCALAR_INT_MODE_P (GET_MODE (XEXP (x, 0))))
6698         return x;
6699
6700       len = INTVAL (XEXP (x, 1));
6701       pos = INTVAL (XEXP (x, 2));
6702
6703       /* This should stay within the object being extracted, fail otherwise.  */
6704       if (len + pos > GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))))
6705         return x;
6706
6707       if (BITS_BIG_ENDIAN)
6708         pos = GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - len - pos;
6709
6710       break;
6711
6712     default:
6713       return x;
6714     }
6715   /* Convert sign extension to zero extension, if we know that the high
6716      bit is not set, as this is easier to optimize.  It will be converted
6717      back to cheaper alternative in make_extraction.  */
6718   if (GET_CODE (x) == SIGN_EXTEND
6719       && (GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
6720           && ((nonzero_bits (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
6721                 & ~(((unsigned HOST_WIDE_INT)
6722                       GET_MODE_MASK (GET_MODE (XEXP (x, 0))))
6723                      >> 1))
6724                == 0)))
6725     {
6726       rtx temp = gen_rtx_ZERO_EXTEND (GET_MODE (x), XEXP (x, 0));
6727       rtx temp2 = expand_compound_operation (temp);
6728
6729       /* Make sure this is a profitable operation.  */
6730       if (rtx_cost (x, SET, optimize_this_for_speed_p)
6731           > rtx_cost (temp2, SET, optimize_this_for_speed_p))
6732        return temp2;
6733       else if (rtx_cost (x, SET, optimize_this_for_speed_p)
6734                > rtx_cost (temp, SET, optimize_this_for_speed_p))
6735        return temp;
6736       else
6737        return x;
6738     }
6739
6740   /* We can optimize some special cases of ZERO_EXTEND.  */
6741   if (GET_CODE (x) == ZERO_EXTEND)
6742     {
6743       /* (zero_extend:DI (truncate:SI foo:DI)) is just foo:DI if we
6744          know that the last value didn't have any inappropriate bits
6745          set.  */
6746       if (GET_CODE (XEXP (x, 0)) == TRUNCATE
6747           && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
6748           && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
6749           && (nonzero_bits (XEXP (XEXP (x, 0), 0), GET_MODE (x))
6750               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6751         return XEXP (XEXP (x, 0), 0);
6752
6753       /* Likewise for (zero_extend:DI (subreg:SI foo:DI 0)).  */
6754       if (GET_CODE (XEXP (x, 0)) == SUBREG
6755           && GET_MODE (SUBREG_REG (XEXP (x, 0))) == GET_MODE (x)
6756           && subreg_lowpart_p (XEXP (x, 0))
6757           && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
6758           && (nonzero_bits (SUBREG_REG (XEXP (x, 0)), GET_MODE (x))
6759               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6760         return SUBREG_REG (XEXP (x, 0));
6761
6762       /* (zero_extend:DI (truncate:SI foo:DI)) is just foo:DI when foo
6763          is a comparison and STORE_FLAG_VALUE permits.  This is like
6764          the first case, but it works even when GET_MODE (x) is larger
6765          than HOST_WIDE_INT.  */
6766       if (GET_CODE (XEXP (x, 0)) == TRUNCATE
6767           && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
6768           && COMPARISON_P (XEXP (XEXP (x, 0), 0))
6769           && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
6770               <= HOST_BITS_PER_WIDE_INT)
6771           && (STORE_FLAG_VALUE & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6772         return XEXP (XEXP (x, 0), 0);
6773
6774       /* Likewise for (zero_extend:DI (subreg:SI foo:DI 0)).  */
6775       if (GET_CODE (XEXP (x, 0)) == SUBREG
6776           && GET_MODE (SUBREG_REG (XEXP (x, 0))) == GET_MODE (x)
6777           && subreg_lowpart_p (XEXP (x, 0))
6778           && COMPARISON_P (SUBREG_REG (XEXP (x, 0)))
6779           && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
6780               <= HOST_BITS_PER_WIDE_INT)
6781           && (STORE_FLAG_VALUE & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6782         return SUBREG_REG (XEXP (x, 0));
6783
6784     }
6785
6786   /* If we reach here, we want to return a pair of shifts.  The inner
6787      shift is a left shift of BITSIZE - POS - LEN bits.  The outer
6788      shift is a right shift of BITSIZE - LEN bits.  It is arithmetic or
6789      logical depending on the value of UNSIGNEDP.
6790
6791      If this was a ZERO_EXTEND or ZERO_EXTRACT, this pair of shifts will be
6792      converted into an AND of a shift.
6793
6794      We must check for the case where the left shift would have a negative
6795      count.  This can happen in a case like (x >> 31) & 255 on machines
6796      that can't shift by a constant.  On those machines, we would first
6797      combine the shift with the AND to produce a variable-position
6798      extraction.  Then the constant of 31 would be substituted in
6799      to produce such a position.  */
6800
6801   modewidth = GET_MODE_BITSIZE (GET_MODE (x));
6802   if (modewidth >= pos + len)
6803     {
6804       enum machine_mode mode = GET_MODE (x);
6805       tem = gen_lowpart (mode, XEXP (x, 0));
6806       if (!tem || GET_CODE (tem) == CLOBBER)
6807         return x;
6808       tem = simplify_shift_const (NULL_RTX, ASHIFT, mode,
6809                                   tem, modewidth - pos - len);
6810       tem = simplify_shift_const (NULL_RTX, unsignedp ? LSHIFTRT : ASHIFTRT,
6811                                   mode, tem, modewidth - len);
6812     }
6813   else if (unsignedp && len < HOST_BITS_PER_WIDE_INT)
6814     tem = simplify_and_const_int (NULL_RTX, GET_MODE (x),
6815                                   simplify_shift_const (NULL_RTX, LSHIFTRT,
6816                                                         GET_MODE (x),
6817                                                         XEXP (x, 0), pos),
6818                                   ((unsigned HOST_WIDE_INT) 1 << len) - 1);
6819   else
6820     /* Any other cases we can't handle.  */
6821     return x;
6822
6823   /* If we couldn't do this for some reason, return the original
6824      expression.  */
6825   if (GET_CODE (tem) == CLOBBER)
6826     return x;
6827
6828   return tem;
6829 }
6830 \f
6831 /* X is a SET which contains an assignment of one object into
6832    a part of another (such as a bit-field assignment, STRICT_LOW_PART,
6833    or certain SUBREGS). If possible, convert it into a series of
6834    logical operations.
6835
6836    We half-heartedly support variable positions, but do not at all
6837    support variable lengths.  */
6838
6839 static const_rtx
6840 expand_field_assignment (const_rtx x)
6841 {
6842   rtx inner;
6843   rtx pos;                      /* Always counts from low bit.  */
6844   int len;
6845   rtx mask, cleared, masked;
6846   enum machine_mode compute_mode;
6847
6848   /* Loop until we find something we can't simplify.  */
6849   while (1)
6850     {
6851       if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART
6852           && GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG)
6853         {
6854           inner = SUBREG_REG (XEXP (SET_DEST (x), 0));
6855           len = GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)));
6856           pos = GEN_INT (subreg_lsb (XEXP (SET_DEST (x), 0)));
6857         }
6858       else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
6859                && CONST_INT_P (XEXP (SET_DEST (x), 1)))
6860         {
6861           inner = XEXP (SET_DEST (x), 0);
6862           len = INTVAL (XEXP (SET_DEST (x), 1));
6863           pos = XEXP (SET_DEST (x), 2);
6864
6865           /* A constant position should stay within the width of INNER.  */
6866           if (CONST_INT_P (pos)
6867               && INTVAL (pos) + len > GET_MODE_BITSIZE (GET_MODE (inner)))
6868             break;
6869
6870           if (BITS_BIG_ENDIAN)
6871             {
6872               if (CONST_INT_P (pos))
6873                 pos = GEN_INT (GET_MODE_BITSIZE (GET_MODE (inner)) - len
6874                                - INTVAL (pos));
6875               else if (GET_CODE (pos) == MINUS
6876                        && CONST_INT_P (XEXP (pos, 1))
6877                        && (INTVAL (XEXP (pos, 1))
6878                            == GET_MODE_BITSIZE (GET_MODE (inner)) - len))
6879                 /* If position is ADJUST - X, new position is X.  */
6880                 pos = XEXP (pos, 0);
6881               else
6882                 pos = simplify_gen_binary (MINUS, GET_MODE (pos),
6883                                            GEN_INT (GET_MODE_BITSIZE (
6884                                                     GET_MODE (inner))
6885                                                     - len),
6886                                            pos);
6887             }
6888         }
6889
6890       /* A SUBREG between two modes that occupy the same numbers of words
6891          can be done by moving the SUBREG to the source.  */
6892       else if (GET_CODE (SET_DEST (x)) == SUBREG
6893                /* We need SUBREGs to compute nonzero_bits properly.  */
6894                && nonzero_sign_valid
6895                && (((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
6896                      + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
6897                    == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
6898                         + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
6899         {
6900           x = gen_rtx_SET (VOIDmode, SUBREG_REG (SET_DEST (x)),
6901                            gen_lowpart
6902                            (GET_MODE (SUBREG_REG (SET_DEST (x))),
6903                             SET_SRC (x)));
6904           continue;
6905         }
6906       else
6907         break;
6908
6909       while (GET_CODE (inner) == SUBREG && subreg_lowpart_p (inner))
6910         inner = SUBREG_REG (inner);
6911
6912       compute_mode = GET_MODE (inner);
6913
6914       /* Don't attempt bitwise arithmetic on non scalar integer modes.  */
6915       if (! SCALAR_INT_MODE_P (compute_mode))
6916         {
6917           enum machine_mode imode;
6918
6919           /* Don't do anything for vector or complex integral types.  */
6920           if (! FLOAT_MODE_P (compute_mode))
6921             break;
6922
6923           /* Try to find an integral mode to pun with.  */
6924           imode = mode_for_size (GET_MODE_BITSIZE (compute_mode), MODE_INT, 0);
6925           if (imode == BLKmode)
6926             break;
6927
6928           compute_mode = imode;
6929           inner = gen_lowpart (imode, inner);
6930         }
6931
6932       /* Compute a mask of LEN bits, if we can do this on the host machine.  */
6933       if (len >= HOST_BITS_PER_WIDE_INT)
6934         break;
6935
6936       /* Now compute the equivalent expression.  Make a copy of INNER
6937          for the SET_DEST in case it is a MEM into which we will substitute;
6938          we don't want shared RTL in that case.  */
6939       mask = GEN_INT (((unsigned HOST_WIDE_INT) 1 << len) - 1);
6940       cleared = simplify_gen_binary (AND, compute_mode,
6941                                      simplify_gen_unary (NOT, compute_mode,
6942                                        simplify_gen_binary (ASHIFT,
6943                                                             compute_mode,
6944                                                             mask, pos),
6945                                        compute_mode),
6946                                      inner);
6947       masked = simplify_gen_binary (ASHIFT, compute_mode,
6948                                     simplify_gen_binary (
6949                                       AND, compute_mode,
6950                                       gen_lowpart (compute_mode, SET_SRC (x)),
6951                                       mask),
6952                                     pos);
6953
6954       x = gen_rtx_SET (VOIDmode, copy_rtx (inner),
6955                        simplify_gen_binary (IOR, compute_mode,
6956                                             cleared, masked));
6957     }
6958
6959   return x;
6960 }
6961 \f
6962 /* Return an RTX for a reference to LEN bits of INNER.  If POS_RTX is nonzero,
6963    it is an RTX that represents a variable starting position; otherwise,
6964    POS is the (constant) starting bit position (counted from the LSB).
6965
6966    UNSIGNEDP is nonzero for an unsigned reference and zero for a
6967    signed reference.
6968
6969    IN_DEST is nonzero if this is a reference in the destination of a
6970    SET.  This is used when a ZERO_ or SIGN_EXTRACT isn't needed.  If nonzero,
6971    a STRICT_LOW_PART will be used, if zero, ZERO_EXTEND or SIGN_EXTEND will
6972    be used.
6973
6974    IN_COMPARE is nonzero if we are in a COMPARE.  This means that a
6975    ZERO_EXTRACT should be built even for bits starting at bit 0.
6976
6977    MODE is the desired mode of the result (if IN_DEST == 0).
6978
6979    The result is an RTX for the extraction or NULL_RTX if the target
6980    can't handle it.  */
6981
6982 static rtx
6983 make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
6984                  rtx pos_rtx, unsigned HOST_WIDE_INT len, int unsignedp,
6985                  int in_dest, int in_compare)
6986 {
6987   /* This mode describes the size of the storage area
6988      to fetch the overall value from.  Within that, we
6989      ignore the POS lowest bits, etc.  */
6990   enum machine_mode is_mode = GET_MODE (inner);
6991   enum machine_mode inner_mode;
6992   enum machine_mode wanted_inner_mode;
6993   enum machine_mode wanted_inner_reg_mode = word_mode;
6994   enum machine_mode pos_mode = word_mode;
6995   enum machine_mode extraction_mode = word_mode;
6996   enum machine_mode tmode = mode_for_size (len, MODE_INT, 1);
6997   rtx new_rtx = 0;
6998   rtx orig_pos_rtx = pos_rtx;
6999   HOST_WIDE_INT orig_pos;
7000
7001   if (GET_CODE (inner) == SUBREG && subreg_lowpart_p (inner))
7002     {
7003       /* If going from (subreg:SI (mem:QI ...)) to (mem:QI ...),
7004          consider just the QI as the memory to extract from.
7005          The subreg adds or removes high bits; its mode is
7006          irrelevant to the meaning of this extraction,
7007          since POS and LEN count from the lsb.  */
7008       if (MEM_P (SUBREG_REG (inner)))
7009         is_mode = GET_MODE (SUBREG_REG (inner));
7010       inner = SUBREG_REG (inner);
7011     }
7012   else if (GET_CODE (inner) == ASHIFT
7013            && CONST_INT_P (XEXP (inner, 1))
7014            && pos_rtx == 0 && pos == 0
7015            && len > UINTVAL (XEXP (inner, 1)))
7016     {
7017       /* We're extracting the least significant bits of an rtx
7018          (ashift X (const_int C)), where LEN > C.  Extract the
7019          least significant (LEN - C) bits of X, giving an rtx
7020          whose mode is MODE, then shift it left C times.  */
7021       new_rtx = make_extraction (mode, XEXP (inner, 0),
7022                              0, 0, len - INTVAL (XEXP (inner, 1)),
7023                              unsignedp, in_dest, in_compare);
7024       if (new_rtx != 0)
7025         return gen_rtx_ASHIFT (mode, new_rtx, XEXP (inner, 1));
7026     }
7027
7028   inner_mode = GET_MODE (inner);
7029
7030   if (pos_rtx && CONST_INT_P (pos_rtx))
7031     pos = INTVAL (pos_rtx), pos_rtx = 0;
7032
7033   /* See if this can be done without an extraction.  We never can if the
7034      width of the field is not the same as that of some integer mode. For
7035      registers, we can only avoid the extraction if the position is at the
7036      low-order bit and this is either not in the destination or we have the
7037      appropriate STRICT_LOW_PART operation available.
7038
7039      For MEM, we can avoid an extract if the field starts on an appropriate
7040      boundary and we can change the mode of the memory reference.  */
7041
7042   if (tmode != BLKmode
7043       && ((pos_rtx == 0 && (pos % BITS_PER_WORD) == 0
7044            && !MEM_P (inner)
7045            && (inner_mode == tmode
7046                || !REG_P (inner)
7047                || TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (tmode),
7048                                          GET_MODE_BITSIZE (inner_mode))
7049                || reg_truncated_to_mode (tmode, inner))
7050            && (! in_dest
7051                || (REG_P (inner)
7052                    && have_insn_for (STRICT_LOW_PART, tmode))))
7053           || (MEM_P (inner) && pos_rtx == 0
7054               && (pos
7055                   % (STRICT_ALIGNMENT ? GET_MODE_ALIGNMENT (tmode)
7056                      : BITS_PER_UNIT)) == 0
7057               /* We can't do this if we are widening INNER_MODE (it
7058                  may not be aligned, for one thing).  */
7059               && GET_MODE_BITSIZE (inner_mode) >= GET_MODE_BITSIZE (tmode)
7060               && (inner_mode == tmode
7061                   || (! mode_dependent_address_p (XEXP (inner, 0))
7062                       && ! MEM_VOLATILE_P (inner))))))
7063     {
7064       /* If INNER is a MEM, make a new MEM that encompasses just the desired
7065          field.  If the original and current mode are the same, we need not
7066          adjust the offset.  Otherwise, we do if bytes big endian.
7067
7068          If INNER is not a MEM, get a piece consisting of just the field
7069          of interest (in this case POS % BITS_PER_WORD must be 0).  */
7070
7071       if (MEM_P (inner))
7072         {
7073           HOST_WIDE_INT offset;
7074
7075           /* POS counts from lsb, but make OFFSET count in memory order.  */
7076           if (BYTES_BIG_ENDIAN)
7077             offset = (GET_MODE_BITSIZE (is_mode) - len - pos) / BITS_PER_UNIT;
7078           else
7079             offset = pos / BITS_PER_UNIT;
7080
7081           new_rtx = adjust_address_nv (inner, tmode, offset);
7082         }
7083       else if (REG_P (inner))
7084         {
7085           if (tmode != inner_mode)
7086             {
7087               /* We can't call gen_lowpart in a DEST since we
7088                  always want a SUBREG (see below) and it would sometimes
7089                  return a new hard register.  */
7090               if (pos || in_dest)
7091                 {
7092                   HOST_WIDE_INT final_word = pos / BITS_PER_WORD;
7093
7094                   if (WORDS_BIG_ENDIAN
7095                       && GET_MODE_SIZE (inner_mode) > UNITS_PER_WORD)
7096                     final_word = ((GET_MODE_SIZE (inner_mode)
7097                                    - GET_MODE_SIZE (tmode))
7098                                   / UNITS_PER_WORD) - final_word;
7099
7100                   final_word *= UNITS_PER_WORD;
7101                   if (BYTES_BIG_ENDIAN &&
7102                       GET_MODE_SIZE (inner_mode) > GET_MODE_SIZE (tmode))
7103                     final_word += (GET_MODE_SIZE (inner_mode)
7104                                    - GET_MODE_SIZE (tmode)) % UNITS_PER_WORD;
7105
7106                   /* Avoid creating invalid subregs, for example when
7107                      simplifying (x>>32)&255.  */
7108                   if (!validate_subreg (tmode, inner_mode, inner, final_word))
7109                     return NULL_RTX;
7110
7111                   new_rtx = gen_rtx_SUBREG (tmode, inner, final_word);
7112                 }
7113               else
7114                 new_rtx = gen_lowpart (tmode, inner);
7115             }
7116           else
7117             new_rtx = inner;
7118         }
7119       else
7120         new_rtx = force_to_mode (inner, tmode,
7121                              len >= HOST_BITS_PER_WIDE_INT
7122                              ? ~(unsigned HOST_WIDE_INT) 0
7123                              : ((unsigned HOST_WIDE_INT) 1 << len) - 1,
7124                              0);
7125
7126       /* If this extraction is going into the destination of a SET,
7127          make a STRICT_LOW_PART unless we made a MEM.  */
7128
7129       if (in_dest)
7130         return (MEM_P (new_rtx) ? new_rtx
7131                 : (GET_CODE (new_rtx) != SUBREG
7132                    ? gen_rtx_CLOBBER (tmode, const0_rtx)
7133                    : gen_rtx_STRICT_LOW_PART (VOIDmode, new_rtx)));
7134
7135       if (mode == tmode)
7136         return new_rtx;
7137
7138       if (CONST_INT_P (new_rtx)
7139           || GET_CODE (new_rtx) == CONST_DOUBLE)
7140         return simplify_unary_operation (unsignedp ? ZERO_EXTEND : SIGN_EXTEND,
7141                                          mode, new_rtx, tmode);
7142
7143       /* If we know that no extraneous bits are set, and that the high
7144          bit is not set, convert the extraction to the cheaper of
7145          sign and zero extension, that are equivalent in these cases.  */
7146       if (flag_expensive_optimizations
7147           && (GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT
7148               && ((nonzero_bits (new_rtx, tmode)
7149                    & ~(((unsigned HOST_WIDE_INT)
7150                         GET_MODE_MASK (tmode))
7151                        >> 1))
7152                   == 0)))
7153         {
7154           rtx temp = gen_rtx_ZERO_EXTEND (mode, new_rtx);
7155           rtx temp1 = gen_rtx_SIGN_EXTEND (mode, new_rtx);
7156
7157           /* Prefer ZERO_EXTENSION, since it gives more information to
7158              backends.  */
7159           if (rtx_cost (temp, SET, optimize_this_for_speed_p)
7160               <= rtx_cost (temp1, SET, optimize_this_for_speed_p))
7161             return temp;
7162           return temp1;
7163         }
7164
7165       /* Otherwise, sign- or zero-extend unless we already are in the
7166          proper mode.  */
7167
7168       return (gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND,
7169                              mode, new_rtx));
7170     }
7171
7172   /* Unless this is a COMPARE or we have a funny memory reference,
7173      don't do anything with zero-extending field extracts starting at
7174      the low-order bit since they are simple AND operations.  */
7175   if (pos_rtx == 0 && pos == 0 && ! in_dest
7176       && ! in_compare && unsignedp)
7177     return 0;
7178
7179   /* Unless INNER is not MEM, reject this if we would be spanning bytes or
7180      if the position is not a constant and the length is not 1.  In all
7181      other cases, we would only be going outside our object in cases when
7182      an original shift would have been undefined.  */
7183   if (MEM_P (inner)
7184       && ((pos_rtx == 0 && pos + len > GET_MODE_BITSIZE (is_mode))
7185           || (pos_rtx != 0 && len != 1)))
7186     return 0;
7187
7188   /* Get the mode to use should INNER not be a MEM, the mode for the position,
7189      and the mode for the result.  */
7190   if (in_dest && mode_for_extraction (EP_insv, -1) != MAX_MACHINE_MODE)
7191     {
7192       wanted_inner_reg_mode = mode_for_extraction (EP_insv, 0);
7193       pos_mode = mode_for_extraction (EP_insv, 2);
7194       extraction_mode = mode_for_extraction (EP_insv, 3);
7195     }
7196
7197   if (! in_dest && unsignedp
7198       && mode_for_extraction (EP_extzv, -1) != MAX_MACHINE_MODE)
7199     {
7200       wanted_inner_reg_mode = mode_for_extraction (EP_extzv, 1);
7201       pos_mode = mode_for_extraction (EP_extzv, 3);
7202       extraction_mode = mode_for_extraction (EP_extzv, 0);
7203     }
7204
7205   if (! in_dest && ! unsignedp
7206       && mode_for_extraction (EP_extv, -1) != MAX_MACHINE_MODE)
7207     {
7208       wanted_inner_reg_mode = mode_for_extraction (EP_extv, 1);
7209       pos_mode = mode_for_extraction (EP_extv, 3);
7210       extraction_mode = mode_for_extraction (EP_extv, 0);
7211     }
7212
7213   /* Never narrow an object, since that might not be safe.  */
7214
7215   if (mode != VOIDmode
7216       && GET_MODE_SIZE (extraction_mode) < GET_MODE_SIZE (mode))
7217     extraction_mode = mode;
7218
7219   if (pos_rtx && GET_MODE (pos_rtx) != VOIDmode
7220       && GET_MODE_SIZE (pos_mode) < GET_MODE_SIZE (GET_MODE (pos_rtx)))
7221     pos_mode = GET_MODE (pos_rtx);
7222
7223   /* If this is not from memory, the desired mode is the preferred mode
7224      for an extraction pattern's first input operand, or word_mode if there
7225      is none.  */
7226   if (!MEM_P (inner))
7227     wanted_inner_mode = wanted_inner_reg_mode;
7228   else
7229     {
7230       /* Be careful not to go beyond the extracted object and maintain the
7231          natural alignment of the memory.  */
7232       wanted_inner_mode = smallest_mode_for_size (len, MODE_INT);
7233       while (pos % GET_MODE_BITSIZE (wanted_inner_mode) + len
7234              > GET_MODE_BITSIZE (wanted_inner_mode))
7235         {
7236           wanted_inner_mode = GET_MODE_WIDER_MODE (wanted_inner_mode);
7237           gcc_assert (wanted_inner_mode != VOIDmode);
7238         }
7239
7240       /* If we have to change the mode of memory and cannot, the desired mode
7241          is EXTRACTION_MODE.  */
7242       if (inner_mode != wanted_inner_mode
7243           && (mode_dependent_address_p (XEXP (inner, 0))
7244               || MEM_VOLATILE_P (inner)
7245               || pos_rtx))
7246         wanted_inner_mode = extraction_mode;
7247     }
7248
7249   orig_pos = pos;
7250
7251   if (BITS_BIG_ENDIAN)
7252     {
7253       /* POS is passed as if BITS_BIG_ENDIAN == 0, so we need to convert it to
7254          BITS_BIG_ENDIAN style.  If position is constant, compute new
7255          position.  Otherwise, build subtraction.
7256          Note that POS is relative to the mode of the original argument.
7257          If it's a MEM we need to recompute POS relative to that.
7258          However, if we're extracting from (or inserting into) a register,
7259          we want to recompute POS relative to wanted_inner_mode.  */
7260       int width = (MEM_P (inner)
7261                    ? GET_MODE_BITSIZE (is_mode)
7262                    : GET_MODE_BITSIZE (wanted_inner_mode));
7263
7264       if (pos_rtx == 0)
7265         pos = width - len - pos;
7266       else
7267         pos_rtx
7268           = gen_rtx_MINUS (GET_MODE (pos_rtx), GEN_INT (width - len), pos_rtx);
7269       /* POS may be less than 0 now, but we check for that below.
7270          Note that it can only be less than 0 if !MEM_P (inner).  */
7271     }
7272
7273   /* If INNER has a wider mode, and this is a constant extraction, try to
7274      make it smaller and adjust the byte to point to the byte containing
7275      the value.  */
7276   if (wanted_inner_mode != VOIDmode
7277       && inner_mode != wanted_inner_mode
7278       && ! pos_rtx
7279       && GET_MODE_SIZE (wanted_inner_mode) < GET_MODE_SIZE (is_mode)
7280       && MEM_P (inner)
7281       && ! mode_dependent_address_p (XEXP (inner, 0))
7282       && ! MEM_VOLATILE_P (inner))
7283     {
7284       int offset = 0;
7285
7286       /* The computations below will be correct if the machine is big
7287          endian in both bits and bytes or little endian in bits and bytes.
7288          If it is mixed, we must adjust.  */
7289
7290       /* If bytes are big endian and we had a paradoxical SUBREG, we must
7291          adjust OFFSET to compensate.  */
7292       if (BYTES_BIG_ENDIAN
7293           && GET_MODE_SIZE (inner_mode) < GET_MODE_SIZE (is_mode))
7294         offset -= GET_MODE_SIZE (is_mode) - GET_MODE_SIZE (inner_mode);
7295
7296       /* We can now move to the desired byte.  */
7297       offset += (pos / GET_MODE_BITSIZE (wanted_inner_mode))
7298                 * GET_MODE_SIZE (wanted_inner_mode);
7299       pos %= GET_MODE_BITSIZE (wanted_inner_mode);
7300
7301       if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN
7302           && is_mode != wanted_inner_mode)
7303         offset = (GET_MODE_SIZE (is_mode)
7304                   - GET_MODE_SIZE (wanted_inner_mode) - offset);
7305
7306       inner = adjust_address_nv (inner, wanted_inner_mode, offset);
7307     }
7308
7309   /* If INNER is not memory, get it into the proper mode.  If we are changing
7310      its mode, POS must be a constant and smaller than the size of the new
7311      mode.  */
7312   else if (!MEM_P (inner))
7313     {
7314       /* On the LHS, don't create paradoxical subregs implicitely truncating
7315          the register unless TRULY_NOOP_TRUNCATION.  */
7316       if (in_dest
7317           && !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (GET_MODE (inner)),
7318                                      GET_MODE_BITSIZE (wanted_inner_mode)))
7319         return NULL_RTX;
7320
7321       if (GET_MODE (inner) != wanted_inner_mode
7322           && (pos_rtx != 0
7323               || orig_pos + len > GET_MODE_BITSIZE (wanted_inner_mode)))
7324         return NULL_RTX;
7325
7326       if (orig_pos < 0)
7327         return NULL_RTX;
7328
7329       inner = force_to_mode (inner, wanted_inner_mode,
7330                              pos_rtx
7331                              || len + orig_pos >= HOST_BITS_PER_WIDE_INT
7332                              ? ~(unsigned HOST_WIDE_INT) 0
7333                              : ((((unsigned HOST_WIDE_INT) 1 << len) - 1)
7334                                 << orig_pos),
7335                              0);
7336     }
7337
7338   /* Adjust mode of POS_RTX, if needed.  If we want a wider mode, we
7339      have to zero extend.  Otherwise, we can just use a SUBREG.  */
7340   if (pos_rtx != 0
7341       && GET_MODE_SIZE (pos_mode) > GET_MODE_SIZE (GET_MODE (pos_rtx)))
7342     {
7343       rtx temp = gen_rtx_ZERO_EXTEND (pos_mode, pos_rtx);
7344
7345       /* If we know that no extraneous bits are set, and that the high
7346          bit is not set, convert extraction to cheaper one - either
7347          SIGN_EXTENSION or ZERO_EXTENSION, that are equivalent in these
7348          cases.  */
7349       if (flag_expensive_optimizations
7350           && (GET_MODE_BITSIZE (GET_MODE (pos_rtx)) <= HOST_BITS_PER_WIDE_INT
7351               && ((nonzero_bits (pos_rtx, GET_MODE (pos_rtx))
7352                    & ~(((unsigned HOST_WIDE_INT)
7353                         GET_MODE_MASK (GET_MODE (pos_rtx)))
7354                        >> 1))
7355                   == 0)))
7356         {
7357           rtx temp1 = gen_rtx_SIGN_EXTEND (pos_mode, pos_rtx);
7358
7359           /* Prefer ZERO_EXTENSION, since it gives more information to
7360              backends.  */
7361           if (rtx_cost (temp1, SET, optimize_this_for_speed_p)
7362               < rtx_cost (temp, SET, optimize_this_for_speed_p))
7363             temp = temp1;
7364         }
7365       pos_rtx = temp;
7366     }
7367   else if (pos_rtx != 0
7368            && GET_MODE_SIZE (pos_mode) < GET_MODE_SIZE (GET_MODE (pos_rtx)))
7369     pos_rtx = gen_lowpart (pos_mode, pos_rtx);
7370
7371   /* Make POS_RTX unless we already have it and it is correct.  If we don't
7372      have a POS_RTX but we do have an ORIG_POS_RTX, the latter must
7373      be a CONST_INT.  */
7374   if (pos_rtx == 0 && orig_pos_rtx != 0 && INTVAL (orig_pos_rtx) == pos)
7375     pos_rtx = orig_pos_rtx;
7376
7377   else if (pos_rtx == 0)
7378     pos_rtx = GEN_INT (pos);
7379
7380   /* Make the required operation.  See if we can use existing rtx.  */
7381   new_rtx = gen_rtx_fmt_eee (unsignedp ? ZERO_EXTRACT : SIGN_EXTRACT,
7382                          extraction_mode, inner, GEN_INT (len), pos_rtx);
7383   if (! in_dest)
7384     new_rtx = gen_lowpart (mode, new_rtx);
7385
7386   return new_rtx;
7387 }
7388 \f
7389 /* See if X contains an ASHIFT of COUNT or more bits that can be commuted
7390    with any other operations in X.  Return X without that shift if so.  */
7391
7392 static rtx
7393 extract_left_shift (rtx x, int count)
7394 {
7395   enum rtx_code code = GET_CODE (x);
7396   enum machine_mode mode = GET_MODE (x);
7397   rtx tem;
7398
7399   switch (code)
7400     {
7401     case ASHIFT:
7402       /* This is the shift itself.  If it is wide enough, we will return
7403          either the value being shifted if the shift count is equal to
7404          COUNT or a shift for the difference.  */
7405       if (CONST_INT_P (XEXP (x, 1))
7406           && INTVAL (XEXP (x, 1)) >= count)
7407         return simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (x, 0),
7408                                      INTVAL (XEXP (x, 1)) - count);
7409       break;
7410
7411     case NEG:  case NOT:
7412       if ((tem = extract_left_shift (XEXP (x, 0), count)) != 0)
7413         return simplify_gen_unary (code, mode, tem, mode);
7414
7415       break;
7416
7417     case PLUS:  case IOR:  case XOR:  case AND:
7418       /* If we can safely shift this constant and we find the inner shift,
7419          make a new operation.  */
7420       if (CONST_INT_P (XEXP (x, 1))
7421           && (UINTVAL (XEXP (x, 1))
7422               & ((((unsigned HOST_WIDE_INT) 1 << count)) - 1)) == 0
7423           && (tem = extract_left_shift (XEXP (x, 0), count)) != 0)
7424         return simplify_gen_binary (code, mode, tem,
7425                                     GEN_INT (INTVAL (XEXP (x, 1)) >> count));
7426
7427       break;
7428
7429     default:
7430       break;
7431     }
7432
7433   return 0;
7434 }
7435 \f
7436 /* Look at the expression rooted at X.  Look for expressions
7437    equivalent to ZERO_EXTRACT, SIGN_EXTRACT, ZERO_EXTEND, SIGN_EXTEND.
7438    Form these expressions.
7439
7440    Return the new rtx, usually just X.
7441
7442    Also, for machines like the VAX that don't have logical shift insns,
7443    try to convert logical to arithmetic shift operations in cases where
7444    they are equivalent.  This undoes the canonicalizations to logical
7445    shifts done elsewhere.
7446
7447    We try, as much as possible, to re-use rtl expressions to save memory.
7448
7449    IN_CODE says what kind of expression we are processing.  Normally, it is
7450    SET.  In a memory address (inside a MEM, PLUS or minus, the latter two
7451    being kludges), it is MEM.  When processing the arguments of a comparison
7452    or a COMPARE against zero, it is COMPARE.  */
7453
7454 static rtx
7455 make_compound_operation (rtx x, enum rtx_code in_code)
7456 {
7457   enum rtx_code code = GET_CODE (x);
7458   enum machine_mode mode = GET_MODE (x);
7459   int mode_width = GET_MODE_BITSIZE (mode);
7460   rtx rhs, lhs;
7461   enum rtx_code next_code;
7462   int i, j;
7463   rtx new_rtx = 0;
7464   rtx tem;
7465   const char *fmt;
7466
7467   /* Select the code to be used in recursive calls.  Once we are inside an
7468      address, we stay there.  If we have a comparison, set to COMPARE,
7469      but once inside, go back to our default of SET.  */
7470
7471   next_code = (code == MEM ? MEM
7472                : ((code == PLUS || code == MINUS)
7473                   && SCALAR_INT_MODE_P (mode)) ? MEM
7474                : ((code == COMPARE || COMPARISON_P (x))
7475                   && XEXP (x, 1) == const0_rtx) ? COMPARE
7476                : in_code == COMPARE ? SET : in_code);
7477
7478   /* Process depending on the code of this operation.  If NEW is set
7479      nonzero, it will be returned.  */
7480
7481   switch (code)
7482     {
7483     case ASHIFT:
7484       /* Convert shifts by constants into multiplications if inside
7485          an address.  */
7486       if (in_code == MEM && CONST_INT_P (XEXP (x, 1))
7487           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
7488           && INTVAL (XEXP (x, 1)) >= 0
7489           && SCALAR_INT_MODE_P (mode))
7490         {
7491           HOST_WIDE_INT count = INTVAL (XEXP (x, 1));
7492           HOST_WIDE_INT multval = (HOST_WIDE_INT) 1 << count;
7493
7494           new_rtx = make_compound_operation (XEXP (x, 0), next_code);
7495           if (GET_CODE (new_rtx) == NEG)
7496             {
7497               new_rtx = XEXP (new_rtx, 0);
7498               multval = -multval;
7499             }
7500           multval = trunc_int_for_mode (multval, mode);
7501           new_rtx = gen_rtx_MULT (mode, new_rtx, GEN_INT (multval));
7502         }
7503       break;
7504
7505     case PLUS:
7506       lhs = XEXP (x, 0);
7507       rhs = XEXP (x, 1);
7508       lhs = make_compound_operation (lhs, next_code);
7509       rhs = make_compound_operation (rhs, next_code);
7510       if (GET_CODE (lhs) == MULT && GET_CODE (XEXP (lhs, 0)) == NEG
7511           && SCALAR_INT_MODE_P (mode))
7512         {
7513           tem = simplify_gen_binary (MULT, mode, XEXP (XEXP (lhs, 0), 0),
7514                                      XEXP (lhs, 1));
7515           new_rtx = simplify_gen_binary (MINUS, mode, rhs, tem);
7516         }
7517       else if (GET_CODE (lhs) == MULT
7518                && (CONST_INT_P (XEXP (lhs, 1)) && INTVAL (XEXP (lhs, 1)) < 0))
7519         {
7520           tem = simplify_gen_binary (MULT, mode, XEXP (lhs, 0),
7521                                      simplify_gen_unary (NEG, mode,
7522                                                          XEXP (lhs, 1),
7523                                                          mode));
7524           new_rtx = simplify_gen_binary (MINUS, mode, rhs, tem);
7525         }
7526       else
7527         {
7528           SUBST (XEXP (x, 0), lhs);
7529           SUBST (XEXP (x, 1), rhs);
7530           goto maybe_swap;
7531         }
7532       x = gen_lowpart (mode, new_rtx);
7533       goto maybe_swap;
7534
7535     case MINUS:
7536       lhs = XEXP (x, 0);
7537       rhs = XEXP (x, 1);
7538       lhs = make_compound_operation (lhs, next_code);
7539       rhs = make_compound_operation (rhs, next_code);
7540       if (GET_CODE (rhs) == MULT && GET_CODE (XEXP (rhs, 0)) == NEG
7541           && SCALAR_INT_MODE_P (mode))
7542         {
7543           tem = simplify_gen_binary (MULT, mode, XEXP (XEXP (rhs, 0), 0),
7544                                      XEXP (rhs, 1));
7545           new_rtx = simplify_gen_binary (PLUS, mode, tem, lhs);
7546         }
7547       else if (GET_CODE (rhs) == MULT
7548                && (CONST_INT_P (XEXP (rhs, 1)) && INTVAL (XEXP (rhs, 1)) < 0))
7549         {
7550           tem = simplify_gen_binary (MULT, mode, XEXP (rhs, 0),
7551                                      simplify_gen_unary (NEG, mode,
7552                                                          XEXP (rhs, 1),
7553                                                          mode));
7554           new_rtx = simplify_gen_binary (PLUS, mode, tem, lhs);
7555         }
7556       else
7557         {
7558           SUBST (XEXP (x, 0), lhs);
7559           SUBST (XEXP (x, 1), rhs);
7560           return x;
7561         }
7562       return gen_lowpart (mode, new_rtx);
7563
7564     case AND:
7565       /* If the second operand is not a constant, we can't do anything
7566          with it.  */
7567       if (!CONST_INT_P (XEXP (x, 1)))
7568         break;
7569
7570       /* If the constant is a power of two minus one and the first operand
7571          is a logical right shift, make an extraction.  */
7572       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
7573           && (i = exact_log2 (UINTVAL (XEXP (x, 1)) + 1)) >= 0)
7574         {
7575           new_rtx = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
7576           new_rtx = make_extraction (mode, new_rtx, 0, XEXP (XEXP (x, 0), 1), i, 1,
7577                                  0, in_code == COMPARE);
7578         }
7579
7580       /* Same as previous, but for (subreg (lshiftrt ...)) in first op.  */
7581       else if (GET_CODE (XEXP (x, 0)) == SUBREG
7582                && subreg_lowpart_p (XEXP (x, 0))
7583                && GET_CODE (SUBREG_REG (XEXP (x, 0))) == LSHIFTRT
7584                && (i = exact_log2 (UINTVAL (XEXP (x, 1)) + 1)) >= 0)
7585         {
7586           new_rtx = make_compound_operation (XEXP (SUBREG_REG (XEXP (x, 0)), 0),
7587                                          next_code);
7588           new_rtx = make_extraction (GET_MODE (SUBREG_REG (XEXP (x, 0))), new_rtx, 0,
7589                                  XEXP (SUBREG_REG (XEXP (x, 0)), 1), i, 1,
7590                                  0, in_code == COMPARE);
7591         }
7592       /* Same as previous, but for (xor/ior (lshiftrt...) (lshiftrt...)).  */
7593       else if ((GET_CODE (XEXP (x, 0)) == XOR
7594                 || GET_CODE (XEXP (x, 0)) == IOR)
7595                && GET_CODE (XEXP (XEXP (x, 0), 0)) == LSHIFTRT
7596                && GET_CODE (XEXP (XEXP (x, 0), 1)) == LSHIFTRT
7597                && (i = exact_log2 (UINTVAL (XEXP (x, 1)) + 1)) >= 0)
7598         {
7599           /* Apply the distributive law, and then try to make extractions.  */
7600           new_rtx = gen_rtx_fmt_ee (GET_CODE (XEXP (x, 0)), mode,
7601                                 gen_rtx_AND (mode, XEXP (XEXP (x, 0), 0),
7602                                              XEXP (x, 1)),
7603                                 gen_rtx_AND (mode, XEXP (XEXP (x, 0), 1),
7604                                              XEXP (x, 1)));
7605           new_rtx = make_compound_operation (new_rtx, in_code);
7606         }
7607
7608       /* If we are have (and (rotate X C) M) and C is larger than the number
7609          of bits in M, this is an extraction.  */
7610
7611       else if (GET_CODE (XEXP (x, 0)) == ROTATE
7612                && CONST_INT_P (XEXP (XEXP (x, 0), 1))
7613                && (i = exact_log2 (UINTVAL (XEXP (x, 1)) + 1)) >= 0
7614                && i <= INTVAL (XEXP (XEXP (x, 0), 1)))
7615         {
7616           new_rtx = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
7617           new_rtx = make_extraction (mode, new_rtx,
7618                                  (GET_MODE_BITSIZE (mode)
7619                                   - INTVAL (XEXP (XEXP (x, 0), 1))),
7620                                  NULL_RTX, i, 1, 0, in_code == COMPARE);
7621         }
7622
7623       /* On machines without logical shifts, if the operand of the AND is
7624          a logical shift and our mask turns off all the propagated sign
7625          bits, we can replace the logical shift with an arithmetic shift.  */
7626       else if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
7627                && !have_insn_for (LSHIFTRT, mode)
7628                && have_insn_for (ASHIFTRT, mode)
7629                && CONST_INT_P (XEXP (XEXP (x, 0), 1))
7630                && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
7631                && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
7632                && mode_width <= HOST_BITS_PER_WIDE_INT)
7633         {
7634           unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
7635
7636           mask >>= INTVAL (XEXP (XEXP (x, 0), 1));
7637           if ((INTVAL (XEXP (x, 1)) & ~mask) == 0)
7638             SUBST (XEXP (x, 0),
7639                    gen_rtx_ASHIFTRT (mode,
7640                                      make_compound_operation
7641                                      (XEXP (XEXP (x, 0), 0), next_code),
7642                                      XEXP (XEXP (x, 0), 1)));
7643         }
7644
7645       /* If the constant is one less than a power of two, this might be
7646          representable by an extraction even if no shift is present.
7647          If it doesn't end up being a ZERO_EXTEND, we will ignore it unless
7648          we are in a COMPARE.  */
7649       else if ((i = exact_log2 (UINTVAL (XEXP (x, 1)) + 1)) >= 0)
7650         new_rtx = make_extraction (mode,
7651                                make_compound_operation (XEXP (x, 0),
7652                                                         next_code),
7653                                0, NULL_RTX, i, 1, 0, in_code == COMPARE);
7654
7655       /* If we are in a comparison and this is an AND with a power of two,
7656          convert this into the appropriate bit extract.  */
7657       else if (in_code == COMPARE
7658                && (i = exact_log2 (UINTVAL (XEXP (x, 1)))) >= 0)
7659         new_rtx = make_extraction (mode,
7660                                make_compound_operation (XEXP (x, 0),
7661                                                         next_code),
7662                                i, NULL_RTX, 1, 1, 0, 1);
7663
7664       break;
7665
7666     case LSHIFTRT:
7667       /* If the sign bit is known to be zero, replace this with an
7668          arithmetic shift.  */
7669       if (have_insn_for (ASHIFTRT, mode)
7670           && ! have_insn_for (LSHIFTRT, mode)
7671           && mode_width <= HOST_BITS_PER_WIDE_INT
7672           && (nonzero_bits (XEXP (x, 0), mode) & (1 << (mode_width - 1))) == 0)
7673         {
7674           new_rtx = gen_rtx_ASHIFTRT (mode,
7675                                   make_compound_operation (XEXP (x, 0),
7676                                                            next_code),
7677                                   XEXP (x, 1));
7678           break;
7679         }
7680
7681       /* ... fall through ...  */
7682
7683     case ASHIFTRT:
7684       lhs = XEXP (x, 0);
7685       rhs = XEXP (x, 1);
7686
7687       /* If we have (ashiftrt (ashift foo C1) C2) with C2 >= C1,
7688          this is a SIGN_EXTRACT.  */
7689       if (CONST_INT_P (rhs)
7690           && GET_CODE (lhs) == ASHIFT
7691           && CONST_INT_P (XEXP (lhs, 1))
7692           && INTVAL (rhs) >= INTVAL (XEXP (lhs, 1))
7693           && INTVAL (rhs) < mode_width)
7694         {
7695           new_rtx = make_compound_operation (XEXP (lhs, 0), next_code);
7696           new_rtx = make_extraction (mode, new_rtx,
7697                                  INTVAL (rhs) - INTVAL (XEXP (lhs, 1)),
7698                                  NULL_RTX, mode_width - INTVAL (rhs),
7699                                  code == LSHIFTRT, 0, in_code == COMPARE);
7700           break;
7701         }
7702
7703       /* See if we have operations between an ASHIFTRT and an ASHIFT.
7704          If so, try to merge the shifts into a SIGN_EXTEND.  We could
7705          also do this for some cases of SIGN_EXTRACT, but it doesn't
7706          seem worth the effort; the case checked for occurs on Alpha.  */
7707
7708       if (!OBJECT_P (lhs)
7709           && ! (GET_CODE (lhs) == SUBREG
7710                 && (OBJECT_P (SUBREG_REG (lhs))))
7711           && CONST_INT_P (rhs)
7712           && INTVAL (rhs) < HOST_BITS_PER_WIDE_INT
7713           && INTVAL (rhs) < mode_width
7714           && (new_rtx = extract_left_shift (lhs, INTVAL (rhs))) != 0)
7715         new_rtx = make_extraction (mode, make_compound_operation (new_rtx, next_code),
7716                                0, NULL_RTX, mode_width - INTVAL (rhs),
7717                                code == LSHIFTRT, 0, in_code == COMPARE);
7718
7719       break;
7720
7721     case SUBREG:
7722       /* Call ourselves recursively on the inner expression.  If we are
7723          narrowing the object and it has a different RTL code from
7724          what it originally did, do this SUBREG as a force_to_mode.  */
7725       {
7726         rtx inner = SUBREG_REG (x), simplified;
7727
7728         tem = make_compound_operation (inner, in_code);
7729
7730         simplified
7731           = simplify_subreg (mode, tem, GET_MODE (inner), SUBREG_BYTE (x));
7732         if (simplified)
7733           tem = simplified;
7734
7735         if (GET_CODE (tem) != GET_CODE (inner)
7736             && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (inner))
7737             && subreg_lowpart_p (x))
7738           {
7739             rtx newer
7740               = force_to_mode (tem, mode, ~(unsigned HOST_WIDE_INT) 0, 0);
7741
7742             /* If we have something other than a SUBREG, we might have
7743                done an expansion, so rerun ourselves.  */
7744             if (GET_CODE (newer) != SUBREG)
7745               newer = make_compound_operation (newer, in_code);
7746
7747             /* force_to_mode can expand compounds.  If it just re-expanded the
7748                compound, use gen_lowpart to convert to the desired mode.  */
7749             if (rtx_equal_p (newer, x)
7750                 /* Likewise if it re-expanded the compound only partially.
7751                    This happens for SUBREG of ZERO_EXTRACT if they extract
7752                    the same number of bits.  */
7753                 || (GET_CODE (newer) == SUBREG
7754                     && (GET_CODE (SUBREG_REG (newer)) == LSHIFTRT
7755                         || GET_CODE (SUBREG_REG (newer)) == ASHIFTRT)
7756                     && GET_CODE (inner) == AND
7757                     && rtx_equal_p (SUBREG_REG (newer), XEXP (inner, 0))))
7758               return gen_lowpart (GET_MODE (x), tem);
7759
7760             return newer;
7761           }
7762
7763         if (simplified)
7764           return tem;
7765       }
7766       break;
7767
7768     default:
7769       break;
7770     }
7771
7772   if (new_rtx)
7773     {
7774       x = gen_lowpart (mode, new_rtx);
7775       code = GET_CODE (x);
7776     }
7777
7778   /* Now recursively process each operand of this operation.  */
7779   fmt = GET_RTX_FORMAT (code);
7780   for (i = 0; i < GET_RTX_LENGTH (code); i++)
7781     if (fmt[i] == 'e')
7782       {
7783         new_rtx = make_compound_operation (XEXP (x, i), next_code);
7784         SUBST (XEXP (x, i), new_rtx);
7785       }
7786     else if (fmt[i] == 'E')
7787       for (j = 0; j < XVECLEN (x, i); j++)
7788         {
7789           new_rtx = make_compound_operation (XVECEXP (x, i, j), next_code);
7790           SUBST (XVECEXP (x, i, j), new_rtx);
7791         }
7792
7793  maybe_swap:
7794   /* If this is a commutative operation, the changes to the operands
7795      may have made it noncanonical.  */
7796   if (COMMUTATIVE_ARITH_P (x)
7797       && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
7798     {
7799       tem = XEXP (x, 0);
7800       SUBST (XEXP (x, 0), XEXP (x, 1));
7801       SUBST (XEXP (x, 1), tem);
7802     }
7803
7804   return x;
7805 }
7806 \f
7807 /* Given M see if it is a value that would select a field of bits
7808    within an item, but not the entire word.  Return -1 if not.
7809    Otherwise, return the starting position of the field, where 0 is the
7810    low-order bit.
7811
7812    *PLEN is set to the length of the field.  */
7813
7814 static int
7815 get_pos_from_mask (unsigned HOST_WIDE_INT m, unsigned HOST_WIDE_INT *plen)
7816 {
7817   /* Get the bit number of the first 1 bit from the right, -1 if none.  */
7818   int pos = m ? ctz_hwi (m) : -1;
7819   int len = 0;
7820
7821   if (pos >= 0)
7822     /* Now shift off the low-order zero bits and see if we have a
7823        power of two minus 1.  */
7824     len = exact_log2 ((m >> pos) + 1);
7825
7826   if (len <= 0)
7827     pos = -1;
7828
7829   *plen = len;
7830   return pos;
7831 }
7832 \f
7833 /* If X refers to a register that equals REG in value, replace these
7834    references with REG.  */
7835 static rtx
7836 canon_reg_for_combine (rtx x, rtx reg)
7837 {
7838   rtx op0, op1, op2;
7839   const char *fmt;
7840   int i;
7841   bool copied;
7842
7843   enum rtx_code code = GET_CODE (x);
7844   switch (GET_RTX_CLASS (code))
7845     {
7846     case RTX_UNARY:
7847       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7848       if (op0 != XEXP (x, 0))
7849         return simplify_gen_unary (GET_CODE (x), GET_MODE (x), op0,
7850                                    GET_MODE (reg));
7851       break;
7852
7853     case RTX_BIN_ARITH:
7854     case RTX_COMM_ARITH:
7855       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7856       op1 = canon_reg_for_combine (XEXP (x, 1), reg);
7857       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
7858         return simplify_gen_binary (GET_CODE (x), GET_MODE (x), op0, op1);
7859       break;
7860
7861     case RTX_COMPARE:
7862     case RTX_COMM_COMPARE:
7863       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7864       op1 = canon_reg_for_combine (XEXP (x, 1), reg);
7865       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
7866         return simplify_gen_relational (GET_CODE (x), GET_MODE (x),
7867                                         GET_MODE (op0), op0, op1);
7868       break;
7869
7870     case RTX_TERNARY:
7871     case RTX_BITFIELD_OPS:
7872       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7873       op1 = canon_reg_for_combine (XEXP (x, 1), reg);
7874       op2 = canon_reg_for_combine (XEXP (x, 2), reg);
7875       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1) || op2 != XEXP (x, 2))
7876         return simplify_gen_ternary (GET_CODE (x), GET_MODE (x),
7877                                      GET_MODE (op0), op0, op1, op2);
7878
7879     case RTX_OBJ:
7880       if (REG_P (x))
7881         {
7882           if (rtx_equal_p (get_last_value (reg), x)
7883               || rtx_equal_p (reg, get_last_value (x)))
7884             return reg;
7885           else
7886             break;
7887         }
7888
7889       /* fall through */
7890
7891     default:
7892       fmt = GET_RTX_FORMAT (code);
7893       copied = false;
7894       for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
7895         if (fmt[i] == 'e')
7896           {
7897             rtx op = canon_reg_for_combine (XEXP (x, i), reg);
7898             if (op != XEXP (x, i))
7899               {
7900                 if (!copied)
7901                   {
7902                     copied = true;
7903                     x = copy_rtx (x);
7904                   }
7905                 XEXP (x, i) = op;
7906               }
7907           }
7908         else if (fmt[i] == 'E')
7909           {
7910             int j;
7911             for (j = 0; j < XVECLEN (x, i); j++)
7912               {
7913                 rtx op = canon_reg_for_combine (XVECEXP (x, i, j), reg);
7914                 if (op != XVECEXP (x, i, j))
7915                   {
7916                     if (!copied)
7917                       {
7918                         copied = true;
7919                         x = copy_rtx (x);
7920                       }
7921                     XVECEXP (x, i, j) = op;
7922                   }
7923               }
7924           }
7925
7926       break;
7927     }
7928
7929   return x;
7930 }
7931
7932 /* Return X converted to MODE.  If the value is already truncated to
7933    MODE we can just return a subreg even though in the general case we
7934    would need an explicit truncation.  */
7935
7936 static rtx
7937 gen_lowpart_or_truncate (enum machine_mode mode, rtx x)
7938 {
7939   if (!CONST_INT_P (x)
7940       && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x))
7941       && !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
7942                                  GET_MODE_BITSIZE (GET_MODE (x)))
7943       && !(REG_P (x) && reg_truncated_to_mode (mode, x)))
7944     {
7945       /* Bit-cast X into an integer mode.  */
7946       if (!SCALAR_INT_MODE_P (GET_MODE (x)))
7947         x = gen_lowpart (int_mode_for_mode (GET_MODE (x)), x);
7948       x = simplify_gen_unary (TRUNCATE, int_mode_for_mode (mode),
7949                               x, GET_MODE (x));
7950     }
7951
7952   return gen_lowpart (mode, x);
7953 }
7954
7955 /* See if X can be simplified knowing that we will only refer to it in
7956    MODE and will only refer to those bits that are nonzero in MASK.
7957    If other bits are being computed or if masking operations are done
7958    that select a superset of the bits in MASK, they can sometimes be
7959    ignored.
7960
7961    Return a possibly simplified expression, but always convert X to
7962    MODE.  If X is a CONST_INT, AND the CONST_INT with MASK.
7963
7964    If JUST_SELECT is nonzero, don't optimize by noticing that bits in MASK
7965    are all off in X.  This is used when X will be complemented, by either
7966    NOT, NEG, or XOR.  */
7967
7968 static rtx
7969 force_to_mode (rtx x, enum machine_mode mode, unsigned HOST_WIDE_INT mask,
7970                int just_select)
7971 {
7972   enum rtx_code code = GET_CODE (x);
7973   int next_select = just_select || code == XOR || code == NOT || code == NEG;
7974   enum machine_mode op_mode;
7975   unsigned HOST_WIDE_INT fuller_mask, nonzero;
7976   rtx op0, op1, temp;
7977
7978   /* If this is a CALL or ASM_OPERANDS, don't do anything.  Some of the
7979      code below will do the wrong thing since the mode of such an
7980      expression is VOIDmode.
7981
7982      Also do nothing if X is a CLOBBER; this can happen if X was
7983      the return value from a call to gen_lowpart.  */
7984   if (code == CALL || code == ASM_OPERANDS || code == CLOBBER)
7985     return x;
7986
7987   /* We want to perform the operation is its present mode unless we know
7988      that the operation is valid in MODE, in which case we do the operation
7989      in MODE.  */
7990   op_mode = ((GET_MODE_CLASS (mode) == GET_MODE_CLASS (GET_MODE (x))
7991               && have_insn_for (code, mode))
7992              ? mode : GET_MODE (x));
7993
7994   /* It is not valid to do a right-shift in a narrower mode
7995      than the one it came in with.  */
7996   if ((code == LSHIFTRT || code == ASHIFTRT)
7997       && GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (GET_MODE (x)))
7998     op_mode = GET_MODE (x);
7999
8000   /* Truncate MASK to fit OP_MODE.  */
8001   if (op_mode)
8002     mask &= GET_MODE_MASK (op_mode);
8003
8004   /* When we have an arithmetic operation, or a shift whose count we
8005      do not know, we need to assume that all bits up to the highest-order
8006      bit in MASK will be needed.  This is how we form such a mask.  */
8007   if (mask & ((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)))
8008     fuller_mask = ~(unsigned HOST_WIDE_INT) 0;
8009   else
8010     fuller_mask = (((unsigned HOST_WIDE_INT) 1 << (floor_log2 (mask) + 1))
8011                    - 1);
8012
8013   /* Determine what bits of X are guaranteed to be (non)zero.  */
8014   nonzero = nonzero_bits (x, mode);
8015
8016   /* If none of the bits in X are needed, return a zero.  */
8017   if (!just_select && (nonzero & mask) == 0 && !side_effects_p (x))
8018     x = const0_rtx;
8019
8020   /* If X is a CONST_INT, return a new one.  Do this here since the
8021      test below will fail.  */
8022   if (CONST_INT_P (x))
8023     {
8024       if (SCALAR_INT_MODE_P (mode))
8025         return gen_int_mode (INTVAL (x) & mask, mode);
8026       else
8027         {
8028           x = GEN_INT (INTVAL (x) & mask);
8029           return gen_lowpart_common (mode, x);
8030         }
8031     }
8032
8033   /* If X is narrower than MODE and we want all the bits in X's mode, just
8034      get X in the proper mode.  */
8035   if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (mode)
8036       && (GET_MODE_MASK (GET_MODE (x)) & ~mask) == 0)
8037     return gen_lowpart (mode, x);
8038
8039   /* We can ignore the effect of a SUBREG if it narrows the mode or
8040      if the constant masks to zero all the bits the mode doesn't have.  */
8041   if (GET_CODE (x) == SUBREG
8042       && subreg_lowpart_p (x)
8043       && ((GET_MODE_SIZE (GET_MODE (x))
8044            < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
8045           || (0 == (mask
8046                     & GET_MODE_MASK (GET_MODE (x))
8047                     & ~GET_MODE_MASK (GET_MODE (SUBREG_REG (x)))))))
8048     return force_to_mode (SUBREG_REG (x), mode, mask, next_select);
8049
8050   /* The arithmetic simplifications here only work for scalar integer modes.  */
8051   if (!SCALAR_INT_MODE_P (mode) || !SCALAR_INT_MODE_P (GET_MODE (x)))
8052     return gen_lowpart_or_truncate (mode, x);
8053
8054   switch (code)
8055     {
8056     case CLOBBER:
8057       /* If X is a (clobber (const_int)), return it since we know we are
8058          generating something that won't match.  */
8059       return x;
8060
8061     case SIGN_EXTEND:
8062     case ZERO_EXTEND:
8063     case ZERO_EXTRACT:
8064     case SIGN_EXTRACT:
8065       x = expand_compound_operation (x);
8066       if (GET_CODE (x) != code)
8067         return force_to_mode (x, mode, mask, next_select);
8068       break;
8069
8070     case TRUNCATE:
8071       /* Similarly for a truncate.  */
8072       return force_to_mode (XEXP (x, 0), mode, mask, next_select);
8073
8074     case AND:
8075       /* If this is an AND with a constant, convert it into an AND
8076          whose constant is the AND of that constant with MASK.  If it
8077          remains an AND of MASK, delete it since it is redundant.  */
8078
8079       if (CONST_INT_P (XEXP (x, 1)))
8080         {
8081           x = simplify_and_const_int (x, op_mode, XEXP (x, 0),
8082                                       mask & INTVAL (XEXP (x, 1)));
8083
8084           /* If X is still an AND, see if it is an AND with a mask that
8085              is just some low-order bits.  If so, and it is MASK, we don't
8086              need it.  */
8087
8088           if (GET_CODE (x) == AND && CONST_INT_P (XEXP (x, 1))
8089               && ((INTVAL (XEXP (x, 1)) & GET_MODE_MASK (GET_MODE (x)))
8090                   == mask))
8091             x = XEXP (x, 0);
8092
8093           /* If it remains an AND, try making another AND with the bits
8094              in the mode mask that aren't in MASK turned on.  If the
8095              constant in the AND is wide enough, this might make a
8096              cheaper constant.  */
8097
8098           if (GET_CODE (x) == AND && CONST_INT_P (XEXP (x, 1))
8099               && GET_MODE_MASK (GET_MODE (x)) != mask
8100               && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
8101             {
8102               unsigned HOST_WIDE_INT cval
8103                 = UINTVAL (XEXP (x, 1))
8104                   | (GET_MODE_MASK (GET_MODE (x)) & ~mask);
8105               int width = GET_MODE_BITSIZE (GET_MODE (x));
8106               rtx y;
8107
8108               /* If MODE is narrower than HOST_WIDE_INT and CVAL is a negative
8109                  number, sign extend it.  */
8110               if (width > 0 && width < HOST_BITS_PER_WIDE_INT
8111                   && (cval & ((unsigned HOST_WIDE_INT) 1 << (width - 1))) != 0)
8112                 cval |= (unsigned HOST_WIDE_INT) -1 << width;
8113
8114               y = simplify_gen_binary (AND, GET_MODE (x),
8115                                        XEXP (x, 0), GEN_INT (cval));
8116               if (rtx_cost (y, SET, optimize_this_for_speed_p)
8117                   < rtx_cost (x, SET, optimize_this_for_speed_p))
8118                 x = y;
8119             }
8120
8121           break;
8122         }
8123
8124       goto binop;
8125
8126     case PLUS:
8127       /* In (and (plus FOO C1) M), if M is a mask that just turns off
8128          low-order bits (as in an alignment operation) and FOO is already
8129          aligned to that boundary, mask C1 to that boundary as well.
8130          This may eliminate that PLUS and, later, the AND.  */
8131
8132       {
8133         unsigned int width = GET_MODE_BITSIZE (mode);
8134         unsigned HOST_WIDE_INT smask = mask;
8135
8136         /* If MODE is narrower than HOST_WIDE_INT and mask is a negative
8137            number, sign extend it.  */
8138
8139         if (width < HOST_BITS_PER_WIDE_INT
8140             && (smask & ((unsigned HOST_WIDE_INT) 1 << (width - 1))) != 0)
8141           smask |= (unsigned HOST_WIDE_INT) (-1) << width;
8142
8143         if (CONST_INT_P (XEXP (x, 1))
8144             && exact_log2 (- smask) >= 0
8145             && (nonzero_bits (XEXP (x, 0), mode) & ~smask) == 0
8146             && (INTVAL (XEXP (x, 1)) & ~smask) != 0)
8147           return force_to_mode (plus_constant (XEXP (x, 0),
8148                                                (INTVAL (XEXP (x, 1)) & smask)),
8149                                 mode, smask, next_select);
8150       }
8151
8152       /* ... fall through ...  */
8153
8154     case MULT:
8155       /* For PLUS, MINUS and MULT, we need any bits less significant than the
8156          most significant bit in MASK since carries from those bits will
8157          affect the bits we are interested in.  */
8158       mask = fuller_mask;
8159       goto binop;
8160
8161     case MINUS:
8162       /* If X is (minus C Y) where C's least set bit is larger than any bit
8163          in the mask, then we may replace with (neg Y).  */
8164       if (CONST_INT_P (XEXP (x, 0))
8165           && (((unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 0))
8166                                         & -INTVAL (XEXP (x, 0))))
8167               > mask))
8168         {
8169           x = simplify_gen_unary (NEG, GET_MODE (x), XEXP (x, 1),
8170                                   GET_MODE (x));
8171           return force_to_mode (x, mode, mask, next_select);
8172         }
8173
8174       /* Similarly, if C contains every bit in the fuller_mask, then we may
8175          replace with (not Y).  */
8176       if (CONST_INT_P (XEXP (x, 0))
8177           && ((UINTVAL (XEXP (x, 0)) | fuller_mask) == UINTVAL (XEXP (x, 0))))
8178         {
8179           x = simplify_gen_unary (NOT, GET_MODE (x),
8180                                   XEXP (x, 1), GET_MODE (x));
8181           return force_to_mode (x, mode, mask, next_select);
8182         }
8183
8184       mask = fuller_mask;
8185       goto binop;
8186
8187     case IOR:
8188     case XOR:
8189       /* If X is (ior (lshiftrt FOO C1) C2), try to commute the IOR and
8190          LSHIFTRT so we end up with an (and (lshiftrt (ior ...) ...) ...)
8191          operation which may be a bitfield extraction.  Ensure that the
8192          constant we form is not wider than the mode of X.  */
8193
8194       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
8195           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
8196           && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
8197           && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
8198           && CONST_INT_P (XEXP (x, 1))
8199           && ((INTVAL (XEXP (XEXP (x, 0), 1))
8200                + floor_log2 (INTVAL (XEXP (x, 1))))
8201               < GET_MODE_BITSIZE (GET_MODE (x)))
8202           && (UINTVAL (XEXP (x, 1))
8203               & ~nonzero_bits (XEXP (x, 0), GET_MODE (x))) == 0)
8204         {
8205           temp = GEN_INT ((INTVAL (XEXP (x, 1)) & mask)
8206                           << INTVAL (XEXP (XEXP (x, 0), 1)));
8207           temp = simplify_gen_binary (GET_CODE (x), GET_MODE (x),
8208                                       XEXP (XEXP (x, 0), 0), temp);
8209           x = simplify_gen_binary (LSHIFTRT, GET_MODE (x), temp,
8210                                    XEXP (XEXP (x, 0), 1));
8211           return force_to_mode (x, mode, mask, next_select);
8212         }
8213
8214     binop:
8215       /* For most binary operations, just propagate into the operation and
8216          change the mode if we have an operation of that mode.  */
8217
8218       op0 = force_to_mode (XEXP (x, 0), mode, mask, next_select);
8219       op1 = force_to_mode (XEXP (x, 1), mode, mask, next_select);
8220
8221       /* If we ended up truncating both operands, truncate the result of the
8222          operation instead.  */
8223       if (GET_CODE (op0) == TRUNCATE
8224           && GET_CODE (op1) == TRUNCATE)
8225         {
8226           op0 = XEXP (op0, 0);
8227           op1 = XEXP (op1, 0);
8228         }
8229
8230       op0 = gen_lowpart_or_truncate (op_mode, op0);
8231       op1 = gen_lowpart_or_truncate (op_mode, op1);
8232
8233       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
8234         x = simplify_gen_binary (code, op_mode, op0, op1);
8235       break;
8236
8237     case ASHIFT:
8238       /* For left shifts, do the same, but just for the first operand.
8239          However, we cannot do anything with shifts where we cannot
8240          guarantee that the counts are smaller than the size of the mode
8241          because such a count will have a different meaning in a
8242          wider mode.  */
8243
8244       if (! (CONST_INT_P (XEXP (x, 1))
8245              && INTVAL (XEXP (x, 1)) >= 0
8246              && INTVAL (XEXP (x, 1)) < GET_MODE_BITSIZE (mode))
8247           && ! (GET_MODE (XEXP (x, 1)) != VOIDmode
8248                 && (nonzero_bits (XEXP (x, 1), GET_MODE (XEXP (x, 1)))
8249                     < (unsigned HOST_WIDE_INT) GET_MODE_BITSIZE (mode))))
8250         break;
8251
8252       /* If the shift count is a constant and we can do arithmetic in
8253          the mode of the shift, refine which bits we need.  Otherwise, use the
8254          conservative form of the mask.  */
8255       if (CONST_INT_P (XEXP (x, 1))
8256           && INTVAL (XEXP (x, 1)) >= 0
8257           && INTVAL (XEXP (x, 1)) < GET_MODE_BITSIZE (op_mode)
8258           && GET_MODE_BITSIZE (op_mode) <= HOST_BITS_PER_WIDE_INT)
8259         mask >>= INTVAL (XEXP (x, 1));
8260       else
8261         mask = fuller_mask;
8262
8263       op0 = gen_lowpart_or_truncate (op_mode,
8264                                      force_to_mode (XEXP (x, 0), op_mode,
8265                                                     mask, next_select));
8266
8267       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0))
8268         x = simplify_gen_binary (code, op_mode, op0, XEXP (x, 1));
8269       break;
8270
8271     case LSHIFTRT:
8272       /* Here we can only do something if the shift count is a constant,
8273          this shift constant is valid for the host, and we can do arithmetic
8274          in OP_MODE.  */
8275
8276       if (CONST_INT_P (XEXP (x, 1))
8277           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
8278           && GET_MODE_BITSIZE (op_mode) <= HOST_BITS_PER_WIDE_INT)
8279         {
8280           rtx inner = XEXP (x, 0);
8281           unsigned HOST_WIDE_INT inner_mask;
8282
8283           /* Select the mask of the bits we need for the shift operand.  */
8284           inner_mask = mask << INTVAL (XEXP (x, 1));
8285
8286           /* We can only change the mode of the shift if we can do arithmetic
8287              in the mode of the shift and INNER_MASK is no wider than the
8288              width of X's mode.  */
8289           if ((inner_mask & ~GET_MODE_MASK (GET_MODE (x))) != 0)
8290             op_mode = GET_MODE (x);
8291
8292           inner = force_to_mode (inner, op_mode, inner_mask, next_select);
8293
8294           if (GET_MODE (x) != op_mode || inner != XEXP (x, 0))
8295             x = simplify_gen_binary (LSHIFTRT, op_mode, inner, XEXP (x, 1));
8296         }
8297
8298       /* If we have (and (lshiftrt FOO C1) C2) where the combination of the
8299          shift and AND produces only copies of the sign bit (C2 is one less
8300          than a power of two), we can do this with just a shift.  */
8301
8302       if (GET_CODE (x) == LSHIFTRT
8303           && CONST_INT_P (XEXP (x, 1))
8304           /* The shift puts one of the sign bit copies in the least significant
8305              bit.  */
8306           && ((INTVAL (XEXP (x, 1))
8307                + num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0))))
8308               >= GET_MODE_BITSIZE (GET_MODE (x)))
8309           && exact_log2 (mask + 1) >= 0
8310           /* Number of bits left after the shift must be more than the mask
8311              needs.  */
8312           && ((INTVAL (XEXP (x, 1)) + exact_log2 (mask + 1))
8313               <= GET_MODE_BITSIZE (GET_MODE (x)))
8314           /* Must be more sign bit copies than the mask needs.  */
8315           && ((int) num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
8316               >= exact_log2 (mask + 1)))
8317         x = simplify_gen_binary (LSHIFTRT, GET_MODE (x), XEXP (x, 0),
8318                                  GEN_INT (GET_MODE_BITSIZE (GET_MODE (x))
8319                                           - exact_log2 (mask + 1)));
8320
8321       goto shiftrt;
8322
8323     case ASHIFTRT:
8324       /* If we are just looking for the sign bit, we don't need this shift at
8325          all, even if it has a variable count.  */
8326       if (GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
8327           && (mask == ((unsigned HOST_WIDE_INT) 1
8328                        << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
8329         return force_to_mode (XEXP (x, 0), mode, mask, next_select);
8330
8331       /* If this is a shift by a constant, get a mask that contains those bits
8332          that are not copies of the sign bit.  We then have two cases:  If
8333          MASK only includes those bits, this can be a logical shift, which may
8334          allow simplifications.  If MASK is a single-bit field not within
8335          those bits, we are requesting a copy of the sign bit and hence can
8336          shift the sign bit to the appropriate location.  */
8337
8338       if (CONST_INT_P (XEXP (x, 1)) && INTVAL (XEXP (x, 1)) >= 0
8339           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
8340         {
8341           int i;
8342
8343           /* If the considered data is wider than HOST_WIDE_INT, we can't
8344              represent a mask for all its bits in a single scalar.
8345              But we only care about the lower bits, so calculate these.  */
8346
8347           if (GET_MODE_BITSIZE (GET_MODE (x)) > HOST_BITS_PER_WIDE_INT)
8348             {
8349               nonzero = ~(unsigned HOST_WIDE_INT) 0;
8350
8351               /* GET_MODE_BITSIZE (GET_MODE (x)) - INTVAL (XEXP (x, 1))
8352                  is the number of bits a full-width mask would have set.
8353                  We need only shift if these are fewer than nonzero can
8354                  hold.  If not, we must keep all bits set in nonzero.  */
8355
8356               if (GET_MODE_BITSIZE (GET_MODE (x)) - INTVAL (XEXP (x, 1))
8357                   < HOST_BITS_PER_WIDE_INT)
8358                 nonzero >>= INTVAL (XEXP (x, 1))
8359                             + HOST_BITS_PER_WIDE_INT
8360                             - GET_MODE_BITSIZE (GET_MODE (x)) ;
8361             }
8362           else
8363             {
8364               nonzero = GET_MODE_MASK (GET_MODE (x));
8365               nonzero >>= INTVAL (XEXP (x, 1));
8366             }
8367
8368           if ((mask & ~nonzero) == 0)
8369             {
8370               x = simplify_shift_const (NULL_RTX, LSHIFTRT, GET_MODE (x),
8371                                         XEXP (x, 0), INTVAL (XEXP (x, 1)));
8372               if (GET_CODE (x) != ASHIFTRT)
8373                 return force_to_mode (x, mode, mask, next_select);
8374             }
8375
8376           else if ((i = exact_log2 (mask)) >= 0)
8377             {
8378               x = simplify_shift_const
8379                   (NULL_RTX, LSHIFTRT, GET_MODE (x), XEXP (x, 0),
8380                    GET_MODE_BITSIZE (GET_MODE (x)) - 1 - i);
8381
8382               if (GET_CODE (x) != ASHIFTRT)
8383                 return force_to_mode (x, mode, mask, next_select);
8384             }
8385         }
8386
8387       /* If MASK is 1, convert this to an LSHIFTRT.  This can be done
8388          even if the shift count isn't a constant.  */
8389       if (mask == 1)
8390         x = simplify_gen_binary (LSHIFTRT, GET_MODE (x),
8391                                  XEXP (x, 0), XEXP (x, 1));
8392
8393     shiftrt:
8394
8395       /* If this is a zero- or sign-extension operation that just affects bits
8396          we don't care about, remove it.  Be sure the call above returned
8397          something that is still a shift.  */
8398
8399       if ((GET_CODE (x) == LSHIFTRT || GET_CODE (x) == ASHIFTRT)
8400           && CONST_INT_P (XEXP (x, 1))
8401           && INTVAL (XEXP (x, 1)) >= 0
8402           && (INTVAL (XEXP (x, 1))
8403               <= GET_MODE_BITSIZE (GET_MODE (x)) - (floor_log2 (mask) + 1))
8404           && GET_CODE (XEXP (x, 0)) == ASHIFT
8405           && XEXP (XEXP (x, 0), 1) == XEXP (x, 1))
8406         return force_to_mode (XEXP (XEXP (x, 0), 0), mode, mask,
8407                               next_select);
8408
8409       break;
8410
8411     case ROTATE:
8412     case ROTATERT:
8413       /* If the shift count is constant and we can do computations
8414          in the mode of X, compute where the bits we care about are.
8415          Otherwise, we can't do anything.  Don't change the mode of
8416          the shift or propagate MODE into the shift, though.  */
8417       if (CONST_INT_P (XEXP (x, 1))
8418           && INTVAL (XEXP (x, 1)) >= 0)
8419         {
8420           temp = simplify_binary_operation (code == ROTATE ? ROTATERT : ROTATE,
8421                                             GET_MODE (x), GEN_INT (mask),
8422                                             XEXP (x, 1));
8423           if (temp && CONST_INT_P (temp))
8424             SUBST (XEXP (x, 0),
8425                    force_to_mode (XEXP (x, 0), GET_MODE (x),
8426                                   INTVAL (temp), next_select));
8427         }
8428       break;
8429
8430     case NEG:
8431       /* If we just want the low-order bit, the NEG isn't needed since it
8432          won't change the low-order bit.  */
8433       if (mask == 1)
8434         return force_to_mode (XEXP (x, 0), mode, mask, just_select);
8435
8436       /* We need any bits less significant than the most significant bit in
8437          MASK since carries from those bits will affect the bits we are
8438          interested in.  */
8439       mask = fuller_mask;
8440       goto unop;
8441
8442     case NOT:
8443       /* (not FOO) is (xor FOO CONST), so if FOO is an LSHIFTRT, we can do the
8444          same as the XOR case above.  Ensure that the constant we form is not
8445          wider than the mode of X.  */
8446
8447       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
8448           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
8449           && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
8450           && (INTVAL (XEXP (XEXP (x, 0), 1)) + floor_log2 (mask)
8451               < GET_MODE_BITSIZE (GET_MODE (x)))
8452           && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT)
8453         {
8454           temp = gen_int_mode (mask << INTVAL (XEXP (XEXP (x, 0), 1)),
8455                                GET_MODE (x));
8456           temp = simplify_gen_binary (XOR, GET_MODE (x),
8457                                       XEXP (XEXP (x, 0), 0), temp);
8458           x = simplify_gen_binary (LSHIFTRT, GET_MODE (x),
8459                                    temp, XEXP (XEXP (x, 0), 1));
8460
8461           return force_to_mode (x, mode, mask, next_select);
8462         }
8463
8464       /* (and (not FOO) CONST) is (not (or FOO (not CONST))), so we must
8465          use the full mask inside the NOT.  */
8466       mask = fuller_mask;
8467
8468     unop:
8469       op0 = gen_lowpart_or_truncate (op_mode,
8470                                      force_to_mode (XEXP (x, 0), mode, mask,
8471                                                     next_select));
8472       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0))
8473         x = simplify_gen_unary (code, op_mode, op0, op_mode);
8474       break;
8475
8476     case NE:
8477       /* (and (ne FOO 0) CONST) can be (and FOO CONST) if CONST is included
8478          in STORE_FLAG_VALUE and FOO has a single bit that might be nonzero,
8479          which is equal to STORE_FLAG_VALUE.  */
8480       if ((mask & ~STORE_FLAG_VALUE) == 0
8481           && XEXP (x, 1) == const0_rtx
8482           && GET_MODE (XEXP (x, 0)) == mode
8483           && exact_log2 (nonzero_bits (XEXP (x, 0), mode)) >= 0
8484           && (nonzero_bits (XEXP (x, 0), mode)
8485               == (unsigned HOST_WIDE_INT) STORE_FLAG_VALUE))
8486         return force_to_mode (XEXP (x, 0), mode, mask, next_select);
8487
8488       break;
8489
8490     case IF_THEN_ELSE:
8491       /* We have no way of knowing if the IF_THEN_ELSE can itself be
8492          written in a narrower mode.  We play it safe and do not do so.  */
8493
8494       SUBST (XEXP (x, 1),
8495              gen_lowpart_or_truncate (GET_MODE (x),
8496                                       force_to_mode (XEXP (x, 1), mode,
8497                                                      mask, next_select)));
8498       SUBST (XEXP (x, 2),
8499              gen_lowpart_or_truncate (GET_MODE (x),
8500                                       force_to_mode (XEXP (x, 2), mode,
8501                                                      mask, next_select)));
8502       break;
8503
8504     default:
8505       break;
8506     }
8507
8508   /* Ensure we return a value of the proper mode.  */
8509   return gen_lowpart_or_truncate (mode, x);
8510 }
8511 \f
8512 /* Return nonzero if X is an expression that has one of two values depending on
8513    whether some other value is zero or nonzero.  In that case, we return the
8514    value that is being tested, *PTRUE is set to the value if the rtx being
8515    returned has a nonzero value, and *PFALSE is set to the other alternative.
8516
8517    If we return zero, we set *PTRUE and *PFALSE to X.  */
8518
8519 static rtx
8520 if_then_else_cond (rtx x, rtx *ptrue, rtx *pfalse)
8521 {
8522   enum machine_mode mode = GET_MODE (x);
8523   enum rtx_code code = GET_CODE (x);
8524   rtx cond0, cond1, true0, true1, false0, false1;
8525   unsigned HOST_WIDE_INT nz;
8526
8527   /* If we are comparing a value against zero, we are done.  */
8528   if ((code == NE || code == EQ)
8529       && XEXP (x, 1) == const0_rtx)
8530     {
8531       *ptrue = (code == NE) ? const_true_rtx : const0_rtx;
8532       *pfalse = (code == NE) ? const0_rtx : const_true_rtx;
8533       return XEXP (x, 0);
8534     }
8535
8536   /* If this is a unary operation whose operand has one of two values, apply
8537      our opcode to compute those values.  */
8538   else if (UNARY_P (x)
8539            && (cond0 = if_then_else_cond (XEXP (x, 0), &true0, &false0)) != 0)
8540     {
8541       *ptrue = simplify_gen_unary (code, mode, true0, GET_MODE (XEXP (x, 0)));
8542       *pfalse = simplify_gen_unary (code, mode, false0,
8543                                     GET_MODE (XEXP (x, 0)));
8544       return cond0;
8545     }
8546
8547   /* If this is a COMPARE, do nothing, since the IF_THEN_ELSE we would
8548      make can't possibly match and would suppress other optimizations.  */
8549   else if (code == COMPARE)
8550     ;
8551
8552   /* If this is a binary operation, see if either side has only one of two
8553      values.  If either one does or if both do and they are conditional on
8554      the same value, compute the new true and false values.  */
8555   else if (BINARY_P (x))
8556     {
8557       cond0 = if_then_else_cond (XEXP (x, 0), &true0, &false0);
8558       cond1 = if_then_else_cond (XEXP (x, 1), &true1, &false1);
8559
8560       if ((cond0 != 0 || cond1 != 0)
8561           && ! (cond0 != 0 && cond1 != 0 && ! rtx_equal_p (cond0, cond1)))
8562         {
8563           /* If if_then_else_cond returned zero, then true/false are the
8564              same rtl.  We must copy one of them to prevent invalid rtl
8565              sharing.  */
8566           if (cond0 == 0)
8567             true0 = copy_rtx (true0);
8568           else if (cond1 == 0)
8569             true1 = copy_rtx (true1);
8570
8571           if (COMPARISON_P (x))
8572             {
8573               *ptrue = simplify_gen_relational (code, mode, VOIDmode,
8574                                                 true0, true1);
8575               *pfalse = simplify_gen_relational (code, mode, VOIDmode,
8576                                                  false0, false1);
8577              }
8578           else
8579             {
8580               *ptrue = simplify_gen_binary (code, mode, true0, true1);
8581               *pfalse = simplify_gen_binary (code, mode, false0, false1);
8582             }
8583
8584           return cond0 ? cond0 : cond1;
8585         }
8586
8587       /* See if we have PLUS, IOR, XOR, MINUS or UMAX, where one of the
8588          operands is zero when the other is nonzero, and vice-versa,
8589          and STORE_FLAG_VALUE is 1 or -1.  */
8590
8591       if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
8592           && (code == PLUS || code == IOR || code == XOR || code == MINUS
8593               || code == UMAX)
8594           && GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == MULT)
8595         {
8596           rtx op0 = XEXP (XEXP (x, 0), 1);
8597           rtx op1 = XEXP (XEXP (x, 1), 1);
8598
8599           cond0 = XEXP (XEXP (x, 0), 0);
8600           cond1 = XEXP (XEXP (x, 1), 0);
8601
8602           if (COMPARISON_P (cond0)
8603               && COMPARISON_P (cond1)
8604               && ((GET_CODE (cond0) == reversed_comparison_code (cond1, NULL)
8605                    && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 0))
8606                    && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 1)))
8607                   || ((swap_condition (GET_CODE (cond0))
8608                        == reversed_comparison_code (cond1, NULL))
8609                       && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 1))
8610                       && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 0))))
8611               && ! side_effects_p (x))
8612             {
8613               *ptrue = simplify_gen_binary (MULT, mode, op0, const_true_rtx);
8614               *pfalse = simplify_gen_binary (MULT, mode,
8615                                              (code == MINUS
8616                                               ? simplify_gen_unary (NEG, mode,
8617                                                                     op1, mode)
8618                                               : op1),
8619                                               const_true_rtx);
8620               return cond0;
8621             }
8622         }
8623
8624       /* Similarly for MULT, AND and UMIN, except that for these the result
8625          is always zero.  */
8626       if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
8627           && (code == MULT || code == AND || code == UMIN)
8628           && GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == MULT)
8629         {
8630           cond0 = XEXP (XEXP (x, 0), 0);
8631           cond1 = XEXP (XEXP (x, 1), 0);
8632
8633           if (COMPARISON_P (cond0)
8634               && COMPARISON_P (cond1)
8635               && ((GET_CODE (cond0) == reversed_comparison_code (cond1, NULL)
8636                    && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 0))
8637                    && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 1)))
8638                   || ((swap_condition (GET_CODE (cond0))
8639                        == reversed_comparison_code (cond1, NULL))
8640                       && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 1))
8641                       && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 0))))
8642               && ! side_effects_p (x))
8643             {
8644               *ptrue = *pfalse = const0_rtx;
8645               return cond0;
8646             }
8647         }
8648     }
8649
8650   else if (code == IF_THEN_ELSE)
8651     {
8652       /* If we have IF_THEN_ELSE already, extract the condition and
8653          canonicalize it if it is NE or EQ.  */
8654       cond0 = XEXP (x, 0);
8655       *ptrue = XEXP (x, 1), *pfalse = XEXP (x, 2);
8656       if (GET_CODE (cond0) == NE && XEXP (cond0, 1) == const0_rtx)
8657         return XEXP (cond0, 0);
8658       else if (GET_CODE (cond0) == EQ && XEXP (cond0, 1) == const0_rtx)
8659         {
8660           *ptrue = XEXP (x, 2), *pfalse = XEXP (x, 1);
8661           return XEXP (cond0, 0);
8662         }
8663       else
8664         return cond0;
8665     }
8666
8667   /* If X is a SUBREG, we can narrow both the true and false values
8668      if the inner expression, if there is a condition.  */
8669   else if (code == SUBREG
8670            && 0 != (cond0 = if_then_else_cond (SUBREG_REG (x),
8671                                                &true0, &false0)))
8672     {
8673       true0 = simplify_gen_subreg (mode, true0,
8674                                    GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
8675       false0 = simplify_gen_subreg (mode, false0,
8676                                     GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
8677       if (true0 && false0)
8678         {
8679           *ptrue = true0;
8680           *pfalse = false0;
8681           return cond0;
8682         }
8683     }
8684
8685   /* If X is a constant, this isn't special and will cause confusions
8686      if we treat it as such.  Likewise if it is equivalent to a constant.  */
8687   else if (CONSTANT_P (x)
8688            || ((cond0 = get_last_value (x)) != 0 && CONSTANT_P (cond0)))
8689     ;
8690
8691   /* If we're in BImode, canonicalize on 0 and STORE_FLAG_VALUE, as that
8692      will be least confusing to the rest of the compiler.  */
8693   else if (mode == BImode)
8694     {
8695       *ptrue = GEN_INT (STORE_FLAG_VALUE), *pfalse = const0_rtx;
8696       return x;
8697     }
8698
8699   /* If X is known to be either 0 or -1, those are the true and
8700      false values when testing X.  */
8701   else if (x == constm1_rtx || x == const0_rtx
8702            || (mode != VOIDmode
8703                && num_sign_bit_copies (x, mode) == GET_MODE_BITSIZE (mode)))
8704     {
8705       *ptrue = constm1_rtx, *pfalse = const0_rtx;
8706       return x;
8707     }
8708
8709   /* Likewise for 0 or a single bit.  */
8710   else if (SCALAR_INT_MODE_P (mode)
8711            && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
8712            && exact_log2 (nz = nonzero_bits (x, mode)) >= 0)
8713     {
8714       *ptrue = gen_int_mode (nz, mode), *pfalse = const0_rtx;
8715       return x;
8716     }
8717
8718   /* Otherwise fail; show no condition with true and false values the same.  */
8719   *ptrue = *pfalse = x;
8720   return 0;
8721 }
8722 \f
8723 /* Return the value of expression X given the fact that condition COND
8724    is known to be true when applied to REG as its first operand and VAL
8725    as its second.  X is known to not be shared and so can be modified in
8726    place.
8727
8728    We only handle the simplest cases, and specifically those cases that
8729    arise with IF_THEN_ELSE expressions.  */
8730
8731 static rtx
8732 known_cond (rtx x, enum rtx_code cond, rtx reg, rtx val)
8733 {
8734   enum rtx_code code = GET_CODE (x);
8735   rtx temp;
8736   const char *fmt;
8737   int i, j;
8738
8739   if (side_effects_p (x))
8740     return x;
8741
8742   /* If either operand of the condition is a floating point value,
8743      then we have to avoid collapsing an EQ comparison.  */
8744   if (cond == EQ
8745       && rtx_equal_p (x, reg)
8746       && ! FLOAT_MODE_P (GET_MODE (x))
8747       && ! FLOAT_MODE_P (GET_MODE (val)))
8748     return val;
8749
8750   if (cond == UNEQ && rtx_equal_p (x, reg))
8751     return val;
8752
8753   /* If X is (abs REG) and we know something about REG's relationship
8754      with zero, we may be able to simplify this.  */
8755
8756   if (code == ABS && rtx_equal_p (XEXP (x, 0), reg) && val == const0_rtx)
8757     switch (cond)
8758       {
8759       case GE:  case GT:  case EQ:
8760         return XEXP (x, 0);
8761       case LT:  case LE:
8762         return simplify_gen_unary (NEG, GET_MODE (XEXP (x, 0)),
8763                                    XEXP (x, 0),
8764                                    GET_MODE (XEXP (x, 0)));
8765       default:
8766         break;
8767       }
8768
8769   /* The only other cases we handle are MIN, MAX, and comparisons if the
8770      operands are the same as REG and VAL.  */
8771
8772   else if (COMPARISON_P (x) || COMMUTATIVE_ARITH_P (x))
8773     {
8774       if (rtx_equal_p (XEXP (x, 0), val))
8775         cond = swap_condition (cond), temp = val, val = reg, reg = temp;
8776
8777       if (rtx_equal_p (XEXP (x, 0), reg) && rtx_equal_p (XEXP (x, 1), val))
8778         {
8779           if (COMPARISON_P (x))
8780             {
8781               if (comparison_dominates_p (cond, code))
8782                 return const_true_rtx;
8783
8784               code = reversed_comparison_code (x, NULL);
8785               if (code != UNKNOWN
8786                   && comparison_dominates_p (cond, code))
8787                 return const0_rtx;
8788               else
8789                 return x;
8790             }
8791           else if (code == SMAX || code == SMIN
8792                    || code == UMIN || code == UMAX)
8793             {
8794               int unsignedp = (code == UMIN || code == UMAX);
8795
8796               /* Do not reverse the condition when it is NE or EQ.
8797                  This is because we cannot conclude anything about
8798                  the value of 'SMAX (x, y)' when x is not equal to y,
8799                  but we can when x equals y.  */
8800               if ((code == SMAX || code == UMAX)
8801                   && ! (cond == EQ || cond == NE))
8802                 cond = reverse_condition (cond);
8803
8804               switch (cond)
8805                 {
8806                 case GE:   case GT:
8807                   return unsignedp ? x : XEXP (x, 1);
8808                 case LE:   case LT:
8809                   return unsignedp ? x : XEXP (x, 0);
8810                 case GEU:  case GTU:
8811                   return unsignedp ? XEXP (x, 1) : x;
8812                 case LEU:  case LTU:
8813                   return unsignedp ? XEXP (x, 0) : x;
8814                 default:
8815                   break;
8816                 }
8817             }
8818         }
8819     }
8820   else if (code == SUBREG)
8821     {
8822       enum machine_mode inner_mode = GET_MODE (SUBREG_REG (x));
8823       rtx new_rtx, r = known_cond (SUBREG_REG (x), cond, reg, val);
8824
8825       if (SUBREG_REG (x) != r)
8826         {
8827           /* We must simplify subreg here, before we lose track of the
8828              original inner_mode.  */
8829           new_rtx = simplify_subreg (GET_MODE (x), r,
8830                                  inner_mode, SUBREG_BYTE (x));
8831           if (new_rtx)
8832             return new_rtx;
8833           else
8834             SUBST (SUBREG_REG (x), r);
8835         }
8836
8837       return x;
8838     }
8839   /* We don't have to handle SIGN_EXTEND here, because even in the
8840      case of replacing something with a modeless CONST_INT, a
8841      CONST_INT is already (supposed to be) a valid sign extension for
8842      its narrower mode, which implies it's already properly
8843      sign-extended for the wider mode.  Now, for ZERO_EXTEND, the
8844      story is different.  */
8845   else if (code == ZERO_EXTEND)
8846     {
8847       enum machine_mode inner_mode = GET_MODE (XEXP (x, 0));
8848       rtx new_rtx, r = known_cond (XEXP (x, 0), cond, reg, val);
8849
8850       if (XEXP (x, 0) != r)
8851         {
8852           /* We must simplify the zero_extend here, before we lose
8853              track of the original inner_mode.  */
8854           new_rtx = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
8855                                           r, inner_mode);
8856           if (new_rtx)
8857             return new_rtx;
8858           else
8859             SUBST (XEXP (x, 0), r);
8860         }
8861
8862       return x;
8863     }
8864
8865   fmt = GET_RTX_FORMAT (code);
8866   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
8867     {
8868       if (fmt[i] == 'e')
8869         SUBST (XEXP (x, i), known_cond (XEXP (x, i), cond, reg, val));
8870       else if (fmt[i] == 'E')
8871         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
8872           SUBST (XVECEXP (x, i, j), known_cond (XVECEXP (x, i, j),
8873                                                 cond, reg, val));
8874     }
8875
8876   return x;
8877 }
8878 \f
8879 /* See if X and Y are equal for the purposes of seeing if we can rewrite an
8880    assignment as a field assignment.  */
8881
8882 static int
8883 rtx_equal_for_field_assignment_p (rtx x, rtx y)
8884 {
8885   if (x == y || rtx_equal_p (x, y))
8886     return 1;
8887
8888   if (x == 0 || y == 0 || GET_MODE (x) != GET_MODE (y))
8889     return 0;
8890
8891   /* Check for a paradoxical SUBREG of a MEM compared with the MEM.
8892      Note that all SUBREGs of MEM are paradoxical; otherwise they
8893      would have been rewritten.  */
8894   if (MEM_P (x) && GET_CODE (y) == SUBREG
8895       && MEM_P (SUBREG_REG (y))
8896       && rtx_equal_p (SUBREG_REG (y),
8897                       gen_lowpart (GET_MODE (SUBREG_REG (y)), x)))
8898     return 1;
8899
8900   if (MEM_P (y) && GET_CODE (x) == SUBREG
8901       && MEM_P (SUBREG_REG (x))
8902       && rtx_equal_p (SUBREG_REG (x),
8903                       gen_lowpart (GET_MODE (SUBREG_REG (x)), y)))
8904     return 1;
8905
8906   /* We used to see if get_last_value of X and Y were the same but that's
8907      not correct.  In one direction, we'll cause the assignment to have
8908      the wrong destination and in the case, we'll import a register into this
8909      insn that might have already have been dead.   So fail if none of the
8910      above cases are true.  */
8911   return 0;
8912 }
8913 \f
8914 /* See if X, a SET operation, can be rewritten as a bit-field assignment.
8915    Return that assignment if so.
8916
8917    We only handle the most common cases.  */
8918
8919 static rtx
8920 make_field_assignment (rtx x)
8921 {
8922   rtx dest = SET_DEST (x);
8923   rtx src = SET_SRC (x);
8924   rtx assign;
8925   rtx rhs, lhs;
8926   HOST_WIDE_INT c1;
8927   HOST_WIDE_INT pos;
8928   unsigned HOST_WIDE_INT len;
8929   rtx other;
8930   enum machine_mode mode;
8931
8932   /* If SRC was (and (not (ashift (const_int 1) POS)) DEST), this is
8933      a clear of a one-bit field.  We will have changed it to
8934      (and (rotate (const_int -2) POS) DEST), so check for that.  Also check
8935      for a SUBREG.  */
8936
8937   if (GET_CODE (src) == AND && GET_CODE (XEXP (src, 0)) == ROTATE
8938       && CONST_INT_P (XEXP (XEXP (src, 0), 0))
8939       && INTVAL (XEXP (XEXP (src, 0), 0)) == -2
8940       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
8941     {
8942       assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
8943                                 1, 1, 1, 0);
8944       if (assign != 0)
8945         return gen_rtx_SET (VOIDmode, assign, const0_rtx);
8946       return x;
8947     }
8948
8949   if (GET_CODE (src) == AND && GET_CODE (XEXP (src, 0)) == SUBREG
8950       && subreg_lowpart_p (XEXP (src, 0))
8951       && (GET_MODE_SIZE (GET_MODE (XEXP (src, 0)))
8952           < GET_MODE_SIZE (GET_MODE (SUBREG_REG (XEXP (src, 0)))))
8953       && GET_CODE (SUBREG_REG (XEXP (src, 0))) == ROTATE
8954       && CONST_INT_P (XEXP (SUBREG_REG (XEXP (src, 0)), 0))
8955       && INTVAL (XEXP (SUBREG_REG (XEXP (src, 0)), 0)) == -2
8956       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
8957     {
8958       assign = make_extraction (VOIDmode, dest, 0,
8959                                 XEXP (SUBREG_REG (XEXP (src, 0)), 1),
8960                                 1, 1, 1, 0);
8961       if (assign != 0)
8962         return gen_rtx_SET (VOIDmode, assign, const0_rtx);
8963       return x;
8964     }
8965
8966   /* If SRC is (ior (ashift (const_int 1) POS) DEST), this is a set of a
8967      one-bit field.  */
8968   if (GET_CODE (src) == IOR && GET_CODE (XEXP (src, 0)) == ASHIFT
8969       && XEXP (XEXP (src, 0), 0) == const1_rtx
8970       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
8971     {
8972       assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
8973                                 1, 1, 1, 0);
8974       if (assign != 0)
8975         return gen_rtx_SET (VOIDmode, assign, const1_rtx);
8976       return x;
8977     }
8978
8979   /* If DEST is already a field assignment, i.e. ZERO_EXTRACT, and the
8980      SRC is an AND with all bits of that field set, then we can discard
8981      the AND.  */
8982   if (GET_CODE (dest) == ZERO_EXTRACT
8983       && CONST_INT_P (XEXP (dest, 1))
8984       && GET_CODE (src) == AND
8985       && CONST_INT_P (XEXP (src, 1)))
8986     {
8987       HOST_WIDE_INT width = INTVAL (XEXP (dest, 1));
8988       unsigned HOST_WIDE_INT and_mask = INTVAL (XEXP (src, 1));
8989       unsigned HOST_WIDE_INT ze_mask;
8990
8991       if (width >= HOST_BITS_PER_WIDE_INT)
8992         ze_mask = -1;
8993       else
8994         ze_mask = ((unsigned HOST_WIDE_INT)1 << width) - 1;
8995
8996       /* Complete overlap.  We can remove the source AND.  */
8997       if ((and_mask & ze_mask) == ze_mask)
8998         return gen_rtx_SET (VOIDmode, dest, XEXP (src, 0));
8999
9000       /* Partial overlap.  We can reduce the source AND.  */
9001       if ((and_mask & ze_mask) != and_mask)
9002         {
9003           mode = GET_MODE (src);
9004           src = gen_rtx_AND (mode, XEXP (src, 0),
9005                              gen_int_mode (and_mask & ze_mask, mode));
9006           return gen_rtx_SET (VOIDmode, dest, src);
9007         }
9008     }
9009
9010   /* The other case we handle is assignments into a constant-position
9011      field.  They look like (ior/xor (and DEST C1) OTHER).  If C1 represents
9012      a mask that has all one bits except for a group of zero bits and
9013      OTHER is known to have zeros where C1 has ones, this is such an
9014      assignment.  Compute the position and length from C1.  Shift OTHER
9015      to the appropriate position, force it to the required mode, and
9016      make the extraction.  Check for the AND in both operands.  */
9017
9018   if (GET_CODE (src) != IOR && GET_CODE (src) != XOR)
9019     return x;
9020
9021   rhs = expand_compound_operation (XEXP (src, 0));
9022   lhs = expand_compound_operation (XEXP (src, 1));
9023
9024   if (GET_CODE (rhs) == AND
9025       && CONST_INT_P (XEXP (rhs, 1))
9026       && rtx_equal_for_field_assignment_p (XEXP (rhs, 0), dest))
9027     c1 = INTVAL (XEXP (rhs, 1)), other = lhs;
9028   else if (GET_CODE (lhs) == AND
9029            && CONST_INT_P (XEXP (lhs, 1))
9030            && rtx_equal_for_field_assignment_p (XEXP (lhs, 0), dest))
9031     c1 = INTVAL (XEXP (lhs, 1)), other = rhs;
9032   else
9033     return x;
9034
9035   pos = get_pos_from_mask ((~c1) & GET_MODE_MASK (GET_MODE (dest)), &len);
9036   if (pos < 0 || pos + len > GET_MODE_BITSIZE (GET_MODE (dest))
9037       || GET_MODE_BITSIZE (GET_MODE (dest)) > HOST_BITS_PER_WIDE_INT
9038       || (c1 & nonzero_bits (other, GET_MODE (dest))) != 0)
9039     return x;
9040
9041   assign = make_extraction (VOIDmode, dest, pos, NULL_RTX, len, 1, 1, 0);
9042   if (assign == 0)
9043     return x;
9044
9045   /* The mode to use for the source is the mode of the assignment, or of
9046      what is inside a possible STRICT_LOW_PART.  */
9047   mode = (GET_CODE (assign) == STRICT_LOW_PART
9048           ? GET_MODE (XEXP (assign, 0)) : GET_MODE (assign));
9049
9050   /* Shift OTHER right POS places and make it the source, restricting it
9051      to the proper length and mode.  */
9052
9053   src = canon_reg_for_combine (simplify_shift_const (NULL_RTX, LSHIFTRT,
9054                                                      GET_MODE (src),
9055                                                      other, pos),
9056                                dest);
9057   src = force_to_mode (src, mode,
9058                        GET_MODE_BITSIZE (mode) >= HOST_BITS_PER_WIDE_INT
9059                        ? ~(unsigned HOST_WIDE_INT) 0
9060                        : ((unsigned HOST_WIDE_INT) 1 << len) - 1,
9061                        0);
9062
9063   /* If SRC is masked by an AND that does not make a difference in
9064      the value being stored, strip it.  */
9065   if (GET_CODE (assign) == ZERO_EXTRACT
9066       && CONST_INT_P (XEXP (assign, 1))
9067       && INTVAL (XEXP (assign, 1)) < HOST_BITS_PER_WIDE_INT
9068       && GET_CODE (src) == AND
9069       && CONST_INT_P (XEXP (src, 1))
9070       && UINTVAL (XEXP (src, 1))
9071          == ((unsigned HOST_WIDE_INT) 1 << INTVAL (XEXP (assign, 1))) - 1)
9072     src = XEXP (src, 0);
9073
9074   return gen_rtx_SET (VOIDmode, assign, src);
9075 }
9076 \f
9077 /* See if X is of the form (+ (* a c) (* b c)) and convert to (* (+ a b) c)
9078    if so.  */
9079
9080 static rtx
9081 apply_distributive_law (rtx x)
9082 {
9083   enum rtx_code code = GET_CODE (x);
9084   enum rtx_code inner_code;
9085   rtx lhs, rhs, other;
9086   rtx tem;
9087
9088   /* Distributivity is not true for floating point as it can change the
9089      value.  So we don't do it unless -funsafe-math-optimizations.  */
9090   if (FLOAT_MODE_P (GET_MODE (x))
9091       && ! flag_unsafe_math_optimizations)
9092     return x;
9093
9094   /* The outer operation can only be one of the following:  */
9095   if (code != IOR && code != AND && code != XOR
9096       && code != PLUS && code != MINUS)
9097     return x;
9098
9099   lhs = XEXP (x, 0);
9100   rhs = XEXP (x, 1);
9101
9102   /* If either operand is a primitive we can't do anything, so get out
9103      fast.  */
9104   if (OBJECT_P (lhs) || OBJECT_P (rhs))
9105     return x;
9106
9107   lhs = expand_compound_operation (lhs);
9108   rhs = expand_compound_operation (rhs);
9109   inner_code = GET_CODE (lhs);
9110   if (inner_code != GET_CODE (rhs))
9111     return x;
9112
9113   /* See if the inner and outer operations distribute.  */
9114   switch (inner_code)
9115     {
9116     case LSHIFTRT:
9117     case ASHIFTRT:
9118     case AND:
9119     case IOR:
9120       /* These all distribute except over PLUS.  */
9121       if (code == PLUS || code == MINUS)
9122         return x;
9123       break;
9124
9125     case MULT:
9126       if (code != PLUS && code != MINUS)
9127         return x;
9128       break;
9129
9130     case ASHIFT:
9131       /* This is also a multiply, so it distributes over everything.  */
9132       break;
9133
9134     case SUBREG:
9135       /* Non-paradoxical SUBREGs distributes over all operations,
9136          provided the inner modes and byte offsets are the same, this
9137          is an extraction of a low-order part, we don't convert an fp
9138          operation to int or vice versa, this is not a vector mode,
9139          and we would not be converting a single-word operation into a
9140          multi-word operation.  The latter test is not required, but
9141          it prevents generating unneeded multi-word operations.  Some
9142          of the previous tests are redundant given the latter test,
9143          but are retained because they are required for correctness.
9144
9145          We produce the result slightly differently in this case.  */
9146
9147       if (GET_MODE (SUBREG_REG (lhs)) != GET_MODE (SUBREG_REG (rhs))
9148           || SUBREG_BYTE (lhs) != SUBREG_BYTE (rhs)
9149           || ! subreg_lowpart_p (lhs)
9150           || (GET_MODE_CLASS (GET_MODE (lhs))
9151               != GET_MODE_CLASS (GET_MODE (SUBREG_REG (lhs))))
9152           || (GET_MODE_SIZE (GET_MODE (lhs))
9153               > GET_MODE_SIZE (GET_MODE (SUBREG_REG (lhs))))
9154           || VECTOR_MODE_P (GET_MODE (lhs))
9155           || GET_MODE_SIZE (GET_MODE (SUBREG_REG (lhs))) > UNITS_PER_WORD
9156           /* Result might need to be truncated.  Don't change mode if
9157              explicit truncation is needed.  */
9158           || !TRULY_NOOP_TRUNCATION
9159                (GET_MODE_BITSIZE (GET_MODE (x)),
9160                 GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (lhs)))))
9161         return x;
9162
9163       tem = simplify_gen_binary (code, GET_MODE (SUBREG_REG (lhs)),
9164                                  SUBREG_REG (lhs), SUBREG_REG (rhs));
9165       return gen_lowpart (GET_MODE (x), tem);
9166
9167     default:
9168       return x;
9169     }
9170
9171   /* Set LHS and RHS to the inner operands (A and B in the example
9172      above) and set OTHER to the common operand (C in the example).
9173      There is only one way to do this unless the inner operation is
9174      commutative.  */
9175   if (COMMUTATIVE_ARITH_P (lhs)
9176       && rtx_equal_p (XEXP (lhs, 0), XEXP (rhs, 0)))
9177     other = XEXP (lhs, 0), lhs = XEXP (lhs, 1), rhs = XEXP (rhs, 1);
9178   else if (COMMUTATIVE_ARITH_P (lhs)
9179            && rtx_equal_p (XEXP (lhs, 0), XEXP (rhs, 1)))
9180     other = XEXP (lhs, 0), lhs = XEXP (lhs, 1), rhs = XEXP (rhs, 0);
9181   else if (COMMUTATIVE_ARITH_P (lhs)
9182            && rtx_equal_p (XEXP (lhs, 1), XEXP (rhs, 0)))
9183     other = XEXP (lhs, 1), lhs = XEXP (lhs, 0), rhs = XEXP (rhs, 1);
9184   else if (rtx_equal_p (XEXP (lhs, 1), XEXP (rhs, 1)))
9185     other = XEXP (lhs, 1), lhs = XEXP (lhs, 0), rhs = XEXP (rhs, 0);
9186   else
9187     return x;
9188
9189   /* Form the new inner operation, seeing if it simplifies first.  */
9190   tem = simplify_gen_binary (code, GET_MODE (x), lhs, rhs);
9191
9192   /* There is one exception to the general way of distributing:
9193      (a | c) ^ (b | c) -> (a ^ b) & ~c  */
9194   if (code == XOR && inner_code == IOR)
9195     {
9196       inner_code = AND;
9197       other = simplify_gen_unary (NOT, GET_MODE (x), other, GET_MODE (x));
9198     }
9199
9200   /* We may be able to continuing distributing the result, so call
9201      ourselves recursively on the inner operation before forming the
9202      outer operation, which we return.  */
9203   return simplify_gen_binary (inner_code, GET_MODE (x),
9204                               apply_distributive_law (tem), other);
9205 }
9206
9207 /* See if X is of the form (* (+ A B) C), and if so convert to
9208    (+ (* A C) (* B C)) and try to simplify.
9209
9210    Most of the time, this results in no change.  However, if some of
9211    the operands are the same or inverses of each other, simplifications
9212    will result.
9213
9214    For example, (and (ior A B) (not B)) can occur as the result of
9215    expanding a bit field assignment.  When we apply the distributive
9216    law to this, we get (ior (and (A (not B))) (and (B (not B)))),
9217    which then simplifies to (and (A (not B))).
9218
9219    Note that no checks happen on the validity of applying the inverse
9220    distributive law.  This is pointless since we can do it in the
9221    few places where this routine is called.
9222
9223    N is the index of the term that is decomposed (the arithmetic operation,
9224    i.e. (+ A B) in the first example above).  !N is the index of the term that
9225    is distributed, i.e. of C in the first example above.  */
9226 static rtx
9227 distribute_and_simplify_rtx (rtx x, int n)
9228 {
9229   enum machine_mode mode;
9230   enum rtx_code outer_code, inner_code;
9231   rtx decomposed, distributed, inner_op0, inner_op1, new_op0, new_op1, tmp;
9232
9233   /* Distributivity is not true for floating point as it can change the
9234      value.  So we don't do it unless -funsafe-math-optimizations.  */
9235   if (FLOAT_MODE_P (GET_MODE (x))
9236       && ! flag_unsafe_math_optimizations)
9237     return NULL_RTX;
9238
9239   decomposed = XEXP (x, n);
9240   if (!ARITHMETIC_P (decomposed))
9241     return NULL_RTX;
9242
9243   mode = GET_MODE (x);
9244   outer_code = GET_CODE (x);
9245   distributed = XEXP (x, !n);
9246
9247   inner_code = GET_CODE (decomposed);
9248   inner_op0 = XEXP (decomposed, 0);
9249   inner_op1 = XEXP (decomposed, 1);
9250
9251   /* Special case (and (xor B C) (not A)), which is equivalent to
9252      (xor (ior A B) (ior A C))  */
9253   if (outer_code == AND && inner_code == XOR && GET_CODE (distributed) == NOT)
9254     {
9255       distributed = XEXP (distributed, 0);
9256       outer_code = IOR;
9257     }
9258
9259   if (n == 0)
9260     {
9261       /* Distribute the second term.  */
9262       new_op0 = simplify_gen_binary (outer_code, mode, inner_op0, distributed);
9263       new_op1 = simplify_gen_binary (outer_code, mode, inner_op1, distributed);
9264     }
9265   else
9266     {
9267       /* Distribute the first term.  */
9268       new_op0 = simplify_gen_binary (outer_code, mode, distributed, inner_op0);
9269       new_op1 = simplify_gen_binary (outer_code, mode, distributed, inner_op1);
9270     }
9271
9272   tmp = apply_distributive_law (simplify_gen_binary (inner_code, mode,
9273                                                      new_op0, new_op1));
9274   if (GET_CODE (tmp) != outer_code
9275       && rtx_cost (tmp, SET, optimize_this_for_speed_p)
9276          < rtx_cost (x, SET, optimize_this_for_speed_p))
9277     return tmp;
9278
9279   return NULL_RTX;
9280 }
9281 \f
9282 /* Simplify a logical `and' of VAROP with the constant CONSTOP, to be done
9283    in MODE.  Return an equivalent form, if different from (and VAROP
9284    (const_int CONSTOP)).  Otherwise, return NULL_RTX.  */
9285
9286 static rtx
9287 simplify_and_const_int_1 (enum machine_mode mode, rtx varop,
9288                           unsigned HOST_WIDE_INT constop)
9289 {
9290   unsigned HOST_WIDE_INT nonzero;
9291   unsigned HOST_WIDE_INT orig_constop;
9292   rtx orig_varop;
9293   int i;
9294
9295   orig_varop = varop;
9296   orig_constop = constop;
9297   if (GET_CODE (varop) == CLOBBER)
9298     return NULL_RTX;
9299
9300   /* Simplify VAROP knowing that we will be only looking at some of the
9301      bits in it.
9302
9303      Note by passing in CONSTOP, we guarantee that the bits not set in
9304      CONSTOP are not significant and will never be examined.  We must
9305      ensure that is the case by explicitly masking out those bits
9306      before returning.  */
9307   varop = force_to_mode (varop, mode, constop, 0);
9308
9309   /* If VAROP is a CLOBBER, we will fail so return it.  */
9310   if (GET_CODE (varop) == CLOBBER)
9311     return varop;
9312
9313   /* If VAROP is a CONST_INT, then we need to apply the mask in CONSTOP
9314      to VAROP and return the new constant.  */
9315   if (CONST_INT_P (varop))
9316     return gen_int_mode (INTVAL (varop) & constop, mode);
9317
9318   /* See what bits may be nonzero in VAROP.  Unlike the general case of
9319      a call to nonzero_bits, here we don't care about bits outside
9320      MODE.  */
9321
9322   nonzero = nonzero_bits (varop, mode) & GET_MODE_MASK (mode);
9323
9324   /* Turn off all bits in the constant that are known to already be zero.
9325      Thus, if the AND isn't needed at all, we will have CONSTOP == NONZERO_BITS
9326      which is tested below.  */
9327
9328   constop &= nonzero;
9329
9330   /* If we don't have any bits left, return zero.  */
9331   if (constop == 0)
9332     return const0_rtx;
9333
9334   /* If VAROP is a NEG of something known to be zero or 1 and CONSTOP is
9335      a power of two, we can replace this with an ASHIFT.  */
9336   if (GET_CODE (varop) == NEG && nonzero_bits (XEXP (varop, 0), mode) == 1
9337       && (i = exact_log2 (constop)) >= 0)
9338     return simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (varop, 0), i);
9339
9340   /* If VAROP is an IOR or XOR, apply the AND to both branches of the IOR
9341      or XOR, then try to apply the distributive law.  This may eliminate
9342      operations if either branch can be simplified because of the AND.
9343      It may also make some cases more complex, but those cases probably
9344      won't match a pattern either with or without this.  */
9345
9346   if (GET_CODE (varop) == IOR || GET_CODE (varop) == XOR)
9347     return
9348       gen_lowpart
9349         (mode,
9350          apply_distributive_law
9351          (simplify_gen_binary (GET_CODE (varop), GET_MODE (varop),
9352                                simplify_and_const_int (NULL_RTX,
9353                                                        GET_MODE (varop),
9354                                                        XEXP (varop, 0),
9355                                                        constop),
9356                                simplify_and_const_int (NULL_RTX,
9357                                                        GET_MODE (varop),
9358                                                        XEXP (varop, 1),
9359                                                        constop))));
9360
9361   /* If VAROP is PLUS, and the constant is a mask of low bits, distribute
9362      the AND and see if one of the operands simplifies to zero.  If so, we
9363      may eliminate it.  */
9364
9365   if (GET_CODE (varop) == PLUS
9366       && exact_log2 (constop + 1) >= 0)
9367     {
9368       rtx o0, o1;
9369
9370       o0 = simplify_and_const_int (NULL_RTX, mode, XEXP (varop, 0), constop);
9371       o1 = simplify_and_const_int (NULL_RTX, mode, XEXP (varop, 1), constop);
9372       if (o0 == const0_rtx)
9373         return o1;
9374       if (o1 == const0_rtx)
9375         return o0;
9376     }
9377
9378   /* Make a SUBREG if necessary.  If we can't make it, fail.  */
9379   varop = gen_lowpart (mode, varop);
9380   if (varop == NULL_RTX || GET_CODE (varop) == CLOBBER)
9381     return NULL_RTX;
9382
9383   /* If we are only masking insignificant bits, return VAROP.  */
9384   if (constop == nonzero)
9385     return varop;
9386
9387   if (varop == orig_varop && constop == orig_constop)
9388     return NULL_RTX;
9389
9390   /* Otherwise, return an AND.  */
9391   return simplify_gen_binary (AND, mode, varop, gen_int_mode (constop, mode));
9392 }
9393
9394
9395 /* We have X, a logical `and' of VAROP with the constant CONSTOP, to be done
9396    in MODE.
9397
9398    Return an equivalent form, if different from X.  Otherwise, return X.  If
9399    X is zero, we are to always construct the equivalent form.  */
9400
9401 static rtx
9402 simplify_and_const_int (rtx x, enum machine_mode mode, rtx varop,
9403                         unsigned HOST_WIDE_INT constop)
9404 {
9405   rtx tem = simplify_and_const_int_1 (mode, varop, constop);
9406   if (tem)
9407     return tem;
9408
9409   if (!x)
9410     x = simplify_gen_binary (AND, GET_MODE (varop), varop,
9411                              gen_int_mode (constop, mode));
9412   if (GET_MODE (x) != mode)
9413     x = gen_lowpart (mode, x);
9414   return x;
9415 }
9416 \f
9417 /* Given a REG, X, compute which bits in X can be nonzero.
9418    We don't care about bits outside of those defined in MODE.
9419
9420    For most X this is simply GET_MODE_MASK (GET_MODE (MODE)), but if X is
9421    a shift, AND, or zero_extract, we can do better.  */
9422
9423 static rtx
9424 reg_nonzero_bits_for_combine (const_rtx x, enum machine_mode mode,
9425                               const_rtx known_x ATTRIBUTE_UNUSED,
9426                               enum machine_mode known_mode ATTRIBUTE_UNUSED,
9427                               unsigned HOST_WIDE_INT known_ret ATTRIBUTE_UNUSED,
9428                               unsigned HOST_WIDE_INT *nonzero)
9429 {
9430   rtx tem;
9431   reg_stat_type *rsp;
9432
9433   /* If X is a register whose nonzero bits value is current, use it.
9434      Otherwise, if X is a register whose value we can find, use that
9435      value.  Otherwise, use the previously-computed global nonzero bits
9436      for this register.  */
9437
9438   rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
9439   if (rsp->last_set_value != 0
9440       && (rsp->last_set_mode == mode
9441           || (GET_MODE_CLASS (rsp->last_set_mode) == MODE_INT
9442               && GET_MODE_CLASS (mode) == MODE_INT))
9443       && ((rsp->last_set_label >= label_tick_ebb_start
9444            && rsp->last_set_label < label_tick)
9445           || (rsp->last_set_label == label_tick
9446               && DF_INSN_LUID (rsp->last_set) < subst_low_luid)
9447           || (REGNO (x) >= FIRST_PSEUDO_REGISTER
9448               && REG_N_SETS (REGNO (x)) == 1
9449               && !REGNO_REG_SET_P
9450                   (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x)))))
9451     {
9452       *nonzero &= rsp->last_set_nonzero_bits;
9453       return NULL;
9454     }
9455
9456   tem = get_last_value (x);
9457
9458   if (tem)
9459     {
9460 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
9461       /* If X is narrower than MODE and TEM is a non-negative
9462          constant that would appear negative in the mode of X,
9463          sign-extend it for use in reg_nonzero_bits because some
9464          machines (maybe most) will actually do the sign-extension
9465          and this is the conservative approach.
9466
9467          ??? For 2.5, try to tighten up the MD files in this regard
9468          instead of this kludge.  */
9469
9470       if (GET_MODE_BITSIZE (GET_MODE (x)) < GET_MODE_BITSIZE (mode)
9471           && CONST_INT_P (tem)
9472           && INTVAL (tem) > 0
9473           && 0 != (UINTVAL (tem)
9474                    & ((unsigned HOST_WIDE_INT) 1
9475                       << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
9476         tem = GEN_INT (UINTVAL (tem)
9477                        | ((unsigned HOST_WIDE_INT) (-1)
9478                           << GET_MODE_BITSIZE (GET_MODE (x))));
9479 #endif
9480       return tem;
9481     }
9482   else if (nonzero_sign_valid && rsp->nonzero_bits)
9483     {
9484       unsigned HOST_WIDE_INT mask = rsp->nonzero_bits;
9485
9486       if (GET_MODE_BITSIZE (GET_MODE (x)) < GET_MODE_BITSIZE (mode))
9487         /* We don't know anything about the upper bits.  */
9488         mask |= GET_MODE_MASK (mode) ^ GET_MODE_MASK (GET_MODE (x));
9489       *nonzero &= mask;
9490     }
9491
9492   return NULL;
9493 }
9494
9495 /* Return the number of bits at the high-order end of X that are known to
9496    be equal to the sign bit.  X will be used in mode MODE; if MODE is
9497    VOIDmode, X will be used in its own mode.  The returned value  will always
9498    be between 1 and the number of bits in MODE.  */
9499
9500 static rtx
9501 reg_num_sign_bit_copies_for_combine (const_rtx x, enum machine_mode mode,
9502                                      const_rtx known_x ATTRIBUTE_UNUSED,
9503                                      enum machine_mode known_mode
9504                                      ATTRIBUTE_UNUSED,
9505                                      unsigned int known_ret ATTRIBUTE_UNUSED,
9506                                      unsigned int *result)
9507 {
9508   rtx tem;
9509   reg_stat_type *rsp;
9510
9511   rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
9512   if (rsp->last_set_value != 0
9513       && rsp->last_set_mode == mode
9514       && ((rsp->last_set_label >= label_tick_ebb_start
9515            && rsp->last_set_label < label_tick)
9516           || (rsp->last_set_label == label_tick
9517               && DF_INSN_LUID (rsp->last_set) < subst_low_luid)
9518           || (REGNO (x) >= FIRST_PSEUDO_REGISTER
9519               && REG_N_SETS (REGNO (x)) == 1
9520               && !REGNO_REG_SET_P
9521                   (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x)))))
9522     {
9523       *result = rsp->last_set_sign_bit_copies;
9524       return NULL;
9525     }
9526
9527   tem = get_last_value (x);
9528   if (tem != 0)
9529     return tem;
9530
9531   if (nonzero_sign_valid && rsp->sign_bit_copies != 0
9532       && GET_MODE_BITSIZE (GET_MODE (x)) == GET_MODE_BITSIZE (mode))
9533     *result = rsp->sign_bit_copies;
9534
9535   return NULL;
9536 }
9537 \f
9538 /* Return the number of "extended" bits there are in X, when interpreted
9539    as a quantity in MODE whose signedness is indicated by UNSIGNEDP.  For
9540    unsigned quantities, this is the number of high-order zero bits.
9541    For signed quantities, this is the number of copies of the sign bit
9542    minus 1.  In both case, this function returns the number of "spare"
9543    bits.  For example, if two quantities for which this function returns
9544    at least 1 are added, the addition is known not to overflow.
9545
9546    This function will always return 0 unless called during combine, which
9547    implies that it must be called from a define_split.  */
9548
9549 unsigned int
9550 extended_count (const_rtx x, enum machine_mode mode, int unsignedp)
9551 {
9552   if (nonzero_sign_valid == 0)
9553     return 0;
9554
9555   return (unsignedp
9556           ? (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9557              ? (unsigned int) (GET_MODE_BITSIZE (mode) - 1
9558                                - floor_log2 (nonzero_bits (x, mode)))
9559              : 0)
9560           : num_sign_bit_copies (x, mode) - 1);
9561 }
9562 \f
9563 /* This function is called from `simplify_shift_const' to merge two
9564    outer operations.  Specifically, we have already found that we need
9565    to perform operation *POP0 with constant *PCONST0 at the outermost
9566    position.  We would now like to also perform OP1 with constant CONST1
9567    (with *POP0 being done last).
9568
9569    Return 1 if we can do the operation and update *POP0 and *PCONST0 with
9570    the resulting operation.  *PCOMP_P is set to 1 if we would need to
9571    complement the innermost operand, otherwise it is unchanged.
9572
9573    MODE is the mode in which the operation will be done.  No bits outside
9574    the width of this mode matter.  It is assumed that the width of this mode
9575    is smaller than or equal to HOST_BITS_PER_WIDE_INT.
9576
9577    If *POP0 or OP1 are UNKNOWN, it means no operation is required.  Only NEG, PLUS,
9578    IOR, XOR, and AND are supported.  We may set *POP0 to SET if the proper
9579    result is simply *PCONST0.
9580
9581    If the resulting operation cannot be expressed as one operation, we
9582    return 0 and do not change *POP0, *PCONST0, and *PCOMP_P.  */
9583
9584 static int
9585 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)
9586 {
9587   enum rtx_code op0 = *pop0;
9588   HOST_WIDE_INT const0 = *pconst0;
9589
9590   const0 &= GET_MODE_MASK (mode);
9591   const1 &= GET_MODE_MASK (mode);
9592
9593   /* If OP0 is an AND, clear unimportant bits in CONST1.  */
9594   if (op0 == AND)
9595     const1 &= const0;
9596
9597   /* If OP0 or OP1 is UNKNOWN, this is easy.  Similarly if they are the same or
9598      if OP0 is SET.  */
9599
9600   if (op1 == UNKNOWN || op0 == SET)
9601     return 1;
9602
9603   else if (op0 == UNKNOWN)
9604     op0 = op1, const0 = const1;
9605
9606   else if (op0 == op1)
9607     {
9608       switch (op0)
9609         {
9610         case AND:
9611           const0 &= const1;
9612           break;
9613         case IOR:
9614           const0 |= const1;
9615           break;
9616         case XOR:
9617           const0 ^= const1;
9618           break;
9619         case PLUS:
9620           const0 += const1;
9621           break;
9622         case NEG:
9623           op0 = UNKNOWN;
9624           break;
9625         default:
9626           break;
9627         }
9628     }
9629
9630   /* Otherwise, if either is a PLUS or NEG, we can't do anything.  */
9631   else if (op0 == PLUS || op1 == PLUS || op0 == NEG || op1 == NEG)
9632     return 0;
9633
9634   /* If the two constants aren't the same, we can't do anything.  The
9635      remaining six cases can all be done.  */
9636   else if (const0 != const1)
9637     return 0;
9638
9639   else
9640     switch (op0)
9641       {
9642       case IOR:
9643         if (op1 == AND)
9644           /* (a & b) | b == b */
9645           op0 = SET;
9646         else /* op1 == XOR */
9647           /* (a ^ b) | b == a | b */
9648           {;}
9649         break;
9650
9651       case XOR:
9652         if (op1 == AND)
9653           /* (a & b) ^ b == (~a) & b */
9654           op0 = AND, *pcomp_p = 1;
9655         else /* op1 == IOR */
9656           /* (a | b) ^ b == a & ~b */
9657           op0 = AND, const0 = ~const0;
9658         break;
9659
9660       case AND:
9661         if (op1 == IOR)
9662           /* (a | b) & b == b */
9663         op0 = SET;
9664         else /* op1 == XOR */
9665           /* (a ^ b) & b) == (~a) & b */
9666           *pcomp_p = 1;
9667         break;
9668       default:
9669         break;
9670       }
9671
9672   /* Check for NO-OP cases.  */
9673   const0 &= GET_MODE_MASK (mode);
9674   if (const0 == 0
9675       && (op0 == IOR || op0 == XOR || op0 == PLUS))
9676     op0 = UNKNOWN;
9677   else if (const0 == 0 && op0 == AND)
9678     op0 = SET;
9679   else if ((unsigned HOST_WIDE_INT) const0 == GET_MODE_MASK (mode)
9680            && op0 == AND)
9681     op0 = UNKNOWN;
9682
9683   *pop0 = op0;
9684
9685   /* ??? Slightly redundant with the above mask, but not entirely.
9686      Moving this above means we'd have to sign-extend the mode mask
9687      for the final test.  */
9688   if (op0 != UNKNOWN && op0 != NEG)
9689     *pconst0 = trunc_int_for_mode (const0, mode);
9690
9691   return 1;
9692 }
9693 \f
9694 /* A helper to simplify_shift_const_1 to determine the mode we can perform
9695    the shift in.  The original shift operation CODE is performed on OP in
9696    ORIG_MODE.  Return the wider mode MODE if we can perform the operation
9697    in that mode.  Return ORIG_MODE otherwise.  We can also assume that the
9698    result of the shift is subject to operation OUTER_CODE with operand
9699    OUTER_CONST.  */
9700
9701 static enum machine_mode
9702 try_widen_shift_mode (enum rtx_code code, rtx op, int count,
9703                       enum machine_mode orig_mode, enum machine_mode mode,
9704                       enum rtx_code outer_code, HOST_WIDE_INT outer_const)
9705 {
9706   if (orig_mode == mode)
9707     return mode;
9708   gcc_assert (GET_MODE_BITSIZE (mode) > GET_MODE_BITSIZE (orig_mode));
9709
9710   /* In general we can't perform in wider mode for right shift and rotate.  */
9711   switch (code)
9712     {
9713     case ASHIFTRT:
9714       /* We can still widen if the bits brought in from the left are identical
9715          to the sign bit of ORIG_MODE.  */
9716       if (num_sign_bit_copies (op, mode)
9717           > (unsigned) (GET_MODE_BITSIZE (mode)
9718                         - GET_MODE_BITSIZE (orig_mode)))
9719         return mode;
9720       return orig_mode;
9721
9722     case LSHIFTRT:
9723       /* Similarly here but with zero bits.  */
9724       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9725           && (nonzero_bits (op, mode) & ~GET_MODE_MASK (orig_mode)) == 0)
9726         return mode;
9727
9728       /* We can also widen if the bits brought in will be masked off.  This
9729          operation is performed in ORIG_MODE.  */
9730       if (outer_code == AND)
9731         {
9732           int care_bits = low_bitmask_len (orig_mode, outer_const);
9733
9734           if (care_bits >= 0
9735               && GET_MODE_BITSIZE (orig_mode) - care_bits >= count)
9736             return mode;
9737         }
9738       /* fall through */
9739
9740     case ROTATE:
9741       return orig_mode;
9742
9743     case ROTATERT:
9744       gcc_unreachable ();
9745
9746     default:
9747       return mode;
9748     }
9749 }
9750
9751 /* Simplify a shift of VAROP by COUNT bits.  CODE says what kind of shift.
9752    The result of the shift is RESULT_MODE.  Return NULL_RTX if we cannot
9753    simplify it.  Otherwise, return a simplified value.
9754
9755    The shift is normally computed in the widest mode we find in VAROP, as
9756    long as it isn't a different number of words than RESULT_MODE.  Exceptions
9757    are ASHIFTRT and ROTATE, which are always done in their original mode.  */
9758
9759 static rtx
9760 simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
9761                         rtx varop, int orig_count)
9762 {
9763   enum rtx_code orig_code = code;
9764   rtx orig_varop = varop;
9765   int count;
9766   enum machine_mode mode = result_mode;
9767   enum machine_mode shift_mode, tmode;
9768   unsigned int mode_words
9769     = (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
9770   /* We form (outer_op (code varop count) (outer_const)).  */
9771   enum rtx_code outer_op = UNKNOWN;
9772   HOST_WIDE_INT outer_const = 0;
9773   int complement_p = 0;
9774   rtx new_rtx, x;
9775
9776   /* Make sure and truncate the "natural" shift on the way in.  We don't
9777      want to do this inside the loop as it makes it more difficult to
9778      combine shifts.  */
9779   if (SHIFT_COUNT_TRUNCATED)
9780     orig_count &= GET_MODE_BITSIZE (mode) - 1;
9781
9782   /* If we were given an invalid count, don't do anything except exactly
9783      what was requested.  */
9784
9785   if (orig_count < 0 || orig_count >= (int) GET_MODE_BITSIZE (mode))
9786     return NULL_RTX;
9787
9788   count = orig_count;
9789
9790   /* Unless one of the branches of the `if' in this loop does a `continue',
9791      we will `break' the loop after the `if'.  */
9792
9793   while (count != 0)
9794     {
9795       /* If we have an operand of (clobber (const_int 0)), fail.  */
9796       if (GET_CODE (varop) == CLOBBER)
9797         return NULL_RTX;
9798
9799       /* Convert ROTATERT to ROTATE.  */
9800       if (code == ROTATERT)
9801         {
9802           unsigned int bitsize = GET_MODE_BITSIZE (result_mode);;
9803           code = ROTATE;
9804           if (VECTOR_MODE_P (result_mode))
9805             count = bitsize / GET_MODE_NUNITS (result_mode) - count;
9806           else
9807             count = bitsize - count;
9808         }
9809
9810       shift_mode = try_widen_shift_mode (code, varop, count, result_mode,
9811                                          mode, outer_op, outer_const);
9812
9813       /* Handle cases where the count is greater than the size of the mode
9814          minus 1.  For ASHIFT, use the size minus one as the count (this can
9815          occur when simplifying (lshiftrt (ashiftrt ..))).  For rotates,
9816          take the count modulo the size.  For other shifts, the result is
9817          zero.
9818
9819          Since these shifts are being produced by the compiler by combining
9820          multiple operations, each of which are defined, we know what the
9821          result is supposed to be.  */
9822
9823       if (count > (GET_MODE_BITSIZE (shift_mode) - 1))
9824         {
9825           if (code == ASHIFTRT)
9826             count = GET_MODE_BITSIZE (shift_mode) - 1;
9827           else if (code == ROTATE || code == ROTATERT)
9828             count %= GET_MODE_BITSIZE (shift_mode);
9829           else
9830             {
9831               /* We can't simply return zero because there may be an
9832                  outer op.  */
9833               varop = const0_rtx;
9834               count = 0;
9835               break;
9836             }
9837         }
9838
9839       /* If we discovered we had to complement VAROP, leave.  Making a NOT
9840          here would cause an infinite loop.  */
9841       if (complement_p)
9842         break;
9843
9844       /* An arithmetic right shift of a quantity known to be -1 or 0
9845          is a no-op.  */
9846       if (code == ASHIFTRT
9847           && (num_sign_bit_copies (varop, shift_mode)
9848               == GET_MODE_BITSIZE (shift_mode)))
9849         {
9850           count = 0;
9851           break;
9852         }
9853
9854       /* If we are doing an arithmetic right shift and discarding all but
9855          the sign bit copies, this is equivalent to doing a shift by the
9856          bitsize minus one.  Convert it into that shift because it will often
9857          allow other simplifications.  */
9858
9859       if (code == ASHIFTRT
9860           && (count + num_sign_bit_copies (varop, shift_mode)
9861               >= GET_MODE_BITSIZE (shift_mode)))
9862         count = GET_MODE_BITSIZE (shift_mode) - 1;
9863
9864       /* We simplify the tests below and elsewhere by converting
9865          ASHIFTRT to LSHIFTRT if we know the sign bit is clear.
9866          `make_compound_operation' will convert it to an ASHIFTRT for
9867          those machines (such as VAX) that don't have an LSHIFTRT.  */
9868       if (GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9869           && code == ASHIFTRT
9870           && ((nonzero_bits (varop, shift_mode)
9871                & ((unsigned HOST_WIDE_INT) 1
9872                   << (GET_MODE_BITSIZE (shift_mode) - 1))) == 0))
9873         code = LSHIFTRT;
9874
9875       if (((code == LSHIFTRT
9876             && GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9877             && !(nonzero_bits (varop, shift_mode) >> count))
9878            || (code == ASHIFT
9879                && GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9880                && !((nonzero_bits (varop, shift_mode) << count)
9881                     & GET_MODE_MASK (shift_mode))))
9882           && !side_effects_p (varop))
9883         varop = const0_rtx;
9884
9885       switch (GET_CODE (varop))
9886         {
9887         case SIGN_EXTEND:
9888         case ZERO_EXTEND:
9889         case SIGN_EXTRACT:
9890         case ZERO_EXTRACT:
9891           new_rtx = expand_compound_operation (varop);
9892           if (new_rtx != varop)
9893             {
9894               varop = new_rtx;
9895               continue;
9896             }
9897           break;
9898
9899         case MEM:
9900           /* If we have (xshiftrt (mem ...) C) and C is MODE_WIDTH
9901              minus the width of a smaller mode, we can do this with a
9902              SIGN_EXTEND or ZERO_EXTEND from the narrower memory location.  */
9903           if ((code == ASHIFTRT || code == LSHIFTRT)
9904               && ! mode_dependent_address_p (XEXP (varop, 0))
9905               && ! MEM_VOLATILE_P (varop)
9906               && (tmode = mode_for_size (GET_MODE_BITSIZE (mode) - count,
9907                                          MODE_INT, 1)) != BLKmode)
9908             {
9909               new_rtx = adjust_address_nv (varop, tmode,
9910                                        BYTES_BIG_ENDIAN ? 0
9911                                        : count / BITS_PER_UNIT);
9912
9913               varop = gen_rtx_fmt_e (code == ASHIFTRT ? SIGN_EXTEND
9914                                      : ZERO_EXTEND, mode, new_rtx);
9915               count = 0;
9916               continue;
9917             }
9918           break;
9919
9920         case SUBREG:
9921           /* If VAROP is a SUBREG, strip it as long as the inner operand has
9922              the same number of words as what we've seen so far.  Then store
9923              the widest mode in MODE.  */
9924           if (subreg_lowpart_p (varop)
9925               && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (varop)))
9926                   > GET_MODE_SIZE (GET_MODE (varop)))
9927               && (unsigned int) ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (varop)))
9928                                   + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
9929                  == mode_words
9930               && GET_MODE_CLASS (GET_MODE (varop)) == MODE_INT
9931               && GET_MODE_CLASS (GET_MODE (SUBREG_REG (varop))) == MODE_INT)
9932             {
9933               varop = SUBREG_REG (varop);
9934               if (GET_MODE_SIZE (GET_MODE (varop)) > GET_MODE_SIZE (mode))
9935                 mode = GET_MODE (varop);
9936               continue;
9937             }
9938           break;
9939
9940         case MULT:
9941           /* Some machines use MULT instead of ASHIFT because MULT
9942              is cheaper.  But it is still better on those machines to
9943              merge two shifts into one.  */
9944           if (CONST_INT_P (XEXP (varop, 1))
9945               && exact_log2 (UINTVAL (XEXP (varop, 1))) >= 0)
9946             {
9947               varop
9948                 = simplify_gen_binary (ASHIFT, GET_MODE (varop),
9949                                        XEXP (varop, 0),
9950                                        GEN_INT (exact_log2 (
9951                                                 UINTVAL (XEXP (varop, 1)))));
9952               continue;
9953             }
9954           break;
9955
9956         case UDIV:
9957           /* Similar, for when divides are cheaper.  */
9958           if (CONST_INT_P (XEXP (varop, 1))
9959               && exact_log2 (UINTVAL (XEXP (varop, 1))) >= 0)
9960             {
9961               varop
9962                 = simplify_gen_binary (LSHIFTRT, GET_MODE (varop),
9963                                        XEXP (varop, 0),
9964                                        GEN_INT (exact_log2 (
9965                                                 UINTVAL (XEXP (varop, 1)))));
9966               continue;
9967             }
9968           break;
9969
9970         case ASHIFTRT:
9971           /* If we are extracting just the sign bit of an arithmetic
9972              right shift, that shift is not needed.  However, the sign
9973              bit of a wider mode may be different from what would be
9974              interpreted as the sign bit in a narrower mode, so, if
9975              the result is narrower, don't discard the shift.  */
9976           if (code == LSHIFTRT
9977               && count == (GET_MODE_BITSIZE (result_mode) - 1)
9978               && (GET_MODE_BITSIZE (result_mode)
9979                   >= GET_MODE_BITSIZE (GET_MODE (varop))))
9980             {
9981               varop = XEXP (varop, 0);
9982               continue;
9983             }
9984
9985           /* ... fall through ...  */
9986
9987         case LSHIFTRT:
9988         case ASHIFT:
9989         case ROTATE:
9990           /* Here we have two nested shifts.  The result is usually the
9991              AND of a new shift with a mask.  We compute the result below.  */
9992           if (CONST_INT_P (XEXP (varop, 1))
9993               && INTVAL (XEXP (varop, 1)) >= 0
9994               && INTVAL (XEXP (varop, 1)) < GET_MODE_BITSIZE (GET_MODE (varop))
9995               && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
9996               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9997               && !VECTOR_MODE_P (result_mode))
9998             {
9999               enum rtx_code first_code = GET_CODE (varop);
10000               unsigned int first_count = INTVAL (XEXP (varop, 1));
10001               unsigned HOST_WIDE_INT mask;
10002               rtx mask_rtx;
10003
10004               /* We have one common special case.  We can't do any merging if
10005                  the inner code is an ASHIFTRT of a smaller mode.  However, if
10006                  we have (ashift:M1 (subreg:M1 (ashiftrt:M2 FOO C1) 0) C2)
10007                  with C2 == GET_MODE_BITSIZE (M1) - GET_MODE_BITSIZE (M2),
10008                  we can convert it to
10009                  (ashiftrt:M1 (ashift:M1 (and:M1 (subreg:M1 FOO 0 C2) C3) C1).
10010                  This simplifies certain SIGN_EXTEND operations.  */
10011               if (code == ASHIFT && first_code == ASHIFTRT
10012                   && count == (GET_MODE_BITSIZE (result_mode)
10013                                - GET_MODE_BITSIZE (GET_MODE (varop))))
10014                 {
10015                   /* C3 has the low-order C1 bits zero.  */
10016
10017                   mask = GET_MODE_MASK (mode)
10018                          & ~(((unsigned HOST_WIDE_INT) 1 << first_count) - 1);
10019
10020                   varop = simplify_and_const_int (NULL_RTX, result_mode,
10021                                                   XEXP (varop, 0), mask);
10022                   varop = simplify_shift_const (NULL_RTX, ASHIFT, result_mode,
10023                                                 varop, count);
10024                   count = first_count;
10025                   code = ASHIFTRT;
10026                   continue;
10027                 }
10028
10029               /* If this was (ashiftrt (ashift foo C1) C2) and FOO has more
10030                  than C1 high-order bits equal to the sign bit, we can convert
10031                  this to either an ASHIFT or an ASHIFTRT depending on the
10032                  two counts.
10033
10034                  We cannot do this if VAROP's mode is not SHIFT_MODE.  */
10035
10036               if (code == ASHIFTRT && first_code == ASHIFT
10037                   && GET_MODE (varop) == shift_mode
10038                   && (num_sign_bit_copies (XEXP (varop, 0), shift_mode)
10039                       > first_count))
10040                 {
10041                   varop = XEXP (varop, 0);
10042                   count -= first_count;
10043                   if (count < 0)
10044                     {
10045                       count = -count;
10046                       code = ASHIFT;
10047                     }
10048
10049                   continue;
10050                 }
10051
10052               /* There are some cases we can't do.  If CODE is ASHIFTRT,
10053                  we can only do this if FIRST_CODE is also ASHIFTRT.
10054
10055                  We can't do the case when CODE is ROTATE and FIRST_CODE is
10056                  ASHIFTRT.
10057
10058                  If the mode of this shift is not the mode of the outer shift,
10059                  we can't do this if either shift is a right shift or ROTATE.
10060
10061                  Finally, we can't do any of these if the mode is too wide
10062                  unless the codes are the same.
10063
10064                  Handle the case where the shift codes are the same
10065                  first.  */
10066
10067               if (code == first_code)
10068                 {
10069                   if (GET_MODE (varop) != result_mode
10070                       && (code == ASHIFTRT || code == LSHIFTRT
10071                           || code == ROTATE))
10072                     break;
10073
10074                   count += first_count;
10075                   varop = XEXP (varop, 0);
10076                   continue;
10077                 }
10078
10079               if (code == ASHIFTRT
10080                   || (code == ROTATE && first_code == ASHIFTRT)
10081                   || GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT
10082                   || (GET_MODE (varop) != result_mode
10083                       && (first_code == ASHIFTRT || first_code == LSHIFTRT
10084                           || first_code == ROTATE
10085                           || code == ROTATE)))
10086                 break;
10087
10088               /* To compute the mask to apply after the shift, shift the
10089                  nonzero bits of the inner shift the same way the
10090                  outer shift will.  */
10091
10092               mask_rtx = GEN_INT (nonzero_bits (varop, GET_MODE (varop)));
10093
10094               mask_rtx
10095                 = simplify_const_binary_operation (code, result_mode, mask_rtx,
10096                                                    GEN_INT (count));
10097
10098               /* Give up if we can't compute an outer operation to use.  */
10099               if (mask_rtx == 0
10100                   || !CONST_INT_P (mask_rtx)
10101                   || ! merge_outer_ops (&outer_op, &outer_const, AND,
10102                                         INTVAL (mask_rtx),
10103                                         result_mode, &complement_p))
10104                 break;
10105
10106               /* If the shifts are in the same direction, we add the
10107                  counts.  Otherwise, we subtract them.  */
10108               if ((code == ASHIFTRT || code == LSHIFTRT)
10109                   == (first_code == ASHIFTRT || first_code == LSHIFTRT))
10110                 count += first_count;
10111               else
10112                 count -= first_count;
10113
10114               /* If COUNT is positive, the new shift is usually CODE,
10115                  except for the two exceptions below, in which case it is
10116                  FIRST_CODE.  If the count is negative, FIRST_CODE should
10117                  always be used  */
10118               if (count > 0
10119                   && ((first_code == ROTATE && code == ASHIFT)
10120                       || (first_code == ASHIFTRT && code == LSHIFTRT)))
10121                 code = first_code;
10122               else if (count < 0)
10123                 code = first_code, count = -count;
10124
10125               varop = XEXP (varop, 0);
10126               continue;
10127             }
10128
10129           /* If we have (A << B << C) for any shift, we can convert this to
10130              (A << C << B).  This wins if A is a constant.  Only try this if
10131              B is not a constant.  */
10132
10133           else if (GET_CODE (varop) == code
10134                    && CONST_INT_P (XEXP (varop, 0))
10135                    && !CONST_INT_P (XEXP (varop, 1)))
10136             {
10137               rtx new_rtx = simplify_const_binary_operation (code, mode,
10138                                                          XEXP (varop, 0),
10139                                                          GEN_INT (count));
10140               varop = gen_rtx_fmt_ee (code, mode, new_rtx, XEXP (varop, 1));
10141               count = 0;
10142               continue;
10143             }
10144           break;
10145
10146         case NOT:
10147           if (VECTOR_MODE_P (mode))
10148             break;
10149
10150           /* Make this fit the case below.  */
10151           varop = gen_rtx_XOR (mode, XEXP (varop, 0),
10152                                GEN_INT (GET_MODE_MASK (mode)));
10153           continue;
10154
10155         case IOR:
10156         case AND:
10157         case XOR:
10158           /* If we have (xshiftrt (ior (plus X (const_int -1)) X) C)
10159              with C the size of VAROP - 1 and the shift is logical if
10160              STORE_FLAG_VALUE is 1 and arithmetic if STORE_FLAG_VALUE is -1,
10161              we have an (le X 0) operation.   If we have an arithmetic shift
10162              and STORE_FLAG_VALUE is 1 or we have a logical shift with
10163              STORE_FLAG_VALUE of -1, we have a (neg (le X 0)) operation.  */
10164
10165           if (GET_CODE (varop) == IOR && GET_CODE (XEXP (varop, 0)) == PLUS
10166               && XEXP (XEXP (varop, 0), 1) == constm1_rtx
10167               && (STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
10168               && (code == LSHIFTRT || code == ASHIFTRT)
10169               && count == (GET_MODE_BITSIZE (GET_MODE (varop)) - 1)
10170               && rtx_equal_p (XEXP (XEXP (varop, 0), 0), XEXP (varop, 1)))
10171             {
10172               count = 0;
10173               varop = gen_rtx_LE (GET_MODE (varop), XEXP (varop, 1),
10174                                   const0_rtx);
10175
10176               if (STORE_FLAG_VALUE == 1 ? code == ASHIFTRT : code == LSHIFTRT)
10177                 varop = gen_rtx_NEG (GET_MODE (varop), varop);
10178
10179               continue;
10180             }
10181
10182           /* If we have (shift (logical)), move the logical to the outside
10183              to allow it to possibly combine with another logical and the
10184              shift to combine with another shift.  This also canonicalizes to
10185              what a ZERO_EXTRACT looks like.  Also, some machines have
10186              (and (shift)) insns.  */
10187
10188           if (CONST_INT_P (XEXP (varop, 1))
10189               /* We can't do this if we have (ashiftrt (xor))  and the
10190                  constant has its sign bit set in shift_mode.  */
10191               && !(code == ASHIFTRT && GET_CODE (varop) == XOR
10192                    && 0 > trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
10193                                               shift_mode))
10194               && (new_rtx = simplify_const_binary_operation (code, result_mode,
10195                                                          XEXP (varop, 1),
10196                                                          GEN_INT (count))) != 0
10197               && CONST_INT_P (new_rtx)
10198               && merge_outer_ops (&outer_op, &outer_const, GET_CODE (varop),
10199                                   INTVAL (new_rtx), result_mode, &complement_p))
10200             {
10201               varop = XEXP (varop, 0);
10202               continue;
10203             }
10204
10205           /* If we can't do that, try to simplify the shift in each arm of the
10206              logical expression, make a new logical expression, and apply
10207              the inverse distributive law.  This also can't be done
10208              for some (ashiftrt (xor)).  */
10209           if (CONST_INT_P (XEXP (varop, 1))
10210              && !(code == ASHIFTRT && GET_CODE (varop) == XOR
10211                   && 0 > trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
10212                                              shift_mode)))
10213             {
10214               rtx lhs = simplify_shift_const (NULL_RTX, code, shift_mode,
10215                                               XEXP (varop, 0), count);
10216               rtx rhs = simplify_shift_const (NULL_RTX, code, shift_mode,
10217                                               XEXP (varop, 1), count);
10218
10219               varop = simplify_gen_binary (GET_CODE (varop), shift_mode,
10220                                            lhs, rhs);
10221               varop = apply_distributive_law (varop);
10222
10223               count = 0;
10224               continue;
10225             }
10226           break;
10227
10228         case EQ:
10229           /* Convert (lshiftrt (eq FOO 0) C) to (xor FOO 1) if STORE_FLAG_VALUE
10230              says that the sign bit can be tested, FOO has mode MODE, C is
10231              GET_MODE_BITSIZE (MODE) - 1, and FOO has only its low-order bit
10232              that may be nonzero.  */
10233           if (code == LSHIFTRT
10234               && XEXP (varop, 1) == const0_rtx
10235               && GET_MODE (XEXP (varop, 0)) == result_mode
10236               && count == (GET_MODE_BITSIZE (result_mode) - 1)
10237               && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
10238               && STORE_FLAG_VALUE == -1
10239               && nonzero_bits (XEXP (varop, 0), result_mode) == 1
10240               && merge_outer_ops (&outer_op, &outer_const, XOR, 1, result_mode,
10241                                   &complement_p))
10242             {
10243               varop = XEXP (varop, 0);
10244               count = 0;
10245               continue;
10246             }
10247           break;
10248
10249         case NEG:
10250           /* (lshiftrt (neg A) C) where A is either 0 or 1 and C is one less
10251              than the number of bits in the mode is equivalent to A.  */
10252           if (code == LSHIFTRT
10253               && count == (GET_MODE_BITSIZE (result_mode) - 1)
10254               && nonzero_bits (XEXP (varop, 0), result_mode) == 1)
10255             {
10256               varop = XEXP (varop, 0);
10257               count = 0;
10258               continue;
10259             }
10260
10261           /* NEG commutes with ASHIFT since it is multiplication.  Move the
10262              NEG outside to allow shifts to combine.  */
10263           if (code == ASHIFT
10264               && merge_outer_ops (&outer_op, &outer_const, NEG, 0, result_mode,
10265                                   &complement_p))
10266             {
10267               varop = XEXP (varop, 0);
10268               continue;
10269             }
10270           break;
10271
10272         case PLUS:
10273           /* (lshiftrt (plus A -1) C) where A is either 0 or 1 and C
10274              is one less than the number of bits in the mode is
10275              equivalent to (xor A 1).  */
10276           if (code == LSHIFTRT
10277               && count == (GET_MODE_BITSIZE (result_mode) - 1)
10278               && XEXP (varop, 1) == constm1_rtx
10279               && nonzero_bits (XEXP (varop, 0), result_mode) == 1
10280               && merge_outer_ops (&outer_op, &outer_const, XOR, 1, result_mode,
10281                                   &complement_p))
10282             {
10283               count = 0;
10284               varop = XEXP (varop, 0);
10285               continue;
10286             }
10287
10288           /* If we have (xshiftrt (plus FOO BAR) C), and the only bits
10289              that might be nonzero in BAR are those being shifted out and those
10290              bits are known zero in FOO, we can replace the PLUS with FOO.
10291              Similarly in the other operand order.  This code occurs when
10292              we are computing the size of a variable-size array.  */
10293
10294           if ((code == ASHIFTRT || code == LSHIFTRT)
10295               && count < HOST_BITS_PER_WIDE_INT
10296               && nonzero_bits (XEXP (varop, 1), result_mode) >> count == 0
10297               && (nonzero_bits (XEXP (varop, 1), result_mode)
10298                   & nonzero_bits (XEXP (varop, 0), result_mode)) == 0)
10299             {
10300               varop = XEXP (varop, 0);
10301               continue;
10302             }
10303           else if ((code == ASHIFTRT || code == LSHIFTRT)
10304                    && count < HOST_BITS_PER_WIDE_INT
10305                    && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
10306                    && 0 == (nonzero_bits (XEXP (varop, 0), result_mode)
10307                             >> count)
10308                    && 0 == (nonzero_bits (XEXP (varop, 0), result_mode)
10309                             & nonzero_bits (XEXP (varop, 1),
10310                                                  result_mode)))
10311             {
10312               varop = XEXP (varop, 1);
10313               continue;
10314             }
10315
10316           /* (ashift (plus foo C) N) is (plus (ashift foo N) C').  */
10317           if (code == ASHIFT
10318               && CONST_INT_P (XEXP (varop, 1))
10319               && (new_rtx = simplify_const_binary_operation (ASHIFT, result_mode,
10320                                                          XEXP (varop, 1),
10321                                                          GEN_INT (count))) != 0
10322               && CONST_INT_P (new_rtx)
10323               && merge_outer_ops (&outer_op, &outer_const, PLUS,
10324                                   INTVAL (new_rtx), result_mode, &complement_p))
10325             {
10326               varop = XEXP (varop, 0);
10327               continue;
10328             }
10329
10330           /* Check for 'PLUS signbit', which is the canonical form of 'XOR
10331              signbit', and attempt to change the PLUS to an XOR and move it to
10332              the outer operation as is done above in the AND/IOR/XOR case
10333              leg for shift(logical). See details in logical handling above
10334              for reasoning in doing so.  */
10335           if (code == LSHIFTRT
10336               && CONST_INT_P (XEXP (varop, 1))
10337               && mode_signbit_p (result_mode, XEXP (varop, 1))
10338               && (new_rtx = simplify_const_binary_operation (code, result_mode,
10339                                                          XEXP (varop, 1),
10340                                                          GEN_INT (count))) != 0
10341               && CONST_INT_P (new_rtx)
10342               && merge_outer_ops (&outer_op, &outer_const, XOR,
10343                                   INTVAL (new_rtx), result_mode, &complement_p))
10344             {
10345               varop = XEXP (varop, 0);
10346               continue;
10347             }
10348
10349           break;
10350
10351         case MINUS:
10352           /* If we have (xshiftrt (minus (ashiftrt X C)) X) C)
10353              with C the size of VAROP - 1 and the shift is logical if
10354              STORE_FLAG_VALUE is 1 and arithmetic if STORE_FLAG_VALUE is -1,
10355              we have a (gt X 0) operation.  If the shift is arithmetic with
10356              STORE_FLAG_VALUE of 1 or logical with STORE_FLAG_VALUE == -1,
10357              we have a (neg (gt X 0)) operation.  */
10358
10359           if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
10360               && GET_CODE (XEXP (varop, 0)) == ASHIFTRT
10361               && count == (GET_MODE_BITSIZE (GET_MODE (varop)) - 1)
10362               && (code == LSHIFTRT || code == ASHIFTRT)
10363               && CONST_INT_P (XEXP (XEXP (varop, 0), 1))
10364               && INTVAL (XEXP (XEXP (varop, 0), 1)) == count
10365               && rtx_equal_p (XEXP (XEXP (varop, 0), 0), XEXP (varop, 1)))
10366             {
10367               count = 0;
10368               varop = gen_rtx_GT (GET_MODE (varop), XEXP (varop, 1),
10369                                   const0_rtx);
10370
10371               if (STORE_FLAG_VALUE == 1 ? code == ASHIFTRT : code == LSHIFTRT)
10372                 varop = gen_rtx_NEG (GET_MODE (varop), varop);
10373
10374               continue;
10375             }
10376           break;
10377
10378         case TRUNCATE:
10379           /* Change (lshiftrt (truncate (lshiftrt))) to (truncate (lshiftrt))
10380              if the truncate does not affect the value.  */
10381           if (code == LSHIFTRT
10382               && GET_CODE (XEXP (varop, 0)) == LSHIFTRT
10383               && CONST_INT_P (XEXP (XEXP (varop, 0), 1))
10384               && (INTVAL (XEXP (XEXP (varop, 0), 1))
10385                   >= (GET_MODE_BITSIZE (GET_MODE (XEXP (varop, 0)))
10386                       - GET_MODE_BITSIZE (GET_MODE (varop)))))
10387             {
10388               rtx varop_inner = XEXP (varop, 0);
10389
10390               varop_inner
10391                 = gen_rtx_LSHIFTRT (GET_MODE (varop_inner),
10392                                     XEXP (varop_inner, 0),
10393                                     GEN_INT
10394                                     (count + INTVAL (XEXP (varop_inner, 1))));
10395               varop = gen_rtx_TRUNCATE (GET_MODE (varop), varop_inner);
10396               count = 0;
10397               continue;
10398             }
10399           break;
10400
10401         default:
10402           break;
10403         }
10404
10405       break;
10406     }
10407
10408   shift_mode = try_widen_shift_mode (code, varop, count, result_mode, mode,
10409                                      outer_op, outer_const);
10410
10411   /* We have now finished analyzing the shift.  The result should be
10412      a shift of type CODE with SHIFT_MODE shifting VAROP COUNT places.  If
10413      OUTER_OP is non-UNKNOWN, it is an operation that needs to be applied
10414      to the result of the shift.  OUTER_CONST is the relevant constant,
10415      but we must turn off all bits turned off in the shift.  */
10416
10417   if (outer_op == UNKNOWN
10418       && orig_code == code && orig_count == count
10419       && varop == orig_varop
10420       && shift_mode == GET_MODE (varop))
10421     return NULL_RTX;
10422
10423   /* Make a SUBREG if necessary.  If we can't make it, fail.  */
10424   varop = gen_lowpart (shift_mode, varop);
10425   if (varop == NULL_RTX || GET_CODE (varop) == CLOBBER)
10426     return NULL_RTX;
10427
10428   /* If we have an outer operation and we just made a shift, it is
10429      possible that we could have simplified the shift were it not
10430      for the outer operation.  So try to do the simplification
10431      recursively.  */
10432
10433   if (outer_op != UNKNOWN)
10434     x = simplify_shift_const_1 (code, shift_mode, varop, count);
10435   else
10436     x = NULL_RTX;
10437
10438   if (x == NULL_RTX)
10439     x = simplify_gen_binary (code, shift_mode, varop, GEN_INT (count));
10440
10441   /* If we were doing an LSHIFTRT in a wider mode than it was originally,
10442      turn off all the bits that the shift would have turned off.  */
10443   if (orig_code == LSHIFTRT && result_mode != shift_mode)
10444     x = simplify_and_const_int (NULL_RTX, shift_mode, x,
10445                                 GET_MODE_MASK (result_mode) >> orig_count);
10446
10447   /* Do the remainder of the processing in RESULT_MODE.  */
10448   x = gen_lowpart_or_truncate (result_mode, x);
10449
10450   /* If COMPLEMENT_P is set, we have to complement X before doing the outer
10451      operation.  */
10452   if (complement_p)
10453     x = simplify_gen_unary (NOT, result_mode, x, result_mode);
10454
10455   if (outer_op != UNKNOWN)
10456     {
10457       if (GET_RTX_CLASS (outer_op) != RTX_UNARY
10458           && GET_MODE_BITSIZE (result_mode) < HOST_BITS_PER_WIDE_INT)
10459         outer_const = trunc_int_for_mode (outer_const, result_mode);
10460
10461       if (outer_op == AND)
10462         x = simplify_and_const_int (NULL_RTX, result_mode, x, outer_const);
10463       else if (outer_op == SET)
10464         {
10465           /* This means that we have determined that the result is
10466              equivalent to a constant.  This should be rare.  */
10467           if (!side_effects_p (x))
10468             x = GEN_INT (outer_const);
10469         }
10470       else if (GET_RTX_CLASS (outer_op) == RTX_UNARY)
10471         x = simplify_gen_unary (outer_op, result_mode, x, result_mode);
10472       else
10473         x = simplify_gen_binary (outer_op, result_mode, x,
10474                                  GEN_INT (outer_const));
10475     }
10476
10477   return x;
10478 }
10479
10480 /* Simplify a shift of VAROP by COUNT bits.  CODE says what kind of shift.
10481    The result of the shift is RESULT_MODE.  If we cannot simplify it,
10482    return X or, if it is NULL, synthesize the expression with
10483    simplify_gen_binary.  Otherwise, return a simplified value.
10484
10485    The shift is normally computed in the widest mode we find in VAROP, as
10486    long as it isn't a different number of words than RESULT_MODE.  Exceptions
10487    are ASHIFTRT and ROTATE, which are always done in their original mode.  */
10488
10489 static rtx
10490 simplify_shift_const (rtx x, enum rtx_code code, enum machine_mode result_mode,
10491                       rtx varop, int count)
10492 {
10493   rtx tem = simplify_shift_const_1 (code, result_mode, varop, count);
10494   if (tem)
10495     return tem;
10496
10497   if (!x)
10498     x = simplify_gen_binary (code, GET_MODE (varop), varop, GEN_INT (count));
10499   if (GET_MODE (x) != result_mode)
10500     x = gen_lowpart (result_mode, x);
10501   return x;
10502 }
10503
10504 \f
10505 /* Like recog, but we receive the address of a pointer to a new pattern.
10506    We try to match the rtx that the pointer points to.
10507    If that fails, we may try to modify or replace the pattern,
10508    storing the replacement into the same pointer object.
10509
10510    Modifications include deletion or addition of CLOBBERs.
10511
10512    PNOTES is a pointer to a location where any REG_UNUSED notes added for
10513    the CLOBBERs are placed.
10514
10515    The value is the final insn code from the pattern ultimately matched,
10516    or -1.  */
10517
10518 static int
10519 recog_for_combine (rtx *pnewpat, rtx insn, rtx *pnotes)
10520 {
10521   rtx pat = *pnewpat;
10522   int insn_code_number;
10523   int num_clobbers_to_add = 0;
10524   int i;
10525   rtx notes = 0;
10526   rtx old_notes, old_pat;
10527
10528   /* If PAT is a PARALLEL, check to see if it contains the CLOBBER
10529      we use to indicate that something didn't match.  If we find such a
10530      thing, force rejection.  */
10531   if (GET_CODE (pat) == PARALLEL)
10532     for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
10533       if (GET_CODE (XVECEXP (pat, 0, i)) == CLOBBER
10534           && XEXP (XVECEXP (pat, 0, i), 0) == const0_rtx)
10535         return -1;
10536
10537   old_pat = PATTERN (insn);
10538   old_notes = REG_NOTES (insn);
10539   PATTERN (insn) = pat;
10540   REG_NOTES (insn) = 0;
10541
10542   insn_code_number = recog (pat, insn, &num_clobbers_to_add);
10543   if (dump_file && (dump_flags & TDF_DETAILS))
10544     {
10545       if (insn_code_number < 0)
10546         fputs ("Failed to match this instruction:\n", dump_file);
10547       else
10548         fputs ("Successfully matched this instruction:\n", dump_file);
10549       print_rtl_single (dump_file, pat);
10550     }
10551
10552   /* If it isn't, there is the possibility that we previously had an insn
10553      that clobbered some register as a side effect, but the combined
10554      insn doesn't need to do that.  So try once more without the clobbers
10555      unless this represents an ASM insn.  */
10556
10557   if (insn_code_number < 0 && ! check_asm_operands (pat)
10558       && GET_CODE (pat) == PARALLEL)
10559     {
10560       int pos;
10561
10562       for (pos = 0, i = 0; i < XVECLEN (pat, 0); i++)
10563         if (GET_CODE (XVECEXP (pat, 0, i)) != CLOBBER)
10564           {
10565             if (i != pos)
10566               SUBST (XVECEXP (pat, 0, pos), XVECEXP (pat, 0, i));
10567             pos++;
10568           }
10569
10570       SUBST_INT (XVECLEN (pat, 0), pos);
10571
10572       if (pos == 1)
10573         pat = XVECEXP (pat, 0, 0);
10574
10575       PATTERN (insn) = pat;
10576       insn_code_number = recog (pat, insn, &num_clobbers_to_add);
10577       if (dump_file && (dump_flags & TDF_DETAILS))
10578         {
10579           if (insn_code_number < 0)
10580             fputs ("Failed to match this instruction:\n", dump_file);
10581           else
10582             fputs ("Successfully matched this instruction:\n", dump_file);
10583           print_rtl_single (dump_file, pat);
10584         }
10585     }
10586   PATTERN (insn) = old_pat;
10587   REG_NOTES (insn) = old_notes;
10588
10589   /* Recognize all noop sets, these will be killed by followup pass.  */
10590   if (insn_code_number < 0 && GET_CODE (pat) == SET && set_noop_p (pat))
10591     insn_code_number = NOOP_MOVE_INSN_CODE, num_clobbers_to_add = 0;
10592
10593   /* If we had any clobbers to add, make a new pattern than contains
10594      them.  Then check to make sure that all of them are dead.  */
10595   if (num_clobbers_to_add)
10596     {
10597       rtx newpat = gen_rtx_PARALLEL (VOIDmode,
10598                                      rtvec_alloc (GET_CODE (pat) == PARALLEL
10599                                                   ? (XVECLEN (pat, 0)
10600                                                      + num_clobbers_to_add)
10601                                                   : num_clobbers_to_add + 1));
10602
10603       if (GET_CODE (pat) == PARALLEL)
10604         for (i = 0; i < XVECLEN (pat, 0); i++)
10605           XVECEXP (newpat, 0, i) = XVECEXP (pat, 0, i);
10606       else
10607         XVECEXP (newpat, 0, 0) = pat;
10608
10609       add_clobbers (newpat, insn_code_number);
10610
10611       for (i = XVECLEN (newpat, 0) - num_clobbers_to_add;
10612            i < XVECLEN (newpat, 0); i++)
10613         {
10614           if (REG_P (XEXP (XVECEXP (newpat, 0, i), 0))
10615               && ! reg_dead_at_p (XEXP (XVECEXP (newpat, 0, i), 0), insn))
10616             return -1;
10617           if (GET_CODE (XEXP (XVECEXP (newpat, 0, i), 0)) != SCRATCH)
10618             {
10619               gcc_assert (REG_P (XEXP (XVECEXP (newpat, 0, i), 0)));
10620               notes = alloc_reg_note (REG_UNUSED,
10621                                       XEXP (XVECEXP (newpat, 0, i), 0), notes);
10622             }
10623         }
10624       pat = newpat;
10625     }
10626
10627   *pnewpat = pat;
10628   *pnotes = notes;
10629
10630   return insn_code_number;
10631 }
10632 \f
10633 /* Like gen_lowpart_general but for use by combine.  In combine it
10634    is not possible to create any new pseudoregs.  However, it is
10635    safe to create invalid memory addresses, because combine will
10636    try to recognize them and all they will do is make the combine
10637    attempt fail.
10638
10639    If for some reason this cannot do its job, an rtx
10640    (clobber (const_int 0)) is returned.
10641    An insn containing that will not be recognized.  */
10642
10643 static rtx
10644 gen_lowpart_for_combine (enum machine_mode omode, rtx x)
10645 {
10646   enum machine_mode imode = GET_MODE (x);
10647   unsigned int osize = GET_MODE_SIZE (omode);
10648   unsigned int isize = GET_MODE_SIZE (imode);
10649   rtx result;
10650
10651   if (omode == imode)
10652     return x;
10653
10654   /* Return identity if this is a CONST or symbolic reference.  */
10655   if (omode == Pmode
10656       && (GET_CODE (x) == CONST
10657           || GET_CODE (x) == SYMBOL_REF
10658           || GET_CODE (x) == LABEL_REF))
10659     return x;
10660
10661   /* We can only support MODE being wider than a word if X is a
10662      constant integer or has a mode the same size.  */
10663   if (GET_MODE_SIZE (omode) > UNITS_PER_WORD
10664       && ! ((imode == VOIDmode
10665              && (CONST_INT_P (x)
10666                  || GET_CODE (x) == CONST_DOUBLE))
10667             || isize == osize))
10668     goto fail;
10669
10670   /* X might be a paradoxical (subreg (mem)).  In that case, gen_lowpart
10671      won't know what to do.  So we will strip off the SUBREG here and
10672      process normally.  */
10673   if (GET_CODE (x) == SUBREG && MEM_P (SUBREG_REG (x)))
10674     {
10675       x = SUBREG_REG (x);
10676
10677       /* For use in case we fall down into the address adjustments
10678          further below, we need to adjust the known mode and size of
10679          x; imode and isize, since we just adjusted x.  */
10680       imode = GET_MODE (x);
10681
10682       if (imode == omode)
10683         return x;
10684
10685       isize = GET_MODE_SIZE (imode);
10686     }
10687
10688   result = gen_lowpart_common (omode, x);
10689
10690   if (result)
10691     return result;
10692
10693   if (MEM_P (x))
10694     {
10695       int offset = 0;
10696
10697       /* Refuse to work on a volatile memory ref or one with a mode-dependent
10698          address.  */
10699       if (MEM_VOLATILE_P (x) || mode_dependent_address_p (XEXP (x, 0)))
10700         goto fail;
10701
10702       /* If we want to refer to something bigger than the original memref,
10703          generate a paradoxical subreg instead.  That will force a reload
10704          of the original memref X.  */
10705       if (isize < osize)
10706         return gen_rtx_SUBREG (omode, x, 0);
10707
10708       if (WORDS_BIG_ENDIAN)
10709         offset = MAX (isize, UNITS_PER_WORD) - MAX (osize, UNITS_PER_WORD);
10710
10711       /* Adjust the address so that the address-after-the-data is
10712          unchanged.  */
10713       if (BYTES_BIG_ENDIAN)
10714         offset -= MIN (UNITS_PER_WORD, osize) - MIN (UNITS_PER_WORD, isize);
10715
10716       return adjust_address_nv (x, omode, offset);
10717     }
10718
10719   /* If X is a comparison operator, rewrite it in a new mode.  This
10720      probably won't match, but may allow further simplifications.  */
10721   else if (COMPARISON_P (x))
10722     return gen_rtx_fmt_ee (GET_CODE (x), omode, XEXP (x, 0), XEXP (x, 1));
10723
10724   /* If we couldn't simplify X any other way, just enclose it in a
10725      SUBREG.  Normally, this SUBREG won't match, but some patterns may
10726      include an explicit SUBREG or we may simplify it further in combine.  */
10727   else
10728     {
10729       int offset = 0;
10730       rtx res;
10731
10732       offset = subreg_lowpart_offset (omode, imode);
10733       if (imode == VOIDmode)
10734         {
10735           imode = int_mode_for_mode (omode);
10736           x = gen_lowpart_common (imode, x);
10737           if (x == NULL)
10738             goto fail;
10739         }
10740       res = simplify_gen_subreg (omode, x, imode, offset);
10741       if (res)
10742         return res;
10743     }
10744
10745  fail:
10746   return gen_rtx_CLOBBER (omode, const0_rtx);
10747 }
10748 \f
10749 /* Simplify a comparison between *POP0 and *POP1 where CODE is the
10750    comparison code that will be tested.
10751
10752    The result is a possibly different comparison code to use.  *POP0 and
10753    *POP1 may be updated.
10754
10755    It is possible that we might detect that a comparison is either always
10756    true or always false.  However, we do not perform general constant
10757    folding in combine, so this knowledge isn't useful.  Such tautologies
10758    should have been detected earlier.  Hence we ignore all such cases.  */
10759
10760 static enum rtx_code
10761 simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1)
10762 {
10763   rtx op0 = *pop0;
10764   rtx op1 = *pop1;
10765   rtx tem, tem1;
10766   int i;
10767   enum machine_mode mode, tmode;
10768
10769   /* Try a few ways of applying the same transformation to both operands.  */
10770   while (1)
10771     {
10772 #ifndef WORD_REGISTER_OPERATIONS
10773       /* The test below this one won't handle SIGN_EXTENDs on these machines,
10774          so check specially.  */
10775       if (code != GTU && code != GEU && code != LTU && code != LEU
10776           && GET_CODE (op0) == ASHIFTRT && GET_CODE (op1) == ASHIFTRT
10777           && GET_CODE (XEXP (op0, 0)) == ASHIFT
10778           && GET_CODE (XEXP (op1, 0)) == ASHIFT
10779           && GET_CODE (XEXP (XEXP (op0, 0), 0)) == SUBREG
10780           && GET_CODE (XEXP (XEXP (op1, 0), 0)) == SUBREG
10781           && (GET_MODE (SUBREG_REG (XEXP (XEXP (op0, 0), 0)))
10782               == GET_MODE (SUBREG_REG (XEXP (XEXP (op1, 0), 0))))
10783           && CONST_INT_P (XEXP (op0, 1))
10784           && XEXP (op0, 1) == XEXP (op1, 1)
10785           && XEXP (op0, 1) == XEXP (XEXP (op0, 0), 1)
10786           && XEXP (op0, 1) == XEXP (XEXP (op1, 0), 1)
10787           && (INTVAL (XEXP (op0, 1))
10788               == (GET_MODE_BITSIZE (GET_MODE (op0))
10789                   - (GET_MODE_BITSIZE
10790                      (GET_MODE (SUBREG_REG (XEXP (XEXP (op0, 0), 0))))))))
10791         {
10792           op0 = SUBREG_REG (XEXP (XEXP (op0, 0), 0));
10793           op1 = SUBREG_REG (XEXP (XEXP (op1, 0), 0));
10794         }
10795 #endif
10796
10797       /* If both operands are the same constant shift, see if we can ignore the
10798          shift.  We can if the shift is a rotate or if the bits shifted out of
10799          this shift are known to be zero for both inputs and if the type of
10800          comparison is compatible with the shift.  */
10801       if (GET_CODE (op0) == GET_CODE (op1)
10802           && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
10803           && ((GET_CODE (op0) == ROTATE && (code == NE || code == EQ))
10804               || ((GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFT)
10805                   && (code != GT && code != LT && code != GE && code != LE))
10806               || (GET_CODE (op0) == ASHIFTRT
10807                   && (code != GTU && code != LTU
10808                       && code != GEU && code != LEU)))
10809           && CONST_INT_P (XEXP (op0, 1))
10810           && INTVAL (XEXP (op0, 1)) >= 0
10811           && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
10812           && XEXP (op0, 1) == XEXP (op1, 1))
10813         {
10814           enum machine_mode mode = GET_MODE (op0);
10815           unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
10816           int shift_count = INTVAL (XEXP (op0, 1));
10817
10818           if (GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFTRT)
10819             mask &= (mask >> shift_count) << shift_count;
10820           else if (GET_CODE (op0) == ASHIFT)
10821             mask = (mask & (mask << shift_count)) >> shift_count;
10822
10823           if ((nonzero_bits (XEXP (op0, 0), mode) & ~mask) == 0
10824               && (nonzero_bits (XEXP (op1, 0), mode) & ~mask) == 0)
10825             op0 = XEXP (op0, 0), op1 = XEXP (op1, 0);
10826           else
10827             break;
10828         }
10829
10830       /* If both operands are AND's of a paradoxical SUBREG by constant, the
10831          SUBREGs are of the same mode, and, in both cases, the AND would
10832          be redundant if the comparison was done in the narrower mode,
10833          do the comparison in the narrower mode (e.g., we are AND'ing with 1
10834          and the operand's possibly nonzero bits are 0xffffff01; in that case
10835          if we only care about QImode, we don't need the AND).  This case
10836          occurs if the output mode of an scc insn is not SImode and
10837          STORE_FLAG_VALUE == 1 (e.g., the 386).
10838
10839          Similarly, check for a case where the AND's are ZERO_EXTEND
10840          operations from some narrower mode even though a SUBREG is not
10841          present.  */
10842
10843       else if (GET_CODE (op0) == AND && GET_CODE (op1) == AND
10844                && CONST_INT_P (XEXP (op0, 1))
10845                && CONST_INT_P (XEXP (op1, 1)))
10846         {
10847           rtx inner_op0 = XEXP (op0, 0);
10848           rtx inner_op1 = XEXP (op1, 0);
10849           HOST_WIDE_INT c0 = INTVAL (XEXP (op0, 1));
10850           HOST_WIDE_INT c1 = INTVAL (XEXP (op1, 1));
10851           int changed = 0;
10852
10853           if (GET_CODE (inner_op0) == SUBREG && GET_CODE (inner_op1) == SUBREG
10854               && (GET_MODE_SIZE (GET_MODE (inner_op0))
10855                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner_op0))))
10856               && (GET_MODE (SUBREG_REG (inner_op0))
10857                   == GET_MODE (SUBREG_REG (inner_op1)))
10858               && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (inner_op0)))
10859                   <= HOST_BITS_PER_WIDE_INT)
10860               && (0 == ((~c0) & nonzero_bits (SUBREG_REG (inner_op0),
10861                                              GET_MODE (SUBREG_REG (inner_op0)))))
10862               && (0 == ((~c1) & nonzero_bits (SUBREG_REG (inner_op1),
10863                                              GET_MODE (SUBREG_REG (inner_op1))))))
10864             {
10865               op0 = SUBREG_REG (inner_op0);
10866               op1 = SUBREG_REG (inner_op1);
10867
10868               /* The resulting comparison is always unsigned since we masked
10869                  off the original sign bit.  */
10870               code = unsigned_condition (code);
10871
10872               changed = 1;
10873             }
10874
10875           else if (c0 == c1)
10876             for (tmode = GET_CLASS_NARROWEST_MODE
10877                  (GET_MODE_CLASS (GET_MODE (op0)));
10878                  tmode != GET_MODE (op0); tmode = GET_MODE_WIDER_MODE (tmode))
10879               if ((unsigned HOST_WIDE_INT) c0 == GET_MODE_MASK (tmode))
10880                 {
10881                   op0 = gen_lowpart (tmode, inner_op0);
10882                   op1 = gen_lowpart (tmode, inner_op1);
10883                   code = unsigned_condition (code);
10884                   changed = 1;
10885                   break;
10886                 }
10887
10888           if (! changed)
10889             break;
10890         }
10891
10892       /* If both operands are NOT, we can strip off the outer operation
10893          and adjust the comparison code for swapped operands; similarly for
10894          NEG, except that this must be an equality comparison.  */
10895       else if ((GET_CODE (op0) == NOT && GET_CODE (op1) == NOT)
10896                || (GET_CODE (op0) == NEG && GET_CODE (op1) == NEG
10897                    && (code == EQ || code == NE)))
10898         op0 = XEXP (op0, 0), op1 = XEXP (op1, 0), code = swap_condition (code);
10899
10900       else
10901         break;
10902     }
10903
10904   /* If the first operand is a constant, swap the operands and adjust the
10905      comparison code appropriately, but don't do this if the second operand
10906      is already a constant integer.  */
10907   if (swap_commutative_operands_p (op0, op1))
10908     {
10909       tem = op0, op0 = op1, op1 = tem;
10910       code = swap_condition (code);
10911     }
10912
10913   /* We now enter a loop during which we will try to simplify the comparison.
10914      For the most part, we only are concerned with comparisons with zero,
10915      but some things may really be comparisons with zero but not start
10916      out looking that way.  */
10917
10918   while (CONST_INT_P (op1))
10919     {
10920       enum machine_mode mode = GET_MODE (op0);
10921       unsigned int mode_width = GET_MODE_BITSIZE (mode);
10922       unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
10923       int equality_comparison_p;
10924       int sign_bit_comparison_p;
10925       int unsigned_comparison_p;
10926       HOST_WIDE_INT const_op;
10927
10928       /* We only want to handle integral modes.  This catches VOIDmode,
10929          CCmode, and the floating-point modes.  An exception is that we
10930          can handle VOIDmode if OP0 is a COMPARE or a comparison
10931          operation.  */
10932
10933       if (GET_MODE_CLASS (mode) != MODE_INT
10934           && ! (mode == VOIDmode
10935                 && (GET_CODE (op0) == COMPARE || COMPARISON_P (op0))))
10936         break;
10937
10938       /* Get the constant we are comparing against and turn off all bits
10939          not on in our mode.  */
10940       const_op = INTVAL (op1);
10941       if (mode != VOIDmode)
10942         const_op = trunc_int_for_mode (const_op, mode);
10943       op1 = GEN_INT (const_op);
10944
10945       /* If we are comparing against a constant power of two and the value
10946          being compared can only have that single bit nonzero (e.g., it was
10947          `and'ed with that bit), we can replace this with a comparison
10948          with zero.  */
10949       if (const_op
10950           && (code == EQ || code == NE || code == GE || code == GEU
10951               || code == LT || code == LTU)
10952           && mode_width <= HOST_BITS_PER_WIDE_INT
10953           && exact_log2 (const_op) >= 0
10954           && nonzero_bits (op0, mode) == (unsigned HOST_WIDE_INT) const_op)
10955         {
10956           code = (code == EQ || code == GE || code == GEU ? NE : EQ);
10957           op1 = const0_rtx, const_op = 0;
10958         }
10959
10960       /* Similarly, if we are comparing a value known to be either -1 or
10961          0 with -1, change it to the opposite comparison against zero.  */
10962
10963       if (const_op == -1
10964           && (code == EQ || code == NE || code == GT || code == LE
10965               || code == GEU || code == LTU)
10966           && num_sign_bit_copies (op0, mode) == mode_width)
10967         {
10968           code = (code == EQ || code == LE || code == GEU ? NE : EQ);
10969           op1 = const0_rtx, const_op = 0;
10970         }
10971
10972       /* Do some canonicalizations based on the comparison code.  We prefer
10973          comparisons against zero and then prefer equality comparisons.
10974          If we can reduce the size of a constant, we will do that too.  */
10975
10976       switch (code)
10977         {
10978         case LT:
10979           /* < C is equivalent to <= (C - 1) */
10980           if (const_op > 0)
10981             {
10982               const_op -= 1;
10983               op1 = GEN_INT (const_op);
10984               code = LE;
10985               /* ... fall through to LE case below.  */
10986             }
10987           else
10988             break;
10989
10990         case LE:
10991           /* <= C is equivalent to < (C + 1); we do this for C < 0  */
10992           if (const_op < 0)
10993             {
10994               const_op += 1;
10995               op1 = GEN_INT (const_op);
10996               code = LT;
10997             }
10998
10999           /* If we are doing a <= 0 comparison on a value known to have
11000              a zero sign bit, we can replace this with == 0.  */
11001           else if (const_op == 0
11002                    && mode_width <= HOST_BITS_PER_WIDE_INT
11003                    && (nonzero_bits (op0, mode)
11004                        & ((unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
11005                          == 0)
11006             code = EQ;
11007           break;
11008
11009         case GE:
11010           /* >= C is equivalent to > (C - 1).  */
11011           if (const_op > 0)
11012             {
11013               const_op -= 1;
11014               op1 = GEN_INT (const_op);
11015               code = GT;
11016               /* ... fall through to GT below.  */
11017             }
11018           else
11019             break;
11020
11021         case GT:
11022           /* > C is equivalent to >= (C + 1); we do this for C < 0.  */
11023           if (const_op < 0)
11024             {
11025               const_op += 1;
11026               op1 = GEN_INT (const_op);
11027               code = GE;
11028             }
11029
11030           /* If we are doing a > 0 comparison on a value known to have
11031              a zero sign bit, we can replace this with != 0.  */
11032           else if (const_op == 0
11033                    && mode_width <= HOST_BITS_PER_WIDE_INT
11034                    && (nonzero_bits (op0, mode)
11035                        & ((unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
11036                        == 0)
11037             code = NE;
11038           break;
11039
11040         case LTU:
11041           /* < C is equivalent to <= (C - 1).  */
11042           if (const_op > 0)
11043             {
11044               const_op -= 1;
11045               op1 = GEN_INT (const_op);
11046               code = LEU;
11047               /* ... fall through ...  */
11048             }
11049
11050           /* (unsigned) < 0x80000000 is equivalent to >= 0.  */
11051           else if (mode_width <= HOST_BITS_PER_WIDE_INT
11052                    && (unsigned HOST_WIDE_INT) const_op
11053                       == (unsigned HOST_WIDE_INT) 1 << (mode_width - 1))
11054             {
11055               const_op = 0, op1 = const0_rtx;
11056               code = GE;
11057               break;
11058             }
11059           else
11060             break;
11061
11062         case LEU:
11063           /* unsigned <= 0 is equivalent to == 0 */
11064           if (const_op == 0)
11065             code = EQ;
11066
11067           /* (unsigned) <= 0x7fffffff is equivalent to >= 0.  */
11068           else if (mode_width <= HOST_BITS_PER_WIDE_INT
11069                    && (unsigned HOST_WIDE_INT) const_op
11070                       == ((unsigned HOST_WIDE_INT) 1 << (mode_width - 1)) - 1)
11071             {
11072               const_op = 0, op1 = const0_rtx;
11073               code = GE;
11074             }
11075           break;
11076
11077         case GEU:
11078           /* >= C is equivalent to > (C - 1).  */
11079           if (const_op > 1)
11080             {
11081               const_op -= 1;
11082               op1 = GEN_INT (const_op);
11083               code = GTU;
11084               /* ... fall through ...  */
11085             }
11086
11087           /* (unsigned) >= 0x80000000 is equivalent to < 0.  */
11088           else if (mode_width <= HOST_BITS_PER_WIDE_INT
11089                    && (unsigned HOST_WIDE_INT) const_op
11090                       == (unsigned HOST_WIDE_INT) 1 << (mode_width - 1))
11091             {
11092               const_op = 0, op1 = const0_rtx;
11093               code = LT;
11094               break;
11095             }
11096           else
11097             break;
11098
11099         case GTU:
11100           /* unsigned > 0 is equivalent to != 0 */
11101           if (const_op == 0)
11102             code = NE;
11103
11104           /* (unsigned) > 0x7fffffff is equivalent to < 0.  */
11105           else if (mode_width <= HOST_BITS_PER_WIDE_INT
11106                    && (unsigned HOST_WIDE_INT) const_op
11107                       == ((unsigned HOST_WIDE_INT) 1 << (mode_width - 1)) - 1)
11108             {
11109               const_op = 0, op1 = const0_rtx;
11110               code = LT;
11111             }
11112           break;
11113
11114         default:
11115           break;
11116         }
11117
11118       /* Compute some predicates to simplify code below.  */
11119
11120       equality_comparison_p = (code == EQ || code == NE);
11121       sign_bit_comparison_p = ((code == LT || code == GE) && const_op == 0);
11122       unsigned_comparison_p = (code == LTU || code == LEU || code == GTU
11123                                || code == GEU);
11124
11125       /* If this is a sign bit comparison and we can do arithmetic in
11126          MODE, say that we will only be needing the sign bit of OP0.  */
11127       if (sign_bit_comparison_p
11128           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11129         op0 = force_to_mode (op0, mode,
11130                              (unsigned HOST_WIDE_INT) 1
11131                              << (GET_MODE_BITSIZE (mode) - 1),
11132                              0);
11133
11134       /* Now try cases based on the opcode of OP0.  If none of the cases
11135          does a "continue", we exit this loop immediately after the
11136          switch.  */
11137
11138       switch (GET_CODE (op0))
11139         {
11140         case ZERO_EXTRACT:
11141           /* If we are extracting a single bit from a variable position in
11142              a constant that has only a single bit set and are comparing it
11143              with zero, we can convert this into an equality comparison
11144              between the position and the location of the single bit.  */
11145           /* Except we can't if SHIFT_COUNT_TRUNCATED is set, since we might
11146              have already reduced the shift count modulo the word size.  */
11147           if (!SHIFT_COUNT_TRUNCATED
11148               && CONST_INT_P (XEXP (op0, 0))
11149               && XEXP (op0, 1) == const1_rtx
11150               && equality_comparison_p && const_op == 0
11151               && (i = exact_log2 (UINTVAL (XEXP (op0, 0)))) >= 0)
11152             {
11153               if (BITS_BIG_ENDIAN)
11154                 {
11155                   enum machine_mode new_mode
11156                     = mode_for_extraction (EP_extzv, 1);
11157                   if (new_mode == MAX_MACHINE_MODE)
11158                     i = BITS_PER_WORD - 1 - i;
11159                   else
11160                     {
11161                       mode = new_mode;
11162                       i = (GET_MODE_BITSIZE (mode) - 1 - i);
11163                     }
11164                 }
11165
11166               op0 = XEXP (op0, 2);
11167               op1 = GEN_INT (i);
11168               const_op = i;
11169
11170               /* Result is nonzero iff shift count is equal to I.  */
11171               code = reverse_condition (code);
11172               continue;
11173             }
11174
11175           /* ... fall through ...  */
11176
11177         case SIGN_EXTRACT:
11178           tem = expand_compound_operation (op0);
11179           if (tem != op0)
11180             {
11181               op0 = tem;
11182               continue;
11183             }
11184           break;
11185
11186         case NOT:
11187           /* If testing for equality, we can take the NOT of the constant.  */
11188           if (equality_comparison_p
11189               && (tem = simplify_unary_operation (NOT, mode, op1, mode)) != 0)
11190             {
11191               op0 = XEXP (op0, 0);
11192               op1 = tem;
11193               continue;
11194             }
11195
11196           /* If just looking at the sign bit, reverse the sense of the
11197              comparison.  */
11198           if (sign_bit_comparison_p)
11199             {
11200               op0 = XEXP (op0, 0);
11201               code = (code == GE ? LT : GE);
11202               continue;
11203             }
11204           break;
11205
11206         case NEG:
11207           /* If testing for equality, we can take the NEG of the constant.  */
11208           if (equality_comparison_p
11209               && (tem = simplify_unary_operation (NEG, mode, op1, mode)) != 0)
11210             {
11211               op0 = XEXP (op0, 0);
11212               op1 = tem;
11213               continue;
11214             }
11215
11216           /* The remaining cases only apply to comparisons with zero.  */
11217           if (const_op != 0)
11218             break;
11219
11220           /* When X is ABS or is known positive,
11221              (neg X) is < 0 if and only if X != 0.  */
11222
11223           if (sign_bit_comparison_p
11224               && (GET_CODE (XEXP (op0, 0)) == ABS
11225                   || (mode_width <= HOST_BITS_PER_WIDE_INT
11226                       && (nonzero_bits (XEXP (op0, 0), mode)
11227                           & ((unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
11228                          == 0)))
11229             {
11230               op0 = XEXP (op0, 0);
11231               code = (code == LT ? NE : EQ);
11232               continue;
11233             }
11234
11235           /* If we have NEG of something whose two high-order bits are the
11236              same, we know that "(-a) < 0" is equivalent to "a > 0".  */
11237           if (num_sign_bit_copies (op0, mode) >= 2)
11238             {
11239               op0 = XEXP (op0, 0);
11240               code = swap_condition (code);
11241               continue;
11242             }
11243           break;
11244
11245         case ROTATE:
11246           /* If we are testing equality and our count is a constant, we
11247              can perform the inverse operation on our RHS.  */
11248           if (equality_comparison_p && CONST_INT_P (XEXP (op0, 1))
11249               && (tem = simplify_binary_operation (ROTATERT, mode,
11250                                                    op1, XEXP (op0, 1))) != 0)
11251             {
11252               op0 = XEXP (op0, 0);
11253               op1 = tem;
11254               continue;
11255             }
11256
11257           /* If we are doing a < 0 or >= 0 comparison, it means we are testing
11258              a particular bit.  Convert it to an AND of a constant of that
11259              bit.  This will be converted into a ZERO_EXTRACT.  */
11260           if (const_op == 0 && sign_bit_comparison_p
11261               && CONST_INT_P (XEXP (op0, 1))
11262               && mode_width <= HOST_BITS_PER_WIDE_INT)
11263             {
11264               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
11265                                             ((unsigned HOST_WIDE_INT) 1
11266                                              << (mode_width - 1
11267                                                  - INTVAL (XEXP (op0, 1)))));
11268               code = (code == LT ? NE : EQ);
11269               continue;
11270             }
11271
11272           /* Fall through.  */
11273
11274         case ABS:
11275           /* ABS is ignorable inside an equality comparison with zero.  */
11276           if (const_op == 0 && equality_comparison_p)
11277             {
11278               op0 = XEXP (op0, 0);
11279               continue;
11280             }
11281           break;
11282
11283         case SIGN_EXTEND:
11284           /* Can simplify (compare (zero/sign_extend FOO) CONST) to
11285              (compare FOO CONST) if CONST fits in FOO's mode and we
11286              are either testing inequality or have an unsigned
11287              comparison with ZERO_EXTEND or a signed comparison with
11288              SIGN_EXTEND.  But don't do it if we don't have a compare
11289              insn of the given mode, since we'd have to revert it
11290              later on, and then we wouldn't know whether to sign- or
11291              zero-extend.  */
11292           mode = GET_MODE (XEXP (op0, 0));
11293           if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
11294               && ! unsigned_comparison_p
11295               && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11296               && ((unsigned HOST_WIDE_INT) const_op
11297                   < (((unsigned HOST_WIDE_INT) 1
11298                       << (GET_MODE_BITSIZE (mode) - 1))))
11299               && have_insn_for (COMPARE, mode))
11300             {
11301               op0 = XEXP (op0, 0);
11302               continue;
11303             }
11304           break;
11305
11306         case SUBREG:
11307           /* Check for the case where we are comparing A - C1 with C2, that is
11308
11309                (subreg:MODE (plus (A) (-C1))) op (C2)
11310
11311              with C1 a constant, and try to lift the SUBREG, i.e. to do the
11312              comparison in the wider mode.  One of the following two conditions
11313              must be true in order for this to be valid:
11314
11315                1. The mode extension results in the same bit pattern being added
11316                   on both sides and the comparison is equality or unsigned.  As
11317                   C2 has been truncated to fit in MODE, the pattern can only be
11318                   all 0s or all 1s.
11319
11320                2. The mode extension results in the sign bit being copied on
11321                   each side.
11322
11323              The difficulty here is that we have predicates for A but not for
11324              (A - C1) so we need to check that C1 is within proper bounds so
11325              as to perturbate A as little as possible.  */
11326
11327           if (mode_width <= HOST_BITS_PER_WIDE_INT
11328               && subreg_lowpart_p (op0)
11329               && GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0))) > mode_width
11330               && GET_CODE (SUBREG_REG (op0)) == PLUS
11331               && CONST_INT_P (XEXP (SUBREG_REG (op0), 1)))
11332             {
11333               enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op0));
11334               rtx a = XEXP (SUBREG_REG (op0), 0);
11335               HOST_WIDE_INT c1 = -INTVAL (XEXP (SUBREG_REG (op0), 1));
11336
11337               if ((c1 > 0
11338                    && (unsigned HOST_WIDE_INT) c1
11339                        < (unsigned HOST_WIDE_INT) 1 << (mode_width - 1)
11340                    && (equality_comparison_p || unsigned_comparison_p)
11341                    /* (A - C1) zero-extends if it is positive and sign-extends
11342                       if it is negative, C2 both zero- and sign-extends.  */
11343                    && ((0 == (nonzero_bits (a, inner_mode)
11344                               & ~GET_MODE_MASK (mode))
11345                         && const_op >= 0)
11346                        /* (A - C1) sign-extends if it is positive and 1-extends
11347                           if it is negative, C2 both sign- and 1-extends.  */
11348                        || (num_sign_bit_copies (a, inner_mode)
11349                            > (unsigned int) (GET_MODE_BITSIZE (inner_mode)
11350                                              - mode_width)
11351                            && const_op < 0)))
11352                   || ((unsigned HOST_WIDE_INT) c1
11353                        < (unsigned HOST_WIDE_INT) 1 << (mode_width - 2)
11354                       /* (A - C1) always sign-extends, like C2.  */
11355                       && num_sign_bit_copies (a, inner_mode)
11356                          > (unsigned int) (GET_MODE_BITSIZE (inner_mode)
11357                                            - (mode_width - 1))))
11358                 {
11359                   op0 = SUBREG_REG (op0);
11360                   continue;
11361                 }
11362             }
11363
11364           /* If the inner mode is narrower and we are extracting the low part,
11365              we can treat the SUBREG as if it were a ZERO_EXTEND.  */
11366           if (subreg_lowpart_p (op0)
11367               && GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0))) < mode_width)
11368             /* Fall through */ ;
11369           else
11370             break;
11371
11372           /* ... fall through ...  */
11373
11374         case ZERO_EXTEND:
11375           mode = GET_MODE (XEXP (op0, 0));
11376           if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
11377               && (unsigned_comparison_p || equality_comparison_p)
11378               && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11379               && ((unsigned HOST_WIDE_INT) const_op < GET_MODE_MASK (mode))
11380               && have_insn_for (COMPARE, mode))
11381             {
11382               op0 = XEXP (op0, 0);
11383               continue;
11384             }
11385           break;
11386
11387         case PLUS:
11388           /* (eq (plus X A) B) -> (eq X (minus B A)).  We can only do
11389              this for equality comparisons due to pathological cases involving
11390              overflows.  */
11391           if (equality_comparison_p
11392               && 0 != (tem = simplify_binary_operation (MINUS, mode,
11393                                                         op1, XEXP (op0, 1))))
11394             {
11395               op0 = XEXP (op0, 0);
11396               op1 = tem;
11397               continue;
11398             }
11399
11400           /* (plus (abs X) (const_int -1)) is < 0 if and only if X == 0.  */
11401           if (const_op == 0 && XEXP (op0, 1) == constm1_rtx
11402               && GET_CODE (XEXP (op0, 0)) == ABS && sign_bit_comparison_p)
11403             {
11404               op0 = XEXP (XEXP (op0, 0), 0);
11405               code = (code == LT ? EQ : NE);
11406               continue;
11407             }
11408           break;
11409
11410         case MINUS:
11411           /* We used to optimize signed comparisons against zero, but that
11412              was incorrect.  Unsigned comparisons against zero (GTU, LEU)
11413              arrive here as equality comparisons, or (GEU, LTU) are
11414              optimized away.  No need to special-case them.  */
11415
11416           /* (eq (minus A B) C) -> (eq A (plus B C)) or
11417              (eq B (minus A C)), whichever simplifies.  We can only do
11418              this for equality comparisons due to pathological cases involving
11419              overflows.  */
11420           if (equality_comparison_p
11421               && 0 != (tem = simplify_binary_operation (PLUS, mode,
11422                                                         XEXP (op0, 1), op1)))
11423             {
11424               op0 = XEXP (op0, 0);
11425               op1 = tem;
11426               continue;
11427             }
11428
11429           if (equality_comparison_p
11430               && 0 != (tem = simplify_binary_operation (MINUS, mode,
11431                                                         XEXP (op0, 0), op1)))
11432             {
11433               op0 = XEXP (op0, 1);
11434               op1 = tem;
11435               continue;
11436             }
11437
11438           /* The sign bit of (minus (ashiftrt X C) X), where C is the number
11439              of bits in X minus 1, is one iff X > 0.  */
11440           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 0)) == ASHIFTRT
11441               && CONST_INT_P (XEXP (XEXP (op0, 0), 1))
11442               && UINTVAL (XEXP (XEXP (op0, 0), 1)) == mode_width - 1
11443               && rtx_equal_p (XEXP (XEXP (op0, 0), 0), XEXP (op0, 1)))
11444             {
11445               op0 = XEXP (op0, 1);
11446               code = (code == GE ? LE : GT);
11447               continue;
11448             }
11449           break;
11450
11451         case XOR:
11452           /* (eq (xor A B) C) -> (eq A (xor B C)).  This is a simplification
11453              if C is zero or B is a constant.  */
11454           if (equality_comparison_p
11455               && 0 != (tem = simplify_binary_operation (XOR, mode,
11456                                                         XEXP (op0, 1), op1)))
11457             {
11458               op0 = XEXP (op0, 0);
11459               op1 = tem;
11460               continue;
11461             }
11462           break;
11463
11464         case EQ:  case NE:
11465         case UNEQ:  case LTGT:
11466         case LT:  case LTU:  case UNLT:  case LE:  case LEU:  case UNLE:
11467         case GT:  case GTU:  case UNGT:  case GE:  case GEU:  case UNGE:
11468         case UNORDERED: case ORDERED:
11469           /* We can't do anything if OP0 is a condition code value, rather
11470              than an actual data value.  */
11471           if (const_op != 0
11472               || CC0_P (XEXP (op0, 0))
11473               || GET_MODE_CLASS (GET_MODE (XEXP (op0, 0))) == MODE_CC)
11474             break;
11475
11476           /* Get the two operands being compared.  */
11477           if (GET_CODE (XEXP (op0, 0)) == COMPARE)
11478             tem = XEXP (XEXP (op0, 0), 0), tem1 = XEXP (XEXP (op0, 0), 1);
11479           else
11480             tem = XEXP (op0, 0), tem1 = XEXP (op0, 1);
11481
11482           /* Check for the cases where we simply want the result of the
11483              earlier test or the opposite of that result.  */
11484           if (code == NE || code == EQ
11485               || (GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
11486                   && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
11487                   && (STORE_FLAG_VALUE
11488                       & (((unsigned HOST_WIDE_INT) 1
11489                           << (GET_MODE_BITSIZE (GET_MODE (op0)) - 1))))
11490                   && (code == LT || code == GE)))
11491             {
11492               enum rtx_code new_code;
11493               if (code == LT || code == NE)
11494                 new_code = GET_CODE (op0);
11495               else
11496                 new_code = reversed_comparison_code (op0, NULL);
11497
11498               if (new_code != UNKNOWN)
11499                 {
11500                   code = new_code;
11501                   op0 = tem;
11502                   op1 = tem1;
11503                   continue;
11504                 }
11505             }
11506           break;
11507
11508         case IOR:
11509           /* The sign bit of (ior (plus X (const_int -1)) X) is nonzero
11510              iff X <= 0.  */
11511           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 0)) == PLUS
11512               && XEXP (XEXP (op0, 0), 1) == constm1_rtx
11513               && rtx_equal_p (XEXP (XEXP (op0, 0), 0), XEXP (op0, 1)))
11514             {
11515               op0 = XEXP (op0, 1);
11516               code = (code == GE ? GT : LE);
11517               continue;
11518             }
11519           break;
11520
11521         case AND:
11522           /* Convert (and (xshift 1 X) Y) to (and (lshiftrt Y X) 1).  This
11523              will be converted to a ZERO_EXTRACT later.  */
11524           if (const_op == 0 && equality_comparison_p
11525               && GET_CODE (XEXP (op0, 0)) == ASHIFT
11526               && XEXP (XEXP (op0, 0), 0) == const1_rtx)
11527             {
11528               op0 = gen_rtx_LSHIFTRT (mode, XEXP (op0, 1),
11529                                       XEXP (XEXP (op0, 0), 1));
11530               op0 = simplify_and_const_int (NULL_RTX, mode, op0, 1);
11531               continue;
11532             }
11533
11534           /* If we are comparing (and (lshiftrt X C1) C2) for equality with
11535              zero and X is a comparison and C1 and C2 describe only bits set
11536              in STORE_FLAG_VALUE, we can compare with X.  */
11537           if (const_op == 0 && equality_comparison_p
11538               && mode_width <= HOST_BITS_PER_WIDE_INT
11539               && CONST_INT_P (XEXP (op0, 1))
11540               && GET_CODE (XEXP (op0, 0)) == LSHIFTRT
11541               && CONST_INT_P (XEXP (XEXP (op0, 0), 1))
11542               && INTVAL (XEXP (XEXP (op0, 0), 1)) >= 0
11543               && INTVAL (XEXP (XEXP (op0, 0), 1)) < HOST_BITS_PER_WIDE_INT)
11544             {
11545               mask = ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
11546                       << INTVAL (XEXP (XEXP (op0, 0), 1)));
11547               if ((~STORE_FLAG_VALUE & mask) == 0
11548                   && (COMPARISON_P (XEXP (XEXP (op0, 0), 0))
11549                       || ((tem = get_last_value (XEXP (XEXP (op0, 0), 0))) != 0
11550                           && COMPARISON_P (tem))))
11551                 {
11552                   op0 = XEXP (XEXP (op0, 0), 0);
11553                   continue;
11554                 }
11555             }
11556
11557           /* If we are doing an equality comparison of an AND of a bit equal
11558              to the sign bit, replace this with a LT or GE comparison of
11559              the underlying value.  */
11560           if (equality_comparison_p
11561               && const_op == 0
11562               && CONST_INT_P (XEXP (op0, 1))
11563               && mode_width <= HOST_BITS_PER_WIDE_INT
11564               && ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
11565                   == (unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
11566             {
11567               op0 = XEXP (op0, 0);
11568               code = (code == EQ ? GE : LT);
11569               continue;
11570             }
11571
11572           /* If this AND operation is really a ZERO_EXTEND from a narrower
11573              mode, the constant fits within that mode, and this is either an
11574              equality or unsigned comparison, try to do this comparison in
11575              the narrower mode.
11576
11577              Note that in:
11578
11579              (ne:DI (and:DI (reg:DI 4) (const_int 0xffffffff)) (const_int 0))
11580              -> (ne:DI (reg:SI 4) (const_int 0))
11581
11582              unless TRULY_NOOP_TRUNCATION allows it or the register is
11583              known to hold a value of the required mode the
11584              transformation is invalid.  */
11585           if ((equality_comparison_p || unsigned_comparison_p)
11586               && CONST_INT_P (XEXP (op0, 1))
11587               && (i = exact_log2 ((UINTVAL (XEXP (op0, 1))
11588                                    & GET_MODE_MASK (mode))
11589                                   + 1)) >= 0
11590               && const_op >> i == 0
11591               && (tmode = mode_for_size (i, MODE_INT, 1)) != BLKmode
11592               && (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (tmode),
11593                                          GET_MODE_BITSIZE (GET_MODE (op0)))
11594                   || (REG_P (XEXP (op0, 0))
11595                       && reg_truncated_to_mode (tmode, XEXP (op0, 0)))))
11596             {
11597               op0 = gen_lowpart (tmode, XEXP (op0, 0));
11598               continue;
11599             }
11600
11601           /* If this is (and:M1 (subreg:M2 X 0) (const_int C1)) where C1
11602              fits in both M1 and M2 and the SUBREG is either paradoxical
11603              or represents the low part, permute the SUBREG and the AND
11604              and try again.  */
11605           if (GET_CODE (XEXP (op0, 0)) == SUBREG)
11606             {
11607               unsigned HOST_WIDE_INT c1;
11608               tmode = GET_MODE (SUBREG_REG (XEXP (op0, 0)));
11609               /* Require an integral mode, to avoid creating something like
11610                  (AND:SF ...).  */
11611               if (SCALAR_INT_MODE_P (tmode)
11612                   /* It is unsafe to commute the AND into the SUBREG if the
11613                      SUBREG is paradoxical and WORD_REGISTER_OPERATIONS is
11614                      not defined.  As originally written the upper bits
11615                      have a defined value due to the AND operation.
11616                      However, if we commute the AND inside the SUBREG then
11617                      they no longer have defined values and the meaning of
11618                      the code has been changed.  */
11619                   && (0
11620 #ifdef WORD_REGISTER_OPERATIONS
11621                       || (mode_width > GET_MODE_BITSIZE (tmode)
11622                           && mode_width <= BITS_PER_WORD)
11623 #endif
11624                       || (mode_width <= GET_MODE_BITSIZE (tmode)
11625                           && subreg_lowpart_p (XEXP (op0, 0))))
11626                   && CONST_INT_P (XEXP (op0, 1))
11627                   && mode_width <= HOST_BITS_PER_WIDE_INT
11628                   && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT
11629                   && ((c1 = INTVAL (XEXP (op0, 1))) & ~mask) == 0
11630                   && (c1 & ~GET_MODE_MASK (tmode)) == 0
11631                   && c1 != mask
11632                   && c1 != GET_MODE_MASK (tmode))
11633                 {
11634                   op0 = simplify_gen_binary (AND, tmode,
11635                                              SUBREG_REG (XEXP (op0, 0)),
11636                                              gen_int_mode (c1, tmode));
11637                   op0 = gen_lowpart (mode, op0);
11638                   continue;
11639                 }
11640             }
11641
11642           /* Convert (ne (and (not X) 1) 0) to (eq (and X 1) 0).  */
11643           if (const_op == 0 && equality_comparison_p
11644               && XEXP (op0, 1) == const1_rtx
11645               && GET_CODE (XEXP (op0, 0)) == NOT)
11646             {
11647               op0 = simplify_and_const_int (NULL_RTX, mode,
11648                                             XEXP (XEXP (op0, 0), 0), 1);
11649               code = (code == NE ? EQ : NE);
11650               continue;
11651             }
11652
11653           /* Convert (ne (and (lshiftrt (not X)) 1) 0) to
11654              (eq (and (lshiftrt X) 1) 0).
11655              Also handle the case where (not X) is expressed using xor.  */
11656           if (const_op == 0 && equality_comparison_p
11657               && XEXP (op0, 1) == const1_rtx
11658               && GET_CODE (XEXP (op0, 0)) == LSHIFTRT)
11659             {
11660               rtx shift_op = XEXP (XEXP (op0, 0), 0);
11661               rtx shift_count = XEXP (XEXP (op0, 0), 1);
11662
11663               if (GET_CODE (shift_op) == NOT
11664                   || (GET_CODE (shift_op) == XOR
11665                       && CONST_INT_P (XEXP (shift_op, 1))
11666                       && CONST_INT_P (shift_count)
11667                       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
11668                       && (UINTVAL (XEXP (shift_op, 1))
11669                           == (unsigned HOST_WIDE_INT) 1
11670                                << INTVAL (shift_count))))
11671                 {
11672                   op0
11673                     = gen_rtx_LSHIFTRT (mode, XEXP (shift_op, 0), shift_count);
11674                   op0 = simplify_and_const_int (NULL_RTX, mode, op0, 1);
11675                   code = (code == NE ? EQ : NE);
11676                   continue;
11677                 }
11678             }
11679           break;
11680
11681         case ASHIFT:
11682           /* If we have (compare (ashift FOO N) (const_int C)) and
11683              the high order N bits of FOO (N+1 if an inequality comparison)
11684              are known to be zero, we can do this by comparing FOO with C
11685              shifted right N bits so long as the low-order N bits of C are
11686              zero.  */
11687           if (CONST_INT_P (XEXP (op0, 1))
11688               && INTVAL (XEXP (op0, 1)) >= 0
11689               && ((INTVAL (XEXP (op0, 1)) + ! equality_comparison_p)
11690                   < HOST_BITS_PER_WIDE_INT)
11691               && (((unsigned HOST_WIDE_INT) const_op
11692                    & (((unsigned HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1)))
11693                       - 1)) == 0)
11694               && mode_width <= HOST_BITS_PER_WIDE_INT
11695               && (nonzero_bits (XEXP (op0, 0), mode)
11696                   & ~(mask >> (INTVAL (XEXP (op0, 1))
11697                                + ! equality_comparison_p))) == 0)
11698             {
11699               /* We must perform a logical shift, not an arithmetic one,
11700                  as we want the top N bits of C to be zero.  */
11701               unsigned HOST_WIDE_INT temp = const_op & GET_MODE_MASK (mode);
11702
11703               temp >>= INTVAL (XEXP (op0, 1));
11704               op1 = gen_int_mode (temp, mode);
11705               op0 = XEXP (op0, 0);
11706               continue;
11707             }
11708
11709           /* If we are doing a sign bit comparison, it means we are testing
11710              a particular bit.  Convert it to the appropriate AND.  */
11711           if (sign_bit_comparison_p && CONST_INT_P (XEXP (op0, 1))
11712               && mode_width <= HOST_BITS_PER_WIDE_INT)
11713             {
11714               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
11715                                             ((unsigned HOST_WIDE_INT) 1
11716                                              << (mode_width - 1
11717                                                  - INTVAL (XEXP (op0, 1)))));
11718               code = (code == LT ? NE : EQ);
11719               continue;
11720             }
11721
11722           /* If this an equality comparison with zero and we are shifting
11723              the low bit to the sign bit, we can convert this to an AND of the
11724              low-order bit.  */
11725           if (const_op == 0 && equality_comparison_p
11726               && CONST_INT_P (XEXP (op0, 1))
11727               && UINTVAL (XEXP (op0, 1)) == mode_width - 1)
11728             {
11729               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0), 1);
11730               continue;
11731             }
11732           break;
11733
11734         case ASHIFTRT:
11735           /* If this is an equality comparison with zero, we can do this
11736              as a logical shift, which might be much simpler.  */
11737           if (equality_comparison_p && const_op == 0
11738               && CONST_INT_P (XEXP (op0, 1)))
11739             {
11740               op0 = simplify_shift_const (NULL_RTX, LSHIFTRT, mode,
11741                                           XEXP (op0, 0),
11742                                           INTVAL (XEXP (op0, 1)));
11743               continue;
11744             }
11745
11746           /* If OP0 is a sign extension and CODE is not an unsigned comparison,
11747              do the comparison in a narrower mode.  */
11748           if (! unsigned_comparison_p
11749               && CONST_INT_P (XEXP (op0, 1))
11750               && GET_CODE (XEXP (op0, 0)) == ASHIFT
11751               && XEXP (op0, 1) == XEXP (XEXP (op0, 0), 1)
11752               && (tmode = mode_for_size (mode_width - INTVAL (XEXP (op0, 1)),
11753                                          MODE_INT, 1)) != BLKmode
11754               && (((unsigned HOST_WIDE_INT) const_op
11755                    + (GET_MODE_MASK (tmode) >> 1) + 1)
11756                   <= GET_MODE_MASK (tmode)))
11757             {
11758               op0 = gen_lowpart (tmode, XEXP (XEXP (op0, 0), 0));
11759               continue;
11760             }
11761
11762           /* Likewise if OP0 is a PLUS of a sign extension with a
11763              constant, which is usually represented with the PLUS
11764              between the shifts.  */
11765           if (! unsigned_comparison_p
11766               && CONST_INT_P (XEXP (op0, 1))
11767               && GET_CODE (XEXP (op0, 0)) == PLUS
11768               && CONST_INT_P (XEXP (XEXP (op0, 0), 1))
11769               && GET_CODE (XEXP (XEXP (op0, 0), 0)) == ASHIFT
11770               && XEXP (op0, 1) == XEXP (XEXP (XEXP (op0, 0), 0), 1)
11771               && (tmode = mode_for_size (mode_width - INTVAL (XEXP (op0, 1)),
11772                                          MODE_INT, 1)) != BLKmode
11773               && (((unsigned HOST_WIDE_INT) const_op
11774                    + (GET_MODE_MASK (tmode) >> 1) + 1)
11775                   <= GET_MODE_MASK (tmode)))
11776             {
11777               rtx inner = XEXP (XEXP (XEXP (op0, 0), 0), 0);
11778               rtx add_const = XEXP (XEXP (op0, 0), 1);
11779               rtx new_const = simplify_gen_binary (ASHIFTRT, GET_MODE (op0),
11780                                                    add_const, XEXP (op0, 1));
11781
11782               op0 = simplify_gen_binary (PLUS, tmode,
11783                                          gen_lowpart (tmode, inner),
11784                                          new_const);
11785               continue;
11786             }
11787
11788           /* ... fall through ...  */
11789         case LSHIFTRT:
11790           /* If we have (compare (xshiftrt FOO N) (const_int C)) and
11791              the low order N bits of FOO are known to be zero, we can do this
11792              by comparing FOO with C shifted left N bits so long as no
11793              overflow occurs.  Even if the low order N bits of FOO aren't known
11794              to be zero, if the comparison is >= or < we can use the same
11795              optimization and for > or <= by setting all the low
11796              order N bits in the comparison constant.  */
11797           if (CONST_INT_P (XEXP (op0, 1))
11798               && INTVAL (XEXP (op0, 1)) > 0
11799               && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
11800               && mode_width <= HOST_BITS_PER_WIDE_INT
11801               && (((unsigned HOST_WIDE_INT) const_op
11802                    + (GET_CODE (op0) != LSHIFTRT
11803                       ? ((GET_MODE_MASK (mode) >> INTVAL (XEXP (op0, 1)) >> 1)
11804                          + 1)
11805                       : 0))
11806                   <= GET_MODE_MASK (mode) >> INTVAL (XEXP (op0, 1))))
11807             {
11808               unsigned HOST_WIDE_INT low_bits
11809                 = (nonzero_bits (XEXP (op0, 0), mode)
11810                    & (((unsigned HOST_WIDE_INT) 1
11811                        << INTVAL (XEXP (op0, 1))) - 1));
11812               if (low_bits == 0 || !equality_comparison_p)
11813                 {
11814                   /* If the shift was logical, then we must make the condition
11815                      unsigned.  */
11816                   if (GET_CODE (op0) == LSHIFTRT)
11817                     code = unsigned_condition (code);
11818
11819                   const_op <<= INTVAL (XEXP (op0, 1));
11820                   if (low_bits != 0
11821                       && (code == GT || code == GTU
11822                           || code == LE || code == LEU))
11823                     const_op
11824                       |= (((HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1))) - 1);
11825                   op1 = GEN_INT (const_op);
11826                   op0 = XEXP (op0, 0);
11827                   continue;
11828                 }
11829             }
11830
11831           /* If we are using this shift to extract just the sign bit, we
11832              can replace this with an LT or GE comparison.  */
11833           if (const_op == 0
11834               && (equality_comparison_p || sign_bit_comparison_p)
11835               && CONST_INT_P (XEXP (op0, 1))
11836               && UINTVAL (XEXP (op0, 1)) == mode_width - 1)
11837             {
11838               op0 = XEXP (op0, 0);
11839               code = (code == NE || code == GT ? LT : GE);
11840               continue;
11841             }
11842           break;
11843
11844         default:
11845           break;
11846         }
11847
11848       break;
11849     }
11850
11851   /* Now make any compound operations involved in this comparison.  Then,
11852      check for an outmost SUBREG on OP0 that is not doing anything or is
11853      paradoxical.  The latter transformation must only be performed when
11854      it is known that the "extra" bits will be the same in op0 and op1 or
11855      that they don't matter.  There are three cases to consider:
11856
11857      1. SUBREG_REG (op0) is a register.  In this case the bits are don't
11858      care bits and we can assume they have any convenient value.  So
11859      making the transformation is safe.
11860
11861      2. SUBREG_REG (op0) is a memory and LOAD_EXTEND_OP is not defined.
11862      In this case the upper bits of op0 are undefined.  We should not make
11863      the simplification in that case as we do not know the contents of
11864      those bits.
11865
11866      3. SUBREG_REG (op0) is a memory and LOAD_EXTEND_OP is defined and not
11867      UNKNOWN.  In that case we know those bits are zeros or ones.  We must
11868      also be sure that they are the same as the upper bits of op1.
11869
11870      We can never remove a SUBREG for a non-equality comparison because
11871      the sign bit is in a different place in the underlying object.  */
11872
11873   op0 = make_compound_operation (op0, op1 == const0_rtx ? COMPARE : SET);
11874   op1 = make_compound_operation (op1, SET);
11875
11876   if (GET_CODE (op0) == SUBREG && subreg_lowpart_p (op0)
11877       && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
11878       && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op0))) == MODE_INT
11879       && (code == NE || code == EQ))
11880     {
11881       if (GET_MODE_SIZE (GET_MODE (op0))
11882           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0))))
11883         {
11884           /* For paradoxical subregs, allow case 1 as above.  Case 3 isn't
11885              implemented.  */
11886           if (REG_P (SUBREG_REG (op0)))
11887             {
11888               op0 = SUBREG_REG (op0);
11889               op1 = gen_lowpart (GET_MODE (op0), op1);
11890             }
11891         }
11892       else if ((GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0)))
11893                 <= HOST_BITS_PER_WIDE_INT)
11894                && (nonzero_bits (SUBREG_REG (op0),
11895                                  GET_MODE (SUBREG_REG (op0)))
11896                    & ~GET_MODE_MASK (GET_MODE (op0))) == 0)
11897         {
11898           tem = gen_lowpart (GET_MODE (SUBREG_REG (op0)), op1);
11899
11900           if ((nonzero_bits (tem, GET_MODE (SUBREG_REG (op0)))
11901                & ~GET_MODE_MASK (GET_MODE (op0))) == 0)
11902             op0 = SUBREG_REG (op0), op1 = tem;
11903         }
11904     }
11905
11906   /* We now do the opposite procedure: Some machines don't have compare
11907      insns in all modes.  If OP0's mode is an integer mode smaller than a
11908      word and we can't do a compare in that mode, see if there is a larger
11909      mode for which we can do the compare.  There are a number of cases in
11910      which we can use the wider mode.  */
11911
11912   mode = GET_MODE (op0);
11913   if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
11914       && GET_MODE_SIZE (mode) < UNITS_PER_WORD
11915       && ! have_insn_for (COMPARE, mode))
11916     for (tmode = GET_MODE_WIDER_MODE (mode);
11917          (tmode != VOIDmode
11918           && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT);
11919          tmode = GET_MODE_WIDER_MODE (tmode))
11920       if (have_insn_for (COMPARE, tmode))
11921         {
11922           int zero_extended;
11923
11924           /* If this is a test for negative, we can make an explicit
11925              test of the sign bit.  Test this first so we can use
11926              a paradoxical subreg to extend OP0.  */
11927
11928           if (op1 == const0_rtx && (code == LT || code == GE)
11929               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11930             {
11931               op0 = simplify_gen_binary (AND, tmode,
11932                                          gen_lowpart (tmode, op0),
11933                                          GEN_INT ((unsigned HOST_WIDE_INT) 1
11934                                                   << (GET_MODE_BITSIZE (mode)
11935                                                       - 1)));
11936               code = (code == LT) ? NE : EQ;
11937               break;
11938             }
11939
11940           /* If the only nonzero bits in OP0 and OP1 are those in the
11941              narrower mode and this is an equality or unsigned comparison,
11942              we can use the wider mode.  Similarly for sign-extended
11943              values, in which case it is true for all comparisons.  */
11944           zero_extended = ((code == EQ || code == NE
11945                             || code == GEU || code == GTU
11946                             || code == LEU || code == LTU)
11947                            && (nonzero_bits (op0, tmode)
11948                                & ~GET_MODE_MASK (mode)) == 0
11949                            && ((CONST_INT_P (op1)
11950                                 || (nonzero_bits (op1, tmode)
11951                                     & ~GET_MODE_MASK (mode)) == 0)));
11952
11953           if (zero_extended
11954               || ((num_sign_bit_copies (op0, tmode)
11955                    > (unsigned int) (GET_MODE_BITSIZE (tmode)
11956                                      - GET_MODE_BITSIZE (mode)))
11957                   && (num_sign_bit_copies (op1, tmode)
11958                       > (unsigned int) (GET_MODE_BITSIZE (tmode)
11959                                         - GET_MODE_BITSIZE (mode)))))
11960             {
11961               /* If OP0 is an AND and we don't have an AND in MODE either,
11962                  make a new AND in the proper mode.  */
11963               if (GET_CODE (op0) == AND
11964                   && !have_insn_for (AND, mode))
11965                 op0 = simplify_gen_binary (AND, tmode,
11966                                            gen_lowpart (tmode,
11967                                                         XEXP (op0, 0)),
11968                                            gen_lowpart (tmode,
11969                                                         XEXP (op0, 1)));
11970               else
11971                 {
11972                   if (zero_extended)
11973                     {
11974                       op0 = simplify_gen_unary (ZERO_EXTEND, tmode, op0, mode);
11975                       op1 = simplify_gen_unary (ZERO_EXTEND, tmode, op1, mode);
11976                     }
11977                   else
11978                     {
11979                       op0 = simplify_gen_unary (SIGN_EXTEND, tmode, op0, mode);
11980                       op1 = simplify_gen_unary (SIGN_EXTEND, tmode, op1, mode);
11981                     }
11982                   break;
11983                 }
11984             }
11985         }
11986
11987 #ifdef CANONICALIZE_COMPARISON
11988   /* If this machine only supports a subset of valid comparisons, see if we
11989      can convert an unsupported one into a supported one.  */
11990   CANONICALIZE_COMPARISON (code, op0, op1);
11991 #endif
11992
11993   *pop0 = op0;
11994   *pop1 = op1;
11995
11996   return code;
11997 }
11998 \f
11999 /* Utility function for record_value_for_reg.  Count number of
12000    rtxs in X.  */
12001 static int
12002 count_rtxs (rtx x)
12003 {
12004   enum rtx_code code = GET_CODE (x);
12005   const char *fmt;
12006   int i, j, ret = 1;
12007
12008   if (GET_RTX_CLASS (code) == '2'
12009       || GET_RTX_CLASS (code) == 'c')
12010     {
12011       rtx x0 = XEXP (x, 0);
12012       rtx x1 = XEXP (x, 1);
12013
12014       if (x0 == x1)
12015         return 1 + 2 * count_rtxs (x0);
12016
12017       if ((GET_RTX_CLASS (GET_CODE (x1)) == '2'
12018            || GET_RTX_CLASS (GET_CODE (x1)) == 'c')
12019           && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
12020         return 2 + 2 * count_rtxs (x0)
12021                + count_rtxs (x == XEXP (x1, 0)
12022                              ? XEXP (x1, 1) : XEXP (x1, 0));
12023
12024       if ((GET_RTX_CLASS (GET_CODE (x0)) == '2'
12025            || GET_RTX_CLASS (GET_CODE (x0)) == 'c')
12026           && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
12027         return 2 + 2 * count_rtxs (x1)
12028                + count_rtxs (x == XEXP (x0, 0)
12029                              ? XEXP (x0, 1) : XEXP (x0, 0));
12030     }
12031
12032   fmt = GET_RTX_FORMAT (code);
12033   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12034     if (fmt[i] == 'e')
12035       ret += count_rtxs (XEXP (x, i));
12036     else if (fmt[i] == 'E')
12037       for (j = 0; j < XVECLEN (x, i); j++)
12038         ret += count_rtxs (XVECEXP (x, i, j));
12039
12040   return ret;
12041 }
12042 \f
12043 /* Utility function for following routine.  Called when X is part of a value
12044    being stored into last_set_value.  Sets last_set_table_tick
12045    for each register mentioned.  Similar to mention_regs in cse.c  */
12046
12047 static void
12048 update_table_tick (rtx x)
12049 {
12050   enum rtx_code code = GET_CODE (x);
12051   const char *fmt = GET_RTX_FORMAT (code);
12052   int i, j;
12053
12054   if (code == REG)
12055     {
12056       unsigned int regno = REGNO (x);
12057       unsigned int endregno = END_REGNO (x);
12058       unsigned int r;
12059
12060       for (r = regno; r < endregno; r++)
12061         {
12062           reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, r);
12063           rsp->last_set_table_tick = label_tick;
12064         }
12065
12066       return;
12067     }
12068
12069   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12070     if (fmt[i] == 'e')
12071       {
12072         /* Check for identical subexpressions.  If x contains
12073            identical subexpression we only have to traverse one of
12074            them.  */
12075         if (i == 0 && ARITHMETIC_P (x))
12076           {
12077             /* Note that at this point x1 has already been
12078                processed.  */
12079             rtx x0 = XEXP (x, 0);
12080             rtx x1 = XEXP (x, 1);
12081
12082             /* If x0 and x1 are identical then there is no need to
12083                process x0.  */
12084             if (x0 == x1)
12085               break;
12086
12087             /* If x0 is identical to a subexpression of x1 then while
12088                processing x1, x0 has already been processed.  Thus we
12089                are done with x.  */
12090             if (ARITHMETIC_P (x1)
12091                 && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
12092               break;
12093
12094             /* If x1 is identical to a subexpression of x0 then we
12095                still have to process the rest of x0.  */
12096             if (ARITHMETIC_P (x0)
12097                 && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
12098               {
12099                 update_table_tick (XEXP (x0, x1 == XEXP (x0, 0) ? 1 : 0));
12100                 break;
12101               }
12102           }
12103
12104         update_table_tick (XEXP (x, i));
12105       }
12106     else if (fmt[i] == 'E')
12107       for (j = 0; j < XVECLEN (x, i); j++)
12108         update_table_tick (XVECEXP (x, i, j));
12109 }
12110
12111 /* Record that REG is set to VALUE in insn INSN.  If VALUE is zero, we
12112    are saying that the register is clobbered and we no longer know its
12113    value.  If INSN is zero, don't update reg_stat[].last_set; this is
12114    only permitted with VALUE also zero and is used to invalidate the
12115    register.  */
12116
12117 static void
12118 record_value_for_reg (rtx reg, rtx insn, rtx value)
12119 {
12120   unsigned int regno = REGNO (reg);
12121   unsigned int endregno = END_REGNO (reg);
12122   unsigned int i;
12123   reg_stat_type *rsp;
12124
12125   /* If VALUE contains REG and we have a previous value for REG, substitute
12126      the previous value.  */
12127   if (value && insn && reg_overlap_mentioned_p (reg, value))
12128     {
12129       rtx tem;
12130
12131       /* Set things up so get_last_value is allowed to see anything set up to
12132          our insn.  */
12133       subst_low_luid = DF_INSN_LUID (insn);
12134       tem = get_last_value (reg);
12135
12136       /* If TEM is simply a binary operation with two CLOBBERs as operands,
12137          it isn't going to be useful and will take a lot of time to process,
12138          so just use the CLOBBER.  */
12139
12140       if (tem)
12141         {
12142           if (ARITHMETIC_P (tem)
12143               && GET_CODE (XEXP (tem, 0)) == CLOBBER
12144               && GET_CODE (XEXP (tem, 1)) == CLOBBER)
12145             tem = XEXP (tem, 0);
12146           else if (count_occurrences (value, reg, 1) >= 2)
12147             {
12148               /* If there are two or more occurrences of REG in VALUE,
12149                  prevent the value from growing too much.  */
12150               if (count_rtxs (tem) > MAX_LAST_VALUE_RTL)
12151                 tem = gen_rtx_CLOBBER (GET_MODE (tem), const0_rtx);
12152             }
12153
12154           value = replace_rtx (copy_rtx (value), reg, tem);
12155         }
12156     }
12157
12158   /* For each register modified, show we don't know its value, that
12159      we don't know about its bitwise content, that its value has been
12160      updated, and that we don't know the location of the death of the
12161      register.  */
12162   for (i = regno; i < endregno; i++)
12163     {
12164       rsp = VEC_index (reg_stat_type, reg_stat, i);
12165
12166       if (insn)
12167         rsp->last_set = insn;
12168
12169       rsp->last_set_value = 0;
12170       rsp->last_set_mode = VOIDmode;
12171       rsp->last_set_nonzero_bits = 0;
12172       rsp->last_set_sign_bit_copies = 0;
12173       rsp->last_death = 0;
12174       rsp->truncated_to_mode = VOIDmode;
12175     }
12176
12177   /* Mark registers that are being referenced in this value.  */
12178   if (value)
12179     update_table_tick (value);
12180
12181   /* Now update the status of each register being set.
12182      If someone is using this register in this block, set this register
12183      to invalid since we will get confused between the two lives in this
12184      basic block.  This makes using this register always invalid.  In cse, we
12185      scan the table to invalidate all entries using this register, but this
12186      is too much work for us.  */
12187
12188   for (i = regno; i < endregno; i++)
12189     {
12190       rsp = VEC_index (reg_stat_type, reg_stat, i);
12191       rsp->last_set_label = label_tick;
12192       if (!insn
12193           || (value && rsp->last_set_table_tick >= label_tick_ebb_start))
12194         rsp->last_set_invalid = 1;
12195       else
12196         rsp->last_set_invalid = 0;
12197     }
12198
12199   /* The value being assigned might refer to X (like in "x++;").  In that
12200      case, we must replace it with (clobber (const_int 0)) to prevent
12201      infinite loops.  */
12202   rsp = VEC_index (reg_stat_type, reg_stat, regno);
12203   if (value && !get_last_value_validate (&value, insn, label_tick, 0))
12204     {
12205       value = copy_rtx (value);
12206       if (!get_last_value_validate (&value, insn, label_tick, 1))
12207         value = 0;
12208     }
12209
12210   /* For the main register being modified, update the value, the mode, the
12211      nonzero bits, and the number of sign bit copies.  */
12212
12213   rsp->last_set_value = value;
12214
12215   if (value)
12216     {
12217       enum machine_mode mode = GET_MODE (reg);
12218       subst_low_luid = DF_INSN_LUID (insn);
12219       rsp->last_set_mode = mode;
12220       if (GET_MODE_CLASS (mode) == MODE_INT
12221           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
12222         mode = nonzero_bits_mode;
12223       rsp->last_set_nonzero_bits = nonzero_bits (value, mode);
12224       rsp->last_set_sign_bit_copies
12225         = num_sign_bit_copies (value, GET_MODE (reg));
12226     }
12227 }
12228
12229 /* Called via note_stores from record_dead_and_set_regs to handle one
12230    SET or CLOBBER in an insn.  DATA is the instruction in which the
12231    set is occurring.  */
12232
12233 static void
12234 record_dead_and_set_regs_1 (rtx dest, const_rtx setter, void *data)
12235 {
12236   rtx record_dead_insn = (rtx) data;
12237
12238   if (GET_CODE (dest) == SUBREG)
12239     dest = SUBREG_REG (dest);
12240
12241   if (!record_dead_insn)
12242     {
12243       if (REG_P (dest))
12244         record_value_for_reg (dest, NULL_RTX, NULL_RTX);
12245       return;
12246     }
12247
12248   if (REG_P (dest))
12249     {
12250       /* If we are setting the whole register, we know its value.  Otherwise
12251          show that we don't know the value.  We can handle SUBREG in
12252          some cases.  */
12253       if (GET_CODE (setter) == SET && dest == SET_DEST (setter))
12254         record_value_for_reg (dest, record_dead_insn, SET_SRC (setter));
12255       else if (GET_CODE (setter) == SET
12256                && GET_CODE (SET_DEST (setter)) == SUBREG
12257                && SUBREG_REG (SET_DEST (setter)) == dest
12258                && GET_MODE_BITSIZE (GET_MODE (dest)) <= BITS_PER_WORD
12259                && subreg_lowpart_p (SET_DEST (setter)))
12260         record_value_for_reg (dest, record_dead_insn,
12261                               gen_lowpart (GET_MODE (dest),
12262                                                        SET_SRC (setter)));
12263       else
12264         record_value_for_reg (dest, record_dead_insn, NULL_RTX);
12265     }
12266   else if (MEM_P (dest)
12267            /* Ignore pushes, they clobber nothing.  */
12268            && ! push_operand (dest, GET_MODE (dest)))
12269     mem_last_set = DF_INSN_LUID (record_dead_insn);
12270 }
12271
12272 /* Update the records of when each REG was most recently set or killed
12273    for the things done by INSN.  This is the last thing done in processing
12274    INSN in the combiner loop.
12275
12276    We update reg_stat[], in particular fields last_set, last_set_value,
12277    last_set_mode, last_set_nonzero_bits, last_set_sign_bit_copies,
12278    last_death, and also the similar information mem_last_set (which insn
12279    most recently modified memory) and last_call_luid (which insn was the
12280    most recent subroutine call).  */
12281
12282 static void
12283 record_dead_and_set_regs (rtx insn)
12284 {
12285   rtx link;
12286   unsigned int i;
12287
12288   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
12289     {
12290       if (REG_NOTE_KIND (link) == REG_DEAD
12291           && REG_P (XEXP (link, 0)))
12292         {
12293           unsigned int regno = REGNO (XEXP (link, 0));
12294           unsigned int endregno = END_REGNO (XEXP (link, 0));
12295
12296           for (i = regno; i < endregno; i++)
12297             {
12298               reg_stat_type *rsp;
12299
12300               rsp = VEC_index (reg_stat_type, reg_stat, i);
12301               rsp->last_death = insn;
12302             }
12303         }
12304       else if (REG_NOTE_KIND (link) == REG_INC)
12305         record_value_for_reg (XEXP (link, 0), insn, NULL_RTX);
12306     }
12307
12308   if (CALL_P (insn))
12309     {
12310       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
12311         if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
12312           {
12313             reg_stat_type *rsp;
12314
12315             rsp = VEC_index (reg_stat_type, reg_stat, i);
12316             rsp->last_set_invalid = 1;
12317             rsp->last_set = insn;
12318             rsp->last_set_value = 0;
12319             rsp->last_set_mode = VOIDmode;
12320             rsp->last_set_nonzero_bits = 0;
12321             rsp->last_set_sign_bit_copies = 0;
12322             rsp->last_death = 0;
12323             rsp->truncated_to_mode = VOIDmode;
12324           }
12325
12326       last_call_luid = mem_last_set = DF_INSN_LUID (insn);
12327
12328       /* We can't combine into a call pattern.  Remember, though, that
12329          the return value register is set at this LUID.  We could
12330          still replace a register with the return value from the
12331          wrong subroutine call!  */
12332       note_stores (PATTERN (insn), record_dead_and_set_regs_1, NULL_RTX);
12333     }
12334   else
12335     note_stores (PATTERN (insn), record_dead_and_set_regs_1, insn);
12336 }
12337
12338 /* If a SUBREG has the promoted bit set, it is in fact a property of the
12339    register present in the SUBREG, so for each such SUBREG go back and
12340    adjust nonzero and sign bit information of the registers that are
12341    known to have some zero/sign bits set.
12342
12343    This is needed because when combine blows the SUBREGs away, the
12344    information on zero/sign bits is lost and further combines can be
12345    missed because of that.  */
12346
12347 static void
12348 record_promoted_value (rtx insn, rtx subreg)
12349 {
12350   rtx links, set;
12351   unsigned int regno = REGNO (SUBREG_REG (subreg));
12352   enum machine_mode mode = GET_MODE (subreg);
12353
12354   if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
12355     return;
12356
12357   for (links = LOG_LINKS (insn); links;)
12358     {
12359       reg_stat_type *rsp;
12360
12361       insn = XEXP (links, 0);
12362       set = single_set (insn);
12363
12364       if (! set || !REG_P (SET_DEST (set))
12365           || REGNO (SET_DEST (set)) != regno
12366           || GET_MODE (SET_DEST (set)) != GET_MODE (SUBREG_REG (subreg)))
12367         {
12368           links = XEXP (links, 1);
12369           continue;
12370         }
12371
12372       rsp = VEC_index (reg_stat_type, reg_stat, regno);
12373       if (rsp->last_set == insn)
12374         {
12375           if (SUBREG_PROMOTED_UNSIGNED_P (subreg) > 0)
12376             rsp->last_set_nonzero_bits &= GET_MODE_MASK (mode);
12377         }
12378
12379       if (REG_P (SET_SRC (set)))
12380         {
12381           regno = REGNO (SET_SRC (set));
12382           links = LOG_LINKS (insn);
12383         }
12384       else
12385         break;
12386     }
12387 }
12388
12389 /* Check if X, a register, is known to contain a value already
12390    truncated to MODE.  In this case we can use a subreg to refer to
12391    the truncated value even though in the generic case we would need
12392    an explicit truncation.  */
12393
12394 static bool
12395 reg_truncated_to_mode (enum machine_mode mode, const_rtx x)
12396 {
12397   reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
12398   enum machine_mode truncated = rsp->truncated_to_mode;
12399
12400   if (truncated == 0
12401       || rsp->truncation_label < label_tick_ebb_start)
12402     return false;
12403   if (GET_MODE_SIZE (truncated) <= GET_MODE_SIZE (mode))
12404     return true;
12405   if (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
12406                              GET_MODE_BITSIZE (truncated)))
12407     return true;
12408   return false;
12409 }
12410
12411 /* Callback for for_each_rtx.  If *P is a hard reg or a subreg record the mode
12412    that the register is accessed in.  For non-TRULY_NOOP_TRUNCATION targets we
12413    might be able to turn a truncate into a subreg using this information.
12414    Return -1 if traversing *P is complete or 0 otherwise.  */
12415
12416 static int
12417 record_truncated_value (rtx *p, void *data ATTRIBUTE_UNUSED)
12418 {
12419   rtx x = *p;
12420   enum machine_mode truncated_mode;
12421   reg_stat_type *rsp;
12422
12423   if (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x)))
12424     {
12425       enum machine_mode original_mode = GET_MODE (SUBREG_REG (x));
12426       truncated_mode = GET_MODE (x);
12427
12428       if (GET_MODE_SIZE (original_mode) <= GET_MODE_SIZE (truncated_mode))
12429         return -1;
12430
12431       if (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (truncated_mode),
12432                                  GET_MODE_BITSIZE (original_mode)))
12433         return -1;
12434
12435       x = SUBREG_REG (x);
12436     }
12437   /* ??? For hard-regs we now record everything.  We might be able to
12438      optimize this using last_set_mode.  */
12439   else if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
12440     truncated_mode = GET_MODE (x);
12441   else
12442     return 0;
12443
12444   rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
12445   if (rsp->truncated_to_mode == 0
12446       || rsp->truncation_label < label_tick_ebb_start
12447       || (GET_MODE_SIZE (truncated_mode)
12448           < GET_MODE_SIZE (rsp->truncated_to_mode)))
12449     {
12450       rsp->truncated_to_mode = truncated_mode;
12451       rsp->truncation_label = label_tick;
12452     }
12453
12454   return -1;
12455 }
12456
12457 /* Callback for note_uses.  Find hardregs and subregs of pseudos and
12458    the modes they are used in.  This can help truning TRUNCATEs into
12459    SUBREGs.  */
12460
12461 static void
12462 record_truncated_values (rtx *x, void *data ATTRIBUTE_UNUSED)
12463 {
12464   for_each_rtx (x, record_truncated_value, NULL);
12465 }
12466
12467 /* Scan X for promoted SUBREGs.  For each one found,
12468    note what it implies to the registers used in it.  */
12469
12470 static void
12471 check_promoted_subreg (rtx insn, rtx x)
12472 {
12473   if (GET_CODE (x) == SUBREG
12474       && SUBREG_PROMOTED_VAR_P (x)
12475       && REG_P (SUBREG_REG (x)))
12476     record_promoted_value (insn, x);
12477   else
12478     {
12479       const char *format = GET_RTX_FORMAT (GET_CODE (x));
12480       int i, j;
12481
12482       for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
12483         switch (format[i])
12484           {
12485           case 'e':
12486             check_promoted_subreg (insn, XEXP (x, i));
12487             break;
12488           case 'V':
12489           case 'E':
12490             if (XVEC (x, i) != 0)
12491               for (j = 0; j < XVECLEN (x, i); j++)
12492                 check_promoted_subreg (insn, XVECEXP (x, i, j));
12493             break;
12494           }
12495     }
12496 }
12497 \f
12498 /* Verify that all the registers and memory references mentioned in *LOC are
12499    still valid.  *LOC was part of a value set in INSN when label_tick was
12500    equal to TICK.  Return 0 if some are not.  If REPLACE is nonzero, replace
12501    the invalid references with (clobber (const_int 0)) and return 1.  This
12502    replacement is useful because we often can get useful information about
12503    the form of a value (e.g., if it was produced by a shift that always
12504    produces -1 or 0) even though we don't know exactly what registers it
12505    was produced from.  */
12506
12507 static int
12508 get_last_value_validate (rtx *loc, rtx insn, int tick, int replace)
12509 {
12510   rtx x = *loc;
12511   const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
12512   int len = GET_RTX_LENGTH (GET_CODE (x));
12513   int i, j;
12514
12515   if (REG_P (x))
12516     {
12517       unsigned int regno = REGNO (x);
12518       unsigned int endregno = END_REGNO (x);
12519       unsigned int j;
12520
12521       for (j = regno; j < endregno; j++)
12522         {
12523           reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, j);
12524           if (rsp->last_set_invalid
12525               /* If this is a pseudo-register that was only set once and not
12526                  live at the beginning of the function, it is always valid.  */
12527               || (! (regno >= FIRST_PSEUDO_REGISTER
12528                      && REG_N_SETS (regno) == 1
12529                      && (!REGNO_REG_SET_P
12530                          (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), regno)))
12531                   && rsp->last_set_label > tick))
12532           {
12533             if (replace)
12534               *loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
12535             return replace;
12536           }
12537         }
12538
12539       return 1;
12540     }
12541   /* If this is a memory reference, make sure that there were no stores after
12542      it that might have clobbered the value.  We don't have alias info, so we
12543      assume any store invalidates it.  Moreover, we only have local UIDs, so
12544      we also assume that there were stores in the intervening basic blocks.  */
12545   else if (MEM_P (x) && !MEM_READONLY_P (x)
12546            && (tick != label_tick || DF_INSN_LUID (insn) <= mem_last_set))
12547     {
12548       if (replace)
12549         *loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
12550       return replace;
12551     }
12552
12553   for (i = 0; i < len; i++)
12554     {
12555       if (fmt[i] == 'e')
12556         {
12557           /* Check for identical subexpressions.  If x contains
12558              identical subexpression we only have to traverse one of
12559              them.  */
12560           if (i == 1 && ARITHMETIC_P (x))
12561             {
12562               /* Note that at this point x0 has already been checked
12563                  and found valid.  */
12564               rtx x0 = XEXP (x, 0);
12565               rtx x1 = XEXP (x, 1);
12566
12567               /* If x0 and x1 are identical then x is also valid.  */
12568               if (x0 == x1)
12569                 return 1;
12570
12571               /* If x1 is identical to a subexpression of x0 then
12572                  while checking x0, x1 has already been checked.  Thus
12573                  it is valid and so as x.  */
12574               if (ARITHMETIC_P (x0)
12575                   && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
12576                 return 1;
12577
12578               /* If x0 is identical to a subexpression of x1 then x is
12579                  valid iff the rest of x1 is valid.  */
12580               if (ARITHMETIC_P (x1)
12581                   && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
12582                 return
12583                   get_last_value_validate (&XEXP (x1,
12584                                                   x0 == XEXP (x1, 0) ? 1 : 0),
12585                                            insn, tick, replace);
12586             }
12587
12588           if (get_last_value_validate (&XEXP (x, i), insn, tick,
12589                                        replace) == 0)
12590             return 0;
12591         }
12592       else if (fmt[i] == 'E')
12593         for (j = 0; j < XVECLEN (x, i); j++)
12594           if (get_last_value_validate (&XVECEXP (x, i, j),
12595                                        insn, tick, replace) == 0)
12596             return 0;
12597     }
12598
12599   /* If we haven't found a reason for it to be invalid, it is valid.  */
12600   return 1;
12601 }
12602
12603 /* Get the last value assigned to X, if known.  Some registers
12604    in the value may be replaced with (clobber (const_int 0)) if their value
12605    is known longer known reliably.  */
12606
12607 static rtx
12608 get_last_value (const_rtx x)
12609 {
12610   unsigned int regno;
12611   rtx value;
12612   reg_stat_type *rsp;
12613
12614   /* If this is a non-paradoxical SUBREG, get the value of its operand and
12615      then convert it to the desired mode.  If this is a paradoxical SUBREG,
12616      we cannot predict what values the "extra" bits might have.  */
12617   if (GET_CODE (x) == SUBREG
12618       && subreg_lowpart_p (x)
12619       && (GET_MODE_SIZE (GET_MODE (x))
12620           <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
12621       && (value = get_last_value (SUBREG_REG (x))) != 0)
12622     return gen_lowpart (GET_MODE (x), value);
12623
12624   if (!REG_P (x))
12625     return 0;
12626
12627   regno = REGNO (x);
12628   rsp = VEC_index (reg_stat_type, reg_stat, regno);
12629   value = rsp->last_set_value;
12630
12631   /* If we don't have a value, or if it isn't for this basic block and
12632      it's either a hard register, set more than once, or it's a live
12633      at the beginning of the function, return 0.
12634
12635      Because if it's not live at the beginning of the function then the reg
12636      is always set before being used (is never used without being set).
12637      And, if it's set only once, and it's always set before use, then all
12638      uses must have the same last value, even if it's not from this basic
12639      block.  */
12640
12641   if (value == 0
12642       || (rsp->last_set_label < label_tick_ebb_start
12643           && (regno < FIRST_PSEUDO_REGISTER
12644               || REG_N_SETS (regno) != 1
12645               || REGNO_REG_SET_P
12646                  (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), regno))))
12647     return 0;
12648
12649   /* If the value was set in a later insn than the ones we are processing,
12650      we can't use it even if the register was only set once.  */
12651   if (rsp->last_set_label == label_tick
12652       && DF_INSN_LUID (rsp->last_set) >= subst_low_luid)
12653     return 0;
12654
12655   /* If the value has all its registers valid, return it.  */
12656   if (get_last_value_validate (&value, rsp->last_set, rsp->last_set_label, 0))
12657     return value;
12658
12659   /* Otherwise, make a copy and replace any invalid register with
12660      (clobber (const_int 0)).  If that fails for some reason, return 0.  */
12661
12662   value = copy_rtx (value);
12663   if (get_last_value_validate (&value, rsp->last_set, rsp->last_set_label, 1))
12664     return value;
12665
12666   return 0;
12667 }
12668 \f
12669 /* Return nonzero if expression X refers to a REG or to memory
12670    that is set in an instruction more recent than FROM_LUID.  */
12671
12672 static int
12673 use_crosses_set_p (const_rtx x, int from_luid)
12674 {
12675   const char *fmt;
12676   int i;
12677   enum rtx_code code = GET_CODE (x);
12678
12679   if (code == REG)
12680     {
12681       unsigned int regno = REGNO (x);
12682       unsigned endreg = END_REGNO (x);
12683
12684 #ifdef PUSH_ROUNDING
12685       /* Don't allow uses of the stack pointer to be moved,
12686          because we don't know whether the move crosses a push insn.  */
12687       if (regno == STACK_POINTER_REGNUM && PUSH_ARGS)
12688         return 1;
12689 #endif
12690       for (; regno < endreg; regno++)
12691         {
12692           reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, regno);
12693           if (rsp->last_set
12694               && rsp->last_set_label == label_tick
12695               && DF_INSN_LUID (rsp->last_set) > from_luid)
12696             return 1;
12697         }
12698       return 0;
12699     }
12700
12701   if (code == MEM && mem_last_set > from_luid)
12702     return 1;
12703
12704   fmt = GET_RTX_FORMAT (code);
12705
12706   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12707     {
12708       if (fmt[i] == 'E')
12709         {
12710           int j;
12711           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
12712             if (use_crosses_set_p (XVECEXP (x, i, j), from_luid))
12713               return 1;
12714         }
12715       else if (fmt[i] == 'e'
12716                && use_crosses_set_p (XEXP (x, i), from_luid))
12717         return 1;
12718     }
12719   return 0;
12720 }
12721 \f
12722 /* Define three variables used for communication between the following
12723    routines.  */
12724
12725 static unsigned int reg_dead_regno, reg_dead_endregno;
12726 static int reg_dead_flag;
12727
12728 /* Function called via note_stores from reg_dead_at_p.
12729
12730    If DEST is within [reg_dead_regno, reg_dead_endregno), set
12731    reg_dead_flag to 1 if X is a CLOBBER and to -1 it is a SET.  */
12732
12733 static void
12734 reg_dead_at_p_1 (rtx dest, const_rtx x, void *data ATTRIBUTE_UNUSED)
12735 {
12736   unsigned int regno, endregno;
12737
12738   if (!REG_P (dest))
12739     return;
12740
12741   regno = REGNO (dest);
12742   endregno = END_REGNO (dest);
12743   if (reg_dead_endregno > regno && reg_dead_regno < endregno)
12744     reg_dead_flag = (GET_CODE (x) == CLOBBER) ? 1 : -1;
12745 }
12746
12747 /* Return nonzero if REG is known to be dead at INSN.
12748
12749    We scan backwards from INSN.  If we hit a REG_DEAD note or a CLOBBER
12750    referencing REG, it is dead.  If we hit a SET referencing REG, it is
12751    live.  Otherwise, see if it is live or dead at the start of the basic
12752    block we are in.  Hard regs marked as being live in NEWPAT_USED_REGS
12753    must be assumed to be always live.  */
12754
12755 static int
12756 reg_dead_at_p (rtx reg, rtx insn)
12757 {
12758   basic_block block;
12759   unsigned int i;
12760
12761   /* Set variables for reg_dead_at_p_1.  */
12762   reg_dead_regno = REGNO (reg);
12763   reg_dead_endregno = END_REGNO (reg);
12764
12765   reg_dead_flag = 0;
12766
12767   /* Check that reg isn't mentioned in NEWPAT_USED_REGS.  For fixed registers
12768      we allow the machine description to decide whether use-and-clobber
12769      patterns are OK.  */
12770   if (reg_dead_regno < FIRST_PSEUDO_REGISTER)
12771     {
12772       for (i = reg_dead_regno; i < reg_dead_endregno; i++)
12773         if (!fixed_regs[i] && TEST_HARD_REG_BIT (newpat_used_regs, i))
12774           return 0;
12775     }
12776
12777   /* Scan backwards until we find a REG_DEAD note, SET, CLOBBER, or
12778      beginning of basic block.  */
12779   block = BLOCK_FOR_INSN (insn);
12780   for (;;)
12781     {
12782       if (INSN_P (insn))
12783         {
12784           note_stores (PATTERN (insn), reg_dead_at_p_1, NULL);
12785           if (reg_dead_flag)
12786             return reg_dead_flag == 1 ? 1 : 0;
12787
12788           if (find_regno_note (insn, REG_DEAD, reg_dead_regno))
12789             return 1;
12790         }
12791
12792       if (insn == BB_HEAD (block))
12793         break;
12794
12795       insn = PREV_INSN (insn);
12796     }
12797
12798   /* Look at live-in sets for the basic block that we were in.  */
12799   for (i = reg_dead_regno; i < reg_dead_endregno; i++)
12800     if (REGNO_REG_SET_P (df_get_live_in (block), i))
12801       return 0;
12802
12803   return 1;
12804 }
12805 \f
12806 /* Note hard registers in X that are used.  */
12807
12808 static void
12809 mark_used_regs_combine (rtx x)
12810 {
12811   RTX_CODE code = GET_CODE (x);
12812   unsigned int regno;
12813   int i;
12814
12815   switch (code)
12816     {
12817     case LABEL_REF:
12818     case SYMBOL_REF:
12819     case CONST_INT:
12820     case CONST:
12821     case CONST_DOUBLE:
12822     case CONST_VECTOR:
12823     case PC:
12824     case ADDR_VEC:
12825     case ADDR_DIFF_VEC:
12826     case ASM_INPUT:
12827 #ifdef HAVE_cc0
12828     /* CC0 must die in the insn after it is set, so we don't need to take
12829        special note of it here.  */
12830     case CC0:
12831 #endif
12832       return;
12833
12834     case CLOBBER:
12835       /* If we are clobbering a MEM, mark any hard registers inside the
12836          address as used.  */
12837       if (MEM_P (XEXP (x, 0)))
12838         mark_used_regs_combine (XEXP (XEXP (x, 0), 0));
12839       return;
12840
12841     case REG:
12842       regno = REGNO (x);
12843       /* A hard reg in a wide mode may really be multiple registers.
12844          If so, mark all of them just like the first.  */
12845       if (regno < FIRST_PSEUDO_REGISTER)
12846         {
12847           /* None of this applies to the stack, frame or arg pointers.  */
12848           if (regno == STACK_POINTER_REGNUM
12849 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
12850               || regno == HARD_FRAME_POINTER_REGNUM
12851 #endif
12852 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
12853               || (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
12854 #endif
12855               || regno == FRAME_POINTER_REGNUM)
12856             return;
12857
12858           add_to_hard_reg_set (&newpat_used_regs, GET_MODE (x), regno);
12859         }
12860       return;
12861
12862     case SET:
12863       {
12864         /* If setting a MEM, or a SUBREG of a MEM, then note any hard regs in
12865            the address.  */
12866         rtx testreg = SET_DEST (x);
12867
12868         while (GET_CODE (testreg) == SUBREG
12869                || GET_CODE (testreg) == ZERO_EXTRACT
12870                || GET_CODE (testreg) == STRICT_LOW_PART)
12871           testreg = XEXP (testreg, 0);
12872
12873         if (MEM_P (testreg))
12874           mark_used_regs_combine (XEXP (testreg, 0));
12875
12876         mark_used_regs_combine (SET_SRC (x));
12877       }
12878       return;
12879
12880     default:
12881       break;
12882     }
12883
12884   /* Recursively scan the operands of this expression.  */
12885
12886   {
12887     const char *fmt = GET_RTX_FORMAT (code);
12888
12889     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12890       {
12891         if (fmt[i] == 'e')
12892           mark_used_regs_combine (XEXP (x, i));
12893         else if (fmt[i] == 'E')
12894           {
12895             int j;
12896
12897             for (j = 0; j < XVECLEN (x, i); j++)
12898               mark_used_regs_combine (XVECEXP (x, i, j));
12899           }
12900       }
12901   }
12902 }
12903 \f
12904 /* Remove register number REGNO from the dead registers list of INSN.
12905
12906    Return the note used to record the death, if there was one.  */
12907
12908 rtx
12909 remove_death (unsigned int regno, rtx insn)
12910 {
12911   rtx note = find_regno_note (insn, REG_DEAD, regno);
12912
12913   if (note)
12914     remove_note (insn, note);
12915
12916   return note;
12917 }
12918
12919 /* For each register (hardware or pseudo) used within expression X, if its
12920    death is in an instruction with luid between FROM_LUID (inclusive) and
12921    TO_INSN (exclusive), put a REG_DEAD note for that register in the
12922    list headed by PNOTES.
12923
12924    That said, don't move registers killed by maybe_kill_insn.
12925
12926    This is done when X is being merged by combination into TO_INSN.  These
12927    notes will then be distributed as needed.  */
12928
12929 static void
12930 move_deaths (rtx x, rtx maybe_kill_insn, int from_luid, rtx to_insn,
12931              rtx *pnotes)
12932 {
12933   const char *fmt;
12934   int len, i;
12935   enum rtx_code code = GET_CODE (x);
12936
12937   if (code == REG)
12938     {
12939       unsigned int regno = REGNO (x);
12940       rtx where_dead = VEC_index (reg_stat_type, reg_stat, regno)->last_death;
12941
12942       /* Don't move the register if it gets killed in between from and to.  */
12943       if (maybe_kill_insn && reg_set_p (x, maybe_kill_insn)
12944           && ! reg_referenced_p (x, maybe_kill_insn))
12945         return;
12946
12947       if (where_dead
12948           && BLOCK_FOR_INSN (where_dead) == BLOCK_FOR_INSN (to_insn)
12949           && DF_INSN_LUID (where_dead) >= from_luid
12950           && DF_INSN_LUID (where_dead) < DF_INSN_LUID (to_insn))
12951         {
12952           rtx note = remove_death (regno, where_dead);
12953
12954           /* It is possible for the call above to return 0.  This can occur
12955              when last_death points to I2 or I1 that we combined with.
12956              In that case make a new note.
12957
12958              We must also check for the case where X is a hard register
12959              and NOTE is a death note for a range of hard registers
12960              including X.  In that case, we must put REG_DEAD notes for
12961              the remaining registers in place of NOTE.  */
12962
12963           if (note != 0 && regno < FIRST_PSEUDO_REGISTER
12964               && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
12965                   > GET_MODE_SIZE (GET_MODE (x))))
12966             {
12967               unsigned int deadregno = REGNO (XEXP (note, 0));
12968               unsigned int deadend = END_HARD_REGNO (XEXP (note, 0));
12969               unsigned int ourend = END_HARD_REGNO (x);
12970               unsigned int i;
12971
12972               for (i = deadregno; i < deadend; i++)
12973                 if (i < regno || i >= ourend)
12974                   add_reg_note (where_dead, REG_DEAD, regno_reg_rtx[i]);
12975             }
12976
12977           /* If we didn't find any note, or if we found a REG_DEAD note that
12978              covers only part of the given reg, and we have a multi-reg hard
12979              register, then to be safe we must check for REG_DEAD notes
12980              for each register other than the first.  They could have
12981              their own REG_DEAD notes lying around.  */
12982           else if ((note == 0
12983                     || (note != 0
12984                         && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
12985                             < GET_MODE_SIZE (GET_MODE (x)))))
12986                    && regno < FIRST_PSEUDO_REGISTER
12987                    && hard_regno_nregs[regno][GET_MODE (x)] > 1)
12988             {
12989               unsigned int ourend = END_HARD_REGNO (x);
12990               unsigned int i, offset;
12991               rtx oldnotes = 0;
12992
12993               if (note)
12994                 offset = hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))];
12995               else
12996                 offset = 1;
12997
12998               for (i = regno + offset; i < ourend; i++)
12999                 move_deaths (regno_reg_rtx[i],
13000                              maybe_kill_insn, from_luid, to_insn, &oldnotes);
13001             }
13002
13003           if (note != 0 && GET_MODE (XEXP (note, 0)) == GET_MODE (x))
13004             {
13005               XEXP (note, 1) = *pnotes;
13006               *pnotes = note;
13007             }
13008           else
13009             *pnotes = alloc_reg_note (REG_DEAD, x, *pnotes);
13010         }
13011
13012       return;
13013     }
13014
13015   else if (GET_CODE (x) == SET)
13016     {
13017       rtx dest = SET_DEST (x);
13018
13019       move_deaths (SET_SRC (x), maybe_kill_insn, from_luid, to_insn, pnotes);
13020
13021       /* In the case of a ZERO_EXTRACT, a STRICT_LOW_PART, or a SUBREG
13022          that accesses one word of a multi-word item, some
13023          piece of everything register in the expression is used by
13024          this insn, so remove any old death.  */
13025       /* ??? So why do we test for equality of the sizes?  */
13026
13027       if (GET_CODE (dest) == ZERO_EXTRACT
13028           || GET_CODE (dest) == STRICT_LOW_PART
13029           || (GET_CODE (dest) == SUBREG
13030               && (((GET_MODE_SIZE (GET_MODE (dest))
13031                     + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
13032                   == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
13033                        + UNITS_PER_WORD - 1) / UNITS_PER_WORD))))
13034         {
13035           move_deaths (dest, maybe_kill_insn, from_luid, to_insn, pnotes);
13036           return;
13037         }
13038
13039       /* If this is some other SUBREG, we know it replaces the entire
13040          value, so use that as the destination.  */
13041       if (GET_CODE (dest) == SUBREG)
13042         dest = SUBREG_REG (dest);
13043
13044       /* If this is a MEM, adjust deaths of anything used in the address.
13045          For a REG (the only other possibility), the entire value is
13046          being replaced so the old value is not used in this insn.  */
13047
13048       if (MEM_P (dest))
13049         move_deaths (XEXP (dest, 0), maybe_kill_insn, from_luid,
13050                      to_insn, pnotes);
13051       return;
13052     }
13053
13054   else if (GET_CODE (x) == CLOBBER)
13055     return;
13056
13057   len = GET_RTX_LENGTH (code);
13058   fmt = GET_RTX_FORMAT (code);
13059
13060   for (i = 0; i < len; i++)
13061     {
13062       if (fmt[i] == 'E')
13063         {
13064           int j;
13065           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
13066             move_deaths (XVECEXP (x, i, j), maybe_kill_insn, from_luid,
13067                          to_insn, pnotes);
13068         }
13069       else if (fmt[i] == 'e')
13070         move_deaths (XEXP (x, i), maybe_kill_insn, from_luid, to_insn, pnotes);
13071     }
13072 }
13073 \f
13074 /* Return 1 if X is the target of a bit-field assignment in BODY, the
13075    pattern of an insn.  X must be a REG.  */
13076
13077 static int
13078 reg_bitfield_target_p (rtx x, rtx body)
13079 {
13080   int i;
13081
13082   if (GET_CODE (body) == SET)
13083     {
13084       rtx dest = SET_DEST (body);
13085       rtx target;
13086       unsigned int regno, tregno, endregno, endtregno;
13087
13088       if (GET_CODE (dest) == ZERO_EXTRACT)
13089         target = XEXP (dest, 0);
13090       else if (GET_CODE (dest) == STRICT_LOW_PART)
13091         target = SUBREG_REG (XEXP (dest, 0));
13092       else
13093         return 0;
13094
13095       if (GET_CODE (target) == SUBREG)
13096         target = SUBREG_REG (target);
13097
13098       if (!REG_P (target))
13099         return 0;
13100
13101       tregno = REGNO (target), regno = REGNO (x);
13102       if (tregno >= FIRST_PSEUDO_REGISTER || regno >= FIRST_PSEUDO_REGISTER)
13103         return target == x;
13104
13105       endtregno = end_hard_regno (GET_MODE (target), tregno);
13106       endregno = end_hard_regno (GET_MODE (x), regno);
13107
13108       return endregno > tregno && regno < endtregno;
13109     }
13110
13111   else if (GET_CODE (body) == PARALLEL)
13112     for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
13113       if (reg_bitfield_target_p (x, XVECEXP (body, 0, i)))
13114         return 1;
13115
13116   return 0;
13117 }
13118 \f
13119 /* Given a chain of REG_NOTES originally from FROM_INSN, try to place them
13120    as appropriate.  I3 and I2 are the insns resulting from the combination
13121    insns including FROM (I2 may be zero).
13122
13123    ELIM_I2 and ELIM_I1 are either zero or registers that we know will
13124    not need REG_DEAD notes because they are being substituted for.  This
13125    saves searching in the most common cases.
13126
13127    Each note in the list is either ignored or placed on some insns, depending
13128    on the type of note.  */
13129
13130 static void
13131 distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2, rtx elim_i2,
13132                   rtx elim_i1, rtx elim_i0)
13133 {
13134   rtx note, next_note;
13135   rtx tem;
13136
13137   for (note = notes; note; note = next_note)
13138     {
13139       rtx place = 0, place2 = 0;
13140
13141       next_note = XEXP (note, 1);
13142       switch (REG_NOTE_KIND (note))
13143         {
13144         case REG_BR_PROB:
13145         case REG_BR_PRED:
13146           /* Doesn't matter much where we put this, as long as it's somewhere.
13147              It is preferable to keep these notes on branches, which is most
13148              likely to be i3.  */
13149           place = i3;
13150           break;
13151
13152         case REG_NON_LOCAL_GOTO:
13153           if (JUMP_P (i3))
13154             place = i3;
13155           else
13156             {
13157               gcc_assert (i2 && JUMP_P (i2));
13158               place = i2;
13159             }
13160           break;
13161
13162         case REG_EH_REGION:
13163           /* These notes must remain with the call or trapping instruction.  */
13164           if (CALL_P (i3))
13165             place = i3;
13166           else if (i2 && CALL_P (i2))
13167             place = i2;
13168           else
13169             {
13170               gcc_assert (cfun->can_throw_non_call_exceptions);
13171               if (may_trap_p (i3))
13172                 place = i3;
13173               else if (i2 && may_trap_p (i2))
13174                 place = i2;
13175               /* ??? Otherwise assume we've combined things such that we
13176                  can now prove that the instructions can't trap.  Drop the
13177                  note in this case.  */
13178             }
13179           break;
13180
13181         case REG_NORETURN:
13182         case REG_SETJMP:
13183           /* These notes must remain with the call.  It should not be
13184              possible for both I2 and I3 to be a call.  */
13185           if (CALL_P (i3))
13186             place = i3;
13187           else
13188             {
13189               gcc_assert (i2 && CALL_P (i2));
13190               place = i2;
13191             }
13192           break;
13193
13194         case REG_UNUSED:
13195           /* Any clobbers for i3 may still exist, and so we must process
13196              REG_UNUSED notes from that insn.
13197
13198              Any clobbers from i2 or i1 can only exist if they were added by
13199              recog_for_combine.  In that case, recog_for_combine created the
13200              necessary REG_UNUSED notes.  Trying to keep any original
13201              REG_UNUSED notes from these insns can cause incorrect output
13202              if it is for the same register as the original i3 dest.
13203              In that case, we will notice that the register is set in i3,
13204              and then add a REG_UNUSED note for the destination of i3, which
13205              is wrong.  However, it is possible to have REG_UNUSED notes from
13206              i2 or i1 for register which were both used and clobbered, so
13207              we keep notes from i2 or i1 if they will turn into REG_DEAD
13208              notes.  */
13209
13210           /* If this register is set or clobbered in I3, put the note there
13211              unless there is one already.  */
13212           if (reg_set_p (XEXP (note, 0), PATTERN (i3)))
13213             {
13214               if (from_insn != i3)
13215                 break;
13216
13217               if (! (REG_P (XEXP (note, 0))
13218                      ? find_regno_note (i3, REG_UNUSED, REGNO (XEXP (note, 0)))
13219                      : find_reg_note (i3, REG_UNUSED, XEXP (note, 0))))
13220                 place = i3;
13221             }
13222           /* Otherwise, if this register is used by I3, then this register
13223              now dies here, so we must put a REG_DEAD note here unless there
13224              is one already.  */
13225           else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3))
13226                    && ! (REG_P (XEXP (note, 0))
13227                          ? find_regno_note (i3, REG_DEAD,
13228                                             REGNO (XEXP (note, 0)))
13229                          : find_reg_note (i3, REG_DEAD, XEXP (note, 0))))
13230             {
13231               PUT_REG_NOTE_KIND (note, REG_DEAD);
13232               place = i3;
13233             }
13234           break;
13235
13236         case REG_EQUAL:
13237         case REG_EQUIV:
13238         case REG_NOALIAS:
13239           /* These notes say something about results of an insn.  We can
13240              only support them if they used to be on I3 in which case they
13241              remain on I3.  Otherwise they are ignored.
13242
13243              If the note refers to an expression that is not a constant, we
13244              must also ignore the note since we cannot tell whether the
13245              equivalence is still true.  It might be possible to do
13246              slightly better than this (we only have a problem if I2DEST
13247              or I1DEST is present in the expression), but it doesn't
13248              seem worth the trouble.  */
13249
13250           if (from_insn == i3
13251               && (XEXP (note, 0) == 0 || CONSTANT_P (XEXP (note, 0))))
13252             place = i3;
13253           break;
13254
13255         case REG_INC:
13256           /* These notes say something about how a register is used.  They must
13257              be present on any use of the register in I2 or I3.  */
13258           if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3)))
13259             place = i3;
13260
13261           if (i2 && reg_mentioned_p (XEXP (note, 0), PATTERN (i2)))
13262             {
13263               if (place)
13264                 place2 = i2;
13265               else
13266                 place = i2;
13267             }
13268           break;
13269
13270         case REG_LABEL_TARGET:
13271         case REG_LABEL_OPERAND:
13272           /* This can show up in several ways -- either directly in the
13273              pattern, or hidden off in the constant pool with (or without?)
13274              a REG_EQUAL note.  */
13275           /* ??? Ignore the without-reg_equal-note problem for now.  */
13276           if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3))
13277               || ((tem = find_reg_note (i3, REG_EQUAL, NULL_RTX))
13278                   && GET_CODE (XEXP (tem, 0)) == LABEL_REF
13279                   && XEXP (XEXP (tem, 0), 0) == XEXP (note, 0)))
13280             place = i3;
13281
13282           if (i2
13283               && (reg_mentioned_p (XEXP (note, 0), PATTERN (i2))
13284                   || ((tem = find_reg_note (i2, REG_EQUAL, NULL_RTX))
13285                       && GET_CODE (XEXP (tem, 0)) == LABEL_REF
13286                       && XEXP (XEXP (tem, 0), 0) == XEXP (note, 0))))
13287             {
13288               if (place)
13289                 place2 = i2;
13290               else
13291                 place = i2;
13292             }
13293
13294           /* For REG_LABEL_TARGET on a JUMP_P, we prefer to put the note
13295              as a JUMP_LABEL or decrement LABEL_NUSES if it's already
13296              there.  */
13297           if (place && JUMP_P (place)
13298               && REG_NOTE_KIND (note) == REG_LABEL_TARGET
13299               && (JUMP_LABEL (place) == NULL
13300                   || JUMP_LABEL (place) == XEXP (note, 0)))
13301             {
13302               rtx label = JUMP_LABEL (place);
13303
13304               if (!label)
13305                 JUMP_LABEL (place) = XEXP (note, 0);
13306               else if (LABEL_P (label))
13307                 LABEL_NUSES (label)--;
13308             }
13309
13310           if (place2 && JUMP_P (place2)
13311               && REG_NOTE_KIND (note) == REG_LABEL_TARGET
13312               && (JUMP_LABEL (place2) == NULL
13313                   || JUMP_LABEL (place2) == XEXP (note, 0)))
13314             {
13315               rtx label = JUMP_LABEL (place2);
13316
13317               if (!label)
13318                 JUMP_LABEL (place2) = XEXP (note, 0);
13319               else if (LABEL_P (label))
13320                 LABEL_NUSES (label)--;
13321               place2 = 0;
13322             }
13323           break;
13324
13325         case REG_NONNEG:
13326           /* This note says something about the value of a register prior
13327              to the execution of an insn.  It is too much trouble to see
13328              if the note is still correct in all situations.  It is better
13329              to simply delete it.  */
13330           break;
13331
13332         case REG_DEAD:
13333           /* If we replaced the right hand side of FROM_INSN with a
13334              REG_EQUAL note, the original use of the dying register
13335              will not have been combined into I3 and I2.  In such cases,
13336              FROM_INSN is guaranteed to be the first of the combined
13337              instructions, so we simply need to search back before
13338              FROM_INSN for the previous use or set of this register,
13339              then alter the notes there appropriately.
13340
13341              If the register is used as an input in I3, it dies there.
13342              Similarly for I2, if it is nonzero and adjacent to I3.
13343
13344              If the register is not used as an input in either I3 or I2
13345              and it is not one of the registers we were supposed to eliminate,
13346              there are two possibilities.  We might have a non-adjacent I2
13347              or we might have somehow eliminated an additional register
13348              from a computation.  For example, we might have had A & B where
13349              we discover that B will always be zero.  In this case we will
13350              eliminate the reference to A.
13351
13352              In both cases, we must search to see if we can find a previous
13353              use of A and put the death note there.  */
13354
13355           if (from_insn
13356               && from_insn == i2mod
13357               && !reg_overlap_mentioned_p (XEXP (note, 0), i2mod_new_rhs))
13358             tem = from_insn;
13359           else
13360             {
13361               if (from_insn
13362                   && CALL_P (from_insn)
13363                   && find_reg_fusage (from_insn, USE, XEXP (note, 0)))
13364                 place = from_insn;
13365               else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3)))
13366                 place = i3;
13367               else if (i2 != 0 && next_nonnote_nondebug_insn (i2) == i3
13368                        && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
13369                 place = i2;
13370               else if ((rtx_equal_p (XEXP (note, 0), elim_i2)
13371                         && !(i2mod
13372                              && reg_overlap_mentioned_p (XEXP (note, 0),
13373                                                          i2mod_old_rhs)))
13374                        || rtx_equal_p (XEXP (note, 0), elim_i1)
13375                        || rtx_equal_p (XEXP (note, 0), elim_i0))
13376                 break;
13377               tem = i3;
13378             }
13379
13380           if (place == 0)
13381             {
13382               basic_block bb = this_basic_block;
13383
13384               for (tem = PREV_INSN (tem); place == 0; tem = PREV_INSN (tem))
13385                 {
13386                   if (!NONDEBUG_INSN_P (tem))
13387                     {
13388                       if (tem == BB_HEAD (bb))
13389                         break;
13390                       continue;
13391                     }
13392
13393                   /* If the register is being set at TEM, see if that is all
13394                      TEM is doing.  If so, delete TEM.  Otherwise, make this
13395                      into a REG_UNUSED note instead. Don't delete sets to
13396                      global register vars.  */
13397                   if ((REGNO (XEXP (note, 0)) >= FIRST_PSEUDO_REGISTER
13398                        || !global_regs[REGNO (XEXP (note, 0))])
13399                       && reg_set_p (XEXP (note, 0), PATTERN (tem)))
13400                     {
13401                       rtx set = single_set (tem);
13402                       rtx inner_dest = 0;
13403 #ifdef HAVE_cc0
13404                       rtx cc0_setter = NULL_RTX;
13405 #endif
13406
13407                       if (set != 0)
13408                         for (inner_dest = SET_DEST (set);
13409                              (GET_CODE (inner_dest) == STRICT_LOW_PART
13410                               || GET_CODE (inner_dest) == SUBREG
13411                               || GET_CODE (inner_dest) == ZERO_EXTRACT);
13412                              inner_dest = XEXP (inner_dest, 0))
13413                           ;
13414
13415                       /* Verify that it was the set, and not a clobber that
13416                          modified the register.
13417
13418                          CC0 targets must be careful to maintain setter/user
13419                          pairs.  If we cannot delete the setter due to side
13420                          effects, mark the user with an UNUSED note instead
13421                          of deleting it.  */
13422
13423                       if (set != 0 && ! side_effects_p (SET_SRC (set))
13424                           && rtx_equal_p (XEXP (note, 0), inner_dest)
13425 #ifdef HAVE_cc0
13426                           && (! reg_mentioned_p (cc0_rtx, SET_SRC (set))
13427                               || ((cc0_setter = prev_cc0_setter (tem)) != NULL
13428                                   && sets_cc0_p (PATTERN (cc0_setter)) > 0))
13429 #endif
13430                           )
13431                         {
13432                           /* Move the notes and links of TEM elsewhere.
13433                              This might delete other dead insns recursively.
13434                              First set the pattern to something that won't use
13435                              any register.  */
13436                           rtx old_notes = REG_NOTES (tem);
13437
13438                           PATTERN (tem) = pc_rtx;
13439                           REG_NOTES (tem) = NULL;
13440
13441                           distribute_notes (old_notes, tem, tem, NULL_RTX,
13442                                             NULL_RTX, NULL_RTX, NULL_RTX);
13443                           distribute_links (LOG_LINKS (tem));
13444
13445                           SET_INSN_DELETED (tem);
13446                           if (tem == i2)
13447                             i2 = NULL_RTX;
13448
13449 #ifdef HAVE_cc0
13450                           /* Delete the setter too.  */
13451                           if (cc0_setter)
13452                             {
13453                               PATTERN (cc0_setter) = pc_rtx;
13454                               old_notes = REG_NOTES (cc0_setter);
13455                               REG_NOTES (cc0_setter) = NULL;
13456
13457                               distribute_notes (old_notes, cc0_setter,
13458                                                 cc0_setter, NULL_RTX,
13459                                                 NULL_RTX, NULL_RTX, NULL_RTX);
13460                               distribute_links (LOG_LINKS (cc0_setter));
13461
13462                               SET_INSN_DELETED (cc0_setter);
13463                               if (cc0_setter == i2)
13464                                 i2 = NULL_RTX;
13465                             }
13466 #endif
13467                         }
13468                       else
13469                         {
13470                           PUT_REG_NOTE_KIND (note, REG_UNUSED);
13471
13472                           /*  If there isn't already a REG_UNUSED note, put one
13473                               here.  Do not place a REG_DEAD note, even if
13474                               the register is also used here; that would not
13475                               match the algorithm used in lifetime analysis
13476                               and can cause the consistency check in the
13477                               scheduler to fail.  */
13478                           if (! find_regno_note (tem, REG_UNUSED,
13479                                                  REGNO (XEXP (note, 0))))
13480                             place = tem;
13481                           break;
13482                         }
13483                     }
13484                   else if (reg_referenced_p (XEXP (note, 0), PATTERN (tem))
13485                            || (CALL_P (tem)
13486                                && find_reg_fusage (tem, USE, XEXP (note, 0))))
13487                     {
13488                       place = tem;
13489
13490                       /* If we are doing a 3->2 combination, and we have a
13491                          register which formerly died in i3 and was not used
13492                          by i2, which now no longer dies in i3 and is used in
13493                          i2 but does not die in i2, and place is between i2
13494                          and i3, then we may need to move a link from place to
13495                          i2.  */
13496                       if (i2 && DF_INSN_LUID (place) > DF_INSN_LUID (i2)
13497                           && from_insn
13498                           && DF_INSN_LUID (from_insn) > DF_INSN_LUID (i2)
13499                           && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
13500                         {
13501                           rtx links = LOG_LINKS (place);
13502                           LOG_LINKS (place) = 0;
13503                           distribute_links (links);
13504                         }
13505                       break;
13506                     }
13507
13508                   if (tem == BB_HEAD (bb))
13509                     break;
13510                 }
13511
13512             }
13513
13514           /* If the register is set or already dead at PLACE, we needn't do
13515              anything with this note if it is still a REG_DEAD note.
13516              We check here if it is set at all, not if is it totally replaced,
13517              which is what `dead_or_set_p' checks, so also check for it being
13518              set partially.  */
13519
13520           if (place && REG_NOTE_KIND (note) == REG_DEAD)
13521             {
13522               unsigned int regno = REGNO (XEXP (note, 0));
13523               reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, regno);
13524
13525               if (dead_or_set_p (place, XEXP (note, 0))
13526                   || reg_bitfield_target_p (XEXP (note, 0), PATTERN (place)))
13527                 {
13528                   /* Unless the register previously died in PLACE, clear
13529                      last_death.  [I no longer understand why this is
13530                      being done.] */
13531                   if (rsp->last_death != place)
13532                     rsp->last_death = 0;
13533                   place = 0;
13534                 }
13535               else
13536                 rsp->last_death = place;
13537
13538               /* If this is a death note for a hard reg that is occupying
13539                  multiple registers, ensure that we are still using all
13540                  parts of the object.  If we find a piece of the object
13541                  that is unused, we must arrange for an appropriate REG_DEAD
13542                  note to be added for it.  However, we can't just emit a USE
13543                  and tag the note to it, since the register might actually
13544                  be dead; so we recourse, and the recursive call then finds
13545                  the previous insn that used this register.  */
13546
13547               if (place && regno < FIRST_PSEUDO_REGISTER
13548                   && hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))] > 1)
13549                 {
13550                   unsigned int endregno = END_HARD_REGNO (XEXP (note, 0));
13551                   int all_used = 1;
13552                   unsigned int i;
13553
13554                   for (i = regno; i < endregno; i++)
13555                     if ((! refers_to_regno_p (i, i + 1, PATTERN (place), 0)
13556                          && ! find_regno_fusage (place, USE, i))
13557                         || dead_or_set_regno_p (place, i))
13558                       all_used = 0;
13559
13560                   if (! all_used)
13561                     {
13562                       /* Put only REG_DEAD notes for pieces that are
13563                          not already dead or set.  */
13564
13565                       for (i = regno; i < endregno;
13566                            i += hard_regno_nregs[i][reg_raw_mode[i]])
13567                         {
13568                           rtx piece = regno_reg_rtx[i];
13569                           basic_block bb = this_basic_block;
13570
13571                           if (! dead_or_set_p (place, piece)
13572                               && ! reg_bitfield_target_p (piece,
13573                                                           PATTERN (place)))
13574                             {
13575                               rtx new_note = alloc_reg_note (REG_DEAD, piece,
13576                                                              NULL_RTX);
13577
13578                               distribute_notes (new_note, place, place,
13579                                                 NULL_RTX, NULL_RTX, NULL_RTX,
13580                                                 NULL_RTX);
13581                             }
13582                           else if (! refers_to_regno_p (i, i + 1,
13583                                                         PATTERN (place), 0)
13584                                    && ! find_regno_fusage (place, USE, i))
13585                             for (tem = PREV_INSN (place); ;
13586                                  tem = PREV_INSN (tem))
13587                               {
13588                                 if (!NONDEBUG_INSN_P (tem))
13589                                   {
13590                                     if (tem == BB_HEAD (bb))
13591                                       break;
13592                                     continue;
13593                                   }
13594                                 if (dead_or_set_p (tem, piece)
13595                                     || reg_bitfield_target_p (piece,
13596                                                               PATTERN (tem)))
13597                                   {
13598                                     add_reg_note (tem, REG_UNUSED, piece);
13599                                     break;
13600                                   }
13601                               }
13602
13603                         }
13604
13605                       place = 0;
13606                     }
13607                 }
13608             }
13609           break;
13610
13611         default:
13612           /* Any other notes should not be present at this point in the
13613              compilation.  */
13614           gcc_unreachable ();
13615         }
13616
13617       if (place)
13618         {
13619           XEXP (note, 1) = REG_NOTES (place);
13620           REG_NOTES (place) = note;
13621         }
13622
13623       if (place2)
13624         add_reg_note (place2, REG_NOTE_KIND (note), XEXP (note, 0));
13625     }
13626 }
13627 \f
13628 /* Similarly to above, distribute the LOG_LINKS that used to be present on
13629    I3, I2, and I1 to new locations.  This is also called to add a link
13630    pointing at I3 when I3's destination is changed.  */
13631
13632 static void
13633 distribute_links (rtx links)
13634 {
13635   rtx link, next_link;
13636
13637   for (link = links; link; link = next_link)
13638     {
13639       rtx place = 0;
13640       rtx insn;
13641       rtx set, reg;
13642
13643       next_link = XEXP (link, 1);
13644
13645       /* If the insn that this link points to is a NOTE or isn't a single
13646          set, ignore it.  In the latter case, it isn't clear what we
13647          can do other than ignore the link, since we can't tell which
13648          register it was for.  Such links wouldn't be used by combine
13649          anyway.
13650
13651          It is not possible for the destination of the target of the link to
13652          have been changed by combine.  The only potential of this is if we
13653          replace I3, I2, and I1 by I3 and I2.  But in that case the
13654          destination of I2 also remains unchanged.  */
13655
13656       if (NOTE_P (XEXP (link, 0))
13657           || (set = single_set (XEXP (link, 0))) == 0)
13658         continue;
13659
13660       reg = SET_DEST (set);
13661       while (GET_CODE (reg) == SUBREG || GET_CODE (reg) == ZERO_EXTRACT
13662              || GET_CODE (reg) == STRICT_LOW_PART)
13663         reg = XEXP (reg, 0);
13664
13665       /* A LOG_LINK is defined as being placed on the first insn that uses
13666          a register and points to the insn that sets the register.  Start
13667          searching at the next insn after the target of the link and stop
13668          when we reach a set of the register or the end of the basic block.
13669
13670          Note that this correctly handles the link that used to point from
13671          I3 to I2.  Also note that not much searching is typically done here
13672          since most links don't point very far away.  */
13673
13674       for (insn = NEXT_INSN (XEXP (link, 0));
13675            (insn && (this_basic_block->next_bb == EXIT_BLOCK_PTR
13676                      || BB_HEAD (this_basic_block->next_bb) != insn));
13677            insn = NEXT_INSN (insn))
13678         if (DEBUG_INSN_P (insn))
13679           continue;
13680         else if (INSN_P (insn) && reg_overlap_mentioned_p (reg, PATTERN (insn)))
13681           {
13682             if (reg_referenced_p (reg, PATTERN (insn)))
13683               place = insn;
13684             break;
13685           }
13686         else if (CALL_P (insn)
13687                  && find_reg_fusage (insn, USE, reg))
13688           {
13689             place = insn;
13690             break;
13691           }
13692         else if (INSN_P (insn) && reg_set_p (reg, insn))
13693           break;
13694
13695       /* If we found a place to put the link, place it there unless there
13696          is already a link to the same insn as LINK at that point.  */
13697
13698       if (place)
13699         {
13700           rtx link2;
13701
13702           for (link2 = LOG_LINKS (place); link2; link2 = XEXP (link2, 1))
13703             if (XEXP (link2, 0) == XEXP (link, 0))
13704               break;
13705
13706           if (link2 == 0)
13707             {
13708               XEXP (link, 1) = LOG_LINKS (place);
13709               LOG_LINKS (place) = link;
13710
13711               /* Set added_links_insn to the earliest insn we added a
13712                  link to.  */
13713               if (added_links_insn == 0
13714                   || DF_INSN_LUID (added_links_insn) > DF_INSN_LUID (place))
13715                 added_links_insn = place;
13716             }
13717         }
13718     }
13719 }
13720 \f
13721 /* Subroutine of unmentioned_reg_p and callback from for_each_rtx.
13722    Check whether the expression pointer to by LOC is a register or
13723    memory, and if so return 1 if it isn't mentioned in the rtx EXPR.
13724    Otherwise return zero.  */
13725
13726 static int
13727 unmentioned_reg_p_1 (rtx *loc, void *expr)
13728 {
13729   rtx x = *loc;
13730
13731   if (x != NULL_RTX
13732       && (REG_P (x) || MEM_P (x))
13733       && ! reg_mentioned_p (x, (rtx) expr))
13734     return 1;
13735   return 0;
13736 }
13737
13738 /* Check for any register or memory mentioned in EQUIV that is not
13739    mentioned in EXPR.  This is used to restrict EQUIV to "specializations"
13740    of EXPR where some registers may have been replaced by constants.  */
13741
13742 static bool
13743 unmentioned_reg_p (rtx equiv, rtx expr)
13744 {
13745   return for_each_rtx (&equiv, unmentioned_reg_p_1, expr);
13746 }
13747 \f
13748 void
13749 dump_combine_stats (FILE *file)
13750 {
13751   fprintf
13752     (file,
13753      ";; Combiner statistics: %d attempts, %d substitutions (%d requiring new space),\n;; %d successes.\n\n",
13754      combine_attempts, combine_merges, combine_extras, combine_successes);
13755 }
13756
13757 void
13758 dump_combine_total_stats (FILE *file)
13759 {
13760   fprintf
13761     (file,
13762      "\n;; Combiner totals: %d attempts, %d substitutions (%d requiring new space),\n;; %d successes.\n",
13763      total_attempts, total_merges, total_extras, total_successes);
13764 }
13765 \f
13766 static bool
13767 gate_handle_combine (void)
13768 {
13769   return (optimize > 0);
13770 }
13771
13772 /* Try combining insns through substitution.  */
13773 static unsigned int
13774 rest_of_handle_combine (void)
13775 {
13776   int rebuild_jump_labels_after_combine;
13777
13778   df_set_flags (DF_LR_RUN_DCE + DF_DEFER_INSN_RESCAN);
13779   df_note_add_problem ();
13780   df_analyze ();
13781
13782   regstat_init_n_sets_and_refs ();
13783
13784   rebuild_jump_labels_after_combine
13785     = combine_instructions (get_insns (), max_reg_num ());
13786
13787   /* Combining insns may have turned an indirect jump into a
13788      direct jump.  Rebuild the JUMP_LABEL fields of jumping
13789      instructions.  */
13790   if (rebuild_jump_labels_after_combine)
13791     {
13792       timevar_push (TV_JUMP);
13793       rebuild_jump_labels (get_insns ());
13794       cleanup_cfg (0);
13795       timevar_pop (TV_JUMP);
13796     }
13797
13798   regstat_free_n_sets_and_refs ();
13799   return 0;
13800 }
13801
13802 struct rtl_opt_pass pass_combine =
13803 {
13804  {
13805   RTL_PASS,
13806   "combine",                            /* name */
13807   gate_handle_combine,                  /* gate */
13808   rest_of_handle_combine,               /* execute */
13809   NULL,                                 /* sub */
13810   NULL,                                 /* next */
13811   0,                                    /* static_pass_number */
13812   TV_COMBINE,                           /* tv_id */
13813   PROP_cfglayout,                       /* properties_required */
13814   0,                                    /* properties_provided */
13815   0,                                    /* properties_destroyed */
13816   0,                                    /* todo_flags_start */
13817   TODO_dump_func |
13818   TODO_df_finish | TODO_verify_rtl_sharing |
13819   TODO_ggc_collect,                     /* todo_flags_finish */
13820  }
13821 };