gcc/combine.c

   1 /* Optimize by combining instructions for GNU compiler.
   2    Copyright (C) 1987, 88, 92-98, 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  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 created by
  53    flow.c aren't completely updated:
  54
  55    - reg_live_length is not updated
  56    - reg_n_refs is not adjusted in the rare case when a register is
  57      no longer required in a computation
  58    - there are extremely rare cases (see distribute_regnotes) when a
  59      REG_DEAD note is lost
  60    - a LOG_LINKS entry that refers to an insn with multiple SETs may be
  61      removed because there is no way to know which register it was
  62      linking
  63
  64    To simplify substitution, we combine only when the earlier insn(s)
  65    consist of only a single assignment.  To simplify updating afterward,
  66    we never combine when a subroutine call appears in the middle.
  67
  68    Since we do not represent assignments to CC0 explicitly except when that
  69    is all an insn does, there is no LOG_LINKS entry in an insn that uses
  70    the condition code for the insn that set the condition code.
  71    Fortunately, these two insns must be consecutive.
  72    Therefore, every JUMP_INSN is taken to have an implicit logical link
  73    to the preceding insn.  This is not quite right, since non-jumps can
  74    also use the condition code; but in practice such insns would not
  75    combine anyway.  */
  76
  77 #include "config.h"
  78 #include "system.h"
  79 #include "rtl.h" /* stdio.h must precede rtl.h for FFS.  */
  80 #include "flags.h"
  81 #include "regs.h"
  82 #include "hard-reg-set.h"
  83 #include "basic-block.h"
  84 #include "insn-config.h"
  85 /* Include expr.h after insn-config.h so we get HAVE_conditional_move. */
  86 #include "expr.h"
  87 #include "insn-flags.h"
  88 #include "insn-codes.h"
  89 #include "insn-attr.h"
  90 #include "recog.h"
  91 #include "real.h"
  92 #include "toplev.h"
  93
  94 /* It is not safe to use ordinary gen_lowpart in combine.
  95    Use gen_lowpart_for_combine instead.  See comments there.  */
  96 #define gen_lowpart dont_use_gen_lowpart_you_dummy
  97
  98 /* Number of attempts to combine instructions in this function.  */
  99
 100 static int combine_attempts;
 101
 102 /* Number of attempts that got as far as substitution in this function.  */
 103
 104 static int combine_merges;
 105
 106 /* Number of instructions combined with added SETs in this function.  */
 107
 108 static int combine_extras;
 109
 110 /* Number of instructions combined in this function.  */
 111
 112 static int combine_successes;
 113
 114 /* Totals over entire compilation.  */
 115
 116 static int total_attempts, total_merges, total_extras, total_successes;
 117
 118 /* Define a default value for REVERSIBLE_CC_MODE.
 119    We can never assume that a condition code mode is safe to reverse unless
 120    the md tells us so.  */
 121 #ifndef REVERSIBLE_CC_MODE
 122 #define REVERSIBLE_CC_MODE(MODE) 0
 123 #endif
 124 \f
 125 /* Vector mapping INSN_UIDs to cuids.
 126    The cuids are like uids but increase monotonically always.
 127    Combine always uses cuids so that it can compare them.
 128    But actually renumbering the uids, which we used to do,
 129    proves to be a bad idea because it makes it hard to compare
 130    the dumps produced by earlier passes with those from later passes.  */
 131
 132 static int *uid_cuid;
 133 static int max_uid_cuid;
 134
 135 /* Get the cuid of an insn.  */
 136
 137 #define INSN_CUID(INSN) \
 138 (INSN_UID (INSN) > max_uid_cuid ? insn_cuid (INSN) : uid_cuid[INSN_UID (INSN)])
 139
 140 /* Maximum register number, which is the size of the tables below.  */
 141
 142 static int combine_max_regno;
 143
 144 /* Record last point of death of (hard or pseudo) register n.  */
 145
 146 static rtx *reg_last_death;
 147
 148 /* Record last point of modification of (hard or pseudo) register n.  */
 149
 150 static rtx *reg_last_set;
 151
 152 /* Record the cuid of the last insn that invalidated memory
 153    (anything that writes memory, and subroutine calls, but not pushes).  */
 154
 155 static int mem_last_set;
 156
 157 /* Record the cuid of the last CALL_INSN
 158    so we can tell whether a potential combination crosses any calls.  */
 159
 160 static int last_call_cuid;
 161
 162 /* When `subst' is called, this is the insn that is being modified
 163    (by combining in a previous insn).  The PATTERN of this insn
 164    is still the old pattern partially modified and it should not be
 165    looked at, but this may be used to examine the successors of the insn
 166    to judge whether a simplification is valid.  */
 167
 168 static rtx subst_insn;
 169
 170 /* This is an insn that belongs before subst_insn, but is not currently
 171    on the insn chain.  */
 172
 173 static rtx subst_prev_insn;
 174
 175 /* This is the lowest CUID that `subst' is currently dealing with.
 176    get_last_value will not return a value if the register was set at or
 177    after this CUID.  If not for this mechanism, we could get confused if
 178    I2 or I1 in try_combine were an insn that used the old value of a register
 179    to obtain a new value.  In that case, we might erroneously get the
 180    new value of the register when we wanted the old one.  */
 181
 182 static int subst_low_cuid;
 183
 184 /* This contains any hard registers that are used in newpat; reg_dead_at_p
 185    must consider all these registers to be always live.  */
 186
 187 static HARD_REG_SET newpat_used_regs;
 188
 189 /* This is an insn to which a LOG_LINKS entry has been added.  If this
 190    insn is the earlier than I2 or I3, combine should rescan starting at
 191    that location.  */
 192
 193 static rtx added_links_insn;
 194
 195 /* Basic block number of the block in which we are performing combines.  */
 196 static int this_basic_block;
 197 \f
 198 /* The next group of arrays allows the recording of the last value assigned
 199    to (hard or pseudo) register n.  We use this information to see if a
 200    operation being processed is redundant given a prior operation performed
 201    on the register.  For example, an `and' with a constant is redundant if
 202    all the zero bits are already known to be turned off.
 203
 204    We use an approach similar to that used by cse, but change it in the
 205    following ways:
 206
 207    (1) We do not want to reinitialize at each label.
 208    (2) It is useful, but not critical, to know the actual value assigned
 209        to a register.  Often just its form is helpful.
 210
 211    Therefore, we maintain the following arrays:
 212
 213    reg_last_set_value           the last value assigned
 214    reg_last_set_label           records the value of label_tick when the
 215                                 register was assigned
 216    reg_last_set_table_tick      records the value of label_tick when a
 217                                 value using the register is assigned
 218    reg_last_set_invalid         set to non-zero when it is not valid
 219                                 to use the value of this register in some
 220                                 register's value
 221
 222    To understand the usage of these tables, it is important to understand
 223    the distinction between the value in reg_last_set_value being valid
 224    and the register being validly contained in some other expression in the
 225    table.
 226
 227    Entry I in reg_last_set_value is valid if it is non-zero, and either
 228    reg_n_sets[i] is 1 or reg_last_set_label[i] == label_tick.
 229
 230    Register I may validly appear in any expression returned for the value
 231    of another register if reg_n_sets[i] is 1.  It may also appear in the
 232    value for register J if reg_last_set_label[i] < reg_last_set_label[j] or
 233    reg_last_set_invalid[j] is zero.
 234
 235    If an expression is found in the table containing a register which may
 236    not validly appear in an expression, the register is replaced by
 237    something that won't match, (clobber (const_int 0)).
 238
 239    reg_last_set_invalid[i] is set non-zero when register I is being assigned
 240    to and reg_last_set_table_tick[i] == label_tick.  */
 241
 242 /* Record last value assigned to (hard or pseudo) register n.  */
 243
 244 static rtx *reg_last_set_value;
 245
 246 /* Record the value of label_tick when the value for register n is placed in
 247    reg_last_set_value[n].  */
 248
 249 static int *reg_last_set_label;
 250
 251 /* Record the value of label_tick when an expression involving register n
 252    is placed in reg_last_set_value.  */
 253
 254 static int *reg_last_set_table_tick;
 255
 256 /* Set non-zero if references to register n in expressions should not be
 257    used.  */
 258
 259 static char *reg_last_set_invalid;
 260
 261 /* Incremented for each label.  */
 262
 263 static int label_tick;
 264
 265 /* Some registers that are set more than once and used in more than one
 266    basic block are nevertheless always set in similar ways.  For example,
 267    a QImode register may be loaded from memory in two places on a machine
 268    where byte loads zero extend.
 269
 270    We record in the following array what we know about the nonzero
 271    bits of a register, specifically which bits are known to be zero.
 272
 273    If an entry is zero, it means that we don't know anything special.  */
 274
 275 static unsigned HOST_WIDE_INT *reg_nonzero_bits;
 276
 277 /* Mode used to compute significance in reg_nonzero_bits.  It is the largest
 278    integer mode that can fit in HOST_BITS_PER_WIDE_INT.  */
 279
 280 static enum machine_mode nonzero_bits_mode;
 281
 282 /* Nonzero if we know that a register has some leading bits that are always
 283    equal to the sign bit.  */
 284
 285 static char *reg_sign_bit_copies;
 286
 287 /* Nonzero when reg_nonzero_bits and reg_sign_bit_copies can be safely used.
 288    It is zero while computing them and after combine has completed.  This
 289    former test prevents propagating values based on previously set values,
 290    which can be incorrect if a variable is modified in a loop.  */
 291
 292 static int nonzero_sign_valid;
 293
 294 /* These arrays are maintained in parallel with reg_last_set_value
 295    and are used to store the mode in which the register was last set,
 296    the bits that were known to be zero when it was last set, and the
 297    number of sign bits copies it was known to have when it was last set.  */
 298
 299 static enum machine_mode *reg_last_set_mode;
 300 static unsigned HOST_WIDE_INT *reg_last_set_nonzero_bits;
 301 static char *reg_last_set_sign_bit_copies;
 302 \f
 303 /* Record one modification to rtl structure
 304    to be undone by storing old_contents into *where.
 305    is_int is 1 if the contents are an int.  */
 306
 307 struct undo
 308 {
 309   struct undo *next;
 310   int is_int;
 311   union {rtx r; int i;} old_contents;
 312   union {rtx *r; int *i;} where;
 313 };
 314
 315 /* Record a bunch of changes to be undone, up to MAX_UNDO of them.
 316    num_undo says how many are currently recorded.
 317
 318    storage is nonzero if we must undo the allocation of new storage.
 319    The value of storage is what to pass to obfree.
 320
 321    other_insn is nonzero if we have modified some other insn in the process
 322    of working on subst_insn.  It must be verified too.
 323
 324    previous_undos is the value of undobuf.undos when we started processing
 325    this substitution.  This will prevent gen_rtx_combine from re-used a piece
 326    from the previous expression.  Doing so can produce circular rtl
 327    structures.  */
 328
 329 struct undobuf
 330 {
 331   char *storage;
 332   struct undo *undos;
 333   struct undo *frees;
 334   struct undo *previous_undos;
 335   rtx other_insn;
 336 };
 337
 338 static struct undobuf undobuf;
 339
 340 /* Substitute NEWVAL, an rtx expression, into INTO, a place in some
 341    insn.  The substitution can be undone by undo_all.  If INTO is already
 342    set to NEWVAL, do not record this change.  Because computing NEWVAL might
 343    also call SUBST, we have to compute it before we put anything into
 344    the undo table.  */
 345
 346 #define SUBST(INTO, NEWVAL)  \
 347  do { rtx _new = (NEWVAL);                                      \
 348       struct undo *_buf;                                        \
 349                                                                 \
 350       if (undobuf.frees)                                        \
 351         _buf = undobuf.frees, undobuf.frees = _buf->next;       \
 352       else                                                      \
 353         _buf = (struct undo *) xmalloc (sizeof (struct undo));  \
 354                                                                 \
 355       _buf->is_int = 0;                                         \
 356       _buf->where.r = &INTO;                                    \
 357       _buf->old_contents.r = INTO;                              \
 358       INTO = _new;                                              \
 359       if (_buf->old_contents.r == INTO)                         \
 360         _buf->next = undobuf.frees, undobuf.frees = _buf;       \
 361       else                                                      \
 362         _buf->next = undobuf.undos, undobuf.undos = _buf;       \
 363     } while (0)
 364
 365 /* Similar to SUBST, but NEWVAL is an int expression.  Note that substitution
 366    for the value of a HOST_WIDE_INT value (including CONST_INT) is
 367    not safe.  */
 368
 369 #define SUBST_INT(INTO, NEWVAL)  \
 370  do { struct undo *_buf;                                        \
 371                                                                 \
 372       if (undobuf.frees)                                        \
 373         _buf = undobuf.frees, undobuf.frees = _buf->next;       \
 374       else                                                      \
 375         _buf = (struct undo *) xmalloc (sizeof (struct undo));  \
 376                                                                 \
 377       _buf->is_int = 1;                                         \
 378       _buf->where.i = (int *) &INTO;                            \
 379       _buf->old_contents.i = INTO;                              \
 380       INTO = NEWVAL;                                            \
 381       if (_buf->old_contents.i == INTO)                         \
 382         _buf->next = undobuf.frees, undobuf.frees = _buf;       \
 383       else                                                      \
 384         _buf->next = undobuf.undos, undobuf.undos = _buf;       \
 385      } while (0)
 386
 387 /* Number of times the pseudo being substituted for
 388    was found and replaced.  */
 389
 390 static int n_occurrences;
 391
 392 static void init_reg_last_arrays        PROTO((void));
 393 static void setup_incoming_promotions   PROTO((void));
 394 static void set_nonzero_bits_and_sign_copies  PROTO((rtx, rtx));
 395 static int can_combine_p        PROTO((rtx, rtx, rtx, rtx, rtx *, rtx *));
 396 static int sets_function_arg_p  PROTO((rtx));
 397 static int combinable_i3pat     PROTO((rtx, rtx *, rtx, rtx, int, rtx *));
 398 static rtx try_combine          PROTO((rtx, rtx, rtx));
 399 static void undo_all            PROTO((void));
 400 static rtx *find_split_point    PROTO((rtx *, rtx));
 401 static rtx subst                PROTO((rtx, rtx, rtx, int, int));
 402 static rtx simplify_rtx         PROTO((rtx, enum machine_mode, int, int));
 403 static rtx simplify_if_then_else  PROTO((rtx));
 404 static rtx simplify_set         PROTO((rtx));
 405 static rtx simplify_logical     PROTO((rtx, int));
 406 static rtx expand_compound_operation  PROTO((rtx));
 407 static rtx expand_field_assignment  PROTO((rtx));
 408 static rtx make_extraction      PROTO((enum machine_mode, rtx, int, rtx, int,
 409                                        int, int, int));
 410 static rtx extract_left_shift   PROTO((rtx, int));
 411 static rtx make_compound_operation  PROTO((rtx, enum rtx_code));
 412 static int get_pos_from_mask    PROTO((unsigned HOST_WIDE_INT, int *));
 413 static rtx force_to_mode        PROTO((rtx, enum machine_mode,
 414                                        unsigned HOST_WIDE_INT, rtx, int));
 415 static rtx if_then_else_cond    PROTO((rtx, rtx *, rtx *));
 416 static rtx known_cond           PROTO((rtx, enum rtx_code, rtx, rtx));
 417 static int rtx_equal_for_field_assignment_p PROTO((rtx, rtx));
 418 static rtx make_field_assignment  PROTO((rtx));
 419 static rtx apply_distributive_law  PROTO((rtx));
 420 static rtx simplify_and_const_int  PROTO((rtx, enum machine_mode, rtx,
 421                                           unsigned HOST_WIDE_INT));
 422 static unsigned HOST_WIDE_INT nonzero_bits  PROTO((rtx, enum machine_mode));
 423 static int num_sign_bit_copies  PROTO((rtx, enum machine_mode));
 424 static int merge_outer_ops      PROTO((enum rtx_code *, HOST_WIDE_INT *,
 425                                        enum rtx_code, HOST_WIDE_INT,
 426                                        enum machine_mode, int *));
 427 static rtx simplify_shift_const PROTO((rtx, enum rtx_code, enum machine_mode,
 428                                        rtx, int));
 429 static int recog_for_combine    PROTO((rtx *, rtx, rtx *));
 430 static rtx gen_lowpart_for_combine  PROTO((enum machine_mode, rtx));
 431 static rtx gen_rtx_combine PVPROTO((enum rtx_code code, enum machine_mode mode,
 432                                   ...));
 433 static rtx gen_binary           PROTO((enum rtx_code, enum machine_mode,
 434                                        rtx, rtx));
 435 static rtx gen_unary            PROTO((enum rtx_code, enum machine_mode,
 436                                        enum machine_mode, rtx));
 437 static enum rtx_code simplify_comparison  PROTO((enum rtx_code, rtx *, rtx *));
 438 static int reversible_comparison_p  PROTO((rtx));
 439 static void update_table_tick   PROTO((rtx));
 440 static void record_value_for_reg  PROTO((rtx, rtx, rtx));
 441 static void record_dead_and_set_regs_1  PROTO((rtx, rtx));
 442 static void record_dead_and_set_regs  PROTO((rtx));
 443 static int get_last_value_validate  PROTO((rtx *, rtx, int, int));
 444 static rtx get_last_value       PROTO((rtx));
 445 static int use_crosses_set_p    PROTO((rtx, int));
 446 static void reg_dead_at_p_1     PROTO((rtx, rtx));
 447 static int reg_dead_at_p        PROTO((rtx, rtx));
 448 static void move_deaths         PROTO((rtx, rtx, int, rtx, rtx *));
 449 static int reg_bitfield_target_p  PROTO((rtx, rtx));
 450 static void distribute_notes    PROTO((rtx, rtx, rtx, rtx, rtx, rtx));
 451 static void distribute_links    PROTO((rtx));
 452 static void mark_used_regs_combine PROTO((rtx));
 453 static int insn_cuid            PROTO((rtx));
 454 \f
 455 /* Main entry point for combiner.  F is the first insn of the function.
 456    NREGS is the first unused pseudo-reg number.  */
 457
 458 void
 459 combine_instructions (f, nregs)
 460      rtx f;
 461      int nregs;
 462 {
 463   register rtx insn, next;
 464 #ifdef HAVE_cc0
 465   register rtx prev;
 466 #endif
 467   register int i;
 468   register rtx links, nextlinks;
 469
 470   combine_attempts = 0;
 471   combine_merges = 0;
 472   combine_extras = 0;
 473   combine_successes = 0;
 474   undobuf.undos = undobuf.previous_undos = 0;
 475
 476   combine_max_regno = nregs;
 477
 478   reg_nonzero_bits
 479     = (unsigned HOST_WIDE_INT *) alloca (nregs * sizeof (HOST_WIDE_INT));
 480   reg_sign_bit_copies = (char *) alloca (nregs * sizeof (char));
 481
 482   bzero ((char *) reg_nonzero_bits, nregs * sizeof (HOST_WIDE_INT));
 483   bzero (reg_sign_bit_copies, nregs * sizeof (char));
 484
 485   reg_last_death = (rtx *) alloca (nregs * sizeof (rtx));
 486   reg_last_set = (rtx *) alloca (nregs * sizeof (rtx));
 487   reg_last_set_value = (rtx *) alloca (nregs * sizeof (rtx));
 488   reg_last_set_table_tick = (int *) alloca (nregs * sizeof (int));
 489   reg_last_set_label = (int *) alloca (nregs * sizeof (int));
 490   reg_last_set_invalid = (char *) alloca (nregs * sizeof (char));
 491   reg_last_set_mode
 492     = (enum machine_mode *) alloca (nregs * sizeof (enum machine_mode));
 493   reg_last_set_nonzero_bits
 494     = (unsigned HOST_WIDE_INT *) alloca (nregs * sizeof (HOST_WIDE_INT));
 495   reg_last_set_sign_bit_copies
 496     = (char *) alloca (nregs * sizeof (char));
 497
 498   init_reg_last_arrays ();
 499
 500   init_recog_no_volatile ();
 501
 502   /* Compute maximum uid value so uid_cuid can be allocated.  */
 503
 504   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
 505     if (INSN_UID (insn) > i)
 506       i = INSN_UID (insn);
 507
 508   uid_cuid = (int *) alloca ((i + 1) * sizeof (int));
 509   max_uid_cuid = i;
 510
 511   nonzero_bits_mode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
 512
 513   /* Don't use reg_nonzero_bits when computing it.  This can cause problems
 514      when, for example, we have j <<= 1 in a loop.  */
 515
 516   nonzero_sign_valid = 0;
 517
 518   /* Compute the mapping from uids to cuids.
 519      Cuids are numbers assigned to insns, like uids,
 520      except that cuids increase monotonically through the code.
 521
 522      Scan all SETs and see if we can deduce anything about what
 523      bits are known to be zero for some registers and how many copies
 524      of the sign bit are known to exist for those registers.
 525
 526      Also set any known values so that we can use it while searching
 527      for what bits are known to be set.  */
 528
 529   label_tick = 1;
 530
 531   /* We need to initialize it here, because record_dead_and_set_regs may call
 532      get_last_value.  */
 533   subst_prev_insn = NULL_RTX;
 534
 535   setup_incoming_promotions ();
 536
 537   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
 538     {
 539       uid_cuid[INSN_UID (insn)] = ++i;
 540       subst_low_cuid = i;
 541       subst_insn = insn;
 542
 543       if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
 544         {
 545           note_stores (PATTERN (insn), set_nonzero_bits_and_sign_copies);
 546           record_dead_and_set_regs (insn);
 547
 548 #ifdef AUTO_INC_DEC
 549           for (links = REG_NOTES (insn); links; links = XEXP (links, 1))
 550             if (REG_NOTE_KIND (links) == REG_INC)
 551               set_nonzero_bits_and_sign_copies (XEXP (links, 0), NULL_RTX);
 552 #endif
 553         }
 554
 555       if (GET_CODE (insn) == CODE_LABEL)
 556         label_tick++;
 557     }
 558
 559   nonzero_sign_valid = 1;
 560
 561   /* Now scan all the insns in forward order.  */
 562
 563   this_basic_block = -1;
 564   label_tick = 1;
 565   last_call_cuid = 0;
 566   mem_last_set = 0;
 567   init_reg_last_arrays ();
 568   setup_incoming_promotions ();
 569
 570   for (insn = f; insn; insn = next ? next : NEXT_INSN (insn))
 571     {
 572       next = 0;
 573
 574       /* If INSN starts a new basic block, update our basic block number.  */
 575       if (this_basic_block + 1 < n_basic_blocks
 576           && BLOCK_HEAD (this_basic_block + 1) == insn)
 577         this_basic_block++;
 578
 579       if (GET_CODE (insn) == CODE_LABEL)
 580         label_tick++;
 581
 582       else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
 583         {
 584           /* Try this insn with each insn it links back to.  */
 585
 586           for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
 587             if ((next = try_combine (insn, XEXP (links, 0), NULL_RTX)) != 0)
 588               goto retry;
 589
 590           /* Try each sequence of three linked insns ending with this one.  */
 591
 592           for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
 593             for (nextlinks = LOG_LINKS (XEXP (links, 0)); nextlinks;
 594                  nextlinks = XEXP (nextlinks, 1))
 595               if ((next = try_combine (insn, XEXP (links, 0),
 596                                        XEXP (nextlinks, 0))) != 0)
 597                 goto retry;
 598
 599 #ifdef HAVE_cc0
 600           /* Try to combine a jump insn that uses CC0
 601              with a preceding insn that sets CC0, and maybe with its
 602              logical predecessor as well.
 603              This is how we make decrement-and-branch insns.
 604              We need this special code because data flow connections
 605              via CC0 do not get entered in LOG_LINKS.  */
 606
 607           if (GET_CODE (insn) == JUMP_INSN
 608               && (prev = prev_nonnote_insn (insn)) != 0
 609               && GET_CODE (prev) == INSN
 610               && sets_cc0_p (PATTERN (prev)))
 611             {
 612               if ((next = try_combine (insn, prev, NULL_RTX)) != 0)
 613                 goto retry;
 614
 615               for (nextlinks = LOG_LINKS (prev); nextlinks;
 616                    nextlinks = XEXP (nextlinks, 1))
 617                 if ((next = try_combine (insn, prev,
 618                                          XEXP (nextlinks, 0))) != 0)
 619                   goto retry;
 620             }
 621
 622           /* Do the same for an insn that explicitly references CC0.  */
 623           if (GET_CODE (insn) == INSN
 624               && (prev = prev_nonnote_insn (insn)) != 0
 625               && GET_CODE (prev) == INSN
 626               && sets_cc0_p (PATTERN (prev))
 627               && GET_CODE (PATTERN (insn)) == SET
 628               && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (insn))))
 629             {
 630               if ((next = try_combine (insn, prev, NULL_RTX)) != 0)
 631                 goto retry;
 632
 633               for (nextlinks = LOG_LINKS (prev); nextlinks;
 634                    nextlinks = XEXP (nextlinks, 1))
 635                 if ((next = try_combine (insn, prev,
 636                                          XEXP (nextlinks, 0))) != 0)
 637                   goto retry;
 638             }
 639
 640           /* Finally, see if any of the insns that this insn links to
 641              explicitly references CC0.  If so, try this insn, that insn,
 642              and its predecessor if it sets CC0.  */
 643           for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
 644             if (GET_CODE (XEXP (links, 0)) == INSN
 645                 && GET_CODE (PATTERN (XEXP (links, 0))) == SET
 646                 && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (XEXP (links, 0))))
 647                 && (prev = prev_nonnote_insn (XEXP (links, 0))) != 0
 648                 && GET_CODE (prev) == INSN
 649                 && sets_cc0_p (PATTERN (prev))
 650                 && (next = try_combine (insn, XEXP (links, 0), prev)) != 0)
 651               goto retry;
 652 #endif
 653
 654           /* Try combining an insn with two different insns whose results it
 655              uses.  */
 656           for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
 657             for (nextlinks = XEXP (links, 1); nextlinks;
 658                  nextlinks = XEXP (nextlinks, 1))
 659               if ((next = try_combine (insn, XEXP (links, 0),
 660                                        XEXP (nextlinks, 0))) != 0)
 661                 goto retry;
 662
 663           if (GET_CODE (insn) != NOTE)
 664             record_dead_and_set_regs (insn);
 665
 666         retry:
 667           ;
 668         }
 669     }
 670
 671   total_attempts += combine_attempts;
 672   total_merges += combine_merges;
 673   total_extras += combine_extras;
 674   total_successes += combine_successes;
 675
 676   nonzero_sign_valid = 0;
 677
 678   /* Make recognizer allow volatile MEMs again.  */
 679   init_recog ();
 680 }
 681
 682 /* Wipe the reg_last_xxx arrays in preparation for another pass.  */
 683
 684 static void
 685 init_reg_last_arrays ()
 686 {
 687   int nregs = combine_max_regno;
 688
 689   bzero ((char *) reg_last_death, nregs * sizeof (rtx));
 690   bzero ((char *) reg_last_set, nregs * sizeof (rtx));
 691   bzero ((char *) reg_last_set_value, nregs * sizeof (rtx));
 692   bzero ((char *) reg_last_set_table_tick, nregs * sizeof (int));
 693   bzero ((char *) reg_last_set_label, nregs * sizeof (int));
 694   bzero (reg_last_set_invalid, nregs * sizeof (char));
 695   bzero ((char *) reg_last_set_mode, nregs * sizeof (enum machine_mode));
 696   bzero ((char *) reg_last_set_nonzero_bits, nregs * sizeof (HOST_WIDE_INT));
 697   bzero (reg_last_set_sign_bit_copies, nregs * sizeof (char));
 698 }
 699 \f
 700 /* Set up any promoted values for incoming argument registers.  */
 701
 702 static void
 703 setup_incoming_promotions ()
 704 {
 705 #ifdef PROMOTE_FUNCTION_ARGS
 706   int regno;
 707   rtx reg;
 708   enum machine_mode mode;
 709   int unsignedp;
 710   rtx first = get_insns ();
 711
 712   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 713     if (FUNCTION_ARG_REGNO_P (regno)
 714         && (reg = promoted_input_arg (regno, &mode, &unsignedp)) != 0)
 715       {
 716         record_value_for_reg
 717           (reg, first, gen_rtx_fmt_e ((unsignedp ? ZERO_EXTEND
 718                                        : SIGN_EXTEND),
 719                                       GET_MODE (reg),
 720                                       gen_rtx_CLOBBER (mode, const0_rtx)));
 721       }
 722 #endif
 723 }
 724 \f
 725 /* Called via note_stores.  If X is a pseudo that is narrower than
 726    HOST_BITS_PER_WIDE_INT and is being set, record what bits are known zero.
 727
 728    If we are setting only a portion of X and we can't figure out what
 729    portion, assume all bits will be used since we don't know what will
 730    be happening.
 731
 732    Similarly, set how many bits of X are known to be copies of the sign bit
 733    at all locations in the function.  This is the smallest number implied
 734    by any set of X.  */
 735
 736 static void
 737 set_nonzero_bits_and_sign_copies (x, set)
 738      rtx x;
 739      rtx set;
 740 {
 741   int num;
 742
 743   if (GET_CODE (x) == REG
 744       && REGNO (x) >= FIRST_PSEUDO_REGISTER
 745       /* If this register is undefined at the start of the file, we can't
 746          say what its contents were.  */
 747       && ! REGNO_REG_SET_P (BASIC_BLOCK (0)->global_live_at_start, REGNO (x))
 748       && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
 749     {
 750       if (set == 0 || GET_CODE (set) == CLOBBER)
 751         {
 752           reg_nonzero_bits[REGNO (x)] = GET_MODE_MASK (GET_MODE (x));
 753           reg_sign_bit_copies[REGNO (x)] = 1;
 754           return;
 755         }
 756
 757       /* If this is a complex assignment, see if we can convert it into a
 758          simple assignment.  */
 759       set = expand_field_assignment (set);
 760
 761       /* If this is a simple assignment, or we have a paradoxical SUBREG,
 762          set what we know about X.  */
 763
 764       if (SET_DEST (set) == x
 765           || (GET_CODE (SET_DEST (set)) == SUBREG
 766               && (GET_MODE_SIZE (GET_MODE (SET_DEST (set)))
 767                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (set)))))
 768               && SUBREG_REG (SET_DEST (set)) == x))
 769         {
 770           rtx src = SET_SRC (set);
 771
 772 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
 773           /* If X is narrower than a word and SRC is a non-negative
 774              constant that would appear negative in the mode of X,
 775              sign-extend it for use in reg_nonzero_bits because some
 776              machines (maybe most) will actually do the sign-extension
 777              and this is the conservative approach.
 778
 779              ??? For 2.5, try to tighten up the MD files in this regard
 780              instead of this kludge.  */
 781
 782           if (GET_MODE_BITSIZE (GET_MODE (x)) < BITS_PER_WORD
 783               && GET_CODE (src) == CONST_INT
 784               && INTVAL (src) > 0
 785               && 0 != (INTVAL (src)
 786                        & ((HOST_WIDE_INT) 1
 787                           << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
 788             src = GEN_INT (INTVAL (src)
 789                            | ((HOST_WIDE_INT) (-1)
 790                               << GET_MODE_BITSIZE (GET_MODE (x))));
 791 #endif
 792
 793           reg_nonzero_bits[REGNO (x)]
 794             |= nonzero_bits (src, nonzero_bits_mode);
 795           num = num_sign_bit_copies (SET_SRC (set), GET_MODE (x));
 796           if (reg_sign_bit_copies[REGNO (x)] == 0
 797               || reg_sign_bit_copies[REGNO (x)] > num)
 798             reg_sign_bit_copies[REGNO (x)] = num;
 799         }
 800       else
 801         {
 802           reg_nonzero_bits[REGNO (x)] = GET_MODE_MASK (GET_MODE (x));
 803           reg_sign_bit_copies[REGNO (x)] = 1;
 804         }
 805     }
 806 }
 807 \f
 808 /* See if INSN can be combined into I3.  PRED and SUCC are optionally
 809    insns that were previously combined into I3 or that will be combined
 810    into the merger of INSN and I3.
 811
 812    Return 0 if the combination is not allowed for any reason.
 813
 814    If the combination is allowed, *PDEST will be set to the single
 815    destination of INSN and *PSRC to the single source, and this function
 816    will return 1.  */
 817
 818 static int
 819 can_combine_p (insn, i3, pred, succ, pdest, psrc)
 820      rtx insn;
 821      rtx i3;
 822      rtx pred ATTRIBUTE_UNUSED;
 823      rtx succ;
 824      rtx *pdest, *psrc;
 825 {
 826   int i;
 827   rtx set = 0, src, dest;
 828   rtx p;
 829 #ifdef AUTO_INC_DEC
 830   rtx link;
 831 #endif
 832   int all_adjacent = (succ ? (next_active_insn (insn) == succ
 833                               && next_active_insn (succ) == i3)
 834                       : next_active_insn (insn) == i3);
 835
 836   /* Can combine only if previous insn is a SET of a REG, a SUBREG or CC0.
 837      or a PARALLEL consisting of such a SET and CLOBBERs.
 838
 839      If INSN has CLOBBER parallel parts, ignore them for our processing.
 840      By definition, these happen during the execution of the insn.  When it
 841      is merged with another insn, all bets are off.  If they are, in fact,
 842      needed and aren't also supplied in I3, they may be added by
 843      recog_for_combine.  Otherwise, it won't match.
 844
 845      We can also ignore a SET whose SET_DEST is mentioned in a REG_UNUSED
 846      note.
 847
 848      Get the source and destination of INSN.  If more than one, can't
 849      combine.  */
 850
 851   if (GET_CODE (PATTERN (insn)) == SET)
 852     set = PATTERN (insn);
 853   else if (GET_CODE (PATTERN (insn)) == PARALLEL
 854            && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
 855     {
 856       for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
 857         {
 858           rtx elt = XVECEXP (PATTERN (insn), 0, i);
 859
 860           switch (GET_CODE (elt))
 861             {
 862             /* This is important to combine floating point insns
 863                for the SH4 port.  */
 864             case USE:
 865               /* Combining an isolated USE doesn't make sense.
 866                  We depend here on combinable_i3_pat to reject them.  */
 867               /* The code below this loop only verifies that the inputs of
 868                  the SET in INSN do not change.  We call reg_set_between_p
 869                  to verify that the REG in the USE does not change betweeen
 870                  I3 and INSN.
 871                  If the USE in INSN was for a pseudo register, the matching
 872                  insn pattern will likely match any register; combining this
 873                  with any other USE would only be safe if we knew that the
 874                  used registers have identical values, or if there was
 875                  something to tell them apart, e.g. different modes.  For
 876                  now, we forgo such compilcated tests and simply disallow
 877                  combining of USES of pseudo registers with any other USE.  */
 878               if (GET_CODE (XEXP (elt, 0)) == REG
 879                   && GET_CODE (PATTERN (i3)) == PARALLEL)
 880                 {
 881                   rtx i3pat = PATTERN (i3);
 882                   int i = XVECLEN (i3pat, 0) - 1;
 883                   int regno = REGNO (XEXP (elt, 0));
 884                   do
 885                     {
 886                       rtx i3elt = XVECEXP (i3pat, 0, i);
 887                       if (GET_CODE (i3elt) == USE
 888                           && GET_CODE (XEXP (i3elt, 0)) == REG
 889                           && (REGNO (XEXP (i3elt, 0)) == regno
 890                               ? reg_set_between_p (XEXP (elt, 0),
 891                                                    PREV_INSN (insn), i3)
 892                               : regno >= FIRST_PSEUDO_REGISTER))
 893                         return 0;
 894                     }
 895                   while (--i >= 0);
 896                 }
 897               break;
 898
 899               /* We can ignore CLOBBERs.  */
 900             case CLOBBER:
 901               break;
 902
 903             case SET:
 904               /* Ignore SETs whose result isn't used but not those that
 905                  have side-effects.  */
 906               if (find_reg_note (insn, REG_UNUSED, SET_DEST (elt))
 907                   && ! side_effects_p (elt))
 908                 break;
 909
 910               /* If we have already found a SET, this is a second one and
 911                  so we cannot combine with this insn.  */
 912               if (set)
 913                 return 0;
 914
 915               set = elt;
 916               break;
 917
 918             default:
 919               /* Anything else means we can't combine.  */
 920               return 0;
 921             }
 922         }
 923
 924       if (set == 0
 925           /* If SET_SRC is an ASM_OPERANDS we can't throw away these CLOBBERs,
 926              so don't do anything with it.  */
 927           || GET_CODE (SET_SRC (set)) == ASM_OPERANDS)
 928         return 0;
 929     }
 930   else
 931     return 0;
 932
 933   if (set == 0)
 934     return 0;
 935
 936   set = expand_field_assignment (set);
 937   src = SET_SRC (set), dest = SET_DEST (set);
 938
 939   /* Don't eliminate a store in the stack pointer.  */
 940   if (dest == stack_pointer_rtx
 941       /* If we couldn't eliminate a field assignment, we can't combine.  */
 942       || GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == STRICT_LOW_PART
 943       /* Don't combine with an insn that sets a register to itself if it has
 944          a REG_EQUAL note.  This may be part of a REG_NO_CONFLICT sequence.  */
 945       || (rtx_equal_p (src, dest) && find_reg_note (insn, REG_EQUAL, NULL_RTX))
 946       /* Can't merge a function call.  */
 947       || GET_CODE (src) == CALL
 948       /* Don't eliminate a function call argument.  */
 949       || (GET_CODE (i3) == CALL_INSN
 950           && (find_reg_fusage (i3, USE, dest)
 951               || (GET_CODE (dest) == REG
 952                   && REGNO (dest) < FIRST_PSEUDO_REGISTER
 953                   && global_regs[REGNO (dest)])))
 954       /* Don't substitute into an incremented register.  */
 955       || FIND_REG_INC_NOTE (i3, dest)
 956       || (succ && FIND_REG_INC_NOTE (succ, dest))
 957 #if 0
 958       /* Don't combine the end of a libcall into anything.  */
 959       /* ??? This gives worse code, and appears to be unnecessary, since no
 960          pass after flow uses REG_LIBCALL/REG_RETVAL notes.  Local-alloc does
 961          use REG_RETVAL notes for noconflict blocks, but other code here
 962          makes sure that those insns don't disappear.  */
 963       || find_reg_note (insn, REG_RETVAL, NULL_RTX)
 964 #endif
 965       /* Make sure that DEST is not used after SUCC but before I3.  */
 966       || (succ && ! all_adjacent
 967           && reg_used_between_p (dest, succ, i3))
 968       /* Make sure that the value that is to be substituted for the register
 969          does not use any registers whose values alter in between.  However,
 970          If the insns are adjacent, a use can't cross a set even though we
 971          think it might (this can happen for a sequence of insns each setting
 972          the same destination; reg_last_set of that register might point to
 973          a NOTE).  If INSN has a REG_EQUIV note, the register is always
 974          equivalent to the memory so the substitution is valid even if there
 975          are intervening stores.  Also, don't move a volatile asm or
 976          UNSPEC_VOLATILE across any other insns.  */
 977       || (! all_adjacent
 978           && (((GET_CODE (src) != MEM
 979                 || ! find_reg_note (insn, REG_EQUIV, src))
 980                && use_crosses_set_p (src, INSN_CUID (insn)))
 981               || (GET_CODE (src) == ASM_OPERANDS && MEM_VOLATILE_P (src))
 982               || GET_CODE (src) == UNSPEC_VOLATILE))
 983       /* If there is a REG_NO_CONFLICT note for DEST in I3 or SUCC, we get
 984          better register allocation by not doing the combine.  */
 985       || find_reg_note (i3, REG_NO_CONFLICT, dest)
 986       || (succ && find_reg_note (succ, REG_NO_CONFLICT, dest))
 987       /* Don't combine across a CALL_INSN, because that would possibly
 988          change whether the life span of some REGs crosses calls or not,
 989          and it is a pain to update that information.
 990          Exception: if source is a constant, moving it later can't hurt.
 991          Accept that special case, because it helps -fforce-addr a lot.  */
 992       || (INSN_CUID (insn) < last_call_cuid && ! CONSTANT_P (src)))
 993     return 0;
 994
 995   /* DEST must either be a REG or CC0.  */
 996   if (GET_CODE (dest) == REG)
 997     {
 998       /* If register alignment is being enforced for multi-word items in all
 999          cases except for parameters, it is possible to have a register copy
1000          insn referencing a hard register that is not allowed to contain the
1001          mode being copied and which would not be valid as an operand of most
1002          insns.  Eliminate this problem by not combining with such an insn.
1003
1004          Also, on some machines we don't want to extend the life of a hard
1005          register.
1006
1007          This is the same test done in can_combine except that we don't test
1008          if SRC is a CALL operation to permit a hard register with
1009          SMALL_REGISTER_CLASSES, and that we have to take all_adjacent
1010          into account.  */
1011
1012       if (GET_CODE (src) == REG
1013           && ((REGNO (dest) < FIRST_PSEUDO_REGISTER
1014                && ! HARD_REGNO_MODE_OK (REGNO (dest), GET_MODE (dest)))
1015               /* Don't extend the life of a hard register unless it is
1016                  user variable (if we have few registers) or it can't
1017                  fit into the desired register (meaning something special
1018                  is going on).
1019                  Also avoid substituting a return register into I3, because
1020                  reload can't handle a conflict with constraints of other
1021                  inputs.  */
1022               || (REGNO (src) < FIRST_PSEUDO_REGISTER
1023                   && (! HARD_REGNO_MODE_OK (REGNO (src), GET_MODE (src))
1024                       || (SMALL_REGISTER_CLASSES
1025                           && ((! all_adjacent && ! REG_USERVAR_P (src))
1026                               || (FUNCTION_VALUE_REGNO_P (REGNO (src))
1027                                   && ! REG_USERVAR_P (src))))))))
1028         return 0;
1029     }
1030   else if (GET_CODE (dest) != CC0)
1031     return 0;
1032
1033   /* Don't substitute for a register intended as a clobberable operand.
1034      Similarly, don't substitute an expression containing a register that
1035      will be clobbered in I3.  */
1036   if (GET_CODE (PATTERN (i3)) == PARALLEL)
1037     for (i = XVECLEN (PATTERN (i3), 0) - 1; i >= 0; i--)
1038       if (GET_CODE (XVECEXP (PATTERN (i3), 0, i)) == CLOBBER
1039           && (reg_overlap_mentioned_p (XEXP (XVECEXP (PATTERN (i3), 0, i), 0),
1040                                        src)
1041               || rtx_equal_p (XEXP (XVECEXP (PATTERN (i3), 0, i), 0), dest)))
1042         return 0;
1043
1044   /* If INSN contains anything volatile, or is an `asm' (whether volatile
1045      or not), reject, unless nothing volatile comes between it and I3 */
1046
1047   if (GET_CODE (src) == ASM_OPERANDS || volatile_refs_p (src))
1048     {
1049       /* Make sure succ doesn't contain a volatile reference.  */
1050       if (succ != 0 && volatile_refs_p (PATTERN (succ)))
1051         return 0;
1052
1053       for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p))
1054         if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
1055           && p != succ && volatile_refs_p (PATTERN (p)))
1056         return 0;
1057     }
1058
1059   /* If INSN is an asm, and DEST is a hard register, reject, since it has
1060      to be an explicit register variable, and was chosen for a reason.  */
1061
1062   if (GET_CODE (src) == ASM_OPERANDS
1063       && GET_CODE (dest) == REG && REGNO (dest) < FIRST_PSEUDO_REGISTER)
1064     return 0;
1065
1066   /* If there are any volatile insns between INSN and I3, reject, because
1067      they might affect machine state.  */
1068
1069   for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p))
1070     if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
1071         && p != succ && volatile_insn_p (PATTERN (p)))
1072       return 0;
1073
1074   /* If INSN or I2 contains an autoincrement or autodecrement,
1075      make sure that register is not used between there and I3,
1076      and not already used in I3 either.
1077      Also insist that I3 not be a jump; if it were one
1078      and the incremented register were spilled, we would lose.  */
1079
1080 #ifdef AUTO_INC_DEC
1081   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1082     if (REG_NOTE_KIND (link) == REG_INC
1083         && (GET_CODE (i3) == JUMP_INSN
1084             || reg_used_between_p (XEXP (link, 0), insn, i3)
1085             || reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i3))))
1086       return 0;
1087 #endif
1088
1089 #ifdef HAVE_cc0
1090   /* Don't combine an insn that follows a CC0-setting insn.
1091      An insn that uses CC0 must not be separated from the one that sets it.
1092      We do, however, allow I2 to follow a CC0-setting insn if that insn
1093      is passed as I1; in that case it will be deleted also.
1094      We also allow combining in this case if all the insns are adjacent
1095      because that would leave the two CC0 insns adjacent as well.
1096      It would be more logical to test whether CC0 occurs inside I1 or I2,
1097      but that would be much slower, and this ought to be equivalent.  */
1098
1099   p = prev_nonnote_insn (insn);
1100   if (p && p != pred && GET_CODE (p) == INSN && sets_cc0_p (PATTERN (p))
1101       && ! all_adjacent)
1102     return 0;
1103 #endif
1104
1105   /* If we get here, we have passed all the tests and the combination is
1106      to be allowed.  */
1107
1108   *pdest = dest;
1109   *psrc = src;
1110
1111   return 1;
1112 }
1113 \f
1114 /* Check if PAT is an insn - or a part of it - used to set up an
1115    argument for a function in a hard register.  */
1116
1117 static int
1118 sets_function_arg_p (pat)
1119      rtx pat;
1120 {
1121   int i;
1122   rtx inner_dest;
1123
1124   switch (GET_CODE (pat))
1125     {
1126     case INSN:
1127       return sets_function_arg_p (PATTERN (pat));
1128
1129     case PARALLEL:
1130       for (i = XVECLEN (pat, 0); --i >= 0;)
1131         if (sets_function_arg_p (XVECEXP (pat, 0, i)))
1132           return 1;
1133
1134       break;
1135
1136     case SET:
1137       inner_dest = SET_DEST (pat);
1138       while (GET_CODE (inner_dest) == STRICT_LOW_PART
1139              || GET_CODE (inner_dest) == SUBREG
1140              || GET_CODE (inner_dest) == ZERO_EXTRACT)
1141         inner_dest = XEXP (inner_dest, 0);
1142
1143       return (GET_CODE (inner_dest) == REG
1144               && REGNO (inner_dest) < FIRST_PSEUDO_REGISTER
1145               && FUNCTION_ARG_REGNO_P (REGNO (inner_dest)));
1146
1147     default:
1148       break;
1149     }
1150
1151   return 0;
1152 }
1153
1154 /* LOC is the location within I3 that contains its pattern or the component
1155    of a PARALLEL of the pattern.  We validate that it is valid for combining.
1156
1157    One problem is if I3 modifies its output, as opposed to replacing it
1158    entirely, we can't allow the output to contain I2DEST or I1DEST as doing
1159    so would produce an insn that is not equivalent to the original insns.
1160
1161    Consider:
1162
1163          (set (reg:DI 101) (reg:DI 100))
1164          (set (subreg:SI (reg:DI 101) 0) <foo>)
1165
1166    This is NOT equivalent to:
1167
1168          (parallel [(set (subreg:SI (reg:DI 100) 0) <foo>)
1169                     (set (reg:DI 101) (reg:DI 100))])
1170
1171    Not only does this modify 100 (in which case it might still be valid
1172    if 100 were dead in I2), it sets 101 to the ORIGINAL value of 100.
1173
1174    We can also run into a problem if I2 sets a register that I1
1175    uses and I1 gets directly substituted into I3 (not via I2).  In that
1176    case, we would be getting the wrong value of I2DEST into I3, so we
1177    must reject the combination.  This case occurs when I2 and I1 both
1178    feed into I3, rather than when I1 feeds into I2, which feeds into I3.
1179    If I1_NOT_IN_SRC is non-zero, it means that finding I1 in the source
1180    of a SET must prevent combination from occurring.
1181
1182    On machines where SMALL_REGISTER_CLASSES is non-zero, we don't combine
1183    if the destination of a SET is a hard register that isn't a user
1184    variable.
1185
1186    Before doing the above check, we first try to expand a field assignment
1187    into a set of logical operations.
1188
1189    If PI3_DEST_KILLED is non-zero, it is a pointer to a location in which
1190    we place a register that is both set and used within I3.  If more than one
1191    such register is detected, we fail.
1192
1193    Return 1 if the combination is valid, zero otherwise.  */
1194
1195 static int
1196 combinable_i3pat (i3, loc, i2dest, i1dest, i1_not_in_src, pi3dest_killed)
1197      rtx i3;
1198      rtx *loc;
1199      rtx i2dest;
1200      rtx i1dest;
1201      int i1_not_in_src;
1202      rtx *pi3dest_killed;
1203 {
1204   rtx x = *loc;
1205
1206   if (GET_CODE (x) == SET)
1207     {
1208       rtx set = expand_field_assignment (x);
1209       rtx dest = SET_DEST (set);
1210       rtx src = SET_SRC (set);
1211       rtx inner_dest = dest;
1212
1213 #if 0
1214       rtx inner_src = src;
1215 #endif
1216
1217       SUBST (*loc, set);
1218
1219       while (GET_CODE (inner_dest) == STRICT_LOW_PART
1220              || GET_CODE (inner_dest) == SUBREG
1221              || GET_CODE (inner_dest) == ZERO_EXTRACT)
1222         inner_dest = XEXP (inner_dest, 0);
1223
1224   /* We probably don't need this any more now that LIMIT_RELOAD_CLASS
1225      was added.  */
1226 #if 0
1227       while (GET_CODE (inner_src) == STRICT_LOW_PART
1228              || GET_CODE (inner_src) == SUBREG
1229              || GET_CODE (inner_src) == ZERO_EXTRACT)
1230         inner_src = XEXP (inner_src, 0);
1231
1232       /* If it is better that two different modes keep two different pseudos,
1233          avoid combining them.  This avoids producing the following pattern
1234          on a 386:
1235           (set (subreg:SI (reg/v:QI 21) 0)
1236                (lshiftrt:SI (reg/v:SI 20)
1237                    (const_int 24)))
1238          If that were made, reload could not handle the pair of
1239          reg 20/21, since it would try to get any GENERAL_REGS
1240          but some of them don't handle QImode.  */
1241
1242       if (rtx_equal_p (inner_src, i2dest)
1243           && GET_CODE (inner_dest) == REG
1244           && ! MODES_TIEABLE_P (GET_MODE (i2dest), GET_MODE (inner_dest)))
1245         return 0;
1246 #endif
1247
1248       /* Check for the case where I3 modifies its output, as
1249          discussed above.  */
1250       if ((inner_dest != dest
1251            && (reg_overlap_mentioned_p (i2dest, inner_dest)
1252                || (i1dest && reg_overlap_mentioned_p (i1dest, inner_dest))))
1253
1254           /* This is the same test done in can_combine_p except that we
1255              allow a hard register with SMALL_REGISTER_CLASSES if SRC is a
1256              CALL operation. Moreover, we can't test all_adjacent; we don't
1257              have to, since this instruction will stay in place, thus we are
1258              not considering increasing the lifetime of INNER_DEST.
1259
1260              Also, if this insn sets a function argument, combining it with
1261              something that might need a spill could clobber a previous
1262              function argument; the all_adjacent test in can_combine_p also
1263              checks this; here, we do a more specific test for this case.  */
1264
1265           || (GET_CODE (inner_dest) == REG
1266               && REGNO (inner_dest) < FIRST_PSEUDO_REGISTER
1267               && (! HARD_REGNO_MODE_OK (REGNO (inner_dest),
1268                                         GET_MODE (inner_dest))
1269                  || (SMALL_REGISTER_CLASSES && GET_CODE (src) != CALL
1270                      && ! REG_USERVAR_P (inner_dest)
1271                      && (FUNCTION_VALUE_REGNO_P (REGNO (inner_dest))
1272                          || (FUNCTION_ARG_REGNO_P (REGNO (inner_dest))
1273                              && i3 != 0
1274                              && sets_function_arg_p (prev_nonnote_insn (i3)))))))
1275           || (i1_not_in_src && reg_overlap_mentioned_p (i1dest, src)))
1276         return 0;
1277
1278       /* If DEST is used in I3, it is being killed in this insn,
1279          so record that for later.
1280          Never add REG_DEAD notes for the FRAME_POINTER_REGNUM or the
1281          STACK_POINTER_REGNUM, since these are always considered to be
1282          live.  Similarly for ARG_POINTER_REGNUM if it is fixed.  */
1283       if (pi3dest_killed && GET_CODE (dest) == REG
1284           && reg_referenced_p (dest, PATTERN (i3))
1285           && REGNO (dest) != FRAME_POINTER_REGNUM
1286 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1287           && REGNO (dest) != HARD_FRAME_POINTER_REGNUM
1288 #endif
1289 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
1290           && (REGNO (dest) != ARG_POINTER_REGNUM
1291               || ! fixed_regs [REGNO (dest)])
1292 #endif
1293           && REGNO (dest) != STACK_POINTER_REGNUM)
1294         {
1295           if (*pi3dest_killed)
1296             return 0;
1297
1298           *pi3dest_killed = dest;
1299         }
1300     }
1301
1302   else if (GET_CODE (x) == PARALLEL)
1303     {
1304       int i;
1305
1306       for (i = 0; i < XVECLEN (x, 0); i++)
1307         if (! combinable_i3pat (i3, &XVECEXP (x, 0, i), i2dest, i1dest,
1308                                 i1_not_in_src, pi3dest_killed))
1309           return 0;
1310     }
1311
1312   return 1;
1313 }
1314 \f
1315 /* Try to combine the insns I1 and I2 into I3.
1316    Here I1 and I2 appear earlier than I3.
1317    I1 can be zero; then we combine just I2 into I3.
1318
1319    It we are combining three insns and the resulting insn is not recognized,
1320    try splitting it into two insns.  If that happens, I2 and I3 are retained
1321    and I1 is pseudo-deleted by turning it into a NOTE.  Otherwise, I1 and I2
1322    are pseudo-deleted.
1323
1324    Return 0 if the combination does not work.  Then nothing is changed.
1325    If we did the combination, return the insn at which combine should
1326    resume scanning.  */
1327
1328 static rtx
1329 try_combine (i3, i2, i1)
1330      register rtx i3, i2, i1;
1331 {
1332   /* New patterns for I3 and I3, respectively.  */
1333   rtx newpat, newi2pat = 0;
1334   /* Indicates need to preserve SET in I1 or I2 in I3 if it is not dead.  */
1335   int added_sets_1, added_sets_2;
1336   /* Total number of SETs to put into I3.  */
1337   int total_sets;
1338   /* Nonzero is I2's body now appears in I3.  */
1339   int i2_is_used;
1340   /* INSN_CODEs for new I3, new I2, and user of condition code.  */
1341   int insn_code_number, i2_code_number, other_code_number;
1342   /* Contains I3 if the destination of I3 is used in its source, which means
1343      that the old life of I3 is being killed.  If that usage is placed into
1344      I2 and not in I3, a REG_DEAD note must be made.  */
1345   rtx i3dest_killed = 0;
1346   /* SET_DEST and SET_SRC of I2 and I1.  */
1347   rtx i2dest, i2src, i1dest = 0, i1src = 0;
1348   /* PATTERN (I2), or a copy of it in certain cases.  */
1349   rtx i2pat;
1350   /* Indicates if I2DEST or I1DEST is in I2SRC or I1_SRC.  */
1351   int i2dest_in_i2src = 0, i1dest_in_i1src = 0, i2dest_in_i1src = 0;
1352   int i1_feeds_i3 = 0;
1353   /* Notes that must be added to REG_NOTES in I3 and I2.  */
1354   rtx new_i3_notes, new_i2_notes;
1355   /* Notes that we substituted I3 into I2 instead of the normal case.  */
1356   int i3_subst_into_i2 = 0;
1357   /* Notes that I1, I2 or I3 is a MULT operation.  */
1358   int have_mult = 0;
1359
1360   int maxreg;
1361   rtx temp;
1362   register rtx link;
1363   int i;
1364
1365   /* If any of I1, I2, and I3 isn't really an insn, we can't do anything.
1366      This can occur when flow deletes an insn that it has merged into an
1367      auto-increment address.  We also can't do anything if I3 has a
1368      REG_LIBCALL note since we don't want to disrupt the contiguity of a
1369      libcall.  */
1370
1371   if (GET_RTX_CLASS (GET_CODE (i3)) != 'i'
1372       || GET_RTX_CLASS (GET_CODE (i2)) != 'i'
1373       || (i1 && GET_RTX_CLASS (GET_CODE (i1)) != 'i')
1374 #if 0
1375       /* ??? This gives worse code, and appears to be unnecessary, since no
1376          pass after flow uses REG_LIBCALL/REG_RETVAL notes.  */
1377       || find_reg_note (i3, REG_LIBCALL, NULL_RTX)
1378 #endif
1379 )
1380     return 0;
1381
1382   combine_attempts++;
1383
1384   undobuf.undos = undobuf.previous_undos = 0;
1385   undobuf.other_insn = 0;
1386
1387   /* Save the current high-water-mark so we can free storage if we didn't
1388      accept this combination.  */
1389   undobuf.storage = (char *) oballoc (0);
1390
1391   /* Reset the hard register usage information.  */
1392   CLEAR_HARD_REG_SET (newpat_used_regs);
1393
1394   /* If I1 and I2 both feed I3, they can be in any order.  To simplify the
1395      code below, set I1 to be the earlier of the two insns.  */
1396   if (i1 && INSN_CUID (i1) > INSN_CUID (i2))
1397     temp = i1, i1 = i2, i2 = temp;
1398
1399   added_links_insn = 0;
1400
1401   /* First check for one important special-case that the code below will
1402      not handle.  Namely, the case where I1 is zero, I2 has multiple sets,
1403      and I3 is a SET whose SET_SRC is a SET_DEST in I2.  In that case,
1404      we may be able to replace that destination with the destination of I3.
1405      This occurs in the common code where we compute both a quotient and
1406      remainder into a structure, in which case we want to do the computation
1407      directly into the structure to avoid register-register copies.
1408
1409      We make very conservative checks below and only try to handle the
1410      most common cases of this.  For example, we only handle the case
1411      where I2 and I3 are adjacent to avoid making difficult register
1412      usage tests.  */
1413
1414   if (i1 == 0 && GET_CODE (i3) == INSN && GET_CODE (PATTERN (i3)) == SET
1415       && GET_CODE (SET_SRC (PATTERN (i3))) == REG
1416       && REGNO (SET_SRC (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
1417       && (! SMALL_REGISTER_CLASSES
1418           || (GET_CODE (SET_DEST (PATTERN (i3))) != REG
1419               || REGNO (SET_DEST (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
1420               || REG_USERVAR_P (SET_DEST (PATTERN (i3)))))
1421       && find_reg_note (i3, REG_DEAD, SET_SRC (PATTERN (i3)))
1422       && GET_CODE (PATTERN (i2)) == PARALLEL
1423       && ! side_effects_p (SET_DEST (PATTERN (i3)))
1424       /* If the dest of I3 is a ZERO_EXTRACT or STRICT_LOW_PART, the code
1425          below would need to check what is inside (and reg_overlap_mentioned_p
1426          doesn't support those codes anyway).  Don't allow those destinations;
1427          the resulting insn isn't likely to be recognized anyway.  */
1428       && GET_CODE (SET_DEST (PATTERN (i3))) != ZERO_EXTRACT
1429       && GET_CODE (SET_DEST (PATTERN (i3))) != STRICT_LOW_PART
1430       && ! reg_overlap_mentioned_p (SET_SRC (PATTERN (i3)),
1431                                     SET_DEST (PATTERN (i3)))
1432       && next_real_insn (i2) == i3)
1433     {
1434       rtx p2 = PATTERN (i2);
1435
1436       /* Make sure that the destination of I3,
1437          which we are going to substitute into one output of I2,
1438          is not used within another output of I2.  We must avoid making this:
1439          (parallel [(set (mem (reg 69)) ...)
1440                     (set (reg 69) ...)])
1441          which is not well-defined as to order of actions.
1442          (Besides, reload can't handle output reloads for this.)
1443
1444          The problem can also happen if the dest of I3 is a memory ref,
1445          if another dest in I2 is an indirect memory ref.  */
1446       for (i = 0; i < XVECLEN (p2, 0); i++)
1447         if ((GET_CODE (XVECEXP (p2, 0, i)) == SET
1448              || GET_CODE (XVECEXP (p2, 0, i)) == CLOBBER)
1449             && reg_overlap_mentioned_p (SET_DEST (PATTERN (i3)),
1450                                         SET_DEST (XVECEXP (p2, 0, i))))
1451           break;
1452
1453       if (i == XVECLEN (p2, 0))
1454         for (i = 0; i < XVECLEN (p2, 0); i++)
1455           if (SET_DEST (XVECEXP (p2, 0, i)) == SET_SRC (PATTERN (i3)))
1456             {
1457               combine_merges++;
1458
1459               subst_insn = i3;
1460               subst_low_cuid = INSN_CUID (i2);
1461
1462               added_sets_2 = added_sets_1 = 0;
1463               i2dest = SET_SRC (PATTERN (i3));
1464
1465               /* Replace the dest in I2 with our dest and make the resulting
1466                  insn the new pattern for I3.  Then skip to where we
1467                  validate the pattern.  Everything was set up above.  */
1468               SUBST (SET_DEST (XVECEXP (p2, 0, i)),
1469                      SET_DEST (PATTERN (i3)));
1470
1471               newpat = p2;
1472               i3_subst_into_i2 = 1;
1473               goto validate_replacement;
1474             }
1475     }
1476
1477 #ifndef HAVE_cc0
1478   /* If we have no I1 and I2 looks like:
1479         (parallel [(set (reg:CC X) (compare:CC OP (const_int 0)))
1480                    (set Y OP)])
1481      make up a dummy I1 that is
1482         (set Y OP)
1483      and change I2 to be
1484         (set (reg:CC X) (compare:CC Y (const_int 0)))
1485
1486      (We can ignore any trailing CLOBBERs.)
1487
1488      This undoes a previous combination and allows us to match a branch-and-
1489      decrement insn.  */
1490
1491   if (i1 == 0 && GET_CODE (PATTERN (i2)) == PARALLEL
1492       && XVECLEN (PATTERN (i2), 0) >= 2
1493       && GET_CODE (XVECEXP (PATTERN (i2), 0, 0)) == SET
1494       && (GET_MODE_CLASS (GET_MODE (SET_DEST (XVECEXP (PATTERN (i2), 0, 0))))
1495           == MODE_CC)
1496       && GET_CODE (SET_SRC (XVECEXP (PATTERN (i2), 0, 0))) == COMPARE
1497       && XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 1) == const0_rtx
1498       && GET_CODE (XVECEXP (PATTERN (i2), 0, 1)) == SET
1499       && GET_CODE (SET_DEST (XVECEXP (PATTERN (i2), 0, 1))) == REG
1500       && rtx_equal_p (XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 0),
1501                       SET_SRC (XVECEXP (PATTERN (i2), 0, 1))))
1502     {
1503       for (i =  XVECLEN (PATTERN (i2), 0) - 1; i >= 2; i--)
1504         if (GET_CODE (XVECEXP (PATTERN (i2), 0, i)) != CLOBBER)
1505           break;
1506
1507       if (i == 1)
1508         {
1509           /* We make I1 with the same INSN_UID as I2.  This gives it
1510              the same INSN_CUID for value tracking.  Our fake I1 will
1511              never appear in the insn stream so giving it the same INSN_UID
1512              as I2 will not cause a problem.  */
1513
1514           subst_prev_insn = i1
1515             = gen_rtx_INSN (VOIDmode, INSN_UID (i2), NULL_RTX, i2,
1516                             XVECEXP (PATTERN (i2), 0, 1), -1, NULL_RTX,
1517                             NULL_RTX);
1518
1519           SUBST (PATTERN (i2), XVECEXP (PATTERN (i2), 0, 0));
1520           SUBST (XEXP (SET_SRC (PATTERN (i2)), 0),
1521                  SET_DEST (PATTERN (i1)));
1522         }
1523     }
1524 #endif
1525
1526   /* Verify that I2 and I1 are valid for combining.  */
1527   if (! can_combine_p (i2, i3, i1, NULL_RTX, &i2dest, &i2src)
1528       || (i1 && ! can_combine_p (i1, i3, NULL_RTX, i2, &i1dest, &i1src)))
1529     {
1530       undo_all ();
1531       return 0;
1532     }
1533
1534   /* Record whether I2DEST is used in I2SRC and similarly for the other
1535      cases.  Knowing this will help in register status updating below.  */
1536   i2dest_in_i2src = reg_overlap_mentioned_p (i2dest, i2src);
1537   i1dest_in_i1src = i1 && reg_overlap_mentioned_p (i1dest, i1src);
1538   i2dest_in_i1src = i1 && reg_overlap_mentioned_p (i2dest, i1src);
1539
1540   /* See if I1 directly feeds into I3.  It does if I1DEST is not used
1541      in I2SRC.  */
1542   i1_feeds_i3 = i1 && ! reg_overlap_mentioned_p (i1dest, i2src);
1543
1544   /* Ensure that I3's pattern can be the destination of combines.  */
1545   if (! combinable_i3pat (i3, &PATTERN (i3), i2dest, i1dest,
1546                           i1 && i2dest_in_i1src && i1_feeds_i3,
1547                           &i3dest_killed))
1548     {
1549       undo_all ();
1550       return 0;
1551     }
1552
1553   /* See if any of the insns is a MULT operation.  Unless one is, we will
1554      reject a combination that is, since it must be slower.  Be conservative
1555      here.  */
1556   if (GET_CODE (i2src) == MULT
1557       || (i1 != 0 && GET_CODE (i1src) == MULT)
1558       || (GET_CODE (PATTERN (i3)) == SET
1559           && GET_CODE (SET_SRC (PATTERN (i3))) == MULT))
1560     have_mult = 1;
1561
1562   /* If I3 has an inc, then give up if I1 or I2 uses the reg that is inc'd.
1563      We used to do this EXCEPT in one case: I3 has a post-inc in an
1564      output operand.  However, that exception can give rise to insns like
1565         mov r3,(r3)+
1566      which is a famous insn on the PDP-11 where the value of r3 used as the
1567      source was model-dependent.  Avoid this sort of thing.  */
1568
1569 #if 0
1570   if (!(GET_CODE (PATTERN (i3)) == SET
1571         && GET_CODE (SET_SRC (PATTERN (i3))) == REG
1572         && GET_CODE (SET_DEST (PATTERN (i3))) == MEM
1573         && (GET_CODE (XEXP (SET_DEST (PATTERN (i3)), 0)) == POST_INC
1574             || GET_CODE (XEXP (SET_DEST (PATTERN (i3)), 0)) == POST_DEC)))
1575     /* It's not the exception.  */
1576 #endif
1577 #ifdef AUTO_INC_DEC
1578     for (link = REG_NOTES (i3); link; link = XEXP (link, 1))
1579       if (REG_NOTE_KIND (link) == REG_INC
1580           && (reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i2))
1581               || (i1 != 0
1582                   && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i1)))))
1583         {
1584           undo_all ();
1585           return 0;
1586         }
1587 #endif
1588
1589   /* See if the SETs in I1 or I2 need to be kept around in the merged
1590      instruction: whenever the value set there is still needed past I3.
1591      For the SETs in I2, this is easy: we see if I2DEST dies or is set in I3.
1592
1593      For the SET in I1, we have two cases:  If I1 and I2 independently
1594      feed into I3, the set in I1 needs to be kept around if I1DEST dies
1595      or is set in I3.  Otherwise (if I1 feeds I2 which feeds I3), the set
1596      in I1 needs to be kept around unless I1DEST dies or is set in either
1597      I2 or I3.  We can distinguish these cases by seeing if I2SRC mentions
1598      I1DEST.  If so, we know I1 feeds into I2.  */
1599
1600   added_sets_2 = ! dead_or_set_p (i3, i2dest);
1601
1602   added_sets_1
1603     = i1 && ! (i1_feeds_i3 ? dead_or_set_p (i3, i1dest)
1604                : (dead_or_set_p (i3, i1dest) || dead_or_set_p (i2, i1dest)));
1605
1606   /* If the set in I2 needs to be kept around, we must make a copy of
1607      PATTERN (I2), so that when we substitute I1SRC for I1DEST in
1608      PATTERN (I2), we are only substituting for the original I1DEST, not into
1609      an already-substituted copy.  This also prevents making self-referential
1610      rtx.  If I2 is a PARALLEL, we just need the piece that assigns I2SRC to
1611      I2DEST.  */
1612
1613   i2pat = (GET_CODE (PATTERN (i2)) == PARALLEL
1614            ? gen_rtx_SET (VOIDmode, i2dest, i2src)
1615            : PATTERN (i2));
1616
1617   if (added_sets_2)
1618     i2pat = copy_rtx (i2pat);
1619
1620   combine_merges++;
1621
1622   /* Substitute in the latest insn for the regs set by the earlier ones.  */
1623
1624   maxreg = max_reg_num ();
1625
1626   subst_insn = i3;
1627
1628   /* It is possible that the source of I2 or I1 may be performing an
1629      unneeded operation, such as a ZERO_EXTEND of something that is known
1630      to have the high part zero.  Handle that case by letting subst look at
1631      the innermost one of them.
1632
1633      Another way to do this would be to have a function that tries to
1634      simplify a single insn instead of merging two or more insns.  We don't
1635      do this because of the potential of infinite loops and because
1636      of the potential extra memory required.  However, doing it the way
1637      we are is a bit of a kludge and doesn't catch all cases.
1638
1639      But only do this if -fexpensive-optimizations since it slows things down
1640      and doesn't usually win.  */
1641
1642   if (flag_expensive_optimizations)
1643     {
1644       /* Pass pc_rtx so no substitutions are done, just simplifications.
1645          The cases that we are interested in here do not involve the few
1646          cases were is_replaced is checked.  */
1647       if (i1)
1648         {
1649           subst_low_cuid = INSN_CUID (i1);
1650           i1src = subst (i1src, pc_rtx, pc_rtx, 0, 0);
1651         }
1652       else
1653         {
1654           subst_low_cuid = INSN_CUID (i2);
1655           i2src = subst (i2src, pc_rtx, pc_rtx, 0, 0);
1656         }
1657
1658       undobuf.previous_undos = undobuf.undos;
1659     }
1660
1661 #ifndef HAVE_cc0
1662   /* Many machines that don't use CC0 have insns that can both perform an
1663      arithmetic operation and set the condition code.  These operations will
1664      be represented as a PARALLEL with the first element of the vector
1665      being a COMPARE of an arithmetic operation with the constant zero.
1666      The second element of the vector will set some pseudo to the result
1667      of the same arithmetic operation.  If we simplify the COMPARE, we won't
1668      match such a pattern and so will generate an extra insn.   Here we test
1669      for this case, where both the comparison and the operation result are
1670      needed, and make the PARALLEL by just replacing I2DEST in I3SRC with
1671      I2SRC.  Later we will make the PARALLEL that contains I2.  */
1672
1673   if (i1 == 0 && added_sets_2 && GET_CODE (PATTERN (i3)) == SET
1674       && GET_CODE (SET_SRC (PATTERN (i3))) == COMPARE
1675       && XEXP (SET_SRC (PATTERN (i3)), 1) == const0_rtx
1676       && rtx_equal_p (XEXP (SET_SRC (PATTERN (i3)), 0), i2dest))
1677     {
1678 #ifdef EXTRA_CC_MODES
1679       rtx *cc_use;
1680       enum machine_mode compare_mode;
1681 #endif
1682
1683       newpat = PATTERN (i3);
1684       SUBST (XEXP (SET_SRC (newpat), 0), i2src);
1685
1686       i2_is_used = 1;
1687
1688 #ifdef EXTRA_CC_MODES
1689       /* See if a COMPARE with the operand we substituted in should be done
1690          with the mode that is currently being used.  If not, do the same
1691          processing we do in `subst' for a SET; namely, if the destination
1692          is used only once, try to replace it with a register of the proper
1693          mode and also replace the COMPARE.  */
1694       if (undobuf.other_insn == 0
1695           && (cc_use = find_single_use (SET_DEST (newpat), i3,
1696                                         &undobuf.other_insn))
1697           && ((compare_mode = SELECT_CC_MODE (GET_CODE (*cc_use),
1698                                               i2src, const0_rtx))
1699               != GET_MODE (SET_DEST (newpat))))
1700         {
1701           int regno = REGNO (SET_DEST (newpat));
1702           rtx new_dest = gen_rtx_REG (compare_mode, regno);
1703
1704           if (regno < FIRST_PSEUDO_REGISTER
1705               || (REG_N_SETS (regno) == 1 && ! added_sets_2
1706                   && ! REG_USERVAR_P (SET_DEST (newpat))))
1707             {
1708               if (regno >= FIRST_PSEUDO_REGISTER)
1709                 SUBST (regno_reg_rtx[regno], new_dest);
1710
1711               SUBST (SET_DEST (newpat), new_dest);
1712               SUBST (XEXP (*cc_use, 0), new_dest);
1713               SUBST (SET_SRC (newpat),
1714                      gen_rtx_combine (COMPARE, compare_mode,
1715                                       i2src, const0_rtx));
1716             }
1717           else
1718             undobuf.other_insn = 0;
1719         }
1720 #endif
1721     }
1722   else
1723 #endif
1724     {
1725       n_occurrences = 0;                /* `subst' counts here */
1726
1727       /* If I1 feeds into I2 (not into I3) and I1DEST is in I1SRC, we
1728          need to make a unique copy of I2SRC each time we substitute it
1729          to avoid self-referential rtl.  */
1730
1731       subst_low_cuid = INSN_CUID (i2);
1732       newpat = subst (PATTERN (i3), i2dest, i2src, 0,
1733                       ! i1_feeds_i3 && i1dest_in_i1src);
1734       undobuf.previous_undos = undobuf.undos;
1735
1736       /* Record whether i2's body now appears within i3's body.  */
1737       i2_is_used = n_occurrences;
1738     }
1739
1740   /* If we already got a failure, don't try to do more.  Otherwise,
1741      try to substitute in I1 if we have it.  */
1742
1743   if (i1 && GET_CODE (newpat) != CLOBBER)
1744     {
1745       /* Before we can do this substitution, we must redo the test done
1746          above (see detailed comments there) that ensures  that I1DEST
1747          isn't mentioned in any SETs in NEWPAT that are field assignments.  */
1748
1749       if (! combinable_i3pat (NULL_RTX, &newpat, i1dest, NULL_RTX,
1750                               0, NULL_PTR))
1751         {
1752           undo_all ();
1753           return 0;
1754         }
1755
1756       n_occurrences = 0;
1757       subst_low_cuid = INSN_CUID (i1);
1758       newpat = subst (newpat, i1dest, i1src, 0, 0);
1759       undobuf.previous_undos = undobuf.undos;
1760     }
1761
1762   /* Fail if an autoincrement side-effect has been duplicated.  Be careful
1763      to count all the ways that I2SRC and I1SRC can be used.  */
1764   if ((FIND_REG_INC_NOTE (i2, NULL_RTX) != 0
1765        && i2_is_used + added_sets_2 > 1)
1766       || (i1 != 0 && FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
1767           && (n_occurrences + added_sets_1 + (added_sets_2 && ! i1_feeds_i3)
1768               > 1))
1769       /* Fail if we tried to make a new register (we used to abort, but there's
1770          really no reason to).  */
1771       || max_reg_num () != maxreg
1772       /* Fail if we couldn't do something and have a CLOBBER.  */
1773       || GET_CODE (newpat) == CLOBBER
1774       /* Fail if this new pattern is a MULT and we didn't have one before
1775          at the outer level.  */
1776       || (GET_CODE (newpat) == SET && GET_CODE (SET_SRC (newpat)) == MULT
1777           && ! have_mult))
1778     {
1779       undo_all ();
1780       return 0;
1781     }
1782
1783   /* If the actions of the earlier insns must be kept
1784      in addition to substituting them into the latest one,
1785      we must make a new PARALLEL for the latest insn
1786      to hold additional the SETs.  */
1787
1788   if (added_sets_1 || added_sets_2)
1789     {
1790       combine_extras++;
1791
1792       if (GET_CODE (newpat) == PARALLEL)
1793         {
1794           rtvec old = XVEC (newpat, 0);
1795           total_sets = XVECLEN (newpat, 0) + added_sets_1 + added_sets_2;
1796           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
1797           bcopy ((char *) &old->elem[0], (char *) XVEC (newpat, 0)->elem,
1798                  sizeof (old->elem[0]) * old->num_elem);
1799         }
1800       else
1801         {
1802           rtx old = newpat;
1803           total_sets = 1 + added_sets_1 + added_sets_2;
1804           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
1805           XVECEXP (newpat, 0, 0) = old;
1806         }
1807
1808      if (added_sets_1)
1809        XVECEXP (newpat, 0, --total_sets)
1810          = (GET_CODE (PATTERN (i1)) == PARALLEL
1811             ? gen_rtx_SET (VOIDmode, i1dest, i1src) : PATTERN (i1));
1812
1813      if (added_sets_2)
1814         {
1815           /* If there is no I1, use I2's body as is.  We used to also not do
1816              the subst call below if I2 was substituted into I3,
1817              but that could lose a simplification.  */
1818           if (i1 == 0)
1819             XVECEXP (newpat, 0, --total_sets) = i2pat;
1820           else
1821             /* See comment where i2pat is assigned.  */
1822             XVECEXP (newpat, 0, --total_sets)
1823               = subst (i2pat, i1dest, i1src, 0, 0);
1824         }
1825     }
1826
1827   /* We come here when we are replacing a destination in I2 with the
1828      destination of I3.  */
1829  validate_replacement:
1830
1831   /* Note which hard regs this insn has as inputs.  */
1832   mark_used_regs_combine (newpat);
1833
1834   /* Is the result of combination a valid instruction?  */
1835   insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
1836
1837   /* If the result isn't valid, see if it is a PARALLEL of two SETs where
1838      the second SET's destination is a register that is unused.  In that case,
1839      we just need the first SET.   This can occur when simplifying a divmod
1840      insn.  We *must* test for this case here because the code below that
1841      splits two independent SETs doesn't handle this case correctly when it
1842      updates the register status.  Also check the case where the first
1843      SET's destination is unused.  That would not cause incorrect code, but
1844      does cause an unneeded insn to remain.  */
1845
1846   if (insn_code_number < 0 && GET_CODE (newpat) == PARALLEL
1847       && XVECLEN (newpat, 0) == 2
1848       && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
1849       && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
1850       && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) == REG
1851       && find_reg_note (i3, REG_UNUSED, SET_DEST (XVECEXP (newpat, 0, 1)))
1852       && ! side_effects_p (SET_SRC (XVECEXP (newpat, 0, 1)))
1853       && asm_noperands (newpat) < 0)
1854     {
1855       newpat = XVECEXP (newpat, 0, 0);
1856       insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
1857     }
1858
1859   else if (insn_code_number < 0 && GET_CODE (newpat) == PARALLEL
1860            && XVECLEN (newpat, 0) == 2
1861            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
1862            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
1863            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) == REG
1864            && find_reg_note (i3, REG_UNUSED, SET_DEST (XVECEXP (newpat, 0, 0)))
1865            && ! side_effects_p (SET_SRC (XVECEXP (newpat, 0, 0)))
1866            && asm_noperands (newpat) < 0)
1867     {
1868       newpat = XVECEXP (newpat, 0, 1);
1869       insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
1870     }
1871
1872   /* If we were combining three insns and the result is a simple SET
1873      with no ASM_OPERANDS that wasn't recognized, try to split it into two
1874      insns.  There are two ways to do this.  It can be split using a
1875      machine-specific method (like when you have an addition of a large
1876      constant) or by combine in the function find_split_point.  */
1877
1878   if (i1 && insn_code_number < 0 && GET_CODE (newpat) == SET
1879       && asm_noperands (newpat) < 0)
1880     {
1881       rtx m_split, *split;
1882       rtx ni2dest = i2dest;
1883
1884       /* See if the MD file can split NEWPAT.  If it can't, see if letting it
1885          use I2DEST as a scratch register will help.  In the latter case,
1886          convert I2DEST to the mode of the source of NEWPAT if we can.  */
1887
1888       m_split = split_insns (newpat, i3);
1889
1890       /* We can only use I2DEST as a scratch reg if it doesn't overlap any
1891          inputs of NEWPAT.  */
1892
1893       /* ??? If I2DEST is not safe, and I1DEST exists, then it would be
1894          possible to try that as a scratch reg.  This would require adding
1895          more code to make it work though.  */
1896
1897       if (m_split == 0 && ! reg_overlap_mentioned_p (ni2dest, newpat))
1898         {
1899           /* If I2DEST is a hard register or the only use of a pseudo,
1900              we can change its mode.  */
1901           if (GET_MODE (SET_DEST (newpat)) != GET_MODE (i2dest)
1902               && GET_MODE (SET_DEST (newpat)) != VOIDmode
1903               && GET_CODE (i2dest) == REG
1904               && (REGNO (i2dest) < FIRST_PSEUDO_REGISTER
1905                   || (REG_N_SETS (REGNO (i2dest)) == 1 && ! added_sets_2
1906                       && ! REG_USERVAR_P (i2dest))))
1907             ni2dest = gen_rtx_REG (GET_MODE (SET_DEST (newpat)),
1908                                REGNO (i2dest));
1909
1910           m_split = split_insns
1911             (gen_rtx_PARALLEL (VOIDmode,
1912                                gen_rtvec (2, newpat,
1913                                           gen_rtx_CLOBBER (VOIDmode,
1914                                                            ni2dest))),
1915              i3);
1916         }
1917
1918       if (m_split && GET_CODE (m_split) == SEQUENCE
1919           && XVECLEN (m_split, 0) == 2
1920           && (next_real_insn (i2) == i3
1921               || ! use_crosses_set_p (PATTERN (XVECEXP (m_split, 0, 0)),
1922                                       INSN_CUID (i2))))
1923         {
1924           rtx i2set, i3set;
1925           rtx newi3pat = PATTERN (XVECEXP (m_split, 0, 1));
1926           newi2pat = PATTERN (XVECEXP (m_split, 0, 0));
1927
1928           i3set = single_set (XVECEXP (m_split, 0, 1));
1929           i2set = single_set (XVECEXP (m_split, 0, 0));
1930
1931           /* In case we changed the mode of I2DEST, replace it in the
1932              pseudo-register table here.  We can't do it above in case this
1933              code doesn't get executed and we do a split the other way.  */
1934
1935           if (REGNO (i2dest) >= FIRST_PSEUDO_REGISTER)
1936             SUBST (regno_reg_rtx[REGNO (i2dest)], ni2dest);
1937
1938           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
1939
1940           /* If I2 or I3 has multiple SETs, we won't know how to track
1941              register status, so don't use these insns.  If I2's destination
1942              is used between I2 and I3, we also can't use these insns.  */
1943
1944           if (i2_code_number >= 0 && i2set && i3set
1945               && (next_real_insn (i2) == i3
1946                   || ! reg_used_between_p (SET_DEST (i2set), i2, i3)))
1947             insn_code_number = recog_for_combine (&newi3pat, i3,
1948                                                   &new_i3_notes);
1949           if (insn_code_number >= 0)
1950             newpat = newi3pat;
1951
1952           /* It is possible that both insns now set the destination of I3.
1953              If so, we must show an extra use of it.  */
1954
1955           if (insn_code_number >= 0)
1956             {
1957               rtx new_i3_dest = SET_DEST (i3set);
1958               rtx new_i2_dest = SET_DEST (i2set);
1959
1960               while (GET_CODE (new_i3_dest) == ZERO_EXTRACT
1961                      || GET_CODE (new_i3_dest) == STRICT_LOW_PART
1962                      || GET_CODE (new_i3_dest) == SUBREG)
1963                 new_i3_dest = XEXP (new_i3_dest, 0);
1964
1965               while (GET_CODE (new_i2_dest) == ZERO_EXTRACT
1966                      || GET_CODE (new_i2_dest) == STRICT_LOW_PART
1967                      || GET_CODE (new_i2_dest) == SUBREG)
1968                 new_i2_dest = XEXP (new_i2_dest, 0);
1969
1970               if (GET_CODE (new_i3_dest) == REG
1971                   && GET_CODE (new_i2_dest) == REG
1972                   && REGNO (new_i3_dest) == REGNO (new_i2_dest))
1973                 REG_N_SETS (REGNO (new_i2_dest))++;
1974             }
1975         }
1976
1977       /* If we can split it and use I2DEST, go ahead and see if that
1978          helps things be recognized.  Verify that none of the registers
1979          are set between I2 and I3.  */
1980       if (insn_code_number < 0 && (split = find_split_point (&newpat, i3)) != 0
1981 #ifdef HAVE_cc0
1982           && GET_CODE (i2dest) == REG
1983 #endif
1984           /* We need I2DEST in the proper mode.  If it is a hard register
1985              or the only use of a pseudo, we can change its mode.  */
1986           && (GET_MODE (*split) == GET_MODE (i2dest)
1987               || GET_MODE (*split) == VOIDmode
1988               || REGNO (i2dest) < FIRST_PSEUDO_REGISTER
1989               || (REG_N_SETS (REGNO (i2dest)) == 1 && ! added_sets_2
1990                   && ! REG_USERVAR_P (i2dest)))
1991           && (next_real_insn (i2) == i3
1992               || ! use_crosses_set_p (*split, INSN_CUID (i2)))
1993           /* We can't overwrite I2DEST if its value is still used by
1994              NEWPAT.  */
1995           && ! reg_referenced_p (i2dest, newpat))
1996         {
1997           rtx newdest = i2dest;
1998           enum rtx_code split_code = GET_CODE (*split);
1999           enum machine_mode split_mode = GET_MODE (*split);
2000
2001           /* Get NEWDEST as a register in the proper mode.  We have already
2002              validated that we can do this.  */
2003           if (GET_MODE (i2dest) != split_mode && split_mode != VOIDmode)
2004             {
2005               newdest = gen_rtx_REG (split_mode, REGNO (i2dest));
2006
2007               if (REGNO (i2dest) >= FIRST_PSEUDO_REGISTER)
2008                 SUBST (regno_reg_rtx[REGNO (i2dest)], newdest);
2009             }
2010
2011           /* If *SPLIT is a (mult FOO (const_int pow2)), convert it to
2012              an ASHIFT.  This can occur if it was inside a PLUS and hence
2013              appeared to be a memory address.  This is a kludge.  */
2014           if (split_code == MULT
2015               && GET_CODE (XEXP (*split, 1)) == CONST_INT
2016               && (i = exact_log2 (INTVAL (XEXP (*split, 1)))) >= 0)
2017             {
2018               SUBST (*split, gen_rtx_combine (ASHIFT, split_mode,
2019                                               XEXP (*split, 0), GEN_INT (i)));
2020               /* Update split_code because we may not have a multiply
2021                  anymore.  */
2022               split_code = GET_CODE (*split);
2023             }
2024
2025 #ifdef INSN_SCHEDULING
2026           /* If *SPLIT is a paradoxical SUBREG, when we split it, it should
2027              be written as a ZERO_EXTEND.  */
2028           if (split_code == SUBREG && GET_CODE (SUBREG_REG (*split)) == MEM)
2029             SUBST (*split, gen_rtx_combine (ZERO_EXTEND, split_mode,
2030                                             XEXP (*split, 0)));
2031 #endif
2032
2033           newi2pat = gen_rtx_combine (SET, VOIDmode, newdest, *split);
2034           SUBST (*split, newdest);
2035           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2036
2037           /* If the split point was a MULT and we didn't have one before,
2038              don't use one now.  */
2039           if (i2_code_number >= 0 && ! (split_code == MULT && ! have_mult))
2040             insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2041         }
2042     }
2043
2044   /* Check for a case where we loaded from memory in a narrow mode and
2045      then sign extended it, but we need both registers.  In that case,
2046      we have a PARALLEL with both loads from the same memory location.
2047      We can split this into a load from memory followed by a register-register
2048      copy.  This saves at least one insn, more if register allocation can
2049      eliminate the copy.
2050
2051      We cannot do this if the destination of the second assignment is
2052      a register that we have already assumed is zero-extended.  Similarly
2053      for a SUBREG of such a register.  */
2054
2055   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
2056            && GET_CODE (newpat) == PARALLEL
2057            && XVECLEN (newpat, 0) == 2
2058            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
2059            && GET_CODE (SET_SRC (XVECEXP (newpat, 0, 0))) == SIGN_EXTEND
2060            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
2061            && rtx_equal_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2062                            XEXP (SET_SRC (XVECEXP (newpat, 0, 0)), 0))
2063            && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2064                                    INSN_CUID (i2))
2065            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
2066            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
2067            && ! (temp = SET_DEST (XVECEXP (newpat, 0, 1)),
2068                  (GET_CODE (temp) == REG
2069                   && reg_nonzero_bits[REGNO (temp)] != 0
2070                   && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
2071                   && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
2072                   && (reg_nonzero_bits[REGNO (temp)]
2073                       != GET_MODE_MASK (word_mode))))
2074            && ! (GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) == SUBREG
2075                  && (temp = SUBREG_REG (SET_DEST (XVECEXP (newpat, 0, 1))),
2076                      (GET_CODE (temp) == REG
2077                       && reg_nonzero_bits[REGNO (temp)] != 0
2078                       && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
2079                       && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
2080                       && (reg_nonzero_bits[REGNO (temp)]
2081                           != GET_MODE_MASK (word_mode)))))
2082            && ! reg_overlap_mentioned_p (SET_DEST (XVECEXP (newpat, 0, 1)),
2083                                          SET_SRC (XVECEXP (newpat, 0, 1)))
2084            && ! find_reg_note (i3, REG_UNUSED,
2085                                SET_DEST (XVECEXP (newpat, 0, 0))))
2086     {
2087       rtx ni2dest;
2088
2089       newi2pat = XVECEXP (newpat, 0, 0);
2090       ni2dest = SET_DEST (XVECEXP (newpat, 0, 0));
2091       newpat = XVECEXP (newpat, 0, 1);
2092       SUBST (SET_SRC (newpat),
2093              gen_lowpart_for_combine (GET_MODE (SET_SRC (newpat)), ni2dest));
2094       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2095
2096       if (i2_code_number >= 0)
2097         insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2098
2099       if (insn_code_number >= 0)
2100         {
2101           rtx insn;
2102           rtx link;
2103
2104           /* If we will be able to accept this, we have made a change to the
2105              destination of I3.  This can invalidate a LOG_LINKS pointing
2106              to I3.  No other part of combine.c makes such a transformation.
2107
2108              The new I3 will have a destination that was previously the
2109              destination of I1 or I2 and which was used in i2 or I3.  Call
2110              distribute_links to make a LOG_LINK from the next use of
2111              that destination.  */
2112
2113           PATTERN (i3) = newpat;
2114           distribute_links (gen_rtx_INSN_LIST (VOIDmode, i3, NULL_RTX));
2115
2116           /* I3 now uses what used to be its destination and which is
2117              now I2's destination.  That means we need a LOG_LINK from
2118              I3 to I2.  But we used to have one, so we still will.
2119
2120              However, some later insn might be using I2's dest and have
2121              a LOG_LINK pointing at I3.  We must remove this link.
2122              The simplest way to remove the link is to point it at I1,
2123              which we know will be a NOTE.  */
2124
2125           for (insn = NEXT_INSN (i3);
2126                insn && (this_basic_block == n_basic_blocks - 1
2127                         || insn != BLOCK_HEAD (this_basic_block + 1));
2128                insn = NEXT_INSN (insn))
2129             {
2130               if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
2131                   && reg_referenced_p (ni2dest, PATTERN (insn)))
2132                 {
2133                   for (link = LOG_LINKS (insn); link;
2134                        link = XEXP (link, 1))
2135                     if (XEXP (link, 0) == i3)
2136                       XEXP (link, 0) = i1;
2137
2138                   break;
2139                 }
2140             }
2141         }
2142     }
2143
2144   /* Similarly, check for a case where we have a PARALLEL of two independent
2145      SETs but we started with three insns.  In this case, we can do the sets
2146      as two separate insns.  This case occurs when some SET allows two
2147      other insns to combine, but the destination of that SET is still live.  */
2148
2149   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
2150            && GET_CODE (newpat) == PARALLEL
2151            && XVECLEN (newpat, 0) == 2
2152            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
2153            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != ZERO_EXTRACT
2154            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != STRICT_LOW_PART
2155            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
2156            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
2157            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
2158            && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2159                                    INSN_CUID (i2))
2160            /* Don't pass sets with (USE (MEM ...)) dests to the following.  */
2161            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != USE
2162            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != USE
2163            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 1)),
2164                                   XVECEXP (newpat, 0, 0))
2165            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 0)),
2166                                   XVECEXP (newpat, 0, 1)))
2167     {
2168       /* Normally, it doesn't matter which of the two is done first,
2169          but it does if one references cc0.  In that case, it has to
2170          be first.  */
2171 #ifdef HAVE_cc0
2172       if (reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 0)))
2173         {
2174           newi2pat = XVECEXP (newpat, 0, 0);
2175           newpat = XVECEXP (newpat, 0, 1);
2176         }
2177       else
2178 #endif
2179         {
2180           newi2pat = XVECEXP (newpat, 0, 1);
2181           newpat = XVECEXP (newpat, 0, 0);
2182         }
2183
2184       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2185
2186       if (i2_code_number >= 0)
2187         insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2188     }
2189
2190   /* If it still isn't recognized, fail and change things back the way they
2191      were.  */
2192   if ((insn_code_number < 0
2193        /* Is the result a reasonable ASM_OPERANDS?  */
2194        && (! check_asm_operands (newpat) || added_sets_1 || added_sets_2)))
2195     {
2196       undo_all ();
2197       return 0;
2198     }
2199
2200   /* If we had to change another insn, make sure it is valid also.  */
2201   if (undobuf.other_insn)
2202     {
2203       rtx other_pat = PATTERN (undobuf.other_insn);
2204       rtx new_other_notes;
2205       rtx note, next;
2206
2207       CLEAR_HARD_REG_SET (newpat_used_regs);
2208
2209       other_code_number = recog_for_combine (&other_pat, undobuf.other_insn,
2210                                              &new_other_notes);
2211
2212       if (other_code_number < 0 && ! check_asm_operands (other_pat))
2213         {
2214           undo_all ();
2215           return 0;
2216         }
2217
2218       PATTERN (undobuf.other_insn) = other_pat;
2219
2220       /* If any of the notes in OTHER_INSN were REG_UNUSED, ensure that they
2221          are still valid.  Then add any non-duplicate notes added by
2222          recog_for_combine.  */
2223       for (note = REG_NOTES (undobuf.other_insn); note; note = next)
2224         {
2225           next = XEXP (note, 1);
2226
2227           if (REG_NOTE_KIND (note) == REG_UNUSED
2228               && ! reg_set_p (XEXP (note, 0), PATTERN (undobuf.other_insn)))
2229             {
2230               if (GET_CODE (XEXP (note, 0)) == REG)
2231                 REG_N_DEATHS (REGNO (XEXP (note, 0)))--;
2232
2233               remove_note (undobuf.other_insn, note);
2234             }
2235         }
2236
2237       for (note = new_other_notes; note; note = XEXP (note, 1))
2238         if (GET_CODE (XEXP (note, 0)) == REG)
2239           REG_N_DEATHS (REGNO (XEXP (note, 0)))++;
2240
2241       distribute_notes (new_other_notes, undobuf.other_insn,
2242                         undobuf.other_insn, NULL_RTX, NULL_RTX, NULL_RTX);
2243     }
2244
2245   /* We now know that we can do this combination.  Merge the insns and
2246      update the status of registers and LOG_LINKS.  */
2247
2248   {
2249     rtx i3notes, i2notes, i1notes = 0;
2250     rtx i3links, i2links, i1links = 0;
2251     rtx midnotes = 0;
2252     register int regno;
2253     /* Compute which registers we expect to eliminate.  newi2pat may be setting
2254        either i3dest or i2dest, so we must check it.  Also, i1dest may be the
2255        same as i3dest, in which case newi2pat may be setting i1dest.  */
2256     rtx elim_i2 = ((newi2pat && reg_set_p (i2dest, newi2pat))
2257                    || i2dest_in_i2src || i2dest_in_i1src
2258                    ? 0 : i2dest);
2259     rtx elim_i1 = (i1 == 0 || i1dest_in_i1src
2260                    || (newi2pat && reg_set_p (i1dest, newi2pat))
2261                    ? 0 : i1dest);
2262
2263     /* Get the old REG_NOTES and LOG_LINKS from all our insns and
2264        clear them.  */
2265     i3notes = REG_NOTES (i3), i3links = LOG_LINKS (i3);
2266     i2notes = REG_NOTES (i2), i2links = LOG_LINKS (i2);
2267     if (i1)
2268       i1notes = REG_NOTES (i1), i1links = LOG_LINKS (i1);
2269
2270     /* Ensure that we do not have something that should not be shared but
2271        occurs multiple times in the new insns.  Check this by first
2272        resetting all the `used' flags and then copying anything is shared.  */
2273
2274     reset_used_flags (i3notes);
2275     reset_used_flags (i2notes);
2276     reset_used_flags (i1notes);
2277     reset_used_flags (newpat);
2278     reset_used_flags (newi2pat);
2279     if (undobuf.other_insn)
2280       reset_used_flags (PATTERN (undobuf.other_insn));
2281
2282     i3notes = copy_rtx_if_shared (i3notes);
2283     i2notes = copy_rtx_if_shared (i2notes);
2284     i1notes = copy_rtx_if_shared (i1notes);
2285     newpat = copy_rtx_if_shared (newpat);
2286     newi2pat = copy_rtx_if_shared (newi2pat);
2287     if (undobuf.other_insn)
2288       reset_used_flags (PATTERN (undobuf.other_insn));
2289
2290     INSN_CODE (i3) = insn_code_number;
2291     PATTERN (i3) = newpat;
2292     if (undobuf.other_insn)
2293       INSN_CODE (undobuf.other_insn) = other_code_number;
2294
2295     /* We had one special case above where I2 had more than one set and
2296        we replaced a destination of one of those sets with the destination
2297        of I3.  In that case, we have to update LOG_LINKS of insns later
2298        in this basic block.  Note that this (expensive) case is rare.
2299
2300        Also, in this case, we must pretend that all REG_NOTEs for I2
2301        actually came from I3, so that REG_UNUSED notes from I2 will be
2302        properly handled.  */
2303
2304     if (i3_subst_into_i2)
2305       {
2306         for (i = 0; i < XVECLEN (PATTERN (i2), 0); i++)
2307           if (GET_CODE (SET_DEST (XVECEXP (PATTERN (i2), 0, i))) == REG
2308               && SET_DEST (XVECEXP (PATTERN (i2), 0, i)) != i2dest
2309               && ! find_reg_note (i2, REG_UNUSED,
2310                                   SET_DEST (XVECEXP (PATTERN (i2), 0, i))))
2311             for (temp = NEXT_INSN (i2);
2312                  temp && (this_basic_block == n_basic_blocks - 1
2313                           || BLOCK_HEAD (this_basic_block) != temp);
2314                  temp = NEXT_INSN (temp))
2315               if (temp != i3 && GET_RTX_CLASS (GET_CODE (temp)) == 'i')
2316                 for (link = LOG_LINKS (temp); link; link = XEXP (link, 1))
2317                   if (XEXP (link, 0) == i2)
2318                     XEXP (link, 0) = i3;
2319
2320         if (i3notes)
2321           {
2322             rtx link = i3notes;
2323             while (XEXP (link, 1))
2324               link = XEXP (link, 1);
2325             XEXP (link, 1) = i2notes;
2326           }
2327         else
2328           i3notes = i2notes;
2329         i2notes = 0;
2330       }
2331
2332     LOG_LINKS (i3) = 0;
2333     REG_NOTES (i3) = 0;
2334     LOG_LINKS (i2) = 0;
2335     REG_NOTES (i2) = 0;
2336
2337     if (newi2pat)
2338       {
2339         INSN_CODE (i2) = i2_code_number;
2340         PATTERN (i2) = newi2pat;
2341       }
2342     else
2343       {
2344         PUT_CODE (i2, NOTE);
2345         NOTE_LINE_NUMBER (i2) = NOTE_INSN_DELETED;
2346         NOTE_SOURCE_FILE (i2) = 0;
2347       }
2348
2349     if (i1)
2350       {
2351         LOG_LINKS (i1) = 0;
2352         REG_NOTES (i1) = 0;
2353         PUT_CODE (i1, NOTE);
2354         NOTE_LINE_NUMBER (i1) = NOTE_INSN_DELETED;
2355         NOTE_SOURCE_FILE (i1) = 0;
2356       }
2357
2358     /* Get death notes for everything that is now used in either I3 or
2359        I2 and used to die in a previous insn.  If we built two new
2360        patterns, move from I1 to I2 then I2 to I3 so that we get the
2361        proper movement on registers that I2 modifies.  */
2362
2363     if (newi2pat)
2364       {
2365         move_deaths (newi2pat, NULL_RTX, INSN_CUID (i1), i2, &midnotes);
2366         move_deaths (newpat, newi2pat, INSN_CUID (i1), i3, &midnotes);
2367       }
2368     else
2369       move_deaths (newpat, NULL_RTX, i1 ? INSN_CUID (i1) : INSN_CUID (i2),
2370                    i3, &midnotes);
2371
2372     /* Distribute all the LOG_LINKS and REG_NOTES from I1, I2, and I3.  */
2373     if (i3notes)
2374       distribute_notes (i3notes, i3, i3, newi2pat ? i2 : NULL_RTX,
2375                         elim_i2, elim_i1);
2376     if (i2notes)
2377       distribute_notes (i2notes, i2, i3, newi2pat ? i2 : NULL_RTX,
2378                         elim_i2, elim_i1);
2379     if (i1notes)
2380       distribute_notes (i1notes, i1, i3, newi2pat ? i2 : NULL_RTX,
2381                         elim_i2, elim_i1);
2382     if (midnotes)
2383       distribute_notes (midnotes, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
2384                         elim_i2, elim_i1);
2385
2386     /* Distribute any notes added to I2 or I3 by recog_for_combine.  We
2387        know these are REG_UNUSED and want them to go to the desired insn,
2388        so we always pass it as i3.  We have not counted the notes in
2389        reg_n_deaths yet, so we need to do so now.  */
2390
2391     if (newi2pat && new_i2_notes)
2392       {
2393         for (temp = new_i2_notes; temp; temp = XEXP (temp, 1))
2394           if (GET_CODE (XEXP (temp, 0)) == REG)
2395             REG_N_DEATHS (REGNO (XEXP (temp, 0)))++;
2396
2397         distribute_notes (new_i2_notes, i2, i2, NULL_RTX, NULL_RTX, NULL_RTX);
2398       }
2399
2400     if (new_i3_notes)
2401       {
2402         for (temp = new_i3_notes; temp; temp = XEXP (temp, 1))
2403           if (GET_CODE (XEXP (temp, 0)) == REG)
2404             REG_N_DEATHS (REGNO (XEXP (temp, 0)))++;
2405
2406         distribute_notes (new_i3_notes, i3, i3, NULL_RTX, NULL_RTX, NULL_RTX);
2407       }
2408
2409     /* If I3DEST was used in I3SRC, it really died in I3.  We may need to
2410        put a REG_DEAD note for it somewhere.  If NEWI2PAT exists and sets
2411        I3DEST, the death must be somewhere before I2, not I3.  If we passed I3
2412        in that case, it might delete I2.  Similarly for I2 and I1.
2413        Show an additional death due to the REG_DEAD note we make here.  If
2414        we discard it in distribute_notes, we will decrement it again.  */
2415
2416     if (i3dest_killed)
2417       {
2418         if (GET_CODE (i3dest_killed) == REG)
2419           REG_N_DEATHS (REGNO (i3dest_killed))++;
2420
2421         if (newi2pat && reg_set_p (i3dest_killed, newi2pat))
2422           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i3dest_killed,
2423                                                NULL_RTX),
2424                             NULL_RTX, i2, NULL_RTX, elim_i2, elim_i1);
2425         else
2426           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i3dest_killed,
2427                                                NULL_RTX),
2428                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
2429                             elim_i2, elim_i1);
2430       }
2431
2432     if (i2dest_in_i2src)
2433       {
2434         if (GET_CODE (i2dest) == REG)
2435           REG_N_DEATHS (REGNO (i2dest))++;
2436
2437         if (newi2pat && reg_set_p (i2dest, newi2pat))
2438           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i2dest, NULL_RTX),
2439                             NULL_RTX, i2, NULL_RTX, NULL_RTX, NULL_RTX);
2440         else
2441           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i2dest, NULL_RTX),
2442                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
2443                             NULL_RTX, NULL_RTX);
2444       }
2445
2446     if (i1dest_in_i1src)
2447       {
2448         if (GET_CODE (i1dest) == REG)
2449           REG_N_DEATHS (REGNO (i1dest))++;
2450
2451         if (newi2pat && reg_set_p (i1dest, newi2pat))
2452           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i1dest, NULL_RTX),
2453                             NULL_RTX, i2, NULL_RTX, NULL_RTX, NULL_RTX);
2454         else
2455           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i1dest, NULL_RTX),
2456                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
2457                             NULL_RTX, NULL_RTX);
2458       }
2459
2460     distribute_links (i3links);
2461     distribute_links (i2links);
2462     distribute_links (i1links);
2463
2464     if (GET_CODE (i2dest) == REG)
2465       {
2466         rtx link;
2467         rtx i2_insn = 0, i2_val = 0, set;
2468
2469         /* The insn that used to set this register doesn't exist, and
2470            this life of the register may not exist either.  See if one of
2471            I3's links points to an insn that sets I2DEST.  If it does,
2472            that is now the last known value for I2DEST. If we don't update
2473            this and I2 set the register to a value that depended on its old
2474            contents, we will get confused.  If this insn is used, thing
2475            will be set correctly in combine_instructions.  */
2476
2477         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
2478           if ((set = single_set (XEXP (link, 0))) != 0
2479               && rtx_equal_p (i2dest, SET_DEST (set)))
2480             i2_insn = XEXP (link, 0), i2_val = SET_SRC (set);
2481
2482         record_value_for_reg (i2dest, i2_insn, i2_val);
2483
2484         /* If the reg formerly set in I2 died only once and that was in I3,
2485            zero its use count so it won't make `reload' do any work.  */
2486         if (! added_sets_2
2487             && (newi2pat == 0 || ! reg_mentioned_p (i2dest, newi2pat))
2488             && ! i2dest_in_i2src)
2489           {
2490             regno = REGNO (i2dest);
2491             REG_N_SETS (regno)--;
2492             if (REG_N_SETS (regno) == 0
2493                 && ! REGNO_REG_SET_P (BASIC_BLOCK (0)->global_live_at_start,
2494                                       regno))
2495               REG_N_REFS (regno) = 0;
2496           }
2497       }
2498
2499     if (i1 && GET_CODE (i1dest) == REG)
2500       {
2501         rtx link;
2502         rtx i1_insn = 0, i1_val = 0, set;
2503
2504         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
2505           if ((set = single_set (XEXP (link, 0))) != 0
2506               && rtx_equal_p (i1dest, SET_DEST (set)))
2507             i1_insn = XEXP (link, 0), i1_val = SET_SRC (set);
2508
2509         record_value_for_reg (i1dest, i1_insn, i1_val);
2510
2511         regno = REGNO (i1dest);
2512         if (! added_sets_1 && ! i1dest_in_i1src)
2513           {
2514             REG_N_SETS (regno)--;
2515             if (REG_N_SETS (regno) == 0
2516                 && ! REGNO_REG_SET_P (BASIC_BLOCK (0)->global_live_at_start,
2517                                       regno))
2518               REG_N_REFS (regno) = 0;
2519           }
2520       }
2521
2522     /* Update reg_nonzero_bits et al for any changes that may have been made
2523        to this insn.  */
2524
2525     note_stores (newpat, set_nonzero_bits_and_sign_copies);
2526     if (newi2pat)
2527       note_stores (newi2pat, set_nonzero_bits_and_sign_copies);
2528
2529     /* If I3 is now an unconditional jump, ensure that it has a
2530        BARRIER following it since it may have initially been a
2531        conditional jump.  It may also be the last nonnote insn.  */
2532
2533     if ((GET_CODE (newpat) == RETURN || simplejump_p (i3))
2534         && ((temp = next_nonnote_insn (i3)) == NULL_RTX
2535             || GET_CODE (temp) != BARRIER))
2536       emit_barrier_after (i3);
2537   }
2538
2539   combine_successes++;
2540
2541   /* Clear this here, so that subsequent get_last_value calls are not
2542      affected.  */
2543   subst_prev_insn = NULL_RTX;
2544
2545   if (added_links_insn
2546       && (newi2pat == 0 || INSN_CUID (added_links_insn) < INSN_CUID (i2))
2547       && INSN_CUID (added_links_insn) < INSN_CUID (i3))
2548     return added_links_insn;
2549   else
2550     return newi2pat ? i2 : i3;
2551 }
2552 \f
2553 /* Undo all the modifications recorded in undobuf.  */
2554
2555 static void
2556 undo_all ()
2557 {
2558   struct undo *undo, *next;
2559
2560   for (undo = undobuf.undos; undo; undo = next)
2561     {
2562       next = undo->next;
2563       if (undo->is_int)
2564         *undo->where.i = undo->old_contents.i;
2565       else
2566         *undo->where.r = undo->old_contents.r;
2567
2568       undo->next = undobuf.frees;
2569       undobuf.frees = undo;
2570     }
2571
2572   obfree (undobuf.storage);
2573   undobuf.undos = undobuf.previous_undos = 0;
2574
2575   /* Clear this here, so that subsequent get_last_value calls are not
2576      affected.  */
2577   subst_prev_insn = NULL_RTX;
2578 }
2579 \f
2580 /* Find the innermost point within the rtx at LOC, possibly LOC itself,
2581    where we have an arithmetic expression and return that point.  LOC will
2582    be inside INSN.
2583
2584    try_combine will call this function to see if an insn can be split into
2585    two insns.  */
2586
2587 static rtx *
2588 find_split_point (loc, insn)
2589      rtx *loc;
2590      rtx insn;
2591 {
2592   rtx x = *loc;
2593   enum rtx_code code = GET_CODE (x);
2594   rtx *split;
2595   int len = 0, pos, unsignedp;
2596   rtx inner;
2597
2598   /* First special-case some codes.  */
2599   switch (code)
2600     {
2601     case SUBREG:
2602 #ifdef INSN_SCHEDULING
2603       /* If we are making a paradoxical SUBREG invalid, it becomes a split
2604          point.  */
2605       if (GET_CODE (SUBREG_REG (x)) == MEM)
2606         return loc;
2607 #endif
2608       return find_split_point (&SUBREG_REG (x), insn);
2609
2610     case MEM:
2611 #ifdef HAVE_lo_sum
2612       /* If we have (mem (const ..)) or (mem (symbol_ref ...)), split it
2613          using LO_SUM and HIGH.  */
2614       if (GET_CODE (XEXP (x, 0)) == CONST
2615           || GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
2616         {
2617           SUBST (XEXP (x, 0),
2618                  gen_rtx_combine (LO_SUM, Pmode,
2619                                   gen_rtx_combine (HIGH, Pmode, XEXP (x, 0)),
2620                                   XEXP (x, 0)));
2621           return &XEXP (XEXP (x, 0), 0);
2622         }
2623 #endif
2624
2625       /* If we have a PLUS whose second operand is a constant and the
2626          address is not valid, perhaps will can split it up using
2627          the machine-specific way to split large constants.  We use
2628          the first pseudo-reg (one of the virtual regs) as a placeholder;
2629          it will not remain in the result.  */
2630       if (GET_CODE (XEXP (x, 0)) == PLUS
2631           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
2632           && ! memory_address_p (GET_MODE (x), XEXP (x, 0)))
2633         {
2634           rtx reg = regno_reg_rtx[FIRST_PSEUDO_REGISTER];
2635           rtx seq = split_insns (gen_rtx_SET (VOIDmode, reg, XEXP (x, 0)),
2636                                  subst_insn);
2637
2638           /* This should have produced two insns, each of which sets our
2639              placeholder.  If the source of the second is a valid address,
2640              we can make put both sources together and make a split point
2641              in the middle.  */
2642
2643           if (seq && XVECLEN (seq, 0) == 2
2644               && GET_CODE (XVECEXP (seq, 0, 0)) == INSN
2645               && GET_CODE (PATTERN (XVECEXP (seq, 0, 0))) == SET
2646               && SET_DEST (PATTERN (XVECEXP (seq, 0, 0))) == reg
2647               && ! reg_mentioned_p (reg,
2648                                     SET_SRC (PATTERN (XVECEXP (seq, 0, 0))))
2649               && GET_CODE (XVECEXP (seq, 0, 1)) == INSN
2650               && GET_CODE (PATTERN (XVECEXP (seq, 0, 1))) == SET
2651               && SET_DEST (PATTERN (XVECEXP (seq, 0, 1))) == reg
2652               && memory_address_p (GET_MODE (x),
2653                                    SET_SRC (PATTERN (XVECEXP (seq, 0, 1)))))
2654             {
2655               rtx src1 = SET_SRC (PATTERN (XVECEXP (seq, 0, 0)));
2656               rtx src2 = SET_SRC (PATTERN (XVECEXP (seq, 0, 1)));
2657
2658               /* Replace the placeholder in SRC2 with SRC1.  If we can
2659                  find where in SRC2 it was placed, that can become our
2660                  split point and we can replace this address with SRC2.
2661                  Just try two obvious places.  */
2662
2663               src2 = replace_rtx (src2, reg, src1);
2664               split = 0;
2665               if (XEXP (src2, 0) == src1)
2666                 split = &XEXP (src2, 0);
2667               else if (GET_RTX_FORMAT (GET_CODE (XEXP (src2, 0)))[0] == 'e'
2668                        && XEXP (XEXP (src2, 0), 0) == src1)
2669                 split = &XEXP (XEXP (src2, 0), 0);
2670
2671               if (split)
2672                 {
2673                   SUBST (XEXP (x, 0), src2);
2674                   return split;
2675                 }
2676             }
2677
2678           /* If that didn't work, perhaps the first operand is complex and
2679              needs to be computed separately, so make a split point there.
2680              This will occur on machines that just support REG + CONST
2681              and have a constant moved through some previous computation.  */
2682
2683           else if (GET_RTX_CLASS (GET_CODE (XEXP (XEXP (x, 0), 0))) != 'o'
2684                    && ! (GET_CODE (XEXP (XEXP (x, 0), 0)) == SUBREG
2685                          && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (XEXP (x, 0), 0))))
2686                              == 'o')))
2687             return &XEXP (XEXP (x, 0), 0);
2688         }
2689       break;
2690
2691     case SET:
2692 #ifdef HAVE_cc0
2693       /* If SET_DEST is CC0 and SET_SRC is not an operand, a COMPARE, or a
2694          ZERO_EXTRACT, the most likely reason why this doesn't match is that
2695          we need to put the operand into a register.  So split at that
2696          point.  */
2697
2698       if (SET_DEST (x) == cc0_rtx
2699           && GET_CODE (SET_SRC (x)) != COMPARE
2700           && GET_CODE (SET_SRC (x)) != ZERO_EXTRACT
2701           && GET_RTX_CLASS (GET_CODE (SET_SRC (x))) != 'o'
2702           && ! (GET_CODE (SET_SRC (x)) == SUBREG
2703                 && GET_RTX_CLASS (GET_CODE (SUBREG_REG (SET_SRC (x)))) == 'o'))
2704         return &SET_SRC (x);
2705 #endif
2706
2707       /* See if we can split SET_SRC as it stands.  */
2708       split = find_split_point (&SET_SRC (x), insn);
2709       if (split && split != &SET_SRC (x))
2710         return split;
2711
2712       /* See if we can split SET_DEST as it stands.  */
2713       split = find_split_point (&SET_DEST (x), insn);
2714       if (split && split != &SET_DEST (x))
2715         return split;
2716
2717       /* See if this is a bitfield assignment with everything constant.  If
2718          so, this is an IOR of an AND, so split it into that.  */
2719       if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
2720           && (GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)))
2721               <= HOST_BITS_PER_WIDE_INT)
2722           && GET_CODE (XEXP (SET_DEST (x), 1)) == CONST_INT
2723           && GET_CODE (XEXP (SET_DEST (x), 2)) == CONST_INT
2724           && GET_CODE (SET_SRC (x)) == CONST_INT
2725           && ((INTVAL (XEXP (SET_DEST (x), 1))
2726               + INTVAL (XEXP (SET_DEST (x), 2)))
2727               <= GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0))))
2728           && ! side_effects_p (XEXP (SET_DEST (x), 0)))
2729         {
2730           int pos = INTVAL (XEXP (SET_DEST (x), 2));
2731           int len = INTVAL (XEXP (SET_DEST (x), 1));
2732           int src = INTVAL (SET_SRC (x));
2733           rtx dest = XEXP (SET_DEST (x), 0);
2734           enum machine_mode mode = GET_MODE (dest);
2735           unsigned HOST_WIDE_INT mask = ((HOST_WIDE_INT) 1 << len) - 1;
2736
2737           if (BITS_BIG_ENDIAN)
2738             pos = GET_MODE_BITSIZE (mode) - len - pos;
2739
2740           if ((unsigned HOST_WIDE_INT) src == mask)
2741             SUBST (SET_SRC (x),
2742                    gen_binary (IOR, mode, dest, GEN_INT (src << pos)));
2743           else
2744             SUBST (SET_SRC (x),
2745                    gen_binary (IOR, mode,
2746                                gen_binary (AND, mode, dest,
2747                                            GEN_INT (~ (mask << pos)
2748                                                     & GET_MODE_MASK (mode))),
2749                                GEN_INT (src << pos)));
2750
2751           SUBST (SET_DEST (x), dest);
2752
2753           split = find_split_point (&SET_SRC (x), insn);
2754           if (split && split != &SET_SRC (x))
2755             return split;
2756         }
2757
2758       /* Otherwise, see if this is an operation that we can split into two.
2759          If so, try to split that.  */
2760       code = GET_CODE (SET_SRC (x));
2761
2762       switch (code)
2763         {
2764         case AND:
2765           /* If we are AND'ing with a large constant that is only a single
2766              bit and the result is only being used in a context where we
2767              need to know if it is zero or non-zero, replace it with a bit
2768              extraction.  This will avoid the large constant, which might
2769              have taken more than one insn to make.  If the constant were
2770              not a valid argument to the AND but took only one insn to make,
2771              this is no worse, but if it took more than one insn, it will
2772              be better.  */
2773
2774           if (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
2775               && GET_CODE (XEXP (SET_SRC (x), 0)) == REG
2776               && (pos = exact_log2 (INTVAL (XEXP (SET_SRC (x), 1)))) >= 7
2777               && GET_CODE (SET_DEST (x)) == REG
2778               && (split = find_single_use (SET_DEST (x), insn, NULL_PTR)) != 0
2779               && (GET_CODE (*split) == EQ || GET_CODE (*split) == NE)
2780               && XEXP (*split, 0) == SET_DEST (x)
2781               && XEXP (*split, 1) == const0_rtx)
2782             {
2783               rtx extraction = make_extraction (GET_MODE (SET_DEST (x)),
2784                                                 XEXP (SET_SRC (x), 0),
2785                                                 pos, NULL_RTX, 1, 1, 0, 0);
2786               if (extraction != 0)
2787                 {
2788                   SUBST (SET_SRC (x), extraction);
2789                   return find_split_point (loc, insn);
2790                 }
2791             }
2792           break;
2793
2794         case NE:
2795           /* if STORE_FLAG_VALUE is -1, this is (NE X 0) and only one bit of X
2796              is known to be on, this can be converted into a NEG of a shift. */
2797           if (STORE_FLAG_VALUE == -1 && XEXP (SET_SRC (x), 1) == const0_rtx
2798               && GET_MODE (SET_SRC (x)) == GET_MODE (XEXP (SET_SRC (x), 0))
2799               && 1 <= (pos = exact_log2
2800                        (nonzero_bits (XEXP (SET_SRC (x), 0),
2801                                       GET_MODE (XEXP (SET_SRC (x), 0))))))
2802             {
2803               enum machine_mode mode = GET_MODE (XEXP (SET_SRC (x), 0));
2804
2805               SUBST (SET_SRC (x),
2806                      gen_rtx_combine (NEG, mode,
2807                                       gen_rtx_combine (LSHIFTRT, mode,
2808                                                        XEXP (SET_SRC (x), 0),
2809                                                        GEN_INT (pos))));
2810
2811               split = find_split_point (&SET_SRC (x), insn);
2812               if (split && split != &SET_SRC (x))
2813                 return split;
2814             }
2815           break;
2816
2817         case SIGN_EXTEND:
2818           inner = XEXP (SET_SRC (x), 0);
2819
2820           /* We can't optimize if either mode is a partial integer
2821              mode as we don't know how many bits are significant
2822              in those modes.  */
2823           if (GET_MODE_CLASS (GET_MODE (inner)) == MODE_PARTIAL_INT
2824               || GET_MODE_CLASS (GET_MODE (SET_SRC (x))) == MODE_PARTIAL_INT)
2825             break;
2826
2827           pos = 0;
2828           len = GET_MODE_BITSIZE (GET_MODE (inner));
2829           unsignedp = 0;
2830           break;
2831
2832         case SIGN_EXTRACT:
2833         case ZERO_EXTRACT:
2834           if (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
2835               && GET_CODE (XEXP (SET_SRC (x), 2)) == CONST_INT)
2836             {
2837               inner = XEXP (SET_SRC (x), 0);
2838               len = INTVAL (XEXP (SET_SRC (x), 1));
2839               pos = INTVAL (XEXP (SET_SRC (x), 2));
2840
2841               if (BITS_BIG_ENDIAN)
2842                 pos = GET_MODE_BITSIZE (GET_MODE (inner)) - len - pos;
2843               unsignedp = (code == ZERO_EXTRACT);
2844             }
2845           break;
2846
2847         default:
2848           break;
2849         }
2850
2851       if (len && pos >= 0 && pos + len <= GET_MODE_BITSIZE (GET_MODE (inner)))
2852         {
2853           enum machine_mode mode = GET_MODE (SET_SRC (x));
2854
2855           /* For unsigned, we have a choice of a shift followed by an
2856              AND or two shifts.  Use two shifts for field sizes where the
2857              constant might be too large.  We assume here that we can
2858              always at least get 8-bit constants in an AND insn, which is
2859              true for every current RISC.  */
2860
2861           if (unsignedp && len <= 8)
2862             {
2863               SUBST (SET_SRC (x),
2864                      gen_rtx_combine
2865                      (AND, mode,
2866                       gen_rtx_combine (LSHIFTRT, mode,
2867                                        gen_lowpart_for_combine (mode, inner),
2868                                        GEN_INT (pos)),
2869                       GEN_INT (((HOST_WIDE_INT) 1 << len) - 1)));
2870
2871               split = find_split_point (&SET_SRC (x), insn);
2872               if (split && split != &SET_SRC (x))
2873                 return split;
2874             }
2875           else
2876             {
2877               SUBST (SET_SRC (x),
2878                      gen_rtx_combine
2879                      (unsignedp ? LSHIFTRT : ASHIFTRT, mode,
2880                       gen_rtx_combine (ASHIFT, mode,
2881                                        gen_lowpart_for_combine (mode, inner),
2882                                        GEN_INT (GET_MODE_BITSIZE (mode)
2883                                                 - len - pos)),
2884                       GEN_INT (GET_MODE_BITSIZE (mode) - len)));
2885
2886               split = find_split_point (&SET_SRC (x), insn);
2887               if (split && split != &SET_SRC (x))
2888                 return split;
2889             }
2890         }
2891
2892       /* See if this is a simple operation with a constant as the second
2893          operand.  It might be that this constant is out of range and hence
2894          could be used as a split point.  */
2895       if ((GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == '2'
2896            || GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == 'c'
2897            || GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == '<')
2898           && CONSTANT_P (XEXP (SET_SRC (x), 1))
2899           && (GET_RTX_CLASS (GET_CODE (XEXP (SET_SRC (x), 0))) == 'o'
2900               || (GET_CODE (XEXP (SET_SRC (x), 0)) == SUBREG
2901                   && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (SET_SRC (x), 0))))
2902                       == 'o'))))
2903         return &XEXP (SET_SRC (x), 1);
2904
2905       /* Finally, see if this is a simple operation with its first operand
2906          not in a register.  The operation might require this operand in a
2907          register, so return it as a split point.  We can always do this
2908          because if the first operand were another operation, we would have
2909          already found it as a split point.  */
2910       if ((GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == '2'
2911            || GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == 'c'
2912            || GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == '<'
2913            || GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == '1')
2914           && ! register_operand (XEXP (SET_SRC (x), 0), VOIDmode))
2915         return &XEXP (SET_SRC (x), 0);
2916
2917       return 0;
2918
2919     case AND:
2920     case IOR:
2921       /* We write NOR as (and (not A) (not B)), but if we don't have a NOR,
2922          it is better to write this as (not (ior A B)) so we can split it.
2923          Similarly for IOR.  */
2924       if (GET_CODE (XEXP (x, 0)) == NOT && GET_CODE (XEXP (x, 1)) == NOT)
2925         {
2926           SUBST (*loc,
2927                  gen_rtx_combine (NOT, GET_MODE (x),
2928                                   gen_rtx_combine (code == IOR ? AND : IOR,
2929                                                    GET_MODE (x),
2930                                                    XEXP (XEXP (x, 0), 0),
2931                                                    XEXP (XEXP (x, 1), 0))));
2932           return find_split_point (loc, insn);
2933         }
2934
2935       /* Many RISC machines have a large set of logical insns.  If the
2936          second operand is a NOT, put it first so we will try to split the
2937          other operand first.  */
2938       if (GET_CODE (XEXP (x, 1)) == NOT)
2939         {
2940           rtx tem = XEXP (x, 0);
2941           SUBST (XEXP (x, 0), XEXP (x, 1));
2942           SUBST (XEXP (x, 1), tem);
2943         }
2944       break;
2945
2946     default:
2947       break;
2948     }
2949
2950   /* Otherwise, select our actions depending on our rtx class.  */
2951   switch (GET_RTX_CLASS (code))
2952     {
2953     case 'b':                   /* This is ZERO_EXTRACT and SIGN_EXTRACT.  */
2954     case '3':
2955       split = find_split_point (&XEXP (x, 2), insn);
2956       if (split)
2957         return split;
2958       /* ... fall through ...  */
2959     case '2':
2960     case 'c':
2961     case '<':
2962       split = find_split_point (&XEXP (x, 1), insn);
2963       if (split)
2964         return split;
2965       /* ... fall through ...  */
2966     case '1':
2967       /* Some machines have (and (shift ...) ...) insns.  If X is not
2968          an AND, but XEXP (X, 0) is, use it as our split point.  */
2969       if (GET_CODE (x) != AND && GET_CODE (XEXP (x, 0)) == AND)
2970         return &XEXP (x, 0);
2971
2972       split = find_split_point (&XEXP (x, 0), insn);
2973       if (split)
2974         return split;
2975       return loc;
2976     }
2977
2978   /* Otherwise, we don't have a split point.  */
2979   return 0;
2980 }
2981 \f
2982 /* Throughout X, replace FROM with TO, and return the result.
2983    The result is TO if X is FROM;
2984    otherwise the result is X, but its contents may have been modified.
2985    If they were modified, a record was made in undobuf so that
2986    undo_all will (among other things) return X to its original state.
2987
2988    If the number of changes necessary is too much to record to undo,
2989    the excess changes are not made, so the result is invalid.
2990    The changes already made can still be undone.
2991    undobuf.num_undo is incremented for such changes, so by testing that
2992    the caller can tell whether the result is valid.
2993
2994    `n_occurrences' is incremented each time FROM is replaced.
2995
2996    IN_DEST is non-zero if we are processing the SET_DEST of a SET.
2997
2998    UNIQUE_COPY is non-zero if each substitution must be unique.  We do this
2999    by copying if `n_occurrences' is non-zero.  */
3000
3001 static rtx
3002 subst (x, from, to, in_dest, unique_copy)
3003      register rtx x, from, to;
3004      int in_dest;
3005      int unique_copy;
3006 {
3007   register enum rtx_code code = GET_CODE (x);
3008   enum machine_mode op0_mode = VOIDmode;
3009   register char *fmt;
3010   register int len, i;
3011   rtx new;
3012
3013 /* Two expressions are equal if they are identical copies of a shared
3014    RTX or if they are both registers with the same register number
3015    and mode.  */
3016
3017 #define COMBINE_RTX_EQUAL_P(X,Y)                        \
3018   ((X) == (Y)                                           \
3019    || (GET_CODE (X) == REG && GET_CODE (Y) == REG       \
3020        && REGNO (X) == REGNO (Y) && GET_MODE (X) == GET_MODE (Y)))
3021
3022   if (! in_dest && COMBINE_RTX_EQUAL_P (x, from))
3023     {
3024       n_occurrences++;
3025       return (unique_copy && n_occurrences > 1 ? copy_rtx (to) : to);
3026     }
3027
3028   /* If X and FROM are the same register but different modes, they will
3029      not have been seen as equal above.  However, flow.c will make a
3030      LOG_LINKS entry for that case.  If we do nothing, we will try to
3031      rerecognize our original insn and, when it succeeds, we will
3032      delete the feeding insn, which is incorrect.
3033
3034      So force this insn not to match in this (rare) case.  */
3035   if (! in_dest && code == REG && GET_CODE (from) == REG
3036       && REGNO (x) == REGNO (from))
3037     return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
3038
3039   /* If this is an object, we are done unless it is a MEM or LO_SUM, both
3040      of which may contain things that can be combined.  */
3041   if (code != MEM && code != LO_SUM && GET_RTX_CLASS (code) == 'o')
3042     return x;
3043
3044   /* It is possible to have a subexpression appear twice in the insn.
3045      Suppose that FROM is a register that appears within TO.
3046      Then, after that subexpression has been scanned once by `subst',
3047      the second time it is scanned, TO may be found.  If we were
3048      to scan TO here, we would find FROM within it and create a
3049      self-referent rtl structure which is completely wrong.  */
3050   if (COMBINE_RTX_EQUAL_P (x, to))
3051     return to;
3052
3053   /* Parallel asm_operands need special attention because all of the
3054      inputs are shared across the arms.  Furthermore, unsharing the
3055      rtl results in recognition failures.  Failure to handle this case
3056      specially can result in circular rtl.
3057
3058      Solve this by doing a normal pass across the first entry of the
3059      parallel, and only processing the SET_DESTs of the subsequent
3060      entries.  Ug.  */
3061
3062   if (code == PARALLEL
3063       && GET_CODE (XVECEXP (x, 0, 0)) == SET
3064       && GET_CODE (SET_SRC (XVECEXP (x, 0, 0))) == ASM_OPERANDS)
3065     {
3066       new = subst (XVECEXP (x, 0, 0), from, to, 0, unique_copy);
3067
3068       /* If this substitution failed, this whole thing fails.  */
3069       if (GET_CODE (new) == CLOBBER
3070           && XEXP (new, 0) == const0_rtx)
3071         return new;
3072
3073       SUBST (XVECEXP (x, 0, 0), new);
3074
3075       for (i = XVECLEN (x, 0) - 1; i >= 1; i--)
3076         {
3077           rtx dest = SET_DEST (XVECEXP (x, 0, i));
3078
3079           if (GET_CODE (dest) != REG
3080               && GET_CODE (dest) != CC0
3081               && GET_CODE (dest) != PC)
3082             {
3083               new = subst (dest, from, to, 0, unique_copy);
3084
3085               /* If this substitution failed, this whole thing fails.  */
3086               if (GET_CODE (new) == CLOBBER
3087                   && XEXP (new, 0) == const0_rtx)
3088                 return new;
3089
3090               SUBST (SET_DEST (XVECEXP (x, 0, i)), new);
3091             }
3092         }
3093     }
3094   else
3095     {
3096       len = GET_RTX_LENGTH (code);
3097       fmt = GET_RTX_FORMAT (code);
3098
3099       /* We don't need to process a SET_DEST that is a register, CC0,
3100          or PC, so set up to skip this common case.  All other cases
3101          where we want to suppress replacing something inside a
3102          SET_SRC are handled via the IN_DEST operand.  */
3103       if (code == SET
3104           && (GET_CODE (SET_DEST (x)) == REG
3105               || GET_CODE (SET_DEST (x)) == CC0
3106               || GET_CODE (SET_DEST (x)) == PC))
3107         fmt = "ie";
3108
3109       /* Get the mode of operand 0 in case X is now a SIGN_EXTEND of a
3110          constant.  */
3111       if (fmt[0] == 'e')
3112         op0_mode = GET_MODE (XEXP (x, 0));
3113
3114       for (i = 0; i < len; i++)
3115         {
3116           if (fmt[i] == 'E')
3117             {
3118               register int j;
3119               for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3120                 {
3121                   if (COMBINE_RTX_EQUAL_P (XVECEXP (x, i, j), from))
3122                     {
3123                       new = (unique_copy && n_occurrences
3124                              ? copy_rtx (to) : to);
3125                       n_occurrences++;
3126                     }
3127                   else
3128                     {
3129                       new = subst (XVECEXP (x, i, j), from, to, 0,
3130                                    unique_copy);
3131
3132                       /* If this substitution failed, this whole thing
3133                          fails.  */
3134                       if (GET_CODE (new) == CLOBBER
3135                           && XEXP (new, 0) == const0_rtx)
3136                         return new;
3137                     }
3138
3139                   SUBST (XVECEXP (x, i, j), new);
3140                 }
3141             }
3142           else if (fmt[i] == 'e')
3143             {
3144               if (COMBINE_RTX_EQUAL_P (XEXP (x, i), from))
3145                 {
3146                   /* In general, don't install a subreg involving two
3147                      modes not tieable.  It can worsen register
3148                      allocation, and can even make invalid reload
3149                      insns, since the reg inside may need to be copied
3150                      from in the outside mode, and that may be invalid
3151                      if it is an fp reg copied in integer mode.
3152
3153                      We allow two exceptions to this: It is valid if
3154                      it is inside another SUBREG and the mode of that
3155                      SUBREG and the mode of the inside of TO is
3156                      tieable and it is valid if X is a SET that copies
3157                      FROM to CC0.  */
3158
3159                   if (GET_CODE (to) == SUBREG
3160                       && ! MODES_TIEABLE_P (GET_MODE (to),
3161                                             GET_MODE (SUBREG_REG (to)))
3162                       && ! (code == SUBREG
3163                             && MODES_TIEABLE_P (GET_MODE (x),
3164                                                 GET_MODE (SUBREG_REG (to))))
3165 #ifdef HAVE_cc0
3166                       && ! (code == SET && i == 1 && XEXP (x, 0) == cc0_rtx)
3167 #endif
3168                       )
3169                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
3170
3171                   new = (unique_copy && n_occurrences ? copy_rtx (to) : to);
3172                   n_occurrences++;
3173                 }
3174               else
3175                 /* If we are in a SET_DEST, suppress most cases unless we
3176                    have gone inside a MEM, in which case we want to
3177                    simplify the address.  We assume here that things that
3178                    are actually part of the destination have their inner
3179                    parts in the first expression.  This is true for SUBREG,
3180                    STRICT_LOW_PART, and ZERO_EXTRACT, which are the only
3181                    things aside from REG and MEM that should appear in a
3182                    SET_DEST.  */
3183                 new = subst (XEXP (x, i), from, to,
3184                              (((in_dest
3185                                 && (code == SUBREG || code == STRICT_LOW_PART
3186                                     || code == ZERO_EXTRACT))
3187                                || code == SET)
3188                               && i == 0), unique_copy);
3189
3190               /* If we found that we will have to reject this combination,
3191                  indicate that by returning the CLOBBER ourselves, rather than
3192                  an expression containing it.  This will speed things up as
3193                  well as prevent accidents where two CLOBBERs are considered
3194                  to be equal, thus producing an incorrect simplification.  */
3195
3196               if (GET_CODE (new) == CLOBBER && XEXP (new, 0) == const0_rtx)
3197                 return new;
3198
3199               SUBST (XEXP (x, i), new);
3200             }
3201         }
3202     }
3203
3204   /* Try to simplify X.  If the simplification changed the code, it is likely
3205      that further simplification will help, so loop, but limit the number
3206      of repetitions that will be performed.  */
3207
3208   for (i = 0; i < 4; i++)
3209     {
3210       /* If X is sufficiently simple, don't bother trying to do anything
3211          with it.  */
3212       if (code != CONST_INT && code != REG && code != CLOBBER)
3213         x = simplify_rtx (x, op0_mode, i == 3, in_dest);
3214
3215       if (GET_CODE (x) == code)
3216         break;
3217
3218       code = GET_CODE (x);
3219
3220       /* We no longer know the original mode of operand 0 since we
3221          have changed the form of X)  */
3222       op0_mode = VOIDmode;
3223     }
3224
3225   return x;
3226 }
3227 \f
3228 /* Simplify X, a piece of RTL.  We just operate on the expression at the
3229    outer level; call `subst' to simplify recursively.  Return the new
3230    expression.
3231
3232    OP0_MODE is the original mode of XEXP (x, 0); LAST is nonzero if this
3233    will be the iteration even if an expression with a code different from
3234    X is returned; IN_DEST is nonzero if we are inside a SET_DEST.  */
3235
3236 static rtx
3237 simplify_rtx (x, op0_mode, last, in_dest)
3238      rtx x;
3239      enum machine_mode op0_mode;
3240      int last;
3241      int in_dest;
3242 {
3243   enum rtx_code code = GET_CODE (x);
3244   enum machine_mode mode = GET_MODE (x);
3245   rtx temp;
3246   int i;
3247
3248   /* If this is a commutative operation, put a constant last and a complex
3249      expression first.  We don't need to do this for comparisons here.  */
3250   if (GET_RTX_CLASS (code) == 'c'
3251       && ((CONSTANT_P (XEXP (x, 0)) && GET_CODE (XEXP (x, 1)) != CONST_INT)
3252           || (GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) == 'o'
3253               && GET_RTX_CLASS (GET_CODE (XEXP (x, 1))) != 'o')
3254           || (GET_CODE (XEXP (x, 0)) == SUBREG
3255               && GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (x, 0)))) == 'o'
3256               && GET_RTX_CLASS (GET_CODE (XEXP (x, 1))) != 'o')))
3257     {
3258       temp = XEXP (x, 0);
3259       SUBST (XEXP (x, 0), XEXP (x, 1));
3260       SUBST (XEXP (x, 1), temp);
3261     }
3262
3263   /* If this is a PLUS, MINUS, or MULT, and the first operand is the
3264      sign extension of a PLUS with a constant, reverse the order of the sign
3265      extension and the addition. Note that this not the same as the original
3266      code, but overflow is undefined for signed values.  Also note that the
3267      PLUS will have been partially moved "inside" the sign-extension, so that
3268      the first operand of X will really look like:
3269          (ashiftrt (plus (ashift A C4) C5) C4).
3270      We convert this to
3271          (plus (ashiftrt (ashift A C4) C2) C4)
3272      and replace the first operand of X with that expression.  Later parts
3273      of this function may simplify the expression further.
3274
3275      For example, if we start with (mult (sign_extend (plus A C1)) C2),
3276      we swap the SIGN_EXTEND and PLUS.  Later code will apply the
3277      distributive law to produce (plus (mult (sign_extend X) C1) C3).
3278
3279      We do this to simplify address expressions.  */
3280
3281   if ((code == PLUS || code == MINUS || code == MULT)
3282       && GET_CODE (XEXP (x, 0)) == ASHIFTRT
3283       && GET_CODE (XEXP (XEXP (x, 0), 0)) == PLUS
3284       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == ASHIFT
3285       && GET_CODE (XEXP (XEXP (XEXP (XEXP (x, 0), 0), 0), 1)) == CONST_INT
3286       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3287       && XEXP (XEXP (XEXP (XEXP (x, 0), 0), 0), 1) == XEXP (XEXP (x, 0), 1)
3288       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
3289       && (temp = simplify_binary_operation (ASHIFTRT, mode,
3290                                             XEXP (XEXP (XEXP (x, 0), 0), 1),
3291                                             XEXP (XEXP (x, 0), 1))) != 0)
3292     {
3293       rtx new
3294         = simplify_shift_const (NULL_RTX, ASHIFT, mode,
3295                                 XEXP (XEXP (XEXP (XEXP (x, 0), 0), 0), 0),
3296                                 INTVAL (XEXP (XEXP (x, 0), 1)));
3297
3298       new = simplify_shift_const (NULL_RTX, ASHIFTRT, mode, new,
3299                                   INTVAL (XEXP (XEXP (x, 0), 1)));
3300
3301       SUBST (XEXP (x, 0), gen_binary (PLUS, mode, new, temp));
3302     }
3303
3304   /* If this is a simple operation applied to an IF_THEN_ELSE, try
3305      applying it to the arms of the IF_THEN_ELSE.  This often simplifies
3306      things.  Check for cases where both arms are testing the same
3307      condition.
3308
3309      Don't do anything if all operands are very simple.  */
3310
3311   if (((GET_RTX_CLASS (code) == '2' || GET_RTX_CLASS (code) == 'c'
3312         || GET_RTX_CLASS (code) == '<')
3313        && ((GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) != 'o'
3314             && ! (GET_CODE (XEXP (x, 0)) == SUBREG
3315                   && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (x, 0))))
3316                       == 'o')))
3317            || (GET_RTX_CLASS (GET_CODE (XEXP (x, 1))) != 'o'
3318                && ! (GET_CODE (XEXP (x, 1)) == SUBREG
3319                      && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (x, 1))))
3320                          == 'o')))))
3321       || (GET_RTX_CLASS (code) == '1'
3322           && ((GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) != 'o'
3323                && ! (GET_CODE (XEXP (x, 0)) == SUBREG
3324                      && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (x, 0))))
3325                          == 'o'))))))
3326     {
3327       rtx cond, true, false;
3328
3329       cond = if_then_else_cond (x, &true, &false);
3330       if (cond != 0
3331           /* If everything is a comparison, what we have is highly unlikely
3332              to be simpler, so don't use it.  */
3333           && ! (GET_RTX_CLASS (code) == '<'
3334                 && (GET_RTX_CLASS (GET_CODE (true)) == '<'
3335                     || GET_RTX_CLASS (GET_CODE (false)) == '<')))
3336         {
3337           rtx cop1 = const0_rtx;
3338           enum rtx_code cond_code = simplify_comparison (NE, &cond, &cop1);
3339
3340           if (cond_code == NE && GET_RTX_CLASS (GET_CODE (cond)) == '<')
3341             return x;
3342
3343           /* Simplify the alternative arms; this may collapse the true and
3344              false arms to store-flag values.  */
3345           true = subst (true, pc_rtx, pc_rtx, 0, 0);
3346           false = subst (false, pc_rtx, pc_rtx, 0, 0);
3347
3348           /* Restarting if we generate a store-flag expression will cause
3349              us to loop.  Just drop through in this case.  */
3350
3351           /* If the result values are STORE_FLAG_VALUE and zero, we can
3352              just make the comparison operation.  */
3353           if (true == const_true_rtx && false == const0_rtx)
3354             x = gen_binary (cond_code, mode, cond, cop1);
3355           else if (true == const0_rtx && false == const_true_rtx)
3356             x = gen_binary (reverse_condition (cond_code), mode, cond, cop1);
3357
3358           /* Likewise, we can make the negate of a comparison operation
3359              if the result values are - STORE_FLAG_VALUE and zero.  */
3360           else if (GET_CODE (true) == CONST_INT
3361                    && INTVAL (true) == - STORE_FLAG_VALUE
3362                    && false == const0_rtx)
3363             x = gen_unary (NEG, mode, mode,
3364                            gen_binary (cond_code, mode, cond, cop1));
3365           else if (GET_CODE (false) == CONST_INT
3366                    && INTVAL (false) == - STORE_FLAG_VALUE
3367                    && true == const0_rtx)
3368             x = gen_unary (NEG, mode, mode,
3369                            gen_binary (reverse_condition (cond_code),
3370                                        mode, cond, cop1));
3371           else
3372             return gen_rtx_IF_THEN_ELSE (mode,
3373                                          gen_binary (cond_code, VOIDmode,
3374                                                      cond, cop1),
3375                                          true, false);
3376
3377           code = GET_CODE (x);
3378           op0_mode = VOIDmode;
3379         }
3380     }
3381
3382   /* Try to fold this expression in case we have constants that weren't
3383      present before.  */
3384   temp = 0;
3385   switch (GET_RTX_CLASS (code))
3386     {
3387     case '1':
3388       temp = simplify_unary_operation (code, mode, XEXP (x, 0), op0_mode);
3389       break;
3390     case '<':
3391       temp = simplify_relational_operation (code, op0_mode,
3392                                             XEXP (x, 0), XEXP (x, 1));
3393 #ifdef FLOAT_STORE_FLAG_VALUE
3394       if (temp != 0 && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
3395         temp = ((temp == const0_rtx) ? CONST0_RTX (GET_MODE (x))
3396                 : immed_real_const_1 (FLOAT_STORE_FLAG_VALUE, GET_MODE (x)));
3397 #endif
3398       break;
3399     case 'c':
3400     case '2':
3401       temp = simplify_binary_operation (code, mode, XEXP (x, 0), XEXP (x, 1));
3402       break;
3403     case 'b':
3404     case '3':
3405       temp = simplify_ternary_operation (code, mode, op0_mode, XEXP (x, 0),
3406                                          XEXP (x, 1), XEXP (x, 2));
3407       break;
3408     }
3409
3410   if (temp)
3411     x = temp, code = GET_CODE (temp);
3412
3413   /* First see if we can apply the inverse distributive law.  */
3414   if (code == PLUS || code == MINUS
3415       || code == AND || code == IOR || code == XOR)
3416     {
3417       x = apply_distributive_law (x);
3418       code = GET_CODE (x);
3419     }
3420
3421   /* If CODE is an associative operation not otherwise handled, see if we
3422      can associate some operands.  This can win if they are constants or
3423      if they are logically related (i.e. (a & b) & a.  */
3424   if ((code == PLUS || code == MINUS
3425        || code == MULT || code == AND || code == IOR || code == XOR
3426        || code == DIV || code == UDIV
3427        || code == SMAX || code == SMIN || code == UMAX || code == UMIN)
3428       && INTEGRAL_MODE_P (mode))
3429     {
3430       if (GET_CODE (XEXP (x, 0)) == code)
3431         {
3432           rtx other = XEXP (XEXP (x, 0), 0);
3433           rtx inner_op0 = XEXP (XEXP (x, 0), 1);
3434           rtx inner_op1 = XEXP (x, 1);
3435           rtx inner;
3436
3437           /* Make sure we pass the constant operand if any as the second
3438              one if this is a commutative operation.  */
3439           if (CONSTANT_P (inner_op0) && GET_RTX_CLASS (code) == 'c')
3440             {
3441               rtx tem = inner_op0;
3442               inner_op0 = inner_op1;
3443               inner_op1 = tem;
3444             }
3445           inner = simplify_binary_operation (code == MINUS ? PLUS
3446                                              : code == DIV ? MULT
3447                                              : code == UDIV ? MULT
3448                                              : code,
3449                                              mode, inner_op0, inner_op1);
3450
3451           /* For commutative operations, try the other pair if that one
3452              didn't simplify.  */
3453           if (inner == 0 && GET_RTX_CLASS (code) == 'c')
3454             {
3455               other = XEXP (XEXP (x, 0), 1);
3456               inner = simplify_binary_operation (code, mode,
3457                                                  XEXP (XEXP (x, 0), 0),
3458                                                  XEXP (x, 1));
3459             }
3460
3461           if (inner)
3462             return gen_binary (code, mode, other, inner);
3463         }
3464     }
3465
3466   /* A little bit of algebraic simplification here.  */
3467   switch (code)
3468     {
3469     case MEM:
3470       /* Ensure that our address has any ASHIFTs converted to MULT in case
3471          address-recognizing predicates are called later.  */
3472       temp = make_compound_operation (XEXP (x, 0), MEM);
3473       SUBST (XEXP (x, 0), temp);
3474       break;
3475
3476     case SUBREG:
3477       /* (subreg:A (mem:B X) N) becomes a modified MEM unless the SUBREG
3478          is paradoxical.  If we can't do that safely, then it becomes
3479          something nonsensical so that this combination won't take place.  */
3480
3481       if (GET_CODE (SUBREG_REG (x)) == MEM
3482           && (GET_MODE_SIZE (mode)
3483               <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
3484         {
3485           rtx inner = SUBREG_REG (x);
3486           int endian_offset = 0;
3487           /* Don't change the mode of the MEM
3488              if that would change the meaning of the address.  */
3489           if (MEM_VOLATILE_P (SUBREG_REG (x))
3490               || mode_dependent_address_p (XEXP (inner, 0)))
3491             return gen_rtx_CLOBBER (mode, const0_rtx);
3492
3493           if (BYTES_BIG_ENDIAN)
3494             {
3495               if (GET_MODE_SIZE (mode) < UNITS_PER_WORD)
3496                 endian_offset += UNITS_PER_WORD - GET_MODE_SIZE (mode);
3497               if (GET_MODE_SIZE (GET_MODE (inner)) < UNITS_PER_WORD)
3498                 endian_offset -= (UNITS_PER_WORD
3499                                   - GET_MODE_SIZE (GET_MODE (inner)));
3500             }
3501           /* Note if the plus_constant doesn't make a valid address
3502              then this combination won't be accepted.  */
3503           x = gen_rtx_MEM (mode,
3504                            plus_constant (XEXP (inner, 0),
3505                                           (SUBREG_WORD (x) * UNITS_PER_WORD
3506                                            + endian_offset)));
3507           RTX_UNCHANGING_P (x) = RTX_UNCHANGING_P (inner);
3508           MEM_COPY_ATTRIBUTES (x, inner);
3509           return x;
3510         }
3511
3512       /* If we are in a SET_DEST, these other cases can't apply.  */
3513       if (in_dest)
3514         return x;
3515
3516       /* Changing mode twice with SUBREG => just change it once,
3517          or not at all if changing back to starting mode.  */
3518       if (GET_CODE (SUBREG_REG (x)) == SUBREG)
3519         {
3520           if (mode == GET_MODE (SUBREG_REG (SUBREG_REG (x)))
3521               && SUBREG_WORD (x) == 0 && SUBREG_WORD (SUBREG_REG (x)) == 0)
3522             return SUBREG_REG (SUBREG_REG (x));
3523
3524           SUBST_INT (SUBREG_WORD (x),
3525                      SUBREG_WORD (x) + SUBREG_WORD (SUBREG_REG (x)));
3526           SUBST (SUBREG_REG (x), SUBREG_REG (SUBREG_REG (x)));
3527         }
3528
3529       /* SUBREG of a hard register => just change the register number
3530          and/or mode.  If the hard register is not valid in that mode,
3531          suppress this combination.  If the hard register is the stack,
3532          frame, or argument pointer, leave this as a SUBREG.  */
3533
3534       if (GET_CODE (SUBREG_REG (x)) == REG
3535           && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER
3536           && REGNO (SUBREG_REG (x)) != FRAME_POINTER_REGNUM
3537 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
3538           && REGNO (SUBREG_REG (x)) != HARD_FRAME_POINTER_REGNUM
3539 #endif
3540 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3541           && REGNO (SUBREG_REG (x)) != ARG_POINTER_REGNUM
3542 #endif
3543           && REGNO (SUBREG_REG (x)) != STACK_POINTER_REGNUM)
3544         {
3545           if (HARD_REGNO_MODE_OK (REGNO (SUBREG_REG (x)) + SUBREG_WORD (x),
3546                                   mode))
3547             return gen_rtx_REG (mode,
3548                                 REGNO (SUBREG_REG (x)) + SUBREG_WORD (x));
3549           else
3550             return gen_rtx_CLOBBER (mode, const0_rtx);
3551         }
3552
3553       /* For a constant, try to pick up the part we want.  Handle a full
3554          word and low-order part.  Only do this if we are narrowing
3555          the constant; if it is being widened, we have no idea what
3556          the extra bits will have been set to.  */
3557
3558       if (CONSTANT_P (SUBREG_REG (x)) && op0_mode != VOIDmode
3559           && GET_MODE_SIZE (mode) == UNITS_PER_WORD
3560           && GET_MODE_SIZE (op0_mode) > UNITS_PER_WORD
3561           && GET_MODE_CLASS (mode) == MODE_INT)
3562         {
3563           temp = operand_subword (SUBREG_REG (x), SUBREG_WORD (x),
3564                                   0, op0_mode);
3565           if (temp)
3566             return temp;
3567         }
3568
3569       /* If we want a subreg of a constant, at offset 0,
3570          take the low bits.  On a little-endian machine, that's
3571          always valid.  On a big-endian machine, it's valid
3572          only if the constant's mode fits in one word.   Note that we
3573          cannot use subreg_lowpart_p since SUBREG_REG may be VOIDmode.  */
3574       if (CONSTANT_P (SUBREG_REG (x))
3575           && ((GET_MODE_SIZE (op0_mode) <= UNITS_PER_WORD
3576               || ! WORDS_BIG_ENDIAN)
3577               ? SUBREG_WORD (x) == 0
3578               : (SUBREG_WORD (x)
3579                  == ((GET_MODE_SIZE (op0_mode)
3580                       - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD))
3581                      / UNITS_PER_WORD)))
3582           && GET_MODE_SIZE (mode) <= GET_MODE_SIZE (op0_mode)
3583           && (! WORDS_BIG_ENDIAN
3584               || GET_MODE_BITSIZE (op0_mode) <= BITS_PER_WORD))
3585         return gen_lowpart_for_combine (mode, SUBREG_REG (x));
3586
3587       /* A paradoxical SUBREG of a VOIDmode constant is the same constant,
3588          since we are saying that the high bits don't matter.  */
3589       if (CONSTANT_P (SUBREG_REG (x)) && GET_MODE (SUBREG_REG (x)) == VOIDmode
3590           && GET_MODE_SIZE (mode) > GET_MODE_SIZE (op0_mode))
3591         return SUBREG_REG (x);
3592
3593       /* Note that we cannot do any narrowing for non-constants since
3594          we might have been counting on using the fact that some bits were
3595          zero.  We now do this in the SET.  */
3596
3597       break;
3598
3599     case NOT:
3600       /* (not (plus X -1)) can become (neg X).  */
3601       if (GET_CODE (XEXP (x, 0)) == PLUS
3602           && XEXP (XEXP (x, 0), 1) == constm1_rtx)
3603         return gen_rtx_combine (NEG, mode, XEXP (XEXP (x, 0), 0));
3604
3605       /* Similarly, (not (neg X)) is (plus X -1).  */
3606       if (GET_CODE (XEXP (x, 0)) == NEG)
3607         return gen_rtx_combine (PLUS, mode, XEXP (XEXP (x, 0), 0),
3608                                 constm1_rtx);
3609
3610       /* (not (xor X C)) for C constant is (xor X D) with D = ~ C.  */
3611       if (GET_CODE (XEXP (x, 0)) == XOR
3612           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3613           && (temp = simplify_unary_operation (NOT, mode,
3614                                                XEXP (XEXP (x, 0), 1),
3615                                                mode)) != 0)
3616         return gen_binary (XOR, mode, XEXP (XEXP (x, 0), 0), temp);
3617
3618       /* (not (ashift 1 X)) is (rotate ~1 X).  We used to do this for operands
3619          other than 1, but that is not valid.  We could do a similar
3620          simplification for (not (lshiftrt C X)) where C is just the sign bit,
3621          but this doesn't seem common enough to bother with.  */
3622       if (GET_CODE (XEXP (x, 0)) == ASHIFT
3623           && XEXP (XEXP (x, 0), 0) == const1_rtx)
3624         return gen_rtx_ROTATE (mode, gen_unary (NOT, mode, mode, const1_rtx),
3625                                XEXP (XEXP (x, 0), 1));
3626
3627       if (GET_CODE (XEXP (x, 0)) == SUBREG
3628           && subreg_lowpart_p (XEXP (x, 0))
3629           && (GET_MODE_SIZE (GET_MODE (XEXP (x, 0)))
3630               < GET_MODE_SIZE (GET_MODE (SUBREG_REG (XEXP (x, 0)))))
3631           && GET_CODE (SUBREG_REG (XEXP (x, 0))) == ASHIFT
3632           && XEXP (SUBREG_REG (XEXP (x, 0)), 0) == const1_rtx)
3633         {
3634           enum machine_mode inner_mode = GET_MODE (SUBREG_REG (XEXP (x, 0)));
3635
3636           x = gen_rtx_ROTATE (inner_mode,
3637                               gen_unary (NOT, inner_mode, inner_mode,
3638                                          const1_rtx),
3639                               XEXP (SUBREG_REG (XEXP (x, 0)), 1));
3640           return gen_lowpart_for_combine (mode, x);
3641         }
3642
3643       /* If STORE_FLAG_VALUE is -1, (not (comparison foo bar)) can be done by
3644          reversing the comparison code if valid.  */
3645       if (STORE_FLAG_VALUE == -1
3646           && GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) == '<'
3647           && reversible_comparison_p (XEXP (x, 0)))
3648         return gen_rtx_combine (reverse_condition (GET_CODE (XEXP (x, 0))),
3649                                 mode, XEXP (XEXP (x, 0), 0),
3650                                 XEXP (XEXP (x, 0), 1));
3651
3652       /* (ashiftrt foo C) where C is the number of bits in FOO minus 1
3653          is (lt foo (const_int 0)) if STORE_FLAG_VALUE is -1, so we can
3654          perform the above simplification.  */
3655
3656       if (STORE_FLAG_VALUE == -1
3657           && XEXP (x, 1) == const1_rtx
3658           && GET_CODE (XEXP (x, 0)) == ASHIFTRT
3659           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3660           && INTVAL (XEXP (XEXP (x, 0), 1)) == GET_MODE_BITSIZE (mode) - 1)
3661         return gen_rtx_combine (GE, mode, XEXP (XEXP (x, 0), 0), const0_rtx);
3662
3663       /* Apply De Morgan's laws to reduce number of patterns for machines
3664          with negating logical insns (and-not, nand, etc.).  If result has
3665          only one NOT, put it first, since that is how the patterns are
3666          coded.  */
3667
3668       if (GET_CODE (XEXP (x, 0)) == IOR || GET_CODE (XEXP (x, 0)) == AND)
3669         {
3670          rtx in1 = XEXP (XEXP (x, 0), 0), in2 = XEXP (XEXP (x, 0), 1);
3671
3672          if (GET_CODE (in1) == NOT)
3673            in1 = XEXP (in1, 0);
3674          else
3675            in1 = gen_rtx_combine (NOT, GET_MODE (in1), in1);
3676
3677          if (GET_CODE (in2) == NOT)
3678            in2 = XEXP (in2, 0);
3679          else if (GET_CODE (in2) == CONST_INT
3680                   && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
3681            in2 = GEN_INT (GET_MODE_MASK (mode) & ~ INTVAL (in2));
3682          else
3683            in2 = gen_rtx_combine (NOT, GET_MODE (in2), in2);
3684
3685          if (GET_CODE (in2) == NOT)
3686            {
3687              rtx tem = in2;
3688              in2 = in1; in1 = tem;
3689            }
3690
3691          return gen_rtx_combine (GET_CODE (XEXP (x, 0)) == IOR ? AND : IOR,
3692                                  mode, in1, in2);
3693        }
3694       break;
3695
3696     case NEG:
3697       /* (neg (plus X 1)) can become (not X).  */
3698       if (GET_CODE (XEXP (x, 0)) == PLUS
3699           && XEXP (XEXP (x, 0), 1) == const1_rtx)
3700         return gen_rtx_combine (NOT, mode, XEXP (XEXP (x, 0), 0));
3701
3702       /* Similarly, (neg (not X)) is (plus X 1).  */
3703       if (GET_CODE (XEXP (x, 0)) == NOT)
3704         return plus_constant (XEXP (XEXP (x, 0), 0), 1);
3705
3706       /* (neg (minus X Y)) can become (minus Y X).  */
3707       if (GET_CODE (XEXP (x, 0)) == MINUS
3708           && (! FLOAT_MODE_P (mode)
3709               /* x-y != -(y-x) with IEEE floating point.  */
3710               || TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3711               || flag_fast_math))
3712         return gen_binary (MINUS, mode, XEXP (XEXP (x, 0), 1),
3713                            XEXP (XEXP (x, 0), 0));
3714
3715       /* (neg (xor A 1)) is (plus A -1) if A is known to be either 0 or 1.  */
3716       if (GET_CODE (XEXP (x, 0)) == XOR && XEXP (XEXP (x, 0), 1) == const1_rtx
3717           && nonzero_bits (XEXP (XEXP (x, 0), 0), mode) == 1)
3718         return gen_binary (PLUS, mode, XEXP (XEXP (x, 0), 0), constm1_rtx);
3719
3720       /* NEG commutes with ASHIFT since it is multiplication.  Only do this
3721          if we can then eliminate the NEG (e.g.,
3722          if the operand is a constant).  */
3723
3724       if (GET_CODE (XEXP (x, 0)) == ASHIFT)
3725         {
3726           temp = simplify_unary_operation (NEG, mode,
3727                                            XEXP (XEXP (x, 0), 0), mode);
3728           if (temp)
3729             {
3730               SUBST (XEXP (XEXP (x, 0), 0), temp);
3731               return XEXP (x, 0);
3732             }
3733         }
3734
3735       temp = expand_compound_operation (XEXP (x, 0));
3736
3737       /* For C equal to the width of MODE minus 1, (neg (ashiftrt X C)) can be
3738          replaced by (lshiftrt X C).  This will convert
3739          (neg (sign_extract X 1 Y)) to (zero_extract X 1 Y).  */
3740
3741       if (GET_CODE (temp) == ASHIFTRT
3742           && GET_CODE (XEXP (temp, 1)) == CONST_INT
3743           && INTVAL (XEXP (temp, 1)) == GET_MODE_BITSIZE (mode) - 1)
3744         return simplify_shift_const (temp, LSHIFTRT, mode, XEXP (temp, 0),
3745                                      INTVAL (XEXP (temp, 1)));
3746
3747       /* If X has only a single bit that might be nonzero, say, bit I, convert
3748          (neg X) to (ashiftrt (ashift X C-I) C-I) where C is the bitsize of
3749          MODE minus 1.  This will convert (neg (zero_extract X 1 Y)) to
3750          (sign_extract X 1 Y).  But only do this if TEMP isn't a register
3751          or a SUBREG of one since we'd be making the expression more
3752          complex if it was just a register.  */
3753
3754       if (GET_CODE (temp) != REG
3755           && ! (GET_CODE (temp) == SUBREG
3756                 && GET_CODE (SUBREG_REG (temp)) == REG)
3757           && (i = exact_log2 (nonzero_bits (temp, mode))) >= 0)
3758         {
3759           rtx temp1 = simplify_shift_const
3760             (NULL_RTX, ASHIFTRT, mode,
3761              simplify_shift_const (NULL_RTX, ASHIFT, mode, temp,
3762                                    GET_MODE_BITSIZE (mode) - 1 - i),
3763              GET_MODE_BITSIZE (mode) - 1 - i);
3764
3765           /* If all we did was surround TEMP with the two shifts, we
3766              haven't improved anything, so don't use it.  Otherwise,
3767              we are better off with TEMP1.  */
3768           if (GET_CODE (temp1) != ASHIFTRT
3769               || GET_CODE (XEXP (temp1, 0)) != ASHIFT
3770               || XEXP (XEXP (temp1, 0), 0) != temp)
3771             return temp1;
3772         }
3773       break;
3774
3775     case TRUNCATE:
3776       /* We can't handle truncation to a partial integer mode here
3777          because we don't know the real bitsize of the partial
3778          integer mode.  */
3779       if (GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
3780         break;
3781
3782       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
3783           && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
3784                                     GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))))
3785         SUBST (XEXP (x, 0),
3786                force_to_mode (XEXP (x, 0), GET_MODE (XEXP (x, 0)),
3787                               GET_MODE_MASK (mode), NULL_RTX, 0));
3788
3789       /* (truncate:SI ({sign,zero}_extend:DI foo:SI)) == foo:SI.  */
3790       if ((GET_CODE (XEXP (x, 0)) == SIGN_EXTEND
3791            || GET_CODE (XEXP (x, 0)) == ZERO_EXTEND)
3792           && GET_MODE (XEXP (XEXP (x, 0), 0)) == mode)
3793         return XEXP (XEXP (x, 0), 0);
3794
3795       /* (truncate:SI (OP:DI ({sign,zero}_extend:DI foo:SI))) is
3796          (OP:SI foo:SI) if OP is NEG or ABS.  */
3797       if ((GET_CODE (XEXP (x, 0)) == ABS
3798            || GET_CODE (XEXP (x, 0)) == NEG)
3799           && (GET_CODE (XEXP (XEXP (x, 0), 0)) == SIGN_EXTEND
3800               || GET_CODE (XEXP (XEXP (x, 0), 0)) == ZERO_EXTEND)
3801           && GET_MODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == mode)
3802         return gen_unary (GET_CODE (XEXP (x, 0)), mode, mode,
3803                           XEXP (XEXP (XEXP (x, 0), 0), 0));
3804
3805       /* (truncate:SI (subreg:DI (truncate:SI X) 0)) is
3806          (truncate:SI x).  */
3807       if (GET_CODE (XEXP (x, 0)) == SUBREG
3808           && GET_CODE (SUBREG_REG (XEXP (x, 0))) == TRUNCATE
3809           && subreg_lowpart_p (XEXP (x, 0)))
3810         return SUBREG_REG (XEXP (x, 0));
3811
3812       /* If we know that the value is already truncated, we can
3813          replace the TRUNCATE with a SUBREG if TRULY_NOOP_TRUNCATION is
3814          nonzero for the corresponding modes.  */
3815       if (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
3816                                  GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))))
3817           && num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
3818              >= GET_MODE_BITSIZE (mode) + 1)
3819         return gen_lowpart_for_combine (mode, XEXP (x, 0));
3820
3821       /* A truncate of a comparison can be replaced with a subreg if
3822          STORE_FLAG_VALUE permits.  This is like the previous test,
3823          but it works even if the comparison is done in a mode larger
3824          than HOST_BITS_PER_WIDE_INT.  */
3825       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
3826           && GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) == '<'
3827           && ((HOST_WIDE_INT) STORE_FLAG_VALUE &~ GET_MODE_MASK (mode)) == 0)
3828         return gen_lowpart_for_combine (mode, XEXP (x, 0));
3829
3830       /* Similarly, a truncate of a register whose value is a
3831          comparison can be replaced with a subreg if STORE_FLAG_VALUE
3832          permits.  */
3833       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
3834           && ((HOST_WIDE_INT) STORE_FLAG_VALUE &~ GET_MODE_MASK (mode)) == 0
3835           && (temp = get_last_value (XEXP (x, 0)))
3836           && GET_RTX_CLASS (GET_CODE (temp)) == '<')
3837         return gen_lowpart_for_combine (mode, XEXP (x, 0));
3838
3839       break;
3840
3841     case FLOAT_TRUNCATE:
3842       /* (float_truncate:SF (float_extend:DF foo:SF)) = foo:SF.  */
3843       if (GET_CODE (XEXP (x, 0)) == FLOAT_EXTEND
3844           && GET_MODE (XEXP (XEXP (x, 0), 0)) == mode)
3845         return XEXP (XEXP (x, 0), 0);
3846
3847       /* (float_truncate:SF (OP:DF (float_extend:DF foo:sf))) is
3848          (OP:SF foo:SF) if OP is NEG or ABS.  */
3849       if ((GET_CODE (XEXP (x, 0)) == ABS
3850            || GET_CODE (XEXP (x, 0)) == NEG)
3851           && GET_CODE (XEXP (XEXP (x, 0), 0)) == FLOAT_EXTEND
3852           && GET_MODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == mode)
3853         return gen_unary (GET_CODE (XEXP (x, 0)), mode, mode,
3854                           XEXP (XEXP (XEXP (x, 0), 0), 0));
3855
3856       /* (float_truncate:SF (subreg:DF (float_truncate:SF X) 0))
3857          is (float_truncate:SF x).  */
3858       if (GET_CODE (XEXP (x, 0)) == SUBREG
3859           && subreg_lowpart_p (XEXP (x, 0))
3860           && GET_CODE (SUBREG_REG (XEXP (x, 0))) == FLOAT_TRUNCATE)
3861         return SUBREG_REG (XEXP (x, 0));
3862       break;
3863
3864 #ifdef HAVE_cc0
3865     case COMPARE:
3866       /* Convert (compare FOO (const_int 0)) to FOO unless we aren't
3867          using cc0, in which case we want to leave it as a COMPARE
3868          so we can distinguish it from a register-register-copy.  */
3869       if (XEXP (x, 1) == const0_rtx)
3870         return XEXP (x, 0);
3871
3872       /* In IEEE floating point, x-0 is not the same as x.  */
3873       if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3874            || ! FLOAT_MODE_P (GET_MODE (XEXP (x, 0)))
3875            || flag_fast_math)
3876           && XEXP (x, 1) == CONST0_RTX (GET_MODE (XEXP (x, 0))))
3877         return XEXP (x, 0);
3878       break;
3879 #endif
3880
3881     case CONST:
3882       /* (const (const X)) can become (const X).  Do it this way rather than
3883          returning the inner CONST since CONST can be shared with a
3884          REG_EQUAL note.  */
3885       if (GET_CODE (XEXP (x, 0)) == CONST)
3886         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
3887       break;
3888
3889 #ifdef HAVE_lo_sum
3890     case LO_SUM:
3891       /* Convert (lo_sum (high FOO) FOO) to FOO.  This is necessary so we
3892          can add in an offset.  find_split_point will split this address up
3893          again if it doesn't match.  */
3894       if (GET_CODE (XEXP (x, 0)) == HIGH
3895           && rtx_equal_p (XEXP (XEXP (x, 0), 0), XEXP (x, 1)))
3896         return XEXP (x, 1);
3897       break;
3898 #endif
3899
3900     case PLUS:
3901       /* If we have (plus (plus (A const) B)), associate it so that CONST is
3902          outermost.  That's because that's the way indexed addresses are
3903          supposed to appear.  This code used to check many more cases, but
3904          they are now checked elsewhere.  */
3905       if (GET_CODE (XEXP (x, 0)) == PLUS
3906           && CONSTANT_ADDRESS_P (XEXP (XEXP (x, 0), 1)))
3907         return gen_binary (PLUS, mode,
3908                            gen_binary (PLUS, mode, XEXP (XEXP (x, 0), 0),
3909                                        XEXP (x, 1)),
3910                            XEXP (XEXP (x, 0), 1));
3911
3912       /* (plus (xor (and <foo> (const_int pow2 - 1)) <c>) <-c>)
3913          when c is (const_int (pow2 + 1) / 2) is a sign extension of a
3914          bit-field and can be replaced by either a sign_extend or a
3915          sign_extract.  The `and' may be a zero_extend.  */
3916       if (GET_CODE (XEXP (x, 0)) == XOR
3917           && GET_CODE (XEXP (x, 1)) == CONST_INT
3918           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3919           && INTVAL (XEXP (x, 1)) == - INTVAL (XEXP (XEXP (x, 0), 1))
3920           && (i = exact_log2 (INTVAL (XEXP (XEXP (x, 0), 1)))) >= 0
3921           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
3922           && ((GET_CODE (XEXP (XEXP (x, 0), 0)) == AND
3923                && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
3924                && (INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1))
3925                    == ((HOST_WIDE_INT) 1 << (i + 1)) - 1))
3926               || (GET_CODE (XEXP (XEXP (x, 0), 0)) == ZERO_EXTEND
3927                   && (GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (XEXP (x, 0), 0), 0)))
3928                       == i + 1))))
3929         return simplify_shift_const
3930           (NULL_RTX, ASHIFTRT, mode,
3931            simplify_shift_const (NULL_RTX, ASHIFT, mode,
3932                                  XEXP (XEXP (XEXP (x, 0), 0), 0),
3933                                  GET_MODE_BITSIZE (mode) - (i + 1)),
3934            GET_MODE_BITSIZE (mode) - (i + 1));
3935
3936       /* (plus (comparison A B) C) can become (neg (rev-comp A B)) if
3937          C is 1 and STORE_FLAG_VALUE is -1 or if C is -1 and STORE_FLAG_VALUE
3938          is 1.  This produces better code than the alternative immediately
3939          below.  */
3940       if (GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) == '<'
3941           && reversible_comparison_p (XEXP (x, 0))
3942           && ((STORE_FLAG_VALUE == -1 && XEXP (x, 1) == const1_rtx)
3943               || (STORE_FLAG_VALUE == 1 && XEXP (x, 1) == constm1_rtx)))
3944         return
3945           gen_unary (NEG, mode, mode,
3946                      gen_binary (reverse_condition (GET_CODE (XEXP (x, 0))),
3947                                  mode, XEXP (XEXP (x, 0), 0),
3948                                  XEXP (XEXP (x, 0), 1)));
3949
3950       /* If only the low-order bit of X is possibly nonzero, (plus x -1)
3951          can become (ashiftrt (ashift (xor x 1) C) C) where C is
3952          the bitsize of the mode - 1.  This allows simplification of
3953          "a = (b & 8) == 0;"  */
3954       if (XEXP (x, 1) == constm1_rtx
3955           && GET_CODE (XEXP (x, 0)) != REG
3956           && ! (GET_CODE (XEXP (x,0)) == SUBREG
3957                 && GET_CODE (SUBREG_REG (XEXP (x, 0))) == REG)
3958           && nonzero_bits (XEXP (x, 0), mode) == 1)
3959         return simplify_shift_const (NULL_RTX, ASHIFTRT, mode,
3960            simplify_shift_const (NULL_RTX, ASHIFT, mode,
3961                                  gen_rtx_combine (XOR, mode,
3962                                                   XEXP (x, 0), const1_rtx),
3963                                  GET_MODE_BITSIZE (mode) - 1),
3964            GET_MODE_BITSIZE (mode) - 1);
3965
3966       /* If we are adding two things that have no bits in common, convert
3967          the addition into an IOR.  This will often be further simplified,
3968          for example in cases like ((a & 1) + (a & 2)), which can
3969          become a & 3.  */
3970
3971       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
3972           && (nonzero_bits (XEXP (x, 0), mode)
3973               & nonzero_bits (XEXP (x, 1), mode)) == 0)
3974         return gen_binary (IOR, mode, XEXP (x, 0), XEXP (x, 1));
3975       break;
3976
3977     case MINUS:
3978       /* If STORE_FLAG_VALUE is 1, (minus 1 (comparison foo bar)) can be done
3979          by reversing the comparison code if valid.  */
3980       if (STORE_FLAG_VALUE == 1
3981           && XEXP (x, 0) == const1_rtx
3982           && GET_RTX_CLASS (GET_CODE (XEXP (x, 1))) == '<'
3983           && reversible_comparison_p (XEXP (x, 1)))
3984         return gen_binary (reverse_condition (GET_CODE (XEXP (x, 1))),
3985                            mode, XEXP (XEXP (x, 1), 0),
3986                                 XEXP (XEXP (x, 1), 1));
3987
3988       /* (minus <foo> (and <foo> (const_int -pow2))) becomes
3989          (and <foo> (const_int pow2-1))  */
3990       if (GET_CODE (XEXP (x, 1)) == AND
3991           && GET_CODE (XEXP (XEXP (x, 1), 1)) == CONST_INT
3992           && exact_log2 (- INTVAL (XEXP (XEXP (x, 1), 1))) >= 0
3993           && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
3994         return simplify_and_const_int (NULL_RTX, mode, XEXP (x, 0),
3995                                        - INTVAL (XEXP (XEXP (x, 1), 1)) - 1);
3996
3997       /* Canonicalize (minus A (plus B C)) to (minus (minus A B) C) for
3998          integers.  */
3999       if (GET_CODE (XEXP (x, 1)) == PLUS && INTEGRAL_MODE_P (mode))
4000         return gen_binary (MINUS, mode,
4001                            gen_binary (MINUS, mode, XEXP (x, 0),
4002                                        XEXP (XEXP (x, 1), 0)),
4003                            XEXP (XEXP (x, 1), 1));
4004       break;
4005
4006     case MULT:
4007       /* If we have (mult (plus A B) C), apply the distributive law and then
4008          the inverse distributive law to see if things simplify.  This
4009          occurs mostly in addresses, often when unrolling loops.  */
4010
4011       if (GET_CODE (XEXP (x, 0)) == PLUS)
4012         {
4013           x = apply_distributive_law
4014             (gen_binary (PLUS, mode,
4015                          gen_binary (MULT, mode,
4016                                      XEXP (XEXP (x, 0), 0), XEXP (x, 1)),
4017                          gen_binary (MULT, mode,
4018                                      XEXP (XEXP (x, 0), 1), XEXP (x, 1))));
4019
4020           if (GET_CODE (x) != MULT)
4021             return x;
4022         }
4023       break;
4024
4025     case UDIV:
4026       /* If this is a divide by a power of two, treat it as a shift if
4027          its first operand is a shift.  */
4028       if (GET_CODE (XEXP (x, 1)) == CONST_INT
4029           && (i = exact_log2 (INTVAL (XEXP (x, 1)))) >= 0
4030           && (GET_CODE (XEXP (x, 0)) == ASHIFT
4031               || GET_CODE (XEXP (x, 0)) == LSHIFTRT
4032               || GET_CODE (XEXP (x, 0)) == ASHIFTRT
4033               || GET_CODE (XEXP (x, 0)) == ROTATE
4034               || GET_CODE (XEXP (x, 0)) == ROTATERT))
4035         return simplify_shift_const (NULL_RTX, LSHIFTRT, mode, XEXP (x, 0), i);
4036       break;
4037
4038     case EQ:  case NE:
4039     case GT:  case GTU:  case GE:  case GEU:
4040     case LT:  case LTU:  case LE:  case LEU:
4041       /* If the first operand is a condition code, we can't do anything
4042          with it.  */
4043       if (GET_CODE (XEXP (x, 0)) == COMPARE
4044           || (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) != MODE_CC
4045 #ifdef HAVE_cc0
4046               && XEXP (x, 0) != cc0_rtx
4047 #endif
4048                ))
4049         {
4050           rtx op0 = XEXP (x, 0);
4051           rtx op1 = XEXP (x, 1);
4052           enum rtx_code new_code;
4053
4054           if (GET_CODE (op0) == COMPARE)
4055             op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
4056
4057           /* Simplify our comparison, if possible.  */
4058           new_code = simplify_comparison (code, &op0, &op1);
4059
4060           /* If STORE_FLAG_VALUE is 1, we can convert (ne x 0) to simply X
4061              if only the low-order bit is possibly nonzero in X (such as when
4062              X is a ZERO_EXTRACT of one bit).  Similarly, we can convert EQ to
4063              (xor X 1) or (minus 1 X); we use the former.  Finally, if X is
4064              known to be either 0 or -1, NE becomes a NEG and EQ becomes
4065              (plus X 1).
4066
4067              Remove any ZERO_EXTRACT we made when thinking this was a
4068              comparison.  It may now be simpler to use, e.g., an AND.  If a
4069              ZERO_EXTRACT is indeed appropriate, it will be placed back by
4070              the call to make_compound_operation in the SET case.  */
4071
4072           if (STORE_FLAG_VALUE == 1
4073               && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
4074               && op1 == const0_rtx && nonzero_bits (op0, mode) == 1)
4075             return gen_lowpart_for_combine (mode,
4076                                             expand_compound_operation (op0));
4077
4078           else if (STORE_FLAG_VALUE == 1
4079                    && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
4080                    && op1 == const0_rtx
4081                    && (num_sign_bit_copies (op0, mode)
4082                        == GET_MODE_BITSIZE (mode)))
4083             {
4084               op0 = expand_compound_operation (op0);
4085               return gen_unary (NEG, mode, mode,
4086                                 gen_lowpart_for_combine (mode, op0));
4087             }
4088
4089           else if (STORE_FLAG_VALUE == 1
4090                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
4091                    && op1 == const0_rtx
4092                    && nonzero_bits (op0, mode) == 1)
4093             {
4094               op0 = expand_compound_operation (op0);
4095               return gen_binary (XOR, mode,
4096                                  gen_lowpart_for_combine (mode, op0),
4097                                  const1_rtx);
4098             }
4099
4100           else if (STORE_FLAG_VALUE == 1
4101                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
4102                    && op1 == const0_rtx
4103                    && (num_sign_bit_copies (op0, mode)
4104                        == GET_MODE_BITSIZE (mode)))
4105             {
4106               op0 = expand_compound_operation (op0);
4107               return plus_constant (gen_lowpart_for_combine (mode, op0), 1);
4108             }
4109
4110           /* If STORE_FLAG_VALUE is -1, we have cases similar to
4111              those above.  */
4112           if (STORE_FLAG_VALUE == -1
4113               && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
4114               && op1 == const0_rtx
4115               && (num_sign_bit_copies (op0, mode)
4116                   == GET_MODE_BITSIZE (mode)))
4117             return gen_lowpart_for_combine (mode,
4118                                             expand_compound_operation (op0));
4119
4120           else if (STORE_FLAG_VALUE == -1
4121                    && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
4122                    && op1 == const0_rtx
4123                    && nonzero_bits (op0, mode) == 1)
4124             {
4125               op0 = expand_compound_operation (op0);
4126               return gen_unary (NEG, mode, mode,
4127                                 gen_lowpart_for_combine (mode, op0));
4128             }
4129
4130           else if (STORE_FLAG_VALUE == -1
4131                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
4132                    && op1 == const0_rtx
4133                    && (num_sign_bit_copies (op0, mode)
4134                        == GET_MODE_BITSIZE (mode)))
4135             {
4136               op0 = expand_compound_operation (op0);
4137               return gen_unary (NOT, mode, mode,
4138                                 gen_lowpart_for_combine (mode, op0));
4139             }
4140
4141           /* If X is 0/1, (eq X 0) is X-1.  */
4142           else if (STORE_FLAG_VALUE == -1
4143                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
4144                    && op1 == const0_rtx
4145                    && nonzero_bits (op0, mode) == 1)
4146             {
4147               op0 = expand_compound_operation (op0);
4148               return plus_constant (gen_lowpart_for_combine (mode, op0), -1);
4149             }
4150
4151           /* If STORE_FLAG_VALUE says to just test the sign bit and X has just
4152              one bit that might be nonzero, we can convert (ne x 0) to
4153              (ashift x c) where C puts the bit in the sign bit.  Remove any
4154              AND with STORE_FLAG_VALUE when we are done, since we are only
4155              going to test the sign bit.  */
4156           if (new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
4157               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4158               && ((STORE_FLAG_VALUE & GET_MODE_MASK (mode))
4159                   == (unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE(mode)-1))
4160               && op1 == const0_rtx
4161               && mode == GET_MODE (op0)
4162               && (i = exact_log2 (nonzero_bits (op0, mode))) >= 0)
4163             {
4164               x = simplify_shift_const (NULL_RTX, ASHIFT, mode,
4165                                         expand_compound_operation (op0),
4166                                         GET_MODE_BITSIZE (mode) - 1 - i);
4167               if (GET_CODE (x) == AND && XEXP (x, 1) == const_true_rtx)
4168                 return XEXP (x, 0);
4169               else
4170                 return x;
4171             }
4172
4173           /* If the code changed, return a whole new comparison.  */
4174           if (new_code != code)
4175             return gen_rtx_combine (new_code, mode, op0, op1);
4176
4177           /* Otherwise, keep this operation, but maybe change its operands.
4178              This also converts (ne (compare FOO BAR) 0) to (ne FOO BAR).  */
4179           SUBST (XEXP (x, 0), op0);
4180           SUBST (XEXP (x, 1), op1);
4181         }
4182       break;
4183
4184     case IF_THEN_ELSE:
4185       return simplify_if_then_else (x);
4186
4187     case ZERO_EXTRACT:
4188     case SIGN_EXTRACT:
4189     case ZERO_EXTEND:
4190     case SIGN_EXTEND:
4191       /* If we are processing SET_DEST, we are done.  */
4192       if (in_dest)
4193         return x;
4194
4195       return expand_compound_operation (x);
4196
4197     case SET:
4198       return simplify_set (x);
4199
4200     case AND:
4201     case IOR:
4202     case XOR:
4203       return simplify_logical (x, last);
4204
4205     case ABS:
4206       /* (abs (neg <foo>)) -> (abs <foo>) */
4207       if (GET_CODE (XEXP (x, 0)) == NEG)
4208         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
4209
4210       /* If the mode of the operand is VOIDmode (i.e. if it is ASM_OPERANDS),
4211          do nothing.  */
4212       if (GET_MODE (XEXP (x, 0)) == VOIDmode)
4213         break;
4214
4215       /* If operand is something known to be positive, ignore the ABS.  */
4216       if (GET_CODE (XEXP (x, 0)) == FFS || GET_CODE (XEXP (x, 0)) == ABS
4217           || ((GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
4218                <= HOST_BITS_PER_WIDE_INT)
4219               && ((nonzero_bits (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
4220                    & ((HOST_WIDE_INT) 1
4221                       << (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - 1)))
4222                   == 0)))
4223         return XEXP (x, 0);
4224
4225
4226       /* If operand is known to be only -1 or 0, convert ABS to NEG.  */
4227       if (num_sign_bit_copies (XEXP (x, 0), mode) == GET_MODE_BITSIZE (mode))
4228         return gen_rtx_combine (NEG, mode, XEXP (x, 0));
4229
4230       break;
4231
4232     case FFS:
4233       /* (ffs (*_extend <X>)) = (ffs <X>) */
4234       if (GET_CODE (XEXP (x, 0)) == SIGN_EXTEND
4235           || GET_CODE (XEXP (x, 0)) == ZERO_EXTEND)
4236         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
4237       break;
4238
4239     case FLOAT:
4240       /* (float (sign_extend <X>)) = (float <X>).  */
4241       if (GET_CODE (XEXP (x, 0)) == SIGN_EXTEND)
4242         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
4243       break;
4244
4245     case ASHIFT:
4246     case LSHIFTRT:
4247     case ASHIFTRT:
4248     case ROTATE:
4249     case ROTATERT:
4250       /* If this is a shift by a constant amount, simplify it.  */
4251       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
4252         return simplify_shift_const (x, code, mode, XEXP (x, 0),
4253                                      INTVAL (XEXP (x, 1)));
4254
4255 #ifdef SHIFT_COUNT_TRUNCATED
4256       else if (SHIFT_COUNT_TRUNCATED && GET_CODE (XEXP (x, 1)) != REG)
4257         SUBST (XEXP (x, 1),
4258                force_to_mode (XEXP (x, 1), GET_MODE (x),
4259                               ((HOST_WIDE_INT) 1
4260                                << exact_log2 (GET_MODE_BITSIZE (GET_MODE (x))))
4261                               - 1,
4262                               NULL_RTX, 0));
4263 #endif
4264
4265       break;
4266
4267     default:
4268       break;
4269     }
4270
4271   return x;
4272 }
4273 \f
4274 /* Simplify X, an IF_THEN_ELSE expression.  Return the new expression.  */
4275
4276 static rtx
4277 simplify_if_then_else (x)
4278      rtx x;
4279 {
4280   enum machine_mode mode = GET_MODE (x);
4281   rtx cond = XEXP (x, 0);
4282   rtx true = XEXP (x, 1);
4283   rtx false = XEXP (x, 2);
4284   enum rtx_code true_code = GET_CODE (cond);
4285   int comparison_p = GET_RTX_CLASS (true_code) == '<';
4286   rtx temp;
4287   int i;
4288
4289   /* Simplify storing of the truth value.  */
4290   if (comparison_p && true == const_true_rtx && false == const0_rtx)
4291     return gen_binary (true_code, mode, XEXP (cond, 0), XEXP (cond, 1));
4292
4293   /* Also when the truth value has to be reversed.  */
4294   if (comparison_p && reversible_comparison_p (cond)
4295       && true == const0_rtx && false == const_true_rtx)
4296     return gen_binary (reverse_condition (true_code),
4297                        mode, XEXP (cond, 0), XEXP (cond, 1));
4298
4299   /* Sometimes we can simplify the arm of an IF_THEN_ELSE if a register used
4300      in it is being compared against certain values.  Get the true and false
4301      comparisons and see if that says anything about the value of each arm.  */
4302
4303   if (comparison_p && reversible_comparison_p (cond)
4304       && GET_CODE (XEXP (cond, 0)) == REG)
4305     {
4306       HOST_WIDE_INT nzb;
4307       rtx from = XEXP (cond, 0);
4308       enum rtx_code false_code = reverse_condition (true_code);
4309       rtx true_val = XEXP (cond, 1);
4310       rtx false_val = true_val;
4311       int swapped = 0;
4312
4313       /* If FALSE_CODE is EQ, swap the codes and arms.  */
4314
4315       if (false_code == EQ)
4316         {
4317           swapped = 1, true_code = EQ, false_code = NE;
4318           temp = true, true = false, false = temp;
4319         }
4320
4321       /* If we are comparing against zero and the expression being tested has
4322          only a single bit that might be nonzero, that is its value when it is
4323          not equal to zero.  Similarly if it is known to be -1 or 0.  */
4324
4325       if (true_code == EQ && true_val == const0_rtx
4326           && exact_log2 (nzb = nonzero_bits (from, GET_MODE (from))) >= 0)
4327         false_code = EQ, false_val = GEN_INT (nzb);
4328       else if (true_code == EQ && true_val == const0_rtx
4329                && (num_sign_bit_copies (from, GET_MODE (from))
4330                    == GET_MODE_BITSIZE (GET_MODE (from))))
4331         false_code = EQ, false_val = constm1_rtx;
4332
4333       /* Now simplify an arm if we know the value of the register in the
4334          branch and it is used in the arm.  Be careful due to the potential
4335          of locally-shared RTL.  */
4336
4337       if (reg_mentioned_p (from, true))
4338         true = subst (known_cond (copy_rtx (true), true_code, from, true_val),
4339                       pc_rtx, pc_rtx, 0, 0);
4340       if (reg_mentioned_p (from, false))
4341         false = subst (known_cond (copy_rtx (false), false_code,
4342                                    from, false_val),
4343                        pc_rtx, pc_rtx, 0, 0);
4344
4345       SUBST (XEXP (x, 1), swapped ? false : true);
4346       SUBST (XEXP (x, 2), swapped ? true : false);
4347
4348       true = XEXP (x, 1), false = XEXP (x, 2), true_code = GET_CODE (cond);
4349     }
4350
4351   /* If we have (if_then_else FOO (pc) (label_ref BAR)) and FOO can be
4352      reversed, do so to avoid needing two sets of patterns for
4353      subtract-and-branch insns.  Similarly if we have a constant in the true
4354      arm, the false arm is the same as the first operand of the comparison, or
4355      the false arm is more complicated than the true arm.  */
4356
4357   if (comparison_p && reversible_comparison_p (cond)
4358       && (true == pc_rtx
4359           || (CONSTANT_P (true)
4360               && GET_CODE (false) != CONST_INT && false != pc_rtx)
4361           || true == const0_rtx
4362           || (GET_RTX_CLASS (GET_CODE (true)) == 'o'
4363               && GET_RTX_CLASS (GET_CODE (false)) != 'o')
4364           || (GET_CODE (true) == SUBREG
4365               && GET_RTX_CLASS (GET_CODE (SUBREG_REG (true))) == 'o'
4366               && GET_RTX_CLASS (GET_CODE (false)) != 'o')
4367           || reg_mentioned_p (true, false)
4368           || rtx_equal_p (false, XEXP (cond, 0))))
4369     {
4370       true_code = reverse_condition (true_code);
4371       SUBST (XEXP (x, 0),
4372              gen_binary (true_code, GET_MODE (cond), XEXP (cond, 0),
4373                          XEXP (cond, 1)));
4374
4375       SUBST (XEXP (x, 1), false);
4376       SUBST (XEXP (x, 2), true);
4377
4378       temp = true, true = false, false = temp, cond = XEXP (x, 0);
4379
4380       /* It is possible that the conditional has been simplified out.  */
4381       true_code = GET_CODE (cond);
4382       comparison_p = GET_RTX_CLASS (true_code) == '<';
4383     }
4384
4385   /* If the two arms are identical, we don't need the comparison.  */
4386
4387   if (rtx_equal_p (true, false) && ! side_effects_p (cond))
4388     return true;
4389
4390   /* Convert a == b ? b : a to "a".  */
4391   if (true_code == EQ && ! side_effects_p (cond)
4392       && rtx_equal_p (XEXP (cond, 0), false)
4393       && rtx_equal_p (XEXP (cond, 1), true))
4394     return false;
4395   else if (true_code == NE && ! side_effects_p (cond)
4396            && rtx_equal_p (XEXP (cond, 0), true)
4397            && rtx_equal_p (XEXP (cond, 1), false))
4398     return true;
4399
4400   /* Look for cases where we have (abs x) or (neg (abs X)).  */
4401
4402   if (GET_MODE_CLASS (mode) == MODE_INT
4403       && GET_CODE (false) == NEG
4404       && rtx_equal_p (true, XEXP (false, 0))
4405       && comparison_p
4406       && rtx_equal_p (true, XEXP (cond, 0))
4407       && ! side_effects_p (true))
4408     switch (true_code)
4409       {
4410       case GT:
4411       case GE:
4412         return gen_unary (ABS, mode, mode, true);
4413       case LT:
4414       case LE:
4415         return gen_unary (NEG, mode, mode, gen_unary (ABS, mode, mode, true));
4416     default:
4417       break;
4418       }
4419
4420   /* Look for MIN or MAX.  */
4421
4422   if ((! FLOAT_MODE_P (mode) || flag_fast_math)
4423       && comparison_p
4424       && rtx_equal_p (XEXP (cond, 0), true)
4425       && rtx_equal_p (XEXP (cond, 1), false)
4426       && ! side_effects_p (cond))
4427     switch (true_code)
4428       {
4429       case GE:
4430       case GT:
4431         return gen_binary (SMAX, mode, true, false);
4432       case LE:
4433       case LT:
4434         return gen_binary (SMIN, mode, true, false);
4435       case GEU:
4436       case GTU:
4437         return gen_binary (UMAX, mode, true, false);
4438       case LEU:
4439       case LTU:
4440         return gen_binary (UMIN, mode, true, false);
4441       default:
4442         break;
4443       }
4444
4445   /* If we have (if_then_else COND (OP Z C1) Z) and OP is an identity when its
4446      second operand is zero, this can be done as (OP Z (mult COND C2)) where
4447      C2 = C1 * STORE_FLAG_VALUE. Similarly if OP has an outer ZERO_EXTEND or
4448      SIGN_EXTEND as long as Z is already extended (so we don't destroy it).
4449      We can do this kind of thing in some cases when STORE_FLAG_VALUE is
4450      neither 1 or -1, but it isn't worth checking for.  */
4451
4452   if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
4453       && comparison_p && mode != VOIDmode && ! side_effects_p (x))
4454     {
4455       rtx t = make_compound_operation (true, SET);
4456       rtx f = make_compound_operation (false, SET);
4457       rtx cond_op0 = XEXP (cond, 0);
4458       rtx cond_op1 = XEXP (cond, 1);
4459       enum rtx_code op, extend_op = NIL;
4460       enum machine_mode m = mode;
4461       rtx z = 0, c1;
4462
4463       if ((GET_CODE (t) == PLUS || GET_CODE (t) == MINUS
4464            || GET_CODE (t) == IOR || GET_CODE (t) == XOR
4465            || GET_CODE (t) == ASHIFT
4466            || GET_CODE (t) == LSHIFTRT || GET_CODE (t) == ASHIFTRT)
4467           && rtx_equal_p (XEXP (t, 0), f))
4468         c1 = XEXP (t, 1), op = GET_CODE (t), z = f;
4469
4470       /* If an identity-zero op is commutative, check whether there
4471          would be a match if we swapped the operands.  */
4472       else if ((GET_CODE (t) == PLUS || GET_CODE (t) == IOR
4473                 || GET_CODE (t) == XOR)
4474                && rtx_equal_p (XEXP (t, 1), f))
4475         c1 = XEXP (t, 0), op = GET_CODE (t), z = f;
4476       else if (GET_CODE (t) == SIGN_EXTEND
4477                && (GET_CODE (XEXP (t, 0)) == PLUS
4478                    || GET_CODE (XEXP (t, 0)) == MINUS
4479                    || GET_CODE (XEXP (t, 0)) == IOR
4480                    || GET_CODE (XEXP (t, 0)) == XOR
4481                    || GET_CODE (XEXP (t, 0)) == ASHIFT
4482                    || GET_CODE (XEXP (t, 0)) == LSHIFTRT
4483                    || GET_CODE (XEXP (t, 0)) == ASHIFTRT)
4484                && GET_CODE (XEXP (XEXP (t, 0), 0)) == SUBREG
4485                && subreg_lowpart_p (XEXP (XEXP (t, 0), 0))
4486                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 0)), f)
4487                && (num_sign_bit_copies (f, GET_MODE (f))
4488                    > (GET_MODE_BITSIZE (mode)
4489                       - GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (t, 0), 0))))))
4490         {
4491           c1 = XEXP (XEXP (t, 0), 1); z = f; op = GET_CODE (XEXP (t, 0));
4492           extend_op = SIGN_EXTEND;
4493           m = GET_MODE (XEXP (t, 0));
4494         }
4495       else if (GET_CODE (t) == SIGN_EXTEND
4496                && (GET_CODE (XEXP (t, 0)) == PLUS
4497                    || GET_CODE (XEXP (t, 0)) == IOR
4498                    || GET_CODE (XEXP (t, 0)) == XOR)
4499                && GET_CODE (XEXP (XEXP (t, 0), 1)) == SUBREG
4500                && subreg_lowpart_p (XEXP (XEXP (t, 0), 1))
4501                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 1)), f)
4502                && (num_sign_bit_copies (f, GET_MODE (f))
4503                    > (GET_MODE_BITSIZE (mode)
4504                       - GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (t, 0), 1))))))
4505         {
4506           c1 = XEXP (XEXP (t, 0), 0); z = f; op = GET_CODE (XEXP (t, 0));
4507           extend_op = SIGN_EXTEND;
4508           m = GET_MODE (XEXP (t, 0));
4509         }
4510       else if (GET_CODE (t) == ZERO_EXTEND
4511                && (GET_CODE (XEXP (t, 0)) == PLUS
4512                    || GET_CODE (XEXP (t, 0)) == MINUS
4513                    || GET_CODE (XEXP (t, 0)) == IOR
4514                    || GET_CODE (XEXP (t, 0)) == XOR
4515                    || GET_CODE (XEXP (t, 0)) == ASHIFT
4516                    || GET_CODE (XEXP (t, 0)) == LSHIFTRT
4517                    || GET_CODE (XEXP (t, 0)) == ASHIFTRT)
4518                && GET_CODE (XEXP (XEXP (t, 0), 0)) == SUBREG
4519                && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4520                && subreg_lowpart_p (XEXP (XEXP (t, 0), 0))
4521                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 0)), f)
4522                && ((nonzero_bits (f, GET_MODE (f))
4523                     & ~ GET_MODE_MASK (GET_MODE (XEXP (XEXP (t, 0), 0))))
4524                    == 0))
4525         {
4526           c1 = XEXP (XEXP (t, 0), 1); z = f; op = GET_CODE (XEXP (t, 0));
4527           extend_op = ZERO_EXTEND;
4528           m = GET_MODE (XEXP (t, 0));
4529         }
4530       else if (GET_CODE (t) == ZERO_EXTEND
4531                && (GET_CODE (XEXP (t, 0)) == PLUS
4532                    || GET_CODE (XEXP (t, 0)) == IOR
4533                    || GET_CODE (XEXP (t, 0)) == XOR)
4534                && GET_CODE (XEXP (XEXP (t, 0), 1)) == SUBREG
4535                && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4536                && subreg_lowpart_p (XEXP (XEXP (t, 0), 1))
4537                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 1)), f)
4538                && ((nonzero_bits (f, GET_MODE (f))
4539                     & ~ GET_MODE_MASK (GET_MODE (XEXP (XEXP (t, 0), 1))))
4540                    == 0))
4541         {
4542           c1 = XEXP (XEXP (t, 0), 0); z = f; op = GET_CODE (XEXP (t, 0));
4543           extend_op = ZERO_EXTEND;
4544           m = GET_MODE (XEXP (t, 0));
4545         }
4546
4547       if (z)
4548         {
4549           temp = subst (gen_binary (true_code, m, cond_op0, cond_op1),
4550                         pc_rtx, pc_rtx, 0, 0);
4551           temp = gen_binary (MULT, m, temp,
4552                              gen_binary (MULT, m, c1, const_true_rtx));
4553           temp = subst (temp, pc_rtx, pc_rtx, 0, 0);
4554           temp = gen_binary (op, m, gen_lowpart_for_combine (m, z), temp);
4555
4556           if (extend_op != NIL)
4557             temp = gen_unary (extend_op, mode, m, temp);
4558
4559           return temp;
4560         }
4561     }
4562
4563   /* If we have (if_then_else (ne A 0) C1 0) and either A is known to be 0 or
4564      1 and C1 is a single bit or A is known to be 0 or -1 and C1 is the
4565      negation of a single bit, we can convert this operation to a shift.  We
4566      can actually do this more generally, but it doesn't seem worth it.  */
4567
4568   if (true_code == NE && XEXP (cond, 1) == const0_rtx
4569       && false == const0_rtx && GET_CODE (true) == CONST_INT
4570       && ((1 == nonzero_bits (XEXP (cond, 0), mode)
4571            && (i = exact_log2 (INTVAL (true))) >= 0)
4572           || ((num_sign_bit_copies (XEXP (cond, 0), mode)
4573                == GET_MODE_BITSIZE (mode))
4574               && (i = exact_log2 (- INTVAL (true))) >= 0)))
4575     return
4576       simplify_shift_const (NULL_RTX, ASHIFT, mode,
4577                             gen_lowpart_for_combine (mode, XEXP (cond, 0)), i);
4578
4579   return x;
4580 }
4581 \f
4582 /* Simplify X, a SET expression.  Return the new expression.  */
4583
4584 static rtx
4585 simplify_set (x)
4586      rtx x;
4587 {
4588   rtx src = SET_SRC (x);
4589   rtx dest = SET_DEST (x);
4590   enum machine_mode mode
4591     = GET_MODE (src) != VOIDmode ? GET_MODE (src) : GET_MODE (dest);
4592   rtx other_insn;
4593   rtx *cc_use;
4594
4595   /* (set (pc) (return)) gets written as (return).  */
4596   if (GET_CODE (dest) == PC && GET_CODE (src) == RETURN)
4597     return src;
4598
4599   /* Now that we know for sure which bits of SRC we are using, see if we can
4600      simplify the expression for the object knowing that we only need the
4601      low-order bits.  */
4602
4603   if (GET_MODE_CLASS (mode) == MODE_INT)
4604     src = force_to_mode (src, mode, GET_MODE_MASK (mode), NULL_RTX, 0);
4605
4606   /* If we are setting CC0 or if the source is a COMPARE, look for the use of
4607      the comparison result and try to simplify it unless we already have used
4608      undobuf.other_insn.  */
4609   if ((GET_CODE (src) == COMPARE
4610 #ifdef HAVE_cc0
4611        || dest == cc0_rtx
4612 #endif
4613        )
4614       && (cc_use = find_single_use (dest, subst_insn, &other_insn)) != 0
4615       && (undobuf.other_insn == 0 || other_insn == undobuf.other_insn)
4616       && GET_RTX_CLASS (GET_CODE (*cc_use)) == '<'
4617       && rtx_equal_p (XEXP (*cc_use, 0), dest))
4618     {
4619       enum rtx_code old_code = GET_CODE (*cc_use);
4620       enum rtx_code new_code;
4621       rtx op0, op1;
4622       int other_changed = 0;
4623       enum machine_mode compare_mode = GET_MODE (dest);
4624
4625       if (GET_CODE (src) == COMPARE)
4626         op0 = XEXP (src, 0), op1 = XEXP (src, 1);
4627       else
4628         op0 = src, op1 = const0_rtx;
4629
4630       /* Simplify our comparison, if possible.  */
4631       new_code = simplify_comparison (old_code, &op0, &op1);
4632
4633 #ifdef EXTRA_CC_MODES
4634       /* If this machine has CC modes other than CCmode, check to see if we
4635          need to use a different CC mode here.  */
4636       compare_mode = SELECT_CC_MODE (new_code, op0, op1);
4637 #endif /* EXTRA_CC_MODES */
4638
4639 #if !defined (HAVE_cc0) && defined (EXTRA_CC_MODES)
4640       /* If the mode changed, we have to change SET_DEST, the mode in the
4641          compare, and the mode in the place SET_DEST is used.  If SET_DEST is
4642          a hard register, just build new versions with the proper mode.  If it
4643          is a pseudo, we lose unless it is only time we set the pseudo, in
4644          which case we can safely change its mode.  */
4645       if (compare_mode != GET_MODE (dest))
4646         {
4647           int regno = REGNO (dest);
4648           rtx new_dest = gen_rtx_REG (compare_mode, regno);
4649
4650           if (regno < FIRST_PSEUDO_REGISTER
4651               || (REG_N_SETS (regno) == 1 && ! REG_USERVAR_P (dest)))
4652             {
4653               if (regno >= FIRST_PSEUDO_REGISTER)
4654                 SUBST (regno_reg_rtx[regno], new_dest);
4655
4656               SUBST (SET_DEST (x), new_dest);
4657               SUBST (XEXP (*cc_use, 0), new_dest);
4658               other_changed = 1;
4659
4660               dest = new_dest;
4661             }
4662         }
4663 #endif
4664
4665       /* If the code changed, we have to build a new comparison in
4666          undobuf.other_insn.  */
4667       if (new_code != old_code)
4668         {
4669           unsigned HOST_WIDE_INT mask;
4670
4671           SUBST (*cc_use, gen_rtx_combine (new_code, GET_MODE (*cc_use),
4672                                            dest, const0_rtx));
4673
4674           /* If the only change we made was to change an EQ into an NE or
4675              vice versa, OP0 has only one bit that might be nonzero, and OP1
4676              is zero, check if changing the user of the condition code will
4677              produce a valid insn.  If it won't, we can keep the original code
4678              in that insn by surrounding our operation with an XOR.  */
4679
4680           if (((old_code == NE && new_code == EQ)
4681                || (old_code == EQ && new_code == NE))
4682               && ! other_changed && op1 == const0_rtx
4683               && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
4684               && exact_log2 (mask = nonzero_bits (op0, GET_MODE (op0))) >= 0)
4685             {
4686               rtx pat = PATTERN (other_insn), note = 0;
4687
4688               if ((recog_for_combine (&pat, other_insn, &note) < 0
4689                    && ! check_asm_operands (pat)))
4690                 {
4691                   PUT_CODE (*cc_use, old_code);
4692                   other_insn = 0;
4693
4694                   op0 = gen_binary (XOR, GET_MODE (op0), op0, GEN_INT (mask));
4695                 }
4696             }
4697
4698           other_changed = 1;
4699         }
4700
4701       if (other_changed)
4702         undobuf.other_insn = other_insn;
4703
4704 #ifdef HAVE_cc0
4705       /* If we are now comparing against zero, change our source if
4706          needed.  If we do not use cc0, we always have a COMPARE.  */
4707       if (op1 == const0_rtx && dest == cc0_rtx)
4708         {
4709           SUBST (SET_SRC (x), op0);
4710           src = op0;
4711         }
4712       else
4713 #endif
4714
4715       /* Otherwise, if we didn't previously have a COMPARE in the
4716          correct mode, we need one.  */
4717       if (GET_CODE (src) != COMPARE || GET_MODE (src) != compare_mode)
4718         {
4719           SUBST (SET_SRC (x),
4720                  gen_rtx_combine (COMPARE, compare_mode, op0, op1));
4721           src = SET_SRC (x);
4722         }
4723       else
4724         {
4725           /* Otherwise, update the COMPARE if needed.  */
4726           SUBST (XEXP (src, 0), op0);
4727           SUBST (XEXP (src, 1), op1);
4728         }
4729     }
4730   else
4731     {
4732       /* Get SET_SRC in a form where we have placed back any
4733          compound expressions.  Then do the checks below.  */
4734       src = make_compound_operation (src, SET);
4735       SUBST (SET_SRC (x), src);
4736     }
4737
4738   /* If we have (set x (subreg:m1 (op:m2 ...) 0)) with OP being some operation,
4739      and X being a REG or (subreg (reg)), we may be able to convert this to
4740      (set (subreg:m2 x) (op)).
4741
4742      We can always do this if M1 is narrower than M2 because that means that
4743      we only care about the low bits of the result.
4744
4745      However, on machines without WORD_REGISTER_OPERATIONS defined, we cannot
4746      perform a narrower operation than requested since the high-order bits will
4747      be undefined.  On machine where it is defined, this transformation is safe
4748      as long as M1 and M2 have the same number of words.  */
4749
4750   if (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)
4751       && GET_RTX_CLASS (GET_CODE (SUBREG_REG (src))) != 'o'
4752       && (((GET_MODE_SIZE (GET_MODE (src)) + (UNITS_PER_WORD - 1))
4753            / UNITS_PER_WORD)
4754           == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (src)))
4755                + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
4756 #ifndef WORD_REGISTER_OPERATIONS
4757       && (GET_MODE_SIZE (GET_MODE (src))
4758           < GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))
4759 #endif
4760 #ifdef CLASS_CANNOT_CHANGE_SIZE
4761       && ! (GET_CODE (dest) == REG && REGNO (dest) < FIRST_PSEUDO_REGISTER
4762             && (TEST_HARD_REG_BIT
4763                 (reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE],
4764                  REGNO (dest)))
4765             && (GET_MODE_SIZE (GET_MODE (src))
4766                 != GET_MODE_SIZE (GET_MODE (SUBREG_REG (src)))))
4767 #endif
4768       && (GET_CODE (dest) == REG
4769           || (GET_CODE (dest) == SUBREG
4770               && GET_CODE (SUBREG_REG (dest)) == REG)))
4771     {
4772       SUBST (SET_DEST (x),
4773              gen_lowpart_for_combine (GET_MODE (SUBREG_REG (src)),
4774                                       dest));
4775       SUBST (SET_SRC (x), SUBREG_REG (src));
4776
4777       src = SET_SRC (x), dest = SET_DEST (x);
4778     }
4779
4780 #ifdef LOAD_EXTEND_OP
4781   /* If we have (set FOO (subreg:M (mem:N BAR) 0)) with M wider than N, this
4782      would require a paradoxical subreg.  Replace the subreg with a
4783      zero_extend to avoid the reload that would otherwise be required.  */
4784
4785   if (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)
4786       && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (src))) != NIL
4787       && SUBREG_WORD (src) == 0
4788       && (GET_MODE_SIZE (GET_MODE (src))
4789           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))
4790       && GET_CODE (SUBREG_REG (src)) == MEM)
4791     {
4792       SUBST (SET_SRC (x),
4793              gen_rtx_combine (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (src))),
4794                               GET_MODE (src), XEXP (src, 0)));
4795
4796       src = SET_SRC (x);
4797     }
4798 #endif
4799
4800   /* If we don't have a conditional move, SET_SRC is an IF_THEN_ELSE, and we
4801      are comparing an item known to be 0 or -1 against 0, use a logical
4802      operation instead. Check for one of the arms being an IOR of the other
4803      arm with some value.  We compute three terms to be IOR'ed together.  In
4804      practice, at most two will be nonzero.  Then we do the IOR's.  */
4805
4806   if (GET_CODE (dest) != PC
4807       && GET_CODE (src) == IF_THEN_ELSE
4808       && GET_MODE_CLASS (GET_MODE (src)) == MODE_INT
4809       && (GET_CODE (XEXP (src, 0)) == EQ || GET_CODE (XEXP (src, 0)) == NE)
4810       && XEXP (XEXP (src, 0), 1) == const0_rtx
4811       && GET_MODE (src) == GET_MODE (XEXP (XEXP (src, 0), 0))
4812 #ifdef HAVE_conditional_move
4813       && ! can_conditionally_move_p (GET_MODE (src))
4814 #endif
4815       && (num_sign_bit_copies (XEXP (XEXP (src, 0), 0),
4816                                GET_MODE (XEXP (XEXP (src, 0), 0)))
4817           == GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (src, 0), 0))))
4818       && ! side_effects_p (src))
4819     {
4820       rtx true = (GET_CODE (XEXP (src, 0)) == NE
4821                       ? XEXP (src, 1) : XEXP (src, 2));
4822       rtx false = (GET_CODE (XEXP (src, 0)) == NE
4823                    ? XEXP (src, 2) : XEXP (src, 1));
4824       rtx term1 = const0_rtx, term2, term3;
4825
4826       if (GET_CODE (true) == IOR && rtx_equal_p (XEXP (true, 0), false))
4827         term1 = false, true = XEXP (true, 1), false = const0_rtx;
4828       else if (GET_CODE (true) == IOR
4829                && rtx_equal_p (XEXP (true, 1), false))
4830         term1 = false, true = XEXP (true, 0), false = const0_rtx;
4831       else if (GET_CODE (false) == IOR
4832                && rtx_equal_p (XEXP (false, 0), true))
4833         term1 = true, false = XEXP (false, 1), true = const0_rtx;
4834       else if (GET_CODE (false) == IOR
4835                && rtx_equal_p (XEXP (false, 1), true))
4836         term1 = true, false = XEXP (false, 0), true = const0_rtx;
4837
4838       term2 = gen_binary (AND, GET_MODE (src), XEXP (XEXP (src, 0), 0), true);
4839       term3 = gen_binary (AND, GET_MODE (src),
4840                           gen_unary (NOT, GET_MODE (src), GET_MODE (src),
4841                                      XEXP (XEXP (src, 0), 0)),
4842                           false);
4843
4844       SUBST (SET_SRC (x),
4845              gen_binary (IOR, GET_MODE (src),
4846                          gen_binary (IOR, GET_MODE (src), term1, term2),
4847                          term3));
4848
4849       src = SET_SRC (x);
4850     }
4851
4852   /* If either SRC or DEST is a CLOBBER of (const_int 0), make this
4853      whole thing fail.  */
4854   if (GET_CODE (src) == CLOBBER && XEXP (src, 0) == const0_rtx)
4855     return src;
4856   else if (GET_CODE (dest) == CLOBBER && XEXP (dest, 0) == const0_rtx)
4857     return dest;
4858   else
4859     /* Convert this into a field assignment operation, if possible.  */
4860     return make_field_assignment (x);
4861 }
4862 \f
4863 /* Simplify, X, and AND, IOR, or XOR operation, and return the simplified
4864    result.  LAST is nonzero if this is the last retry.  */
4865
4866 static rtx
4867 simplify_logical (x, last)
4868      rtx x;
4869      int last;
4870 {
4871   enum machine_mode mode = GET_MODE (x);
4872   rtx op0 = XEXP (x, 0);
4873   rtx op1 = XEXP (x, 1);
4874
4875   switch (GET_CODE (x))
4876     {
4877     case AND:
4878       /* Convert (A ^ B) & A to A & (~ B) since the latter is often a single
4879          insn (and may simplify more).  */
4880       if (GET_CODE (op0) == XOR
4881           && rtx_equal_p (XEXP (op0, 0), op1)
4882           && ! side_effects_p (op1))
4883         x = gen_binary (AND, mode,
4884                         gen_unary (NOT, mode, mode, XEXP (op0, 1)), op1);
4885
4886       if (GET_CODE (op0) == XOR
4887           && rtx_equal_p (XEXP (op0, 1), op1)
4888           && ! side_effects_p (op1))
4889         x = gen_binary (AND, mode,
4890                         gen_unary (NOT, mode, mode, XEXP (op0, 0)), op1);
4891
4892       /* Similarly for (~ (A ^ B)) & A.  */
4893       if (GET_CODE (op0) == NOT
4894           && GET_CODE (XEXP (op0, 0)) == XOR
4895           && rtx_equal_p (XEXP (XEXP (op0, 0), 0), op1)
4896           && ! side_effects_p (op1))
4897         x = gen_binary (AND, mode, XEXP (XEXP (op0, 0), 1), op1);
4898
4899       if (GET_CODE (op0) == NOT
4900           && GET_CODE (XEXP (op0, 0)) == XOR
4901           && rtx_equal_p (XEXP (XEXP (op0, 0), 1), op1)
4902           && ! side_effects_p (op1))
4903         x = gen_binary (AND, mode, XEXP (XEXP (op0, 0), 0), op1);
4904
4905       /* We can call simplify_and_const_int only if we don't lose
4906          any (sign) bits when converting INTVAL (op1) to
4907          "unsigned HOST_WIDE_INT".  */
4908       if (GET_CODE (op1) == CONST_INT
4909           && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4910               || INTVAL (op1) > 0))
4911         {
4912           x = simplify_and_const_int (x, mode, op0, INTVAL (op1));
4913
4914           /* If we have (ior (and (X C1) C2)) and the next restart would be
4915              the last, simplify this by making C1 as small as possible
4916              and then exit.  */
4917           if (last
4918               && GET_CODE (x) == IOR && GET_CODE (op0) == AND
4919               && GET_CODE (XEXP (op0, 1)) == CONST_INT
4920               && GET_CODE (op1) == CONST_INT)
4921             return gen_binary (IOR, mode,
4922                                gen_binary (AND, mode, XEXP (op0, 0),
4923                                            GEN_INT (INTVAL (XEXP (op0, 1))
4924                                                     & ~ INTVAL (op1))), op1);
4925
4926           if (GET_CODE (x) != AND)
4927             return x;
4928
4929           if (GET_RTX_CLASS (GET_CODE (x)) == 'c'
4930               || GET_RTX_CLASS (GET_CODE (x)) == '2')
4931             op0 = XEXP (x, 0), op1 = XEXP (x, 1);
4932         }
4933
4934       /* Convert (A | B) & A to A.  */
4935       if (GET_CODE (op0) == IOR
4936           && (rtx_equal_p (XEXP (op0, 0), op1)
4937               || rtx_equal_p (XEXP (op0, 1), op1))
4938           && ! side_effects_p (XEXP (op0, 0))
4939           && ! side_effects_p (XEXP (op0, 1)))
4940         return op1;
4941
4942       /* In the following group of tests (and those in case IOR below),
4943          we start with some combination of logical operations and apply
4944          the distributive law followed by the inverse distributive law.
4945          Most of the time, this results in no change.  However, if some of
4946          the operands are the same or inverses of each other, simplifications
4947          will result.
4948
4949          For example, (and (ior A B) (not B)) can occur as the result of
4950          expanding a bit field assignment.  When we apply the distributive
4951          law to this, we get (ior (and (A (not B))) (and (B (not B)))),
4952          which then simplifies to (and (A (not B))).
4953
4954          If we have (and (ior A B) C), apply the distributive law and then
4955          the inverse distributive law to see if things simplify.  */
4956
4957       if (GET_CODE (op0) == IOR || GET_CODE (op0) == XOR)
4958         {
4959           x = apply_distributive_law
4960             (gen_binary (GET_CODE (op0), mode,
4961                          gen_binary (AND, mode, XEXP (op0, 0), op1),
4962                          gen_binary (AND, mode, XEXP (op0, 1), op1)));
4963           if (GET_CODE (x) != AND)
4964             return x;
4965         }
4966
4967       if (GET_CODE (op1) == IOR || GET_CODE (op1) == XOR)
4968         return apply_distributive_law
4969           (gen_binary (GET_CODE (op1), mode,
4970                        gen_binary (AND, mode, XEXP (op1, 0), op0),
4971                        gen_binary (AND, mode, XEXP (op1, 1), op0)));
4972
4973       /* Similarly, taking advantage of the fact that
4974          (and (not A) (xor B C)) == (xor (ior A B) (ior A C))  */
4975
4976       if (GET_CODE (op0) == NOT && GET_CODE (op1) == XOR)
4977         return apply_distributive_law
4978           (gen_binary (XOR, mode,
4979                        gen_binary (IOR, mode, XEXP (op0, 0), XEXP (op1, 0)),
4980                        gen_binary (IOR, mode, XEXP (op0, 0), XEXP (op1, 1))));
4981
4982       else if (GET_CODE (op1) == NOT && GET_CODE (op0) == XOR)
4983         return apply_distributive_law
4984           (gen_binary (XOR, mode,
4985                        gen_binary (IOR, mode, XEXP (op1, 0), XEXP (op0, 0)),
4986                        gen_binary (IOR, mode, XEXP (op1, 0), XEXP (op0, 1))));
4987       break;
4988
4989     case IOR:
4990       /* (ior A C) is C if all bits of A that might be nonzero are on in C.  */
4991       if (GET_CODE (op1) == CONST_INT
4992           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4993           && (nonzero_bits (op0, mode) & ~ INTVAL (op1)) == 0)
4994         return op1;
4995
4996       /* Convert (A & B) | A to A.  */
4997       if (GET_CODE (op0) == AND
4998           && (rtx_equal_p (XEXP (op0, 0), op1)
4999               || rtx_equal_p (XEXP (op0, 1), op1))
5000           && ! side_effects_p (XEXP (op0, 0))
5001           && ! side_effects_p (XEXP (op0, 1)))
5002         return op1;
5003
5004       /* If we have (ior (and A B) C), apply the distributive law and then
5005          the inverse distributive law to see if things simplify.  */
5006
5007       if (GET_CODE (op0) == AND)
5008         {
5009           x = apply_distributive_law
5010             (gen_binary (AND, mode,
5011                          gen_binary (IOR, mode, XEXP (op0, 0), op1),
5012                          gen_binary (IOR, mode, XEXP (op0, 1), op1)));
5013
5014           if (GET_CODE (x) != IOR)
5015             return x;
5016         }
5017
5018       if (GET_CODE (op1) == AND)
5019         {
5020           x = apply_distributive_law
5021             (gen_binary (AND, mode,
5022                          gen_binary (IOR, mode, XEXP (op1, 0), op0),
5023                          gen_binary (IOR, mode, XEXP (op1, 1), op0)));
5024
5025           if (GET_CODE (x) != IOR)
5026             return x;
5027         }
5028
5029       /* Convert (ior (ashift A CX) (lshiftrt A CY)) where CX+CY equals the
5030          mode size to (rotate A CX).  */
5031
5032       if (((GET_CODE (op0) == ASHIFT && GET_CODE (op1) == LSHIFTRT)
5033            || (GET_CODE (op1) == ASHIFT && GET_CODE (op0) == LSHIFTRT))
5034           && rtx_equal_p (XEXP (op0, 0), XEXP (op1, 0))
5035           && GET_CODE (XEXP (op0, 1)) == CONST_INT
5036           && GET_CODE (XEXP (op1, 1)) == CONST_INT
5037           && (INTVAL (XEXP (op0, 1)) + INTVAL (XEXP (op1, 1))
5038               == GET_MODE_BITSIZE (mode)))
5039         return gen_rtx_ROTATE (mode, XEXP (op0, 0),
5040                                (GET_CODE (op0) == ASHIFT
5041                                 ? XEXP (op0, 1) : XEXP (op1, 1)));
5042
5043       /* If OP0 is (ashiftrt (plus ...) C), it might actually be
5044          a (sign_extend (plus ...)).  If so, OP1 is a CONST_INT, and the PLUS
5045          does not affect any of the bits in OP1, it can really be done
5046          as a PLUS and we can associate.  We do this by seeing if OP1
5047          can be safely shifted left C bits.  */
5048       if (GET_CODE (op1) == CONST_INT && GET_CODE (op0) == ASHIFTRT
5049           && GET_CODE (XEXP (op0, 0)) == PLUS
5050           && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
5051           && GET_CODE (XEXP (op0, 1)) == CONST_INT
5052           && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT)
5053         {
5054           int count = INTVAL (XEXP (op0, 1));
5055           HOST_WIDE_INT mask = INTVAL (op1) << count;
5056
5057           if (mask >> count == INTVAL (op1)
5058               && (mask & nonzero_bits (XEXP (op0, 0), mode)) == 0)
5059             {
5060               SUBST (XEXP (XEXP (op0, 0), 1),
5061                      GEN_INT (INTVAL (XEXP (XEXP (op0, 0), 1)) | mask));
5062               return op0;
5063             }
5064         }
5065       break;
5066
5067     case XOR:
5068       /* Convert (XOR (NOT x) (NOT y)) to (XOR x y).
5069          Also convert (XOR (NOT x) y) to (NOT (XOR x y)), similarly for
5070          (NOT y).  */
5071       {
5072         int num_negated = 0;
5073
5074         if (GET_CODE (op0) == NOT)
5075           num_negated++, op0 = XEXP (op0, 0);
5076         if (GET_CODE (op1) == NOT)
5077           num_negated++, op1 = XEXP (op1, 0);
5078
5079         if (num_negated == 2)
5080           {
5081             SUBST (XEXP (x, 0), op0);
5082             SUBST (XEXP (x, 1), op1);
5083           }
5084         else if (num_negated == 1)
5085           return gen_unary (NOT, mode, mode, gen_binary (XOR, mode, op0, op1));
5086       }
5087
5088       /* Convert (xor (and A B) B) to (and (not A) B).  The latter may
5089          correspond to a machine insn or result in further simplifications
5090          if B is a constant.  */
5091
5092       if (GET_CODE (op0) == AND
5093           && rtx_equal_p (XEXP (op0, 1), op1)
5094           && ! side_effects_p (op1))
5095         return gen_binary (AND, mode,
5096                            gen_unary (NOT, mode, mode, XEXP (op0, 0)),
5097                            op1);
5098
5099       else if (GET_CODE (op0) == AND
5100                && rtx_equal_p (XEXP (op0, 0), op1)
5101                && ! side_effects_p (op1))
5102         return gen_binary (AND, mode,
5103                            gen_unary (NOT, mode, mode, XEXP (op0, 1)),
5104                            op1);
5105
5106       /* (xor (comparison foo bar) (const_int 1)) can become the reversed
5107          comparison if STORE_FLAG_VALUE is 1.  */
5108       if (STORE_FLAG_VALUE == 1
5109           && op1 == const1_rtx
5110           && GET_RTX_CLASS (GET_CODE (op0)) == '<'
5111           && reversible_comparison_p (op0))
5112         return gen_rtx_combine (reverse_condition (GET_CODE (op0)),
5113                                 mode, XEXP (op0, 0), XEXP (op0, 1));
5114
5115       /* (lshiftrt foo C) where C is the number of bits in FOO minus 1
5116          is (lt foo (const_int 0)), so we can perform the above
5117          simplification if STORE_FLAG_VALUE is 1.  */
5118
5119       if (STORE_FLAG_VALUE == 1
5120           && op1 == const1_rtx
5121           && GET_CODE (op0) == LSHIFTRT
5122           && GET_CODE (XEXP (op0, 1)) == CONST_INT
5123           && INTVAL (XEXP (op0, 1)) == GET_MODE_BITSIZE (mode) - 1)
5124         return gen_rtx_combine (GE, mode, XEXP (op0, 0), const0_rtx);
5125
5126       /* (xor (comparison foo bar) (const_int sign-bit))
5127          when STORE_FLAG_VALUE is the sign bit.  */
5128       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5129           && ((STORE_FLAG_VALUE & GET_MODE_MASK (mode))
5130               == (unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (mode) - 1))
5131           && op1 == const_true_rtx
5132           && GET_RTX_CLASS (GET_CODE (op0)) == '<'
5133           && reversible_comparison_p (op0))
5134         return gen_rtx_combine (reverse_condition (GET_CODE (op0)),
5135                                 mode, XEXP (op0, 0), XEXP (op0, 1));
5136       break;
5137
5138     default:
5139       abort ();
5140     }
5141
5142   return x;
5143 }
5144 \f
5145 /* We consider ZERO_EXTRACT, SIGN_EXTRACT, and SIGN_EXTEND as "compound
5146    operations" because they can be replaced with two more basic operations.
5147    ZERO_EXTEND is also considered "compound" because it can be replaced with
5148    an AND operation, which is simpler, though only one operation.
5149
5150    The function expand_compound_operation is called with an rtx expression
5151    and will convert it to the appropriate shifts and AND operations,
5152    simplifying at each stage.
5153
5154    The function make_compound_operation is called to convert an expression
5155    consisting of shifts and ANDs into the equivalent compound expression.
5156    It is the inverse of this function, loosely speaking.  */
5157
5158 static rtx
5159 expand_compound_operation (x)
5160      rtx x;
5161 {
5162   int pos = 0, len;
5163   int unsignedp = 0;
5164   int modewidth;
5165   rtx tem;
5166
5167   switch (GET_CODE (x))
5168     {
5169     case ZERO_EXTEND:
5170       unsignedp = 1;
5171     case SIGN_EXTEND:
5172       /* We can't necessarily use a const_int for a multiword mode;
5173          it depends on implicitly extending the value.
5174          Since we don't know the right way to extend it,
5175          we can't tell whether the implicit way is right.
5176
5177          Even for a mode that is no wider than a const_int,
5178          we can't win, because we need to sign extend one of its bits through
5179          the rest of it, and we don't know which bit.  */
5180       if (GET_CODE (XEXP (x, 0)) == CONST_INT)
5181         return x;
5182
5183       /* Return if (subreg:MODE FROM 0) is not a safe replacement for
5184          (zero_extend:MODE FROM) or (sign_extend:MODE FROM).  It is for any MEM
5185          because (SUBREG (MEM...)) is guaranteed to cause the MEM to be
5186          reloaded. If not for that, MEM's would very rarely be safe.
5187
5188          Reject MODEs bigger than a word, because we might not be able
5189          to reference a two-register group starting with an arbitrary register
5190          (and currently gen_lowpart might crash for a SUBREG).  */
5191
5192       if (GET_MODE_SIZE (GET_MODE (XEXP (x, 0))) > UNITS_PER_WORD)
5193         return x;
5194
5195       len = GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)));
5196       /* If the inner object has VOIDmode (the only way this can happen
5197          is if it is a ASM_OPERANDS), we can't do anything since we don't
5198          know how much masking to do.  */
5199       if (len == 0)
5200         return x;
5201
5202       break;
5203
5204     case ZERO_EXTRACT:
5205       unsignedp = 1;
5206     case SIGN_EXTRACT:
5207       /* If the operand is a CLOBBER, just return it.  */
5208       if (GET_CODE (XEXP (x, 0)) == CLOBBER)
5209         return XEXP (x, 0);
5210
5211       if (GET_CODE (XEXP (x, 1)) != CONST_INT
5212           || GET_CODE (XEXP (x, 2)) != CONST_INT
5213           || GET_MODE (XEXP (x, 0)) == VOIDmode)
5214         return x;
5215
5216       len = INTVAL (XEXP (x, 1));
5217       pos = INTVAL (XEXP (x, 2));
5218
5219       /* If this goes outside the object being extracted, replace the object
5220          with a (use (mem ...)) construct that only combine understands
5221          and is used only for this purpose.  */
5222       if (len + pos > GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))))
5223         SUBST (XEXP (x, 0), gen_rtx_USE (GET_MODE (x), XEXP (x, 0)));
5224
5225       if (BITS_BIG_ENDIAN)
5226         pos = GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - len - pos;
5227
5228       break;
5229
5230     default:
5231       return x;
5232     }
5233
5234   /* We can optimize some special cases of ZERO_EXTEND.  */
5235   if (GET_CODE (x) == ZERO_EXTEND)
5236     {
5237       /* (zero_extend:DI (truncate:SI foo:DI)) is just foo:DI if we
5238          know that the last value didn't have any inappropriate bits
5239          set.  */
5240       if (GET_CODE (XEXP (x, 0)) == TRUNCATE
5241           && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
5242           && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
5243           && (nonzero_bits (XEXP (XEXP (x, 0), 0), GET_MODE (x))
5244               & ~ GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
5245         return XEXP (XEXP (x, 0), 0);
5246
5247       /* Likewise for (zero_extend:DI (subreg:SI foo:DI 0)).  */
5248       if (GET_CODE (XEXP (x, 0)) == SUBREG
5249           && GET_MODE (SUBREG_REG (XEXP (x, 0))) == GET_MODE (x)
5250           && subreg_lowpart_p (XEXP (x, 0))
5251           && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
5252           && (nonzero_bits (SUBREG_REG (XEXP (x, 0)), GET_MODE (x))
5253               & ~ GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
5254         return SUBREG_REG (XEXP (x, 0));
5255
5256       /* (zero_extend:DI (truncate:SI foo:DI)) is just foo:DI when foo
5257          is a comparison and STORE_FLAG_VALUE permits.  This is like
5258          the first case, but it works even when GET_MODE (x) is larger
5259          than HOST_WIDE_INT.  */
5260       if (GET_CODE (XEXP (x, 0)) == TRUNCATE
5261           && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
5262           && GET_RTX_CLASS (GET_CODE (XEXP (XEXP (x, 0), 0))) == '<'
5263           && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
5264               <= HOST_BITS_PER_WIDE_INT)
5265           && ((HOST_WIDE_INT) STORE_FLAG_VALUE
5266               & ~ GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
5267         return XEXP (XEXP (x, 0), 0);
5268
5269       /* Likewise for (zero_extend:DI (subreg:SI foo:DI 0)).  */
5270       if (GET_CODE (XEXP (x, 0)) == SUBREG
5271           && GET_MODE (SUBREG_REG (XEXP (x, 0))) == GET_MODE (x)
5272           && subreg_lowpart_p (XEXP (x, 0))
5273           && GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (x, 0)))) == '<'
5274           && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
5275               <= HOST_BITS_PER_WIDE_INT)
5276           && ((HOST_WIDE_INT) STORE_FLAG_VALUE
5277               & ~ GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
5278         return SUBREG_REG (XEXP (x, 0));
5279
5280       /* If sign extension is cheaper than zero extension, then use it
5281          if we know that no extraneous bits are set, and that the high
5282          bit is not set.  */
5283       if (flag_expensive_optimizations
5284           && ((GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
5285                && ((nonzero_bits (XEXP (x, 0), GET_MODE (x))
5286                     & ~ (((unsigned HOST_WIDE_INT)
5287                           GET_MODE_MASK (GET_MODE (XEXP (x, 0))))
5288                          >> 1))
5289                    == 0))
5290               || (GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) == '<'
5291                   && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
5292                       <= HOST_BITS_PER_WIDE_INT)
5293                   && (((HOST_WIDE_INT) STORE_FLAG_VALUE
5294                        & ~ (((unsigned HOST_WIDE_INT)
5295                              GET_MODE_MASK (GET_MODE (XEXP (x, 0))))
5296                             >> 1))
5297                       == 0))))
5298         {
5299           rtx temp = gen_rtx_SIGN_EXTEND (GET_MODE (x), XEXP (x, 0));
5300
5301           if (rtx_cost (temp, SET) < rtx_cost (x, SET))
5302             return expand_compound_operation (temp);
5303         }
5304     }
5305
5306   /* If we reach here, we want to return a pair of shifts.  The inner
5307      shift is a left shift of BITSIZE - POS - LEN bits.  The outer
5308      shift is a right shift of BITSIZE - LEN bits.  It is arithmetic or
5309      logical depending on the value of UNSIGNEDP.
5310
5311      If this was a ZERO_EXTEND or ZERO_EXTRACT, this pair of shifts will be
5312      converted into an AND of a shift.
5313
5314      We must check for the case where the left shift would have a negative
5315      count.  This can happen in a case like (x >> 31) & 255 on machines
5316      that can't shift by a constant.  On those machines, we would first
5317      combine the shift with the AND to produce a variable-position
5318      extraction.  Then the constant of 31 would be substituted in to produce
5319      a such a position.  */
5320
5321   modewidth = GET_MODE_BITSIZE (GET_MODE (x));
5322   if (modewidth >= pos - len)
5323     tem = simplify_shift_const (NULL_RTX, unsignedp ? LSHIFTRT : ASHIFTRT,
5324                                 GET_MODE (x),
5325                                 simplify_shift_const (NULL_RTX, ASHIFT,
5326                                                       GET_MODE (x),
5327                                                       XEXP (x, 0),
5328                                                       modewidth - pos - len),
5329                                 modewidth - len);
5330
5331   else if (unsignedp && len < HOST_BITS_PER_WIDE_INT)
5332     tem = simplify_and_const_int (NULL_RTX, GET_MODE (x),
5333                                   simplify_shift_const (NULL_RTX, LSHIFTRT,
5334                                                         GET_MODE (x),
5335                                                         XEXP (x, 0), pos),
5336                                   ((HOST_WIDE_INT) 1 << len) - 1);
5337   else
5338     /* Any other cases we can't handle.  */
5339     return x;
5340
5341
5342   /* If we couldn't do this for some reason, return the original
5343      expression.  */
5344   if (GET_CODE (tem) == CLOBBER)
5345     return x;
5346
5347   return tem;
5348 }
5349 \f
5350 /* X is a SET which contains an assignment of one object into
5351    a part of another (such as a bit-field assignment, STRICT_LOW_PART,
5352    or certain SUBREGS). If possible, convert it into a series of
5353    logical operations.
5354
5355    We half-heartedly support variable positions, but do not at all
5356    support variable lengths.  */
5357
5358 static rtx
5359 expand_field_assignment (x)
5360      rtx x;
5361 {
5362   rtx inner;
5363   rtx pos;                      /* Always counts from low bit.  */
5364   int len;
5365   rtx mask;
5366   enum machine_mode compute_mode;
5367
5368   /* Loop until we find something we can't simplify.  */
5369   while (1)
5370     {
5371       if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART
5372           && GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG)
5373         {
5374           inner = SUBREG_REG (XEXP (SET_DEST (x), 0));
5375           len = GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)));
5376           pos = GEN_INT (BITS_PER_WORD * SUBREG_WORD (XEXP (SET_DEST (x), 0)));
5377         }
5378       else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
5379                && GET_CODE (XEXP (SET_DEST (x), 1)) == CONST_INT)
5380         {
5381           inner = XEXP (SET_DEST (x), 0);
5382           len = INTVAL (XEXP (SET_DEST (x), 1));
5383           pos = XEXP (SET_DEST (x), 2);
5384
5385           /* If the position is constant and spans the width of INNER,
5386              surround INNER  with a USE to indicate this.  */
5387           if (GET_CODE (pos) == CONST_INT
5388               && INTVAL (pos) + len > GET_MODE_BITSIZE (GET_MODE (inner)))
5389             inner = gen_rtx_USE (GET_MODE (SET_DEST (x)), inner);
5390
5391           if (BITS_BIG_ENDIAN)
5392             {
5393               if (GET_CODE (pos) == CONST_INT)
5394                 pos = GEN_INT (GET_MODE_BITSIZE (GET_MODE (inner)) - len
5395                                - INTVAL (pos));
5396               else if (GET_CODE (pos) == MINUS
5397                        && GET_CODE (XEXP (pos, 1)) == CONST_INT
5398                        && (INTVAL (XEXP (pos, 1))
5399                            == GET_MODE_BITSIZE (GET_MODE (inner)) - len))
5400                 /* If position is ADJUST - X, new position is X.  */
5401                 pos = XEXP (pos, 0);
5402               else
5403                 pos = gen_binary (MINUS, GET_MODE (pos),
5404                                   GEN_INT (GET_MODE_BITSIZE (GET_MODE (inner))
5405                                            - len),
5406                                   pos);
5407             }
5408         }
5409
5410       /* A SUBREG between two modes that occupy the same numbers of words
5411          can be done by moving the SUBREG to the source.  */
5412       else if (GET_CODE (SET_DEST (x)) == SUBREG
5413                && (((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
5414                      + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
5415                    == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
5416                         + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
5417         {
5418           x = gen_rtx_SET (VOIDmode, SUBREG_REG (SET_DEST (x)),
5419                            gen_lowpart_for_combine (GET_MODE (SUBREG_REG (SET_DEST (x))),
5420                                                     SET_SRC (x)));
5421           continue;
5422         }
5423       else
5424         break;
5425
5426       while (GET_CODE (inner) == SUBREG && subreg_lowpart_p (inner))
5427         inner = SUBREG_REG (inner);
5428
5429       compute_mode = GET_MODE (inner);
5430
5431       /* Don't attempt bitwise arithmetic on non-integral modes.  */
5432       if (! INTEGRAL_MODE_P (compute_mode))
5433         {
5434           enum machine_mode imode;
5435
5436           /* Something is probably seriously wrong if this matches.  */
5437           if (! FLOAT_MODE_P (compute_mode))
5438             break;
5439
5440           /* Try to find an integral mode to pun with.  */
5441           imode = mode_for_size (GET_MODE_BITSIZE (compute_mode), MODE_INT, 0);
5442           if (imode == BLKmode)
5443             break;
5444
5445           compute_mode = imode;
5446           inner = gen_lowpart_for_combine (imode, inner);
5447         }
5448
5449       /* Compute a mask of LEN bits, if we can do this on the host machine.  */
5450       if (len < HOST_BITS_PER_WIDE_INT)
5451         mask = GEN_INT (((HOST_WIDE_INT) 1 << len) - 1);
5452       else
5453         break;
5454
5455       /* Now compute the equivalent expression.  Make a copy of INNER
5456          for the SET_DEST in case it is a MEM into which we will substitute;
5457          we don't want shared RTL in that case.  */
5458       x = gen_rtx_SET (VOIDmode, copy_rtx (inner),
5459                        gen_binary (IOR, compute_mode,
5460                                    gen_binary (AND, compute_mode,
5461                                                gen_unary (NOT, compute_mode,
5462                                                           compute_mode,
5463                                                           gen_binary (ASHIFT,
5464                                                                       compute_mode,
5465                                                                       mask, pos)),
5466                                                inner),
5467                                    gen_binary (ASHIFT, compute_mode,
5468                                                gen_binary (AND, compute_mode,
5469                                                            gen_lowpart_for_combine
5470                                                            (compute_mode,
5471                                                             SET_SRC (x)),
5472                                                            mask),
5473                                                pos)));
5474     }
5475
5476   return x;
5477 }
5478 \f
5479 /* Return an RTX for a reference to LEN bits of INNER.  If POS_RTX is nonzero,
5480    it is an RTX that represents a variable starting position; otherwise,
5481    POS is the (constant) starting bit position (counted from the LSB).
5482
5483    INNER may be a USE.  This will occur when we started with a bitfield
5484    that went outside the boundary of the object in memory, which is
5485    allowed on most machines.  To isolate this case, we produce a USE
5486    whose mode is wide enough and surround the MEM with it.  The only
5487    code that understands the USE is this routine.  If it is not removed,
5488    it will cause the resulting insn not to match.
5489
5490    UNSIGNEDP is non-zero for an unsigned reference and zero for a
5491    signed reference.
5492
5493    IN_DEST is non-zero if this is a reference in the destination of a
5494    SET.  This is used when a ZERO_ or SIGN_EXTRACT isn't needed.  If non-zero,
5495    a STRICT_LOW_PART will be used, if zero, ZERO_EXTEND or SIGN_EXTEND will
5496    be used.
5497
5498    IN_COMPARE is non-zero if we are in a COMPARE.  This means that a
5499    ZERO_EXTRACT should be built even for bits starting at bit 0.
5500
5501    MODE is the desired mode of the result (if IN_DEST == 0).
5502
5503    The result is an RTX for the extraction or NULL_RTX if the target
5504    can't handle it.  */
5505
5506 static rtx
5507 make_extraction (mode, inner, pos, pos_rtx, len,
5508                  unsignedp, in_dest, in_compare)
5509      enum machine_mode mode;
5510      rtx inner;
5511      int pos;
5512      rtx pos_rtx;
5513      int len;
5514      int unsignedp;
5515      int in_dest, in_compare;
5516 {
5517   /* This mode describes the size of the storage area
5518      to fetch the overall value from.  Within that, we
5519      ignore the POS lowest bits, etc.  */
5520   enum machine_mode is_mode = GET_MODE (inner);
5521   enum machine_mode inner_mode;
5522   enum machine_mode wanted_inner_mode = byte_mode;
5523   enum machine_mode wanted_inner_reg_mode = word_mode;
5524   enum machine_mode pos_mode = word_mode;
5525   enum machine_mode extraction_mode = word_mode;
5526   enum machine_mode tmode = mode_for_size (len, MODE_INT, 1);
5527   int spans_byte = 0;
5528   rtx new = 0;
5529   rtx orig_pos_rtx = pos_rtx;
5530   int orig_pos;
5531
5532   /* Get some information about INNER and get the innermost object.  */
5533   if (GET_CODE (inner) == USE)
5534     /* (use:SI (mem:QI foo)) stands for (mem:SI foo).  */
5535     /* We don't need to adjust the position because we set up the USE
5536        to pretend that it was a full-word object.  */
5537     spans_byte = 1, inner = XEXP (inner, 0);
5538   else if (GET_CODE (inner) == SUBREG && subreg_lowpart_p (inner))
5539     {
5540       /* If going from (subreg:SI (mem:QI ...)) to (mem:QI ...),
5541          consider just the QI as the memory to extract from.
5542          The subreg adds or removes high bits; its mode is
5543          irrelevant to the meaning of this extraction,
5544          since POS and LEN count from the lsb.  */
5545       if (GET_CODE (SUBREG_REG (inner)) == MEM)
5546         is_mode = GET_MODE (SUBREG_REG (inner));
5547       inner = SUBREG_REG (inner);
5548     }
5549
5550   inner_mode = GET_MODE (inner);
5551
5552   if (pos_rtx && GET_CODE (pos_rtx) == CONST_INT)
5553     pos = INTVAL (pos_rtx), pos_rtx = 0;
5554
5555   /* See if this can be done without an extraction.  We never can if the
5556      width of the field is not the same as that of some integer mode. For
5557      registers, we can only avoid the extraction if the position is at the
5558      low-order bit and this is either not in the destination or we have the
5559      appropriate STRICT_LOW_PART operation available.
5560
5561      For MEM, we can avoid an extract if the field starts on an appropriate
5562      boundary and we can change the mode of the memory reference.  However,
5563      we cannot directly access the MEM if we have a USE and the underlying
5564      MEM is not TMODE.  This combination means that MEM was being used in a
5565      context where bits outside its mode were being referenced; that is only
5566      valid in bit-field insns.  */
5567
5568   if (tmode != BLKmode
5569       && ! (spans_byte && inner_mode != tmode)
5570       && ((pos_rtx == 0 && (pos % BITS_PER_WORD) == 0
5571            && GET_CODE (inner) != MEM
5572            && (! in_dest
5573                || (GET_CODE (inner) == REG
5574                    && (movstrict_optab->handlers[(int) tmode].insn_code
5575                        != CODE_FOR_nothing))))
5576           || (GET_CODE (inner) == MEM && pos_rtx == 0
5577               && (pos
5578                   % (STRICT_ALIGNMENT ? GET_MODE_ALIGNMENT (tmode)
5579                      : BITS_PER_UNIT)) == 0
5580               /* We can't do this if we are widening INNER_MODE (it
5581                  may not be aligned, for one thing).  */
5582               && GET_MODE_BITSIZE (inner_mode) >= GET_MODE_BITSIZE (tmode)
5583               && (inner_mode == tmode
5584                   || (! mode_dependent_address_p (XEXP (inner, 0))
5585                       && ! MEM_VOLATILE_P (inner))))))
5586     {
5587       /* If INNER is a MEM, make a new MEM that encompasses just the desired
5588          field.  If the original and current mode are the same, we need not
5589          adjust the offset.  Otherwise, we do if bytes big endian.
5590
5591          If INNER is not a MEM, get a piece consisting of just the field
5592          of interest (in this case POS % BITS_PER_WORD must be 0).  */
5593
5594       if (GET_CODE (inner) == MEM)
5595         {
5596           int offset;
5597           /* POS counts from lsb, but make OFFSET count in memory order.  */
5598           if (BYTES_BIG_ENDIAN)
5599             offset = (GET_MODE_BITSIZE (is_mode) - len - pos) / BITS_PER_UNIT;
5600           else
5601             offset = pos / BITS_PER_UNIT;
5602
5603           new = gen_rtx_MEM (tmode, plus_constant (XEXP (inner, 0), offset));
5604           RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (inner);
5605           MEM_COPY_ATTRIBUTES (new, inner);
5606         }
5607       else if (GET_CODE (inner) == REG)
5608         {
5609           /* We can't call gen_lowpart_for_combine here since we always want
5610              a SUBREG and it would sometimes return a new hard register.  */
5611           if (tmode != inner_mode)
5612             new = gen_rtx_SUBREG (tmode, inner,
5613                                   (WORDS_BIG_ENDIAN
5614                                    && GET_MODE_SIZE (inner_mode) > UNITS_PER_WORD
5615                                    ? (((GET_MODE_SIZE (inner_mode)
5616                                         - GET_MODE_SIZE (tmode))
5617                                        / UNITS_PER_WORD)
5618                                       - pos / BITS_PER_WORD)
5619                                    : pos / BITS_PER_WORD));
5620           else
5621             new = inner;
5622         }
5623       else
5624         new = force_to_mode (inner, tmode,
5625                              len >= HOST_BITS_PER_WIDE_INT
5626                              ? GET_MODE_MASK (tmode)
5627                              : ((HOST_WIDE_INT) 1 << len) - 1,
5628                              NULL_RTX, 0);
5629
5630       /* If this extraction is going into the destination of a SET,
5631          make a STRICT_LOW_PART unless we made a MEM.  */
5632
5633       if (in_dest)
5634         return (GET_CODE (new) == MEM ? new
5635                 : (GET_CODE (new) != SUBREG
5636                    ? gen_rtx_CLOBBER (tmode, const0_rtx)
5637                    : gen_rtx_combine (STRICT_LOW_PART, VOIDmode, new)));
5638
5639       /* Otherwise, sign- or zero-extend unless we already are in the
5640          proper mode.  */
5641
5642       return (mode == tmode ? new
5643               : gen_rtx_combine (unsignedp ? ZERO_EXTEND : SIGN_EXTEND,
5644                                  mode, new));
5645     }
5646
5647   /* Unless this is a COMPARE or we have a funny memory reference,
5648      don't do anything with zero-extending field extracts starting at
5649      the low-order bit since they are simple AND operations.  */
5650   if (pos_rtx == 0 && pos == 0 && ! in_dest
5651       && ! in_compare && ! spans_byte && unsignedp)
5652     return 0;
5653
5654   /* Unless we are allowed to span bytes, reject this if we would be
5655      spanning bytes or if the position is not a constant and the length
5656      is not 1.  In all other cases, we would only be going outside
5657      out object in cases when an original shift would have been
5658      undefined.  */
5659   if (! spans_byte
5660       && ((pos_rtx == 0 && pos + len > GET_MODE_BITSIZE (is_mode))
5661           || (pos_rtx != 0 && len != 1)))
5662     return 0;
5663
5664   /* Get the mode to use should INNER not be a MEM, the mode for the position,
5665      and the mode for the result.  */
5666 #ifdef HAVE_insv
5667   if (in_dest)
5668     {
5669       wanted_inner_reg_mode
5670         = (insn_operand_mode[(int) CODE_FOR_insv][0] == VOIDmode
5671            ? word_mode
5672            : insn_operand_mode[(int) CODE_FOR_insv][0]);
5673       pos_mode = (insn_operand_mode[(int) CODE_FOR_insv][2] == VOIDmode
5674                   ? word_mode : insn_operand_mode[(int) CODE_FOR_insv][2]);
5675       extraction_mode = (insn_operand_mode[(int) CODE_FOR_insv][3] == VOIDmode
5676                          ? word_mode
5677                          : insn_operand_mode[(int) CODE_FOR_insv][3]);
5678     }
5679 #endif
5680
5681 #ifdef HAVE_extzv
5682   if (! in_dest && unsignedp)
5683     {
5684       wanted_inner_reg_mode
5685         = (insn_operand_mode[(int) CODE_FOR_extzv][1] == VOIDmode
5686            ? word_mode
5687            : insn_operand_mode[(int) CODE_FOR_extzv][1]);
5688       pos_mode = (insn_operand_mode[(int) CODE_FOR_extzv][3] == VOIDmode
5689                   ? word_mode : insn_operand_mode[(int) CODE_FOR_extzv][3]);
5690       extraction_mode = (insn_operand_mode[(int) CODE_FOR_extzv][0] == VOIDmode
5691                          ? word_mode
5692                          : insn_operand_mode[(int) CODE_FOR_extzv][0]);
5693     }
5694 #endif
5695
5696 #ifdef HAVE_extv
5697   if (! in_dest && ! unsignedp)
5698     {
5699       wanted_inner_reg_mode
5700         = (insn_operand_mode[(int) CODE_FOR_extv][1] == VOIDmode
5701            ? word_mode
5702            : insn_operand_mode[(int) CODE_FOR_extv][1]);
5703       pos_mode = (insn_operand_mode[(int) CODE_FOR_extv][3] == VOIDmode
5704                   ? word_mode : insn_operand_mode[(int) CODE_FOR_extv][3]);
5705       extraction_mode = (insn_operand_mode[(int) CODE_FOR_extv][0] == VOIDmode
5706                          ? word_mode
5707                          : insn_operand_mode[(int) CODE_FOR_extv][0]);
5708     }
5709 #endif
5710
5711   /* Never narrow an object, since that might not be safe.  */
5712
5713   if (mode != VOIDmode
5714       && GET_MODE_SIZE (extraction_mode) < GET_MODE_SIZE (mode))
5715     extraction_mode = mode;
5716
5717   if (pos_rtx && GET_MODE (pos_rtx) != VOIDmode
5718       && GET_MODE_SIZE (pos_mode) < GET_MODE_SIZE (GET_MODE (pos_rtx)))
5719     pos_mode = GET_MODE (pos_rtx);
5720
5721   /* If this is not from memory, the desired mode is wanted_inner_reg_mode;
5722      if we have to change the mode of memory and cannot, the desired mode is
5723      EXTRACTION_MODE.  */
5724   if (GET_CODE (inner) != MEM)
5725     wanted_inner_mode = wanted_inner_reg_mode;
5726   else if (inner_mode != wanted_inner_mode
5727            && (mode_dependent_address_p (XEXP (inner, 0))
5728                || MEM_VOLATILE_P (inner)))
5729     wanted_inner_mode = extraction_mode;
5730
5731   orig_pos = pos;
5732
5733   if (BITS_BIG_ENDIAN)
5734     {
5735       /* POS is passed as if BITS_BIG_ENDIAN == 0, so we need to convert it to
5736          BITS_BIG_ENDIAN style.  If position is constant, compute new
5737          position.  Otherwise, build subtraction.
5738          Note that POS is relative to the mode of the original argument.
5739          If it's a MEM we need to recompute POS relative to that.
5740          However, if we're extracting from (or inserting into) a register,
5741          we want to recompute POS relative to wanted_inner_mode.  */
5742       int width = (GET_CODE (inner) == MEM
5743                    ? GET_MODE_BITSIZE (is_mode)
5744                    : GET_MODE_BITSIZE (wanted_inner_mode));
5745
5746       if (pos_rtx == 0)
5747         pos = width - len - pos;
5748       else
5749         pos_rtx
5750           = gen_rtx_combine (MINUS, GET_MODE (pos_rtx),
5751                              GEN_INT (width - len), pos_rtx);
5752       /* POS may be less than 0 now, but we check for that below.
5753          Note that it can only be less than 0 if GET_CODE (inner) != MEM.  */
5754     }
5755
5756   /* If INNER has a wider mode, make it smaller.  If this is a constant
5757      extract, try to adjust the byte to point to the byte containing
5758      the value.  */
5759   if (wanted_inner_mode != VOIDmode
5760       && GET_MODE_SIZE (wanted_inner_mode) < GET_MODE_SIZE (is_mode)
5761       && ((GET_CODE (inner) == MEM
5762            && (inner_mode == wanted_inner_mode
5763                || (! mode_dependent_address_p (XEXP (inner, 0))
5764                    && ! MEM_VOLATILE_P (inner))))))
5765     {
5766       int offset = 0;
5767
5768       /* The computations below will be correct if the machine is big
5769          endian in both bits and bytes or little endian in bits and bytes.
5770          If it is mixed, we must adjust.  */
5771
5772       /* If bytes are big endian and we had a paradoxical SUBREG, we must
5773          adjust OFFSET to compensate.  */
5774       if (BYTES_BIG_ENDIAN
5775           && ! spans_byte
5776           && GET_MODE_SIZE (inner_mode) < GET_MODE_SIZE (is_mode))
5777         offset -= GET_MODE_SIZE (is_mode) - GET_MODE_SIZE (inner_mode);
5778
5779       /* If this is a constant position, we can move to the desired byte.  */
5780       if (pos_rtx == 0)
5781         {
5782           offset += pos / BITS_PER_UNIT;
5783           pos %= GET_MODE_BITSIZE (wanted_inner_mode);
5784         }
5785
5786       if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN
5787           && ! spans_byte
5788           && is_mode != wanted_inner_mode)
5789         offset = (GET_MODE_SIZE (is_mode)
5790                   - GET_MODE_SIZE (wanted_inner_mode) - offset);
5791
5792       if (offset != 0 || inner_mode != wanted_inner_mode)
5793         {
5794           rtx newmem = gen_rtx_MEM (wanted_inner_mode,
5795                                     plus_constant (XEXP (inner, 0), offset));
5796           RTX_UNCHANGING_P (newmem) = RTX_UNCHANGING_P (inner);
5797           MEM_COPY_ATTRIBUTES (newmem, inner);
5798           inner = newmem;
5799         }
5800     }
5801
5802   /* If INNER is not memory, we can always get it into the proper mode.  If we
5803      are changing its mode, POS must be a constant and smaller than the size
5804      of the new mode.  */
5805   else if (GET_CODE (inner) != MEM)
5806     {
5807       if (GET_MODE (inner) != wanted_inner_mode
5808           && (pos_rtx != 0
5809               || orig_pos + len > GET_MODE_BITSIZE (wanted_inner_mode)))
5810         return 0;
5811
5812       inner = force_to_mode (inner, wanted_inner_mode,
5813                              pos_rtx
5814                              || len + orig_pos >= HOST_BITS_PER_WIDE_INT
5815                              ? GET_MODE_MASK (wanted_inner_mode)
5816                              : (((HOST_WIDE_INT) 1 << len) - 1) << orig_pos,
5817                              NULL_RTX, 0);
5818     }
5819
5820   /* Adjust mode of POS_RTX, if needed.  If we want a wider mode, we
5821      have to zero extend.  Otherwise, we can just use a SUBREG.  */
5822   if (pos_rtx != 0
5823       && GET_MODE_SIZE (pos_mode) > GET_MODE_SIZE (GET_MODE (pos_rtx)))
5824     pos_rtx = gen_rtx_combine (ZERO_EXTEND, pos_mode, pos_rtx);
5825   else if (pos_rtx != 0
5826            && GET_MODE_SIZE (pos_mode) < GET_MODE_SIZE (GET_MODE (pos_rtx)))
5827     pos_rtx = gen_lowpart_for_combine (pos_mode, pos_rtx);
5828
5829   /* Make POS_RTX unless we already have it and it is correct.  If we don't
5830      have a POS_RTX but we do have an ORIG_POS_RTX, the latter must
5831      be a CONST_INT.  */
5832   if (pos_rtx == 0 && orig_pos_rtx != 0 && INTVAL (orig_pos_rtx) == pos)
5833     pos_rtx = orig_pos_rtx;
5834
5835   else if (pos_rtx == 0)
5836     pos_rtx = GEN_INT (pos);
5837
5838   /* Make the required operation.  See if we can use existing rtx.  */
5839   new = gen_rtx_combine (unsignedp ? ZERO_EXTRACT : SIGN_EXTRACT,
5840                          extraction_mode, inner, GEN_INT (len), pos_rtx);
5841   if (! in_dest)
5842     new = gen_lowpart_for_combine (mode, new);
5843
5844   return new;
5845 }
5846 \f
5847 /* See if X contains an ASHIFT of COUNT or more bits that can be commuted
5848    with any other operations in X.  Return X without that shift if so.  */
5849
5850 static rtx
5851 extract_left_shift (x, count)
5852      rtx x;
5853      int count;
5854 {
5855   enum rtx_code code = GET_CODE (x);
5856   enum machine_mode mode = GET_MODE (x);
5857   rtx tem;
5858
5859   switch (code)
5860     {
5861     case ASHIFT:
5862       /* This is the shift itself.  If it is wide enough, we will return
5863          either the value being shifted if the shift count is equal to
5864          COUNT or a shift for the difference.  */
5865       if (GET_CODE (XEXP (x, 1)) == CONST_INT
5866           && INTVAL (XEXP (x, 1)) >= count)
5867         return simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (x, 0),
5868                                      INTVAL (XEXP (x, 1)) - count);
5869       break;
5870
5871     case NEG:  case NOT:
5872       if ((tem = extract_left_shift (XEXP (x, 0), count)) != 0)
5873         return gen_unary (code, mode, mode, tem);
5874
5875       break;
5876
5877     case PLUS:  case IOR:  case XOR:  case AND:
5878       /* If we can safely shift this constant and we find the inner shift,
5879          make a new operation.  */
5880       if (GET_CODE (XEXP (x,1)) == CONST_INT
5881           && (INTVAL (XEXP (x, 1)) & ((((HOST_WIDE_INT) 1 << count)) - 1)) == 0
5882           && (tem = extract_left_shift (XEXP (x, 0), count)) != 0)
5883         return gen_binary (code, mode, tem,
5884                            GEN_INT (INTVAL (XEXP (x, 1)) >> count));
5885
5886       break;
5887
5888     default:
5889       break;
5890     }
5891
5892   return 0;
5893 }
5894 \f
5895 /* Look at the expression rooted at X.  Look for expressions
5896    equivalent to ZERO_EXTRACT, SIGN_EXTRACT, ZERO_EXTEND, SIGN_EXTEND.
5897    Form these expressions.
5898
5899    Return the new rtx, usually just X.
5900
5901    Also, for machines like the Vax that don't have logical shift insns,
5902    try to convert logical to arithmetic shift operations in cases where
5903    they are equivalent.  This undoes the canonicalizations to logical
5904    shifts done elsewhere.
5905
5906    We try, as much as possible, to re-use rtl expressions to save memory.
5907
5908    IN_CODE says what kind of expression we are processing.  Normally, it is
5909    SET.  In a memory address (inside a MEM, PLUS or minus, the latter two
5910    being kludges), it is MEM.  When processing the arguments of a comparison
5911    or a COMPARE against zero, it is COMPARE.  */
5912
5913 static rtx
5914 make_compound_operation (x, in_code)
5915      rtx x;
5916      enum rtx_code in_code;
5917 {
5918   enum rtx_code code = GET_CODE (x);
5919   enum machine_mode mode = GET_MODE (x);
5920   int mode_width = GET_MODE_BITSIZE (mode);
5921   rtx rhs, lhs;
5922   enum rtx_code next_code;
5923   int i;
5924   rtx new = 0;
5925   rtx tem;
5926   char *fmt;
5927
5928   /* Select the code to be used in recursive calls.  Once we are inside an
5929      address, we stay there.  If we have a comparison, set to COMPARE,
5930      but once inside, go back to our default of SET.  */
5931
5932   next_code = (code == MEM || code == PLUS || code == MINUS ? MEM
5933                : ((code == COMPARE || GET_RTX_CLASS (code) == '<')
5934                   && XEXP (x, 1) == const0_rtx) ? COMPARE
5935                : in_code == COMPARE ? SET : in_code);
5936
5937   /* Process depending on the code of this operation.  If NEW is set
5938      non-zero, it will be returned.  */
5939
5940   switch (code)
5941     {
5942     case ASHIFT:
5943       /* Convert shifts by constants into multiplications if inside
5944          an address.  */
5945       if (in_code == MEM && GET_CODE (XEXP (x, 1)) == CONST_INT
5946           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
5947           && INTVAL (XEXP (x, 1)) >= 0)
5948         {
5949           new = make_compound_operation (XEXP (x, 0), next_code);
5950           new = gen_rtx_combine (MULT, mode, new,
5951                                  GEN_INT ((HOST_WIDE_INT) 1
5952                                           << INTVAL (XEXP (x, 1))));
5953         }
5954       break;
5955
5956     case AND:
5957       /* If the second operand is not a constant, we can't do anything
5958          with it.  */
5959       if (GET_CODE (XEXP (x, 1)) != CONST_INT)
5960         break;
5961
5962       /* If the constant is a power of two minus one and the first operand
5963          is a logical right shift, make an extraction.  */
5964       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
5965           && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
5966         {
5967           new = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
5968           new = make_extraction (mode, new, 0, XEXP (XEXP (x, 0), 1), i, 1,
5969                                  0, in_code == COMPARE);
5970         }
5971
5972       /* Same as previous, but for (subreg (lshiftrt ...)) in first op.  */
5973       else if (GET_CODE (XEXP (x, 0)) == SUBREG
5974                && subreg_lowpart_p (XEXP (x, 0))
5975                && GET_CODE (SUBREG_REG (XEXP (x, 0))) == LSHIFTRT
5976                && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
5977         {
5978           new = make_compound_operation (XEXP (SUBREG_REG (XEXP (x, 0)), 0),
5979                                          next_code);
5980           new = make_extraction (GET_MODE (SUBREG_REG (XEXP (x, 0))), new, 0,
5981                                  XEXP (SUBREG_REG (XEXP (x, 0)), 1), i, 1,
5982                                  0, in_code == COMPARE);
5983         }
5984       /* Same as previous, but for (xor/ior (lshiftrt...) (lshiftrt...)).  */
5985       else if ((GET_CODE (XEXP (x, 0)) == XOR
5986                 || GET_CODE (XEXP (x, 0)) == IOR)
5987                && GET_CODE (XEXP (XEXP (x, 0), 0)) == LSHIFTRT
5988                && GET_CODE (XEXP (XEXP (x, 0), 1)) == LSHIFTRT
5989                && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
5990         {
5991           /* Apply the distributive law, and then try to make extractions.  */
5992           new = gen_rtx_combine (GET_CODE (XEXP (x, 0)), mode,
5993                                  gen_rtx_AND (mode, XEXP (XEXP (x, 0), 0),
5994                                               XEXP (x, 1)),
5995                                  gen_rtx_AND (mode, XEXP (XEXP (x, 0), 1),
5996                                               XEXP (x, 1)));
5997           new = make_compound_operation (new, in_code);
5998         }
5999
6000       /* If we are have (and (rotate X C) M) and C is larger than the number
6001          of bits in M, this is an extraction.  */
6002
6003       else if (GET_CODE (XEXP (x, 0)) == ROTATE
6004                && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
6005                && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0
6006                && i <= INTVAL (XEXP (XEXP (x, 0), 1)))
6007         {
6008           new = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
6009           new = make_extraction (mode, new,
6010                                  (GET_MODE_BITSIZE (mode)
6011                                   - INTVAL (XEXP (XEXP (x, 0), 1))),
6012                                  NULL_RTX, i, 1, 0, in_code == COMPARE);
6013         }
6014
6015       /* On machines without logical shifts, if the operand of the AND is
6016          a logical shift and our mask turns off all the propagated sign
6017          bits, we can replace the logical shift with an arithmetic shift.  */
6018       else if (ashr_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
6019                && (lshr_optab->handlers[(int) mode].insn_code
6020                    == CODE_FOR_nothing)
6021                && GET_CODE (XEXP (x, 0)) == LSHIFTRT
6022                && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
6023                && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
6024                && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
6025                && mode_width <= HOST_BITS_PER_WIDE_INT)
6026         {
6027           unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
6028
6029           mask >>= INTVAL (XEXP (XEXP (x, 0), 1));
6030           if ((INTVAL (XEXP (x, 1)) & ~mask) == 0)
6031             SUBST (XEXP (x, 0),
6032                    gen_rtx_combine (ASHIFTRT, mode,
6033                                     make_compound_operation (XEXP (XEXP (x, 0), 0),
6034                                                              next_code),
6035                                     XEXP (XEXP (x, 0), 1)));
6036         }
6037
6038       /* If the constant is one less than a power of two, this might be
6039          representable by an extraction even if no shift is present.
6040          If it doesn't end up being a ZERO_EXTEND, we will ignore it unless
6041          we are in a COMPARE.  */
6042       else if ((i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
6043         new = make_extraction (mode,
6044                                make_compound_operation (XEXP (x, 0),
6045                                                         next_code),
6046                                0, NULL_RTX, i, 1, 0, in_code == COMPARE);
6047
6048       /* If we are in a comparison and this is an AND with a power of two,
6049          convert this into the appropriate bit extract.  */
6050       else if (in_code == COMPARE
6051                && (i = exact_log2 (INTVAL (XEXP (x, 1)))) >= 0)
6052         new = make_extraction (mode,
6053                                make_compound_operation (XEXP (x, 0),
6054                                                         next_code),
6055                                i, NULL_RTX, 1, 1, 0, 1);
6056
6057       break;
6058
6059     case LSHIFTRT:
6060       /* If the sign bit is known to be zero, replace this with an
6061          arithmetic shift.  */
6062       if (ashr_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing
6063           && lshr_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
6064           && mode_width <= HOST_BITS_PER_WIDE_INT
6065           && (nonzero_bits (XEXP (x, 0), mode) & (1 << (mode_width - 1))) == 0)
6066         {
6067           new = gen_rtx_combine (ASHIFTRT, mode,
6068                                  make_compound_operation (XEXP (x, 0),
6069                                                           next_code),
6070                                  XEXP (x, 1));
6071           break;
6072         }
6073
6074       /* ... fall through ...  */
6075
6076     case ASHIFTRT:
6077       lhs = XEXP (x, 0);
6078       rhs = XEXP (x, 1);
6079
6080       /* If we have (ashiftrt (ashift foo C1) C2) with C2 >= C1,
6081          this is a SIGN_EXTRACT.  */
6082       if (GET_CODE (rhs) == CONST_INT
6083           && GET_CODE (lhs) == ASHIFT
6084           && GET_CODE (XEXP (lhs, 1)) == CONST_INT
6085           && INTVAL (rhs) >= INTVAL (XEXP (lhs, 1)))
6086         {
6087           new = make_compound_operation (XEXP (lhs, 0), next_code);
6088           new = make_extraction (mode, new,
6089                                  INTVAL (rhs) - INTVAL (XEXP (lhs, 1)),
6090                                  NULL_RTX, mode_width - INTVAL (rhs),
6091                                  code == LSHIFTRT, 0, in_code == COMPARE);
6092         }
6093
6094       /* See if we have operations between an ASHIFTRT and an ASHIFT.
6095          If so, try to merge the shifts into a SIGN_EXTEND.  We could
6096          also do this for some cases of SIGN_EXTRACT, but it doesn't
6097          seem worth the effort; the case checked for occurs on Alpha.  */
6098
6099       if (GET_RTX_CLASS (GET_CODE (lhs)) != 'o'
6100           && ! (GET_CODE (lhs) == SUBREG
6101                 && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (lhs))) == 'o'))
6102           && GET_CODE (rhs) == CONST_INT
6103           && INTVAL (rhs) < HOST_BITS_PER_WIDE_INT
6104           && (new = extract_left_shift (lhs, INTVAL (rhs))) != 0)
6105         new = make_extraction (mode, make_compound_operation (new, next_code),
6106                                0, NULL_RTX, mode_width - INTVAL (rhs),
6107                                code == LSHIFTRT, 0, in_code == COMPARE);
6108
6109       break;
6110
6111     case SUBREG:
6112       /* Call ourselves recursively on the inner expression.  If we are
6113          narrowing the object and it has a different RTL code from
6114          what it originally did, do this SUBREG as a force_to_mode.  */
6115
6116       tem = make_compound_operation (SUBREG_REG (x), in_code);
6117       if (GET_CODE (tem) != GET_CODE (SUBREG_REG (x))
6118           && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (tem))
6119           && subreg_lowpart_p (x))
6120         {
6121           rtx newer = force_to_mode (tem, mode,
6122                                      GET_MODE_MASK (mode), NULL_RTX, 0);
6123
6124           /* If we have something other than a SUBREG, we might have
6125              done an expansion, so rerun outselves.  */
6126           if (GET_CODE (newer) != SUBREG)
6127             newer = make_compound_operation (newer, in_code);
6128
6129           return newer;
6130         }
6131
6132       /* If this is a paradoxical subreg, and the new code is a sign or
6133          zero extension, omit the subreg and widen the extension.  If it
6134          is a regular subreg, we can still get rid of the subreg by not
6135          widening so much, or in fact removing the extension entirely.  */
6136       if ((GET_CODE (tem) == SIGN_EXTEND
6137            || GET_CODE (tem) == ZERO_EXTEND)
6138           && subreg_lowpart_p (x))
6139         {
6140           if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (tem))
6141               || (GET_MODE_SIZE (mode) >
6142                   GET_MODE_SIZE (GET_MODE (XEXP (tem, 0)))))
6143             tem = gen_rtx_combine (GET_CODE (tem), mode, XEXP (tem, 0));
6144           else
6145             tem = gen_lowpart_for_combine (mode, XEXP (tem, 0));
6146           return tem;
6147         }
6148       break;
6149
6150     default:
6151       break;
6152     }
6153
6154   if (new)
6155     {
6156       x = gen_lowpart_for_combine (mode, new);
6157       code = GET_CODE (x);
6158     }
6159
6160   /* Now recursively process each operand of this operation.  */
6161   fmt = GET_RTX_FORMAT (code);
6162   for (i = 0; i < GET_RTX_LENGTH (code); i++)
6163     if (fmt[i] == 'e')
6164       {
6165         new = make_compound_operation (XEXP (x, i), next_code);
6166         SUBST (XEXP (x, i), new);
6167       }
6168
6169   return x;
6170 }
6171 \f
6172 /* Given M see if it is a value that would select a field of bits
6173     within an item, but not the entire word.  Return -1 if not.
6174     Otherwise, return the starting position of the field, where 0 is the
6175     low-order bit.
6176
6177    *PLEN is set to the length of the field.  */
6178
6179 static int
6180 get_pos_from_mask (m, plen)
6181      unsigned HOST_WIDE_INT m;
6182      int *plen;
6183 {
6184   /* Get the bit number of the first 1 bit from the right, -1 if none.  */
6185   int pos = exact_log2 (m & - m);
6186
6187   if (pos < 0)
6188     return -1;
6189
6190   /* Now shift off the low-order zero bits and see if we have a power of
6191      two minus 1.  */
6192   *plen = exact_log2 ((m >> pos) + 1);
6193
6194   if (*plen <= 0)
6195     return -1;
6196
6197   return pos;
6198 }
6199 \f
6200 /* See if X can be simplified knowing that we will only refer to it in
6201    MODE and will only refer to those bits that are nonzero in MASK.
6202    If other bits are being computed or if masking operations are done
6203    that select a superset of the bits in MASK, they can sometimes be
6204    ignored.
6205
6206    Return a possibly simplified expression, but always convert X to
6207    MODE.  If X is a CONST_INT, AND the CONST_INT with MASK.
6208
6209    Also, if REG is non-zero and X is a register equal in value to REG,
6210    replace X with REG.
6211
6212    If JUST_SELECT is nonzero, don't optimize by noticing that bits in MASK
6213    are all off in X.  This is used when X will be complemented, by either
6214    NOT, NEG, or XOR.  */
6215
6216 static rtx
6217 force_to_mode (x, mode, mask, reg, just_select)
6218      rtx x;
6219      enum machine_mode mode;
6220      unsigned HOST_WIDE_INT mask;
6221      rtx reg;
6222      int just_select;
6223 {
6224   enum rtx_code code = GET_CODE (x);
6225   int next_select = just_select || code == XOR || code == NOT || code == NEG;
6226   enum machine_mode op_mode;
6227   unsigned HOST_WIDE_INT fuller_mask, nonzero;
6228   rtx op0, op1, temp;
6229
6230   /* If this is a CALL or ASM_OPERANDS, don't do anything.  Some of the
6231      code below will do the wrong thing since the mode of such an
6232      expression is VOIDmode.
6233
6234      Also do nothing if X is a CLOBBER; this can happen if X was
6235      the return value from a call to gen_lowpart_for_combine.  */
6236   if (code == CALL || code == ASM_OPERANDS || code == CLOBBER)
6237     return x;
6238
6239   /* We want to perform the operation is its present mode unless we know
6240      that the operation is valid in MODE, in which case we do the operation
6241      in MODE.  */
6242   op_mode = ((GET_MODE_CLASS (mode) == GET_MODE_CLASS (GET_MODE (x))
6243               && code_to_optab[(int) code] != 0
6244               && (code_to_optab[(int) code]->handlers[(int) mode].insn_code
6245                   != CODE_FOR_nothing))
6246              ? mode : GET_MODE (x));
6247
6248   /* It is not valid to do a right-shift in a narrower mode
6249      than the one it came in with.  */
6250   if ((code == LSHIFTRT || code == ASHIFTRT)
6251       && GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (GET_MODE (x)))
6252     op_mode = GET_MODE (x);
6253
6254   /* Truncate MASK to fit OP_MODE.  */
6255   if (op_mode)
6256     mask &= GET_MODE_MASK (op_mode);
6257
6258   /* When we have an arithmetic operation, or a shift whose count we
6259      do not know, we need to assume that all bit the up to the highest-order
6260      bit in MASK will be needed.  This is how we form such a mask.  */
6261   if (op_mode)
6262     fuller_mask = (GET_MODE_BITSIZE (op_mode) >= HOST_BITS_PER_WIDE_INT
6263                    ? GET_MODE_MASK (op_mode)
6264                    : ((HOST_WIDE_INT) 1 << (floor_log2 (mask) + 1)) - 1);
6265   else
6266     fuller_mask = ~ (HOST_WIDE_INT) 0;
6267
6268   /* Determine what bits of X are guaranteed to be (non)zero.  */
6269   nonzero = nonzero_bits (x, mode);
6270
6271   /* If none of the bits in X are needed, return a zero.  */
6272   if (! just_select && (nonzero & mask) == 0)
6273     return const0_rtx;
6274
6275   /* If X is a CONST_INT, return a new one.  Do this here since the
6276      test below will fail.  */
6277   if (GET_CODE (x) == CONST_INT)
6278     {
6279       HOST_WIDE_INT cval = INTVAL (x) & mask;
6280       int width = GET_MODE_BITSIZE (mode);
6281
6282       /* If MODE is narrower that HOST_WIDE_INT and CVAL is a negative
6283          number, sign extend it.  */
6284       if (width > 0 && width < HOST_BITS_PER_WIDE_INT
6285           && (cval & ((HOST_WIDE_INT) 1 << (width - 1))) != 0)
6286         cval |= (HOST_WIDE_INT) -1 << width;
6287
6288       return GEN_INT (cval);
6289     }
6290
6291   /* If X is narrower than MODE and we want all the bits in X's mode, just
6292      get X in the proper mode.  */
6293   if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (mode)
6294       && (GET_MODE_MASK (GET_MODE (x)) & ~ mask) == 0)
6295     return gen_lowpart_for_combine (mode, x);
6296
6297   /* If we aren't changing the mode, X is not a SUBREG, and all zero bits in
6298      MASK are already known to be zero in X, we need not do anything.  */
6299   if (GET_MODE (x) == mode && code != SUBREG && (~ mask & nonzero) == 0)
6300     return x;
6301
6302   switch (code)
6303     {
6304     case CLOBBER:
6305       /* If X is a (clobber (const_int)), return it since we know we are
6306          generating something that won't match.  */
6307       return x;
6308
6309     case USE:
6310       /* X is a (use (mem ..)) that was made from a bit-field extraction that
6311          spanned the boundary of the MEM.  If we are now masking so it is
6312          within that boundary, we don't need the USE any more.  */
6313       if (! BITS_BIG_ENDIAN
6314           && (mask & ~ GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6315         return force_to_mode (XEXP (x, 0), mode, mask, reg, next_select);
6316       break;
6317
6318     case SIGN_EXTEND:
6319     case ZERO_EXTEND:
6320     case ZERO_EXTRACT:
6321     case SIGN_EXTRACT:
6322       x = expand_compound_operation (x);
6323       if (GET_CODE (x) != code)
6324         return force_to_mode (x, mode, mask, reg, next_select);
6325       break;
6326
6327     case REG:
6328       if (reg != 0 && (rtx_equal_p (get_last_value (reg), x)
6329                        || rtx_equal_p (reg, get_last_value (x))))
6330         x = reg;
6331       break;
6332
6333     case SUBREG:
6334       if (subreg_lowpart_p (x)
6335           /* We can ignore the effect of this SUBREG if it narrows the mode or
6336              if the constant masks to zero all the bits the mode doesn't
6337              have.  */
6338           && ((GET_MODE_SIZE (GET_MODE (x))
6339                < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
6340               || (0 == (mask
6341                         & GET_MODE_MASK (GET_MODE (x))
6342                         & ~ GET_MODE_MASK (GET_MODE (SUBREG_REG (x)))))))
6343         return force_to_mode (SUBREG_REG (x), mode, mask, reg, next_select);
6344       break;
6345
6346     case AND:
6347       /* If this is an AND with a constant, convert it into an AND
6348          whose constant is the AND of that constant with MASK.  If it
6349          remains an AND of MASK, delete it since it is redundant.  */
6350
6351       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
6352         {
6353           x = simplify_and_const_int (x, op_mode, XEXP (x, 0),
6354                                       mask & INTVAL (XEXP (x, 1)));
6355
6356           /* If X is still an AND, see if it is an AND with a mask that
6357              is just some low-order bits.  If so, and it is MASK, we don't
6358              need it.  */
6359
6360           if (GET_CODE (x) == AND && GET_CODE (XEXP (x, 1)) == CONST_INT
6361               && (unsigned HOST_WIDE_INT) INTVAL (XEXP (x, 1)) == mask)
6362             x = XEXP (x, 0);
6363
6364           /* If it remains an AND, try making another AND with the bits
6365              in the mode mask that aren't in MASK turned on.  If the
6366              constant in the AND is wide enough, this might make a
6367              cheaper constant.  */
6368
6369           if (GET_CODE (x) == AND && GET_CODE (XEXP (x, 1)) == CONST_INT
6370               && GET_MODE_MASK (GET_MODE (x)) != mask
6371               && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
6372             {
6373               HOST_WIDE_INT cval = (INTVAL (XEXP (x, 1))
6374                                     | (GET_MODE_MASK (GET_MODE (x)) & ~ mask));
6375               int width = GET_MODE_BITSIZE (GET_MODE (x));
6376               rtx y;
6377
6378               /* If MODE is narrower that HOST_WIDE_INT and CVAL is a negative
6379                  number, sign extend it.  */
6380               if (width > 0 && width < HOST_BITS_PER_WIDE_INT
6381                   && (cval & ((HOST_WIDE_INT) 1 << (width - 1))) != 0)
6382                 cval |= (HOST_WIDE_INT) -1 << width;
6383
6384               y = gen_binary (AND, GET_MODE (x), XEXP (x, 0), GEN_INT (cval));
6385               if (rtx_cost (y, SET) < rtx_cost (x, SET))
6386                 x = y;
6387             }
6388
6389           break;
6390         }
6391
6392       goto binop;
6393
6394     case PLUS:
6395       /* In (and (plus FOO C1) M), if M is a mask that just turns off
6396          low-order bits (as in an alignment operation) and FOO is already
6397          aligned to that boundary, mask C1 to that boundary as well.
6398          This may eliminate that PLUS and, later, the AND.  */
6399
6400       {
6401         int width = GET_MODE_BITSIZE (mode);
6402         unsigned HOST_WIDE_INT smask = mask;
6403
6404         /* If MODE is narrower than HOST_WIDE_INT and mask is a negative
6405            number, sign extend it.  */
6406
6407         if (width < HOST_BITS_PER_WIDE_INT
6408             && (smask & ((HOST_WIDE_INT) 1 << (width - 1))) != 0)
6409           smask |= (HOST_WIDE_INT) -1 << width;
6410
6411         if (GET_CODE (XEXP (x, 1)) == CONST_INT
6412             && exact_log2 (- smask) >= 0)
6413           {
6414 #ifdef STACK_BIAS
6415             if (STACK_BIAS
6416                 && (XEXP (x, 0) == stack_pointer_rtx
6417                     || XEXP (x, 0) == frame_pointer_rtx))
6418               {
6419                 int sp_alignment = STACK_BOUNDARY / BITS_PER_UNIT;
6420                 unsigned HOST_WIDE_INT sp_mask = GET_MODE_MASK (mode);
6421
6422                 sp_mask &= ~ (sp_alignment - 1);
6423                 if ((sp_mask & ~ smask) == 0
6424                     && ((INTVAL (XEXP (x, 1)) - STACK_BIAS) & ~ smask) != 0)
6425                   return force_to_mode (plus_constant (XEXP (x, 0),
6426                                                        ((INTVAL (XEXP (x, 1)) -
6427                                                          STACK_BIAS) & smask)
6428                                                        + STACK_BIAS),
6429                                         mode, smask, reg, next_select);
6430               }
6431 #endif
6432             if ((nonzero_bits (XEXP (x, 0), mode) & ~ smask) == 0
6433                 && (INTVAL (XEXP (x, 1)) & ~ smask) != 0)
6434               return force_to_mode (plus_constant (XEXP (x, 0),
6435                                                    (INTVAL (XEXP (x, 1))
6436                                                     & smask)),
6437                                     mode, smask, reg, next_select);
6438           }
6439       }
6440
6441       /* ... fall through ...  */
6442
6443     case MINUS:
6444     case MULT:
6445       /* For PLUS, MINUS and MULT, we need any bits less significant than the
6446          most significant bit in MASK since carries from those bits will
6447          affect the bits we are interested in.  */
6448       mask = fuller_mask;
6449       goto binop;
6450
6451     case IOR:
6452     case XOR:
6453       /* If X is (ior (lshiftrt FOO C1) C2), try to commute the IOR and
6454          LSHIFTRT so we end up with an (and (lshiftrt (ior ...) ...) ...)
6455          operation which may be a bitfield extraction.  Ensure that the
6456          constant we form is not wider than the mode of X.  */
6457
6458       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
6459           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
6460           && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
6461           && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
6462           && GET_CODE (XEXP (x, 1)) == CONST_INT
6463           && ((INTVAL (XEXP (XEXP (x, 0), 1))
6464                + floor_log2 (INTVAL (XEXP (x, 1))))
6465               < GET_MODE_BITSIZE (GET_MODE (x)))
6466           && (INTVAL (XEXP (x, 1))
6467               & ~ nonzero_bits (XEXP (x, 0), GET_MODE (x))) == 0)
6468         {
6469           temp = GEN_INT ((INTVAL (XEXP (x, 1)) & mask)
6470                               << INTVAL (XEXP (XEXP (x, 0), 1)));
6471           temp = gen_binary (GET_CODE (x), GET_MODE (x),
6472                              XEXP (XEXP (x, 0), 0), temp);
6473           x = gen_binary (LSHIFTRT, GET_MODE (x), temp,
6474                           XEXP (XEXP (x, 0), 1));
6475           return force_to_mode (x, mode, mask, reg, next_select);
6476         }
6477
6478     binop:
6479       /* For most binary operations, just propagate into the operation and
6480          change the mode if we have an operation of that mode.   */
6481
6482       op0 = gen_lowpart_for_combine (op_mode,
6483                                      force_to_mode (XEXP (x, 0), mode, mask,
6484                                                     reg, next_select));
6485       op1 = gen_lowpart_for_combine (op_mode,
6486                                      force_to_mode (XEXP (x, 1), mode, mask,
6487                                                     reg, next_select));
6488
6489       /* If OP1 is a CONST_INT and X is an IOR or XOR, clear bits outside
6490          MASK since OP1 might have been sign-extended but we never want
6491          to turn on extra bits, since combine might have previously relied
6492          on them being off.  */
6493       if (GET_CODE (op1) == CONST_INT && (code == IOR || code == XOR)
6494           && (INTVAL (op1) & mask) != 0)
6495         op1 = GEN_INT (INTVAL (op1) & mask);
6496
6497       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
6498         x = gen_binary (code, op_mode, op0, op1);
6499       break;
6500
6501     case ASHIFT:
6502       /* For left shifts, do the same, but just for the first operand.
6503          However, we cannot do anything with shifts where we cannot
6504          guarantee that the counts are smaller than the size of the mode
6505          because such a count will have a different meaning in a
6506          wider mode.  */
6507
6508       if (! (GET_CODE (XEXP (x, 1)) == CONST_INT
6509              && INTVAL (XEXP (x, 1)) >= 0
6510              && INTVAL (XEXP (x, 1)) < GET_MODE_BITSIZE (mode))
6511           && ! (GET_MODE (XEXP (x, 1)) != VOIDmode
6512                 && (nonzero_bits (XEXP (x, 1), GET_MODE (XEXP (x, 1)))
6513                     < (unsigned HOST_WIDE_INT) GET_MODE_BITSIZE (mode))))
6514         break;
6515
6516       /* If the shift count is a constant and we can do arithmetic in
6517          the mode of the shift, refine which bits we need.  Otherwise, use the
6518          conservative form of the mask.  */
6519       if (GET_CODE (XEXP (x, 1)) == CONST_INT
6520           && INTVAL (XEXP (x, 1)) >= 0
6521           && INTVAL (XEXP (x, 1)) < GET_MODE_BITSIZE (op_mode)
6522           && GET_MODE_BITSIZE (op_mode) <= HOST_BITS_PER_WIDE_INT)
6523         mask >>= INTVAL (XEXP (x, 1));
6524       else
6525         mask = fuller_mask;
6526
6527       op0 = gen_lowpart_for_combine (op_mode,
6528                                      force_to_mode (XEXP (x, 0), op_mode,
6529                                                     mask, reg, next_select));
6530
6531       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0))
6532         x =  gen_binary (code, op_mode, op0, XEXP (x, 1));
6533       break;
6534
6535     case LSHIFTRT:
6536       /* Here we can only do something if the shift count is a constant,
6537          this shift constant is valid for the host, and we can do arithmetic
6538          in OP_MODE.  */
6539
6540       if (GET_CODE (XEXP (x, 1)) == CONST_INT
6541           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
6542           && GET_MODE_BITSIZE (op_mode) <= HOST_BITS_PER_WIDE_INT)
6543         {
6544           rtx inner = XEXP (x, 0);
6545
6546           /* Select the mask of the bits we need for the shift operand.  */
6547           mask <<= INTVAL (XEXP (x, 1));
6548
6549           /* We can only change the mode of the shift if we can do arithmetic
6550              in the mode of the shift and MASK is no wider than the width of
6551              OP_MODE.  */
6552           if (GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT
6553               || (mask & ~ GET_MODE_MASK (op_mode)) != 0)
6554             op_mode = GET_MODE (x);
6555
6556           inner = force_to_mode (inner, op_mode, mask, reg, next_select);
6557
6558           if (GET_MODE (x) != op_mode || inner != XEXP (x, 0))
6559             x = gen_binary (LSHIFTRT, op_mode, inner, XEXP (x, 1));
6560         }
6561
6562       /* If we have (and (lshiftrt FOO C1) C2) where the combination of the
6563          shift and AND produces only copies of the sign bit (C2 is one less
6564          than a power of two), we can do this with just a shift.  */
6565
6566       if (GET_CODE (x) == LSHIFTRT
6567           && GET_CODE (XEXP (x, 1)) == CONST_INT
6568           && ((INTVAL (XEXP (x, 1))
6569                + num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0))))
6570               >= GET_MODE_BITSIZE (GET_MODE (x)))
6571           && exact_log2 (mask + 1) >= 0
6572           && (num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
6573               >= exact_log2 (mask + 1)))
6574         x = gen_binary (LSHIFTRT, GET_MODE (x), XEXP (x, 0),
6575                         GEN_INT (GET_MODE_BITSIZE (GET_MODE (x))
6576                                  - exact_log2 (mask + 1)));
6577       break;
6578
6579     case ASHIFTRT:
6580       /* If we are just looking for the sign bit, we don't need this shift at
6581          all, even if it has a variable count.  */
6582       if (GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
6583           && (mask == ((unsigned HOST_WIDE_INT) 1
6584                        << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
6585         return force_to_mode (XEXP (x, 0), mode, mask, reg, next_select);
6586
6587       /* If this is a shift by a constant, get a mask that contains those bits
6588          that are not copies of the sign bit.  We then have two cases:  If
6589          MASK only includes those bits, this can be a logical shift, which may
6590          allow simplifications.  If MASK is a single-bit field not within
6591          those bits, we are requesting a copy of the sign bit and hence can
6592          shift the sign bit to the appropriate location.  */
6593
6594       if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) >= 0
6595           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
6596         {
6597           int i = -1;
6598
6599           /* If the considered data is wider then HOST_WIDE_INT, we can't
6600              represent a mask for all its bits in a single scalar.
6601              But we only care about the lower bits, so calculate these.  */
6602
6603           if (GET_MODE_BITSIZE (GET_MODE (x)) > HOST_BITS_PER_WIDE_INT)
6604             {
6605               nonzero = ~ (HOST_WIDE_INT) 0;
6606
6607               /* GET_MODE_BITSIZE (GET_MODE (x)) - INTVAL (XEXP (x, 1))
6608                  is the number of bits a full-width mask would have set.
6609                  We need only shift if these are fewer than nonzero can
6610                  hold.  If not, we must keep all bits set in nonzero.  */
6611
6612               if (GET_MODE_BITSIZE (GET_MODE (x)) - INTVAL (XEXP (x, 1))
6613                   < HOST_BITS_PER_WIDE_INT)
6614                 nonzero >>= INTVAL (XEXP (x, 1))
6615                             + HOST_BITS_PER_WIDE_INT
6616                             - GET_MODE_BITSIZE (GET_MODE (x)) ;
6617             }
6618           else
6619             {
6620               nonzero = GET_MODE_MASK (GET_MODE (x));
6621               nonzero >>= INTVAL (XEXP (x, 1));
6622             }
6623
6624           if ((mask & ~ nonzero) == 0
6625               || (i = exact_log2 (mask)) >= 0)
6626             {
6627               x = simplify_shift_const
6628                 (x, LSHIFTRT, GET_MODE (x), XEXP (x, 0),
6629                  i < 0 ? INTVAL (XEXP (x, 1))
6630                  : GET_MODE_BITSIZE (GET_MODE (x)) - 1 - i);
6631
6632               if (GET_CODE (x) != ASHIFTRT)
6633                 return force_to_mode (x, mode, mask, reg, next_select);
6634             }
6635         }
6636
6637       /* If MASK is 1, convert this to a LSHIFTRT.  This can be done
6638          even if the shift count isn't a constant.  */
6639       if (mask == 1)
6640         x = gen_binary (LSHIFTRT, GET_MODE (x), XEXP (x, 0), XEXP (x, 1));
6641
6642       /* If this is a sign-extension operation that just affects bits
6643          we don't care about, remove it.  Be sure the call above returned
6644          something that is still a shift.  */
6645
6646       if ((GET_CODE (x) == LSHIFTRT || GET_CODE (x) == ASHIFTRT)
6647           && GET_CODE (XEXP (x, 1)) == CONST_INT
6648           && INTVAL (XEXP (x, 1)) >= 0
6649           && (INTVAL (XEXP (x, 1))
6650               <= GET_MODE_BITSIZE (GET_MODE (x)) - (floor_log2 (mask) + 1))
6651           && GET_CODE (XEXP (x, 0)) == ASHIFT
6652           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
6653           && INTVAL (XEXP (XEXP (x, 0), 1)) == INTVAL (XEXP (x, 1)))
6654         return force_to_mode (XEXP (XEXP (x, 0), 0), mode, mask,
6655                               reg, next_select);
6656
6657       break;
6658
6659     case ROTATE:
6660     case ROTATERT:
6661       /* If the shift count is constant and we can do computations
6662          in the mode of X, compute where the bits we care about are.
6663          Otherwise, we can't do anything.  Don't change the mode of
6664          the shift or propagate MODE into the shift, though.  */
6665       if (GET_CODE (XEXP (x, 1)) == CONST_INT
6666           && INTVAL (XEXP (x, 1)) >= 0)
6667         {
6668           temp = simplify_binary_operation (code == ROTATE ? ROTATERT : ROTATE,
6669                                             GET_MODE (x), GEN_INT (mask),
6670                                             XEXP (x, 1));
6671           if (temp && GET_CODE(temp) == CONST_INT)
6672             SUBST (XEXP (x, 0),
6673                    force_to_mode (XEXP (x, 0), GET_MODE (x),
6674                                   INTVAL (temp), reg, next_select));
6675         }
6676       break;
6677
6678     case NEG:
6679       /* If we just want the low-order bit, the NEG isn't needed since it
6680          won't change the low-order bit.    */
6681       if (mask == 1)
6682         return force_to_mode (XEXP (x, 0), mode, mask, reg, just_select);
6683
6684       /* We need any bits less significant than the most significant bit in
6685          MASK since carries from those bits will affect the bits we are
6686          interested in.  */
6687       mask = fuller_mask;
6688       goto unop;
6689
6690     case NOT:
6691       /* (not FOO) is (xor FOO CONST), so if FOO is an LSHIFTRT, we can do the
6692          same as the XOR case above.  Ensure that the constant we form is not
6693          wider than the mode of X.  */
6694
6695       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
6696           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
6697           && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
6698           && (INTVAL (XEXP (XEXP (x, 0), 1)) + floor_log2 (mask)
6699               < GET_MODE_BITSIZE (GET_MODE (x)))
6700           && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT)
6701         {
6702           temp = GEN_INT (mask << INTVAL (XEXP (XEXP (x, 0), 1)));
6703           temp = gen_binary (XOR, GET_MODE (x), XEXP (XEXP (x, 0), 0), temp);
6704           x = gen_binary (LSHIFTRT, GET_MODE (x), temp, XEXP (XEXP (x, 0), 1));
6705
6706           return force_to_mode (x, mode, mask, reg, next_select);
6707         }
6708
6709       /* (and (not FOO) CONST) is (not (or FOO (not CONST))), so we must
6710          use the full mask inside the NOT.  */
6711       mask = fuller_mask;
6712
6713     unop:
6714       op0 = gen_lowpart_for_combine (op_mode,
6715                                      force_to_mode (XEXP (x, 0), mode, mask,
6716                                                     reg, next_select));
6717       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0))
6718         x = gen_unary (code, op_mode, op_mode, op0);
6719       break;
6720
6721     case NE:
6722       /* (and (ne FOO 0) CONST) can be (and FOO CONST) if CONST is included
6723          in STORE_FLAG_VALUE and FOO has a single bit that might be nonzero,
6724          which is equal to STORE_FLAG_VALUE.  */
6725       if ((mask & ~ STORE_FLAG_VALUE) == 0 && XEXP (x, 1) == const0_rtx
6726           && exact_log2 (nonzero_bits (XEXP (x, 0), mode)) >= 0
6727           && nonzero_bits (XEXP (x, 0), mode) == STORE_FLAG_VALUE)
6728         return force_to_mode (XEXP (x, 0), mode, mask, reg, next_select);
6729
6730       break;
6731
6732     case IF_THEN_ELSE:
6733       /* We have no way of knowing if the IF_THEN_ELSE can itself be
6734          written in a narrower mode.  We play it safe and do not do so.  */
6735
6736       SUBST (XEXP (x, 1),
6737              gen_lowpart_for_combine (GET_MODE (x),
6738                                       force_to_mode (XEXP (x, 1), mode,
6739                                                      mask, reg, next_select)));
6740       SUBST (XEXP (x, 2),
6741              gen_lowpart_for_combine (GET_MODE (x),
6742                                       force_to_mode (XEXP (x, 2), mode,
6743                                                      mask, reg,next_select)));
6744       break;
6745
6746     default:
6747       break;
6748     }
6749
6750   /* Ensure we return a value of the proper mode.  */
6751   return gen_lowpart_for_combine (mode, x);
6752 }
6753 \f
6754 /* Return nonzero if X is an expression that has one of two values depending on
6755    whether some other value is zero or nonzero.  In that case, we return the
6756    value that is being tested, *PTRUE is set to the value if the rtx being
6757    returned has a nonzero value, and *PFALSE is set to the other alternative.
6758
6759    If we return zero, we set *PTRUE and *PFALSE to X.  */
6760
6761 static rtx
6762 if_then_else_cond (x, ptrue, pfalse)
6763      rtx x;
6764      rtx *ptrue, *pfalse;
6765 {
6766   enum machine_mode mode = GET_MODE (x);
6767   enum rtx_code code = GET_CODE (x);
6768   int size = GET_MODE_BITSIZE (mode);
6769   rtx cond0, cond1, true0, true1, false0, false1;
6770   unsigned HOST_WIDE_INT nz;
6771
6772   /* If this is a unary operation whose operand has one of two values, apply
6773      our opcode to compute those values.  */
6774   if (GET_RTX_CLASS (code) == '1'
6775       && (cond0 = if_then_else_cond (XEXP (x, 0), &true0, &false0)) != 0)
6776     {
6777       *ptrue = gen_unary (code, mode, GET_MODE (XEXP (x, 0)), true0);
6778       *pfalse = gen_unary (code, mode, GET_MODE (XEXP (x, 0)), false0);
6779       return cond0;
6780     }
6781
6782   /* If this is a COMPARE, do nothing, since the IF_THEN_ELSE we would
6783      make can't possibly match and would suppress other optimizations.  */
6784   else if (code == COMPARE)
6785     ;
6786
6787   /* If this is a binary operation, see if either side has only one of two
6788      values.  If either one does or if both do and they are conditional on
6789      the same value, compute the new true and false values.  */
6790   else if (GET_RTX_CLASS (code) == 'c' || GET_RTX_CLASS (code) == '2'
6791            || GET_RTX_CLASS (code) == '<')
6792     {
6793       cond0 = if_then_else_cond (XEXP (x, 0), &true0, &false0);
6794       cond1 = if_then_else_cond (XEXP (x, 1), &true1, &false1);
6795
6796       if ((cond0 != 0 || cond1 != 0)
6797           && ! (cond0 != 0 && cond1 != 0 && ! rtx_equal_p (cond0, cond1)))
6798         {
6799           /* If if_then_else_cond returned zero, then true/false are the
6800              same rtl.  We must copy one of them to prevent invalid rtl
6801              sharing.  */
6802           if (cond0 == 0)
6803             true0 = copy_rtx (true0);
6804           else if (cond1 == 0)
6805             true1 = copy_rtx (true1);
6806
6807           *ptrue = gen_binary (code, mode, true0, true1);
6808           *pfalse = gen_binary (code, mode, false0, false1);
6809           return cond0 ? cond0 : cond1;
6810         }
6811
6812       /* See if we have PLUS, IOR, XOR, MINUS or UMAX, where one of the
6813          operands is zero when the other is non-zero, and vice-versa,
6814          and STORE_FLAG_VALUE is 1 or -1.  */
6815
6816       if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
6817           && (code == PLUS || code == IOR || code == XOR || code == MINUS
6818            || code == UMAX)
6819           && GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == MULT)
6820         {
6821           rtx op0 = XEXP (XEXP (x, 0), 1);
6822           rtx op1 = XEXP (XEXP (x, 1), 1);
6823
6824           cond0 = XEXP (XEXP (x, 0), 0);
6825           cond1 = XEXP (XEXP (x, 1), 0);
6826
6827           if (GET_RTX_CLASS (GET_CODE (cond0)) == '<'
6828               && GET_RTX_CLASS (GET_CODE (cond1)) == '<'
6829               && reversible_comparison_p (cond1)
6830               && ((GET_CODE (cond0) == reverse_condition (GET_CODE (cond1))
6831                    && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 0))
6832                    && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 1)))
6833                   || ((swap_condition (GET_CODE (cond0))
6834                        == reverse_condition (GET_CODE (cond1)))
6835                       && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 1))
6836                       && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 0))))
6837               && ! side_effects_p (x))
6838             {
6839               *ptrue = gen_binary (MULT, mode, op0, const_true_rtx);
6840               *pfalse = gen_binary (MULT, mode,
6841                                     (code == MINUS
6842                                      ? gen_unary (NEG, mode, mode, op1) : op1),
6843                                     const_true_rtx);
6844               return cond0;
6845             }
6846         }
6847
6848       /* Similarly for MULT, AND and UMIN, execpt that for these the result
6849          is always zero.  */
6850       if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
6851           && (code == MULT || code == AND || code == UMIN)
6852           && GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == MULT)
6853         {
6854           cond0 = XEXP (XEXP (x, 0), 0);
6855           cond1 = XEXP (XEXP (x, 1), 0);
6856
6857           if (GET_RTX_CLASS (GET_CODE (cond0)) == '<'
6858               && GET_RTX_CLASS (GET_CODE (cond1)) == '<'
6859               && reversible_comparison_p (cond1)
6860               && ((GET_CODE (cond0) == reverse_condition (GET_CODE (cond1))
6861                    && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 0))
6862                    && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 1)))
6863                   || ((swap_condition (GET_CODE (cond0))
6864                        == reverse_condition (GET_CODE (cond1)))
6865                       && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 1))
6866                       && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 0))))
6867               && ! side_effects_p (x))
6868             {
6869               *ptrue = *pfalse = const0_rtx;
6870               return cond0;
6871             }
6872         }
6873     }
6874
6875   else if (code == IF_THEN_ELSE)
6876     {
6877       /* If we have IF_THEN_ELSE already, extract the condition and
6878          canonicalize it if it is NE or EQ.  */
6879       cond0 = XEXP (x, 0);
6880       *ptrue = XEXP (x, 1), *pfalse = XEXP (x, 2);
6881       if (GET_CODE (cond0) == NE && XEXP (cond0, 1) == const0_rtx)
6882         return XEXP (cond0, 0);
6883       else if (GET_CODE (cond0) == EQ && XEXP (cond0, 1) == const0_rtx)
6884         {
6885           *ptrue = XEXP (x, 2), *pfalse = XEXP (x, 1);
6886           return XEXP (cond0, 0);
6887         }
6888       else
6889         return cond0;
6890     }
6891
6892   /* If X is a normal SUBREG with both inner and outer modes integral,
6893      we can narrow both the true and false values of the inner expression,
6894      if there is a condition.  */
6895   else if (code == SUBREG && GET_MODE_CLASS (mode) == MODE_INT
6896            && GET_MODE_CLASS (GET_MODE (SUBREG_REG (x))) == MODE_INT
6897            && GET_MODE_SIZE (mode) <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
6898            && 0 != (cond0 = if_then_else_cond (SUBREG_REG (x),
6899                                                &true0, &false0)))
6900     {
6901       *ptrue = force_to_mode (true0, mode, GET_MODE_MASK (mode), NULL_RTX, 0);
6902       *pfalse
6903         = force_to_mode (false0, mode, GET_MODE_MASK (mode), NULL_RTX, 0);
6904
6905       return cond0;
6906     }
6907
6908   /* If X is a constant, this isn't special and will cause confusions
6909      if we treat it as such.  Likewise if it is equivalent to a constant.  */
6910   else if (CONSTANT_P (x)
6911            || ((cond0 = get_last_value (x)) != 0 && CONSTANT_P (cond0)))
6912     ;
6913
6914   /* If X is known to be either 0 or -1, those are the true and
6915      false values when testing X.  */
6916   else if (num_sign_bit_copies (x, mode) == size)
6917     {
6918       *ptrue = constm1_rtx, *pfalse = const0_rtx;
6919       return x;
6920     }
6921
6922   /* Likewise for 0 or a single bit.  */
6923   else if (exact_log2 (nz = nonzero_bits (x, mode)) >= 0)
6924     {
6925       *ptrue = GEN_INT (nz), *pfalse = const0_rtx;
6926       return x;
6927     }
6928
6929   /* Otherwise fail; show no condition with true and false values the same.  */
6930   *ptrue = *pfalse = x;
6931   return 0;
6932 }
6933 \f
6934 /* Return the value of expression X given the fact that condition COND
6935    is known to be true when applied to REG as its first operand and VAL
6936    as its second.  X is known to not be shared and so can be modified in
6937    place.
6938
6939    We only handle the simplest cases, and specifically those cases that
6940    arise with IF_THEN_ELSE expressions.  */
6941
6942 static rtx
6943 known_cond (x, cond, reg, val)
6944      rtx x;
6945      enum rtx_code cond;
6946      rtx reg, val;
6947 {
6948   enum rtx_code code = GET_CODE (x);
6949   rtx temp;
6950   char *fmt;
6951   int i, j;
6952
6953   if (side_effects_p (x))
6954     return x;
6955
6956   if (cond == EQ && rtx_equal_p (x, reg))
6957     return val;
6958
6959   /* If X is (abs REG) and we know something about REG's relationship
6960      with zero, we may be able to simplify this.  */
6961
6962   if (code == ABS && rtx_equal_p (XEXP (x, 0), reg) && val == const0_rtx)
6963     switch (cond)
6964       {
6965       case GE:  case GT:  case EQ:
6966         return XEXP (x, 0);
6967       case LT:  case LE:
6968         return gen_unary (NEG, GET_MODE (XEXP (x, 0)), GET_MODE (XEXP (x, 0)),
6969                           XEXP (x, 0));
6970       default:
6971         break;
6972       }
6973
6974   /* The only other cases we handle are MIN, MAX, and comparisons if the
6975      operands are the same as REG and VAL.  */
6976
6977   else if (GET_RTX_CLASS (code) == '<' || GET_RTX_CLASS (code) == 'c')
6978     {
6979       if (rtx_equal_p (XEXP (x, 0), val))
6980         cond = swap_condition (cond), temp = val, val = reg, reg = temp;
6981
6982       if (rtx_equal_p (XEXP (x, 0), reg) && rtx_equal_p (XEXP (x, 1), val))
6983         {
6984           if (GET_RTX_CLASS (code) == '<')
6985             return (comparison_dominates_p (cond, code) ? const_true_rtx
6986                     : (comparison_dominates_p (cond,
6987                                                reverse_condition (code))
6988                        ? const0_rtx : x));
6989
6990           else if (code == SMAX || code == SMIN
6991                    || code == UMIN || code == UMAX)
6992             {
6993               int unsignedp = (code == UMIN || code == UMAX);
6994
6995               if (code == SMAX || code == UMAX)
6996                 cond = reverse_condition (cond);
6997
6998               switch (cond)
6999                 {
7000                 case GE:   case GT:
7001                   return unsignedp ? x : XEXP (x, 1);
7002                 case LE:   case LT:
7003                   return unsignedp ? x : XEXP (x, 0);
7004                 case GEU:  case GTU:
7005                   return unsignedp ? XEXP (x, 1) : x;
7006                 case LEU:  case LTU:
7007                   return unsignedp ? XEXP (x, 0) : x;
7008                 default:
7009                   break;
7010                 }
7011             }
7012         }
7013     }
7014
7015   fmt = GET_RTX_FORMAT (code);
7016   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
7017     {
7018       if (fmt[i] == 'e')
7019         SUBST (XEXP (x, i), known_cond (XEXP (x, i), cond, reg, val));
7020       else if (fmt[i] == 'E')
7021         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
7022           SUBST (XVECEXP (x, i, j), known_cond (XVECEXP (x, i, j),
7023                                                 cond, reg, val));
7024     }
7025
7026   return x;
7027 }
7028 \f
7029 /* See if X and Y are equal for the purposes of seeing if we can rewrite an
7030    assignment as a field assignment.  */
7031
7032 static int
7033 rtx_equal_for_field_assignment_p (x, y)
7034      rtx x;
7035      rtx y;
7036 {
7037   if (x == y || rtx_equal_p (x, y))
7038     return 1;
7039
7040   if (x == 0 || y == 0 || GET_MODE (x) != GET_MODE (y))
7041     return 0;
7042
7043   /* Check for a paradoxical SUBREG of a MEM compared with the MEM.
7044      Note that all SUBREGs of MEM are paradoxical; otherwise they
7045      would have been rewritten.  */
7046   if (GET_CODE (x) == MEM && GET_CODE (y) == SUBREG
7047       && GET_CODE (SUBREG_REG (y)) == MEM
7048       && rtx_equal_p (SUBREG_REG (y),
7049                       gen_lowpart_for_combine (GET_MODE (SUBREG_REG (y)), x)))
7050     return 1;
7051
7052   if (GET_CODE (y) == MEM && GET_CODE (x) == SUBREG
7053       && GET_CODE (SUBREG_REG (x)) == MEM
7054       && rtx_equal_p (SUBREG_REG (x),
7055                       gen_lowpart_for_combine (GET_MODE (SUBREG_REG (x)), y)))
7056     return 1;
7057
7058   /* We used to see if get_last_value of X and Y were the same but that's
7059      not correct.  In one direction, we'll cause the assignment to have
7060      the wrong destination and in the case, we'll import a register into this
7061      insn that might have already have been dead.   So fail if none of the
7062      above cases are true.  */
7063   return 0;
7064 }
7065 \f
7066 /* See if X, a SET operation, can be rewritten as a bit-field assignment.
7067    Return that assignment if so.
7068
7069    We only handle the most common cases.  */
7070
7071 static rtx
7072 make_field_assignment (x)
7073      rtx x;
7074 {
7075   rtx dest = SET_DEST (x);
7076   rtx src = SET_SRC (x);
7077   rtx assign;
7078   rtx rhs, lhs;
7079   HOST_WIDE_INT c1;
7080   int pos, len;
7081   rtx other;
7082   enum machine_mode mode;
7083
7084   /* If SRC was (and (not (ashift (const_int 1) POS)) DEST), this is
7085      a clear of a one-bit field.  We will have changed it to
7086      (and (rotate (const_int -2) POS) DEST), so check for that.  Also check
7087      for a SUBREG.  */
7088
7089   if (GET_CODE (src) == AND && GET_CODE (XEXP (src, 0)) == ROTATE
7090       && GET_CODE (XEXP (XEXP (src, 0), 0)) == CONST_INT
7091       && INTVAL (XEXP (XEXP (src, 0), 0)) == -2
7092       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
7093     {
7094       assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
7095                                 1, 1, 1, 0);
7096       if (assign != 0)
7097         return gen_rtx_SET (VOIDmode, assign, const0_rtx);
7098       return x;
7099     }
7100
7101   else if (GET_CODE (src) == AND && GET_CODE (XEXP (src, 0)) == SUBREG
7102            && subreg_lowpart_p (XEXP (src, 0))
7103            && (GET_MODE_SIZE (GET_MODE (XEXP (src, 0)))
7104                < GET_MODE_SIZE (GET_MODE (SUBREG_REG (XEXP (src, 0)))))
7105            && GET_CODE (SUBREG_REG (XEXP (src, 0))) == ROTATE
7106            && INTVAL (XEXP (SUBREG_REG (XEXP (src, 0)), 0)) == -2
7107            && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
7108     {
7109       assign = make_extraction (VOIDmode, dest, 0,
7110                                 XEXP (SUBREG_REG (XEXP (src, 0)), 1),
7111                                 1, 1, 1, 0);
7112       if (assign != 0)
7113         return gen_rtx_SET (VOIDmode, assign, const0_rtx);
7114       return x;
7115     }
7116
7117   /* If SRC is (ior (ashift (const_int 1) POS) DEST), this is a set of a
7118      one-bit field.  */
7119   else if (GET_CODE (src) == IOR && GET_CODE (XEXP (src, 0)) == ASHIFT
7120            && XEXP (XEXP (src, 0), 0) == const1_rtx
7121            && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
7122     {
7123       assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
7124                                 1, 1, 1, 0);
7125       if (assign != 0)
7126         return gen_rtx_SET (VOIDmode, assign, const1_rtx);
7127       return x;
7128     }
7129
7130   /* The other case we handle is assignments into a constant-position
7131      field.  They look like (ior/xor (and DEST C1) OTHER).  If C1 represents
7132      a mask that has all one bits except for a group of zero bits and
7133      OTHER is known to have zeros where C1 has ones, this is such an
7134      assignment.  Compute the position and length from C1.  Shift OTHER
7135      to the appropriate position, force it to the required mode, and
7136      make the extraction.  Check for the AND in both operands.  */
7137
7138   if (GET_CODE (src) != IOR && GET_CODE (src) != XOR)
7139     return x;
7140
7141   rhs = expand_compound_operation (XEXP (src, 0));
7142   lhs = expand_compound_operation (XEXP (src, 1));
7143
7144   if (GET_CODE (rhs) == AND
7145       && GET_CODE (XEXP (rhs, 1)) == CONST_INT
7146       && rtx_equal_for_field_assignment_p (XEXP (rhs, 0), dest))
7147     c1 = INTVAL (XEXP (rhs, 1)), other = lhs;
7148   else if (GET_CODE (lhs) == AND
7149            && GET_CODE (XEXP (lhs, 1)) == CONST_INT
7150            && rtx_equal_for_field_assignment_p (XEXP (lhs, 0), dest))
7151     c1 = INTVAL (XEXP (lhs, 1)), other = rhs;
7152   else
7153     return x;
7154
7155   pos = get_pos_from_mask ((~ c1) & GET_MODE_MASK (GET_MODE (dest)), &len);
7156   if (pos < 0 || pos + len > GET_MODE_BITSIZE (GET_MODE (dest))
7157       || GET_MODE_BITSIZE (GET_MODE (dest)) > HOST_BITS_PER_WIDE_INT
7158       || (c1 & nonzero_bits (other, GET_MODE (dest))) != 0)
7159     return x;
7160
7161   assign = make_extraction (VOIDmode, dest, pos, NULL_RTX, len, 1, 1, 0);
7162   if (assign == 0)
7163     return x;
7164
7165   /* The mode to use for the source is the mode of the assignment, or of
7166      what is inside a possible STRICT_LOW_PART.  */
7167   mode = (GET_CODE (assign) == STRICT_LOW_PART
7168           ? GET_MODE (XEXP (assign, 0)) : GET_MODE (assign));
7169
7170   /* Shift OTHER right POS places and make it the source, restricting it
7171      to the proper length and mode.  */
7172
7173   src = force_to_mode (simplify_shift_const (NULL_RTX, LSHIFTRT,
7174                                              GET_MODE (src), other, pos),
7175                        mode,
7176                        GET_MODE_BITSIZE (mode) >= HOST_BITS_PER_WIDE_INT
7177                        ? GET_MODE_MASK (mode)
7178                        : ((HOST_WIDE_INT) 1 << len) - 1,
7179                        dest, 0);
7180
7181   return gen_rtx_combine (SET, VOIDmode, assign, src);
7182 }
7183 \f
7184 /* See if X is of the form (+ (* a c) (* b c)) and convert to (* (+ a b) c)
7185    if so.  */
7186
7187 static rtx
7188 apply_distributive_law (x)
7189      rtx x;
7190 {
7191   enum rtx_code code = GET_CODE (x);
7192   rtx lhs, rhs, other;
7193   rtx tem;
7194   enum rtx_code inner_code;
7195
7196   /* Distributivity is not true for floating point.
7197      It can change the value.  So don't do it.
7198      -- rms and moshier@world.std.com.  */
7199   if (FLOAT_MODE_P (GET_MODE (x)))
7200     return x;
7201
7202   /* The outer operation can only be one of the following:  */
7203   if (code != IOR && code != AND && code != XOR
7204       && code != PLUS && code != MINUS)
7205     return x;
7206
7207   lhs = XEXP (x, 0), rhs = XEXP (x, 1);
7208
7209   /* If either operand is a primitive we can't do anything, so get out
7210      fast.  */
7211   if (GET_RTX_CLASS (GET_CODE (lhs)) == 'o'
7212       || GET_RTX_CLASS (GET_CODE (rhs)) == 'o')
7213     return x;
7214
7215   lhs = expand_compound_operation (lhs);
7216   rhs = expand_compound_operation (rhs);
7217   inner_code = GET_CODE (lhs);
7218   if (inner_code != GET_CODE (rhs))
7219     return x;
7220
7221   /* See if the inner and outer operations distribute.  */
7222   switch (inner_code)
7223     {
7224     case LSHIFTRT:
7225     case ASHIFTRT:
7226     case AND:
7227     case IOR:
7228       /* These all distribute except over PLUS.  */
7229       if (code == PLUS || code == MINUS)
7230         return x;
7231       break;
7232
7233     case MULT:
7234       if (code != PLUS && code != MINUS)
7235         return x;
7236       break;
7237
7238     case ASHIFT:
7239       /* This is also a multiply, so it distributes over everything.  */
7240       break;
7241
7242     case SUBREG:
7243       /* Non-paradoxical SUBREGs distributes over all operations, provided
7244          the inner modes and word numbers are the same, this is an extraction
7245          of a low-order part, we don't convert an fp operation to int or
7246          vice versa, and we would not be converting a single-word
7247          operation into a multi-word operation.  The latter test is not
7248          required, but it prevents generating unneeded multi-word operations.
7249          Some of the previous tests are redundant given the latter test, but
7250          are retained because they are required for correctness.
7251
7252          We produce the result slightly differently in this case.  */
7253
7254       if (GET_MODE (SUBREG_REG (lhs)) != GET_MODE (SUBREG_REG (rhs))
7255           || SUBREG_WORD (lhs) != SUBREG_WORD (rhs)
7256           || ! subreg_lowpart_p (lhs)
7257           || (GET_MODE_CLASS (GET_MODE (lhs))
7258               != GET_MODE_CLASS (GET_MODE (SUBREG_REG (lhs))))
7259           || (GET_MODE_SIZE (GET_MODE (lhs))
7260               > GET_MODE_SIZE (GET_MODE (SUBREG_REG (lhs))))
7261           || GET_MODE_SIZE (GET_MODE (SUBREG_REG (lhs))) > UNITS_PER_WORD)
7262         return x;
7263
7264       tem = gen_binary (code, GET_MODE (SUBREG_REG (lhs)),
7265                         SUBREG_REG (lhs), SUBREG_REG (rhs));
7266       return gen_lowpart_for_combine (GET_MODE (x), tem);
7267
7268     default:
7269       return x;
7270     }
7271
7272   /* Set LHS and RHS to the inner operands (A and B in the example
7273      above) and set OTHER to the common operand (C in the example).
7274      These is only one way to do this unless the inner operation is
7275      commutative.  */
7276   if (GET_RTX_CLASS (inner_code) == 'c'
7277       && rtx_equal_p (XEXP (lhs, 0), XEXP (rhs, 0)))
7278     other = XEXP (lhs, 0), lhs = XEXP (lhs, 1), rhs = XEXP (rhs, 1);
7279   else if (GET_RTX_CLASS (inner_code) == 'c'
7280            && rtx_equal_p (XEXP (lhs, 0), XEXP (rhs, 1)))
7281     other = XEXP (lhs, 0), lhs = XEXP (lhs, 1), rhs = XEXP (rhs, 0);
7282   else if (GET_RTX_CLASS (inner_code) == 'c'
7283            && rtx_equal_p (XEXP (lhs, 1), XEXP (rhs, 0)))
7284     other = XEXP (lhs, 1), lhs = XEXP (lhs, 0), rhs = XEXP (rhs, 1);
7285   else if (rtx_equal_p (XEXP (lhs, 1), XEXP (rhs, 1)))
7286     other = XEXP (lhs, 1), lhs = XEXP (lhs, 0), rhs = XEXP (rhs, 0);
7287   else
7288     return x;
7289
7290   /* Form the new inner operation, seeing if it simplifies first.  */
7291   tem = gen_binary (code, GET_MODE (x), lhs, rhs);
7292
7293   /* There is one exception to the general way of distributing:
7294      (a ^ b) | (a ^ c) -> (~a) & (b ^ c)  */
7295   if (code == XOR && inner_code == IOR)
7296     {
7297       inner_code = AND;
7298       other = gen_unary (NOT, GET_MODE (x), GET_MODE (x), other);
7299     }
7300
7301   /* We may be able to continuing distributing the result, so call
7302      ourselves recursively on the inner operation before forming the
7303      outer operation, which we return.  */
7304   return gen_binary (inner_code, GET_MODE (x),
7305                      apply_distributive_law (tem), other);
7306 }
7307 \f
7308 /* We have X, a logical `and' of VAROP with the constant CONSTOP, to be done
7309    in MODE.
7310
7311    Return an equivalent form, if different from X.  Otherwise, return X.  If
7312    X is zero, we are to always construct the equivalent form.  */
7313
7314 static rtx
7315 simplify_and_const_int (x, mode, varop, constop)
7316      rtx x;
7317      enum machine_mode mode;
7318      rtx varop;
7319      unsigned HOST_WIDE_INT constop;
7320 {
7321   unsigned HOST_WIDE_INT nonzero;
7322   int width = GET_MODE_BITSIZE (mode);
7323   int i;
7324
7325   /* Simplify VAROP knowing that we will be only looking at some of the
7326      bits in it.  */
7327   varop = force_to_mode (varop, mode, constop, NULL_RTX, 0);
7328
7329   /* If VAROP is a CLOBBER, we will fail so return it; if it is a
7330      CONST_INT, we are done.  */
7331   if (GET_CODE (varop) == CLOBBER || GET_CODE (varop) == CONST_INT)
7332     return varop;
7333
7334   /* See what bits may be nonzero in VAROP.  Unlike the general case of
7335      a call to nonzero_bits, here we don't care about bits outside
7336      MODE.  */
7337
7338   nonzero = nonzero_bits (varop, mode) & GET_MODE_MASK (mode);
7339
7340   /* If this would be an entire word for the target, but is not for
7341      the host, then sign-extend on the host so that the number will look
7342      the same way on the host that it would on the target.
7343
7344      For example, when building a 64 bit alpha hosted 32 bit sparc
7345      targeted compiler, then we want the 32 bit unsigned value -1 to be
7346      represented as a 64 bit value -1, and not as 0x00000000ffffffff.
7347      The later confuses the sparc backend.  */
7348
7349   if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT && BITS_PER_WORD == width
7350       && (nonzero & ((HOST_WIDE_INT) 1 << (width - 1))))
7351     nonzero |= ((HOST_WIDE_INT) (-1) << width);
7352
7353   /* Turn off all bits in the constant that are known to already be zero.
7354      Thus, if the AND isn't needed at all, we will have CONSTOP == NONZERO_BITS
7355      which is tested below.  */
7356
7357   constop &= nonzero;
7358
7359   /* If we don't have any bits left, return zero.  */
7360   if (constop == 0)
7361     return const0_rtx;
7362
7363   /* If VAROP is a NEG of something known to be zero or 1 and CONSTOP is
7364      a power of two, we can replace this with a ASHIFT.  */
7365   if (GET_CODE (varop) == NEG && nonzero_bits (XEXP (varop, 0), mode) == 1
7366       && (i = exact_log2 (constop)) >= 0)
7367     return simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (varop, 0), i);
7368
7369   /* If VAROP is an IOR or XOR, apply the AND to both branches of the IOR
7370      or XOR, then try to apply the distributive law.  This may eliminate
7371      operations if either branch can be simplified because of the AND.
7372      It may also make some cases more complex, but those cases probably
7373      won't match a pattern either with or without this.  */
7374
7375   if (GET_CODE (varop) == IOR || GET_CODE (varop) == XOR)
7376     return
7377       gen_lowpart_for_combine
7378         (mode,
7379          apply_distributive_law
7380          (gen_binary (GET_CODE (varop), GET_MODE (varop),
7381                       simplify_and_const_int (NULL_RTX, GET_MODE (varop),
7382                                               XEXP (varop, 0), constop),
7383                       simplify_and_const_int (NULL_RTX, GET_MODE (varop),
7384                                               XEXP (varop, 1), constop))));
7385
7386   /* Get VAROP in MODE.  Try to get a SUBREG if not.  Don't make a new SUBREG
7387      if we already had one (just check for the simplest cases).  */
7388   if (x && GET_CODE (XEXP (x, 0)) == SUBREG
7389       && GET_MODE (XEXP (x, 0)) == mode
7390       && SUBREG_REG (XEXP (x, 0)) == varop)
7391     varop = XEXP (x, 0);
7392   else
7393     varop = gen_lowpart_for_combine (mode, varop);
7394
7395   /* If we can't make the SUBREG, try to return what we were given.  */
7396   if (GET_CODE (varop) == CLOBBER)
7397     return x ? x : varop;
7398
7399   /* If we are only masking insignificant bits, return VAROP.  */
7400   if (constop == nonzero)
7401     x = varop;
7402
7403   /* Otherwise, return an AND.  See how much, if any, of X we can use.  */
7404   else if (x == 0 || GET_CODE (x) != AND || GET_MODE (x) != mode)
7405     x = gen_binary (AND, mode, varop, GEN_INT (constop));
7406
7407   else
7408     {
7409       if (GET_CODE (XEXP (x, 1)) != CONST_INT
7410           || (unsigned HOST_WIDE_INT) INTVAL (XEXP (x, 1)) != constop)
7411         SUBST (XEXP (x, 1), GEN_INT (constop));
7412
7413       SUBST (XEXP (x, 0), varop);
7414     }
7415
7416   return x;
7417 }
7418 \f
7419 /* We let num_sign_bit_copies recur into nonzero_bits as that is useful.
7420    We don't let nonzero_bits recur into num_sign_bit_copies, because that
7421    is less useful.  We can't allow both, because that results in exponential
7422    run time recursion.  There is a nullstone testcase that triggered
7423    this.  This macro avoids accidental uses of num_sign_bit_copies.  */
7424 #define num_sign_bit_copies()
7425
7426 /* Given an expression, X, compute which bits in X can be non-zero.
7427    We don't care about bits outside of those defined in MODE.
7428
7429    For most X this is simply GET_MODE_MASK (GET_MODE (MODE)), but if X is
7430    a shift, AND, or zero_extract, we can do better.  */
7431
7432 static unsigned HOST_WIDE_INT
7433 nonzero_bits (x, mode)
7434      rtx x;
7435      enum machine_mode mode;
7436 {
7437   unsigned HOST_WIDE_INT nonzero = GET_MODE_MASK (mode);
7438   unsigned HOST_WIDE_INT inner_nz;
7439   enum rtx_code code;
7440   int mode_width = GET_MODE_BITSIZE (mode);
7441   rtx tem;
7442
7443   /* For floating-point values, assume all bits are needed.  */
7444   if (FLOAT_MODE_P (GET_MODE (x)) || FLOAT_MODE_P (mode))
7445     return nonzero;
7446
7447   /* If X is wider than MODE, use its mode instead.  */
7448   if (GET_MODE_BITSIZE (GET_MODE (x)) > mode_width)
7449     {
7450       mode = GET_MODE (x);
7451       nonzero = GET_MODE_MASK (mode);
7452       mode_width = GET_MODE_BITSIZE (mode);
7453     }
7454
7455   if (mode_width > HOST_BITS_PER_WIDE_INT)
7456     /* Our only callers in this case look for single bit values.  So
7457        just return the mode mask.  Those tests will then be false.  */
7458     return nonzero;
7459
7460 #ifndef WORD_REGISTER_OPERATIONS
7461   /* If MODE is wider than X, but both are a single word for both the host
7462      and target machines, we can compute this from which bits of the
7463      object might be nonzero in its own mode, taking into account the fact
7464      that on many CISC machines, accessing an object in a wider mode
7465      causes the high-order bits to become undefined.  So they are
7466      not known to be zero.  */
7467
7468   if (GET_MODE (x) != VOIDmode && GET_MODE (x) != mode
7469       && GET_MODE_BITSIZE (GET_MODE (x)) <= BITS_PER_WORD
7470       && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
7471       && GET_MODE_BITSIZE (mode) > GET_MODE_BITSIZE (GET_MODE (x)))
7472     {
7473       nonzero &= nonzero_bits (x, GET_MODE (x));
7474       nonzero |= GET_MODE_MASK (mode) & ~ GET_MODE_MASK (GET_MODE (x));
7475       return nonzero;
7476     }
7477 #endif
7478
7479   code = GET_CODE (x);
7480   switch (code)
7481     {
7482     case REG:
7483 #ifdef POINTERS_EXTEND_UNSIGNED
7484       /* If pointers extend unsigned and this is a pointer in Pmode, say that
7485          all the bits above ptr_mode are known to be zero.  */
7486       if (POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode
7487           && REGNO_POINTER_FLAG (REGNO (x)))
7488         nonzero &= GET_MODE_MASK (ptr_mode);
7489 #endif
7490
7491 #ifdef STACK_BOUNDARY
7492       /* If this is the stack pointer, we may know something about its
7493          alignment.  If PUSH_ROUNDING is defined, it is possible for the
7494          stack to be momentarily aligned only to that amount, so we pick
7495          the least alignment.  */
7496
7497       /* We can't check for arg_pointer_rtx here, because it is not
7498          guaranteed to have as much alignment as the stack pointer.
7499          In particular, in the Irix6 n64 ABI, the stack has 128 bit
7500          alignment but the argument pointer has only 64 bit alignment.  */
7501
7502       if ((x == frame_pointer_rtx
7503            || x == stack_pointer_rtx
7504            || x == hard_frame_pointer_rtx
7505            || (REGNO (x) >= FIRST_VIRTUAL_REGISTER
7506                && REGNO (x) <= LAST_VIRTUAL_REGISTER))
7507 #ifdef STACK_BIAS
7508           && !STACK_BIAS
7509 #endif
7510               )
7511         {
7512           int sp_alignment = STACK_BOUNDARY / BITS_PER_UNIT;
7513
7514 #ifdef PUSH_ROUNDING
7515           if (REGNO (x) == STACK_POINTER_REGNUM)
7516             sp_alignment = MIN (PUSH_ROUNDING (1), sp_alignment);
7517 #endif
7518
7519           /* We must return here, otherwise we may get a worse result from
7520              one of the choices below.  There is nothing useful below as
7521              far as the stack pointer is concerned.  */
7522           return nonzero &= ~ (sp_alignment - 1);
7523         }
7524 #endif
7525
7526       /* If X is a register whose nonzero bits value is current, use it.
7527          Otherwise, if X is a register whose value we can find, use that
7528          value.  Otherwise, use the previously-computed global nonzero bits
7529          for this register.  */
7530
7531       if (reg_last_set_value[REGNO (x)] != 0
7532           && reg_last_set_mode[REGNO (x)] == mode
7533           && (REG_N_SETS (REGNO (x)) == 1
7534               || reg_last_set_label[REGNO (x)] == label_tick)
7535           && INSN_CUID (reg_last_set[REGNO (x)]) < subst_low_cuid)
7536         return reg_last_set_nonzero_bits[REGNO (x)];
7537
7538       tem = get_last_value (x);
7539
7540       if (tem)
7541         {
7542 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
7543           /* If X is narrower than MODE and TEM is a non-negative
7544              constant that would appear negative in the mode of X,
7545              sign-extend it for use in reg_nonzero_bits because some
7546              machines (maybe most) will actually do the sign-extension
7547              and this is the conservative approach.
7548
7549              ??? For 2.5, try to tighten up the MD files in this regard
7550              instead of this kludge.  */
7551
7552           if (GET_MODE_BITSIZE (GET_MODE (x)) < mode_width
7553               && GET_CODE (tem) == CONST_INT
7554               && INTVAL (tem) > 0
7555               && 0 != (INTVAL (tem)
7556                        & ((HOST_WIDE_INT) 1
7557                           << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
7558             tem = GEN_INT (INTVAL (tem)
7559                            | ((HOST_WIDE_INT) (-1)
7560                               << GET_MODE_BITSIZE (GET_MODE (x))));
7561 #endif
7562           return nonzero_bits (tem, mode);
7563         }
7564       else if (nonzero_sign_valid && reg_nonzero_bits[REGNO (x)])
7565         return reg_nonzero_bits[REGNO (x)] & nonzero;
7566       else
7567         return nonzero;
7568
7569     case CONST_INT:
7570 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
7571       /* If X is negative in MODE, sign-extend the value.  */
7572       if (INTVAL (x) > 0 && mode_width < BITS_PER_WORD
7573           && 0 != (INTVAL (x) & ((HOST_WIDE_INT) 1 << (mode_width - 1))))
7574         return (INTVAL (x) | ((HOST_WIDE_INT) (-1) << mode_width));
7575 #endif
7576
7577       return INTVAL (x);
7578
7579     case MEM:
7580 #ifdef LOAD_EXTEND_OP
7581       /* In many, if not most, RISC machines, reading a byte from memory
7582          zeros the rest of the register.  Noticing that fact saves a lot
7583          of extra zero-extends.  */
7584       if (LOAD_EXTEND_OP (GET_MODE (x)) == ZERO_EXTEND)
7585         nonzero &= GET_MODE_MASK (GET_MODE (x));
7586 #endif
7587       break;
7588
7589     case EQ:  case NE:
7590     case GT:  case GTU:
7591     case LT:  case LTU:
7592     case GE:  case GEU:
7593     case LE:  case LEU:
7594
7595       /* If this produces an integer result, we know which bits are set.
7596          Code here used to clear bits outside the mode of X, but that is
7597          now done above.  */
7598
7599       if (GET_MODE_CLASS (mode) == MODE_INT
7600           && mode_width <= HOST_BITS_PER_WIDE_INT)
7601         nonzero = STORE_FLAG_VALUE;
7602       break;
7603
7604     case NEG:
7605 #if 0
7606       /* Disabled to avoid exponential mutual recursion between nonzero_bits
7607          and num_sign_bit_copies.  */
7608       if (num_sign_bit_copies (XEXP (x, 0), GET_MODE (x))
7609           == GET_MODE_BITSIZE (GET_MODE (x)))
7610         nonzero = 1;
7611 #endif
7612
7613       if (GET_MODE_SIZE (GET_MODE (x)) < mode_width)
7614         nonzero |= (GET_MODE_MASK (mode) & ~ GET_MODE_MASK (GET_MODE (x)));
7615       break;
7616
7617     case ABS:
7618 #if 0
7619       /* Disabled to avoid exponential mutual recursion between nonzero_bits
7620          and num_sign_bit_copies.  */
7621       if (num_sign_bit_copies (XEXP (x, 0), GET_MODE (x))
7622           == GET_MODE_BITSIZE (GET_MODE (x)))
7623         nonzero = 1;
7624 #endif
7625       break;
7626
7627     case TRUNCATE:
7628       nonzero &= (nonzero_bits (XEXP (x, 0), mode) & GET_MODE_MASK (mode));
7629       break;
7630
7631     case ZERO_EXTEND:
7632       nonzero &= nonzero_bits (XEXP (x, 0), mode);
7633       if (GET_MODE (XEXP (x, 0)) != VOIDmode)
7634         nonzero &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
7635       break;
7636
7637     case SIGN_EXTEND:
7638       /* If the sign bit is known clear, this is the same as ZERO_EXTEND.
7639          Otherwise, show all the bits in the outer mode but not the inner
7640          may be non-zero.  */
7641       inner_nz = nonzero_bits (XEXP (x, 0), mode);
7642       if (GET_MODE (XEXP (x, 0)) != VOIDmode)
7643         {
7644           inner_nz &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
7645           if (inner_nz
7646               & (((HOST_WIDE_INT) 1
7647                   << (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - 1))))
7648             inner_nz |= (GET_MODE_MASK (mode)
7649                           & ~ GET_MODE_MASK (GET_MODE (XEXP (x, 0))));
7650         }
7651
7652       nonzero &= inner_nz;
7653       break;
7654
7655     case AND:
7656       nonzero &= (nonzero_bits (XEXP (x, 0), mode)
7657                   & nonzero_bits (XEXP (x, 1), mode));
7658       break;
7659
7660     case XOR:   case IOR:
7661     case UMIN:  case UMAX:  case SMIN:  case SMAX:
7662       nonzero &= (nonzero_bits (XEXP (x, 0), mode)
7663                   | nonzero_bits (XEXP (x, 1), mode));
7664       break;
7665
7666     case PLUS:  case MINUS:
7667     case MULT:
7668     case DIV:   case UDIV:
7669     case MOD:   case UMOD:
7670       /* We can apply the rules of arithmetic to compute the number of
7671          high- and low-order zero bits of these operations.  We start by
7672          computing the width (position of the highest-order non-zero bit)
7673          and the number of low-order zero bits for each value.  */
7674       {
7675         unsigned HOST_WIDE_INT nz0 = nonzero_bits (XEXP (x, 0), mode);
7676         unsigned HOST_WIDE_INT nz1 = nonzero_bits (XEXP (x, 1), mode);
7677         int width0 = floor_log2 (nz0) + 1;
7678         int width1 = floor_log2 (nz1) + 1;
7679         int low0 = floor_log2 (nz0 & -nz0);
7680         int low1 = floor_log2 (nz1 & -nz1);
7681         HOST_WIDE_INT op0_maybe_minusp
7682           = (nz0 & ((HOST_WIDE_INT) 1 << (mode_width - 1)));
7683         HOST_WIDE_INT op1_maybe_minusp
7684           = (nz1 & ((HOST_WIDE_INT) 1 << (mode_width - 1)));
7685         int result_width = mode_width;
7686         int result_low = 0;
7687
7688         switch (code)
7689           {
7690           case PLUS:
7691 #ifdef STACK_BIAS
7692             if (STACK_BIAS
7693                 && (XEXP (x, 0) == stack_pointer_rtx
7694                     || XEXP (x, 0) == frame_pointer_rtx)
7695                 && GET_CODE (XEXP (x, 1)) == CONST_INT)
7696               {
7697                 int sp_alignment = STACK_BOUNDARY / BITS_PER_UNIT;
7698
7699                 nz0 = (GET_MODE_MASK (mode) & ~ (sp_alignment - 1));
7700                 nz1 = INTVAL (XEXP (x, 1)) - STACK_BIAS;
7701                 width0 = floor_log2 (nz0) + 1;
7702                 width1 = floor_log2 (nz1) + 1;
7703                 low0 = floor_log2 (nz0 & -nz0);
7704                 low1 = floor_log2 (nz1 & -nz1);
7705               }
7706 #endif
7707             result_width = MAX (width0, width1) + 1;
7708             result_low = MIN (low0, low1);
7709             break;
7710           case MINUS:
7711             result_low = MIN (low0, low1);
7712             break;
7713           case MULT:
7714             result_width = width0 + width1;
7715             result_low = low0 + low1;
7716             break;
7717           case DIV:
7718             if (! op0_maybe_minusp && ! op1_maybe_minusp)
7719               result_width = width0;
7720             break;
7721           case UDIV:
7722             result_width = width0;
7723             break;
7724           case MOD:
7725             if (! op0_maybe_minusp && ! op1_maybe_minusp)
7726               result_width = MIN (width0, width1);
7727             result_low = MIN (low0, low1);
7728             break;
7729           case UMOD:
7730             result_width = MIN (width0, width1);
7731             result_low = MIN (low0, low1);
7732             break;
7733           default:
7734             abort ();
7735           }
7736
7737         if (result_width < mode_width)
7738           nonzero &= ((HOST_WIDE_INT) 1 << result_width) - 1;
7739
7740         if (result_low > 0)
7741           nonzero &= ~ (((HOST_WIDE_INT) 1 << result_low) - 1);
7742       }
7743       break;
7744
7745     case ZERO_EXTRACT:
7746       if (GET_CODE (XEXP (x, 1)) == CONST_INT
7747           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
7748         nonzero &= ((HOST_WIDE_INT) 1 << INTVAL (XEXP (x, 1))) - 1;
7749       break;
7750
7751     case SUBREG:
7752       /* If this is a SUBREG formed for a promoted variable that has
7753          been zero-extended, we know that at least the high-order bits
7754          are zero, though others might be too.  */
7755
7756       if (SUBREG_PROMOTED_VAR_P (x) && SUBREG_PROMOTED_UNSIGNED_P (x))
7757         nonzero = (GET_MODE_MASK (GET_MODE (x))
7758                    & nonzero_bits (SUBREG_REG (x), GET_MODE (x)));
7759
7760       /* If the inner mode is a single word for both the host and target
7761          machines, we can compute this from which bits of the inner
7762          object might be nonzero.  */
7763       if (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) <= BITS_PER_WORD
7764           && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
7765               <= HOST_BITS_PER_WIDE_INT))
7766         {
7767           nonzero &= nonzero_bits (SUBREG_REG (x), mode);
7768
7769 #if defined (WORD_REGISTER_OPERATIONS) && defined (LOAD_EXTEND_OP)
7770           /* If this is a typical RISC machine, we only have to worry
7771              about the way loads are extended.  */
7772           if (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) == SIGN_EXTEND
7773               ? (nonzero
7774                  & (1L << (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) - 1)))
7775               : LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) != ZERO_EXTEND)
7776 #endif
7777             {
7778               /* On many CISC machines, accessing an object in a wider mode
7779                  causes the high-order bits to become undefined.  So they are
7780                  not known to be zero.  */
7781               if (GET_MODE_SIZE (GET_MODE (x))
7782                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
7783                 nonzero |= (GET_MODE_MASK (GET_MODE (x))
7784                             & ~ GET_MODE_MASK (GET_MODE (SUBREG_REG (x))));
7785             }
7786         }
7787       break;
7788
7789     case ASHIFTRT:
7790     case LSHIFTRT:
7791     case ASHIFT:
7792     case ROTATE:
7793       /* The nonzero bits are in two classes: any bits within MODE
7794          that aren't in GET_MODE (x) are always significant.  The rest of the
7795          nonzero bits are those that are significant in the operand of
7796          the shift when shifted the appropriate number of bits.  This
7797          shows that high-order bits are cleared by the right shift and
7798          low-order bits by left shifts.  */
7799       if (GET_CODE (XEXP (x, 1)) == CONST_INT
7800           && INTVAL (XEXP (x, 1)) >= 0
7801           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
7802         {
7803           enum machine_mode inner_mode = GET_MODE (x);
7804           int width = GET_MODE_BITSIZE (inner_mode);
7805           int count = INTVAL (XEXP (x, 1));
7806           unsigned HOST_WIDE_INT mode_mask = GET_MODE_MASK (inner_mode);
7807           unsigned HOST_WIDE_INT op_nonzero = nonzero_bits (XEXP (x, 0), mode);
7808           unsigned HOST_WIDE_INT inner = op_nonzero & mode_mask;
7809           unsigned HOST_WIDE_INT outer = 0;
7810
7811           if (mode_width > width)
7812             outer = (op_nonzero & nonzero & ~ mode_mask);
7813
7814           if (code == LSHIFTRT)
7815             inner >>= count;
7816           else if (code == ASHIFTRT)
7817             {
7818               inner >>= count;
7819
7820               /* If the sign bit may have been nonzero before the shift, we
7821                  need to mark all the places it could have been copied to
7822                  by the shift as possibly nonzero.  */
7823               if (inner & ((HOST_WIDE_INT) 1 << (width - 1 - count)))
7824                 inner |= (((HOST_WIDE_INT) 1 << count) - 1) << (width - count);
7825             }
7826           else if (code == ASHIFT)
7827             inner <<= count;
7828           else
7829             inner = ((inner << (count % width)
7830                       | (inner >> (width - (count % width)))) & mode_mask);
7831
7832           nonzero &= (outer | inner);
7833         }
7834       break;
7835
7836     case FFS:
7837       /* This is at most the number of bits in the mode.  */
7838       nonzero = ((HOST_WIDE_INT) 1 << (floor_log2 (mode_width) + 1)) - 1;
7839       break;
7840
7841     case IF_THEN_ELSE:
7842       nonzero &= (nonzero_bits (XEXP (x, 1), mode)
7843                   | nonzero_bits (XEXP (x, 2), mode));
7844       break;
7845
7846     default:
7847       break;
7848     }
7849
7850   return nonzero;
7851 }
7852
7853 /* See the macro definition above.  */
7854 #undef num_sign_bit_copies
7855 \f
7856 /* Return the number of bits at the high-order end of X that are known to
7857    be equal to the sign bit.  X will be used in mode MODE; if MODE is
7858    VOIDmode, X will be used in its own mode.  The returned value  will always
7859    be between 1 and the number of bits in MODE.  */
7860
7861 static int
7862 num_sign_bit_copies (x, mode)
7863      rtx x;
7864      enum machine_mode mode;
7865 {
7866   enum rtx_code code = GET_CODE (x);
7867   int bitwidth;
7868   int num0, num1, result;
7869   unsigned HOST_WIDE_INT nonzero;
7870   rtx tem;
7871
7872   /* If we weren't given a mode, use the mode of X.  If the mode is still
7873      VOIDmode, we don't know anything.  Likewise if one of the modes is
7874      floating-point.  */
7875
7876   if (mode == VOIDmode)
7877     mode = GET_MODE (x);
7878
7879   if (mode == VOIDmode || FLOAT_MODE_P (mode) || FLOAT_MODE_P (GET_MODE (x)))
7880     return 1;
7881
7882   bitwidth = GET_MODE_BITSIZE (mode);
7883
7884   /* For a smaller object, just ignore the high bits.  */
7885   if (bitwidth < GET_MODE_BITSIZE (GET_MODE (x)))
7886     return MAX (1, (num_sign_bit_copies (x, GET_MODE (x))
7887                     - (GET_MODE_BITSIZE (GET_MODE (x)) - bitwidth)));
7888
7889   if (GET_MODE (x) != VOIDmode && bitwidth > GET_MODE_BITSIZE (GET_MODE (x)))
7890     {
7891 #ifndef WORD_REGISTER_OPERATIONS
7892   /* If this machine does not do all register operations on the entire
7893      register and MODE is wider than the mode of X, we can say nothing
7894      at all about the high-order bits.  */
7895       return 1;
7896 #else
7897       /* Likewise on machines that do, if the mode of the object is smaller
7898          than a word and loads of that size don't sign extend, we can say
7899          nothing about the high order bits.  */
7900       if (GET_MODE_BITSIZE (GET_MODE (x)) < BITS_PER_WORD
7901 #ifdef LOAD_EXTEND_OP
7902           && LOAD_EXTEND_OP (GET_MODE (x)) != SIGN_EXTEND
7903 #endif
7904           )
7905         return 1;
7906 #endif
7907     }
7908
7909   switch (code)
7910     {
7911     case REG:
7912
7913 #ifdef POINTERS_EXTEND_UNSIGNED
7914       /* If pointers extend signed and this is a pointer in Pmode, say that
7915          all the bits above ptr_mode are known to be sign bit copies.  */
7916       if (! POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode && mode == Pmode
7917           && REGNO_POINTER_FLAG (REGNO (x)))
7918         return GET_MODE_BITSIZE (Pmode) - GET_MODE_BITSIZE (ptr_mode) + 1;
7919 #endif
7920
7921       if (reg_last_set_value[REGNO (x)] != 0
7922           && reg_last_set_mode[REGNO (x)] == mode
7923           && (REG_N_SETS (REGNO (x)) == 1
7924               || reg_last_set_label[REGNO (x)] == label_tick)
7925           && INSN_CUID (reg_last_set[REGNO (x)]) < subst_low_cuid)
7926         return reg_last_set_sign_bit_copies[REGNO (x)];
7927
7928       tem =  get_last_value (x);
7929       if (tem != 0)
7930         return num_sign_bit_copies (tem, mode);
7931
7932       if (nonzero_sign_valid && reg_sign_bit_copies[REGNO (x)] != 0)
7933         return reg_sign_bit_copies[REGNO (x)];
7934       break;
7935
7936     case MEM:
7937 #ifdef LOAD_EXTEND_OP
7938       /* Some RISC machines sign-extend all loads of smaller than a word.  */
7939       if (LOAD_EXTEND_OP (GET_MODE (x)) == SIGN_EXTEND)
7940         return MAX (1, bitwidth - GET_MODE_BITSIZE (GET_MODE (x)) + 1);
7941 #endif
7942       break;
7943
7944     case CONST_INT:
7945       /* If the constant is negative, take its 1's complement and remask.
7946          Then see how many zero bits we have.  */
7947       nonzero = INTVAL (x) & GET_MODE_MASK (mode);
7948       if (bitwidth <= HOST_BITS_PER_WIDE_INT
7949           && (nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
7950         nonzero = (~ nonzero) & GET_MODE_MASK (mode);
7951
7952       return (nonzero == 0 ? bitwidth : bitwidth - floor_log2 (nonzero) - 1);
7953
7954     case SUBREG:
7955       /* If this is a SUBREG for a promoted object that is sign-extended
7956          and we are looking at it in a wider mode, we know that at least the
7957          high-order bits are known to be sign bit copies.  */
7958
7959       if (SUBREG_PROMOTED_VAR_P (x) && ! SUBREG_PROMOTED_UNSIGNED_P (x))
7960         return MAX (bitwidth - GET_MODE_BITSIZE (GET_MODE (x)) + 1,
7961                     num_sign_bit_copies (SUBREG_REG (x), mode));
7962
7963       /* For a smaller object, just ignore the high bits.  */
7964       if (bitwidth <= GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))))
7965         {
7966           num0 = num_sign_bit_copies (SUBREG_REG (x), VOIDmode);
7967           return MAX (1, (num0
7968                           - (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
7969                              - bitwidth)));
7970         }
7971
7972 #ifdef WORD_REGISTER_OPERATIONS
7973 #ifdef LOAD_EXTEND_OP
7974       /* For paradoxical SUBREGs on machines where all register operations
7975          affect the entire register, just look inside.  Note that we are
7976          passing MODE to the recursive call, so the number of sign bit copies
7977          will remain relative to that mode, not the inner mode.  */
7978
7979       /* This works only if loads sign extend.  Otherwise, if we get a
7980          reload for the inner part, it may be loaded from the stack, and
7981          then we lose all sign bit copies that existed before the store
7982          to the stack.  */
7983
7984       if ((GET_MODE_SIZE (GET_MODE (x))
7985            > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
7986           && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) == SIGN_EXTEND)
7987         return num_sign_bit_copies (SUBREG_REG (x), mode);
7988 #endif
7989 #endif
7990       break;
7991
7992     case SIGN_EXTRACT:
7993       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
7994         return MAX (1, bitwidth - INTVAL (XEXP (x, 1)));
7995       break;
7996
7997     case SIGN_EXTEND:
7998       return (bitwidth - GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
7999               + num_sign_bit_copies (XEXP (x, 0), VOIDmode));
8000
8001     case TRUNCATE:
8002       /* For a smaller object, just ignore the high bits.  */
8003       num0 = num_sign_bit_copies (XEXP (x, 0), VOIDmode);
8004       return MAX (1, (num0 - (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
8005                               - bitwidth)));
8006
8007     case NOT:
8008       return num_sign_bit_copies (XEXP (x, 0), mode);
8009
8010     case ROTATE:       case ROTATERT:
8011       /* If we are rotating left by a number of bits less than the number
8012          of sign bit copies, we can just subtract that amount from the
8013          number.  */
8014       if (GET_CODE (XEXP (x, 1)) == CONST_INT
8015           && INTVAL (XEXP (x, 1)) >= 0 && INTVAL (XEXP (x, 1)) < bitwidth)
8016         {
8017           num0 = num_sign_bit_copies (XEXP (x, 0), mode);
8018           return MAX (1, num0 - (code == ROTATE ? INTVAL (XEXP (x, 1))
8019                                  : bitwidth - INTVAL (XEXP (x, 1))));
8020         }
8021       break;
8022
8023     case NEG:
8024       /* In general, this subtracts one sign bit copy.  But if the value
8025          is known to be positive, the number of sign bit copies is the
8026          same as that of the input.  Finally, if the input has just one bit
8027          that might be nonzero, all the bits are copies of the sign bit.  */
8028       num0 = num_sign_bit_copies (XEXP (x, 0), mode);
8029       if (bitwidth > HOST_BITS_PER_WIDE_INT)
8030         return num0 > 1 ? num0 - 1 : 1;
8031
8032       nonzero = nonzero_bits (XEXP (x, 0), mode);
8033       if (nonzero == 1)
8034         return bitwidth;
8035
8036       if (num0 > 1
8037           && (((HOST_WIDE_INT) 1 << (bitwidth - 1)) & nonzero))
8038         num0--;
8039
8040       return num0;
8041
8042     case IOR:   case AND:   case XOR:
8043     case SMIN:  case SMAX:  case UMIN:  case UMAX:
8044       /* Logical operations will preserve the number of sign-bit copies.
8045          MIN and MAX operations always return one of the operands.  */
8046       num0 = num_sign_bit_copies (XEXP (x, 0), mode);
8047       num1 = num_sign_bit_copies (XEXP (x, 1), mode);
8048       return MIN (num0, num1);
8049
8050     case PLUS:  case MINUS:
8051       /* For addition and subtraction, we can have a 1-bit carry.  However,
8052          if we are subtracting 1 from a positive number, there will not
8053          be such a carry.  Furthermore, if the positive number is known to
8054          be 0 or 1, we know the result is either -1 or 0.  */
8055
8056       if (code == PLUS && XEXP (x, 1) == constm1_rtx
8057           && bitwidth <= HOST_BITS_PER_WIDE_INT)
8058         {
8059           nonzero = nonzero_bits (XEXP (x, 0), mode);
8060           if ((((HOST_WIDE_INT) 1 << (bitwidth - 1)) & nonzero) == 0)
8061             return (nonzero == 1 || nonzero == 0 ? bitwidth
8062                     : bitwidth - floor_log2 (nonzero) - 1);
8063         }
8064
8065       num0 = num_sign_bit_copies (XEXP (x, 0), mode);
8066       num1 = num_sign_bit_copies (XEXP (x, 1), mode);
8067       return MAX (1, MIN (num0, num1) - 1);
8068
8069     case MULT:
8070       /* The number of bits of the product is the sum of the number of
8071          bits of both terms.  However, unless one of the terms if known
8072          to be positive, we must allow for an additional bit since negating
8073          a negative number can remove one sign bit copy.  */
8074
8075       num0 = num_sign_bit_copies (XEXP (x, 0), mode);
8076       num1 = num_sign_bit_copies (XEXP (x, 1), mode);
8077
8078       result = bitwidth - (bitwidth - num0) - (bitwidth - num1);
8079       if (result > 0
8080           && (bitwidth > HOST_BITS_PER_WIDE_INT
8081               || (((nonzero_bits (XEXP (x, 0), mode)
8082                     & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
8083                   && ((nonzero_bits (XEXP (x, 1), mode)
8084                        & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))))
8085         result--;
8086
8087       return MAX (1, result);
8088
8089     case UDIV:
8090       /* The result must be <= the first operand.  If the first operand
8091          has the high bit set, we know nothing about the number of sign
8092          bit copies.  */
8093       if (bitwidth > HOST_BITS_PER_WIDE_INT)
8094         return 1;
8095       else if ((nonzero_bits (XEXP (x, 0), mode)
8096                 & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
8097         return 1;
8098       else
8099         return num_sign_bit_copies (XEXP (x, 0), mode);
8100
8101     case UMOD:
8102       /* The result must be <= the scond operand.  */
8103       return num_sign_bit_copies (XEXP (x, 1), mode);
8104
8105     case DIV:
8106       /* Similar to unsigned division, except that we have to worry about
8107          the case where the divisor is negative, in which case we have
8108          to add 1.  */
8109       result = num_sign_bit_copies (XEXP (x, 0), mode);
8110       if (result > 1
8111           && (bitwidth > HOST_BITS_PER_WIDE_INT
8112               || (nonzero_bits (XEXP (x, 1), mode)
8113                   & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))
8114         result--;
8115
8116       return result;
8117
8118     case MOD:
8119       result = num_sign_bit_copies (XEXP (x, 1), mode);
8120       if (result > 1
8121           && (bitwidth > HOST_BITS_PER_WIDE_INT
8122               || (nonzero_bits (XEXP (x, 1), mode)
8123                   & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))
8124         result--;
8125
8126       return result;
8127
8128     case ASHIFTRT:
8129       /* Shifts by a constant add to the number of bits equal to the
8130          sign bit.  */
8131       num0 = num_sign_bit_copies (XEXP (x, 0), mode);
8132       if (GET_CODE (XEXP (x, 1)) == CONST_INT
8133           && INTVAL (XEXP (x, 1)) > 0)
8134         num0 = MIN (bitwidth, num0 + INTVAL (XEXP (x, 1)));
8135
8136       return num0;
8137
8138     case ASHIFT:
8139       /* Left shifts destroy copies.  */
8140       if (GET_CODE (XEXP (x, 1)) != CONST_INT
8141           || INTVAL (XEXP (x, 1)) < 0
8142           || INTVAL (XEXP (x, 1)) >= bitwidth)
8143         return 1;
8144
8145       num0 = num_sign_bit_copies (XEXP (x, 0), mode);
8146       return MAX (1, num0 - INTVAL (XEXP (x, 1)));
8147
8148     case IF_THEN_ELSE:
8149       num0 = num_sign_bit_copies (XEXP (x, 1), mode);
8150       num1 = num_sign_bit_copies (XEXP (x, 2), mode);
8151       return MIN (num0, num1);
8152
8153     case EQ:  case NE:  case GE:  case GT:  case LE:  case LT:
8154     case GEU: case GTU: case LEU: case LTU:
8155       if (STORE_FLAG_VALUE == -1)
8156         return bitwidth;
8157       break;
8158
8159     default:
8160       break;
8161     }
8162
8163   /* If we haven't been able to figure it out by one of the above rules,
8164      see if some of the high-order bits are known to be zero.  If so,
8165      count those bits and return one less than that amount.  If we can't
8166      safely compute the mask for this mode, always return BITWIDTH.  */
8167
8168   if (bitwidth > HOST_BITS_PER_WIDE_INT)
8169     return 1;
8170
8171   nonzero = nonzero_bits (x, mode);
8172   return (nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))
8173           ? 1 : bitwidth - floor_log2 (nonzero) - 1);
8174 }
8175 \f
8176 /* Return the number of "extended" bits there are in X, when interpreted
8177    as a quantity in MODE whose signedness is indicated by UNSIGNEDP.  For
8178    unsigned quantities, this is the number of high-order zero bits.
8179    For signed quantities, this is the number of copies of the sign bit
8180    minus 1.  In both case, this function returns the number of "spare"
8181    bits.  For example, if two quantities for which this function returns
8182    at least 1 are added, the addition is known not to overflow.
8183
8184    This function will always return 0 unless called during combine, which
8185    implies that it must be called from a define_split.  */
8186
8187 int
8188 extended_count (x, mode, unsignedp)
8189      rtx x;
8190      enum machine_mode mode;
8191      int unsignedp;
8192 {
8193   if (nonzero_sign_valid == 0)
8194     return 0;
8195
8196   return (unsignedp
8197           ? (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
8198              && (GET_MODE_BITSIZE (mode) - 1
8199                  - floor_log2 (nonzero_bits (x, mode))))
8200           : num_sign_bit_copies (x, mode) - 1);
8201 }
8202 \f
8203 /* This function is called from `simplify_shift_const' to merge two
8204    outer operations.  Specifically, we have already found that we need
8205    to perform operation *POP0 with constant *PCONST0 at the outermost
8206    position.  We would now like to also perform OP1 with constant CONST1
8207    (with *POP0 being done last).
8208
8209    Return 1 if we can do the operation and update *POP0 and *PCONST0 with
8210    the resulting operation.  *PCOMP_P is set to 1 if we would need to
8211    complement the innermost operand, otherwise it is unchanged.
8212
8213    MODE is the mode in which the operation will be done.  No bits outside
8214    the width of this mode matter.  It is assumed that the width of this mode
8215    is smaller than or equal to HOST_BITS_PER_WIDE_INT.
8216
8217    If *POP0 or OP1 are NIL, it means no operation is required.  Only NEG, PLUS,
8218    IOR, XOR, and AND are supported.  We may set *POP0 to SET if the proper
8219    result is simply *PCONST0.
8220
8221    If the resulting operation cannot be expressed as one operation, we
8222    return 0 and do not change *POP0, *PCONST0, and *PCOMP_P.  */
8223
8224 static int
8225 merge_outer_ops (pop0, pconst0, op1, const1, mode, pcomp_p)
8226      enum rtx_code *pop0;
8227      HOST_WIDE_INT *pconst0;
8228      enum rtx_code op1;
8229      HOST_WIDE_INT const1;
8230      enum machine_mode mode;
8231      int *pcomp_p;
8232 {
8233   enum rtx_code op0 = *pop0;
8234   HOST_WIDE_INT const0 = *pconst0;
8235   int width = GET_MODE_BITSIZE (mode);
8236
8237   const0 &= GET_MODE_MASK (mode);
8238   const1 &= GET_MODE_MASK (mode);
8239
8240   /* If OP0 is an AND, clear unimportant bits in CONST1.  */
8241   if (op0 == AND)
8242     const1 &= const0;
8243
8244   /* If OP0 or OP1 is NIL, this is easy.  Similarly if they are the same or
8245      if OP0 is SET.  */
8246
8247   if (op1 == NIL || op0 == SET)
8248     return 1;
8249
8250   else if (op0 == NIL)
8251     op0 = op1, const0 = const1;
8252
8253   else if (op0 == op1)
8254     {
8255       switch (op0)
8256         {
8257         case AND:
8258           const0 &= const1;
8259           break;
8260         case IOR:
8261           const0 |= const1;
8262           break;
8263         case XOR:
8264           const0 ^= const1;
8265           break;
8266         case PLUS:
8267           const0 += const1;
8268           break;
8269         case NEG:
8270           op0 = NIL;
8271           break;
8272         default:
8273           break;
8274         }
8275     }
8276
8277   /* Otherwise, if either is a PLUS or NEG, we can't do anything.  */
8278   else if (op0 == PLUS || op1 == PLUS || op0 == NEG || op1 == NEG)
8279     return 0;
8280
8281   /* If the two constants aren't the same, we can't do anything.  The
8282      remaining six cases can all be done.  */
8283   else if (const0 != const1)
8284     return 0;
8285
8286   else
8287     switch (op0)
8288       {
8289       case IOR:
8290         if (op1 == AND)
8291           /* (a & b) | b == b */
8292           op0 = SET;
8293         else /* op1 == XOR */
8294           /* (a ^ b) | b == a | b */
8295           {;}
8296         break;
8297
8298       case XOR:
8299         if (op1 == AND)
8300           /* (a & b) ^ b == (~a) & b */
8301           op0 = AND, *pcomp_p = 1;
8302         else /* op1 == IOR */
8303           /* (a | b) ^ b == a & ~b */
8304           op0 = AND, *pconst0 = ~ const0;
8305         break;
8306
8307       case AND:
8308         if (op1 == IOR)
8309           /* (a | b) & b == b */
8310         op0 = SET;
8311         else /* op1 == XOR */
8312           /* (a ^ b) & b) == (~a) & b */
8313           *pcomp_p = 1;
8314         break;
8315       default:
8316         break;
8317       }
8318
8319   /* Check for NO-OP cases.  */
8320   const0 &= GET_MODE_MASK (mode);
8321   if (const0 == 0
8322       && (op0 == IOR || op0 == XOR || op0 == PLUS))
8323     op0 = NIL;
8324   else if (const0 == 0 && op0 == AND)
8325     op0 = SET;
8326   else if ((unsigned HOST_WIDE_INT) const0 == GET_MODE_MASK (mode)
8327            && op0 == AND)
8328     op0 = NIL;
8329
8330   /* If this would be an entire word for the target, but is not for
8331      the host, then sign-extend on the host so that the number will look
8332      the same way on the host that it would on the target.
8333
8334      For example, when building a 64 bit alpha hosted 32 bit sparc
8335      targeted compiler, then we want the 32 bit unsigned value -1 to be
8336      represented as a 64 bit value -1, and not as 0x00000000ffffffff.
8337      The later confuses the sparc backend.  */
8338
8339   if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT && BITS_PER_WORD == width
8340       && (const0 & ((HOST_WIDE_INT) 1 << (width - 1))))
8341     const0 |= ((HOST_WIDE_INT) (-1) << width);
8342
8343   *pop0 = op0;
8344   *pconst0 = const0;
8345
8346   return 1;
8347 }
8348 \f
8349 /* Simplify a shift of VAROP by COUNT bits.  CODE says what kind of shift.
8350    The result of the shift is RESULT_MODE.  X, if non-zero, is an expression
8351    that we started with.
8352
8353    The shift is normally computed in the widest mode we find in VAROP, as
8354    long as it isn't a different number of words than RESULT_MODE.  Exceptions
8355    are ASHIFTRT and ROTATE, which are always done in their original mode,  */
8356
8357 static rtx
8358 simplify_shift_const (x, code, result_mode, varop, count)
8359      rtx x;
8360      enum rtx_code code;
8361      enum machine_mode result_mode;
8362      rtx varop;
8363      int count;
8364 {
8365   enum rtx_code orig_code = code;
8366   int orig_count = count;
8367   enum machine_mode mode = result_mode;
8368   enum machine_mode shift_mode, tmode;
8369   int mode_words
8370     = (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
8371   /* We form (outer_op (code varop count) (outer_const)).  */
8372   enum rtx_code outer_op = NIL;
8373   HOST_WIDE_INT outer_const = 0;
8374   rtx const_rtx;
8375   int complement_p = 0;
8376   rtx new;
8377
8378   /* If we were given an invalid count, don't do anything except exactly
8379      what was requested.  */
8380
8381   if (count < 0 || count > GET_MODE_BITSIZE (mode))
8382     {
8383       if (x)
8384         return x;
8385
8386       return gen_rtx_fmt_ee (code, mode, varop, GEN_INT (count));
8387     }
8388
8389   /* Unless one of the branches of the `if' in this loop does a `continue',
8390      we will `break' the loop after the `if'.  */
8391
8392   while (count != 0)
8393     {
8394       /* If we have an operand of (clobber (const_int 0)), just return that
8395          value.  */
8396       if (GET_CODE (varop) == CLOBBER)
8397         return varop;
8398
8399       /* If we discovered we had to complement VAROP, leave.  Making a NOT
8400          here would cause an infinite loop.  */
8401       if (complement_p)
8402         break;
8403
8404       /* Convert ROTATERT to ROTATE.  */
8405       if (code == ROTATERT)
8406         code = ROTATE, count = GET_MODE_BITSIZE (result_mode) - count;
8407
8408       /* We need to determine what mode we will do the shift in.  If the
8409          shift is a right shift or a ROTATE, we must always do it in the mode
8410          it was originally done in.  Otherwise, we can do it in MODE, the
8411          widest mode encountered.  */
8412       shift_mode
8413         = (code == ASHIFTRT || code == LSHIFTRT || code == ROTATE
8414            ? result_mode : mode);
8415
8416       /* Handle cases where the count is greater than the size of the mode
8417          minus 1.  For ASHIFT, use the size minus one as the count (this can
8418          occur when simplifying (lshiftrt (ashiftrt ..))).  For rotates,
8419          take the count modulo the size.  For other shifts, the result is
8420          zero.
8421
8422          Since these shifts are being produced by the compiler by combining
8423          multiple operations, each of which are defined, we know what the
8424          result is supposed to be.  */
8425
8426       if (count > GET_MODE_BITSIZE (shift_mode) - 1)
8427         {
8428           if (code == ASHIFTRT)
8429             count = GET_MODE_BITSIZE (shift_mode) - 1;
8430           else if (code == ROTATE || code == ROTATERT)
8431             count %= GET_MODE_BITSIZE (shift_mode);
8432           else
8433             {
8434               /* We can't simply return zero because there may be an
8435                  outer op.  */
8436               varop = const0_rtx;
8437               count = 0;
8438               break;
8439             }
8440         }
8441
8442       /* Negative counts are invalid and should not have been made (a
8443          programmer-specified negative count should have been handled
8444          above).  */
8445       else if (count < 0)
8446         abort ();
8447
8448       /* An arithmetic right shift of a quantity known to be -1 or 0
8449          is a no-op.  */
8450       if (code == ASHIFTRT
8451           && (num_sign_bit_copies (varop, shift_mode)
8452               == GET_MODE_BITSIZE (shift_mode)))
8453         {
8454           count = 0;
8455           break;
8456         }
8457
8458       /* If we are doing an arithmetic right shift and discarding all but
8459          the sign bit copies, this is equivalent to doing a shift by the
8460          bitsize minus one.  Convert it into that shift because it will often
8461          allow other simplifications.  */
8462
8463       if (code == ASHIFTRT
8464           && (count + num_sign_bit_copies (varop, shift_mode)
8465               >= GET_MODE_BITSIZE (shift_mode)))
8466         count = GET_MODE_BITSIZE (shift_mode) - 1;
8467
8468       /* We simplify the tests below and elsewhere by converting
8469          ASHIFTRT to LSHIFTRT if we know the sign bit is clear.
8470          `make_compound_operation' will convert it to a ASHIFTRT for
8471          those machines (such as Vax) that don't have a LSHIFTRT.  */
8472       if (GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
8473           && code == ASHIFTRT
8474           && ((nonzero_bits (varop, shift_mode)
8475                & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (shift_mode) - 1)))
8476               == 0))
8477         code = LSHIFTRT;
8478
8479       switch (GET_CODE (varop))
8480         {
8481         case SIGN_EXTEND:
8482         case ZERO_EXTEND:
8483         case SIGN_EXTRACT:
8484         case ZERO_EXTRACT:
8485           new = expand_compound_operation (varop);
8486           if (new != varop)
8487             {
8488               varop = new;
8489               continue;
8490             }
8491           break;
8492
8493         case MEM:
8494           /* If we have (xshiftrt (mem ...) C) and C is MODE_WIDTH
8495              minus the width of a smaller mode, we can do this with a
8496              SIGN_EXTEND or ZERO_EXTEND from the narrower memory location.  */
8497           if ((code == ASHIFTRT || code == LSHIFTRT)
8498               && ! mode_dependent_address_p (XEXP (varop, 0))
8499               && ! MEM_VOLATILE_P (varop)
8500               && (tmode = mode_for_size (GET_MODE_BITSIZE (mode) - count,
8501                                          MODE_INT, 1)) != BLKmode)
8502             {
8503               if (BYTES_BIG_ENDIAN)
8504                 new = gen_rtx_MEM (tmode, XEXP (varop, 0));
8505               else
8506                 new = gen_rtx_MEM (tmode,
8507                                    plus_constant (XEXP (varop, 0),
8508                                                   count / BITS_PER_UNIT));
8509               RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (varop);
8510               MEM_COPY_ATTRIBUTES (new, varop);
8511               varop = gen_rtx_combine (code == ASHIFTRT ? SIGN_EXTEND
8512                                        : ZERO_EXTEND, mode, new);
8513               count = 0;
8514               continue;
8515             }
8516           break;
8517
8518         case USE:
8519           /* Similar to the case above, except that we can only do this if
8520              the resulting mode is the same as that of the underlying
8521              MEM and adjust the address depending on the *bits* endianness
8522              because of the way that bit-field extract insns are defined.  */
8523           if ((code == ASHIFTRT || code == LSHIFTRT)
8524               && (tmode = mode_for_size (GET_MODE_BITSIZE (mode) - count,
8525                                          MODE_INT, 1)) != BLKmode
8526               && tmode == GET_MODE (XEXP (varop, 0)))
8527             {
8528               if (BITS_BIG_ENDIAN)
8529                 new = XEXP (varop, 0);
8530               else
8531                 {
8532                   new = copy_rtx (XEXP (varop, 0));
8533                   SUBST (XEXP (new, 0),
8534                          plus_constant (XEXP (new, 0),
8535                                         count / BITS_PER_UNIT));
8536                 }
8537
8538               varop = gen_rtx_combine (code == ASHIFTRT ? SIGN_EXTEND
8539                                        : ZERO_EXTEND, mode, new);
8540               count = 0;
8541               continue;
8542             }
8543           break;
8544
8545         case SUBREG:
8546           /* If VAROP is a SUBREG, strip it as long as the inner operand has
8547              the same number of words as what we've seen so far.  Then store
8548              the widest mode in MODE.  */
8549           if (subreg_lowpart_p (varop)
8550               && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (varop)))
8551                   > GET_MODE_SIZE (GET_MODE (varop)))
8552               && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (varop)))
8553                     + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
8554                   == mode_words))
8555             {
8556               varop = SUBREG_REG (varop);
8557               if (GET_MODE_SIZE (GET_MODE (varop)) > GET_MODE_SIZE (mode))
8558                 mode = GET_MODE (varop);
8559               continue;
8560             }
8561           break;
8562
8563         case MULT:
8564           /* Some machines use MULT instead of ASHIFT because MULT
8565              is cheaper.  But it is still better on those machines to
8566              merge two shifts into one.  */
8567           if (GET_CODE (XEXP (varop, 1)) == CONST_INT
8568               && exact_log2 (INTVAL (XEXP (varop, 1))) >= 0)
8569             {
8570               varop = gen_binary (ASHIFT, GET_MODE (varop), XEXP (varop, 0),
8571                                   GEN_INT (exact_log2 (INTVAL (XEXP (varop, 1)))));;
8572               continue;
8573             }
8574           break;
8575
8576         case UDIV:
8577           /* Similar, for when divides are cheaper.  */
8578           if (GET_CODE (XEXP (varop, 1)) == CONST_INT
8579               && exact_log2 (INTVAL (XEXP (varop, 1))) >= 0)
8580             {
8581               varop = gen_binary (LSHIFTRT, GET_MODE (varop), XEXP (varop, 0),
8582                                   GEN_INT (exact_log2 (INTVAL (XEXP (varop, 1)))));
8583               continue;
8584             }
8585           break;
8586
8587         case ASHIFTRT:
8588           /* If we are extracting just the sign bit of an arithmetic right
8589              shift, that shift is not needed.  */
8590           if (code == LSHIFTRT && count == GET_MODE_BITSIZE (result_mode) - 1)
8591             {
8592               varop = XEXP (varop, 0);
8593               continue;
8594             }
8595
8596           /* ... fall through ...  */
8597
8598         case LSHIFTRT:
8599         case ASHIFT:
8600         case ROTATE:
8601           /* Here we have two nested shifts.  The result is usually the
8602              AND of a new shift with a mask.  We compute the result below.  */
8603           if (GET_CODE (XEXP (varop, 1)) == CONST_INT
8604               && INTVAL (XEXP (varop, 1)) >= 0
8605               && INTVAL (XEXP (varop, 1)) < GET_MODE_BITSIZE (GET_MODE (varop))
8606               && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
8607               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
8608             {
8609               enum rtx_code first_code = GET_CODE (varop);
8610               int first_count = INTVAL (XEXP (varop, 1));
8611               unsigned HOST_WIDE_INT mask;
8612               rtx mask_rtx;
8613
8614               /* We have one common special case.  We can't do any merging if
8615                  the inner code is an ASHIFTRT of a smaller mode.  However, if
8616                  we have (ashift:M1 (subreg:M1 (ashiftrt:M2 FOO C1) 0) C2)
8617                  with C2 == GET_MODE_BITSIZE (M1) - GET_MODE_BITSIZE (M2),
8618                  we can convert it to
8619                  (ashiftrt:M1 (ashift:M1 (and:M1 (subreg:M1 FOO 0 C2) C3) C1).
8620                  This simplifies certain SIGN_EXTEND operations.  */
8621               if (code == ASHIFT && first_code == ASHIFTRT
8622                   && (GET_MODE_BITSIZE (result_mode)
8623                       - GET_MODE_BITSIZE (GET_MODE (varop))) == count)
8624                 {
8625                   /* C3 has the low-order C1 bits zero.  */
8626
8627                   mask = (GET_MODE_MASK (mode)
8628                           & ~ (((HOST_WIDE_INT) 1 << first_count) - 1));
8629
8630                   varop = simplify_and_const_int (NULL_RTX, result_mode,
8631                                                   XEXP (varop, 0), mask);
8632                   varop = simplify_shift_const (NULL_RTX, ASHIFT, result_mode,
8633                                                 varop, count);
8634                   count = first_count;
8635                   code = ASHIFTRT;
8636                   continue;
8637                 }
8638
8639               /* If this was (ashiftrt (ashift foo C1) C2) and FOO has more
8640                  than C1 high-order bits equal to the sign bit, we can convert
8641                  this to either an ASHIFT or a ASHIFTRT depending on the
8642                  two counts.
8643
8644                  We cannot do this if VAROP's mode is not SHIFT_MODE.  */
8645
8646               if (code == ASHIFTRT && first_code == ASHIFT
8647                   && GET_MODE (varop) == shift_mode
8648                   && (num_sign_bit_copies (XEXP (varop, 0), shift_mode)
8649                       > first_count))
8650                 {
8651                   count -= first_count;
8652                   if (count < 0)
8653                     count = - count, code = ASHIFT;
8654                   varop = XEXP (varop, 0);
8655                   continue;
8656                 }
8657
8658               /* There are some cases we can't do.  If CODE is ASHIFTRT,
8659                  we can only do this if FIRST_CODE is also ASHIFTRT.
8660
8661                  We can't do the case when CODE is ROTATE and FIRST_CODE is
8662                  ASHIFTRT.
8663
8664                  If the mode of this shift is not the mode of the outer shift,
8665                  we can't do this if either shift is a right shift or ROTATE.
8666
8667                  Finally, we can't do any of these if the mode is too wide
8668                  unless the codes are the same.
8669
8670                  Handle the case where the shift codes are the same
8671                  first.  */
8672
8673               if (code == first_code)
8674                 {
8675                   if (GET_MODE (varop) != result_mode
8676                       && (code == ASHIFTRT || code == LSHIFTRT
8677                           || code == ROTATE))
8678                     break;
8679
8680                   count += first_count;
8681                   varop = XEXP (varop, 0);
8682                   continue;
8683                 }
8684
8685               if (code == ASHIFTRT
8686                   || (code == ROTATE && first_code == ASHIFTRT)
8687                   || GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT
8688                   || (GET_MODE (varop) != result_mode
8689                       && (first_code == ASHIFTRT || first_code == LSHIFTRT
8690                           || first_code == ROTATE
8691                           || code == ROTATE)))
8692                 break;
8693
8694               /* To compute the mask to apply after the shift, shift the
8695                  nonzero bits of the inner shift the same way the
8696                  outer shift will.  */
8697
8698               mask_rtx = GEN_INT (nonzero_bits (varop, GET_MODE (varop)));
8699
8700               mask_rtx
8701                 = simplify_binary_operation (code, result_mode, mask_rtx,
8702                                              GEN_INT (count));
8703
8704               /* Give up if we can't compute an outer operation to use.  */
8705               if (mask_rtx == 0
8706                   || GET_CODE (mask_rtx) != CONST_INT
8707                   || ! merge_outer_ops (&outer_op, &outer_const, AND,
8708                                         INTVAL (mask_rtx),
8709                                         result_mode, &complement_p))
8710                 break;
8711
8712               /* If the shifts are in the same direction, we add the
8713                  counts.  Otherwise, we subtract them.  */
8714               if ((code == ASHIFTRT || code == LSHIFTRT)
8715                   == (first_code == ASHIFTRT || first_code == LSHIFTRT))
8716                 count += first_count;
8717               else
8718                 count -= first_count;
8719
8720               /* If COUNT is positive, the new shift is usually CODE,
8721                  except for the two exceptions below, in which case it is
8722                  FIRST_CODE.  If the count is negative, FIRST_CODE should
8723                  always be used  */
8724               if (count > 0
8725                   && ((first_code == ROTATE && code == ASHIFT)
8726                       || (first_code == ASHIFTRT && code == LSHIFTRT)))
8727                 code = first_code;
8728               else if (count < 0)
8729                 code = first_code, count = - count;
8730
8731               varop = XEXP (varop, 0);
8732               continue;
8733             }
8734
8735           /* If we have (A << B << C) for any shift, we can convert this to
8736              (A << C << B).  This wins if A is a constant.  Only try this if
8737              B is not a constant.  */
8738
8739           else if (GET_CODE (varop) == code
8740                    && GET_CODE (XEXP (varop, 1)) != CONST_INT
8741                    && 0 != (new
8742                             = simplify_binary_operation (code, mode,
8743                                                          XEXP (varop, 0),
8744                                                          GEN_INT (count))))
8745             {
8746               varop = gen_rtx_combine (code, mode, new, XEXP (varop, 1));
8747               count = 0;
8748               continue;
8749             }
8750           break;
8751
8752         case NOT:
8753           /* Make this fit the case below.  */
8754           varop = gen_rtx_combine (XOR, mode, XEXP (varop, 0),
8755                                    GEN_INT (GET_MODE_MASK (mode)));
8756           continue;
8757
8758         case IOR:
8759         case AND:
8760         case XOR:
8761           /* If we have (xshiftrt (ior (plus X (const_int -1)) X) C)
8762              with C the size of VAROP - 1 and the shift is logical if
8763              STORE_FLAG_VALUE is 1 and arithmetic if STORE_FLAG_VALUE is -1,
8764              we have an (le X 0) operation.   If we have an arithmetic shift
8765              and STORE_FLAG_VALUE is 1 or we have a logical shift with
8766              STORE_FLAG_VALUE of -1, we have a (neg (le X 0)) operation.  */
8767
8768           if (GET_CODE (varop) == IOR && GET_CODE (XEXP (varop, 0)) == PLUS
8769               && XEXP (XEXP (varop, 0), 1) == constm1_rtx
8770               && (STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
8771               && (code == LSHIFTRT || code == ASHIFTRT)
8772               && count == GET_MODE_BITSIZE (GET_MODE (varop)) - 1
8773               && rtx_equal_p (XEXP (XEXP (varop, 0), 0), XEXP (varop, 1)))
8774             {
8775               count = 0;
8776               varop = gen_rtx_combine (LE, GET_MODE (varop), XEXP (varop, 1),
8777                                        const0_rtx);
8778
8779               if (STORE_FLAG_VALUE == 1 ? code == ASHIFTRT : code == LSHIFTRT)
8780                 varop = gen_rtx_combine (NEG, GET_MODE (varop), varop);
8781
8782               continue;
8783             }
8784
8785           /* If we have (shift (logical)), move the logical to the outside
8786              to allow it to possibly combine with another logical and the
8787              shift to combine with another shift.  This also canonicalizes to
8788              what a ZERO_EXTRACT looks like.  Also, some machines have
8789              (and (shift)) insns.  */
8790
8791           if (GET_CODE (XEXP (varop, 1)) == CONST_INT
8792               && (new = simplify_binary_operation (code, result_mode,
8793                                                    XEXP (varop, 1),
8794                                                    GEN_INT (count))) != 0
8795               && GET_CODE(new) == CONST_INT
8796               && merge_outer_ops (&outer_op, &outer_const, GET_CODE (varop),
8797                                   INTVAL (new), result_mode, &complement_p))
8798             {
8799               varop = XEXP (varop, 0);
8800               continue;
8801             }
8802
8803           /* If we can't do that, try to simplify the shift in each arm of the
8804              logical expression, make a new logical expression, and apply
8805              the inverse distributive law.  */
8806           {
8807             rtx lhs = simplify_shift_const (NULL_RTX, code, shift_mode,
8808                                             XEXP (varop, 0), count);
8809             rtx rhs = simplify_shift_const (NULL_RTX, code, shift_mode,
8810                                             XEXP (varop, 1), count);
8811
8812             varop = gen_binary (GET_CODE (varop), shift_mode, lhs, rhs);
8813             varop = apply_distributive_law (varop);
8814
8815             count = 0;
8816           }
8817           break;
8818
8819         case EQ:
8820           /* convert (lshiftrt (eq FOO 0) C) to (xor FOO 1) if STORE_FLAG_VALUE
8821              says that the sign bit can be tested, FOO has mode MODE, C is
8822              GET_MODE_BITSIZE (MODE) - 1, and FOO has only its low-order bit
8823              that may be nonzero.  */
8824           if (code == LSHIFTRT
8825               && XEXP (varop, 1) == const0_rtx
8826               && GET_MODE (XEXP (varop, 0)) == result_mode
8827               && count == GET_MODE_BITSIZE (result_mode) - 1
8828               && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
8829               && ((STORE_FLAG_VALUE
8830                    & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (result_mode) - 1))))
8831               && nonzero_bits (XEXP (varop, 0), result_mode) == 1
8832               && merge_outer_ops (&outer_op, &outer_const, XOR,
8833                                   (HOST_WIDE_INT) 1, result_mode,
8834                                   &complement_p))
8835             {
8836               varop = XEXP (varop, 0);
8837               count = 0;
8838               continue;
8839             }
8840           break;
8841
8842         case NEG:
8843           /* (lshiftrt (neg A) C) where A is either 0 or 1 and C is one less
8844              than the number of bits in the mode is equivalent to A.  */
8845           if (code == LSHIFTRT && count == GET_MODE_BITSIZE (result_mode) - 1
8846               && nonzero_bits (XEXP (varop, 0), result_mode) == 1)
8847             {
8848               varop = XEXP (varop, 0);
8849               count = 0;
8850               continue;
8851             }
8852
8853           /* NEG commutes with ASHIFT since it is multiplication.  Move the
8854              NEG outside to allow shifts to combine.  */
8855           if (code == ASHIFT
8856               && merge_outer_ops (&outer_op, &outer_const, NEG,
8857                                   (HOST_WIDE_INT) 0, result_mode,
8858                                   &complement_p))
8859             {
8860               varop = XEXP (varop, 0);
8861               continue;
8862             }
8863           break;
8864
8865         case PLUS:
8866           /* (lshiftrt (plus A -1) C) where A is either 0 or 1 and C
8867              is one less than the number of bits in the mode is
8868              equivalent to (xor A 1).  */
8869           if (code == LSHIFTRT && count == GET_MODE_BITSIZE (result_mode) - 1
8870               && XEXP (varop, 1) == constm1_rtx
8871               && nonzero_bits (XEXP (varop, 0), result_mode) == 1
8872               && merge_outer_ops (&outer_op, &outer_const, XOR,
8873                                   (HOST_WIDE_INT) 1, result_mode,
8874                                   &complement_p))
8875             {
8876               count = 0;
8877               varop = XEXP (varop, 0);
8878               continue;
8879             }
8880
8881           /* If we have (xshiftrt (plus FOO BAR) C), and the only bits
8882              that might be nonzero in BAR are those being shifted out and those
8883              bits are known zero in FOO, we can replace the PLUS with FOO.
8884              Similarly in the other operand order.  This code occurs when
8885              we are computing the size of a variable-size array.  */
8886
8887           if ((code == ASHIFTRT || code == LSHIFTRT)
8888               && count < HOST_BITS_PER_WIDE_INT
8889               && nonzero_bits (XEXP (varop, 1), result_mode) >> count == 0
8890               && (nonzero_bits (XEXP (varop, 1), result_mode)
8891                   & nonzero_bits (XEXP (varop, 0), result_mode)) == 0)
8892             {
8893               varop = XEXP (varop, 0);
8894               continue;
8895             }
8896           else if ((code == ASHIFTRT || code == LSHIFTRT)
8897                    && count < HOST_BITS_PER_WIDE_INT
8898                    && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
8899                    && 0 == (nonzero_bits (XEXP (varop, 0), result_mode)
8900                             >> count)
8901                    && 0 == (nonzero_bits (XEXP (varop, 0), result_mode)
8902                             & nonzero_bits (XEXP (varop, 1),
8903                                                  result_mode)))
8904             {
8905               varop = XEXP (varop, 1);
8906               continue;
8907             }
8908
8909           /* (ashift (plus foo C) N) is (plus (ashift foo N) C').  */
8910           if (code == ASHIFT
8911               && GET_CODE (XEXP (varop, 1)) == CONST_INT
8912               && (new = simplify_binary_operation (ASHIFT, result_mode,
8913                                                    XEXP (varop, 1),
8914                                                    GEN_INT (count))) != 0
8915               && GET_CODE(new) == CONST_INT
8916               && merge_outer_ops (&outer_op, &outer_const, PLUS,
8917                                   INTVAL (new), result_mode, &complement_p))
8918             {
8919               varop = XEXP (varop, 0);
8920               continue;
8921             }
8922           break;
8923
8924         case MINUS:
8925           /* If we have (xshiftrt (minus (ashiftrt X C)) X) C)
8926              with C the size of VAROP - 1 and the shift is logical if
8927              STORE_FLAG_VALUE is 1 and arithmetic if STORE_FLAG_VALUE is -1,
8928              we have a (gt X 0) operation.  If the shift is arithmetic with
8929              STORE_FLAG_VALUE of 1 or logical with STORE_FLAG_VALUE == -1,
8930              we have a (neg (gt X 0)) operation.  */
8931
8932           if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
8933               && GET_CODE (XEXP (varop, 0)) == ASHIFTRT
8934               && count == GET_MODE_BITSIZE (GET_MODE (varop)) - 1
8935               && (code == LSHIFTRT || code == ASHIFTRT)
8936               && GET_CODE (XEXP (XEXP (varop, 0), 1)) == CONST_INT
8937               && INTVAL (XEXP (XEXP (varop, 0), 1)) == count
8938               && rtx_equal_p (XEXP (XEXP (varop, 0), 0), XEXP (varop, 1)))
8939             {
8940               count = 0;
8941               varop = gen_rtx_combine (GT, GET_MODE (varop), XEXP (varop, 1),
8942                                        const0_rtx);
8943
8944               if (STORE_FLAG_VALUE == 1 ? code == ASHIFTRT : code == LSHIFTRT)
8945                 varop = gen_rtx_combine (NEG, GET_MODE (varop), varop);
8946
8947               continue;
8948             }
8949           break;
8950
8951         case TRUNCATE:
8952           /* Change (lshiftrt (truncate (lshiftrt))) to (truncate (lshiftrt))
8953              if the truncate does not affect the value.  */
8954           if (code == LSHIFTRT
8955               && GET_CODE (XEXP (varop, 0)) == LSHIFTRT
8956               && GET_CODE (XEXP (XEXP (varop, 0), 1)) == CONST_INT
8957               && (INTVAL (XEXP (XEXP (varop, 0), 1))
8958                   >= (GET_MODE_BITSIZE (GET_MODE (XEXP (varop, 0)))
8959                       - GET_MODE_BITSIZE (GET_MODE (varop)))))
8960             {
8961               rtx varop_inner = XEXP (varop, 0);
8962
8963               varop_inner = gen_rtx_combine (LSHIFTRT,
8964                                              GET_MODE (varop_inner),
8965                                              XEXP (varop_inner, 0),
8966                                              GEN_INT (count + INTVAL (XEXP (varop_inner, 1))));
8967               varop = gen_rtx_combine (TRUNCATE, GET_MODE (varop),
8968                                        varop_inner);
8969               count = 0;
8970               continue;
8971             }
8972           break;
8973
8974         default:
8975           break;
8976         }
8977
8978       break;
8979     }
8980
8981   /* We need to determine what mode to do the shift in.  If the shift is
8982      a right shift or ROTATE, we must always do it in the mode it was
8983      originally done in.  Otherwise, we can do it in MODE, the widest mode
8984      encountered.  The code we care about is that of the shift that will
8985      actually be done, not the shift that was originally requested.  */
8986   shift_mode
8987     = (code == ASHIFTRT || code == LSHIFTRT || code == ROTATE
8988        ? result_mode : mode);
8989
8990   /* We have now finished analyzing the shift.  The result should be
8991      a shift of type CODE with SHIFT_MODE shifting VAROP COUNT places.  If
8992      OUTER_OP is non-NIL, it is an operation that needs to be applied
8993      to the result of the shift.  OUTER_CONST is the relevant constant,
8994      but we must turn off all bits turned off in the shift.
8995
8996      If we were passed a value for X, see if we can use any pieces of
8997      it.  If not, make new rtx.  */
8998
8999   if (x && GET_RTX_CLASS (GET_CODE (x)) == '2'
9000       && GET_CODE (XEXP (x, 1)) == CONST_INT
9001       && INTVAL (XEXP (x, 1)) == count)
9002     const_rtx = XEXP (x, 1);
9003   else
9004     const_rtx = GEN_INT (count);
9005
9006   if (x && GET_CODE (XEXP (x, 0)) == SUBREG
9007       && GET_MODE (XEXP (x, 0)) == shift_mode
9008       && SUBREG_REG (XEXP (x, 0)) == varop)
9009     varop = XEXP (x, 0);
9010   else if (GET_MODE (varop) != shift_mode)
9011     varop = gen_lowpart_for_combine (shift_mode, varop);
9012
9013   /* If we can't make the SUBREG, try to return what we were given.  */
9014   if (GET_CODE (varop) == CLOBBER)
9015     return x ? x : varop;
9016
9017   new = simplify_binary_operation (code, shift_mode, varop, const_rtx);
9018   if (new != 0)
9019     x = new;
9020   else
9021     {
9022       if (x == 0 || GET_CODE (x) != code || GET_MODE (x) != shift_mode)
9023         x = gen_rtx_combine (code, shift_mode, varop, const_rtx);
9024
9025       SUBST (XEXP (x, 0), varop);
9026       SUBST (XEXP (x, 1), const_rtx);
9027     }
9028
9029   /* If we have an outer operation and we just made a shift, it is
9030      possible that we could have simplified the shift were it not
9031      for the outer operation.  So try to do the simplification
9032      recursively.  */
9033
9034   if (outer_op != NIL && GET_CODE (x) == code
9035       && GET_CODE (XEXP (x, 1)) == CONST_INT)
9036     x = simplify_shift_const (x, code, shift_mode, XEXP (x, 0),
9037                               INTVAL (XEXP (x, 1)));
9038
9039   /* If we were doing a LSHIFTRT in a wider mode than it was originally,
9040      turn off all the bits that the shift would have turned off.  */
9041   if (orig_code == LSHIFTRT && result_mode != shift_mode)
9042     x = simplify_and_const_int (NULL_RTX, shift_mode, x,
9043                                 GET_MODE_MASK (result_mode) >> orig_count);
9044
9045   /* Do the remainder of the processing in RESULT_MODE.  */
9046   x = gen_lowpart_for_combine (result_mode, x);
9047
9048   /* If COMPLEMENT_P is set, we have to complement X before doing the outer
9049      operation.  */
9050   if (complement_p)
9051     x = gen_unary (NOT, result_mode, result_mode, x);
9052
9053   if (outer_op != NIL)
9054     {
9055       if (GET_MODE_BITSIZE (result_mode) < HOST_BITS_PER_WIDE_INT)
9056         {
9057           int width = GET_MODE_BITSIZE (result_mode);
9058
9059           outer_const &= GET_MODE_MASK (result_mode);
9060
9061           /* If this would be an entire word for the target, but is not for
9062              the host, then sign-extend on the host so that the number will
9063              look the same way on the host that it would on the target.
9064
9065              For example, when building a 64 bit alpha hosted 32 bit sparc
9066              targeted compiler, then we want the 32 bit unsigned value -1 to be
9067              represented as a 64 bit value -1, and not as 0x00000000ffffffff.
9068              The later confuses the sparc backend.  */
9069
9070           if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT && BITS_PER_WORD == width
9071               && (outer_const & ((HOST_WIDE_INT) 1 << (width - 1))))
9072             outer_const |= ((HOST_WIDE_INT) (-1) << width);
9073         }
9074
9075       if (outer_op == AND)
9076         x = simplify_and_const_int (NULL_RTX, result_mode, x, outer_const);
9077       else if (outer_op == SET)
9078         /* This means that we have determined that the result is
9079            equivalent to a constant.  This should be rare.  */
9080         x = GEN_INT (outer_const);
9081       else if (GET_RTX_CLASS (outer_op) == '1')
9082         x = gen_unary (outer_op, result_mode, result_mode, x);
9083       else
9084         x = gen_binary (outer_op, result_mode, x, GEN_INT (outer_const));
9085     }
9086
9087   return x;
9088 }
9089 \f
9090 /* Like recog, but we receive the address of a pointer to a new pattern.
9091    We try to match the rtx that the pointer points to.
9092    If that fails, we may try to modify or replace the pattern,
9093    storing the replacement into the same pointer object.
9094
9095    Modifications include deletion or addition of CLOBBERs.
9096
9097    PNOTES is a pointer to a location where any REG_UNUSED notes added for
9098    the CLOBBERs are placed.
9099
9100    The value is the final insn code from the pattern ultimately matched,
9101    or -1.  */
9102
9103 static int
9104 recog_for_combine (pnewpat, insn, pnotes)
9105      rtx *pnewpat;
9106      rtx insn;
9107      rtx *pnotes;
9108 {
9109   register rtx pat = *pnewpat;
9110   int insn_code_number;
9111   int num_clobbers_to_add = 0;
9112   int i;
9113   rtx notes = 0;
9114
9115   /* If PAT is a PARALLEL, check to see if it contains the CLOBBER
9116      we use to indicate that something didn't match.  If we find such a
9117      thing, force rejection.  */
9118   if (GET_CODE (pat) == PARALLEL)
9119     for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
9120       if (GET_CODE (XVECEXP (pat, 0, i)) == CLOBBER
9121           && XEXP (XVECEXP (pat, 0, i), 0) == const0_rtx)
9122         return -1;
9123
9124   /* Is the result of combination a valid instruction?  */
9125   insn_code_number = recog (pat, insn, &num_clobbers_to_add);
9126
9127   /* If it isn't, there is the possibility that we previously had an insn
9128      that clobbered some register as a side effect, but the combined
9129      insn doesn't need to do that.  So try once more without the clobbers
9130      unless this represents an ASM insn.  */
9131
9132   if (insn_code_number < 0 && ! check_asm_operands (pat)
9133       && GET_CODE (pat) == PARALLEL)
9134     {
9135       int pos;
9136
9137       for (pos = 0, i = 0; i < XVECLEN (pat, 0); i++)
9138         if (GET_CODE (XVECEXP (pat, 0, i)) != CLOBBER)
9139           {
9140             if (i != pos)
9141               SUBST (XVECEXP (pat, 0, pos), XVECEXP (pat, 0, i));
9142             pos++;
9143           }
9144
9145       SUBST_INT (XVECLEN (pat, 0), pos);
9146
9147       if (pos == 1)
9148         pat = XVECEXP (pat, 0, 0);
9149
9150       insn_code_number = recog (pat, insn, &num_clobbers_to_add);
9151     }
9152
9153   /* If we had any clobbers to add, make a new pattern than contains
9154      them.  Then check to make sure that all of them are dead.  */
9155   if (num_clobbers_to_add)
9156     {
9157       rtx newpat = gen_rtx_PARALLEL (VOIDmode,
9158                                      gen_rtvec (GET_CODE (pat) == PARALLEL
9159                                                 ? XVECLEN (pat, 0) + num_clobbers_to_add
9160                                                 : num_clobbers_to_add + 1));
9161
9162       if (GET_CODE (pat) == PARALLEL)
9163         for (i = 0; i < XVECLEN (pat, 0); i++)
9164           XVECEXP (newpat, 0, i) = XVECEXP (pat, 0, i);
9165       else
9166         XVECEXP (newpat, 0, 0) = pat;
9167
9168       add_clobbers (newpat, insn_code_number);
9169
9170       for (i = XVECLEN (newpat, 0) - num_clobbers_to_add;
9171            i < XVECLEN (newpat, 0); i++)
9172         {
9173           if (GET_CODE (XEXP (XVECEXP (newpat, 0, i), 0)) == REG
9174               && ! reg_dead_at_p (XEXP (XVECEXP (newpat, 0, i), 0), insn))
9175             return -1;
9176           notes = gen_rtx_EXPR_LIST (REG_UNUSED,
9177                                      XEXP (XVECEXP (newpat, 0, i), 0), notes);
9178         }
9179       pat = newpat;
9180     }
9181
9182   *pnewpat = pat;
9183   *pnotes = notes;
9184
9185   return insn_code_number;
9186 }
9187 \f
9188 /* Like gen_lowpart but for use by combine.  In combine it is not possible
9189    to create any new pseudoregs.  However, it is safe to create
9190    invalid memory addresses, because combine will try to recognize
9191    them and all they will do is make the combine attempt fail.
9192
9193    If for some reason this cannot do its job, an rtx
9194    (clobber (const_int 0)) is returned.
9195    An insn containing that will not be recognized.  */
9196
9197 #undef gen_lowpart
9198
9199 static rtx
9200 gen_lowpart_for_combine (mode, x)
9201      enum machine_mode mode;
9202      register rtx x;
9203 {
9204   rtx result;
9205
9206   if (GET_MODE (x) == mode)
9207     return x;
9208
9209   /* We can only support MODE being wider than a word if X is a
9210      constant integer or has a mode the same size.  */
9211
9212   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
9213       && ! ((GET_MODE (x) == VOIDmode
9214              && (GET_CODE (x) == CONST_INT
9215                  || GET_CODE (x) == CONST_DOUBLE))
9216             || GET_MODE_SIZE (GET_MODE (x)) == GET_MODE_SIZE (mode)))
9217     return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
9218
9219   /* X might be a paradoxical (subreg (mem)).  In that case, gen_lowpart
9220      won't know what to do.  So we will strip off the SUBREG here and
9221      process normally.  */
9222   if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == MEM)
9223     {
9224       x = SUBREG_REG (x);
9225       if (GET_MODE (x) == mode)
9226         return x;
9227     }
9228
9229   result = gen_lowpart_common (mode, x);
9230   if (result != 0
9231       && GET_CODE (result) == SUBREG
9232       && GET_CODE (SUBREG_REG (result)) == REG
9233       && REGNO (SUBREG_REG (result)) >= FIRST_PSEUDO_REGISTER
9234       && (GET_MODE_SIZE (GET_MODE (result))
9235           != GET_MODE_SIZE (GET_MODE (SUBREG_REG (result)))))
9236     REG_CHANGES_SIZE (REGNO (SUBREG_REG (result))) = 1;
9237
9238   if (result)
9239     return result;
9240
9241   if (GET_CODE (x) == MEM)
9242     {
9243       register int offset = 0;
9244       rtx new;
9245
9246       /* Refuse to work on a volatile memory ref or one with a mode-dependent
9247          address.  */
9248       if (MEM_VOLATILE_P (x) || mode_dependent_address_p (XEXP (x, 0)))
9249         return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
9250
9251       /* If we want to refer to something bigger than the original memref,
9252          generate a perverse subreg instead.  That will force a reload
9253          of the original memref X.  */
9254       if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (mode))
9255         return gen_rtx_SUBREG (mode, x, 0);
9256
9257       if (WORDS_BIG_ENDIAN)
9258         offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
9259                   - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
9260       if (BYTES_BIG_ENDIAN)
9261         {
9262           /* Adjust the address so that the address-after-the-data is
9263              unchanged.  */
9264           offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
9265                      - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
9266         }
9267       new = gen_rtx_MEM (mode, plus_constant (XEXP (x, 0), offset));
9268       RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (x);
9269       MEM_COPY_ATTRIBUTES (new, x);
9270       return new;
9271     }
9272
9273   /* If X is a comparison operator, rewrite it in a new mode.  This
9274      probably won't match, but may allow further simplifications.  */
9275   else if (GET_RTX_CLASS (GET_CODE (x)) == '<')
9276     return gen_rtx_combine (GET_CODE (x), mode, XEXP (x, 0), XEXP (x, 1));
9277
9278   /* If we couldn't simplify X any other way, just enclose it in a
9279      SUBREG.  Normally, this SUBREG won't match, but some patterns may
9280      include an explicit SUBREG or we may simplify it further in combine.  */
9281   else
9282     {
9283       int word = 0;
9284
9285       if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
9286         word = ((GET_MODE_SIZE (GET_MODE (x))
9287                  - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD))
9288                 / UNITS_PER_WORD);
9289       return gen_rtx_SUBREG (mode, x, word);
9290     }
9291 }
9292 \f
9293 /* Make an rtx expression.  This is a subset of gen_rtx and only supports
9294    expressions of 1, 2, or 3 operands, each of which are rtx expressions.
9295
9296    If the identical expression was previously in the insn (in the undobuf),
9297    it will be returned.  Only if it is not found will a new expression
9298    be made.  */
9299
9300 /*VARARGS2*/
9301 static rtx
9302 gen_rtx_combine VPROTO((enum rtx_code code, enum machine_mode mode, ...))
9303 {
9304 #ifndef ANSI_PROTOTYPES
9305   enum rtx_code code;
9306   enum machine_mode mode;
9307 #endif
9308   va_list p;
9309   int n_args;
9310   rtx args[3];
9311   int j;
9312   char *fmt;
9313   rtx rt;
9314   struct undo *undo;
9315
9316   VA_START (p, mode);
9317
9318 #ifndef ANSI_PROTOTYPES
9319   code = va_arg (p, enum rtx_code);
9320   mode = va_arg (p, enum machine_mode);
9321 #endif
9322
9323   n_args = GET_RTX_LENGTH (code);
9324   fmt = GET_RTX_FORMAT (code);
9325
9326   if (n_args == 0 || n_args > 3)
9327     abort ();
9328
9329   /* Get each arg and verify that it is supposed to be an expression.  */
9330   for (j = 0; j < n_args; j++)
9331     {
9332       if (*fmt++ != 'e')
9333         abort ();
9334
9335       args[j] = va_arg (p, rtx);
9336     }
9337
9338   /* See if this is in undobuf.  Be sure we don't use objects that came
9339      from another insn; this could produce circular rtl structures.  */
9340
9341   for (undo = undobuf.undos; undo != undobuf.previous_undos; undo = undo->next)
9342     if (!undo->is_int
9343         && GET_CODE (undo->old_contents.r) == code
9344         && GET_MODE (undo->old_contents.r) == mode)
9345       {
9346         for (j = 0; j < n_args; j++)
9347           if (XEXP (undo->old_contents.r, j) != args[j])
9348             break;
9349
9350         if (j == n_args)
9351           return undo->old_contents.r;
9352       }
9353
9354   /* Otherwise make a new rtx.  We know we have 1, 2, or 3 args.
9355      Use rtx_alloc instead of gen_rtx because it's faster on RISC.  */
9356   rt = rtx_alloc (code);
9357   PUT_MODE (rt, mode);
9358   XEXP (rt, 0) = args[0];
9359   if (n_args > 1)
9360     {
9361       XEXP (rt, 1) = args[1];
9362       if (n_args > 2)
9363         XEXP (rt, 2) = args[2];
9364     }
9365   return rt;
9366 }
9367
9368 /* These routines make binary and unary operations by first seeing if they
9369    fold; if not, a new expression is allocated.  */
9370
9371 static rtx
9372 gen_binary (code, mode, op0, op1)
9373      enum rtx_code code;
9374      enum machine_mode mode;
9375      rtx op0, op1;
9376 {
9377   rtx result;
9378   rtx tem;
9379
9380   if (GET_RTX_CLASS (code) == 'c'
9381       && (GET_CODE (op0) == CONST_INT
9382           || (CONSTANT_P (op0) && GET_CODE (op1) != CONST_INT)))
9383     tem = op0, op0 = op1, op1 = tem;
9384
9385   if (GET_RTX_CLASS (code) == '<')
9386     {
9387       enum machine_mode op_mode = GET_MODE (op0);
9388
9389       /* Strip the COMPARE from (REL_OP (compare X Y) 0) to get
9390          just (REL_OP X Y).  */
9391       if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
9392         {
9393           op1 = XEXP (op0, 1);
9394           op0 = XEXP (op0, 0);
9395           op_mode = GET_MODE (op0);
9396         }
9397
9398       if (op_mode == VOIDmode)
9399         op_mode = GET_MODE (op1);
9400       result = simplify_relational_operation (code, op_mode, op0, op1);
9401     }
9402   else
9403     result = simplify_binary_operation (code, mode, op0, op1);
9404
9405   if (result)
9406     return result;
9407
9408   /* Put complex operands first and constants second.  */
9409   if (GET_RTX_CLASS (code) == 'c'
9410       && ((CONSTANT_P (op0) && GET_CODE (op1) != CONST_INT)
9411           || (GET_RTX_CLASS (GET_CODE (op0)) == 'o'
9412               && GET_RTX_CLASS (GET_CODE (op1)) != 'o')
9413           || (GET_CODE (op0) == SUBREG
9414               && GET_RTX_CLASS (GET_CODE (SUBREG_REG (op0))) == 'o'
9415               && GET_RTX_CLASS (GET_CODE (op1)) != 'o')))
9416     return gen_rtx_combine (code, mode, op1, op0);
9417
9418   /* If we are turning off bits already known off in OP0, we need not do
9419      an AND.  */
9420   else if (code == AND && GET_CODE (op1) == CONST_INT
9421            && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9422            && (nonzero_bits (op0, mode) & ~ INTVAL (op1)) == 0)
9423     return op0;
9424
9425   return gen_rtx_combine (code, mode, op0, op1);
9426 }
9427
9428 static rtx
9429 gen_unary (code, mode, op0_mode, op0)
9430      enum rtx_code code;
9431      enum machine_mode mode, op0_mode;
9432      rtx op0;
9433 {
9434   rtx result = simplify_unary_operation (code, mode, op0, op0_mode);
9435
9436   if (result)
9437     return result;
9438
9439   return gen_rtx_combine (code, mode, op0);
9440 }
9441 \f
9442 /* Simplify a comparison between *POP0 and *POP1 where CODE is the
9443    comparison code that will be tested.
9444
9445    The result is a possibly different comparison code to use.  *POP0 and
9446    *POP1 may be updated.
9447
9448    It is possible that we might detect that a comparison is either always
9449    true or always false.  However, we do not perform general constant
9450    folding in combine, so this knowledge isn't useful.  Such tautologies
9451    should have been detected earlier.  Hence we ignore all such cases.  */
9452
9453 static enum rtx_code
9454 simplify_comparison (code, pop0, pop1)
9455      enum rtx_code code;
9456      rtx *pop0;
9457      rtx *pop1;
9458 {
9459   rtx op0 = *pop0;
9460   rtx op1 = *pop1;
9461   rtx tem, tem1;
9462   int i;
9463   enum machine_mode mode, tmode;
9464
9465   /* Try a few ways of applying the same transformation to both operands.  */
9466   while (1)
9467     {
9468 #ifndef WORD_REGISTER_OPERATIONS
9469       /* The test below this one won't handle SIGN_EXTENDs on these machines,
9470          so check specially.  */
9471       if (code != GTU && code != GEU && code != LTU && code != LEU
9472           && GET_CODE (op0) == ASHIFTRT && GET_CODE (op1) == ASHIFTRT
9473           && GET_CODE (XEXP (op0, 0)) == ASHIFT
9474           && GET_CODE (XEXP (op1, 0)) == ASHIFT
9475           && GET_CODE (XEXP (XEXP (op0, 0), 0)) == SUBREG
9476           && GET_CODE (XEXP (XEXP (op1, 0), 0)) == SUBREG
9477           && (GET_MODE (SUBREG_REG (XEXP (XEXP (op0, 0), 0)))
9478               == GET_MODE (SUBREG_REG (XEXP (XEXP (op1, 0), 0))))
9479           && GET_CODE (XEXP (op0, 1)) == CONST_INT
9480           && GET_CODE (XEXP (op1, 1)) == CONST_INT
9481           && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
9482           && GET_CODE (XEXP (XEXP (op1, 0), 1)) == CONST_INT
9483           && INTVAL (XEXP (op0, 1)) == INTVAL (XEXP (op1, 1))
9484           && INTVAL (XEXP (op0, 1)) == INTVAL (XEXP (XEXP (op0, 0), 1))
9485           && INTVAL (XEXP (op0, 1)) == INTVAL (XEXP (XEXP (op1, 0), 1))
9486           && (INTVAL (XEXP (op0, 1))
9487               == (GET_MODE_BITSIZE (GET_MODE (op0))
9488                   - (GET_MODE_BITSIZE
9489                      (GET_MODE (SUBREG_REG (XEXP (XEXP (op0, 0), 0))))))))
9490         {
9491           op0 = SUBREG_REG (XEXP (XEXP (op0, 0), 0));
9492           op1 = SUBREG_REG (XEXP (XEXP (op1, 0), 0));
9493         }
9494 #endif
9495
9496       /* If both operands are the same constant shift, see if we can ignore the
9497          shift.  We can if the shift is a rotate or if the bits shifted out of
9498          this shift are known to be zero for both inputs and if the type of
9499          comparison is compatible with the shift.  */
9500       if (GET_CODE (op0) == GET_CODE (op1)
9501           && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
9502           && ((GET_CODE (op0) == ROTATE && (code == NE || code == EQ))
9503               || ((GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFT)
9504                   && (code != GT && code != LT && code != GE && code != LE))
9505               || (GET_CODE (op0) == ASHIFTRT
9506                   && (code != GTU && code != LTU
9507                       && code != GEU && code != GEU)))
9508           && GET_CODE (XEXP (op0, 1)) == CONST_INT
9509           && INTVAL (XEXP (op0, 1)) >= 0
9510           && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
9511           && XEXP (op0, 1) == XEXP (op1, 1))
9512         {
9513           enum machine_mode mode = GET_MODE (op0);
9514           unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
9515           int shift_count = INTVAL (XEXP (op0, 1));
9516
9517           if (GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFTRT)
9518             mask &= (mask >> shift_count) << shift_count;
9519           else if (GET_CODE (op0) == ASHIFT)
9520             mask = (mask & (mask << shift_count)) >> shift_count;
9521
9522           if ((nonzero_bits (XEXP (op0, 0), mode) & ~ mask) == 0
9523               && (nonzero_bits (XEXP (op1, 0), mode) & ~ mask) == 0)
9524             op0 = XEXP (op0, 0), op1 = XEXP (op1, 0);
9525           else
9526             break;
9527         }
9528
9529       /* If both operands are AND's of a paradoxical SUBREG by constant, the
9530          SUBREGs are of the same mode, and, in both cases, the AND would
9531          be redundant if the comparison was done in the narrower mode,
9532          do the comparison in the narrower mode (e.g., we are AND'ing with 1
9533          and the operand's possibly nonzero bits are 0xffffff01; in that case
9534          if we only care about QImode, we don't need the AND).  This case
9535          occurs if the output mode of an scc insn is not SImode and
9536          STORE_FLAG_VALUE == 1 (e.g., the 386).
9537
9538          Similarly, check for a case where the AND's are ZERO_EXTEND
9539          operations from some narrower mode even though a SUBREG is not
9540          present.  */
9541
9542       else if  (GET_CODE (op0) == AND && GET_CODE (op1) == AND
9543                 && GET_CODE (XEXP (op0, 1)) == CONST_INT
9544                 && GET_CODE (XEXP (op1, 1)) == CONST_INT)
9545         {
9546           rtx inner_op0 = XEXP (op0, 0);
9547           rtx inner_op1 = XEXP (op1, 0);
9548           HOST_WIDE_INT c0 = INTVAL (XEXP (op0, 1));
9549           HOST_WIDE_INT c1 = INTVAL (XEXP (op1, 1));
9550           int changed = 0;
9551
9552           if (GET_CODE (inner_op0) == SUBREG && GET_CODE (inner_op1) == SUBREG
9553               && (GET_MODE_SIZE (GET_MODE (inner_op0))
9554                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner_op0))))
9555               && (GET_MODE (SUBREG_REG (inner_op0))
9556                   == GET_MODE (SUBREG_REG (inner_op1)))
9557               && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (inner_op0)))
9558                   <= HOST_BITS_PER_WIDE_INT)
9559               && (0 == ((~c0) & nonzero_bits (SUBREG_REG (inner_op0),
9560                                              GET_MODE (SUBREG_REG (inner_op0)))))
9561               && (0 == ((~c1) & nonzero_bits (SUBREG_REG (inner_op1),
9562                                              GET_MODE (SUBREG_REG (inner_op1))))))
9563             {
9564               op0 = SUBREG_REG (inner_op0);
9565               op1 = SUBREG_REG (inner_op1);
9566
9567               /* The resulting comparison is always unsigned since we masked
9568                  off the original sign bit.  */
9569               code = unsigned_condition (code);
9570
9571               changed = 1;
9572             }
9573
9574           else if (c0 == c1)
9575             for (tmode = GET_CLASS_NARROWEST_MODE
9576                  (GET_MODE_CLASS (GET_MODE (op0)));
9577                  tmode != GET_MODE (op0); tmode = GET_MODE_WIDER_MODE (tmode))
9578               if ((unsigned HOST_WIDE_INT) c0 == GET_MODE_MASK (tmode))
9579                 {
9580                   op0 = gen_lowpart_for_combine (tmode, inner_op0);
9581                   op1 = gen_lowpart_for_combine (tmode, inner_op1);
9582                   code = unsigned_condition (code);
9583                   changed = 1;
9584                   break;
9585                 }
9586
9587           if (! changed)
9588             break;
9589         }
9590
9591       /* If both operands are NOT, we can strip off the outer operation
9592          and adjust the comparison code for swapped operands; similarly for
9593          NEG, except that this must be an equality comparison.  */
9594       else if ((GET_CODE (op0) == NOT && GET_CODE (op1) == NOT)
9595                || (GET_CODE (op0) == NEG && GET_CODE (op1) == NEG
9596                    && (code == EQ || code == NE)))
9597         op0 = XEXP (op0, 0), op1 = XEXP (op1, 0), code = swap_condition (code);
9598
9599       else
9600         break;
9601     }
9602
9603   /* If the first operand is a constant, swap the operands and adjust the
9604      comparison code appropriately, but don't do this if the second operand
9605      is already a constant integer.  */
9606   if (CONSTANT_P (op0) && GET_CODE (op1) != CONST_INT)
9607     {
9608       tem = op0, op0 = op1, op1 = tem;
9609       code = swap_condition (code);
9610     }
9611
9612   /* We now enter a loop during which we will try to simplify the comparison.
9613      For the most part, we only are concerned with comparisons with zero,
9614      but some things may really be comparisons with zero but not start
9615      out looking that way.  */
9616
9617   while (GET_CODE (op1) == CONST_INT)
9618     {
9619       enum machine_mode mode = GET_MODE (op0);
9620       int mode_width = GET_MODE_BITSIZE (mode);
9621       unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
9622       int equality_comparison_p;
9623       int sign_bit_comparison_p;
9624       int unsigned_comparison_p;
9625       HOST_WIDE_INT const_op;
9626
9627       /* We only want to handle integral modes.  This catches VOIDmode,
9628          CCmode, and the floating-point modes.  An exception is that we
9629          can handle VOIDmode if OP0 is a COMPARE or a comparison
9630          operation.  */
9631
9632       if (GET_MODE_CLASS (mode) != MODE_INT
9633           && ! (mode == VOIDmode
9634                 && (GET_CODE (op0) == COMPARE
9635                     || GET_RTX_CLASS (GET_CODE (op0)) == '<')))
9636         break;
9637
9638       /* Get the constant we are comparing against and turn off all bits
9639          not on in our mode.  */
9640       const_op = INTVAL (op1);
9641       if (mode_width <= HOST_BITS_PER_WIDE_INT)
9642         const_op &= mask;
9643
9644       /* If we are comparing against a constant power of two and the value
9645          being compared can only have that single bit nonzero (e.g., it was
9646          `and'ed with that bit), we can replace this with a comparison
9647          with zero.  */
9648       if (const_op
9649           && (code == EQ || code == NE || code == GE || code == GEU
9650               || code == LT || code == LTU)
9651           && mode_width <= HOST_BITS_PER_WIDE_INT
9652           && exact_log2 (const_op) >= 0
9653           && nonzero_bits (op0, mode) == (unsigned HOST_WIDE_INT) const_op)
9654         {
9655           code = (code == EQ || code == GE || code == GEU ? NE : EQ);
9656           op1 = const0_rtx, const_op = 0;
9657         }
9658
9659       /* Similarly, if we are comparing a value known to be either -1 or
9660          0 with -1, change it to the opposite comparison against zero.  */
9661
9662       if (const_op == -1
9663           && (code == EQ || code == NE || code == GT || code == LE
9664               || code == GEU || code == LTU)
9665           && num_sign_bit_copies (op0, mode) == mode_width)
9666         {
9667           code = (code == EQ || code == LE || code == GEU ? NE : EQ);
9668           op1 = const0_rtx, const_op = 0;
9669         }
9670
9671       /* Do some canonicalizations based on the comparison code.  We prefer
9672          comparisons against zero and then prefer equality comparisons.
9673          If we can reduce the size of a constant, we will do that too.  */
9674
9675       switch (code)
9676         {
9677         case LT:
9678           /* < C is equivalent to <= (C - 1) */
9679           if (const_op > 0)
9680             {
9681               const_op -= 1;
9682               op1 = GEN_INT (const_op);
9683               code = LE;
9684               /* ... fall through to LE case below.  */
9685             }
9686           else
9687             break;
9688
9689         case LE:
9690           /* <= C is equivalent to < (C + 1); we do this for C < 0  */
9691           if (const_op < 0)
9692             {
9693               const_op += 1;
9694               op1 = GEN_INT (const_op);
9695               code = LT;
9696             }
9697
9698           /* If we are doing a <= 0 comparison on a value known to have
9699              a zero sign bit, we can replace this with == 0.  */
9700           else if (const_op == 0
9701                    && mode_width <= HOST_BITS_PER_WIDE_INT
9702                    && (nonzero_bits (op0, mode)
9703                        & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)
9704             code = EQ;
9705           break;
9706
9707         case GE:
9708           /* >= C is equivalent to > (C - 1).  */
9709           if (const_op > 0)
9710             {
9711               const_op -= 1;
9712               op1 = GEN_INT (const_op);
9713               code = GT;
9714               /* ... fall through to GT below.  */
9715             }
9716           else
9717             break;
9718
9719         case GT:
9720           /* > C is equivalent to >= (C + 1); we do this for C < 0*/
9721           if (const_op < 0)
9722             {
9723               const_op += 1;
9724               op1 = GEN_INT (const_op);
9725               code = GE;
9726             }
9727
9728           /* If we are doing a > 0 comparison on a value known to have
9729              a zero sign bit, we can replace this with != 0.  */
9730           else if (const_op == 0
9731                    && mode_width <= HOST_BITS_PER_WIDE_INT
9732                    && (nonzero_bits (op0, mode)
9733                        & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)
9734             code = NE;
9735           break;
9736
9737         case LTU:
9738           /* < C is equivalent to <= (C - 1).  */
9739           if (const_op > 0)
9740             {
9741               const_op -= 1;
9742               op1 = GEN_INT (const_op);
9743               code = LEU;
9744               /* ... fall through ...  */
9745             }
9746
9747           /* (unsigned) < 0x80000000 is equivalent to >= 0.  */
9748           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
9749                    && (const_op == (HOST_WIDE_INT) 1 << (mode_width - 1)))
9750             {
9751               const_op = 0, op1 = const0_rtx;
9752               code = GE;
9753               break;
9754             }
9755           else
9756             break;
9757
9758         case LEU:
9759           /* unsigned <= 0 is equivalent to == 0 */
9760           if (const_op == 0)
9761             code = EQ;
9762
9763           /* (unsigned) <= 0x7fffffff is equivalent to >= 0.  */
9764           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
9765                    && (const_op == ((HOST_WIDE_INT) 1 << (mode_width - 1)) - 1))
9766             {
9767               const_op = 0, op1 = const0_rtx;
9768               code = GE;
9769             }
9770           break;
9771
9772         case GEU:
9773           /* >= C is equivalent to < (C - 1).  */
9774           if (const_op > 1)
9775             {
9776               const_op -= 1;
9777               op1 = GEN_INT (const_op);
9778               code = GTU;
9779               /* ... fall through ...  */
9780             }
9781
9782           /* (unsigned) >= 0x80000000 is equivalent to < 0.  */
9783           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
9784                    && (const_op == (HOST_WIDE_INT) 1 << (mode_width - 1)))
9785             {
9786               const_op = 0, op1 = const0_rtx;
9787               code = LT;
9788               break;
9789             }
9790           else
9791             break;
9792
9793         case GTU:
9794           /* unsigned > 0 is equivalent to != 0 */
9795           if (const_op == 0)
9796             code = NE;
9797
9798           /* (unsigned) > 0x7fffffff is equivalent to < 0.  */
9799           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
9800                     && (const_op == ((HOST_WIDE_INT) 1 << (mode_width - 1)) - 1))
9801             {
9802               const_op = 0, op1 = const0_rtx;
9803               code = LT;
9804             }
9805           break;
9806
9807         default:
9808           break;
9809         }
9810
9811       /* Compute some predicates to simplify code below.  */
9812
9813       equality_comparison_p = (code == EQ || code == NE);
9814       sign_bit_comparison_p = ((code == LT || code == GE) && const_op == 0);
9815       unsigned_comparison_p = (code == LTU || code == LEU || code == GTU
9816                                || code == LEU);
9817
9818       /* If this is a sign bit comparison and we can do arithmetic in
9819          MODE, say that we will only be needing the sign bit of OP0.  */
9820       if (sign_bit_comparison_p
9821           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
9822         op0 = force_to_mode (op0, mode,
9823                              ((HOST_WIDE_INT) 1
9824                               << (GET_MODE_BITSIZE (mode) - 1)),
9825                              NULL_RTX, 0);
9826
9827       /* Now try cases based on the opcode of OP0.  If none of the cases
9828          does a "continue", we exit this loop immediately after the
9829          switch.  */
9830
9831       switch (GET_CODE (op0))
9832         {
9833         case ZERO_EXTRACT:
9834           /* If we are extracting a single bit from a variable position in
9835              a constant that has only a single bit set and are comparing it
9836              with zero, we can convert this into an equality comparison
9837              between the position and the location of the single bit.  */
9838
9839           if (GET_CODE (XEXP (op0, 0)) == CONST_INT
9840               && XEXP (op0, 1) == const1_rtx
9841               && equality_comparison_p && const_op == 0
9842               && (i = exact_log2 (INTVAL (XEXP (op0, 0)))) >= 0)
9843             {
9844               if (BITS_BIG_ENDIAN)
9845                 {
9846 #ifdef HAVE_extzv
9847                   mode = insn_operand_mode[(int) CODE_FOR_extzv][1];
9848                   if (mode == VOIDmode)
9849                     mode = word_mode;
9850                   i = (GET_MODE_BITSIZE (mode) - 1 - i);
9851 #else
9852                   i = BITS_PER_WORD - 1 - i;
9853 #endif
9854                 }
9855
9856               op0 = XEXP (op0, 2);
9857               op1 = GEN_INT (i);
9858               const_op = i;
9859
9860               /* Result is nonzero iff shift count is equal to I.  */
9861               code = reverse_condition (code);
9862               continue;
9863             }
9864
9865           /* ... fall through ...  */
9866
9867         case SIGN_EXTRACT:
9868           tem = expand_compound_operation (op0);
9869           if (tem != op0)
9870             {
9871               op0 = tem;
9872               continue;
9873             }
9874           break;
9875
9876         case NOT:
9877           /* If testing for equality, we can take the NOT of the constant.  */
9878           if (equality_comparison_p
9879               && (tem = simplify_unary_operation (NOT, mode, op1, mode)) != 0)
9880             {
9881               op0 = XEXP (op0, 0);
9882               op1 = tem;
9883               continue;
9884             }
9885
9886           /* If just looking at the sign bit, reverse the sense of the
9887              comparison.  */
9888           if (sign_bit_comparison_p)
9889             {
9890               op0 = XEXP (op0, 0);
9891               code = (code == GE ? LT : GE);
9892               continue;
9893             }
9894           break;
9895
9896         case NEG:
9897           /* If testing for equality, we can take the NEG of the constant.  */
9898           if (equality_comparison_p
9899               && (tem = simplify_unary_operation (NEG, mode, op1, mode)) != 0)
9900             {
9901               op0 = XEXP (op0, 0);
9902               op1 = tem;
9903               continue;
9904             }
9905
9906           /* The remaining cases only apply to comparisons with zero.  */
9907           if (const_op != 0)
9908             break;
9909
9910           /* When X is ABS or is known positive,
9911              (neg X) is < 0 if and only if X != 0.  */
9912
9913           if (sign_bit_comparison_p
9914               && (GET_CODE (XEXP (op0, 0)) == ABS
9915                   || (mode_width <= HOST_BITS_PER_WIDE_INT
9916                       && (nonzero_bits (XEXP (op0, 0), mode)
9917                           & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)))
9918             {
9919               op0 = XEXP (op0, 0);
9920               code = (code == LT ? NE : EQ);
9921               continue;
9922             }
9923
9924           /* If we have NEG of something whose two high-order bits are the
9925              same, we know that "(-a) < 0" is equivalent to "a > 0".  */
9926           if (num_sign_bit_copies (op0, mode) >= 2)
9927             {
9928               op0 = XEXP (op0, 0);
9929               code = swap_condition (code);
9930               continue;
9931             }
9932           break;
9933
9934         case ROTATE:
9935           /* If we are testing equality and our count is a constant, we
9936              can perform the inverse operation on our RHS.  */
9937           if (equality_comparison_p && GET_CODE (XEXP (op0, 1)) == CONST_INT
9938               && (tem = simplify_binary_operation (ROTATERT, mode,
9939                                                    op1, XEXP (op0, 1))) != 0)
9940             {
9941               op0 = XEXP (op0, 0);
9942               op1 = tem;
9943               continue;
9944             }
9945
9946           /* If we are doing a < 0 or >= 0 comparison, it means we are testing
9947              a particular bit.  Convert it to an AND of a constant of that
9948              bit.  This will be converted into a ZERO_EXTRACT.  */
9949           if (const_op == 0 && sign_bit_comparison_p
9950               && GET_CODE (XEXP (op0, 1)) == CONST_INT
9951               && mode_width <= HOST_BITS_PER_WIDE_INT)
9952             {
9953               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
9954                                             ((HOST_WIDE_INT) 1
9955                                              << (mode_width - 1
9956                                                  - INTVAL (XEXP (op0, 1)))));
9957               code = (code == LT ? NE : EQ);
9958               continue;
9959             }
9960
9961           /* ... fall through ...  */
9962
9963         case ABS:
9964           /* ABS is ignorable inside an equality comparison with zero.  */
9965           if (const_op == 0 && equality_comparison_p)
9966             {
9967               op0 = XEXP (op0, 0);
9968               continue;
9969             }
9970           break;
9971
9972
9973         case SIGN_EXTEND:
9974           /* Can simplify (compare (zero/sign_extend FOO) CONST)
9975              to (compare FOO CONST) if CONST fits in FOO's mode and we
9976              are either testing inequality or have an unsigned comparison
9977              with ZERO_EXTEND or a signed comparison with SIGN_EXTEND.  */
9978           if (! unsigned_comparison_p
9979               && (GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0)))
9980                   <= HOST_BITS_PER_WIDE_INT)
9981               && ((unsigned HOST_WIDE_INT) const_op
9982                   < (((unsigned HOST_WIDE_INT) 1
9983                       << (GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0))) - 1)))))
9984             {
9985               op0 = XEXP (op0, 0);
9986               continue;
9987             }
9988           break;
9989
9990         case SUBREG:
9991           /* Check for the case where we are comparing A - C1 with C2,
9992              both constants are smaller than 1/2 the maximum positive
9993              value in MODE, and the comparison is equality or unsigned.
9994              In that case, if A is either zero-extended to MODE or has
9995              sufficient sign bits so that the high-order bit in MODE
9996              is a copy of the sign in the inner mode, we can prove that it is
9997              safe to do the operation in the wider mode.  This simplifies
9998              many range checks.  */
9999
10000           if (mode_width <= HOST_BITS_PER_WIDE_INT
10001               && subreg_lowpart_p (op0)
10002               && GET_CODE (SUBREG_REG (op0)) == PLUS
10003               && GET_CODE (XEXP (SUBREG_REG (op0), 1)) == CONST_INT
10004               && INTVAL (XEXP (SUBREG_REG (op0), 1)) < 0
10005               && (- INTVAL (XEXP (SUBREG_REG (op0), 1))
10006                   < (HOST_WIDE_INT)(GET_MODE_MASK (mode) / 2))
10007               && (unsigned HOST_WIDE_INT) const_op < GET_MODE_MASK (mode) / 2
10008               && (0 == (nonzero_bits (XEXP (SUBREG_REG (op0), 0),
10009                                       GET_MODE (SUBREG_REG (op0)))
10010                         & ~ GET_MODE_MASK (mode))
10011                   || (num_sign_bit_copies (XEXP (SUBREG_REG (op0), 0),
10012                                            GET_MODE (SUBREG_REG (op0)))
10013                       > (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0)))
10014                          - GET_MODE_BITSIZE (mode)))))
10015             {
10016               op0 = SUBREG_REG (op0);
10017               continue;
10018             }
10019
10020           /* If the inner mode is narrower and we are extracting the low part,
10021              we can treat the SUBREG as if it were a ZERO_EXTEND.  */
10022           if (subreg_lowpart_p (op0)
10023               && GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0))) < mode_width)
10024             /* Fall through */ ;
10025           else
10026             break;
10027
10028           /* ... fall through ...  */
10029
10030         case ZERO_EXTEND:
10031           if ((unsigned_comparison_p || equality_comparison_p)
10032               && (GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0)))
10033                   <= HOST_BITS_PER_WIDE_INT)
10034               && ((unsigned HOST_WIDE_INT) const_op
10035                   < GET_MODE_MASK (GET_MODE (XEXP (op0, 0)))))
10036             {
10037               op0 = XEXP (op0, 0);
10038               continue;
10039             }
10040           break;
10041
10042         case PLUS:
10043           /* (eq (plus X A) B) -> (eq X (minus B A)).  We can only do
10044              this for equality comparisons due to pathological cases involving
10045              overflows.  */
10046           if (equality_comparison_p
10047               && 0 != (tem = simplify_binary_operation (MINUS, mode,
10048                                                         op1, XEXP (op0, 1))))
10049             {
10050               op0 = XEXP (op0, 0);
10051               op1 = tem;
10052               continue;
10053             }
10054
10055           /* (plus (abs X) (const_int -1)) is < 0 if and only if X == 0.  */
10056           if (const_op == 0 && XEXP (op0, 1) == constm1_rtx
10057               && GET_CODE (XEXP (op0, 0)) == ABS && sign_bit_comparison_p)
10058             {
10059               op0 = XEXP (XEXP (op0, 0), 0);
10060               code = (code == LT ? EQ : NE);
10061               continue;
10062             }
10063           break;
10064
10065         case MINUS:
10066           /* (eq (minus A B) C) -> (eq A (plus B C)) or
10067              (eq B (minus A C)), whichever simplifies.  We can only do
10068              this for equality comparisons due to pathological cases involving
10069              overflows.  */
10070           if (equality_comparison_p
10071               && 0 != (tem = simplify_binary_operation (PLUS, mode,
10072                                                         XEXP (op0, 1), op1)))
10073             {
10074               op0 = XEXP (op0, 0);
10075               op1 = tem;
10076               continue;
10077             }
10078
10079           if (equality_comparison_p
10080               && 0 != (tem = simplify_binary_operation (MINUS, mode,
10081                                                         XEXP (op0, 0), op1)))
10082             {
10083               op0 = XEXP (op0, 1);
10084               op1 = tem;
10085               continue;
10086             }
10087
10088           /* The sign bit of (minus (ashiftrt X C) X), where C is the number
10089              of bits in X minus 1, is one iff X > 0.  */
10090           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 0)) == ASHIFTRT
10091               && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
10092               && INTVAL (XEXP (XEXP (op0, 0), 1)) == mode_width - 1
10093               && rtx_equal_p (XEXP (XEXP (op0, 0), 0), XEXP (op0, 1)))
10094             {
10095               op0 = XEXP (op0, 1);
10096               code = (code == GE ? LE : GT);
10097               continue;
10098             }
10099           break;
10100
10101         case XOR:
10102           /* (eq (xor A B) C) -> (eq A (xor B C)).  This is a simplification
10103              if C is zero or B is a constant.  */
10104           if (equality_comparison_p
10105               && 0 != (tem = simplify_binary_operation (XOR, mode,
10106                                                         XEXP (op0, 1), op1)))
10107             {
10108               op0 = XEXP (op0, 0);
10109               op1 = tem;
10110               continue;
10111             }
10112           break;
10113
10114         case EQ:  case NE:
10115         case LT:  case LTU:  case LE:  case LEU:
10116         case GT:  case GTU:  case GE:  case GEU:
10117           /* We can't do anything if OP0 is a condition code value, rather
10118              than an actual data value.  */
10119           if (const_op != 0
10120 #ifdef HAVE_cc0
10121               || XEXP (op0, 0) == cc0_rtx
10122 #endif
10123               || GET_MODE_CLASS (GET_MODE (XEXP (op0, 0))) == MODE_CC)
10124             break;
10125
10126           /* Get the two operands being compared.  */
10127           if (GET_CODE (XEXP (op0, 0)) == COMPARE)
10128             tem = XEXP (XEXP (op0, 0), 0), tem1 = XEXP (XEXP (op0, 0), 1);
10129           else
10130             tem = XEXP (op0, 0), tem1 = XEXP (op0, 1);
10131
10132           /* Check for the cases where we simply want the result of the
10133              earlier test or the opposite of that result.  */
10134           if (code == NE
10135               || (code == EQ && reversible_comparison_p (op0))
10136               || (GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
10137                   && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
10138                   && (STORE_FLAG_VALUE
10139                       & (((HOST_WIDE_INT) 1
10140                           << (GET_MODE_BITSIZE (GET_MODE (op0)) - 1))))
10141                   && (code == LT
10142                       || (code == GE && reversible_comparison_p (op0)))))
10143             {
10144               code = (code == LT || code == NE
10145                       ? GET_CODE (op0) : reverse_condition (GET_CODE (op0)));
10146               op0 = tem, op1 = tem1;
10147               continue;
10148             }
10149           break;
10150
10151         case IOR:
10152           /* The sign bit of (ior (plus X (const_int -1)) X) is non-zero
10153              iff X <= 0.  */
10154           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 0)) == PLUS
10155               && XEXP (XEXP (op0, 0), 1) == constm1_rtx
10156               && rtx_equal_p (XEXP (XEXP (op0, 0), 0), XEXP (op0, 1)))
10157             {
10158               op0 = XEXP (op0, 1);
10159               code = (code == GE ? GT : LE);
10160               continue;
10161             }
10162           break;
10163
10164         case AND:
10165           /* Convert (and (xshift 1 X) Y) to (and (lshiftrt Y X) 1).  This
10166              will be converted to a ZERO_EXTRACT later.  */
10167           if (const_op == 0 && equality_comparison_p
10168               && GET_CODE (XEXP (op0, 0)) == ASHIFT
10169               && XEXP (XEXP (op0, 0), 0) == const1_rtx)
10170             {
10171               op0 = simplify_and_const_int
10172                 (op0, mode, gen_rtx_combine (LSHIFTRT, mode,
10173                                              XEXP (op0, 1),
10174                                              XEXP (XEXP (op0, 0), 1)),
10175                  (HOST_WIDE_INT) 1);
10176               continue;
10177             }
10178
10179           /* If we are comparing (and (lshiftrt X C1) C2) for equality with
10180              zero and X is a comparison and C1 and C2 describe only bits set
10181              in STORE_FLAG_VALUE, we can compare with X.  */
10182           if (const_op == 0 && equality_comparison_p
10183               && mode_width <= HOST_BITS_PER_WIDE_INT
10184               && GET_CODE (XEXP (op0, 1)) == CONST_INT
10185               && GET_CODE (XEXP (op0, 0)) == LSHIFTRT
10186               && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
10187               && INTVAL (XEXP (XEXP (op0, 0), 1)) >= 0
10188               && INTVAL (XEXP (XEXP (op0, 0), 1)) < HOST_BITS_PER_WIDE_INT)
10189             {
10190               mask = ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
10191                       << INTVAL (XEXP (XEXP (op0, 0), 1)));
10192               if ((~ STORE_FLAG_VALUE & mask) == 0
10193                   && (GET_RTX_CLASS (GET_CODE (XEXP (XEXP (op0, 0), 0))) == '<'
10194                       || ((tem = get_last_value (XEXP (XEXP (op0, 0), 0))) != 0
10195                           && GET_RTX_CLASS (GET_CODE (tem)) == '<')))
10196                 {
10197                   op0 = XEXP (XEXP (op0, 0), 0);
10198                   continue;
10199                 }
10200             }
10201
10202           /* If we are doing an equality comparison of an AND of a bit equal
10203              to the sign bit, replace this with a LT or GE comparison of
10204              the underlying value.  */
10205           if (equality_comparison_p
10206               && const_op == 0
10207               && GET_CODE (XEXP (op0, 1)) == CONST_INT
10208               && mode_width <= HOST_BITS_PER_WIDE_INT
10209               && ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
10210                   == (unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
10211             {
10212               op0 = XEXP (op0, 0);
10213               code = (code == EQ ? GE : LT);
10214               continue;
10215             }
10216
10217           /* If this AND operation is really a ZERO_EXTEND from a narrower
10218              mode, the constant fits within that mode, and this is either an
10219              equality or unsigned comparison, try to do this comparison in
10220              the narrower mode.  */
10221           if ((equality_comparison_p || unsigned_comparison_p)
10222               && GET_CODE (XEXP (op0, 1)) == CONST_INT
10223               && (i = exact_log2 ((INTVAL (XEXP (op0, 1))
10224                                    & GET_MODE_MASK (mode))
10225                                   + 1)) >= 0
10226               && const_op >> i == 0
10227               && (tmode = mode_for_size (i, MODE_INT, 1)) != BLKmode)
10228             {
10229               op0 = gen_lowpart_for_combine (tmode, XEXP (op0, 0));
10230               continue;
10231             }
10232
10233           /* If this is (and:M1 (subreg:M2 X 0) (const_int C1)) where C1 fits
10234              in both M1 and M2 and the SUBREG is either paradoxical or
10235              represents the low part, permute the SUBREG and the AND and
10236              try again.  */
10237           if (GET_CODE (XEXP (op0, 0)) == SUBREG
10238               && ((mode_width
10239                    >= GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (XEXP (op0, 0)))))
10240 #ifdef WORD_REGISTER_OPERATIONS
10241                   || subreg_lowpart_p (XEXP (op0, 0))
10242 #endif
10243                   )
10244 #ifndef WORD_REGISTER_OPERATIONS
10245               /* It is unsafe to commute the AND into the SUBREG if the SUBREG
10246                  is paradoxical and WORD_REGISTER_OPERATIONS is not defined.
10247                  As originally written the upper bits have a defined value
10248                  due to the AND operation.  However, if we commute the AND
10249                  inside the SUBREG then they no longer have defined values
10250                  and the meaning of the code has been changed.  */
10251               && (GET_MODE_SIZE (GET_MODE (XEXP (op0, 0)))
10252                   <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (XEXP (op0, 0)))))
10253 #endif
10254               && GET_CODE (XEXP (op0, 1)) == CONST_INT
10255               && mode_width <= HOST_BITS_PER_WIDE_INT
10256               && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (XEXP (op0, 0))))
10257                   <= HOST_BITS_PER_WIDE_INT)
10258               && (INTVAL (XEXP (op0, 1)) & ~ mask) == 0
10259               && 0 == (~ GET_MODE_MASK (GET_MODE (SUBREG_REG (XEXP (op0, 0))))
10260                        & INTVAL (XEXP (op0, 1)))
10261               && (unsigned HOST_WIDE_INT) INTVAL (XEXP (op0, 1)) != mask
10262               && ((unsigned HOST_WIDE_INT) INTVAL (XEXP (op0, 1))
10263                   != GET_MODE_MASK (GET_MODE (SUBREG_REG (XEXP (op0, 0))))))
10264
10265             {
10266               op0
10267                 = gen_lowpart_for_combine
10268                   (mode,
10269                    gen_binary (AND, GET_MODE (SUBREG_REG (XEXP (op0, 0))),
10270                                SUBREG_REG (XEXP (op0, 0)), XEXP (op0, 1)));
10271               continue;
10272             }
10273
10274           break;
10275
10276         case ASHIFT:
10277           /* If we have (compare (ashift FOO N) (const_int C)) and
10278              the high order N bits of FOO (N+1 if an inequality comparison)
10279              are known to be zero, we can do this by comparing FOO with C
10280              shifted right N bits so long as the low-order N bits of C are
10281              zero.  */
10282           if (GET_CODE (XEXP (op0, 1)) == CONST_INT
10283               && INTVAL (XEXP (op0, 1)) >= 0
10284               && ((INTVAL (XEXP (op0, 1)) + ! equality_comparison_p)
10285                   < HOST_BITS_PER_WIDE_INT)
10286               && ((const_op
10287                    & (((HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1))) - 1)) == 0)
10288               && mode_width <= HOST_BITS_PER_WIDE_INT
10289               && (nonzero_bits (XEXP (op0, 0), mode)
10290                   & ~ (mask >> (INTVAL (XEXP (op0, 1))
10291                                 + ! equality_comparison_p))) == 0)
10292             {
10293               const_op >>= INTVAL (XEXP (op0, 1));
10294               op1 = GEN_INT (const_op);
10295               op0 = XEXP (op0, 0);
10296               continue;
10297             }
10298
10299           /* If we are doing a sign bit comparison, it means we are testing
10300              a particular bit.  Convert it to the appropriate AND.  */
10301           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 1)) == CONST_INT
10302               && mode_width <= HOST_BITS_PER_WIDE_INT)
10303             {
10304               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
10305                                             ((HOST_WIDE_INT) 1
10306                                              << (mode_width - 1
10307                                                  - INTVAL (XEXP (op0, 1)))));
10308               code = (code == LT ? NE : EQ);
10309               continue;
10310             }
10311
10312           /* If this an equality comparison with zero and we are shifting
10313              the low bit to the sign bit, we can convert this to an AND of the
10314              low-order bit.  */
10315           if (const_op == 0 && equality_comparison_p
10316               && GET_CODE (XEXP (op0, 1)) == CONST_INT
10317               && INTVAL (XEXP (op0, 1)) == mode_width - 1)
10318             {
10319               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
10320                                             (HOST_WIDE_INT) 1);
10321               continue;
10322             }
10323           break;
10324
10325         case ASHIFTRT:
10326           /* If this is an equality comparison with zero, we can do this
10327              as a logical shift, which might be much simpler.  */
10328           if (equality_comparison_p && const_op == 0
10329               && GET_CODE (XEXP (op0, 1)) == CONST_INT)
10330             {
10331               op0 = simplify_shift_const (NULL_RTX, LSHIFTRT, mode,
10332                                           XEXP (op0, 0),
10333                                           INTVAL (XEXP (op0, 1)));
10334               continue;
10335             }
10336
10337           /* If OP0 is a sign extension and CODE is not an unsigned comparison,
10338              do the comparison in a narrower mode.  */
10339           if (! unsigned_comparison_p
10340               && GET_CODE (XEXP (op0, 1)) == CONST_INT
10341               && GET_CODE (XEXP (op0, 0)) == ASHIFT
10342               && XEXP (op0, 1) == XEXP (XEXP (op0, 0), 1)
10343               && (tmode = mode_for_size (mode_width - INTVAL (XEXP (op0, 1)),
10344                                          MODE_INT, 1)) != BLKmode
10345               && ((unsigned HOST_WIDE_INT) const_op <= GET_MODE_MASK (tmode)
10346                   || ((unsigned HOST_WIDE_INT) - const_op
10347                       <= GET_MODE_MASK (tmode))))
10348             {
10349               op0 = gen_lowpart_for_combine (tmode, XEXP (XEXP (op0, 0), 0));
10350               continue;
10351             }
10352
10353           /* ... fall through ...  */
10354         case LSHIFTRT:
10355           /* If we have (compare (xshiftrt FOO N) (const_int C)) and
10356              the low order N bits of FOO are known to be zero, we can do this
10357              by comparing FOO with C shifted left N bits so long as no
10358              overflow occurs.  */
10359           if (GET_CODE (XEXP (op0, 1)) == CONST_INT
10360               && INTVAL (XEXP (op0, 1)) >= 0
10361               && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
10362               && mode_width <= HOST_BITS_PER_WIDE_INT
10363               && (nonzero_bits (XEXP (op0, 0), mode)
10364                   & (((HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1))) - 1)) == 0
10365               && (const_op == 0
10366                   || (floor_log2 (const_op) + INTVAL (XEXP (op0, 1))
10367                       < mode_width)))
10368             {
10369               const_op <<= INTVAL (XEXP (op0, 1));
10370               op1 = GEN_INT (const_op);
10371               op0 = XEXP (op0, 0);
10372               continue;
10373             }
10374
10375           /* If we are using this shift to extract just the sign bit, we
10376              can replace this with an LT or GE comparison.  */
10377           if (const_op == 0
10378               && (equality_comparison_p || sign_bit_comparison_p)
10379               && GET_CODE (XEXP (op0, 1)) == CONST_INT
10380               && INTVAL (XEXP (op0, 1)) == mode_width - 1)
10381             {
10382               op0 = XEXP (op0, 0);
10383               code = (code == NE || code == GT ? LT : GE);
10384               continue;
10385             }
10386           break;
10387
10388         default:
10389           break;
10390         }
10391
10392       break;
10393     }
10394
10395   /* Now make any compound operations involved in this comparison.  Then,
10396      check for an outmost SUBREG on OP0 that is not doing anything or is
10397      paradoxical.  The latter case can only occur when it is known that the
10398      "extra" bits will be zero.  Therefore, it is safe to remove the SUBREG.
10399      We can never remove a SUBREG for a non-equality comparison because the
10400      sign bit is in a different place in the underlying object.  */
10401
10402   op0 = make_compound_operation (op0, op1 == const0_rtx ? COMPARE : SET);
10403   op1 = make_compound_operation (op1, SET);
10404
10405   if (GET_CODE (op0) == SUBREG && subreg_lowpart_p (op0)
10406       && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
10407       && (code == NE || code == EQ)
10408       && ((GET_MODE_SIZE (GET_MODE (op0))
10409            > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0))))))
10410     {
10411       op0 = SUBREG_REG (op0);
10412       op1 = gen_lowpart_for_combine (GET_MODE (op0), op1);
10413     }
10414
10415   else if (GET_CODE (op0) == SUBREG && subreg_lowpart_p (op0)
10416            && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
10417            && (code == NE || code == EQ)
10418            && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0)))
10419                <= HOST_BITS_PER_WIDE_INT)
10420            && (nonzero_bits (SUBREG_REG (op0), GET_MODE (SUBREG_REG (op0)))
10421                & ~ GET_MODE_MASK (GET_MODE (op0))) == 0
10422            && (tem = gen_lowpart_for_combine (GET_MODE (SUBREG_REG (op0)),
10423                                               op1),
10424                (nonzero_bits (tem, GET_MODE (SUBREG_REG (op0)))
10425                 & ~ GET_MODE_MASK (GET_MODE (op0))) == 0))
10426     op0 = SUBREG_REG (op0), op1 = tem;
10427
10428   /* We now do the opposite procedure: Some machines don't have compare
10429      insns in all modes.  If OP0's mode is an integer mode smaller than a
10430      word and we can't do a compare in that mode, see if there is a larger
10431      mode for which we can do the compare.  There are a number of cases in
10432      which we can use the wider mode.  */
10433
10434   mode = GET_MODE (op0);
10435   if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
10436       && GET_MODE_SIZE (mode) < UNITS_PER_WORD
10437       && cmp_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
10438     for (tmode = GET_MODE_WIDER_MODE (mode);
10439          (tmode != VOIDmode
10440           && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT);
10441          tmode = GET_MODE_WIDER_MODE (tmode))
10442       if (cmp_optab->handlers[(int) tmode].insn_code != CODE_FOR_nothing)
10443         {
10444           /* If the only nonzero bits in OP0 and OP1 are those in the
10445              narrower mode and this is an equality or unsigned comparison,
10446              we can use the wider mode.  Similarly for sign-extended
10447              values, in which case it is true for all comparisons.  */
10448           if (((code == EQ || code == NE
10449                 || code == GEU || code == GTU || code == LEU || code == LTU)
10450                && (nonzero_bits (op0, tmode) & ~ GET_MODE_MASK (mode)) == 0
10451                && (nonzero_bits (op1, tmode) & ~ GET_MODE_MASK (mode)) == 0)
10452               || ((num_sign_bit_copies (op0, tmode)
10453                    > GET_MODE_BITSIZE (tmode) - GET_MODE_BITSIZE (mode))
10454                   && (num_sign_bit_copies (op1, tmode)
10455                       > GET_MODE_BITSIZE (tmode) - GET_MODE_BITSIZE (mode))))
10456             {
10457               op0 = gen_lowpart_for_combine (tmode, op0);
10458               op1 = gen_lowpart_for_combine (tmode, op1);
10459               break;
10460             }
10461
10462           /* If this is a test for negative, we can make an explicit
10463              test of the sign bit.  */
10464
10465           if (op1 == const0_rtx && (code == LT || code == GE)
10466               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
10467             {
10468               op0 = gen_binary (AND, tmode,
10469                                 gen_lowpart_for_combine (tmode, op0),
10470                                 GEN_INT ((HOST_WIDE_INT) 1
10471                                          << (GET_MODE_BITSIZE (mode) - 1)));
10472               code = (code == LT) ? NE : EQ;
10473               break;
10474             }
10475         }
10476
10477 #ifdef CANONICALIZE_COMPARISON
10478   /* If this machine only supports a subset of valid comparisons, see if we
10479      can convert an unsupported one into a supported one.  */
10480   CANONICALIZE_COMPARISON (code, op0, op1);
10481 #endif
10482
10483   *pop0 = op0;
10484   *pop1 = op1;
10485
10486   return code;
10487 }
10488 \f
10489 /* Return 1 if we know that X, a comparison operation, is not operating
10490    on a floating-point value or is EQ or NE, meaning that we can safely
10491    reverse it.  */
10492
10493 static int
10494 reversible_comparison_p (x)
10495      rtx x;
10496 {
10497   if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
10498       || flag_fast_math
10499       || GET_CODE (x) == NE || GET_CODE (x) == EQ)
10500     return 1;
10501
10502   switch (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))))
10503     {
10504     case MODE_INT:
10505     case MODE_PARTIAL_INT:
10506     case MODE_COMPLEX_INT:
10507       return 1;
10508
10509     case MODE_CC:
10510       /* If the mode of the condition codes tells us that this is safe,
10511          we need look no further.  */
10512       if (REVERSIBLE_CC_MODE (GET_MODE (XEXP (x, 0))))
10513         return 1;
10514
10515       /* Otherwise try and find where the condition codes were last set and
10516          use that.  */
10517       x = get_last_value (XEXP (x, 0));
10518       return (x && GET_CODE (x) == COMPARE
10519               && ! FLOAT_MODE_P (GET_MODE (XEXP (x, 0))));
10520
10521     default:
10522       return 0;
10523     }
10524 }
10525 \f
10526 /* Utility function for following routine.  Called when X is part of a value
10527    being stored into reg_last_set_value.  Sets reg_last_set_table_tick
10528    for each register mentioned.  Similar to mention_regs in cse.c  */
10529
10530 static void
10531 update_table_tick (x)
10532      rtx x;
10533 {
10534   register enum rtx_code code = GET_CODE (x);
10535   register char *fmt = GET_RTX_FORMAT (code);
10536   register int i;
10537
10538   if (code == REG)
10539     {
10540       int regno = REGNO (x);
10541       int endregno = regno + (regno < FIRST_PSEUDO_REGISTER
10542                               ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
10543
10544       for (i = regno; i < endregno; i++)
10545         reg_last_set_table_tick[i] = label_tick;
10546
10547       return;
10548     }
10549
10550   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
10551     /* Note that we can't have an "E" in values stored; see
10552        get_last_value_validate.  */
10553     if (fmt[i] == 'e')
10554       update_table_tick (XEXP (x, i));
10555 }
10556
10557 /* Record that REG is set to VALUE in insn INSN.  If VALUE is zero, we
10558    are saying that the register is clobbered and we no longer know its
10559    value.  If INSN is zero, don't update reg_last_set; this is only permitted
10560    with VALUE also zero and is used to invalidate the register.  */
10561
10562 static void
10563 record_value_for_reg (reg, insn, value)
10564      rtx reg;
10565      rtx insn;
10566      rtx value;
10567 {
10568   int regno = REGNO (reg);
10569   int endregno = regno + (regno < FIRST_PSEUDO_REGISTER
10570                           ? HARD_REGNO_NREGS (regno, GET_MODE (reg)) : 1);
10571   int i;
10572
10573   /* If VALUE contains REG and we have a previous value for REG, substitute
10574      the previous value.  */
10575   if (value && insn && reg_overlap_mentioned_p (reg, value))
10576     {
10577       rtx tem;
10578
10579       /* Set things up so get_last_value is allowed to see anything set up to
10580          our insn.  */
10581       subst_low_cuid = INSN_CUID (insn);
10582       tem = get_last_value (reg);
10583
10584       if (tem)
10585         value = replace_rtx (copy_rtx (value), reg, tem);
10586     }
10587
10588   /* For each register modified, show we don't know its value, that
10589      we don't know about its bitwise content, that its value has been
10590      updated, and that we don't know the location of the death of the
10591      register.  */
10592   for (i = regno; i < endregno; i ++)
10593     {
10594       if (insn)
10595         reg_last_set[i] = insn;
10596       reg_last_set_value[i] = 0;
10597       reg_last_set_mode[i] = 0;
10598       reg_last_set_nonzero_bits[i] = 0;
10599       reg_last_set_sign_bit_copies[i] = 0;
10600       reg_last_death[i] = 0;
10601     }
10602
10603   /* Mark registers that are being referenced in this value.  */
10604   if (value)
10605     update_table_tick (value);
10606
10607   /* Now update the status of each register being set.
10608      If someone is using this register in this block, set this register
10609      to invalid since we will get confused between the two lives in this
10610      basic block.  This makes using this register always invalid.  In cse, we
10611      scan the table to invalidate all entries using this register, but this
10612      is too much work for us.  */
10613
10614   for (i = regno; i < endregno; i++)
10615     {
10616       reg_last_set_label[i] = label_tick;
10617       if (value && reg_last_set_table_tick[i] == label_tick)
10618         reg_last_set_invalid[i] = 1;
10619       else
10620         reg_last_set_invalid[i] = 0;
10621     }
10622
10623   /* The value being assigned might refer to X (like in "x++;").  In that
10624      case, we must replace it with (clobber (const_int 0)) to prevent
10625      infinite loops.  */
10626   if (value && ! get_last_value_validate (&value, insn,
10627                                           reg_last_set_label[regno], 0))
10628     {
10629       value = copy_rtx (value);
10630       if (! get_last_value_validate (&value, insn,
10631                                      reg_last_set_label[regno], 1))
10632         value = 0;
10633     }
10634
10635   /* For the main register being modified, update the value, the mode, the
10636      nonzero bits, and the number of sign bit copies.  */
10637
10638   reg_last_set_value[regno] = value;
10639
10640   if (value)
10641     {
10642       subst_low_cuid = INSN_CUID (insn);
10643       reg_last_set_mode[regno] = GET_MODE (reg);
10644       reg_last_set_nonzero_bits[regno] = nonzero_bits (value, GET_MODE (reg));
10645       reg_last_set_sign_bit_copies[regno]
10646         = num_sign_bit_copies (value, GET_MODE (reg));
10647     }
10648 }
10649
10650 /* Used for communication between the following two routines.  */
10651 static rtx record_dead_insn;
10652
10653 /* Called via note_stores from record_dead_and_set_regs to handle one
10654    SET or CLOBBER in an insn.  */
10655
10656 static void
10657 record_dead_and_set_regs_1 (dest, setter)
10658      rtx dest, setter;
10659 {
10660   if (GET_CODE (dest) == SUBREG)
10661     dest = SUBREG_REG (dest);
10662
10663   if (GET_CODE (dest) == REG)
10664     {
10665       /* If we are setting the whole register, we know its value.  Otherwise
10666          show that we don't know the value.  We can handle SUBREG in
10667          some cases.  */
10668       if (GET_CODE (setter) == SET && dest == SET_DEST (setter))
10669         record_value_for_reg (dest, record_dead_insn, SET_SRC (setter));
10670       else if (GET_CODE (setter) == SET
10671                && GET_CODE (SET_DEST (setter)) == SUBREG
10672                && SUBREG_REG (SET_DEST (setter)) == dest
10673                && GET_MODE_BITSIZE (GET_MODE (dest)) <= BITS_PER_WORD
10674                && subreg_lowpart_p (SET_DEST (setter)))
10675         record_value_for_reg (dest, record_dead_insn,
10676                               gen_lowpart_for_combine (GET_MODE (dest),
10677                                                        SET_SRC (setter)));
10678       else
10679         record_value_for_reg (dest, record_dead_insn, NULL_RTX);
10680     }
10681   else if (GET_CODE (dest) == MEM
10682            /* Ignore pushes, they clobber nothing.  */
10683            && ! push_operand (dest, GET_MODE (dest)))
10684     mem_last_set = INSN_CUID (record_dead_insn);
10685 }
10686
10687 /* Update the records of when each REG was most recently set or killed
10688    for the things done by INSN.  This is the last thing done in processing
10689    INSN in the combiner loop.
10690
10691    We update reg_last_set, reg_last_set_value, reg_last_set_mode,
10692    reg_last_set_nonzero_bits, reg_last_set_sign_bit_copies, reg_last_death,
10693    and also the similar information mem_last_set (which insn most recently
10694    modified memory) and last_call_cuid (which insn was the most recent
10695    subroutine call).  */
10696
10697 static void
10698 record_dead_and_set_regs (insn)
10699      rtx insn;
10700 {
10701   register rtx link;
10702   int i;
10703
10704   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
10705     {
10706       if (REG_NOTE_KIND (link) == REG_DEAD
10707           && GET_CODE (XEXP (link, 0)) == REG)
10708         {
10709           int regno = REGNO (XEXP (link, 0));
10710           int endregno
10711             = regno + (regno < FIRST_PSEUDO_REGISTER
10712                        ? HARD_REGNO_NREGS (regno, GET_MODE (XEXP (link, 0)))
10713                        : 1);
10714
10715           for (i = regno; i < endregno; i++)
10716             reg_last_death[i] = insn;
10717         }
10718       else if (REG_NOTE_KIND (link) == REG_INC)
10719         record_value_for_reg (XEXP (link, 0), insn, NULL_RTX);
10720     }
10721
10722   if (GET_CODE (insn) == CALL_INSN)
10723     {
10724       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
10725         if (call_used_regs[i])
10726           {
10727             reg_last_set_value[i] = 0;
10728             reg_last_set_mode[i] = 0;
10729             reg_last_set_nonzero_bits[i] = 0;
10730             reg_last_set_sign_bit_copies[i] = 0;
10731             reg_last_death[i] = 0;
10732           }
10733
10734       last_call_cuid = mem_last_set = INSN_CUID (insn);
10735     }
10736
10737   record_dead_insn = insn;
10738   note_stores (PATTERN (insn), record_dead_and_set_regs_1);
10739 }
10740 \f
10741 /* Utility routine for the following function.  Verify that all the registers
10742    mentioned in *LOC are valid when *LOC was part of a value set when
10743    label_tick == TICK.  Return 0 if some are not.
10744
10745    If REPLACE is non-zero, replace the invalid reference with
10746    (clobber (const_int 0)) and return 1.  This replacement is useful because
10747    we often can get useful information about the form of a value (e.g., if
10748    it was produced by a shift that always produces -1 or 0) even though
10749    we don't know exactly what registers it was produced from.  */
10750
10751 static int
10752 get_last_value_validate (loc, insn, tick, replace)
10753      rtx *loc;
10754      rtx insn;
10755      int tick;
10756      int replace;
10757 {
10758   rtx x = *loc;
10759   char *fmt = GET_RTX_FORMAT (GET_CODE (x));
10760   int len = GET_RTX_LENGTH (GET_CODE (x));
10761   int i;
10762
10763   if (GET_CODE (x) == REG)
10764     {
10765       int regno = REGNO (x);
10766       int endregno = regno + (regno < FIRST_PSEUDO_REGISTER
10767                               ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
10768       int j;
10769
10770       for (j = regno; j < endregno; j++)
10771         if (reg_last_set_invalid[j]
10772             /* If this is a pseudo-register that was only set once, it is
10773                always valid.  */
10774             || (! (regno >= FIRST_PSEUDO_REGISTER && REG_N_SETS (regno) == 1)
10775                 && reg_last_set_label[j] > tick))
10776           {
10777             if (replace)
10778               *loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
10779             return replace;
10780           }
10781
10782       return 1;
10783     }
10784   /* If this is a memory reference, make sure that there were
10785      no stores after it that might have clobbered the value.  We don't
10786      have alias info, so we assume any store invalidates it.  */
10787   else if (GET_CODE (x) == MEM && ! RTX_UNCHANGING_P (x)
10788            && INSN_CUID (insn) <= mem_last_set)
10789     {
10790       if (replace)
10791         *loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
10792       return replace;
10793     }
10794
10795   for (i = 0; i < len; i++)
10796     if ((fmt[i] == 'e'
10797          && get_last_value_validate (&XEXP (x, i), insn, tick, replace) == 0)
10798         /* Don't bother with these.  They shouldn't occur anyway.  */
10799         || fmt[i] == 'E')
10800       return 0;
10801
10802   /* If we haven't found a reason for it to be invalid, it is valid.  */
10803   return 1;
10804 }
10805
10806 /* Get the last value assigned to X, if known.  Some registers
10807    in the value may be replaced with (clobber (const_int 0)) if their value
10808    is known longer known reliably.  */
10809
10810 static rtx
10811 get_last_value (x)
10812      rtx x;
10813 {
10814   int regno;
10815   rtx value;
10816
10817   /* If this is a non-paradoxical SUBREG, get the value of its operand and
10818      then convert it to the desired mode.  If this is a paradoxical SUBREG,
10819      we cannot predict what values the "extra" bits might have.  */
10820   if (GET_CODE (x) == SUBREG
10821       && subreg_lowpart_p (x)
10822       && (GET_MODE_SIZE (GET_MODE (x))
10823           <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
10824       && (value = get_last_value (SUBREG_REG (x))) != 0)
10825     return gen_lowpart_for_combine (GET_MODE (x), value);
10826
10827   if (GET_CODE (x) != REG)
10828     return 0;
10829
10830   regno = REGNO (x);
10831   value = reg_last_set_value[regno];
10832
10833   /* If we don't have a value or if it isn't for this basic block,
10834      return 0.  */
10835
10836   if (value == 0
10837       || (REG_N_SETS (regno) != 1
10838           && reg_last_set_label[regno] != label_tick))
10839     return 0;
10840
10841   /* If the value was set in a later insn than the ones we are processing,
10842      we can't use it even if the register was only set once, but make a quick
10843      check to see if the previous insn set it to something.  This is commonly
10844      the case when the same pseudo is used by repeated insns.
10845
10846      This does not work if there exists an instruction which is temporarily
10847      not on the insn chain.  */
10848
10849   if (INSN_CUID (reg_last_set[regno]) >= subst_low_cuid)
10850     {
10851       rtx insn, set;
10852
10853       /* We can not do anything useful in this case, because there is
10854          an instruction which is not on the insn chain.  */
10855       if (subst_prev_insn)
10856         return 0;
10857
10858       /* Skip over USE insns.  They are not useful here, and they may have
10859          been made by combine, in which case they do not have a INSN_CUID
10860          value.  We can't use prev_real_insn, because that would incorrectly
10861          take us backwards across labels.  Skip over BARRIERs also, since
10862          they could have been made by combine.  If we see one, we must be
10863          optimizing dead code, so it doesn't matter what we do.  */
10864       for (insn = prev_nonnote_insn (subst_insn);
10865            insn && ((GET_CODE (insn) == INSN
10866                      && GET_CODE (PATTERN (insn)) == USE)
10867                     || GET_CODE (insn) == BARRIER
10868                     || INSN_CUID (insn) >= subst_low_cuid);
10869            insn = prev_nonnote_insn (insn))
10870         ;
10871
10872       if (insn
10873           && (set = single_set (insn)) != 0
10874           && rtx_equal_p (SET_DEST (set), x))
10875         {
10876           value = SET_SRC (set);
10877
10878           /* Make sure that VALUE doesn't reference X.  Replace any
10879              explicit references with a CLOBBER.  If there are any remaining
10880              references (rare), don't use the value.  */
10881
10882           if (reg_mentioned_p (x, value))
10883             value = replace_rtx (copy_rtx (value), x,
10884                                  gen_rtx_CLOBBER (GET_MODE (x), const0_rtx));
10885
10886           if (reg_overlap_mentioned_p (x, value))
10887             return 0;
10888         }
10889       else
10890         return 0;
10891     }
10892
10893   /* If the value has all its registers valid, return it.  */
10894   if (get_last_value_validate (&value, reg_last_set[regno],
10895                                reg_last_set_label[regno], 0))
10896     return value;
10897
10898   /* Otherwise, make a copy and replace any invalid register with
10899      (clobber (const_int 0)).  If that fails for some reason, return 0.  */
10900
10901   value = copy_rtx (value);
10902   if (get_last_value_validate (&value, reg_last_set[regno],
10903                                reg_last_set_label[regno], 1))
10904     return value;
10905
10906   return 0;
10907 }
10908 \f
10909 /* Return nonzero if expression X refers to a REG or to memory
10910    that is set in an instruction more recent than FROM_CUID.  */
10911
10912 static int
10913 use_crosses_set_p (x, from_cuid)
10914      register rtx x;
10915      int from_cuid;
10916 {
10917   register char *fmt;
10918   register int i;
10919   register enum rtx_code code = GET_CODE (x);
10920
10921   if (code == REG)
10922     {
10923       register int regno = REGNO (x);
10924       int endreg = regno + (regno < FIRST_PSEUDO_REGISTER
10925                             ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
10926
10927 #ifdef PUSH_ROUNDING
10928       /* Don't allow uses of the stack pointer to be moved,
10929          because we don't know whether the move crosses a push insn.  */
10930       if (regno == STACK_POINTER_REGNUM)
10931         return 1;
10932 #endif
10933       for (;regno < endreg; regno++)
10934         if (reg_last_set[regno]
10935             && INSN_CUID (reg_last_set[regno]) > from_cuid)
10936           return 1;
10937       return 0;
10938     }
10939
10940   if (code == MEM && mem_last_set > from_cuid)
10941     return 1;
10942
10943   fmt = GET_RTX_FORMAT (code);
10944
10945   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
10946     {
10947       if (fmt[i] == 'E')
10948         {
10949           register int j;
10950           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
10951             if (use_crosses_set_p (XVECEXP (x, i, j), from_cuid))
10952               return 1;
10953         }
10954       else if (fmt[i] == 'e'
10955                && use_crosses_set_p (XEXP (x, i), from_cuid))
10956         return 1;
10957     }
10958   return 0;
10959 }
10960 \f
10961 /* Define three variables used for communication between the following
10962    routines.  */
10963
10964 static int reg_dead_regno, reg_dead_endregno;
10965 static int reg_dead_flag;
10966
10967 /* Function called via note_stores from reg_dead_at_p.
10968
10969    If DEST is within [reg_dead_regno, reg_dead_endregno), set
10970    reg_dead_flag to 1 if X is a CLOBBER and to -1 it is a SET.  */
10971
10972 static void
10973 reg_dead_at_p_1 (dest, x)
10974      rtx dest;
10975      rtx x;
10976 {
10977   int regno, endregno;
10978
10979   if (GET_CODE (dest) != REG)
10980     return;
10981
10982   regno = REGNO (dest);
10983   endregno = regno + (regno < FIRST_PSEUDO_REGISTER
10984                       ? HARD_REGNO_NREGS (regno, GET_MODE (dest)) : 1);
10985
10986   if (reg_dead_endregno > regno && reg_dead_regno < endregno)
10987     reg_dead_flag = (GET_CODE (x) == CLOBBER) ? 1 : -1;
10988 }
10989
10990 /* Return non-zero if REG is known to be dead at INSN.
10991
10992    We scan backwards from INSN.  If we hit a REG_DEAD note or a CLOBBER
10993    referencing REG, it is dead.  If we hit a SET referencing REG, it is
10994    live.  Otherwise, see if it is live or dead at the start of the basic
10995    block we are in.  Hard regs marked as being live in NEWPAT_USED_REGS
10996    must be assumed to be always live.  */
10997
10998 static int
10999 reg_dead_at_p (reg, insn)
11000      rtx reg;
11001      rtx insn;
11002 {
11003   int block, i;
11004
11005   /* Set variables for reg_dead_at_p_1.  */
11006   reg_dead_regno = REGNO (reg);
11007   reg_dead_endregno = reg_dead_regno + (reg_dead_regno < FIRST_PSEUDO_REGISTER
11008                                         ? HARD_REGNO_NREGS (reg_dead_regno,
11009                                                             GET_MODE (reg))
11010                                         : 1);
11011
11012   reg_dead_flag = 0;
11013
11014   /* Check that reg isn't mentioned in NEWPAT_USED_REGS.  */
11015   if (reg_dead_regno < FIRST_PSEUDO_REGISTER)
11016     {
11017       for (i = reg_dead_regno; i < reg_dead_endregno; i++)
11018         if (TEST_HARD_REG_BIT (newpat_used_regs, i))
11019           return 0;
11020     }
11021
11022   /* Scan backwards until we find a REG_DEAD note, SET, CLOBBER, label, or
11023      beginning of function.  */
11024   for (; insn && GET_CODE (insn) != CODE_LABEL && GET_CODE (insn) != BARRIER;
11025        insn = prev_nonnote_insn (insn))
11026     {
11027       note_stores (PATTERN (insn), reg_dead_at_p_1);
11028       if (reg_dead_flag)
11029         return reg_dead_flag == 1 ? 1 : 0;
11030
11031       if (find_regno_note (insn, REG_DEAD, reg_dead_regno))
11032         return 1;
11033     }
11034
11035   /* Get the basic block number that we were in.  */
11036   if (insn == 0)
11037     block = 0;
11038   else
11039     {
11040       for (block = 0; block < n_basic_blocks; block++)
11041         if (insn == BLOCK_HEAD (block))
11042           break;
11043
11044       if (block == n_basic_blocks)
11045         return 0;
11046     }
11047
11048   for (i = reg_dead_regno; i < reg_dead_endregno; i++)
11049     if (REGNO_REG_SET_P (BASIC_BLOCK (block)->global_live_at_start, i))
11050       return 0;
11051
11052   return 1;
11053 }
11054 \f
11055 /* Note hard registers in X that are used.  This code is similar to
11056    that in flow.c, but much simpler since we don't care about pseudos.  */
11057
11058 static void
11059 mark_used_regs_combine (x)
11060      rtx x;
11061 {
11062   register RTX_CODE code = GET_CODE (x);
11063   register int regno;
11064   int i;
11065
11066   switch (code)
11067     {
11068     case LABEL_REF:
11069     case SYMBOL_REF:
11070     case CONST_INT:
11071     case CONST:
11072     case CONST_DOUBLE:
11073     case PC:
11074     case ADDR_VEC:
11075     case ADDR_DIFF_VEC:
11076     case ASM_INPUT:
11077 #ifdef HAVE_cc0
11078     /* CC0 must die in the insn after it is set, so we don't need to take
11079        special note of it here.  */
11080     case CC0:
11081 #endif
11082       return;
11083
11084     case CLOBBER:
11085       /* If we are clobbering a MEM, mark any hard registers inside the
11086          address as used.  */
11087       if (GET_CODE (XEXP (x, 0)) == MEM)
11088         mark_used_regs_combine (XEXP (XEXP (x, 0), 0));
11089       return;
11090
11091     case REG:
11092       regno = REGNO (x);
11093       /* A hard reg in a wide mode may really be multiple registers.
11094          If so, mark all of them just like the first.  */
11095       if (regno < FIRST_PSEUDO_REGISTER)
11096         {
11097           /* None of this applies to the stack, frame or arg pointers */
11098           if (regno == STACK_POINTER_REGNUM
11099 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
11100               || regno == HARD_FRAME_POINTER_REGNUM
11101 #endif
11102 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
11103               || (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
11104 #endif
11105               || regno == FRAME_POINTER_REGNUM)
11106             return;
11107
11108           i = HARD_REGNO_NREGS (regno, GET_MODE (x));
11109           while (i-- > 0)
11110             SET_HARD_REG_BIT (newpat_used_regs, regno + i);
11111         }
11112       return;
11113
11114     case SET:
11115       {
11116         /* If setting a MEM, or a SUBREG of a MEM, then note any hard regs in
11117            the address.  */
11118         register rtx testreg = SET_DEST (x);
11119
11120         while (GET_CODE (testreg) == SUBREG
11121                || GET_CODE (testreg) == ZERO_EXTRACT
11122                || GET_CODE (testreg) == SIGN_EXTRACT
11123                || GET_CODE (testreg) == STRICT_LOW_PART)
11124           testreg = XEXP (testreg, 0);
11125
11126         if (GET_CODE (testreg) == MEM)
11127           mark_used_regs_combine (XEXP (testreg, 0));
11128
11129         mark_used_regs_combine (SET_SRC (x));
11130       }
11131       return;
11132
11133     default:
11134       break;
11135     }
11136
11137   /* Recursively scan the operands of this expression.  */
11138
11139   {
11140     register char *fmt = GET_RTX_FORMAT (code);
11141
11142     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
11143       {
11144         if (fmt[i] == 'e')
11145           mark_used_regs_combine (XEXP (x, i));
11146         else if (fmt[i] == 'E')
11147           {
11148             register int j;
11149
11150             for (j = 0; j < XVECLEN (x, i); j++)
11151               mark_used_regs_combine (XVECEXP (x, i, j));
11152           }
11153       }
11154   }
11155 }
11156
11157 \f
11158 /* Remove register number REGNO from the dead registers list of INSN.
11159
11160    Return the note used to record the death, if there was one.  */
11161
11162 rtx
11163 remove_death (regno, insn)
11164      int regno;
11165      rtx insn;
11166 {
11167   register rtx note = find_regno_note (insn, REG_DEAD, regno);
11168
11169   if (note)
11170     {
11171       REG_N_DEATHS (regno)--;
11172       remove_note (insn, note);
11173     }
11174
11175   return note;
11176 }
11177
11178 /* For each register (hardware or pseudo) used within expression X, if its
11179    death is in an instruction with cuid between FROM_CUID (inclusive) and
11180    TO_INSN (exclusive), put a REG_DEAD note for that register in the
11181    list headed by PNOTES.
11182
11183    That said, don't move registers killed by maybe_kill_insn.
11184
11185    This is done when X is being merged by combination into TO_INSN.  These
11186    notes will then be distributed as needed.  */
11187
11188 static void
11189 move_deaths (x, maybe_kill_insn, from_cuid, to_insn, pnotes)
11190      rtx x;
11191      rtx maybe_kill_insn;
11192      int from_cuid;
11193      rtx to_insn;
11194      rtx *pnotes;
11195 {
11196   register char *fmt;
11197   register int len, i;
11198   register enum rtx_code code = GET_CODE (x);
11199
11200   if (code == REG)
11201     {
11202       register int regno = REGNO (x);
11203       register rtx where_dead = reg_last_death[regno];
11204       register rtx before_dead, after_dead;
11205
11206       /* Don't move the register if it gets killed in between from and to */
11207       if (maybe_kill_insn && reg_set_p (x, maybe_kill_insn)
11208           && !reg_referenced_p (x, maybe_kill_insn))
11209         return;
11210
11211       /* WHERE_DEAD could be a USE insn made by combine, so first we
11212          make sure that we have insns with valid INSN_CUID values.  */
11213       before_dead = where_dead;
11214       while (before_dead && INSN_UID (before_dead) > max_uid_cuid)
11215         before_dead = PREV_INSN (before_dead);
11216       after_dead = where_dead;
11217       while (after_dead && INSN_UID (after_dead) > max_uid_cuid)
11218         after_dead = NEXT_INSN (after_dead);
11219
11220       if (before_dead && after_dead
11221           && INSN_CUID (before_dead) >= from_cuid
11222           && (INSN_CUID (after_dead) < INSN_CUID (to_insn)
11223               || (where_dead != after_dead
11224                   && INSN_CUID (after_dead) == INSN_CUID (to_insn))))
11225         {
11226           rtx note = remove_death (regno, where_dead);
11227
11228           /* It is possible for the call above to return 0.  This can occur
11229              when reg_last_death points to I2 or I1 that we combined with.
11230              In that case make a new note.
11231
11232              We must also check for the case where X is a hard register
11233              and NOTE is a death note for a range of hard registers
11234              including X.  In that case, we must put REG_DEAD notes for
11235              the remaining registers in place of NOTE.  */
11236
11237           if (note != 0 && regno < FIRST_PSEUDO_REGISTER
11238               && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
11239                   > GET_MODE_SIZE (GET_MODE (x))))
11240             {
11241               int deadregno = REGNO (XEXP (note, 0));
11242               int deadend
11243                 = (deadregno + HARD_REGNO_NREGS (deadregno,
11244                                                  GET_MODE (XEXP (note, 0))));
11245               int ourend = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
11246               int i;
11247
11248               for (i = deadregno; i < deadend; i++)
11249                 if (i < regno || i >= ourend)
11250                   REG_NOTES (where_dead)
11251                     = gen_rtx_EXPR_LIST (REG_DEAD,
11252                                          gen_rtx_REG (reg_raw_mode[i], i),
11253                                          REG_NOTES (where_dead));
11254             }
11255           /* If we didn't find any note, or if we found a REG_DEAD note that
11256              covers only part of the given reg, and we have a multi-reg hard
11257              register, then to be safe we must check for REG_DEAD notes
11258              for each register other than the first.  They could have
11259              their own REG_DEAD notes lying around.  */
11260           else if ((note == 0
11261                     || (note != 0
11262                         && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
11263                             < GET_MODE_SIZE (GET_MODE (x)))))
11264                    && regno < FIRST_PSEUDO_REGISTER
11265                    && HARD_REGNO_NREGS (regno, GET_MODE (x)) > 1)
11266             {
11267               int ourend = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
11268               int i, offset;
11269               rtx oldnotes = 0;
11270
11271               if (note)
11272                 offset = HARD_REGNO_NREGS (regno, GET_MODE (XEXP (note, 0)));
11273               else
11274                 offset = 1;
11275
11276               for (i = regno + offset; i < ourend; i++)
11277                 move_deaths (gen_rtx_REG (reg_raw_mode[i], i),
11278                              maybe_kill_insn, from_cuid, to_insn, &oldnotes);
11279             }
11280
11281           if (note != 0 && GET_MODE (XEXP (note, 0)) == GET_MODE (x))
11282             {
11283               XEXP (note, 1) = *pnotes;
11284               *pnotes = note;
11285             }
11286           else
11287             *pnotes = gen_rtx_EXPR_LIST (REG_DEAD, x, *pnotes);
11288
11289           REG_N_DEATHS (regno)++;
11290         }
11291
11292       return;
11293     }
11294
11295   else if (GET_CODE (x) == SET)
11296     {
11297       rtx dest = SET_DEST (x);
11298
11299       move_deaths (SET_SRC (x), maybe_kill_insn, from_cuid, to_insn, pnotes);
11300
11301       /* In the case of a ZERO_EXTRACT, a STRICT_LOW_PART, or a SUBREG
11302          that accesses one word of a multi-word item, some
11303          piece of everything register in the expression is used by
11304          this insn, so remove any old death.  */
11305
11306       if (GET_CODE (dest) == ZERO_EXTRACT
11307           || GET_CODE (dest) == STRICT_LOW_PART
11308           || (GET_CODE (dest) == SUBREG
11309               && (((GET_MODE_SIZE (GET_MODE (dest))
11310                     + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
11311                   == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
11312                        + UNITS_PER_WORD - 1) / UNITS_PER_WORD))))
11313         {
11314           move_deaths (dest, maybe_kill_insn, from_cuid, to_insn, pnotes);
11315           return;
11316         }
11317
11318       /* If this is some other SUBREG, we know it replaces the entire
11319          value, so use that as the destination.  */
11320       if (GET_CODE (dest) == SUBREG)
11321         dest = SUBREG_REG (dest);
11322
11323       /* If this is a MEM, adjust deaths of anything used in the address.
11324          For a REG (the only other possibility), the entire value is
11325          being replaced so the old value is not used in this insn.  */
11326
11327       if (GET_CODE (dest) == MEM)
11328         move_deaths (XEXP (dest, 0), maybe_kill_insn, from_cuid,
11329                      to_insn, pnotes);
11330       return;
11331     }
11332
11333   else if (GET_CODE (x) == CLOBBER)
11334     return;
11335
11336   len = GET_RTX_LENGTH (code);
11337   fmt = GET_RTX_FORMAT (code);
11338
11339   for (i = 0; i < len; i++)
11340     {
11341       if (fmt[i] == 'E')
11342         {
11343           register int j;
11344           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
11345             move_deaths (XVECEXP (x, i, j), maybe_kill_insn, from_cuid,
11346                          to_insn, pnotes);
11347         }
11348       else if (fmt[i] == 'e')
11349         move_deaths (XEXP (x, i), maybe_kill_insn, from_cuid, to_insn, pnotes);
11350     }
11351 }
11352 \f
11353 /* Return 1 if X is the target of a bit-field assignment in BODY, the
11354    pattern of an insn.  X must be a REG.  */
11355
11356 static int
11357 reg_bitfield_target_p (x, body)
11358      rtx x;
11359      rtx body;
11360 {
11361   int i;
11362
11363   if (GET_CODE (body) == SET)
11364     {
11365       rtx dest = SET_DEST (body);
11366       rtx target;
11367       int regno, tregno, endregno, endtregno;
11368
11369       if (GET_CODE (dest) == ZERO_EXTRACT)
11370         target = XEXP (dest, 0);
11371       else if (GET_CODE (dest) == STRICT_LOW_PART)
11372         target = SUBREG_REG (XEXP (dest, 0));
11373       else
11374         return 0;
11375
11376       if (GET_CODE (target) == SUBREG)
11377         target = SUBREG_REG (target);
11378
11379       if (GET_CODE (target) != REG)
11380         return 0;
11381
11382       tregno = REGNO (target), regno = REGNO (x);
11383       if (tregno >= FIRST_PSEUDO_REGISTER || regno >= FIRST_PSEUDO_REGISTER)
11384         return target == x;
11385
11386       endtregno = tregno + HARD_REGNO_NREGS (tregno, GET_MODE (target));
11387       endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
11388
11389       return endregno > tregno && regno < endtregno;
11390     }
11391
11392   else if (GET_CODE (body) == PARALLEL)
11393     for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
11394       if (reg_bitfield_target_p (x, XVECEXP (body, 0, i)))
11395         return 1;
11396
11397   return 0;
11398 }
11399 \f
11400 /* Given a chain of REG_NOTES originally from FROM_INSN, try to place them
11401    as appropriate.  I3 and I2 are the insns resulting from the combination
11402    insns including FROM (I2 may be zero).
11403
11404    ELIM_I2 and ELIM_I1 are either zero or registers that we know will
11405    not need REG_DEAD notes because they are being substituted for.  This
11406    saves searching in the most common cases.
11407
11408    Each note in the list is either ignored or placed on some insns, depending
11409    on the type of note.  */
11410
11411 static void
11412 distribute_notes (notes, from_insn, i3, i2, elim_i2, elim_i1)
11413      rtx notes;
11414      rtx from_insn;
11415      rtx i3, i2;
11416      rtx elim_i2, elim_i1;
11417 {
11418   rtx note, next_note;
11419   rtx tem;
11420
11421   for (note = notes; note; note = next_note)
11422     {
11423       rtx place = 0, place2 = 0;
11424
11425       /* If this NOTE references a pseudo register, ensure it references
11426          the latest copy of that register.  */
11427       if (XEXP (note, 0) && GET_CODE (XEXP (note, 0)) == REG
11428           && REGNO (XEXP (note, 0)) >= FIRST_PSEUDO_REGISTER)
11429         XEXP (note, 0) = regno_reg_rtx[REGNO (XEXP (note, 0))];
11430
11431       next_note = XEXP (note, 1);
11432       switch (REG_NOTE_KIND (note))
11433         {
11434         case REG_BR_PROB:
11435         case REG_EXEC_COUNT:
11436           /* Doesn't matter much where we put this, as long as it's somewhere.
11437              It is preferable to keep these notes on branches, which is most
11438              likely to be i3.  */
11439           place = i3;
11440           break;
11441
11442         case REG_EH_REGION:
11443           /* This note must remain with the call.  It should not be possible
11444              for both I2 and I3 to be a call.  */
11445           if (GET_CODE (i3) == CALL_INSN)
11446             place = i3;
11447           else if (i2 && GET_CODE (i2) == CALL_INSN)
11448             place = i2;
11449           else
11450             abort ();
11451           break;
11452
11453         case REG_UNUSED:
11454           /* Any clobbers for i3 may still exist, and so we must process
11455              REG_UNUSED notes from that insn.
11456
11457              Any clobbers from i2 or i1 can only exist if they were added by
11458              recog_for_combine.  In that case, recog_for_combine created the
11459              necessary REG_UNUSED notes.  Trying to keep any original
11460              REG_UNUSED notes from these insns can cause incorrect output
11461              if it is for the same register as the original i3 dest.
11462              In that case, we will notice that the register is set in i3,
11463              and then add a REG_UNUSED note for the destination of i3, which
11464              is wrong.  However, it is possible to have REG_UNUSED notes from
11465              i2 or i1 for register which were both used and clobbered, so
11466              we keep notes from i2 or i1 if they will turn into REG_DEAD
11467              notes.  */
11468
11469           /* If this register is set or clobbered in I3, put the note there
11470              unless there is one already.  */
11471           if (reg_set_p (XEXP (note, 0), PATTERN (i3)))
11472             {
11473               if (from_insn != i3)
11474                 break;
11475
11476               if (! (GET_CODE (XEXP (note, 0)) == REG
11477                      ? find_regno_note (i3, REG_UNUSED, REGNO (XEXP (note, 0)))
11478                      : find_reg_note (i3, REG_UNUSED, XEXP (note, 0))))
11479                 place = i3;
11480             }
11481           /* Otherwise, if this register is used by I3, then this register
11482              now dies here, so we must put a REG_DEAD note here unless there
11483              is one already.  */
11484           else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3))
11485                    && ! (GET_CODE (XEXP (note, 0)) == REG
11486                          ? find_regno_note (i3, REG_DEAD, REGNO (XEXP (note, 0)))
11487                          : find_reg_note (i3, REG_DEAD, XEXP (note, 0))))
11488             {
11489               PUT_REG_NOTE_KIND (note, REG_DEAD);
11490               place = i3;
11491             }
11492           break;
11493
11494         case REG_EQUAL:
11495         case REG_EQUIV:
11496         case REG_NONNEG:
11497         case REG_NOALIAS:
11498           /* These notes say something about results of an insn.  We can
11499              only support them if they used to be on I3 in which case they
11500              remain on I3.  Otherwise they are ignored.
11501
11502              If the note refers to an expression that is not a constant, we
11503              must also ignore the note since we cannot tell whether the
11504              equivalence is still true.  It might be possible to do
11505              slightly better than this (we only have a problem if I2DEST
11506              or I1DEST is present in the expression), but it doesn't
11507              seem worth the trouble.  */
11508
11509           if (from_insn == i3
11510               && (XEXP (note, 0) == 0 || CONSTANT_P (XEXP (note, 0))))
11511             place = i3;
11512           break;
11513
11514         case REG_INC:
11515         case REG_NO_CONFLICT:
11516           /* These notes say something about how a register is used.  They must
11517              be present on any use of the register in I2 or I3.  */
11518           if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3)))
11519             place = i3;
11520
11521           if (i2 && reg_mentioned_p (XEXP (note, 0), PATTERN (i2)))
11522             {
11523               if (place)
11524                 place2 = i2;
11525               else
11526                 place = i2;
11527             }
11528           break;
11529
11530         case REG_LABEL:
11531           /* This can show up in several ways -- either directly in the
11532              pattern, or hidden off in the constant pool with (or without?)
11533              a REG_EQUAL note.  */
11534           /* ??? Ignore the without-reg_equal-note problem for now.  */
11535           if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3))
11536               || ((tem = find_reg_note (i3, REG_EQUAL, NULL_RTX))
11537                   && GET_CODE (XEXP (tem, 0)) == LABEL_REF
11538                   && XEXP (XEXP (tem, 0), 0) == XEXP (note, 0)))
11539             place = i3;
11540
11541           if (i2
11542               && (reg_mentioned_p (XEXP (note, 0), PATTERN (i2))
11543                   || ((tem = find_reg_note (i2, REG_EQUAL, NULL_RTX))
11544                       && GET_CODE (XEXP (tem, 0)) == LABEL_REF
11545                       && XEXP (XEXP (tem, 0), 0) == XEXP (note, 0))))
11546             {
11547               if (place)
11548                 place2 = i2;
11549               else
11550                 place = i2;
11551             }
11552           break;
11553
11554         case REG_WAS_0:
11555           /* It is too much trouble to try to see if this note is still
11556              correct in all situations.  It is better to simply delete it.  */
11557           break;
11558
11559         case REG_RETVAL:
11560           /* If the insn previously containing this note still exists,
11561              put it back where it was.  Otherwise move it to the previous
11562              insn.  Adjust the corresponding REG_LIBCALL note.  */
11563           if (GET_CODE (from_insn) != NOTE)
11564             place = from_insn;
11565           else
11566             {
11567               tem = find_reg_note (XEXP (note, 0), REG_LIBCALL, NULL_RTX);
11568               place = prev_real_insn (from_insn);
11569               if (tem && place)
11570                 XEXP (tem, 0) = place;
11571             }
11572           break;
11573
11574         case REG_LIBCALL:
11575           /* This is handled similarly to REG_RETVAL.  */
11576           if (GET_CODE (from_insn) != NOTE)
11577             place = from_insn;
11578           else
11579             {
11580               tem = find_reg_note (XEXP (note, 0), REG_RETVAL, NULL_RTX);
11581               place = next_real_insn (from_insn);
11582               if (tem && place)
11583                 XEXP (tem, 0) = place;
11584             }
11585           break;
11586
11587         case REG_DEAD:
11588           /* If the register is used as an input in I3, it dies there.
11589              Similarly for I2, if it is non-zero and adjacent to I3.
11590
11591              If the register is not used as an input in either I3 or I2
11592              and it is not one of the registers we were supposed to eliminate,
11593              there are two possibilities.  We might have a non-adjacent I2
11594              or we might have somehow eliminated an additional register
11595              from a computation.  For example, we might have had A & B where
11596              we discover that B will always be zero.  In this case we will
11597              eliminate the reference to A.
11598
11599              In both cases, we must search to see if we can find a previous
11600              use of A and put the death note there.  */
11601
11602           if (from_insn
11603               && GET_CODE (from_insn) == CALL_INSN
11604               && find_reg_fusage (from_insn, USE, XEXP (note, 0)))
11605             place = from_insn;
11606           else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3)))
11607             place = i3;
11608           else if (i2 != 0 && next_nonnote_insn (i2) == i3
11609                    && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
11610             place = i2;
11611
11612           if (XEXP (note, 0) == elim_i2 || XEXP (note, 0) == elim_i1)
11613             break;
11614
11615           /* If the register is used in both I2 and I3 and it dies in I3,
11616              we might have added another reference to it.  If reg_n_refs
11617              was 2, bump it to 3.  This has to be correct since the
11618              register must have been set somewhere.  The reason this is
11619              done is because local-alloc.c treats 2 references as a
11620              special case.  */
11621
11622           if (place == i3 && i2 != 0 && GET_CODE (XEXP (note, 0)) == REG
11623               && REG_N_REFS (REGNO (XEXP (note, 0)))== 2
11624               && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
11625             REG_N_REFS (REGNO (XEXP (note, 0))) = 3;
11626
11627           if (place == 0)
11628             {
11629               for (tem = prev_nonnote_insn (i3);
11630                    place == 0 && tem
11631                    && (GET_CODE (tem) == INSN || GET_CODE (tem) == CALL_INSN);
11632                    tem = prev_nonnote_insn (tem))
11633                 {
11634                   /* If the register is being set at TEM, see if that is all
11635                      TEM is doing.  If so, delete TEM.  Otherwise, make this
11636                      into a REG_UNUSED note instead.  */
11637                   if (reg_set_p (XEXP (note, 0), PATTERN (tem)))
11638                     {
11639                       rtx set = single_set (tem);
11640                       rtx inner_dest = 0;
11641 #ifdef HAVE_cc0
11642                       rtx cc0_setter = NULL_RTX;
11643 #endif
11644
11645                       if (set != 0)
11646                         for (inner_dest = SET_DEST (set);
11647                              GET_CODE (inner_dest) == STRICT_LOW_PART
11648                              || GET_CODE (inner_dest) == SUBREG
11649                              || GET_CODE (inner_dest) == ZERO_EXTRACT;
11650                              inner_dest = XEXP (inner_dest, 0))
11651                           ;
11652
11653                       /* Verify that it was the set, and not a clobber that
11654                          modified the register.
11655
11656                          CC0 targets must be careful to maintain setter/user
11657                          pairs.  If we cannot delete the setter due to side
11658                          effects, mark the user with an UNUSED note instead
11659                          of deleting it.  */
11660
11661                       if (set != 0 && ! side_effects_p (SET_SRC (set))
11662                           && rtx_equal_p (XEXP (note, 0), inner_dest)
11663 #ifdef HAVE_cc0
11664                           && (! reg_mentioned_p (cc0_rtx, SET_SRC (set))
11665                               || ((cc0_setter = prev_cc0_setter (tem)) != NULL
11666                                   && sets_cc0_p (PATTERN (cc0_setter)) > 0))
11667 #endif
11668                           )
11669                         {
11670                           /* Move the notes and links of TEM elsewhere.
11671                              This might delete other dead insns recursively.
11672                              First set the pattern to something that won't use
11673                              any register.  */
11674
11675                           PATTERN (tem) = pc_rtx;
11676
11677                           distribute_notes (REG_NOTES (tem), tem, tem,
11678                                             NULL_RTX, NULL_RTX, NULL_RTX);
11679                           distribute_links (LOG_LINKS (tem));
11680
11681                           PUT_CODE (tem, NOTE);
11682                           NOTE_LINE_NUMBER (tem) = NOTE_INSN_DELETED;
11683                           NOTE_SOURCE_FILE (tem) = 0;
11684
11685 #ifdef HAVE_cc0
11686                           /* Delete the setter too.  */
11687                           if (cc0_setter)
11688                             {
11689                               PATTERN (cc0_setter) = pc_rtx;
11690
11691                               distribute_notes (REG_NOTES (cc0_setter),
11692                                                 cc0_setter, cc0_setter,
11693                                                 NULL_RTX, NULL_RTX, NULL_RTX);
11694                               distribute_links (LOG_LINKS (cc0_setter));
11695
11696                               PUT_CODE (cc0_setter, NOTE);
11697                               NOTE_LINE_NUMBER (cc0_setter) = NOTE_INSN_DELETED;
11698                               NOTE_SOURCE_FILE (cc0_setter) = 0;
11699                             }
11700 #endif
11701                         }
11702                       /* If the register is both set and used here, put the
11703                          REG_DEAD note here, but place a REG_UNUSED note
11704                          here too unless there already is one.  */
11705                       else if (reg_referenced_p (XEXP (note, 0),
11706                                                  PATTERN (tem)))
11707                         {
11708                           place = tem;
11709
11710                           if (! find_regno_note (tem, REG_UNUSED,
11711                                                  REGNO (XEXP (note, 0))))
11712                             REG_NOTES (tem)
11713                               = gen_rtx_EXPR_LIST (REG_UNUSED,
11714                                                    XEXP (note, 0),
11715                                                    REG_NOTES (tem));
11716                         }
11717                       else
11718                         {
11719                           PUT_REG_NOTE_KIND (note, REG_UNUSED);
11720
11721                           /*  If there isn't already a REG_UNUSED note, put one
11722                               here.  */
11723                           if (! find_regno_note (tem, REG_UNUSED,
11724                                                  REGNO (XEXP (note, 0))))
11725                             place = tem;
11726                           break;
11727                       }
11728                   }
11729                 else if (reg_referenced_p (XEXP (note, 0), PATTERN (tem))
11730                          || (GET_CODE (tem) == CALL_INSN
11731                              && find_reg_fusage (tem, USE, XEXP (note, 0))))
11732                   {
11733                     place = tem;
11734
11735                     /* If we are doing a 3->2 combination, and we have a
11736                        register which formerly died in i3 and was not used
11737                        by i2, which now no longer dies in i3 and is used in
11738                        i2 but does not die in i2, and place is between i2
11739                        and i3, then we may need to move a link from place to
11740                        i2.  */
11741                     if (i2 && INSN_UID (place) <= max_uid_cuid
11742                         && INSN_CUID (place) > INSN_CUID (i2)
11743                         && from_insn && INSN_CUID (from_insn) > INSN_CUID (i2)
11744                         && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
11745                       {
11746                         rtx links = LOG_LINKS (place);
11747                         LOG_LINKS (place) = 0;
11748                         distribute_links (links);
11749                       }
11750                     break;
11751                   }
11752                 }
11753
11754               /* If we haven't found an insn for the death note and it
11755                  is still a REG_DEAD note, but we have hit a CODE_LABEL,
11756                  insert a USE insn for the register at that label and
11757                  put the death node there.  This prevents problems with
11758                  call-state tracking in caller-save.c.  */
11759               if (REG_NOTE_KIND (note) == REG_DEAD && place == 0 && tem != 0)
11760                 {
11761                   place
11762                     = emit_insn_after (gen_rtx_USE (VOIDmode, XEXP (note, 0)),
11763                                        tem);
11764
11765                   /* If this insn was emitted between blocks, then update
11766                      BLOCK_HEAD of the current block to include it.  */
11767                   if (BLOCK_END (this_basic_block - 1) == tem)
11768                     BLOCK_HEAD (this_basic_block) = place;
11769                 }
11770             }
11771
11772           /* If the register is set or already dead at PLACE, we needn't do
11773              anything with this note if it is still a REG_DEAD note.
11774              We can here if it is set at all, not if is it totally replace,
11775              which is what `dead_or_set_p' checks, so also check for it being
11776              set partially.  */
11777
11778
11779           if (place && REG_NOTE_KIND (note) == REG_DEAD)
11780             {
11781               int regno = REGNO (XEXP (note, 0));
11782
11783               if (dead_or_set_p (place, XEXP (note, 0))
11784                   || reg_bitfield_target_p (XEXP (note, 0), PATTERN (place)))
11785                 {
11786                   /* Unless the register previously died in PLACE, clear
11787                      reg_last_death.  [I no longer understand why this is
11788                      being done.] */
11789                   if (reg_last_death[regno] != place)
11790                     reg_last_death[regno] = 0;
11791                   place = 0;
11792                 }
11793               else
11794                 reg_last_death[regno] = place;
11795
11796               /* If this is a death note for a hard reg that is occupying
11797                  multiple registers, ensure that we are still using all
11798                  parts of the object.  If we find a piece of the object
11799                  that is unused, we must add a USE for that piece before
11800                  PLACE and put the appropriate REG_DEAD note on it.
11801
11802                  An alternative would be to put a REG_UNUSED for the pieces
11803                  on the insn that set the register, but that can't be done if
11804                  it is not in the same block.  It is simpler, though less
11805                  efficient, to add the USE insns.  */
11806
11807               if (place && regno < FIRST_PSEUDO_REGISTER
11808                   && HARD_REGNO_NREGS (regno, GET_MODE (XEXP (note, 0))) > 1)
11809                 {
11810                   int endregno
11811                     = regno + HARD_REGNO_NREGS (regno,
11812                                                 GET_MODE (XEXP (note, 0)));
11813                   int all_used = 1;
11814                   int i;
11815
11816                   for (i = regno; i < endregno; i++)
11817                     if (! refers_to_regno_p (i, i + 1, PATTERN (place), 0)
11818                         && ! find_regno_fusage (place, USE, i))
11819                       {
11820                         rtx piece = gen_rtx_REG (reg_raw_mode[i], i);
11821                         rtx p;
11822
11823                         /* See if we already placed a USE note for this
11824                            register in front of PLACE.  */
11825                         for (p = place;
11826                              GET_CODE (PREV_INSN (p)) == INSN
11827                              && GET_CODE (PATTERN (PREV_INSN (p))) == USE;
11828                              p = PREV_INSN (p))
11829                           if (rtx_equal_p (piece,
11830                                            XEXP (PATTERN (PREV_INSN (p)), 0)))
11831                             {
11832                               p = 0;
11833                               break;
11834                             }
11835
11836                         if (p)
11837                           {
11838                             rtx use_insn
11839                               = emit_insn_before (gen_rtx_USE (VOIDmode,
11840                                                                piece),
11841                                                   p);
11842                             REG_NOTES (use_insn)
11843                               = gen_rtx_EXPR_LIST (REG_DEAD, piece,
11844                                                    REG_NOTES (use_insn));
11845                           }
11846
11847                         all_used = 0;
11848                       }
11849
11850                   /* Check for the case where the register dying partially
11851                      overlaps the register set by this insn.  */
11852                   if (all_used)
11853                     for (i = regno; i < endregno; i++)
11854                       if (dead_or_set_regno_p (place, i))
11855                           {
11856                             all_used = 0;
11857                             break;
11858                           }
11859
11860                   if (! all_used)
11861                     {
11862                       /* Put only REG_DEAD notes for pieces that are
11863                          still used and that are not already dead or set.  */
11864
11865                       for (i = regno; i < endregno; i++)
11866                         {
11867                           rtx piece = gen_rtx_REG (reg_raw_mode[i], i);
11868
11869                           if ((reg_referenced_p (piece, PATTERN (place))
11870                                || (GET_CODE (place) == CALL_INSN
11871                                    && find_reg_fusage (place, USE, piece)))
11872                               && ! dead_or_set_p (place, piece)
11873                               && ! reg_bitfield_target_p (piece,
11874                                                           PATTERN (place)))
11875                             REG_NOTES (place)
11876                               = gen_rtx_EXPR_LIST (REG_DEAD,
11877                                                    piece, REG_NOTES (place));
11878                         }
11879
11880                       place = 0;
11881                     }
11882                 }
11883             }
11884           break;
11885
11886         default:
11887           /* Any other notes should not be present at this point in the
11888              compilation.  */
11889           abort ();
11890         }
11891
11892       if (place)
11893         {
11894           XEXP (note, 1) = REG_NOTES (place);
11895           REG_NOTES (place) = note;
11896         }
11897       else if ((REG_NOTE_KIND (note) == REG_DEAD
11898                 || REG_NOTE_KIND (note) == REG_UNUSED)
11899                && GET_CODE (XEXP (note, 0)) == REG)
11900         REG_N_DEATHS (REGNO (XEXP (note, 0)))--;
11901
11902       if (place2)
11903         {
11904           if ((REG_NOTE_KIND (note) == REG_DEAD
11905                || REG_NOTE_KIND (note) == REG_UNUSED)
11906               && GET_CODE (XEXP (note, 0)) == REG)
11907             REG_N_DEATHS (REGNO (XEXP (note, 0)))++;
11908
11909           REG_NOTES (place2) = gen_rtx_fmt_ee (GET_CODE (note),
11910                                                REG_NOTE_KIND (note),
11911                                                XEXP (note, 0),
11912                                                REG_NOTES (place2));
11913         }
11914     }
11915 }
11916 \f
11917 /* Similarly to above, distribute the LOG_LINKS that used to be present on
11918    I3, I2, and I1 to new locations.  This is also called in one case to
11919    add a link pointing at I3 when I3's destination is changed.  */
11920
11921 static void
11922 distribute_links (links)
11923      rtx links;
11924 {
11925   rtx link, next_link;
11926
11927   for (link = links; link; link = next_link)
11928     {
11929       rtx place = 0;
11930       rtx insn;
11931       rtx set, reg;
11932
11933       next_link = XEXP (link, 1);
11934
11935       /* If the insn that this link points to is a NOTE or isn't a single
11936          set, ignore it.  In the latter case, it isn't clear what we
11937          can do other than ignore the link, since we can't tell which
11938          register it was for.  Such links wouldn't be used by combine
11939          anyway.
11940
11941          It is not possible for the destination of the target of the link to
11942          have been changed by combine.  The only potential of this is if we
11943          replace I3, I2, and I1 by I3 and I2.  But in that case the
11944          destination of I2 also remains unchanged.  */
11945
11946       if (GET_CODE (XEXP (link, 0)) == NOTE
11947           || (set = single_set (XEXP (link, 0))) == 0)
11948         continue;
11949
11950       reg = SET_DEST (set);
11951       while (GET_CODE (reg) == SUBREG || GET_CODE (reg) == ZERO_EXTRACT
11952              || GET_CODE (reg) == SIGN_EXTRACT
11953              || GET_CODE (reg) == STRICT_LOW_PART)
11954         reg = XEXP (reg, 0);
11955
11956       /* A LOG_LINK is defined as being placed on the first insn that uses
11957          a register and points to the insn that sets the register.  Start
11958          searching at the next insn after the target of the link and stop
11959          when we reach a set of the register or the end of the basic block.
11960
11961          Note that this correctly handles the link that used to point from
11962          I3 to I2.  Also note that not much searching is typically done here
11963          since most links don't point very far away.  */
11964
11965       for (insn = NEXT_INSN (XEXP (link, 0));
11966            (insn && (this_basic_block == n_basic_blocks - 1
11967                      || BLOCK_HEAD (this_basic_block + 1) != insn));
11968            insn = NEXT_INSN (insn))
11969         if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
11970             && reg_overlap_mentioned_p (reg, PATTERN (insn)))
11971           {
11972             if (reg_referenced_p (reg, PATTERN (insn)))
11973               place = insn;
11974             break;
11975           }
11976         else if (GET_CODE (insn) == CALL_INSN
11977               && find_reg_fusage (insn, USE, reg))
11978           {
11979             place = insn;
11980             break;
11981           }
11982
11983       /* If we found a place to put the link, place it there unless there
11984          is already a link to the same insn as LINK at that point.  */
11985
11986       if (place)
11987         {
11988           rtx link2;
11989
11990           for (link2 = LOG_LINKS (place); link2; link2 = XEXP (link2, 1))
11991             if (XEXP (link2, 0) == XEXP (link, 0))
11992               break;
11993
11994           if (link2 == 0)
11995             {
11996               XEXP (link, 1) = LOG_LINKS (place);
11997               LOG_LINKS (place) = link;
11998
11999               /* Set added_links_insn to the earliest insn we added a
12000                  link to.  */
12001               if (added_links_insn == 0
12002                   || INSN_CUID (added_links_insn) > INSN_CUID (place))
12003                 added_links_insn = place;
12004             }
12005         }
12006     }
12007 }
12008 \f
12009 /* Compute INSN_CUID for INSN, which is an insn made by combine.  */
12010
12011 static int
12012 insn_cuid (insn)
12013      rtx insn;
12014 {
12015   while (insn != 0 && INSN_UID (insn) > max_uid_cuid
12016          && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == USE)
12017     insn = NEXT_INSN (insn);
12018
12019   if (INSN_UID (insn) > max_uid_cuid)
12020     abort ();
12021
12022   return INSN_CUID (insn);
12023 }
12024 \f
12025 void
12026 dump_combine_stats (file)
12027      FILE *file;
12028 {
12029   fnotice
12030     (file,
12031      ";; Combiner statistics: %d attempts, %d substitutions (%d requiring new space),\n;; %d successes.\n\n",
12032      combine_attempts, combine_merges, combine_extras, combine_successes);
12033 }
12034
12035 void
12036 dump_combine_total_stats (file)
12037      FILE *file;
12038 {
12039   fnotice
12040     (file,
12041      "\n;; Combiner totals: %d attempts, %d substitutions (%d requiring new space),\n;; %d successes.\n",
12042      total_attempts, total_merges, total_extras, total_successes);
12043 }