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 inner insns.
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
3092           subst_low_luid = DF_INSN_LUID (i2);
3093           i2src = subst (i2src, pc_rtx, pc_rtx, 0, 0);
3094         }
3095
3096       n_occurrences = 0;                /* `subst' counts here */
3097       subst_low_luid = DF_INSN_LUID (i2);
3098
3099       /* If I1 feeds into I2 and I1DEST is in I1SRC, we need to make a unique
3100          copy of I2SRC each time we substitute it, in order to avoid creating
3101          self-referential RTL when we will be substituting I1SRC for I1DEST
3102          later.  Likewise if I0 feeds into I2, either directly or indirectly
3103          through I1, and I0DEST is in I0SRC.  */
3104       newpat = subst (PATTERN (i3), i2dest, i2src, 0,
3105                       (i1_feeds_i2_n && i1dest_in_i1src)
3106                       || ((i0_feeds_i2_n || (i0_feeds_i1_n && i1_feeds_i2_n))
3107                           && i0dest_in_i0src));
3108       substed_i2 = 1;
3109
3110       /* Record whether I2's body now appears within I3's body.  */
3111       i2_is_used = n_occurrences;
3112     }
3113
3114   /* If we already got a failure, don't try to do more.  Otherwise, try to
3115      substitute I1 if we have it.  */
3116
3117   if (i1 && GET_CODE (newpat) != CLOBBER)
3118     {
3119       /* Check that an autoincrement side-effect on I1 has not been lost.
3120          This happens if I1DEST is mentioned in I2 and dies there, and
3121          has disappeared from the new pattern.  */
3122       if ((FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
3123            && i1_feeds_i2_n
3124            && dead_or_set_p (i2, i1dest)
3125            && !reg_overlap_mentioned_p (i1dest, newpat))
3126            /* Before we can do this substitution, we must redo the test done
3127               above (see detailed comments there) that ensures I1DEST isn't
3128               mentioned in any SETs in NEWPAT that are field assignments.  */
3129           || !combinable_i3pat (NULL_RTX, &newpat, i1dest, NULL_RTX, NULL_RTX,
3130                                 0, 0, 0))
3131         {
3132           undo_all ();
3133           return 0;
3134         }
3135
3136       n_occurrences = 0;
3137       subst_low_luid = DF_INSN_LUID (i1);
3138
3139       /* If I0 feeds into I1 and I0DEST is in I0SRC, we need to make a unique
3140          copy of I1SRC each time we substitute it, in order to avoid creating
3141          self-referential RTL when we will be substituting I0SRC for I0DEST
3142          later.  */
3143       newpat = subst (newpat, i1dest, i1src, 0,
3144                       i0_feeds_i1_n && i0dest_in_i0src);
3145       substed_i1 = 1;
3146
3147       /* Record whether I1's body now appears within I3's body.  */
3148       i1_is_used = n_occurrences;
3149     }
3150
3151   /* Likewise for I0 if we have it.  */
3152
3153   if (i0 && GET_CODE (newpat) != CLOBBER)
3154     {
3155       if ((FIND_REG_INC_NOTE (i0, NULL_RTX) != 0
3156            && ((i0_feeds_i2_n && dead_or_set_p (i2, i0dest))
3157                || (i0_feeds_i1_n && dead_or_set_p (i1, i0dest)))
3158            && !reg_overlap_mentioned_p (i0dest, newpat))
3159           || !combinable_i3pat (NULL_RTX, &newpat, i0dest, NULL_RTX, NULL_RTX,
3160                                 0, 0, 0))
3161         {
3162           undo_all ();
3163           return 0;
3164         }
3165
3166       /* If the following substitution will modify I1SRC, make a copy of it
3167          for the case where it is substituted for I1DEST in I2PAT later.  */
3168       if (i0_feeds_i1_n && added_sets_2 && i1_feeds_i2_n)
3169         i1src_copy = copy_rtx (i1src);
3170
3171       n_occurrences = 0;
3172       subst_low_luid = DF_INSN_LUID (i0);
3173       newpat = subst (newpat, i0dest, i0src, 0, 0);
3174       substed_i0 = 1;
3175     }
3176
3177   /* Fail if an autoincrement side-effect has been duplicated.  Be careful
3178      to count all the ways that I2SRC and I1SRC can be used.  */
3179   if ((FIND_REG_INC_NOTE (i2, NULL_RTX) != 0
3180        && i2_is_used + added_sets_2 > 1)
3181       || (i1 != 0 && FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
3182           && (i1_is_used + added_sets_1 + (added_sets_2 && i1_feeds_i2_n)
3183               > 1))
3184       || (i0 != 0 && FIND_REG_INC_NOTE (i0, NULL_RTX) != 0
3185           && (n_occurrences + added_sets_0
3186               + (added_sets_1 && i0_feeds_i1_n)
3187               + (added_sets_2 && i0_feeds_i2_n)
3188               > 1))
3189       /* Fail if we tried to make a new register.  */
3190       || max_reg_num () != maxreg
3191       /* Fail if we couldn't do something and have a CLOBBER.  */
3192       || GET_CODE (newpat) == CLOBBER
3193       /* Fail if this new pattern is a MULT and we didn't have one before
3194          at the outer level.  */
3195       || (GET_CODE (newpat) == SET && GET_CODE (SET_SRC (newpat)) == MULT
3196           && ! have_mult))
3197     {
3198       undo_all ();
3199       return 0;
3200     }
3201
3202   /* If the actions of the earlier insns must be kept
3203      in addition to substituting them into the latest one,
3204      we must make a new PARALLEL for the latest insn
3205      to hold additional the SETs.  */
3206
3207   if (added_sets_0 || added_sets_1 || added_sets_2)
3208     {
3209       int extra_sets = added_sets_0 + added_sets_1 + added_sets_2;
3210       combine_extras++;
3211
3212       if (GET_CODE (newpat) == PARALLEL)
3213         {
3214           rtvec old = XVEC (newpat, 0);
3215           total_sets = XVECLEN (newpat, 0) + extra_sets;
3216           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
3217           memcpy (XVEC (newpat, 0)->elem, &old->elem[0],
3218                   sizeof (old->elem[0]) * old->num_elem);
3219         }
3220       else
3221         {
3222           rtx old = newpat;
3223           total_sets = 1 + extra_sets;
3224           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
3225           XVECEXP (newpat, 0, 0) = old;
3226         }
3227
3228       if (added_sets_0)
3229         XVECEXP (newpat, 0, --total_sets) = i0pat;
3230
3231       if (added_sets_1)
3232         {
3233           rtx t = i1pat;
3234           if (i0_feeds_i1_n)
3235             t = subst (t, i0dest, i0src, 0, 0);
3236
3237           XVECEXP (newpat, 0, --total_sets) = t;
3238         }
3239       if (added_sets_2)
3240         {
3241           rtx t = i2pat;
3242           if (i1_feeds_i2_n)
3243             t = subst (t, i1dest, i1src_copy ? i1src_copy : i1src, 0,
3244                        i0_feeds_i1_n && i0dest_in_i0src);
3245           if ((i0_feeds_i1_n && i1_feeds_i2_n) || i0_feeds_i2_n)
3246             t = subst (t, i0dest, i0src, 0, 0);
3247
3248           XVECEXP (newpat, 0, --total_sets) = t;
3249         }
3250     }
3251
3252  validate_replacement:
3253
3254   /* Note which hard regs this insn has as inputs.  */
3255   mark_used_regs_combine (newpat);
3256
3257   /* If recog_for_combine fails, it strips existing clobbers.  If we'll
3258      consider splitting this pattern, we might need these clobbers.  */
3259   if (i1 && GET_CODE (newpat) == PARALLEL
3260       && GET_CODE (XVECEXP (newpat, 0, XVECLEN (newpat, 0) - 1)) == CLOBBER)
3261     {
3262       int len = XVECLEN (newpat, 0);
3263
3264       newpat_vec_with_clobbers = rtvec_alloc (len);
3265       for (i = 0; i < len; i++)
3266         RTVEC_ELT (newpat_vec_with_clobbers, i) = XVECEXP (newpat, 0, i);
3267     }
3268
3269   /* Is the result of combination a valid instruction?  */
3270   insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3271
3272   /* If the result isn't valid, see if it is a PARALLEL of two SETs where
3273      the second SET's destination is a register that is unused and isn't
3274      marked as an instruction that might trap in an EH region.  In that case,
3275      we just need the first SET.   This can occur when simplifying a divmod
3276      insn.  We *must* test for this case here because the code below that
3277      splits two independent SETs doesn't handle this case correctly when it
3278      updates the register status.
3279
3280      It's pointless doing this if we originally had two sets, one from
3281      i3, and one from i2.  Combining then splitting the parallel results
3282      in the original i2 again plus an invalid insn (which we delete).
3283      The net effect is only to move instructions around, which makes
3284      debug info less accurate.
3285
3286      Also check the case where the first SET's destination is unused.
3287      That would not cause incorrect code, but does cause an unneeded
3288      insn to remain.  */
3289
3290   if (insn_code_number < 0
3291       && !(added_sets_2 && i1 == 0)
3292       && GET_CODE (newpat) == PARALLEL
3293       && XVECLEN (newpat, 0) == 2
3294       && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
3295       && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
3296       && asm_noperands (newpat) < 0)
3297     {
3298       rtx set0 = XVECEXP (newpat, 0, 0);
3299       rtx set1 = XVECEXP (newpat, 0, 1);
3300
3301       if (((REG_P (SET_DEST (set1))
3302             && find_reg_note (i3, REG_UNUSED, SET_DEST (set1)))
3303            || (GET_CODE (SET_DEST (set1)) == SUBREG
3304                && find_reg_note (i3, REG_UNUSED, SUBREG_REG (SET_DEST (set1)))))
3305           && insn_nothrow_p (i3)
3306           && !side_effects_p (SET_SRC (set1)))
3307         {
3308           newpat = set0;
3309           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3310         }
3311
3312       else if (((REG_P (SET_DEST (set0))
3313                  && find_reg_note (i3, REG_UNUSED, SET_DEST (set0)))
3314                 || (GET_CODE (SET_DEST (set0)) == SUBREG
3315                     && find_reg_note (i3, REG_UNUSED,
3316                                       SUBREG_REG (SET_DEST (set0)))))
3317                && insn_nothrow_p (i3)
3318                && !side_effects_p (SET_SRC (set0)))
3319         {
3320           newpat = set1;
3321           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3322
3323           if (insn_code_number >= 0)
3324             changed_i3_dest = 1;
3325         }
3326     }
3327
3328   /* If we were combining three insns and the result is a simple SET
3329      with no ASM_OPERANDS that wasn't recognized, try to split it into two
3330      insns.  There are two ways to do this.  It can be split using a
3331      machine-specific method (like when you have an addition of a large
3332      constant) or by combine in the function find_split_point.  */
3333
3334   if (i1 && insn_code_number < 0 && GET_CODE (newpat) == SET
3335       && asm_noperands (newpat) < 0)
3336     {
3337       rtx parallel, m_split, *split;
3338
3339       /* See if the MD file can split NEWPAT.  If it can't, see if letting it
3340          use I2DEST as a scratch register will help.  In the latter case,
3341          convert I2DEST to the mode of the source of NEWPAT if we can.  */
3342
3343       m_split = combine_split_insns (newpat, i3);
3344
3345       /* We can only use I2DEST as a scratch reg if it doesn't overlap any
3346          inputs of NEWPAT.  */
3347
3348       /* ??? If I2DEST is not safe, and I1DEST exists, then it would be
3349          possible to try that as a scratch reg.  This would require adding
3350          more code to make it work though.  */
3351
3352       if (m_split == 0 && ! reg_overlap_mentioned_p (i2dest, newpat))
3353         {
3354           enum machine_mode new_mode = GET_MODE (SET_DEST (newpat));
3355
3356           /* First try to split using the original register as a
3357              scratch register.  */
3358           parallel = gen_rtx_PARALLEL (VOIDmode,
3359                                        gen_rtvec (2, newpat,
3360                                                   gen_rtx_CLOBBER (VOIDmode,
3361                                                                    i2dest)));
3362           m_split = combine_split_insns (parallel, i3);
3363
3364           /* If that didn't work, try changing the mode of I2DEST if
3365              we can.  */
3366           if (m_split == 0
3367               && new_mode != GET_MODE (i2dest)
3368               && new_mode != VOIDmode
3369               && can_change_dest_mode (i2dest, added_sets_2, new_mode))
3370             {
3371               enum machine_mode old_mode = GET_MODE (i2dest);
3372               rtx ni2dest;
3373
3374               if (REGNO (i2dest) < FIRST_PSEUDO_REGISTER)
3375                 ni2dest = gen_rtx_REG (new_mode, REGNO (i2dest));
3376               else
3377                 {
3378                   SUBST_MODE (regno_reg_rtx[REGNO (i2dest)], new_mode);
3379                   ni2dest = regno_reg_rtx[REGNO (i2dest)];
3380                 }
3381
3382               parallel = (gen_rtx_PARALLEL
3383                           (VOIDmode,
3384                            gen_rtvec (2, newpat,
3385                                       gen_rtx_CLOBBER (VOIDmode,
3386                                                        ni2dest))));
3387               m_split = combine_split_insns (parallel, i3);
3388
3389               if (m_split == 0
3390                   && REGNO (i2dest) >= FIRST_PSEUDO_REGISTER)
3391                 {
3392                   struct undo *buf;
3393
3394                   adjust_reg_mode (regno_reg_rtx[REGNO (i2dest)], old_mode);
3395                   buf = undobuf.undos;
3396                   undobuf.undos = buf->next;
3397                   buf->next = undobuf.frees;
3398                   undobuf.frees = buf;
3399                 }
3400             }
3401
3402           i2scratch = m_split != 0;
3403         }
3404
3405       /* If recog_for_combine has discarded clobbers, try to use them
3406          again for the split.  */
3407       if (m_split == 0 && newpat_vec_with_clobbers)
3408         {
3409           parallel = gen_rtx_PARALLEL (VOIDmode, newpat_vec_with_clobbers);
3410           m_split = combine_split_insns (parallel, i3);
3411         }
3412
3413       if (m_split && NEXT_INSN (m_split) == NULL_RTX)
3414         {
3415           m_split = PATTERN (m_split);
3416           insn_code_number = recog_for_combine (&m_split, i3, &new_i3_notes);
3417           if (insn_code_number >= 0)
3418             newpat = m_split;
3419         }
3420       else if (m_split && NEXT_INSN (NEXT_INSN (m_split)) == NULL_RTX
3421                && (next_real_insn (i2) == i3
3422                    || ! use_crosses_set_p (PATTERN (m_split), DF_INSN_LUID (i2))))
3423         {
3424           rtx i2set, i3set;
3425           rtx newi3pat = PATTERN (NEXT_INSN (m_split));
3426           newi2pat = PATTERN (m_split);
3427
3428           i3set = single_set (NEXT_INSN (m_split));
3429           i2set = single_set (m_split);
3430
3431           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3432
3433           /* If I2 or I3 has multiple SETs, we won't know how to track
3434              register status, so don't use these insns.  If I2's destination
3435              is used between I2 and I3, we also can't use these insns.  */
3436
3437           if (i2_code_number >= 0 && i2set && i3set
3438               && (next_real_insn (i2) == i3
3439                   || ! reg_used_between_p (SET_DEST (i2set), i2, i3)))
3440             insn_code_number = recog_for_combine (&newi3pat, i3,
3441                                                   &new_i3_notes);
3442           if (insn_code_number >= 0)
3443             newpat = newi3pat;
3444
3445           /* It is possible that both insns now set the destination of I3.
3446              If so, we must show an extra use of it.  */
3447
3448           if (insn_code_number >= 0)
3449             {
3450               rtx new_i3_dest = SET_DEST (i3set);
3451               rtx new_i2_dest = SET_DEST (i2set);
3452
3453               while (GET_CODE (new_i3_dest) == ZERO_EXTRACT
3454                      || GET_CODE (new_i3_dest) == STRICT_LOW_PART
3455                      || GET_CODE (new_i3_dest) == SUBREG)
3456                 new_i3_dest = XEXP (new_i3_dest, 0);
3457
3458               while (GET_CODE (new_i2_dest) == ZERO_EXTRACT
3459                      || GET_CODE (new_i2_dest) == STRICT_LOW_PART
3460                      || GET_CODE (new_i2_dest) == SUBREG)
3461                 new_i2_dest = XEXP (new_i2_dest, 0);
3462
3463               if (REG_P (new_i3_dest)
3464                   && REG_P (new_i2_dest)
3465                   && REGNO (new_i3_dest) == REGNO (new_i2_dest))
3466                 INC_REG_N_SETS (REGNO (new_i2_dest), 1);
3467             }
3468         }
3469
3470       /* If we can split it and use I2DEST, go ahead and see if that
3471          helps things be recognized.  Verify that none of the registers
3472          are set between I2 and I3.  */
3473       if (insn_code_number < 0
3474           && (split = find_split_point (&newpat, i3, false)) != 0
3475 #ifdef HAVE_cc0
3476           && REG_P (i2dest)
3477 #endif
3478           /* We need I2DEST in the proper mode.  If it is a hard register
3479              or the only use of a pseudo, we can change its mode.
3480              Make sure we don't change a hard register to have a mode that
3481              isn't valid for it, or change the number of registers.  */
3482           && (GET_MODE (*split) == GET_MODE (i2dest)
3483               || GET_MODE (*split) == VOIDmode
3484               || can_change_dest_mode (i2dest, added_sets_2,
3485                                        GET_MODE (*split)))
3486           && (next_real_insn (i2) == i3
3487               || ! use_crosses_set_p (*split, DF_INSN_LUID (i2)))
3488           /* We can't overwrite I2DEST if its value is still used by
3489              NEWPAT.  */
3490           && ! reg_referenced_p (i2dest, newpat))
3491         {
3492           rtx newdest = i2dest;
3493           enum rtx_code split_code = GET_CODE (*split);
3494           enum machine_mode split_mode = GET_MODE (*split);
3495           bool subst_done = false;
3496           newi2pat = NULL_RTX;
3497
3498           i2scratch = true;
3499
3500           /* *SPLIT may be part of I2SRC, so make sure we have the
3501              original expression around for later debug processing.
3502              We should not need I2SRC any more in other cases.  */
3503           if (MAY_HAVE_DEBUG_INSNS)
3504             i2src = copy_rtx (i2src);
3505           else
3506             i2src = NULL;
3507
3508           /* Get NEWDEST as a register in the proper mode.  We have already
3509              validated that we can do this.  */
3510           if (GET_MODE (i2dest) != split_mode && split_mode != VOIDmode)
3511             {
3512               if (REGNO (i2dest) < FIRST_PSEUDO_REGISTER)
3513                 newdest = gen_rtx_REG (split_mode, REGNO (i2dest));
3514               else
3515                 {
3516                   SUBST_MODE (regno_reg_rtx[REGNO (i2dest)], split_mode);
3517                   newdest = regno_reg_rtx[REGNO (i2dest)];
3518                 }
3519             }
3520
3521           /* If *SPLIT is a (mult FOO (const_int pow2)), convert it to
3522              an ASHIFT.  This can occur if it was inside a PLUS and hence
3523              appeared to be a memory address.  This is a kludge.  */
3524           if (split_code == MULT
3525               && CONST_INT_P (XEXP (*split, 1))
3526               && INTVAL (XEXP (*split, 1)) > 0
3527               && (i = exact_log2 (UINTVAL (XEXP (*split, 1)))) >= 0)
3528             {
3529               SUBST (*split, gen_rtx_ASHIFT (split_mode,
3530                                              XEXP (*split, 0), GEN_INT (i)));
3531               /* Update split_code because we may not have a multiply
3532                  anymore.  */
3533               split_code = GET_CODE (*split);
3534             }
3535
3536 #ifdef INSN_SCHEDULING
3537           /* If *SPLIT is a paradoxical SUBREG, when we split it, it should
3538              be written as a ZERO_EXTEND.  */
3539           if (split_code == SUBREG && MEM_P (SUBREG_REG (*split)))
3540             {
3541 #ifdef LOAD_EXTEND_OP
3542               /* Or as a SIGN_EXTEND if LOAD_EXTEND_OP says that that's
3543                  what it really is.  */
3544               if (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (*split)))
3545                   == SIGN_EXTEND)
3546                 SUBST (*split, gen_rtx_SIGN_EXTEND (split_mode,
3547                                                     SUBREG_REG (*split)));
3548               else
3549 #endif
3550                 SUBST (*split, gen_rtx_ZERO_EXTEND (split_mode,
3551                                                     SUBREG_REG (*split)));
3552             }
3553 #endif
3554
3555           /* Attempt to split binary operators using arithmetic identities.  */
3556           if (BINARY_P (SET_SRC (newpat))
3557               && split_mode == GET_MODE (SET_SRC (newpat))
3558               && ! side_effects_p (SET_SRC (newpat)))
3559             {
3560               rtx setsrc = SET_SRC (newpat);
3561               enum machine_mode mode = GET_MODE (setsrc);
3562               enum rtx_code code = GET_CODE (setsrc);
3563               rtx src_op0 = XEXP (setsrc, 0);
3564               rtx src_op1 = XEXP (setsrc, 1);
3565
3566               /* Split "X = Y op Y" as "Z = Y; X = Z op Z".  */
3567               if (rtx_equal_p (src_op0, src_op1))
3568                 {
3569                   newi2pat = gen_rtx_SET (VOIDmode, newdest, src_op0);
3570                   SUBST (XEXP (setsrc, 0), newdest);
3571                   SUBST (XEXP (setsrc, 1), newdest);
3572                   subst_done = true;
3573                 }
3574               /* Split "((P op Q) op R) op S" where op is PLUS or MULT.  */
3575               else if ((code == PLUS || code == MULT)
3576                        && GET_CODE (src_op0) == code
3577                        && GET_CODE (XEXP (src_op0, 0)) == code
3578                        && (INTEGRAL_MODE_P (mode)
3579                            || (FLOAT_MODE_P (mode)
3580                                && flag_unsafe_math_optimizations)))
3581                 {
3582                   rtx p = XEXP (XEXP (src_op0, 0), 0);
3583                   rtx q = XEXP (XEXP (src_op0, 0), 1);
3584                   rtx r = XEXP (src_op0, 1);
3585                   rtx s = src_op1;
3586
3587                   /* Split both "((X op Y) op X) op Y" and
3588                      "((X op Y) op Y) op X" as "T op T" where T is
3589                      "X op Y".  */
3590                   if ((rtx_equal_p (p,r) && rtx_equal_p (q,s))
3591                        || (rtx_equal_p (p,s) && rtx_equal_p (q,r)))
3592                     {
3593                       newi2pat = gen_rtx_SET (VOIDmode, newdest,
3594                                               XEXP (src_op0, 0));
3595                       SUBST (XEXP (setsrc, 0), newdest);
3596                       SUBST (XEXP (setsrc, 1), newdest);
3597                       subst_done = true;
3598                     }
3599                   /* Split "((X op X) op Y) op Y)" as "T op T" where
3600                      T is "X op Y".  */
3601                   else if (rtx_equal_p (p,q) && rtx_equal_p (r,s))
3602                     {
3603                       rtx tmp = simplify_gen_binary (code, mode, p, r);
3604                       newi2pat = gen_rtx_SET (VOIDmode, newdest, tmp);
3605                       SUBST (XEXP (setsrc, 0), newdest);
3606                       SUBST (XEXP (setsrc, 1), newdest);
3607                       subst_done = true;
3608                     }
3609                 }
3610             }
3611
3612           if (!subst_done)
3613             {
3614               newi2pat = gen_rtx_SET (VOIDmode, newdest, *split);
3615               SUBST (*split, newdest);
3616             }
3617
3618           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3619
3620           /* recog_for_combine might have added CLOBBERs to newi2pat.
3621              Make sure NEWPAT does not depend on the clobbered regs.  */
3622           if (GET_CODE (newi2pat) == PARALLEL)
3623             for (i = XVECLEN (newi2pat, 0) - 1; i >= 0; i--)
3624               if (GET_CODE (XVECEXP (newi2pat, 0, i)) == CLOBBER)
3625                 {
3626                   rtx reg = XEXP (XVECEXP (newi2pat, 0, i), 0);
3627                   if (reg_overlap_mentioned_p (reg, newpat))
3628                     {
3629                       undo_all ();
3630                       return 0;
3631                     }
3632                 }
3633
3634           /* If the split point was a MULT and we didn't have one before,
3635              don't use one now.  */
3636           if (i2_code_number >= 0 && ! (split_code == MULT && ! have_mult))
3637             insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3638         }
3639     }
3640
3641   /* Check for a case where we loaded from memory in a narrow mode and
3642      then sign extended it, but we need both registers.  In that case,
3643      we have a PARALLEL with both loads from the same memory location.
3644      We can split this into a load from memory followed by a register-register
3645      copy.  This saves at least one insn, more if register allocation can
3646      eliminate the copy.
3647
3648      We cannot do this if the destination of the first assignment is a
3649      condition code register or cc0.  We eliminate this case by making sure
3650      the SET_DEST and SET_SRC have the same mode.
3651
3652      We cannot do this if the destination of the second assignment is
3653      a register that we have already assumed is zero-extended.  Similarly
3654      for a SUBREG of such a register.  */
3655
3656   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
3657            && GET_CODE (newpat) == PARALLEL
3658            && XVECLEN (newpat, 0) == 2
3659            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
3660            && GET_CODE (SET_SRC (XVECEXP (newpat, 0, 0))) == SIGN_EXTEND
3661            && (GET_MODE (SET_DEST (XVECEXP (newpat, 0, 0)))
3662                == GET_MODE (SET_SRC (XVECEXP (newpat, 0, 0))))
3663            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
3664            && rtx_equal_p (SET_SRC (XVECEXP (newpat, 0, 1)),
3665                            XEXP (SET_SRC (XVECEXP (newpat, 0, 0)), 0))
3666            && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
3667                                    DF_INSN_LUID (i2))
3668            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
3669            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
3670            && ! (temp = SET_DEST (XVECEXP (newpat, 0, 1)),
3671                  (REG_P (temp)
3672                   && VEC_index (reg_stat_type, reg_stat,
3673                                 REGNO (temp))->nonzero_bits != 0
3674                   && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
3675                   && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
3676                   && (VEC_index (reg_stat_type, reg_stat,
3677                                  REGNO (temp))->nonzero_bits
3678                       != GET_MODE_MASK (word_mode))))
3679            && ! (GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) == SUBREG
3680                  && (temp = SUBREG_REG (SET_DEST (XVECEXP (newpat, 0, 1))),
3681                      (REG_P (temp)
3682                       && VEC_index (reg_stat_type, reg_stat,
3683                                     REGNO (temp))->nonzero_bits != 0
3684                       && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
3685                       && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
3686                       && (VEC_index (reg_stat_type, reg_stat,
3687                                      REGNO (temp))->nonzero_bits
3688                           != GET_MODE_MASK (word_mode)))))
3689            && ! reg_overlap_mentioned_p (SET_DEST (XVECEXP (newpat, 0, 1)),
3690                                          SET_SRC (XVECEXP (newpat, 0, 1)))
3691            && ! find_reg_note (i3, REG_UNUSED,
3692                                SET_DEST (XVECEXP (newpat, 0, 0))))
3693     {
3694       rtx ni2dest;
3695
3696       newi2pat = XVECEXP (newpat, 0, 0);
3697       ni2dest = SET_DEST (XVECEXP (newpat, 0, 0));
3698       newpat = XVECEXP (newpat, 0, 1);
3699       SUBST (SET_SRC (newpat),
3700              gen_lowpart (GET_MODE (SET_SRC (newpat)), ni2dest));
3701       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3702
3703       if (i2_code_number >= 0)
3704         insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3705
3706       if (insn_code_number >= 0)
3707         swap_i2i3 = 1;
3708     }
3709
3710   /* Similarly, check for a case where we have a PARALLEL of two independent
3711      SETs but we started with three insns.  In this case, we can do the sets
3712      as two separate insns.  This case occurs when some SET allows two
3713      other insns to combine, but the destination of that SET is still live.  */
3714
3715   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
3716            && GET_CODE (newpat) == PARALLEL
3717            && XVECLEN (newpat, 0) == 2
3718            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
3719            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != ZERO_EXTRACT
3720            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != STRICT_LOW_PART
3721            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
3722            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
3723            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
3724            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 1)),
3725                                   XVECEXP (newpat, 0, 0))
3726            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 0)),
3727                                   XVECEXP (newpat, 0, 1))
3728            && ! (contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 0)))
3729                  && contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 1)))))
3730     {
3731       /* Normally, it doesn't matter which of the two is done first,
3732          but the one that references cc0 can't be the second, and
3733          one which uses any regs/memory set in between i2 and i3 can't
3734          be first.  */
3735       if (!use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
3736                               DF_INSN_LUID (i2))
3737 #ifdef HAVE_cc0
3738           && !reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 0))
3739 #endif
3740          )
3741         {
3742           newi2pat = XVECEXP (newpat, 0, 1);
3743           newpat = XVECEXP (newpat, 0, 0);
3744         }
3745       else if (!use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 0)),
3746                                    DF_INSN_LUID (i2))
3747 #ifdef HAVE_cc0
3748                && !reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 1))
3749 #endif
3750               )
3751         {
3752           newi2pat = XVECEXP (newpat, 0, 0);
3753           newpat = XVECEXP (newpat, 0, 1);
3754         }
3755       else
3756         {
3757           undo_all ();
3758           return 0;
3759         }
3760
3761       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3762
3763       if (i2_code_number >= 0)
3764         {
3765           /* recog_for_combine might have added CLOBBERs to newi2pat.
3766              Make sure NEWPAT does not depend on the clobbered regs.  */
3767           if (GET_CODE (newi2pat) == PARALLEL)
3768             {
3769               for (i = XVECLEN (newi2pat, 0) - 1; i >= 0; i--)
3770                 if (GET_CODE (XVECEXP (newi2pat, 0, i)) == CLOBBER)
3771                   {
3772                     rtx reg = XEXP (XVECEXP (newi2pat, 0, i), 0);
3773                     if (reg_overlap_mentioned_p (reg, newpat))
3774                       {
3775                         undo_all ();
3776                         return 0;
3777                       }
3778                   }
3779             }
3780
3781           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3782         }
3783     }
3784
3785   /* If it still isn't recognized, fail and change things back the way they
3786      were.  */
3787   if ((insn_code_number < 0
3788        /* Is the result a reasonable ASM_OPERANDS?  */
3789        && (! check_asm_operands (newpat) || added_sets_1 || added_sets_2)))
3790     {
3791       undo_all ();
3792       return 0;
3793     }
3794
3795   /* If we had to change another insn, make sure it is valid also.  */
3796   if (undobuf.other_insn)
3797     {
3798       CLEAR_HARD_REG_SET (newpat_used_regs);
3799
3800       other_pat = PATTERN (undobuf.other_insn);
3801       other_code_number = recog_for_combine (&other_pat, undobuf.other_insn,
3802                                              &new_other_notes);
3803
3804       if (other_code_number < 0 && ! check_asm_operands (other_pat))
3805         {
3806           undo_all ();
3807           return 0;
3808         }
3809     }
3810
3811 #ifdef HAVE_cc0
3812   /* If I2 is the CC0 setter and I3 is the CC0 user then check whether
3813      they are adjacent to each other or not.  */
3814   {
3815     rtx p = prev_nonnote_insn (i3);
3816     if (p && p != i2 && NONJUMP_INSN_P (p) && newi2pat
3817         && sets_cc0_p (newi2pat))
3818       {
3819         undo_all ();
3820         return 0;
3821       }
3822   }
3823 #endif
3824
3825   /* Only allow this combination if insn_rtx_costs reports that the
3826      replacement instructions are cheaper than the originals.  */
3827   if (!combine_validate_cost (i0, i1, i2, i3, newpat, newi2pat, other_pat))
3828     {
3829       undo_all ();
3830       return 0;
3831     }
3832
3833   if (MAY_HAVE_DEBUG_INSNS)
3834     {
3835       struct undo *undo;
3836
3837       for (undo = undobuf.undos; undo; undo = undo->next)
3838         if (undo->kind == UNDO_MODE)
3839           {
3840             rtx reg = *undo->where.r;
3841             enum machine_mode new_mode = GET_MODE (reg);
3842             enum machine_mode old_mode = undo->old_contents.m;
3843
3844             /* Temporarily revert mode back.  */
3845             adjust_reg_mode (reg, old_mode);
3846
3847             if (reg == i2dest && i2scratch)
3848               {
3849                 /* If we used i2dest as a scratch register with a
3850                    different mode, substitute it for the original
3851                    i2src while its original mode is temporarily
3852                    restored, and then clear i2scratch so that we don't
3853                    do it again later.  */
3854                 propagate_for_debug (i2, i3, reg, i2src);
3855                 i2scratch = false;
3856                 /* Put back the new mode.  */
3857                 adjust_reg_mode (reg, new_mode);
3858               }
3859             else
3860               {
3861                 rtx tempreg = gen_raw_REG (old_mode, REGNO (reg));
3862                 rtx first, last;
3863
3864                 if (reg == i2dest)
3865                   {
3866                     first = i2;
3867                     last = i3;
3868                   }
3869                 else
3870                   {
3871                     first = i3;
3872                     last = undobuf.other_insn;
3873                     gcc_assert (last);
3874                   }
3875
3876                 /* We're dealing with a reg that changed mode but not
3877                    meaning, so we want to turn it into a subreg for
3878                    the new mode.  However, because of REG sharing and
3879                    because its mode had already changed, we have to do
3880                    it in two steps.  First, replace any debug uses of
3881                    reg, with its original mode temporarily restored,
3882                    with this copy we have created; then, replace the
3883                    copy with the SUBREG of the original shared reg,
3884                    once again changed to the new mode.  */
3885                 propagate_for_debug (first, last, reg, tempreg);
3886                 adjust_reg_mode (reg, new_mode);
3887                 propagate_for_debug (first, last, tempreg,
3888                                      lowpart_subreg (old_mode, reg, new_mode));
3889               }
3890           }
3891     }
3892
3893   /* If we will be able to accept this, we have made a
3894      change to the destination of I3.  This requires us to
3895      do a few adjustments.  */
3896
3897   if (changed_i3_dest)
3898     {
3899       PATTERN (i3) = newpat;
3900       adjust_for_new_dest (i3);
3901     }
3902
3903   /* We now know that we can do this combination.  Merge the insns and
3904      update the status of registers and LOG_LINKS.  */
3905
3906   if (undobuf.other_insn)
3907     {
3908       rtx note, next;
3909
3910       PATTERN (undobuf.other_insn) = other_pat;
3911
3912       /* If any of the notes in OTHER_INSN were REG_UNUSED, ensure that they
3913          are still valid.  Then add any non-duplicate notes added by
3914          recog_for_combine.  */
3915       for (note = REG_NOTES (undobuf.other_insn); note; note = next)
3916         {
3917           next = XEXP (note, 1);
3918
3919           if (REG_NOTE_KIND (note) == REG_UNUSED
3920               && ! reg_set_p (XEXP (note, 0), PATTERN (undobuf.other_insn)))
3921             remove_note (undobuf.other_insn, note);
3922         }
3923
3924       distribute_notes (new_other_notes, undobuf.other_insn,
3925                         undobuf.other_insn, NULL_RTX, NULL_RTX, NULL_RTX,
3926                         NULL_RTX);
3927     }
3928
3929   if (swap_i2i3)
3930     {
3931       rtx insn;
3932       rtx link;
3933       rtx ni2dest;
3934
3935       /* I3 now uses what used to be its destination and which is now
3936          I2's destination.  This requires us to do a few adjustments.  */
3937       PATTERN (i3) = newpat;
3938       adjust_for_new_dest (i3);
3939
3940       /* We need a LOG_LINK from I3 to I2.  But we used to have one,
3941          so we still will.
3942
3943          However, some later insn might be using I2's dest and have
3944          a LOG_LINK pointing at I3.  We must remove this link.
3945          The simplest way to remove the link is to point it at I1,
3946          which we know will be a NOTE.  */
3947
3948       /* newi2pat is usually a SET here; however, recog_for_combine might
3949          have added some clobbers.  */
3950       if (GET_CODE (newi2pat) == PARALLEL)
3951         ni2dest = SET_DEST (XVECEXP (newi2pat, 0, 0));
3952       else
3953         ni2dest = SET_DEST (newi2pat);
3954
3955       for (insn = NEXT_INSN (i3);
3956            insn && (this_basic_block->next_bb == EXIT_BLOCK_PTR
3957                     || insn != BB_HEAD (this_basic_block->next_bb));
3958            insn = NEXT_INSN (insn))
3959         {
3960           if (INSN_P (insn) && reg_referenced_p (ni2dest, PATTERN (insn)))
3961             {
3962               for (link = LOG_LINKS (insn); link;
3963                    link = XEXP (link, 1))
3964                 if (XEXP (link, 0) == i3)
3965                   XEXP (link, 0) = i1;
3966
3967               break;
3968             }
3969         }
3970     }
3971
3972   {
3973     rtx i3notes, i2notes, i1notes = 0, i0notes = 0;
3974     rtx i3links, i2links, i1links = 0, i0links = 0;
3975     rtx midnotes = 0;
3976     int from_luid;
3977     /* Compute which registers we expect to eliminate.  newi2pat may be setting
3978        either i3dest or i2dest, so we must check it.  Also, i1dest may be the
3979        same as i3dest, in which case newi2pat may be setting i1dest.  */
3980     rtx elim_i2 = ((newi2pat && reg_set_p (i2dest, newi2pat))
3981                    || i2dest_in_i2src || i2dest_in_i1src || i2dest_in_i0src
3982                    || !i2dest_killed
3983                    ? 0 : i2dest);
3984     rtx elim_i1 = (i1 == 0 || i1dest_in_i1src || i1dest_in_i0src
3985                    || (newi2pat && reg_set_p (i1dest, newi2pat))
3986                    || !i1dest_killed
3987                    ? 0 : i1dest);
3988     rtx elim_i0 = (i0 == 0 || i0dest_in_i0src
3989                    || (newi2pat && reg_set_p (i0dest, newi2pat))
3990                    || !i0dest_killed
3991                    ? 0 : i0dest);
3992
3993     /* Get the old REG_NOTES and LOG_LINKS from all our insns and
3994        clear them.  */
3995     i3notes = REG_NOTES (i3), i3links = LOG_LINKS (i3);
3996     i2notes = REG_NOTES (i2), i2links = LOG_LINKS (i2);
3997     if (i1)
3998       i1notes = REG_NOTES (i1), i1links = LOG_LINKS (i1);
3999     if (i0)
4000       i0notes = REG_NOTES (i0), i0links = LOG_LINKS (i0);
4001
4002     /* Ensure that we do not have something that should not be shared but
4003        occurs multiple times in the new insns.  Check this by first
4004        resetting all the `used' flags and then copying anything is shared.  */
4005
4006     reset_used_flags (i3notes);
4007     reset_used_flags (i2notes);
4008     reset_used_flags (i1notes);
4009     reset_used_flags (i0notes);
4010     reset_used_flags (newpat);
4011     reset_used_flags (newi2pat);
4012     if (undobuf.other_insn)
4013       reset_used_flags (PATTERN (undobuf.other_insn));
4014
4015     i3notes = copy_rtx_if_shared (i3notes);
4016     i2notes = copy_rtx_if_shared (i2notes);
4017     i1notes = copy_rtx_if_shared (i1notes);
4018     i0notes = copy_rtx_if_shared (i0notes);
4019     newpat = copy_rtx_if_shared (newpat);
4020     newi2pat = copy_rtx_if_shared (newi2pat);
4021     if (undobuf.other_insn)
4022       reset_used_flags (PATTERN (undobuf.other_insn));
4023
4024     INSN_CODE (i3) = insn_code_number;
4025     PATTERN (i3) = newpat;
4026
4027     if (CALL_P (i3) && CALL_INSN_FUNCTION_USAGE (i3))
4028       {
4029         rtx call_usage = CALL_INSN_FUNCTION_USAGE (i3);
4030
4031         reset_used_flags (call_usage);
4032         call_usage = copy_rtx (call_usage);
4033
4034         if (substed_i2)
4035           {
4036             /* I2SRC must still be meaningful at this point.  Some splitting
4037                operations can invalidate I2SRC, but those operations do not
4038                apply to calls.  */
4039             gcc_assert (i2src);
4040             replace_rtx (call_usage, i2dest, i2src);
4041           }
4042
4043         if (substed_i1)
4044           replace_rtx (call_usage, i1dest, i1src);
4045         if (substed_i0)
4046           replace_rtx (call_usage, i0dest, i0src);
4047
4048         CALL_INSN_FUNCTION_USAGE (i3) = call_usage;
4049       }
4050
4051     if (undobuf.other_insn)
4052       INSN_CODE (undobuf.other_insn) = other_code_number;
4053
4054     /* We had one special case above where I2 had more than one set and
4055        we replaced a destination of one of those sets with the destination
4056        of I3.  In that case, we have to update LOG_LINKS of insns later
4057        in this basic block.  Note that this (expensive) case is rare.
4058
4059        Also, in this case, we must pretend that all REG_NOTEs for I2
4060        actually came from I3, so that REG_UNUSED notes from I2 will be
4061        properly handled.  */
4062
4063     if (i3_subst_into_i2)
4064       {
4065         for (i = 0; i < XVECLEN (PATTERN (i2), 0); i++)
4066           if ((GET_CODE (XVECEXP (PATTERN (i2), 0, i)) == SET
4067                || GET_CODE (XVECEXP (PATTERN (i2), 0, i)) == CLOBBER)
4068               && REG_P (SET_DEST (XVECEXP (PATTERN (i2), 0, i)))
4069               && SET_DEST (XVECEXP (PATTERN (i2), 0, i)) != i2dest
4070               && ! find_reg_note (i2, REG_UNUSED,
4071                                   SET_DEST (XVECEXP (PATTERN (i2), 0, i))))
4072             for (temp = NEXT_INSN (i2);
4073                  temp && (this_basic_block->next_bb == EXIT_BLOCK_PTR
4074                           || BB_HEAD (this_basic_block) != temp);
4075                  temp = NEXT_INSN (temp))
4076               if (temp != i3 && INSN_P (temp))
4077                 for (link = LOG_LINKS (temp); link; link = XEXP (link, 1))
4078                   if (XEXP (link, 0) == i2)
4079                     XEXP (link, 0) = i3;
4080
4081         if (i3notes)
4082           {
4083             rtx link = i3notes;
4084             while (XEXP (link, 1))
4085               link = XEXP (link, 1);
4086             XEXP (link, 1) = i2notes;
4087           }
4088         else
4089           i3notes = i2notes;
4090         i2notes = 0;
4091       }
4092
4093     LOG_LINKS (i3) = 0;
4094     REG_NOTES (i3) = 0;
4095     LOG_LINKS (i2) = 0;
4096     REG_NOTES (i2) = 0;
4097
4098     if (newi2pat)
4099       {
4100         if (MAY_HAVE_DEBUG_INSNS && i2scratch)
4101           propagate_for_debug (i2, i3, i2dest, i2src);
4102         INSN_CODE (i2) = i2_code_number;
4103         PATTERN (i2) = newi2pat;
4104       }
4105     else
4106       {
4107         if (MAY_HAVE_DEBUG_INSNS && i2src)
4108           propagate_for_debug (i2, i3, i2dest, i2src);
4109         SET_INSN_DELETED (i2);
4110       }
4111
4112     if (i1)
4113       {
4114         LOG_LINKS (i1) = 0;
4115         REG_NOTES (i1) = 0;
4116         if (MAY_HAVE_DEBUG_INSNS)
4117           propagate_for_debug (i1, i3, i1dest, i1src);
4118         SET_INSN_DELETED (i1);
4119       }
4120
4121     if (i0)
4122       {
4123         LOG_LINKS (i0) = 0;
4124         REG_NOTES (i0) = 0;
4125         if (MAY_HAVE_DEBUG_INSNS)
4126           propagate_for_debug (i0, i3, i0dest, i0src);
4127         SET_INSN_DELETED (i0);
4128       }
4129
4130     /* Get death notes for everything that is now used in either I3 or
4131        I2 and used to die in a previous insn.  If we built two new
4132        patterns, move from I1 to I2 then I2 to I3 so that we get the
4133        proper movement on registers that I2 modifies.  */
4134
4135     if (i0)
4136       from_luid = DF_INSN_LUID (i0);
4137     else if (i1)
4138       from_luid = DF_INSN_LUID (i1);
4139     else
4140       from_luid = DF_INSN_LUID (i2);
4141     if (newi2pat)
4142       move_deaths (newi2pat, NULL_RTX, from_luid, i2, &midnotes);
4143     move_deaths (newpat, newi2pat, from_luid, i3, &midnotes);
4144
4145     /* Distribute all the LOG_LINKS and REG_NOTES from I1, I2, and I3.  */
4146     if (i3notes)
4147       distribute_notes (i3notes, i3, i3, newi2pat ? i2 : NULL_RTX,
4148                         elim_i2, elim_i1, elim_i0);
4149     if (i2notes)
4150       distribute_notes (i2notes, i2, i3, newi2pat ? i2 : NULL_RTX,
4151                         elim_i2, elim_i1, elim_i0);
4152     if (i1notes)
4153       distribute_notes (i1notes, i1, i3, newi2pat ? i2 : NULL_RTX,
4154                         elim_i2, elim_i1, elim_i0);
4155     if (i0notes)
4156       distribute_notes (i0notes, i0, i3, newi2pat ? i2 : NULL_RTX,
4157                         elim_i2, elim_i1, elim_i0);
4158     if (midnotes)
4159       distribute_notes (midnotes, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4160                         elim_i2, elim_i1, elim_i0);
4161
4162     /* Distribute any notes added to I2 or I3 by recog_for_combine.  We
4163        know these are REG_UNUSED and want them to go to the desired insn,
4164        so we always pass it as i3.  */
4165
4166     if (newi2pat && new_i2_notes)
4167       distribute_notes (new_i2_notes, i2, i2, NULL_RTX, NULL_RTX, NULL_RTX,
4168                         NULL_RTX);
4169
4170     if (new_i3_notes)
4171       distribute_notes (new_i3_notes, i3, i3, NULL_RTX, NULL_RTX, NULL_RTX,
4172                         NULL_RTX);
4173
4174     /* If I3DEST was used in I3SRC, it really died in I3.  We may need to
4175        put a REG_DEAD note for it somewhere.  If NEWI2PAT exists and sets
4176        I3DEST, the death must be somewhere before I2, not I3.  If we passed I3
4177        in that case, it might delete I2.  Similarly for I2 and I1.
4178        Show an additional death due to the REG_DEAD note we make here.  If
4179        we discard it in distribute_notes, we will decrement it again.  */
4180
4181     if (i3dest_killed)
4182       {
4183         if (newi2pat && reg_set_p (i3dest_killed, newi2pat))
4184           distribute_notes (alloc_reg_note (REG_DEAD, i3dest_killed,
4185                                             NULL_RTX),
4186                             NULL_RTX, i2, NULL_RTX, elim_i2, elim_i1, elim_i0);
4187         else
4188           distribute_notes (alloc_reg_note (REG_DEAD, i3dest_killed,
4189                                             NULL_RTX),
4190                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4191                             elim_i2, elim_i1, elim_i0);
4192       }
4193
4194     if (i2dest_in_i2src)
4195       {
4196         rtx new_note = alloc_reg_note (REG_DEAD, i2dest, NULL_RTX);
4197         if (newi2pat && reg_set_p (i2dest, newi2pat))
4198           distribute_notes (new_note,  NULL_RTX, i2, NULL_RTX, NULL_RTX,
4199                             NULL_RTX, NULL_RTX);
4200         else
4201           distribute_notes (new_note, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4202                             NULL_RTX, NULL_RTX, NULL_RTX);
4203       }
4204
4205     if (i1dest_in_i1src)
4206       {
4207         rtx new_note = alloc_reg_note (REG_DEAD, i1dest, NULL_RTX);
4208         if (newi2pat && reg_set_p (i1dest, newi2pat))
4209           distribute_notes (new_note, NULL_RTX, i2, NULL_RTX, NULL_RTX,
4210                             NULL_RTX, NULL_RTX);
4211         else
4212           distribute_notes (new_note, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4213                             NULL_RTX, NULL_RTX, NULL_RTX);
4214       }
4215
4216     if (i0dest_in_i0src)
4217       {
4218         rtx new_note = alloc_reg_note (REG_DEAD, i0dest, NULL_RTX);
4219         if (newi2pat && reg_set_p (i0dest, newi2pat))
4220           distribute_notes (new_note, NULL_RTX, i2, NULL_RTX, NULL_RTX,
4221                             NULL_RTX, NULL_RTX);
4222         else
4223           distribute_notes (new_note, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4224                             NULL_RTX, NULL_RTX, NULL_RTX);
4225       }
4226
4227     distribute_links (i3links);
4228     distribute_links (i2links);
4229     distribute_links (i1links);
4230     distribute_links (i0links);
4231
4232     if (REG_P (i2dest))
4233       {
4234         rtx link, i2_insn = 0, i2_val = 0, set;
4235
4236         /* The insn that used to set this register doesn't exist, and
4237            this life of the register may not exist either.  See if one of
4238            I3's links points to an insn that sets I2DEST.  If it does,
4239            that is now the last known value for I2DEST. If we don't update
4240            this and I2 set the register to a value that depended on its old
4241            contents, we will get confused.  If this insn is used, thing
4242            will be set correctly in combine_instructions.  */
4243         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
4244           if ((set = single_set (XEXP (link, 0))) != 0
4245               && rtx_equal_p (i2dest, SET_DEST (set)))
4246             i2_insn = XEXP (link, 0), i2_val = SET_SRC (set);
4247
4248         record_value_for_reg (i2dest, i2_insn, i2_val);
4249
4250         /* If the reg formerly set in I2 died only once and that was in I3,
4251            zero its use count so it won't make `reload' do any work.  */
4252         if (! added_sets_2
4253             && (newi2pat == 0 || ! reg_mentioned_p (i2dest, newi2pat))
4254             && ! i2dest_in_i2src)
4255           INC_REG_N_SETS (REGNO (i2dest), -1);
4256       }
4257
4258     if (i1 && REG_P (i1dest))
4259       {
4260         rtx link, i1_insn = 0, i1_val = 0, set;
4261
4262         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
4263           if ((set = single_set (XEXP (link, 0))) != 0
4264               && rtx_equal_p (i1dest, SET_DEST (set)))
4265             i1_insn = XEXP (link, 0), i1_val = SET_SRC (set);
4266
4267         record_value_for_reg (i1dest, i1_insn, i1_val);
4268
4269         if (! added_sets_1 && ! i1dest_in_i1src)
4270           INC_REG_N_SETS (REGNO (i1dest), -1);
4271       }
4272
4273     if (i0 && REG_P (i0dest))
4274       {
4275         rtx link, i0_insn = 0, i0_val = 0, set;
4276
4277         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
4278           if ((set = single_set (XEXP (link, 0))) != 0
4279               && rtx_equal_p (i0dest, SET_DEST (set)))
4280             i0_insn = XEXP (link, 0), i0_val = SET_SRC (set);
4281
4282         record_value_for_reg (i0dest, i0_insn, i0_val);
4283
4284         if (! added_sets_0 && ! i0dest_in_i0src)
4285           INC_REG_N_SETS (REGNO (i0dest), -1);
4286       }
4287
4288     /* Update reg_stat[].nonzero_bits et al for any changes that may have
4289        been made to this insn.  The order of
4290        set_nonzero_bits_and_sign_copies() is important.  Because newi2pat
4291        can affect nonzero_bits of newpat */
4292     if (newi2pat)
4293       note_stores (newi2pat, set_nonzero_bits_and_sign_copies, NULL);
4294     note_stores (newpat, set_nonzero_bits_and_sign_copies, NULL);
4295   }
4296
4297   if (undobuf.other_insn != NULL_RTX)
4298     {
4299       if (dump_file)
4300         {
4301           fprintf (dump_file, "modifying other_insn ");
4302           dump_insn_slim (dump_file, undobuf.other_insn);
4303         }
4304       df_insn_rescan (undobuf.other_insn);
4305     }
4306
4307   if (i0 && !(NOTE_P(i0) && (NOTE_KIND (i0) == NOTE_INSN_DELETED)))
4308     {
4309       if (dump_file)
4310         {
4311           fprintf (dump_file, "modifying insn i1 ");
4312           dump_insn_slim (dump_file, i0);
4313         }
4314       df_insn_rescan (i0);
4315     }
4316
4317   if (i1 && !(NOTE_P(i1) && (NOTE_KIND (i1) == NOTE_INSN_DELETED)))
4318     {
4319       if (dump_file)
4320         {
4321           fprintf (dump_file, "modifying insn i1 ");
4322           dump_insn_slim (dump_file, i1);
4323         }
4324       df_insn_rescan (i1);
4325     }
4326
4327   if (i2 && !(NOTE_P(i2) && (NOTE_KIND (i2) == NOTE_INSN_DELETED)))
4328     {
4329       if (dump_file)
4330         {
4331           fprintf (dump_file, "modifying insn i2 ");
4332           dump_insn_slim (dump_file, i2);
4333         }
4334       df_insn_rescan (i2);
4335     }
4336
4337   if (i3 && !(NOTE_P(i3) && (NOTE_KIND (i3) == NOTE_INSN_DELETED)))
4338     {
4339       if (dump_file)
4340         {
4341           fprintf (dump_file, "modifying insn i3 ");
4342           dump_insn_slim (dump_file, i3);
4343         }
4344       df_insn_rescan (i3);
4345     }
4346
4347   /* Set new_direct_jump_p if a new return or simple jump instruction
4348      has been created.  Adjust the CFG accordingly.  */
4349
4350   if (returnjump_p (i3) || any_uncondjump_p (i3))
4351     {
4352       *new_direct_jump_p = 1;
4353       mark_jump_label (PATTERN (i3), i3, 0);
4354       update_cfg_for_uncondjump (i3);
4355     }
4356
4357   if (undobuf.other_insn != NULL_RTX
4358       && (returnjump_p (undobuf.other_insn)
4359           || any_uncondjump_p (undobuf.other_insn)))
4360     {
4361       *new_direct_jump_p = 1;
4362       update_cfg_for_uncondjump (undobuf.other_insn);
4363     }
4364
4365   /* A noop might also need cleaning up of CFG, if it comes from the
4366      simplification of a jump.  */
4367   if (GET_CODE (newpat) == SET
4368       && SET_SRC (newpat) == pc_rtx
4369       && SET_DEST (newpat) == pc_rtx)
4370     {
4371       *new_direct_jump_p = 1;
4372       update_cfg_for_uncondjump (i3);
4373     }
4374
4375   if (undobuf.other_insn != NULL_RTX
4376       && GET_CODE (PATTERN (undobuf.other_insn)) == SET
4377       && SET_SRC (PATTERN (undobuf.other_insn)) == pc_rtx
4378       && SET_DEST (PATTERN (undobuf.other_insn)) == pc_rtx)
4379     {
4380       *new_direct_jump_p = 1;
4381       update_cfg_for_uncondjump (undobuf.other_insn);
4382     }
4383
4384   combine_successes++;
4385   undo_commit ();
4386
4387   if (added_links_insn
4388       && (newi2pat == 0 || DF_INSN_LUID (added_links_insn) < DF_INSN_LUID (i2))
4389       && DF_INSN_LUID (added_links_insn) < DF_INSN_LUID (i3))
4390     return added_links_insn;
4391   else
4392     return newi2pat ? i2 : i3;
4393 }
4394 \f
4395 /* Undo all the modifications recorded in undobuf.  */
4396
4397 static void
4398 undo_all (void)
4399 {
4400   struct undo *undo, *next;
4401
4402   for (undo = undobuf.undos; undo; undo = next)
4403     {
4404       next = undo->next;
4405       switch (undo->kind)
4406         {
4407         case UNDO_RTX:
4408           *undo->where.r = undo->old_contents.r;
4409           break;
4410         case UNDO_INT:
4411           *undo->where.i = undo->old_contents.i;
4412           break;
4413         case UNDO_MODE:
4414           adjust_reg_mode (*undo->where.r, undo->old_contents.m);
4415           break;
4416         default:
4417           gcc_unreachable ();
4418         }
4419
4420       undo->next = undobuf.frees;
4421       undobuf.frees = undo;
4422     }
4423
4424   undobuf.undos = 0;
4425 }
4426
4427 /* We've committed to accepting the changes we made.  Move all
4428    of the undos to the free list.  */
4429
4430 static void
4431 undo_commit (void)
4432 {
4433   struct undo *undo, *next;
4434
4435   for (undo = undobuf.undos; undo; undo = next)
4436     {
4437       next = undo->next;
4438       undo->next = undobuf.frees;
4439       undobuf.frees = undo;
4440     }
4441   undobuf.undos = 0;
4442 }
4443 \f
4444 /* Find the innermost point within the rtx at LOC, possibly LOC itself,
4445    where we have an arithmetic expression and return that point.  LOC will
4446    be inside INSN.
4447
4448    try_combine will call this function to see if an insn can be split into
4449    two insns.  */
4450
4451 static rtx *
4452 find_split_point (rtx *loc, rtx insn, bool set_src)
4453 {
4454   rtx x = *loc;
4455   enum rtx_code code = GET_CODE (x);
4456   rtx *split;
4457   unsigned HOST_WIDE_INT len = 0;
4458   HOST_WIDE_INT pos = 0;
4459   int unsignedp = 0;
4460   rtx inner = NULL_RTX;
4461
4462   /* First special-case some codes.  */
4463   switch (code)
4464     {
4465     case SUBREG:
4466 #ifdef INSN_SCHEDULING
4467       /* If we are making a paradoxical SUBREG invalid, it becomes a split
4468          point.  */
4469       if (MEM_P (SUBREG_REG (x)))
4470         return loc;
4471 #endif
4472       return find_split_point (&SUBREG_REG (x), insn, false);
4473
4474     case MEM:
4475 #ifdef HAVE_lo_sum
4476       /* If we have (mem (const ..)) or (mem (symbol_ref ...)), split it
4477          using LO_SUM and HIGH.  */
4478       if (GET_CODE (XEXP (x, 0)) == CONST
4479           || GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
4480         {
4481           enum machine_mode address_mode
4482             = targetm.addr_space.address_mode (MEM_ADDR_SPACE (x));
4483
4484           SUBST (XEXP (x, 0),
4485                  gen_rtx_LO_SUM (address_mode,
4486                                  gen_rtx_HIGH (address_mode, XEXP (x, 0)),
4487                                  XEXP (x, 0)));
4488           return &XEXP (XEXP (x, 0), 0);
4489         }
4490 #endif
4491
4492       /* If we have a PLUS whose second operand is a constant and the
4493          address is not valid, perhaps will can split it up using
4494          the machine-specific way to split large constants.  We use
4495          the first pseudo-reg (one of the virtual regs) as a placeholder;
4496          it will not remain in the result.  */
4497       if (GET_CODE (XEXP (x, 0)) == PLUS
4498           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
4499           && ! memory_address_addr_space_p (GET_MODE (x), XEXP (x, 0),
4500                                             MEM_ADDR_SPACE (x)))
4501         {
4502           rtx reg = regno_reg_rtx[FIRST_PSEUDO_REGISTER];
4503           rtx seq = combine_split_insns (gen_rtx_SET (VOIDmode, reg,
4504                                                       XEXP (x, 0)),
4505                                          subst_insn);
4506
4507           /* This should have produced two insns, each of which sets our
4508              placeholder.  If the source of the second is a valid address,
4509              we can make put both sources together and make a split point
4510              in the middle.  */
4511
4512           if (seq
4513               && NEXT_INSN (seq) != NULL_RTX
4514               && NEXT_INSN (NEXT_INSN (seq)) == NULL_RTX
4515               && NONJUMP_INSN_P (seq)
4516               && GET_CODE (PATTERN (seq)) == SET
4517               && SET_DEST (PATTERN (seq)) == reg
4518               && ! reg_mentioned_p (reg,
4519                                     SET_SRC (PATTERN (seq)))
4520               && NONJUMP_INSN_P (NEXT_INSN (seq))
4521               && GET_CODE (PATTERN (NEXT_INSN (seq))) == SET
4522               && SET_DEST (PATTERN (NEXT_INSN (seq))) == reg
4523               && memory_address_addr_space_p
4524                    (GET_MODE (x), SET_SRC (PATTERN (NEXT_INSN (seq))),
4525                     MEM_ADDR_SPACE (x)))
4526             {
4527               rtx src1 = SET_SRC (PATTERN (seq));
4528               rtx src2 = SET_SRC (PATTERN (NEXT_INSN (seq)));
4529
4530               /* Replace the placeholder in SRC2 with SRC1.  If we can
4531                  find where in SRC2 it was placed, that can become our
4532                  split point and we can replace this address with SRC2.
4533                  Just try two obvious places.  */
4534
4535               src2 = replace_rtx (src2, reg, src1);
4536               split = 0;
4537               if (XEXP (src2, 0) == src1)
4538                 split = &XEXP (src2, 0);
4539               else if (GET_RTX_FORMAT (GET_CODE (XEXP (src2, 0)))[0] == 'e'
4540                        && XEXP (XEXP (src2, 0), 0) == src1)
4541                 split = &XEXP (XEXP (src2, 0), 0);
4542
4543               if (split)
4544                 {
4545                   SUBST (XEXP (x, 0), src2);
4546                   return split;
4547                 }
4548             }
4549
4550           /* If that didn't work, perhaps the first operand is complex and
4551              needs to be computed separately, so make a split point there.
4552              This will occur on machines that just support REG + CONST
4553              and have a constant moved through some previous computation.  */
4554
4555           else if (!OBJECT_P (XEXP (XEXP (x, 0), 0))
4556                    && ! (GET_CODE (XEXP (XEXP (x, 0), 0)) == SUBREG
4557                          && OBJECT_P (SUBREG_REG (XEXP (XEXP (x, 0), 0)))))
4558             return &XEXP (XEXP (x, 0), 0);
4559         }
4560
4561       /* If we have a PLUS whose first operand is complex, try computing it
4562          separately by making a split there.  */
4563       if (GET_CODE (XEXP (x, 0)) == PLUS
4564           && ! memory_address_addr_space_p (GET_MODE (x), XEXP (x, 0),
4565                                             MEM_ADDR_SPACE (x))
4566           && ! OBJECT_P (XEXP (XEXP (x, 0), 0))
4567           && ! (GET_CODE (XEXP (XEXP (x, 0), 0)) == SUBREG
4568                 && OBJECT_P (SUBREG_REG (XEXP (XEXP (x, 0), 0)))))
4569         return &XEXP (XEXP (x, 0), 0);
4570       break;
4571
4572     case SET:
4573 #ifdef HAVE_cc0
4574       /* If SET_DEST is CC0 and SET_SRC is not an operand, a COMPARE, or a
4575          ZERO_EXTRACT, the most likely reason why this doesn't match is that
4576          we need to put the operand into a register.  So split at that
4577          point.  */
4578
4579       if (SET_DEST (x) == cc0_rtx
4580           && GET_CODE (SET_SRC (x)) != COMPARE
4581           && GET_CODE (SET_SRC (x)) != ZERO_EXTRACT
4582           && !OBJECT_P (SET_SRC (x))
4583           && ! (GET_CODE (SET_SRC (x)) == SUBREG
4584                 && OBJECT_P (SUBREG_REG (SET_SRC (x)))))
4585         return &SET_SRC (x);
4586 #endif
4587
4588       /* See if we can split SET_SRC as it stands.  */
4589       split = find_split_point (&SET_SRC (x), insn, true);
4590       if (split && split != &SET_SRC (x))
4591         return split;
4592
4593       /* See if we can split SET_DEST as it stands.  */
4594       split = find_split_point (&SET_DEST (x), insn, false);
4595       if (split && split != &SET_DEST (x))
4596         return split;
4597
4598       /* See if this is a bitfield assignment with everything constant.  If
4599          so, this is an IOR of an AND, so split it into that.  */
4600       if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
4601           && (GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)))
4602               <= HOST_BITS_PER_WIDE_INT)
4603           && CONST_INT_P (XEXP (SET_DEST (x), 1))
4604           && CONST_INT_P (XEXP (SET_DEST (x), 2))
4605           && CONST_INT_P (SET_SRC (x))
4606           && ((INTVAL (XEXP (SET_DEST (x), 1))
4607                + INTVAL (XEXP (SET_DEST (x), 2)))
4608               <= GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0))))
4609           && ! side_effects_p (XEXP (SET_DEST (x), 0)))
4610         {
4611           HOST_WIDE_INT pos = INTVAL (XEXP (SET_DEST (x), 2));
4612           unsigned HOST_WIDE_INT len = INTVAL (XEXP (SET_DEST (x), 1));
4613           unsigned HOST_WIDE_INT src = INTVAL (SET_SRC (x));
4614           rtx dest = XEXP (SET_DEST (x), 0);
4615           enum machine_mode mode = GET_MODE (dest);
4616           unsigned HOST_WIDE_INT mask
4617             = ((unsigned HOST_WIDE_INT) 1 << len) - 1;
4618           rtx or_mask;
4619
4620           if (BITS_BIG_ENDIAN)
4621             pos = GET_MODE_BITSIZE (mode) - len - pos;
4622
4623           or_mask = gen_int_mode (src << pos, mode);
4624           if (src == mask)
4625             SUBST (SET_SRC (x),
4626                    simplify_gen_binary (IOR, mode, dest, or_mask));
4627           else
4628             {
4629               rtx negmask = gen_int_mode (~(mask << pos), mode);
4630               SUBST (SET_SRC (x),
4631                      simplify_gen_binary (IOR, mode,
4632                                           simplify_gen_binary (AND, mode,
4633                                                                dest, negmask),
4634                                           or_mask));
4635             }
4636
4637           SUBST (SET_DEST (x), dest);
4638
4639           split = find_split_point (&SET_SRC (x), insn, true);
4640           if (split && split != &SET_SRC (x))
4641             return split;
4642         }
4643
4644       /* Otherwise, see if this is an operation that we can split into two.
4645          If so, try to split that.  */
4646       code = GET_CODE (SET_SRC (x));
4647
4648       switch (code)
4649         {
4650         case AND:
4651           /* If we are AND'ing with a large constant that is only a single
4652              bit and the result is only being used in a context where we
4653              need to know if it is zero or nonzero, replace it with a bit
4654              extraction.  This will avoid the large constant, which might
4655              have taken more than one insn to make.  If the constant were
4656              not a valid argument to the AND but took only one insn to make,
4657              this is no worse, but if it took more than one insn, it will
4658              be better.  */
4659
4660           if (CONST_INT_P (XEXP (SET_SRC (x), 1))
4661               && REG_P (XEXP (SET_SRC (x), 0))
4662               && (pos = exact_log2 (UINTVAL (XEXP (SET_SRC (x), 1)))) >= 7
4663               && REG_P (SET_DEST (x))
4664               && (split = find_single_use (SET_DEST (x), insn, (rtx*) 0)) != 0
4665               && (GET_CODE (*split) == EQ || GET_CODE (*split) == NE)
4666               && XEXP (*split, 0) == SET_DEST (x)
4667               && XEXP (*split, 1) == const0_rtx)
4668             {
4669               rtx extraction = make_extraction (GET_MODE (SET_DEST (x)),
4670                                                 XEXP (SET_SRC (x), 0),
4671                                                 pos, NULL_RTX, 1, 1, 0, 0);
4672               if (extraction != 0)
4673                 {
4674                   SUBST (SET_SRC (x), extraction);
4675                   return find_split_point (loc, insn, false);
4676                 }
4677             }
4678           break;
4679
4680         case NE:
4681           /* If STORE_FLAG_VALUE is -1, this is (NE X 0) and only one bit of X
4682              is known to be on, this can be converted into a NEG of a shift.  */
4683           if (STORE_FLAG_VALUE == -1 && XEXP (SET_SRC (x), 1) == const0_rtx
4684               && GET_MODE (SET_SRC (x)) == GET_MODE (XEXP (SET_SRC (x), 0))
4685               && 1 <= (pos = exact_log2
4686                        (nonzero_bits (XEXP (SET_SRC (x), 0),
4687                                       GET_MODE (XEXP (SET_SRC (x), 0))))))
4688             {
4689               enum machine_mode mode = GET_MODE (XEXP (SET_SRC (x), 0));
4690
4691               SUBST (SET_SRC (x),
4692                      gen_rtx_NEG (mode,
4693                                   gen_rtx_LSHIFTRT (mode,
4694                                                     XEXP (SET_SRC (x), 0),
4695                                                     GEN_INT (pos))));
4696
4697               split = find_split_point (&SET_SRC (x), insn, true);
4698               if (split && split != &SET_SRC (x))
4699                 return split;
4700             }
4701           break;
4702
4703         case SIGN_EXTEND:
4704           inner = XEXP (SET_SRC (x), 0);
4705
4706           /* We can't optimize if either mode is a partial integer
4707              mode as we don't know how many bits are significant
4708              in those modes.  */
4709           if (GET_MODE_CLASS (GET_MODE (inner)) == MODE_PARTIAL_INT
4710               || GET_MODE_CLASS (GET_MODE (SET_SRC (x))) == MODE_PARTIAL_INT)
4711             break;
4712
4713           pos = 0;
4714           len = GET_MODE_BITSIZE (GET_MODE (inner));
4715           unsignedp = 0;
4716           break;
4717
4718         case SIGN_EXTRACT:
4719         case ZERO_EXTRACT:
4720           if (CONST_INT_P (XEXP (SET_SRC (x), 1))
4721               && CONST_INT_P (XEXP (SET_SRC (x), 2)))
4722             {
4723               inner = XEXP (SET_SRC (x), 0);
4724               len = INTVAL (XEXP (SET_SRC (x), 1));
4725               pos = INTVAL (XEXP (SET_SRC (x), 2));
4726
4727               if (BITS_BIG_ENDIAN)
4728                 pos = GET_MODE_BITSIZE (GET_MODE (inner)) - len - pos;
4729               unsignedp = (code == ZERO_EXTRACT);
4730             }
4731           break;
4732
4733         default:
4734           break;
4735         }
4736
4737       if (len && pos >= 0 && pos + len <= GET_MODE_BITSIZE (GET_MODE (inner)))
4738         {
4739           enum machine_mode mode = GET_MODE (SET_SRC (x));
4740
4741           /* For unsigned, we have a choice of a shift followed by an
4742              AND or two shifts.  Use two shifts for field sizes where the
4743              constant might be too large.  We assume here that we can
4744              always at least get 8-bit constants in an AND insn, which is
4745              true for every current RISC.  */
4746
4747           if (unsignedp && len <= 8)
4748             {
4749               SUBST (SET_SRC (x),
4750                      gen_rtx_AND (mode,
4751                                   gen_rtx_LSHIFTRT
4752                                   (mode, gen_lowpart (mode, inner),
4753                                    GEN_INT (pos)),
4754                                   GEN_INT (((unsigned HOST_WIDE_INT) 1 << len)
4755                                            - 1)));
4756
4757               split = find_split_point (&SET_SRC (x), insn, true);
4758               if (split && split != &SET_SRC (x))
4759                 return split;
4760             }
4761           else
4762             {
4763               SUBST (SET_SRC (x),
4764                      gen_rtx_fmt_ee
4765                      (unsignedp ? LSHIFTRT : ASHIFTRT, mode,
4766                       gen_rtx_ASHIFT (mode,
4767                                       gen_lowpart (mode, inner),
4768                                       GEN_INT (GET_MODE_BITSIZE (mode)
4769                                                - len - pos)),
4770                       GEN_INT (GET_MODE_BITSIZE (mode) - len)));
4771
4772               split = find_split_point (&SET_SRC (x), insn, true);
4773               if (split && split != &SET_SRC (x))
4774                 return split;
4775             }
4776         }
4777
4778       /* See if this is a simple operation with a constant as the second
4779          operand.  It might be that this constant is out of range and hence
4780          could be used as a split point.  */
4781       if (BINARY_P (SET_SRC (x))
4782           && CONSTANT_P (XEXP (SET_SRC (x), 1))
4783           && (OBJECT_P (XEXP (SET_SRC (x), 0))
4784               || (GET_CODE (XEXP (SET_SRC (x), 0)) == SUBREG
4785                   && OBJECT_P (SUBREG_REG (XEXP (SET_SRC (x), 0))))))
4786         return &XEXP (SET_SRC (x), 1);
4787
4788       /* Finally, see if this is a simple operation with its first operand
4789          not in a register.  The operation might require this operand in a
4790          register, so return it as a split point.  We can always do this
4791          because if the first operand were another operation, we would have
4792          already found it as a split point.  */
4793       if ((BINARY_P (SET_SRC (x)) || UNARY_P (SET_SRC (x)))
4794           && ! register_operand (XEXP (SET_SRC (x), 0), VOIDmode))
4795         return &XEXP (SET_SRC (x), 0);
4796
4797       return 0;
4798
4799     case AND:
4800     case IOR:
4801       /* We write NOR as (and (not A) (not B)), but if we don't have a NOR,
4802          it is better to write this as (not (ior A B)) so we can split it.
4803          Similarly for IOR.  */
4804       if (GET_CODE (XEXP (x, 0)) == NOT && GET_CODE (XEXP (x, 1)) == NOT)
4805         {
4806           SUBST (*loc,
4807                  gen_rtx_NOT (GET_MODE (x),
4808                               gen_rtx_fmt_ee (code == IOR ? AND : IOR,
4809                                               GET_MODE (x),
4810                                               XEXP (XEXP (x, 0), 0),
4811                                               XEXP (XEXP (x, 1), 0))));
4812           return find_split_point (loc, insn, set_src);
4813         }
4814
4815       /* Many RISC machines have a large set of logical insns.  If the
4816          second operand is a NOT, put it first so we will try to split the
4817          other operand first.  */
4818       if (GET_CODE (XEXP (x, 1)) == NOT)
4819         {
4820           rtx tem = XEXP (x, 0);
4821           SUBST (XEXP (x, 0), XEXP (x, 1));
4822           SUBST (XEXP (x, 1), tem);
4823         }
4824       break;
4825
4826     case PLUS:
4827     case MINUS:
4828       /* Canonicalization can produce (minus A (mult B C)), where C is a
4829          constant.  It may be better to try splitting (plus (mult B -C) A)
4830          instead if this isn't a multiply by a power of two.  */
4831       if (set_src && code == MINUS && GET_CODE (XEXP (x, 1)) == MULT
4832           && GET_CODE (XEXP (XEXP (x, 1), 1)) == CONST_INT
4833           && exact_log2 (INTVAL (XEXP (XEXP (x, 1), 1))) < 0)
4834         {
4835           enum machine_mode mode = GET_MODE (x);
4836           unsigned HOST_WIDE_INT this_int = INTVAL (XEXP (XEXP (x, 1), 1));
4837           HOST_WIDE_INT other_int = trunc_int_for_mode (-this_int, mode);
4838           SUBST (*loc, gen_rtx_PLUS (mode, gen_rtx_MULT (mode,
4839                                                          XEXP (XEXP (x, 1), 0),
4840                                                          GEN_INT (other_int)),
4841                                      XEXP (x, 0)));
4842           return find_split_point (loc, insn, set_src);
4843         }
4844
4845       /* Split at a multiply-accumulate instruction.  However if this is
4846          the SET_SRC, we likely do not have such an instruction and it's
4847          worthless to try this split.  */
4848       if (!set_src && GET_CODE (XEXP (x, 0)) == MULT)
4849         return loc;
4850
4851     default:
4852       break;
4853     }
4854
4855   /* Otherwise, select our actions depending on our rtx class.  */
4856   switch (GET_RTX_CLASS (code))
4857     {
4858     case RTX_BITFIELD_OPS:              /* This is ZERO_EXTRACT and SIGN_EXTRACT.  */
4859     case RTX_TERNARY:
4860       split = find_split_point (&XEXP (x, 2), insn, false);
4861       if (split)
4862         return split;
4863       /* ... fall through ...  */
4864     case RTX_BIN_ARITH:
4865     case RTX_COMM_ARITH:
4866     case RTX_COMPARE:
4867     case RTX_COMM_COMPARE:
4868       split = find_split_point (&XEXP (x, 1), insn, false);
4869       if (split)
4870         return split;
4871       /* ... fall through ...  */
4872     case RTX_UNARY:
4873       /* Some machines have (and (shift ...) ...) insns.  If X is not
4874          an AND, but XEXP (X, 0) is, use it as our split point.  */
4875       if (GET_CODE (x) != AND && GET_CODE (XEXP (x, 0)) == AND)
4876         return &XEXP (x, 0);
4877
4878       split = find_split_point (&XEXP (x, 0), insn, false);
4879       if (split)
4880         return split;
4881       return loc;
4882
4883     default:
4884       /* Otherwise, we don't have a split point.  */
4885       return 0;
4886     }
4887 }
4888 \f
4889 /* Throughout X, replace FROM with TO, and return the result.
4890    The result is TO if X is FROM;
4891    otherwise the result is X, but its contents may have been modified.
4892    If they were modified, a record was made in undobuf so that
4893    undo_all will (among other things) return X to its original state.
4894
4895    If the number of changes necessary is too much to record to undo,
4896    the excess changes are not made, so the result is invalid.
4897    The changes already made can still be undone.
4898    undobuf.num_undo is incremented for such changes, so by testing that
4899    the caller can tell whether the result is valid.
4900
4901    `n_occurrences' is incremented each time FROM is replaced.
4902
4903    IN_DEST is nonzero if we are processing the SET_DEST of a SET.
4904
4905    UNIQUE_COPY is nonzero if each substitution must be unique.  We do this
4906    by copying if `n_occurrences' is nonzero.  */
4907
4908 static rtx
4909 subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
4910 {
4911   enum rtx_code code = GET_CODE (x);
4912   enum machine_mode op0_mode = VOIDmode;
4913   const char *fmt;
4914   int len, i;
4915   rtx new_rtx;
4916
4917 /* Two expressions are equal if they are identical copies of a shared
4918    RTX or if they are both registers with the same register number
4919    and mode.  */
4920
4921 #define COMBINE_RTX_EQUAL_P(X,Y)                        \
4922   ((X) == (Y)                                           \
4923    || (REG_P (X) && REG_P (Y)   \
4924        && REGNO (X) == REGNO (Y) && GET_MODE (X) == GET_MODE (Y)))
4925
4926   if (! in_dest && COMBINE_RTX_EQUAL_P (x, from))
4927     {
4928       n_occurrences++;
4929       return (unique_copy && n_occurrences > 1 ? copy_rtx (to) : to);
4930     }
4931
4932   /* If X and FROM are the same register but different modes, they
4933      will not have been seen as equal above.  However, the log links code
4934      will make a LOG_LINKS entry for that case.  If we do nothing, we
4935      will try to rerecognize our original insn and, when it succeeds,
4936      we will delete the feeding insn, which is incorrect.
4937
4938      So force this insn not to match in this (rare) case.  */
4939   if (! in_dest && code == REG && REG_P (from)
4940       && reg_overlap_mentioned_p (x, from))
4941     return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
4942
4943   /* If this is an object, we are done unless it is a MEM or LO_SUM, both
4944      of which may contain things that can be combined.  */
4945   if (code != MEM && code != LO_SUM && OBJECT_P (x))
4946     return x;
4947
4948   /* It is possible to have a subexpression appear twice in the insn.
4949      Suppose that FROM is a register that appears within TO.
4950      Then, after that subexpression has been scanned once by `subst',
4951      the second time it is scanned, TO may be found.  If we were
4952      to scan TO here, we would find FROM within it and create a
4953      self-referent rtl structure which is completely wrong.  */
4954   if (COMBINE_RTX_EQUAL_P (x, to))
4955     return to;
4956
4957   /* Parallel asm_operands need special attention because all of the
4958      inputs are shared across the arms.  Furthermore, unsharing the
4959      rtl results in recognition failures.  Failure to handle this case
4960      specially can result in circular rtl.
4961
4962      Solve this by doing a normal pass across the first entry of the
4963      parallel, and only processing the SET_DESTs of the subsequent
4964      entries.  Ug.  */
4965
4966   if (code == PARALLEL
4967       && GET_CODE (XVECEXP (x, 0, 0)) == SET
4968       && GET_CODE (SET_SRC (XVECEXP (x, 0, 0))) == ASM_OPERANDS)
4969     {
4970       new_rtx = subst (XVECEXP (x, 0, 0), from, to, 0, unique_copy);
4971
4972       /* If this substitution failed, this whole thing fails.  */
4973       if (GET_CODE (new_rtx) == CLOBBER
4974           && XEXP (new_rtx, 0) == const0_rtx)
4975         return new_rtx;
4976
4977       SUBST (XVECEXP (x, 0, 0), new_rtx);
4978
4979       for (i = XVECLEN (x, 0) - 1; i >= 1; i--)
4980         {
4981           rtx dest = SET_DEST (XVECEXP (x, 0, i));
4982
4983           if (!REG_P (dest)
4984               && GET_CODE (dest) != CC0
4985               && GET_CODE (dest) != PC)
4986             {
4987               new_rtx = subst (dest, from, to, 0, unique_copy);
4988
4989               /* If this substitution failed, this whole thing fails.  */
4990               if (GET_CODE (new_rtx) == CLOBBER
4991                   && XEXP (new_rtx, 0) == const0_rtx)
4992                 return new_rtx;
4993
4994               SUBST (SET_DEST (XVECEXP (x, 0, i)), new_rtx);
4995             }
4996         }
4997     }
4998   else
4999     {
5000       len = GET_RTX_LENGTH (code);
5001       fmt = GET_RTX_FORMAT (code);
5002
5003       /* We don't need to process a SET_DEST that is a register, CC0,
5004          or PC, so set up to skip this common case.  All other cases
5005          where we want to suppress replacing something inside a
5006          SET_SRC are handled via the IN_DEST operand.  */
5007       if (code == SET
5008           && (REG_P (SET_DEST (x))
5009               || GET_CODE (SET_DEST (x)) == CC0
5010               || GET_CODE (SET_DEST (x)) == PC))
5011         fmt = "ie";
5012
5013       /* Get the mode of operand 0 in case X is now a SIGN_EXTEND of a
5014          constant.  */
5015       if (fmt[0] == 'e')
5016         op0_mode = GET_MODE (XEXP (x, 0));
5017
5018       for (i = 0; i < len; i++)
5019         {
5020           if (fmt[i] == 'E')
5021             {
5022               int j;
5023               for (j = XVECLEN (x, i) - 1; j >= 0; j--)
5024                 {
5025                   if (COMBINE_RTX_EQUAL_P (XVECEXP (x, i, j), from))
5026                     {
5027                       new_rtx = (unique_copy && n_occurrences
5028                              ? copy_rtx (to) : to);
5029                       n_occurrences++;
5030                     }
5031                   else
5032                     {
5033                       new_rtx = subst (XVECEXP (x, i, j), from, to, 0,
5034                                    unique_copy);
5035
5036                       /* If this substitution failed, this whole thing
5037                          fails.  */
5038                       if (GET_CODE (new_rtx) == CLOBBER
5039                           && XEXP (new_rtx, 0) == const0_rtx)
5040                         return new_rtx;
5041                     }
5042
5043                   SUBST (XVECEXP (x, i, j), new_rtx);
5044                 }
5045             }
5046           else if (fmt[i] == 'e')
5047             {
5048               /* If this is a register being set, ignore it.  */
5049               new_rtx = XEXP (x, i);
5050               if (in_dest
5051                   && i == 0
5052                   && (((code == SUBREG || code == ZERO_EXTRACT)
5053                        && REG_P (new_rtx))
5054                       || code == STRICT_LOW_PART))
5055                 ;
5056
5057               else if (COMBINE_RTX_EQUAL_P (XEXP (x, i), from))
5058                 {
5059                   /* In general, don't install a subreg involving two
5060                      modes not tieable.  It can worsen register
5061                      allocation, and can even make invalid reload
5062                      insns, since the reg inside may need to be copied
5063                      from in the outside mode, and that may be invalid
5064                      if it is an fp reg copied in integer mode.
5065
5066                      We allow two exceptions to this: It is valid if
5067                      it is inside another SUBREG and the mode of that
5068                      SUBREG and the mode of the inside of TO is
5069                      tieable and it is valid if X is a SET that copies
5070                      FROM to CC0.  */
5071
5072                   if (GET_CODE (to) == SUBREG
5073                       && ! MODES_TIEABLE_P (GET_MODE (to),
5074                                             GET_MODE (SUBREG_REG (to)))
5075                       && ! (code == SUBREG
5076                             && MODES_TIEABLE_P (GET_MODE (x),
5077                                                 GET_MODE (SUBREG_REG (to))))
5078 #ifdef HAVE_cc0
5079                       && ! (code == SET && i == 1 && XEXP (x, 0) == cc0_rtx)
5080 #endif
5081                       )
5082                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
5083
5084 #ifdef CANNOT_CHANGE_MODE_CLASS
5085                   if (code == SUBREG
5086                       && REG_P (to)
5087                       && REGNO (to) < FIRST_PSEUDO_REGISTER
5088                       && REG_CANNOT_CHANGE_MODE_P (REGNO (to),
5089                                                    GET_MODE (to),
5090                                                    GET_MODE (x)))
5091                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
5092 #endif
5093
5094                   new_rtx = (unique_copy && n_occurrences ? copy_rtx (to) : to);
5095                   n_occurrences++;
5096                 }
5097               else
5098                 /* If we are in a SET_DEST, suppress most cases unless we
5099                    have gone inside a MEM, in which case we want to
5100                    simplify the address.  We assume here that things that
5101                    are actually part of the destination have their inner
5102                    parts in the first expression.  This is true for SUBREG,
5103                    STRICT_LOW_PART, and ZERO_EXTRACT, which are the only
5104                    things aside from REG and MEM that should appear in a
5105                    SET_DEST.  */
5106                 new_rtx = subst (XEXP (x, i), from, to,
5107                              (((in_dest
5108                                 && (code == SUBREG || code == STRICT_LOW_PART
5109                                     || code == ZERO_EXTRACT))
5110                                || code == SET)
5111                               && i == 0), unique_copy);
5112
5113               /* If we found that we will have to reject this combination,
5114                  indicate that by returning the CLOBBER ourselves, rather than
5115                  an expression containing it.  This will speed things up as
5116                  well as prevent accidents where two CLOBBERs are considered
5117                  to be equal, thus producing an incorrect simplification.  */
5118
5119               if (GET_CODE (new_rtx) == CLOBBER && XEXP (new_rtx, 0) == const0_rtx)
5120                 return new_rtx;
5121
5122               if (GET_CODE (x) == SUBREG
5123                   && (CONST_INT_P (new_rtx)
5124                       || GET_CODE (new_rtx) == CONST_DOUBLE))
5125                 {
5126                   enum machine_mode mode = GET_MODE (x);
5127
5128                   x = simplify_subreg (GET_MODE (x), new_rtx,
5129                                        GET_MODE (SUBREG_REG (x)),
5130                                        SUBREG_BYTE (x));
5131                   if (! x)
5132                     x = gen_rtx_CLOBBER (mode, const0_rtx);
5133                 }
5134               else if (CONST_INT_P (new_rtx)
5135                        && GET_CODE (x) == ZERO_EXTEND)
5136                 {
5137                   x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
5138                                                 new_rtx, GET_MODE (XEXP (x, 0)));
5139                   gcc_assert (x);
5140                 }
5141               else
5142                 SUBST (XEXP (x, i), new_rtx);
5143             }
5144         }
5145     }
5146
5147   /* Check if we are loading something from the constant pool via float
5148      extension; in this case we would undo compress_float_constant
5149      optimization and degenerate constant load to an immediate value.  */
5150   if (GET_CODE (x) == FLOAT_EXTEND
5151       && MEM_P (XEXP (x, 0))
5152       && MEM_READONLY_P (XEXP (x, 0)))
5153     {
5154       rtx tmp = avoid_constant_pool_reference (x);
5155       if (x != tmp)
5156         return x;
5157     }
5158
5159   /* Try to simplify X.  If the simplification changed the code, it is likely
5160      that further simplification will help, so loop, but limit the number
5161      of repetitions that will be performed.  */
5162
5163   for (i = 0; i < 4; i++)
5164     {
5165       /* If X is sufficiently simple, don't bother trying to do anything
5166          with it.  */
5167       if (code != CONST_INT && code != REG && code != CLOBBER)
5168         x = combine_simplify_rtx (x, op0_mode, in_dest);
5169
5170       if (GET_CODE (x) == code)
5171         break;
5172
5173       code = GET_CODE (x);
5174
5175       /* We no longer know the original mode of operand 0 since we
5176          have changed the form of X)  */
5177       op0_mode = VOIDmode;
5178     }
5179
5180   return x;
5181 }
5182 \f
5183 /* Simplify X, a piece of RTL.  We just operate on the expression at the
5184    outer level; call `subst' to simplify recursively.  Return the new
5185    expression.
5186
5187    OP0_MODE is the original mode of XEXP (x, 0).  IN_DEST is nonzero
5188    if we are inside a SET_DEST.  */
5189
5190 static rtx
5191 combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int in_dest)
5192 {
5193   enum rtx_code code = GET_CODE (x);
5194   enum machine_mode mode = GET_MODE (x);
5195   rtx temp;
5196   int i;
5197
5198   /* If this is a commutative operation, put a constant last and a complex
5199      expression first.  We don't need to do this for comparisons here.  */
5200   if (COMMUTATIVE_ARITH_P (x)
5201       && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
5202     {
5203       temp = XEXP (x, 0);
5204       SUBST (XEXP (x, 0), XEXP (x, 1));
5205       SUBST (XEXP (x, 1), temp);
5206     }
5207
5208   /* If this is a simple operation applied to an IF_THEN_ELSE, try
5209      applying it to the arms of the IF_THEN_ELSE.  This often simplifies
5210      things.  Check for cases where both arms are testing the same
5211      condition.
5212
5213      Don't do anything if all operands are very simple.  */
5214
5215   if ((BINARY_P (x)
5216        && ((!OBJECT_P (XEXP (x, 0))
5217             && ! (GET_CODE (XEXP (x, 0)) == SUBREG
5218                   && OBJECT_P (SUBREG_REG (XEXP (x, 0)))))
5219            || (!OBJECT_P (XEXP (x, 1))
5220                && ! (GET_CODE (XEXP (x, 1)) == SUBREG
5221                      && OBJECT_P (SUBREG_REG (XEXP (x, 1)))))))
5222       || (UNARY_P (x)
5223           && (!OBJECT_P (XEXP (x, 0))
5224                && ! (GET_CODE (XEXP (x, 0)) == SUBREG
5225                      && OBJECT_P (SUBREG_REG (XEXP (x, 0)))))))
5226     {
5227       rtx cond, true_rtx, false_rtx;
5228
5229       cond = if_then_else_cond (x, &true_rtx, &false_rtx);
5230       if (cond != 0
5231           /* If everything is a comparison, what we have is highly unlikely
5232              to be simpler, so don't use it.  */
5233           && ! (COMPARISON_P (x)
5234                 && (COMPARISON_P (true_rtx) || COMPARISON_P (false_rtx))))
5235         {
5236           rtx cop1 = const0_rtx;
5237           enum rtx_code cond_code = simplify_comparison (NE, &cond, &cop1);
5238
5239           if (cond_code == NE && COMPARISON_P (cond))
5240             return x;
5241
5242           /* Simplify the alternative arms; this may collapse the true and
5243              false arms to store-flag values.  Be careful to use copy_rtx
5244              here since true_rtx or false_rtx might share RTL with x as a
5245              result of the if_then_else_cond call above.  */
5246           true_rtx = subst (copy_rtx (true_rtx), pc_rtx, pc_rtx, 0, 0);
5247           false_rtx = subst (copy_rtx (false_rtx), pc_rtx, pc_rtx, 0, 0);
5248
5249           /* If true_rtx and false_rtx are not general_operands, an if_then_else
5250              is unlikely to be simpler.  */
5251           if (general_operand (true_rtx, VOIDmode)
5252               && general_operand (false_rtx, VOIDmode))
5253             {
5254               enum rtx_code reversed;
5255
5256               /* Restarting if we generate a store-flag expression will cause
5257                  us to loop.  Just drop through in this case.  */
5258
5259               /* If the result values are STORE_FLAG_VALUE and zero, we can
5260                  just make the comparison operation.  */
5261               if (true_rtx == const_true_rtx && false_rtx == const0_rtx)
5262                 x = simplify_gen_relational (cond_code, mode, VOIDmode,
5263                                              cond, cop1);
5264               else if (true_rtx == const0_rtx && false_rtx == const_true_rtx
5265                        && ((reversed = reversed_comparison_code_parts
5266                                         (cond_code, cond, cop1, NULL))
5267                            != UNKNOWN))
5268                 x = simplify_gen_relational (reversed, mode, VOIDmode,
5269                                              cond, cop1);
5270
5271               /* Likewise, we can make the negate of a comparison operation
5272                  if the result values are - STORE_FLAG_VALUE and zero.  */
5273               else if (CONST_INT_P (true_rtx)
5274                        && INTVAL (true_rtx) == - STORE_FLAG_VALUE
5275                        && false_rtx == const0_rtx)
5276                 x = simplify_gen_unary (NEG, mode,
5277                                         simplify_gen_relational (cond_code,
5278                                                                  mode, VOIDmode,
5279                                                                  cond, cop1),
5280                                         mode);
5281               else if (CONST_INT_P (false_rtx)
5282                        && INTVAL (false_rtx) == - STORE_FLAG_VALUE
5283                        && true_rtx == const0_rtx
5284                        && ((reversed = reversed_comparison_code_parts
5285                                         (cond_code, cond, cop1, NULL))
5286                            != UNKNOWN))
5287                 x = simplify_gen_unary (NEG, mode,
5288                                         simplify_gen_relational (reversed,
5289                                                                  mode, VOIDmode,
5290                                                                  cond, cop1),
5291                                         mode);
5292               else
5293                 return gen_rtx_IF_THEN_ELSE (mode,
5294                                              simplify_gen_relational (cond_code,
5295                                                                       mode,
5296                                                                       VOIDmode,
5297                                                                       cond,
5298                                                                       cop1),
5299                                              true_rtx, false_rtx);
5300
5301               code = GET_CODE (x);
5302               op0_mode = VOIDmode;
5303             }
5304         }
5305     }
5306
5307   /* Try to fold this expression in case we have constants that weren't
5308      present before.  */
5309   temp = 0;
5310   switch (GET_RTX_CLASS (code))
5311     {
5312     case RTX_UNARY:
5313       if (op0_mode == VOIDmode)
5314         op0_mode = GET_MODE (XEXP (x, 0));
5315       temp = simplify_unary_operation (code, mode, XEXP (x, 0), op0_mode);
5316       break;
5317     case RTX_COMPARE:
5318     case RTX_COMM_COMPARE:
5319       {
5320         enum machine_mode cmp_mode = GET_MODE (XEXP (x, 0));
5321         if (cmp_mode == VOIDmode)
5322           {
5323             cmp_mode = GET_MODE (XEXP (x, 1));
5324             if (cmp_mode == VOIDmode)
5325               cmp_mode = op0_mode;
5326           }
5327         temp = simplify_relational_operation (code, mode, cmp_mode,
5328                                               XEXP (x, 0), XEXP (x, 1));
5329       }
5330       break;
5331     case RTX_COMM_ARITH:
5332     case RTX_BIN_ARITH:
5333       temp = simplify_binary_operation (code, mode, XEXP (x, 0), XEXP (x, 1));
5334       break;
5335     case RTX_BITFIELD_OPS:
5336     case RTX_TERNARY:
5337       temp = simplify_ternary_operation (code, mode, op0_mode, XEXP (x, 0),
5338                                          XEXP (x, 1), XEXP (x, 2));
5339       break;
5340     default:
5341       break;
5342     }
5343
5344   if (temp)
5345     {
5346       x = temp;
5347       code = GET_CODE (temp);
5348       op0_mode = VOIDmode;
5349       mode = GET_MODE (temp);
5350     }
5351
5352   /* First see if we can apply the inverse distributive law.  */
5353   if (code == PLUS || code == MINUS
5354       || code == AND || code == IOR || code == XOR)
5355     {
5356       x = apply_distributive_law (x);
5357       code = GET_CODE (x);
5358       op0_mode = VOIDmode;
5359     }
5360
5361   /* If CODE is an associative operation not otherwise handled, see if we
5362      can associate some operands.  This can win if they are constants or
5363      if they are logically related (i.e. (a & b) & a).  */
5364   if ((code == PLUS || code == MINUS || code == MULT || code == DIV
5365        || code == AND || code == IOR || code == XOR
5366        || code == SMAX || code == SMIN || code == UMAX || code == UMIN)
5367       && ((INTEGRAL_MODE_P (mode) && code != DIV)
5368           || (flag_associative_math && FLOAT_MODE_P (mode))))
5369     {
5370       if (GET_CODE (XEXP (x, 0)) == code)
5371         {
5372           rtx other = XEXP (XEXP (x, 0), 0);
5373           rtx inner_op0 = XEXP (XEXP (x, 0), 1);
5374           rtx inner_op1 = XEXP (x, 1);
5375           rtx inner;
5376
5377           /* Make sure we pass the constant operand if any as the second
5378              one if this is a commutative operation.  */
5379           if (CONSTANT_P (inner_op0) && COMMUTATIVE_ARITH_P (x))
5380             {
5381               rtx tem = inner_op0;
5382               inner_op0 = inner_op1;
5383               inner_op1 = tem;
5384             }
5385           inner = simplify_binary_operation (code == MINUS ? PLUS
5386                                              : code == DIV ? MULT
5387                                              : code,
5388                                              mode, inner_op0, inner_op1);
5389
5390           /* For commutative operations, try the other pair if that one
5391              didn't simplify.  */
5392           if (inner == 0 && COMMUTATIVE_ARITH_P (x))
5393             {
5394               other = XEXP (XEXP (x, 0), 1);
5395               inner = simplify_binary_operation (code, mode,
5396                                                  XEXP (XEXP (x, 0), 0),
5397                                                  XEXP (x, 1));
5398             }
5399
5400           if (inner)
5401             return simplify_gen_binary (code, mode, other, inner);
5402         }
5403     }
5404
5405   /* A little bit of algebraic simplification here.  */
5406   switch (code)
5407     {
5408     case MEM:
5409       /* Ensure that our address has any ASHIFTs converted to MULT in case
5410          address-recognizing predicates are called later.  */
5411       temp = make_compound_operation (XEXP (x, 0), MEM);
5412       SUBST (XEXP (x, 0), temp);
5413       break;
5414
5415     case SUBREG:
5416       if (op0_mode == VOIDmode)
5417         op0_mode = GET_MODE (SUBREG_REG (x));
5418
5419       /* See if this can be moved to simplify_subreg.  */
5420       if (CONSTANT_P (SUBREG_REG (x))
5421           && subreg_lowpart_offset (mode, op0_mode) == SUBREG_BYTE (x)
5422              /* Don't call gen_lowpart if the inner mode
5423                 is VOIDmode and we cannot simplify it, as SUBREG without
5424                 inner mode is invalid.  */
5425           && (GET_MODE (SUBREG_REG (x)) != VOIDmode
5426               || gen_lowpart_common (mode, SUBREG_REG (x))))
5427         return gen_lowpart (mode, SUBREG_REG (x));
5428
5429       if (GET_MODE_CLASS (GET_MODE (SUBREG_REG (x))) == MODE_CC)
5430         break;
5431       {
5432         rtx temp;
5433         temp = simplify_subreg (mode, SUBREG_REG (x), op0_mode,
5434                                 SUBREG_BYTE (x));
5435         if (temp)
5436           return temp;
5437       }
5438
5439       /* Don't change the mode of the MEM if that would change the meaning
5440          of the address.  */
5441       if (MEM_P (SUBREG_REG (x))
5442           && (MEM_VOLATILE_P (SUBREG_REG (x))
5443               || mode_dependent_address_p (XEXP (SUBREG_REG (x), 0))))
5444         return gen_rtx_CLOBBER (mode, const0_rtx);
5445
5446       /* Note that we cannot do any narrowing for non-constants since
5447          we might have been counting on using the fact that some bits were
5448          zero.  We now do this in the SET.  */
5449
5450       break;
5451
5452     case NEG:
5453       temp = expand_compound_operation (XEXP (x, 0));
5454
5455       /* For C equal to the width of MODE minus 1, (neg (ashiftrt X C)) can be
5456          replaced by (lshiftrt X C).  This will convert
5457          (neg (sign_extract X 1 Y)) to (zero_extract X 1 Y).  */
5458
5459       if (GET_CODE (temp) == ASHIFTRT
5460           && CONST_INT_P (XEXP (temp, 1))
5461           && INTVAL (XEXP (temp, 1)) == GET_MODE_BITSIZE (mode) - 1)
5462         return simplify_shift_const (NULL_RTX, LSHIFTRT, mode, XEXP (temp, 0),
5463                                      INTVAL (XEXP (temp, 1)));
5464
5465       /* If X has only a single bit that might be nonzero, say, bit I, convert
5466          (neg X) to (ashiftrt (ashift X C-I) C-I) where C is the bitsize of
5467          MODE minus 1.  This will convert (neg (zero_extract X 1 Y)) to
5468          (sign_extract X 1 Y).  But only do this if TEMP isn't a register
5469          or a SUBREG of one since we'd be making the expression more
5470          complex if it was just a register.  */
5471
5472       if (!REG_P (temp)
5473           && ! (GET_CODE (temp) == SUBREG
5474                 && REG_P (SUBREG_REG (temp)))
5475           && (i = exact_log2 (nonzero_bits (temp, mode))) >= 0)
5476         {
5477           rtx temp1 = simplify_shift_const
5478             (NULL_RTX, ASHIFTRT, mode,
5479              simplify_shift_const (NULL_RTX, ASHIFT, mode, temp,
5480                                    GET_MODE_BITSIZE (mode) - 1 - i),
5481              GET_MODE_BITSIZE (mode) - 1 - i);
5482
5483           /* If all we did was surround TEMP with the two shifts, we
5484              haven't improved anything, so don't use it.  Otherwise,
5485              we are better off with TEMP1.  */
5486           if (GET_CODE (temp1) != ASHIFTRT
5487               || GET_CODE (XEXP (temp1, 0)) != ASHIFT
5488               || XEXP (XEXP (temp1, 0), 0) != temp)
5489             return temp1;
5490         }
5491       break;
5492
5493     case TRUNCATE:
5494       /* We can't handle truncation to a partial integer mode here
5495          because we don't know the real bitsize of the partial
5496          integer mode.  */
5497       if (GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
5498         break;
5499
5500       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
5501         SUBST (XEXP (x, 0),
5502                force_to_mode (XEXP (x, 0), GET_MODE (XEXP (x, 0)),
5503                               GET_MODE_MASK (mode), 0));
5504
5505       /* We can truncate a constant value and return it.  */
5506       if (CONST_INT_P (XEXP (x, 0)))
5507         return gen_int_mode (INTVAL (XEXP (x, 0)), mode);
5508
5509       /* Similarly to what we do in simplify-rtx.c, a truncate of a register
5510          whose value is a comparison can be replaced with a subreg if
5511          STORE_FLAG_VALUE permits.  */
5512       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5513           && (STORE_FLAG_VALUE & ~GET_MODE_MASK (mode)) == 0
5514           && (temp = get_last_value (XEXP (x, 0)))
5515           && COMPARISON_P (temp))
5516         return gen_lowpart (mode, XEXP (x, 0));
5517       break;
5518
5519     case CONST:
5520       /* (const (const X)) can become (const X).  Do it this way rather than
5521          returning the inner CONST since CONST can be shared with a
5522          REG_EQUAL note.  */
5523       if (GET_CODE (XEXP (x, 0)) == CONST)
5524         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
5525       break;
5526
5527 #ifdef HAVE_lo_sum
5528     case LO_SUM:
5529       /* Convert (lo_sum (high FOO) FOO) to FOO.  This is necessary so we
5530          can add in an offset.  find_split_point will split this address up
5531          again if it doesn't match.  */
5532       if (GET_CODE (XEXP (x, 0)) == HIGH
5533           && rtx_equal_p (XEXP (XEXP (x, 0), 0), XEXP (x, 1)))
5534         return XEXP (x, 1);
5535       break;
5536 #endif
5537
5538     case PLUS:
5539       /* (plus (xor (and <foo> (const_int pow2 - 1)) <c>) <-c>)
5540          when c is (const_int (pow2 + 1) / 2) is a sign extension of a
5541          bit-field and can be replaced by either a sign_extend or a
5542          sign_extract.  The `and' may be a zero_extend and the two
5543          <c>, -<c> constants may be reversed.  */
5544       if (GET_CODE (XEXP (x, 0)) == XOR
5545           && CONST_INT_P (XEXP (x, 1))
5546           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
5547           && INTVAL (XEXP (x, 1)) == -INTVAL (XEXP (XEXP (x, 0), 1))
5548           && ((i = exact_log2 (UINTVAL (XEXP (XEXP (x, 0), 1)))) >= 0
5549               || (i = exact_log2 (UINTVAL (XEXP (x, 1)))) >= 0)
5550           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5551           && ((GET_CODE (XEXP (XEXP (x, 0), 0)) == AND
5552                && CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 0), 1))
5553                && (UINTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1))
5554                    == ((unsigned HOST_WIDE_INT) 1 << (i + 1)) - 1))
5555               || (GET_CODE (XEXP (XEXP (x, 0), 0)) == ZERO_EXTEND
5556                   && (GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (XEXP (x, 0), 0), 0)))
5557                       == (unsigned int) i + 1))))
5558         return simplify_shift_const
5559           (NULL_RTX, ASHIFTRT, mode,
5560            simplify_shift_const (NULL_RTX, ASHIFT, mode,
5561                                  XEXP (XEXP (XEXP (x, 0), 0), 0),
5562                                  GET_MODE_BITSIZE (mode) - (i + 1)),
5563            GET_MODE_BITSIZE (mode) - (i + 1));
5564
5565       /* If only the low-order bit of X is possibly nonzero, (plus x -1)
5566          can become (ashiftrt (ashift (xor x 1) C) C) where C is
5567          the bitsize of the mode - 1.  This allows simplification of
5568          "a = (b & 8) == 0;"  */
5569       if (XEXP (x, 1) == constm1_rtx
5570           && !REG_P (XEXP (x, 0))
5571           && ! (GET_CODE (XEXP (x, 0)) == SUBREG
5572                 && REG_P (SUBREG_REG (XEXP (x, 0))))
5573           && nonzero_bits (XEXP (x, 0), mode) == 1)
5574         return simplify_shift_const (NULL_RTX, ASHIFTRT, mode,
5575            simplify_shift_const (NULL_RTX, ASHIFT, mode,
5576                                  gen_rtx_XOR (mode, XEXP (x, 0), const1_rtx),
5577                                  GET_MODE_BITSIZE (mode) - 1),
5578            GET_MODE_BITSIZE (mode) - 1);
5579
5580       /* If we are adding two things that have no bits in common, convert
5581          the addition into an IOR.  This will often be further simplified,
5582          for example in cases like ((a & 1) + (a & 2)), which can
5583          become a & 3.  */
5584
5585       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5586           && (nonzero_bits (XEXP (x, 0), mode)
5587               & nonzero_bits (XEXP (x, 1), mode)) == 0)
5588         {
5589           /* Try to simplify the expression further.  */
5590           rtx tor = simplify_gen_binary (IOR, mode, XEXP (x, 0), XEXP (x, 1));
5591           temp = combine_simplify_rtx (tor, mode, in_dest);
5592
5593           /* If we could, great.  If not, do not go ahead with the IOR
5594              replacement, since PLUS appears in many special purpose
5595              address arithmetic instructions.  */
5596           if (GET_CODE (temp) != CLOBBER && temp != tor)
5597             return temp;
5598         }
5599       break;
5600
5601     case MINUS:
5602       /* (minus <foo> (and <foo> (const_int -pow2))) becomes
5603          (and <foo> (const_int pow2-1))  */
5604       if (GET_CODE (XEXP (x, 1)) == AND
5605           && CONST_INT_P (XEXP (XEXP (x, 1), 1))
5606           && exact_log2 (-UINTVAL (XEXP (XEXP (x, 1), 1))) >= 0
5607           && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
5608         return simplify_and_const_int (NULL_RTX, mode, XEXP (x, 0),
5609                                        -INTVAL (XEXP (XEXP (x, 1), 1)) - 1);
5610       break;
5611
5612     case MULT:
5613       /* If we have (mult (plus A B) C), apply the distributive law and then
5614          the inverse distributive law to see if things simplify.  This
5615          occurs mostly in addresses, often when unrolling loops.  */
5616
5617       if (GET_CODE (XEXP (x, 0)) == PLUS)
5618         {
5619           rtx result = distribute_and_simplify_rtx (x, 0);
5620           if (result)
5621             return result;
5622         }
5623
5624       /* Try simplify a*(b/c) as (a*b)/c.  */
5625       if (FLOAT_MODE_P (mode) && flag_associative_math
5626           && GET_CODE (XEXP (x, 0)) == DIV)
5627         {
5628           rtx tem = simplify_binary_operation (MULT, mode,
5629                                                XEXP (XEXP (x, 0), 0),
5630                                                XEXP (x, 1));
5631           if (tem)
5632             return simplify_gen_binary (DIV, mode, tem, XEXP (XEXP (x, 0), 1));
5633         }
5634       break;
5635
5636     case UDIV:
5637       /* If this is a divide by a power of two, treat it as a shift if
5638          its first operand is a shift.  */
5639       if (CONST_INT_P (XEXP (x, 1))
5640           && (i = exact_log2 (UINTVAL (XEXP (x, 1)))) >= 0
5641           && (GET_CODE (XEXP (x, 0)) == ASHIFT
5642               || GET_CODE (XEXP (x, 0)) == LSHIFTRT
5643               || GET_CODE (XEXP (x, 0)) == ASHIFTRT
5644               || GET_CODE (XEXP (x, 0)) == ROTATE
5645               || GET_CODE (XEXP (x, 0)) == ROTATERT))
5646         return simplify_shift_const (NULL_RTX, LSHIFTRT, mode, XEXP (x, 0), i);
5647       break;
5648
5649     case EQ:  case NE:
5650     case GT:  case GTU:  case GE:  case GEU:
5651     case LT:  case LTU:  case LE:  case LEU:
5652     case UNEQ:  case LTGT:
5653     case UNGT:  case UNGE:
5654     case UNLT:  case UNLE:
5655     case UNORDERED: case ORDERED:
5656       /* If the first operand is a condition code, we can't do anything
5657          with it.  */
5658       if (GET_CODE (XEXP (x, 0)) == COMPARE
5659           || (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) != MODE_CC
5660               && ! CC0_P (XEXP (x, 0))))
5661         {
5662           rtx op0 = XEXP (x, 0);
5663           rtx op1 = XEXP (x, 1);
5664           enum rtx_code new_code;
5665
5666           if (GET_CODE (op0) == COMPARE)
5667             op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
5668
5669           /* Simplify our comparison, if possible.  */
5670           new_code = simplify_comparison (code, &op0, &op1);
5671
5672           /* If STORE_FLAG_VALUE is 1, we can convert (ne x 0) to simply X
5673              if only the low-order bit is possibly nonzero in X (such as when
5674              X is a ZERO_EXTRACT of one bit).  Similarly, we can convert EQ to
5675              (xor X 1) or (minus 1 X); we use the former.  Finally, if X is
5676              known to be either 0 or -1, NE becomes a NEG and EQ becomes
5677              (plus X 1).
5678
5679              Remove any ZERO_EXTRACT we made when thinking this was a
5680              comparison.  It may now be simpler to use, e.g., an AND.  If a
5681              ZERO_EXTRACT is indeed appropriate, it will be placed back by
5682              the call to make_compound_operation in the SET case.  */
5683
5684           if (STORE_FLAG_VALUE == 1
5685               && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5686               && op1 == const0_rtx
5687               && mode == GET_MODE (op0)
5688               && nonzero_bits (op0, mode) == 1)
5689             return gen_lowpart (mode,
5690                                 expand_compound_operation (op0));
5691
5692           else if (STORE_FLAG_VALUE == 1
5693                    && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5694                    && op1 == const0_rtx
5695                    && mode == GET_MODE (op0)
5696                    && (num_sign_bit_copies (op0, mode)
5697                        == GET_MODE_BITSIZE (mode)))
5698             {
5699               op0 = expand_compound_operation (op0);
5700               return simplify_gen_unary (NEG, mode,
5701                                          gen_lowpart (mode, op0),
5702                                          mode);
5703             }
5704
5705           else if (STORE_FLAG_VALUE == 1
5706                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5707                    && op1 == const0_rtx
5708                    && mode == GET_MODE (op0)
5709                    && nonzero_bits (op0, mode) == 1)
5710             {
5711               op0 = expand_compound_operation (op0);
5712               return simplify_gen_binary (XOR, mode,
5713                                           gen_lowpart (mode, op0),
5714                                           const1_rtx);
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                    && (num_sign_bit_copies (op0, mode)
5722                        == GET_MODE_BITSIZE (mode)))
5723             {
5724               op0 = expand_compound_operation (op0);
5725               return plus_constant (gen_lowpart (mode, op0), 1);
5726             }
5727
5728           /* If STORE_FLAG_VALUE is -1, we have cases similar to
5729              those above.  */
5730           if (STORE_FLAG_VALUE == -1
5731               && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5732               && op1 == const0_rtx
5733               && (num_sign_bit_copies (op0, mode)
5734                   == GET_MODE_BITSIZE (mode)))
5735             return gen_lowpart (mode,
5736                                 expand_compound_operation (op0));
5737
5738           else if (STORE_FLAG_VALUE == -1
5739                    && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5740                    && op1 == const0_rtx
5741                    && mode == GET_MODE (op0)
5742                    && nonzero_bits (op0, mode) == 1)
5743             {
5744               op0 = expand_compound_operation (op0);
5745               return simplify_gen_unary (NEG, mode,
5746                                          gen_lowpart (mode, op0),
5747                                          mode);
5748             }
5749
5750           else if (STORE_FLAG_VALUE == -1
5751                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5752                    && op1 == const0_rtx
5753                    && mode == GET_MODE (op0)
5754                    && (num_sign_bit_copies (op0, mode)
5755                        == GET_MODE_BITSIZE (mode)))
5756             {
5757               op0 = expand_compound_operation (op0);
5758               return simplify_gen_unary (NOT, mode,
5759                                          gen_lowpart (mode, op0),
5760                                          mode);
5761             }
5762
5763           /* If X is 0/1, (eq X 0) is X-1.  */
5764           else if (STORE_FLAG_VALUE == -1
5765                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5766                    && op1 == const0_rtx
5767                    && mode == GET_MODE (op0)
5768                    && nonzero_bits (op0, mode) == 1)
5769             {
5770               op0 = expand_compound_operation (op0);
5771               return plus_constant (gen_lowpart (mode, op0), -1);
5772             }
5773
5774           /* If STORE_FLAG_VALUE says to just test the sign bit and X has just
5775              one bit that might be nonzero, we can convert (ne x 0) to
5776              (ashift x c) where C puts the bit in the sign bit.  Remove any
5777              AND with STORE_FLAG_VALUE when we are done, since we are only
5778              going to test the sign bit.  */
5779           if (new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5780               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5781               && ((STORE_FLAG_VALUE & GET_MODE_MASK (mode))
5782                   == (unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (mode) - 1))
5783               && op1 == const0_rtx
5784               && mode == GET_MODE (op0)
5785               && (i = exact_log2 (nonzero_bits (op0, mode))) >= 0)
5786             {
5787               x = simplify_shift_const (NULL_RTX, ASHIFT, mode,
5788                                         expand_compound_operation (op0),
5789                                         GET_MODE_BITSIZE (mode) - 1 - i);
5790               if (GET_CODE (x) == AND && XEXP (x, 1) == const_true_rtx)
5791                 return XEXP (x, 0);
5792               else
5793                 return x;
5794             }
5795
5796           /* If the code changed, return a whole new comparison.  */
5797           if (new_code != code)
5798             return gen_rtx_fmt_ee (new_code, mode, op0, op1);
5799
5800           /* Otherwise, keep this operation, but maybe change its operands.
5801              This also converts (ne (compare FOO BAR) 0) to (ne FOO BAR).  */
5802           SUBST (XEXP (x, 0), op0);
5803           SUBST (XEXP (x, 1), op1);
5804         }
5805       break;
5806
5807     case IF_THEN_ELSE:
5808       return simplify_if_then_else (x);
5809
5810     case ZERO_EXTRACT:
5811     case SIGN_EXTRACT:
5812     case ZERO_EXTEND:
5813     case SIGN_EXTEND:
5814       /* If we are processing SET_DEST, we are done.  */
5815       if (in_dest)
5816         return x;
5817
5818       return expand_compound_operation (x);
5819
5820     case SET:
5821       return simplify_set (x);
5822
5823     case AND:
5824     case IOR:
5825       return simplify_logical (x);
5826
5827     case ASHIFT:
5828     case LSHIFTRT:
5829     case ASHIFTRT:
5830     case ROTATE:
5831     case ROTATERT:
5832       /* If this is a shift by a constant amount, simplify it.  */
5833       if (CONST_INT_P (XEXP (x, 1)))
5834         return simplify_shift_const (x, code, mode, XEXP (x, 0),
5835                                      INTVAL (XEXP (x, 1)));
5836
5837       else if (SHIFT_COUNT_TRUNCATED && !REG_P (XEXP (x, 1)))
5838         SUBST (XEXP (x, 1),
5839                force_to_mode (XEXP (x, 1), GET_MODE (XEXP (x, 1)),
5840                               ((unsigned HOST_WIDE_INT) 1
5841                                << exact_log2 (GET_MODE_BITSIZE (GET_MODE (x))))
5842                               - 1,
5843                               0));
5844       break;
5845
5846     default:
5847       break;
5848     }
5849
5850   return x;
5851 }
5852 \f
5853 /* Simplify X, an IF_THEN_ELSE expression.  Return the new expression.  */
5854
5855 static rtx
5856 simplify_if_then_else (rtx x)
5857 {
5858   enum machine_mode mode = GET_MODE (x);
5859   rtx cond = XEXP (x, 0);
5860   rtx true_rtx = XEXP (x, 1);
5861   rtx false_rtx = XEXP (x, 2);
5862   enum rtx_code true_code = GET_CODE (cond);
5863   int comparison_p = COMPARISON_P (cond);
5864   rtx temp;
5865   int i;
5866   enum rtx_code false_code;
5867   rtx reversed;
5868
5869   /* Simplify storing of the truth value.  */
5870   if (comparison_p && true_rtx == const_true_rtx && false_rtx == const0_rtx)
5871     return simplify_gen_relational (true_code, mode, VOIDmode,
5872                                     XEXP (cond, 0), XEXP (cond, 1));
5873
5874   /* Also when the truth value has to be reversed.  */
5875   if (comparison_p
5876       && true_rtx == const0_rtx && false_rtx == const_true_rtx
5877       && (reversed = reversed_comparison (cond, mode)))
5878     return reversed;
5879
5880   /* Sometimes we can simplify the arm of an IF_THEN_ELSE if a register used
5881      in it is being compared against certain values.  Get the true and false
5882      comparisons and see if that says anything about the value of each arm.  */
5883
5884   if (comparison_p
5885       && ((false_code = reversed_comparison_code (cond, NULL))
5886           != UNKNOWN)
5887       && REG_P (XEXP (cond, 0)))
5888     {
5889       HOST_WIDE_INT nzb;
5890       rtx from = XEXP (cond, 0);
5891       rtx true_val = XEXP (cond, 1);
5892       rtx false_val = true_val;
5893       int swapped = 0;
5894
5895       /* If FALSE_CODE is EQ, swap the codes and arms.  */
5896
5897       if (false_code == EQ)
5898         {
5899           swapped = 1, true_code = EQ, false_code = NE;
5900           temp = true_rtx, true_rtx = false_rtx, false_rtx = temp;
5901         }
5902
5903       /* If we are comparing against zero and the expression being tested has
5904          only a single bit that might be nonzero, that is its value when it is
5905          not equal to zero.  Similarly if it is known to be -1 or 0.  */
5906
5907       if (true_code == EQ && true_val == const0_rtx
5908           && exact_log2 (nzb = nonzero_bits (from, GET_MODE (from))) >= 0)
5909         {
5910           false_code = EQ;
5911           false_val = GEN_INT (trunc_int_for_mode (nzb, GET_MODE (from)));
5912         }
5913       else if (true_code == EQ && true_val == const0_rtx
5914                && (num_sign_bit_copies (from, GET_MODE (from))
5915                    == GET_MODE_BITSIZE (GET_MODE (from))))
5916         {
5917           false_code = EQ;
5918           false_val = constm1_rtx;
5919         }
5920
5921       /* Now simplify an arm if we know the value of the register in the
5922          branch and it is used in the arm.  Be careful due to the potential
5923          of locally-shared RTL.  */
5924
5925       if (reg_mentioned_p (from, true_rtx))
5926         true_rtx = subst (known_cond (copy_rtx (true_rtx), true_code,
5927                                       from, true_val),
5928                       pc_rtx, pc_rtx, 0, 0);
5929       if (reg_mentioned_p (from, false_rtx))
5930         false_rtx = subst (known_cond (copy_rtx (false_rtx), false_code,
5931                                    from, false_val),
5932                        pc_rtx, pc_rtx, 0, 0);
5933
5934       SUBST (XEXP (x, 1), swapped ? false_rtx : true_rtx);
5935       SUBST (XEXP (x, 2), swapped ? true_rtx : false_rtx);
5936
5937       true_rtx = XEXP (x, 1);
5938       false_rtx = XEXP (x, 2);
5939       true_code = GET_CODE (cond);
5940     }
5941
5942   /* If we have (if_then_else FOO (pc) (label_ref BAR)) and FOO can be
5943      reversed, do so to avoid needing two sets of patterns for
5944      subtract-and-branch insns.  Similarly if we have a constant in the true
5945      arm, the false arm is the same as the first operand of the comparison, or
5946      the false arm is more complicated than the true arm.  */
5947
5948   if (comparison_p
5949       && reversed_comparison_code (cond, NULL) != UNKNOWN
5950       && (true_rtx == pc_rtx
5951           || (CONSTANT_P (true_rtx)
5952               && !CONST_INT_P (false_rtx) && false_rtx != pc_rtx)
5953           || true_rtx == const0_rtx
5954           || (OBJECT_P (true_rtx) && !OBJECT_P (false_rtx))
5955           || (GET_CODE (true_rtx) == SUBREG && OBJECT_P (SUBREG_REG (true_rtx))
5956               && !OBJECT_P (false_rtx))
5957           || reg_mentioned_p (true_rtx, false_rtx)
5958           || rtx_equal_p (false_rtx, XEXP (cond, 0))))
5959     {
5960       true_code = reversed_comparison_code (cond, NULL);
5961       SUBST (XEXP (x, 0), reversed_comparison (cond, GET_MODE (cond)));
5962       SUBST (XEXP (x, 1), false_rtx);
5963       SUBST (XEXP (x, 2), true_rtx);
5964
5965       temp = true_rtx, true_rtx = false_rtx, false_rtx = temp;
5966       cond = XEXP (x, 0);
5967
5968       /* It is possible that the conditional has been simplified out.  */
5969       true_code = GET_CODE (cond);
5970       comparison_p = COMPARISON_P (cond);
5971     }
5972
5973   /* If the two arms are identical, we don't need the comparison.  */
5974
5975   if (rtx_equal_p (true_rtx, false_rtx) && ! side_effects_p (cond))
5976     return true_rtx;
5977
5978   /* Convert a == b ? b : a to "a".  */
5979   if (true_code == EQ && ! side_effects_p (cond)
5980       && !HONOR_NANS (mode)
5981       && rtx_equal_p (XEXP (cond, 0), false_rtx)
5982       && rtx_equal_p (XEXP (cond, 1), true_rtx))
5983     return false_rtx;
5984   else if (true_code == NE && ! side_effects_p (cond)
5985            && !HONOR_NANS (mode)
5986            && rtx_equal_p (XEXP (cond, 0), true_rtx)
5987            && rtx_equal_p (XEXP (cond, 1), false_rtx))
5988     return true_rtx;
5989
5990   /* Look for cases where we have (abs x) or (neg (abs X)).  */
5991
5992   if (GET_MODE_CLASS (mode) == MODE_INT
5993       && comparison_p
5994       && XEXP (cond, 1) == const0_rtx
5995       && GET_CODE (false_rtx) == NEG
5996       && rtx_equal_p (true_rtx, XEXP (false_rtx, 0))
5997       && rtx_equal_p (true_rtx, XEXP (cond, 0))
5998       && ! side_effects_p (true_rtx))
5999     switch (true_code)
6000       {
6001       case GT:
6002       case GE:
6003         return simplify_gen_unary (ABS, mode, true_rtx, mode);
6004       case LT:
6005       case LE:
6006         return
6007           simplify_gen_unary (NEG, mode,
6008                               simplify_gen_unary (ABS, mode, true_rtx, mode),
6009                               mode);
6010       default:
6011         break;
6012       }
6013
6014   /* Look for MIN or MAX.  */
6015
6016   if ((! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations)
6017       && comparison_p
6018       && rtx_equal_p (XEXP (cond, 0), true_rtx)
6019       && rtx_equal_p (XEXP (cond, 1), false_rtx)
6020       && ! side_effects_p (cond))
6021     switch (true_code)
6022       {
6023       case GE:
6024       case GT:
6025         return simplify_gen_binary (SMAX, mode, true_rtx, false_rtx);
6026       case LE:
6027       case LT:
6028         return simplify_gen_binary (SMIN, mode, true_rtx, false_rtx);
6029       case GEU:
6030       case GTU:
6031         return simplify_gen_binary (UMAX, mode, true_rtx, false_rtx);
6032       case LEU:
6033       case LTU:
6034         return simplify_gen_binary (UMIN, mode, true_rtx, false_rtx);
6035       default:
6036         break;
6037       }
6038
6039   /* If we have (if_then_else COND (OP Z C1) Z) and OP is an identity when its
6040      second operand is zero, this can be done as (OP Z (mult COND C2)) where
6041      C2 = C1 * STORE_FLAG_VALUE. Similarly if OP has an outer ZERO_EXTEND or
6042      SIGN_EXTEND as long as Z is already extended (so we don't destroy it).
6043      We can do this kind of thing in some cases when STORE_FLAG_VALUE is
6044      neither 1 or -1, but it isn't worth checking for.  */
6045
6046   if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
6047       && comparison_p
6048       && GET_MODE_CLASS (mode) == MODE_INT
6049       && ! side_effects_p (x))
6050     {
6051       rtx t = make_compound_operation (true_rtx, SET);
6052       rtx f = make_compound_operation (false_rtx, SET);
6053       rtx cond_op0 = XEXP (cond, 0);
6054       rtx cond_op1 = XEXP (cond, 1);
6055       enum rtx_code op = UNKNOWN, extend_op = UNKNOWN;
6056       enum machine_mode m = mode;
6057       rtx z = 0, c1 = NULL_RTX;
6058
6059       if ((GET_CODE (t) == PLUS || GET_CODE (t) == MINUS
6060            || GET_CODE (t) == IOR || GET_CODE (t) == XOR
6061            || GET_CODE (t) == ASHIFT
6062            || GET_CODE (t) == LSHIFTRT || GET_CODE (t) == ASHIFTRT)
6063           && rtx_equal_p (XEXP (t, 0), f))
6064         c1 = XEXP (t, 1), op = GET_CODE (t), z = f;
6065
6066       /* If an identity-zero op is commutative, check whether there
6067          would be a match if we swapped the operands.  */
6068       else if ((GET_CODE (t) == PLUS || GET_CODE (t) == IOR
6069                 || GET_CODE (t) == XOR)
6070                && rtx_equal_p (XEXP (t, 1), f))
6071         c1 = XEXP (t, 0), op = GET_CODE (t), z = f;
6072       else if (GET_CODE (t) == SIGN_EXTEND
6073                && (GET_CODE (XEXP (t, 0)) == PLUS
6074                    || GET_CODE (XEXP (t, 0)) == MINUS
6075                    || GET_CODE (XEXP (t, 0)) == IOR
6076                    || GET_CODE (XEXP (t, 0)) == XOR
6077                    || GET_CODE (XEXP (t, 0)) == ASHIFT
6078                    || GET_CODE (XEXP (t, 0)) == LSHIFTRT
6079                    || GET_CODE (XEXP (t, 0)) == ASHIFTRT)
6080                && GET_CODE (XEXP (XEXP (t, 0), 0)) == SUBREG
6081                && subreg_lowpart_p (XEXP (XEXP (t, 0), 0))
6082                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 0)), f)
6083                && (num_sign_bit_copies (f, GET_MODE (f))
6084                    > (unsigned int)
6085                      (GET_MODE_BITSIZE (mode)
6086                       - GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (t, 0), 0))))))
6087         {
6088           c1 = XEXP (XEXP (t, 0), 1); z = f; op = GET_CODE (XEXP (t, 0));
6089           extend_op = SIGN_EXTEND;
6090           m = GET_MODE (XEXP (t, 0));
6091         }
6092       else if (GET_CODE (t) == SIGN_EXTEND
6093                && (GET_CODE (XEXP (t, 0)) == PLUS
6094                    || GET_CODE (XEXP (t, 0)) == IOR
6095                    || GET_CODE (XEXP (t, 0)) == XOR)
6096                && GET_CODE (XEXP (XEXP (t, 0), 1)) == SUBREG
6097                && subreg_lowpart_p (XEXP (XEXP (t, 0), 1))
6098                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 1)), f)
6099                && (num_sign_bit_copies (f, GET_MODE (f))
6100                    > (unsigned int)
6101                      (GET_MODE_BITSIZE (mode)
6102                       - GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (t, 0), 1))))))
6103         {
6104           c1 = XEXP (XEXP (t, 0), 0); z = f; op = GET_CODE (XEXP (t, 0));
6105           extend_op = SIGN_EXTEND;
6106           m = GET_MODE (XEXP (t, 0));
6107         }
6108       else if (GET_CODE (t) == ZERO_EXTEND
6109                && (GET_CODE (XEXP (t, 0)) == PLUS
6110                    || GET_CODE (XEXP (t, 0)) == MINUS
6111                    || GET_CODE (XEXP (t, 0)) == IOR
6112                    || GET_CODE (XEXP (t, 0)) == XOR
6113                    || GET_CODE (XEXP (t, 0)) == ASHIFT
6114                    || GET_CODE (XEXP (t, 0)) == LSHIFTRT
6115                    || GET_CODE (XEXP (t, 0)) == ASHIFTRT)
6116                && GET_CODE (XEXP (XEXP (t, 0), 0)) == SUBREG
6117                && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
6118                && subreg_lowpart_p (XEXP (XEXP (t, 0), 0))
6119                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 0)), f)
6120                && ((nonzero_bits (f, GET_MODE (f))
6121                     & ~GET_MODE_MASK (GET_MODE (XEXP (XEXP (t, 0), 0))))
6122                    == 0))
6123         {
6124           c1 = XEXP (XEXP (t, 0), 1); z = f; op = GET_CODE (XEXP (t, 0));
6125           extend_op = ZERO_EXTEND;
6126           m = GET_MODE (XEXP (t, 0));
6127         }
6128       else if (GET_CODE (t) == ZERO_EXTEND
6129                && (GET_CODE (XEXP (t, 0)) == PLUS
6130                    || GET_CODE (XEXP (t, 0)) == IOR
6131                    || GET_CODE (XEXP (t, 0)) == XOR)
6132                && GET_CODE (XEXP (XEXP (t, 0), 1)) == SUBREG
6133                && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
6134                && subreg_lowpart_p (XEXP (XEXP (t, 0), 1))
6135                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 1)), f)
6136                && ((nonzero_bits (f, GET_MODE (f))
6137                     & ~GET_MODE_MASK (GET_MODE (XEXP (XEXP (t, 0), 1))))
6138                    == 0))
6139         {
6140           c1 = XEXP (XEXP (t, 0), 0); z = f; op = GET_CODE (XEXP (t, 0));
6141           extend_op = ZERO_EXTEND;
6142           m = GET_MODE (XEXP (t, 0));
6143         }
6144
6145       if (z)
6146         {
6147           temp = subst (simplify_gen_relational (true_code, m, VOIDmode,
6148                                                  cond_op0, cond_op1),
6149                         pc_rtx, pc_rtx, 0, 0);
6150           temp = simplify_gen_binary (MULT, m, temp,
6151                                       simplify_gen_binary (MULT, m, c1,
6152                                                            const_true_rtx));
6153           temp = subst (temp, pc_rtx, pc_rtx, 0, 0);
6154           temp = simplify_gen_binary (op, m, gen_lowpart (m, z), temp);
6155
6156           if (extend_op != UNKNOWN)
6157             temp = simplify_gen_unary (extend_op, mode, temp, m);
6158
6159           return temp;
6160         }
6161     }
6162
6163   /* If we have (if_then_else (ne A 0) C1 0) and either A is known to be 0 or
6164      1 and C1 is a single bit or A is known to be 0 or -1 and C1 is the
6165      negation of a single bit, we can convert this operation to a shift.  We
6166      can actually do this more generally, but it doesn't seem worth it.  */
6167
6168   if (true_code == NE && XEXP (cond, 1) == const0_rtx
6169       && false_rtx == const0_rtx && CONST_INT_P (true_rtx)
6170       && ((1 == nonzero_bits (XEXP (cond, 0), mode)
6171            && (i = exact_log2 (UINTVAL (true_rtx))) >= 0)
6172           || ((num_sign_bit_copies (XEXP (cond, 0), mode)
6173                == GET_MODE_BITSIZE (mode))
6174               && (i = exact_log2 (-UINTVAL (true_rtx))) >= 0)))
6175     return
6176       simplify_shift_const (NULL_RTX, ASHIFT, mode,
6177                             gen_lowpart (mode, XEXP (cond, 0)), i);
6178
6179   /* (IF_THEN_ELSE (NE REG 0) (0) (8)) is REG for nonzero_bits (REG) == 8.  */
6180   if (true_code == NE && XEXP (cond, 1) == const0_rtx
6181       && false_rtx == const0_rtx && CONST_INT_P (true_rtx)
6182       && GET_MODE (XEXP (cond, 0)) == mode
6183       && (UINTVAL (true_rtx) & GET_MODE_MASK (mode))
6184           == nonzero_bits (XEXP (cond, 0), mode)
6185       && (i = exact_log2 (UINTVAL (true_rtx) & GET_MODE_MASK (mode))) >= 0)
6186     return XEXP (cond, 0);
6187
6188   return x;
6189 }
6190 \f
6191 /* Simplify X, a SET expression.  Return the new expression.  */
6192
6193 static rtx
6194 simplify_set (rtx x)
6195 {
6196   rtx src = SET_SRC (x);
6197   rtx dest = SET_DEST (x);
6198   enum machine_mode mode
6199     = GET_MODE (src) != VOIDmode ? GET_MODE (src) : GET_MODE (dest);
6200   rtx other_insn;
6201   rtx *cc_use;
6202
6203   /* (set (pc) (return)) gets written as (return).  */
6204   if (GET_CODE (dest) == PC && GET_CODE (src) == RETURN)
6205     return src;
6206
6207   /* Now that we know for sure which bits of SRC we are using, see if we can
6208      simplify the expression for the object knowing that we only need the
6209      low-order bits.  */
6210
6211   if (GET_MODE_CLASS (mode) == MODE_INT
6212       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
6213     {
6214       src = force_to_mode (src, mode, ~(unsigned HOST_WIDE_INT) 0, 0);
6215       SUBST (SET_SRC (x), src);
6216     }
6217
6218   /* If we are setting CC0 or if the source is a COMPARE, look for the use of
6219      the comparison result and try to simplify it unless we already have used
6220      undobuf.other_insn.  */
6221   if ((GET_MODE_CLASS (mode) == MODE_CC
6222        || GET_CODE (src) == COMPARE
6223        || CC0_P (dest))
6224       && (cc_use = find_single_use (dest, subst_insn, &other_insn)) != 0
6225       && (undobuf.other_insn == 0 || other_insn == undobuf.other_insn)
6226       && COMPARISON_P (*cc_use)
6227       && rtx_equal_p (XEXP (*cc_use, 0), dest))
6228     {
6229       enum rtx_code old_code = GET_CODE (*cc_use);
6230       enum rtx_code new_code;
6231       rtx op0, op1, tmp;
6232       int other_changed = 0;
6233       rtx inner_compare = NULL_RTX;
6234       enum machine_mode compare_mode = GET_MODE (dest);
6235
6236       if (GET_CODE (src) == COMPARE)
6237         {
6238           op0 = XEXP (src, 0), op1 = XEXP (src, 1);
6239           if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
6240             {
6241               inner_compare = op0;
6242               op0 = XEXP (inner_compare, 0), op1 = XEXP (inner_compare, 1);
6243             }
6244         }
6245       else
6246         op0 = src, op1 = CONST0_RTX (GET_MODE (src));
6247
6248       tmp = simplify_relational_operation (old_code, compare_mode, VOIDmode,
6249                                            op0, op1);
6250       if (!tmp)
6251         new_code = old_code;
6252       else if (!CONSTANT_P (tmp))
6253         {
6254           new_code = GET_CODE (tmp);
6255           op0 = XEXP (tmp, 0);
6256           op1 = XEXP (tmp, 1);
6257         }
6258       else
6259         {
6260           rtx pat = PATTERN (other_insn);
6261           undobuf.other_insn = other_insn;
6262           SUBST (*cc_use, tmp);
6263
6264           /* Attempt to simplify CC user.  */
6265           if (GET_CODE (pat) == SET)
6266             {
6267               rtx new_rtx = simplify_rtx (SET_SRC (pat));
6268               if (new_rtx != NULL_RTX)
6269                 SUBST (SET_SRC (pat), new_rtx);
6270             }
6271
6272           /* Convert X into a no-op move.  */
6273           SUBST (SET_DEST (x), pc_rtx);
6274           SUBST (SET_SRC (x), pc_rtx);
6275           return x;
6276         }
6277
6278       /* Simplify our comparison, if possible.  */
6279       new_code = simplify_comparison (new_code, &op0, &op1);
6280
6281 #ifdef SELECT_CC_MODE
6282       /* If this machine has CC modes other than CCmode, check to see if we
6283          need to use a different CC mode here.  */
6284       if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
6285         compare_mode = GET_MODE (op0);
6286       else if (inner_compare
6287                && GET_MODE_CLASS (GET_MODE (inner_compare)) == MODE_CC
6288                && new_code == old_code
6289                && op0 == XEXP (inner_compare, 0)
6290                && op1 == XEXP (inner_compare, 1))
6291         compare_mode = GET_MODE (inner_compare);
6292       else
6293         compare_mode = SELECT_CC_MODE (new_code, op0, op1);
6294
6295 #ifndef HAVE_cc0
6296       /* If the mode changed, we have to change SET_DEST, the mode in the
6297          compare, and the mode in the place SET_DEST is used.  If SET_DEST is
6298          a hard register, just build new versions with the proper mode.  If it
6299          is a pseudo, we lose unless it is only time we set the pseudo, in
6300          which case we can safely change its mode.  */
6301       if (compare_mode != GET_MODE (dest))
6302         {
6303           if (can_change_dest_mode (dest, 0, compare_mode))
6304             {
6305               unsigned int regno = REGNO (dest);
6306               rtx new_dest;
6307
6308               if (regno < FIRST_PSEUDO_REGISTER)
6309                 new_dest = gen_rtx_REG (compare_mode, regno);
6310               else
6311                 {
6312                   SUBST_MODE (regno_reg_rtx[regno], compare_mode);
6313                   new_dest = regno_reg_rtx[regno];
6314                 }
6315
6316               SUBST (SET_DEST (x), new_dest);
6317               SUBST (XEXP (*cc_use, 0), new_dest);
6318               other_changed = 1;
6319
6320               dest = new_dest;
6321             }
6322         }
6323 #endif  /* cc0 */
6324 #endif  /* SELECT_CC_MODE */
6325
6326       /* If the code changed, we have to build a new comparison in
6327          undobuf.other_insn.  */
6328       if (new_code != old_code)
6329         {
6330           int other_changed_previously = other_changed;
6331           unsigned HOST_WIDE_INT mask;
6332           rtx old_cc_use = *cc_use;
6333
6334           SUBST (*cc_use, gen_rtx_fmt_ee (new_code, GET_MODE (*cc_use),
6335                                           dest, const0_rtx));
6336           other_changed = 1;
6337
6338           /* If the only change we made was to change an EQ into an NE or
6339              vice versa, OP0 has only one bit that might be nonzero, and OP1
6340              is zero, check if changing the user of the condition code will
6341              produce a valid insn.  If it won't, we can keep the original code
6342              in that insn by surrounding our operation with an XOR.  */
6343
6344           if (((old_code == NE && new_code == EQ)
6345                || (old_code == EQ && new_code == NE))
6346               && ! other_changed_previously && op1 == const0_rtx
6347               && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
6348               && exact_log2 (mask = nonzero_bits (op0, GET_MODE (op0))) >= 0)
6349             {
6350               rtx pat = PATTERN (other_insn), note = 0;
6351
6352               if ((recog_for_combine (&pat, other_insn, &note) < 0
6353                    && ! check_asm_operands (pat)))
6354                 {
6355                   *cc_use = old_cc_use;
6356                   other_changed = 0;
6357
6358                   op0 = simplify_gen_binary (XOR, GET_MODE (op0),
6359                                              op0, GEN_INT (mask));
6360                 }
6361             }
6362         }
6363
6364       if (other_changed)
6365         undobuf.other_insn = other_insn;
6366
6367       /* Otherwise, if we didn't previously have a COMPARE in the
6368          correct mode, we need one.  */
6369       if (GET_CODE (src) != COMPARE || GET_MODE (src) != compare_mode)
6370         {
6371           SUBST (SET_SRC (x), gen_rtx_COMPARE (compare_mode, op0, op1));
6372           src = SET_SRC (x);
6373         }
6374       else if (GET_MODE (op0) == compare_mode && op1 == const0_rtx)
6375         {
6376           SUBST (SET_SRC (x), op0);
6377           src = SET_SRC (x);
6378         }
6379       /* Otherwise, update the COMPARE if needed.  */
6380       else if (XEXP (src, 0) != op0 || XEXP (src, 1) != op1)
6381         {
6382           SUBST (SET_SRC (x), gen_rtx_COMPARE (compare_mode, op0, op1));
6383           src = SET_SRC (x);
6384         }
6385     }
6386   else
6387     {
6388       /* Get SET_SRC in a form where we have placed back any
6389          compound expressions.  Then do the checks below.  */
6390       src = make_compound_operation (src, SET);
6391       SUBST (SET_SRC (x), src);
6392     }
6393
6394   /* If we have (set x (subreg:m1 (op:m2 ...) 0)) with OP being some operation,
6395      and X being a REG or (subreg (reg)), we may be able to convert this to
6396      (set (subreg:m2 x) (op)).
6397
6398      We can always do this if M1 is narrower than M2 because that means that
6399      we only care about the low bits of the result.
6400
6401      However, on machines without WORD_REGISTER_OPERATIONS defined, we cannot
6402      perform a narrower operation than requested since the high-order bits will
6403      be undefined.  On machine where it is defined, this transformation is safe
6404      as long as M1 and M2 have the same number of words.  */
6405
6406   if (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)
6407       && !OBJECT_P (SUBREG_REG (src))
6408       && (((GET_MODE_SIZE (GET_MODE (src)) + (UNITS_PER_WORD - 1))
6409            / UNITS_PER_WORD)
6410           == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (src)))
6411                + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
6412 #ifndef WORD_REGISTER_OPERATIONS
6413       && (GET_MODE_SIZE (GET_MODE (src))
6414         < GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))
6415 #endif
6416 #ifdef CANNOT_CHANGE_MODE_CLASS
6417       && ! (REG_P (dest) && REGNO (dest) < FIRST_PSEUDO_REGISTER
6418             && REG_CANNOT_CHANGE_MODE_P (REGNO (dest),
6419                                          GET_MODE (SUBREG_REG (src)),
6420                                          GET_MODE (src)))
6421 #endif
6422       && (REG_P (dest)
6423           || (GET_CODE (dest) == SUBREG
6424               && REG_P (SUBREG_REG (dest)))))
6425     {
6426       SUBST (SET_DEST (x),
6427              gen_lowpart (GET_MODE (SUBREG_REG (src)),
6428                                       dest));
6429       SUBST (SET_SRC (x), SUBREG_REG (src));
6430
6431       src = SET_SRC (x), dest = SET_DEST (x);
6432     }
6433
6434 #ifdef HAVE_cc0
6435   /* If we have (set (cc0) (subreg ...)), we try to remove the subreg
6436      in SRC.  */
6437   if (dest == cc0_rtx
6438       && GET_CODE (src) == SUBREG
6439       && subreg_lowpart_p (src)
6440       && (GET_MODE_BITSIZE (GET_MODE (src))
6441           < GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (src)))))
6442     {
6443       rtx inner = SUBREG_REG (src);
6444       enum machine_mode inner_mode = GET_MODE (inner);
6445
6446       /* Here we make sure that we don't have a sign bit on.  */
6447       if (GET_MODE_BITSIZE (inner_mode) <= HOST_BITS_PER_WIDE_INT
6448           && (nonzero_bits (inner, inner_mode)
6449               < ((unsigned HOST_WIDE_INT) 1
6450                  << (GET_MODE_BITSIZE (GET_MODE (src)) - 1))))
6451         {
6452           SUBST (SET_SRC (x), inner);
6453           src = SET_SRC (x);
6454         }
6455     }
6456 #endif
6457
6458 #ifdef LOAD_EXTEND_OP
6459   /* If we have (set FOO (subreg:M (mem:N BAR) 0)) with M wider than N, this
6460      would require a paradoxical subreg.  Replace the subreg with a
6461      zero_extend to avoid the reload that would otherwise be required.  */
6462
6463   if (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)
6464       && INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (src)))
6465       && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (src))) != UNKNOWN
6466       && SUBREG_BYTE (src) == 0
6467       && (GET_MODE_SIZE (GET_MODE (src))
6468           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))
6469       && MEM_P (SUBREG_REG (src)))
6470     {
6471       SUBST (SET_SRC (x),
6472              gen_rtx_fmt_e (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (src))),
6473                             GET_MODE (src), SUBREG_REG (src)));
6474
6475       src = SET_SRC (x);
6476     }
6477 #endif
6478
6479   /* If we don't have a conditional move, SET_SRC is an IF_THEN_ELSE, and we
6480      are comparing an item known to be 0 or -1 against 0, use a logical
6481      operation instead. Check for one of the arms being an IOR of the other
6482      arm with some value.  We compute three terms to be IOR'ed together.  In
6483      practice, at most two will be nonzero.  Then we do the IOR's.  */
6484
6485   if (GET_CODE (dest) != PC
6486       && GET_CODE (src) == IF_THEN_ELSE
6487       && GET_MODE_CLASS (GET_MODE (src)) == MODE_INT
6488       && (GET_CODE (XEXP (src, 0)) == EQ || GET_CODE (XEXP (src, 0)) == NE)
6489       && XEXP (XEXP (src, 0), 1) == const0_rtx
6490       && GET_MODE (src) == GET_MODE (XEXP (XEXP (src, 0), 0))
6491 #ifdef HAVE_conditional_move
6492       && ! can_conditionally_move_p (GET_MODE (src))
6493 #endif
6494       && (num_sign_bit_copies (XEXP (XEXP (src, 0), 0),
6495                                GET_MODE (XEXP (XEXP (src, 0), 0)))
6496           == GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (src, 0), 0))))
6497       && ! side_effects_p (src))
6498     {
6499       rtx true_rtx = (GET_CODE (XEXP (src, 0)) == NE
6500                       ? XEXP (src, 1) : XEXP (src, 2));
6501       rtx false_rtx = (GET_CODE (XEXP (src, 0)) == NE
6502                    ? XEXP (src, 2) : XEXP (src, 1));
6503       rtx term1 = const0_rtx, term2, term3;
6504
6505       if (GET_CODE (true_rtx) == IOR
6506           && rtx_equal_p (XEXP (true_rtx, 0), false_rtx))
6507         term1 = false_rtx, true_rtx = XEXP (true_rtx, 1), false_rtx = const0_rtx;
6508       else if (GET_CODE (true_rtx) == IOR
6509                && rtx_equal_p (XEXP (true_rtx, 1), false_rtx))
6510         term1 = false_rtx, true_rtx = XEXP (true_rtx, 0), false_rtx = const0_rtx;
6511       else if (GET_CODE (false_rtx) == IOR
6512                && rtx_equal_p (XEXP (false_rtx, 0), true_rtx))
6513         term1 = true_rtx, false_rtx = XEXP (false_rtx, 1), true_rtx = const0_rtx;
6514       else if (GET_CODE (false_rtx) == IOR
6515                && rtx_equal_p (XEXP (false_rtx, 1), true_rtx))
6516         term1 = true_rtx, false_rtx = XEXP (false_rtx, 0), true_rtx = const0_rtx;
6517
6518       term2 = simplify_gen_binary (AND, GET_MODE (src),
6519                                    XEXP (XEXP (src, 0), 0), true_rtx);
6520       term3 = simplify_gen_binary (AND, GET_MODE (src),
6521                                    simplify_gen_unary (NOT, GET_MODE (src),
6522                                                        XEXP (XEXP (src, 0), 0),
6523                                                        GET_MODE (src)),
6524                                    false_rtx);
6525
6526       SUBST (SET_SRC (x),
6527              simplify_gen_binary (IOR, GET_MODE (src),
6528                                   simplify_gen_binary (IOR, GET_MODE (src),
6529                                                        term1, term2),
6530                                   term3));
6531
6532       src = SET_SRC (x);
6533     }
6534
6535   /* If either SRC or DEST is a CLOBBER of (const_int 0), make this
6536      whole thing fail.  */
6537   if (GET_CODE (src) == CLOBBER && XEXP (src, 0) == const0_rtx)
6538     return src;
6539   else if (GET_CODE (dest) == CLOBBER && XEXP (dest, 0) == const0_rtx)
6540     return dest;
6541   else
6542     /* Convert this into a field assignment operation, if possible.  */
6543     return make_field_assignment (x);
6544 }
6545 \f
6546 /* Simplify, X, and AND, IOR, or XOR operation, and return the simplified
6547    result.  */
6548
6549 static rtx
6550 simplify_logical (rtx x)
6551 {
6552   enum machine_mode mode = GET_MODE (x);
6553   rtx op0 = XEXP (x, 0);
6554   rtx op1 = XEXP (x, 1);
6555
6556   switch (GET_CODE (x))
6557     {
6558     case AND:
6559       /* We can call simplify_and_const_int only if we don't lose
6560          any (sign) bits when converting INTVAL (op1) to
6561          "unsigned HOST_WIDE_INT".  */
6562       if (CONST_INT_P (op1)
6563           && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
6564               || INTVAL (op1) > 0))
6565         {
6566           x = simplify_and_const_int (x, mode, op0, INTVAL (op1));
6567           if (GET_CODE (x) != AND)
6568             return x;
6569
6570           op0 = XEXP (x, 0);
6571           op1 = XEXP (x, 1);
6572         }
6573
6574       /* If we have any of (and (ior A B) C) or (and (xor A B) C),
6575          apply the distributive law and then the inverse distributive
6576          law to see if things simplify.  */
6577       if (GET_CODE (op0) == IOR || GET_CODE (op0) == XOR)
6578         {
6579           rtx result = distribute_and_simplify_rtx (x, 0);
6580           if (result)
6581             return result;
6582         }
6583       if (GET_CODE (op1) == IOR || GET_CODE (op1) == XOR)
6584         {
6585           rtx result = distribute_and_simplify_rtx (x, 1);
6586           if (result)
6587             return result;
6588         }
6589       break;
6590
6591     case IOR:
6592       /* If we have (ior (and A B) C), apply the distributive law and then
6593          the inverse distributive law to see if things simplify.  */
6594
6595       if (GET_CODE (op0) == AND)
6596         {
6597           rtx result = distribute_and_simplify_rtx (x, 0);
6598           if (result)
6599             return result;
6600         }
6601
6602       if (GET_CODE (op1) == AND)
6603         {
6604           rtx result = distribute_and_simplify_rtx (x, 1);
6605           if (result)
6606             return result;
6607         }
6608       break;
6609
6610     default:
6611       gcc_unreachable ();
6612     }
6613
6614   return x;
6615 }
6616 \f
6617 /* We consider ZERO_EXTRACT, SIGN_EXTRACT, and SIGN_EXTEND as "compound
6618    operations" because they can be replaced with two more basic operations.
6619    ZERO_EXTEND is also considered "compound" because it can be replaced with
6620    an AND operation, which is simpler, though only one operation.
6621
6622    The function expand_compound_operation is called with an rtx expression
6623    and will convert it to the appropriate shifts and AND operations,
6624    simplifying at each stage.
6625
6626    The function make_compound_operation is called to convert an expression
6627    consisting of shifts and ANDs into the equivalent compound expression.
6628    It is the inverse of this function, loosely speaking.  */
6629
6630 static rtx
6631 expand_compound_operation (rtx x)
6632 {
6633   unsigned HOST_WIDE_INT pos = 0, len;
6634   int unsignedp = 0;
6635   unsigned int modewidth;
6636   rtx tem;
6637
6638   switch (GET_CODE (x))
6639     {
6640     case ZERO_EXTEND:
6641       unsignedp = 1;
6642     case SIGN_EXTEND:
6643       /* We can't necessarily use a const_int for a multiword mode;
6644          it depends on implicitly extending the value.
6645          Since we don't know the right way to extend it,
6646          we can't tell whether the implicit way is right.
6647
6648          Even for a mode that is no wider than a const_int,
6649          we can't win, because we need to sign extend one of its bits through
6650          the rest of it, and we don't know which bit.  */
6651       if (CONST_INT_P (XEXP (x, 0)))
6652         return x;
6653
6654       /* Return if (subreg:MODE FROM 0) is not a safe replacement for
6655          (zero_extend:MODE FROM) or (sign_extend:MODE FROM).  It is for any MEM
6656          because (SUBREG (MEM...)) is guaranteed to cause the MEM to be
6657          reloaded. If not for that, MEM's would very rarely be safe.
6658
6659          Reject MODEs bigger than a word, because we might not be able
6660          to reference a two-register group starting with an arbitrary register
6661          (and currently gen_lowpart might crash for a SUBREG).  */
6662
6663       if (GET_MODE_SIZE (GET_MODE (XEXP (x, 0))) > UNITS_PER_WORD)
6664         return x;
6665
6666       /* Reject MODEs that aren't scalar integers because turning vector
6667          or complex modes into shifts causes problems.  */
6668
6669       if (! SCALAR_INT_MODE_P (GET_MODE (XEXP (x, 0))))
6670         return x;
6671
6672       len = GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)));
6673       /* If the inner object has VOIDmode (the only way this can happen
6674          is if it is an ASM_OPERANDS), we can't do anything since we don't
6675          know how much masking to do.  */
6676       if (len == 0)
6677         return x;
6678
6679       break;
6680
6681     case ZERO_EXTRACT:
6682       unsignedp = 1;
6683
6684       /* ... fall through ...  */
6685
6686     case SIGN_EXTRACT:
6687       /* If the operand is a CLOBBER, just return it.  */
6688       if (GET_CODE (XEXP (x, 0)) == CLOBBER)
6689         return XEXP (x, 0);
6690
6691       if (!CONST_INT_P (XEXP (x, 1))
6692           || !CONST_INT_P (XEXP (x, 2))
6693           || GET_MODE (XEXP (x, 0)) == VOIDmode)
6694         return x;
6695
6696       /* Reject MODEs that aren't scalar integers because turning vector
6697          or complex modes into shifts causes problems.  */
6698
6699       if (! SCALAR_INT_MODE_P (GET_MODE (XEXP (x, 0))))
6700         return x;
6701
6702       len = INTVAL (XEXP (x, 1));
6703       pos = INTVAL (XEXP (x, 2));
6704
6705       /* This should stay within the object being extracted, fail otherwise.  */
6706       if (len + pos > GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))))
6707         return x;
6708
6709       if (BITS_BIG_ENDIAN)
6710         pos = GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - len - pos;
6711
6712       break;
6713
6714     default:
6715       return x;
6716     }
6717   /* Convert sign extension to zero extension, if we know that the high
6718      bit is not set, as this is easier to optimize.  It will be converted
6719      back to cheaper alternative in make_extraction.  */
6720   if (GET_CODE (x) == SIGN_EXTEND
6721       && (GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
6722           && ((nonzero_bits (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
6723                 & ~(((unsigned HOST_WIDE_INT)
6724                       GET_MODE_MASK (GET_MODE (XEXP (x, 0))))
6725                      >> 1))
6726                == 0)))
6727     {
6728       rtx temp = gen_rtx_ZERO_EXTEND (GET_MODE (x), XEXP (x, 0));
6729       rtx temp2 = expand_compound_operation (temp);
6730
6731       /* Make sure this is a profitable operation.  */
6732       if (rtx_cost (x, SET, optimize_this_for_speed_p)
6733           > rtx_cost (temp2, SET, optimize_this_for_speed_p))
6734        return temp2;
6735       else if (rtx_cost (x, SET, optimize_this_for_speed_p)
6736                > rtx_cost (temp, SET, optimize_this_for_speed_p))
6737        return temp;
6738       else
6739        return x;
6740     }
6741
6742   /* We can optimize some special cases of ZERO_EXTEND.  */
6743   if (GET_CODE (x) == ZERO_EXTEND)
6744     {
6745       /* (zero_extend:DI (truncate:SI foo:DI)) is just foo:DI if we
6746          know that the last value didn't have any inappropriate bits
6747          set.  */
6748       if (GET_CODE (XEXP (x, 0)) == TRUNCATE
6749           && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
6750           && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
6751           && (nonzero_bits (XEXP (XEXP (x, 0), 0), GET_MODE (x))
6752               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6753         return XEXP (XEXP (x, 0), 0);
6754
6755       /* Likewise for (zero_extend:DI (subreg:SI foo:DI 0)).  */
6756       if (GET_CODE (XEXP (x, 0)) == SUBREG
6757           && GET_MODE (SUBREG_REG (XEXP (x, 0))) == GET_MODE (x)
6758           && subreg_lowpart_p (XEXP (x, 0))
6759           && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
6760           && (nonzero_bits (SUBREG_REG (XEXP (x, 0)), GET_MODE (x))
6761               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6762         return SUBREG_REG (XEXP (x, 0));
6763
6764       /* (zero_extend:DI (truncate:SI foo:DI)) is just foo:DI when foo
6765          is a comparison and STORE_FLAG_VALUE permits.  This is like
6766          the first case, but it works even when GET_MODE (x) is larger
6767          than HOST_WIDE_INT.  */
6768       if (GET_CODE (XEXP (x, 0)) == TRUNCATE
6769           && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
6770           && COMPARISON_P (XEXP (XEXP (x, 0), 0))
6771           && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
6772               <= HOST_BITS_PER_WIDE_INT)
6773           && (STORE_FLAG_VALUE & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6774         return XEXP (XEXP (x, 0), 0);
6775
6776       /* Likewise for (zero_extend:DI (subreg:SI foo:DI 0)).  */
6777       if (GET_CODE (XEXP (x, 0)) == SUBREG
6778           && GET_MODE (SUBREG_REG (XEXP (x, 0))) == GET_MODE (x)
6779           && subreg_lowpart_p (XEXP (x, 0))
6780           && COMPARISON_P (SUBREG_REG (XEXP (x, 0)))
6781           && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
6782               <= HOST_BITS_PER_WIDE_INT)
6783           && (STORE_FLAG_VALUE & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6784         return SUBREG_REG (XEXP (x, 0));
6785
6786     }
6787
6788   /* If we reach here, we want to return a pair of shifts.  The inner
6789      shift is a left shift of BITSIZE - POS - LEN bits.  The outer
6790      shift is a right shift of BITSIZE - LEN bits.  It is arithmetic or
6791      logical depending on the value of UNSIGNEDP.
6792
6793      If this was a ZERO_EXTEND or ZERO_EXTRACT, this pair of shifts will be
6794      converted into an AND of a shift.
6795
6796      We must check for the case where the left shift would have a negative
6797      count.  This can happen in a case like (x >> 31) & 255 on machines
6798      that can't shift by a constant.  On those machines, we would first
6799      combine the shift with the AND to produce a variable-position
6800      extraction.  Then the constant of 31 would be substituted in
6801      to produce such a position.  */
6802
6803   modewidth = GET_MODE_BITSIZE (GET_MODE (x));
6804   if (modewidth >= pos + len)
6805     {
6806       enum machine_mode mode = GET_MODE (x);
6807       tem = gen_lowpart (mode, XEXP (x, 0));
6808       if (!tem || GET_CODE (tem) == CLOBBER)
6809         return x;
6810       tem = simplify_shift_const (NULL_RTX, ASHIFT, mode,
6811                                   tem, modewidth - pos - len);
6812       tem = simplify_shift_const (NULL_RTX, unsignedp ? LSHIFTRT : ASHIFTRT,
6813                                   mode, tem, modewidth - len);
6814     }
6815   else if (unsignedp && len < HOST_BITS_PER_WIDE_INT)
6816     tem = simplify_and_const_int (NULL_RTX, GET_MODE (x),
6817                                   simplify_shift_const (NULL_RTX, LSHIFTRT,
6818                                                         GET_MODE (x),
6819                                                         XEXP (x, 0), pos),
6820                                   ((unsigned HOST_WIDE_INT) 1 << len) - 1);
6821   else
6822     /* Any other cases we can't handle.  */
6823     return x;
6824
6825   /* If we couldn't do this for some reason, return the original
6826      expression.  */
6827   if (GET_CODE (tem) == CLOBBER)
6828     return x;
6829
6830   return tem;
6831 }
6832 \f
6833 /* X is a SET which contains an assignment of one object into
6834    a part of another (such as a bit-field assignment, STRICT_LOW_PART,
6835    or certain SUBREGS). If possible, convert it into a series of
6836    logical operations.
6837
6838    We half-heartedly support variable positions, but do not at all
6839    support variable lengths.  */
6840
6841 static const_rtx
6842 expand_field_assignment (const_rtx x)
6843 {
6844   rtx inner;
6845   rtx pos;                      /* Always counts from low bit.  */
6846   int len;
6847   rtx mask, cleared, masked;
6848   enum machine_mode compute_mode;
6849
6850   /* Loop until we find something we can't simplify.  */
6851   while (1)
6852     {
6853       if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART
6854           && GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG)
6855         {
6856           inner = SUBREG_REG (XEXP (SET_DEST (x), 0));
6857           len = GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)));
6858           pos = GEN_INT (subreg_lsb (XEXP (SET_DEST (x), 0)));
6859         }
6860       else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
6861                && CONST_INT_P (XEXP (SET_DEST (x), 1)))
6862         {
6863           inner = XEXP (SET_DEST (x), 0);
6864           len = INTVAL (XEXP (SET_DEST (x), 1));
6865           pos = XEXP (SET_DEST (x), 2);
6866
6867           /* A constant position should stay within the width of INNER.  */
6868           if (CONST_INT_P (pos)
6869               && INTVAL (pos) + len > GET_MODE_BITSIZE (GET_MODE (inner)))
6870             break;
6871
6872           if (BITS_BIG_ENDIAN)
6873             {
6874               if (CONST_INT_P (pos))
6875                 pos = GEN_INT (GET_MODE_BITSIZE (GET_MODE (inner)) - len
6876                                - INTVAL (pos));
6877               else if (GET_CODE (pos) == MINUS
6878                        && CONST_INT_P (XEXP (pos, 1))
6879                        && (INTVAL (XEXP (pos, 1))
6880                            == GET_MODE_BITSIZE (GET_MODE (inner)) - len))
6881                 /* If position is ADJUST - X, new position is X.  */
6882                 pos = XEXP (pos, 0);
6883               else
6884                 pos = simplify_gen_binary (MINUS, GET_MODE (pos),
6885                                            GEN_INT (GET_MODE_BITSIZE (
6886                                                     GET_MODE (inner))
6887                                                     - len),
6888                                            pos);
6889             }
6890         }
6891
6892       /* A SUBREG between two modes that occupy the same numbers of words
6893          can be done by moving the SUBREG to the source.  */
6894       else if (GET_CODE (SET_DEST (x)) == SUBREG
6895                /* We need SUBREGs to compute nonzero_bits properly.  */
6896                && nonzero_sign_valid
6897                && (((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
6898                      + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
6899                    == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
6900                         + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
6901         {
6902           x = gen_rtx_SET (VOIDmode, SUBREG_REG (SET_DEST (x)),
6903                            gen_lowpart
6904                            (GET_MODE (SUBREG_REG (SET_DEST (x))),
6905                             SET_SRC (x)));
6906           continue;
6907         }
6908       else
6909         break;
6910
6911       while (GET_CODE (inner) == SUBREG && subreg_lowpart_p (inner))
6912         inner = SUBREG_REG (inner);
6913
6914       compute_mode = GET_MODE (inner);
6915
6916       /* Don't attempt bitwise arithmetic on non scalar integer modes.  */
6917       if (! SCALAR_INT_MODE_P (compute_mode))
6918         {
6919           enum machine_mode imode;
6920
6921           /* Don't do anything for vector or complex integral types.  */
6922           if (! FLOAT_MODE_P (compute_mode))
6923             break;
6924
6925           /* Try to find an integral mode to pun with.  */
6926           imode = mode_for_size (GET_MODE_BITSIZE (compute_mode), MODE_INT, 0);
6927           if (imode == BLKmode)
6928             break;
6929
6930           compute_mode = imode;
6931           inner = gen_lowpart (imode, inner);
6932         }
6933
6934       /* Compute a mask of LEN bits, if we can do this on the host machine.  */
6935       if (len >= HOST_BITS_PER_WIDE_INT)
6936         break;
6937
6938       /* Now compute the equivalent expression.  Make a copy of INNER
6939          for the SET_DEST in case it is a MEM into which we will substitute;
6940          we don't want shared RTL in that case.  */
6941       mask = GEN_INT (((unsigned HOST_WIDE_INT) 1 << len) - 1);
6942       cleared = simplify_gen_binary (AND, compute_mode,
6943                                      simplify_gen_unary (NOT, compute_mode,
6944                                        simplify_gen_binary (ASHIFT,
6945                                                             compute_mode,
6946                                                             mask, pos),
6947                                        compute_mode),
6948                                      inner);
6949       masked = simplify_gen_binary (ASHIFT, compute_mode,
6950                                     simplify_gen_binary (
6951                                       AND, compute_mode,
6952                                       gen_lowpart (compute_mode, SET_SRC (x)),
6953                                       mask),
6954                                     pos);
6955
6956       x = gen_rtx_SET (VOIDmode, copy_rtx (inner),
6957                        simplify_gen_binary (IOR, compute_mode,
6958                                             cleared, masked));
6959     }
6960
6961   return x;
6962 }
6963 \f
6964 /* Return an RTX for a reference to LEN bits of INNER.  If POS_RTX is nonzero,
6965    it is an RTX that represents a variable starting position; otherwise,
6966    POS is the (constant) starting bit position (counted from the LSB).
6967
6968    UNSIGNEDP is nonzero for an unsigned reference and zero for a
6969    signed reference.
6970
6971    IN_DEST is nonzero if this is a reference in the destination of a
6972    SET.  This is used when a ZERO_ or SIGN_EXTRACT isn't needed.  If nonzero,
6973    a STRICT_LOW_PART will be used, if zero, ZERO_EXTEND or SIGN_EXTEND will
6974    be used.
6975
6976    IN_COMPARE is nonzero if we are in a COMPARE.  This means that a
6977    ZERO_EXTRACT should be built even for bits starting at bit 0.
6978
6979    MODE is the desired mode of the result (if IN_DEST == 0).
6980
6981    The result is an RTX for the extraction or NULL_RTX if the target
6982    can't handle it.  */
6983
6984 static rtx
6985 make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
6986                  rtx pos_rtx, unsigned HOST_WIDE_INT len, int unsignedp,
6987                  int in_dest, int in_compare)
6988 {
6989   /* This mode describes the size of the storage area
6990      to fetch the overall value from.  Within that, we
6991      ignore the POS lowest bits, etc.  */
6992   enum machine_mode is_mode = GET_MODE (inner);
6993   enum machine_mode inner_mode;
6994   enum machine_mode wanted_inner_mode;
6995   enum machine_mode wanted_inner_reg_mode = word_mode;
6996   enum machine_mode pos_mode = word_mode;
6997   enum machine_mode extraction_mode = word_mode;
6998   enum machine_mode tmode = mode_for_size (len, MODE_INT, 1);
6999   rtx new_rtx = 0;
7000   rtx orig_pos_rtx = pos_rtx;
7001   HOST_WIDE_INT orig_pos;
7002
7003   if (GET_CODE (inner) == SUBREG && subreg_lowpart_p (inner))
7004     {
7005       /* If going from (subreg:SI (mem:QI ...)) to (mem:QI ...),
7006          consider just the QI as the memory to extract from.
7007          The subreg adds or removes high bits; its mode is
7008          irrelevant to the meaning of this extraction,
7009          since POS and LEN count from the lsb.  */
7010       if (MEM_P (SUBREG_REG (inner)))
7011         is_mode = GET_MODE (SUBREG_REG (inner));
7012       inner = SUBREG_REG (inner);
7013     }
7014   else if (GET_CODE (inner) == ASHIFT
7015            && CONST_INT_P (XEXP (inner, 1))
7016            && pos_rtx == 0 && pos == 0
7017            && len > UINTVAL (XEXP (inner, 1)))
7018     {
7019       /* We're extracting the least significant bits of an rtx
7020          (ashift X (const_int C)), where LEN > C.  Extract the
7021          least significant (LEN - C) bits of X, giving an rtx
7022          whose mode is MODE, then shift it left C times.  */
7023       new_rtx = make_extraction (mode, XEXP (inner, 0),
7024                              0, 0, len - INTVAL (XEXP (inner, 1)),
7025                              unsignedp, in_dest, in_compare);
7026       if (new_rtx != 0)
7027         return gen_rtx_ASHIFT (mode, new_rtx, XEXP (inner, 1));
7028     }
7029
7030   inner_mode = GET_MODE (inner);
7031
7032   if (pos_rtx && CONST_INT_P (pos_rtx))
7033     pos = INTVAL (pos_rtx), pos_rtx = 0;
7034
7035   /* See if this can be done without an extraction.  We never can if the
7036      width of the field is not the same as that of some integer mode. For
7037      registers, we can only avoid the extraction if the position is at the
7038      low-order bit and this is either not in the destination or we have the
7039      appropriate STRICT_LOW_PART operation available.
7040
7041      For MEM, we can avoid an extract if the field starts on an appropriate
7042      boundary and we can change the mode of the memory reference.  */
7043
7044   if (tmode != BLKmode
7045       && ((pos_rtx == 0 && (pos % BITS_PER_WORD) == 0
7046            && !MEM_P (inner)
7047            && (inner_mode == tmode
7048                || !REG_P (inner)
7049                || TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (tmode),
7050                                          GET_MODE_BITSIZE (inner_mode))
7051                || reg_truncated_to_mode (tmode, inner))
7052            && (! in_dest
7053                || (REG_P (inner)
7054                    && have_insn_for (STRICT_LOW_PART, tmode))))
7055           || (MEM_P (inner) && pos_rtx == 0
7056               && (pos
7057                   % (STRICT_ALIGNMENT ? GET_MODE_ALIGNMENT (tmode)
7058                      : BITS_PER_UNIT)) == 0
7059               /* We can't do this if we are widening INNER_MODE (it
7060                  may not be aligned, for one thing).  */
7061               && GET_MODE_BITSIZE (inner_mode) >= GET_MODE_BITSIZE (tmode)
7062               && (inner_mode == tmode
7063                   || (! mode_dependent_address_p (XEXP (inner, 0))
7064                       && ! MEM_VOLATILE_P (inner))))))
7065     {
7066       /* If INNER is a MEM, make a new MEM that encompasses just the desired
7067          field.  If the original and current mode are the same, we need not
7068          adjust the offset.  Otherwise, we do if bytes big endian.
7069
7070          If INNER is not a MEM, get a piece consisting of just the field
7071          of interest (in this case POS % BITS_PER_WORD must be 0).  */
7072
7073       if (MEM_P (inner))
7074         {
7075           HOST_WIDE_INT offset;
7076
7077           /* POS counts from lsb, but make OFFSET count in memory order.  */
7078           if (BYTES_BIG_ENDIAN)
7079             offset = (GET_MODE_BITSIZE (is_mode) - len - pos) / BITS_PER_UNIT;
7080           else
7081             offset = pos / BITS_PER_UNIT;
7082
7083           new_rtx = adjust_address_nv (inner, tmode, offset);
7084         }
7085       else if (REG_P (inner))
7086         {
7087           if (tmode != inner_mode)
7088             {
7089               /* We can't call gen_lowpart in a DEST since we
7090                  always want a SUBREG (see below) and it would sometimes
7091                  return a new hard register.  */
7092               if (pos || in_dest)
7093                 {
7094                   HOST_WIDE_INT final_word = pos / BITS_PER_WORD;
7095
7096                   if (WORDS_BIG_ENDIAN
7097                       && GET_MODE_SIZE (inner_mode) > UNITS_PER_WORD)
7098                     final_word = ((GET_MODE_SIZE (inner_mode)
7099                                    - GET_MODE_SIZE (tmode))
7100                                   / UNITS_PER_WORD) - final_word;
7101
7102                   final_word *= UNITS_PER_WORD;
7103                   if (BYTES_BIG_ENDIAN &&
7104                       GET_MODE_SIZE (inner_mode) > GET_MODE_SIZE (tmode))
7105                     final_word += (GET_MODE_SIZE (inner_mode)
7106                                    - GET_MODE_SIZE (tmode)) % UNITS_PER_WORD;
7107
7108                   /* Avoid creating invalid subregs, for example when
7109                      simplifying (x>>32)&255.  */
7110                   if (!validate_subreg (tmode, inner_mode, inner, final_word))
7111                     return NULL_RTX;
7112
7113                   new_rtx = gen_rtx_SUBREG (tmode, inner, final_word);
7114                 }
7115               else
7116                 new_rtx = gen_lowpart (tmode, inner);
7117             }
7118           else
7119             new_rtx = inner;
7120         }
7121       else
7122         new_rtx = force_to_mode (inner, tmode,
7123                              len >= HOST_BITS_PER_WIDE_INT
7124                              ? ~(unsigned HOST_WIDE_INT) 0
7125                              : ((unsigned HOST_WIDE_INT) 1 << len) - 1,
7126                              0);
7127
7128       /* If this extraction is going into the destination of a SET,
7129          make a STRICT_LOW_PART unless we made a MEM.  */
7130
7131       if (in_dest)
7132         return (MEM_P (new_rtx) ? new_rtx
7133                 : (GET_CODE (new_rtx) != SUBREG
7134                    ? gen_rtx_CLOBBER (tmode, const0_rtx)
7135                    : gen_rtx_STRICT_LOW_PART (VOIDmode, new_rtx)));
7136
7137       if (mode == tmode)
7138         return new_rtx;
7139
7140       if (CONST_INT_P (new_rtx)
7141           || GET_CODE (new_rtx) == CONST_DOUBLE)
7142         return simplify_unary_operation (unsignedp ? ZERO_EXTEND : SIGN_EXTEND,
7143                                          mode, new_rtx, tmode);
7144
7145       /* If we know that no extraneous bits are set, and that the high
7146          bit is not set, convert the extraction to the cheaper of
7147          sign and zero extension, that are equivalent in these cases.  */
7148       if (flag_expensive_optimizations
7149           && (GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT
7150               && ((nonzero_bits (new_rtx, tmode)
7151                    & ~(((unsigned HOST_WIDE_INT)
7152                         GET_MODE_MASK (tmode))
7153                        >> 1))
7154                   == 0)))
7155         {
7156           rtx temp = gen_rtx_ZERO_EXTEND (mode, new_rtx);
7157           rtx temp1 = gen_rtx_SIGN_EXTEND (mode, new_rtx);
7158
7159           /* Prefer ZERO_EXTENSION, since it gives more information to
7160              backends.  */
7161           if (rtx_cost (temp, SET, optimize_this_for_speed_p)
7162               <= rtx_cost (temp1, SET, optimize_this_for_speed_p))
7163             return temp;
7164           return temp1;
7165         }
7166
7167       /* Otherwise, sign- or zero-extend unless we already are in the
7168          proper mode.  */
7169
7170       return (gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND,
7171                              mode, new_rtx));
7172     }
7173
7174   /* Unless this is a COMPARE or we have a funny memory reference,
7175      don't do anything with zero-extending field extracts starting at
7176      the low-order bit since they are simple AND operations.  */
7177   if (pos_rtx == 0 && pos == 0 && ! in_dest
7178       && ! in_compare && unsignedp)
7179     return 0;
7180
7181   /* Unless INNER is not MEM, reject this if we would be spanning bytes or
7182      if the position is not a constant and the length is not 1.  In all
7183      other cases, we would only be going outside our object in cases when
7184      an original shift would have been undefined.  */
7185   if (MEM_P (inner)
7186       && ((pos_rtx == 0 && pos + len > GET_MODE_BITSIZE (is_mode))
7187           || (pos_rtx != 0 && len != 1)))
7188     return 0;
7189
7190   /* Get the mode to use should INNER not be a MEM, the mode for the position,
7191      and the mode for the result.  */
7192   if (in_dest && mode_for_extraction (EP_insv, -1) != MAX_MACHINE_MODE)
7193     {
7194       wanted_inner_reg_mode = mode_for_extraction (EP_insv, 0);
7195       pos_mode = mode_for_extraction (EP_insv, 2);
7196       extraction_mode = mode_for_extraction (EP_insv, 3);
7197     }
7198
7199   if (! in_dest && unsignedp
7200       && mode_for_extraction (EP_extzv, -1) != MAX_MACHINE_MODE)
7201     {
7202       wanted_inner_reg_mode = mode_for_extraction (EP_extzv, 1);
7203       pos_mode = mode_for_extraction (EP_extzv, 3);
7204       extraction_mode = mode_for_extraction (EP_extzv, 0);
7205     }
7206
7207   if (! in_dest && ! unsignedp
7208       && mode_for_extraction (EP_extv, -1) != MAX_MACHINE_MODE)
7209     {
7210       wanted_inner_reg_mode = mode_for_extraction (EP_extv, 1);
7211       pos_mode = mode_for_extraction (EP_extv, 3);
7212       extraction_mode = mode_for_extraction (EP_extv, 0);
7213     }
7214
7215   /* Never narrow an object, since that might not be safe.  */
7216
7217   if (mode != VOIDmode
7218       && GET_MODE_SIZE (extraction_mode) < GET_MODE_SIZE (mode))
7219     extraction_mode = mode;
7220
7221   if (pos_rtx && GET_MODE (pos_rtx) != VOIDmode
7222       && GET_MODE_SIZE (pos_mode) < GET_MODE_SIZE (GET_MODE (pos_rtx)))
7223     pos_mode = GET_MODE (pos_rtx);
7224
7225   /* If this is not from memory, the desired mode is the preferred mode
7226      for an extraction pattern's first input operand, or word_mode if there
7227      is none.  */
7228   if (!MEM_P (inner))
7229     wanted_inner_mode = wanted_inner_reg_mode;
7230   else
7231     {
7232       /* Be careful not to go beyond the extracted object and maintain the
7233          natural alignment of the memory.  */
7234       wanted_inner_mode = smallest_mode_for_size (len, MODE_INT);
7235       while (pos % GET_MODE_BITSIZE (wanted_inner_mode) + len
7236              > GET_MODE_BITSIZE (wanted_inner_mode))
7237         {
7238           wanted_inner_mode = GET_MODE_WIDER_MODE (wanted_inner_mode);
7239           gcc_assert (wanted_inner_mode != VOIDmode);
7240         }
7241
7242       /* If we have to change the mode of memory and cannot, the desired mode
7243          is EXTRACTION_MODE.  */
7244       if (inner_mode != wanted_inner_mode
7245           && (mode_dependent_address_p (XEXP (inner, 0))
7246               || MEM_VOLATILE_P (inner)
7247               || pos_rtx))
7248         wanted_inner_mode = extraction_mode;
7249     }
7250
7251   orig_pos = pos;
7252
7253   if (BITS_BIG_ENDIAN)
7254     {
7255       /* POS is passed as if BITS_BIG_ENDIAN == 0, so we need to convert it to
7256          BITS_BIG_ENDIAN style.  If position is constant, compute new
7257          position.  Otherwise, build subtraction.
7258          Note that POS is relative to the mode of the original argument.
7259          If it's a MEM we need to recompute POS relative to that.
7260          However, if we're extracting from (or inserting into) a register,
7261          we want to recompute POS relative to wanted_inner_mode.  */
7262       int width = (MEM_P (inner)
7263                    ? GET_MODE_BITSIZE (is_mode)
7264                    : GET_MODE_BITSIZE (wanted_inner_mode));
7265
7266       if (pos_rtx == 0)
7267         pos = width - len - pos;
7268       else
7269         pos_rtx
7270           = gen_rtx_MINUS (GET_MODE (pos_rtx), GEN_INT (width - len), pos_rtx);
7271       /* POS may be less than 0 now, but we check for that below.
7272          Note that it can only be less than 0 if !MEM_P (inner).  */
7273     }
7274
7275   /* If INNER has a wider mode, and this is a constant extraction, try to
7276      make it smaller and adjust the byte to point to the byte containing
7277      the value.  */
7278   if (wanted_inner_mode != VOIDmode
7279       && inner_mode != wanted_inner_mode
7280       && ! pos_rtx
7281       && GET_MODE_SIZE (wanted_inner_mode) < GET_MODE_SIZE (is_mode)
7282       && MEM_P (inner)
7283       && ! mode_dependent_address_p (XEXP (inner, 0))
7284       && ! MEM_VOLATILE_P (inner))
7285     {
7286       int offset = 0;
7287
7288       /* The computations below will be correct if the machine is big
7289          endian in both bits and bytes or little endian in bits and bytes.
7290          If it is mixed, we must adjust.  */
7291
7292       /* If bytes are big endian and we had a paradoxical SUBREG, we must
7293          adjust OFFSET to compensate.  */
7294       if (BYTES_BIG_ENDIAN
7295           && GET_MODE_SIZE (inner_mode) < GET_MODE_SIZE (is_mode))
7296         offset -= GET_MODE_SIZE (is_mode) - GET_MODE_SIZE (inner_mode);
7297
7298       /* We can now move to the desired byte.  */
7299       offset += (pos / GET_MODE_BITSIZE (wanted_inner_mode))
7300                 * GET_MODE_SIZE (wanted_inner_mode);
7301       pos %= GET_MODE_BITSIZE (wanted_inner_mode);
7302
7303       if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN
7304           && is_mode != wanted_inner_mode)
7305         offset = (GET_MODE_SIZE (is_mode)
7306                   - GET_MODE_SIZE (wanted_inner_mode) - offset);
7307
7308       inner = adjust_address_nv (inner, wanted_inner_mode, offset);
7309     }
7310
7311   /* If INNER is not memory, get it into the proper mode.  If we are changing
7312      its mode, POS must be a constant and smaller than the size of the new
7313      mode.  */
7314   else if (!MEM_P (inner))
7315     {
7316       /* On the LHS, don't create paradoxical subregs implicitely truncating
7317          the register unless TRULY_NOOP_TRUNCATION.  */
7318       if (in_dest
7319           && !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (GET_MODE (inner)),
7320                                      GET_MODE_BITSIZE (wanted_inner_mode)))
7321         return NULL_RTX;
7322
7323       if (GET_MODE (inner) != wanted_inner_mode
7324           && (pos_rtx != 0
7325               || orig_pos + len > GET_MODE_BITSIZE (wanted_inner_mode)))
7326         return NULL_RTX;
7327
7328       if (orig_pos < 0)
7329         return NULL_RTX;
7330
7331       inner = force_to_mode (inner, wanted_inner_mode,
7332                              pos_rtx
7333                              || len + orig_pos >= HOST_BITS_PER_WIDE_INT
7334                              ? ~(unsigned HOST_WIDE_INT) 0
7335                              : ((((unsigned HOST_WIDE_INT) 1 << len) - 1)
7336                                 << orig_pos),
7337                              0);
7338     }
7339
7340   /* Adjust mode of POS_RTX, if needed.  If we want a wider mode, we
7341      have to zero extend.  Otherwise, we can just use a SUBREG.  */
7342   if (pos_rtx != 0
7343       && GET_MODE_SIZE (pos_mode) > GET_MODE_SIZE (GET_MODE (pos_rtx)))
7344     {
7345       rtx temp = gen_rtx_ZERO_EXTEND (pos_mode, pos_rtx);
7346
7347       /* If we know that no extraneous bits are set, and that the high
7348          bit is not set, convert extraction to cheaper one - either
7349          SIGN_EXTENSION or ZERO_EXTENSION, that are equivalent in these
7350          cases.  */
7351       if (flag_expensive_optimizations
7352           && (GET_MODE_BITSIZE (GET_MODE (pos_rtx)) <= HOST_BITS_PER_WIDE_INT
7353               && ((nonzero_bits (pos_rtx, GET_MODE (pos_rtx))
7354                    & ~(((unsigned HOST_WIDE_INT)
7355                         GET_MODE_MASK (GET_MODE (pos_rtx)))
7356                        >> 1))
7357                   == 0)))
7358         {
7359           rtx temp1 = gen_rtx_SIGN_EXTEND (pos_mode, pos_rtx);
7360
7361           /* Prefer ZERO_EXTENSION, since it gives more information to
7362              backends.  */
7363           if (rtx_cost (temp1, SET, optimize_this_for_speed_p)
7364               < rtx_cost (temp, SET, optimize_this_for_speed_p))
7365             temp = temp1;
7366         }
7367       pos_rtx = temp;
7368     }
7369   else if (pos_rtx != 0
7370            && GET_MODE_SIZE (pos_mode) < GET_MODE_SIZE (GET_MODE (pos_rtx)))
7371     pos_rtx = gen_lowpart (pos_mode, pos_rtx);
7372
7373   /* Make POS_RTX unless we already have it and it is correct.  If we don't
7374      have a POS_RTX but we do have an ORIG_POS_RTX, the latter must
7375      be a CONST_INT.  */
7376   if (pos_rtx == 0 && orig_pos_rtx != 0 && INTVAL (orig_pos_rtx) == pos)
7377     pos_rtx = orig_pos_rtx;
7378
7379   else if (pos_rtx == 0)
7380     pos_rtx = GEN_INT (pos);
7381
7382   /* Make the required operation.  See if we can use existing rtx.  */
7383   new_rtx = gen_rtx_fmt_eee (unsignedp ? ZERO_EXTRACT : SIGN_EXTRACT,
7384                          extraction_mode, inner, GEN_INT (len), pos_rtx);
7385   if (! in_dest)
7386     new_rtx = gen_lowpart (mode, new_rtx);
7387
7388   return new_rtx;
7389 }
7390 \f
7391 /* See if X contains an ASHIFT of COUNT or more bits that can be commuted
7392    with any other operations in X.  Return X without that shift if so.  */
7393
7394 static rtx
7395 extract_left_shift (rtx x, int count)
7396 {
7397   enum rtx_code code = GET_CODE (x);
7398   enum machine_mode mode = GET_MODE (x);
7399   rtx tem;
7400
7401   switch (code)
7402     {
7403     case ASHIFT:
7404       /* This is the shift itself.  If it is wide enough, we will return
7405          either the value being shifted if the shift count is equal to
7406          COUNT or a shift for the difference.  */
7407       if (CONST_INT_P (XEXP (x, 1))
7408           && INTVAL (XEXP (x, 1)) >= count)
7409         return simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (x, 0),
7410                                      INTVAL (XEXP (x, 1)) - count);
7411       break;
7412
7413     case NEG:  case NOT:
7414       if ((tem = extract_left_shift (XEXP (x, 0), count)) != 0)
7415         return simplify_gen_unary (code, mode, tem, mode);
7416
7417       break;
7418
7419     case PLUS:  case IOR:  case XOR:  case AND:
7420       /* If we can safely shift this constant and we find the inner shift,
7421          make a new operation.  */
7422       if (CONST_INT_P (XEXP (x, 1))
7423           && (UINTVAL (XEXP (x, 1))
7424               & ((((unsigned HOST_WIDE_INT) 1 << count)) - 1)) == 0
7425           && (tem = extract_left_shift (XEXP (x, 0), count)) != 0)
7426         return simplify_gen_binary (code, mode, tem,
7427                                     GEN_INT (INTVAL (XEXP (x, 1)) >> count));
7428
7429       break;
7430
7431     default:
7432       break;
7433     }
7434
7435   return 0;
7436 }
7437 \f
7438 /* Look at the expression rooted at X.  Look for expressions
7439    equivalent to ZERO_EXTRACT, SIGN_EXTRACT, ZERO_EXTEND, SIGN_EXTEND.
7440    Form these expressions.
7441
7442    Return the new rtx, usually just X.
7443
7444    Also, for machines like the VAX that don't have logical shift insns,
7445    try to convert logical to arithmetic shift operations in cases where
7446    they are equivalent.  This undoes the canonicalizations to logical
7447    shifts done elsewhere.
7448
7449    We try, as much as possible, to re-use rtl expressions to save memory.
7450
7451    IN_CODE says what kind of expression we are processing.  Normally, it is
7452    SET.  In a memory address (inside a MEM, PLUS or minus, the latter two
7453    being kludges), it is MEM.  When processing the arguments of a comparison
7454    or a COMPARE against zero, it is COMPARE.  */
7455
7456 static rtx
7457 make_compound_operation (rtx x, enum rtx_code in_code)
7458 {
7459   enum rtx_code code = GET_CODE (x);
7460   enum machine_mode mode = GET_MODE (x);
7461   int mode_width = GET_MODE_BITSIZE (mode);
7462   rtx rhs, lhs;
7463   enum rtx_code next_code;
7464   int i, j;
7465   rtx new_rtx = 0;
7466   rtx tem;
7467   const char *fmt;
7468
7469   /* Select the code to be used in recursive calls.  Once we are inside an
7470      address, we stay there.  If we have a comparison, set to COMPARE,
7471      but once inside, go back to our default of SET.  */
7472
7473   next_code = (code == MEM ? MEM
7474                : ((code == PLUS || code == MINUS)
7475                   && SCALAR_INT_MODE_P (mode)) ? MEM
7476                : ((code == COMPARE || COMPARISON_P (x))
7477                   && XEXP (x, 1) == const0_rtx) ? COMPARE
7478                : in_code == COMPARE ? SET : in_code);
7479
7480   /* Process depending on the code of this operation.  If NEW is set
7481      nonzero, it will be returned.  */
7482
7483   switch (code)
7484     {
7485     case ASHIFT:
7486       /* Convert shifts by constants into multiplications if inside
7487          an address.  */
7488       if (in_code == MEM && CONST_INT_P (XEXP (x, 1))
7489           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
7490           && INTVAL (XEXP (x, 1)) >= 0
7491           && SCALAR_INT_MODE_P (mode))
7492         {
7493           HOST_WIDE_INT count = INTVAL (XEXP (x, 1));
7494           HOST_WIDE_INT multval = (HOST_WIDE_INT) 1 << count;
7495
7496           new_rtx = make_compound_operation (XEXP (x, 0), next_code);
7497           if (GET_CODE (new_rtx) == NEG)
7498             {
7499               new_rtx = XEXP (new_rtx, 0);
7500               multval = -multval;
7501             }
7502           multval = trunc_int_for_mode (multval, mode);
7503           new_rtx = gen_rtx_MULT (mode, new_rtx, GEN_INT (multval));
7504         }
7505       break;
7506
7507     case PLUS:
7508       lhs = XEXP (x, 0);
7509       rhs = XEXP (x, 1);
7510       lhs = make_compound_operation (lhs, next_code);
7511       rhs = make_compound_operation (rhs, next_code);
7512       if (GET_CODE (lhs) == MULT && GET_CODE (XEXP (lhs, 0)) == NEG
7513           && SCALAR_INT_MODE_P (mode))
7514         {
7515           tem = simplify_gen_binary (MULT, mode, XEXP (XEXP (lhs, 0), 0),
7516                                      XEXP (lhs, 1));
7517           new_rtx = simplify_gen_binary (MINUS, mode, rhs, tem);
7518         }
7519       else if (GET_CODE (lhs) == MULT
7520                && (CONST_INT_P (XEXP (lhs, 1)) && INTVAL (XEXP (lhs, 1)) < 0))
7521         {
7522           tem = simplify_gen_binary (MULT, mode, XEXP (lhs, 0),
7523                                      simplify_gen_unary (NEG, mode,
7524                                                          XEXP (lhs, 1),
7525                                                          mode));
7526           new_rtx = simplify_gen_binary (MINUS, mode, rhs, tem);
7527         }
7528       else
7529         {
7530           SUBST (XEXP (x, 0), lhs);
7531           SUBST (XEXP (x, 1), rhs);
7532           goto maybe_swap;
7533         }
7534       x = gen_lowpart (mode, new_rtx);
7535       goto maybe_swap;
7536
7537     case MINUS:
7538       lhs = XEXP (x, 0);
7539       rhs = XEXP (x, 1);
7540       lhs = make_compound_operation (lhs, next_code);
7541       rhs = make_compound_operation (rhs, next_code);
7542       if (GET_CODE (rhs) == MULT && GET_CODE (XEXP (rhs, 0)) == NEG
7543           && SCALAR_INT_MODE_P (mode))
7544         {
7545           tem = simplify_gen_binary (MULT, mode, XEXP (XEXP (rhs, 0), 0),
7546                                      XEXP (rhs, 1));
7547           new_rtx = simplify_gen_binary (PLUS, mode, tem, lhs);
7548         }
7549       else if (GET_CODE (rhs) == MULT
7550                && (CONST_INT_P (XEXP (rhs, 1)) && INTVAL (XEXP (rhs, 1)) < 0))
7551         {
7552           tem = simplify_gen_binary (MULT, mode, XEXP (rhs, 0),
7553                                      simplify_gen_unary (NEG, mode,
7554                                                          XEXP (rhs, 1),
7555                                                          mode));
7556           new_rtx = simplify_gen_binary (PLUS, mode, tem, lhs);
7557         }
7558       else
7559         {
7560           SUBST (XEXP (x, 0), lhs);
7561           SUBST (XEXP (x, 1), rhs);
7562           return x;
7563         }
7564       return gen_lowpart (mode, new_rtx);
7565
7566     case AND:
7567       /* If the second operand is not a constant, we can't do anything
7568          with it.  */
7569       if (!CONST_INT_P (XEXP (x, 1)))
7570         break;
7571
7572       /* If the constant is a power of two minus one and the first operand
7573          is a logical right shift, make an extraction.  */
7574       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
7575           && (i = exact_log2 (UINTVAL (XEXP (x, 1)) + 1)) >= 0)
7576         {
7577           new_rtx = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
7578           new_rtx = make_extraction (mode, new_rtx, 0, XEXP (XEXP (x, 0), 1), i, 1,
7579                                  0, in_code == COMPARE);
7580         }
7581
7582       /* Same as previous, but for (subreg (lshiftrt ...)) in first op.  */
7583       else if (GET_CODE (XEXP (x, 0)) == SUBREG
7584                && subreg_lowpart_p (XEXP (x, 0))
7585                && GET_CODE (SUBREG_REG (XEXP (x, 0))) == LSHIFTRT
7586                && (i = exact_log2 (UINTVAL (XEXP (x, 1)) + 1)) >= 0)
7587         {
7588           new_rtx = make_compound_operation (XEXP (SUBREG_REG (XEXP (x, 0)), 0),
7589                                          next_code);
7590           new_rtx = make_extraction (GET_MODE (SUBREG_REG (XEXP (x, 0))), new_rtx, 0,
7591                                  XEXP (SUBREG_REG (XEXP (x, 0)), 1), i, 1,
7592                                  0, in_code == COMPARE);
7593         }
7594       /* Same as previous, but for (xor/ior (lshiftrt...) (lshiftrt...)).  */
7595       else if ((GET_CODE (XEXP (x, 0)) == XOR
7596                 || GET_CODE (XEXP (x, 0)) == IOR)
7597                && GET_CODE (XEXP (XEXP (x, 0), 0)) == LSHIFTRT
7598                && GET_CODE (XEXP (XEXP (x, 0), 1)) == LSHIFTRT
7599                && (i = exact_log2 (UINTVAL (XEXP (x, 1)) + 1)) >= 0)
7600         {
7601           /* Apply the distributive law, and then try to make extractions.  */
7602           new_rtx = gen_rtx_fmt_ee (GET_CODE (XEXP (x, 0)), mode,
7603                                 gen_rtx_AND (mode, XEXP (XEXP (x, 0), 0),
7604                                              XEXP (x, 1)),
7605                                 gen_rtx_AND (mode, XEXP (XEXP (x, 0), 1),
7606                                              XEXP (x, 1)));
7607           new_rtx = make_compound_operation (new_rtx, in_code);
7608         }
7609
7610       /* If we are have (and (rotate X C) M) and C is larger than the number
7611          of bits in M, this is an extraction.  */
7612
7613       else if (GET_CODE (XEXP (x, 0)) == ROTATE
7614                && CONST_INT_P (XEXP (XEXP (x, 0), 1))
7615                && (i = exact_log2 (UINTVAL (XEXP (x, 1)) + 1)) >= 0
7616                && i <= INTVAL (XEXP (XEXP (x, 0), 1)))
7617         {
7618           new_rtx = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
7619           new_rtx = make_extraction (mode, new_rtx,
7620                                  (GET_MODE_BITSIZE (mode)
7621                                   - INTVAL (XEXP (XEXP (x, 0), 1))),
7622                                  NULL_RTX, i, 1, 0, in_code == COMPARE);
7623         }
7624
7625       /* On machines without logical shifts, if the operand of the AND is
7626          a logical shift and our mask turns off all the propagated sign
7627          bits, we can replace the logical shift with an arithmetic shift.  */
7628       else if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
7629                && !have_insn_for (LSHIFTRT, mode)
7630                && have_insn_for (ASHIFTRT, mode)
7631                && CONST_INT_P (XEXP (XEXP (x, 0), 1))
7632                && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
7633                && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
7634                && mode_width <= HOST_BITS_PER_WIDE_INT)
7635         {
7636           unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
7637
7638           mask >>= INTVAL (XEXP (XEXP (x, 0), 1));
7639           if ((INTVAL (XEXP (x, 1)) & ~mask) == 0)
7640             SUBST (XEXP (x, 0),
7641                    gen_rtx_ASHIFTRT (mode,
7642                                      make_compound_operation
7643                                      (XEXP (XEXP (x, 0), 0), next_code),
7644                                      XEXP (XEXP (x, 0), 1)));
7645         }
7646
7647       /* If the constant is one less than a power of two, this might be
7648          representable by an extraction even if no shift is present.
7649          If it doesn't end up being a ZERO_EXTEND, we will ignore it unless
7650          we are in a COMPARE.  */
7651       else if ((i = exact_log2 (UINTVAL (XEXP (x, 1)) + 1)) >= 0)
7652         new_rtx = make_extraction (mode,
7653                                make_compound_operation (XEXP (x, 0),
7654                                                         next_code),
7655                                0, NULL_RTX, i, 1, 0, in_code == COMPARE);
7656
7657       /* If we are in a comparison and this is an AND with a power of two,
7658          convert this into the appropriate bit extract.  */
7659       else if (in_code == COMPARE
7660                && (i = exact_log2 (UINTVAL (XEXP (x, 1)))) >= 0)
7661         new_rtx = make_extraction (mode,
7662                                make_compound_operation (XEXP (x, 0),
7663                                                         next_code),
7664                                i, NULL_RTX, 1, 1, 0, 1);
7665
7666       break;
7667
7668     case LSHIFTRT:
7669       /* If the sign bit is known to be zero, replace this with an
7670          arithmetic shift.  */
7671       if (have_insn_for (ASHIFTRT, mode)
7672           && ! have_insn_for (LSHIFTRT, mode)
7673           && mode_width <= HOST_BITS_PER_WIDE_INT
7674           && (nonzero_bits (XEXP (x, 0), mode) & (1 << (mode_width - 1))) == 0)
7675         {
7676           new_rtx = gen_rtx_ASHIFTRT (mode,
7677                                   make_compound_operation (XEXP (x, 0),
7678                                                            next_code),
7679                                   XEXP (x, 1));
7680           break;
7681         }
7682
7683       /* ... fall through ...  */
7684
7685     case ASHIFTRT:
7686       lhs = XEXP (x, 0);
7687       rhs = XEXP (x, 1);
7688
7689       /* If we have (ashiftrt (ashift foo C1) C2) with C2 >= C1,
7690          this is a SIGN_EXTRACT.  */
7691       if (CONST_INT_P (rhs)
7692           && GET_CODE (lhs) == ASHIFT
7693           && CONST_INT_P (XEXP (lhs, 1))
7694           && INTVAL (rhs) >= INTVAL (XEXP (lhs, 1))
7695           && INTVAL (rhs) < mode_width)
7696         {
7697           new_rtx = make_compound_operation (XEXP (lhs, 0), next_code);
7698           new_rtx = make_extraction (mode, new_rtx,
7699                                  INTVAL (rhs) - INTVAL (XEXP (lhs, 1)),
7700                                  NULL_RTX, mode_width - INTVAL (rhs),
7701                                  code == LSHIFTRT, 0, in_code == COMPARE);
7702           break;
7703         }
7704
7705       /* See if we have operations between an ASHIFTRT and an ASHIFT.
7706          If so, try to merge the shifts into a SIGN_EXTEND.  We could
7707          also do this for some cases of SIGN_EXTRACT, but it doesn't
7708          seem worth the effort; the case checked for occurs on Alpha.  */
7709
7710       if (!OBJECT_P (lhs)
7711           && ! (GET_CODE (lhs) == SUBREG
7712                 && (OBJECT_P (SUBREG_REG (lhs))))
7713           && CONST_INT_P (rhs)
7714           && INTVAL (rhs) < HOST_BITS_PER_WIDE_INT
7715           && INTVAL (rhs) < mode_width
7716           && (new_rtx = extract_left_shift (lhs, INTVAL (rhs))) != 0)
7717         new_rtx = make_extraction (mode, make_compound_operation (new_rtx, next_code),
7718                                0, NULL_RTX, mode_width - INTVAL (rhs),
7719                                code == LSHIFTRT, 0, in_code == COMPARE);
7720
7721       break;
7722
7723     case SUBREG:
7724       /* Call ourselves recursively on the inner expression.  If we are
7725          narrowing the object and it has a different RTL code from
7726          what it originally did, do this SUBREG as a force_to_mode.  */
7727       {
7728         rtx inner = SUBREG_REG (x), simplified;
7729
7730         tem = make_compound_operation (inner, in_code);
7731
7732         simplified
7733           = simplify_subreg (mode, tem, GET_MODE (inner), SUBREG_BYTE (x));
7734         if (simplified)
7735           tem = simplified;
7736
7737         if (GET_CODE (tem) != GET_CODE (inner)
7738             && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (inner))
7739             && subreg_lowpart_p (x))
7740           {
7741             rtx newer
7742               = force_to_mode (tem, mode, ~(unsigned HOST_WIDE_INT) 0, 0);
7743
7744             /* If we have something other than a SUBREG, we might have
7745                done an expansion, so rerun ourselves.  */
7746             if (GET_CODE (newer) != SUBREG)
7747               newer = make_compound_operation (newer, in_code);
7748
7749             /* force_to_mode can expand compounds.  If it just re-expanded the
7750                compound, use gen_lowpart to convert to the desired mode.  */
7751             if (rtx_equal_p (newer, x)
7752                 /* Likewise if it re-expanded the compound only partially.
7753                    This happens for SUBREG of ZERO_EXTRACT if they extract
7754                    the same number of bits.  */
7755                 || (GET_CODE (newer) == SUBREG
7756                     && (GET_CODE (SUBREG_REG (newer)) == LSHIFTRT
7757                         || GET_CODE (SUBREG_REG (newer)) == ASHIFTRT)
7758                     && GET_CODE (inner) == AND
7759                     && rtx_equal_p (SUBREG_REG (newer), XEXP (inner, 0))))
7760               return gen_lowpart (GET_MODE (x), tem);
7761
7762             return newer;
7763           }
7764
7765         if (simplified)
7766           return tem;
7767       }
7768       break;
7769
7770     default:
7771       break;
7772     }
7773
7774   if (new_rtx)
7775     {
7776       x = gen_lowpart (mode, new_rtx);
7777       code = GET_CODE (x);
7778     }
7779
7780   /* Now recursively process each operand of this operation.  */
7781   fmt = GET_RTX_FORMAT (code);
7782   for (i = 0; i < GET_RTX_LENGTH (code); i++)
7783     if (fmt[i] == 'e')
7784       {
7785         new_rtx = make_compound_operation (XEXP (x, i), next_code);
7786         SUBST (XEXP (x, i), new_rtx);
7787       }
7788     else if (fmt[i] == 'E')
7789       for (j = 0; j < XVECLEN (x, i); j++)
7790         {
7791           new_rtx = make_compound_operation (XVECEXP (x, i, j), next_code);
7792           SUBST (XVECEXP (x, i, j), new_rtx);
7793         }
7794
7795  maybe_swap:
7796   /* If this is a commutative operation, the changes to the operands
7797      may have made it noncanonical.  */
7798   if (COMMUTATIVE_ARITH_P (x)
7799       && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
7800     {
7801       tem = XEXP (x, 0);
7802       SUBST (XEXP (x, 0), XEXP (x, 1));
7803       SUBST (XEXP (x, 1), tem);
7804     }
7805
7806   return x;
7807 }
7808 \f
7809 /* Given M see if it is a value that would select a field of bits
7810    within an item, but not the entire word.  Return -1 if not.
7811    Otherwise, return the starting position of the field, where 0 is the
7812    low-order bit.
7813
7814    *PLEN is set to the length of the field.  */
7815
7816 static int
7817 get_pos_from_mask (unsigned HOST_WIDE_INT m, unsigned HOST_WIDE_INT *plen)
7818 {
7819   /* Get the bit number of the first 1 bit from the right, -1 if none.  */
7820   int pos = m ? ctz_hwi (m) : -1;
7821   int len = 0;
7822
7823   if (pos >= 0)
7824     /* Now shift off the low-order zero bits and see if we have a
7825        power of two minus 1.  */
7826     len = exact_log2 ((m >> pos) + 1);
7827
7828   if (len <= 0)
7829     pos = -1;
7830
7831   *plen = len;
7832   return pos;
7833 }
7834 \f
7835 /* If X refers to a register that equals REG in value, replace these
7836    references with REG.  */
7837 static rtx
7838 canon_reg_for_combine (rtx x, rtx reg)
7839 {
7840   rtx op0, op1, op2;
7841   const char *fmt;
7842   int i;
7843   bool copied;
7844
7845   enum rtx_code code = GET_CODE (x);
7846   switch (GET_RTX_CLASS (code))
7847     {
7848     case RTX_UNARY:
7849       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7850       if (op0 != XEXP (x, 0))
7851         return simplify_gen_unary (GET_CODE (x), GET_MODE (x), op0,
7852                                    GET_MODE (reg));
7853       break;
7854
7855     case RTX_BIN_ARITH:
7856     case RTX_COMM_ARITH:
7857       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7858       op1 = canon_reg_for_combine (XEXP (x, 1), reg);
7859       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
7860         return simplify_gen_binary (GET_CODE (x), GET_MODE (x), op0, op1);
7861       break;
7862
7863     case RTX_COMPARE:
7864     case RTX_COMM_COMPARE:
7865       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7866       op1 = canon_reg_for_combine (XEXP (x, 1), reg);
7867       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
7868         return simplify_gen_relational (GET_CODE (x), GET_MODE (x),
7869                                         GET_MODE (op0), op0, op1);
7870       break;
7871
7872     case RTX_TERNARY:
7873     case RTX_BITFIELD_OPS:
7874       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7875       op1 = canon_reg_for_combine (XEXP (x, 1), reg);
7876       op2 = canon_reg_for_combine (XEXP (x, 2), reg);
7877       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1) || op2 != XEXP (x, 2))
7878         return simplify_gen_ternary (GET_CODE (x), GET_MODE (x),
7879                                      GET_MODE (op0), op0, op1, op2);
7880
7881     case RTX_OBJ:
7882       if (REG_P (x))
7883         {
7884           if (rtx_equal_p (get_last_value (reg), x)
7885               || rtx_equal_p (reg, get_last_value (x)))
7886             return reg;
7887           else
7888             break;
7889         }
7890
7891       /* fall through */
7892
7893     default:
7894       fmt = GET_RTX_FORMAT (code);
7895       copied = false;
7896       for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
7897         if (fmt[i] == 'e')
7898           {
7899             rtx op = canon_reg_for_combine (XEXP (x, i), reg);
7900             if (op != XEXP (x, i))
7901               {
7902                 if (!copied)
7903                   {
7904                     copied = true;
7905                     x = copy_rtx (x);
7906                   }
7907                 XEXP (x, i) = op;
7908               }
7909           }
7910         else if (fmt[i] == 'E')
7911           {
7912             int j;
7913             for (j = 0; j < XVECLEN (x, i); j++)
7914               {
7915                 rtx op = canon_reg_for_combine (XVECEXP (x, i, j), reg);
7916                 if (op != XVECEXP (x, i, j))
7917                   {
7918                     if (!copied)
7919                       {
7920                         copied = true;
7921                         x = copy_rtx (x);
7922                       }
7923                     XVECEXP (x, i, j) = op;
7924                   }
7925               }
7926           }
7927
7928       break;
7929     }
7930
7931   return x;
7932 }
7933
7934 /* Return X converted to MODE.  If the value is already truncated to
7935    MODE we can just return a subreg even though in the general case we
7936    would need an explicit truncation.  */
7937
7938 static rtx
7939 gen_lowpart_or_truncate (enum machine_mode mode, rtx x)
7940 {
7941   if (!CONST_INT_P (x)
7942       && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x))
7943       && !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
7944                                  GET_MODE_BITSIZE (GET_MODE (x)))
7945       && !(REG_P (x) && reg_truncated_to_mode (mode, x)))
7946     {
7947       /* Bit-cast X into an integer mode.  */
7948       if (!SCALAR_INT_MODE_P (GET_MODE (x)))
7949         x = gen_lowpart (int_mode_for_mode (GET_MODE (x)), x);
7950       x = simplify_gen_unary (TRUNCATE, int_mode_for_mode (mode),
7951                               x, GET_MODE (x));
7952     }
7953
7954   return gen_lowpart (mode, x);
7955 }
7956
7957 /* See if X can be simplified knowing that we will only refer to it in
7958    MODE and will only refer to those bits that are nonzero in MASK.
7959    If other bits are being computed or if masking operations are done
7960    that select a superset of the bits in MASK, they can sometimes be
7961    ignored.
7962
7963    Return a possibly simplified expression, but always convert X to
7964    MODE.  If X is a CONST_INT, AND the CONST_INT with MASK.
7965
7966    If JUST_SELECT is nonzero, don't optimize by noticing that bits in MASK
7967    are all off in X.  This is used when X will be complemented, by either
7968    NOT, NEG, or XOR.  */
7969
7970 static rtx
7971 force_to_mode (rtx x, enum machine_mode mode, unsigned HOST_WIDE_INT mask,
7972                int just_select)
7973 {
7974   enum rtx_code code = GET_CODE (x);
7975   int next_select = just_select || code == XOR || code == NOT || code == NEG;
7976   enum machine_mode op_mode;
7977   unsigned HOST_WIDE_INT fuller_mask, nonzero;
7978   rtx op0, op1, temp;
7979
7980   /* If this is a CALL or ASM_OPERANDS, don't do anything.  Some of the
7981      code below will do the wrong thing since the mode of such an
7982      expression is VOIDmode.
7983
7984      Also do nothing if X is a CLOBBER; this can happen if X was
7985      the return value from a call to gen_lowpart.  */
7986   if (code == CALL || code == ASM_OPERANDS || code == CLOBBER)
7987     return x;
7988
7989   /* We want to perform the operation is its present mode unless we know
7990      that the operation is valid in MODE, in which case we do the operation
7991      in MODE.  */
7992   op_mode = ((GET_MODE_CLASS (mode) == GET_MODE_CLASS (GET_MODE (x))
7993               && have_insn_for (code, mode))
7994              ? mode : GET_MODE (x));
7995
7996   /* It is not valid to do a right-shift in a narrower mode
7997      than the one it came in with.  */
7998   if ((code == LSHIFTRT || code == ASHIFTRT)
7999       && GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (GET_MODE (x)))
8000     op_mode = GET_MODE (x);
8001
8002   /* Truncate MASK to fit OP_MODE.  */
8003   if (op_mode)
8004     mask &= GET_MODE_MASK (op_mode);
8005
8006   /* When we have an arithmetic operation, or a shift whose count we
8007      do not know, we need to assume that all bits up to the highest-order
8008      bit in MASK will be needed.  This is how we form such a mask.  */
8009   if (mask & ((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)))
8010     fuller_mask = ~(unsigned HOST_WIDE_INT) 0;
8011   else
8012     fuller_mask = (((unsigned HOST_WIDE_INT) 1 << (floor_log2 (mask) + 1))
8013                    - 1);
8014
8015   /* Determine what bits of X are guaranteed to be (non)zero.  */
8016   nonzero = nonzero_bits (x, mode);
8017
8018   /* If none of the bits in X are needed, return a zero.  */
8019   if (!just_select && (nonzero & mask) == 0 && !side_effects_p (x))
8020     x = const0_rtx;
8021
8022   /* If X is a CONST_INT, return a new one.  Do this here since the
8023      test below will fail.  */
8024   if (CONST_INT_P (x))
8025     {
8026       if (SCALAR_INT_MODE_P (mode))
8027         return gen_int_mode (INTVAL (x) & mask, mode);
8028       else
8029         {
8030           x = GEN_INT (INTVAL (x) & mask);
8031           return gen_lowpart_common (mode, x);
8032         }
8033     }
8034
8035   /* If X is narrower than MODE and we want all the bits in X's mode, just
8036      get X in the proper mode.  */
8037   if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (mode)
8038       && (GET_MODE_MASK (GET_MODE (x)) & ~mask) == 0)
8039     return gen_lowpart (mode, x);
8040
8041   /* We can ignore the effect of a SUBREG if it narrows the mode or
8042      if the constant masks to zero all the bits the mode doesn't have.  */
8043   if (GET_CODE (x) == SUBREG
8044       && subreg_lowpart_p (x)
8045       && ((GET_MODE_SIZE (GET_MODE (x))
8046            < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
8047           || (0 == (mask
8048                     & GET_MODE_MASK (GET_MODE (x))
8049                     & ~GET_MODE_MASK (GET_MODE (SUBREG_REG (x)))))))
8050     return force_to_mode (SUBREG_REG (x), mode, mask, next_select);
8051
8052   /* The arithmetic simplifications here only work for scalar integer modes.  */
8053   if (!SCALAR_INT_MODE_P (mode) || !SCALAR_INT_MODE_P (GET_MODE (x)))
8054     return gen_lowpart_or_truncate (mode, x);
8055
8056   switch (code)
8057     {
8058     case CLOBBER:
8059       /* If X is a (clobber (const_int)), return it since we know we are
8060          generating something that won't match.  */
8061       return x;
8062
8063     case SIGN_EXTEND:
8064     case ZERO_EXTEND:
8065     case ZERO_EXTRACT:
8066     case SIGN_EXTRACT:
8067       x = expand_compound_operation (x);
8068       if (GET_CODE (x) != code)
8069         return force_to_mode (x, mode, mask, next_select);
8070       break;
8071
8072     case TRUNCATE:
8073       /* Similarly for a truncate.  */
8074       return force_to_mode (XEXP (x, 0), mode, mask, next_select);
8075
8076     case AND:
8077       /* If this is an AND with a constant, convert it into an AND
8078          whose constant is the AND of that constant with MASK.  If it
8079          remains an AND of MASK, delete it since it is redundant.  */
8080
8081       if (CONST_INT_P (XEXP (x, 1)))
8082         {
8083           x = simplify_and_const_int (x, op_mode, XEXP (x, 0),
8084                                       mask & INTVAL (XEXP (x, 1)));
8085
8086           /* If X is still an AND, see if it is an AND with a mask that
8087              is just some low-order bits.  If so, and it is MASK, we don't
8088              need it.  */
8089
8090           if (GET_CODE (x) == AND && CONST_INT_P (XEXP (x, 1))
8091               && ((INTVAL (XEXP (x, 1)) & GET_MODE_MASK (GET_MODE (x)))
8092                   == mask))
8093             x = XEXP (x, 0);
8094
8095           /* If it remains an AND, try making another AND with the bits
8096              in the mode mask that aren't in MASK turned on.  If the
8097              constant in the AND is wide enough, this might make a
8098              cheaper constant.  */
8099
8100           if (GET_CODE (x) == AND && CONST_INT_P (XEXP (x, 1))
8101               && GET_MODE_MASK (GET_MODE (x)) != mask
8102               && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
8103             {
8104               unsigned HOST_WIDE_INT cval
8105                 = UINTVAL (XEXP (x, 1))
8106                   | (GET_MODE_MASK (GET_MODE (x)) & ~mask);
8107               int width = GET_MODE_BITSIZE (GET_MODE (x));
8108               rtx y;
8109
8110               /* If MODE is narrower than HOST_WIDE_INT and CVAL is a negative
8111                  number, sign extend it.  */
8112               if (width > 0 && width < HOST_BITS_PER_WIDE_INT
8113                   && (cval & ((unsigned HOST_WIDE_INT) 1 << (width - 1))) != 0)
8114                 cval |= (unsigned HOST_WIDE_INT) -1 << width;
8115
8116               y = simplify_gen_binary (AND, GET_MODE (x),
8117                                        XEXP (x, 0), GEN_INT (cval));
8118               if (rtx_cost (y, SET, optimize_this_for_speed_p)
8119                   < rtx_cost (x, SET, optimize_this_for_speed_p))
8120                 x = y;
8121             }
8122
8123           break;
8124         }
8125
8126       goto binop;
8127
8128     case PLUS:
8129       /* In (and (plus FOO C1) M), if M is a mask that just turns off
8130          low-order bits (as in an alignment operation) and FOO is already
8131          aligned to that boundary, mask C1 to that boundary as well.
8132          This may eliminate that PLUS and, later, the AND.  */
8133
8134       {
8135         unsigned int width = GET_MODE_BITSIZE (mode);
8136         unsigned HOST_WIDE_INT smask = mask;
8137
8138         /* If MODE is narrower than HOST_WIDE_INT and mask is a negative
8139            number, sign extend it.  */
8140
8141         if (width < HOST_BITS_PER_WIDE_INT
8142             && (smask & ((unsigned HOST_WIDE_INT) 1 << (width - 1))) != 0)
8143           smask |= (unsigned HOST_WIDE_INT) (-1) << width;
8144
8145         if (CONST_INT_P (XEXP (x, 1))
8146             && exact_log2 (- smask) >= 0
8147             && (nonzero_bits (XEXP (x, 0), mode) & ~smask) == 0
8148             && (INTVAL (XEXP (x, 1)) & ~smask) != 0)
8149           return force_to_mode (plus_constant (XEXP (x, 0),
8150                                                (INTVAL (XEXP (x, 1)) & smask)),
8151                                 mode, smask, next_select);
8152       }
8153
8154       /* ... fall through ...  */
8155
8156     case MULT:
8157       /* For PLUS, MINUS and MULT, we need any bits less significant than the
8158          most significant bit in MASK since carries from those bits will
8159          affect the bits we are interested in.  */
8160       mask = fuller_mask;
8161       goto binop;
8162
8163     case MINUS:
8164       /* If X is (minus C Y) where C's least set bit is larger than any bit
8165          in the mask, then we may replace with (neg Y).  */
8166       if (CONST_INT_P (XEXP (x, 0))
8167           && (((unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 0))
8168                                         & -INTVAL (XEXP (x, 0))))
8169               > mask))
8170         {
8171           x = simplify_gen_unary (NEG, GET_MODE (x), XEXP (x, 1),
8172                                   GET_MODE (x));
8173           return force_to_mode (x, mode, mask, next_select);
8174         }
8175
8176       /* Similarly, if C contains every bit in the fuller_mask, then we may
8177          replace with (not Y).  */
8178       if (CONST_INT_P (XEXP (x, 0))
8179           && ((UINTVAL (XEXP (x, 0)) | fuller_mask) == UINTVAL (XEXP (x, 0))))
8180         {
8181           x = simplify_gen_unary (NOT, GET_MODE (x),
8182                                   XEXP (x, 1), GET_MODE (x));
8183           return force_to_mode (x, mode, mask, next_select);
8184         }
8185
8186       mask = fuller_mask;
8187       goto binop;
8188
8189     case IOR:
8190     case XOR:
8191       /* If X is (ior (lshiftrt FOO C1) C2), try to commute the IOR and
8192          LSHIFTRT so we end up with an (and (lshiftrt (ior ...) ...) ...)
8193          operation which may be a bitfield extraction.  Ensure that the
8194          constant we form is not wider than the mode of X.  */
8195
8196       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
8197           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
8198           && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
8199           && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
8200           && CONST_INT_P (XEXP (x, 1))
8201           && ((INTVAL (XEXP (XEXP (x, 0), 1))
8202                + floor_log2 (INTVAL (XEXP (x, 1))))
8203               < GET_MODE_BITSIZE (GET_MODE (x)))
8204           && (UINTVAL (XEXP (x, 1))
8205               & ~nonzero_bits (XEXP (x, 0), GET_MODE (x))) == 0)
8206         {
8207           temp = GEN_INT ((INTVAL (XEXP (x, 1)) & mask)
8208                           << INTVAL (XEXP (XEXP (x, 0), 1)));
8209           temp = simplify_gen_binary (GET_CODE (x), GET_MODE (x),
8210                                       XEXP (XEXP (x, 0), 0), temp);
8211           x = simplify_gen_binary (LSHIFTRT, GET_MODE (x), temp,
8212                                    XEXP (XEXP (x, 0), 1));
8213           return force_to_mode (x, mode, mask, next_select);
8214         }
8215
8216     binop:
8217       /* For most binary operations, just propagate into the operation and
8218          change the mode if we have an operation of that mode.  */
8219
8220       op0 = force_to_mode (XEXP (x, 0), mode, mask, next_select);
8221       op1 = force_to_mode (XEXP (x, 1), mode, mask, next_select);
8222
8223       /* If we ended up truncating both operands, truncate the result of the
8224          operation instead.  */
8225       if (GET_CODE (op0) == TRUNCATE
8226           && GET_CODE (op1) == TRUNCATE)
8227         {
8228           op0 = XEXP (op0, 0);
8229           op1 = XEXP (op1, 0);
8230         }
8231
8232       op0 = gen_lowpart_or_truncate (op_mode, op0);
8233       op1 = gen_lowpart_or_truncate (op_mode, op1);
8234
8235       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
8236         x = simplify_gen_binary (code, op_mode, op0, op1);
8237       break;
8238
8239     case ASHIFT:
8240       /* For left shifts, do the same, but just for the first operand.
8241          However, we cannot do anything with shifts where we cannot
8242          guarantee that the counts are smaller than the size of the mode
8243          because such a count will have a different meaning in a
8244          wider mode.  */
8245
8246       if (! (CONST_INT_P (XEXP (x, 1))
8247              && INTVAL (XEXP (x, 1)) >= 0
8248              && INTVAL (XEXP (x, 1)) < GET_MODE_BITSIZE (mode))
8249           && ! (GET_MODE (XEXP (x, 1)) != VOIDmode
8250                 && (nonzero_bits (XEXP (x, 1), GET_MODE (XEXP (x, 1)))
8251                     < (unsigned HOST_WIDE_INT) GET_MODE_BITSIZE (mode))))
8252         break;
8253
8254       /* If the shift count is a constant and we can do arithmetic in
8255          the mode of the shift, refine which bits we need.  Otherwise, use the
8256          conservative form of the mask.  */
8257       if (CONST_INT_P (XEXP (x, 1))
8258           && INTVAL (XEXP (x, 1)) >= 0
8259           && INTVAL (XEXP (x, 1)) < GET_MODE_BITSIZE (op_mode)
8260           && GET_MODE_BITSIZE (op_mode) <= HOST_BITS_PER_WIDE_INT)
8261         mask >>= INTVAL (XEXP (x, 1));
8262       else
8263         mask = fuller_mask;
8264
8265       op0 = gen_lowpart_or_truncate (op_mode,
8266                                      force_to_mode (XEXP (x, 0), op_mode,
8267                                                     mask, next_select));
8268
8269       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0))
8270         x = simplify_gen_binary (code, op_mode, op0, XEXP (x, 1));
8271       break;
8272
8273     case LSHIFTRT:
8274       /* Here we can only do something if the shift count is a constant,
8275          this shift constant is valid for the host, and we can do arithmetic
8276          in OP_MODE.  */
8277
8278       if (CONST_INT_P (XEXP (x, 1))
8279           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
8280           && GET_MODE_BITSIZE (op_mode) <= HOST_BITS_PER_WIDE_INT)
8281         {
8282           rtx inner = XEXP (x, 0);
8283           unsigned HOST_WIDE_INT inner_mask;
8284
8285           /* Select the mask of the bits we need for the shift operand.  */
8286           inner_mask = mask << INTVAL (XEXP (x, 1));
8287
8288           /* We can only change the mode of the shift if we can do arithmetic
8289              in the mode of the shift and INNER_MASK is no wider than the
8290              width of X's mode.  */
8291           if ((inner_mask & ~GET_MODE_MASK (GET_MODE (x))) != 0)
8292             op_mode = GET_MODE (x);
8293
8294           inner = force_to_mode (inner, op_mode, inner_mask, next_select);
8295
8296           if (GET_MODE (x) != op_mode || inner != XEXP (x, 0))
8297             x = simplify_gen_binary (LSHIFTRT, op_mode, inner, XEXP (x, 1));
8298         }
8299
8300       /* If we have (and (lshiftrt FOO C1) C2) where the combination of the
8301          shift and AND produces only copies of the sign bit (C2 is one less
8302          than a power of two), we can do this with just a shift.  */
8303
8304       if (GET_CODE (x) == LSHIFTRT
8305           && CONST_INT_P (XEXP (x, 1))
8306           /* The shift puts one of the sign bit copies in the least significant
8307              bit.  */
8308           && ((INTVAL (XEXP (x, 1))
8309                + num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0))))
8310               >= GET_MODE_BITSIZE (GET_MODE (x)))
8311           && exact_log2 (mask + 1) >= 0
8312           /* Number of bits left after the shift must be more than the mask
8313              needs.  */
8314           && ((INTVAL (XEXP (x, 1)) + exact_log2 (mask + 1))
8315               <= GET_MODE_BITSIZE (GET_MODE (x)))
8316           /* Must be more sign bit copies than the mask needs.  */
8317           && ((int) num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
8318               >= exact_log2 (mask + 1)))
8319         x = simplify_gen_binary (LSHIFTRT, GET_MODE (x), XEXP (x, 0),
8320                                  GEN_INT (GET_MODE_BITSIZE (GET_MODE (x))
8321                                           - exact_log2 (mask + 1)));
8322
8323       goto shiftrt;
8324
8325     case ASHIFTRT:
8326       /* If we are just looking for the sign bit, we don't need this shift at
8327          all, even if it has a variable count.  */
8328       if (GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
8329           && (mask == ((unsigned HOST_WIDE_INT) 1
8330                        << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
8331         return force_to_mode (XEXP (x, 0), mode, mask, next_select);
8332
8333       /* If this is a shift by a constant, get a mask that contains those bits
8334          that are not copies of the sign bit.  We then have two cases:  If
8335          MASK only includes those bits, this can be a logical shift, which may
8336          allow simplifications.  If MASK is a single-bit field not within
8337          those bits, we are requesting a copy of the sign bit and hence can
8338          shift the sign bit to the appropriate location.  */
8339
8340       if (CONST_INT_P (XEXP (x, 1)) && INTVAL (XEXP (x, 1)) >= 0
8341           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
8342         {
8343           int i;
8344
8345           /* If the considered data is wider than HOST_WIDE_INT, we can't
8346              represent a mask for all its bits in a single scalar.
8347              But we only care about the lower bits, so calculate these.  */
8348
8349           if (GET_MODE_BITSIZE (GET_MODE (x)) > HOST_BITS_PER_WIDE_INT)
8350             {
8351               nonzero = ~(unsigned HOST_WIDE_INT) 0;
8352
8353               /* GET_MODE_BITSIZE (GET_MODE (x)) - INTVAL (XEXP (x, 1))
8354                  is the number of bits a full-width mask would have set.
8355                  We need only shift if these are fewer than nonzero can
8356                  hold.  If not, we must keep all bits set in nonzero.  */
8357
8358               if (GET_MODE_BITSIZE (GET_MODE (x)) - INTVAL (XEXP (x, 1))
8359                   < HOST_BITS_PER_WIDE_INT)
8360                 nonzero >>= INTVAL (XEXP (x, 1))
8361                             + HOST_BITS_PER_WIDE_INT
8362                             - GET_MODE_BITSIZE (GET_MODE (x)) ;
8363             }
8364           else
8365             {
8366               nonzero = GET_MODE_MASK (GET_MODE (x));
8367               nonzero >>= INTVAL (XEXP (x, 1));
8368             }
8369
8370           if ((mask & ~nonzero) == 0)
8371             {
8372               x = simplify_shift_const (NULL_RTX, LSHIFTRT, GET_MODE (x),
8373                                         XEXP (x, 0), INTVAL (XEXP (x, 1)));
8374               if (GET_CODE (x) != ASHIFTRT)
8375                 return force_to_mode (x, mode, mask, next_select);
8376             }
8377
8378           else if ((i = exact_log2 (mask)) >= 0)
8379             {
8380               x = simplify_shift_const
8381                   (NULL_RTX, LSHIFTRT, GET_MODE (x), XEXP (x, 0),
8382                    GET_MODE_BITSIZE (GET_MODE (x)) - 1 - i);
8383
8384               if (GET_CODE (x) != ASHIFTRT)
8385                 return force_to_mode (x, mode, mask, next_select);
8386             }
8387         }
8388
8389       /* If MASK is 1, convert this to an LSHIFTRT.  This can be done
8390          even if the shift count isn't a constant.  */
8391       if (mask == 1)
8392         x = simplify_gen_binary (LSHIFTRT, GET_MODE (x),
8393                                  XEXP (x, 0), XEXP (x, 1));
8394
8395     shiftrt:
8396
8397       /* If this is a zero- or sign-extension operation that just affects bits
8398          we don't care about, remove it.  Be sure the call above returned
8399          something that is still a shift.  */
8400
8401       if ((GET_CODE (x) == LSHIFTRT || GET_CODE (x) == ASHIFTRT)
8402           && CONST_INT_P (XEXP (x, 1))
8403           && INTVAL (XEXP (x, 1)) >= 0
8404           && (INTVAL (XEXP (x, 1))
8405               <= GET_MODE_BITSIZE (GET_MODE (x)) - (floor_log2 (mask) + 1))
8406           && GET_CODE (XEXP (x, 0)) == ASHIFT
8407           && XEXP (XEXP (x, 0), 1) == XEXP (x, 1))
8408         return force_to_mode (XEXP (XEXP (x, 0), 0), mode, mask,
8409                               next_select);
8410
8411       break;
8412
8413     case ROTATE:
8414     case ROTATERT:
8415       /* If the shift count is constant and we can do computations
8416          in the mode of X, compute where the bits we care about are.
8417          Otherwise, we can't do anything.  Don't change the mode of
8418          the shift or propagate MODE into the shift, though.  */
8419       if (CONST_INT_P (XEXP (x, 1))
8420           && INTVAL (XEXP (x, 1)) >= 0)
8421         {
8422           temp = simplify_binary_operation (code == ROTATE ? ROTATERT : ROTATE,
8423                                             GET_MODE (x), GEN_INT (mask),
8424                                             XEXP (x, 1));
8425           if (temp && CONST_INT_P (temp))
8426             SUBST (XEXP (x, 0),
8427                    force_to_mode (XEXP (x, 0), GET_MODE (x),
8428                                   INTVAL (temp), next_select));
8429         }
8430       break;
8431
8432     case NEG:
8433       /* If we just want the low-order bit, the NEG isn't needed since it
8434          won't change the low-order bit.  */
8435       if (mask == 1)
8436         return force_to_mode (XEXP (x, 0), mode, mask, just_select);
8437
8438       /* We need any bits less significant than the most significant bit in
8439          MASK since carries from those bits will affect the bits we are
8440          interested in.  */
8441       mask = fuller_mask;
8442       goto unop;
8443
8444     case NOT:
8445       /* (not FOO) is (xor FOO CONST), so if FOO is an LSHIFTRT, we can do the
8446          same as the XOR case above.  Ensure that the constant we form is not
8447          wider than the mode of X.  */
8448
8449       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
8450           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
8451           && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
8452           && (INTVAL (XEXP (XEXP (x, 0), 1)) + floor_log2 (mask)
8453               < GET_MODE_BITSIZE (GET_MODE (x)))
8454           && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT)
8455         {
8456           temp = gen_int_mode (mask << INTVAL (XEXP (XEXP (x, 0), 1)),
8457                                GET_MODE (x));
8458           temp = simplify_gen_binary (XOR, GET_MODE (x),
8459                                       XEXP (XEXP (x, 0), 0), temp);
8460           x = simplify_gen_binary (LSHIFTRT, GET_MODE (x),
8461                                    temp, XEXP (XEXP (x, 0), 1));
8462
8463           return force_to_mode (x, mode, mask, next_select);
8464         }
8465
8466       /* (and (not FOO) CONST) is (not (or FOO (not CONST))), so we must
8467          use the full mask inside the NOT.  */
8468       mask = fuller_mask;
8469
8470     unop:
8471       op0 = gen_lowpart_or_truncate (op_mode,
8472                                      force_to_mode (XEXP (x, 0), mode, mask,
8473                                                     next_select));
8474       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0))
8475         x = simplify_gen_unary (code, op_mode, op0, op_mode);
8476       break;
8477
8478     case NE:
8479       /* (and (ne FOO 0) CONST) can be (and FOO CONST) if CONST is included
8480          in STORE_FLAG_VALUE and FOO has a single bit that might be nonzero,
8481          which is equal to STORE_FLAG_VALUE.  */
8482       if ((mask & ~STORE_FLAG_VALUE) == 0
8483           && XEXP (x, 1) == const0_rtx
8484           && GET_MODE (XEXP (x, 0)) == mode
8485           && exact_log2 (nonzero_bits (XEXP (x, 0), mode)) >= 0
8486           && (nonzero_bits (XEXP (x, 0), mode)
8487               == (unsigned HOST_WIDE_INT) STORE_FLAG_VALUE))
8488         return force_to_mode (XEXP (x, 0), mode, mask, next_select);
8489
8490       break;
8491
8492     case IF_THEN_ELSE:
8493       /* We have no way of knowing if the IF_THEN_ELSE can itself be
8494          written in a narrower mode.  We play it safe and do not do so.  */
8495
8496       SUBST (XEXP (x, 1),
8497              gen_lowpart_or_truncate (GET_MODE (x),
8498                                       force_to_mode (XEXP (x, 1), mode,
8499                                                      mask, next_select)));
8500       SUBST (XEXP (x, 2),
8501              gen_lowpart_or_truncate (GET_MODE (x),
8502                                       force_to_mode (XEXP (x, 2), mode,
8503                                                      mask, next_select)));
8504       break;
8505
8506     default:
8507       break;
8508     }
8509
8510   /* Ensure we return a value of the proper mode.  */
8511   return gen_lowpart_or_truncate (mode, x);
8512 }
8513 \f
8514 /* Return nonzero if X is an expression that has one of two values depending on
8515    whether some other value is zero or nonzero.  In that case, we return the
8516    value that is being tested, *PTRUE is set to the value if the rtx being
8517    returned has a nonzero value, and *PFALSE is set to the other alternative.
8518
8519    If we return zero, we set *PTRUE and *PFALSE to X.  */
8520
8521 static rtx
8522 if_then_else_cond (rtx x, rtx *ptrue, rtx *pfalse)
8523 {
8524   enum machine_mode mode = GET_MODE (x);
8525   enum rtx_code code = GET_CODE (x);
8526   rtx cond0, cond1, true0, true1, false0, false1;
8527   unsigned HOST_WIDE_INT nz;
8528
8529   /* If we are comparing a value against zero, we are done.  */
8530   if ((code == NE || code == EQ)
8531       && XEXP (x, 1) == const0_rtx)
8532     {
8533       *ptrue = (code == NE) ? const_true_rtx : const0_rtx;
8534       *pfalse = (code == NE) ? const0_rtx : const_true_rtx;
8535       return XEXP (x, 0);
8536     }
8537
8538   /* If this is a unary operation whose operand has one of two values, apply
8539      our opcode to compute those values.  */
8540   else if (UNARY_P (x)
8541            && (cond0 = if_then_else_cond (XEXP (x, 0), &true0, &false0)) != 0)
8542     {
8543       *ptrue = simplify_gen_unary (code, mode, true0, GET_MODE (XEXP (x, 0)));
8544       *pfalse = simplify_gen_unary (code, mode, false0,
8545                                     GET_MODE (XEXP (x, 0)));
8546       return cond0;
8547     }
8548
8549   /* If this is a COMPARE, do nothing, since the IF_THEN_ELSE we would
8550      make can't possibly match and would suppress other optimizations.  */
8551   else if (code == COMPARE)
8552     ;
8553
8554   /* If this is a binary operation, see if either side has only one of two
8555      values.  If either one does or if both do and they are conditional on
8556      the same value, compute the new true and false values.  */
8557   else if (BINARY_P (x))
8558     {
8559       cond0 = if_then_else_cond (XEXP (x, 0), &true0, &false0);
8560       cond1 = if_then_else_cond (XEXP (x, 1), &true1, &false1);
8561
8562       if ((cond0 != 0 || cond1 != 0)
8563           && ! (cond0 != 0 && cond1 != 0 && ! rtx_equal_p (cond0, cond1)))
8564         {
8565           /* If if_then_else_cond returned zero, then true/false are the
8566              same rtl.  We must copy one of them to prevent invalid rtl
8567              sharing.  */
8568           if (cond0 == 0)
8569             true0 = copy_rtx (true0);
8570           else if (cond1 == 0)
8571             true1 = copy_rtx (true1);
8572
8573           if (COMPARISON_P (x))
8574             {
8575               *ptrue = simplify_gen_relational (code, mode, VOIDmode,
8576                                                 true0, true1);
8577               *pfalse = simplify_gen_relational (code, mode, VOIDmode,
8578                                                  false0, false1);
8579              }
8580           else
8581             {
8582               *ptrue = simplify_gen_binary (code, mode, true0, true1);
8583               *pfalse = simplify_gen_binary (code, mode, false0, false1);
8584             }
8585
8586           return cond0 ? cond0 : cond1;
8587         }
8588
8589       /* See if we have PLUS, IOR, XOR, MINUS or UMAX, where one of the
8590          operands is zero when the other is nonzero, and vice-versa,
8591          and STORE_FLAG_VALUE is 1 or -1.  */
8592
8593       if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
8594           && (code == PLUS || code == IOR || code == XOR || code == MINUS
8595               || code == UMAX)
8596           && GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == MULT)
8597         {
8598           rtx op0 = XEXP (XEXP (x, 0), 1);
8599           rtx op1 = XEXP (XEXP (x, 1), 1);
8600
8601           cond0 = XEXP (XEXP (x, 0), 0);
8602           cond1 = XEXP (XEXP (x, 1), 0);
8603
8604           if (COMPARISON_P (cond0)
8605               && COMPARISON_P (cond1)
8606               && ((GET_CODE (cond0) == reversed_comparison_code (cond1, NULL)
8607                    && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 0))
8608                    && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 1)))
8609                   || ((swap_condition (GET_CODE (cond0))
8610                        == reversed_comparison_code (cond1, NULL))
8611                       && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 1))
8612                       && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 0))))
8613               && ! side_effects_p (x))
8614             {
8615               *ptrue = simplify_gen_binary (MULT, mode, op0, const_true_rtx);
8616               *pfalse = simplify_gen_binary (MULT, mode,
8617                                              (code == MINUS
8618                                               ? simplify_gen_unary (NEG, mode,
8619                                                                     op1, mode)
8620                                               : op1),
8621                                               const_true_rtx);
8622               return cond0;
8623             }
8624         }
8625
8626       /* Similarly for MULT, AND and UMIN, except that for these the result
8627          is always zero.  */
8628       if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
8629           && (code == MULT || code == AND || code == UMIN)
8630           && GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == MULT)
8631         {
8632           cond0 = XEXP (XEXP (x, 0), 0);
8633           cond1 = XEXP (XEXP (x, 1), 0);
8634
8635           if (COMPARISON_P (cond0)
8636               && COMPARISON_P (cond1)
8637               && ((GET_CODE (cond0) == reversed_comparison_code (cond1, NULL)
8638                    && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 0))
8639                    && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 1)))
8640                   || ((swap_condition (GET_CODE (cond0))
8641                        == reversed_comparison_code (cond1, NULL))
8642                       && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 1))
8643                       && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 0))))
8644               && ! side_effects_p (x))
8645             {
8646               *ptrue = *pfalse = const0_rtx;
8647               return cond0;
8648             }
8649         }
8650     }
8651
8652   else if (code == IF_THEN_ELSE)
8653     {
8654       /* If we have IF_THEN_ELSE already, extract the condition and
8655          canonicalize it if it is NE or EQ.  */
8656       cond0 = XEXP (x, 0);
8657       *ptrue = XEXP (x, 1), *pfalse = XEXP (x, 2);
8658       if (GET_CODE (cond0) == NE && XEXP (cond0, 1) == const0_rtx)
8659         return XEXP (cond0, 0);
8660       else if (GET_CODE (cond0) == EQ && XEXP (cond0, 1) == const0_rtx)
8661         {
8662           *ptrue = XEXP (x, 2), *pfalse = XEXP (x, 1);
8663           return XEXP (cond0, 0);
8664         }
8665       else
8666         return cond0;
8667     }
8668
8669   /* If X is a SUBREG, we can narrow both the true and false values
8670      if the inner expression, if there is a condition.  */
8671   else if (code == SUBREG
8672            && 0 != (cond0 = if_then_else_cond (SUBREG_REG (x),
8673                                                &true0, &false0)))
8674     {
8675       true0 = simplify_gen_subreg (mode, true0,
8676                                    GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
8677       false0 = simplify_gen_subreg (mode, false0,
8678                                     GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
8679       if (true0 && false0)
8680         {
8681           *ptrue = true0;
8682           *pfalse = false0;
8683           return cond0;
8684         }
8685     }
8686
8687   /* If X is a constant, this isn't special and will cause confusions
8688      if we treat it as such.  Likewise if it is equivalent to a constant.  */
8689   else if (CONSTANT_P (x)
8690            || ((cond0 = get_last_value (x)) != 0 && CONSTANT_P (cond0)))
8691     ;
8692
8693   /* If we're in BImode, canonicalize on 0 and STORE_FLAG_VALUE, as that
8694      will be least confusing to the rest of the compiler.  */
8695   else if (mode == BImode)
8696     {
8697       *ptrue = GEN_INT (STORE_FLAG_VALUE), *pfalse = const0_rtx;
8698       return x;
8699     }
8700
8701   /* If X is known to be either 0 or -1, those are the true and
8702      false values when testing X.  */
8703   else if (x == constm1_rtx || x == const0_rtx
8704            || (mode != VOIDmode
8705                && num_sign_bit_copies (x, mode) == GET_MODE_BITSIZE (mode)))
8706     {
8707       *ptrue = constm1_rtx, *pfalse = const0_rtx;
8708       return x;
8709     }
8710
8711   /* Likewise for 0 or a single bit.  */
8712   else if (SCALAR_INT_MODE_P (mode)
8713            && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
8714            && exact_log2 (nz = nonzero_bits (x, mode)) >= 0)
8715     {
8716       *ptrue = gen_int_mode (nz, mode), *pfalse = const0_rtx;
8717       return x;
8718     }
8719
8720   /* Otherwise fail; show no condition with true and false values the same.  */
8721   *ptrue = *pfalse = x;
8722   return 0;
8723 }
8724 \f
8725 /* Return the value of expression X given the fact that condition COND
8726    is known to be true when applied to REG as its first operand and VAL
8727    as its second.  X is known to not be shared and so can be modified in
8728    place.
8729
8730    We only handle the simplest cases, and specifically those cases that
8731    arise with IF_THEN_ELSE expressions.  */
8732
8733 static rtx
8734 known_cond (rtx x, enum rtx_code cond, rtx reg, rtx val)
8735 {
8736   enum rtx_code code = GET_CODE (x);
8737   rtx temp;
8738   const char *fmt;
8739   int i, j;
8740
8741   if (side_effects_p (x))
8742     return x;
8743
8744   /* If either operand of the condition is a floating point value,
8745      then we have to avoid collapsing an EQ comparison.  */
8746   if (cond == EQ
8747       && rtx_equal_p (x, reg)
8748       && ! FLOAT_MODE_P (GET_MODE (x))
8749       && ! FLOAT_MODE_P (GET_MODE (val)))
8750     return val;
8751
8752   if (cond == UNEQ && rtx_equal_p (x, reg))
8753     return val;
8754
8755   /* If X is (abs REG) and we know something about REG's relationship
8756      with zero, we may be able to simplify this.  */
8757
8758   if (code == ABS && rtx_equal_p (XEXP (x, 0), reg) && val == const0_rtx)
8759     switch (cond)
8760       {
8761       case GE:  case GT:  case EQ:
8762         return XEXP (x, 0);
8763       case LT:  case LE:
8764         return simplify_gen_unary (NEG, GET_MODE (XEXP (x, 0)),
8765                                    XEXP (x, 0),
8766                                    GET_MODE (XEXP (x, 0)));
8767       default:
8768         break;
8769       }
8770
8771   /* The only other cases we handle are MIN, MAX, and comparisons if the
8772      operands are the same as REG and VAL.  */
8773
8774   else if (COMPARISON_P (x) || COMMUTATIVE_ARITH_P (x))
8775     {
8776       if (rtx_equal_p (XEXP (x, 0), val))
8777         cond = swap_condition (cond), temp = val, val = reg, reg = temp;
8778
8779       if (rtx_equal_p (XEXP (x, 0), reg) && rtx_equal_p (XEXP (x, 1), val))
8780         {
8781           if (COMPARISON_P (x))
8782             {
8783               if (comparison_dominates_p (cond, code))
8784                 return const_true_rtx;
8785
8786               code = reversed_comparison_code (x, NULL);
8787               if (code != UNKNOWN
8788                   && comparison_dominates_p (cond, code))
8789                 return const0_rtx;
8790               else
8791                 return x;
8792             }
8793           else if (code == SMAX || code == SMIN
8794                    || code == UMIN || code == UMAX)
8795             {
8796               int unsignedp = (code == UMIN || code == UMAX);
8797
8798               /* Do not reverse the condition when it is NE or EQ.
8799                  This is because we cannot conclude anything about
8800                  the value of 'SMAX (x, y)' when x is not equal to y,
8801                  but we can when x equals y.  */
8802               if ((code == SMAX || code == UMAX)
8803                   && ! (cond == EQ || cond == NE))
8804                 cond = reverse_condition (cond);
8805
8806               switch (cond)
8807                 {
8808                 case GE:   case GT:
8809                   return unsignedp ? x : XEXP (x, 1);
8810                 case LE:   case LT:
8811                   return unsignedp ? x : XEXP (x, 0);
8812                 case GEU:  case GTU:
8813                   return unsignedp ? XEXP (x, 1) : x;
8814                 case LEU:  case LTU:
8815                   return unsignedp ? XEXP (x, 0) : x;
8816                 default:
8817                   break;
8818                 }
8819             }
8820         }
8821     }
8822   else if (code == SUBREG)
8823     {
8824       enum machine_mode inner_mode = GET_MODE (SUBREG_REG (x));
8825       rtx new_rtx, r = known_cond (SUBREG_REG (x), cond, reg, val);
8826
8827       if (SUBREG_REG (x) != r)
8828         {
8829           /* We must simplify subreg here, before we lose track of the
8830              original inner_mode.  */
8831           new_rtx = simplify_subreg (GET_MODE (x), r,
8832                                  inner_mode, SUBREG_BYTE (x));
8833           if (new_rtx)
8834             return new_rtx;
8835           else
8836             SUBST (SUBREG_REG (x), r);
8837         }
8838
8839       return x;
8840     }
8841   /* We don't have to handle SIGN_EXTEND here, because even in the
8842      case of replacing something with a modeless CONST_INT, a
8843      CONST_INT is already (supposed to be) a valid sign extension for
8844      its narrower mode, which implies it's already properly
8845      sign-extended for the wider mode.  Now, for ZERO_EXTEND, the
8846      story is different.  */
8847   else if (code == ZERO_EXTEND)
8848     {
8849       enum machine_mode inner_mode = GET_MODE (XEXP (x, 0));
8850       rtx new_rtx, r = known_cond (XEXP (x, 0), cond, reg, val);
8851
8852       if (XEXP (x, 0) != r)
8853         {
8854           /* We must simplify the zero_extend here, before we lose
8855              track of the original inner_mode.  */
8856           new_rtx = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
8857                                           r, inner_mode);
8858           if (new_rtx)
8859             return new_rtx;
8860           else
8861             SUBST (XEXP (x, 0), r);
8862         }
8863
8864       return x;
8865     }
8866
8867   fmt = GET_RTX_FORMAT (code);
8868   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
8869     {
8870       if (fmt[i] == 'e')
8871         SUBST (XEXP (x, i), known_cond (XEXP (x, i), cond, reg, val));
8872       else if (fmt[i] == 'E')
8873         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
8874           SUBST (XVECEXP (x, i, j), known_cond (XVECEXP (x, i, j),
8875                                                 cond, reg, val));
8876     }
8877
8878   return x;
8879 }
8880 \f
8881 /* See if X and Y are equal for the purposes of seeing if we can rewrite an
8882    assignment as a field assignment.  */
8883
8884 static int
8885 rtx_equal_for_field_assignment_p (rtx x, rtx y)
8886 {
8887   if (x == y || rtx_equal_p (x, y))
8888     return 1;
8889
8890   if (x == 0 || y == 0 || GET_MODE (x) != GET_MODE (y))
8891     return 0;
8892
8893   /* Check for a paradoxical SUBREG of a MEM compared with the MEM.
8894      Note that all SUBREGs of MEM are paradoxical; otherwise they
8895      would have been rewritten.  */
8896   if (MEM_P (x) && GET_CODE (y) == SUBREG
8897       && MEM_P (SUBREG_REG (y))
8898       && rtx_equal_p (SUBREG_REG (y),
8899                       gen_lowpart (GET_MODE (SUBREG_REG (y)), x)))
8900     return 1;
8901
8902   if (MEM_P (y) && GET_CODE (x) == SUBREG
8903       && MEM_P (SUBREG_REG (x))
8904       && rtx_equal_p (SUBREG_REG (x),
8905                       gen_lowpart (GET_MODE (SUBREG_REG (x)), y)))
8906     return 1;
8907
8908   /* We used to see if get_last_value of X and Y were the same but that's
8909      not correct.  In one direction, we'll cause the assignment to have
8910      the wrong destination and in the case, we'll import a register into this
8911      insn that might have already have been dead.   So fail if none of the
8912      above cases are true.  */
8913   return 0;
8914 }
8915 \f
8916 /* See if X, a SET operation, can be rewritten as a bit-field assignment.
8917    Return that assignment if so.
8918
8919    We only handle the most common cases.  */
8920
8921 static rtx
8922 make_field_assignment (rtx x)
8923 {
8924   rtx dest = SET_DEST (x);
8925   rtx src = SET_SRC (x);
8926   rtx assign;
8927   rtx rhs, lhs;
8928   HOST_WIDE_INT c1;
8929   HOST_WIDE_INT pos;
8930   unsigned HOST_WIDE_INT len;
8931   rtx other;
8932   enum machine_mode mode;
8933
8934   /* If SRC was (and (not (ashift (const_int 1) POS)) DEST), this is
8935      a clear of a one-bit field.  We will have changed it to
8936      (and (rotate (const_int -2) POS) DEST), so check for that.  Also check
8937      for a SUBREG.  */
8938
8939   if (GET_CODE (src) == AND && GET_CODE (XEXP (src, 0)) == ROTATE
8940       && CONST_INT_P (XEXP (XEXP (src, 0), 0))
8941       && INTVAL (XEXP (XEXP (src, 0), 0)) == -2
8942       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
8943     {
8944       assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
8945                                 1, 1, 1, 0);
8946       if (assign != 0)
8947         return gen_rtx_SET (VOIDmode, assign, const0_rtx);
8948       return x;
8949     }
8950
8951   if (GET_CODE (src) == AND && GET_CODE (XEXP (src, 0)) == SUBREG
8952       && subreg_lowpart_p (XEXP (src, 0))
8953       && (GET_MODE_SIZE (GET_MODE (XEXP (src, 0)))
8954           < GET_MODE_SIZE (GET_MODE (SUBREG_REG (XEXP (src, 0)))))
8955       && GET_CODE (SUBREG_REG (XEXP (src, 0))) == ROTATE
8956       && CONST_INT_P (XEXP (SUBREG_REG (XEXP (src, 0)), 0))
8957       && INTVAL (XEXP (SUBREG_REG (XEXP (src, 0)), 0)) == -2
8958       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
8959     {
8960       assign = make_extraction (VOIDmode, dest, 0,
8961                                 XEXP (SUBREG_REG (XEXP (src, 0)), 1),
8962                                 1, 1, 1, 0);
8963       if (assign != 0)
8964         return gen_rtx_SET (VOIDmode, assign, const0_rtx);
8965       return x;
8966     }
8967
8968   /* If SRC is (ior (ashift (const_int 1) POS) DEST), this is a set of a
8969      one-bit field.  */
8970   if (GET_CODE (src) == IOR && GET_CODE (XEXP (src, 0)) == ASHIFT
8971       && XEXP (XEXP (src, 0), 0) == const1_rtx
8972       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
8973     {
8974       assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
8975                                 1, 1, 1, 0);
8976       if (assign != 0)
8977         return gen_rtx_SET (VOIDmode, assign, const1_rtx);
8978       return x;
8979     }
8980
8981   /* If DEST is already a field assignment, i.e. ZERO_EXTRACT, and the
8982      SRC is an AND with all bits of that field set, then we can discard
8983      the AND.  */
8984   if (GET_CODE (dest) == ZERO_EXTRACT
8985       && CONST_INT_P (XEXP (dest, 1))
8986       && GET_CODE (src) == AND
8987       && CONST_INT_P (XEXP (src, 1)))
8988     {
8989       HOST_WIDE_INT width = INTVAL (XEXP (dest, 1));
8990       unsigned HOST_WIDE_INT and_mask = INTVAL (XEXP (src, 1));
8991       unsigned HOST_WIDE_INT ze_mask;
8992
8993       if (width >= HOST_BITS_PER_WIDE_INT)
8994         ze_mask = -1;
8995       else
8996         ze_mask = ((unsigned HOST_WIDE_INT)1 << width) - 1;
8997
8998       /* Complete overlap.  We can remove the source AND.  */
8999       if ((and_mask & ze_mask) == ze_mask)
9000         return gen_rtx_SET (VOIDmode, dest, XEXP (src, 0));
9001
9002       /* Partial overlap.  We can reduce the source AND.  */
9003       if ((and_mask & ze_mask) != and_mask)
9004         {
9005           mode = GET_MODE (src);
9006           src = gen_rtx_AND (mode, XEXP (src, 0),
9007                              gen_int_mode (and_mask & ze_mask, mode));
9008           return gen_rtx_SET (VOIDmode, dest, src);
9009         }
9010     }
9011
9012   /* The other case we handle is assignments into a constant-position
9013      field.  They look like (ior/xor (and DEST C1) OTHER).  If C1 represents
9014      a mask that has all one bits except for a group of zero bits and
9015      OTHER is known to have zeros where C1 has ones, this is such an
9016      assignment.  Compute the position and length from C1.  Shift OTHER
9017      to the appropriate position, force it to the required mode, and
9018      make the extraction.  Check for the AND in both operands.  */
9019
9020   if (GET_CODE (src) != IOR && GET_CODE (src) != XOR)
9021     return x;
9022
9023   rhs = expand_compound_operation (XEXP (src, 0));
9024   lhs = expand_compound_operation (XEXP (src, 1));
9025
9026   if (GET_CODE (rhs) == AND
9027       && CONST_INT_P (XEXP (rhs, 1))
9028       && rtx_equal_for_field_assignment_p (XEXP (rhs, 0), dest))
9029     c1 = INTVAL (XEXP (rhs, 1)), other = lhs;
9030   else if (GET_CODE (lhs) == AND
9031            && CONST_INT_P (XEXP (lhs, 1))
9032            && rtx_equal_for_field_assignment_p (XEXP (lhs, 0), dest))
9033     c1 = INTVAL (XEXP (lhs, 1)), other = rhs;
9034   else
9035     return x;
9036
9037   pos = get_pos_from_mask ((~c1) & GET_MODE_MASK (GET_MODE (dest)), &len);
9038   if (pos < 0 || pos + len > GET_MODE_BITSIZE (GET_MODE (dest))
9039       || GET_MODE_BITSIZE (GET_MODE (dest)) > HOST_BITS_PER_WIDE_INT
9040       || (c1 & nonzero_bits (other, GET_MODE (dest))) != 0)
9041     return x;
9042
9043   assign = make_extraction (VOIDmode, dest, pos, NULL_RTX, len, 1, 1, 0);
9044   if (assign == 0)
9045     return x;
9046
9047   /* The mode to use for the source is the mode of the assignment, or of
9048      what is inside a possible STRICT_LOW_PART.  */
9049   mode = (GET_CODE (assign) == STRICT_LOW_PART
9050           ? GET_MODE (XEXP (assign, 0)) : GET_MODE (assign));
9051
9052   /* Shift OTHER right POS places and make it the source, restricting it
9053      to the proper length and mode.  */
9054
9055   src = canon_reg_for_combine (simplify_shift_const (NULL_RTX, LSHIFTRT,
9056                                                      GET_MODE (src),
9057                                                      other, pos),
9058                                dest);
9059   src = force_to_mode (src, mode,
9060                        GET_MODE_BITSIZE (mode) >= HOST_BITS_PER_WIDE_INT
9061                        ? ~(unsigned HOST_WIDE_INT) 0
9062                        : ((unsigned HOST_WIDE_INT) 1 << len) - 1,
9063                        0);
9064
9065   /* If SRC is masked by an AND that does not make a difference in
9066      the value being stored, strip it.  */
9067   if (GET_CODE (assign) == ZERO_EXTRACT
9068       && CONST_INT_P (XEXP (assign, 1))
9069       && INTVAL (XEXP (assign, 1)) < HOST_BITS_PER_WIDE_INT
9070       && GET_CODE (src) == AND
9071       && CONST_INT_P (XEXP (src, 1))
9072       && UINTVAL (XEXP (src, 1))
9073          == ((unsigned HOST_WIDE_INT) 1 << INTVAL (XEXP (assign, 1))) - 1)
9074     src = XEXP (src, 0);
9075
9076   return gen_rtx_SET (VOIDmode, assign, src);
9077 }
9078 \f
9079 /* See if X is of the form (+ (* a c) (* b c)) and convert to (* (+ a b) c)
9080    if so.  */
9081
9082 static rtx
9083 apply_distributive_law (rtx x)
9084 {
9085   enum rtx_code code = GET_CODE (x);
9086   enum rtx_code inner_code;
9087   rtx lhs, rhs, other;
9088   rtx tem;
9089
9090   /* Distributivity is not true for floating point as it can change the
9091      value.  So we don't do it unless -funsafe-math-optimizations.  */
9092   if (FLOAT_MODE_P (GET_MODE (x))
9093       && ! flag_unsafe_math_optimizations)
9094     return x;
9095
9096   /* The outer operation can only be one of the following:  */
9097   if (code != IOR && code != AND && code != XOR
9098       && code != PLUS && code != MINUS)
9099     return x;
9100
9101   lhs = XEXP (x, 0);
9102   rhs = XEXP (x, 1);
9103
9104   /* If either operand is a primitive we can't do anything, so get out
9105      fast.  */
9106   if (OBJECT_P (lhs) || OBJECT_P (rhs))
9107     return x;
9108
9109   lhs = expand_compound_operation (lhs);
9110   rhs = expand_compound_operation (rhs);
9111   inner_code = GET_CODE (lhs);
9112   if (inner_code != GET_CODE (rhs))
9113     return x;
9114
9115   /* See if the inner and outer operations distribute.  */
9116   switch (inner_code)
9117     {
9118     case LSHIFTRT:
9119     case ASHIFTRT:
9120     case AND:
9121     case IOR:
9122       /* These all distribute except over PLUS.  */
9123       if (code == PLUS || code == MINUS)
9124         return x;
9125       break;
9126
9127     case MULT:
9128       if (code != PLUS && code != MINUS)
9129         return x;
9130       break;
9131
9132     case ASHIFT:
9133       /* This is also a multiply, so it distributes over everything.  */
9134       break;
9135
9136     case SUBREG:
9137       /* Non-paradoxical SUBREGs distributes over all operations,
9138          provided the inner modes and byte offsets are the same, this
9139          is an extraction of a low-order part, we don't convert an fp
9140          operation to int or vice versa, this is not a vector mode,
9141          and we would not be converting a single-word operation into a
9142          multi-word operation.  The latter test is not required, but
9143          it prevents generating unneeded multi-word operations.  Some
9144          of the previous tests are redundant given the latter test,
9145          but are retained because they are required for correctness.
9146
9147          We produce the result slightly differently in this case.  */
9148
9149       if (GET_MODE (SUBREG_REG (lhs)) != GET_MODE (SUBREG_REG (rhs))
9150           || SUBREG_BYTE (lhs) != SUBREG_BYTE (rhs)
9151           || ! subreg_lowpart_p (lhs)
9152           || (GET_MODE_CLASS (GET_MODE (lhs))
9153               != GET_MODE_CLASS (GET_MODE (SUBREG_REG (lhs))))
9154           || (GET_MODE_SIZE (GET_MODE (lhs))
9155               > GET_MODE_SIZE (GET_MODE (SUBREG_REG (lhs))))
9156           || VECTOR_MODE_P (GET_MODE (lhs))
9157           || GET_MODE_SIZE (GET_MODE (SUBREG_REG (lhs))) > UNITS_PER_WORD
9158           /* Result might need to be truncated.  Don't change mode if
9159              explicit truncation is needed.  */
9160           || !TRULY_NOOP_TRUNCATION
9161                (GET_MODE_BITSIZE (GET_MODE (x)),
9162                 GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (lhs)))))
9163         return x;
9164
9165       tem = simplify_gen_binary (code, GET_MODE (SUBREG_REG (lhs)),
9166                                  SUBREG_REG (lhs), SUBREG_REG (rhs));
9167       return gen_lowpart (GET_MODE (x), tem);
9168
9169     default:
9170       return x;
9171     }
9172
9173   /* Set LHS and RHS to the inner operands (A and B in the example
9174      above) and set OTHER to the common operand (C in the example).
9175      There is only one way to do this unless the inner operation is
9176      commutative.  */
9177   if (COMMUTATIVE_ARITH_P (lhs)
9178       && rtx_equal_p (XEXP (lhs, 0), XEXP (rhs, 0)))
9179     other = XEXP (lhs, 0), lhs = XEXP (lhs, 1), rhs = XEXP (rhs, 1);
9180   else if (COMMUTATIVE_ARITH_P (lhs)
9181            && rtx_equal_p (XEXP (lhs, 0), XEXP (rhs, 1)))
9182     other = XEXP (lhs, 0), lhs = XEXP (lhs, 1), rhs = XEXP (rhs, 0);
9183   else if (COMMUTATIVE_ARITH_P (lhs)
9184            && rtx_equal_p (XEXP (lhs, 1), XEXP (rhs, 0)))
9185     other = XEXP (lhs, 1), lhs = XEXP (lhs, 0), rhs = XEXP (rhs, 1);
9186   else if (rtx_equal_p (XEXP (lhs, 1), XEXP (rhs, 1)))
9187     other = XEXP (lhs, 1), lhs = XEXP (lhs, 0), rhs = XEXP (rhs, 0);
9188   else
9189     return x;
9190
9191   /* Form the new inner operation, seeing if it simplifies first.  */
9192   tem = simplify_gen_binary (code, GET_MODE (x), lhs, rhs);
9193
9194   /* There is one exception to the general way of distributing:
9195      (a | c) ^ (b | c) -> (a ^ b) & ~c  */
9196   if (code == XOR && inner_code == IOR)
9197     {
9198       inner_code = AND;
9199       other = simplify_gen_unary (NOT, GET_MODE (x), other, GET_MODE (x));
9200     }
9201
9202   /* We may be able to continuing distributing the result, so call
9203      ourselves recursively on the inner operation before forming the
9204      outer operation, which we return.  */
9205   return simplify_gen_binary (inner_code, GET_MODE (x),
9206                               apply_distributive_law (tem), other);
9207 }
9208
9209 /* See if X is of the form (* (+ A B) C), and if so convert to
9210    (+ (* A C) (* B C)) and try to simplify.
9211
9212    Most of the time, this results in no change.  However, if some of
9213    the operands are the same or inverses of each other, simplifications
9214    will result.
9215
9216    For example, (and (ior A B) (not B)) can occur as the result of
9217    expanding a bit field assignment.  When we apply the distributive
9218    law to this, we get (ior (and (A (not B))) (and (B (not B)))),
9219    which then simplifies to (and (A (not B))).
9220
9221    Note that no checks happen on the validity of applying the inverse
9222    distributive law.  This is pointless since we can do it in the
9223    few places where this routine is called.
9224
9225    N is the index of the term that is decomposed (the arithmetic operation,
9226    i.e. (+ A B) in the first example above).  !N is the index of the term that
9227    is distributed, i.e. of C in the first example above.  */
9228 static rtx
9229 distribute_and_simplify_rtx (rtx x, int n)
9230 {
9231   enum machine_mode mode;
9232   enum rtx_code outer_code, inner_code;
9233   rtx decomposed, distributed, inner_op0, inner_op1, new_op0, new_op1, tmp;
9234
9235   /* Distributivity is not true for floating point as it can change the
9236      value.  So we don't do it unless -funsafe-math-optimizations.  */
9237   if (FLOAT_MODE_P (GET_MODE (x))
9238       && ! flag_unsafe_math_optimizations)
9239     return NULL_RTX;
9240
9241   decomposed = XEXP (x, n);
9242   if (!ARITHMETIC_P (decomposed))
9243     return NULL_RTX;
9244
9245   mode = GET_MODE (x);
9246   outer_code = GET_CODE (x);
9247   distributed = XEXP (x, !n);
9248
9249   inner_code = GET_CODE (decomposed);
9250   inner_op0 = XEXP (decomposed, 0);
9251   inner_op1 = XEXP (decomposed, 1);
9252
9253   /* Special case (and (xor B C) (not A)), which is equivalent to
9254      (xor (ior A B) (ior A C))  */
9255   if (outer_code == AND && inner_code == XOR && GET_CODE (distributed) == NOT)
9256     {
9257       distributed = XEXP (distributed, 0);
9258       outer_code = IOR;
9259     }
9260
9261   if (n == 0)
9262     {
9263       /* Distribute the second term.  */
9264       new_op0 = simplify_gen_binary (outer_code, mode, inner_op0, distributed);
9265       new_op1 = simplify_gen_binary (outer_code, mode, inner_op1, distributed);
9266     }
9267   else
9268     {
9269       /* Distribute the first term.  */
9270       new_op0 = simplify_gen_binary (outer_code, mode, distributed, inner_op0);
9271       new_op1 = simplify_gen_binary (outer_code, mode, distributed, inner_op1);
9272     }
9273
9274   tmp = apply_distributive_law (simplify_gen_binary (inner_code, mode,
9275                                                      new_op0, new_op1));
9276   if (GET_CODE (tmp) != outer_code
9277       && rtx_cost (tmp, SET, optimize_this_for_speed_p)
9278          < rtx_cost (x, SET, optimize_this_for_speed_p))
9279     return tmp;
9280
9281   return NULL_RTX;
9282 }
9283 \f
9284 /* Simplify a logical `and' of VAROP with the constant CONSTOP, to be done
9285    in MODE.  Return an equivalent form, if different from (and VAROP
9286    (const_int CONSTOP)).  Otherwise, return NULL_RTX.  */
9287
9288 static rtx
9289 simplify_and_const_int_1 (enum machine_mode mode, rtx varop,
9290                           unsigned HOST_WIDE_INT constop)
9291 {
9292   unsigned HOST_WIDE_INT nonzero;
9293   unsigned HOST_WIDE_INT orig_constop;
9294   rtx orig_varop;
9295   int i;
9296
9297   orig_varop = varop;
9298   orig_constop = constop;
9299   if (GET_CODE (varop) == CLOBBER)
9300     return NULL_RTX;
9301
9302   /* Simplify VAROP knowing that we will be only looking at some of the
9303      bits in it.
9304
9305      Note by passing in CONSTOP, we guarantee that the bits not set in
9306      CONSTOP are not significant and will never be examined.  We must
9307      ensure that is the case by explicitly masking out those bits
9308      before returning.  */
9309   varop = force_to_mode (varop, mode, constop, 0);
9310
9311   /* If VAROP is a CLOBBER, we will fail so return it.  */
9312   if (GET_CODE (varop) == CLOBBER)
9313     return varop;
9314
9315   /* If VAROP is a CONST_INT, then we need to apply the mask in CONSTOP
9316      to VAROP and return the new constant.  */
9317   if (CONST_INT_P (varop))
9318     return gen_int_mode (INTVAL (varop) & constop, mode);
9319
9320   /* See what bits may be nonzero in VAROP.  Unlike the general case of
9321      a call to nonzero_bits, here we don't care about bits outside
9322      MODE.  */
9323
9324   nonzero = nonzero_bits (varop, mode) & GET_MODE_MASK (mode);
9325
9326   /* Turn off all bits in the constant that are known to already be zero.
9327      Thus, if the AND isn't needed at all, we will have CONSTOP == NONZERO_BITS
9328      which is tested below.  */
9329
9330   constop &= nonzero;
9331
9332   /* If we don't have any bits left, return zero.  */
9333   if (constop == 0)
9334     return const0_rtx;
9335
9336   /* If VAROP is a NEG of something known to be zero or 1 and CONSTOP is
9337      a power of two, we can replace this with an ASHIFT.  */
9338   if (GET_CODE (varop) == NEG && nonzero_bits (XEXP (varop, 0), mode) == 1
9339       && (i = exact_log2 (constop)) >= 0)
9340     return simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (varop, 0), i);
9341
9342   /* If VAROP is an IOR or XOR, apply the AND to both branches of the IOR
9343      or XOR, then try to apply the distributive law.  This may eliminate
9344      operations if either branch can be simplified because of the AND.
9345      It may also make some cases more complex, but those cases probably
9346      won't match a pattern either with or without this.  */
9347
9348   if (GET_CODE (varop) == IOR || GET_CODE (varop) == XOR)
9349     return
9350       gen_lowpart
9351         (mode,
9352          apply_distributive_law
9353          (simplify_gen_binary (GET_CODE (varop), GET_MODE (varop),
9354                                simplify_and_const_int (NULL_RTX,
9355                                                        GET_MODE (varop),
9356                                                        XEXP (varop, 0),
9357                                                        constop),
9358                                simplify_and_const_int (NULL_RTX,
9359                                                        GET_MODE (varop),
9360                                                        XEXP (varop, 1),
9361                                                        constop))));
9362
9363   /* If VAROP is PLUS, and the constant is a mask of low bits, distribute
9364      the AND and see if one of the operands simplifies to zero.  If so, we
9365      may eliminate it.  */
9366
9367   if (GET_CODE (varop) == PLUS
9368       && exact_log2 (constop + 1) >= 0)
9369     {
9370       rtx o0, o1;
9371
9372       o0 = simplify_and_const_int (NULL_RTX, mode, XEXP (varop, 0), constop);
9373       o1 = simplify_and_const_int (NULL_RTX, mode, XEXP (varop, 1), constop);
9374       if (o0 == const0_rtx)
9375         return o1;
9376       if (o1 == const0_rtx)
9377         return o0;
9378     }
9379
9380   /* Make a SUBREG if necessary.  If we can't make it, fail.  */
9381   varop = gen_lowpart (mode, varop);
9382   if (varop == NULL_RTX || GET_CODE (varop) == CLOBBER)
9383     return NULL_RTX;
9384
9385   /* If we are only masking insignificant bits, return VAROP.  */
9386   if (constop == nonzero)
9387     return varop;
9388
9389   if (varop == orig_varop && constop == orig_constop)
9390     return NULL_RTX;
9391
9392   /* Otherwise, return an AND.  */
9393   return simplify_gen_binary (AND, mode, varop, gen_int_mode (constop, mode));
9394 }
9395
9396
9397 /* We have X, a logical `and' of VAROP with the constant CONSTOP, to be done
9398    in MODE.
9399
9400    Return an equivalent form, if different from X.  Otherwise, return X.  If
9401    X is zero, we are to always construct the equivalent form.  */
9402
9403 static rtx
9404 simplify_and_const_int (rtx x, enum machine_mode mode, rtx varop,
9405                         unsigned HOST_WIDE_INT constop)
9406 {
9407   rtx tem = simplify_and_const_int_1 (mode, varop, constop);
9408   if (tem)
9409     return tem;
9410
9411   if (!x)
9412     x = simplify_gen_binary (AND, GET_MODE (varop), varop,
9413                              gen_int_mode (constop, mode));
9414   if (GET_MODE (x) != mode)
9415     x = gen_lowpart (mode, x);
9416   return x;
9417 }
9418 \f
9419 /* Given a REG, X, compute which bits in X can be nonzero.
9420    We don't care about bits outside of those defined in MODE.
9421
9422    For most X this is simply GET_MODE_MASK (GET_MODE (MODE)), but if X is
9423    a shift, AND, or zero_extract, we can do better.  */
9424
9425 static rtx
9426 reg_nonzero_bits_for_combine (const_rtx x, enum machine_mode mode,
9427                               const_rtx known_x ATTRIBUTE_UNUSED,
9428                               enum machine_mode known_mode ATTRIBUTE_UNUSED,
9429                               unsigned HOST_WIDE_INT known_ret ATTRIBUTE_UNUSED,
9430                               unsigned HOST_WIDE_INT *nonzero)
9431 {
9432   rtx tem;
9433   reg_stat_type *rsp;
9434
9435   /* If X is a register whose nonzero bits value is current, use it.
9436      Otherwise, if X is a register whose value we can find, use that
9437      value.  Otherwise, use the previously-computed global nonzero bits
9438      for this register.  */
9439
9440   rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
9441   if (rsp->last_set_value != 0
9442       && (rsp->last_set_mode == mode
9443           || (GET_MODE_CLASS (rsp->last_set_mode) == MODE_INT
9444               && GET_MODE_CLASS (mode) == MODE_INT))
9445       && ((rsp->last_set_label >= label_tick_ebb_start
9446            && rsp->last_set_label < label_tick)
9447           || (rsp->last_set_label == label_tick
9448               && DF_INSN_LUID (rsp->last_set) < subst_low_luid)
9449           || (REGNO (x) >= FIRST_PSEUDO_REGISTER
9450               && REG_N_SETS (REGNO (x)) == 1
9451               && !REGNO_REG_SET_P
9452                   (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x)))))
9453     {
9454       *nonzero &= rsp->last_set_nonzero_bits;
9455       return NULL;
9456     }
9457
9458   tem = get_last_value (x);
9459
9460   if (tem)
9461     {
9462 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
9463       /* If X is narrower than MODE and TEM is a non-negative
9464          constant that would appear negative in the mode of X,
9465          sign-extend it for use in reg_nonzero_bits because some
9466          machines (maybe most) will actually do the sign-extension
9467          and this is the conservative approach.
9468
9469          ??? For 2.5, try to tighten up the MD files in this regard
9470          instead of this kludge.  */
9471
9472       if (GET_MODE_BITSIZE (GET_MODE (x)) < GET_MODE_BITSIZE (mode)
9473           && CONST_INT_P (tem)
9474           && INTVAL (tem) > 0
9475           && 0 != (UINTVAL (tem)
9476                    & ((unsigned HOST_WIDE_INT) 1
9477                       << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
9478         tem = GEN_INT (UINTVAL (tem)
9479                        | ((unsigned HOST_WIDE_INT) (-1)
9480                           << GET_MODE_BITSIZE (GET_MODE (x))));
9481 #endif
9482       return tem;
9483     }
9484   else if (nonzero_sign_valid && rsp->nonzero_bits)
9485     {
9486       unsigned HOST_WIDE_INT mask = rsp->nonzero_bits;
9487
9488       if (GET_MODE_BITSIZE (GET_MODE (x)) < GET_MODE_BITSIZE (mode))
9489         /* We don't know anything about the upper bits.  */
9490         mask |= GET_MODE_MASK (mode) ^ GET_MODE_MASK (GET_MODE (x));
9491       *nonzero &= mask;
9492     }
9493
9494   return NULL;
9495 }
9496
9497 /* Return the number of bits at the high-order end of X that are known to
9498    be equal to the sign bit.  X will be used in mode MODE; if MODE is
9499    VOIDmode, X will be used in its own mode.  The returned value  will always
9500    be between 1 and the number of bits in MODE.  */
9501
9502 static rtx
9503 reg_num_sign_bit_copies_for_combine (const_rtx x, enum machine_mode mode,
9504                                      const_rtx known_x ATTRIBUTE_UNUSED,
9505                                      enum machine_mode known_mode
9506                                      ATTRIBUTE_UNUSED,
9507                                      unsigned int known_ret ATTRIBUTE_UNUSED,
9508                                      unsigned int *result)
9509 {
9510   rtx tem;
9511   reg_stat_type *rsp;
9512
9513   rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
9514   if (rsp->last_set_value != 0
9515       && rsp->last_set_mode == mode
9516       && ((rsp->last_set_label >= label_tick_ebb_start
9517            && rsp->last_set_label < label_tick)
9518           || (rsp->last_set_label == label_tick
9519               && DF_INSN_LUID (rsp->last_set) < subst_low_luid)
9520           || (REGNO (x) >= FIRST_PSEUDO_REGISTER
9521               && REG_N_SETS (REGNO (x)) == 1
9522               && !REGNO_REG_SET_P
9523                   (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x)))))
9524     {
9525       *result = rsp->last_set_sign_bit_copies;
9526       return NULL;
9527     }
9528
9529   tem = get_last_value (x);
9530   if (tem != 0)
9531     return tem;
9532
9533   if (nonzero_sign_valid && rsp->sign_bit_copies != 0
9534       && GET_MODE_BITSIZE (GET_MODE (x)) == GET_MODE_BITSIZE (mode))
9535     *result = rsp->sign_bit_copies;
9536
9537   return NULL;
9538 }
9539 \f
9540 /* Return the number of "extended" bits there are in X, when interpreted
9541    as a quantity in MODE whose signedness is indicated by UNSIGNEDP.  For
9542    unsigned quantities, this is the number of high-order zero bits.
9543    For signed quantities, this is the number of copies of the sign bit
9544    minus 1.  In both case, this function returns the number of "spare"
9545    bits.  For example, if two quantities for which this function returns
9546    at least 1 are added, the addition is known not to overflow.
9547
9548    This function will always return 0 unless called during combine, which
9549    implies that it must be called from a define_split.  */
9550
9551 unsigned int
9552 extended_count (const_rtx x, enum machine_mode mode, int unsignedp)
9553 {
9554   if (nonzero_sign_valid == 0)
9555     return 0;
9556
9557   return (unsignedp
9558           ? (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9559              ? (unsigned int) (GET_MODE_BITSIZE (mode) - 1
9560                                - floor_log2 (nonzero_bits (x, mode)))
9561              : 0)
9562           : num_sign_bit_copies (x, mode) - 1);
9563 }
9564 \f
9565 /* This function is called from `simplify_shift_const' to merge two
9566    outer operations.  Specifically, we have already found that we need
9567    to perform operation *POP0 with constant *PCONST0 at the outermost
9568    position.  We would now like to also perform OP1 with constant CONST1
9569    (with *POP0 being done last).
9570
9571    Return 1 if we can do the operation and update *POP0 and *PCONST0 with
9572    the resulting operation.  *PCOMP_P is set to 1 if we would need to
9573    complement the innermost operand, otherwise it is unchanged.
9574
9575    MODE is the mode in which the operation will be done.  No bits outside
9576    the width of this mode matter.  It is assumed that the width of this mode
9577    is smaller than or equal to HOST_BITS_PER_WIDE_INT.
9578
9579    If *POP0 or OP1 are UNKNOWN, it means no operation is required.  Only NEG, PLUS,
9580    IOR, XOR, and AND are supported.  We may set *POP0 to SET if the proper
9581    result is simply *PCONST0.
9582
9583    If the resulting operation cannot be expressed as one operation, we
9584    return 0 and do not change *POP0, *PCONST0, and *PCOMP_P.  */
9585
9586 static int
9587 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)
9588 {
9589   enum rtx_code op0 = *pop0;
9590   HOST_WIDE_INT const0 = *pconst0;
9591
9592   const0 &= GET_MODE_MASK (mode);
9593   const1 &= GET_MODE_MASK (mode);
9594
9595   /* If OP0 is an AND, clear unimportant bits in CONST1.  */
9596   if (op0 == AND)
9597     const1 &= const0;
9598
9599   /* If OP0 or OP1 is UNKNOWN, this is easy.  Similarly if they are the same or
9600      if OP0 is SET.  */
9601
9602   if (op1 == UNKNOWN || op0 == SET)
9603     return 1;
9604
9605   else if (op0 == UNKNOWN)
9606     op0 = op1, const0 = const1;
9607
9608   else if (op0 == op1)
9609     {
9610       switch (op0)
9611         {
9612         case AND:
9613           const0 &= const1;
9614           break;
9615         case IOR:
9616           const0 |= const1;
9617           break;
9618         case XOR:
9619           const0 ^= const1;
9620           break;
9621         case PLUS:
9622           const0 += const1;
9623           break;
9624         case NEG:
9625           op0 = UNKNOWN;
9626           break;
9627         default:
9628           break;
9629         }
9630     }
9631
9632   /* Otherwise, if either is a PLUS or NEG, we can't do anything.  */
9633   else if (op0 == PLUS || op1 == PLUS || op0 == NEG || op1 == NEG)
9634     return 0;
9635
9636   /* If the two constants aren't the same, we can't do anything.  The
9637      remaining six cases can all be done.  */
9638   else if (const0 != const1)
9639     return 0;
9640
9641   else
9642     switch (op0)
9643       {
9644       case IOR:
9645         if (op1 == AND)
9646           /* (a & b) | b == b */
9647           op0 = SET;
9648         else /* op1 == XOR */
9649           /* (a ^ b) | b == a | b */
9650           {;}
9651         break;
9652
9653       case XOR:
9654         if (op1 == AND)
9655           /* (a & b) ^ b == (~a) & b */
9656           op0 = AND, *pcomp_p = 1;
9657         else /* op1 == IOR */
9658           /* (a | b) ^ b == a & ~b */
9659           op0 = AND, const0 = ~const0;
9660         break;
9661
9662       case AND:
9663         if (op1 == IOR)
9664           /* (a | b) & b == b */
9665         op0 = SET;
9666         else /* op1 == XOR */
9667           /* (a ^ b) & b) == (~a) & b */
9668           *pcomp_p = 1;
9669         break;
9670       default:
9671         break;
9672       }
9673
9674   /* Check for NO-OP cases.  */
9675   const0 &= GET_MODE_MASK (mode);
9676   if (const0 == 0
9677       && (op0 == IOR || op0 == XOR || op0 == PLUS))
9678     op0 = UNKNOWN;
9679   else if (const0 == 0 && op0 == AND)
9680     op0 = SET;
9681   else if ((unsigned HOST_WIDE_INT) const0 == GET_MODE_MASK (mode)
9682            && op0 == AND)
9683     op0 = UNKNOWN;
9684
9685   *pop0 = op0;
9686
9687   /* ??? Slightly redundant with the above mask, but not entirely.
9688      Moving this above means we'd have to sign-extend the mode mask
9689      for the final test.  */
9690   if (op0 != UNKNOWN && op0 != NEG)
9691     *pconst0 = trunc_int_for_mode (const0, mode);
9692
9693   return 1;
9694 }
9695 \f
9696 /* A helper to simplify_shift_const_1 to determine the mode we can perform
9697    the shift in.  The original shift operation CODE is performed on OP in
9698    ORIG_MODE.  Return the wider mode MODE if we can perform the operation
9699    in that mode.  Return ORIG_MODE otherwise.  We can also assume that the
9700    result of the shift is subject to operation OUTER_CODE with operand
9701    OUTER_CONST.  */
9702
9703 static enum machine_mode
9704 try_widen_shift_mode (enum rtx_code code, rtx op, int count,
9705                       enum machine_mode orig_mode, enum machine_mode mode,
9706                       enum rtx_code outer_code, HOST_WIDE_INT outer_const)
9707 {
9708   if (orig_mode == mode)
9709     return mode;
9710   gcc_assert (GET_MODE_BITSIZE (mode) > GET_MODE_BITSIZE (orig_mode));
9711
9712   /* In general we can't perform in wider mode for right shift and rotate.  */
9713   switch (code)
9714     {
9715     case ASHIFTRT:
9716       /* We can still widen if the bits brought in from the left are identical
9717          to the sign bit of ORIG_MODE.  */
9718       if (num_sign_bit_copies (op, mode)
9719           > (unsigned) (GET_MODE_BITSIZE (mode)
9720                         - GET_MODE_BITSIZE (orig_mode)))
9721         return mode;
9722       return orig_mode;
9723
9724     case LSHIFTRT:
9725       /* Similarly here but with zero bits.  */
9726       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9727           && (nonzero_bits (op, mode) & ~GET_MODE_MASK (orig_mode)) == 0)
9728         return mode;
9729
9730       /* We can also widen if the bits brought in will be masked off.  This
9731          operation is performed in ORIG_MODE.  */
9732       if (outer_code == AND)
9733         {
9734           int care_bits = low_bitmask_len (orig_mode, outer_const);
9735
9736           if (care_bits >= 0
9737               && GET_MODE_BITSIZE (orig_mode) - care_bits >= count)
9738             return mode;
9739         }
9740       /* fall through */
9741
9742     case ROTATE:
9743       return orig_mode;
9744
9745     case ROTATERT:
9746       gcc_unreachable ();
9747
9748     default:
9749       return mode;
9750     }
9751 }
9752
9753 /* Simplify a shift of VAROP by COUNT bits.  CODE says what kind of shift.
9754    The result of the shift is RESULT_MODE.  Return NULL_RTX if we cannot
9755    simplify it.  Otherwise, return a simplified value.
9756
9757    The shift is normally computed in the widest mode we find in VAROP, as
9758    long as it isn't a different number of words than RESULT_MODE.  Exceptions
9759    are ASHIFTRT and ROTATE, which are always done in their original mode.  */
9760
9761 static rtx
9762 simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
9763                         rtx varop, int orig_count)
9764 {
9765   enum rtx_code orig_code = code;
9766   rtx orig_varop = varop;
9767   int count;
9768   enum machine_mode mode = result_mode;
9769   enum machine_mode shift_mode, tmode;
9770   unsigned int mode_words
9771     = (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
9772   /* We form (outer_op (code varop count) (outer_const)).  */
9773   enum rtx_code outer_op = UNKNOWN;
9774   HOST_WIDE_INT outer_const = 0;
9775   int complement_p = 0;
9776   rtx new_rtx, x;
9777
9778   /* Make sure and truncate the "natural" shift on the way in.  We don't
9779      want to do this inside the loop as it makes it more difficult to
9780      combine shifts.  */
9781   if (SHIFT_COUNT_TRUNCATED)
9782     orig_count &= GET_MODE_BITSIZE (mode) - 1;
9783
9784   /* If we were given an invalid count, don't do anything except exactly
9785      what was requested.  */
9786
9787   if (orig_count < 0 || orig_count >= (int) GET_MODE_BITSIZE (mode))
9788     return NULL_RTX;
9789
9790   count = orig_count;
9791
9792   /* Unless one of the branches of the `if' in this loop does a `continue',
9793      we will `break' the loop after the `if'.  */
9794
9795   while (count != 0)
9796     {
9797       /* If we have an operand of (clobber (const_int 0)), fail.  */
9798       if (GET_CODE (varop) == CLOBBER)
9799         return NULL_RTX;
9800
9801       /* Convert ROTATERT to ROTATE.  */
9802       if (code == ROTATERT)
9803         {
9804           unsigned int bitsize = GET_MODE_BITSIZE (result_mode);;
9805           code = ROTATE;
9806           if (VECTOR_MODE_P (result_mode))
9807             count = bitsize / GET_MODE_NUNITS (result_mode) - count;
9808           else
9809             count = bitsize - count;
9810         }
9811
9812       shift_mode = try_widen_shift_mode (code, varop, count, result_mode,
9813                                          mode, outer_op, outer_const);
9814
9815       /* Handle cases where the count is greater than the size of the mode
9816          minus 1.  For ASHIFT, use the size minus one as the count (this can
9817          occur when simplifying (lshiftrt (ashiftrt ..))).  For rotates,
9818          take the count modulo the size.  For other shifts, the result is
9819          zero.
9820
9821          Since these shifts are being produced by the compiler by combining
9822          multiple operations, each of which are defined, we know what the
9823          result is supposed to be.  */
9824
9825       if (count > (GET_MODE_BITSIZE (shift_mode) - 1))
9826         {
9827           if (code == ASHIFTRT)
9828             count = GET_MODE_BITSIZE (shift_mode) - 1;
9829           else if (code == ROTATE || code == ROTATERT)
9830             count %= GET_MODE_BITSIZE (shift_mode);
9831           else
9832             {
9833               /* We can't simply return zero because there may be an
9834                  outer op.  */
9835               varop = const0_rtx;
9836               count = 0;
9837               break;
9838             }
9839         }
9840
9841       /* If we discovered we had to complement VAROP, leave.  Making a NOT
9842          here would cause an infinite loop.  */
9843       if (complement_p)
9844         break;
9845
9846       /* An arithmetic right shift of a quantity known to be -1 or 0
9847          is a no-op.  */
9848       if (code == ASHIFTRT
9849           && (num_sign_bit_copies (varop, shift_mode)
9850               == GET_MODE_BITSIZE (shift_mode)))
9851         {
9852           count = 0;
9853           break;
9854         }
9855
9856       /* If we are doing an arithmetic right shift and discarding all but
9857          the sign bit copies, this is equivalent to doing a shift by the
9858          bitsize minus one.  Convert it into that shift because it will often
9859          allow other simplifications.  */
9860
9861       if (code == ASHIFTRT
9862           && (count + num_sign_bit_copies (varop, shift_mode)
9863               >= GET_MODE_BITSIZE (shift_mode)))
9864         count = GET_MODE_BITSIZE (shift_mode) - 1;
9865
9866       /* We simplify the tests below and elsewhere by converting
9867          ASHIFTRT to LSHIFTRT if we know the sign bit is clear.
9868          `make_compound_operation' will convert it to an ASHIFTRT for
9869          those machines (such as VAX) that don't have an LSHIFTRT.  */
9870       if (GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9871           && code == ASHIFTRT
9872           && ((nonzero_bits (varop, shift_mode)
9873                & ((unsigned HOST_WIDE_INT) 1
9874                   << (GET_MODE_BITSIZE (shift_mode) - 1))) == 0))
9875         code = LSHIFTRT;
9876
9877       if (((code == LSHIFTRT
9878             && GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9879             && !(nonzero_bits (varop, shift_mode) >> count))
9880            || (code == ASHIFT
9881                && GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9882                && !((nonzero_bits (varop, shift_mode) << count)
9883                     & GET_MODE_MASK (shift_mode))))
9884           && !side_effects_p (varop))
9885         varop = const0_rtx;
9886
9887       switch (GET_CODE (varop))
9888         {
9889         case SIGN_EXTEND:
9890         case ZERO_EXTEND:
9891         case SIGN_EXTRACT:
9892         case ZERO_EXTRACT:
9893           new_rtx = expand_compound_operation (varop);
9894           if (new_rtx != varop)
9895             {
9896               varop = new_rtx;
9897               continue;
9898             }
9899           break;
9900
9901         case MEM:
9902           /* If we have (xshiftrt (mem ...) C) and C is MODE_WIDTH
9903              minus the width of a smaller mode, we can do this with a
9904              SIGN_EXTEND or ZERO_EXTEND from the narrower memory location.  */
9905           if ((code == ASHIFTRT || code == LSHIFTRT)
9906               && ! mode_dependent_address_p (XEXP (varop, 0))
9907               && ! MEM_VOLATILE_P (varop)
9908               && (tmode = mode_for_size (GET_MODE_BITSIZE (mode) - count,
9909                                          MODE_INT, 1)) != BLKmode)
9910             {
9911               new_rtx = adjust_address_nv (varop, tmode,
9912                                        BYTES_BIG_ENDIAN ? 0
9913                                        : count / BITS_PER_UNIT);
9914
9915               varop = gen_rtx_fmt_e (code == ASHIFTRT ? SIGN_EXTEND
9916                                      : ZERO_EXTEND, mode, new_rtx);
9917               count = 0;
9918               continue;
9919             }
9920           break;
9921
9922         case SUBREG:
9923           /* If VAROP is a SUBREG, strip it as long as the inner operand has
9924              the same number of words as what we've seen so far.  Then store
9925              the widest mode in MODE.  */
9926           if (subreg_lowpart_p (varop)
9927               && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (varop)))
9928                   > GET_MODE_SIZE (GET_MODE (varop)))
9929               && (unsigned int) ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (varop)))
9930                                   + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
9931                  == mode_words
9932               && GET_MODE_CLASS (GET_MODE (varop)) == MODE_INT
9933               && GET_MODE_CLASS (GET_MODE (SUBREG_REG (varop))) == MODE_INT)
9934             {
9935               varop = SUBREG_REG (varop);
9936               if (GET_MODE_SIZE (GET_MODE (varop)) > GET_MODE_SIZE (mode))
9937                 mode = GET_MODE (varop);
9938               continue;
9939             }
9940           break;
9941
9942         case MULT:
9943           /* Some machines use MULT instead of ASHIFT because MULT
9944              is cheaper.  But it is still better on those machines to
9945              merge two shifts into one.  */
9946           if (CONST_INT_P (XEXP (varop, 1))
9947               && exact_log2 (UINTVAL (XEXP (varop, 1))) >= 0)
9948             {
9949               varop
9950                 = simplify_gen_binary (ASHIFT, GET_MODE (varop),
9951                                        XEXP (varop, 0),
9952                                        GEN_INT (exact_log2 (
9953                                                 UINTVAL (XEXP (varop, 1)))));
9954               continue;
9955             }
9956           break;
9957
9958         case UDIV:
9959           /* Similar, for when divides are cheaper.  */
9960           if (CONST_INT_P (XEXP (varop, 1))
9961               && exact_log2 (UINTVAL (XEXP (varop, 1))) >= 0)
9962             {
9963               varop
9964                 = simplify_gen_binary (LSHIFTRT, GET_MODE (varop),
9965                                        XEXP (varop, 0),
9966                                        GEN_INT (exact_log2 (
9967                                                 UINTVAL (XEXP (varop, 1)))));
9968               continue;
9969             }
9970           break;
9971
9972         case ASHIFTRT:
9973           /* If we are extracting just the sign bit of an arithmetic
9974              right shift, that shift is not needed.  However, the sign
9975              bit of a wider mode may be different from what would be
9976              interpreted as the sign bit in a narrower mode, so, if
9977              the result is narrower, don't discard the shift.  */
9978           if (code == LSHIFTRT
9979               && count == (GET_MODE_BITSIZE (result_mode) - 1)
9980               && (GET_MODE_BITSIZE (result_mode)
9981                   >= GET_MODE_BITSIZE (GET_MODE (varop))))
9982             {
9983               varop = XEXP (varop, 0);
9984               continue;
9985             }
9986
9987           /* ... fall through ...  */
9988
9989         case LSHIFTRT:
9990         case ASHIFT:
9991         case ROTATE:
9992           /* Here we have two nested shifts.  The result is usually the
9993              AND of a new shift with a mask.  We compute the result below.  */
9994           if (CONST_INT_P (XEXP (varop, 1))
9995               && INTVAL (XEXP (varop, 1)) >= 0
9996               && INTVAL (XEXP (varop, 1)) < GET_MODE_BITSIZE (GET_MODE (varop))
9997               && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
9998               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9999               && !VECTOR_MODE_P (result_mode))
10000             {
10001               enum rtx_code first_code = GET_CODE (varop);
10002               unsigned int first_count = INTVAL (XEXP (varop, 1));
10003               unsigned HOST_WIDE_INT mask;
10004               rtx mask_rtx;
10005
10006               /* We have one common special case.  We can't do any merging if
10007                  the inner code is an ASHIFTRT of a smaller mode.  However, if
10008                  we have (ashift:M1 (subreg:M1 (ashiftrt:M2 FOO C1) 0) C2)
10009                  with C2 == GET_MODE_BITSIZE (M1) - GET_MODE_BITSIZE (M2),
10010                  we can convert it to
10011                  (ashiftrt:M1 (ashift:M1 (and:M1 (subreg:M1 FOO 0 C2) C3) C1).
10012                  This simplifies certain SIGN_EXTEND operations.  */
10013               if (code == ASHIFT && first_code == ASHIFTRT
10014                   && count == (GET_MODE_BITSIZE (result_mode)
10015                                - GET_MODE_BITSIZE (GET_MODE (varop))))
10016                 {
10017                   /* C3 has the low-order C1 bits zero.  */
10018
10019                   mask = GET_MODE_MASK (mode)
10020                          & ~(((unsigned HOST_WIDE_INT) 1 << first_count) - 1);
10021
10022                   varop = simplify_and_const_int (NULL_RTX, result_mode,
10023                                                   XEXP (varop, 0), mask);
10024                   varop = simplify_shift_const (NULL_RTX, ASHIFT, result_mode,
10025                                                 varop, count);
10026                   count = first_count;
10027                   code = ASHIFTRT;
10028                   continue;
10029                 }
10030
10031               /* If this was (ashiftrt (ashift foo C1) C2) and FOO has more
10032                  than C1 high-order bits equal to the sign bit, we can convert
10033                  this to either an ASHIFT or an ASHIFTRT depending on the
10034                  two counts.
10035
10036                  We cannot do this if VAROP's mode is not SHIFT_MODE.  */
10037
10038               if (code == ASHIFTRT && first_code == ASHIFT
10039                   && GET_MODE (varop) == shift_mode
10040                   && (num_sign_bit_copies (XEXP (varop, 0), shift_mode)
10041                       > first_count))
10042                 {
10043                   varop = XEXP (varop, 0);
10044                   count -= first_count;
10045                   if (count < 0)
10046                     {
10047                       count = -count;
10048                       code = ASHIFT;
10049                     }
10050
10051                   continue;
10052                 }
10053
10054               /* There are some cases we can't do.  If CODE is ASHIFTRT,
10055                  we can only do this if FIRST_CODE is also ASHIFTRT.
10056
10057                  We can't do the case when CODE is ROTATE and FIRST_CODE is
10058                  ASHIFTRT.
10059
10060                  If the mode of this shift is not the mode of the outer shift,
10061                  we can't do this if either shift is a right shift or ROTATE.
10062
10063                  Finally, we can't do any of these if the mode is too wide
10064                  unless the codes are the same.
10065
10066                  Handle the case where the shift codes are the same
10067                  first.  */
10068
10069               if (code == first_code)
10070                 {
10071                   if (GET_MODE (varop) != result_mode
10072                       && (code == ASHIFTRT || code == LSHIFTRT
10073                           || code == ROTATE))
10074                     break;
10075
10076                   count += first_count;
10077                   varop = XEXP (varop, 0);
10078                   continue;
10079                 }
10080
10081               if (code == ASHIFTRT
10082                   || (code == ROTATE && first_code == ASHIFTRT)
10083                   || GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT
10084                   || (GET_MODE (varop) != result_mode
10085                       && (first_code == ASHIFTRT || first_code == LSHIFTRT
10086                           || first_code == ROTATE
10087                           || code == ROTATE)))
10088                 break;
10089
10090               /* To compute the mask to apply after the shift, shift the
10091                  nonzero bits of the inner shift the same way the
10092                  outer shift will.  */
10093
10094               mask_rtx = GEN_INT (nonzero_bits (varop, GET_MODE (varop)));
10095
10096               mask_rtx
10097                 = simplify_const_binary_operation (code, result_mode, mask_rtx,
10098                                                    GEN_INT (count));
10099
10100               /* Give up if we can't compute an outer operation to use.  */
10101               if (mask_rtx == 0
10102                   || !CONST_INT_P (mask_rtx)
10103                   || ! merge_outer_ops (&outer_op, &outer_const, AND,
10104                                         INTVAL (mask_rtx),
10105                                         result_mode, &complement_p))
10106                 break;
10107
10108               /* If the shifts are in the same direction, we add the
10109                  counts.  Otherwise, we subtract them.  */
10110               if ((code == ASHIFTRT || code == LSHIFTRT)
10111                   == (first_code == ASHIFTRT || first_code == LSHIFTRT))
10112                 count += first_count;
10113               else
10114                 count -= first_count;
10115
10116               /* If COUNT is positive, the new shift is usually CODE,
10117                  except for the two exceptions below, in which case it is
10118                  FIRST_CODE.  If the count is negative, FIRST_CODE should
10119                  always be used  */
10120               if (count > 0
10121                   && ((first_code == ROTATE && code == ASHIFT)
10122                       || (first_code == ASHIFTRT && code == LSHIFTRT)))
10123                 code = first_code;
10124               else if (count < 0)
10125                 code = first_code, count = -count;
10126
10127               varop = XEXP (varop, 0);
10128               continue;
10129             }
10130
10131           /* If we have (A << B << C) for any shift, we can convert this to
10132              (A << C << B).  This wins if A is a constant.  Only try this if
10133              B is not a constant.  */
10134
10135           else if (GET_CODE (varop) == code
10136                    && CONST_INT_P (XEXP (varop, 0))
10137                    && !CONST_INT_P (XEXP (varop, 1)))
10138             {
10139               rtx new_rtx = simplify_const_binary_operation (code, mode,
10140                                                          XEXP (varop, 0),
10141                                                          GEN_INT (count));
10142               varop = gen_rtx_fmt_ee (code, mode, new_rtx, XEXP (varop, 1));
10143               count = 0;
10144               continue;
10145             }
10146           break;
10147
10148         case NOT:
10149           if (VECTOR_MODE_P (mode))
10150             break;
10151
10152           /* Make this fit the case below.  */
10153           varop = gen_rtx_XOR (mode, XEXP (varop, 0),
10154                                GEN_INT (GET_MODE_MASK (mode)));
10155           continue;
10156
10157         case IOR:
10158         case AND:
10159         case XOR:
10160           /* If we have (xshiftrt (ior (plus X (const_int -1)) X) C)
10161              with C the size of VAROP - 1 and the shift is logical if
10162              STORE_FLAG_VALUE is 1 and arithmetic if STORE_FLAG_VALUE is -1,
10163              we have an (le X 0) operation.   If we have an arithmetic shift
10164              and STORE_FLAG_VALUE is 1 or we have a logical shift with
10165              STORE_FLAG_VALUE of -1, we have a (neg (le X 0)) operation.  */
10166
10167           if (GET_CODE (varop) == IOR && GET_CODE (XEXP (varop, 0)) == PLUS
10168               && XEXP (XEXP (varop, 0), 1) == constm1_rtx
10169               && (STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
10170               && (code == LSHIFTRT || code == ASHIFTRT)
10171               && count == (GET_MODE_BITSIZE (GET_MODE (varop)) - 1)
10172               && rtx_equal_p (XEXP (XEXP (varop, 0), 0), XEXP (varop, 1)))
10173             {
10174               count = 0;
10175               varop = gen_rtx_LE (GET_MODE (varop), XEXP (varop, 1),
10176                                   const0_rtx);
10177
10178               if (STORE_FLAG_VALUE == 1 ? code == ASHIFTRT : code == LSHIFTRT)
10179                 varop = gen_rtx_NEG (GET_MODE (varop), varop);
10180
10181               continue;
10182             }
10183
10184           /* If we have (shift (logical)), move the logical to the outside
10185              to allow it to possibly combine with another logical and the
10186              shift to combine with another shift.  This also canonicalizes to
10187              what a ZERO_EXTRACT looks like.  Also, some machines have
10188              (and (shift)) insns.  */
10189
10190           if (CONST_INT_P (XEXP (varop, 1))
10191               /* We can't do this if we have (ashiftrt (xor))  and the
10192                  constant has its sign bit set in shift_mode.  */
10193               && !(code == ASHIFTRT && GET_CODE (varop) == XOR
10194                    && 0 > trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
10195                                               shift_mode))
10196               && (new_rtx = simplify_const_binary_operation (code, result_mode,
10197                                                          XEXP (varop, 1),
10198                                                          GEN_INT (count))) != 0
10199               && CONST_INT_P (new_rtx)
10200               && merge_outer_ops (&outer_op, &outer_const, GET_CODE (varop),
10201                                   INTVAL (new_rtx), result_mode, &complement_p))
10202             {
10203               varop = XEXP (varop, 0);
10204               continue;
10205             }
10206
10207           /* If we can't do that, try to simplify the shift in each arm of the
10208              logical expression, make a new logical expression, and apply
10209              the inverse distributive law.  This also can't be done
10210              for some (ashiftrt (xor)).  */
10211           if (CONST_INT_P (XEXP (varop, 1))
10212              && !(code == ASHIFTRT && GET_CODE (varop) == XOR
10213                   && 0 > trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
10214                                              shift_mode)))
10215             {
10216               rtx lhs = simplify_shift_const (NULL_RTX, code, shift_mode,
10217                                               XEXP (varop, 0), count);
10218               rtx rhs = simplify_shift_const (NULL_RTX, code, shift_mode,
10219                                               XEXP (varop, 1), count);
10220
10221               varop = simplify_gen_binary (GET_CODE (varop), shift_mode,
10222                                            lhs, rhs);
10223               varop = apply_distributive_law (varop);
10224
10225               count = 0;
10226               continue;
10227             }
10228           break;
10229
10230         case EQ:
10231           /* Convert (lshiftrt (eq FOO 0) C) to (xor FOO 1) if STORE_FLAG_VALUE
10232              says that the sign bit can be tested, FOO has mode MODE, C is
10233              GET_MODE_BITSIZE (MODE) - 1, and FOO has only its low-order bit
10234              that may be nonzero.  */
10235           if (code == LSHIFTRT
10236               && XEXP (varop, 1) == const0_rtx
10237               && GET_MODE (XEXP (varop, 0)) == result_mode
10238               && count == (GET_MODE_BITSIZE (result_mode) - 1)
10239               && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
10240               && STORE_FLAG_VALUE == -1
10241               && nonzero_bits (XEXP (varop, 0), result_mode) == 1
10242               && merge_outer_ops (&outer_op, &outer_const, XOR, 1, result_mode,
10243                                   &complement_p))
10244             {
10245               varop = XEXP (varop, 0);
10246               count = 0;
10247               continue;
10248             }
10249           break;
10250
10251         case NEG:
10252           /* (lshiftrt (neg A) C) where A is either 0 or 1 and C is one less
10253              than the number of bits in the mode is equivalent to A.  */
10254           if (code == LSHIFTRT
10255               && count == (GET_MODE_BITSIZE (result_mode) - 1)
10256               && nonzero_bits (XEXP (varop, 0), result_mode) == 1)
10257             {
10258               varop = XEXP (varop, 0);
10259               count = 0;
10260               continue;
10261             }
10262
10263           /* NEG commutes with ASHIFT since it is multiplication.  Move the
10264              NEG outside to allow shifts to combine.  */
10265           if (code == ASHIFT
10266               && merge_outer_ops (&outer_op, &outer_const, NEG, 0, result_mode,
10267                                   &complement_p))
10268             {
10269               varop = XEXP (varop, 0);
10270               continue;
10271             }
10272           break;
10273
10274         case PLUS:
10275           /* (lshiftrt (plus A -1) C) where A is either 0 or 1 and C
10276              is one less than the number of bits in the mode is
10277              equivalent to (xor A 1).  */
10278           if (code == LSHIFTRT
10279               && count == (GET_MODE_BITSIZE (result_mode) - 1)
10280               && XEXP (varop, 1) == constm1_rtx
10281               && nonzero_bits (XEXP (varop, 0), result_mode) == 1
10282               && merge_outer_ops (&outer_op, &outer_const, XOR, 1, result_mode,
10283                                   &complement_p))
10284             {
10285               count = 0;
10286               varop = XEXP (varop, 0);
10287               continue;
10288             }
10289
10290           /* If we have (xshiftrt (plus FOO BAR) C), and the only bits
10291              that might be nonzero in BAR are those being shifted out and those
10292              bits are known zero in FOO, we can replace the PLUS with FOO.
10293              Similarly in the other operand order.  This code occurs when
10294              we are computing the size of a variable-size array.  */
10295
10296           if ((code == ASHIFTRT || code == LSHIFTRT)
10297               && count < HOST_BITS_PER_WIDE_INT
10298               && nonzero_bits (XEXP (varop, 1), result_mode) >> count == 0
10299               && (nonzero_bits (XEXP (varop, 1), result_mode)
10300                   & nonzero_bits (XEXP (varop, 0), result_mode)) == 0)
10301             {
10302               varop = XEXP (varop, 0);
10303               continue;
10304             }
10305           else if ((code == ASHIFTRT || code == LSHIFTRT)
10306                    && count < HOST_BITS_PER_WIDE_INT
10307                    && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
10308                    && 0 == (nonzero_bits (XEXP (varop, 0), result_mode)
10309                             >> count)
10310                    && 0 == (nonzero_bits (XEXP (varop, 0), result_mode)
10311                             & nonzero_bits (XEXP (varop, 1),
10312                                                  result_mode)))
10313             {
10314               varop = XEXP (varop, 1);
10315               continue;
10316             }
10317
10318           /* (ashift (plus foo C) N) is (plus (ashift foo N) C').  */
10319           if (code == ASHIFT
10320               && CONST_INT_P (XEXP (varop, 1))
10321               && (new_rtx = simplify_const_binary_operation (ASHIFT, result_mode,
10322                                                          XEXP (varop, 1),
10323                                                          GEN_INT (count))) != 0
10324               && CONST_INT_P (new_rtx)
10325               && merge_outer_ops (&outer_op, &outer_const, PLUS,
10326                                   INTVAL (new_rtx), result_mode, &complement_p))
10327             {
10328               varop = XEXP (varop, 0);
10329               continue;
10330             }
10331
10332           /* Check for 'PLUS signbit', which is the canonical form of 'XOR
10333              signbit', and attempt to change the PLUS to an XOR and move it to
10334              the outer operation as is done above in the AND/IOR/XOR case
10335              leg for shift(logical). See details in logical handling above
10336              for reasoning in doing so.  */
10337           if (code == LSHIFTRT
10338               && CONST_INT_P (XEXP (varop, 1))
10339               && mode_signbit_p (result_mode, XEXP (varop, 1))
10340               && (new_rtx = simplify_const_binary_operation (code, result_mode,
10341                                                          XEXP (varop, 1),
10342                                                          GEN_INT (count))) != 0
10343               && CONST_INT_P (new_rtx)
10344               && merge_outer_ops (&outer_op, &outer_const, XOR,
10345                                   INTVAL (new_rtx), result_mode, &complement_p))
10346             {
10347               varop = XEXP (varop, 0);
10348               continue;
10349             }
10350
10351           break;
10352
10353         case MINUS:
10354           /* If we have (xshiftrt (minus (ashiftrt X C)) X) C)
10355              with C the size of VAROP - 1 and the shift is logical if
10356              STORE_FLAG_VALUE is 1 and arithmetic if STORE_FLAG_VALUE is -1,
10357              we have a (gt X 0) operation.  If the shift is arithmetic with
10358              STORE_FLAG_VALUE of 1 or logical with STORE_FLAG_VALUE == -1,
10359              we have a (neg (gt X 0)) operation.  */
10360
10361           if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
10362               && GET_CODE (XEXP (varop, 0)) == ASHIFTRT
10363               && count == (GET_MODE_BITSIZE (GET_MODE (varop)) - 1)
10364               && (code == LSHIFTRT || code == ASHIFTRT)
10365               && CONST_INT_P (XEXP (XEXP (varop, 0), 1))
10366               && INTVAL (XEXP (XEXP (varop, 0), 1)) == count
10367               && rtx_equal_p (XEXP (XEXP (varop, 0), 0), XEXP (varop, 1)))
10368             {
10369               count = 0;
10370               varop = gen_rtx_GT (GET_MODE (varop), XEXP (varop, 1),
10371                                   const0_rtx);
10372
10373               if (STORE_FLAG_VALUE == 1 ? code == ASHIFTRT : code == LSHIFTRT)
10374                 varop = gen_rtx_NEG (GET_MODE (varop), varop);
10375
10376               continue;
10377             }
10378           break;
10379
10380         case TRUNCATE:
10381           /* Change (lshiftrt (truncate (lshiftrt))) to (truncate (lshiftrt))
10382              if the truncate does not affect the value.  */
10383           if (code == LSHIFTRT
10384               && GET_CODE (XEXP (varop, 0)) == LSHIFTRT
10385               && CONST_INT_P (XEXP (XEXP (varop, 0), 1))
10386               && (INTVAL (XEXP (XEXP (varop, 0), 1))
10387                   >= (GET_MODE_BITSIZE (GET_MODE (XEXP (varop, 0)))
10388                       - GET_MODE_BITSIZE (GET_MODE (varop)))))
10389             {
10390               rtx varop_inner = XEXP (varop, 0);
10391
10392               varop_inner
10393                 = gen_rtx_LSHIFTRT (GET_MODE (varop_inner),
10394                                     XEXP (varop_inner, 0),
10395                                     GEN_INT
10396                                     (count + INTVAL (XEXP (varop_inner, 1))));
10397               varop = gen_rtx_TRUNCATE (GET_MODE (varop), varop_inner);
10398               count = 0;
10399               continue;
10400             }
10401           break;
10402
10403         default:
10404           break;
10405         }
10406
10407       break;
10408     }
10409
10410   shift_mode = try_widen_shift_mode (code, varop, count, result_mode, mode,
10411                                      outer_op, outer_const);
10412
10413   /* We have now finished analyzing the shift.  The result should be
10414      a shift of type CODE with SHIFT_MODE shifting VAROP COUNT places.  If
10415      OUTER_OP is non-UNKNOWN, it is an operation that needs to be applied
10416      to the result of the shift.  OUTER_CONST is the relevant constant,
10417      but we must turn off all bits turned off in the shift.  */
10418
10419   if (outer_op == UNKNOWN
10420       && orig_code == code && orig_count == count
10421       && varop == orig_varop
10422       && shift_mode == GET_MODE (varop))
10423     return NULL_RTX;
10424
10425   /* Make a SUBREG if necessary.  If we can't make it, fail.  */
10426   varop = gen_lowpart (shift_mode, varop);
10427   if (varop == NULL_RTX || GET_CODE (varop) == CLOBBER)
10428     return NULL_RTX;
10429
10430   /* If we have an outer operation and we just made a shift, it is
10431      possible that we could have simplified the shift were it not
10432      for the outer operation.  So try to do the simplification
10433      recursively.  */
10434
10435   if (outer_op != UNKNOWN)
10436     x = simplify_shift_const_1 (code, shift_mode, varop, count);
10437   else
10438     x = NULL_RTX;
10439
10440   if (x == NULL_RTX)
10441     x = simplify_gen_binary (code, shift_mode, varop, GEN_INT (count));
10442
10443   /* If we were doing an LSHIFTRT in a wider mode than it was originally,
10444      turn off all the bits that the shift would have turned off.  */
10445   if (orig_code == LSHIFTRT && result_mode != shift_mode)
10446     x = simplify_and_const_int (NULL_RTX, shift_mode, x,
10447                                 GET_MODE_MASK (result_mode) >> orig_count);
10448
10449   /* Do the remainder of the processing in RESULT_MODE.  */
10450   x = gen_lowpart_or_truncate (result_mode, x);
10451
10452   /* If COMPLEMENT_P is set, we have to complement X before doing the outer
10453      operation.  */
10454   if (complement_p)
10455     x = simplify_gen_unary (NOT, result_mode, x, result_mode);
10456
10457   if (outer_op != UNKNOWN)
10458     {
10459       if (GET_RTX_CLASS (outer_op) != RTX_UNARY
10460           && GET_MODE_BITSIZE (result_mode) < HOST_BITS_PER_WIDE_INT)
10461         outer_const = trunc_int_for_mode (outer_const, result_mode);
10462
10463       if (outer_op == AND)
10464         x = simplify_and_const_int (NULL_RTX, result_mode, x, outer_const);
10465       else if (outer_op == SET)
10466         {
10467           /* This means that we have determined that the result is
10468              equivalent to a constant.  This should be rare.  */
10469           if (!side_effects_p (x))
10470             x = GEN_INT (outer_const);
10471         }
10472       else if (GET_RTX_CLASS (outer_op) == RTX_UNARY)
10473         x = simplify_gen_unary (outer_op, result_mode, x, result_mode);
10474       else
10475         x = simplify_gen_binary (outer_op, result_mode, x,
10476                                  GEN_INT (outer_const));
10477     }
10478
10479   return x;
10480 }
10481
10482 /* Simplify a shift of VAROP by COUNT bits.  CODE says what kind of shift.
10483    The result of the shift is RESULT_MODE.  If we cannot simplify it,
10484    return X or, if it is NULL, synthesize the expression with
10485    simplify_gen_binary.  Otherwise, return a simplified value.
10486
10487    The shift is normally computed in the widest mode we find in VAROP, as
10488    long as it isn't a different number of words than RESULT_MODE.  Exceptions
10489    are ASHIFTRT and ROTATE, which are always done in their original mode.  */
10490
10491 static rtx
10492 simplify_shift_const (rtx x, enum rtx_code code, enum machine_mode result_mode,
10493                       rtx varop, int count)
10494 {
10495   rtx tem = simplify_shift_const_1 (code, result_mode, varop, count);
10496   if (tem)
10497     return tem;
10498
10499   if (!x)
10500     x = simplify_gen_binary (code, GET_MODE (varop), varop, GEN_INT (count));
10501   if (GET_MODE (x) != result_mode)
10502     x = gen_lowpart (result_mode, x);
10503   return x;
10504 }
10505
10506 \f
10507 /* Like recog, but we receive the address of a pointer to a new pattern.
10508    We try to match the rtx that the pointer points to.
10509    If that fails, we may try to modify or replace the pattern,
10510    storing the replacement into the same pointer object.
10511
10512    Modifications include deletion or addition of CLOBBERs.
10513
10514    PNOTES is a pointer to a location where any REG_UNUSED notes added for
10515    the CLOBBERs are placed.
10516
10517    The value is the final insn code from the pattern ultimately matched,
10518    or -1.  */
10519
10520 static int
10521 recog_for_combine (rtx *pnewpat, rtx insn, rtx *pnotes)
10522 {
10523   rtx pat = *pnewpat;
10524   int insn_code_number;
10525   int num_clobbers_to_add = 0;
10526   int i;
10527   rtx notes = 0;
10528   rtx old_notes, old_pat;
10529
10530   /* If PAT is a PARALLEL, check to see if it contains the CLOBBER
10531      we use to indicate that something didn't match.  If we find such a
10532      thing, force rejection.  */
10533   if (GET_CODE (pat) == PARALLEL)
10534     for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
10535       if (GET_CODE (XVECEXP (pat, 0, i)) == CLOBBER
10536           && XEXP (XVECEXP (pat, 0, i), 0) == const0_rtx)
10537         return -1;
10538
10539   old_pat = PATTERN (insn);
10540   old_notes = REG_NOTES (insn);
10541   PATTERN (insn) = pat;
10542   REG_NOTES (insn) = 0;
10543
10544   insn_code_number = recog (pat, insn, &num_clobbers_to_add);
10545   if (dump_file && (dump_flags & TDF_DETAILS))
10546     {
10547       if (insn_code_number < 0)
10548         fputs ("Failed to match this instruction:\n", dump_file);
10549       else
10550         fputs ("Successfully matched this instruction:\n", dump_file);
10551       print_rtl_single (dump_file, pat);
10552     }
10553
10554   /* If it isn't, there is the possibility that we previously had an insn
10555      that clobbered some register as a side effect, but the combined
10556      insn doesn't need to do that.  So try once more without the clobbers
10557      unless this represents an ASM insn.  */
10558
10559   if (insn_code_number < 0 && ! check_asm_operands (pat)
10560       && GET_CODE (pat) == PARALLEL)
10561     {
10562       int pos;
10563
10564       for (pos = 0, i = 0; i < XVECLEN (pat, 0); i++)
10565         if (GET_CODE (XVECEXP (pat, 0, i)) != CLOBBER)
10566           {
10567             if (i != pos)
10568               SUBST (XVECEXP (pat, 0, pos), XVECEXP (pat, 0, i));
10569             pos++;
10570           }
10571
10572       SUBST_INT (XVECLEN (pat, 0), pos);
10573
10574       if (pos == 1)
10575         pat = XVECEXP (pat, 0, 0);
10576
10577       PATTERN (insn) = pat;
10578       insn_code_number = recog (pat, insn, &num_clobbers_to_add);
10579       if (dump_file && (dump_flags & TDF_DETAILS))
10580         {
10581           if (insn_code_number < 0)
10582             fputs ("Failed to match this instruction:\n", dump_file);
10583           else
10584             fputs ("Successfully matched this instruction:\n", dump_file);
10585           print_rtl_single (dump_file, pat);
10586         }
10587     }
10588   PATTERN (insn) = old_pat;
10589   REG_NOTES (insn) = old_notes;
10590
10591   /* Recognize all noop sets, these will be killed by followup pass.  */
10592   if (insn_code_number < 0 && GET_CODE (pat) == SET && set_noop_p (pat))
10593     insn_code_number = NOOP_MOVE_INSN_CODE, num_clobbers_to_add = 0;
10594
10595   /* If we had any clobbers to add, make a new pattern than contains
10596      them.  Then check to make sure that all of them are dead.  */
10597   if (num_clobbers_to_add)
10598     {
10599       rtx newpat = gen_rtx_PARALLEL (VOIDmode,
10600                                      rtvec_alloc (GET_CODE (pat) == PARALLEL
10601                                                   ? (XVECLEN (pat, 0)
10602                                                      + num_clobbers_to_add)
10603                                                   : num_clobbers_to_add + 1));
10604
10605       if (GET_CODE (pat) == PARALLEL)
10606         for (i = 0; i < XVECLEN (pat, 0); i++)
10607           XVECEXP (newpat, 0, i) = XVECEXP (pat, 0, i);
10608       else
10609         XVECEXP (newpat, 0, 0) = pat;
10610
10611       add_clobbers (newpat, insn_code_number);
10612
10613       for (i = XVECLEN (newpat, 0) - num_clobbers_to_add;
10614            i < XVECLEN (newpat, 0); i++)
10615         {
10616           if (REG_P (XEXP (XVECEXP (newpat, 0, i), 0))
10617               && ! reg_dead_at_p (XEXP (XVECEXP (newpat, 0, i), 0), insn))
10618             return -1;
10619           if (GET_CODE (XEXP (XVECEXP (newpat, 0, i), 0)) != SCRATCH)
10620             {
10621               gcc_assert (REG_P (XEXP (XVECEXP (newpat, 0, i), 0)));
10622               notes = alloc_reg_note (REG_UNUSED,
10623                                       XEXP (XVECEXP (newpat, 0, i), 0), notes);
10624             }
10625         }
10626       pat = newpat;
10627     }
10628
10629   *pnewpat = pat;
10630   *pnotes = notes;
10631
10632   return insn_code_number;
10633 }
10634 \f
10635 /* Like gen_lowpart_general but for use by combine.  In combine it
10636    is not possible to create any new pseudoregs.  However, it is
10637    safe to create invalid memory addresses, because combine will
10638    try to recognize them and all they will do is make the combine
10639    attempt fail.
10640
10641    If for some reason this cannot do its job, an rtx
10642    (clobber (const_int 0)) is returned.
10643    An insn containing that will not be recognized.  */
10644
10645 static rtx
10646 gen_lowpart_for_combine (enum machine_mode omode, rtx x)
10647 {
10648   enum machine_mode imode = GET_MODE (x);
10649   unsigned int osize = GET_MODE_SIZE (omode);
10650   unsigned int isize = GET_MODE_SIZE (imode);
10651   rtx result;
10652
10653   if (omode == imode)
10654     return x;
10655
10656   /* Return identity if this is a CONST or symbolic reference.  */
10657   if (omode == Pmode
10658       && (GET_CODE (x) == CONST
10659           || GET_CODE (x) == SYMBOL_REF
10660           || GET_CODE (x) == LABEL_REF))
10661     return x;
10662
10663   /* We can only support MODE being wider than a word if X is a
10664      constant integer or has a mode the same size.  */
10665   if (GET_MODE_SIZE (omode) > UNITS_PER_WORD
10666       && ! ((imode == VOIDmode
10667              && (CONST_INT_P (x)
10668                  || GET_CODE (x) == CONST_DOUBLE))
10669             || isize == osize))
10670     goto fail;
10671
10672   /* X might be a paradoxical (subreg (mem)).  In that case, gen_lowpart
10673      won't know what to do.  So we will strip off the SUBREG here and
10674      process normally.  */
10675   if (GET_CODE (x) == SUBREG && MEM_P (SUBREG_REG (x)))
10676     {
10677       x = SUBREG_REG (x);
10678
10679       /* For use in case we fall down into the address adjustments
10680          further below, we need to adjust the known mode and size of
10681          x; imode and isize, since we just adjusted x.  */
10682       imode = GET_MODE (x);
10683
10684       if (imode == omode)
10685         return x;
10686
10687       isize = GET_MODE_SIZE (imode);
10688     }
10689
10690   result = gen_lowpart_common (omode, x);
10691
10692   if (result)
10693     return result;
10694
10695   if (MEM_P (x))
10696     {
10697       int offset = 0;
10698
10699       /* Refuse to work on a volatile memory ref or one with a mode-dependent
10700          address.  */
10701       if (MEM_VOLATILE_P (x) || mode_dependent_address_p (XEXP (x, 0)))
10702         goto fail;
10703
10704       /* If we want to refer to something bigger than the original memref,
10705          generate a paradoxical subreg instead.  That will force a reload
10706          of the original memref X.  */
10707       if (isize < osize)
10708         return gen_rtx_SUBREG (omode, x, 0);
10709
10710       if (WORDS_BIG_ENDIAN)
10711         offset = MAX (isize, UNITS_PER_WORD) - MAX (osize, UNITS_PER_WORD);
10712
10713       /* Adjust the address so that the address-after-the-data is
10714          unchanged.  */
10715       if (BYTES_BIG_ENDIAN)
10716         offset -= MIN (UNITS_PER_WORD, osize) - MIN (UNITS_PER_WORD, isize);
10717
10718       return adjust_address_nv (x, omode, offset);
10719     }
10720
10721   /* If X is a comparison operator, rewrite it in a new mode.  This
10722      probably won't match, but may allow further simplifications.  */
10723   else if (COMPARISON_P (x))
10724     return gen_rtx_fmt_ee (GET_CODE (x), omode, XEXP (x, 0), XEXP (x, 1));
10725
10726   /* If we couldn't simplify X any other way, just enclose it in a
10727      SUBREG.  Normally, this SUBREG won't match, but some patterns may
10728      include an explicit SUBREG or we may simplify it further in combine.  */
10729   else
10730     {
10731       int offset = 0;
10732       rtx res;
10733
10734       offset = subreg_lowpart_offset (omode, imode);
10735       if (imode == VOIDmode)
10736         {
10737           imode = int_mode_for_mode (omode);
10738           x = gen_lowpart_common (imode, x);
10739           if (x == NULL)
10740             goto fail;
10741         }
10742       res = simplify_gen_subreg (omode, x, imode, offset);
10743       if (res)
10744         return res;
10745     }
10746
10747  fail:
10748   return gen_rtx_CLOBBER (omode, const0_rtx);
10749 }
10750 \f
10751 /* Simplify a comparison between *POP0 and *POP1 where CODE is the
10752    comparison code that will be tested.
10753
10754    The result is a possibly different comparison code to use.  *POP0 and
10755    *POP1 may be updated.
10756
10757    It is possible that we might detect that a comparison is either always
10758    true or always false.  However, we do not perform general constant
10759    folding in combine, so this knowledge isn't useful.  Such tautologies
10760    should have been detected earlier.  Hence we ignore all such cases.  */
10761
10762 static enum rtx_code
10763 simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1)
10764 {
10765   rtx op0 = *pop0;
10766   rtx op1 = *pop1;
10767   rtx tem, tem1;
10768   int i;
10769   enum machine_mode mode, tmode;
10770
10771   /* Try a few ways of applying the same transformation to both operands.  */
10772   while (1)
10773     {
10774 #ifndef WORD_REGISTER_OPERATIONS
10775       /* The test below this one won't handle SIGN_EXTENDs on these machines,
10776          so check specially.  */
10777       if (code != GTU && code != GEU && code != LTU && code != LEU
10778           && GET_CODE (op0) == ASHIFTRT && GET_CODE (op1) == ASHIFTRT
10779           && GET_CODE (XEXP (op0, 0)) == ASHIFT
10780           && GET_CODE (XEXP (op1, 0)) == ASHIFT
10781           && GET_CODE (XEXP (XEXP (op0, 0), 0)) == SUBREG
10782           && GET_CODE (XEXP (XEXP (op1, 0), 0)) == SUBREG
10783           && (GET_MODE (SUBREG_REG (XEXP (XEXP (op0, 0), 0)))
10784               == GET_MODE (SUBREG_REG (XEXP (XEXP (op1, 0), 0))))
10785           && CONST_INT_P (XEXP (op0, 1))
10786           && XEXP (op0, 1) == XEXP (op1, 1)
10787           && XEXP (op0, 1) == XEXP (XEXP (op0, 0), 1)
10788           && XEXP (op0, 1) == XEXP (XEXP (op1, 0), 1)
10789           && (INTVAL (XEXP (op0, 1))
10790               == (GET_MODE_BITSIZE (GET_MODE (op0))
10791                   - (GET_MODE_BITSIZE
10792                      (GET_MODE (SUBREG_REG (XEXP (XEXP (op0, 0), 0))))))))
10793         {
10794           op0 = SUBREG_REG (XEXP (XEXP (op0, 0), 0));
10795           op1 = SUBREG_REG (XEXP (XEXP (op1, 0), 0));
10796         }
10797 #endif
10798
10799       /* If both operands are the same constant shift, see if we can ignore the
10800          shift.  We can if the shift is a rotate or if the bits shifted out of
10801          this shift are known to be zero for both inputs and if the type of
10802          comparison is compatible with the shift.  */
10803       if (GET_CODE (op0) == GET_CODE (op1)
10804           && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
10805           && ((GET_CODE (op0) == ROTATE && (code == NE || code == EQ))
10806               || ((GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFT)
10807                   && (code != GT && code != LT && code != GE && code != LE))
10808               || (GET_CODE (op0) == ASHIFTRT
10809                   && (code != GTU && code != LTU
10810                       && code != GEU && code != LEU)))
10811           && CONST_INT_P (XEXP (op0, 1))
10812           && INTVAL (XEXP (op0, 1)) >= 0
10813           && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
10814           && XEXP (op0, 1) == XEXP (op1, 1))
10815         {
10816           enum machine_mode mode = GET_MODE (op0);
10817           unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
10818           int shift_count = INTVAL (XEXP (op0, 1));
10819
10820           if (GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFTRT)
10821             mask &= (mask >> shift_count) << shift_count;
10822           else if (GET_CODE (op0) == ASHIFT)
10823             mask = (mask & (mask << shift_count)) >> shift_count;
10824
10825           if ((nonzero_bits (XEXP (op0, 0), mode) & ~mask) == 0
10826               && (nonzero_bits (XEXP (op1, 0), mode) & ~mask) == 0)
10827             op0 = XEXP (op0, 0), op1 = XEXP (op1, 0);
10828           else
10829             break;
10830         }
10831
10832       /* If both operands are AND's of a paradoxical SUBREG by constant, the
10833          SUBREGs are of the same mode, and, in both cases, the AND would
10834          be redundant if the comparison was done in the narrower mode,
10835          do the comparison in the narrower mode (e.g., we are AND'ing with 1
10836          and the operand's possibly nonzero bits are 0xffffff01; in that case
10837          if we only care about QImode, we don't need the AND).  This case
10838          occurs if the output mode of an scc insn is not SImode and
10839          STORE_FLAG_VALUE == 1 (e.g., the 386).
10840
10841          Similarly, check for a case where the AND's are ZERO_EXTEND
10842          operations from some narrower mode even though a SUBREG is not
10843          present.  */
10844
10845       else if (GET_CODE (op0) == AND && GET_CODE (op1) == AND
10846                && CONST_INT_P (XEXP (op0, 1))
10847                && CONST_INT_P (XEXP (op1, 1)))
10848         {
10849           rtx inner_op0 = XEXP (op0, 0);
10850           rtx inner_op1 = XEXP (op1, 0);
10851           HOST_WIDE_INT c0 = INTVAL (XEXP (op0, 1));
10852           HOST_WIDE_INT c1 = INTVAL (XEXP (op1, 1));
10853           int changed = 0;
10854
10855           if (GET_CODE (inner_op0) == SUBREG && GET_CODE (inner_op1) == SUBREG
10856               && (GET_MODE_SIZE (GET_MODE (inner_op0))
10857                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner_op0))))
10858               && (GET_MODE (SUBREG_REG (inner_op0))
10859                   == GET_MODE (SUBREG_REG (inner_op1)))
10860               && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (inner_op0)))
10861                   <= HOST_BITS_PER_WIDE_INT)
10862               && (0 == ((~c0) & nonzero_bits (SUBREG_REG (inner_op0),
10863                                              GET_MODE (SUBREG_REG (inner_op0)))))
10864               && (0 == ((~c1) & nonzero_bits (SUBREG_REG (inner_op1),
10865                                              GET_MODE (SUBREG_REG (inner_op1))))))
10866             {
10867               op0 = SUBREG_REG (inner_op0);
10868               op1 = SUBREG_REG (inner_op1);
10869
10870               /* The resulting comparison is always unsigned since we masked
10871                  off the original sign bit.  */
10872               code = unsigned_condition (code);
10873
10874               changed = 1;
10875             }
10876
10877           else if (c0 == c1)
10878             for (tmode = GET_CLASS_NARROWEST_MODE
10879                  (GET_MODE_CLASS (GET_MODE (op0)));
10880                  tmode != GET_MODE (op0); tmode = GET_MODE_WIDER_MODE (tmode))
10881               if ((unsigned HOST_WIDE_INT) c0 == GET_MODE_MASK (tmode))
10882                 {
10883                   op0 = gen_lowpart (tmode, inner_op0);
10884                   op1 = gen_lowpart (tmode, inner_op1);
10885                   code = unsigned_condition (code);
10886                   changed = 1;
10887                   break;
10888                 }
10889
10890           if (! changed)
10891             break;
10892         }
10893
10894       /* If both operands are NOT, we can strip off the outer operation
10895          and adjust the comparison code for swapped operands; similarly for
10896          NEG, except that this must be an equality comparison.  */
10897       else if ((GET_CODE (op0) == NOT && GET_CODE (op1) == NOT)
10898                || (GET_CODE (op0) == NEG && GET_CODE (op1) == NEG
10899                    && (code == EQ || code == NE)))
10900         op0 = XEXP (op0, 0), op1 = XEXP (op1, 0), code = swap_condition (code);
10901
10902       else
10903         break;
10904     }
10905
10906   /* If the first operand is a constant, swap the operands and adjust the
10907      comparison code appropriately, but don't do this if the second operand
10908      is already a constant integer.  */
10909   if (swap_commutative_operands_p (op0, op1))
10910     {
10911       tem = op0, op0 = op1, op1 = tem;
10912       code = swap_condition (code);
10913     }
10914
10915   /* We now enter a loop during which we will try to simplify the comparison.
10916      For the most part, we only are concerned with comparisons with zero,
10917      but some things may really be comparisons with zero but not start
10918      out looking that way.  */
10919
10920   while (CONST_INT_P (op1))
10921     {
10922       enum machine_mode mode = GET_MODE (op0);
10923       unsigned int mode_width = GET_MODE_BITSIZE (mode);
10924       unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
10925       int equality_comparison_p;
10926       int sign_bit_comparison_p;
10927       int unsigned_comparison_p;
10928       HOST_WIDE_INT const_op;
10929
10930       /* We only want to handle integral modes.  This catches VOIDmode,
10931          CCmode, and the floating-point modes.  An exception is that we
10932          can handle VOIDmode if OP0 is a COMPARE or a comparison
10933          operation.  */
10934
10935       if (GET_MODE_CLASS (mode) != MODE_INT
10936           && ! (mode == VOIDmode
10937                 && (GET_CODE (op0) == COMPARE || COMPARISON_P (op0))))
10938         break;
10939
10940       /* Get the constant we are comparing against and turn off all bits
10941          not on in our mode.  */
10942       const_op = INTVAL (op1);
10943       if (mode != VOIDmode)
10944         const_op = trunc_int_for_mode (const_op, mode);
10945       op1 = GEN_INT (const_op);
10946
10947       /* If we are comparing against a constant power of two and the value
10948          being compared can only have that single bit nonzero (e.g., it was
10949          `and'ed with that bit), we can replace this with a comparison
10950          with zero.  */
10951       if (const_op
10952           && (code == EQ || code == NE || code == GE || code == GEU
10953               || code == LT || code == LTU)
10954           && mode_width <= HOST_BITS_PER_WIDE_INT
10955           && exact_log2 (const_op) >= 0
10956           && nonzero_bits (op0, mode) == (unsigned HOST_WIDE_INT) const_op)
10957         {
10958           code = (code == EQ || code == GE || code == GEU ? NE : EQ);
10959           op1 = const0_rtx, const_op = 0;
10960         }
10961
10962       /* Similarly, if we are comparing a value known to be either -1 or
10963          0 with -1, change it to the opposite comparison against zero.  */
10964
10965       if (const_op == -1
10966           && (code == EQ || code == NE || code == GT || code == LE
10967               || code == GEU || code == LTU)
10968           && num_sign_bit_copies (op0, mode) == mode_width)
10969         {
10970           code = (code == EQ || code == LE || code == GEU ? NE : EQ);
10971           op1 = const0_rtx, const_op = 0;
10972         }
10973
10974       /* Do some canonicalizations based on the comparison code.  We prefer
10975          comparisons against zero and then prefer equality comparisons.
10976          If we can reduce the size of a constant, we will do that too.  */
10977
10978       switch (code)
10979         {
10980         case LT:
10981           /* < C is equivalent to <= (C - 1) */
10982           if (const_op > 0)
10983             {
10984               const_op -= 1;
10985               op1 = GEN_INT (const_op);
10986               code = LE;
10987               /* ... fall through to LE case below.  */
10988             }
10989           else
10990             break;
10991
10992         case LE:
10993           /* <= C is equivalent to < (C + 1); we do this for C < 0  */
10994           if (const_op < 0)
10995             {
10996               const_op += 1;
10997               op1 = GEN_INT (const_op);
10998               code = LT;
10999             }
11000
11001           /* If we are doing a <= 0 comparison on a value known to have
11002              a zero sign bit, we can replace this with == 0.  */
11003           else if (const_op == 0
11004                    && mode_width <= HOST_BITS_PER_WIDE_INT
11005                    && (nonzero_bits (op0, mode)
11006                        & ((unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
11007                          == 0)
11008             code = EQ;
11009           break;
11010
11011         case GE:
11012           /* >= C is equivalent to > (C - 1).  */
11013           if (const_op > 0)
11014             {
11015               const_op -= 1;
11016               op1 = GEN_INT (const_op);
11017               code = GT;
11018               /* ... fall through to GT below.  */
11019             }
11020           else
11021             break;
11022
11023         case GT:
11024           /* > C is equivalent to >= (C + 1); we do this for C < 0.  */
11025           if (const_op < 0)
11026             {
11027               const_op += 1;
11028               op1 = GEN_INT (const_op);
11029               code = GE;
11030             }
11031
11032           /* If we are doing a > 0 comparison on a value known to have
11033              a zero sign bit, we can replace this with != 0.  */
11034           else if (const_op == 0
11035                    && mode_width <= HOST_BITS_PER_WIDE_INT
11036                    && (nonzero_bits (op0, mode)
11037                        & ((unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
11038                        == 0)
11039             code = NE;
11040           break;
11041
11042         case LTU:
11043           /* < C is equivalent to <= (C - 1).  */
11044           if (const_op > 0)
11045             {
11046               const_op -= 1;
11047               op1 = GEN_INT (const_op);
11048               code = LEU;
11049               /* ... fall through ...  */
11050             }
11051
11052           /* (unsigned) < 0x80000000 is equivalent to >= 0.  */
11053           else if (mode_width <= HOST_BITS_PER_WIDE_INT
11054                    && (unsigned HOST_WIDE_INT) const_op
11055                       == (unsigned HOST_WIDE_INT) 1 << (mode_width - 1))
11056             {
11057               const_op = 0, op1 = const0_rtx;
11058               code = GE;
11059               break;
11060             }
11061           else
11062             break;
11063
11064         case LEU:
11065           /* unsigned <= 0 is equivalent to == 0 */
11066           if (const_op == 0)
11067             code = EQ;
11068
11069           /* (unsigned) <= 0x7fffffff is equivalent to >= 0.  */
11070           else if (mode_width <= HOST_BITS_PER_WIDE_INT
11071                    && (unsigned HOST_WIDE_INT) const_op
11072                       == ((unsigned HOST_WIDE_INT) 1 << (mode_width - 1)) - 1)
11073             {
11074               const_op = 0, op1 = const0_rtx;
11075               code = GE;
11076             }
11077           break;
11078
11079         case GEU:
11080           /* >= C is equivalent to > (C - 1).  */
11081           if (const_op > 1)
11082             {
11083               const_op -= 1;
11084               op1 = GEN_INT (const_op);
11085               code = GTU;
11086               /* ... fall through ...  */
11087             }
11088
11089           /* (unsigned) >= 0x80000000 is equivalent to < 0.  */
11090           else if (mode_width <= HOST_BITS_PER_WIDE_INT
11091                    && (unsigned HOST_WIDE_INT) const_op
11092                       == (unsigned HOST_WIDE_INT) 1 << (mode_width - 1))
11093             {
11094               const_op = 0, op1 = const0_rtx;
11095               code = LT;
11096               break;
11097             }
11098           else
11099             break;
11100
11101         case GTU:
11102           /* unsigned > 0 is equivalent to != 0 */
11103           if (const_op == 0)
11104             code = NE;
11105
11106           /* (unsigned) > 0x7fffffff is equivalent to < 0.  */
11107           else if (mode_width <= HOST_BITS_PER_WIDE_INT
11108                    && (unsigned HOST_WIDE_INT) const_op
11109                       == ((unsigned HOST_WIDE_INT) 1 << (mode_width - 1)) - 1)
11110             {
11111               const_op = 0, op1 = const0_rtx;
11112               code = LT;
11113             }
11114           break;
11115
11116         default:
11117           break;
11118         }
11119
11120       /* Compute some predicates to simplify code below.  */
11121
11122       equality_comparison_p = (code == EQ || code == NE);
11123       sign_bit_comparison_p = ((code == LT || code == GE) && const_op == 0);
11124       unsigned_comparison_p = (code == LTU || code == LEU || code == GTU
11125                                || code == GEU);
11126
11127       /* If this is a sign bit comparison and we can do arithmetic in
11128          MODE, say that we will only be needing the sign bit of OP0.  */
11129       if (sign_bit_comparison_p
11130           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11131         op0 = force_to_mode (op0, mode,
11132                              (unsigned HOST_WIDE_INT) 1
11133                              << (GET_MODE_BITSIZE (mode) - 1),
11134                              0);
11135
11136       /* Now try cases based on the opcode of OP0.  If none of the cases
11137          does a "continue", we exit this loop immediately after the
11138          switch.  */
11139
11140       switch (GET_CODE (op0))
11141         {
11142         case ZERO_EXTRACT:
11143           /* If we are extracting a single bit from a variable position in
11144              a constant that has only a single bit set and are comparing it
11145              with zero, we can convert this into an equality comparison
11146              between the position and the location of the single bit.  */
11147           /* Except we can't if SHIFT_COUNT_TRUNCATED is set, since we might
11148              have already reduced the shift count modulo the word size.  */
11149           if (!SHIFT_COUNT_TRUNCATED
11150               && CONST_INT_P (XEXP (op0, 0))
11151               && XEXP (op0, 1) == const1_rtx
11152               && equality_comparison_p && const_op == 0
11153               && (i = exact_log2 (UINTVAL (XEXP (op0, 0)))) >= 0)
11154             {
11155               if (BITS_BIG_ENDIAN)
11156                 {
11157                   enum machine_mode new_mode
11158                     = mode_for_extraction (EP_extzv, 1);
11159                   if (new_mode == MAX_MACHINE_MODE)
11160                     i = BITS_PER_WORD - 1 - i;
11161                   else
11162                     {
11163                       mode = new_mode;
11164                       i = (GET_MODE_BITSIZE (mode) - 1 - i);
11165                     }
11166                 }
11167
11168               op0 = XEXP (op0, 2);
11169               op1 = GEN_INT (i);
11170               const_op = i;
11171
11172               /* Result is nonzero iff shift count is equal to I.  */
11173               code = reverse_condition (code);
11174               continue;
11175             }
11176
11177           /* ... fall through ...  */
11178
11179         case SIGN_EXTRACT:
11180           tem = expand_compound_operation (op0);
11181           if (tem != op0)
11182             {
11183               op0 = tem;
11184               continue;
11185             }
11186           break;
11187
11188         case NOT:
11189           /* If testing for equality, we can take the NOT of the constant.  */
11190           if (equality_comparison_p
11191               && (tem = simplify_unary_operation (NOT, mode, op1, mode)) != 0)
11192             {
11193               op0 = XEXP (op0, 0);
11194               op1 = tem;
11195               continue;
11196             }
11197
11198           /* If just looking at the sign bit, reverse the sense of the
11199              comparison.  */
11200           if (sign_bit_comparison_p)
11201             {
11202               op0 = XEXP (op0, 0);
11203               code = (code == GE ? LT : GE);
11204               continue;
11205             }
11206           break;
11207
11208         case NEG:
11209           /* If testing for equality, we can take the NEG of the constant.  */
11210           if (equality_comparison_p
11211               && (tem = simplify_unary_operation (NEG, mode, op1, mode)) != 0)
11212             {
11213               op0 = XEXP (op0, 0);
11214               op1 = tem;
11215               continue;
11216             }
11217
11218           /* The remaining cases only apply to comparisons with zero.  */
11219           if (const_op != 0)
11220             break;
11221
11222           /* When X is ABS or is known positive,
11223              (neg X) is < 0 if and only if X != 0.  */
11224
11225           if (sign_bit_comparison_p
11226               && (GET_CODE (XEXP (op0, 0)) == ABS
11227                   || (mode_width <= HOST_BITS_PER_WIDE_INT
11228                       && (nonzero_bits (XEXP (op0, 0), mode)
11229                           & ((unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
11230                          == 0)))
11231             {
11232               op0 = XEXP (op0, 0);
11233               code = (code == LT ? NE : EQ);
11234               continue;
11235             }
11236
11237           /* If we have NEG of something whose two high-order bits are the
11238              same, we know that "(-a) < 0" is equivalent to "a > 0".  */
11239           if (num_sign_bit_copies (op0, mode) >= 2)
11240             {
11241               op0 = XEXP (op0, 0);
11242               code = swap_condition (code);
11243               continue;
11244             }
11245           break;
11246
11247         case ROTATE:
11248           /* If we are testing equality and our count is a constant, we
11249              can perform the inverse operation on our RHS.  */
11250           if (equality_comparison_p && CONST_INT_P (XEXP (op0, 1))
11251               && (tem = simplify_binary_operation (ROTATERT, mode,
11252                                                    op1, XEXP (op0, 1))) != 0)
11253             {
11254               op0 = XEXP (op0, 0);
11255               op1 = tem;
11256               continue;
11257             }
11258
11259           /* If we are doing a < 0 or >= 0 comparison, it means we are testing
11260              a particular bit.  Convert it to an AND of a constant of that
11261              bit.  This will be converted into a ZERO_EXTRACT.  */
11262           if (const_op == 0 && sign_bit_comparison_p
11263               && CONST_INT_P (XEXP (op0, 1))
11264               && mode_width <= HOST_BITS_PER_WIDE_INT)
11265             {
11266               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
11267                                             ((unsigned HOST_WIDE_INT) 1
11268                                              << (mode_width - 1
11269                                                  - INTVAL (XEXP (op0, 1)))));
11270               code = (code == LT ? NE : EQ);
11271               continue;
11272             }
11273
11274           /* Fall through.  */
11275
11276         case ABS:
11277           /* ABS is ignorable inside an equality comparison with zero.  */
11278           if (const_op == 0 && equality_comparison_p)
11279             {
11280               op0 = XEXP (op0, 0);
11281               continue;
11282             }
11283           break;
11284
11285         case SIGN_EXTEND:
11286           /* Can simplify (compare (zero/sign_extend FOO) CONST) to
11287              (compare FOO CONST) if CONST fits in FOO's mode and we
11288              are either testing inequality or have an unsigned
11289              comparison with ZERO_EXTEND or a signed comparison with
11290              SIGN_EXTEND.  But don't do it if we don't have a compare
11291              insn of the given mode, since we'd have to revert it
11292              later on, and then we wouldn't know whether to sign- or
11293              zero-extend.  */
11294           mode = GET_MODE (XEXP (op0, 0));
11295           if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
11296               && ! unsigned_comparison_p
11297               && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11298               && ((unsigned HOST_WIDE_INT) const_op
11299                   < (((unsigned HOST_WIDE_INT) 1
11300                       << (GET_MODE_BITSIZE (mode) - 1))))
11301               && have_insn_for (COMPARE, mode))
11302             {
11303               op0 = XEXP (op0, 0);
11304               continue;
11305             }
11306           break;
11307
11308         case SUBREG:
11309           /* Check for the case where we are comparing A - C1 with C2, that is
11310
11311                (subreg:MODE (plus (A) (-C1))) op (C2)
11312
11313              with C1 a constant, and try to lift the SUBREG, i.e. to do the
11314              comparison in the wider mode.  One of the following two conditions
11315              must be true in order for this to be valid:
11316
11317                1. The mode extension results in the same bit pattern being added
11318                   on both sides and the comparison is equality or unsigned.  As
11319                   C2 has been truncated to fit in MODE, the pattern can only be
11320                   all 0s or all 1s.
11321
11322                2. The mode extension results in the sign bit being copied on
11323                   each side.
11324
11325              The difficulty here is that we have predicates for A but not for
11326              (A - C1) so we need to check that C1 is within proper bounds so
11327              as to perturbate A as little as possible.  */
11328
11329           if (mode_width <= HOST_BITS_PER_WIDE_INT
11330               && subreg_lowpart_p (op0)
11331               && GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0))) > mode_width
11332               && GET_CODE (SUBREG_REG (op0)) == PLUS
11333               && CONST_INT_P (XEXP (SUBREG_REG (op0), 1)))
11334             {
11335               enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op0));
11336               rtx a = XEXP (SUBREG_REG (op0), 0);
11337               HOST_WIDE_INT c1 = -INTVAL (XEXP (SUBREG_REG (op0), 1));
11338
11339               if ((c1 > 0
11340                    && (unsigned HOST_WIDE_INT) c1
11341                        < (unsigned HOST_WIDE_INT) 1 << (mode_width - 1)
11342                    && (equality_comparison_p || unsigned_comparison_p)
11343                    /* (A - C1) zero-extends if it is positive and sign-extends
11344                       if it is negative, C2 both zero- and sign-extends.  */
11345                    && ((0 == (nonzero_bits (a, inner_mode)
11346                               & ~GET_MODE_MASK (mode))
11347                         && const_op >= 0)
11348                        /* (A - C1) sign-extends if it is positive and 1-extends
11349                           if it is negative, C2 both sign- and 1-extends.  */
11350                        || (num_sign_bit_copies (a, inner_mode)
11351                            > (unsigned int) (GET_MODE_BITSIZE (inner_mode)
11352                                              - mode_width)
11353                            && const_op < 0)))
11354                   || ((unsigned HOST_WIDE_INT) c1
11355                        < (unsigned HOST_WIDE_INT) 1 << (mode_width - 2)
11356                       /* (A - C1) always sign-extends, like C2.  */
11357                       && num_sign_bit_copies (a, inner_mode)
11358                          > (unsigned int) (GET_MODE_BITSIZE (inner_mode)
11359                                            - (mode_width - 1))))
11360                 {
11361                   op0 = SUBREG_REG (op0);
11362                   continue;
11363                 }
11364             }
11365
11366           /* If the inner mode is narrower and we are extracting the low part,
11367              we can treat the SUBREG as if it were a ZERO_EXTEND.  */
11368           if (subreg_lowpart_p (op0)
11369               && GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0))) < mode_width)
11370             /* Fall through */ ;
11371           else
11372             break;
11373
11374           /* ... fall through ...  */
11375
11376         case ZERO_EXTEND:
11377           mode = GET_MODE (XEXP (op0, 0));
11378           if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
11379               && (unsigned_comparison_p || equality_comparison_p)
11380               && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11381               && ((unsigned HOST_WIDE_INT) const_op < GET_MODE_MASK (mode))
11382               && have_insn_for (COMPARE, mode))
11383             {
11384               op0 = XEXP (op0, 0);
11385               continue;
11386             }
11387           break;
11388
11389         case PLUS:
11390           /* (eq (plus X A) B) -> (eq X (minus B A)).  We can only do
11391              this for equality comparisons due to pathological cases involving
11392              overflows.  */
11393           if (equality_comparison_p
11394               && 0 != (tem = simplify_binary_operation (MINUS, mode,
11395                                                         op1, XEXP (op0, 1))))
11396             {
11397               op0 = XEXP (op0, 0);
11398               op1 = tem;
11399               continue;
11400             }
11401
11402           /* (plus (abs X) (const_int -1)) is < 0 if and only if X == 0.  */
11403           if (const_op == 0 && XEXP (op0, 1) == constm1_rtx
11404               && GET_CODE (XEXP (op0, 0)) == ABS && sign_bit_comparison_p)
11405             {
11406               op0 = XEXP (XEXP (op0, 0), 0);
11407               code = (code == LT ? EQ : NE);
11408               continue;
11409             }
11410           break;
11411
11412         case MINUS:
11413           /* We used to optimize signed comparisons against zero, but that
11414              was incorrect.  Unsigned comparisons against zero (GTU, LEU)
11415              arrive here as equality comparisons, or (GEU, LTU) are
11416              optimized away.  No need to special-case them.  */
11417
11418           /* (eq (minus A B) C) -> (eq A (plus B C)) or
11419              (eq B (minus A C)), whichever simplifies.  We can only do
11420              this for equality comparisons due to pathological cases involving
11421              overflows.  */
11422           if (equality_comparison_p
11423               && 0 != (tem = simplify_binary_operation (PLUS, mode,
11424                                                         XEXP (op0, 1), op1)))
11425             {
11426               op0 = XEXP (op0, 0);
11427               op1 = tem;
11428               continue;
11429             }
11430
11431           if (equality_comparison_p
11432               && 0 != (tem = simplify_binary_operation (MINUS, mode,
11433                                                         XEXP (op0, 0), op1)))
11434             {
11435               op0 = XEXP (op0, 1);
11436               op1 = tem;
11437               continue;
11438             }
11439
11440           /* The sign bit of (minus (ashiftrt X C) X), where C is the number
11441              of bits in X minus 1, is one iff X > 0.  */
11442           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 0)) == ASHIFTRT
11443               && CONST_INT_P (XEXP (XEXP (op0, 0), 1))
11444               && UINTVAL (XEXP (XEXP (op0, 0), 1)) == mode_width - 1
11445               && rtx_equal_p (XEXP (XEXP (op0, 0), 0), XEXP (op0, 1)))
11446             {
11447               op0 = XEXP (op0, 1);
11448               code = (code == GE ? LE : GT);
11449               continue;
11450             }
11451           break;
11452
11453         case XOR:
11454           /* (eq (xor A B) C) -> (eq A (xor B C)).  This is a simplification
11455              if C is zero or B is a constant.  */
11456           if (equality_comparison_p
11457               && 0 != (tem = simplify_binary_operation (XOR, mode,
11458                                                         XEXP (op0, 1), op1)))
11459             {
11460               op0 = XEXP (op0, 0);
11461               op1 = tem;
11462               continue;
11463             }
11464           break;
11465
11466         case EQ:  case NE:
11467         case UNEQ:  case LTGT:
11468         case LT:  case LTU:  case UNLT:  case LE:  case LEU:  case UNLE:
11469         case GT:  case GTU:  case UNGT:  case GE:  case GEU:  case UNGE:
11470         case UNORDERED: case ORDERED:
11471           /* We can't do anything if OP0 is a condition code value, rather
11472              than an actual data value.  */
11473           if (const_op != 0
11474               || CC0_P (XEXP (op0, 0))
11475               || GET_MODE_CLASS (GET_MODE (XEXP (op0, 0))) == MODE_CC)
11476             break;
11477
11478           /* Get the two operands being compared.  */
11479           if (GET_CODE (XEXP (op0, 0)) == COMPARE)
11480             tem = XEXP (XEXP (op0, 0), 0), tem1 = XEXP (XEXP (op0, 0), 1);
11481           else
11482             tem = XEXP (op0, 0), tem1 = XEXP (op0, 1);
11483
11484           /* Check for the cases where we simply want the result of the
11485              earlier test or the opposite of that result.  */
11486           if (code == NE || code == EQ
11487               || (GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
11488                   && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
11489                   && (STORE_FLAG_VALUE
11490                       & (((unsigned HOST_WIDE_INT) 1
11491                           << (GET_MODE_BITSIZE (GET_MODE (op0)) - 1))))
11492                   && (code == LT || code == GE)))
11493             {
11494               enum rtx_code new_code;
11495               if (code == LT || code == NE)
11496                 new_code = GET_CODE (op0);
11497               else
11498                 new_code = reversed_comparison_code (op0, NULL);
11499
11500               if (new_code != UNKNOWN)
11501                 {
11502                   code = new_code;
11503                   op0 = tem;
11504                   op1 = tem1;
11505                   continue;
11506                 }
11507             }
11508           break;
11509
11510         case IOR:
11511           /* The sign bit of (ior (plus X (const_int -1)) X) is nonzero
11512              iff X <= 0.  */
11513           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 0)) == PLUS
11514               && XEXP (XEXP (op0, 0), 1) == constm1_rtx
11515               && rtx_equal_p (XEXP (XEXP (op0, 0), 0), XEXP (op0, 1)))
11516             {
11517               op0 = XEXP (op0, 1);
11518               code = (code == GE ? GT : LE);
11519               continue;
11520             }
11521           break;
11522
11523         case AND:
11524           /* Convert (and (xshift 1 X) Y) to (and (lshiftrt Y X) 1).  This
11525              will be converted to a ZERO_EXTRACT later.  */
11526           if (const_op == 0 && equality_comparison_p
11527               && GET_CODE (XEXP (op0, 0)) == ASHIFT
11528               && XEXP (XEXP (op0, 0), 0) == const1_rtx)
11529             {
11530               op0 = gen_rtx_LSHIFTRT (mode, XEXP (op0, 1),
11531                                       XEXP (XEXP (op0, 0), 1));
11532               op0 = simplify_and_const_int (NULL_RTX, mode, op0, 1);
11533               continue;
11534             }
11535
11536           /* If we are comparing (and (lshiftrt X C1) C2) for equality with
11537              zero and X is a comparison and C1 and C2 describe only bits set
11538              in STORE_FLAG_VALUE, we can compare with X.  */
11539           if (const_op == 0 && equality_comparison_p
11540               && mode_width <= HOST_BITS_PER_WIDE_INT
11541               && CONST_INT_P (XEXP (op0, 1))
11542               && GET_CODE (XEXP (op0, 0)) == LSHIFTRT
11543               && CONST_INT_P (XEXP (XEXP (op0, 0), 1))
11544               && INTVAL (XEXP (XEXP (op0, 0), 1)) >= 0
11545               && INTVAL (XEXP (XEXP (op0, 0), 1)) < HOST_BITS_PER_WIDE_INT)
11546             {
11547               mask = ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
11548                       << INTVAL (XEXP (XEXP (op0, 0), 1)));
11549               if ((~STORE_FLAG_VALUE & mask) == 0
11550                   && (COMPARISON_P (XEXP (XEXP (op0, 0), 0))
11551                       || ((tem = get_last_value (XEXP (XEXP (op0, 0), 0))) != 0
11552                           && COMPARISON_P (tem))))
11553                 {
11554                   op0 = XEXP (XEXP (op0, 0), 0);
11555                   continue;
11556                 }
11557             }
11558
11559           /* If we are doing an equality comparison of an AND of a bit equal
11560              to the sign bit, replace this with a LT or GE comparison of
11561              the underlying value.  */
11562           if (equality_comparison_p
11563               && const_op == 0
11564               && CONST_INT_P (XEXP (op0, 1))
11565               && mode_width <= HOST_BITS_PER_WIDE_INT
11566               && ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
11567                   == (unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
11568             {
11569               op0 = XEXP (op0, 0);
11570               code = (code == EQ ? GE : LT);
11571               continue;
11572             }
11573
11574           /* If this AND operation is really a ZERO_EXTEND from a narrower
11575              mode, the constant fits within that mode, and this is either an
11576              equality or unsigned comparison, try to do this comparison in
11577              the narrower mode.
11578
11579              Note that in:
11580
11581              (ne:DI (and:DI (reg:DI 4) (const_int 0xffffffff)) (const_int 0))
11582              -> (ne:DI (reg:SI 4) (const_int 0))
11583
11584              unless TRULY_NOOP_TRUNCATION allows it or the register is
11585              known to hold a value of the required mode the
11586              transformation is invalid.  */
11587           if ((equality_comparison_p || unsigned_comparison_p)
11588               && CONST_INT_P (XEXP (op0, 1))
11589               && (i = exact_log2 ((UINTVAL (XEXP (op0, 1))
11590                                    & GET_MODE_MASK (mode))
11591                                   + 1)) >= 0
11592               && const_op >> i == 0
11593               && (tmode = mode_for_size (i, MODE_INT, 1)) != BLKmode
11594               && (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (tmode),
11595                                          GET_MODE_BITSIZE (GET_MODE (op0)))
11596                   || (REG_P (XEXP (op0, 0))
11597                       && reg_truncated_to_mode (tmode, XEXP (op0, 0)))))
11598             {
11599               op0 = gen_lowpart (tmode, XEXP (op0, 0));
11600               continue;
11601             }
11602
11603           /* If this is (and:M1 (subreg:M2 X 0) (const_int C1)) where C1
11604              fits in both M1 and M2 and the SUBREG is either paradoxical
11605              or represents the low part, permute the SUBREG and the AND
11606              and try again.  */
11607           if (GET_CODE (XEXP (op0, 0)) == SUBREG)
11608             {
11609               unsigned HOST_WIDE_INT c1;
11610               tmode = GET_MODE (SUBREG_REG (XEXP (op0, 0)));
11611               /* Require an integral mode, to avoid creating something like
11612                  (AND:SF ...).  */
11613               if (SCALAR_INT_MODE_P (tmode)
11614                   /* It is unsafe to commute the AND into the SUBREG if the
11615                      SUBREG is paradoxical and WORD_REGISTER_OPERATIONS is
11616                      not defined.  As originally written the upper bits
11617                      have a defined value due to the AND operation.
11618                      However, if we commute the AND inside the SUBREG then
11619                      they no longer have defined values and the meaning of
11620                      the code has been changed.  */
11621                   && (0
11622 #ifdef WORD_REGISTER_OPERATIONS
11623                       || (mode_width > GET_MODE_BITSIZE (tmode)
11624                           && mode_width <= BITS_PER_WORD)
11625 #endif
11626                       || (mode_width <= GET_MODE_BITSIZE (tmode)
11627                           && subreg_lowpart_p (XEXP (op0, 0))))
11628                   && CONST_INT_P (XEXP (op0, 1))
11629                   && mode_width <= HOST_BITS_PER_WIDE_INT
11630                   && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT
11631                   && ((c1 = INTVAL (XEXP (op0, 1))) & ~mask) == 0
11632                   && (c1 & ~GET_MODE_MASK (tmode)) == 0
11633                   && c1 != mask
11634                   && c1 != GET_MODE_MASK (tmode))
11635                 {
11636                   op0 = simplify_gen_binary (AND, tmode,
11637                                              SUBREG_REG (XEXP (op0, 0)),
11638                                              gen_int_mode (c1, tmode));
11639                   op0 = gen_lowpart (mode, op0);
11640                   continue;
11641                 }
11642             }
11643
11644           /* Convert (ne (and (not X) 1) 0) to (eq (and X 1) 0).  */
11645           if (const_op == 0 && equality_comparison_p
11646               && XEXP (op0, 1) == const1_rtx
11647               && GET_CODE (XEXP (op0, 0)) == NOT)
11648             {
11649               op0 = simplify_and_const_int (NULL_RTX, mode,
11650                                             XEXP (XEXP (op0, 0), 0), 1);
11651               code = (code == NE ? EQ : NE);
11652               continue;
11653             }
11654
11655           /* Convert (ne (and (lshiftrt (not X)) 1) 0) to
11656              (eq (and (lshiftrt X) 1) 0).
11657              Also handle the case where (not X) is expressed using xor.  */
11658           if (const_op == 0 && equality_comparison_p
11659               && XEXP (op0, 1) == const1_rtx
11660               && GET_CODE (XEXP (op0, 0)) == LSHIFTRT)
11661             {
11662               rtx shift_op = XEXP (XEXP (op0, 0), 0);
11663               rtx shift_count = XEXP (XEXP (op0, 0), 1);
11664
11665               if (GET_CODE (shift_op) == NOT
11666                   || (GET_CODE (shift_op) == XOR
11667                       && CONST_INT_P (XEXP (shift_op, 1))
11668                       && CONST_INT_P (shift_count)
11669                       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
11670                       && (UINTVAL (XEXP (shift_op, 1))
11671                           == (unsigned HOST_WIDE_INT) 1
11672                                << INTVAL (shift_count))))
11673                 {
11674                   op0
11675                     = gen_rtx_LSHIFTRT (mode, XEXP (shift_op, 0), shift_count);
11676                   op0 = simplify_and_const_int (NULL_RTX, mode, op0, 1);
11677                   code = (code == NE ? EQ : NE);
11678                   continue;
11679                 }
11680             }
11681           break;
11682
11683         case ASHIFT:
11684           /* If we have (compare (ashift FOO N) (const_int C)) and
11685              the high order N bits of FOO (N+1 if an inequality comparison)
11686              are known to be zero, we can do this by comparing FOO with C
11687              shifted right N bits so long as the low-order N bits of C are
11688              zero.  */
11689           if (CONST_INT_P (XEXP (op0, 1))
11690               && INTVAL (XEXP (op0, 1)) >= 0
11691               && ((INTVAL (XEXP (op0, 1)) + ! equality_comparison_p)
11692                   < HOST_BITS_PER_WIDE_INT)
11693               && (((unsigned HOST_WIDE_INT) const_op
11694                    & (((unsigned HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1)))
11695                       - 1)) == 0)
11696               && mode_width <= HOST_BITS_PER_WIDE_INT
11697               && (nonzero_bits (XEXP (op0, 0), mode)
11698                   & ~(mask >> (INTVAL (XEXP (op0, 1))
11699                                + ! equality_comparison_p))) == 0)
11700             {
11701               /* We must perform a logical shift, not an arithmetic one,
11702                  as we want the top N bits of C to be zero.  */
11703               unsigned HOST_WIDE_INT temp = const_op & GET_MODE_MASK (mode);
11704
11705               temp >>= INTVAL (XEXP (op0, 1));
11706               op1 = gen_int_mode (temp, mode);
11707               op0 = XEXP (op0, 0);
11708               continue;
11709             }
11710
11711           /* If we are doing a sign bit comparison, it means we are testing
11712              a particular bit.  Convert it to the appropriate AND.  */
11713           if (sign_bit_comparison_p && CONST_INT_P (XEXP (op0, 1))
11714               && mode_width <= HOST_BITS_PER_WIDE_INT)
11715             {
11716               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
11717                                             ((unsigned HOST_WIDE_INT) 1
11718                                              << (mode_width - 1
11719                                                  - INTVAL (XEXP (op0, 1)))));
11720               code = (code == LT ? NE : EQ);
11721               continue;
11722             }
11723
11724           /* If this an equality comparison with zero and we are shifting
11725              the low bit to the sign bit, we can convert this to an AND of the
11726              low-order bit.  */
11727           if (const_op == 0 && equality_comparison_p
11728               && CONST_INT_P (XEXP (op0, 1))
11729               && UINTVAL (XEXP (op0, 1)) == mode_width - 1)
11730             {
11731               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0), 1);
11732               continue;
11733             }
11734           break;
11735
11736         case ASHIFTRT:
11737           /* If this is an equality comparison with zero, we can do this
11738              as a logical shift, which might be much simpler.  */
11739           if (equality_comparison_p && const_op == 0
11740               && CONST_INT_P (XEXP (op0, 1)))
11741             {
11742               op0 = simplify_shift_const (NULL_RTX, LSHIFTRT, mode,
11743                                           XEXP (op0, 0),
11744                                           INTVAL (XEXP (op0, 1)));
11745               continue;
11746             }
11747
11748           /* If OP0 is a sign extension and CODE is not an unsigned comparison,
11749              do the comparison in a narrower mode.  */
11750           if (! unsigned_comparison_p
11751               && CONST_INT_P (XEXP (op0, 1))
11752               && GET_CODE (XEXP (op0, 0)) == ASHIFT
11753               && XEXP (op0, 1) == XEXP (XEXP (op0, 0), 1)
11754               && (tmode = mode_for_size (mode_width - INTVAL (XEXP (op0, 1)),
11755                                          MODE_INT, 1)) != BLKmode
11756               && (((unsigned HOST_WIDE_INT) const_op
11757                    + (GET_MODE_MASK (tmode) >> 1) + 1)
11758                   <= GET_MODE_MASK (tmode)))
11759             {
11760               op0 = gen_lowpart (tmode, XEXP (XEXP (op0, 0), 0));
11761               continue;
11762             }
11763
11764           /* Likewise if OP0 is a PLUS of a sign extension with a
11765              constant, which is usually represented with the PLUS
11766              between the shifts.  */
11767           if (! unsigned_comparison_p
11768               && CONST_INT_P (XEXP (op0, 1))
11769               && GET_CODE (XEXP (op0, 0)) == PLUS
11770               && CONST_INT_P (XEXP (XEXP (op0, 0), 1))
11771               && GET_CODE (XEXP (XEXP (op0, 0), 0)) == ASHIFT
11772               && XEXP (op0, 1) == XEXP (XEXP (XEXP (op0, 0), 0), 1)
11773               && (tmode = mode_for_size (mode_width - INTVAL (XEXP (op0, 1)),
11774                                          MODE_INT, 1)) != BLKmode
11775               && (((unsigned HOST_WIDE_INT) const_op
11776                    + (GET_MODE_MASK (tmode) >> 1) + 1)
11777                   <= GET_MODE_MASK (tmode)))
11778             {
11779               rtx inner = XEXP (XEXP (XEXP (op0, 0), 0), 0);
11780               rtx add_const = XEXP (XEXP (op0, 0), 1);
11781               rtx new_const = simplify_gen_binary (ASHIFTRT, GET_MODE (op0),
11782                                                    add_const, XEXP (op0, 1));
11783
11784               op0 = simplify_gen_binary (PLUS, tmode,
11785                                          gen_lowpart (tmode, inner),
11786                                          new_const);
11787               continue;
11788             }
11789
11790           /* ... fall through ...  */
11791         case LSHIFTRT:
11792           /* If we have (compare (xshiftrt FOO N) (const_int C)) and
11793              the low order N bits of FOO are known to be zero, we can do this
11794              by comparing FOO with C shifted left N bits so long as no
11795              overflow occurs.  Even if the low order N bits of FOO aren't known
11796              to be zero, if the comparison is >= or < we can use the same
11797              optimization and for > or <= by setting all the low
11798              order N bits in the comparison constant.  */
11799           if (CONST_INT_P (XEXP (op0, 1))
11800               && INTVAL (XEXP (op0, 1)) > 0
11801               && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
11802               && mode_width <= HOST_BITS_PER_WIDE_INT
11803               && (((unsigned HOST_WIDE_INT) const_op
11804                    + (GET_CODE (op0) != LSHIFTRT
11805                       ? ((GET_MODE_MASK (mode) >> INTVAL (XEXP (op0, 1)) >> 1)
11806                          + 1)
11807                       : 0))
11808                   <= GET_MODE_MASK (mode) >> INTVAL (XEXP (op0, 1))))
11809             {
11810               unsigned HOST_WIDE_INT low_bits
11811                 = (nonzero_bits (XEXP (op0, 0), mode)
11812                    & (((unsigned HOST_WIDE_INT) 1
11813                        << INTVAL (XEXP (op0, 1))) - 1));
11814               if (low_bits == 0 || !equality_comparison_p)
11815                 {
11816                   /* If the shift was logical, then we must make the condition
11817                      unsigned.  */
11818                   if (GET_CODE (op0) == LSHIFTRT)
11819                     code = unsigned_condition (code);
11820
11821                   const_op <<= INTVAL (XEXP (op0, 1));
11822                   if (low_bits != 0
11823                       && (code == GT || code == GTU
11824                           || code == LE || code == LEU))
11825                     const_op
11826                       |= (((HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1))) - 1);
11827                   op1 = GEN_INT (const_op);
11828                   op0 = XEXP (op0, 0);
11829                   continue;
11830                 }
11831             }
11832
11833           /* If we are using this shift to extract just the sign bit, we
11834              can replace this with an LT or GE comparison.  */
11835           if (const_op == 0
11836               && (equality_comparison_p || sign_bit_comparison_p)
11837               && CONST_INT_P (XEXP (op0, 1))
11838               && UINTVAL (XEXP (op0, 1)) == mode_width - 1)
11839             {
11840               op0 = XEXP (op0, 0);
11841               code = (code == NE || code == GT ? LT : GE);
11842               continue;
11843             }
11844           break;
11845
11846         default:
11847           break;
11848         }
11849
11850       break;
11851     }
11852
11853   /* Now make any compound operations involved in this comparison.  Then,
11854      check for an outmost SUBREG on OP0 that is not doing anything or is
11855      paradoxical.  The latter transformation must only be performed when
11856      it is known that the "extra" bits will be the same in op0 and op1 or
11857      that they don't matter.  There are three cases to consider:
11858
11859      1. SUBREG_REG (op0) is a register.  In this case the bits are don't
11860      care bits and we can assume they have any convenient value.  So
11861      making the transformation is safe.
11862
11863      2. SUBREG_REG (op0) is a memory and LOAD_EXTEND_OP is not defined.
11864      In this case the upper bits of op0 are undefined.  We should not make
11865      the simplification in that case as we do not know the contents of
11866      those bits.
11867
11868      3. SUBREG_REG (op0) is a memory and LOAD_EXTEND_OP is defined and not
11869      UNKNOWN.  In that case we know those bits are zeros or ones.  We must
11870      also be sure that they are the same as the upper bits of op1.
11871
11872      We can never remove a SUBREG for a non-equality comparison because
11873      the sign bit is in a different place in the underlying object.  */
11874
11875   op0 = make_compound_operation (op0, op1 == const0_rtx ? COMPARE : SET);
11876   op1 = make_compound_operation (op1, SET);
11877
11878   if (GET_CODE (op0) == SUBREG && subreg_lowpart_p (op0)
11879       && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
11880       && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op0))) == MODE_INT
11881       && (code == NE || code == EQ))
11882     {
11883       if (GET_MODE_SIZE (GET_MODE (op0))
11884           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0))))
11885         {
11886           /* For paradoxical subregs, allow case 1 as above.  Case 3 isn't
11887              implemented.  */
11888           if (REG_P (SUBREG_REG (op0)))
11889             {
11890               op0 = SUBREG_REG (op0);
11891               op1 = gen_lowpart (GET_MODE (op0), op1);
11892             }
11893         }
11894       else if ((GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0)))
11895                 <= HOST_BITS_PER_WIDE_INT)
11896                && (nonzero_bits (SUBREG_REG (op0),
11897                                  GET_MODE (SUBREG_REG (op0)))
11898                    & ~GET_MODE_MASK (GET_MODE (op0))) == 0)
11899         {
11900           tem = gen_lowpart (GET_MODE (SUBREG_REG (op0)), op1);
11901
11902           if ((nonzero_bits (tem, GET_MODE (SUBREG_REG (op0)))
11903                & ~GET_MODE_MASK (GET_MODE (op0))) == 0)
11904             op0 = SUBREG_REG (op0), op1 = tem;
11905         }
11906     }
11907
11908   /* We now do the opposite procedure: Some machines don't have compare
11909      insns in all modes.  If OP0's mode is an integer mode smaller than a
11910      word and we can't do a compare in that mode, see if there is a larger
11911      mode for which we can do the compare.  There are a number of cases in
11912      which we can use the wider mode.  */
11913
11914   mode = GET_MODE (op0);
11915   if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
11916       && GET_MODE_SIZE (mode) < UNITS_PER_WORD
11917       && ! have_insn_for (COMPARE, mode))
11918     for (tmode = GET_MODE_WIDER_MODE (mode);
11919          (tmode != VOIDmode
11920           && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT);
11921          tmode = GET_MODE_WIDER_MODE (tmode))
11922       if (have_insn_for (COMPARE, tmode))
11923         {
11924           int zero_extended;
11925
11926           /* If this is a test for negative, we can make an explicit
11927              test of the sign bit.  Test this first so we can use
11928              a paradoxical subreg to extend OP0.  */
11929
11930           if (op1 == const0_rtx && (code == LT || code == GE)
11931               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11932             {
11933               op0 = simplify_gen_binary (AND, tmode,
11934                                          gen_lowpart (tmode, op0),
11935                                          GEN_INT ((unsigned HOST_WIDE_INT) 1
11936                                                   << (GET_MODE_BITSIZE (mode)
11937                                                       - 1)));
11938               code = (code == LT) ? NE : EQ;
11939               break;
11940             }
11941
11942           /* If the only nonzero bits in OP0 and OP1 are those in the
11943              narrower mode and this is an equality or unsigned comparison,
11944              we can use the wider mode.  Similarly for sign-extended
11945              values, in which case it is true for all comparisons.  */
11946           zero_extended = ((code == EQ || code == NE
11947                             || code == GEU || code == GTU
11948                             || code == LEU || code == LTU)
11949                            && (nonzero_bits (op0, tmode)
11950                                & ~GET_MODE_MASK (mode)) == 0
11951                            && ((CONST_INT_P (op1)
11952                                 || (nonzero_bits (op1, tmode)
11953                                     & ~GET_MODE_MASK (mode)) == 0)));
11954
11955           if (zero_extended
11956               || ((num_sign_bit_copies (op0, tmode)
11957                    > (unsigned int) (GET_MODE_BITSIZE (tmode)
11958                                      - GET_MODE_BITSIZE (mode)))
11959                   && (num_sign_bit_copies (op1, tmode)
11960                       > (unsigned int) (GET_MODE_BITSIZE (tmode)
11961                                         - GET_MODE_BITSIZE (mode)))))
11962             {
11963               /* If OP0 is an AND and we don't have an AND in MODE either,
11964                  make a new AND in the proper mode.  */
11965               if (GET_CODE (op0) == AND
11966                   && !have_insn_for (AND, mode))
11967                 op0 = simplify_gen_binary (AND, tmode,
11968                                            gen_lowpart (tmode,
11969                                                         XEXP (op0, 0)),
11970                                            gen_lowpart (tmode,
11971                                                         XEXP (op0, 1)));
11972               else
11973                 {
11974                   if (zero_extended)
11975                     {
11976                       op0 = simplify_gen_unary (ZERO_EXTEND, tmode, op0, mode);
11977                       op1 = simplify_gen_unary (ZERO_EXTEND, tmode, op1, mode);
11978                     }
11979                   else
11980                     {
11981                       op0 = simplify_gen_unary (SIGN_EXTEND, tmode, op0, mode);
11982                       op1 = simplify_gen_unary (SIGN_EXTEND, tmode, op1, mode);
11983                     }
11984                   break;
11985                 }
11986             }
11987         }
11988
11989 #ifdef CANONICALIZE_COMPARISON
11990   /* If this machine only supports a subset of valid comparisons, see if we
11991      can convert an unsupported one into a supported one.  */
11992   CANONICALIZE_COMPARISON (code, op0, op1);
11993 #endif
11994
11995   *pop0 = op0;
11996   *pop1 = op1;
11997
11998   return code;
11999 }
12000 \f
12001 /* Utility function for record_value_for_reg.  Count number of
12002    rtxs in X.  */
12003 static int
12004 count_rtxs (rtx x)
12005 {
12006   enum rtx_code code = GET_CODE (x);
12007   const char *fmt;
12008   int i, j, ret = 1;
12009
12010   if (GET_RTX_CLASS (code) == '2'
12011       || GET_RTX_CLASS (code) == 'c')
12012     {
12013       rtx x0 = XEXP (x, 0);
12014       rtx x1 = XEXP (x, 1);
12015
12016       if (x0 == x1)
12017         return 1 + 2 * count_rtxs (x0);
12018
12019       if ((GET_RTX_CLASS (GET_CODE (x1)) == '2'
12020            || GET_RTX_CLASS (GET_CODE (x1)) == 'c')
12021           && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
12022         return 2 + 2 * count_rtxs (x0)
12023                + count_rtxs (x == XEXP (x1, 0)
12024                              ? XEXP (x1, 1) : XEXP (x1, 0));
12025
12026       if ((GET_RTX_CLASS (GET_CODE (x0)) == '2'
12027            || GET_RTX_CLASS (GET_CODE (x0)) == 'c')
12028           && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
12029         return 2 + 2 * count_rtxs (x1)
12030                + count_rtxs (x == XEXP (x0, 0)
12031                              ? XEXP (x0, 1) : XEXP (x0, 0));
12032     }
12033
12034   fmt = GET_RTX_FORMAT (code);
12035   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12036     if (fmt[i] == 'e')
12037       ret += count_rtxs (XEXP (x, i));
12038     else if (fmt[i] == 'E')
12039       for (j = 0; j < XVECLEN (x, i); j++)
12040         ret += count_rtxs (XVECEXP (x, i, j));
12041
12042   return ret;
12043 }
12044 \f
12045 /* Utility function for following routine.  Called when X is part of a value
12046    being stored into last_set_value.  Sets last_set_table_tick
12047    for each register mentioned.  Similar to mention_regs in cse.c  */
12048
12049 static void
12050 update_table_tick (rtx x)
12051 {
12052   enum rtx_code code = GET_CODE (x);
12053   const char *fmt = GET_RTX_FORMAT (code);
12054   int i, j;
12055
12056   if (code == REG)
12057     {
12058       unsigned int regno = REGNO (x);
12059       unsigned int endregno = END_REGNO (x);
12060       unsigned int r;
12061
12062       for (r = regno; r < endregno; r++)
12063         {
12064           reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, r);
12065           rsp->last_set_table_tick = label_tick;
12066         }
12067
12068       return;
12069     }
12070
12071   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12072     if (fmt[i] == 'e')
12073       {
12074         /* Check for identical subexpressions.  If x contains
12075            identical subexpression we only have to traverse one of
12076            them.  */
12077         if (i == 0 && ARITHMETIC_P (x))
12078           {
12079             /* Note that at this point x1 has already been
12080                processed.  */
12081             rtx x0 = XEXP (x, 0);
12082             rtx x1 = XEXP (x, 1);
12083
12084             /* If x0 and x1 are identical then there is no need to
12085                process x0.  */
12086             if (x0 == x1)
12087               break;
12088
12089             /* If x0 is identical to a subexpression of x1 then while
12090                processing x1, x0 has already been processed.  Thus we
12091                are done with x.  */
12092             if (ARITHMETIC_P (x1)
12093                 && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
12094               break;
12095
12096             /* If x1 is identical to a subexpression of x0 then we
12097                still have to process the rest of x0.  */
12098             if (ARITHMETIC_P (x0)
12099                 && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
12100               {
12101                 update_table_tick (XEXP (x0, x1 == XEXP (x0, 0) ? 1 : 0));
12102                 break;
12103               }
12104           }
12105
12106         update_table_tick (XEXP (x, i));
12107       }
12108     else if (fmt[i] == 'E')
12109       for (j = 0; j < XVECLEN (x, i); j++)
12110         update_table_tick (XVECEXP (x, i, j));
12111 }
12112
12113 /* Record that REG is set to VALUE in insn INSN.  If VALUE is zero, we
12114    are saying that the register is clobbered and we no longer know its
12115    value.  If INSN is zero, don't update reg_stat[].last_set; this is
12116    only permitted with VALUE also zero and is used to invalidate the
12117    register.  */
12118
12119 static void
12120 record_value_for_reg (rtx reg, rtx insn, rtx value)
12121 {
12122   unsigned int regno = REGNO (reg);
12123   unsigned int endregno = END_REGNO (reg);
12124   unsigned int i;
12125   reg_stat_type *rsp;
12126
12127   /* If VALUE contains REG and we have a previous value for REG, substitute
12128      the previous value.  */
12129   if (value && insn && reg_overlap_mentioned_p (reg, value))
12130     {
12131       rtx tem;
12132
12133       /* Set things up so get_last_value is allowed to see anything set up to
12134          our insn.  */
12135       subst_low_luid = DF_INSN_LUID (insn);
12136       tem = get_last_value (reg);
12137
12138       /* If TEM is simply a binary operation with two CLOBBERs as operands,
12139          it isn't going to be useful and will take a lot of time to process,
12140          so just use the CLOBBER.  */
12141
12142       if (tem)
12143         {
12144           if (ARITHMETIC_P (tem)
12145               && GET_CODE (XEXP (tem, 0)) == CLOBBER
12146               && GET_CODE (XEXP (tem, 1)) == CLOBBER)
12147             tem = XEXP (tem, 0);
12148           else if (count_occurrences (value, reg, 1) >= 2)
12149             {
12150               /* If there are two or more occurrences of REG in VALUE,
12151                  prevent the value from growing too much.  */
12152               if (count_rtxs (tem) > MAX_LAST_VALUE_RTL)
12153                 tem = gen_rtx_CLOBBER (GET_MODE (tem), const0_rtx);
12154             }
12155
12156           value = replace_rtx (copy_rtx (value), reg, tem);
12157         }
12158     }
12159
12160   /* For each register modified, show we don't know its value, that
12161      we don't know about its bitwise content, that its value has been
12162      updated, and that we don't know the location of the death of the
12163      register.  */
12164   for (i = regno; i < endregno; i++)
12165     {
12166       rsp = VEC_index (reg_stat_type, reg_stat, i);
12167
12168       if (insn)
12169         rsp->last_set = insn;
12170
12171       rsp->last_set_value = 0;
12172       rsp->last_set_mode = VOIDmode;
12173       rsp->last_set_nonzero_bits = 0;
12174       rsp->last_set_sign_bit_copies = 0;
12175       rsp->last_death = 0;
12176       rsp->truncated_to_mode = VOIDmode;
12177     }
12178
12179   /* Mark registers that are being referenced in this value.  */
12180   if (value)
12181     update_table_tick (value);
12182
12183   /* Now update the status of each register being set.
12184      If someone is using this register in this block, set this register
12185      to invalid since we will get confused between the two lives in this
12186      basic block.  This makes using this register always invalid.  In cse, we
12187      scan the table to invalidate all entries using this register, but this
12188      is too much work for us.  */
12189
12190   for (i = regno; i < endregno; i++)
12191     {
12192       rsp = VEC_index (reg_stat_type, reg_stat, i);
12193       rsp->last_set_label = label_tick;
12194       if (!insn
12195           || (value && rsp->last_set_table_tick >= label_tick_ebb_start))
12196         rsp->last_set_invalid = 1;
12197       else
12198         rsp->last_set_invalid = 0;
12199     }
12200
12201   /* The value being assigned might refer to X (like in "x++;").  In that
12202      case, we must replace it with (clobber (const_int 0)) to prevent
12203      infinite loops.  */
12204   rsp = VEC_index (reg_stat_type, reg_stat, regno);
12205   if (value && !get_last_value_validate (&value, insn, label_tick, 0))
12206     {
12207       value = copy_rtx (value);
12208       if (!get_last_value_validate (&value, insn, label_tick, 1))
12209         value = 0;
12210     }
12211
12212   /* For the main register being modified, update the value, the mode, the
12213      nonzero bits, and the number of sign bit copies.  */
12214
12215   rsp->last_set_value = value;
12216
12217   if (value)
12218     {
12219       enum machine_mode mode = GET_MODE (reg);
12220       subst_low_luid = DF_INSN_LUID (insn);
12221       rsp->last_set_mode = mode;
12222       if (GET_MODE_CLASS (mode) == MODE_INT
12223           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
12224         mode = nonzero_bits_mode;
12225       rsp->last_set_nonzero_bits = nonzero_bits (value, mode);
12226       rsp->last_set_sign_bit_copies
12227         = num_sign_bit_copies (value, GET_MODE (reg));
12228     }
12229 }
12230
12231 /* Called via note_stores from record_dead_and_set_regs to handle one
12232    SET or CLOBBER in an insn.  DATA is the instruction in which the
12233    set is occurring.  */
12234
12235 static void
12236 record_dead_and_set_regs_1 (rtx dest, const_rtx setter, void *data)
12237 {
12238   rtx record_dead_insn = (rtx) data;
12239
12240   if (GET_CODE (dest) == SUBREG)
12241     dest = SUBREG_REG (dest);
12242
12243   if (!record_dead_insn)
12244     {
12245       if (REG_P (dest))
12246         record_value_for_reg (dest, NULL_RTX, NULL_RTX);
12247       return;
12248     }
12249
12250   if (REG_P (dest))
12251     {
12252       /* If we are setting the whole register, we know its value.  Otherwise
12253          show that we don't know the value.  We can handle SUBREG in
12254          some cases.  */
12255       if (GET_CODE (setter) == SET && dest == SET_DEST (setter))
12256         record_value_for_reg (dest, record_dead_insn, SET_SRC (setter));
12257       else if (GET_CODE (setter) == SET
12258                && GET_CODE (SET_DEST (setter)) == SUBREG
12259                && SUBREG_REG (SET_DEST (setter)) == dest
12260                && GET_MODE_BITSIZE (GET_MODE (dest)) <= BITS_PER_WORD
12261                && subreg_lowpart_p (SET_DEST (setter)))
12262         record_value_for_reg (dest, record_dead_insn,
12263                               gen_lowpart (GET_MODE (dest),
12264                                                        SET_SRC (setter)));
12265       else
12266         record_value_for_reg (dest, record_dead_insn, NULL_RTX);
12267     }
12268   else if (MEM_P (dest)
12269            /* Ignore pushes, they clobber nothing.  */
12270            && ! push_operand (dest, GET_MODE (dest)))
12271     mem_last_set = DF_INSN_LUID (record_dead_insn);
12272 }
12273
12274 /* Update the records of when each REG was most recently set or killed
12275    for the things done by INSN.  This is the last thing done in processing
12276    INSN in the combiner loop.
12277
12278    We update reg_stat[], in particular fields last_set, last_set_value,
12279    last_set_mode, last_set_nonzero_bits, last_set_sign_bit_copies,
12280    last_death, and also the similar information mem_last_set (which insn
12281    most recently modified memory) and last_call_luid (which insn was the
12282    most recent subroutine call).  */
12283
12284 static void
12285 record_dead_and_set_regs (rtx insn)
12286 {
12287   rtx link;
12288   unsigned int i;
12289
12290   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
12291     {
12292       if (REG_NOTE_KIND (link) == REG_DEAD
12293           && REG_P (XEXP (link, 0)))
12294         {
12295           unsigned int regno = REGNO (XEXP (link, 0));
12296           unsigned int endregno = END_REGNO (XEXP (link, 0));
12297
12298           for (i = regno; i < endregno; i++)
12299             {
12300               reg_stat_type *rsp;
12301
12302               rsp = VEC_index (reg_stat_type, reg_stat, i);
12303               rsp->last_death = insn;
12304             }
12305         }
12306       else if (REG_NOTE_KIND (link) == REG_INC)
12307         record_value_for_reg (XEXP (link, 0), insn, NULL_RTX);
12308     }
12309
12310   if (CALL_P (insn))
12311     {
12312       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
12313         if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
12314           {
12315             reg_stat_type *rsp;
12316
12317             rsp = VEC_index (reg_stat_type, reg_stat, i);
12318             rsp->last_set_invalid = 1;
12319             rsp->last_set = insn;
12320             rsp->last_set_value = 0;
12321             rsp->last_set_mode = VOIDmode;
12322             rsp->last_set_nonzero_bits = 0;
12323             rsp->last_set_sign_bit_copies = 0;
12324             rsp->last_death = 0;
12325             rsp->truncated_to_mode = VOIDmode;
12326           }
12327
12328       last_call_luid = mem_last_set = DF_INSN_LUID (insn);
12329
12330       /* We can't combine into a call pattern.  Remember, though, that
12331          the return value register is set at this LUID.  We could
12332          still replace a register with the return value from the
12333          wrong subroutine call!  */
12334       note_stores (PATTERN (insn), record_dead_and_set_regs_1, NULL_RTX);
12335     }
12336   else
12337     note_stores (PATTERN (insn), record_dead_and_set_regs_1, insn);
12338 }
12339
12340 /* If a SUBREG has the promoted bit set, it is in fact a property of the
12341    register present in the SUBREG, so for each such SUBREG go back and
12342    adjust nonzero and sign bit information of the registers that are
12343    known to have some zero/sign bits set.
12344
12345    This is needed because when combine blows the SUBREGs away, the
12346    information on zero/sign bits is lost and further combines can be
12347    missed because of that.  */
12348
12349 static void
12350 record_promoted_value (rtx insn, rtx subreg)
12351 {
12352   rtx links, set;
12353   unsigned int regno = REGNO (SUBREG_REG (subreg));
12354   enum machine_mode mode = GET_MODE (subreg);
12355
12356   if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
12357     return;
12358
12359   for (links = LOG_LINKS (insn); links;)
12360     {
12361       reg_stat_type *rsp;
12362
12363       insn = XEXP (links, 0);
12364       set = single_set (insn);
12365
12366       if (! set || !REG_P (SET_DEST (set))
12367           || REGNO (SET_DEST (set)) != regno
12368           || GET_MODE (SET_DEST (set)) != GET_MODE (SUBREG_REG (subreg)))
12369         {
12370           links = XEXP (links, 1);
12371           continue;
12372         }
12373
12374       rsp = VEC_index (reg_stat_type, reg_stat, regno);
12375       if (rsp->last_set == insn)
12376         {
12377           if (SUBREG_PROMOTED_UNSIGNED_P (subreg) > 0)
12378             rsp->last_set_nonzero_bits &= GET_MODE_MASK (mode);
12379         }
12380
12381       if (REG_P (SET_SRC (set)))
12382         {
12383           regno = REGNO (SET_SRC (set));
12384           links = LOG_LINKS (insn);
12385         }
12386       else
12387         break;
12388     }
12389 }
12390
12391 /* Check if X, a register, is known to contain a value already
12392    truncated to MODE.  In this case we can use a subreg to refer to
12393    the truncated value even though in the generic case we would need
12394    an explicit truncation.  */
12395
12396 static bool
12397 reg_truncated_to_mode (enum machine_mode mode, const_rtx x)
12398 {
12399   reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
12400   enum machine_mode truncated = rsp->truncated_to_mode;
12401
12402   if (truncated == 0
12403       || rsp->truncation_label < label_tick_ebb_start)
12404     return false;
12405   if (GET_MODE_SIZE (truncated) <= GET_MODE_SIZE (mode))
12406     return true;
12407   if (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
12408                              GET_MODE_BITSIZE (truncated)))
12409     return true;
12410   return false;
12411 }
12412
12413 /* Callback for for_each_rtx.  If *P is a hard reg or a subreg record the mode
12414    that the register is accessed in.  For non-TRULY_NOOP_TRUNCATION targets we
12415    might be able to turn a truncate into a subreg using this information.
12416    Return -1 if traversing *P is complete or 0 otherwise.  */
12417
12418 static int
12419 record_truncated_value (rtx *p, void *data ATTRIBUTE_UNUSED)
12420 {
12421   rtx x = *p;
12422   enum machine_mode truncated_mode;
12423   reg_stat_type *rsp;
12424
12425   if (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x)))
12426     {
12427       enum machine_mode original_mode = GET_MODE (SUBREG_REG (x));
12428       truncated_mode = GET_MODE (x);
12429
12430       if (GET_MODE_SIZE (original_mode) <= GET_MODE_SIZE (truncated_mode))
12431         return -1;
12432
12433       if (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (truncated_mode),
12434                                  GET_MODE_BITSIZE (original_mode)))
12435         return -1;
12436
12437       x = SUBREG_REG (x);
12438     }
12439   /* ??? For hard-regs we now record everything.  We might be able to
12440      optimize this using last_set_mode.  */
12441   else if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
12442     truncated_mode = GET_MODE (x);
12443   else
12444     return 0;
12445
12446   rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
12447   if (rsp->truncated_to_mode == 0
12448       || rsp->truncation_label < label_tick_ebb_start
12449       || (GET_MODE_SIZE (truncated_mode)
12450           < GET_MODE_SIZE (rsp->truncated_to_mode)))
12451     {
12452       rsp->truncated_to_mode = truncated_mode;
12453       rsp->truncation_label = label_tick;
12454     }
12455
12456   return -1;
12457 }
12458
12459 /* Callback for note_uses.  Find hardregs and subregs of pseudos and
12460    the modes they are used in.  This can help truning TRUNCATEs into
12461    SUBREGs.  */
12462
12463 static void
12464 record_truncated_values (rtx *x, void *data ATTRIBUTE_UNUSED)
12465 {
12466   for_each_rtx (x, record_truncated_value, NULL);
12467 }
12468
12469 /* Scan X for promoted SUBREGs.  For each one found,
12470    note what it implies to the registers used in it.  */
12471
12472 static void
12473 check_promoted_subreg (rtx insn, rtx x)
12474 {
12475   if (GET_CODE (x) == SUBREG
12476       && SUBREG_PROMOTED_VAR_P (x)
12477       && REG_P (SUBREG_REG (x)))
12478     record_promoted_value (insn, x);
12479   else
12480     {
12481       const char *format = GET_RTX_FORMAT (GET_CODE (x));
12482       int i, j;
12483
12484       for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
12485         switch (format[i])
12486           {
12487           case 'e':
12488             check_promoted_subreg (insn, XEXP (x, i));
12489             break;
12490           case 'V':
12491           case 'E':
12492             if (XVEC (x, i) != 0)
12493               for (j = 0; j < XVECLEN (x, i); j++)
12494                 check_promoted_subreg (insn, XVECEXP (x, i, j));
12495             break;
12496           }
12497     }
12498 }
12499 \f
12500 /* Verify that all the registers and memory references mentioned in *LOC are
12501    still valid.  *LOC was part of a value set in INSN when label_tick was
12502    equal to TICK.  Return 0 if some are not.  If REPLACE is nonzero, replace
12503    the invalid references with (clobber (const_int 0)) and return 1.  This
12504    replacement is useful because we often can get useful information about
12505    the form of a value (e.g., if it was produced by a shift that always
12506    produces -1 or 0) even though we don't know exactly what registers it
12507    was produced from.  */
12508
12509 static int
12510 get_last_value_validate (rtx *loc, rtx insn, int tick, int replace)
12511 {
12512   rtx x = *loc;
12513   const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
12514   int len = GET_RTX_LENGTH (GET_CODE (x));
12515   int i, j;
12516
12517   if (REG_P (x))
12518     {
12519       unsigned int regno = REGNO (x);
12520       unsigned int endregno = END_REGNO (x);
12521       unsigned int j;
12522
12523       for (j = regno; j < endregno; j++)
12524         {
12525           reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, j);
12526           if (rsp->last_set_invalid
12527               /* If this is a pseudo-register that was only set once and not
12528                  live at the beginning of the function, it is always valid.  */
12529               || (! (regno >= FIRST_PSEUDO_REGISTER
12530                      && REG_N_SETS (regno) == 1
12531                      && (!REGNO_REG_SET_P
12532                          (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), regno)))
12533                   && rsp->last_set_label > tick))
12534           {
12535             if (replace)
12536               *loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
12537             return replace;
12538           }
12539         }
12540
12541       return 1;
12542     }
12543   /* If this is a memory reference, make sure that there were no stores after
12544      it that might have clobbered the value.  We don't have alias info, so we
12545      assume any store invalidates it.  Moreover, we only have local UIDs, so
12546      we also assume that there were stores in the intervening basic blocks.  */
12547   else if (MEM_P (x) && !MEM_READONLY_P (x)
12548            && (tick != label_tick || DF_INSN_LUID (insn) <= mem_last_set))
12549     {
12550       if (replace)
12551         *loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
12552       return replace;
12553     }
12554
12555   for (i = 0; i < len; i++)
12556     {
12557       if (fmt[i] == 'e')
12558         {
12559           /* Check for identical subexpressions.  If x contains
12560              identical subexpression we only have to traverse one of
12561              them.  */
12562           if (i == 1 && ARITHMETIC_P (x))
12563             {
12564               /* Note that at this point x0 has already been checked
12565                  and found valid.  */
12566               rtx x0 = XEXP (x, 0);
12567               rtx x1 = XEXP (x, 1);
12568
12569               /* If x0 and x1 are identical then x is also valid.  */
12570               if (x0 == x1)
12571                 return 1;
12572
12573               /* If x1 is identical to a subexpression of x0 then
12574                  while checking x0, x1 has already been checked.  Thus
12575                  it is valid and so as x.  */
12576               if (ARITHMETIC_P (x0)
12577                   && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
12578                 return 1;
12579
12580               /* If x0 is identical to a subexpression of x1 then x is
12581                  valid iff the rest of x1 is valid.  */
12582               if (ARITHMETIC_P (x1)
12583                   && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
12584                 return
12585                   get_last_value_validate (&XEXP (x1,
12586                                                   x0 == XEXP (x1, 0) ? 1 : 0),
12587                                            insn, tick, replace);
12588             }
12589
12590           if (get_last_value_validate (&XEXP (x, i), insn, tick,
12591                                        replace) == 0)
12592             return 0;
12593         }
12594       else if (fmt[i] == 'E')
12595         for (j = 0; j < XVECLEN (x, i); j++)
12596           if (get_last_value_validate (&XVECEXP (x, i, j),
12597                                        insn, tick, replace) == 0)
12598             return 0;
12599     }
12600
12601   /* If we haven't found a reason for it to be invalid, it is valid.  */
12602   return 1;
12603 }
12604
12605 /* Get the last value assigned to X, if known.  Some registers
12606    in the value may be replaced with (clobber (const_int 0)) if their value
12607    is known longer known reliably.  */
12608
12609 static rtx
12610 get_last_value (const_rtx x)
12611 {
12612   unsigned int regno;
12613   rtx value;
12614   reg_stat_type *rsp;
12615
12616   /* If this is a non-paradoxical SUBREG, get the value of its operand and
12617      then convert it to the desired mode.  If this is a paradoxical SUBREG,
12618      we cannot predict what values the "extra" bits might have.  */
12619   if (GET_CODE (x) == SUBREG
12620       && subreg_lowpart_p (x)
12621       && (GET_MODE_SIZE (GET_MODE (x))
12622           <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
12623       && (value = get_last_value (SUBREG_REG (x))) != 0)
12624     return gen_lowpart (GET_MODE (x), value);
12625
12626   if (!REG_P (x))
12627     return 0;
12628
12629   regno = REGNO (x);
12630   rsp = VEC_index (reg_stat_type, reg_stat, regno);
12631   value = rsp->last_set_value;
12632
12633   /* If we don't have a value, or if it isn't for this basic block and
12634      it's either a hard register, set more than once, or it's a live
12635      at the beginning of the function, return 0.
12636
12637      Because if it's not live at the beginning of the function then the reg
12638      is always set before being used (is never used without being set).
12639      And, if it's set only once, and it's always set before use, then all
12640      uses must have the same last value, even if it's not from this basic
12641      block.  */
12642
12643   if (value == 0
12644       || (rsp->last_set_label < label_tick_ebb_start
12645           && (regno < FIRST_PSEUDO_REGISTER
12646               || REG_N_SETS (regno) != 1
12647               || REGNO_REG_SET_P
12648                  (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), regno))))
12649     return 0;
12650
12651   /* If the value was set in a later insn than the ones we are processing,
12652      we can't use it even if the register was only set once.  */
12653   if (rsp->last_set_label == label_tick
12654       && DF_INSN_LUID (rsp->last_set) >= subst_low_luid)
12655     return 0;
12656
12657   /* If the value has all its registers valid, return it.  */
12658   if (get_last_value_validate (&value, rsp->last_set, rsp->last_set_label, 0))
12659     return value;
12660
12661   /* Otherwise, make a copy and replace any invalid register with
12662      (clobber (const_int 0)).  If that fails for some reason, return 0.  */
12663
12664   value = copy_rtx (value);
12665   if (get_last_value_validate (&value, rsp->last_set, rsp->last_set_label, 1))
12666     return value;
12667
12668   return 0;
12669 }
12670 \f
12671 /* Return nonzero if expression X refers to a REG or to memory
12672    that is set in an instruction more recent than FROM_LUID.  */
12673
12674 static int
12675 use_crosses_set_p (const_rtx x, int from_luid)
12676 {
12677   const char *fmt;
12678   int i;
12679   enum rtx_code code = GET_CODE (x);
12680
12681   if (code == REG)
12682     {
12683       unsigned int regno = REGNO (x);
12684       unsigned endreg = END_REGNO (x);
12685
12686 #ifdef PUSH_ROUNDING
12687       /* Don't allow uses of the stack pointer to be moved,
12688          because we don't know whether the move crosses a push insn.  */
12689       if (regno == STACK_POINTER_REGNUM && PUSH_ARGS)
12690         return 1;
12691 #endif
12692       for (; regno < endreg; regno++)
12693         {
12694           reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, regno);
12695           if (rsp->last_set
12696               && rsp->last_set_label == label_tick
12697               && DF_INSN_LUID (rsp->last_set) > from_luid)
12698             return 1;
12699         }
12700       return 0;
12701     }
12702
12703   if (code == MEM && mem_last_set > from_luid)
12704     return 1;
12705
12706   fmt = GET_RTX_FORMAT (code);
12707
12708   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12709     {
12710       if (fmt[i] == 'E')
12711         {
12712           int j;
12713           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
12714             if (use_crosses_set_p (XVECEXP (x, i, j), from_luid))
12715               return 1;
12716         }
12717       else if (fmt[i] == 'e'
12718                && use_crosses_set_p (XEXP (x, i), from_luid))
12719         return 1;
12720     }
12721   return 0;
12722 }
12723 \f
12724 /* Define three variables used for communication between the following
12725    routines.  */
12726
12727 static unsigned int reg_dead_regno, reg_dead_endregno;
12728 static int reg_dead_flag;
12729
12730 /* Function called via note_stores from reg_dead_at_p.
12731
12732    If DEST is within [reg_dead_regno, reg_dead_endregno), set
12733    reg_dead_flag to 1 if X is a CLOBBER and to -1 it is a SET.  */
12734
12735 static void
12736 reg_dead_at_p_1 (rtx dest, const_rtx x, void *data ATTRIBUTE_UNUSED)
12737 {
12738   unsigned int regno, endregno;
12739
12740   if (!REG_P (dest))
12741     return;
12742
12743   regno = REGNO (dest);
12744   endregno = END_REGNO (dest);
12745   if (reg_dead_endregno > regno && reg_dead_regno < endregno)
12746     reg_dead_flag = (GET_CODE (x) == CLOBBER) ? 1 : -1;
12747 }
12748
12749 /* Return nonzero if REG is known to be dead at INSN.
12750
12751    We scan backwards from INSN.  If we hit a REG_DEAD note or a CLOBBER
12752    referencing REG, it is dead.  If we hit a SET referencing REG, it is
12753    live.  Otherwise, see if it is live or dead at the start of the basic
12754    block we are in.  Hard regs marked as being live in NEWPAT_USED_REGS
12755    must be assumed to be always live.  */
12756
12757 static int
12758 reg_dead_at_p (rtx reg, rtx insn)
12759 {
12760   basic_block block;
12761   unsigned int i;
12762
12763   /* Set variables for reg_dead_at_p_1.  */
12764   reg_dead_regno = REGNO (reg);
12765   reg_dead_endregno = END_REGNO (reg);
12766
12767   reg_dead_flag = 0;
12768
12769   /* Check that reg isn't mentioned in NEWPAT_USED_REGS.  For fixed registers
12770      we allow the machine description to decide whether use-and-clobber
12771      patterns are OK.  */
12772   if (reg_dead_regno < FIRST_PSEUDO_REGISTER)
12773     {
12774       for (i = reg_dead_regno; i < reg_dead_endregno; i++)
12775         if (!fixed_regs[i] && TEST_HARD_REG_BIT (newpat_used_regs, i))
12776           return 0;
12777     }
12778
12779   /* Scan backwards until we find a REG_DEAD note, SET, CLOBBER, or
12780      beginning of basic block.  */
12781   block = BLOCK_FOR_INSN (insn);
12782   for (;;)
12783     {
12784       if (INSN_P (insn))
12785         {
12786           note_stores (PATTERN (insn), reg_dead_at_p_1, NULL);
12787           if (reg_dead_flag)
12788             return reg_dead_flag == 1 ? 1 : 0;
12789
12790           if (find_regno_note (insn, REG_DEAD, reg_dead_regno))
12791             return 1;
12792         }
12793
12794       if (insn == BB_HEAD (block))
12795         break;
12796
12797       insn = PREV_INSN (insn);
12798     }
12799
12800   /* Look at live-in sets for the basic block that we were in.  */
12801   for (i = reg_dead_regno; i < reg_dead_endregno; i++)
12802     if (REGNO_REG_SET_P (df_get_live_in (block), i))
12803       return 0;
12804
12805   return 1;
12806 }
12807 \f
12808 /* Note hard registers in X that are used.  */
12809
12810 static void
12811 mark_used_regs_combine (rtx x)
12812 {
12813   RTX_CODE code = GET_CODE (x);
12814   unsigned int regno;
12815   int i;
12816
12817   switch (code)
12818     {
12819     case LABEL_REF:
12820     case SYMBOL_REF:
12821     case CONST_INT:
12822     case CONST:
12823     case CONST_DOUBLE:
12824     case CONST_VECTOR:
12825     case PC:
12826     case ADDR_VEC:
12827     case ADDR_DIFF_VEC:
12828     case ASM_INPUT:
12829 #ifdef HAVE_cc0
12830     /* CC0 must die in the insn after it is set, so we don't need to take
12831        special note of it here.  */
12832     case CC0:
12833 #endif
12834       return;
12835
12836     case CLOBBER:
12837       /* If we are clobbering a MEM, mark any hard registers inside the
12838          address as used.  */
12839       if (MEM_P (XEXP (x, 0)))
12840         mark_used_regs_combine (XEXP (XEXP (x, 0), 0));
12841       return;
12842
12843     case REG:
12844       regno = REGNO (x);
12845       /* A hard reg in a wide mode may really be multiple registers.
12846          If so, mark all of them just like the first.  */
12847       if (regno < FIRST_PSEUDO_REGISTER)
12848         {
12849           /* None of this applies to the stack, frame or arg pointers.  */
12850           if (regno == STACK_POINTER_REGNUM
12851 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
12852               || regno == HARD_FRAME_POINTER_REGNUM
12853 #endif
12854 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
12855               || (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
12856 #endif
12857               || regno == FRAME_POINTER_REGNUM)
12858             return;
12859
12860           add_to_hard_reg_set (&newpat_used_regs, GET_MODE (x), regno);
12861         }
12862       return;
12863
12864     case SET:
12865       {
12866         /* If setting a MEM, or a SUBREG of a MEM, then note any hard regs in
12867            the address.  */
12868         rtx testreg = SET_DEST (x);
12869
12870         while (GET_CODE (testreg) == SUBREG
12871                || GET_CODE (testreg) == ZERO_EXTRACT
12872                || GET_CODE (testreg) == STRICT_LOW_PART)
12873           testreg = XEXP (testreg, 0);
12874
12875         if (MEM_P (testreg))
12876           mark_used_regs_combine (XEXP (testreg, 0));
12877
12878         mark_used_regs_combine (SET_SRC (x));
12879       }
12880       return;
12881
12882     default:
12883       break;
12884     }
12885
12886   /* Recursively scan the operands of this expression.  */
12887
12888   {
12889     const char *fmt = GET_RTX_FORMAT (code);
12890
12891     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12892       {
12893         if (fmt[i] == 'e')
12894           mark_used_regs_combine (XEXP (x, i));
12895         else if (fmt[i] == 'E')
12896           {
12897             int j;
12898
12899             for (j = 0; j < XVECLEN (x, i); j++)
12900               mark_used_regs_combine (XVECEXP (x, i, j));
12901           }
12902       }
12903   }
12904 }
12905 \f
12906 /* Remove register number REGNO from the dead registers list of INSN.
12907
12908    Return the note used to record the death, if there was one.  */
12909
12910 rtx
12911 remove_death (unsigned int regno, rtx insn)
12912 {
12913   rtx note = find_regno_note (insn, REG_DEAD, regno);
12914
12915   if (note)
12916     remove_note (insn, note);
12917
12918   return note;
12919 }
12920
12921 /* For each register (hardware or pseudo) used within expression X, if its
12922    death is in an instruction with luid between FROM_LUID (inclusive) and
12923    TO_INSN (exclusive), put a REG_DEAD note for that register in the
12924    list headed by PNOTES.
12925
12926    That said, don't move registers killed by maybe_kill_insn.
12927
12928    This is done when X is being merged by combination into TO_INSN.  These
12929    notes will then be distributed as needed.  */
12930
12931 static void
12932 move_deaths (rtx x, rtx maybe_kill_insn, int from_luid, rtx to_insn,
12933              rtx *pnotes)
12934 {
12935   const char *fmt;
12936   int len, i;
12937   enum rtx_code code = GET_CODE (x);
12938
12939   if (code == REG)
12940     {
12941       unsigned int regno = REGNO (x);
12942       rtx where_dead = VEC_index (reg_stat_type, reg_stat, regno)->last_death;
12943
12944       /* Don't move the register if it gets killed in between from and to.  */
12945       if (maybe_kill_insn && reg_set_p (x, maybe_kill_insn)
12946           && ! reg_referenced_p (x, maybe_kill_insn))
12947         return;
12948
12949       if (where_dead
12950           && BLOCK_FOR_INSN (where_dead) == BLOCK_FOR_INSN (to_insn)
12951           && DF_INSN_LUID (where_dead) >= from_luid
12952           && DF_INSN_LUID (where_dead) < DF_INSN_LUID (to_insn))
12953         {
12954           rtx note = remove_death (regno, where_dead);
12955
12956           /* It is possible for the call above to return 0.  This can occur
12957              when last_death points to I2 or I1 that we combined with.
12958              In that case make a new note.
12959
12960              We must also check for the case where X is a hard register
12961              and NOTE is a death note for a range of hard registers
12962              including X.  In that case, we must put REG_DEAD notes for
12963              the remaining registers in place of NOTE.  */
12964
12965           if (note != 0 && regno < FIRST_PSEUDO_REGISTER
12966               && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
12967                   > GET_MODE_SIZE (GET_MODE (x))))
12968             {
12969               unsigned int deadregno = REGNO (XEXP (note, 0));
12970               unsigned int deadend = END_HARD_REGNO (XEXP (note, 0));
12971               unsigned int ourend = END_HARD_REGNO (x);
12972               unsigned int i;
12973
12974               for (i = deadregno; i < deadend; i++)
12975                 if (i < regno || i >= ourend)
12976                   add_reg_note (where_dead, REG_DEAD, regno_reg_rtx[i]);
12977             }
12978
12979           /* If we didn't find any note, or if we found a REG_DEAD note that
12980              covers only part of the given reg, and we have a multi-reg hard
12981              register, then to be safe we must check for REG_DEAD notes
12982              for each register other than the first.  They could have
12983              their own REG_DEAD notes lying around.  */
12984           else if ((note == 0
12985                     || (note != 0
12986                         && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
12987                             < GET_MODE_SIZE (GET_MODE (x)))))
12988                    && regno < FIRST_PSEUDO_REGISTER
12989                    && hard_regno_nregs[regno][GET_MODE (x)] > 1)
12990             {
12991               unsigned int ourend = END_HARD_REGNO (x);
12992               unsigned int i, offset;
12993               rtx oldnotes = 0;
12994
12995               if (note)
12996                 offset = hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))];
12997               else
12998                 offset = 1;
12999
13000               for (i = regno + offset; i < ourend; i++)
13001                 move_deaths (regno_reg_rtx[i],
13002                              maybe_kill_insn, from_luid, to_insn, &oldnotes);
13003             }
13004
13005           if (note != 0 && GET_MODE (XEXP (note, 0)) == GET_MODE (x))
13006             {
13007               XEXP (note, 1) = *pnotes;
13008               *pnotes = note;
13009             }
13010           else
13011             *pnotes = alloc_reg_note (REG_DEAD, x, *pnotes);
13012         }
13013
13014       return;
13015     }
13016
13017   else if (GET_CODE (x) == SET)
13018     {
13019       rtx dest = SET_DEST (x);
13020
13021       move_deaths (SET_SRC (x), maybe_kill_insn, from_luid, to_insn, pnotes);
13022
13023       /* In the case of a ZERO_EXTRACT, a STRICT_LOW_PART, or a SUBREG
13024          that accesses one word of a multi-word item, some
13025          piece of everything register in the expression is used by
13026          this insn, so remove any old death.  */
13027       /* ??? So why do we test for equality of the sizes?  */
13028
13029       if (GET_CODE (dest) == ZERO_EXTRACT
13030           || GET_CODE (dest) == STRICT_LOW_PART
13031           || (GET_CODE (dest) == SUBREG
13032               && (((GET_MODE_SIZE (GET_MODE (dest))
13033                     + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
13034                   == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
13035                        + UNITS_PER_WORD - 1) / UNITS_PER_WORD))))
13036         {
13037           move_deaths (dest, maybe_kill_insn, from_luid, to_insn, pnotes);
13038           return;
13039         }
13040
13041       /* If this is some other SUBREG, we know it replaces the entire
13042          value, so use that as the destination.  */
13043       if (GET_CODE (dest) == SUBREG)
13044         dest = SUBREG_REG (dest);
13045
13046       /* If this is a MEM, adjust deaths of anything used in the address.
13047          For a REG (the only other possibility), the entire value is
13048          being replaced so the old value is not used in this insn.  */
13049
13050       if (MEM_P (dest))
13051         move_deaths (XEXP (dest, 0), maybe_kill_insn, from_luid,
13052                      to_insn, pnotes);
13053       return;
13054     }
13055
13056   else if (GET_CODE (x) == CLOBBER)
13057     return;
13058
13059   len = GET_RTX_LENGTH (code);
13060   fmt = GET_RTX_FORMAT (code);
13061
13062   for (i = 0; i < len; i++)
13063     {
13064       if (fmt[i] == 'E')
13065         {
13066           int j;
13067           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
13068             move_deaths (XVECEXP (x, i, j), maybe_kill_insn, from_luid,
13069                          to_insn, pnotes);
13070         }
13071       else if (fmt[i] == 'e')
13072         move_deaths (XEXP (x, i), maybe_kill_insn, from_luid, to_insn, pnotes);
13073     }
13074 }
13075 \f
13076 /* Return 1 if X is the target of a bit-field assignment in BODY, the
13077    pattern of an insn.  X must be a REG.  */
13078
13079 static int
13080 reg_bitfield_target_p (rtx x, rtx body)
13081 {
13082   int i;
13083
13084   if (GET_CODE (body) == SET)
13085     {
13086       rtx dest = SET_DEST (body);
13087       rtx target;
13088       unsigned int regno, tregno, endregno, endtregno;
13089
13090       if (GET_CODE (dest) == ZERO_EXTRACT)
13091         target = XEXP (dest, 0);
13092       else if (GET_CODE (dest) == STRICT_LOW_PART)
13093         target = SUBREG_REG (XEXP (dest, 0));
13094       else
13095         return 0;
13096
13097       if (GET_CODE (target) == SUBREG)
13098         target = SUBREG_REG (target);
13099
13100       if (!REG_P (target))
13101         return 0;
13102
13103       tregno = REGNO (target), regno = REGNO (x);
13104       if (tregno >= FIRST_PSEUDO_REGISTER || regno >= FIRST_PSEUDO_REGISTER)
13105         return target == x;
13106
13107       endtregno = end_hard_regno (GET_MODE (target), tregno);
13108       endregno = end_hard_regno (GET_MODE (x), regno);
13109
13110       return endregno > tregno && regno < endtregno;
13111     }
13112
13113   else if (GET_CODE (body) == PARALLEL)
13114     for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
13115       if (reg_bitfield_target_p (x, XVECEXP (body, 0, i)))
13116         return 1;
13117
13118   return 0;
13119 }
13120 \f
13121 /* Given a chain of REG_NOTES originally from FROM_INSN, try to place them
13122    as appropriate.  I3 and I2 are the insns resulting from the combination
13123    insns including FROM (I2 may be zero).
13124
13125    ELIM_I2 and ELIM_I1 are either zero or registers that we know will
13126    not need REG_DEAD notes because they are being substituted for.  This
13127    saves searching in the most common cases.
13128
13129    Each note in the list is either ignored or placed on some insns, depending
13130    on the type of note.  */
13131
13132 static void
13133 distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2, rtx elim_i2,
13134                   rtx elim_i1, rtx elim_i0)
13135 {
13136   rtx note, next_note;
13137   rtx tem;
13138
13139   for (note = notes; note; note = next_note)
13140     {
13141       rtx place = 0, place2 = 0;
13142
13143       next_note = XEXP (note, 1);
13144       switch (REG_NOTE_KIND (note))
13145         {
13146         case REG_BR_PROB:
13147         case REG_BR_PRED:
13148           /* Doesn't matter much where we put this, as long as it's somewhere.
13149              It is preferable to keep these notes on branches, which is most
13150              likely to be i3.  */
13151           place = i3;
13152           break;
13153
13154         case REG_NON_LOCAL_GOTO:
13155           if (JUMP_P (i3))
13156             place = i3;
13157           else
13158             {
13159               gcc_assert (i2 && JUMP_P (i2));
13160               place = i2;
13161             }
13162           break;
13163
13164         case REG_EH_REGION:
13165           /* These notes must remain with the call or trapping instruction.  */
13166           if (CALL_P (i3))
13167             place = i3;
13168           else if (i2 && CALL_P (i2))
13169             place = i2;
13170           else
13171             {
13172               gcc_assert (cfun->can_throw_non_call_exceptions);
13173               if (may_trap_p (i3))
13174                 place = i3;
13175               else if (i2 && may_trap_p (i2))
13176                 place = i2;
13177               /* ??? Otherwise assume we've combined things such that we
13178                  can now prove that the instructions can't trap.  Drop the
13179                  note in this case.  */
13180             }
13181           break;
13182
13183         case REG_NORETURN:
13184         case REG_SETJMP:
13185           /* These notes must remain with the call.  It should not be
13186              possible for both I2 and I3 to be a call.  */
13187           if (CALL_P (i3))
13188             place = i3;
13189           else
13190             {
13191               gcc_assert (i2 && CALL_P (i2));
13192               place = i2;
13193             }
13194           break;
13195
13196         case REG_UNUSED:
13197           /* Any clobbers for i3 may still exist, and so we must process
13198              REG_UNUSED notes from that insn.
13199
13200              Any clobbers from i2 or i1 can only exist if they were added by
13201              recog_for_combine.  In that case, recog_for_combine created the
13202              necessary REG_UNUSED notes.  Trying to keep any original
13203              REG_UNUSED notes from these insns can cause incorrect output
13204              if it is for the same register as the original i3 dest.
13205              In that case, we will notice that the register is set in i3,
13206              and then add a REG_UNUSED note for the destination of i3, which
13207              is wrong.  However, it is possible to have REG_UNUSED notes from
13208              i2 or i1 for register which were both used and clobbered, so
13209              we keep notes from i2 or i1 if they will turn into REG_DEAD
13210              notes.  */
13211
13212           /* If this register is set or clobbered in I3, put the note there
13213              unless there is one already.  */
13214           if (reg_set_p (XEXP (note, 0), PATTERN (i3)))
13215             {
13216               if (from_insn != i3)
13217                 break;
13218
13219               if (! (REG_P (XEXP (note, 0))
13220                      ? find_regno_note (i3, REG_UNUSED, REGNO (XEXP (note, 0)))
13221                      : find_reg_note (i3, REG_UNUSED, XEXP (note, 0))))
13222                 place = i3;
13223             }
13224           /* Otherwise, if this register is used by I3, then this register
13225              now dies here, so we must put a REG_DEAD note here unless there
13226              is one already.  */
13227           else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3))
13228                    && ! (REG_P (XEXP (note, 0))
13229                          ? find_regno_note (i3, REG_DEAD,
13230                                             REGNO (XEXP (note, 0)))
13231                          : find_reg_note (i3, REG_DEAD, XEXP (note, 0))))
13232             {
13233               PUT_REG_NOTE_KIND (note, REG_DEAD);
13234               place = i3;
13235             }
13236           break;
13237
13238         case REG_EQUAL:
13239         case REG_EQUIV:
13240         case REG_NOALIAS:
13241           /* These notes say something about results of an insn.  We can
13242              only support them if they used to be on I3 in which case they
13243              remain on I3.  Otherwise they are ignored.
13244
13245              If the note refers to an expression that is not a constant, we
13246              must also ignore the note since we cannot tell whether the
13247              equivalence is still true.  It might be possible to do
13248              slightly better than this (we only have a problem if I2DEST
13249              or I1DEST is present in the expression), but it doesn't
13250              seem worth the trouble.  */
13251
13252           if (from_insn == i3
13253               && (XEXP (note, 0) == 0 || CONSTANT_P (XEXP (note, 0))))
13254             place = i3;
13255           break;
13256
13257         case REG_INC:
13258           /* These notes say something about how a register is used.  They must
13259              be present on any use of the register in I2 or I3.  */
13260           if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3)))
13261             place = i3;
13262
13263           if (i2 && reg_mentioned_p (XEXP (note, 0), PATTERN (i2)))
13264             {
13265               if (place)
13266                 place2 = i2;
13267               else
13268                 place = i2;
13269             }
13270           break;
13271
13272         case REG_LABEL_TARGET:
13273         case REG_LABEL_OPERAND:
13274           /* This can show up in several ways -- either directly in the
13275              pattern, or hidden off in the constant pool with (or without?)
13276              a REG_EQUAL note.  */
13277           /* ??? Ignore the without-reg_equal-note problem for now.  */
13278           if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3))
13279               || ((tem = find_reg_note (i3, REG_EQUAL, NULL_RTX))
13280                   && GET_CODE (XEXP (tem, 0)) == LABEL_REF
13281                   && XEXP (XEXP (tem, 0), 0) == XEXP (note, 0)))
13282             place = i3;
13283
13284           if (i2
13285               && (reg_mentioned_p (XEXP (note, 0), PATTERN (i2))
13286                   || ((tem = find_reg_note (i2, REG_EQUAL, NULL_RTX))
13287                       && GET_CODE (XEXP (tem, 0)) == LABEL_REF
13288                       && XEXP (XEXP (tem, 0), 0) == XEXP (note, 0))))
13289             {
13290               if (place)
13291                 place2 = i2;
13292               else
13293                 place = i2;
13294             }
13295
13296           /* For REG_LABEL_TARGET on a JUMP_P, we prefer to put the note
13297              as a JUMP_LABEL or decrement LABEL_NUSES if it's already
13298              there.  */
13299           if (place && JUMP_P (place)
13300               && REG_NOTE_KIND (note) == REG_LABEL_TARGET
13301               && (JUMP_LABEL (place) == NULL
13302                   || JUMP_LABEL (place) == XEXP (note, 0)))
13303             {
13304               rtx label = JUMP_LABEL (place);
13305
13306               if (!label)
13307                 JUMP_LABEL (place) = XEXP (note, 0);
13308               else if (LABEL_P (label))
13309                 LABEL_NUSES (label)--;
13310             }
13311
13312           if (place2 && JUMP_P (place2)
13313               && REG_NOTE_KIND (note) == REG_LABEL_TARGET
13314               && (JUMP_LABEL (place2) == NULL
13315                   || JUMP_LABEL (place2) == XEXP (note, 0)))
13316             {
13317               rtx label = JUMP_LABEL (place2);
13318
13319               if (!label)
13320                 JUMP_LABEL (place2) = XEXP (note, 0);
13321               else if (LABEL_P (label))
13322                 LABEL_NUSES (label)--;
13323               place2 = 0;
13324             }
13325           break;
13326
13327         case REG_NONNEG:
13328           /* This note says something about the value of a register prior
13329              to the execution of an insn.  It is too much trouble to see
13330              if the note is still correct in all situations.  It is better
13331              to simply delete it.  */
13332           break;
13333
13334         case REG_DEAD:
13335           /* If we replaced the right hand side of FROM_INSN with a
13336              REG_EQUAL note, the original use of the dying register
13337              will not have been combined into I3 and I2.  In such cases,
13338              FROM_INSN is guaranteed to be the first of the combined
13339              instructions, so we simply need to search back before
13340              FROM_INSN for the previous use or set of this register,
13341              then alter the notes there appropriately.
13342
13343              If the register is used as an input in I3, it dies there.
13344              Similarly for I2, if it is nonzero and adjacent to I3.
13345
13346              If the register is not used as an input in either I3 or I2
13347              and it is not one of the registers we were supposed to eliminate,
13348              there are two possibilities.  We might have a non-adjacent I2
13349              or we might have somehow eliminated an additional register
13350              from a computation.  For example, we might have had A & B where
13351              we discover that B will always be zero.  In this case we will
13352              eliminate the reference to A.
13353
13354              In both cases, we must search to see if we can find a previous
13355              use of A and put the death note there.  */
13356
13357           if (from_insn
13358               && from_insn == i2mod
13359               && !reg_overlap_mentioned_p (XEXP (note, 0), i2mod_new_rhs))
13360             tem = from_insn;
13361           else
13362             {
13363               if (from_insn
13364                   && CALL_P (from_insn)
13365                   && find_reg_fusage (from_insn, USE, XEXP (note, 0)))
13366                 place = from_insn;
13367               else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3)))
13368                 place = i3;
13369               else if (i2 != 0 && next_nonnote_nondebug_insn (i2) == i3
13370                        && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
13371                 place = i2;
13372               else if ((rtx_equal_p (XEXP (note, 0), elim_i2)
13373                         && !(i2mod
13374                              && reg_overlap_mentioned_p (XEXP (note, 0),
13375                                                          i2mod_old_rhs)))
13376                        || rtx_equal_p (XEXP (note, 0), elim_i1)
13377                        || rtx_equal_p (XEXP (note, 0), elim_i0))
13378                 break;
13379               tem = i3;
13380             }
13381
13382           if (place == 0)
13383             {
13384               basic_block bb = this_basic_block;
13385
13386               for (tem = PREV_INSN (tem); place == 0; tem = PREV_INSN (tem))
13387                 {
13388                   if (!NONDEBUG_INSN_P (tem))
13389                     {
13390                       if (tem == BB_HEAD (bb))
13391                         break;
13392                       continue;
13393                     }
13394
13395                   /* If the register is being set at TEM, see if that is all
13396                      TEM is doing.  If so, delete TEM.  Otherwise, make this
13397                      into a REG_UNUSED note instead. Don't delete sets to
13398                      global register vars.  */
13399                   if ((REGNO (XEXP (note, 0)) >= FIRST_PSEUDO_REGISTER
13400                        || !global_regs[REGNO (XEXP (note, 0))])
13401                       && reg_set_p (XEXP (note, 0), PATTERN (tem)))
13402                     {
13403                       rtx set = single_set (tem);
13404                       rtx inner_dest = 0;
13405 #ifdef HAVE_cc0
13406                       rtx cc0_setter = NULL_RTX;
13407 #endif
13408
13409                       if (set != 0)
13410                         for (inner_dest = SET_DEST (set);
13411                              (GET_CODE (inner_dest) == STRICT_LOW_PART
13412                               || GET_CODE (inner_dest) == SUBREG
13413                               || GET_CODE (inner_dest) == ZERO_EXTRACT);
13414                              inner_dest = XEXP (inner_dest, 0))
13415                           ;
13416
13417                       /* Verify that it was the set, and not a clobber that
13418                          modified the register.
13419
13420                          CC0 targets must be careful to maintain setter/user
13421                          pairs.  If we cannot delete the setter due to side
13422                          effects, mark the user with an UNUSED note instead
13423                          of deleting it.  */
13424
13425                       if (set != 0 && ! side_effects_p (SET_SRC (set))
13426                           && rtx_equal_p (XEXP (note, 0), inner_dest)
13427 #ifdef HAVE_cc0
13428                           && (! reg_mentioned_p (cc0_rtx, SET_SRC (set))
13429                               || ((cc0_setter = prev_cc0_setter (tem)) != NULL
13430                                   && sets_cc0_p (PATTERN (cc0_setter)) > 0))
13431 #endif
13432                           )
13433                         {
13434                           /* Move the notes and links of TEM elsewhere.
13435                              This might delete other dead insns recursively.
13436                              First set the pattern to something that won't use
13437                              any register.  */
13438                           rtx old_notes = REG_NOTES (tem);
13439
13440                           PATTERN (tem) = pc_rtx;
13441                           REG_NOTES (tem) = NULL;
13442
13443                           distribute_notes (old_notes, tem, tem, NULL_RTX,
13444                                             NULL_RTX, NULL_RTX, NULL_RTX);
13445                           distribute_links (LOG_LINKS (tem));
13446
13447                           SET_INSN_DELETED (tem);
13448                           if (tem == i2)
13449                             i2 = NULL_RTX;
13450
13451 #ifdef HAVE_cc0
13452                           /* Delete the setter too.  */
13453                           if (cc0_setter)
13454                             {
13455                               PATTERN (cc0_setter) = pc_rtx;
13456                               old_notes = REG_NOTES (cc0_setter);
13457                               REG_NOTES (cc0_setter) = NULL;
13458
13459                               distribute_notes (old_notes, cc0_setter,
13460                                                 cc0_setter, NULL_RTX,
13461                                                 NULL_RTX, NULL_RTX, NULL_RTX);
13462                               distribute_links (LOG_LINKS (cc0_setter));
13463
13464                               SET_INSN_DELETED (cc0_setter);
13465                               if (cc0_setter == i2)
13466                                 i2 = NULL_RTX;
13467                             }
13468 #endif
13469                         }
13470                       else
13471                         {
13472                           PUT_REG_NOTE_KIND (note, REG_UNUSED);
13473
13474                           /*  If there isn't already a REG_UNUSED note, put one
13475                               here.  Do not place a REG_DEAD note, even if
13476                               the register is also used here; that would not
13477                               match the algorithm used in lifetime analysis
13478                               and can cause the consistency check in the
13479                               scheduler to fail.  */
13480                           if (! find_regno_note (tem, REG_UNUSED,
13481                                                  REGNO (XEXP (note, 0))))
13482                             place = tem;
13483                           break;
13484                         }
13485                     }
13486                   else if (reg_referenced_p (XEXP (note, 0), PATTERN (tem))
13487                            || (CALL_P (tem)
13488                                && find_reg_fusage (tem, USE, XEXP (note, 0))))
13489                     {
13490                       place = tem;
13491
13492                       /* If we are doing a 3->2 combination, and we have a
13493                          register which formerly died in i3 and was not used
13494                          by i2, which now no longer dies in i3 and is used in
13495                          i2 but does not die in i2, and place is between i2
13496                          and i3, then we may need to move a link from place to
13497                          i2.  */
13498                       if (i2 && DF_INSN_LUID (place) > DF_INSN_LUID (i2)
13499                           && from_insn
13500                           && DF_INSN_LUID (from_insn) > DF_INSN_LUID (i2)
13501                           && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
13502                         {
13503                           rtx links = LOG_LINKS (place);
13504                           LOG_LINKS (place) = 0;
13505                           distribute_links (links);
13506                         }
13507                       break;
13508                     }
13509
13510                   if (tem == BB_HEAD (bb))
13511                     break;
13512                 }
13513
13514             }
13515
13516           /* If the register is set or already dead at PLACE, we needn't do
13517              anything with this note if it is still a REG_DEAD note.
13518              We check here if it is set at all, not if is it totally replaced,
13519              which is what `dead_or_set_p' checks, so also check for it being
13520              set partially.  */
13521
13522           if (place && REG_NOTE_KIND (note) == REG_DEAD)
13523             {
13524               unsigned int regno = REGNO (XEXP (note, 0));
13525               reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, regno);
13526
13527               if (dead_or_set_p (place, XEXP (note, 0))
13528                   || reg_bitfield_target_p (XEXP (note, 0), PATTERN (place)))
13529                 {
13530                   /* Unless the register previously died in PLACE, clear
13531                      last_death.  [I no longer understand why this is
13532                      being done.] */
13533                   if (rsp->last_death != place)
13534                     rsp->last_death = 0;
13535                   place = 0;
13536                 }
13537               else
13538                 rsp->last_death = place;
13539
13540               /* If this is a death note for a hard reg that is occupying
13541                  multiple registers, ensure that we are still using all
13542                  parts of the object.  If we find a piece of the object
13543                  that is unused, we must arrange for an appropriate REG_DEAD
13544                  note to be added for it.  However, we can't just emit a USE
13545                  and tag the note to it, since the register might actually
13546                  be dead; so we recourse, and the recursive call then finds
13547                  the previous insn that used this register.  */
13548
13549               if (place && regno < FIRST_PSEUDO_REGISTER
13550                   && hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))] > 1)
13551                 {
13552                   unsigned int endregno = END_HARD_REGNO (XEXP (note, 0));
13553                   int all_used = 1;
13554                   unsigned int i;
13555
13556                   for (i = regno; i < endregno; i++)
13557                     if ((! refers_to_regno_p (i, i + 1, PATTERN (place), 0)
13558                          && ! find_regno_fusage (place, USE, i))
13559                         || dead_or_set_regno_p (place, i))
13560                       all_used = 0;
13561
13562                   if (! all_used)
13563                     {
13564                       /* Put only REG_DEAD notes for pieces that are
13565                          not already dead or set.  */
13566
13567                       for (i = regno; i < endregno;
13568                            i += hard_regno_nregs[i][reg_raw_mode[i]])
13569                         {
13570                           rtx piece = regno_reg_rtx[i];
13571                           basic_block bb = this_basic_block;
13572
13573                           if (! dead_or_set_p (place, piece)
13574                               && ! reg_bitfield_target_p (piece,
13575                                                           PATTERN (place)))
13576                             {
13577                               rtx new_note = alloc_reg_note (REG_DEAD, piece,
13578                                                              NULL_RTX);
13579
13580                               distribute_notes (new_note, place, place,
13581                                                 NULL_RTX, NULL_RTX, NULL_RTX,
13582                                                 NULL_RTX);
13583                             }
13584                           else if (! refers_to_regno_p (i, i + 1,
13585                                                         PATTERN (place), 0)
13586                                    && ! find_regno_fusage (place, USE, i))
13587                             for (tem = PREV_INSN (place); ;
13588                                  tem = PREV_INSN (tem))
13589                               {
13590                                 if (!NONDEBUG_INSN_P (tem))
13591                                   {
13592                                     if (tem == BB_HEAD (bb))
13593                                       break;
13594                                     continue;
13595                                   }
13596                                 if (dead_or_set_p (tem, piece)
13597                                     || reg_bitfield_target_p (piece,
13598                                                               PATTERN (tem)))
13599                                   {
13600                                     add_reg_note (tem, REG_UNUSED, piece);
13601                                     break;
13602                                   }
13603                               }
13604
13605                         }
13606
13607                       place = 0;
13608                     }
13609                 }
13610             }
13611           break;
13612
13613         default:
13614           /* Any other notes should not be present at this point in the
13615              compilation.  */
13616           gcc_unreachable ();
13617         }
13618
13619       if (place)
13620         {
13621           XEXP (note, 1) = REG_NOTES (place);
13622           REG_NOTES (place) = note;
13623         }
13624
13625       if (place2)
13626         add_reg_note (place2, REG_NOTE_KIND (note), XEXP (note, 0));
13627     }
13628 }
13629 \f
13630 /* Similarly to above, distribute the LOG_LINKS that used to be present on
13631    I3, I2, and I1 to new locations.  This is also called to add a link
13632    pointing at I3 when I3's destination is changed.  */
13633
13634 static void
13635 distribute_links (rtx links)
13636 {
13637   rtx link, next_link;
13638
13639   for (link = links; link; link = next_link)
13640     {
13641       rtx place = 0;
13642       rtx insn;
13643       rtx set, reg;
13644
13645       next_link = XEXP (link, 1);
13646
13647       /* If the insn that this link points to is a NOTE or isn't a single
13648          set, ignore it.  In the latter case, it isn't clear what we
13649          can do other than ignore the link, since we can't tell which
13650          register it was for.  Such links wouldn't be used by combine
13651          anyway.
13652
13653          It is not possible for the destination of the target of the link to
13654          have been changed by combine.  The only potential of this is if we
13655          replace I3, I2, and I1 by I3 and I2.  But in that case the
13656          destination of I2 also remains unchanged.  */
13657
13658       if (NOTE_P (XEXP (link, 0))
13659           || (set = single_set (XEXP (link, 0))) == 0)
13660         continue;
13661
13662       reg = SET_DEST (set);
13663       while (GET_CODE (reg) == SUBREG || GET_CODE (reg) == ZERO_EXTRACT
13664              || GET_CODE (reg) == STRICT_LOW_PART)
13665         reg = XEXP (reg, 0);
13666
13667       /* A LOG_LINK is defined as being placed on the first insn that uses
13668          a register and points to the insn that sets the register.  Start
13669          searching at the next insn after the target of the link and stop
13670          when we reach a set of the register or the end of the basic block.
13671
13672          Note that this correctly handles the link that used to point from
13673          I3 to I2.  Also note that not much searching is typically done here
13674          since most links don't point very far away.  */
13675
13676       for (insn = NEXT_INSN (XEXP (link, 0));
13677            (insn && (this_basic_block->next_bb == EXIT_BLOCK_PTR
13678                      || BB_HEAD (this_basic_block->next_bb) != insn));
13679            insn = NEXT_INSN (insn))
13680         if (DEBUG_INSN_P (insn))
13681           continue;
13682         else if (INSN_P (insn) && reg_overlap_mentioned_p (reg, PATTERN (insn)))
13683           {
13684             if (reg_referenced_p (reg, PATTERN (insn)))
13685               place = insn;
13686             break;
13687           }
13688         else if (CALL_P (insn)
13689                  && find_reg_fusage (insn, USE, reg))
13690           {
13691             place = insn;
13692             break;
13693           }
13694         else if (INSN_P (insn) && reg_set_p (reg, insn))
13695           break;
13696
13697       /* If we found a place to put the link, place it there unless there
13698          is already a link to the same insn as LINK at that point.  */
13699
13700       if (place)
13701         {
13702           rtx link2;
13703
13704           for (link2 = LOG_LINKS (place); link2; link2 = XEXP (link2, 1))
13705             if (XEXP (link2, 0) == XEXP (link, 0))
13706               break;
13707
13708           if (link2 == 0)
13709             {
13710               XEXP (link, 1) = LOG_LINKS (place);
13711               LOG_LINKS (place) = link;
13712
13713               /* Set added_links_insn to the earliest insn we added a
13714                  link to.  */
13715               if (added_links_insn == 0
13716                   || DF_INSN_LUID (added_links_insn) > DF_INSN_LUID (place))
13717                 added_links_insn = place;
13718             }
13719         }
13720     }
13721 }
13722 \f
13723 /* Subroutine of unmentioned_reg_p and callback from for_each_rtx.
13724    Check whether the expression pointer to by LOC is a register or
13725    memory, and if so return 1 if it isn't mentioned in the rtx EXPR.
13726    Otherwise return zero.  */
13727
13728 static int
13729 unmentioned_reg_p_1 (rtx *loc, void *expr)
13730 {
13731   rtx x = *loc;
13732
13733   if (x != NULL_RTX
13734       && (REG_P (x) || MEM_P (x))
13735       && ! reg_mentioned_p (x, (rtx) expr))
13736     return 1;
13737   return 0;
13738 }
13739
13740 /* Check for any register or memory mentioned in EQUIV that is not
13741    mentioned in EXPR.  This is used to restrict EQUIV to "specializations"
13742    of EXPR where some registers may have been replaced by constants.  */
13743
13744 static bool
13745 unmentioned_reg_p (rtx equiv, rtx expr)
13746 {
13747   return for_each_rtx (&equiv, unmentioned_reg_p_1, expr);
13748 }
13749 \f
13750 void
13751 dump_combine_stats (FILE *file)
13752 {
13753   fprintf
13754     (file,
13755      ";; Combiner statistics: %d attempts, %d substitutions (%d requiring new space),\n;; %d successes.\n\n",
13756      combine_attempts, combine_merges, combine_extras, combine_successes);
13757 }
13758
13759 void
13760 dump_combine_total_stats (FILE *file)
13761 {
13762   fprintf
13763     (file,
13764      "\n;; Combiner totals: %d attempts, %d substitutions (%d requiring new space),\n;; %d successes.\n",
13765      total_attempts, total_merges, total_extras, total_successes);
13766 }
13767 \f
13768 static bool
13769 gate_handle_combine (void)
13770 {
13771   return (optimize > 0);
13772 }
13773
13774 /* Try combining insns through substitution.  */
13775 static unsigned int
13776 rest_of_handle_combine (void)
13777 {
13778   int rebuild_jump_labels_after_combine;
13779
13780   df_set_flags (DF_LR_RUN_DCE + DF_DEFER_INSN_RESCAN);
13781   df_note_add_problem ();
13782   df_analyze ();
13783
13784   regstat_init_n_sets_and_refs ();
13785
13786   rebuild_jump_labels_after_combine
13787     = combine_instructions (get_insns (), max_reg_num ());
13788
13789   /* Combining insns may have turned an indirect jump into a
13790      direct jump.  Rebuild the JUMP_LABEL fields of jumping
13791      instructions.  */
13792   if (rebuild_jump_labels_after_combine)
13793     {
13794       timevar_push (TV_JUMP);
13795       rebuild_jump_labels (get_insns ());
13796       cleanup_cfg (0);
13797       timevar_pop (TV_JUMP);
13798     }
13799
13800   regstat_free_n_sets_and_refs ();
13801   return 0;
13802 }
13803
13804 struct rtl_opt_pass pass_combine =
13805 {
13806  {
13807   RTL_PASS,
13808   "combine",                            /* name */
13809   gate_handle_combine,                  /* gate */
13810   rest_of_handle_combine,               /* execute */
13811   NULL,                                 /* sub */
13812   NULL,                                 /* next */
13813   0,                                    /* static_pass_number */
13814   TV_COMBINE,                           /* tv_id */
13815   PROP_cfglayout,                       /* properties_required */
13816   0,                                    /* properties_provided */
13817   0,                                    /* properties_destroyed */
13818   0,                                    /* todo_flags_start */
13819   TODO_dump_func |
13820   TODO_df_finish | TODO_verify_rtl_sharing |
13821   TODO_ggc_collect,                     /* todo_flags_finish */
13822  }
13823 };