OSDN Git Service

* fold-const.c (fold <EQ_EXPR>): Don't fold x == x only if x
[pf3gnuchains/gcc-fork.git] / gcc / combine.c
1 /* Optimize by combining instructions for GNU compiler.
2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 /* 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    - a LOG_LINKS entry that refers to an insn with multiple SETs may be
57      removed because there is no way to know which register it was
58      linking
59
60    To simplify substitution, we combine only when the earlier insn(s)
61    consist of only a single assignment.  To simplify updating afterward,
62    we never combine when a subroutine call appears in the middle.
63
64    Since we do not represent assignments to CC0 explicitly except when that
65    is all an insn does, there is no LOG_LINKS entry in an insn that uses
66    the condition code for the insn that set the condition code.
67    Fortunately, these two insns must be consecutive.
68    Therefore, every JUMP_INSN is taken to have an implicit logical link
69    to the preceding insn.  This is not quite right, since non-jumps can
70    also use the condition code; but in practice such insns would not
71    combine anyway.  */
72
73 #include "config.h"
74 #include "system.h"
75 #include "coretypes.h"
76 #include "tm.h"
77 #include "rtl.h"
78 #include "tm_p.h"
79 #include "flags.h"
80 #include "regs.h"
81 #include "hard-reg-set.h"
82 #include "basic-block.h"
83 #include "insn-config.h"
84 #include "function.h"
85 /* Include expr.h after insn-config.h so we get HAVE_conditional_move.  */
86 #include "expr.h"
87 #include "insn-attr.h"
88 #include "recog.h"
89 #include "real.h"
90 #include "toplev.h"
91
92 /* It is not safe to use ordinary gen_lowpart in combine.
93    Use gen_lowpart_for_combine instead.  See comments there.  */
94 #define gen_lowpart dont_use_gen_lowpart_you_dummy
95
96 /* Number of attempts to combine instructions in this function.  */
97
98 static int combine_attempts;
99
100 /* Number of attempts that got as far as substitution in this function.  */
101
102 static int combine_merges;
103
104 /* Number of instructions combined with added SETs in this function.  */
105
106 static int combine_extras;
107
108 /* Number of instructions combined in this function.  */
109
110 static int combine_successes;
111
112 /* Totals over entire compilation.  */
113
114 static int total_attempts, total_merges, total_extras, total_successes;
115
116 \f
117 /* Vector mapping INSN_UIDs to cuids.
118    The cuids are like uids but increase monotonically always.
119    Combine always uses cuids so that it can compare them.
120    But actually renumbering the uids, which we used to do,
121    proves to be a bad idea because it makes it hard to compare
122    the dumps produced by earlier passes with those from later passes.  */
123
124 static int *uid_cuid;
125 static int max_uid_cuid;
126
127 /* Get the cuid of an insn.  */
128
129 #define INSN_CUID(INSN) \
130 (INSN_UID (INSN) > max_uid_cuid ? insn_cuid (INSN) : uid_cuid[INSN_UID (INSN)])
131
132 /* In case BITS_PER_WORD == HOST_BITS_PER_WIDE_INT, shifting by
133    BITS_PER_WORD would invoke undefined behavior.  Work around it.  */
134
135 #define UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD(val) \
136   (((unsigned HOST_WIDE_INT) (val) << (BITS_PER_WORD - 1)) << 1)
137
138 #define nonzero_bits(X, M) \
139   cached_nonzero_bits (X, M, NULL_RTX, VOIDmode, 0)
140
141 #define num_sign_bit_copies(X, M) \
142   cached_num_sign_bit_copies (X, M, NULL_RTX, VOIDmode, 0)
143
144 /* Maximum register number, which is the size of the tables below.  */
145
146 static unsigned int combine_max_regno;
147
148 /* Record last point of death of (hard or pseudo) register n.  */
149
150 static rtx *reg_last_death;
151
152 /* Record last point of modification of (hard or pseudo) register n.  */
153
154 static rtx *reg_last_set;
155
156 /* Record the cuid of the last insn that invalidated memory
157    (anything that writes memory, and subroutine calls, but not pushes).  */
158
159 static int mem_last_set;
160
161 /* Record the cuid of the last CALL_INSN
162    so we can tell whether a potential combination crosses any calls.  */
163
164 static int last_call_cuid;
165
166 /* When `subst' is called, this is the insn that is being modified
167    (by combining in a previous insn).  The PATTERN of this insn
168    is still the old pattern partially modified and it should not be
169    looked at, but this may be used to examine the successors of the insn
170    to judge whether a simplification is valid.  */
171
172 static rtx subst_insn;
173
174 /* This is the lowest CUID that `subst' is currently dealing with.
175    get_last_value will not return a value if the register was set at or
176    after this CUID.  If not for this mechanism, we could get confused if
177    I2 or I1 in try_combine were an insn that used the old value of a register
178    to obtain a new value.  In that case, we might erroneously get the
179    new value of the register when we wanted the old one.  */
180
181 static int subst_low_cuid;
182
183 /* This contains any hard registers that are used in newpat; reg_dead_at_p
184    must consider all these registers to be always live.  */
185
186 static HARD_REG_SET newpat_used_regs;
187
188 /* This is an insn to which a LOG_LINKS entry has been added.  If this
189    insn is the earlier than I2 or I3, combine should rescan starting at
190    that location.  */
191
192 static rtx added_links_insn;
193
194 /* Basic block in which we are performing combines.  */
195 static basic_block this_basic_block;
196
197 /* A bitmap indicating which blocks had registers go dead at entry.
198    After combine, we'll need to re-do global life analysis with
199    those blocks as starting points.  */
200 static sbitmap refresh_blocks;
201 \f
202 /* The next group of arrays allows the recording of the last value assigned
203    to (hard or pseudo) register n.  We use this information to see if an
204    operation being processed is redundant given a prior operation performed
205    on the register.  For example, an `and' with a constant is redundant if
206    all the zero bits are already known to be turned off.
207
208    We use an approach similar to that used by cse, but change it in the
209    following ways:
210
211    (1) We do not want to reinitialize at each label.
212    (2) It is useful, but not critical, to know the actual value assigned
213        to a register.  Often just its form is helpful.
214
215    Therefore, we maintain the following arrays:
216
217    reg_last_set_value           the last value assigned
218    reg_last_set_label           records the value of label_tick when the
219                                 register was assigned
220    reg_last_set_table_tick      records the value of label_tick when a
221                                 value using the register is assigned
222    reg_last_set_invalid         set to nonzero when it is not valid
223                                 to use the value of this register in some
224                                 register's value
225
226    To understand the usage of these tables, it is important to understand
227    the distinction between the value in reg_last_set_value being valid
228    and the register being validly contained in some other expression in the
229    table.
230
231    Entry I in reg_last_set_value is valid if it is nonzero, and either
232    reg_n_sets[i] is 1 or reg_last_set_label[i] == label_tick.
233
234    Register I may validly appear in any expression returned for the value
235    of another register if reg_n_sets[i] is 1.  It may also appear in the
236    value for register J if reg_last_set_label[i] < reg_last_set_label[j] or
237    reg_last_set_invalid[j] is zero.
238
239    If an expression is found in the table containing a register which may
240    not validly appear in an expression, the register is replaced by
241    something that won't match, (clobber (const_int 0)).
242
243    reg_last_set_invalid[i] is set nonzero when register I is being assigned
244    to and reg_last_set_table_tick[i] == label_tick.  */
245
246 /* Record last value assigned to (hard or pseudo) register n.  */
247
248 static rtx *reg_last_set_value;
249
250 /* Record the value of label_tick when the value for register n is placed in
251    reg_last_set_value[n].  */
252
253 static int *reg_last_set_label;
254
255 /* Record the value of label_tick when an expression involving register n
256    is placed in reg_last_set_value.  */
257
258 static int *reg_last_set_table_tick;
259
260 /* Set nonzero if references to register n in expressions should not be
261    used.  */
262
263 static char *reg_last_set_invalid;
264
265 /* Incremented for each label.  */
266
267 static int label_tick;
268
269 /* Some registers that are set more than once and used in more than one
270    basic block are nevertheless always set in similar ways.  For example,
271    a QImode register may be loaded from memory in two places on a machine
272    where byte loads zero extend.
273
274    We record in the following array what we know about the nonzero
275    bits of a register, specifically which bits are known to be zero.
276
277    If an entry is zero, it means that we don't know anything special.  */
278
279 static unsigned HOST_WIDE_INT *reg_nonzero_bits;
280
281 /* Mode used to compute significance in reg_nonzero_bits.  It is the largest
282    integer mode that can fit in HOST_BITS_PER_WIDE_INT.  */
283
284 static enum machine_mode nonzero_bits_mode;
285
286 /* Nonzero if we know that a register has some leading bits that are always
287    equal to the sign bit.  */
288
289 static unsigned char *reg_sign_bit_copies;
290
291 /* Nonzero when reg_nonzero_bits and reg_sign_bit_copies can be safely used.
292    It is zero while computing them and after combine has completed.  This
293    former test prevents propagating values based on previously set values,
294    which can be incorrect if a variable is modified in a loop.  */
295
296 static int nonzero_sign_valid;
297
298 /* These arrays are maintained in parallel with reg_last_set_value
299    and are used to store the mode in which the register was last set,
300    the bits that were known to be zero when it was last set, and the
301    number of sign bits copies it was known to have when it was last set.  */
302
303 static enum machine_mode *reg_last_set_mode;
304 static unsigned HOST_WIDE_INT *reg_last_set_nonzero_bits;
305 static char *reg_last_set_sign_bit_copies;
306 \f
307 /* Record one modification to rtl structure
308    to be undone by storing old_contents into *where.
309    is_int is 1 if the contents are an int.  */
310
311 struct undo
312 {
313   struct undo *next;
314   int is_int;
315   union {rtx r; int i;} old_contents;
316   union {rtx *r; int *i;} where;
317 };
318
319 /* Record a bunch of changes to be undone, up to MAX_UNDO of them.
320    num_undo says how many are currently recorded.
321
322    other_insn is nonzero if we have modified some other insn in the process
323    of working on subst_insn.  It must be verified too.  */
324
325 struct undobuf
326 {
327   struct undo *undos;
328   struct undo *frees;
329   rtx other_insn;
330 };
331
332 static struct undobuf undobuf;
333
334 /* Number of times the pseudo being substituted for
335    was found and replaced.  */
336
337 static int n_occurrences;
338
339 static void do_SUBST (rtx *, rtx);
340 static void do_SUBST_INT (int *, int);
341 static void init_reg_last_arrays (void);
342 static void setup_incoming_promotions (void);
343 static void set_nonzero_bits_and_sign_copies (rtx, rtx, void *);
344 static int cant_combine_insn_p (rtx);
345 static int can_combine_p (rtx, rtx, rtx, rtx, rtx *, rtx *);
346 static int sets_function_arg_p (rtx);
347 static int combinable_i3pat (rtx, rtx *, rtx, rtx, int, rtx *);
348 static int contains_muldiv (rtx);
349 static rtx try_combine (rtx, rtx, rtx, int *);
350 static void undo_all (void);
351 static void undo_commit (void);
352 static rtx *find_split_point (rtx *, rtx);
353 static rtx subst (rtx, rtx, rtx, int, int);
354 static rtx combine_simplify_rtx (rtx, enum machine_mode, int, int);
355 static rtx simplify_if_then_else (rtx);
356 static rtx simplify_set (rtx);
357 static rtx simplify_logical (rtx, int);
358 static rtx expand_compound_operation (rtx);
359 static rtx expand_field_assignment (rtx);
360 static rtx make_extraction (enum machine_mode, rtx, HOST_WIDE_INT,
361                             rtx, unsigned HOST_WIDE_INT, int, int, int);
362 static rtx extract_left_shift (rtx, int);
363 static rtx make_compound_operation (rtx, enum rtx_code);
364 static int get_pos_from_mask (unsigned HOST_WIDE_INT,
365                               unsigned HOST_WIDE_INT *);
366 static rtx force_to_mode (rtx, enum machine_mode,
367                           unsigned HOST_WIDE_INT, rtx, int);
368 static rtx if_then_else_cond (rtx, rtx *, rtx *);
369 static rtx known_cond (rtx, enum rtx_code, rtx, rtx);
370 static int rtx_equal_for_field_assignment_p (rtx, rtx);
371 static rtx make_field_assignment (rtx);
372 static rtx apply_distributive_law (rtx);
373 static rtx simplify_and_const_int (rtx, enum machine_mode, rtx,
374                                    unsigned HOST_WIDE_INT);
375 static unsigned HOST_WIDE_INT cached_nonzero_bits (rtx, enum machine_mode,
376                                                    rtx, enum machine_mode,
377                                                    unsigned HOST_WIDE_INT);
378 static unsigned HOST_WIDE_INT nonzero_bits1 (rtx, enum machine_mode, rtx,
379                                              enum machine_mode,
380                                              unsigned HOST_WIDE_INT);
381 static unsigned int cached_num_sign_bit_copies (rtx, enum machine_mode, rtx,
382                                                 enum machine_mode,
383                                                 unsigned int);
384 static unsigned int num_sign_bit_copies1 (rtx, enum machine_mode, rtx,
385                                           enum machine_mode, unsigned int);
386 static int merge_outer_ops (enum rtx_code *, HOST_WIDE_INT *, enum rtx_code,
387                             HOST_WIDE_INT, enum machine_mode, int *);
388 static rtx simplify_shift_const (rtx, enum rtx_code, enum machine_mode, rtx,
389                                  int);
390 static int recog_for_combine (rtx *, rtx, rtx *);
391 static rtx gen_lowpart_for_combine (enum machine_mode, rtx);
392 static rtx gen_binary (enum rtx_code, enum machine_mode, rtx, rtx);
393 static enum rtx_code simplify_comparison (enum rtx_code, rtx *, rtx *);
394 static void update_table_tick (rtx);
395 static void record_value_for_reg (rtx, rtx, rtx);
396 static void check_promoted_subreg (rtx, rtx);
397 static void record_dead_and_set_regs_1 (rtx, rtx, void *);
398 static void record_dead_and_set_regs (rtx);
399 static int get_last_value_validate (rtx *, rtx, int, int);
400 static rtx get_last_value (rtx);
401 static int use_crosses_set_p (rtx, int);
402 static void reg_dead_at_p_1 (rtx, rtx, void *);
403 static int reg_dead_at_p (rtx, rtx);
404 static void move_deaths (rtx, rtx, int, rtx, rtx *);
405 static int reg_bitfield_target_p (rtx, rtx);
406 static void distribute_notes (rtx, rtx, rtx, rtx);
407 static void distribute_links (rtx);
408 static void mark_used_regs_combine (rtx);
409 static int insn_cuid (rtx);
410 static void record_promoted_value (rtx, rtx);
411 static rtx reversed_comparison (rtx, enum machine_mode, rtx, rtx);
412 static enum rtx_code combine_reversed_comparison_code (rtx);
413 \f
414 /* Substitute NEWVAL, an rtx expression, into INTO, a place in some
415    insn.  The substitution can be undone by undo_all.  If INTO is already
416    set to NEWVAL, do not record this change.  Because computing NEWVAL might
417    also call SUBST, we have to compute it before we put anything into
418    the undo table.  */
419
420 static void
421 do_SUBST (rtx *into, rtx newval)
422 {
423   struct undo *buf;
424   rtx oldval = *into;
425
426   if (oldval == newval)
427     return;
428
429   /* We'd like to catch as many invalid transformations here as
430      possible.  Unfortunately, there are way too many mode changes
431      that are perfectly valid, so we'd waste too much effort for
432      little gain doing the checks here.  Focus on catching invalid
433      transformations involving integer constants.  */
434   if (GET_MODE_CLASS (GET_MODE (oldval)) == MODE_INT
435       && GET_CODE (newval) == CONST_INT)
436     {
437       /* Sanity check that we're replacing oldval with a CONST_INT
438          that is a valid sign-extension for the original mode.  */
439       if (INTVAL (newval) != trunc_int_for_mode (INTVAL (newval),
440                                                  GET_MODE (oldval)))
441         abort ();
442
443       /* Replacing the operand of a SUBREG or a ZERO_EXTEND with a
444          CONST_INT is not valid, because after the replacement, the
445          original mode would be gone.  Unfortunately, we can't tell
446          when do_SUBST is called to replace the operand thereof, so we
447          perform this test on oldval instead, checking whether an
448          invalid replacement took place before we got here.  */
449       if ((GET_CODE (oldval) == SUBREG
450            && GET_CODE (SUBREG_REG (oldval)) == CONST_INT)
451           || (GET_CODE (oldval) == ZERO_EXTEND
452               && GET_CODE (XEXP (oldval, 0)) == CONST_INT))
453         abort ();
454     }
455
456   if (undobuf.frees)
457     buf = undobuf.frees, undobuf.frees = buf->next;
458   else
459     buf = (struct undo *) xmalloc (sizeof (struct undo));
460
461   buf->is_int = 0;
462   buf->where.r = into;
463   buf->old_contents.r = oldval;
464   *into = newval;
465
466   buf->next = undobuf.undos, undobuf.undos = buf;
467 }
468
469 #define SUBST(INTO, NEWVAL)     do_SUBST(&(INTO), (NEWVAL))
470
471 /* Similar to SUBST, but NEWVAL is an int expression.  Note that substitution
472    for the value of a HOST_WIDE_INT value (including CONST_INT) is
473    not safe.  */
474
475 static void
476 do_SUBST_INT (int *into, int newval)
477 {
478   struct undo *buf;
479   int oldval = *into;
480
481   if (oldval == newval)
482     return;
483
484   if (undobuf.frees)
485     buf = undobuf.frees, undobuf.frees = buf->next;
486   else
487     buf = (struct undo *) xmalloc (sizeof (struct undo));
488
489   buf->is_int = 1;
490   buf->where.i = into;
491   buf->old_contents.i = oldval;
492   *into = newval;
493
494   buf->next = undobuf.undos, undobuf.undos = buf;
495 }
496
497 #define SUBST_INT(INTO, NEWVAL)  do_SUBST_INT(&(INTO), (NEWVAL))
498 \f
499 /* Main entry point for combiner.  F is the first insn of the function.
500    NREGS is the first unused pseudo-reg number.
501
502    Return nonzero if the combiner has turned an indirect jump
503    instruction into a direct jump.  */
504 int
505 combine_instructions (rtx f, unsigned int nregs)
506 {
507   rtx insn, next;
508 #ifdef HAVE_cc0
509   rtx prev;
510 #endif
511   int i;
512   rtx links, nextlinks;
513
514   int new_direct_jump_p = 0;
515
516   combine_attempts = 0;
517   combine_merges = 0;
518   combine_extras = 0;
519   combine_successes = 0;
520
521   combine_max_regno = nregs;
522
523   reg_nonzero_bits = ((unsigned HOST_WIDE_INT *)
524                       xcalloc (nregs, sizeof (unsigned HOST_WIDE_INT)));
525   reg_sign_bit_copies
526     = (unsigned char *) xcalloc (nregs, sizeof (unsigned char));
527
528   reg_last_death = (rtx *) xmalloc (nregs * sizeof (rtx));
529   reg_last_set = (rtx *) xmalloc (nregs * sizeof (rtx));
530   reg_last_set_value = (rtx *) xmalloc (nregs * sizeof (rtx));
531   reg_last_set_table_tick = (int *) xmalloc (nregs * sizeof (int));
532   reg_last_set_label = (int *) xmalloc (nregs * sizeof (int));
533   reg_last_set_invalid = (char *) xmalloc (nregs * sizeof (char));
534   reg_last_set_mode
535     = (enum machine_mode *) xmalloc (nregs * sizeof (enum machine_mode));
536   reg_last_set_nonzero_bits
537     = (unsigned HOST_WIDE_INT *) xmalloc (nregs * sizeof (HOST_WIDE_INT));
538   reg_last_set_sign_bit_copies
539     = (char *) xmalloc (nregs * sizeof (char));
540
541   init_reg_last_arrays ();
542
543   init_recog_no_volatile ();
544
545   /* Compute maximum uid value so uid_cuid can be allocated.  */
546
547   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
548     if (INSN_UID (insn) > i)
549       i = INSN_UID (insn);
550
551   uid_cuid = (int *) xmalloc ((i + 1) * sizeof (int));
552   max_uid_cuid = i;
553
554   nonzero_bits_mode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
555
556   /* Don't use reg_nonzero_bits when computing it.  This can cause problems
557      when, for example, we have j <<= 1 in a loop.  */
558
559   nonzero_sign_valid = 0;
560
561   /* Compute the mapping from uids to cuids.
562      Cuids are numbers assigned to insns, like uids,
563      except that cuids increase monotonically through the code.
564
565      Scan all SETs and see if we can deduce anything about what
566      bits are known to be zero for some registers and how many copies
567      of the sign bit are known to exist for those registers.
568
569      Also set any known values so that we can use it while searching
570      for what bits are known to be set.  */
571
572   label_tick = 1;
573
574   setup_incoming_promotions ();
575
576   refresh_blocks = sbitmap_alloc (last_basic_block);
577   sbitmap_zero (refresh_blocks);
578
579   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
580     {
581       uid_cuid[INSN_UID (insn)] = ++i;
582       subst_low_cuid = i;
583       subst_insn = insn;
584
585       if (INSN_P (insn))
586         {
587           note_stores (PATTERN (insn), set_nonzero_bits_and_sign_copies,
588                        NULL);
589           record_dead_and_set_regs (insn);
590
591 #ifdef AUTO_INC_DEC
592           for (links = REG_NOTES (insn); links; links = XEXP (links, 1))
593             if (REG_NOTE_KIND (links) == REG_INC)
594               set_nonzero_bits_and_sign_copies (XEXP (links, 0), NULL_RTX,
595                                                 NULL);
596 #endif
597         }
598
599       if (GET_CODE (insn) == CODE_LABEL)
600         label_tick++;
601     }
602
603   nonzero_sign_valid = 1;
604
605   /* Now scan all the insns in forward order.  */
606
607   label_tick = 1;
608   last_call_cuid = 0;
609   mem_last_set = 0;
610   init_reg_last_arrays ();
611   setup_incoming_promotions ();
612
613   FOR_EACH_BB (this_basic_block)
614     {
615       for (insn = this_basic_block->head;
616            insn != NEXT_INSN (this_basic_block->end);
617            insn = next ? next : NEXT_INSN (insn))
618         {
619           next = 0;
620
621           if (GET_CODE (insn) == CODE_LABEL)
622             label_tick++;
623
624           else if (INSN_P (insn))
625             {
626               /* See if we know about function return values before this
627                  insn based upon SUBREG flags.  */
628               check_promoted_subreg (insn, PATTERN (insn));
629
630               /* Try this insn with each insn it links back to.  */
631
632               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
633                 if ((next = try_combine (insn, XEXP (links, 0),
634                                          NULL_RTX, &new_direct_jump_p)) != 0)
635                   goto retry;
636
637               /* Try each sequence of three linked insns ending with this one.  */
638
639               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
640                 {
641                   rtx link = XEXP (links, 0);
642
643                   /* If the linked insn has been replaced by a note, then there
644                      is no point in pursuing this chain any further.  */
645                   if (GET_CODE (link) == NOTE)
646                     continue;
647
648                   for (nextlinks = LOG_LINKS (link);
649                        nextlinks;
650                        nextlinks = XEXP (nextlinks, 1))
651                     if ((next = try_combine (insn, link,
652                                              XEXP (nextlinks, 0),
653                                              &new_direct_jump_p)) != 0)
654                       goto retry;
655                 }
656
657 #ifdef HAVE_cc0
658               /* Try to combine a jump insn that uses CC0
659                  with a preceding insn that sets CC0, and maybe with its
660                  logical predecessor as well.
661                  This is how we make decrement-and-branch insns.
662                  We need this special code because data flow connections
663                  via CC0 do not get entered in LOG_LINKS.  */
664
665               if (GET_CODE (insn) == JUMP_INSN
666                   && (prev = prev_nonnote_insn (insn)) != 0
667                   && GET_CODE (prev) == INSN
668                   && sets_cc0_p (PATTERN (prev)))
669                 {
670                   if ((next = try_combine (insn, prev,
671                                            NULL_RTX, &new_direct_jump_p)) != 0)
672                     goto retry;
673
674                   for (nextlinks = LOG_LINKS (prev); nextlinks;
675                        nextlinks = XEXP (nextlinks, 1))
676                     if ((next = try_combine (insn, prev,
677                                              XEXP (nextlinks, 0),
678                                              &new_direct_jump_p)) != 0)
679                       goto retry;
680                 }
681
682               /* Do the same for an insn that explicitly references CC0.  */
683               if (GET_CODE (insn) == INSN
684                   && (prev = prev_nonnote_insn (insn)) != 0
685                   && GET_CODE (prev) == INSN
686                   && sets_cc0_p (PATTERN (prev))
687                   && GET_CODE (PATTERN (insn)) == SET
688                   && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (insn))))
689                 {
690                   if ((next = try_combine (insn, prev,
691                                            NULL_RTX, &new_direct_jump_p)) != 0)
692                     goto retry;
693
694                   for (nextlinks = LOG_LINKS (prev); nextlinks;
695                        nextlinks = XEXP (nextlinks, 1))
696                     if ((next = try_combine (insn, prev,
697                                              XEXP (nextlinks, 0),
698                                              &new_direct_jump_p)) != 0)
699                       goto retry;
700                 }
701
702               /* Finally, see if any of the insns that this insn links to
703                  explicitly references CC0.  If so, try this insn, that insn,
704                  and its predecessor if it sets CC0.  */
705               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
706                 if (GET_CODE (XEXP (links, 0)) == INSN
707                     && GET_CODE (PATTERN (XEXP (links, 0))) == SET
708                     && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (XEXP (links, 0))))
709                     && (prev = prev_nonnote_insn (XEXP (links, 0))) != 0
710                     && GET_CODE (prev) == INSN
711                     && sets_cc0_p (PATTERN (prev))
712                     && (next = try_combine (insn, XEXP (links, 0),
713                                             prev, &new_direct_jump_p)) != 0)
714                   goto retry;
715 #endif
716
717               /* Try combining an insn with two different insns whose results it
718                  uses.  */
719               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
720                 for (nextlinks = XEXP (links, 1); nextlinks;
721                      nextlinks = XEXP (nextlinks, 1))
722                   if ((next = try_combine (insn, XEXP (links, 0),
723                                            XEXP (nextlinks, 0),
724                                            &new_direct_jump_p)) != 0)
725                     goto retry;
726
727               if (GET_CODE (insn) != NOTE)
728                 record_dead_and_set_regs (insn);
729
730             retry:
731               ;
732             }
733         }
734     }
735   clear_bb_flags ();
736
737   EXECUTE_IF_SET_IN_SBITMAP (refresh_blocks, 0, i,
738                              BASIC_BLOCK (i)->flags |= BB_DIRTY);
739   new_direct_jump_p |= purge_all_dead_edges (0);
740   delete_noop_moves (f);
741
742   update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
743                                     PROP_DEATH_NOTES | PROP_SCAN_DEAD_CODE
744                                     | PROP_KILL_DEAD_CODE);
745
746   /* Clean up.  */
747   sbitmap_free (refresh_blocks);
748   free (reg_nonzero_bits);
749   free (reg_sign_bit_copies);
750   free (reg_last_death);
751   free (reg_last_set);
752   free (reg_last_set_value);
753   free (reg_last_set_table_tick);
754   free (reg_last_set_label);
755   free (reg_last_set_invalid);
756   free (reg_last_set_mode);
757   free (reg_last_set_nonzero_bits);
758   free (reg_last_set_sign_bit_copies);
759   free (uid_cuid);
760
761   {
762     struct undo *undo, *next;
763     for (undo = undobuf.frees; undo; undo = next)
764       {
765         next = undo->next;
766         free (undo);
767       }
768     undobuf.frees = 0;
769   }
770
771   total_attempts += combine_attempts;
772   total_merges += combine_merges;
773   total_extras += combine_extras;
774   total_successes += combine_successes;
775
776   nonzero_sign_valid = 0;
777
778   /* Make recognizer allow volatile MEMs again.  */
779   init_recog ();
780
781   return new_direct_jump_p;
782 }
783
784 /* Wipe the reg_last_xxx arrays in preparation for another pass.  */
785
786 static void
787 init_reg_last_arrays (void)
788 {
789   unsigned int nregs = combine_max_regno;
790
791   memset ((char *) reg_last_death, 0, nregs * sizeof (rtx));
792   memset ((char *) reg_last_set, 0, nregs * sizeof (rtx));
793   memset ((char *) reg_last_set_value, 0, nregs * sizeof (rtx));
794   memset ((char *) reg_last_set_table_tick, 0, nregs * sizeof (int));
795   memset ((char *) reg_last_set_label, 0, nregs * sizeof (int));
796   memset (reg_last_set_invalid, 0, nregs * sizeof (char));
797   memset ((char *) reg_last_set_mode, 0, nregs * sizeof (enum machine_mode));
798   memset ((char *) reg_last_set_nonzero_bits, 0, nregs * sizeof (HOST_WIDE_INT));
799   memset (reg_last_set_sign_bit_copies, 0, nregs * sizeof (char));
800 }
801 \f
802 /* Set up any promoted values for incoming argument registers.  */
803
804 static void
805 setup_incoming_promotions (void)
806 {
807 #ifdef PROMOTE_FUNCTION_ARGS
808   unsigned int regno;
809   rtx reg;
810   enum machine_mode mode;
811   int unsignedp;
812   rtx first = get_insns ();
813
814 #ifndef OUTGOING_REGNO
815 #define OUTGOING_REGNO(N) N
816 #endif
817   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
818     /* Check whether this register can hold an incoming pointer
819        argument.  FUNCTION_ARG_REGNO_P tests outgoing register
820        numbers, so translate if necessary due to register windows.  */
821     if (FUNCTION_ARG_REGNO_P (OUTGOING_REGNO (regno))
822         && (reg = promoted_input_arg (regno, &mode, &unsignedp)) != 0)
823       {
824         record_value_for_reg
825           (reg, first, gen_rtx_fmt_e ((unsignedp ? ZERO_EXTEND
826                                        : SIGN_EXTEND),
827                                       GET_MODE (reg),
828                                       gen_rtx_CLOBBER (mode, const0_rtx)));
829       }
830 #endif
831 }
832 \f
833 /* Called via note_stores.  If X is a pseudo that is narrower than
834    HOST_BITS_PER_WIDE_INT and is being set, record what bits are known zero.
835
836    If we are setting only a portion of X and we can't figure out what
837    portion, assume all bits will be used since we don't know what will
838    be happening.
839
840    Similarly, set how many bits of X are known to be copies of the sign bit
841    at all locations in the function.  This is the smallest number implied
842    by any set of X.  */
843
844 static void
845 set_nonzero_bits_and_sign_copies (rtx x, rtx set,
846                                   void *data ATTRIBUTE_UNUSED)
847 {
848   unsigned int num;
849
850   if (GET_CODE (x) == REG
851       && REGNO (x) >= FIRST_PSEUDO_REGISTER
852       /* If this register is undefined at the start of the file, we can't
853          say what its contents were.  */
854       && ! REGNO_REG_SET_P (ENTRY_BLOCK_PTR->next_bb->global_live_at_start, REGNO (x))
855       && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
856     {
857       if (set == 0 || GET_CODE (set) == CLOBBER)
858         {
859           reg_nonzero_bits[REGNO (x)] = GET_MODE_MASK (GET_MODE (x));
860           reg_sign_bit_copies[REGNO (x)] = 1;
861           return;
862         }
863
864       /* If this is a complex assignment, see if we can convert it into a
865          simple assignment.  */
866       set = expand_field_assignment (set);
867
868       /* If this is a simple assignment, or we have a paradoxical SUBREG,
869          set what we know about X.  */
870
871       if (SET_DEST (set) == x
872           || (GET_CODE (SET_DEST (set)) == SUBREG
873               && (GET_MODE_SIZE (GET_MODE (SET_DEST (set)))
874                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (set)))))
875               && SUBREG_REG (SET_DEST (set)) == x))
876         {
877           rtx src = SET_SRC (set);
878
879 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
880           /* If X is narrower than a word and SRC is a non-negative
881              constant that would appear negative in the mode of X,
882              sign-extend it for use in reg_nonzero_bits because some
883              machines (maybe most) will actually do the sign-extension
884              and this is the conservative approach.
885
886              ??? For 2.5, try to tighten up the MD files in this regard
887              instead of this kludge.  */
888
889           if (GET_MODE_BITSIZE (GET_MODE (x)) < BITS_PER_WORD
890               && GET_CODE (src) == CONST_INT
891               && INTVAL (src) > 0
892               && 0 != (INTVAL (src)
893                        & ((HOST_WIDE_INT) 1
894                           << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
895             src = GEN_INT (INTVAL (src)
896                            | ((HOST_WIDE_INT) (-1)
897                               << GET_MODE_BITSIZE (GET_MODE (x))));
898 #endif
899
900           /* Don't call nonzero_bits if it cannot change anything.  */
901           if (reg_nonzero_bits[REGNO (x)] != ~(unsigned HOST_WIDE_INT) 0)
902             reg_nonzero_bits[REGNO (x)]
903               |= nonzero_bits (src, nonzero_bits_mode);
904           num = num_sign_bit_copies (SET_SRC (set), GET_MODE (x));
905           if (reg_sign_bit_copies[REGNO (x)] == 0
906               || reg_sign_bit_copies[REGNO (x)] > num)
907             reg_sign_bit_copies[REGNO (x)] = num;
908         }
909       else
910         {
911           reg_nonzero_bits[REGNO (x)] = GET_MODE_MASK (GET_MODE (x));
912           reg_sign_bit_copies[REGNO (x)] = 1;
913         }
914     }
915 }
916 \f
917 /* See if INSN can be combined into I3.  PRED and SUCC are optionally
918    insns that were previously combined into I3 or that will be combined
919    into the merger of INSN and I3.
920
921    Return 0 if the combination is not allowed for any reason.
922
923    If the combination is allowed, *PDEST will be set to the single
924    destination of INSN and *PSRC to the single source, and this function
925    will return 1.  */
926
927 static int
928 can_combine_p (rtx insn, rtx i3, rtx pred ATTRIBUTE_UNUSED, rtx succ,
929                rtx *pdest, rtx *psrc)
930 {
931   int i;
932   rtx set = 0, src, dest;
933   rtx p;
934 #ifdef AUTO_INC_DEC
935   rtx link;
936 #endif
937   int all_adjacent = (succ ? (next_active_insn (insn) == succ
938                               && next_active_insn (succ) == i3)
939                       : next_active_insn (insn) == i3);
940
941   /* Can combine only if previous insn is a SET of a REG, a SUBREG or CC0.
942      or a PARALLEL consisting of such a SET and CLOBBERs.
943
944      If INSN has CLOBBER parallel parts, ignore them for our processing.
945      By definition, these happen during the execution of the insn.  When it
946      is merged with another insn, all bets are off.  If they are, in fact,
947      needed and aren't also supplied in I3, they may be added by
948      recog_for_combine.  Otherwise, it won't match.
949
950      We can also ignore a SET whose SET_DEST is mentioned in a REG_UNUSED
951      note.
952
953      Get the source and destination of INSN.  If more than one, can't
954      combine.  */
955
956   if (GET_CODE (PATTERN (insn)) == SET)
957     set = PATTERN (insn);
958   else if (GET_CODE (PATTERN (insn)) == PARALLEL
959            && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
960     {
961       for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
962         {
963           rtx elt = XVECEXP (PATTERN (insn), 0, i);
964
965           switch (GET_CODE (elt))
966             {
967             /* This is important to combine floating point insns
968                for the SH4 port.  */
969             case USE:
970               /* Combining an isolated USE doesn't make sense.
971                  We depend here on combinable_i3pat to reject them.  */
972               /* The code below this loop only verifies that the inputs of
973                  the SET in INSN do not change.  We call reg_set_between_p
974                  to verify that the REG in the USE does not change between
975                  I3 and INSN.
976                  If the USE in INSN was for a pseudo register, the matching
977                  insn pattern will likely match any register; combining this
978                  with any other USE would only be safe if we knew that the
979                  used registers have identical values, or if there was
980                  something to tell them apart, e.g. different modes.  For
981                  now, we forgo such complicated tests and simply disallow
982                  combining of USES of pseudo registers with any other USE.  */
983               if (GET_CODE (XEXP (elt, 0)) == REG
984                   && GET_CODE (PATTERN (i3)) == PARALLEL)
985                 {
986                   rtx i3pat = PATTERN (i3);
987                   int i = XVECLEN (i3pat, 0) - 1;
988                   unsigned int regno = REGNO (XEXP (elt, 0));
989
990                   do
991                     {
992                       rtx i3elt = XVECEXP (i3pat, 0, i);
993
994                       if (GET_CODE (i3elt) == USE
995                           && GET_CODE (XEXP (i3elt, 0)) == REG
996                           && (REGNO (XEXP (i3elt, 0)) == regno
997                               ? reg_set_between_p (XEXP (elt, 0),
998                                                    PREV_INSN (insn), i3)
999                               : regno >= FIRST_PSEUDO_REGISTER))
1000                         return 0;
1001                     }
1002                   while (--i >= 0);
1003                 }
1004               break;
1005
1006               /* We can ignore CLOBBERs.  */
1007             case CLOBBER:
1008               break;
1009
1010             case SET:
1011               /* Ignore SETs whose result isn't used but not those that
1012                  have side-effects.  */
1013               if (find_reg_note (insn, REG_UNUSED, SET_DEST (elt))
1014                   && ! side_effects_p (elt))
1015                 break;
1016
1017               /* If we have already found a SET, this is a second one and
1018                  so we cannot combine with this insn.  */
1019               if (set)
1020                 return 0;
1021
1022               set = elt;
1023               break;
1024
1025             default:
1026               /* Anything else means we can't combine.  */
1027               return 0;
1028             }
1029         }
1030
1031       if (set == 0
1032           /* If SET_SRC is an ASM_OPERANDS we can't throw away these CLOBBERs,
1033              so don't do anything with it.  */
1034           || GET_CODE (SET_SRC (set)) == ASM_OPERANDS)
1035         return 0;
1036     }
1037   else
1038     return 0;
1039
1040   if (set == 0)
1041     return 0;
1042
1043   set = expand_field_assignment (set);
1044   src = SET_SRC (set), dest = SET_DEST (set);
1045
1046   /* Don't eliminate a store in the stack pointer.  */
1047   if (dest == stack_pointer_rtx
1048       /* Don't combine with an insn that sets a register to itself if it has
1049          a REG_EQUAL note.  This may be part of a REG_NO_CONFLICT sequence.  */
1050       || (rtx_equal_p (src, dest) && find_reg_note (insn, REG_EQUAL, NULL_RTX))
1051       /* Can't merge an ASM_OPERANDS.  */
1052       || GET_CODE (src) == ASM_OPERANDS
1053       /* Can't merge a function call.  */
1054       || GET_CODE (src) == CALL
1055       /* Don't eliminate a function call argument.  */
1056       || (GET_CODE (i3) == CALL_INSN
1057           && (find_reg_fusage (i3, USE, dest)
1058               || (GET_CODE (dest) == REG
1059                   && REGNO (dest) < FIRST_PSEUDO_REGISTER
1060                   && global_regs[REGNO (dest)])))
1061       /* Don't substitute into an incremented register.  */
1062       || FIND_REG_INC_NOTE (i3, dest)
1063       || (succ && FIND_REG_INC_NOTE (succ, dest))
1064 #if 0
1065       /* Don't combine the end of a libcall into anything.  */
1066       /* ??? This gives worse code, and appears to be unnecessary, since no
1067          pass after flow uses REG_LIBCALL/REG_RETVAL notes.  Local-alloc does
1068          use REG_RETVAL notes for noconflict blocks, but other code here
1069          makes sure that those insns don't disappear.  */
1070       || find_reg_note (insn, REG_RETVAL, NULL_RTX)
1071 #endif
1072       /* Make sure that DEST is not used after SUCC but before I3.  */
1073       || (succ && ! all_adjacent
1074           && reg_used_between_p (dest, succ, i3))
1075       /* Make sure that the value that is to be substituted for the register
1076          does not use any registers whose values alter in between.  However,
1077          If the insns are adjacent, a use can't cross a set even though we
1078          think it might (this can happen for a sequence of insns each setting
1079          the same destination; reg_last_set of that register might point to
1080          a NOTE).  If INSN has a REG_EQUIV note, the register is always
1081          equivalent to the memory so the substitution is valid even if there
1082          are intervening stores.  Also, don't move a volatile asm or
1083          UNSPEC_VOLATILE across any other insns.  */
1084       || (! all_adjacent
1085           && (((GET_CODE (src) != MEM
1086                 || ! find_reg_note (insn, REG_EQUIV, src))
1087                && use_crosses_set_p (src, INSN_CUID (insn)))
1088               || (GET_CODE (src) == ASM_OPERANDS && MEM_VOLATILE_P (src))
1089               || GET_CODE (src) == UNSPEC_VOLATILE))
1090       /* If there is a REG_NO_CONFLICT note for DEST in I3 or SUCC, we get
1091          better register allocation by not doing the combine.  */
1092       || find_reg_note (i3, REG_NO_CONFLICT, dest)
1093       || (succ && find_reg_note (succ, REG_NO_CONFLICT, dest))
1094       /* Don't combine across a CALL_INSN, because that would possibly
1095          change whether the life span of some REGs crosses calls or not,
1096          and it is a pain to update that information.
1097          Exception: if source is a constant, moving it later can't hurt.
1098          Accept that special case, because it helps -fforce-addr a lot.  */
1099       || (INSN_CUID (insn) < last_call_cuid && ! CONSTANT_P (src)))
1100     return 0;
1101
1102   /* DEST must either be a REG or CC0.  */
1103   if (GET_CODE (dest) == REG)
1104     {
1105       /* If register alignment is being enforced for multi-word items in all
1106          cases except for parameters, it is possible to have a register copy
1107          insn referencing a hard register that is not allowed to contain the
1108          mode being copied and which would not be valid as an operand of most
1109          insns.  Eliminate this problem by not combining with such an insn.
1110
1111          Also, on some machines we don't want to extend the life of a hard
1112          register.  */
1113
1114       if (GET_CODE (src) == REG
1115           && ((REGNO (dest) < FIRST_PSEUDO_REGISTER
1116                && ! HARD_REGNO_MODE_OK (REGNO (dest), GET_MODE (dest)))
1117               /* Don't extend the life of a hard register unless it is
1118                  user variable (if we have few registers) or it can't
1119                  fit into the desired register (meaning something special
1120                  is going on).
1121                  Also avoid substituting a return register into I3, because
1122                  reload can't handle a conflict with constraints of other
1123                  inputs.  */
1124               || (REGNO (src) < FIRST_PSEUDO_REGISTER
1125                   && ! HARD_REGNO_MODE_OK (REGNO (src), GET_MODE (src)))))
1126         return 0;
1127     }
1128   else if (GET_CODE (dest) != CC0)
1129     return 0;
1130
1131   /* Don't substitute for a register intended as a clobberable operand.
1132      Similarly, don't substitute an expression containing a register that
1133      will be clobbered in I3.  */
1134   if (GET_CODE (PATTERN (i3)) == PARALLEL)
1135     for (i = XVECLEN (PATTERN (i3), 0) - 1; i >= 0; i--)
1136       if (GET_CODE (XVECEXP (PATTERN (i3), 0, i)) == CLOBBER
1137           && (reg_overlap_mentioned_p (XEXP (XVECEXP (PATTERN (i3), 0, i), 0),
1138                                        src)
1139               || rtx_equal_p (XEXP (XVECEXP (PATTERN (i3), 0, i), 0), dest)))
1140         return 0;
1141
1142   /* If INSN contains anything volatile, or is an `asm' (whether volatile
1143      or not), reject, unless nothing volatile comes between it and I3 */
1144
1145   if (GET_CODE (src) == ASM_OPERANDS || volatile_refs_p (src))
1146     {
1147       /* Make sure succ doesn't contain a volatile reference.  */
1148       if (succ != 0 && volatile_refs_p (PATTERN (succ)))
1149         return 0;
1150
1151       for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p))
1152         if (INSN_P (p) && p != succ && volatile_refs_p (PATTERN (p)))
1153           return 0;
1154     }
1155
1156   /* If INSN is an asm, and DEST is a hard register, reject, since it has
1157      to be an explicit register variable, and was chosen for a reason.  */
1158
1159   if (GET_CODE (src) == ASM_OPERANDS
1160       && GET_CODE (dest) == REG && REGNO (dest) < FIRST_PSEUDO_REGISTER)
1161     return 0;
1162
1163   /* If there are any volatile insns between INSN and I3, reject, because
1164      they might affect machine state.  */
1165
1166   for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p))
1167     if (INSN_P (p) && p != succ && volatile_insn_p (PATTERN (p)))
1168       return 0;
1169
1170   /* If INSN or I2 contains an autoincrement or autodecrement,
1171      make sure that register is not used between there and I3,
1172      and not already used in I3 either.
1173      Also insist that I3 not be a jump; if it were one
1174      and the incremented register were spilled, we would lose.  */
1175
1176 #ifdef AUTO_INC_DEC
1177   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1178     if (REG_NOTE_KIND (link) == REG_INC
1179         && (GET_CODE (i3) == JUMP_INSN
1180             || reg_used_between_p (XEXP (link, 0), insn, i3)
1181             || reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i3))))
1182       return 0;
1183 #endif
1184
1185 #ifdef HAVE_cc0
1186   /* Don't combine an insn that follows a CC0-setting insn.
1187      An insn that uses CC0 must not be separated from the one that sets it.
1188      We do, however, allow I2 to follow a CC0-setting insn if that insn
1189      is passed as I1; in that case it will be deleted also.
1190      We also allow combining in this case if all the insns are adjacent
1191      because that would leave the two CC0 insns adjacent as well.
1192      It would be more logical to test whether CC0 occurs inside I1 or I2,
1193      but that would be much slower, and this ought to be equivalent.  */
1194
1195   p = prev_nonnote_insn (insn);
1196   if (p && p != pred && GET_CODE (p) == INSN && sets_cc0_p (PATTERN (p))
1197       && ! all_adjacent)
1198     return 0;
1199 #endif
1200
1201   /* If we get here, we have passed all the tests and the combination is
1202      to be allowed.  */
1203
1204   *pdest = dest;
1205   *psrc = src;
1206
1207   return 1;
1208 }
1209 \f
1210 /* Check if PAT is an insn - or a part of it - used to set up an
1211    argument for a function in a hard register.  */
1212
1213 static int
1214 sets_function_arg_p (rtx pat)
1215 {
1216   int i;
1217   rtx inner_dest;
1218
1219   switch (GET_CODE (pat))
1220     {
1221     case INSN:
1222       return sets_function_arg_p (PATTERN (pat));
1223
1224     case PARALLEL:
1225       for (i = XVECLEN (pat, 0); --i >= 0;)
1226         if (sets_function_arg_p (XVECEXP (pat, 0, i)))
1227           return 1;
1228
1229       break;
1230
1231     case SET:
1232       inner_dest = SET_DEST (pat);
1233       while (GET_CODE (inner_dest) == STRICT_LOW_PART
1234              || GET_CODE (inner_dest) == SUBREG
1235              || GET_CODE (inner_dest) == ZERO_EXTRACT)
1236         inner_dest = XEXP (inner_dest, 0);
1237
1238       return (GET_CODE (inner_dest) == REG
1239               && REGNO (inner_dest) < FIRST_PSEUDO_REGISTER
1240               && FUNCTION_ARG_REGNO_P (REGNO (inner_dest)));
1241
1242     default:
1243       break;
1244     }
1245
1246   return 0;
1247 }
1248
1249 /* LOC is the location within I3 that contains its pattern or the component
1250    of a PARALLEL of the pattern.  We validate that it is valid for combining.
1251
1252    One problem is if I3 modifies its output, as opposed to replacing it
1253    entirely, we can't allow the output to contain I2DEST or I1DEST as doing
1254    so would produce an insn that is not equivalent to the original insns.
1255
1256    Consider:
1257
1258          (set (reg:DI 101) (reg:DI 100))
1259          (set (subreg:SI (reg:DI 101) 0) <foo>)
1260
1261    This is NOT equivalent to:
1262
1263          (parallel [(set (subreg:SI (reg:DI 100) 0) <foo>)
1264                     (set (reg:DI 101) (reg:DI 100))])
1265
1266    Not only does this modify 100 (in which case it might still be valid
1267    if 100 were dead in I2), it sets 101 to the ORIGINAL value of 100.
1268
1269    We can also run into a problem if I2 sets a register that I1
1270    uses and I1 gets directly substituted into I3 (not via I2).  In that
1271    case, we would be getting the wrong value of I2DEST into I3, so we
1272    must reject the combination.  This case occurs when I2 and I1 both
1273    feed into I3, rather than when I1 feeds into I2, which feeds into I3.
1274    If I1_NOT_IN_SRC is nonzero, it means that finding I1 in the source
1275    of a SET must prevent combination from occurring.
1276
1277    Before doing the above check, we first try to expand a field assignment
1278    into a set of logical operations.
1279
1280    If PI3_DEST_KILLED is nonzero, it is a pointer to a location in which
1281    we place a register that is both set and used within I3.  If more than one
1282    such register is detected, we fail.
1283
1284    Return 1 if the combination is valid, zero otherwise.  */
1285
1286 static int
1287 combinable_i3pat (rtx i3, rtx *loc, rtx i2dest, rtx i1dest,
1288                   int i1_not_in_src, rtx *pi3dest_killed)
1289 {
1290   rtx x = *loc;
1291
1292   if (GET_CODE (x) == SET)
1293     {
1294       rtx set = x ;
1295       rtx dest = SET_DEST (set);
1296       rtx src = SET_SRC (set);
1297       rtx inner_dest = dest;
1298
1299       while (GET_CODE (inner_dest) == STRICT_LOW_PART
1300              || GET_CODE (inner_dest) == SUBREG
1301              || GET_CODE (inner_dest) == ZERO_EXTRACT)
1302         inner_dest = XEXP (inner_dest, 0);
1303
1304       /* Check for the case where I3 modifies its output, as
1305          discussed above.  */
1306       if ((inner_dest != dest
1307            && (reg_overlap_mentioned_p (i2dest, inner_dest)
1308                || (i1dest && reg_overlap_mentioned_p (i1dest, inner_dest))))
1309
1310           /* This is the same test done in can_combine_p except we can't test
1311              all_adjacent; we don't have to, since this instruction will stay
1312              in place, thus we are not considering increasing the lifetime of
1313              INNER_DEST.
1314
1315              Also, if this insn sets a function argument, combining it with
1316              something that might need a spill could clobber a previous
1317              function argument; the all_adjacent test in can_combine_p also
1318              checks this; here, we do a more specific test for this case.  */
1319
1320           || (GET_CODE (inner_dest) == REG
1321               && REGNO (inner_dest) < FIRST_PSEUDO_REGISTER
1322               && (! HARD_REGNO_MODE_OK (REGNO (inner_dest),
1323                                         GET_MODE (inner_dest))))
1324           || (i1_not_in_src && reg_overlap_mentioned_p (i1dest, src)))
1325         return 0;
1326
1327       /* If DEST is used in I3, it is being killed in this insn,
1328          so record that for later.
1329          Never add REG_DEAD notes for the FRAME_POINTER_REGNUM or the
1330          STACK_POINTER_REGNUM, since these are always considered to be
1331          live.  Similarly for ARG_POINTER_REGNUM if it is fixed.  */
1332       if (pi3dest_killed && GET_CODE (dest) == REG
1333           && reg_referenced_p (dest, PATTERN (i3))
1334           && REGNO (dest) != FRAME_POINTER_REGNUM
1335 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1336           && REGNO (dest) != HARD_FRAME_POINTER_REGNUM
1337 #endif
1338 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
1339           && (REGNO (dest) != ARG_POINTER_REGNUM
1340               || ! fixed_regs [REGNO (dest)])
1341 #endif
1342           && REGNO (dest) != STACK_POINTER_REGNUM)
1343         {
1344           if (*pi3dest_killed)
1345             return 0;
1346
1347           *pi3dest_killed = dest;
1348         }
1349     }
1350
1351   else if (GET_CODE (x) == PARALLEL)
1352     {
1353       int i;
1354
1355       for (i = 0; i < XVECLEN (x, 0); i++)
1356         if (! combinable_i3pat (i3, &XVECEXP (x, 0, i), i2dest, i1dest,
1357                                 i1_not_in_src, pi3dest_killed))
1358           return 0;
1359     }
1360
1361   return 1;
1362 }
1363 \f
1364 /* Return 1 if X is an arithmetic expression that contains a multiplication
1365    and division.  We don't count multiplications by powers of two here.  */
1366
1367 static int
1368 contains_muldiv (rtx x)
1369 {
1370   switch (GET_CODE (x))
1371     {
1372     case MOD:  case DIV:  case UMOD:  case UDIV:
1373       return 1;
1374
1375     case MULT:
1376       return ! (GET_CODE (XEXP (x, 1)) == CONST_INT
1377                 && exact_log2 (INTVAL (XEXP (x, 1))) >= 0);
1378     default:
1379       switch (GET_RTX_CLASS (GET_CODE (x)))
1380         {
1381         case 'c':  case '<':  case '2':
1382           return contains_muldiv (XEXP (x, 0))
1383             || contains_muldiv (XEXP (x, 1));
1384
1385         case '1':
1386           return contains_muldiv (XEXP (x, 0));
1387
1388         default:
1389           return 0;
1390         }
1391     }
1392 }
1393 \f
1394 /* Determine whether INSN can be used in a combination.  Return nonzero if
1395    not.  This is used in try_combine to detect early some cases where we
1396    can't perform combinations.  */
1397
1398 static int
1399 cant_combine_insn_p (rtx insn)
1400 {
1401   rtx set;
1402   rtx src, dest;
1403
1404   /* If this isn't really an insn, we can't do anything.
1405      This can occur when flow deletes an insn that it has merged into an
1406      auto-increment address.  */
1407   if (! INSN_P (insn))
1408     return 1;
1409
1410   /* Never combine loads and stores involving hard regs that are likely
1411      to be spilled.  The register allocator can usually handle such
1412      reg-reg moves by tying.  If we allow the combiner to make
1413      substitutions of likely-spilled regs, we may abort in reload.
1414      As an exception, we allow combinations involving fixed regs; these are
1415      not available to the register allocator so there's no risk involved.  */
1416
1417   set = single_set (insn);
1418   if (! set)
1419     return 0;
1420   src = SET_SRC (set);
1421   dest = SET_DEST (set);
1422   if (GET_CODE (src) == SUBREG)
1423     src = SUBREG_REG (src);
1424   if (GET_CODE (dest) == SUBREG)
1425     dest = SUBREG_REG (dest);
1426   if (REG_P (src) && REG_P (dest)
1427       && ((REGNO (src) < FIRST_PSEUDO_REGISTER
1428            && ! fixed_regs[REGNO (src)]
1429            && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (REGNO (src))))
1430           || (REGNO (dest) < FIRST_PSEUDO_REGISTER
1431               && ! fixed_regs[REGNO (dest)]
1432               && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (REGNO (dest))))))
1433     return 1;
1434
1435   return 0;
1436 }
1437
1438 /* Try to combine the insns I1 and I2 into I3.
1439    Here I1 and I2 appear earlier than I3.
1440    I1 can be zero; then we combine just I2 into I3.
1441
1442    If we are combining three insns and the resulting insn is not recognized,
1443    try splitting it into two insns.  If that happens, I2 and I3 are retained
1444    and I1 is pseudo-deleted by turning it into a NOTE.  Otherwise, I1 and I2
1445    are pseudo-deleted.
1446
1447    Return 0 if the combination does not work.  Then nothing is changed.
1448    If we did the combination, return the insn at which combine should
1449    resume scanning.
1450
1451    Set NEW_DIRECT_JUMP_P to a nonzero value if try_combine creates a
1452    new direct jump instruction.  */
1453
1454 static rtx
1455 try_combine (rtx i3, rtx i2, rtx i1, int *new_direct_jump_p)
1456 {
1457   /* New patterns for I3 and I2, respectively.  */
1458   rtx newpat, newi2pat = 0;
1459   int substed_i2 = 0, substed_i1 = 0;
1460   /* Indicates need to preserve SET in I1 or I2 in I3 if it is not dead.  */
1461   int added_sets_1, added_sets_2;
1462   /* Total number of SETs to put into I3.  */
1463   int total_sets;
1464   /* Nonzero is I2's body now appears in I3.  */
1465   int i2_is_used;
1466   /* INSN_CODEs for new I3, new I2, and user of condition code.  */
1467   int insn_code_number, i2_code_number = 0, other_code_number = 0;
1468   /* Contains I3 if the destination of I3 is used in its source, which means
1469      that the old life of I3 is being killed.  If that usage is placed into
1470      I2 and not in I3, a REG_DEAD note must be made.  */
1471   rtx i3dest_killed = 0;
1472   /* SET_DEST and SET_SRC of I2 and I1.  */
1473   rtx i2dest, i2src, i1dest = 0, i1src = 0;
1474   /* PATTERN (I2), or a copy of it in certain cases.  */
1475   rtx i2pat;
1476   /* Indicates if I2DEST or I1DEST is in I2SRC or I1_SRC.  */
1477   int i2dest_in_i2src = 0, i1dest_in_i1src = 0, i2dest_in_i1src = 0;
1478   int i1_feeds_i3 = 0;
1479   /* Notes that must be added to REG_NOTES in I3 and I2.  */
1480   rtx new_i3_notes, new_i2_notes;
1481   /* Notes that we substituted I3 into I2 instead of the normal case.  */
1482   int i3_subst_into_i2 = 0;
1483   /* Notes that I1, I2 or I3 is a MULT operation.  */
1484   int have_mult = 0;
1485
1486   int maxreg;
1487   rtx temp;
1488   rtx link;
1489   int i;
1490
1491   /* Exit early if one of the insns involved can't be used for
1492      combinations.  */
1493   if (cant_combine_insn_p (i3)
1494       || cant_combine_insn_p (i2)
1495       || (i1 && cant_combine_insn_p (i1))
1496       /* We also can't do anything if I3 has a
1497          REG_LIBCALL note since we don't want to disrupt the contiguity of a
1498          libcall.  */
1499 #if 0
1500       /* ??? This gives worse code, and appears to be unnecessary, since no
1501          pass after flow uses REG_LIBCALL/REG_RETVAL notes.  */
1502       || find_reg_note (i3, REG_LIBCALL, NULL_RTX)
1503 #endif
1504       )
1505     return 0;
1506
1507   combine_attempts++;
1508   undobuf.other_insn = 0;
1509
1510   /* Reset the hard register usage information.  */
1511   CLEAR_HARD_REG_SET (newpat_used_regs);
1512
1513   /* If I1 and I2 both feed I3, they can be in any order.  To simplify the
1514      code below, set I1 to be the earlier of the two insns.  */
1515   if (i1 && INSN_CUID (i1) > INSN_CUID (i2))
1516     temp = i1, i1 = i2, i2 = temp;
1517
1518   added_links_insn = 0;
1519
1520   /* First check for one important special-case that the code below will
1521      not handle.  Namely, the case where I1 is zero, I2 is a PARALLEL
1522      and I3 is a SET whose SET_SRC is a SET_DEST in I2.  In that case,
1523      we may be able to replace that destination with the destination of I3.
1524      This occurs in the common code where we compute both a quotient and
1525      remainder into a structure, in which case we want to do the computation
1526      directly into the structure to avoid register-register copies.
1527
1528      Note that this case handles both multiple sets in I2 and also
1529      cases where I2 has a number of CLOBBER or PARALLELs.
1530
1531      We make very conservative checks below and only try to handle the
1532      most common cases of this.  For example, we only handle the case
1533      where I2 and I3 are adjacent to avoid making difficult register
1534      usage tests.  */
1535
1536   if (i1 == 0 && GET_CODE (i3) == INSN && GET_CODE (PATTERN (i3)) == SET
1537       && GET_CODE (SET_SRC (PATTERN (i3))) == REG
1538       && REGNO (SET_SRC (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
1539       && find_reg_note (i3, REG_DEAD, SET_SRC (PATTERN (i3)))
1540       && GET_CODE (PATTERN (i2)) == PARALLEL
1541       && ! side_effects_p (SET_DEST (PATTERN (i3)))
1542       /* If the dest of I3 is a ZERO_EXTRACT or STRICT_LOW_PART, the code
1543          below would need to check what is inside (and reg_overlap_mentioned_p
1544          doesn't support those codes anyway).  Don't allow those destinations;
1545          the resulting insn isn't likely to be recognized anyway.  */
1546       && GET_CODE (SET_DEST (PATTERN (i3))) != ZERO_EXTRACT
1547       && GET_CODE (SET_DEST (PATTERN (i3))) != STRICT_LOW_PART
1548       && ! reg_overlap_mentioned_p (SET_SRC (PATTERN (i3)),
1549                                     SET_DEST (PATTERN (i3)))
1550       && next_real_insn (i2) == i3)
1551     {
1552       rtx p2 = PATTERN (i2);
1553
1554       /* Make sure that the destination of I3,
1555          which we are going to substitute into one output of I2,
1556          is not used within another output of I2.  We must avoid making this:
1557          (parallel [(set (mem (reg 69)) ...)
1558                     (set (reg 69) ...)])
1559          which is not well-defined as to order of actions.
1560          (Besides, reload can't handle output reloads for this.)
1561
1562          The problem can also happen if the dest of I3 is a memory ref,
1563          if another dest in I2 is an indirect memory ref.  */
1564       for (i = 0; i < XVECLEN (p2, 0); i++)
1565         if ((GET_CODE (XVECEXP (p2, 0, i)) == SET
1566              || GET_CODE (XVECEXP (p2, 0, i)) == CLOBBER)
1567             && reg_overlap_mentioned_p (SET_DEST (PATTERN (i3)),
1568                                         SET_DEST (XVECEXP (p2, 0, i))))
1569           break;
1570
1571       if (i == XVECLEN (p2, 0))
1572         for (i = 0; i < XVECLEN (p2, 0); i++)
1573           if ((GET_CODE (XVECEXP (p2, 0, i)) == SET
1574                || GET_CODE (XVECEXP (p2, 0, i)) == CLOBBER)
1575               && SET_DEST (XVECEXP (p2, 0, i)) == SET_SRC (PATTERN (i3)))
1576             {
1577               combine_merges++;
1578
1579               subst_insn = i3;
1580               subst_low_cuid = INSN_CUID (i2);
1581
1582               added_sets_2 = added_sets_1 = 0;
1583               i2dest = SET_SRC (PATTERN (i3));
1584
1585               /* Replace the dest in I2 with our dest and make the resulting
1586                  insn the new pattern for I3.  Then skip to where we
1587                  validate the pattern.  Everything was set up above.  */
1588               SUBST (SET_DEST (XVECEXP (p2, 0, i)),
1589                      SET_DEST (PATTERN (i3)));
1590
1591               newpat = p2;
1592               i3_subst_into_i2 = 1;
1593               goto validate_replacement;
1594             }
1595     }
1596
1597   /* If I2 is setting a double-word pseudo to a constant and I3 is setting
1598      one of those words to another constant, merge them by making a new
1599      constant.  */
1600   if (i1 == 0
1601       && (temp = single_set (i2)) != 0
1602       && (GET_CODE (SET_SRC (temp)) == CONST_INT
1603           || GET_CODE (SET_SRC (temp)) == CONST_DOUBLE)
1604       && GET_CODE (SET_DEST (temp)) == REG
1605       && GET_MODE_CLASS (GET_MODE (SET_DEST (temp))) == MODE_INT
1606       && GET_MODE_SIZE (GET_MODE (SET_DEST (temp))) == 2 * UNITS_PER_WORD
1607       && GET_CODE (PATTERN (i3)) == SET
1608       && GET_CODE (SET_DEST (PATTERN (i3))) == SUBREG
1609       && SUBREG_REG (SET_DEST (PATTERN (i3))) == SET_DEST (temp)
1610       && GET_MODE_CLASS (GET_MODE (SET_DEST (PATTERN (i3)))) == MODE_INT
1611       && GET_MODE_SIZE (GET_MODE (SET_DEST (PATTERN (i3)))) == UNITS_PER_WORD
1612       && GET_CODE (SET_SRC (PATTERN (i3))) == CONST_INT)
1613     {
1614       HOST_WIDE_INT lo, hi;
1615
1616       if (GET_CODE (SET_SRC (temp)) == CONST_INT)
1617         lo = INTVAL (SET_SRC (temp)), hi = lo < 0 ? -1 : 0;
1618       else
1619         {
1620           lo = CONST_DOUBLE_LOW (SET_SRC (temp));
1621           hi = CONST_DOUBLE_HIGH (SET_SRC (temp));
1622         }
1623
1624       if (subreg_lowpart_p (SET_DEST (PATTERN (i3))))
1625         {
1626           /* We don't handle the case of the target word being wider
1627              than a host wide int.  */
1628           if (HOST_BITS_PER_WIDE_INT < BITS_PER_WORD)
1629             abort ();
1630
1631           lo &= ~(UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD (1) - 1);
1632           lo |= (INTVAL (SET_SRC (PATTERN (i3)))
1633                  & (UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD (1) - 1));
1634         }
1635       else if (HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
1636         hi = INTVAL (SET_SRC (PATTERN (i3)));
1637       else if (HOST_BITS_PER_WIDE_INT >= 2 * BITS_PER_WORD)
1638         {
1639           int sign = -(int) ((unsigned HOST_WIDE_INT) lo
1640                              >> (HOST_BITS_PER_WIDE_INT - 1));
1641
1642           lo &= ~ (UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD
1643                    (UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD (1) - 1));
1644           lo |= (UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD
1645                  (INTVAL (SET_SRC (PATTERN (i3)))));
1646           if (hi == sign)
1647             hi = lo < 0 ? -1 : 0;
1648         }
1649       else
1650         /* We don't handle the case of the higher word not fitting
1651            entirely in either hi or lo.  */
1652         abort ();
1653
1654       combine_merges++;
1655       subst_insn = i3;
1656       subst_low_cuid = INSN_CUID (i2);
1657       added_sets_2 = added_sets_1 = 0;
1658       i2dest = SET_DEST (temp);
1659
1660       SUBST (SET_SRC (temp),
1661              immed_double_const (lo, hi, GET_MODE (SET_DEST (temp))));
1662
1663       newpat = PATTERN (i2);
1664       goto validate_replacement;
1665     }
1666
1667 #ifndef HAVE_cc0
1668   /* If we have no I1 and I2 looks like:
1669         (parallel [(set (reg:CC X) (compare:CC OP (const_int 0)))
1670                    (set Y OP)])
1671      make up a dummy I1 that is
1672         (set Y OP)
1673      and change I2 to be
1674         (set (reg:CC X) (compare:CC Y (const_int 0)))
1675
1676      (We can ignore any trailing CLOBBERs.)
1677
1678      This undoes a previous combination and allows us to match a branch-and-
1679      decrement insn.  */
1680
1681   if (i1 == 0 && GET_CODE (PATTERN (i2)) == PARALLEL
1682       && XVECLEN (PATTERN (i2), 0) >= 2
1683       && GET_CODE (XVECEXP (PATTERN (i2), 0, 0)) == SET
1684       && (GET_MODE_CLASS (GET_MODE (SET_DEST (XVECEXP (PATTERN (i2), 0, 0))))
1685           == MODE_CC)
1686       && GET_CODE (SET_SRC (XVECEXP (PATTERN (i2), 0, 0))) == COMPARE
1687       && XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 1) == const0_rtx
1688       && GET_CODE (XVECEXP (PATTERN (i2), 0, 1)) == SET
1689       && GET_CODE (SET_DEST (XVECEXP (PATTERN (i2), 0, 1))) == REG
1690       && rtx_equal_p (XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 0),
1691                       SET_SRC (XVECEXP (PATTERN (i2), 0, 1))))
1692     {
1693       for (i = XVECLEN (PATTERN (i2), 0) - 1; i >= 2; i--)
1694         if (GET_CODE (XVECEXP (PATTERN (i2), 0, i)) != CLOBBER)
1695           break;
1696
1697       if (i == 1)
1698         {
1699           /* We make I1 with the same INSN_UID as I2.  This gives it
1700              the same INSN_CUID for value tracking.  Our fake I1 will
1701              never appear in the insn stream so giving it the same INSN_UID
1702              as I2 will not cause a problem.  */
1703
1704           i1 = gen_rtx_INSN (VOIDmode, INSN_UID (i2), NULL_RTX, i2,
1705                              BLOCK_FOR_INSN (i2), INSN_LOCATOR (i2),
1706                              XVECEXP (PATTERN (i2), 0, 1), -1, NULL_RTX,
1707                              NULL_RTX);
1708
1709           SUBST (PATTERN (i2), XVECEXP (PATTERN (i2), 0, 0));
1710           SUBST (XEXP (SET_SRC (PATTERN (i2)), 0),
1711                  SET_DEST (PATTERN (i1)));
1712         }
1713     }
1714 #endif
1715
1716   /* Verify that I2 and I1 are valid for combining.  */
1717   if (! can_combine_p (i2, i3, i1, NULL_RTX, &i2dest, &i2src)
1718       || (i1 && ! can_combine_p (i1, i3, NULL_RTX, i2, &i1dest, &i1src)))
1719     {
1720       undo_all ();
1721       return 0;
1722     }
1723
1724   /* Record whether I2DEST is used in I2SRC and similarly for the other
1725      cases.  Knowing this will help in register status updating below.  */
1726   i2dest_in_i2src = reg_overlap_mentioned_p (i2dest, i2src);
1727   i1dest_in_i1src = i1 && reg_overlap_mentioned_p (i1dest, i1src);
1728   i2dest_in_i1src = i1 && reg_overlap_mentioned_p (i2dest, i1src);
1729
1730   /* See if I1 directly feeds into I3.  It does if I1DEST is not used
1731      in I2SRC.  */
1732   i1_feeds_i3 = i1 && ! reg_overlap_mentioned_p (i1dest, i2src);
1733
1734   /* Ensure that I3's pattern can be the destination of combines.  */
1735   if (! combinable_i3pat (i3, &PATTERN (i3), i2dest, i1dest,
1736                           i1 && i2dest_in_i1src && i1_feeds_i3,
1737                           &i3dest_killed))
1738     {
1739       undo_all ();
1740       return 0;
1741     }
1742
1743   /* See if any of the insns is a MULT operation.  Unless one is, we will
1744      reject a combination that is, since it must be slower.  Be conservative
1745      here.  */
1746   if (GET_CODE (i2src) == MULT
1747       || (i1 != 0 && GET_CODE (i1src) == MULT)
1748       || (GET_CODE (PATTERN (i3)) == SET
1749           && GET_CODE (SET_SRC (PATTERN (i3))) == MULT))
1750     have_mult = 1;
1751
1752   /* If I3 has an inc, then give up if I1 or I2 uses the reg that is inc'd.
1753      We used to do this EXCEPT in one case: I3 has a post-inc in an
1754      output operand.  However, that exception can give rise to insns like
1755         mov r3,(r3)+
1756      which is a famous insn on the PDP-11 where the value of r3 used as the
1757      source was model-dependent.  Avoid this sort of thing.  */
1758
1759 #if 0
1760   if (!(GET_CODE (PATTERN (i3)) == SET
1761         && GET_CODE (SET_SRC (PATTERN (i3))) == REG
1762         && GET_CODE (SET_DEST (PATTERN (i3))) == MEM
1763         && (GET_CODE (XEXP (SET_DEST (PATTERN (i3)), 0)) == POST_INC
1764             || GET_CODE (XEXP (SET_DEST (PATTERN (i3)), 0)) == POST_DEC)))
1765     /* It's not the exception.  */
1766 #endif
1767 #ifdef AUTO_INC_DEC
1768     for (link = REG_NOTES (i3); link; link = XEXP (link, 1))
1769       if (REG_NOTE_KIND (link) == REG_INC
1770           && (reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i2))
1771               || (i1 != 0
1772                   && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i1)))))
1773         {
1774           undo_all ();
1775           return 0;
1776         }
1777 #endif
1778
1779   /* See if the SETs in I1 or I2 need to be kept around in the merged
1780      instruction: whenever the value set there is still needed past I3.
1781      For the SETs in I2, this is easy: we see if I2DEST dies or is set in I3.
1782
1783      For the SET in I1, we have two cases:  If I1 and I2 independently
1784      feed into I3, the set in I1 needs to be kept around if I1DEST dies
1785      or is set in I3.  Otherwise (if I1 feeds I2 which feeds I3), the set
1786      in I1 needs to be kept around unless I1DEST dies or is set in either
1787      I2 or I3.  We can distinguish these cases by seeing if I2SRC mentions
1788      I1DEST.  If so, we know I1 feeds into I2.  */
1789
1790   added_sets_2 = ! dead_or_set_p (i3, i2dest);
1791
1792   added_sets_1
1793     = i1 && ! (i1_feeds_i3 ? dead_or_set_p (i3, i1dest)
1794                : (dead_or_set_p (i3, i1dest) || dead_or_set_p (i2, i1dest)));
1795
1796   /* If the set in I2 needs to be kept around, we must make a copy of
1797      PATTERN (I2), so that when we substitute I1SRC for I1DEST in
1798      PATTERN (I2), we are only substituting for the original I1DEST, not into
1799      an already-substituted copy.  This also prevents making self-referential
1800      rtx.  If I2 is a PARALLEL, we just need the piece that assigns I2SRC to
1801      I2DEST.  */
1802
1803   i2pat = (GET_CODE (PATTERN (i2)) == PARALLEL
1804            ? gen_rtx_SET (VOIDmode, i2dest, i2src)
1805            : PATTERN (i2));
1806
1807   if (added_sets_2)
1808     i2pat = copy_rtx (i2pat);
1809
1810   combine_merges++;
1811
1812   /* Substitute in the latest insn for the regs set by the earlier ones.  */
1813
1814   maxreg = max_reg_num ();
1815
1816   subst_insn = i3;
1817
1818   /* It is possible that the source of I2 or I1 may be performing an
1819      unneeded operation, such as a ZERO_EXTEND of something that is known
1820      to have the high part zero.  Handle that case by letting subst look at
1821      the innermost one of them.
1822
1823      Another way to do this would be to have a function that tries to
1824      simplify a single insn instead of merging two or more insns.  We don't
1825      do this because of the potential of infinite loops and because
1826      of the potential extra memory required.  However, doing it the way
1827      we are is a bit of a kludge and doesn't catch all cases.
1828
1829      But only do this if -fexpensive-optimizations since it slows things down
1830      and doesn't usually win.  */
1831
1832   if (flag_expensive_optimizations)
1833     {
1834       /* Pass pc_rtx so no substitutions are done, just simplifications.
1835          The cases that we are interested in here do not involve the few
1836          cases were is_replaced is checked.  */
1837       if (i1)
1838         {
1839           subst_low_cuid = INSN_CUID (i1);
1840           i1src = subst (i1src, pc_rtx, pc_rtx, 0, 0);
1841         }
1842       else
1843         {
1844           subst_low_cuid = INSN_CUID (i2);
1845           i2src = subst (i2src, pc_rtx, pc_rtx, 0, 0);
1846         }
1847     }
1848
1849 #ifndef HAVE_cc0
1850   /* Many machines that don't use CC0 have insns that can both perform an
1851      arithmetic operation and set the condition code.  These operations will
1852      be represented as a PARALLEL with the first element of the vector
1853      being a COMPARE of an arithmetic operation with the constant zero.
1854      The second element of the vector will set some pseudo to the result
1855      of the same arithmetic operation.  If we simplify the COMPARE, we won't
1856      match such a pattern and so will generate an extra insn.   Here we test
1857      for this case, where both the comparison and the operation result are
1858      needed, and make the PARALLEL by just replacing I2DEST in I3SRC with
1859      I2SRC.  Later we will make the PARALLEL that contains I2.  */
1860
1861   if (i1 == 0 && added_sets_2 && GET_CODE (PATTERN (i3)) == SET
1862       && GET_CODE (SET_SRC (PATTERN (i3))) == COMPARE
1863       && XEXP (SET_SRC (PATTERN (i3)), 1) == const0_rtx
1864       && rtx_equal_p (XEXP (SET_SRC (PATTERN (i3)), 0), i2dest))
1865     {
1866 #ifdef EXTRA_CC_MODES
1867       rtx *cc_use;
1868       enum machine_mode compare_mode;
1869 #endif
1870
1871       newpat = PATTERN (i3);
1872       SUBST (XEXP (SET_SRC (newpat), 0), i2src);
1873
1874       i2_is_used = 1;
1875
1876 #ifdef EXTRA_CC_MODES
1877       /* See if a COMPARE with the operand we substituted in should be done
1878          with the mode that is currently being used.  If not, do the same
1879          processing we do in `subst' for a SET; namely, if the destination
1880          is used only once, try to replace it with a register of the proper
1881          mode and also replace the COMPARE.  */
1882       if (undobuf.other_insn == 0
1883           && (cc_use = find_single_use (SET_DEST (newpat), i3,
1884                                         &undobuf.other_insn))
1885           && ((compare_mode = SELECT_CC_MODE (GET_CODE (*cc_use),
1886                                               i2src, const0_rtx))
1887               != GET_MODE (SET_DEST (newpat))))
1888         {
1889           unsigned int regno = REGNO (SET_DEST (newpat));
1890           rtx new_dest = gen_rtx_REG (compare_mode, regno);
1891
1892           if (regno < FIRST_PSEUDO_REGISTER
1893               || (REG_N_SETS (regno) == 1 && ! added_sets_2
1894                   && ! REG_USERVAR_P (SET_DEST (newpat))))
1895             {
1896               if (regno >= FIRST_PSEUDO_REGISTER)
1897                 SUBST (regno_reg_rtx[regno], new_dest);
1898
1899               SUBST (SET_DEST (newpat), new_dest);
1900               SUBST (XEXP (*cc_use, 0), new_dest);
1901               SUBST (SET_SRC (newpat),
1902                      gen_rtx_COMPARE (compare_mode, i2src, const0_rtx));
1903             }
1904           else
1905             undobuf.other_insn = 0;
1906         }
1907 #endif
1908     }
1909   else
1910 #endif
1911     {
1912       n_occurrences = 0;                /* `subst' counts here */
1913
1914       /* If I1 feeds into I2 (not into I3) and I1DEST is in I1SRC, we
1915          need to make a unique copy of I2SRC each time we substitute it
1916          to avoid self-referential rtl.  */
1917
1918       subst_low_cuid = INSN_CUID (i2);
1919       newpat = subst (PATTERN (i3), i2dest, i2src, 0,
1920                       ! i1_feeds_i3 && i1dest_in_i1src);
1921       substed_i2 = 1;
1922
1923       /* Record whether i2's body now appears within i3's body.  */
1924       i2_is_used = n_occurrences;
1925     }
1926
1927   /* If we already got a failure, don't try to do more.  Otherwise,
1928      try to substitute in I1 if we have it.  */
1929
1930   if (i1 && GET_CODE (newpat) != CLOBBER)
1931     {
1932       /* Before we can do this substitution, we must redo the test done
1933          above (see detailed comments there) that ensures  that I1DEST
1934          isn't mentioned in any SETs in NEWPAT that are field assignments.  */
1935
1936       if (! combinable_i3pat (NULL_RTX, &newpat, i1dest, NULL_RTX,
1937                               0, (rtx*) 0))
1938         {
1939           undo_all ();
1940           return 0;
1941         }
1942
1943       n_occurrences = 0;
1944       subst_low_cuid = INSN_CUID (i1);
1945       newpat = subst (newpat, i1dest, i1src, 0, 0);
1946       substed_i1 = 1;
1947     }
1948
1949   /* Fail if an autoincrement side-effect has been duplicated.  Be careful
1950      to count all the ways that I2SRC and I1SRC can be used.  */
1951   if ((FIND_REG_INC_NOTE (i2, NULL_RTX) != 0
1952        && i2_is_used + added_sets_2 > 1)
1953       || (i1 != 0 && FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
1954           && (n_occurrences + added_sets_1 + (added_sets_2 && ! i1_feeds_i3)
1955               > 1))
1956       /* Fail if we tried to make a new register (we used to abort, but there's
1957          really no reason to).  */
1958       || max_reg_num () != maxreg
1959       /* Fail if we couldn't do something and have a CLOBBER.  */
1960       || GET_CODE (newpat) == CLOBBER
1961       /* Fail if this new pattern is a MULT and we didn't have one before
1962          at the outer level.  */
1963       || (GET_CODE (newpat) == SET && GET_CODE (SET_SRC (newpat)) == MULT
1964           && ! have_mult))
1965     {
1966       undo_all ();
1967       return 0;
1968     }
1969
1970   /* If the actions of the earlier insns must be kept
1971      in addition to substituting them into the latest one,
1972      we must make a new PARALLEL for the latest insn
1973      to hold additional the SETs.  */
1974
1975   if (added_sets_1 || added_sets_2)
1976     {
1977       combine_extras++;
1978
1979       if (GET_CODE (newpat) == PARALLEL)
1980         {
1981           rtvec old = XVEC (newpat, 0);
1982           total_sets = XVECLEN (newpat, 0) + added_sets_1 + added_sets_2;
1983           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
1984           memcpy (XVEC (newpat, 0)->elem, &old->elem[0],
1985                   sizeof (old->elem[0]) * old->num_elem);
1986         }
1987       else
1988         {
1989           rtx old = newpat;
1990           total_sets = 1 + added_sets_1 + added_sets_2;
1991           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
1992           XVECEXP (newpat, 0, 0) = old;
1993         }
1994
1995       if (added_sets_1)
1996         XVECEXP (newpat, 0, --total_sets)
1997           = (GET_CODE (PATTERN (i1)) == PARALLEL
1998              ? gen_rtx_SET (VOIDmode, i1dest, i1src) : PATTERN (i1));
1999
2000       if (added_sets_2)
2001         {
2002           /* If there is no I1, use I2's body as is.  We used to also not do
2003              the subst call below if I2 was substituted into I3,
2004              but that could lose a simplification.  */
2005           if (i1 == 0)
2006             XVECEXP (newpat, 0, --total_sets) = i2pat;
2007           else
2008             /* See comment where i2pat is assigned.  */
2009             XVECEXP (newpat, 0, --total_sets)
2010               = subst (i2pat, i1dest, i1src, 0, 0);
2011         }
2012     }
2013
2014   /* We come here when we are replacing a destination in I2 with the
2015      destination of I3.  */
2016  validate_replacement:
2017
2018   /* Note which hard regs this insn has as inputs.  */
2019   mark_used_regs_combine (newpat);
2020
2021   /* Is the result of combination a valid instruction?  */
2022   insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2023
2024   /* If the result isn't valid, see if it is a PARALLEL of two SETs where
2025      the second SET's destination is a register that is unused.  In that case,
2026      we just need the first SET.   This can occur when simplifying a divmod
2027      insn.  We *must* test for this case here because the code below that
2028      splits two independent SETs doesn't handle this case correctly when it
2029      updates the register status.  Also check the case where the first
2030      SET's destination is unused.  That would not cause incorrect code, but
2031      does cause an unneeded insn to remain.  */
2032
2033   if (insn_code_number < 0 && GET_CODE (newpat) == PARALLEL
2034       && XVECLEN (newpat, 0) == 2
2035       && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
2036       && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
2037       && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) == REG
2038       && find_reg_note (i3, REG_UNUSED, SET_DEST (XVECEXP (newpat, 0, 1)))
2039       && ! side_effects_p (SET_SRC (XVECEXP (newpat, 0, 1)))
2040       && asm_noperands (newpat) < 0)
2041     {
2042       newpat = XVECEXP (newpat, 0, 0);
2043       insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2044     }
2045
2046   else if (insn_code_number < 0 && GET_CODE (newpat) == PARALLEL
2047            && XVECLEN (newpat, 0) == 2
2048            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
2049            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
2050            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) == REG
2051            && find_reg_note (i3, REG_UNUSED, SET_DEST (XVECEXP (newpat, 0, 0)))
2052            && ! side_effects_p (SET_SRC (XVECEXP (newpat, 0, 0)))
2053            && asm_noperands (newpat) < 0)
2054     {
2055       newpat = XVECEXP (newpat, 0, 1);
2056       insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2057     }
2058
2059   /* If we were combining three insns and the result is a simple SET
2060      with no ASM_OPERANDS that wasn't recognized, try to split it into two
2061      insns.  There are two ways to do this.  It can be split using a
2062      machine-specific method (like when you have an addition of a large
2063      constant) or by combine in the function find_split_point.  */
2064
2065   if (i1 && insn_code_number < 0 && GET_CODE (newpat) == SET
2066       && asm_noperands (newpat) < 0)
2067     {
2068       rtx m_split, *split;
2069       rtx ni2dest = i2dest;
2070
2071       /* See if the MD file can split NEWPAT.  If it can't, see if letting it
2072          use I2DEST as a scratch register will help.  In the latter case,
2073          convert I2DEST to the mode of the source of NEWPAT if we can.  */
2074
2075       m_split = split_insns (newpat, i3);
2076
2077       /* We can only use I2DEST as a scratch reg if it doesn't overlap any
2078          inputs of NEWPAT.  */
2079
2080       /* ??? If I2DEST is not safe, and I1DEST exists, then it would be
2081          possible to try that as a scratch reg.  This would require adding
2082          more code to make it work though.  */
2083
2084       if (m_split == 0 && ! reg_overlap_mentioned_p (ni2dest, newpat))
2085         {
2086           /* If I2DEST is a hard register or the only use of a pseudo,
2087              we can change its mode.  */
2088           if (GET_MODE (SET_DEST (newpat)) != GET_MODE (i2dest)
2089               && GET_MODE (SET_DEST (newpat)) != VOIDmode
2090               && GET_CODE (i2dest) == REG
2091               && (REGNO (i2dest) < FIRST_PSEUDO_REGISTER
2092                   || (REG_N_SETS (REGNO (i2dest)) == 1 && ! added_sets_2
2093                       && ! REG_USERVAR_P (i2dest))))
2094             ni2dest = gen_rtx_REG (GET_MODE (SET_DEST (newpat)),
2095                                    REGNO (i2dest));
2096
2097           m_split = split_insns (gen_rtx_PARALLEL
2098                                  (VOIDmode,
2099                                   gen_rtvec (2, newpat,
2100                                              gen_rtx_CLOBBER (VOIDmode,
2101                                                               ni2dest))),
2102                                  i3);
2103           /* If the split with the mode-changed register didn't work, try
2104              the original register.  */
2105           if (! m_split && ni2dest != i2dest)
2106             {
2107               ni2dest = i2dest;
2108               m_split = split_insns (gen_rtx_PARALLEL
2109                                      (VOIDmode,
2110                                       gen_rtvec (2, newpat,
2111                                                  gen_rtx_CLOBBER (VOIDmode,
2112                                                                   i2dest))),
2113                                      i3);
2114             }
2115         }
2116
2117       if (m_split && NEXT_INSN (m_split) == NULL_RTX)
2118         {
2119           m_split = PATTERN (m_split);
2120           insn_code_number = recog_for_combine (&m_split, i3, &new_i3_notes);
2121           if (insn_code_number >= 0)
2122             newpat = m_split;
2123         }
2124       else if (m_split && NEXT_INSN (NEXT_INSN (m_split)) == NULL_RTX
2125                && (next_real_insn (i2) == i3
2126                    || ! use_crosses_set_p (PATTERN (m_split), INSN_CUID (i2))))
2127         {
2128           rtx i2set, i3set;
2129           rtx newi3pat = PATTERN (NEXT_INSN (m_split));
2130           newi2pat = PATTERN (m_split);
2131
2132           i3set = single_set (NEXT_INSN (m_split));
2133           i2set = single_set (m_split);
2134
2135           /* In case we changed the mode of I2DEST, replace it in the
2136              pseudo-register table here.  We can't do it above in case this
2137              code doesn't get executed and we do a split the other way.  */
2138
2139           if (REGNO (i2dest) >= FIRST_PSEUDO_REGISTER)
2140             SUBST (regno_reg_rtx[REGNO (i2dest)], ni2dest);
2141
2142           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2143
2144           /* If I2 or I3 has multiple SETs, we won't know how to track
2145              register status, so don't use these insns.  If I2's destination
2146              is used between I2 and I3, we also can't use these insns.  */
2147
2148           if (i2_code_number >= 0 && i2set && i3set
2149               && (next_real_insn (i2) == i3
2150                   || ! reg_used_between_p (SET_DEST (i2set), i2, i3)))
2151             insn_code_number = recog_for_combine (&newi3pat, i3,
2152                                                   &new_i3_notes);
2153           if (insn_code_number >= 0)
2154             newpat = newi3pat;
2155
2156           /* It is possible that both insns now set the destination of I3.
2157              If so, we must show an extra use of it.  */
2158
2159           if (insn_code_number >= 0)
2160             {
2161               rtx new_i3_dest = SET_DEST (i3set);
2162               rtx new_i2_dest = SET_DEST (i2set);
2163
2164               while (GET_CODE (new_i3_dest) == ZERO_EXTRACT
2165                      || GET_CODE (new_i3_dest) == STRICT_LOW_PART
2166                      || GET_CODE (new_i3_dest) == SUBREG)
2167                 new_i3_dest = XEXP (new_i3_dest, 0);
2168
2169               while (GET_CODE (new_i2_dest) == ZERO_EXTRACT
2170                      || GET_CODE (new_i2_dest) == STRICT_LOW_PART
2171                      || GET_CODE (new_i2_dest) == SUBREG)
2172                 new_i2_dest = XEXP (new_i2_dest, 0);
2173
2174               if (GET_CODE (new_i3_dest) == REG
2175                   && GET_CODE (new_i2_dest) == REG
2176                   && REGNO (new_i3_dest) == REGNO (new_i2_dest))
2177                 REG_N_SETS (REGNO (new_i2_dest))++;
2178             }
2179         }
2180
2181       /* If we can split it and use I2DEST, go ahead and see if that
2182          helps things be recognized.  Verify that none of the registers
2183          are set between I2 and I3.  */
2184       if (insn_code_number < 0 && (split = find_split_point (&newpat, i3)) != 0
2185 #ifdef HAVE_cc0
2186           && GET_CODE (i2dest) == REG
2187 #endif
2188           /* We need I2DEST in the proper mode.  If it is a hard register
2189              or the only use of a pseudo, we can change its mode.  */
2190           && (GET_MODE (*split) == GET_MODE (i2dest)
2191               || GET_MODE (*split) == VOIDmode
2192               || REGNO (i2dest) < FIRST_PSEUDO_REGISTER
2193               || (REG_N_SETS (REGNO (i2dest)) == 1 && ! added_sets_2
2194                   && ! REG_USERVAR_P (i2dest)))
2195           && (next_real_insn (i2) == i3
2196               || ! use_crosses_set_p (*split, INSN_CUID (i2)))
2197           /* We can't overwrite I2DEST if its value is still used by
2198              NEWPAT.  */
2199           && ! reg_referenced_p (i2dest, newpat))
2200         {
2201           rtx newdest = i2dest;
2202           enum rtx_code split_code = GET_CODE (*split);
2203           enum machine_mode split_mode = GET_MODE (*split);
2204
2205           /* Get NEWDEST as a register in the proper mode.  We have already
2206              validated that we can do this.  */
2207           if (GET_MODE (i2dest) != split_mode && split_mode != VOIDmode)
2208             {
2209               newdest = gen_rtx_REG (split_mode, REGNO (i2dest));
2210
2211               if (REGNO (i2dest) >= FIRST_PSEUDO_REGISTER)
2212                 SUBST (regno_reg_rtx[REGNO (i2dest)], newdest);
2213             }
2214
2215           /* If *SPLIT is a (mult FOO (const_int pow2)), convert it to
2216              an ASHIFT.  This can occur if it was inside a PLUS and hence
2217              appeared to be a memory address.  This is a kludge.  */
2218           if (split_code == MULT
2219               && GET_CODE (XEXP (*split, 1)) == CONST_INT
2220               && INTVAL (XEXP (*split, 1)) > 0
2221               && (i = exact_log2 (INTVAL (XEXP (*split, 1)))) >= 0)
2222             {
2223               SUBST (*split, gen_rtx_ASHIFT (split_mode,
2224                                              XEXP (*split, 0), GEN_INT (i)));
2225               /* Update split_code because we may not have a multiply
2226                  anymore.  */
2227               split_code = GET_CODE (*split);
2228             }
2229
2230 #ifdef INSN_SCHEDULING
2231           /* If *SPLIT is a paradoxical SUBREG, when we split it, it should
2232              be written as a ZERO_EXTEND.  */
2233           if (split_code == SUBREG && GET_CODE (SUBREG_REG (*split)) == MEM)
2234             {
2235 #ifdef LOAD_EXTEND_OP
2236               /* Or as a SIGN_EXTEND if LOAD_EXTEND_OP says that that's
2237                  what it really is.  */
2238               if (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (*split)))
2239                   == SIGN_EXTEND)
2240                 SUBST (*split, gen_rtx_SIGN_EXTEND (split_mode,
2241                                                     SUBREG_REG (*split)));
2242               else
2243 #endif
2244                 SUBST (*split, gen_rtx_ZERO_EXTEND (split_mode,
2245                                                     SUBREG_REG (*split)));
2246             }
2247 #endif
2248
2249           newi2pat = gen_rtx_SET (VOIDmode, newdest, *split);
2250           SUBST (*split, newdest);
2251           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2252
2253           /* If the split point was a MULT and we didn't have one before,
2254              don't use one now.  */
2255           if (i2_code_number >= 0 && ! (split_code == MULT && ! have_mult))
2256             insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2257         }
2258     }
2259
2260   /* Check for a case where we loaded from memory in a narrow mode and
2261      then sign extended it, but we need both registers.  In that case,
2262      we have a PARALLEL with both loads from the same memory location.
2263      We can split this into a load from memory followed by a register-register
2264      copy.  This saves at least one insn, more if register allocation can
2265      eliminate the copy.
2266
2267      We cannot do this if the destination of the first assignment is a
2268      condition code register or cc0.  We eliminate this case by making sure
2269      the SET_DEST and SET_SRC have the same mode.
2270
2271      We cannot do this if the destination of the second assignment is
2272      a register that we have already assumed is zero-extended.  Similarly
2273      for a SUBREG of such a register.  */
2274
2275   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
2276            && GET_CODE (newpat) == PARALLEL
2277            && XVECLEN (newpat, 0) == 2
2278            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
2279            && GET_CODE (SET_SRC (XVECEXP (newpat, 0, 0))) == SIGN_EXTEND
2280            && (GET_MODE (SET_DEST (XVECEXP (newpat, 0, 0)))
2281                == GET_MODE (SET_SRC (XVECEXP (newpat, 0, 0))))
2282            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
2283            && rtx_equal_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2284                            XEXP (SET_SRC (XVECEXP (newpat, 0, 0)), 0))
2285            && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2286                                    INSN_CUID (i2))
2287            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
2288            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
2289            && ! (temp = SET_DEST (XVECEXP (newpat, 0, 1)),
2290                  (GET_CODE (temp) == REG
2291                   && reg_nonzero_bits[REGNO (temp)] != 0
2292                   && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
2293                   && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
2294                   && (reg_nonzero_bits[REGNO (temp)]
2295                       != GET_MODE_MASK (word_mode))))
2296            && ! (GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) == SUBREG
2297                  && (temp = SUBREG_REG (SET_DEST (XVECEXP (newpat, 0, 1))),
2298                      (GET_CODE (temp) == REG
2299                       && reg_nonzero_bits[REGNO (temp)] != 0
2300                       && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
2301                       && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
2302                       && (reg_nonzero_bits[REGNO (temp)]
2303                           != GET_MODE_MASK (word_mode)))))
2304            && ! reg_overlap_mentioned_p (SET_DEST (XVECEXP (newpat, 0, 1)),
2305                                          SET_SRC (XVECEXP (newpat, 0, 1)))
2306            && ! find_reg_note (i3, REG_UNUSED,
2307                                SET_DEST (XVECEXP (newpat, 0, 0))))
2308     {
2309       rtx ni2dest;
2310
2311       newi2pat = XVECEXP (newpat, 0, 0);
2312       ni2dest = SET_DEST (XVECEXP (newpat, 0, 0));
2313       newpat = XVECEXP (newpat, 0, 1);
2314       SUBST (SET_SRC (newpat),
2315              gen_lowpart_for_combine (GET_MODE (SET_SRC (newpat)), ni2dest));
2316       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2317
2318       if (i2_code_number >= 0)
2319         insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2320
2321       if (insn_code_number >= 0)
2322         {
2323           rtx insn;
2324           rtx link;
2325
2326           /* If we will be able to accept this, we have made a change to the
2327              destination of I3.  This can invalidate a LOG_LINKS pointing
2328              to I3.  No other part of combine.c makes such a transformation.
2329
2330              The new I3 will have a destination that was previously the
2331              destination of I1 or I2 and which was used in i2 or I3.  Call
2332              distribute_links to make a LOG_LINK from the next use of
2333              that destination.  */
2334
2335           PATTERN (i3) = newpat;
2336           distribute_links (gen_rtx_INSN_LIST (VOIDmode, i3, NULL_RTX));
2337
2338           /* I3 now uses what used to be its destination and which is
2339              now I2's destination.  That means we need a LOG_LINK from
2340              I3 to I2.  But we used to have one, so we still will.
2341
2342              However, some later insn might be using I2's dest and have
2343              a LOG_LINK pointing at I3.  We must remove this link.
2344              The simplest way to remove the link is to point it at I1,
2345              which we know will be a NOTE.  */
2346
2347           for (insn = NEXT_INSN (i3);
2348                insn && (this_basic_block->next_bb == EXIT_BLOCK_PTR
2349                         || insn != this_basic_block->next_bb->head);
2350                insn = NEXT_INSN (insn))
2351             {
2352               if (INSN_P (insn) && reg_referenced_p (ni2dest, PATTERN (insn)))
2353                 {
2354                   for (link = LOG_LINKS (insn); link;
2355                        link = XEXP (link, 1))
2356                     if (XEXP (link, 0) == i3)
2357                       XEXP (link, 0) = i1;
2358
2359                   break;
2360                 }
2361             }
2362         }
2363     }
2364
2365   /* Similarly, check for a case where we have a PARALLEL of two independent
2366      SETs but we started with three insns.  In this case, we can do the sets
2367      as two separate insns.  This case occurs when some SET allows two
2368      other insns to combine, but the destination of that SET is still live.  */
2369
2370   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
2371            && GET_CODE (newpat) == PARALLEL
2372            && XVECLEN (newpat, 0) == 2
2373            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
2374            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != ZERO_EXTRACT
2375            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != STRICT_LOW_PART
2376            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
2377            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
2378            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
2379            && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2380                                    INSN_CUID (i2))
2381            /* Don't pass sets with (USE (MEM ...)) dests to the following.  */
2382            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != USE
2383            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != USE
2384            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 1)),
2385                                   XVECEXP (newpat, 0, 0))
2386            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 0)),
2387                                   XVECEXP (newpat, 0, 1))
2388            && ! (contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 0)))
2389                  && contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 1)))))
2390     {
2391       /* Normally, it doesn't matter which of the two is done first,
2392          but it does if one references cc0.  In that case, it has to
2393          be first.  */
2394 #ifdef HAVE_cc0
2395       if (reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 0)))
2396         {
2397           newi2pat = XVECEXP (newpat, 0, 0);
2398           newpat = XVECEXP (newpat, 0, 1);
2399         }
2400       else
2401 #endif
2402         {
2403           newi2pat = XVECEXP (newpat, 0, 1);
2404           newpat = XVECEXP (newpat, 0, 0);
2405         }
2406
2407       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2408
2409       if (i2_code_number >= 0)
2410         insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2411     }
2412
2413   /* If it still isn't recognized, fail and change things back the way they
2414      were.  */
2415   if ((insn_code_number < 0
2416        /* Is the result a reasonable ASM_OPERANDS?  */
2417        && (! check_asm_operands (newpat) || added_sets_1 || added_sets_2)))
2418     {
2419       undo_all ();
2420       return 0;
2421     }
2422
2423   /* If we had to change another insn, make sure it is valid also.  */
2424   if (undobuf.other_insn)
2425     {
2426       rtx other_pat = PATTERN (undobuf.other_insn);
2427       rtx new_other_notes;
2428       rtx note, next;
2429
2430       CLEAR_HARD_REG_SET (newpat_used_regs);
2431
2432       other_code_number = recog_for_combine (&other_pat, undobuf.other_insn,
2433                                              &new_other_notes);
2434
2435       if (other_code_number < 0 && ! check_asm_operands (other_pat))
2436         {
2437           undo_all ();
2438           return 0;
2439         }
2440
2441       PATTERN (undobuf.other_insn) = other_pat;
2442
2443       /* If any of the notes in OTHER_INSN were REG_UNUSED, ensure that they
2444          are still valid.  Then add any non-duplicate notes added by
2445          recog_for_combine.  */
2446       for (note = REG_NOTES (undobuf.other_insn); note; note = next)
2447         {
2448           next = XEXP (note, 1);
2449
2450           if (REG_NOTE_KIND (note) == REG_UNUSED
2451               && ! reg_set_p (XEXP (note, 0), PATTERN (undobuf.other_insn)))
2452             {
2453               if (GET_CODE (XEXP (note, 0)) == REG)
2454                 REG_N_DEATHS (REGNO (XEXP (note, 0)))--;
2455
2456               remove_note (undobuf.other_insn, note);
2457             }
2458         }
2459
2460       for (note = new_other_notes; note; note = XEXP (note, 1))
2461         if (GET_CODE (XEXP (note, 0)) == REG)
2462           REG_N_DEATHS (REGNO (XEXP (note, 0)))++;
2463
2464       distribute_notes (new_other_notes, undobuf.other_insn,
2465                         undobuf.other_insn, NULL_RTX);
2466     }
2467 #ifdef HAVE_cc0
2468   /* If I2 is the setter CC0 and I3 is the user CC0 then check whether
2469      they are adjacent to each other or not.  */
2470   {
2471     rtx p = prev_nonnote_insn (i3);
2472     if (p && p != i2 && GET_CODE (p) == INSN && newi2pat
2473         && sets_cc0_p (newi2pat))
2474       {
2475         undo_all ();
2476         return 0;
2477       }
2478   }
2479 #endif
2480
2481   /* We now know that we can do this combination.  Merge the insns and
2482      update the status of registers and LOG_LINKS.  */
2483
2484   {
2485     rtx i3notes, i2notes, i1notes = 0;
2486     rtx i3links, i2links, i1links = 0;
2487     rtx midnotes = 0;
2488     unsigned int regno;
2489
2490     /* Get the old REG_NOTES and LOG_LINKS from all our insns and
2491        clear them.  */
2492     i3notes = REG_NOTES (i3), i3links = LOG_LINKS (i3);
2493     i2notes = REG_NOTES (i2), i2links = LOG_LINKS (i2);
2494     if (i1)
2495       i1notes = REG_NOTES (i1), i1links = LOG_LINKS (i1);
2496
2497     /* Ensure that we do not have something that should not be shared but
2498        occurs multiple times in the new insns.  Check this by first
2499        resetting all the `used' flags and then copying anything is shared.  */
2500
2501     reset_used_flags (i3notes);
2502     reset_used_flags (i2notes);
2503     reset_used_flags (i1notes);
2504     reset_used_flags (newpat);
2505     reset_used_flags (newi2pat);
2506     if (undobuf.other_insn)
2507       reset_used_flags (PATTERN (undobuf.other_insn));
2508
2509     i3notes = copy_rtx_if_shared (i3notes);
2510     i2notes = copy_rtx_if_shared (i2notes);
2511     i1notes = copy_rtx_if_shared (i1notes);
2512     newpat = copy_rtx_if_shared (newpat);
2513     newi2pat = copy_rtx_if_shared (newi2pat);
2514     if (undobuf.other_insn)
2515       reset_used_flags (PATTERN (undobuf.other_insn));
2516
2517     INSN_CODE (i3) = insn_code_number;
2518     PATTERN (i3) = newpat;
2519
2520     if (GET_CODE (i3) == CALL_INSN && CALL_INSN_FUNCTION_USAGE (i3))
2521       {
2522         rtx call_usage = CALL_INSN_FUNCTION_USAGE (i3);
2523
2524         reset_used_flags (call_usage);
2525         call_usage = copy_rtx (call_usage);
2526
2527         if (substed_i2)
2528           replace_rtx (call_usage, i2dest, i2src);
2529
2530         if (substed_i1)
2531           replace_rtx (call_usage, i1dest, i1src);
2532
2533         CALL_INSN_FUNCTION_USAGE (i3) = call_usage;
2534       }
2535
2536     if (undobuf.other_insn)
2537       INSN_CODE (undobuf.other_insn) = other_code_number;
2538
2539     /* We had one special case above where I2 had more than one set and
2540        we replaced a destination of one of those sets with the destination
2541        of I3.  In that case, we have to update LOG_LINKS of insns later
2542        in this basic block.  Note that this (expensive) case is rare.
2543
2544        Also, in this case, we must pretend that all REG_NOTEs for I2
2545        actually came from I3, so that REG_UNUSED notes from I2 will be
2546        properly handled.  */
2547
2548     if (i3_subst_into_i2)
2549       {
2550         for (i = 0; i < XVECLEN (PATTERN (i2), 0); i++)
2551           if (GET_CODE (XVECEXP (PATTERN (i2), 0, i)) != USE
2552               && GET_CODE (SET_DEST (XVECEXP (PATTERN (i2), 0, i))) == REG
2553               && SET_DEST (XVECEXP (PATTERN (i2), 0, i)) != i2dest
2554               && ! find_reg_note (i2, REG_UNUSED,
2555                                   SET_DEST (XVECEXP (PATTERN (i2), 0, i))))
2556             for (temp = NEXT_INSN (i2);
2557                  temp && (this_basic_block->next_bb == EXIT_BLOCK_PTR
2558                           || this_basic_block->head != temp);
2559                  temp = NEXT_INSN (temp))
2560               if (temp != i3 && INSN_P (temp))
2561                 for (link = LOG_LINKS (temp); link; link = XEXP (link, 1))
2562                   if (XEXP (link, 0) == i2)
2563                     XEXP (link, 0) = i3;
2564
2565         if (i3notes)
2566           {
2567             rtx link = i3notes;
2568             while (XEXP (link, 1))
2569               link = XEXP (link, 1);
2570             XEXP (link, 1) = i2notes;
2571           }
2572         else
2573           i3notes = i2notes;
2574         i2notes = 0;
2575       }
2576
2577     LOG_LINKS (i3) = 0;
2578     REG_NOTES (i3) = 0;
2579     LOG_LINKS (i2) = 0;
2580     REG_NOTES (i2) = 0;
2581
2582     if (newi2pat)
2583       {
2584         INSN_CODE (i2) = i2_code_number;
2585         PATTERN (i2) = newi2pat;
2586       }
2587     else
2588       {
2589         PUT_CODE (i2, NOTE);
2590         NOTE_LINE_NUMBER (i2) = NOTE_INSN_DELETED;
2591         NOTE_SOURCE_FILE (i2) = 0;
2592       }
2593
2594     if (i1)
2595       {
2596         LOG_LINKS (i1) = 0;
2597         REG_NOTES (i1) = 0;
2598         PUT_CODE (i1, NOTE);
2599         NOTE_LINE_NUMBER (i1) = NOTE_INSN_DELETED;
2600         NOTE_SOURCE_FILE (i1) = 0;
2601       }
2602
2603     /* Get death notes for everything that is now used in either I3 or
2604        I2 and used to die in a previous insn.  If we built two new
2605        patterns, move from I1 to I2 then I2 to I3 so that we get the
2606        proper movement on registers that I2 modifies.  */
2607
2608     if (newi2pat)
2609       {
2610         move_deaths (newi2pat, NULL_RTX, INSN_CUID (i1), i2, &midnotes);
2611         move_deaths (newpat, newi2pat, INSN_CUID (i1), i3, &midnotes);
2612       }
2613     else
2614       move_deaths (newpat, NULL_RTX, i1 ? INSN_CUID (i1) : INSN_CUID (i2),
2615                    i3, &midnotes);
2616
2617     /* Distribute all the LOG_LINKS and REG_NOTES from I1, I2, and I3.  */
2618     if (i3notes)
2619       distribute_notes (i3notes, i3, i3, newi2pat ? i2 : NULL_RTX);
2620     if (i2notes)
2621       distribute_notes (i2notes, i2, i3, newi2pat ? i2 : NULL_RTX);
2622     if (i1notes)
2623       distribute_notes (i1notes, i1, i3, newi2pat ? i2 : NULL_RTX);
2624     if (midnotes)
2625       distribute_notes (midnotes, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX);
2626
2627     /* Distribute any notes added to I2 or I3 by recog_for_combine.  We
2628        know these are REG_UNUSED and want them to go to the desired insn,
2629        so we always pass it as i3.  We have not counted the notes in
2630        reg_n_deaths yet, so we need to do so now.  */
2631
2632     if (newi2pat && new_i2_notes)
2633       {
2634         for (temp = new_i2_notes; temp; temp = XEXP (temp, 1))
2635           if (GET_CODE (XEXP (temp, 0)) == REG)
2636             REG_N_DEATHS (REGNO (XEXP (temp, 0)))++;
2637
2638         distribute_notes (new_i2_notes, i2, i2, NULL_RTX);
2639       }
2640
2641     if (new_i3_notes)
2642       {
2643         for (temp = new_i3_notes; temp; temp = XEXP (temp, 1))
2644           if (GET_CODE (XEXP (temp, 0)) == REG)
2645             REG_N_DEATHS (REGNO (XEXP (temp, 0)))++;
2646
2647         distribute_notes (new_i3_notes, i3, i3, NULL_RTX);
2648       }
2649
2650     /* If I3DEST was used in I3SRC, it really died in I3.  We may need to
2651        put a REG_DEAD note for it somewhere.  If NEWI2PAT exists and sets
2652        I3DEST, the death must be somewhere before I2, not I3.  If we passed I3
2653        in that case, it might delete I2.  Similarly for I2 and I1.
2654        Show an additional death due to the REG_DEAD note we make here.  If
2655        we discard it in distribute_notes, we will decrement it again.  */
2656
2657     if (i3dest_killed)
2658       {
2659         if (GET_CODE (i3dest_killed) == REG)
2660           REG_N_DEATHS (REGNO (i3dest_killed))++;
2661
2662         if (newi2pat && reg_set_p (i3dest_killed, newi2pat))
2663           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i3dest_killed,
2664                                                NULL_RTX),
2665                             NULL_RTX, i2, NULL_RTX);
2666         else
2667           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i3dest_killed,
2668                                                NULL_RTX),
2669                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX);
2670       }
2671
2672     if (i2dest_in_i2src)
2673       {
2674         if (GET_CODE (i2dest) == REG)
2675           REG_N_DEATHS (REGNO (i2dest))++;
2676
2677         if (newi2pat && reg_set_p (i2dest, newi2pat))
2678           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i2dest, NULL_RTX),
2679                             NULL_RTX, i2, NULL_RTX);
2680         else
2681           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i2dest, NULL_RTX),
2682                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX);
2683       }
2684
2685     if (i1dest_in_i1src)
2686       {
2687         if (GET_CODE (i1dest) == REG)
2688           REG_N_DEATHS (REGNO (i1dest))++;
2689
2690         if (newi2pat && reg_set_p (i1dest, newi2pat))
2691           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i1dest, NULL_RTX),
2692                             NULL_RTX, i2, NULL_RTX);
2693         else
2694           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i1dest, NULL_RTX),
2695                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX);
2696       }
2697
2698     distribute_links (i3links);
2699     distribute_links (i2links);
2700     distribute_links (i1links);
2701
2702     if (GET_CODE (i2dest) == REG)
2703       {
2704         rtx link;
2705         rtx i2_insn = 0, i2_val = 0, set;
2706
2707         /* The insn that used to set this register doesn't exist, and
2708            this life of the register may not exist either.  See if one of
2709            I3's links points to an insn that sets I2DEST.  If it does,
2710            that is now the last known value for I2DEST. If we don't update
2711            this and I2 set the register to a value that depended on its old
2712            contents, we will get confused.  If this insn is used, thing
2713            will be set correctly in combine_instructions.  */
2714
2715         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
2716           if ((set = single_set (XEXP (link, 0))) != 0
2717               && rtx_equal_p (i2dest, SET_DEST (set)))
2718             i2_insn = XEXP (link, 0), i2_val = SET_SRC (set);
2719
2720         record_value_for_reg (i2dest, i2_insn, i2_val);
2721
2722         /* If the reg formerly set in I2 died only once and that was in I3,
2723            zero its use count so it won't make `reload' do any work.  */
2724         if (! added_sets_2
2725             && (newi2pat == 0 || ! reg_mentioned_p (i2dest, newi2pat))
2726             && ! i2dest_in_i2src)
2727           {
2728             regno = REGNO (i2dest);
2729             REG_N_SETS (regno)--;
2730           }
2731       }
2732
2733     if (i1 && GET_CODE (i1dest) == REG)
2734       {
2735         rtx link;
2736         rtx i1_insn = 0, i1_val = 0, set;
2737
2738         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
2739           if ((set = single_set (XEXP (link, 0))) != 0
2740               && rtx_equal_p (i1dest, SET_DEST (set)))
2741             i1_insn = XEXP (link, 0), i1_val = SET_SRC (set);
2742
2743         record_value_for_reg (i1dest, i1_insn, i1_val);
2744
2745         regno = REGNO (i1dest);
2746         if (! added_sets_1 && ! i1dest_in_i1src)
2747           REG_N_SETS (regno)--;
2748       }
2749
2750     /* Update reg_nonzero_bits et al for any changes that may have been made
2751        to this insn.  The order of set_nonzero_bits_and_sign_copies() is
2752        important.  Because newi2pat can affect nonzero_bits of newpat */
2753     if (newi2pat)
2754       note_stores (newi2pat, set_nonzero_bits_and_sign_copies, NULL);
2755     note_stores (newpat, set_nonzero_bits_and_sign_copies, NULL);
2756
2757     /* Set new_direct_jump_p if a new return or simple jump instruction
2758        has been created.
2759
2760        If I3 is now an unconditional jump, ensure that it has a
2761        BARRIER following it since it may have initially been a
2762        conditional jump.  It may also be the last nonnote insn.  */
2763
2764     if (returnjump_p (i3) || any_uncondjump_p (i3))
2765       {
2766         *new_direct_jump_p = 1;
2767
2768         if ((temp = next_nonnote_insn (i3)) == NULL_RTX
2769             || GET_CODE (temp) != BARRIER)
2770           emit_barrier_after (i3);
2771       }
2772
2773     if (undobuf.other_insn != NULL_RTX
2774         && (returnjump_p (undobuf.other_insn)
2775             || any_uncondjump_p (undobuf.other_insn)))
2776       {
2777         *new_direct_jump_p = 1;
2778
2779         if ((temp = next_nonnote_insn (undobuf.other_insn)) == NULL_RTX
2780             || GET_CODE (temp) != BARRIER)
2781           emit_barrier_after (undobuf.other_insn);
2782       }
2783
2784     /* An NOOP jump does not need barrier, but it does need cleaning up
2785        of CFG.  */
2786     if (GET_CODE (newpat) == SET
2787         && SET_SRC (newpat) == pc_rtx
2788         && SET_DEST (newpat) == pc_rtx)
2789       *new_direct_jump_p = 1;
2790   }
2791
2792   combine_successes++;
2793   undo_commit ();
2794
2795   if (added_links_insn
2796       && (newi2pat == 0 || INSN_CUID (added_links_insn) < INSN_CUID (i2))
2797       && INSN_CUID (added_links_insn) < INSN_CUID (i3))
2798     return added_links_insn;
2799   else
2800     return newi2pat ? i2 : i3;
2801 }
2802 \f
2803 /* Undo all the modifications recorded in undobuf.  */
2804
2805 static void
2806 undo_all (void)
2807 {
2808   struct undo *undo, *next;
2809
2810   for (undo = undobuf.undos; undo; undo = next)
2811     {
2812       next = undo->next;
2813       if (undo->is_int)
2814         *undo->where.i = undo->old_contents.i;
2815       else
2816         *undo->where.r = undo->old_contents.r;
2817
2818       undo->next = undobuf.frees;
2819       undobuf.frees = undo;
2820     }
2821
2822   undobuf.undos = 0;
2823 }
2824
2825 /* We've committed to accepting the changes we made.  Move all
2826    of the undos to the free list.  */
2827
2828 static void
2829 undo_commit (void)
2830 {
2831   struct undo *undo, *next;
2832
2833   for (undo = undobuf.undos; undo; undo = next)
2834     {
2835       next = undo->next;
2836       undo->next = undobuf.frees;
2837       undobuf.frees = undo;
2838     }
2839   undobuf.undos = 0;
2840 }
2841
2842 \f
2843 /* Find the innermost point within the rtx at LOC, possibly LOC itself,
2844    where we have an arithmetic expression and return that point.  LOC will
2845    be inside INSN.
2846
2847    try_combine will call this function to see if an insn can be split into
2848    two insns.  */
2849
2850 static rtx *
2851 find_split_point (rtx *loc, rtx insn)
2852 {
2853   rtx x = *loc;
2854   enum rtx_code code = GET_CODE (x);
2855   rtx *split;
2856   unsigned HOST_WIDE_INT len = 0;
2857   HOST_WIDE_INT pos = 0;
2858   int unsignedp = 0;
2859   rtx inner = NULL_RTX;
2860
2861   /* First special-case some codes.  */
2862   switch (code)
2863     {
2864     case SUBREG:
2865 #ifdef INSN_SCHEDULING
2866       /* If we are making a paradoxical SUBREG invalid, it becomes a split
2867          point.  */
2868       if (GET_CODE (SUBREG_REG (x)) == MEM)
2869         return loc;
2870 #endif
2871       return find_split_point (&SUBREG_REG (x), insn);
2872
2873     case MEM:
2874 #ifdef HAVE_lo_sum
2875       /* If we have (mem (const ..)) or (mem (symbol_ref ...)), split it
2876          using LO_SUM and HIGH.  */
2877       if (GET_CODE (XEXP (x, 0)) == CONST
2878           || GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
2879         {
2880           SUBST (XEXP (x, 0),
2881                  gen_rtx_LO_SUM (Pmode,
2882                                  gen_rtx_HIGH (Pmode, XEXP (x, 0)),
2883                                  XEXP (x, 0)));
2884           return &XEXP (XEXP (x, 0), 0);
2885         }
2886 #endif
2887
2888       /* If we have a PLUS whose second operand is a constant and the
2889          address is not valid, perhaps will can split it up using
2890          the machine-specific way to split large constants.  We use
2891          the first pseudo-reg (one of the virtual regs) as a placeholder;
2892          it will not remain in the result.  */
2893       if (GET_CODE (XEXP (x, 0)) == PLUS
2894           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
2895           && ! memory_address_p (GET_MODE (x), XEXP (x, 0)))
2896         {
2897           rtx reg = regno_reg_rtx[FIRST_PSEUDO_REGISTER];
2898           rtx seq = split_insns (gen_rtx_SET (VOIDmode, reg, XEXP (x, 0)),
2899                                  subst_insn);
2900
2901           /* This should have produced two insns, each of which sets our
2902              placeholder.  If the source of the second is a valid address,
2903              we can make put both sources together and make a split point
2904              in the middle.  */
2905
2906           if (seq
2907               && NEXT_INSN (seq) != NULL_RTX
2908               && NEXT_INSN (NEXT_INSN (seq)) == NULL_RTX
2909               && GET_CODE (seq) == INSN
2910               && GET_CODE (PATTERN (seq)) == SET
2911               && SET_DEST (PATTERN (seq)) == reg
2912               && ! reg_mentioned_p (reg,
2913                                     SET_SRC (PATTERN (seq)))
2914               && GET_CODE (NEXT_INSN (seq)) == INSN
2915               && GET_CODE (PATTERN (NEXT_INSN (seq))) == SET
2916               && SET_DEST (PATTERN (NEXT_INSN (seq))) == reg
2917               && memory_address_p (GET_MODE (x),
2918                                    SET_SRC (PATTERN (NEXT_INSN (seq)))))
2919             {
2920               rtx src1 = SET_SRC (PATTERN (seq));
2921               rtx src2 = SET_SRC (PATTERN (NEXT_INSN (seq)));
2922
2923               /* Replace the placeholder in SRC2 with SRC1.  If we can
2924                  find where in SRC2 it was placed, that can become our
2925                  split point and we can replace this address with SRC2.
2926                  Just try two obvious places.  */
2927
2928               src2 = replace_rtx (src2, reg, src1);
2929               split = 0;
2930               if (XEXP (src2, 0) == src1)
2931                 split = &XEXP (src2, 0);
2932               else if (GET_RTX_FORMAT (GET_CODE (XEXP (src2, 0)))[0] == 'e'
2933                        && XEXP (XEXP (src2, 0), 0) == src1)
2934                 split = &XEXP (XEXP (src2, 0), 0);
2935
2936               if (split)
2937                 {
2938                   SUBST (XEXP (x, 0), src2);
2939                   return split;
2940                 }
2941             }
2942
2943           /* If that didn't work, perhaps the first operand is complex and
2944              needs to be computed separately, so make a split point there.
2945              This will occur on machines that just support REG + CONST
2946              and have a constant moved through some previous computation.  */
2947
2948           else if (GET_RTX_CLASS (GET_CODE (XEXP (XEXP (x, 0), 0))) != 'o'
2949                    && ! (GET_CODE (XEXP (XEXP (x, 0), 0)) == SUBREG
2950                          && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (XEXP (x, 0), 0))))
2951                              == 'o')))
2952             return &XEXP (XEXP (x, 0), 0);
2953         }
2954       break;
2955
2956     case SET:
2957 #ifdef HAVE_cc0
2958       /* If SET_DEST is CC0 and SET_SRC is not an operand, a COMPARE, or a
2959          ZERO_EXTRACT, the most likely reason why this doesn't match is that
2960          we need to put the operand into a register.  So split at that
2961          point.  */
2962
2963       if (SET_DEST (x) == cc0_rtx
2964           && GET_CODE (SET_SRC (x)) != COMPARE
2965           && GET_CODE (SET_SRC (x)) != ZERO_EXTRACT
2966           && GET_RTX_CLASS (GET_CODE (SET_SRC (x))) != 'o'
2967           && ! (GET_CODE (SET_SRC (x)) == SUBREG
2968                 && GET_RTX_CLASS (GET_CODE (SUBREG_REG (SET_SRC (x)))) == 'o'))
2969         return &SET_SRC (x);
2970 #endif
2971
2972       /* See if we can split SET_SRC as it stands.  */
2973       split = find_split_point (&SET_SRC (x), insn);
2974       if (split && split != &SET_SRC (x))
2975         return split;
2976
2977       /* See if we can split SET_DEST as it stands.  */
2978       split = find_split_point (&SET_DEST (x), insn);
2979       if (split && split != &SET_DEST (x))
2980         return split;
2981
2982       /* See if this is a bitfield assignment with everything constant.  If
2983          so, this is an IOR of an AND, so split it into that.  */
2984       if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
2985           && (GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)))
2986               <= HOST_BITS_PER_WIDE_INT)
2987           && GET_CODE (XEXP (SET_DEST (x), 1)) == CONST_INT
2988           && GET_CODE (XEXP (SET_DEST (x), 2)) == CONST_INT
2989           && GET_CODE (SET_SRC (x)) == CONST_INT
2990           && ((INTVAL (XEXP (SET_DEST (x), 1))
2991                + INTVAL (XEXP (SET_DEST (x), 2)))
2992               <= GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0))))
2993           && ! side_effects_p (XEXP (SET_DEST (x), 0)))
2994         {
2995           HOST_WIDE_INT pos = INTVAL (XEXP (SET_DEST (x), 2));
2996           unsigned HOST_WIDE_INT len = INTVAL (XEXP (SET_DEST (x), 1));
2997           unsigned HOST_WIDE_INT src = INTVAL (SET_SRC (x));
2998           rtx dest = XEXP (SET_DEST (x), 0);
2999           enum machine_mode mode = GET_MODE (dest);
3000           unsigned HOST_WIDE_INT mask = ((HOST_WIDE_INT) 1 << len) - 1;
3001
3002           if (BITS_BIG_ENDIAN)
3003             pos = GET_MODE_BITSIZE (mode) - len - pos;
3004
3005           if (src == mask)
3006             SUBST (SET_SRC (x),
3007                    gen_binary (IOR, mode, dest, GEN_INT (src << pos)));
3008           else
3009             SUBST (SET_SRC (x),
3010                    gen_binary (IOR, mode,
3011                                gen_binary (AND, mode, dest,
3012                                            gen_int_mode (~(mask << pos),
3013                                                          mode)),
3014                                GEN_INT (src << pos)));
3015
3016           SUBST (SET_DEST (x), dest);
3017
3018           split = find_split_point (&SET_SRC (x), insn);
3019           if (split && split != &SET_SRC (x))
3020             return split;
3021         }
3022
3023       /* Otherwise, see if this is an operation that we can split into two.
3024          If so, try to split that.  */
3025       code = GET_CODE (SET_SRC (x));
3026
3027       switch (code)
3028         {
3029         case AND:
3030           /* If we are AND'ing with a large constant that is only a single
3031              bit and the result is only being used in a context where we
3032              need to know if it is zero or nonzero, replace it with a bit
3033              extraction.  This will avoid the large constant, which might
3034              have taken more than one insn to make.  If the constant were
3035              not a valid argument to the AND but took only one insn to make,
3036              this is no worse, but if it took more than one insn, it will
3037              be better.  */
3038
3039           if (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
3040               && GET_CODE (XEXP (SET_SRC (x), 0)) == REG
3041               && (pos = exact_log2 (INTVAL (XEXP (SET_SRC (x), 1)))) >= 7
3042               && GET_CODE (SET_DEST (x)) == REG
3043               && (split = find_single_use (SET_DEST (x), insn, (rtx*) 0)) != 0
3044               && (GET_CODE (*split) == EQ || GET_CODE (*split) == NE)
3045               && XEXP (*split, 0) == SET_DEST (x)
3046               && XEXP (*split, 1) == const0_rtx)
3047             {
3048               rtx extraction = make_extraction (GET_MODE (SET_DEST (x)),
3049                                                 XEXP (SET_SRC (x), 0),
3050                                                 pos, NULL_RTX, 1, 1, 0, 0);
3051               if (extraction != 0)
3052                 {
3053                   SUBST (SET_SRC (x), extraction);
3054                   return find_split_point (loc, insn);
3055                 }
3056             }
3057           break;
3058
3059         case NE:
3060           /* if STORE_FLAG_VALUE is -1, this is (NE X 0) and only one bit of X
3061              is known to be on, this can be converted into a NEG of a shift.  */
3062           if (STORE_FLAG_VALUE == -1 && XEXP (SET_SRC (x), 1) == const0_rtx
3063               && GET_MODE (SET_SRC (x)) == GET_MODE (XEXP (SET_SRC (x), 0))
3064               && 1 <= (pos = exact_log2
3065                        (nonzero_bits (XEXP (SET_SRC (x), 0),
3066                                       GET_MODE (XEXP (SET_SRC (x), 0))))))
3067             {
3068               enum machine_mode mode = GET_MODE (XEXP (SET_SRC (x), 0));
3069
3070               SUBST (SET_SRC (x),
3071                      gen_rtx_NEG (mode,
3072                                   gen_rtx_LSHIFTRT (mode,
3073                                                     XEXP (SET_SRC (x), 0),
3074                                                     GEN_INT (pos))));
3075
3076               split = find_split_point (&SET_SRC (x), insn);
3077               if (split && split != &SET_SRC (x))
3078                 return split;
3079             }
3080           break;
3081
3082         case SIGN_EXTEND:
3083           inner = XEXP (SET_SRC (x), 0);
3084
3085           /* We can't optimize if either mode is a partial integer
3086              mode as we don't know how many bits are significant
3087              in those modes.  */
3088           if (GET_MODE_CLASS (GET_MODE (inner)) == MODE_PARTIAL_INT
3089               || GET_MODE_CLASS (GET_MODE (SET_SRC (x))) == MODE_PARTIAL_INT)
3090             break;
3091
3092           pos = 0;
3093           len = GET_MODE_BITSIZE (GET_MODE (inner));
3094           unsignedp = 0;
3095           break;
3096
3097         case SIGN_EXTRACT:
3098         case ZERO_EXTRACT:
3099           if (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
3100               && GET_CODE (XEXP (SET_SRC (x), 2)) == CONST_INT)
3101             {
3102               inner = XEXP (SET_SRC (x), 0);
3103               len = INTVAL (XEXP (SET_SRC (x), 1));
3104               pos = INTVAL (XEXP (SET_SRC (x), 2));
3105
3106               if (BITS_BIG_ENDIAN)
3107                 pos = GET_MODE_BITSIZE (GET_MODE (inner)) - len - pos;
3108               unsignedp = (code == ZERO_EXTRACT);
3109             }
3110           break;
3111
3112         default:
3113           break;
3114         }
3115
3116       if (len && pos >= 0 && pos + len <= GET_MODE_BITSIZE (GET_MODE (inner)))
3117         {
3118           enum machine_mode mode = GET_MODE (SET_SRC (x));
3119
3120           /* For unsigned, we have a choice of a shift followed by an
3121              AND or two shifts.  Use two shifts for field sizes where the
3122              constant might be too large.  We assume here that we can
3123              always at least get 8-bit constants in an AND insn, which is
3124              true for every current RISC.  */
3125
3126           if (unsignedp && len <= 8)
3127             {
3128               SUBST (SET_SRC (x),
3129                      gen_rtx_AND (mode,
3130                                   gen_rtx_LSHIFTRT
3131                                   (mode, gen_lowpart_for_combine (mode, inner),
3132                                    GEN_INT (pos)),
3133                                   GEN_INT (((HOST_WIDE_INT) 1 << len) - 1)));
3134
3135               split = find_split_point (&SET_SRC (x), insn);
3136               if (split && split != &SET_SRC (x))
3137                 return split;
3138             }
3139           else
3140             {
3141               SUBST (SET_SRC (x),
3142                      gen_rtx_fmt_ee
3143                      (unsignedp ? LSHIFTRT : ASHIFTRT, mode,
3144                       gen_rtx_ASHIFT (mode,
3145                                       gen_lowpart_for_combine (mode, inner),
3146                                       GEN_INT (GET_MODE_BITSIZE (mode)
3147                                                - len - pos)),
3148                       GEN_INT (GET_MODE_BITSIZE (mode) - len)));
3149
3150               split = find_split_point (&SET_SRC (x), insn);
3151               if (split && split != &SET_SRC (x))
3152                 return split;
3153             }
3154         }
3155
3156       /* See if this is a simple operation with a constant as the second
3157          operand.  It might be that this constant is out of range and hence
3158          could be used as a split point.  */
3159       if ((GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == '2'
3160            || GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == 'c'
3161            || GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == '<')
3162           && CONSTANT_P (XEXP (SET_SRC (x), 1))
3163           && (GET_RTX_CLASS (GET_CODE (XEXP (SET_SRC (x), 0))) == 'o'
3164               || (GET_CODE (XEXP (SET_SRC (x), 0)) == SUBREG
3165                   && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (SET_SRC (x), 0))))
3166                       == 'o'))))
3167         return &XEXP (SET_SRC (x), 1);
3168
3169       /* Finally, see if this is a simple operation with its first operand
3170          not in a register.  The operation might require this operand in a
3171          register, so return it as a split point.  We can always do this
3172          because if the first operand were another operation, we would have
3173          already found it as a split point.  */
3174       if ((GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == '2'
3175            || GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == 'c'
3176            || GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == '<'
3177            || GET_RTX_CLASS (GET_CODE (SET_SRC (x))) == '1')
3178           && ! register_operand (XEXP (SET_SRC (x), 0), VOIDmode))
3179         return &XEXP (SET_SRC (x), 0);
3180
3181       return 0;
3182
3183     case AND:
3184     case IOR:
3185       /* We write NOR as (and (not A) (not B)), but if we don't have a NOR,
3186          it is better to write this as (not (ior A B)) so we can split it.
3187          Similarly for IOR.  */
3188       if (GET_CODE (XEXP (x, 0)) == NOT && GET_CODE (XEXP (x, 1)) == NOT)
3189         {
3190           SUBST (*loc,
3191                  gen_rtx_NOT (GET_MODE (x),
3192                               gen_rtx_fmt_ee (code == IOR ? AND : IOR,
3193                                               GET_MODE (x),
3194                                               XEXP (XEXP (x, 0), 0),
3195                                               XEXP (XEXP (x, 1), 0))));
3196           return find_split_point (loc, insn);
3197         }
3198
3199       /* Many RISC machines have a large set of logical insns.  If the
3200          second operand is a NOT, put it first so we will try to split the
3201          other operand first.  */
3202       if (GET_CODE (XEXP (x, 1)) == NOT)
3203         {
3204           rtx tem = XEXP (x, 0);
3205           SUBST (XEXP (x, 0), XEXP (x, 1));
3206           SUBST (XEXP (x, 1), tem);
3207         }
3208       break;
3209
3210     default:
3211       break;
3212     }
3213
3214   /* Otherwise, select our actions depending on our rtx class.  */
3215   switch (GET_RTX_CLASS (code))
3216     {
3217     case 'b':                   /* This is ZERO_EXTRACT and SIGN_EXTRACT.  */
3218     case '3':
3219       split = find_split_point (&XEXP (x, 2), insn);
3220       if (split)
3221         return split;
3222       /* ... fall through ...  */
3223     case '2':
3224     case 'c':
3225     case '<':
3226       split = find_split_point (&XEXP (x, 1), insn);
3227       if (split)
3228         return split;
3229       /* ... fall through ...  */
3230     case '1':
3231       /* Some machines have (and (shift ...) ...) insns.  If X is not
3232          an AND, but XEXP (X, 0) is, use it as our split point.  */
3233       if (GET_CODE (x) != AND && GET_CODE (XEXP (x, 0)) == AND)
3234         return &XEXP (x, 0);
3235
3236       split = find_split_point (&XEXP (x, 0), insn);
3237       if (split)
3238         return split;
3239       return loc;
3240     }
3241
3242   /* Otherwise, we don't have a split point.  */
3243   return 0;
3244 }
3245 \f
3246 /* Throughout X, replace FROM with TO, and return the result.
3247    The result is TO if X is FROM;
3248    otherwise the result is X, but its contents may have been modified.
3249    If they were modified, a record was made in undobuf so that
3250    undo_all will (among other things) return X to its original state.
3251
3252    If the number of changes necessary is too much to record to undo,
3253    the excess changes are not made, so the result is invalid.
3254    The changes already made can still be undone.
3255    undobuf.num_undo is incremented for such changes, so by testing that
3256    the caller can tell whether the result is valid.
3257
3258    `n_occurrences' is incremented each time FROM is replaced.
3259
3260    IN_DEST is nonzero if we are processing the SET_DEST of a SET.
3261
3262    UNIQUE_COPY is nonzero if each substitution must be unique.  We do this
3263    by copying if `n_occurrences' is nonzero.  */
3264
3265 static rtx
3266 subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
3267 {
3268   enum rtx_code code = GET_CODE (x);
3269   enum machine_mode op0_mode = VOIDmode;
3270   const char *fmt;
3271   int len, i;
3272   rtx new;
3273
3274 /* Two expressions are equal if they are identical copies of a shared
3275    RTX or if they are both registers with the same register number
3276    and mode.  */
3277
3278 #define COMBINE_RTX_EQUAL_P(X,Y)                        \
3279   ((X) == (Y)                                           \
3280    || (GET_CODE (X) == REG && GET_CODE (Y) == REG       \
3281        && REGNO (X) == REGNO (Y) && GET_MODE (X) == GET_MODE (Y)))
3282
3283   if (! in_dest && COMBINE_RTX_EQUAL_P (x, from))
3284     {
3285       n_occurrences++;
3286       return (unique_copy && n_occurrences > 1 ? copy_rtx (to) : to);
3287     }
3288
3289   /* If X and FROM are the same register but different modes, they will
3290      not have been seen as equal above.  However, flow.c will make a
3291      LOG_LINKS entry for that case.  If we do nothing, we will try to
3292      rerecognize our original insn and, when it succeeds, we will
3293      delete the feeding insn, which is incorrect.
3294
3295      So force this insn not to match in this (rare) case.  */
3296   if (! in_dest && code == REG && GET_CODE (from) == REG
3297       && REGNO (x) == REGNO (from))
3298     return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
3299
3300   /* If this is an object, we are done unless it is a MEM or LO_SUM, both
3301      of which may contain things that can be combined.  */
3302   if (code != MEM && code != LO_SUM && GET_RTX_CLASS (code) == 'o')
3303     return x;
3304
3305   /* It is possible to have a subexpression appear twice in the insn.
3306      Suppose that FROM is a register that appears within TO.
3307      Then, after that subexpression has been scanned once by `subst',
3308      the second time it is scanned, TO may be found.  If we were
3309      to scan TO here, we would find FROM within it and create a
3310      self-referent rtl structure which is completely wrong.  */
3311   if (COMBINE_RTX_EQUAL_P (x, to))
3312     return to;
3313
3314   /* Parallel asm_operands need special attention because all of the
3315      inputs are shared across the arms.  Furthermore, unsharing the
3316      rtl results in recognition failures.  Failure to handle this case
3317      specially can result in circular rtl.
3318
3319      Solve this by doing a normal pass across the first entry of the
3320      parallel, and only processing the SET_DESTs of the subsequent
3321      entries.  Ug.  */
3322
3323   if (code == PARALLEL
3324       && GET_CODE (XVECEXP (x, 0, 0)) == SET
3325       && GET_CODE (SET_SRC (XVECEXP (x, 0, 0))) == ASM_OPERANDS)
3326     {
3327       new = subst (XVECEXP (x, 0, 0), from, to, 0, unique_copy);
3328
3329       /* If this substitution failed, this whole thing fails.  */
3330       if (GET_CODE (new) == CLOBBER
3331           && XEXP (new, 0) == const0_rtx)
3332         return new;
3333
3334       SUBST (XVECEXP (x, 0, 0), new);
3335
3336       for (i = XVECLEN (x, 0) - 1; i >= 1; i--)
3337         {
3338           rtx dest = SET_DEST (XVECEXP (x, 0, i));
3339
3340           if (GET_CODE (dest) != REG
3341               && GET_CODE (dest) != CC0
3342               && GET_CODE (dest) != PC)
3343             {
3344               new = subst (dest, from, to, 0, unique_copy);
3345
3346               /* If this substitution failed, this whole thing fails.  */
3347               if (GET_CODE (new) == CLOBBER
3348                   && XEXP (new, 0) == const0_rtx)
3349                 return new;
3350
3351               SUBST (SET_DEST (XVECEXP (x, 0, i)), new);
3352             }
3353         }
3354     }
3355   else
3356     {
3357       len = GET_RTX_LENGTH (code);
3358       fmt = GET_RTX_FORMAT (code);
3359
3360       /* We don't need to process a SET_DEST that is a register, CC0,
3361          or PC, so set up to skip this common case.  All other cases
3362          where we want to suppress replacing something inside a
3363          SET_SRC are handled via the IN_DEST operand.  */
3364       if (code == SET
3365           && (GET_CODE (SET_DEST (x)) == REG
3366               || GET_CODE (SET_DEST (x)) == CC0
3367               || GET_CODE (SET_DEST (x)) == PC))
3368         fmt = "ie";
3369
3370       /* Get the mode of operand 0 in case X is now a SIGN_EXTEND of a
3371          constant.  */
3372       if (fmt[0] == 'e')
3373         op0_mode = GET_MODE (XEXP (x, 0));
3374
3375       for (i = 0; i < len; i++)
3376         {
3377           if (fmt[i] == 'E')
3378             {
3379               int j;
3380               for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3381                 {
3382                   if (COMBINE_RTX_EQUAL_P (XVECEXP (x, i, j), from))
3383                     {
3384                       new = (unique_copy && n_occurrences
3385                              ? copy_rtx (to) : to);
3386                       n_occurrences++;
3387                     }
3388                   else
3389                     {
3390                       new = subst (XVECEXP (x, i, j), from, to, 0,
3391                                    unique_copy);
3392
3393                       /* If this substitution failed, this whole thing
3394                          fails.  */
3395                       if (GET_CODE (new) == CLOBBER
3396                           && XEXP (new, 0) == const0_rtx)
3397                         return new;
3398                     }
3399
3400                   SUBST (XVECEXP (x, i, j), new);
3401                 }
3402             }
3403           else if (fmt[i] == 'e')
3404             {
3405               /* If this is a register being set, ignore it.  */
3406               new = XEXP (x, i);
3407               if (in_dest
3408                   && (code == SUBREG || code == STRICT_LOW_PART
3409                       || code == ZERO_EXTRACT)
3410                   && i == 0
3411                   && GET_CODE (new) == REG)
3412                 ;
3413
3414               else if (COMBINE_RTX_EQUAL_P (XEXP (x, i), from))
3415                 {
3416                   /* In general, don't install a subreg involving two
3417                      modes not tieable.  It can worsen register
3418                      allocation, and can even make invalid reload
3419                      insns, since the reg inside may need to be copied
3420                      from in the outside mode, and that may be invalid
3421                      if it is an fp reg copied in integer mode.
3422
3423                      We allow two exceptions to this: It is valid if
3424                      it is inside another SUBREG and the mode of that
3425                      SUBREG and the mode of the inside of TO is
3426                      tieable and it is valid if X is a SET that copies
3427                      FROM to CC0.  */
3428
3429                   if (GET_CODE (to) == SUBREG
3430                       && ! MODES_TIEABLE_P (GET_MODE (to),
3431                                             GET_MODE (SUBREG_REG (to)))
3432                       && ! (code == SUBREG
3433                             && MODES_TIEABLE_P (GET_MODE (x),
3434                                                 GET_MODE (SUBREG_REG (to))))
3435 #ifdef HAVE_cc0
3436                       && ! (code == SET && i == 1 && XEXP (x, 0) == cc0_rtx)
3437 #endif
3438                       )
3439                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
3440
3441 #ifdef CANNOT_CHANGE_MODE_CLASS
3442                   if (code == SUBREG
3443                       && GET_CODE (to) == REG
3444                       && REGNO (to) < FIRST_PSEUDO_REGISTER
3445                       && REG_CANNOT_CHANGE_MODE_P (REGNO (to),
3446                                                    GET_MODE (to),
3447                                                    GET_MODE (x)))
3448                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
3449 #endif
3450
3451                   new = (unique_copy && n_occurrences ? copy_rtx (to) : to);
3452                   n_occurrences++;
3453                 }
3454               else
3455                 /* If we are in a SET_DEST, suppress most cases unless we
3456                    have gone inside a MEM, in which case we want to
3457                    simplify the address.  We assume here that things that
3458                    are actually part of the destination have their inner
3459                    parts in the first expression.  This is true for SUBREG,
3460                    STRICT_LOW_PART, and ZERO_EXTRACT, which are the only
3461                    things aside from REG and MEM that should appear in a
3462                    SET_DEST.  */
3463                 new = subst (XEXP (x, i), from, to,
3464                              (((in_dest
3465                                 && (code == SUBREG || code == STRICT_LOW_PART
3466                                     || code == ZERO_EXTRACT))
3467                                || code == SET)
3468                               && i == 0), unique_copy);
3469
3470               /* If we found that we will have to reject this combination,
3471                  indicate that by returning the CLOBBER ourselves, rather than
3472                  an expression containing it.  This will speed things up as
3473                  well as prevent accidents where two CLOBBERs are considered
3474                  to be equal, thus producing an incorrect simplification.  */
3475
3476               if (GET_CODE (new) == CLOBBER && XEXP (new, 0) == const0_rtx)
3477                 return new;
3478
3479               if (GET_CODE (new) == CONST_INT && GET_CODE (x) == SUBREG)
3480                 {
3481                   enum machine_mode mode = GET_MODE (x);
3482
3483                   x = simplify_subreg (GET_MODE (x), new,
3484                                        GET_MODE (SUBREG_REG (x)),
3485                                        SUBREG_BYTE (x));
3486                   if (! x)
3487                     x = gen_rtx_CLOBBER (mode, const0_rtx);
3488                 }
3489               else if (GET_CODE (new) == CONST_INT
3490                        && GET_CODE (x) == ZERO_EXTEND)
3491                 {
3492                   x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
3493                                                 new, GET_MODE (XEXP (x, 0)));
3494                   if (! x)
3495                     abort ();
3496                 }
3497               else
3498                 SUBST (XEXP (x, i), new);
3499             }
3500         }
3501     }
3502
3503   /* Try to simplify X.  If the simplification changed the code, it is likely
3504      that further simplification will help, so loop, but limit the number
3505      of repetitions that will be performed.  */
3506
3507   for (i = 0; i < 4; i++)
3508     {
3509       /* If X is sufficiently simple, don't bother trying to do anything
3510          with it.  */
3511       if (code != CONST_INT && code != REG && code != CLOBBER)
3512         x = combine_simplify_rtx (x, op0_mode, i == 3, in_dest);
3513
3514       if (GET_CODE (x) == code)
3515         break;
3516
3517       code = GET_CODE (x);
3518
3519       /* We no longer know the original mode of operand 0 since we
3520          have changed the form of X)  */
3521       op0_mode = VOIDmode;
3522     }
3523
3524   return x;
3525 }
3526 \f
3527 /* Simplify X, a piece of RTL.  We just operate on the expression at the
3528    outer level; call `subst' to simplify recursively.  Return the new
3529    expression.
3530
3531    OP0_MODE is the original mode of XEXP (x, 0); LAST is nonzero if this
3532    will be the iteration even if an expression with a code different from
3533    X is returned; IN_DEST is nonzero if we are inside a SET_DEST.  */
3534
3535 static rtx
3536 combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int last,
3537                       int in_dest)
3538 {
3539   enum rtx_code code = GET_CODE (x);
3540   enum machine_mode mode = GET_MODE (x);
3541   rtx temp;
3542   rtx reversed;
3543   int i;
3544
3545   /* If this is a commutative operation, put a constant last and a complex
3546      expression first.  We don't need to do this for comparisons here.  */
3547   if (GET_RTX_CLASS (code) == 'c'
3548       && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
3549     {
3550       temp = XEXP (x, 0);
3551       SUBST (XEXP (x, 0), XEXP (x, 1));
3552       SUBST (XEXP (x, 1), temp);
3553     }
3554
3555   /* If this is a PLUS, MINUS, or MULT, and the first operand is the
3556      sign extension of a PLUS with a constant, reverse the order of the sign
3557      extension and the addition. Note that this not the same as the original
3558      code, but overflow is undefined for signed values.  Also note that the
3559      PLUS will have been partially moved "inside" the sign-extension, so that
3560      the first operand of X will really look like:
3561          (ashiftrt (plus (ashift A C4) C5) C4).
3562      We convert this to
3563          (plus (ashiftrt (ashift A C4) C2) C4)
3564      and replace the first operand of X with that expression.  Later parts
3565      of this function may simplify the expression further.
3566
3567      For example, if we start with (mult (sign_extend (plus A C1)) C2),
3568      we swap the SIGN_EXTEND and PLUS.  Later code will apply the
3569      distributive law to produce (plus (mult (sign_extend X) C1) C3).
3570
3571      We do this to simplify address expressions.  */
3572
3573   if ((code == PLUS || code == MINUS || code == MULT)
3574       && GET_CODE (XEXP (x, 0)) == ASHIFTRT
3575       && GET_CODE (XEXP (XEXP (x, 0), 0)) == PLUS
3576       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == ASHIFT
3577       && GET_CODE (XEXP (XEXP (XEXP (XEXP (x, 0), 0), 0), 1)) == CONST_INT
3578       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3579       && XEXP (XEXP (XEXP (XEXP (x, 0), 0), 0), 1) == XEXP (XEXP (x, 0), 1)
3580       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
3581       && (temp = simplify_binary_operation (ASHIFTRT, mode,
3582                                             XEXP (XEXP (XEXP (x, 0), 0), 1),
3583                                             XEXP (XEXP (x, 0), 1))) != 0)
3584     {
3585       rtx new
3586         = simplify_shift_const (NULL_RTX, ASHIFT, mode,
3587                                 XEXP (XEXP (XEXP (XEXP (x, 0), 0), 0), 0),
3588                                 INTVAL (XEXP (XEXP (x, 0), 1)));
3589
3590       new = simplify_shift_const (NULL_RTX, ASHIFTRT, mode, new,
3591                                   INTVAL (XEXP (XEXP (x, 0), 1)));
3592
3593       SUBST (XEXP (x, 0), gen_binary (PLUS, mode, new, temp));
3594     }
3595
3596   /* If this is a simple operation applied to an IF_THEN_ELSE, try
3597      applying it to the arms of the IF_THEN_ELSE.  This often simplifies
3598      things.  Check for cases where both arms are testing the same
3599      condition.
3600
3601      Don't do anything if all operands are very simple.  */
3602
3603   if (((GET_RTX_CLASS (code) == '2' || GET_RTX_CLASS (code) == 'c'
3604         || GET_RTX_CLASS (code) == '<')
3605        && ((GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) != 'o'
3606             && ! (GET_CODE (XEXP (x, 0)) == SUBREG
3607                   && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (x, 0))))
3608                       == 'o')))
3609            || (GET_RTX_CLASS (GET_CODE (XEXP (x, 1))) != 'o'
3610                && ! (GET_CODE (XEXP (x, 1)) == SUBREG
3611                      && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (x, 1))))
3612                          == 'o')))))
3613       || (GET_RTX_CLASS (code) == '1'
3614           && ((GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) != 'o'
3615                && ! (GET_CODE (XEXP (x, 0)) == SUBREG
3616                      && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (x, 0))))
3617                          == 'o'))))))
3618     {
3619       rtx cond, true_rtx, false_rtx;
3620
3621       cond = if_then_else_cond (x, &true_rtx, &false_rtx);
3622       if (cond != 0
3623           /* If everything is a comparison, what we have is highly unlikely
3624              to be simpler, so don't use it.  */
3625           && ! (GET_RTX_CLASS (code) == '<'
3626                 && (GET_RTX_CLASS (GET_CODE (true_rtx)) == '<'
3627                     || GET_RTX_CLASS (GET_CODE (false_rtx)) == '<')))
3628         {
3629           rtx cop1 = const0_rtx;
3630           enum rtx_code cond_code = simplify_comparison (NE, &cond, &cop1);
3631
3632           if (cond_code == NE && GET_RTX_CLASS (GET_CODE (cond)) == '<')
3633             return x;
3634
3635           /* Simplify the alternative arms; this may collapse the true and
3636              false arms to store-flag values.  */
3637           true_rtx = subst (true_rtx, pc_rtx, pc_rtx, 0, 0);
3638           false_rtx = subst (false_rtx, pc_rtx, pc_rtx, 0, 0);
3639
3640           /* If true_rtx and false_rtx are not general_operands, an if_then_else
3641              is unlikely to be simpler.  */
3642           if (general_operand (true_rtx, VOIDmode)
3643               && general_operand (false_rtx, VOIDmode))
3644             {
3645               enum rtx_code reversed;
3646
3647               /* Restarting if we generate a store-flag expression will cause
3648                  us to loop.  Just drop through in this case.  */
3649
3650               /* If the result values are STORE_FLAG_VALUE and zero, we can
3651                  just make the comparison operation.  */
3652               if (true_rtx == const_true_rtx && false_rtx == const0_rtx)
3653                 x = gen_binary (cond_code, mode, cond, cop1);
3654               else if (true_rtx == const0_rtx && false_rtx == const_true_rtx
3655                        && ((reversed = reversed_comparison_code_parts
3656                                         (cond_code, cond, cop1, NULL))
3657                            != UNKNOWN))
3658                 x = gen_binary (reversed, mode, cond, cop1);
3659
3660               /* Likewise, we can make the negate of a comparison operation
3661                  if the result values are - STORE_FLAG_VALUE and zero.  */
3662               else if (GET_CODE (true_rtx) == CONST_INT
3663                        && INTVAL (true_rtx) == - STORE_FLAG_VALUE
3664                        && false_rtx == const0_rtx)
3665                 x = simplify_gen_unary (NEG, mode,
3666                                         gen_binary (cond_code, mode, cond,
3667                                                     cop1),
3668                                         mode);
3669               else if (GET_CODE (false_rtx) == CONST_INT
3670                        && INTVAL (false_rtx) == - STORE_FLAG_VALUE
3671                        && true_rtx == const0_rtx
3672                        && ((reversed = reversed_comparison_code_parts
3673                                         (cond_code, cond, cop1, NULL))
3674                            != UNKNOWN))
3675                 x = simplify_gen_unary (NEG, mode,
3676                                         gen_binary (reversed, mode,
3677                                                     cond, cop1),
3678                                         mode);
3679               else
3680                 return gen_rtx_IF_THEN_ELSE (mode,
3681                                              gen_binary (cond_code, VOIDmode,
3682                                                          cond, cop1),
3683                                              true_rtx, false_rtx);
3684
3685               code = GET_CODE (x);
3686               op0_mode = VOIDmode;
3687             }
3688         }
3689     }
3690
3691   /* Try to fold this expression in case we have constants that weren't
3692      present before.  */
3693   temp = 0;
3694   switch (GET_RTX_CLASS (code))
3695     {
3696     case '1':
3697       temp = simplify_unary_operation (code, mode, XEXP (x, 0), op0_mode);
3698       break;
3699     case '<':
3700       {
3701         enum machine_mode cmp_mode = GET_MODE (XEXP (x, 0));
3702         if (cmp_mode == VOIDmode)
3703           {
3704             cmp_mode = GET_MODE (XEXP (x, 1));
3705             if (cmp_mode == VOIDmode)
3706               cmp_mode = op0_mode;
3707           }
3708         temp = simplify_relational_operation (code, cmp_mode,
3709                                               XEXP (x, 0), XEXP (x, 1));
3710       }
3711 #ifdef FLOAT_STORE_FLAG_VALUE
3712       if (temp != 0 && GET_MODE_CLASS (mode) == MODE_FLOAT)
3713         {
3714           if (temp == const0_rtx)
3715             temp = CONST0_RTX (mode);
3716           else
3717             temp = CONST_DOUBLE_FROM_REAL_VALUE (FLOAT_STORE_FLAG_VALUE (mode),
3718                                                  mode);
3719         }
3720 #endif
3721       break;
3722     case 'c':
3723     case '2':
3724       temp = simplify_binary_operation (code, mode, XEXP (x, 0), XEXP (x, 1));
3725       break;
3726     case 'b':
3727     case '3':
3728       temp = simplify_ternary_operation (code, mode, op0_mode, XEXP (x, 0),
3729                                          XEXP (x, 1), XEXP (x, 2));
3730       break;
3731     }
3732
3733   if (temp)
3734     {
3735       x = temp;
3736       code = GET_CODE (temp);
3737       op0_mode = VOIDmode;
3738       mode = GET_MODE (temp);
3739     }
3740
3741   /* First see if we can apply the inverse distributive law.  */
3742   if (code == PLUS || code == MINUS
3743       || code == AND || code == IOR || code == XOR)
3744     {
3745       x = apply_distributive_law (x);
3746       code = GET_CODE (x);
3747       op0_mode = VOIDmode;
3748     }
3749
3750   /* If CODE is an associative operation not otherwise handled, see if we
3751      can associate some operands.  This can win if they are constants or
3752      if they are logically related (i.e. (a & b) & a).  */
3753   if ((code == PLUS || code == MINUS || code == MULT || code == DIV
3754        || code == AND || code == IOR || code == XOR
3755        || code == SMAX || code == SMIN || code == UMAX || code == UMIN)
3756       && ((INTEGRAL_MODE_P (mode) && code != DIV)
3757           || (flag_unsafe_math_optimizations && FLOAT_MODE_P (mode))))
3758     {
3759       if (GET_CODE (XEXP (x, 0)) == code)
3760         {
3761           rtx other = XEXP (XEXP (x, 0), 0);
3762           rtx inner_op0 = XEXP (XEXP (x, 0), 1);
3763           rtx inner_op1 = XEXP (x, 1);
3764           rtx inner;
3765
3766           /* Make sure we pass the constant operand if any as the second
3767              one if this is a commutative operation.  */
3768           if (CONSTANT_P (inner_op0) && GET_RTX_CLASS (code) == 'c')
3769             {
3770               rtx tem = inner_op0;
3771               inner_op0 = inner_op1;
3772               inner_op1 = tem;
3773             }
3774           inner = simplify_binary_operation (code == MINUS ? PLUS
3775                                              : code == DIV ? MULT
3776                                              : code,
3777                                              mode, inner_op0, inner_op1);
3778
3779           /* For commutative operations, try the other pair if that one
3780              didn't simplify.  */
3781           if (inner == 0 && GET_RTX_CLASS (code) == 'c')
3782             {
3783               other = XEXP (XEXP (x, 0), 1);
3784               inner = simplify_binary_operation (code, mode,
3785                                                  XEXP (XEXP (x, 0), 0),
3786                                                  XEXP (x, 1));
3787             }
3788
3789           if (inner)
3790             return gen_binary (code, mode, other, inner);
3791         }
3792     }
3793
3794   /* A little bit of algebraic simplification here.  */
3795   switch (code)
3796     {
3797     case MEM:
3798       /* Ensure that our address has any ASHIFTs converted to MULT in case
3799          address-recognizing predicates are called later.  */
3800       temp = make_compound_operation (XEXP (x, 0), MEM);
3801       SUBST (XEXP (x, 0), temp);
3802       break;
3803
3804     case SUBREG:
3805       if (op0_mode == VOIDmode)
3806         op0_mode = GET_MODE (SUBREG_REG (x));
3807
3808       /* simplify_subreg can't use gen_lowpart_for_combine.  */
3809       if (CONSTANT_P (SUBREG_REG (x))
3810           && subreg_lowpart_offset (mode, op0_mode) == SUBREG_BYTE (x)
3811              /* Don't call gen_lowpart_for_combine if the inner mode
3812                 is VOIDmode and we cannot simplify it, as SUBREG without
3813                 inner mode is invalid.  */
3814           && (GET_MODE (SUBREG_REG (x)) != VOIDmode
3815               || gen_lowpart_common (mode, SUBREG_REG (x))))
3816         return gen_lowpart_for_combine (mode, SUBREG_REG (x));
3817
3818       if (GET_MODE_CLASS (GET_MODE (SUBREG_REG (x))) == MODE_CC)
3819         break;
3820       {
3821         rtx temp;
3822         temp = simplify_subreg (mode, SUBREG_REG (x), op0_mode,
3823                                 SUBREG_BYTE (x));
3824         if (temp)
3825           return temp;
3826       }
3827
3828       /* Don't change the mode of the MEM if that would change the meaning
3829          of the address.  */
3830       if (GET_CODE (SUBREG_REG (x)) == MEM
3831           && (MEM_VOLATILE_P (SUBREG_REG (x))
3832               || mode_dependent_address_p (XEXP (SUBREG_REG (x), 0))))
3833         return gen_rtx_CLOBBER (mode, const0_rtx);
3834
3835       /* Note that we cannot do any narrowing for non-constants since
3836          we might have been counting on using the fact that some bits were
3837          zero.  We now do this in the SET.  */
3838
3839       break;
3840
3841     case NOT:
3842       /* (not (plus X -1)) can become (neg X).  */
3843       if (GET_CODE (XEXP (x, 0)) == PLUS
3844           && XEXP (XEXP (x, 0), 1) == constm1_rtx)
3845         return gen_rtx_NEG (mode, XEXP (XEXP (x, 0), 0));
3846
3847       /* Similarly, (not (neg X)) is (plus X -1).  */
3848       if (GET_CODE (XEXP (x, 0)) == NEG)
3849         return gen_rtx_PLUS (mode, XEXP (XEXP (x, 0), 0), constm1_rtx);
3850
3851       /* (not (xor X C)) for C constant is (xor X D) with D = ~C.  */
3852       if (GET_CODE (XEXP (x, 0)) == XOR
3853           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3854           && (temp = simplify_unary_operation (NOT, mode,
3855                                                XEXP (XEXP (x, 0), 1),
3856                                                mode)) != 0)
3857         return gen_binary (XOR, mode, XEXP (XEXP (x, 0), 0), temp);
3858
3859       /* (not (ashift 1 X)) is (rotate ~1 X).  We used to do this for operands
3860          other than 1, but that is not valid.  We could do a similar
3861          simplification for (not (lshiftrt C X)) where C is just the sign bit,
3862          but this doesn't seem common enough to bother with.  */
3863       if (GET_CODE (XEXP (x, 0)) == ASHIFT
3864           && XEXP (XEXP (x, 0), 0) == const1_rtx)
3865         return gen_rtx_ROTATE (mode, simplify_gen_unary (NOT, mode,
3866                                                          const1_rtx, mode),
3867                                XEXP (XEXP (x, 0), 1));
3868
3869       if (GET_CODE (XEXP (x, 0)) == SUBREG
3870           && subreg_lowpart_p (XEXP (x, 0))
3871           && (GET_MODE_SIZE (GET_MODE (XEXP (x, 0)))
3872               < GET_MODE_SIZE (GET_MODE (SUBREG_REG (XEXP (x, 0)))))
3873           && GET_CODE (SUBREG_REG (XEXP (x, 0))) == ASHIFT
3874           && XEXP (SUBREG_REG (XEXP (x, 0)), 0) == const1_rtx)
3875         {
3876           enum machine_mode inner_mode = GET_MODE (SUBREG_REG (XEXP (x, 0)));
3877
3878           x = gen_rtx_ROTATE (inner_mode,
3879                               simplify_gen_unary (NOT, inner_mode, const1_rtx,
3880                                                   inner_mode),
3881                               XEXP (SUBREG_REG (XEXP (x, 0)), 1));
3882           return gen_lowpart_for_combine (mode, x);
3883         }
3884
3885       /* If STORE_FLAG_VALUE is -1, (not (comparison foo bar)) can be done by
3886          reversing the comparison code if valid.  */
3887       if (STORE_FLAG_VALUE == -1
3888           && GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) == '<'
3889           && (reversed = reversed_comparison (x, mode, XEXP (XEXP (x, 0), 0),
3890                                               XEXP (XEXP (x, 0), 1))))
3891         return reversed;
3892
3893       /* (not (ashiftrt foo C)) where C is the number of bits in FOO minus 1
3894          is (ge foo (const_int 0)) if STORE_FLAG_VALUE is -1, so we can
3895          perform the above simplification.  */
3896
3897       if (STORE_FLAG_VALUE == -1
3898           && GET_CODE (XEXP (x, 0)) == ASHIFTRT
3899           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3900           && INTVAL (XEXP (XEXP (x, 0), 1)) == GET_MODE_BITSIZE (mode) - 1)
3901         return gen_rtx_GE (mode, XEXP (XEXP (x, 0), 0), const0_rtx);
3902
3903       /* Apply De Morgan's laws to reduce number of patterns for machines
3904          with negating logical insns (and-not, nand, etc.).  If result has
3905          only one NOT, put it first, since that is how the patterns are
3906          coded.  */
3907
3908       if (GET_CODE (XEXP (x, 0)) == IOR || GET_CODE (XEXP (x, 0)) == AND)
3909         {
3910           rtx in1 = XEXP (XEXP (x, 0), 0), in2 = XEXP (XEXP (x, 0), 1);
3911           enum machine_mode op_mode;
3912
3913           op_mode = GET_MODE (in1);
3914           in1 = simplify_gen_unary (NOT, op_mode, in1, op_mode);
3915
3916           op_mode = GET_MODE (in2);
3917           if (op_mode == VOIDmode)
3918             op_mode = mode;
3919           in2 = simplify_gen_unary (NOT, op_mode, in2, op_mode);
3920
3921           if (GET_CODE (in2) == NOT && GET_CODE (in1) != NOT)
3922             {
3923               rtx tem = in2;
3924               in2 = in1; in1 = tem;
3925             }
3926
3927           return gen_rtx_fmt_ee (GET_CODE (XEXP (x, 0)) == IOR ? AND : IOR,
3928                                  mode, in1, in2);
3929         }
3930       break;
3931
3932     case NEG:
3933       /* (neg (plus X 1)) can become (not X).  */
3934       if (GET_CODE (XEXP (x, 0)) == PLUS
3935           && XEXP (XEXP (x, 0), 1) == const1_rtx)
3936         return gen_rtx_NOT (mode, XEXP (XEXP (x, 0), 0));
3937
3938       /* Similarly, (neg (not X)) is (plus X 1).  */
3939       if (GET_CODE (XEXP (x, 0)) == NOT)
3940         return plus_constant (XEXP (XEXP (x, 0), 0), 1);
3941
3942       /* (neg (minus X Y)) can become (minus Y X).  This transformation
3943          isn't safe for modes with signed zeros, since if X and Y are
3944          both +0, (minus Y X) is the same as (minus X Y).  If the rounding
3945          mode is towards +infinity (or -infinity) then the two expressions
3946          will be rounded differently.  */
3947       if (GET_CODE (XEXP (x, 0)) == MINUS
3948           && !HONOR_SIGNED_ZEROS (mode)
3949           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
3950         return gen_binary (MINUS, mode, XEXP (XEXP (x, 0), 1),
3951                            XEXP (XEXP (x, 0), 0));
3952
3953       /* (neg (plus A B)) is canonicalized to (minus (neg A) B).  */
3954       if (GET_CODE (XEXP (x, 0)) == PLUS
3955           && !HONOR_SIGNED_ZEROS (mode)
3956           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
3957         {
3958           temp = simplify_gen_unary (NEG, mode, XEXP (XEXP (x, 0), 0), mode);
3959           temp = combine_simplify_rtx (temp, mode, last, in_dest);
3960           return gen_binary (MINUS, mode, temp, XEXP (XEXP (x, 0), 1));
3961         }
3962
3963       /* (neg (mult A B)) becomes (mult (neg A) B).
3964          This works even for floating-point values.  */
3965       if (GET_CODE (XEXP (x, 0)) == MULT)
3966         {
3967           temp = simplify_gen_unary (NEG, mode, XEXP (XEXP (x, 0), 0), mode);
3968           return gen_binary (MULT, mode, temp, XEXP (XEXP (x, 0), 1));
3969         }
3970
3971       /* (neg (xor A 1)) is (plus A -1) if A is known to be either 0 or 1.  */
3972       if (GET_CODE (XEXP (x, 0)) == XOR && XEXP (XEXP (x, 0), 1) == const1_rtx
3973           && nonzero_bits (XEXP (XEXP (x, 0), 0), mode) == 1)
3974         return gen_binary (PLUS, mode, XEXP (XEXP (x, 0), 0), constm1_rtx);
3975
3976       /* NEG commutes with ASHIFT since it is multiplication.  Only do this
3977          if we can then eliminate the NEG (e.g.,
3978          if the operand is a constant).  */
3979
3980       if (GET_CODE (XEXP (x, 0)) == ASHIFT)
3981         {
3982           temp = simplify_unary_operation (NEG, mode,
3983                                            XEXP (XEXP (x, 0), 0), mode);
3984           if (temp)
3985             return gen_binary (ASHIFT, mode, temp, XEXP (XEXP (x, 0), 1));
3986         }
3987
3988       temp = expand_compound_operation (XEXP (x, 0));
3989
3990       /* For C equal to the width of MODE minus 1, (neg (ashiftrt X C)) can be
3991          replaced by (lshiftrt X C).  This will convert
3992          (neg (sign_extract X 1 Y)) to (zero_extract X 1 Y).  */
3993
3994       if (GET_CODE (temp) == ASHIFTRT
3995           && GET_CODE (XEXP (temp, 1)) == CONST_INT
3996           && INTVAL (XEXP (temp, 1)) == GET_MODE_BITSIZE (mode) - 1)
3997         return simplify_shift_const (temp, LSHIFTRT, mode, XEXP (temp, 0),
3998                                      INTVAL (XEXP (temp, 1)));
3999
4000       /* If X has only a single bit that might be nonzero, say, bit I, convert
4001          (neg X) to (ashiftrt (ashift X C-I) C-I) where C is the bitsize of
4002          MODE minus 1.  This will convert (neg (zero_extract X 1 Y)) to
4003          (sign_extract X 1 Y).  But only do this if TEMP isn't a register
4004          or a SUBREG of one since we'd be making the expression more
4005          complex if it was just a register.  */
4006
4007       if (GET_CODE (temp) != REG
4008           && ! (GET_CODE (temp) == SUBREG
4009                 && GET_CODE (SUBREG_REG (temp)) == REG)
4010           && (i = exact_log2 (nonzero_bits (temp, mode))) >= 0)
4011         {
4012           rtx temp1 = simplify_shift_const
4013             (NULL_RTX, ASHIFTRT, mode,
4014              simplify_shift_const (NULL_RTX, ASHIFT, mode, temp,
4015                                    GET_MODE_BITSIZE (mode) - 1 - i),
4016              GET_MODE_BITSIZE (mode) - 1 - i);
4017
4018           /* If all we did was surround TEMP with the two shifts, we
4019              haven't improved anything, so don't use it.  Otherwise,
4020              we are better off with TEMP1.  */
4021           if (GET_CODE (temp1) != ASHIFTRT
4022               || GET_CODE (XEXP (temp1, 0)) != ASHIFT
4023               || XEXP (XEXP (temp1, 0), 0) != temp)
4024             return temp1;
4025         }
4026       break;
4027
4028     case TRUNCATE:
4029       /* We can't handle truncation to a partial integer mode here
4030          because we don't know the real bitsize of the partial
4031          integer mode.  */
4032       if (GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
4033         break;
4034
4035       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4036           && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
4037                                     GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))))
4038         SUBST (XEXP (x, 0),
4039                force_to_mode (XEXP (x, 0), GET_MODE (XEXP (x, 0)),
4040                               GET_MODE_MASK (mode), NULL_RTX, 0));
4041
4042       /* (truncate:SI ({sign,zero}_extend:DI foo:SI)) == foo:SI.  */
4043       if ((GET_CODE (XEXP (x, 0)) == SIGN_EXTEND
4044            || GET_CODE (XEXP (x, 0)) == ZERO_EXTEND)
4045           && GET_MODE (XEXP (XEXP (x, 0), 0)) == mode)
4046         return XEXP (XEXP (x, 0), 0);
4047
4048       /* (truncate:SI (OP:DI ({sign,zero}_extend:DI foo:SI))) is
4049          (OP:SI foo:SI) if OP is NEG or ABS.  */
4050       if ((GET_CODE (XEXP (x, 0)) == ABS
4051            || GET_CODE (XEXP (x, 0)) == NEG)
4052           && (GET_CODE (XEXP (XEXP (x, 0), 0)) == SIGN_EXTEND
4053               || GET_CODE (XEXP (XEXP (x, 0), 0)) == ZERO_EXTEND)
4054           && GET_MODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == mode)
4055         return simplify_gen_unary (GET_CODE (XEXP (x, 0)), mode,
4056                                    XEXP (XEXP (XEXP (x, 0), 0), 0), mode);
4057
4058       /* (truncate:SI (subreg:DI (truncate:SI X) 0)) is
4059          (truncate:SI x).  */
4060       if (GET_CODE (XEXP (x, 0)) == SUBREG
4061           && GET_CODE (SUBREG_REG (XEXP (x, 0))) == TRUNCATE
4062           && subreg_lowpart_p (XEXP (x, 0)))
4063         return SUBREG_REG (XEXP (x, 0));
4064
4065       /* If we know that the value is already truncated, we can
4066          replace the TRUNCATE with a SUBREG if TRULY_NOOP_TRUNCATION
4067          is nonzero for the corresponding modes.  But don't do this
4068          for an (LSHIFTRT (MULT ...)) since this will cause problems
4069          with the umulXi3_highpart patterns.  */
4070       if (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
4071                                  GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))))
4072           && num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
4073              >= (unsigned int) (GET_MODE_BITSIZE (mode) + 1)
4074           && ! (GET_CODE (XEXP (x, 0)) == LSHIFTRT
4075                 && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT))
4076         return gen_lowpart_for_combine (mode, XEXP (x, 0));
4077
4078       /* A truncate of a comparison can be replaced with a subreg if
4079          STORE_FLAG_VALUE permits.  This is like the previous test,
4080          but it works even if the comparison is done in a mode larger
4081          than HOST_BITS_PER_WIDE_INT.  */
4082       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4083           && GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) == '<'
4084           && ((HOST_WIDE_INT) STORE_FLAG_VALUE & ~GET_MODE_MASK (mode)) == 0)
4085         return gen_lowpart_for_combine (mode, XEXP (x, 0));
4086
4087       /* Similarly, a truncate of a register whose value is a
4088          comparison can be replaced with a subreg if STORE_FLAG_VALUE
4089          permits.  */
4090       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4091           && ((HOST_WIDE_INT) STORE_FLAG_VALUE & ~GET_MODE_MASK (mode)) == 0
4092           && (temp = get_last_value (XEXP (x, 0)))
4093           && GET_RTX_CLASS (GET_CODE (temp)) == '<')
4094         return gen_lowpart_for_combine (mode, XEXP (x, 0));
4095
4096       break;
4097
4098     case FLOAT_TRUNCATE:
4099       /* (float_truncate:SF (float_extend:DF foo:SF)) = foo:SF.  */
4100       if (GET_CODE (XEXP (x, 0)) == FLOAT_EXTEND
4101           && GET_MODE (XEXP (XEXP (x, 0), 0)) == mode)
4102         return XEXP (XEXP (x, 0), 0);
4103
4104       /* (float_truncate:SF (float_truncate:DF foo:XF))
4105          = (float_truncate:SF foo:XF).
4106          This may elliminate double rounding, so it is unsafe.
4107
4108          (float_truncate:SF (float_extend:XF foo:DF))
4109          = (float_truncate:SF foo:DF).
4110
4111          (float_truncate:DF (float_extend:XF foo:SF))
4112          = (float_extend:SF foo:DF).  */
4113       if ((GET_CODE (XEXP (x, 0)) == FLOAT_TRUNCATE
4114            && flag_unsafe_math_optimizations)
4115           || GET_CODE (XEXP (x, 0)) == FLOAT_EXTEND)
4116         return simplify_gen_unary (GET_MODE_SIZE (GET_MODE (XEXP (XEXP (x, 0),
4117                                                             0)))
4118                                    > GET_MODE_SIZE (mode)
4119                                    ? FLOAT_TRUNCATE : FLOAT_EXTEND,
4120                                    mode,
4121                                    XEXP (XEXP (x, 0), 0), mode);
4122
4123       /*  (float_truncate (float x)) is (float x)  */
4124       if (GET_CODE (XEXP (x, 0)) == FLOAT
4125           && (flag_unsafe_math_optimizations
4126               || ((unsigned)significand_size (GET_MODE (XEXP (x, 0)))
4127                   >= (GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (x, 0), 0)))
4128                       - num_sign_bit_copies (XEXP (XEXP (x, 0), 0),
4129                                              GET_MODE (XEXP (XEXP (x, 0), 0)))))))
4130         return simplify_gen_unary (FLOAT, mode,
4131                                    XEXP (XEXP (x, 0), 0),
4132                                    GET_MODE (XEXP (XEXP (x, 0), 0)));
4133
4134       /* (float_truncate:SF (OP:DF (float_extend:DF foo:sf))) is
4135          (OP:SF foo:SF) if OP is NEG or ABS.  */
4136       if ((GET_CODE (XEXP (x, 0)) == ABS
4137            || GET_CODE (XEXP (x, 0)) == NEG)
4138           && GET_CODE (XEXP (XEXP (x, 0), 0)) == FLOAT_EXTEND
4139           && GET_MODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == mode)
4140         return simplify_gen_unary (GET_CODE (XEXP (x, 0)), mode,
4141                                    XEXP (XEXP (XEXP (x, 0), 0), 0), mode);
4142
4143       /* (float_truncate:SF (subreg:DF (float_truncate:SF X) 0))
4144          is (float_truncate:SF x).  */
4145       if (GET_CODE (XEXP (x, 0)) == SUBREG
4146           && subreg_lowpart_p (XEXP (x, 0))
4147           && GET_CODE (SUBREG_REG (XEXP (x, 0))) == FLOAT_TRUNCATE)
4148         return SUBREG_REG (XEXP (x, 0));
4149       break;
4150     case FLOAT_EXTEND:
4151       /*  (float_extend (float_extend x)) is (float_extend x)
4152
4153           (float_extend (float x)) is (float x) assuming that double
4154           rounding can't happen.
4155           */
4156       if (GET_CODE (XEXP (x, 0)) == FLOAT_EXTEND
4157           || (GET_CODE (XEXP (x, 0)) == FLOAT
4158               && ((unsigned)significand_size (GET_MODE (XEXP (x, 0)))
4159                   >= (GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (x, 0), 0)))
4160                       - num_sign_bit_copies (XEXP (XEXP (x, 0), 0),
4161                                              GET_MODE (XEXP (XEXP (x, 0), 0)))))))
4162         return simplify_gen_unary (GET_CODE (XEXP (x, 0)), mode,
4163                                    XEXP (XEXP (x, 0), 0),
4164                                    GET_MODE (XEXP (XEXP (x, 0), 0)));
4165
4166       break;
4167 #ifdef HAVE_cc0
4168     case COMPARE:
4169       /* Convert (compare FOO (const_int 0)) to FOO unless we aren't
4170          using cc0, in which case we want to leave it as a COMPARE
4171          so we can distinguish it from a register-register-copy.  */
4172       if (XEXP (x, 1) == const0_rtx)
4173         return XEXP (x, 0);
4174
4175       /* x - 0 is the same as x unless x's mode has signed zeros and
4176          allows rounding towards -infinity.  Under those conditions,
4177          0 - 0 is -0.  */
4178       if (!(HONOR_SIGNED_ZEROS (GET_MODE (XEXP (x, 0)))
4179             && HONOR_SIGN_DEPENDENT_ROUNDING (GET_MODE (XEXP (x, 0))))
4180           && XEXP (x, 1) == CONST0_RTX (GET_MODE (XEXP (x, 0))))
4181         return XEXP (x, 0);
4182       break;
4183 #endif
4184
4185     case CONST:
4186       /* (const (const X)) can become (const X).  Do it this way rather than
4187          returning the inner CONST since CONST can be shared with a
4188          REG_EQUAL note.  */
4189       if (GET_CODE (XEXP (x, 0)) == CONST)
4190         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
4191       break;
4192
4193 #ifdef HAVE_lo_sum
4194     case LO_SUM:
4195       /* Convert (lo_sum (high FOO) FOO) to FOO.  This is necessary so we
4196          can add in an offset.  find_split_point will split this address up
4197          again if it doesn't match.  */
4198       if (GET_CODE (XEXP (x, 0)) == HIGH
4199           && rtx_equal_p (XEXP (XEXP (x, 0), 0), XEXP (x, 1)))
4200         return XEXP (x, 1);
4201       break;
4202 #endif
4203
4204     case PLUS:
4205       /* Canonicalize (plus (mult (neg B) C) A) to (minus A (mult B C)).
4206        */
4207       if (GET_CODE (XEXP (x, 0)) == MULT
4208           && GET_CODE (XEXP (XEXP (x, 0), 0)) == NEG)
4209         {
4210           rtx in1, in2;
4211
4212           in1 = XEXP (XEXP (XEXP (x, 0), 0), 0);
4213           in2 = XEXP (XEXP (x, 0), 1);
4214           return gen_binary (MINUS, mode, XEXP (x, 1),
4215                              gen_binary (MULT, mode, in1, in2));
4216         }
4217
4218       /* If we have (plus (plus (A const) B)), associate it so that CONST is
4219          outermost.  That's because that's the way indexed addresses are
4220          supposed to appear.  This code used to check many more cases, but
4221          they are now checked elsewhere.  */
4222       if (GET_CODE (XEXP (x, 0)) == PLUS
4223           && CONSTANT_ADDRESS_P (XEXP (XEXP (x, 0), 1)))
4224         return gen_binary (PLUS, mode,
4225                            gen_binary (PLUS, mode, XEXP (XEXP (x, 0), 0),
4226                                        XEXP (x, 1)),
4227                            XEXP (XEXP (x, 0), 1));
4228
4229       /* (plus (xor (and <foo> (const_int pow2 - 1)) <c>) <-c>)
4230          when c is (const_int (pow2 + 1) / 2) is a sign extension of a
4231          bit-field and can be replaced by either a sign_extend or a
4232          sign_extract.  The `and' may be a zero_extend and the two
4233          <c>, -<c> constants may be reversed.  */
4234       if (GET_CODE (XEXP (x, 0)) == XOR
4235           && GET_CODE (XEXP (x, 1)) == CONST_INT
4236           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
4237           && INTVAL (XEXP (x, 1)) == -INTVAL (XEXP (XEXP (x, 0), 1))
4238           && ((i = exact_log2 (INTVAL (XEXP (XEXP (x, 0), 1)))) >= 0
4239               || (i = exact_log2 (INTVAL (XEXP (x, 1)))) >= 0)
4240           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4241           && ((GET_CODE (XEXP (XEXP (x, 0), 0)) == AND
4242                && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
4243                && (INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1))
4244                    == ((HOST_WIDE_INT) 1 << (i + 1)) - 1))
4245               || (GET_CODE (XEXP (XEXP (x, 0), 0)) == ZERO_EXTEND
4246                   && (GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (XEXP (x, 0), 0), 0)))
4247                       == (unsigned int) i + 1))))
4248         return simplify_shift_const
4249           (NULL_RTX, ASHIFTRT, mode,
4250            simplify_shift_const (NULL_RTX, ASHIFT, mode,
4251                                  XEXP (XEXP (XEXP (x, 0), 0), 0),
4252                                  GET_MODE_BITSIZE (mode) - (i + 1)),
4253            GET_MODE_BITSIZE (mode) - (i + 1));
4254
4255       /* (plus (comparison A B) C) can become (neg (rev-comp A B)) if
4256          C is 1 and STORE_FLAG_VALUE is -1 or if C is -1 and STORE_FLAG_VALUE
4257          is 1.  This produces better code than the alternative immediately
4258          below.  */
4259       if (GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) == '<'
4260           && ((STORE_FLAG_VALUE == -1 && XEXP (x, 1) == const1_rtx)
4261               || (STORE_FLAG_VALUE == 1 && XEXP (x, 1) == constm1_rtx))
4262           && (reversed = reversed_comparison (XEXP (x, 0), mode,
4263                                               XEXP (XEXP (x, 0), 0),
4264                                               XEXP (XEXP (x, 0), 1))))
4265         return
4266           simplify_gen_unary (NEG, mode, reversed, mode);
4267
4268       /* If only the low-order bit of X is possibly nonzero, (plus x -1)
4269          can become (ashiftrt (ashift (xor x 1) C) C) where C is
4270          the bitsize of the mode - 1.  This allows simplification of
4271          "a = (b & 8) == 0;"  */
4272       if (XEXP (x, 1) == constm1_rtx
4273           && GET_CODE (XEXP (x, 0)) != REG
4274           && ! (GET_CODE (XEXP (x, 0)) == SUBREG
4275                 && GET_CODE (SUBREG_REG (XEXP (x, 0))) == REG)
4276           && nonzero_bits (XEXP (x, 0), mode) == 1)
4277         return simplify_shift_const (NULL_RTX, ASHIFTRT, mode,
4278            simplify_shift_const (NULL_RTX, ASHIFT, mode,
4279                                  gen_rtx_XOR (mode, XEXP (x, 0), const1_rtx),
4280                                  GET_MODE_BITSIZE (mode) - 1),
4281            GET_MODE_BITSIZE (mode) - 1);
4282
4283       /* If we are adding two things that have no bits in common, convert
4284          the addition into an IOR.  This will often be further simplified,
4285          for example in cases like ((a & 1) + (a & 2)), which can
4286          become a & 3.  */
4287
4288       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4289           && (nonzero_bits (XEXP (x, 0), mode)
4290               & nonzero_bits (XEXP (x, 1), mode)) == 0)
4291         {
4292           /* Try to simplify the expression further.  */
4293           rtx tor = gen_binary (IOR, mode, XEXP (x, 0), XEXP (x, 1));
4294           temp = combine_simplify_rtx (tor, mode, last, in_dest);
4295
4296           /* If we could, great.  If not, do not go ahead with the IOR
4297              replacement, since PLUS appears in many special purpose
4298              address arithmetic instructions.  */
4299           if (GET_CODE (temp) != CLOBBER && temp != tor)
4300             return temp;
4301         }
4302       break;
4303
4304     case MINUS:
4305       /* If STORE_FLAG_VALUE is 1, (minus 1 (comparison foo bar)) can be done
4306          by reversing the comparison code if valid.  */
4307       if (STORE_FLAG_VALUE == 1
4308           && XEXP (x, 0) == const1_rtx
4309           && GET_RTX_CLASS (GET_CODE (XEXP (x, 1))) == '<'
4310           && (reversed = reversed_comparison (XEXP (x, 1), mode,
4311                                               XEXP (XEXP (x, 1), 0),
4312                                               XEXP (XEXP (x, 1), 1))))
4313         return reversed;
4314
4315       /* (minus <foo> (and <foo> (const_int -pow2))) becomes
4316          (and <foo> (const_int pow2-1))  */
4317       if (GET_CODE (XEXP (x, 1)) == AND
4318           && GET_CODE (XEXP (XEXP (x, 1), 1)) == CONST_INT
4319           && exact_log2 (-INTVAL (XEXP (XEXP (x, 1), 1))) >= 0
4320           && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
4321         return simplify_and_const_int (NULL_RTX, mode, XEXP (x, 0),
4322                                        -INTVAL (XEXP (XEXP (x, 1), 1)) - 1);
4323
4324       /* Canonicalize (minus A (mult (neg B) C)) to (plus (mult B C) A).
4325        */
4326       if (GET_CODE (XEXP (x, 1)) == MULT
4327           && GET_CODE (XEXP (XEXP (x, 1), 0)) == NEG)
4328         {
4329           rtx in1, in2;
4330
4331           in1 = XEXP (XEXP (XEXP (x, 1), 0), 0);
4332           in2 = XEXP (XEXP (x, 1), 1);
4333           return gen_binary (PLUS, mode, gen_binary (MULT, mode, in1, in2),
4334                              XEXP (x, 0));
4335         }
4336
4337       /* Canonicalize (minus (neg A) (mult B C)) to
4338          (minus (mult (neg B) C) A).  */
4339       if (GET_CODE (XEXP (x, 1)) == MULT
4340           && GET_CODE (XEXP (x, 0)) == NEG)
4341         {
4342           rtx in1, in2;
4343
4344           in1 = simplify_gen_unary (NEG, mode, XEXP (XEXP (x, 1), 0), mode);
4345           in2 = XEXP (XEXP (x, 1), 1);
4346           return gen_binary (MINUS, mode, gen_binary (MULT, mode, in1, in2),
4347                              XEXP (XEXP (x, 0), 0));
4348         }
4349
4350       /* Canonicalize (minus A (plus B C)) to (minus (minus A B) C) for
4351          integers.  */
4352       if (GET_CODE (XEXP (x, 1)) == PLUS && INTEGRAL_MODE_P (mode))
4353         return gen_binary (MINUS, mode,
4354                            gen_binary (MINUS, mode, XEXP (x, 0),
4355                                        XEXP (XEXP (x, 1), 0)),
4356                            XEXP (XEXP (x, 1), 1));
4357       break;
4358
4359     case MULT:
4360       /* If we have (mult (plus A B) C), apply the distributive law and then
4361          the inverse distributive law to see if things simplify.  This
4362          occurs mostly in addresses, often when unrolling loops.  */
4363
4364       if (GET_CODE (XEXP (x, 0)) == PLUS)
4365         {
4366           x = apply_distributive_law
4367             (gen_binary (PLUS, mode,
4368                          gen_binary (MULT, mode,
4369                                      XEXP (XEXP (x, 0), 0), XEXP (x, 1)),
4370                          gen_binary (MULT, mode,
4371                                      XEXP (XEXP (x, 0), 1),
4372                                      copy_rtx (XEXP (x, 1)))));
4373
4374           if (GET_CODE (x) != MULT)
4375             return x;
4376         }
4377       /* Try simplify a*(b/c) as (a*b)/c.  */
4378       if (FLOAT_MODE_P (mode) && flag_unsafe_math_optimizations
4379           && GET_CODE (XEXP (x, 0)) == DIV)
4380         {
4381           rtx tem = simplify_binary_operation (MULT, mode,
4382                                                XEXP (XEXP (x, 0), 0),
4383                                                XEXP (x, 1));
4384           if (tem)
4385             return gen_binary (DIV, mode, tem, XEXP (XEXP (x, 0), 1));
4386         }
4387       break;
4388
4389     case UDIV:
4390       /* If this is a divide by a power of two, treat it as a shift if
4391          its first operand is a shift.  */
4392       if (GET_CODE (XEXP (x, 1)) == CONST_INT
4393           && (i = exact_log2 (INTVAL (XEXP (x, 1)))) >= 0
4394           && (GET_CODE (XEXP (x, 0)) == ASHIFT
4395               || GET_CODE (XEXP (x, 0)) == LSHIFTRT
4396               || GET_CODE (XEXP (x, 0)) == ASHIFTRT
4397               || GET_CODE (XEXP (x, 0)) == ROTATE
4398               || GET_CODE (XEXP (x, 0)) == ROTATERT))
4399         return simplify_shift_const (NULL_RTX, LSHIFTRT, mode, XEXP (x, 0), i);
4400       break;
4401
4402     case EQ:  case NE:
4403     case GT:  case GTU:  case GE:  case GEU:
4404     case LT:  case LTU:  case LE:  case LEU:
4405     case UNEQ:  case LTGT:
4406     case UNGT:  case UNGE:
4407     case UNLT:  case UNLE:
4408     case UNORDERED: case ORDERED:
4409       /* If the first operand is a condition code, we can't do anything
4410          with it.  */
4411       if (GET_CODE (XEXP (x, 0)) == COMPARE
4412           || (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) != MODE_CC
4413               && ! CC0_P (XEXP (x, 0))))
4414         {
4415           rtx op0 = XEXP (x, 0);
4416           rtx op1 = XEXP (x, 1);
4417           enum rtx_code new_code;
4418
4419           if (GET_CODE (op0) == COMPARE)
4420             op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
4421
4422           /* Simplify our comparison, if possible.  */
4423           new_code = simplify_comparison (code, &op0, &op1);
4424
4425           /* If STORE_FLAG_VALUE is 1, we can convert (ne x 0) to simply X
4426              if only the low-order bit is possibly nonzero in X (such as when
4427              X is a ZERO_EXTRACT of one bit).  Similarly, we can convert EQ to
4428              (xor X 1) or (minus 1 X); we use the former.  Finally, if X is
4429              known to be either 0 or -1, NE becomes a NEG and EQ becomes
4430              (plus X 1).
4431
4432              Remove any ZERO_EXTRACT we made when thinking this was a
4433              comparison.  It may now be simpler to use, e.g., an AND.  If a
4434              ZERO_EXTRACT is indeed appropriate, it will be placed back by
4435              the call to make_compound_operation in the SET case.  */
4436
4437           if (STORE_FLAG_VALUE == 1
4438               && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
4439               && op1 == const0_rtx
4440               && mode == GET_MODE (op0)
4441               && nonzero_bits (op0, mode) == 1)
4442             return gen_lowpart_for_combine (mode,
4443                                             expand_compound_operation (op0));
4444
4445           else if (STORE_FLAG_VALUE == 1
4446                    && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
4447                    && op1 == const0_rtx
4448                    && mode == GET_MODE (op0)
4449                    && (num_sign_bit_copies (op0, mode)
4450                        == GET_MODE_BITSIZE (mode)))
4451             {
4452               op0 = expand_compound_operation (op0);
4453               return simplify_gen_unary (NEG, mode,
4454                                          gen_lowpart_for_combine (mode, op0),
4455                                          mode);
4456             }
4457
4458           else if (STORE_FLAG_VALUE == 1
4459                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
4460                    && op1 == const0_rtx
4461                    && mode == GET_MODE (op0)
4462                    && nonzero_bits (op0, mode) == 1)
4463             {
4464               op0 = expand_compound_operation (op0);
4465               return gen_binary (XOR, mode,
4466                                  gen_lowpart_for_combine (mode, op0),
4467                                  const1_rtx);
4468             }
4469
4470           else if (STORE_FLAG_VALUE == 1
4471                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
4472                    && op1 == const0_rtx
4473                    && mode == GET_MODE (op0)
4474                    && (num_sign_bit_copies (op0, mode)
4475                        == GET_MODE_BITSIZE (mode)))
4476             {
4477               op0 = expand_compound_operation (op0);
4478               return plus_constant (gen_lowpart_for_combine (mode, op0), 1);
4479             }
4480
4481           /* If STORE_FLAG_VALUE is -1, we have cases similar to
4482              those above.  */
4483           if (STORE_FLAG_VALUE == -1
4484               && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
4485               && op1 == const0_rtx
4486               && (num_sign_bit_copies (op0, mode)
4487                   == GET_MODE_BITSIZE (mode)))
4488             return gen_lowpart_for_combine (mode,
4489                                             expand_compound_operation (op0));
4490
4491           else if (STORE_FLAG_VALUE == -1
4492                    && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
4493                    && op1 == const0_rtx
4494                    && mode == GET_MODE (op0)
4495                    && nonzero_bits (op0, mode) == 1)
4496             {
4497               op0 = expand_compound_operation (op0);
4498               return simplify_gen_unary (NEG, mode,
4499                                          gen_lowpart_for_combine (mode, op0),
4500                                          mode);
4501             }
4502
4503           else if (STORE_FLAG_VALUE == -1
4504                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
4505                    && op1 == const0_rtx
4506                    && mode == GET_MODE (op0)
4507                    && (num_sign_bit_copies (op0, mode)
4508                        == GET_MODE_BITSIZE (mode)))
4509             {
4510               op0 = expand_compound_operation (op0);
4511               return simplify_gen_unary (NOT, mode,
4512                                          gen_lowpart_for_combine (mode, op0),
4513                                          mode);
4514             }
4515
4516           /* If X is 0/1, (eq X 0) is X-1.  */
4517           else if (STORE_FLAG_VALUE == -1
4518                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
4519                    && op1 == const0_rtx
4520                    && mode == GET_MODE (op0)
4521                    && nonzero_bits (op0, mode) == 1)
4522             {
4523               op0 = expand_compound_operation (op0);
4524               return plus_constant (gen_lowpart_for_combine (mode, op0), -1);
4525             }
4526
4527           /* If STORE_FLAG_VALUE says to just test the sign bit and X has just
4528              one bit that might be nonzero, we can convert (ne x 0) to
4529              (ashift x c) where C puts the bit in the sign bit.  Remove any
4530              AND with STORE_FLAG_VALUE when we are done, since we are only
4531              going to test the sign bit.  */
4532           if (new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
4533               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4534               && ((STORE_FLAG_VALUE & GET_MODE_MASK (mode))
4535                   == (unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (mode) - 1))
4536               && op1 == const0_rtx
4537               && mode == GET_MODE (op0)
4538               && (i = exact_log2 (nonzero_bits (op0, mode))) >= 0)
4539             {
4540               x = simplify_shift_const (NULL_RTX, ASHIFT, mode,
4541                                         expand_compound_operation (op0),
4542                                         GET_MODE_BITSIZE (mode) - 1 - i);
4543               if (GET_CODE (x) == AND && XEXP (x, 1) == const_true_rtx)
4544                 return XEXP (x, 0);
4545               else
4546                 return x;
4547             }
4548
4549           /* If the code changed, return a whole new comparison.  */
4550           if (new_code != code)
4551             return gen_rtx_fmt_ee (new_code, mode, op0, op1);
4552
4553           /* Otherwise, keep this operation, but maybe change its operands.
4554              This also converts (ne (compare FOO BAR) 0) to (ne FOO BAR).  */
4555           SUBST (XEXP (x, 0), op0);
4556           SUBST (XEXP (x, 1), op1);
4557         }
4558       break;
4559
4560     case IF_THEN_ELSE:
4561       return simplify_if_then_else (x);
4562
4563     case ZERO_EXTRACT:
4564     case SIGN_EXTRACT:
4565     case ZERO_EXTEND:
4566     case SIGN_EXTEND:
4567       /* If we are processing SET_DEST, we are done.  */
4568       if (in_dest)
4569         return x;
4570
4571       return expand_compound_operation (x);
4572
4573     case SET:
4574       return simplify_set (x);
4575
4576     case AND:
4577     case IOR:
4578     case XOR:
4579       return simplify_logical (x, last);
4580
4581     case ABS:
4582       /* (abs (neg <foo>)) -> (abs <foo>) */
4583       if (GET_CODE (XEXP (x, 0)) == NEG)
4584         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
4585
4586       /* If the mode of the operand is VOIDmode (i.e. if it is ASM_OPERANDS),
4587          do nothing.  */
4588       if (GET_MODE (XEXP (x, 0)) == VOIDmode)
4589         break;
4590
4591       /* If operand is something known to be positive, ignore the ABS.  */
4592       if (GET_CODE (XEXP (x, 0)) == FFS || GET_CODE (XEXP (x, 0)) == ABS
4593           || ((GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
4594                <= HOST_BITS_PER_WIDE_INT)
4595               && ((nonzero_bits (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
4596                    & ((HOST_WIDE_INT) 1
4597                       << (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - 1)))
4598                   == 0)))
4599         return XEXP (x, 0);
4600
4601       /* If operand is known to be only -1 or 0, convert ABS to NEG.  */
4602       if (num_sign_bit_copies (XEXP (x, 0), mode) == GET_MODE_BITSIZE (mode))
4603         return gen_rtx_NEG (mode, XEXP (x, 0));
4604
4605       break;
4606
4607     case FFS:
4608       /* (ffs (*_extend <X>)) = (ffs <X>) */
4609       if (GET_CODE (XEXP (x, 0)) == SIGN_EXTEND
4610           || GET_CODE (XEXP (x, 0)) == ZERO_EXTEND)
4611         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
4612       break;
4613
4614     case POPCOUNT:
4615     case PARITY:
4616       /* (pop* (zero_extend <X>)) = (pop* <X>) */
4617       if (GET_CODE (XEXP (x, 0)) == ZERO_EXTEND)
4618         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
4619       break;
4620
4621     case FLOAT:
4622       /* (float (sign_extend <X>)) = (float <X>).  */
4623       if (GET_CODE (XEXP (x, 0)) == SIGN_EXTEND)
4624         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
4625       break;
4626
4627     case ASHIFT:
4628     case LSHIFTRT:
4629     case ASHIFTRT:
4630     case ROTATE:
4631     case ROTATERT:
4632       /* If this is a shift by a constant amount, simplify it.  */
4633       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
4634         return simplify_shift_const (x, code, mode, XEXP (x, 0),
4635                                      INTVAL (XEXP (x, 1)));
4636
4637 #ifdef SHIFT_COUNT_TRUNCATED
4638       else if (SHIFT_COUNT_TRUNCATED && GET_CODE (XEXP (x, 1)) != REG)
4639         SUBST (XEXP (x, 1),
4640                force_to_mode (XEXP (x, 1), GET_MODE (XEXP (x, 1)),
4641                               ((HOST_WIDE_INT) 1
4642                                << exact_log2 (GET_MODE_BITSIZE (GET_MODE (x))))
4643                               - 1,
4644                               NULL_RTX, 0));
4645 #endif
4646
4647       break;
4648
4649     case VEC_SELECT:
4650       {
4651         rtx op0 = XEXP (x, 0);
4652         rtx op1 = XEXP (x, 1);
4653         int len;
4654
4655         if (GET_CODE (op1) != PARALLEL)
4656           abort ();
4657         len = XVECLEN (op1, 0);
4658         if (len == 1
4659             && GET_CODE (XVECEXP (op1, 0, 0)) == CONST_INT
4660             && GET_CODE (op0) == VEC_CONCAT)
4661           {
4662             int offset = INTVAL (XVECEXP (op1, 0, 0)) * GET_MODE_SIZE (GET_MODE (x));
4663
4664             /* Try to find the element in the VEC_CONCAT.  */
4665             for (;;)
4666               {
4667                 if (GET_MODE (op0) == GET_MODE (x))
4668                   return op0;
4669                 if (GET_CODE (op0) == VEC_CONCAT)
4670                   {
4671                     HOST_WIDE_INT op0_size = GET_MODE_SIZE (GET_MODE (XEXP (op0, 0)));
4672                     if (op0_size < offset)
4673                       op0 = XEXP (op0, 0);
4674                     else
4675                       {
4676                         offset -= op0_size;
4677                         op0 = XEXP (op0, 1);
4678                       }
4679                   }
4680                 else
4681                   break;
4682               }
4683           }
4684       }
4685
4686       break;
4687
4688     default:
4689       break;
4690     }
4691
4692   return x;
4693 }
4694 \f
4695 /* Simplify X, an IF_THEN_ELSE expression.  Return the new expression.  */
4696
4697 static rtx
4698 simplify_if_then_else (rtx x)
4699 {
4700   enum machine_mode mode = GET_MODE (x);
4701   rtx cond = XEXP (x, 0);
4702   rtx true_rtx = XEXP (x, 1);
4703   rtx false_rtx = XEXP (x, 2);
4704   enum rtx_code true_code = GET_CODE (cond);
4705   int comparison_p = GET_RTX_CLASS (true_code) == '<';
4706   rtx temp;
4707   int i;
4708   enum rtx_code false_code;
4709   rtx reversed;
4710
4711   /* Simplify storing of the truth value.  */
4712   if (comparison_p && true_rtx == const_true_rtx && false_rtx == const0_rtx)
4713     return gen_binary (true_code, mode, XEXP (cond, 0), XEXP (cond, 1));
4714
4715   /* Also when the truth value has to be reversed.  */
4716   if (comparison_p
4717       && true_rtx == const0_rtx && false_rtx == const_true_rtx
4718       && (reversed = reversed_comparison (cond, mode, XEXP (cond, 0),
4719                                           XEXP (cond, 1))))
4720     return reversed;
4721
4722   /* Sometimes we can simplify the arm of an IF_THEN_ELSE if a register used
4723      in it is being compared against certain values.  Get the true and false
4724      comparisons and see if that says anything about the value of each arm.  */
4725
4726   if (comparison_p
4727       && ((false_code = combine_reversed_comparison_code (cond))
4728           != UNKNOWN)
4729       && GET_CODE (XEXP (cond, 0)) == REG)
4730     {
4731       HOST_WIDE_INT nzb;
4732       rtx from = XEXP (cond, 0);
4733       rtx true_val = XEXP (cond, 1);
4734       rtx false_val = true_val;
4735       int swapped = 0;
4736
4737       /* If FALSE_CODE is EQ, swap the codes and arms.  */
4738
4739       if (false_code == EQ)
4740         {
4741           swapped = 1, true_code = EQ, false_code = NE;
4742           temp = true_rtx, true_rtx = false_rtx, false_rtx = temp;
4743         }
4744
4745       /* If we are comparing against zero and the expression being tested has
4746          only a single bit that might be nonzero, that is its value when it is
4747          not equal to zero.  Similarly if it is known to be -1 or 0.  */
4748
4749       if (true_code == EQ && true_val == const0_rtx
4750           && exact_log2 (nzb = nonzero_bits (from, GET_MODE (from))) >= 0)
4751         false_code = EQ, false_val = GEN_INT (nzb);
4752       else if (true_code == EQ && true_val == const0_rtx
4753                && (num_sign_bit_copies (from, GET_MODE (from))
4754                    == GET_MODE_BITSIZE (GET_MODE (from))))
4755         false_code = EQ, false_val = constm1_rtx;
4756
4757       /* Now simplify an arm if we know the value of the register in the
4758          branch and it is used in the arm.  Be careful due to the potential
4759          of locally-shared RTL.  */
4760
4761       if (reg_mentioned_p (from, true_rtx))
4762         true_rtx = subst (known_cond (copy_rtx (true_rtx), true_code,
4763                                       from, true_val),
4764                       pc_rtx, pc_rtx, 0, 0);
4765       if (reg_mentioned_p (from, false_rtx))
4766         false_rtx = subst (known_cond (copy_rtx (false_rtx), false_code,
4767                                    from, false_val),
4768                        pc_rtx, pc_rtx, 0, 0);
4769
4770       SUBST (XEXP (x, 1), swapped ? false_rtx : true_rtx);
4771       SUBST (XEXP (x, 2), swapped ? true_rtx : false_rtx);
4772
4773       true_rtx = XEXP (x, 1);
4774       false_rtx = XEXP (x, 2);
4775       true_code = GET_CODE (cond);
4776     }
4777
4778   /* If we have (if_then_else FOO (pc) (label_ref BAR)) and FOO can be
4779      reversed, do so to avoid needing two sets of patterns for
4780      subtract-and-branch insns.  Similarly if we have a constant in the true
4781      arm, the false arm is the same as the first operand of the comparison, or
4782      the false arm is more complicated than the true arm.  */
4783
4784   if (comparison_p
4785       && combine_reversed_comparison_code (cond) != UNKNOWN
4786       && (true_rtx == pc_rtx
4787           || (CONSTANT_P (true_rtx)
4788               && GET_CODE (false_rtx) != CONST_INT && false_rtx != pc_rtx)
4789           || true_rtx == const0_rtx
4790           || (GET_RTX_CLASS (GET_CODE (true_rtx)) == 'o'
4791               && GET_RTX_CLASS (GET_CODE (false_rtx)) != 'o')
4792           || (GET_CODE (true_rtx) == SUBREG
4793               && GET_RTX_CLASS (GET_CODE (SUBREG_REG (true_rtx))) == 'o'
4794               && GET_RTX_CLASS (GET_CODE (false_rtx)) != 'o')
4795           || reg_mentioned_p (true_rtx, false_rtx)
4796           || rtx_equal_p (false_rtx, XEXP (cond, 0))))
4797     {
4798       true_code = reversed_comparison_code (cond, NULL);
4799       SUBST (XEXP (x, 0),
4800              reversed_comparison (cond, GET_MODE (cond), XEXP (cond, 0),
4801                                   XEXP (cond, 1)));
4802
4803       SUBST (XEXP (x, 1), false_rtx);
4804       SUBST (XEXP (x, 2), true_rtx);
4805
4806       temp = true_rtx, true_rtx = false_rtx, false_rtx = temp;
4807       cond = XEXP (x, 0);
4808
4809       /* It is possible that the conditional has been simplified out.  */
4810       true_code = GET_CODE (cond);
4811       comparison_p = GET_RTX_CLASS (true_code) == '<';
4812     }
4813
4814   /* If the two arms are identical, we don't need the comparison.  */
4815
4816   if (rtx_equal_p (true_rtx, false_rtx) && ! side_effects_p (cond))
4817     return true_rtx;
4818
4819   /* Convert a == b ? b : a to "a".  */
4820   if (true_code == EQ && ! side_effects_p (cond)
4821       && !HONOR_NANS (mode)
4822       && rtx_equal_p (XEXP (cond, 0), false_rtx)
4823       && rtx_equal_p (XEXP (cond, 1), true_rtx))
4824     return false_rtx;
4825   else if (true_code == NE && ! side_effects_p (cond)
4826            && !HONOR_NANS (mode)
4827            && rtx_equal_p (XEXP (cond, 0), true_rtx)
4828            && rtx_equal_p (XEXP (cond, 1), false_rtx))
4829     return true_rtx;
4830
4831   /* Look for cases where we have (abs x) or (neg (abs X)).  */
4832
4833   if (GET_MODE_CLASS (mode) == MODE_INT
4834       && GET_CODE (false_rtx) == NEG
4835       && rtx_equal_p (true_rtx, XEXP (false_rtx, 0))
4836       && comparison_p
4837       && rtx_equal_p (true_rtx, XEXP (cond, 0))
4838       && ! side_effects_p (true_rtx))
4839     switch (true_code)
4840       {
4841       case GT:
4842       case GE:
4843         return simplify_gen_unary (ABS, mode, true_rtx, mode);
4844       case LT:
4845       case LE:
4846         return
4847           simplify_gen_unary (NEG, mode,
4848                               simplify_gen_unary (ABS, mode, true_rtx, mode),
4849                               mode);
4850       default:
4851         break;
4852       }
4853
4854   /* Look for MIN or MAX.  */
4855
4856   if ((! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations)
4857       && comparison_p
4858       && rtx_equal_p (XEXP (cond, 0), true_rtx)
4859       && rtx_equal_p (XEXP (cond, 1), false_rtx)
4860       && ! side_effects_p (cond))
4861     switch (true_code)
4862       {
4863       case GE:
4864       case GT:
4865         return gen_binary (SMAX, mode, true_rtx, false_rtx);
4866       case LE:
4867       case LT:
4868         return gen_binary (SMIN, mode, true_rtx, false_rtx);
4869       case GEU:
4870       case GTU:
4871         return gen_binary (UMAX, mode, true_rtx, false_rtx);
4872       case LEU:
4873       case LTU:
4874         return gen_binary (UMIN, mode, true_rtx, false_rtx);
4875       default:
4876         break;
4877       }
4878
4879   /* If we have (if_then_else COND (OP Z C1) Z) and OP is an identity when its
4880      second operand is zero, this can be done as (OP Z (mult COND C2)) where
4881      C2 = C1 * STORE_FLAG_VALUE. Similarly if OP has an outer ZERO_EXTEND or
4882      SIGN_EXTEND as long as Z is already extended (so we don't destroy it).
4883      We can do this kind of thing in some cases when STORE_FLAG_VALUE is
4884      neither 1 or -1, but it isn't worth checking for.  */
4885
4886   if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
4887       && comparison_p
4888       && GET_MODE_CLASS (mode) == MODE_INT
4889       && ! side_effects_p (x))
4890     {
4891       rtx t = make_compound_operation (true_rtx, SET);
4892       rtx f = make_compound_operation (false_rtx, SET);
4893       rtx cond_op0 = XEXP (cond, 0);
4894       rtx cond_op1 = XEXP (cond, 1);
4895       enum rtx_code op = NIL, extend_op = NIL;
4896       enum machine_mode m = mode;
4897       rtx z = 0, c1 = NULL_RTX;
4898
4899       if ((GET_CODE (t) == PLUS || GET_CODE (t) == MINUS
4900            || GET_CODE (t) == IOR || GET_CODE (t) == XOR
4901            || GET_CODE (t) == ASHIFT
4902            || GET_CODE (t) == LSHIFTRT || GET_CODE (t) == ASHIFTRT)
4903           && rtx_equal_p (XEXP (t, 0), f))
4904         c1 = XEXP (t, 1), op = GET_CODE (t), z = f;
4905
4906       /* If an identity-zero op is commutative, check whether there
4907          would be a match if we swapped the operands.  */
4908       else if ((GET_CODE (t) == PLUS || GET_CODE (t) == IOR
4909                 || GET_CODE (t) == XOR)
4910                && rtx_equal_p (XEXP (t, 1), f))
4911         c1 = XEXP (t, 0), op = GET_CODE (t), z = f;
4912       else if (GET_CODE (t) == SIGN_EXTEND
4913                && (GET_CODE (XEXP (t, 0)) == PLUS
4914                    || GET_CODE (XEXP (t, 0)) == MINUS
4915                    || GET_CODE (XEXP (t, 0)) == IOR
4916                    || GET_CODE (XEXP (t, 0)) == XOR
4917                    || GET_CODE (XEXP (t, 0)) == ASHIFT
4918                    || GET_CODE (XEXP (t, 0)) == LSHIFTRT
4919                    || GET_CODE (XEXP (t, 0)) == ASHIFTRT)
4920                && GET_CODE (XEXP (XEXP (t, 0), 0)) == SUBREG
4921                && subreg_lowpart_p (XEXP (XEXP (t, 0), 0))
4922                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 0)), f)
4923                && (num_sign_bit_copies (f, GET_MODE (f))
4924                    > (unsigned int)
4925                      (GET_MODE_BITSIZE (mode)
4926                       - GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (t, 0), 0))))))
4927         {
4928           c1 = XEXP (XEXP (t, 0), 1); z = f; op = GET_CODE (XEXP (t, 0));
4929           extend_op = SIGN_EXTEND;
4930           m = GET_MODE (XEXP (t, 0));
4931         }
4932       else if (GET_CODE (t) == SIGN_EXTEND
4933                && (GET_CODE (XEXP (t, 0)) == PLUS
4934                    || GET_CODE (XEXP (t, 0)) == IOR
4935                    || GET_CODE (XEXP (t, 0)) == XOR)
4936                && GET_CODE (XEXP (XEXP (t, 0), 1)) == SUBREG
4937                && subreg_lowpart_p (XEXP (XEXP (t, 0), 1))
4938                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 1)), f)
4939                && (num_sign_bit_copies (f, GET_MODE (f))
4940                    > (unsigned int)
4941                      (GET_MODE_BITSIZE (mode)
4942                       - GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (t, 0), 1))))))
4943         {
4944           c1 = XEXP (XEXP (t, 0), 0); z = f; op = GET_CODE (XEXP (t, 0));
4945           extend_op = SIGN_EXTEND;
4946           m = GET_MODE (XEXP (t, 0));
4947         }
4948       else if (GET_CODE (t) == ZERO_EXTEND
4949                && (GET_CODE (XEXP (t, 0)) == PLUS
4950                    || GET_CODE (XEXP (t, 0)) == MINUS
4951                    || GET_CODE (XEXP (t, 0)) == IOR
4952                    || GET_CODE (XEXP (t, 0)) == XOR
4953                    || GET_CODE (XEXP (t, 0)) == ASHIFT
4954                    || GET_CODE (XEXP (t, 0)) == LSHIFTRT
4955                    || GET_CODE (XEXP (t, 0)) == ASHIFTRT)
4956                && GET_CODE (XEXP (XEXP (t, 0), 0)) == SUBREG
4957                && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4958                && subreg_lowpart_p (XEXP (XEXP (t, 0), 0))
4959                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 0)), f)
4960                && ((nonzero_bits (f, GET_MODE (f))
4961                     & ~GET_MODE_MASK (GET_MODE (XEXP (XEXP (t, 0), 0))))
4962                    == 0))
4963         {
4964           c1 = XEXP (XEXP (t, 0), 1); z = f; op = GET_CODE (XEXP (t, 0));
4965           extend_op = ZERO_EXTEND;
4966           m = GET_MODE (XEXP (t, 0));
4967         }
4968       else if (GET_CODE (t) == ZERO_EXTEND
4969                && (GET_CODE (XEXP (t, 0)) == PLUS
4970                    || GET_CODE (XEXP (t, 0)) == IOR
4971                    || GET_CODE (XEXP (t, 0)) == XOR)
4972                && GET_CODE (XEXP (XEXP (t, 0), 1)) == SUBREG
4973                && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4974                && subreg_lowpart_p (XEXP (XEXP (t, 0), 1))
4975                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 1)), f)
4976                && ((nonzero_bits (f, GET_MODE (f))
4977                     & ~GET_MODE_MASK (GET_MODE (XEXP (XEXP (t, 0), 1))))
4978                    == 0))
4979         {
4980           c1 = XEXP (XEXP (t, 0), 0); z = f; op = GET_CODE (XEXP (t, 0));
4981           extend_op = ZERO_EXTEND;
4982           m = GET_MODE (XEXP (t, 0));
4983         }
4984
4985       if (z)
4986         {
4987           temp = subst (gen_binary (true_code, m, cond_op0, cond_op1),
4988                         pc_rtx, pc_rtx, 0, 0);
4989           temp = gen_binary (MULT, m, temp,
4990                              gen_binary (MULT, m, c1, const_true_rtx));
4991           temp = subst (temp, pc_rtx, pc_rtx, 0, 0);
4992           temp = gen_binary (op, m, gen_lowpart_for_combine (m, z), temp);
4993
4994           if (extend_op != NIL)
4995             temp = simplify_gen_unary (extend_op, mode, temp, m);
4996
4997           return temp;
4998         }
4999     }
5000
5001   /* If we have (if_then_else (ne A 0) C1 0) and either A is known to be 0 or
5002      1 and C1 is a single bit or A is known to be 0 or -1 and C1 is the
5003      negation of a single bit, we can convert this operation to a shift.  We
5004      can actually do this more generally, but it doesn't seem worth it.  */
5005
5006   if (true_code == NE && XEXP (cond, 1) == const0_rtx
5007       && false_rtx == const0_rtx && GET_CODE (true_rtx) == CONST_INT
5008       && ((1 == nonzero_bits (XEXP (cond, 0), mode)
5009            && (i = exact_log2 (INTVAL (true_rtx))) >= 0)
5010           || ((num_sign_bit_copies (XEXP (cond, 0), mode)
5011                == GET_MODE_BITSIZE (mode))
5012               && (i = exact_log2 (-INTVAL (true_rtx))) >= 0)))
5013     return
5014       simplify_shift_const (NULL_RTX, ASHIFT, mode,
5015                             gen_lowpart_for_combine (mode, XEXP (cond, 0)), i);
5016
5017   /* (IF_THEN_ELSE (NE REG 0) (0) (8)) is REG for nonzero_bits (REG) == 8.  */
5018   if (true_code == NE && XEXP (cond, 1) == const0_rtx
5019       && false_rtx == const0_rtx && GET_CODE (true_rtx) == CONST_INT
5020       && (INTVAL (true_rtx) & GET_MODE_MASK (mode))
5021           == nonzero_bits (XEXP (cond, 0), mode)
5022       && (i = exact_log2 (INTVAL (true_rtx) & GET_MODE_MASK (mode))) >= 0)
5023     return XEXP (cond, 0);
5024
5025   return x;
5026 }
5027 \f
5028 /* Simplify X, a SET expression.  Return the new expression.  */
5029
5030 static rtx
5031 simplify_set (rtx x)
5032 {
5033   rtx src = SET_SRC (x);
5034   rtx dest = SET_DEST (x);
5035   enum machine_mode mode
5036     = GET_MODE (src) != VOIDmode ? GET_MODE (src) : GET_MODE (dest);
5037   rtx other_insn;
5038   rtx *cc_use;
5039
5040   /* (set (pc) (return)) gets written as (return).  */
5041   if (GET_CODE (dest) == PC && GET_CODE (src) == RETURN)
5042     return src;
5043
5044   /* Now that we know for sure which bits of SRC we are using, see if we can
5045      simplify the expression for the object knowing that we only need the
5046      low-order bits.  */
5047
5048   if (GET_MODE_CLASS (mode) == MODE_INT
5049       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
5050     {
5051       src = force_to_mode (src, mode, ~(HOST_WIDE_INT) 0, NULL_RTX, 0);
5052       SUBST (SET_SRC (x), src);
5053     }
5054
5055   /* If we are setting CC0 or if the source is a COMPARE, look for the use of
5056      the comparison result and try to simplify it unless we already have used
5057      undobuf.other_insn.  */
5058   if ((GET_MODE_CLASS (mode) == MODE_CC
5059        || GET_CODE (src) == COMPARE
5060        || CC0_P (dest))
5061       && (cc_use = find_single_use (dest, subst_insn, &other_insn)) != 0
5062       && (undobuf.other_insn == 0 || other_insn == undobuf.other_insn)
5063       && GET_RTX_CLASS (GET_CODE (*cc_use)) == '<'
5064       && rtx_equal_p (XEXP (*cc_use, 0), dest))
5065     {
5066       enum rtx_code old_code = GET_CODE (*cc_use);
5067       enum rtx_code new_code;
5068       rtx op0, op1, tmp;
5069       int other_changed = 0;
5070       enum machine_mode compare_mode = GET_MODE (dest);
5071       enum machine_mode tmp_mode;
5072
5073       if (GET_CODE (src) == COMPARE)
5074         op0 = XEXP (src, 0), op1 = XEXP (src, 1);
5075       else
5076         op0 = src, op1 = const0_rtx;
5077
5078       /* Check whether the comparison is known at compile time.  */
5079       if (GET_MODE (op0) != VOIDmode)
5080         tmp_mode = GET_MODE (op0);
5081       else if (GET_MODE (op1) != VOIDmode)
5082         tmp_mode = GET_MODE (op1);
5083       else
5084         tmp_mode = compare_mode;
5085       tmp = simplify_relational_operation (old_code, tmp_mode, op0, op1);
5086       if (tmp != NULL_RTX)
5087         {
5088           rtx pat = PATTERN (other_insn);
5089           undobuf.other_insn = other_insn;
5090           SUBST (*cc_use, tmp);
5091
5092           /* Attempt to simplify CC user.  */
5093           if (GET_CODE (pat) == SET)
5094             {
5095               rtx new = simplify_rtx (SET_SRC (pat));
5096               if (new != NULL_RTX)
5097                 SUBST (SET_SRC (pat), new);
5098             }
5099
5100           /* Convert X into a no-op move.  */
5101           SUBST (SET_DEST (x), pc_rtx);
5102           SUBST (SET_SRC (x), pc_rtx);
5103           return x;
5104         }
5105
5106       /* Simplify our comparison, if possible.  */
5107       new_code = simplify_comparison (old_code, &op0, &op1);
5108
5109 #ifdef EXTRA_CC_MODES
5110       /* If this machine has CC modes other than CCmode, check to see if we
5111          need to use a different CC mode here.  */
5112       compare_mode = SELECT_CC_MODE (new_code, op0, op1);
5113 #endif /* EXTRA_CC_MODES */
5114
5115 #if !defined (HAVE_cc0) && defined (EXTRA_CC_MODES)
5116       /* If the mode changed, we have to change SET_DEST, the mode in the
5117          compare, and the mode in the place SET_DEST is used.  If SET_DEST is
5118          a hard register, just build new versions with the proper mode.  If it
5119          is a pseudo, we lose unless it is only time we set the pseudo, in
5120          which case we can safely change its mode.  */
5121       if (compare_mode != GET_MODE (dest))
5122         {
5123           unsigned int regno = REGNO (dest);
5124           rtx new_dest = gen_rtx_REG (compare_mode, regno);
5125
5126           if (regno < FIRST_PSEUDO_REGISTER
5127               || (REG_N_SETS (regno) == 1 && ! REG_USERVAR_P (dest)))
5128             {
5129               if (regno >= FIRST_PSEUDO_REGISTER)
5130                 SUBST (regno_reg_rtx[regno], new_dest);
5131
5132               SUBST (SET_DEST (x), new_dest);
5133               SUBST (XEXP (*cc_use, 0), new_dest);
5134               other_changed = 1;
5135
5136               dest = new_dest;
5137             }
5138         }
5139 #endif
5140
5141       /* If the code changed, we have to build a new comparison in
5142          undobuf.other_insn.  */
5143       if (new_code != old_code)
5144         {
5145           unsigned HOST_WIDE_INT mask;
5146
5147           SUBST (*cc_use, gen_rtx_fmt_ee (new_code, GET_MODE (*cc_use),
5148                                           dest, const0_rtx));
5149
5150           /* If the only change we made was to change an EQ into an NE or
5151              vice versa, OP0 has only one bit that might be nonzero, and OP1
5152              is zero, check if changing the user of the condition code will
5153              produce a valid insn.  If it won't, we can keep the original code
5154              in that insn by surrounding our operation with an XOR.  */
5155
5156           if (((old_code == NE && new_code == EQ)
5157                || (old_code == EQ && new_code == NE))
5158               && ! other_changed && op1 == const0_rtx
5159               && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
5160               && exact_log2 (mask = nonzero_bits (op0, GET_MODE (op0))) >= 0)
5161             {
5162               rtx pat = PATTERN (other_insn), note = 0;
5163
5164               if ((recog_for_combine (&pat, other_insn, &note) < 0
5165                    && ! check_asm_operands (pat)))
5166                 {
5167                   PUT_CODE (*cc_use, old_code);
5168                   other_insn = 0;
5169
5170                   op0 = gen_binary (XOR, GET_MODE (op0), op0, GEN_INT (mask));
5171                 }
5172             }
5173
5174           other_changed = 1;
5175         }
5176
5177       if (other_changed)
5178         undobuf.other_insn = other_insn;
5179
5180 #ifdef HAVE_cc0
5181       /* If we are now comparing against zero, change our source if
5182          needed.  If we do not use cc0, we always have a COMPARE.  */
5183       if (op1 == const0_rtx && dest == cc0_rtx)
5184         {
5185           SUBST (SET_SRC (x), op0);
5186           src = op0;
5187         }
5188       else
5189 #endif
5190
5191       /* Otherwise, if we didn't previously have a COMPARE in the
5192          correct mode, we need one.  */
5193       if (GET_CODE (src) != COMPARE || GET_MODE (src) != compare_mode)
5194         {
5195           SUBST (SET_SRC (x), gen_rtx_COMPARE (compare_mode, op0, op1));
5196           src = SET_SRC (x);
5197         }
5198       else
5199         {
5200           /* Otherwise, update the COMPARE if needed.  */
5201           SUBST (XEXP (src, 0), op0);
5202           SUBST (XEXP (src, 1), op1);
5203         }
5204     }
5205   else
5206     {
5207       /* Get SET_SRC in a form where we have placed back any
5208          compound expressions.  Then do the checks below.  */
5209       src = make_compound_operation (src, SET);
5210       SUBST (SET_SRC (x), src);
5211     }
5212
5213 #ifdef WORD_REGISTER_OPERATIONS
5214   /* If we have (set x (subreg:m1 (op:m2 ...) 0)) with OP being some operation,
5215      and X being a REG or (subreg (reg)), we may be able to convert this to
5216      (set (subreg:m2 x) (op)).
5217
5218      On a machine where WORD_REGISTER_OPERATIONS is defined, this
5219      transformation is safe as long as M1 and M2 have the same number
5220      of words.
5221
5222      However, on a machine without WORD_REGISTER_OPERATIONS defined,
5223      we cannot apply this transformation because it would create a
5224      paradoxical subreg in SET_DEST.  */
5225
5226   if (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)
5227       && GET_RTX_CLASS (GET_CODE (SUBREG_REG (src))) != 'o'
5228       && (((GET_MODE_SIZE (GET_MODE (src)) + (UNITS_PER_WORD - 1))
5229            / UNITS_PER_WORD)
5230           == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (src)))
5231                + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
5232 #ifdef CANNOT_CHANGE_MODE_CLASS
5233       && ! (GET_CODE (dest) == REG && REGNO (dest) < FIRST_PSEUDO_REGISTER
5234             && REG_CANNOT_CHANGE_MODE_P (REGNO (dest),
5235                                          GET_MODE (SUBREG_REG (src)),
5236                                          GET_MODE (src)))
5237 #endif
5238       && (GET_CODE (dest) == REG
5239           || (GET_CODE (dest) == SUBREG
5240               && GET_CODE (SUBREG_REG (dest)) == REG)))
5241     {
5242       SUBST (SET_DEST (x),
5243              gen_lowpart_for_combine (GET_MODE (SUBREG_REG (src)),
5244                                       dest));
5245       SUBST (SET_SRC (x), SUBREG_REG (src));
5246
5247       src = SET_SRC (x), dest = SET_DEST (x);
5248     }
5249 #endif
5250
5251 #ifdef HAVE_cc0
5252   /* If we have (set (cc0) (subreg ...)), we try to remove the subreg
5253      in SRC.  */
5254   if (dest == cc0_rtx
5255       && GET_CODE (src) == SUBREG
5256       && subreg_lowpart_p (src)
5257       && (GET_MODE_BITSIZE (GET_MODE (src))
5258           < GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (src)))))
5259     {
5260       rtx inner = SUBREG_REG (src);
5261       enum machine_mode inner_mode = GET_MODE (inner);
5262
5263       /* Here we make sure that we don't have a sign bit on.  */
5264       if (GET_MODE_BITSIZE (inner_mode) <= HOST_BITS_PER_WIDE_INT
5265           && (nonzero_bits (inner, inner_mode)
5266               < ((unsigned HOST_WIDE_INT) 1
5267                  << (GET_MODE_BITSIZE (GET_MODE (src)) - 1))))
5268         {
5269           SUBST (SET_SRC (x), inner);
5270           src = SET_SRC (x);
5271         }
5272     }
5273 #endif
5274
5275 #ifdef LOAD_EXTEND_OP
5276   /* If we have (set FOO (subreg:M (mem:N BAR) 0)) with M wider than N, this
5277      would require a paradoxical subreg.  Replace the subreg with a
5278      zero_extend to avoid the reload that would otherwise be required.  */
5279
5280   if (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)
5281       && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (src))) != NIL
5282       && SUBREG_BYTE (src) == 0
5283       && (GET_MODE_SIZE (GET_MODE (src))
5284           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))
5285       && GET_CODE (SUBREG_REG (src)) == MEM)
5286     {
5287       SUBST (SET_SRC (x),
5288              gen_rtx (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (src))),
5289                       GET_MODE (src), SUBREG_REG (src)));
5290
5291       src = SET_SRC (x);
5292     }
5293 #endif
5294
5295   /* If we don't have a conditional move, SET_SRC is an IF_THEN_ELSE, and we
5296      are comparing an item known to be 0 or -1 against 0, use a logical
5297      operation instead. Check for one of the arms being an IOR of the other
5298      arm with some value.  We compute three terms to be IOR'ed together.  In
5299      practice, at most two will be nonzero.  Then we do the IOR's.  */
5300
5301   if (GET_CODE (dest) != PC
5302       && GET_CODE (src) == IF_THEN_ELSE
5303       && GET_MODE_CLASS (GET_MODE (src)) == MODE_INT
5304       && (GET_CODE (XEXP (src, 0)) == EQ || GET_CODE (XEXP (src, 0)) == NE)
5305       && XEXP (XEXP (src, 0), 1) == const0_rtx
5306       && GET_MODE (src) == GET_MODE (XEXP (XEXP (src, 0), 0))
5307 #ifdef HAVE_conditional_move
5308       && ! can_conditionally_move_p (GET_MODE (src))
5309 #endif
5310       && (num_sign_bit_copies (XEXP (XEXP (src, 0), 0),
5311                                GET_MODE (XEXP (XEXP (src, 0), 0)))
5312           == GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (src, 0), 0))))
5313       && ! side_effects_p (src))
5314     {
5315       rtx true_rtx = (GET_CODE (XEXP (src, 0)) == NE
5316                       ? XEXP (src, 1) : XEXP (src, 2));
5317       rtx false_rtx = (GET_CODE (XEXP (src, 0)) == NE
5318                    ? XEXP (src, 2) : XEXP (src, 1));
5319       rtx term1 = const0_rtx, term2, term3;
5320
5321       if (GET_CODE (true_rtx) == IOR
5322           && rtx_equal_p (XEXP (true_rtx, 0), false_rtx))
5323         term1 = false_rtx, true_rtx = XEXP (true_rtx, 1), false_rtx = const0_rtx;
5324       else if (GET_CODE (true_rtx) == IOR
5325                && rtx_equal_p (XEXP (true_rtx, 1), false_rtx))
5326         term1 = false_rtx, true_rtx = XEXP (true_rtx, 0), false_rtx = const0_rtx;
5327       else if (GET_CODE (false_rtx) == IOR
5328                && rtx_equal_p (XEXP (false_rtx, 0), true_rtx))
5329         term1 = true_rtx, false_rtx = XEXP (false_rtx, 1), true_rtx = const0_rtx;
5330       else if (GET_CODE (false_rtx) == IOR
5331                && rtx_equal_p (XEXP (false_rtx, 1), true_rtx))
5332         term1 = true_rtx, false_rtx = XEXP (false_rtx, 0), true_rtx = const0_rtx;
5333
5334       term2 = gen_binary (AND, GET_MODE (src),
5335                           XEXP (XEXP (src, 0), 0), true_rtx);
5336       term3 = gen_binary (AND, GET_MODE (src),
5337                           simplify_gen_unary (NOT, GET_MODE (src),
5338                                               XEXP (XEXP (src, 0), 0),
5339                                               GET_MODE (src)),
5340                           false_rtx);
5341
5342       SUBST (SET_SRC (x),
5343              gen_binary (IOR, GET_MODE (src),
5344                          gen_binary (IOR, GET_MODE (src), term1, term2),
5345                          term3));
5346
5347       src = SET_SRC (x);
5348     }
5349
5350   /* If either SRC or DEST is a CLOBBER of (const_int 0), make this
5351      whole thing fail.  */
5352   if (GET_CODE (src) == CLOBBER && XEXP (src, 0) == const0_rtx)
5353     return src;
5354   else if (GET_CODE (dest) == CLOBBER && XEXP (dest, 0) == const0_rtx)
5355     return dest;
5356   else
5357     /* Convert this into a field assignment operation, if possible.  */
5358     return make_field_assignment (x);
5359 }
5360 \f
5361 /* Simplify, X, and AND, IOR, or XOR operation, and return the simplified
5362    result.  LAST is nonzero if this is the last retry.  */
5363
5364 static rtx
5365 simplify_logical (rtx x, int last)
5366 {
5367   enum machine_mode mode = GET_MODE (x);
5368   rtx op0 = XEXP (x, 0);
5369   rtx op1 = XEXP (x, 1);
5370   rtx reversed;
5371
5372   switch (GET_CODE (x))
5373     {
5374     case AND:
5375       /* Convert (A ^ B) & A to A & (~B) since the latter is often a single
5376          insn (and may simplify more).  */
5377       if (GET_CODE (op0) == XOR
5378           && rtx_equal_p (XEXP (op0, 0), op1)
5379           && ! side_effects_p (op1))
5380         x = gen_binary (AND, mode,
5381                         simplify_gen_unary (NOT, mode, XEXP (op0, 1), mode),
5382                         op1);
5383
5384       if (GET_CODE (op0) == XOR
5385           && rtx_equal_p (XEXP (op0, 1), op1)
5386           && ! side_effects_p (op1))
5387         x = gen_binary (AND, mode,
5388                         simplify_gen_unary (NOT, mode, XEXP (op0, 0), mode),
5389                         op1);
5390
5391       /* Similarly for (~(A ^ B)) & A.  */
5392       if (GET_CODE (op0) == NOT
5393           && GET_CODE (XEXP (op0, 0)) == XOR
5394           && rtx_equal_p (XEXP (XEXP (op0, 0), 0), op1)
5395           && ! side_effects_p (op1))
5396         x = gen_binary (AND, mode, XEXP (XEXP (op0, 0), 1), op1);
5397
5398       if (GET_CODE (op0) == NOT
5399           && GET_CODE (XEXP (op0, 0)) == XOR
5400           && rtx_equal_p (XEXP (XEXP (op0, 0), 1), op1)
5401           && ! side_effects_p (op1))
5402         x = gen_binary (AND, mode, XEXP (XEXP (op0, 0), 0), op1);
5403
5404       /* We can call simplify_and_const_int only if we don't lose
5405          any (sign) bits when converting INTVAL (op1) to
5406          "unsigned HOST_WIDE_INT".  */
5407       if (GET_CODE (op1) == CONST_INT
5408           && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5409               || INTVAL (op1) > 0))
5410         {
5411           x = simplify_and_const_int (x, mode, op0, INTVAL (op1));
5412
5413           /* If we have (ior (and (X C1) C2)) and the next restart would be
5414              the last, simplify this by making C1 as small as possible
5415              and then exit.  */
5416           if (last
5417               && GET_CODE (x) == IOR && GET_CODE (op0) == AND
5418               && GET_CODE (XEXP (op0, 1)) == CONST_INT
5419               && GET_CODE (op1) == CONST_INT)
5420             return gen_binary (IOR, mode,
5421                                gen_binary (AND, mode, XEXP (op0, 0),
5422                                            GEN_INT (INTVAL (XEXP (op0, 1))
5423                                                     & ~INTVAL (op1))), op1);
5424
5425           if (GET_CODE (x) != AND)
5426             return x;
5427
5428           if (GET_RTX_CLASS (GET_CODE (x)) == 'c'
5429               || GET_RTX_CLASS (GET_CODE (x)) == '2')
5430             op0 = XEXP (x, 0), op1 = XEXP (x, 1);
5431         }
5432
5433       /* Convert (A | B) & A to A.  */
5434       if (GET_CODE (op0) == IOR
5435           && (rtx_equal_p (XEXP (op0, 0), op1)
5436               || rtx_equal_p (XEXP (op0, 1), op1))
5437           && ! side_effects_p (XEXP (op0, 0))
5438           && ! side_effects_p (XEXP (op0, 1)))
5439         return op1;
5440
5441       /* In the following group of tests (and those in case IOR below),
5442          we start with some combination of logical operations and apply
5443          the distributive law followed by the inverse distributive law.
5444          Most of the time, this results in no change.  However, if some of
5445          the operands are the same or inverses of each other, simplifications
5446          will result.
5447
5448          For example, (and (ior A B) (not B)) can occur as the result of
5449          expanding a bit field assignment.  When we apply the distributive
5450          law to this, we get (ior (and (A (not B))) (and (B (not B)))),
5451          which then simplifies to (and (A (not B))).
5452
5453          If we have (and (ior A B) C), apply the distributive law and then
5454          the inverse distributive law to see if things simplify.  */
5455
5456       if (GET_CODE (op0) == IOR || GET_CODE (op0) == XOR)
5457         {
5458           x = apply_distributive_law
5459             (gen_binary (GET_CODE (op0), mode,
5460                          gen_binary (AND, mode, XEXP (op0, 0), op1),
5461                          gen_binary (AND, mode, XEXP (op0, 1),
5462                                      copy_rtx (op1))));
5463           if (GET_CODE (x) != AND)
5464             return x;
5465         }
5466
5467       if (GET_CODE (op1) == IOR || GET_CODE (op1) == XOR)
5468         return apply_distributive_law
5469           (gen_binary (GET_CODE (op1), mode,
5470                        gen_binary (AND, mode, XEXP (op1, 0), op0),
5471                        gen_binary (AND, mode, XEXP (op1, 1),
5472                                    copy_rtx (op0))));
5473
5474       /* Similarly, taking advantage of the fact that
5475          (and (not A) (xor B C)) == (xor (ior A B) (ior A C))  */
5476
5477       if (GET_CODE (op0) == NOT && GET_CODE (op1) == XOR)
5478         return apply_distributive_law
5479           (gen_binary (XOR, mode,
5480                        gen_binary (IOR, mode, XEXP (op0, 0), XEXP (op1, 0)),
5481                        gen_binary (IOR, mode, copy_rtx (XEXP (op0, 0)),
5482                                    XEXP (op1, 1))));
5483
5484       else if (GET_CODE (op1) == NOT && GET_CODE (op0) == XOR)
5485         return apply_distributive_law
5486           (gen_binary (XOR, mode,
5487                        gen_binary (IOR, mode, XEXP (op1, 0), XEXP (op0, 0)),
5488                        gen_binary (IOR, mode, copy_rtx (XEXP (op1, 0)), XEXP (op0, 1))));
5489       break;
5490
5491     case IOR:
5492       /* (ior A C) is C if all bits of A that might be nonzero are on in C.  */
5493       if (GET_CODE (op1) == CONST_INT
5494           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5495           && (nonzero_bits (op0, mode) & ~INTVAL (op1)) == 0)
5496         return op1;
5497
5498       /* Convert (A & B) | A to A.  */
5499       if (GET_CODE (op0) == AND
5500           && (rtx_equal_p (XEXP (op0, 0), op1)
5501               || rtx_equal_p (XEXP (op0, 1), op1))
5502           && ! side_effects_p (XEXP (op0, 0))
5503           && ! side_effects_p (XEXP (op0, 1)))
5504         return op1;
5505
5506       /* If we have (ior (and A B) C), apply the distributive law and then
5507          the inverse distributive law to see if things simplify.  */
5508
5509       if (GET_CODE (op0) == AND)
5510         {
5511           x = apply_distributive_law
5512             (gen_binary (AND, mode,
5513                          gen_binary (IOR, mode, XEXP (op0, 0), op1),
5514                          gen_binary (IOR, mode, XEXP (op0, 1),
5515                                      copy_rtx (op1))));
5516
5517           if (GET_CODE (x) != IOR)
5518             return x;
5519         }
5520
5521       if (GET_CODE (op1) == AND)
5522         {
5523           x = apply_distributive_law
5524             (gen_binary (AND, mode,
5525                          gen_binary (IOR, mode, XEXP (op1, 0), op0),
5526                          gen_binary (IOR, mode, XEXP (op1, 1),
5527                                      copy_rtx (op0))));
5528
5529           if (GET_CODE (x) != IOR)
5530             return x;
5531         }
5532
5533       /* Convert (ior (ashift A CX) (lshiftrt A CY)) where CX+CY equals the
5534          mode size to (rotate A CX).  */
5535
5536       if (((GET_CODE (op0) == ASHIFT && GET_CODE (op1) == LSHIFTRT)
5537            || (GET_CODE (op1) == ASHIFT && GET_CODE (op0) == LSHIFTRT))
5538           && rtx_equal_p (XEXP (op0, 0), XEXP (op1, 0))
5539           && GET_CODE (XEXP (op0, 1)) == CONST_INT
5540           && GET_CODE (XEXP (op1, 1)) == CONST_INT
5541           && (INTVAL (XEXP (op0, 1)) + INTVAL (XEXP (op1, 1))
5542               == GET_MODE_BITSIZE (mode)))
5543         return gen_rtx_ROTATE (mode, XEXP (op0, 0),
5544                                (GET_CODE (op0) == ASHIFT
5545                                 ? XEXP (op0, 1) : XEXP (op1, 1)));
5546
5547       /* If OP0 is (ashiftrt (plus ...) C), it might actually be
5548          a (sign_extend (plus ...)).  If so, OP1 is a CONST_INT, and the PLUS
5549          does not affect any of the bits in OP1, it can really be done
5550          as a PLUS and we can associate.  We do this by seeing if OP1
5551          can be safely shifted left C bits.  */
5552       if (GET_CODE (op1) == CONST_INT && GET_CODE (op0) == ASHIFTRT
5553           && GET_CODE (XEXP (op0, 0)) == PLUS
5554           && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
5555           && GET_CODE (XEXP (op0, 1)) == CONST_INT
5556           && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT)
5557         {
5558           int count = INTVAL (XEXP (op0, 1));
5559           HOST_WIDE_INT mask = INTVAL (op1) << count;
5560
5561           if (mask >> count == INTVAL (op1)
5562               && (mask & nonzero_bits (XEXP (op0, 0), mode)) == 0)
5563             {
5564               SUBST (XEXP (XEXP (op0, 0), 1),
5565                      GEN_INT (INTVAL (XEXP (XEXP (op0, 0), 1)) | mask));
5566               return op0;
5567             }
5568         }
5569       break;
5570
5571     case XOR:
5572       /* If we are XORing two things that have no bits in common,
5573          convert them into an IOR.  This helps to detect rotation encoded
5574          using those methods and possibly other simplifications.  */
5575
5576       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5577           && (nonzero_bits (op0, mode)
5578               & nonzero_bits (op1, mode)) == 0)
5579         return (gen_binary (IOR, mode, op0, op1));
5580
5581       /* Convert (XOR (NOT x) (NOT y)) to (XOR x y).
5582          Also convert (XOR (NOT x) y) to (NOT (XOR x y)), similarly for
5583          (NOT y).  */
5584       {
5585         int num_negated = 0;
5586
5587         if (GET_CODE (op0) == NOT)
5588           num_negated++, op0 = XEXP (op0, 0);
5589         if (GET_CODE (op1) == NOT)
5590           num_negated++, op1 = XEXP (op1, 0);
5591
5592         if (num_negated == 2)
5593           {
5594             SUBST (XEXP (x, 0), op0);
5595             SUBST (XEXP (x, 1), op1);
5596           }
5597         else if (num_negated == 1)
5598           return
5599             simplify_gen_unary (NOT, mode, gen_binary (XOR, mode, op0, op1),
5600                                 mode);
5601       }
5602
5603       /* Convert (xor (and A B) B) to (and (not A) B).  The latter may
5604          correspond to a machine insn or result in further simplifications
5605          if B is a constant.  */
5606
5607       if (GET_CODE (op0) == AND
5608           && rtx_equal_p (XEXP (op0, 1), op1)
5609           && ! side_effects_p (op1))
5610         return gen_binary (AND, mode,
5611                            simplify_gen_unary (NOT, mode, XEXP (op0, 0), mode),
5612                            op1);
5613
5614       else if (GET_CODE (op0) == AND
5615                && rtx_equal_p (XEXP (op0, 0), op1)
5616                && ! side_effects_p (op1))
5617         return gen_binary (AND, mode,
5618                            simplify_gen_unary (NOT, mode, XEXP (op0, 1), mode),
5619                            op1);
5620
5621       /* (xor (comparison foo bar) (const_int 1)) can become the reversed
5622          comparison if STORE_FLAG_VALUE is 1.  */
5623       if (STORE_FLAG_VALUE == 1
5624           && op1 == const1_rtx
5625           && GET_RTX_CLASS (GET_CODE (op0)) == '<'
5626           && (reversed = reversed_comparison (op0, mode, XEXP (op0, 0),
5627                                               XEXP (op0, 1))))
5628         return reversed;
5629
5630       /* (lshiftrt foo C) where C is the number of bits in FOO minus 1
5631          is (lt foo (const_int 0)), so we can perform the above
5632          simplification if STORE_FLAG_VALUE is 1.  */
5633
5634       if (STORE_FLAG_VALUE == 1
5635           && op1 == const1_rtx
5636           && GET_CODE (op0) == LSHIFTRT
5637           && GET_CODE (XEXP (op0, 1)) == CONST_INT
5638           && INTVAL (XEXP (op0, 1)) == GET_MODE_BITSIZE (mode) - 1)
5639         return gen_rtx_GE (mode, XEXP (op0, 0), const0_rtx);
5640
5641       /* (xor (comparison foo bar) (const_int sign-bit))
5642          when STORE_FLAG_VALUE is the sign bit.  */
5643       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5644           && ((STORE_FLAG_VALUE & GET_MODE_MASK (mode))
5645               == (unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (mode) - 1))
5646           && op1 == const_true_rtx
5647           && GET_RTX_CLASS (GET_CODE (op0)) == '<'
5648           && (reversed = reversed_comparison (op0, mode, XEXP (op0, 0),
5649                                               XEXP (op0, 1))))
5650         return reversed;
5651
5652       break;
5653
5654     default:
5655       abort ();
5656     }
5657
5658   return x;
5659 }
5660 \f
5661 /* We consider ZERO_EXTRACT, SIGN_EXTRACT, and SIGN_EXTEND as "compound
5662    operations" because they can be replaced with two more basic operations.
5663    ZERO_EXTEND is also considered "compound" because it can be replaced with
5664    an AND operation, which is simpler, though only one operation.
5665
5666    The function expand_compound_operation is called with an rtx expression
5667    and will convert it to the appropriate shifts and AND operations,
5668    simplifying at each stage.
5669
5670    The function make_compound_operation is called to convert an expression
5671    consisting of shifts and ANDs into the equivalent compound expression.
5672    It is the inverse of this function, loosely speaking.  */
5673
5674 static rtx
5675 expand_compound_operation (rtx x)
5676 {
5677   unsigned HOST_WIDE_INT pos = 0, len;
5678   int unsignedp = 0;
5679   unsigned int modewidth;
5680   rtx tem;
5681
5682   switch (GET_CODE (x))
5683     {
5684     case ZERO_EXTEND:
5685       unsignedp = 1;
5686     case SIGN_EXTEND:
5687       /* We can't necessarily use a const_int for a multiword mode;
5688          it depends on implicitly extending the value.
5689          Since we don't know the right way to extend it,
5690          we can't tell whether the implicit way is right.
5691
5692          Even for a mode that is no wider than a const_int,
5693          we can't win, because we need to sign extend one of its bits through
5694          the rest of it, and we don't know which bit.  */
5695       if (GET_CODE (XEXP (x, 0)) == CONST_INT)
5696         return x;
5697
5698       /* Return if (subreg:MODE FROM 0) is not a safe replacement for
5699          (zero_extend:MODE FROM) or (sign_extend:MODE FROM).  It is for any MEM
5700          because (SUBREG (MEM...)) is guaranteed to cause the MEM to be
5701          reloaded. If not for that, MEM's would very rarely be safe.
5702
5703          Reject MODEs bigger than a word, because we might not be able
5704          to reference a two-register group starting with an arbitrary register
5705          (and currently gen_lowpart might crash for a SUBREG).  */
5706
5707       if (GET_MODE_SIZE (GET_MODE (XEXP (x, 0))) > UNITS_PER_WORD)
5708         return x;
5709
5710       /* Reject MODEs that aren't scalar integers because turning vector
5711          or complex modes into shifts causes problems.  */
5712
5713       if (! SCALAR_INT_MODE_P (GET_MODE (XEXP (x, 0))))
5714         return x;
5715
5716       len = GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)));
5717       /* If the inner object has VOIDmode (the only way this can happen
5718          is if it is an ASM_OPERANDS), we can't do anything since we don't
5719          know how much masking to do.  */
5720       if (len == 0)
5721         return x;
5722
5723       break;
5724
5725     case ZERO_EXTRACT:
5726       unsignedp = 1;
5727     case SIGN_EXTRACT:
5728       /* If the operand is a CLOBBER, just return it.  */
5729       if (GET_CODE (XEXP (x, 0)) == CLOBBER)
5730         return XEXP (x, 0);
5731
5732       if (GET_CODE (XEXP (x, 1)) != CONST_INT
5733           || GET_CODE (XEXP (x, 2)) != CONST_INT
5734           || GET_MODE (XEXP (x, 0)) == VOIDmode)
5735         return x;
5736
5737       /* Reject MODEs that aren't scalar integers because turning vector
5738          or complex modes into shifts causes problems.  */
5739
5740       if (! SCALAR_INT_MODE_P (GET_MODE (XEXP (x, 0))))
5741         return x;
5742
5743       len = INTVAL (XEXP (x, 1));
5744       pos = INTVAL (XEXP (x, 2));
5745
5746       /* If this goes outside the object being extracted, replace the object
5747          with a (use (mem ...)) construct that only combine understands
5748          and is used only for this purpose.  */
5749       if (len + pos > GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))))
5750         SUBST (XEXP (x, 0), gen_rtx_USE (GET_MODE (x), XEXP (x, 0)));
5751
5752       if (BITS_BIG_ENDIAN)
5753         pos = GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - len - pos;
5754
5755       break;
5756
5757     default:
5758       return x;
5759     }
5760   /* Convert sign extension to zero extension, if we know that the high
5761      bit is not set, as this is easier to optimize.  It will be converted
5762      back to cheaper alternative in make_extraction.  */
5763   if (GET_CODE (x) == SIGN_EXTEND
5764       && (GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
5765           && ((nonzero_bits (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
5766                 & ~(((unsigned HOST_WIDE_INT)
5767                       GET_MODE_MASK (GET_MODE (XEXP (x, 0))))
5768                      >> 1))
5769                == 0)))
5770     {
5771       rtx temp = gen_rtx_ZERO_EXTEND (GET_MODE (x), XEXP (x, 0));
5772       rtx temp2 = expand_compound_operation (temp);
5773
5774       /* Make sure this is a profitable operation.  */
5775       if (rtx_cost (x, SET) > rtx_cost (temp2, SET))
5776        return temp2;
5777       else if (rtx_cost (x, SET) > rtx_cost (temp, SET))
5778        return temp;
5779       else
5780        return x;
5781     }
5782
5783   /* We can optimize some special cases of ZERO_EXTEND.  */
5784   if (GET_CODE (x) == ZERO_EXTEND)
5785     {
5786       /* (zero_extend:DI (truncate:SI foo:DI)) is just foo:DI if we
5787          know that the last value didn't have any inappropriate bits
5788          set.  */
5789       if (GET_CODE (XEXP (x, 0)) == TRUNCATE
5790           && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
5791           && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
5792           && (nonzero_bits (XEXP (XEXP (x, 0), 0), GET_MODE (x))
5793               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
5794         return XEXP (XEXP (x, 0), 0);
5795
5796       /* Likewise for (zero_extend:DI (subreg:SI foo:DI 0)).  */
5797       if (GET_CODE (XEXP (x, 0)) == SUBREG
5798           && GET_MODE (SUBREG_REG (XEXP (x, 0))) == GET_MODE (x)
5799           && subreg_lowpart_p (XEXP (x, 0))
5800           && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
5801           && (nonzero_bits (SUBREG_REG (XEXP (x, 0)), GET_MODE (x))
5802               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
5803         return SUBREG_REG (XEXP (x, 0));
5804
5805       /* (zero_extend:DI (truncate:SI foo:DI)) is just foo:DI when foo
5806          is a comparison and STORE_FLAG_VALUE permits.  This is like
5807          the first case, but it works even when GET_MODE (x) is larger
5808          than HOST_WIDE_INT.  */
5809       if (GET_CODE (XEXP (x, 0)) == TRUNCATE
5810           && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
5811           && GET_RTX_CLASS (GET_CODE (XEXP (XEXP (x, 0), 0))) == '<'
5812           && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
5813               <= HOST_BITS_PER_WIDE_INT)
5814           && ((HOST_WIDE_INT) STORE_FLAG_VALUE
5815               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
5816         return XEXP (XEXP (x, 0), 0);
5817
5818       /* Likewise for (zero_extend:DI (subreg:SI foo:DI 0)).  */
5819       if (GET_CODE (XEXP (x, 0)) == SUBREG
5820           && GET_MODE (SUBREG_REG (XEXP (x, 0))) == GET_MODE (x)
5821           && subreg_lowpart_p (XEXP (x, 0))
5822           && GET_RTX_CLASS (GET_CODE (SUBREG_REG (XEXP (x, 0)))) == '<'
5823           && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
5824               <= HOST_BITS_PER_WIDE_INT)
5825           && ((HOST_WIDE_INT) STORE_FLAG_VALUE
5826               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
5827         return SUBREG_REG (XEXP (x, 0));
5828
5829     }
5830
5831   /* If we reach here, we want to return a pair of shifts.  The inner
5832      shift is a left shift of BITSIZE - POS - LEN bits.  The outer
5833      shift is a right shift of BITSIZE - LEN bits.  It is arithmetic or
5834      logical depending on the value of UNSIGNEDP.
5835
5836      If this was a ZERO_EXTEND or ZERO_EXTRACT, this pair of shifts will be
5837      converted into an AND of a shift.
5838
5839      We must check for the case where the left shift would have a negative
5840      count.  This can happen in a case like (x >> 31) & 255 on machines
5841      that can't shift by a constant.  On those machines, we would first
5842      combine the shift with the AND to produce a variable-position
5843      extraction.  Then the constant of 31 would be substituted in to produce
5844      a such a position.  */
5845
5846   modewidth = GET_MODE_BITSIZE (GET_MODE (x));
5847   if (modewidth + len >= pos)
5848     tem = simplify_shift_const (NULL_RTX, unsignedp ? LSHIFTRT : ASHIFTRT,
5849                                 GET_MODE (x),
5850                                 simplify_shift_const (NULL_RTX, ASHIFT,
5851                                                       GET_MODE (x),
5852                                                       XEXP (x, 0),
5853                                                       modewidth - pos - len),
5854                                 modewidth - len);
5855
5856   else if (unsignedp && len < HOST_BITS_PER_WIDE_INT)
5857     tem = simplify_and_const_int (NULL_RTX, GET_MODE (x),
5858                                   simplify_shift_const (NULL_RTX, LSHIFTRT,
5859                                                         GET_MODE (x),
5860                                                         XEXP (x, 0), pos),
5861                                   ((HOST_WIDE_INT) 1 << len) - 1);
5862   else
5863     /* Any other cases we can't handle.  */
5864     return x;
5865
5866   /* If we couldn't do this for some reason, return the original
5867      expression.  */
5868   if (GET_CODE (tem) == CLOBBER)
5869     return x;
5870
5871   return tem;
5872 }
5873 \f
5874 /* X is a SET which contains an assignment of one object into
5875    a part of another (such as a bit-field assignment, STRICT_LOW_PART,
5876    or certain SUBREGS). If possible, convert it into a series of
5877    logical operations.
5878
5879    We half-heartedly support variable positions, but do not at all
5880    support variable lengths.  */
5881
5882 static rtx
5883 expand_field_assignment (rtx x)
5884 {
5885   rtx inner;
5886   rtx pos;                      /* Always counts from low bit.  */
5887   int len;
5888   rtx mask;
5889   enum machine_mode compute_mode;
5890
5891   /* Loop until we find something we can't simplify.  */
5892   while (1)
5893     {
5894       if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART
5895           && GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG)
5896         {
5897           inner = SUBREG_REG (XEXP (SET_DEST (x), 0));
5898           len = GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)));
5899           pos = GEN_INT (subreg_lsb (XEXP (SET_DEST (x), 0)));
5900         }
5901       else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
5902                && GET_CODE (XEXP (SET_DEST (x), 1)) == CONST_INT)
5903         {
5904           inner = XEXP (SET_DEST (x), 0);
5905           len = INTVAL (XEXP (SET_DEST (x), 1));
5906           pos = XEXP (SET_DEST (x), 2);
5907
5908           /* If the position is constant and spans the width of INNER,
5909              surround INNER  with a USE to indicate this.  */
5910           if (GET_CODE (pos) == CONST_INT
5911               && INTVAL (pos) + len > GET_MODE_BITSIZE (GET_MODE (inner)))
5912             inner = gen_rtx_USE (GET_MODE (SET_DEST (x)), inner);
5913
5914           if (BITS_BIG_ENDIAN)
5915             {
5916               if (GET_CODE (pos) == CONST_INT)
5917                 pos = GEN_INT (GET_MODE_BITSIZE (GET_MODE (inner)) - len
5918                                - INTVAL (pos));
5919               else if (GET_CODE (pos) == MINUS
5920                        && GET_CODE (XEXP (pos, 1)) == CONST_INT
5921                        && (INTVAL (XEXP (pos, 1))
5922                            == GET_MODE_BITSIZE (GET_MODE (inner)) - len))
5923                 /* If position is ADJUST - X, new position is X.  */
5924                 pos = XEXP (pos, 0);
5925               else
5926                 pos = gen_binary (MINUS, GET_MODE (pos),
5927                                   GEN_INT (GET_MODE_BITSIZE (GET_MODE (inner))
5928                                            - len),
5929                                   pos);
5930             }
5931         }
5932
5933       /* A SUBREG between two modes that occupy the same numbers of words
5934          can be done by moving the SUBREG to the source.  */
5935       else if (GET_CODE (SET_DEST (x)) == SUBREG
5936                /* We need SUBREGs to compute nonzero_bits properly.  */
5937                && nonzero_sign_valid
5938                && (((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
5939                      + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
5940                    == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
5941                         + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
5942         {
5943           x = gen_rtx_SET (VOIDmode, SUBREG_REG (SET_DEST (x)),
5944                            gen_lowpart_for_combine
5945                            (GET_MODE (SUBREG_REG (SET_DEST (x))),
5946                             SET_SRC (x)));
5947           continue;
5948         }
5949       else
5950         break;
5951
5952       while (GET_CODE (inner) == SUBREG && subreg_lowpart_p (inner))
5953         inner = SUBREG_REG (inner);
5954
5955       compute_mode = GET_MODE (inner);
5956
5957       /* Don't attempt bitwise arithmetic on non scalar integer modes.  */
5958       if (! SCALAR_INT_MODE_P (compute_mode))
5959         {
5960           enum machine_mode imode;
5961
5962           /* Don't do anything for vector or complex integral types.  */
5963           if (! FLOAT_MODE_P (compute_mode))
5964             break;
5965
5966           /* Try to find an integral mode to pun with.  */
5967           imode = mode_for_size (GET_MODE_BITSIZE (compute_mode), MODE_INT, 0);
5968           if (imode == BLKmode)
5969             break;
5970
5971           compute_mode = imode;
5972           inner = gen_lowpart_for_combine (imode, inner);
5973         }
5974
5975       /* Compute a mask of LEN bits, if we can do this on the host machine.  */
5976       if (len < HOST_BITS_PER_WIDE_INT)
5977         mask = GEN_INT (((HOST_WIDE_INT) 1 << len) - 1);
5978       else
5979         break;
5980
5981       /* Now compute the equivalent expression.  Make a copy of INNER
5982          for the SET_DEST in case it is a MEM into which we will substitute;
5983          we don't want shared RTL in that case.  */
5984       x = gen_rtx_SET
5985         (VOIDmode, copy_rtx (inner),
5986          gen_binary (IOR, compute_mode,
5987                      gen_binary (AND, compute_mode,
5988                                  simplify_gen_unary (NOT, compute_mode,
5989                                                      gen_binary (ASHIFT,
5990                                                                  compute_mode,
5991                                                                  mask, pos),
5992                                                      compute_mode),
5993                                  inner),
5994                      gen_binary (ASHIFT, compute_mode,
5995                                  gen_binary (AND, compute_mode,
5996                                              gen_lowpart_for_combine
5997                                              (compute_mode, SET_SRC (x)),
5998                                              mask),
5999                                  pos)));
6000     }
6001
6002   return x;
6003 }
6004 \f
6005 /* Return an RTX for a reference to LEN bits of INNER.  If POS_RTX is nonzero,
6006    it is an RTX that represents a variable starting position; otherwise,
6007    POS is the (constant) starting bit position (counted from the LSB).
6008
6009    INNER may be a USE.  This will occur when we started with a bitfield
6010    that went outside the boundary of the object in memory, which is
6011    allowed on most machines.  To isolate this case, we produce a USE
6012    whose mode is wide enough and surround the MEM with it.  The only
6013    code that understands the USE is this routine.  If it is not removed,
6014    it will cause the resulting insn not to match.
6015
6016    UNSIGNEDP is nonzero for an unsigned reference and zero for a
6017    signed reference.
6018
6019    IN_DEST is nonzero if this is a reference in the destination of a
6020    SET.  This is used when a ZERO_ or SIGN_EXTRACT isn't needed.  If nonzero,
6021    a STRICT_LOW_PART will be used, if zero, ZERO_EXTEND or SIGN_EXTEND will
6022    be used.
6023
6024    IN_COMPARE is nonzero if we are in a COMPARE.  This means that a
6025    ZERO_EXTRACT should be built even for bits starting at bit 0.
6026
6027    MODE is the desired mode of the result (if IN_DEST == 0).
6028
6029    The result is an RTX for the extraction or NULL_RTX if the target
6030    can't handle it.  */
6031
6032 static rtx
6033 make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
6034                  rtx pos_rtx, unsigned HOST_WIDE_INT len, int unsignedp,
6035                  int in_dest, int in_compare)
6036 {
6037   /* This mode describes the size of the storage area
6038      to fetch the overall value from.  Within that, we
6039      ignore the POS lowest bits, etc.  */
6040   enum machine_mode is_mode = GET_MODE (inner);
6041   enum machine_mode inner_mode;
6042   enum machine_mode wanted_inner_mode = byte_mode;
6043   enum machine_mode wanted_inner_reg_mode = word_mode;
6044   enum machine_mode pos_mode = word_mode;
6045   enum machine_mode extraction_mode = word_mode;
6046   enum machine_mode tmode = mode_for_size (len, MODE_INT, 1);
6047   int spans_byte = 0;
6048   rtx new = 0;
6049   rtx orig_pos_rtx = pos_rtx;
6050   HOST_WIDE_INT orig_pos;
6051
6052   /* Get some information about INNER and get the innermost object.  */
6053   if (GET_CODE (inner) == USE)
6054     /* (use:SI (mem:QI foo)) stands for (mem:SI foo).  */
6055     /* We don't need to adjust the position because we set up the USE
6056        to pretend that it was a full-word object.  */
6057     spans_byte = 1, inner = XEXP (inner, 0);
6058   else if (GET_CODE (inner) == SUBREG && subreg_lowpart_p (inner))
6059     {
6060       /* If going from (subreg:SI (mem:QI ...)) to (mem:QI ...),
6061          consider just the QI as the memory to extract from.
6062          The subreg adds or removes high bits; its mode is
6063          irrelevant to the meaning of this extraction,
6064          since POS and LEN count from the lsb.  */
6065       if (GET_CODE (SUBREG_REG (inner)) == MEM)
6066         is_mode = GET_MODE (SUBREG_REG (inner));
6067       inner = SUBREG_REG (inner);
6068     }
6069   else if (GET_CODE (inner) == ASHIFT
6070            && GET_CODE (XEXP (inner, 1)) == CONST_INT
6071            && pos_rtx == 0 && pos == 0
6072            && len > (unsigned HOST_WIDE_INT) INTVAL (XEXP (inner, 1)))
6073     {
6074       /* We're extracting the least significant bits of an rtx
6075          (ashift X (const_int C)), where LEN > C.  Extract the
6076          least significant (LEN - C) bits of X, giving an rtx
6077          whose mode is MODE, then shift it left C times.  */
6078       new = make_extraction (mode, XEXP (inner, 0),
6079                              0, 0, len - INTVAL (XEXP (inner, 1)),
6080                              unsignedp, in_dest, in_compare);
6081       if (new != 0)
6082         return gen_rtx_ASHIFT (mode, new, XEXP (inner, 1));
6083     }
6084
6085   inner_mode = GET_MODE (inner);
6086
6087   if (pos_rtx && GET_CODE (pos_rtx) == CONST_INT)
6088     pos = INTVAL (pos_rtx), pos_rtx = 0;
6089
6090   /* See if this can be done without an extraction.  We never can if the
6091      width of the field is not the same as that of some integer mode. For
6092      registers, we can only avoid the extraction if the position is at the
6093      low-order bit and this is either not in the destination or we have the
6094      appropriate STRICT_LOW_PART operation available.
6095
6096      For MEM, we can avoid an extract if the field starts on an appropriate
6097      boundary and we can change the mode of the memory reference.  However,
6098      we cannot directly access the MEM if we have a USE and the underlying
6099      MEM is not TMODE.  This combination means that MEM was being used in a
6100      context where bits outside its mode were being referenced; that is only
6101      valid in bit-field insns.  */
6102
6103   if (tmode != BLKmode
6104       && ! (spans_byte && inner_mode != tmode)
6105       && ((pos_rtx == 0 && (pos % BITS_PER_WORD) == 0
6106            && GET_CODE (inner) != MEM
6107            && (! in_dest
6108                || (GET_CODE (inner) == REG
6109                    && have_insn_for (STRICT_LOW_PART, tmode))))
6110           || (GET_CODE (inner) == MEM && pos_rtx == 0
6111               && (pos
6112                   % (STRICT_ALIGNMENT ? GET_MODE_ALIGNMENT (tmode)
6113                      : BITS_PER_UNIT)) == 0
6114               /* We can't do this if we are widening INNER_MODE (it
6115                  may not be aligned, for one thing).  */
6116               && GET_MODE_BITSIZE (inner_mode) >= GET_MODE_BITSIZE (tmode)
6117               && (inner_mode == tmode
6118                   || (! mode_dependent_address_p (XEXP (inner, 0))
6119                       && ! MEM_VOLATILE_P (inner))))))
6120     {
6121       /* If INNER is a MEM, make a new MEM that encompasses just the desired
6122          field.  If the original and current mode are the same, we need not
6123          adjust the offset.  Otherwise, we do if bytes big endian.
6124
6125          If INNER is not a MEM, get a piece consisting of just the field
6126          of interest (in this case POS % BITS_PER_WORD must be 0).  */
6127
6128       if (GET_CODE (inner) == MEM)
6129         {
6130           HOST_WIDE_INT offset;
6131
6132           /* POS counts from lsb, but make OFFSET count in memory order.  */
6133           if (BYTES_BIG_ENDIAN)
6134             offset = (GET_MODE_BITSIZE (is_mode) - len - pos) / BITS_PER_UNIT;
6135           else
6136             offset = pos / BITS_PER_UNIT;
6137
6138           new = adjust_address_nv (inner, tmode, offset);
6139         }
6140       else if (GET_CODE (inner) == REG)
6141         {
6142           /* We can't call gen_lowpart_for_combine here since we always want
6143              a SUBREG and it would sometimes return a new hard register.  */
6144           if (tmode != inner_mode)
6145             {
6146               HOST_WIDE_INT final_word = pos / BITS_PER_WORD;
6147
6148               if (WORDS_BIG_ENDIAN
6149                   && GET_MODE_SIZE (inner_mode) > UNITS_PER_WORD)
6150                 final_word = ((GET_MODE_SIZE (inner_mode)
6151                                - GET_MODE_SIZE (tmode))
6152                               / UNITS_PER_WORD) - final_word;
6153
6154               final_word *= UNITS_PER_WORD;
6155               if (BYTES_BIG_ENDIAN &&
6156                   GET_MODE_SIZE (inner_mode) > GET_MODE_SIZE (tmode))
6157                 final_word += (GET_MODE_SIZE (inner_mode)
6158                                - GET_MODE_SIZE (tmode)) % UNITS_PER_WORD;
6159
6160               /* Avoid creating invalid subregs, for example when
6161                  simplifying (x>>32)&255.  */
6162               if (final_word >= GET_MODE_SIZE (inner_mode))
6163                 return NULL_RTX;
6164
6165               new = gen_rtx_SUBREG (tmode, inner, final_word);
6166             }
6167           else
6168             new = inner;
6169         }
6170       else
6171         new = force_to_mode (inner, tmode,
6172                              len >= HOST_BITS_PER_WIDE_INT
6173                              ? ~(unsigned HOST_WIDE_INT) 0
6174                              : ((unsigned HOST_WIDE_INT) 1 << len) - 1,
6175                              NULL_RTX, 0);
6176
6177       /* If this extraction is going into the destination of a SET,
6178          make a STRICT_LOW_PART unless we made a MEM.  */
6179
6180       if (in_dest)
6181         return (GET_CODE (new) == MEM ? new
6182                 : (GET_CODE (new) != SUBREG
6183                    ? gen_rtx_CLOBBER (tmode, const0_rtx)
6184                    : gen_rtx_STRICT_LOW_PART (VOIDmode, new)));
6185
6186       if (mode == tmode)
6187         return new;
6188
6189       if (GET_CODE (new) == CONST_INT)
6190         return gen_int_mode (INTVAL (new), mode);
6191
6192       /* If we know that no extraneous bits are set, and that the high
6193          bit is not set, convert the extraction to the cheaper of
6194          sign and zero extension, that are equivalent in these cases.  */
6195       if (flag_expensive_optimizations
6196           && (GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT
6197               && ((nonzero_bits (new, tmode)
6198                    & ~(((unsigned HOST_WIDE_INT)
6199                         GET_MODE_MASK (tmode))
6200                        >> 1))
6201                   == 0)))
6202         {
6203           rtx temp = gen_rtx_ZERO_EXTEND (mode, new);
6204           rtx temp1 = gen_rtx_SIGN_EXTEND (mode, new);
6205
6206           /* Prefer ZERO_EXTENSION, since it gives more information to
6207              backends.  */
6208           if (rtx_cost (temp, SET) <= rtx_cost (temp1, SET))
6209             return temp;
6210           return temp1;
6211         }
6212
6213       /* Otherwise, sign- or zero-extend unless we already are in the
6214          proper mode.  */
6215
6216       return (gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND,
6217                              mode, new));
6218     }
6219
6220   /* Unless this is a COMPARE or we have a funny memory reference,
6221      don't do anything with zero-extending field extracts starting at
6222      the low-order bit since they are simple AND operations.  */
6223   if (pos_rtx == 0 && pos == 0 && ! in_dest
6224       && ! in_compare && ! spans_byte && unsignedp)
6225     return 0;
6226
6227   /* Unless we are allowed to span bytes or INNER is not MEM, reject this if
6228      we would be spanning bytes or if the position is not a constant and the
6229      length is not 1.  In all other cases, we would only be going outside
6230      our object in cases when an original shift would have been
6231      undefined.  */
6232   if (! spans_byte && GET_CODE (inner) == MEM
6233       && ((pos_rtx == 0 && pos + len > GET_MODE_BITSIZE (is_mode))
6234           || (pos_rtx != 0 && len != 1)))
6235     return 0;
6236
6237   /* Get the mode to use should INNER not be a MEM, the mode for the position,
6238      and the mode for the result.  */
6239   if (in_dest && mode_for_extraction (EP_insv, -1) != MAX_MACHINE_MODE)
6240     {
6241       wanted_inner_reg_mode = mode_for_extraction (EP_insv, 0);
6242       pos_mode = mode_for_extraction (EP_insv, 2);
6243       extraction_mode = mode_for_extraction (EP_insv, 3);
6244     }
6245
6246   if (! in_dest && unsignedp
6247       && mode_for_extraction (EP_extzv, -1) != MAX_MACHINE_MODE)
6248     {
6249       wanted_inner_reg_mode = mode_for_extraction (EP_extzv, 1);
6250       pos_mode = mode_for_extraction (EP_extzv, 3);
6251       extraction_mode = mode_for_extraction (EP_extzv, 0);
6252     }
6253
6254   if (! in_dest && ! unsignedp
6255       && mode_for_extraction (EP_extv, -1) != MAX_MACHINE_MODE)
6256     {
6257       wanted_inner_reg_mode = mode_for_extraction (EP_extv, 1);
6258       pos_mode = mode_for_extraction (EP_extv, 3);
6259       extraction_mode = mode_for_extraction (EP_extv, 0);
6260     }
6261
6262   /* Never narrow an object, since that might not be safe.  */
6263
6264   if (mode != VOIDmode
6265       && GET_MODE_SIZE (extraction_mode) < GET_MODE_SIZE (mode))
6266     extraction_mode = mode;
6267
6268   if (pos_rtx && GET_MODE (pos_rtx) != VOIDmode
6269       && GET_MODE_SIZE (pos_mode) < GET_MODE_SIZE (GET_MODE (pos_rtx)))
6270     pos_mode = GET_MODE (pos_rtx);
6271
6272   /* If this is not from memory, the desired mode is wanted_inner_reg_mode;
6273      if we have to change the mode of memory and cannot, the desired mode is
6274      EXTRACTION_MODE.  */
6275   if (GET_CODE (inner) != MEM)
6276     wanted_inner_mode = wanted_inner_reg_mode;
6277   else if (inner_mode != wanted_inner_mode
6278            && (mode_dependent_address_p (XEXP (inner, 0))
6279                || MEM_VOLATILE_P (inner)))
6280     wanted_inner_mode = extraction_mode;
6281
6282   orig_pos = pos;
6283
6284   if (BITS_BIG_ENDIAN)
6285     {
6286       /* POS is passed as if BITS_BIG_ENDIAN == 0, so we need to convert it to
6287          BITS_BIG_ENDIAN style.  If position is constant, compute new
6288          position.  Otherwise, build subtraction.
6289          Note that POS is relative to the mode of the original argument.
6290          If it's a MEM we need to recompute POS relative to that.
6291          However, if we're extracting from (or inserting into) a register,
6292          we want to recompute POS relative to wanted_inner_mode.  */
6293       int width = (GET_CODE (inner) == MEM
6294                    ? GET_MODE_BITSIZE (is_mode)
6295                    : GET_MODE_BITSIZE (wanted_inner_mode));
6296
6297       if (pos_rtx == 0)
6298         pos = width - len - pos;
6299       else
6300         pos_rtx
6301           = gen_rtx_MINUS (GET_MODE (pos_rtx), GEN_INT (width - len), pos_rtx);
6302       /* POS may be less than 0 now, but we check for that below.
6303          Note that it can only be less than 0 if GET_CODE (inner) != MEM.  */
6304     }
6305
6306   /* If INNER has a wider mode, make it smaller.  If this is a constant
6307      extract, try to adjust the byte to point to the byte containing
6308      the value.  */
6309   if (wanted_inner_mode != VOIDmode
6310       && GET_MODE_SIZE (wanted_inner_mode) < GET_MODE_SIZE (is_mode)
6311       && ((GET_CODE (inner) == MEM
6312            && (inner_mode == wanted_inner_mode
6313                || (! mode_dependent_address_p (XEXP (inner, 0))
6314                    && ! MEM_VOLATILE_P (inner))))))
6315     {
6316       int offset = 0;
6317
6318       /* The computations below will be correct if the machine is big
6319          endian in both bits and bytes or little endian in bits and bytes.
6320          If it is mixed, we must adjust.  */
6321
6322       /* If bytes are big endian and we had a paradoxical SUBREG, we must
6323          adjust OFFSET to compensate.  */
6324       if (BYTES_BIG_ENDIAN
6325           && ! spans_byte
6326           && GET_MODE_SIZE (inner_mode) < GET_MODE_SIZE (is_mode))
6327         offset -= GET_MODE_SIZE (is_mode) - GET_MODE_SIZE (inner_mode);
6328
6329       /* If this is a constant position, we can move to the desired byte.  */
6330       if (pos_rtx == 0)
6331         {
6332           offset += pos / BITS_PER_UNIT;
6333           pos %= GET_MODE_BITSIZE (wanted_inner_mode);
6334         }
6335
6336       if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN
6337           && ! spans_byte
6338           && is_mode != wanted_inner_mode)
6339         offset = (GET_MODE_SIZE (is_mode)
6340                   - GET_MODE_SIZE (wanted_inner_mode) - offset);
6341
6342       if (offset != 0 || inner_mode != wanted_inner_mode)
6343         inner = adjust_address_nv (inner, wanted_inner_mode, offset);
6344     }
6345
6346   /* If INNER is not memory, we can always get it into the proper mode.  If we
6347      are changing its mode, POS must be a constant and smaller than the size
6348      of the new mode.  */
6349   else if (GET_CODE (inner) != MEM)
6350     {
6351       if (GET_MODE (inner) != wanted_inner_mode
6352           && (pos_rtx != 0
6353               || orig_pos + len > GET_MODE_BITSIZE (wanted_inner_mode)))
6354         return 0;
6355
6356       inner = force_to_mode (inner, wanted_inner_mode,
6357                              pos_rtx
6358                              || len + orig_pos >= HOST_BITS_PER_WIDE_INT
6359                              ? ~(unsigned HOST_WIDE_INT) 0
6360                              : ((((unsigned HOST_WIDE_INT) 1 << len) - 1)
6361                                 << orig_pos),
6362                              NULL_RTX, 0);
6363     }
6364
6365   /* Adjust mode of POS_RTX, if needed.  If we want a wider mode, we
6366      have to zero extend.  Otherwise, we can just use a SUBREG.  */
6367   if (pos_rtx != 0
6368       && GET_MODE_SIZE (pos_mode) > GET_MODE_SIZE (GET_MODE (pos_rtx)))
6369     {
6370       rtx temp = gen_rtx_ZERO_EXTEND (pos_mode, pos_rtx);
6371
6372       /* If we know that no extraneous bits are set, and that the high
6373          bit is not set, convert extraction to cheaper one - either
6374          SIGN_EXTENSION or ZERO_EXTENSION, that are equivalent in these
6375          cases.  */
6376       if (flag_expensive_optimizations
6377           && (GET_MODE_BITSIZE (GET_MODE (pos_rtx)) <= HOST_BITS_PER_WIDE_INT
6378               && ((nonzero_bits (pos_rtx, GET_MODE (pos_rtx))
6379                    & ~(((unsigned HOST_WIDE_INT)
6380                         GET_MODE_MASK (GET_MODE (pos_rtx)))
6381                        >> 1))
6382                   == 0)))
6383         {
6384           rtx temp1 = gen_rtx_SIGN_EXTEND (pos_mode, pos_rtx);
6385
6386           /* Prefer ZERO_EXTENSION, since it gives more information to
6387              backends.  */
6388           if (rtx_cost (temp1, SET) < rtx_cost (temp, SET))
6389             temp = temp1;
6390         }
6391       pos_rtx = temp;
6392     }
6393   else if (pos_rtx != 0
6394            && GET_MODE_SIZE (pos_mode) < GET_MODE_SIZE (GET_MODE (pos_rtx)))
6395     pos_rtx = gen_lowpart_for_combine (pos_mode, pos_rtx);
6396
6397   /* Make POS_RTX unless we already have it and it is correct.  If we don't
6398      have a POS_RTX but we do have an ORIG_POS_RTX, the latter must
6399      be a CONST_INT.  */
6400   if (pos_rtx == 0 && orig_pos_rtx != 0 && INTVAL (orig_pos_rtx) == pos)
6401     pos_rtx = orig_pos_rtx;
6402
6403   else if (pos_rtx == 0)
6404     pos_rtx = GEN_INT (pos);
6405
6406   /* Make the required operation.  See if we can use existing rtx.  */
6407   new = gen_rtx_fmt_eee (unsignedp ? ZERO_EXTRACT : SIGN_EXTRACT,
6408                          extraction_mode, inner, GEN_INT (len), pos_rtx);
6409   if (! in_dest)
6410     new = gen_lowpart_for_combine (mode, new);
6411
6412   return new;
6413 }
6414 \f
6415 /* See if X contains an ASHIFT of COUNT or more bits that can be commuted
6416    with any other operations in X.  Return X without that shift if so.  */
6417
6418 static rtx
6419 extract_left_shift (rtx x, int count)
6420 {
6421   enum rtx_code code = GET_CODE (x);
6422   enum machine_mode mode = GET_MODE (x);
6423   rtx tem;
6424
6425   switch (code)
6426     {
6427     case ASHIFT:
6428       /* This is the shift itself.  If it is wide enough, we will return
6429          either the value being shifted if the shift count is equal to
6430          COUNT or a shift for the difference.  */
6431       if (GET_CODE (XEXP (x, 1)) == CONST_INT
6432           && INTVAL (XEXP (x, 1)) >= count)
6433         return simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (x, 0),
6434                                      INTVAL (XEXP (x, 1)) - count);
6435       break;
6436
6437     case NEG:  case NOT:
6438       if ((tem = extract_left_shift (XEXP (x, 0), count)) != 0)
6439         return simplify_gen_unary (code, mode, tem, mode);
6440
6441       break;
6442
6443     case PLUS:  case IOR:  case XOR:  case AND:
6444       /* If we can safely shift this constant and we find the inner shift,
6445          make a new operation.  */
6446       if (GET_CODE (XEXP (x, 1)) == CONST_INT
6447           && (INTVAL (XEXP (x, 1)) & ((((HOST_WIDE_INT) 1 << count)) - 1)) == 0
6448           && (tem = extract_left_shift (XEXP (x, 0), count)) != 0)
6449         return gen_binary (code, mode, tem,
6450                            GEN_INT (INTVAL (XEXP (x, 1)) >> count));
6451
6452       break;
6453
6454     default:
6455       break;
6456     }
6457
6458   return 0;
6459 }
6460 \f
6461 /* Look at the expression rooted at X.  Look for expressions
6462    equivalent to ZERO_EXTRACT, SIGN_EXTRACT, ZERO_EXTEND, SIGN_EXTEND.
6463    Form these expressions.
6464
6465    Return the new rtx, usually just X.
6466
6467    Also, for machines like the VAX that don't have logical shift insns,
6468    try to convert logical to arithmetic shift operations in cases where
6469    they are equivalent.  This undoes the canonicalizations to logical
6470    shifts done elsewhere.
6471
6472    We try, as much as possible, to re-use rtl expressions to save memory.
6473
6474    IN_CODE says what kind of expression we are processing.  Normally, it is
6475    SET.  In a memory address (inside a MEM, PLUS or minus, the latter two
6476    being kludges), it is MEM.  When processing the arguments of a comparison
6477    or a COMPARE against zero, it is COMPARE.  */
6478
6479 static rtx
6480 make_compound_operation (rtx x, enum rtx_code in_code)
6481 {
6482   enum rtx_code code = GET_CODE (x);
6483   enum machine_mode mode = GET_MODE (x);
6484   int mode_width = GET_MODE_BITSIZE (mode);
6485   rtx rhs, lhs;
6486   enum rtx_code next_code;
6487   int i;
6488   rtx new = 0;
6489   rtx tem;
6490   const char *fmt;
6491
6492   /* Select the code to be used in recursive calls.  Once we are inside an
6493      address, we stay there.  If we have a comparison, set to COMPARE,
6494      but once inside, go back to our default of SET.  */
6495
6496   next_code = (code == MEM || code == PLUS || code == MINUS ? MEM
6497                : ((code == COMPARE || GET_RTX_CLASS (code) == '<')
6498                   && XEXP (x, 1) == const0_rtx) ? COMPARE
6499                : in_code == COMPARE ? SET : in_code);
6500
6501   /* Process depending on the code of this operation.  If NEW is set
6502      nonzero, it will be returned.  */
6503
6504   switch (code)
6505     {
6506     case ASHIFT:
6507       /* Convert shifts by constants into multiplications if inside
6508          an address.  */
6509       if (in_code == MEM && GET_CODE (XEXP (x, 1)) == CONST_INT
6510           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
6511           && INTVAL (XEXP (x, 1)) >= 0)
6512         {
6513           new = make_compound_operation (XEXP (x, 0), next_code);
6514           new = gen_rtx_MULT (mode, new,
6515                               GEN_INT ((HOST_WIDE_INT) 1
6516                                        << INTVAL (XEXP (x, 1))));
6517         }
6518       break;
6519
6520     case AND:
6521       /* If the second operand is not a constant, we can't do anything
6522          with it.  */
6523       if (GET_CODE (XEXP (x, 1)) != CONST_INT)
6524         break;
6525
6526       /* If the constant is a power of two minus one and the first operand
6527          is a logical right shift, make an extraction.  */
6528       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
6529           && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
6530         {
6531           new = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
6532           new = make_extraction (mode, new, 0, XEXP (XEXP (x, 0), 1), i, 1,
6533                                  0, in_code == COMPARE);
6534         }
6535
6536       /* Same as previous, but for (subreg (lshiftrt ...)) in first op.  */
6537       else if (GET_CODE (XEXP (x, 0)) == SUBREG
6538                && subreg_lowpart_p (XEXP (x, 0))
6539                && GET_CODE (SUBREG_REG (XEXP (x, 0))) == LSHIFTRT
6540                && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
6541         {
6542           new = make_compound_operation (XEXP (SUBREG_REG (XEXP (x, 0)), 0),
6543                                          next_code);
6544           new = make_extraction (GET_MODE (SUBREG_REG (XEXP (x, 0))), new, 0,
6545                                  XEXP (SUBREG_REG (XEXP (x, 0)), 1), i, 1,
6546                                  0, in_code == COMPARE);
6547         }
6548       /* Same as previous, but for (xor/ior (lshiftrt...) (lshiftrt...)).  */
6549       else if ((GET_CODE (XEXP (x, 0)) == XOR
6550                 || GET_CODE (XEXP (x, 0)) == IOR)
6551                && GET_CODE (XEXP (XEXP (x, 0), 0)) == LSHIFTRT
6552                && GET_CODE (XEXP (XEXP (x, 0), 1)) == LSHIFTRT
6553                && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
6554         {
6555           /* Apply the distributive law, and then try to make extractions.  */
6556           new = gen_rtx_fmt_ee (GET_CODE (XEXP (x, 0)), mode,
6557                                 gen_rtx_AND (mode, XEXP (XEXP (x, 0), 0),
6558                                              XEXP (x, 1)),
6559                                 gen_rtx_AND (mode, XEXP (XEXP (x, 0), 1),
6560                                              XEXP (x, 1)));
6561           new = make_compound_operation (new, in_code);
6562         }
6563
6564       /* If we are have (and (rotate X C) M) and C is larger than the number
6565          of bits in M, this is an extraction.  */
6566
6567       else if (GET_CODE (XEXP (x, 0)) == ROTATE
6568                && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
6569                && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0
6570                && i <= INTVAL (XEXP (XEXP (x, 0), 1)))
6571         {
6572           new = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
6573           new = make_extraction (mode, new,
6574                                  (GET_MODE_BITSIZE (mode)
6575                                   - INTVAL (XEXP (XEXP (x, 0), 1))),
6576                                  NULL_RTX, i, 1, 0, in_code == COMPARE);
6577         }
6578
6579       /* On machines without logical shifts, if the operand of the AND is
6580          a logical shift and our mask turns off all the propagated sign
6581          bits, we can replace the logical shift with an arithmetic shift.  */
6582       else if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
6583                && !have_insn_for (LSHIFTRT, mode)
6584                && have_insn_for (ASHIFTRT, mode)
6585                && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
6586                && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
6587                && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
6588                && mode_width <= HOST_BITS_PER_WIDE_INT)
6589         {
6590           unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
6591
6592           mask >>= INTVAL (XEXP (XEXP (x, 0), 1));
6593           if ((INTVAL (XEXP (x, 1)) & ~mask) == 0)
6594             SUBST (XEXP (x, 0),
6595                    gen_rtx_ASHIFTRT (mode,
6596                                      make_compound_operation
6597                                      (XEXP (XEXP (x, 0), 0), next_code),
6598                                      XEXP (XEXP (x, 0), 1)));
6599         }
6600
6601       /* If the constant is one less than a power of two, this might be
6602          representable by an extraction even if no shift is present.
6603          If it doesn't end up being a ZERO_EXTEND, we will ignore it unless
6604          we are in a COMPARE.  */
6605       else if ((i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
6606         new = make_extraction (mode,
6607                                make_compound_operation (XEXP (x, 0),
6608                                                         next_code),
6609                                0, NULL_RTX, i, 1, 0, in_code == COMPARE);
6610
6611       /* If we are in a comparison and this is an AND with a power of two,
6612          convert this into the appropriate bit extract.  */
6613       else if (in_code == COMPARE
6614                && (i = exact_log2 (INTVAL (XEXP (x, 1)))) >= 0)
6615         new = make_extraction (mode,
6616                                make_compound_operation (XEXP (x, 0),
6617                                                         next_code),
6618                                i, NULL_RTX, 1, 1, 0, 1);
6619
6620       break;
6621
6622     case LSHIFTRT:
6623       /* If the sign bit is known to be zero, replace this with an
6624          arithmetic shift.  */
6625       if (have_insn_for (ASHIFTRT, mode)
6626           && ! have_insn_for (LSHIFTRT, mode)
6627           && mode_width <= HOST_BITS_PER_WIDE_INT
6628           && (nonzero_bits (XEXP (x, 0), mode) & (1 << (mode_width - 1))) == 0)
6629         {
6630           new = gen_rtx_ASHIFTRT (mode,
6631                                   make_compound_operation (XEXP (x, 0),
6632                                                            next_code),
6633                                   XEXP (x, 1));
6634           break;
6635         }
6636
6637       /* ... fall through ...  */
6638
6639     case ASHIFTRT:
6640       lhs = XEXP (x, 0);
6641       rhs = XEXP (x, 1);
6642
6643       /* If we have (ashiftrt (ashift foo C1) C2) with C2 >= C1,
6644          this is a SIGN_EXTRACT.  */
6645       if (GET_CODE (rhs) == CONST_INT
6646           && GET_CODE (lhs) == ASHIFT
6647           && GET_CODE (XEXP (lhs, 1)) == CONST_INT
6648           && INTVAL (rhs) >= INTVAL (XEXP (lhs, 1)))
6649         {
6650           new = make_compound_operation (XEXP (lhs, 0), next_code);
6651           new = make_extraction (mode, new,
6652                                  INTVAL (rhs) - INTVAL (XEXP (lhs, 1)),
6653                                  NULL_RTX, mode_width - INTVAL (rhs),
6654                                  code == LSHIFTRT, 0, in_code == COMPARE);
6655           break;
6656         }
6657
6658       /* See if we have operations between an ASHIFTRT and an ASHIFT.
6659          If so, try to merge the shifts into a SIGN_EXTEND.  We could
6660          also do this for some cases of SIGN_EXTRACT, but it doesn't
6661          seem worth the effort; the case checked for occurs on Alpha.  */
6662
6663       if (GET_RTX_CLASS (GET_CODE (lhs)) != 'o'
6664           && ! (GET_CODE (lhs) == SUBREG
6665                 && (GET_RTX_CLASS (GET_CODE (SUBREG_REG (lhs))) == 'o'))
6666           && GET_CODE (rhs) == CONST_INT
6667           && INTVAL (rhs) < HOST_BITS_PER_WIDE_INT
6668           && (new = extract_left_shift (lhs, INTVAL (rhs))) != 0)
6669         new = make_extraction (mode, make_compound_operation (new, next_code),
6670                                0, NULL_RTX, mode_width - INTVAL (rhs),
6671                                code == LSHIFTRT, 0, in_code == COMPARE);
6672
6673       break;
6674
6675     case SUBREG:
6676       /* Call ourselves recursively on the inner expression.  If we are
6677          narrowing the object and it has a different RTL code from
6678          what it originally did, do this SUBREG as a force_to_mode.  */
6679
6680       tem = make_compound_operation (SUBREG_REG (x), in_code);
6681       if (GET_CODE (tem) != GET_CODE (SUBREG_REG (x))
6682           && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (tem))
6683           && subreg_lowpart_p (x))
6684         {
6685           rtx newer = force_to_mode (tem, mode, ~(HOST_WIDE_INT) 0,
6686                                      NULL_RTX, 0);
6687
6688           /* If we have something other than a SUBREG, we might have
6689              done an expansion, so rerun ourselves.  */
6690           if (GET_CODE (newer) != SUBREG)
6691             newer = make_compound_operation (newer, in_code);
6692
6693           return newer;
6694         }
6695
6696       /* If this is a paradoxical subreg, and the new code is a sign or
6697          zero extension, omit the subreg and widen the extension.  If it
6698          is a regular subreg, we can still get rid of the subreg by not
6699          widening so much, or in fact removing the extension entirely.  */
6700       if ((GET_CODE (tem) == SIGN_EXTEND
6701            || GET_CODE (tem) == ZERO_EXTEND)
6702           && subreg_lowpart_p (x))
6703         {
6704           if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (tem))
6705               || (GET_MODE_SIZE (mode) >
6706                   GET_MODE_SIZE (GET_MODE (XEXP (tem, 0)))))
6707             {
6708               if (! SCALAR_INT_MODE_P (mode))
6709                 break;
6710               tem = gen_rtx_fmt_e (GET_CODE (tem), mode, XEXP (tem, 0));
6711             }
6712           else
6713             tem = gen_lowpart_for_combine (mode, XEXP (tem, 0));
6714           return tem;
6715         }
6716       break;
6717
6718     default:
6719       break;
6720     }
6721
6722   if (new)
6723     {
6724       x = gen_lowpart_for_combine (mode, new);
6725       code = GET_CODE (x);
6726     }
6727
6728   /* Now recursively process each operand of this operation.  */
6729   fmt = GET_RTX_FORMAT (code);
6730   for (i = 0; i < GET_RTX_LENGTH (code); i++)
6731     if (fmt[i] == 'e')
6732       {
6733         new = make_compound_operation (XEXP (x, i), next_code);
6734         SUBST (XEXP (x, i), new);
6735       }
6736
6737   return x;
6738 }
6739 \f
6740 /* Given M see if it is a value that would select a field of bits
6741    within an item, but not the entire word.  Return -1 if not.
6742    Otherwise, return the starting position of the field, where 0 is the
6743    low-order bit.
6744
6745    *PLEN is set to the length of the field.  */
6746
6747 static int
6748 get_pos_from_mask (unsigned HOST_WIDE_INT m, unsigned HOST_WIDE_INT *plen)
6749 {
6750   /* Get the bit number of the first 1 bit from the right, -1 if none.  */
6751   int pos = exact_log2 (m & -m);
6752   int len;
6753
6754   if (pos < 0)
6755     return -1;
6756
6757   /* Now shift off the low-order zero bits and see if we have a power of
6758      two minus 1.  */
6759   len = exact_log2 ((m >> pos) + 1);
6760
6761   if (len <= 0)
6762     return -1;
6763
6764   *plen = len;
6765   return pos;
6766 }
6767 \f
6768 /* See if X can be simplified knowing that we will only refer to it in
6769    MODE and will only refer to those bits that are nonzero in MASK.
6770    If other bits are being computed or if masking operations are done
6771    that select a superset of the bits in MASK, they can sometimes be
6772    ignored.
6773
6774    Return a possibly simplified expression, but always convert X to
6775    MODE.  If X is a CONST_INT, AND the CONST_INT with MASK.
6776
6777    Also, if REG is nonzero and X is a register equal in value to REG,
6778    replace X with REG.
6779
6780    If JUST_SELECT is nonzero, don't optimize by noticing that bits in MASK
6781    are all off in X.  This is used when X will be complemented, by either
6782    NOT, NEG, or XOR.  */
6783
6784 static rtx
6785 force_to_mode (rtx x, enum machine_mode mode, unsigned HOST_WIDE_INT mask,
6786                rtx reg, int just_select)
6787 {
6788   enum rtx_code code = GET_CODE (x);
6789   int next_select = just_select || code == XOR || code == NOT || code == NEG;
6790   enum machine_mode op_mode;
6791   unsigned HOST_WIDE_INT fuller_mask, nonzero;
6792   rtx op0, op1, temp;
6793
6794   /* If this is a CALL or ASM_OPERANDS, don't do anything.  Some of the
6795      code below will do the wrong thing since the mode of such an
6796      expression is VOIDmode.
6797
6798      Also do nothing if X is a CLOBBER; this can happen if X was
6799      the return value from a call to gen_lowpart_for_combine.  */
6800   if (code == CALL || code == ASM_OPERANDS || code == CLOBBER)
6801     return x;
6802
6803   /* We want to perform the operation is its present mode unless we know
6804      that the operation is valid in MODE, in which case we do the operation
6805      in MODE.  */
6806   op_mode = ((GET_MODE_CLASS (mode) == GET_MODE_CLASS (GET_MODE (x))
6807               && have_insn_for (code, mode))
6808              ? mode : GET_MODE (x));
6809
6810   /* It is not valid to do a right-shift in a narrower mode
6811      than the one it came in with.  */
6812   if ((code == LSHIFTRT || code == ASHIFTRT)
6813       && GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (GET_MODE (x)))
6814     op_mode = GET_MODE (x);
6815
6816   /* Truncate MASK to fit OP_MODE.  */
6817   if (op_mode)
6818     mask &= GET_MODE_MASK (op_mode);
6819
6820   /* When we have an arithmetic operation, or a shift whose count we
6821      do not know, we need to assume that all bit the up to the highest-order
6822      bit in MASK will be needed.  This is how we form such a mask.  */
6823   if (op_mode)
6824     fuller_mask = (GET_MODE_BITSIZE (op_mode) >= HOST_BITS_PER_WIDE_INT
6825                    ? GET_MODE_MASK (op_mode)
6826                    : (((unsigned HOST_WIDE_INT) 1 << (floor_log2 (mask) + 1))
6827                       - 1));
6828   else
6829     fuller_mask = ~(HOST_WIDE_INT) 0;
6830
6831   /* Determine what bits of X are guaranteed to be (non)zero.  */
6832   nonzero = nonzero_bits (x, mode);
6833
6834   /* If none of the bits in X are needed, return a zero.  */
6835   if (! just_select && (nonzero & mask) == 0)
6836     x = const0_rtx;
6837
6838   /* If X is a CONST_INT, return a new one.  Do this here since the
6839      test below will fail.  */
6840   if (GET_CODE (x) == CONST_INT)
6841     {
6842       if (SCALAR_INT_MODE_P (mode))
6843         return gen_int_mode (INTVAL (x) & mask, mode);
6844       else
6845         {
6846           x = GEN_INT (INTVAL (x) & mask);
6847           return gen_lowpart_common (mode, x);
6848         }
6849     }
6850
6851   /* If X is narrower than MODE and we want all the bits in X's mode, just
6852      get X in the proper mode.  */
6853   if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (mode)
6854       && (GET_MODE_MASK (GET_MODE (x)) & ~mask) == 0)
6855     return gen_lowpart_for_combine (mode, x);
6856
6857   /* If we aren't changing the mode, X is not a SUBREG, and all zero bits in
6858      MASK are already known to be zero in X, we need not do anything.  */
6859   if (GET_MODE (x) == mode && code != SUBREG && (~mask & nonzero) == 0)
6860     return x;
6861
6862   switch (code)
6863     {
6864     case CLOBBER:
6865       /* If X is a (clobber (const_int)), return it since we know we are
6866          generating something that won't match.  */
6867       return x;
6868
6869     case USE:
6870       /* X is a (use (mem ..)) that was made from a bit-field extraction that
6871          spanned the boundary of the MEM.  If we are now masking so it is
6872          within that boundary, we don't need the USE any more.  */
6873       if (! BITS_BIG_ENDIAN
6874           && (mask & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6875         return force_to_mode (XEXP (x, 0), mode, mask, reg, next_select);
6876       break;
6877
6878     case SIGN_EXTEND:
6879     case ZERO_EXTEND:
6880     case ZERO_EXTRACT:
6881     case SIGN_EXTRACT:
6882       x = expand_compound_operation (x);
6883       if (GET_CODE (x) != code)
6884         return force_to_mode (x, mode, mask, reg, next_select);
6885       break;
6886
6887     case REG:
6888       if (reg != 0 && (rtx_equal_p (get_last_value (reg), x)
6889                        || rtx_equal_p (reg, get_last_value (x))))
6890         x = reg;
6891       break;
6892
6893     case SUBREG:
6894       if (subreg_lowpart_p (x)
6895           /* We can ignore the effect of this SUBREG if it narrows the mode or
6896              if the constant masks to zero all the bits the mode doesn't
6897              have.  */
6898           && ((GET_MODE_SIZE (GET_MODE (x))
6899                < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
6900               || (0 == (mask
6901                         & GET_MODE_MASK (GET_MODE (x))
6902                         & ~GET_MODE_MASK (GET_MODE (SUBREG_REG (x)))))))
6903         return force_to_mode (SUBREG_REG (x), mode, mask, reg, next_select);
6904       break;
6905
6906     case AND:
6907       /* If this is an AND with a constant, convert it into an AND
6908          whose constant is the AND of that constant with MASK.  If it
6909          remains an AND of MASK, delete it since it is redundant.  */
6910
6911       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
6912         {
6913           x = simplify_and_const_int (x, op_mode, XEXP (x, 0),
6914                                       mask & INTVAL (XEXP (x, 1)));
6915
6916           /* If X is still an AND, see if it is an AND with a mask that
6917              is just some low-order bits.  If so, and it is MASK, we don't
6918              need it.  */
6919
6920           if (GET_CODE (x) == AND && GET_CODE (XEXP (x, 1)) == CONST_INT
6921               && ((INTVAL (XEXP (x, 1)) & GET_MODE_MASK (GET_MODE (x)))
6922                   == mask))
6923             x = XEXP (x, 0);
6924
6925           /* If it remains an AND, try making another AND with the bits
6926              in the mode mask that aren't in MASK turned on.  If the
6927              constant in the AND is wide enough, this might make a
6928              cheaper constant.  */
6929
6930           if (GET_CODE (x) == AND && GET_CODE (XEXP (x, 1)) == CONST_INT
6931               && GET_MODE_MASK (GET_MODE (x)) != mask
6932               && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
6933             {
6934               HOST_WIDE_INT cval = (INTVAL (XEXP (x, 1))
6935                                     | (GET_MODE_MASK (GET_MODE (x)) & ~mask));
6936               int width = GET_MODE_BITSIZE (GET_MODE (x));
6937               rtx y;
6938
6939               /* If MODE is narrower that HOST_WIDE_INT and CVAL is a negative
6940                  number, sign extend it.  */
6941               if (width > 0 && width < HOST_BITS_PER_WIDE_INT
6942                   && (cval & ((HOST_WIDE_INT) 1 << (width - 1))) != 0)
6943                 cval |= (HOST_WIDE_INT) -1 << width;
6944
6945               y = gen_binary (AND, GET_MODE (x), XEXP (x, 0), GEN_INT (cval));
6946               if (rtx_cost (y, SET) < rtx_cost (x, SET))
6947                 x = y;
6948             }
6949
6950           break;
6951         }
6952
6953       goto binop;
6954
6955     case PLUS:
6956       /* In (and (plus FOO C1) M), if M is a mask that just turns off
6957          low-order bits (as in an alignment operation) and FOO is already
6958          aligned to that boundary, mask C1 to that boundary as well.
6959          This may eliminate that PLUS and, later, the AND.  */
6960
6961       {
6962         unsigned int width = GET_MODE_BITSIZE (mode);
6963         unsigned HOST_WIDE_INT smask = mask;
6964
6965         /* If MODE is narrower than HOST_WIDE_INT and mask is a negative
6966            number, sign extend it.  */
6967
6968         if (width < HOST_BITS_PER_WIDE_INT
6969             && (smask & ((HOST_WIDE_INT) 1 << (width - 1))) != 0)
6970           smask |= (HOST_WIDE_INT) -1 << width;
6971
6972         if (GET_CODE (XEXP (x, 1)) == CONST_INT
6973             && exact_log2 (- smask) >= 0
6974             && (nonzero_bits (XEXP (x, 0), mode) & ~smask) == 0
6975             && (INTVAL (XEXP (x, 1)) & ~smask) != 0)
6976           return force_to_mode (plus_constant (XEXP (x, 0),
6977                                                (INTVAL (XEXP (x, 1)) & smask)),
6978                                 mode, smask, reg, next_select);
6979       }
6980
6981       /* ... fall through ...  */
6982
6983     case MULT:
6984       /* For PLUS, MINUS and MULT, we need any bits less significant than the
6985          most significant bit in MASK since carries from those bits will
6986          affect the bits we are interested in.  */
6987       mask = fuller_mask;
6988       goto binop;
6989
6990     case MINUS:
6991       /* If X is (minus C Y) where C's least set bit is larger than any bit
6992          in the mask, then we may replace with (neg Y).  */
6993       if (GET_CODE (XEXP (x, 0)) == CONST_INT
6994           && (((unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 0))
6995                                         & -INTVAL (XEXP (x, 0))))
6996               > mask))
6997         {
6998           x = simplify_gen_unary (NEG, GET_MODE (x), XEXP (x, 1),
6999                                   GET_MODE (x));
7000           return force_to_mode (x, mode, mask, reg, next_select);
7001         }
7002
7003       /* Similarly, if C contains every bit in the fuller_mask, then we may
7004          replace with (not Y).  */
7005       if (GET_CODE (XEXP (x, 0)) == CONST_INT
7006           && ((INTVAL (XEXP (x, 0)) | (HOST_WIDE_INT) fuller_mask)
7007               == INTVAL (XEXP (x, 0))))
7008         {
7009           x = simplify_gen_unary (NOT, GET_MODE (x),
7010                                   XEXP (x, 1), GET_MODE (x));
7011           return force_to_mode (x, mode, mask, reg, next_select);
7012         }
7013
7014       mask = fuller_mask;
7015       goto binop;
7016
7017     case IOR:
7018     case XOR:
7019       /* If X is (ior (lshiftrt FOO C1) C2), try to commute the IOR and
7020          LSHIFTRT so we end up with an (and (lshiftrt (ior ...) ...) ...)
7021          operation which may be a bitfield extraction.  Ensure that the
7022          constant we form is not wider than the mode of X.  */
7023
7024       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
7025           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
7026           && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
7027           && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
7028           && GET_CODE (XEXP (x, 1)) == CONST_INT
7029           && ((INTVAL (XEXP (XEXP (x, 0), 1))
7030                + floor_log2 (INTVAL (XEXP (x, 1))))
7031               < GET_MODE_BITSIZE (GET_MODE (x)))
7032           && (INTVAL (XEXP (x, 1))
7033               & ~nonzero_bits (XEXP (x, 0), GET_MODE (x))) == 0)
7034         {
7035           temp = GEN_INT ((INTVAL (XEXP (x, 1)) & mask)
7036                           << INTVAL (XEXP (XEXP (x, 0), 1)));
7037           temp = gen_binary (GET_CODE (x), GET_MODE (x),
7038                              XEXP (XEXP (x, 0), 0), temp);
7039           x = gen_binary (LSHIFTRT, GET_MODE (x), temp,
7040                           XEXP (XEXP (x, 0), 1));
7041           return force_to_mode (x, mode, mask, reg, next_select);
7042         }
7043
7044     binop:
7045       /* For most binary operations, just propagate into the operation and
7046          change the mode if we have an operation of that mode.  */
7047
7048       op0 = gen_lowpart_for_combine (op_mode,
7049                                      force_to_mode (XEXP (x, 0), mode, mask,
7050                                                     reg, next_select));
7051       op1 = gen_lowpart_for_combine (op_mode,
7052                                      force_to_mode (XEXP (x, 1), mode, mask,
7053                                                     reg, next_select));
7054
7055       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
7056         x = gen_binary (code, op_mode, op0, op1);
7057       break;
7058
7059     case ASHIFT:
7060       /* For left shifts, do the same, but just for the first operand.
7061          However, we cannot do anything with shifts where we cannot
7062          guarantee that the counts are smaller than the size of the mode
7063          because such a count will have a different meaning in a
7064          wider mode.  */
7065
7066       if (! (GET_CODE (XEXP (x, 1)) == CONST_INT
7067              && INTVAL (XEXP (x, 1)) >= 0
7068              && INTVAL (XEXP (x, 1)) < GET_MODE_BITSIZE (mode))
7069           && ! (GET_MODE (XEXP (x, 1)) != VOIDmode
7070                 && (nonzero_bits (XEXP (x, 1), GET_MODE (XEXP (x, 1)))
7071                     < (unsigned HOST_WIDE_INT) GET_MODE_BITSIZE (mode))))
7072         break;
7073
7074       /* If the shift count is a constant and we can do arithmetic in
7075          the mode of the shift, refine which bits we need.  Otherwise, use the
7076          conservative form of the mask.  */
7077       if (GET_CODE (XEXP (x, 1)) == CONST_INT
7078           && INTVAL (XEXP (x, 1)) >= 0
7079           && INTVAL (XEXP (x, 1)) < GET_MODE_BITSIZE (op_mode)
7080           && GET_MODE_BITSIZE (op_mode) <= HOST_BITS_PER_WIDE_INT)
7081         mask >>= INTVAL (XEXP (x, 1));
7082       else
7083         mask = fuller_mask;
7084
7085       op0 = gen_lowpart_for_combine (op_mode,
7086                                      force_to_mode (XEXP (x, 0), op_mode,
7087                                                     mask, reg, next_select));
7088
7089       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0))
7090         x = gen_binary (code, op_mode, op0, XEXP (x, 1));
7091       break;
7092
7093     case LSHIFTRT:
7094       /* Here we can only do something if the shift count is a constant,
7095          this shift constant is valid for the host, and we can do arithmetic
7096          in OP_MODE.  */
7097
7098       if (GET_CODE (XEXP (x, 1)) == CONST_INT
7099           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
7100           && GET_MODE_BITSIZE (op_mode) <= HOST_BITS_PER_WIDE_INT)
7101         {
7102           rtx inner = XEXP (x, 0);
7103           unsigned HOST_WIDE_INT inner_mask;
7104
7105           /* Select the mask of the bits we need for the shift operand.  */
7106           inner_mask = mask << INTVAL (XEXP (x, 1));
7107
7108           /* We can only change the mode of the shift if we can do arithmetic
7109              in the mode of the shift and INNER_MASK is no wider than the
7110              width of OP_MODE.  */
7111           if (GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT
7112               || (inner_mask & ~GET_MODE_MASK (op_mode)) != 0)
7113             op_mode = GET_MODE (x);
7114
7115           inner = force_to_mode (inner, op_mode, inner_mask, reg, next_select);
7116
7117           if (GET_MODE (x) != op_mode || inner != XEXP (x, 0))
7118             x = gen_binary (LSHIFTRT, op_mode, inner, XEXP (x, 1));
7119         }
7120
7121       /* If we have (and (lshiftrt FOO C1) C2) where the combination of the
7122          shift and AND produces only copies of the sign bit (C2 is one less
7123          than a power of two), we can do this with just a shift.  */
7124
7125       if (GET_CODE (x) == LSHIFTRT
7126           && GET_CODE (XEXP (x, 1)) == CONST_INT
7127           /* The shift puts one of the sign bit copies in the least significant
7128              bit.  */
7129           && ((INTVAL (XEXP (x, 1))
7130                + num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0))))
7131               >= GET_MODE_BITSIZE (GET_MODE (x)))
7132           && exact_log2 (mask + 1) >= 0
7133           /* Number of bits left after the shift must be more than the mask
7134              needs.  */
7135           && ((INTVAL (XEXP (x, 1)) + exact_log2 (mask + 1))
7136               <= GET_MODE_BITSIZE (GET_MODE (x)))
7137           /* Must be more sign bit copies than the mask needs.  */
7138           && ((int) num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
7139               >= exact_log2 (mask + 1)))
7140         x = gen_binary (LSHIFTRT, GET_MODE (x), XEXP (x, 0),
7141                         GEN_INT (GET_MODE_BITSIZE (GET_MODE (x))
7142                                  - exact_log2 (mask + 1)));
7143
7144       goto shiftrt;
7145
7146     case ASHIFTRT:
7147       /* If we are just looking for the sign bit, we don't need this shift at
7148          all, even if it has a variable count.  */
7149       if (GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
7150           && (mask == ((unsigned HOST_WIDE_INT) 1
7151                        << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
7152         return force_to_mode (XEXP (x, 0), mode, mask, reg, next_select);
7153
7154       /* If this is a shift by a constant, get a mask that contains those bits
7155          that are not copies of the sign bit.  We then have two cases:  If
7156          MASK only includes those bits, this can be a logical shift, which may
7157          allow simplifications.  If MASK is a single-bit field not within
7158          those bits, we are requesting a copy of the sign bit and hence can
7159          shift the sign bit to the appropriate location.  */
7160
7161       if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) >= 0
7162           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
7163         {
7164           int i = -1;
7165
7166           /* If the considered data is wider than HOST_WIDE_INT, we can't
7167              represent a mask for all its bits in a single scalar.
7168              But we only care about the lower bits, so calculate these.  */
7169
7170           if (GET_MODE_BITSIZE (GET_MODE (x)) > HOST_BITS_PER_WIDE_INT)
7171             {
7172               nonzero = ~(HOST_WIDE_INT) 0;
7173
7174               /* GET_MODE_BITSIZE (GET_MODE (x)) - INTVAL (XEXP (x, 1))
7175                  is the number of bits a full-width mask would have set.
7176                  We need only shift if these are fewer than nonzero can
7177                  hold.  If not, we must keep all bits set in nonzero.  */
7178
7179               if (GET_MODE_BITSIZE (GET_MODE (x)) - INTVAL (XEXP (x, 1))
7180                   < HOST_BITS_PER_WIDE_INT)
7181                 nonzero >>= INTVAL (XEXP (x, 1))
7182                             + HOST_BITS_PER_WIDE_INT
7183                             - GET_MODE_BITSIZE (GET_MODE (x)) ;
7184             }
7185           else
7186             {
7187               nonzero = GET_MODE_MASK (GET_MODE (x));
7188               nonzero >>= INTVAL (XEXP (x, 1));
7189             }
7190
7191           if ((mask & ~nonzero) == 0
7192               || (i = exact_log2 (mask)) >= 0)
7193             {
7194               x = simplify_shift_const
7195                 (x, LSHIFTRT, GET_MODE (x), XEXP (x, 0),
7196                  i < 0 ? INTVAL (XEXP (x, 1))
7197                  : GET_MODE_BITSIZE (GET_MODE (x)) - 1 - i);
7198
7199               if (GET_CODE (x) != ASHIFTRT)
7200                 return force_to_mode (x, mode, mask, reg, next_select);
7201             }
7202         }
7203
7204       /* If MASK is 1, convert this to an LSHIFTRT.  This can be done
7205          even if the shift count isn't a constant.  */
7206       if (mask == 1)
7207         x = gen_binary (LSHIFTRT, GET_MODE (x), XEXP (x, 0), XEXP (x, 1));
7208
7209     shiftrt:
7210
7211       /* If this is a zero- or sign-extension operation that just affects bits
7212          we don't care about, remove it.  Be sure the call above returned
7213          something that is still a shift.  */
7214
7215       if ((GET_CODE (x) == LSHIFTRT || GET_CODE (x) == ASHIFTRT)
7216           && GET_CODE (XEXP (x, 1)) == CONST_INT
7217           && INTVAL (XEXP (x, 1)) >= 0
7218           && (INTVAL (XEXP (x, 1))
7219               <= GET_MODE_BITSIZE (GET_MODE (x)) - (floor_log2 (mask) + 1))
7220           && GET_CODE (XEXP (x, 0)) == ASHIFT
7221           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
7222           && INTVAL (XEXP (XEXP (x, 0), 1)) == INTVAL (XEXP (x, 1)))
7223         return force_to_mode (XEXP (XEXP (x, 0), 0), mode, mask,
7224                               reg, next_select);
7225
7226       break;
7227
7228     case ROTATE:
7229     case ROTATERT:
7230       /* If the shift count is constant and we can do computations
7231          in the mode of X, compute where the bits we care about are.
7232          Otherwise, we can't do anything.  Don't change the mode of
7233          the shift or propagate MODE into the shift, though.  */
7234       if (GET_CODE (XEXP (x, 1)) == CONST_INT
7235           && INTVAL (XEXP (x, 1)) >= 0)
7236         {
7237           temp = simplify_binary_operation (code == ROTATE ? ROTATERT : ROTATE,
7238                                             GET_MODE (x), GEN_INT (mask),
7239                                             XEXP (x, 1));
7240           if (temp && GET_CODE (temp) == CONST_INT)
7241             SUBST (XEXP (x, 0),
7242                    force_to_mode (XEXP (x, 0), GET_MODE (x),
7243                                   INTVAL (temp), reg, next_select));
7244         }
7245       break;
7246
7247     case NEG:
7248       /* If we just want the low-order bit, the NEG isn't needed since it
7249          won't change the low-order bit.  */
7250       if (mask == 1)
7251         return force_to_mode (XEXP (x, 0), mode, mask, reg, just_select);
7252
7253       /* We need any bits less significant than the most significant bit in
7254          MASK since carries from those bits will affect the bits we are
7255          interested in.  */
7256       mask = fuller_mask;
7257       goto unop;
7258
7259     case NOT:
7260       /* (not FOO) is (xor FOO CONST), so if FOO is an LSHIFTRT, we can do the
7261          same as the XOR case above.  Ensure that the constant we form is not
7262          wider than the mode of X.  */
7263
7264       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
7265           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
7266           && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
7267           && (INTVAL (XEXP (XEXP (x, 0), 1)) + floor_log2 (mask)
7268               < GET_MODE_BITSIZE (GET_MODE (x)))
7269           && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT)
7270         {
7271           temp = gen_int_mode (mask << INTVAL (XEXP (XEXP (x, 0), 1)),
7272                                GET_MODE (x));
7273           temp = gen_binary (XOR, GET_MODE (x), XEXP (XEXP (x, 0), 0), temp);
7274           x = gen_binary (LSHIFTRT, GET_MODE (x), temp, XEXP (XEXP (x, 0), 1));
7275
7276           return force_to_mode (x, mode, mask, reg, next_select);
7277         }
7278
7279       /* (and (not FOO) CONST) is (not (or FOO (not CONST))), so we must
7280          use the full mask inside the NOT.  */
7281       mask = fuller_mask;
7282
7283     unop:
7284       op0 = gen_lowpart_for_combine (op_mode,
7285                                      force_to_mode (XEXP (x, 0), mode, mask,
7286                                                     reg, next_select));
7287       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0))
7288         x = simplify_gen_unary (code, op_mode, op0, op_mode);
7289       break;
7290
7291     case NE:
7292       /* (and (ne FOO 0) CONST) can be (and FOO CONST) if CONST is included
7293          in STORE_FLAG_VALUE and FOO has a single bit that might be nonzero,
7294          which is equal to STORE_FLAG_VALUE.  */
7295       if ((mask & ~STORE_FLAG_VALUE) == 0 && XEXP (x, 1) == const0_rtx
7296           && exact_log2 (nonzero_bits (XEXP (x, 0), mode)) >= 0
7297           && (nonzero_bits (XEXP (x, 0), mode)
7298               == (unsigned HOST_WIDE_INT) STORE_FLAG_VALUE))
7299         return force_to_mode (XEXP (x, 0), mode, mask, reg, next_select);
7300
7301       break;
7302
7303     case IF_THEN_ELSE:
7304       /* We have no way of knowing if the IF_THEN_ELSE can itself be
7305          written in a narrower mode.  We play it safe and do not do so.  */
7306
7307       SUBST (XEXP (x, 1),
7308              gen_lowpart_for_combine (GET_MODE (x),
7309                                       force_to_mode (XEXP (x, 1), mode,
7310                                                      mask, reg, next_select)));
7311       SUBST (XEXP (x, 2),
7312              gen_lowpart_for_combine (GET_MODE (x),
7313                                       force_to_mode (XEXP (x, 2), mode,
7314                                                      mask, reg, next_select)));
7315       break;
7316
7317     default:
7318       break;
7319     }
7320
7321   /* Ensure we return a value of the proper mode.  */
7322   return gen_lowpart_for_combine (mode, x);
7323 }
7324 \f
7325 /* Return nonzero if X is an expression that has one of two values depending on
7326    whether some other value is zero or nonzero.  In that case, we return the
7327    value that is being tested, *PTRUE is set to the value if the rtx being
7328    returned has a nonzero value, and *PFALSE is set to the other alternative.
7329
7330    If we return zero, we set *PTRUE and *PFALSE to X.  */
7331
7332 static rtx
7333 if_then_else_cond (rtx x, rtx *ptrue, rtx *pfalse)
7334 {
7335   enum machine_mode mode = GET_MODE (x);
7336   enum rtx_code code = GET_CODE (x);
7337   rtx cond0, cond1, true0, true1, false0, false1;
7338   unsigned HOST_WIDE_INT nz;
7339
7340   /* If we are comparing a value against zero, we are done.  */
7341   if ((code == NE || code == EQ)
7342       && GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
7343     {
7344       *ptrue = (code == NE) ? const_true_rtx : const0_rtx;
7345       *pfalse = (code == NE) ? const0_rtx : const_true_rtx;
7346       return XEXP (x, 0);
7347     }
7348
7349   /* If this is a unary operation whose operand has one of two values, apply
7350      our opcode to compute those values.  */
7351   else if (GET_RTX_CLASS (code) == '1'
7352            && (cond0 = if_then_else_cond (XEXP (x, 0), &true0, &false0)) != 0)
7353     {
7354       *ptrue = simplify_gen_unary (code, mode, true0, GET_MODE (XEXP (x, 0)));
7355       *pfalse = simplify_gen_unary (code, mode, false0,
7356                                     GET_MODE (XEXP (x, 0)));
7357       return cond0;
7358     }
7359
7360   /* If this is a COMPARE, do nothing, since the IF_THEN_ELSE we would
7361      make can't possibly match and would suppress other optimizations.  */
7362   else if (code == COMPARE)
7363     ;
7364
7365   /* If this is a binary operation, see if either side has only one of two
7366      values.  If either one does or if both do and they are conditional on
7367      the same value, compute the new true and false values.  */
7368   else if (GET_RTX_CLASS (code) == 'c' || GET_RTX_CLASS (code) == '2'
7369            || GET_RTX_CLASS (code) == '<')
7370     {
7371       cond0 = if_then_else_cond (XEXP (x, 0), &true0, &false0);
7372       cond1 = if_then_else_cond (XEXP (x, 1), &true1, &false1);
7373
7374       if ((cond0 != 0 || cond1 != 0)
7375           && ! (cond0 != 0 && cond1 != 0 && ! rtx_equal_p (cond0, cond1)))
7376         {
7377           /* If if_then_else_cond returned zero, then true/false are the
7378              same rtl.  We must copy one of them to prevent invalid rtl
7379              sharing.  */
7380           if (cond0 == 0)
7381             true0 = copy_rtx (true0);
7382           else if (cond1 == 0)
7383             true1 = copy_rtx (true1);
7384
7385           *ptrue = gen_binary (code, mode, true0, true1);
7386           *pfalse = gen_binary (code, mode, false0, false1);
7387           return cond0 ? cond0 : cond1;
7388         }
7389
7390       /* See if we have PLUS, IOR, XOR, MINUS or UMAX, where one of the
7391          operands is zero when the other is nonzero, and vice-versa,
7392          and STORE_FLAG_VALUE is 1 or -1.  */
7393
7394       if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
7395           && (code == PLUS || code == IOR || code == XOR || code == MINUS
7396               || code == UMAX)
7397           && GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == MULT)
7398         {
7399           rtx op0 = XEXP (XEXP (x, 0), 1);
7400           rtx op1 = XEXP (XEXP (x, 1), 1);
7401
7402           cond0 = XEXP (XEXP (x, 0), 0);
7403           cond1 = XEXP (XEXP (x, 1), 0);
7404
7405           if (GET_RTX_CLASS (GET_CODE (cond0)) == '<'
7406               && GET_RTX_CLASS (GET_CODE (cond1)) == '<'
7407               && ((GET_CODE (cond0) == combine_reversed_comparison_code (cond1)
7408                    && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 0))
7409                    && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 1)))
7410                   || ((swap_condition (GET_CODE (cond0))
7411                        == combine_reversed_comparison_code (cond1))
7412                       && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 1))
7413                       && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 0))))
7414               && ! side_effects_p (x))
7415             {
7416               *ptrue = gen_binary (MULT, mode, op0, const_true_rtx);
7417               *pfalse = gen_binary (MULT, mode,
7418                                     (code == MINUS
7419                                      ? simplify_gen_unary (NEG, mode, op1,
7420                                                            mode)
7421                                      : op1),
7422                                     const_true_rtx);
7423               return cond0;
7424             }
7425         }
7426
7427       /* Similarly for MULT, AND and UMIN, except that for these the result
7428          is always zero.  */
7429       if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
7430           && (code == MULT || code == AND || code == UMIN)
7431           && GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == MULT)
7432         {
7433           cond0 = XEXP (XEXP (x, 0), 0);
7434           cond1 = XEXP (XEXP (x, 1), 0);
7435
7436           if (GET_RTX_CLASS (GET_CODE (cond0)) == '<'
7437               && GET_RTX_CLASS (GET_CODE (cond1)) == '<'
7438               && ((GET_CODE (cond0) == combine_reversed_comparison_code (cond1)
7439                    && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 0))
7440                    && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 1)))
7441                   || ((swap_condition (GET_CODE (cond0))
7442                        == combine_reversed_comparison_code (cond1))
7443                       && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 1))
7444                       && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 0))))
7445               && ! side_effects_p (x))
7446             {
7447               *ptrue = *pfalse = const0_rtx;
7448               return cond0;
7449             }
7450         }
7451     }
7452
7453   else if (code == IF_THEN_ELSE)
7454     {
7455       /* If we have IF_THEN_ELSE already, extract the condition and
7456          canonicalize it if it is NE or EQ.  */
7457       cond0 = XEXP (x, 0);
7458       *ptrue = XEXP (x, 1), *pfalse = XEXP (x, 2);
7459       if (GET_CODE (cond0) == NE && XEXP (cond0, 1) == const0_rtx)
7460         return XEXP (cond0, 0);
7461       else if (GET_CODE (cond0) == EQ && XEXP (cond0, 1) == const0_rtx)
7462         {
7463           *ptrue = XEXP (x, 2), *pfalse = XEXP (x, 1);
7464           return XEXP (cond0, 0);
7465         }
7466       else
7467         return cond0;
7468     }
7469
7470   /* If X is a SUBREG, we can narrow both the true and false values
7471      if the inner expression, if there is a condition.  */
7472   else if (code == SUBREG
7473            && 0 != (cond0 = if_then_else_cond (SUBREG_REG (x),
7474                                                &true0, &false0)))
7475     {
7476       *ptrue = simplify_gen_subreg (mode, true0,
7477                                     GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
7478       *pfalse = simplify_gen_subreg (mode, false0,
7479                                      GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
7480
7481       return cond0;
7482     }
7483
7484   /* If X is a constant, this isn't special and will cause confusions
7485      if we treat it as such.  Likewise if it is equivalent to a constant.  */
7486   else if (CONSTANT_P (x)
7487            || ((cond0 = get_last_value (x)) != 0 && CONSTANT_P (cond0)))
7488     ;
7489
7490   /* If we're in BImode, canonicalize on 0 and STORE_FLAG_VALUE, as that
7491      will be least confusing to the rest of the compiler.  */
7492   else if (mode == BImode)
7493     {
7494       *ptrue = GEN_INT (STORE_FLAG_VALUE), *pfalse = const0_rtx;
7495       return x;
7496     }
7497
7498   /* If X is known to be either 0 or -1, those are the true and
7499      false values when testing X.  */
7500   else if (x == constm1_rtx || x == const0_rtx
7501            || (mode != VOIDmode
7502                && num_sign_bit_copies (x, mode) == GET_MODE_BITSIZE (mode)))
7503     {
7504       *ptrue = constm1_rtx, *pfalse = const0_rtx;
7505       return x;
7506     }
7507
7508   /* Likewise for 0 or a single bit.  */
7509   else if (mode != VOIDmode
7510            && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
7511            && exact_log2 (nz = nonzero_bits (x, mode)) >= 0)
7512     {
7513       *ptrue = gen_int_mode (nz, mode), *pfalse = const0_rtx;
7514       return x;
7515     }
7516
7517   /* Otherwise fail; show no condition with true and false values the same.  */
7518   *ptrue = *pfalse = x;
7519   return 0;
7520 }
7521 \f
7522 /* Return the value of expression X given the fact that condition COND
7523    is known to be true when applied to REG as its first operand and VAL
7524    as its second.  X is known to not be shared and so can be modified in
7525    place.
7526
7527    We only handle the simplest cases, and specifically those cases that
7528    arise with IF_THEN_ELSE expressions.  */
7529
7530 static rtx
7531 known_cond (rtx x, enum rtx_code cond, rtx reg, rtx val)
7532 {
7533   enum rtx_code code = GET_CODE (x);
7534   rtx temp;
7535   const char *fmt;
7536   int i, j;
7537
7538   if (side_effects_p (x))
7539     return x;
7540
7541   /* If either operand of the condition is a floating point value,
7542      then we have to avoid collapsing an EQ comparison.  */
7543   if (cond == EQ
7544       && rtx_equal_p (x, reg)
7545       && ! FLOAT_MODE_P (GET_MODE (x))
7546       && ! FLOAT_MODE_P (GET_MODE (val)))
7547     return val;
7548
7549   if (cond == UNEQ && rtx_equal_p (x, reg))
7550     return val;
7551
7552   /* If X is (abs REG) and we know something about REG's relationship
7553      with zero, we may be able to simplify this.  */
7554
7555   if (code == ABS && rtx_equal_p (XEXP (x, 0), reg) && val == const0_rtx)
7556     switch (cond)
7557       {
7558       case GE:  case GT:  case EQ:
7559         return XEXP (x, 0);
7560       case LT:  case LE:
7561         return simplify_gen_unary (NEG, GET_MODE (XEXP (x, 0)),
7562                                    XEXP (x, 0),
7563                                    GET_MODE (XEXP (x, 0)));
7564       default:
7565         break;
7566       }
7567
7568   /* The only other cases we handle are MIN, MAX, and comparisons if the
7569      operands are the same as REG and VAL.  */
7570
7571   else if (GET_RTX_CLASS (code) == '<' || GET_RTX_CLASS (code) == 'c')
7572     {
7573       if (rtx_equal_p (XEXP (x, 0), val))
7574         cond = swap_condition (cond), temp = val, val = reg, reg = temp;
7575
7576       if (rtx_equal_p (XEXP (x, 0), reg) && rtx_equal_p (XEXP (x, 1), val))
7577         {
7578           if (GET_RTX_CLASS (code) == '<')
7579             {
7580               if (comparison_dominates_p (cond, code))
7581                 return const_true_rtx;
7582
7583               code = combine_reversed_comparison_code (x);
7584               if (code != UNKNOWN
7585                   && comparison_dominates_p (cond, code))
7586                 return const0_rtx;
7587               else
7588                 return x;
7589             }
7590           else if (code == SMAX || code == SMIN
7591                    || code == UMIN || code == UMAX)
7592             {
7593               int unsignedp = (code == UMIN || code == UMAX);
7594
7595               /* Do not reverse the condition when it is NE or EQ.
7596                  This is because we cannot conclude anything about
7597                  the value of 'SMAX (x, y)' when x is not equal to y,
7598                  but we can when x equals y.  */
7599               if ((code == SMAX || code == UMAX)
7600                   && ! (cond == EQ || cond == NE))
7601                 cond = reverse_condition (cond);
7602
7603               switch (cond)
7604                 {
7605                 case GE:   case GT:
7606                   return unsignedp ? x : XEXP (x, 1);
7607                 case LE:   case LT:
7608                   return unsignedp ? x : XEXP (x, 0);
7609                 case GEU:  case GTU:
7610                   return unsignedp ? XEXP (x, 1) : x;
7611                 case LEU:  case LTU:
7612                   return unsignedp ? XEXP (x, 0) : x;
7613                 default:
7614                   break;
7615                 }
7616             }
7617         }
7618     }
7619   else if (code == SUBREG)
7620     {
7621       enum machine_mode inner_mode = GET_MODE (SUBREG_REG (x));
7622       rtx new, r = known_cond (SUBREG_REG (x), cond, reg, val);
7623
7624       if (SUBREG_REG (x) != r)
7625         {
7626           /* We must simplify subreg here, before we lose track of the
7627              original inner_mode.  */
7628           new = simplify_subreg (GET_MODE (x), r,
7629                                  inner_mode, SUBREG_BYTE (x));
7630           if (new)
7631             return new;
7632           else
7633             SUBST (SUBREG_REG (x), r);
7634         }
7635
7636       return x;
7637     }
7638   /* We don't have to handle SIGN_EXTEND here, because even in the
7639      case of replacing something with a modeless CONST_INT, a
7640      CONST_INT is already (supposed to be) a valid sign extension for
7641      its narrower mode, which implies it's already properly
7642      sign-extended for the wider mode.  Now, for ZERO_EXTEND, the
7643      story is different.  */
7644   else if (code == ZERO_EXTEND)
7645     {
7646       enum machine_mode inner_mode = GET_MODE (XEXP (x, 0));
7647       rtx new, r = known_cond (XEXP (x, 0), cond, reg, val);
7648
7649       if (XEXP (x, 0) != r)
7650         {
7651           /* We must simplify the zero_extend here, before we lose
7652              track of the original inner_mode.  */
7653           new = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
7654                                           r, inner_mode);
7655           if (new)
7656             return new;
7657           else
7658             SUBST (XEXP (x, 0), r);
7659         }
7660
7661       return x;
7662     }
7663
7664   fmt = GET_RTX_FORMAT (code);
7665   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
7666     {
7667       if (fmt[i] == 'e')
7668         SUBST (XEXP (x, i), known_cond (XEXP (x, i), cond, reg, val));
7669       else if (fmt[i] == 'E')
7670         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
7671           SUBST (XVECEXP (x, i, j), known_cond (XVECEXP (x, i, j),
7672                                                 cond, reg, val));
7673     }
7674
7675   return x;
7676 }
7677 \f
7678 /* See if X and Y are equal for the purposes of seeing if we can rewrite an
7679    assignment as a field assignment.  */
7680
7681 static int
7682 rtx_equal_for_field_assignment_p (rtx x, rtx y)
7683 {
7684   if (x == y || rtx_equal_p (x, y))
7685     return 1;
7686
7687   if (x == 0 || y == 0 || GET_MODE (x) != GET_MODE (y))
7688     return 0;
7689
7690   /* Check for a paradoxical SUBREG of a MEM compared with the MEM.
7691      Note that all SUBREGs of MEM are paradoxical; otherwise they
7692      would have been rewritten.  */
7693   if (GET_CODE (x) == MEM && GET_CODE (y) == SUBREG
7694       && GET_CODE (SUBREG_REG (y)) == MEM
7695       && rtx_equal_p (SUBREG_REG (y),
7696                       gen_lowpart_for_combine (GET_MODE (SUBREG_REG (y)), x)))
7697     return 1;
7698
7699   if (GET_CODE (y) == MEM && GET_CODE (x) == SUBREG
7700       && GET_CODE (SUBREG_REG (x)) == MEM
7701       && rtx_equal_p (SUBREG_REG (x),
7702                       gen_lowpart_for_combine (GET_MODE (SUBREG_REG (x)), y)))
7703     return 1;
7704
7705   /* We used to see if get_last_value of X and Y were the same but that's
7706      not correct.  In one direction, we'll cause the assignment to have
7707      the wrong destination and in the case, we'll import a register into this
7708      insn that might have already have been dead.   So fail if none of the
7709      above cases are true.  */
7710   return 0;
7711 }
7712 \f
7713 /* See if X, a SET operation, can be rewritten as a bit-field assignment.
7714    Return that assignment if so.
7715
7716    We only handle the most common cases.  */
7717
7718 static rtx
7719 make_field_assignment (rtx x)
7720 {
7721   rtx dest = SET_DEST (x);
7722   rtx src = SET_SRC (x);
7723   rtx assign;
7724   rtx rhs, lhs;
7725   HOST_WIDE_INT c1;
7726   HOST_WIDE_INT pos;
7727   unsigned HOST_WIDE_INT len;
7728   rtx other;
7729   enum machine_mode mode;
7730
7731   /* If SRC was (and (not (ashift (const_int 1) POS)) DEST), this is
7732      a clear of a one-bit field.  We will have changed it to
7733      (and (rotate (const_int -2) POS) DEST), so check for that.  Also check
7734      for a SUBREG.  */
7735
7736   if (GET_CODE (src) == AND && GET_CODE (XEXP (src, 0)) == ROTATE
7737       && GET_CODE (XEXP (XEXP (src, 0), 0)) == CONST_INT
7738       && INTVAL (XEXP (XEXP (src, 0), 0)) == -2
7739       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
7740     {
7741       assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
7742                                 1, 1, 1, 0);
7743       if (assign != 0)
7744         return gen_rtx_SET (VOIDmode, assign, const0_rtx);
7745       return x;
7746     }
7747
7748   else if (GET_CODE (src) == AND && GET_CODE (XEXP (src, 0)) == SUBREG
7749            && subreg_lowpart_p (XEXP (src, 0))
7750            && (GET_MODE_SIZE (GET_MODE (XEXP (src, 0)))
7751                < GET_MODE_SIZE (GET_MODE (SUBREG_REG (XEXP (src, 0)))))
7752            && GET_CODE (SUBREG_REG (XEXP (src, 0))) == ROTATE
7753            && INTVAL (XEXP (SUBREG_REG (XEXP (src, 0)), 0)) == -2
7754            && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
7755     {
7756       assign = make_extraction (VOIDmode, dest, 0,
7757                                 XEXP (SUBREG_REG (XEXP (src, 0)), 1),
7758                                 1, 1, 1, 0);
7759       if (assign != 0)
7760         return gen_rtx_SET (VOIDmode, assign, const0_rtx);
7761       return x;
7762     }
7763
7764   /* If SRC is (ior (ashift (const_int 1) POS) DEST), this is a set of a
7765      one-bit field.  */
7766   else if (GET_CODE (src) == IOR && GET_CODE (XEXP (src, 0)) == ASHIFT
7767            && XEXP (XEXP (src, 0), 0) == const1_rtx
7768            && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
7769     {
7770       assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
7771                                 1, 1, 1, 0);
7772       if (assign != 0)
7773         return gen_rtx_SET (VOIDmode, assign, const1_rtx);
7774       return x;
7775     }
7776
7777   /* The other case we handle is assignments into a constant-position
7778      field.  They look like (ior/xor (and DEST C1) OTHER).  If C1 represents
7779      a mask that has all one bits except for a group of zero bits and
7780      OTHER is known to have zeros where C1 has ones, this is such an
7781      assignment.  Compute the position and length from C1.  Shift OTHER
7782      to the appropriate position, force it to the required mode, and
7783      make the extraction.  Check for the AND in both operands.  */
7784
7785   if (GET_CODE (src) != IOR && GET_CODE (src) != XOR)
7786     return x;
7787
7788   rhs = expand_compound_operation (XEXP (src, 0));
7789   lhs = expand_compound_operation (XEXP (src, 1));
7790
7791   if (GET_CODE (rhs) == AND
7792       && GET_CODE (XEXP (rhs, 1)) == CONST_INT
7793       && rtx_equal_for_field_assignment_p (XEXP (rhs, 0), dest))
7794     c1 = INTVAL (XEXP (rhs, 1)), other = lhs;
7795   else if (GET_CODE (lhs) == AND
7796            && GET_CODE (XEXP (lhs, 1)) == CONST_INT
7797            && rtx_equal_for_field_assignment_p (XEXP (lhs, 0), dest))
7798     c1 = INTVAL (XEXP (lhs, 1)), other = rhs;
7799   else
7800     return x;
7801
7802   pos = get_pos_from_mask ((~c1) & GET_MODE_MASK (GET_MODE (dest)), &len);
7803   if (pos < 0 || pos + len > GET_MODE_BITSIZE (GET_MODE (dest))
7804       || GET_MODE_BITSIZE (GET_MODE (dest)) > HOST_BITS_PER_WIDE_INT
7805       || (c1 & nonzero_bits (other, GET_MODE (dest))) != 0)
7806     return x;
7807
7808   assign = make_extraction (VOIDmode, dest, pos, NULL_RTX, len, 1, 1, 0);
7809   if (assign == 0)
7810     return x;
7811
7812   /* The mode to use for the source is the mode of the assignment, or of
7813      what is inside a possible STRICT_LOW_PART.  */
7814   mode = (GET_CODE (assign) == STRICT_LOW_PART
7815           ? GET_MODE (XEXP (assign, 0)) : GET_MODE (assign));
7816
7817   /* Shift OTHER right POS places and make it the source, restricting it
7818      to the proper length and mode.  */
7819
7820   src = force_to_mode (simplify_shift_const (NULL_RTX, LSHIFTRT,
7821                                              GET_MODE (src), other, pos),
7822                        mode,
7823                        GET_MODE_BITSIZE (mode) >= HOST_BITS_PER_WIDE_INT
7824                        ? ~(unsigned HOST_WIDE_INT) 0
7825                        : ((unsigned HOST_WIDE_INT) 1 << len) - 1,
7826                        dest, 0);
7827
7828   /* If SRC is masked by an AND that does not make a difference in
7829      the value being stored, strip it.  */
7830   if (GET_CODE (assign) == ZERO_EXTRACT
7831       && GET_CODE (XEXP (assign, 1)) == CONST_INT
7832       && INTVAL (XEXP (assign, 1)) < HOST_BITS_PER_WIDE_INT
7833       && GET_CODE (src) == AND
7834       && GET_CODE (XEXP (src, 1)) == CONST_INT
7835       && ((unsigned HOST_WIDE_INT) INTVAL (XEXP (src, 1))
7836           == ((unsigned HOST_WIDE_INT) 1 << INTVAL (XEXP (assign, 1))) - 1))
7837     src = XEXP (src, 0);
7838
7839   return gen_rtx_SET (VOIDmode, assign, src);
7840 }
7841 \f
7842 /* See if X is of the form (+ (* a c) (* b c)) and convert to (* (+ a b) c)
7843    if so.  */
7844
7845 static rtx
7846 apply_distributive_law (rtx x)
7847 {
7848   enum rtx_code code = GET_CODE (x);
7849   rtx lhs, rhs, other;
7850   rtx tem;
7851   enum rtx_code inner_code;
7852
7853   /* Distributivity is not true for floating point.
7854      It can change the value.  So don't do it.
7855      -- rms and moshier@world.std.com.  */
7856   if (FLOAT_MODE_P (GET_MODE (x)))
7857     return x;
7858
7859   /* The outer operation can only be one of the following:  */
7860   if (code != IOR && code != AND && code != XOR
7861       && code != PLUS && code != MINUS)
7862     return x;
7863
7864   lhs = XEXP (x, 0), rhs = XEXP (x, 1);
7865
7866   /* If either operand is a primitive we can't do anything, so get out
7867      fast.  */
7868   if (GET_RTX_CLASS (GET_CODE (lhs)) == 'o'
7869       || GET_RTX_CLASS (GET_CODE (rhs)) == 'o')
7870     return x;
7871
7872   lhs = expand_compound_operation (lhs);
7873   rhs = expand_compound_operation (rhs);
7874   inner_code = GET_CODE (lhs);
7875   if (inner_code != GET_CODE (rhs))
7876     return x;
7877
7878   /* See if the inner and outer operations distribute.  */
7879   switch (inner_code)
7880     {
7881     case LSHIFTRT:
7882     case ASHIFTRT:
7883     case AND:
7884     case IOR:
7885       /* These all distribute except over PLUS.  */
7886       if (code == PLUS || code == MINUS)
7887         return x;
7888       break;
7889
7890     case MULT:
7891       if (code != PLUS && code != MINUS)
7892         return x;
7893       break;
7894
7895     case ASHIFT:
7896       /* This is also a multiply, so it distributes over everything.  */
7897       break;
7898
7899     case SUBREG:
7900       /* Non-paradoxical SUBREGs distributes over all operations, provided
7901          the inner modes and byte offsets are the same, this is an extraction
7902          of a low-order part, we don't convert an fp operation to int or
7903          vice versa, and we would not be converting a single-word
7904          operation into a multi-word operation.  The latter test is not
7905          required, but it prevents generating unneeded multi-word operations.
7906          Some of the previous tests are redundant given the latter test, but
7907          are retained because they are required for correctness.
7908
7909          We produce the result slightly differently in this case.  */
7910
7911       if (GET_MODE (SUBREG_REG (lhs)) != GET_MODE (SUBREG_REG (rhs))
7912           || SUBREG_BYTE (lhs) != SUBREG_BYTE (rhs)
7913           || ! subreg_lowpart_p (lhs)
7914           || (GET_MODE_CLASS (GET_MODE (lhs))
7915               != GET_MODE_CLASS (GET_MODE (SUBREG_REG (lhs))))
7916           || (GET_MODE_SIZE (GET_MODE (lhs))
7917               > GET_MODE_SIZE (GET_MODE (SUBREG_REG (lhs))))
7918           || GET_MODE_SIZE (GET_MODE (SUBREG_REG (lhs))) > UNITS_PER_WORD)
7919         return x;
7920
7921       tem = gen_binary (code, GET_MODE (SUBREG_REG (lhs)),
7922                         SUBREG_REG (lhs), SUBREG_REG (rhs));
7923       return gen_lowpart_for_combine (GET_MODE (x), tem);
7924
7925     default:
7926       return x;
7927     }
7928
7929   /* Set LHS and RHS to the inner operands (A and B in the example
7930      above) and set OTHER to the common operand (C in the example).
7931      These is only one way to do this unless the inner operation is
7932      commutative.  */
7933   if (GET_RTX_CLASS (inner_code) == 'c'
7934       && rtx_equal_p (XEXP (lhs, 0), XEXP (rhs, 0)))
7935     other = XEXP (lhs, 0), lhs = XEXP (lhs, 1), rhs = XEXP (rhs, 1);
7936   else if (GET_RTX_CLASS (inner_code) == 'c'
7937            && rtx_equal_p (XEXP (lhs, 0), XEXP (rhs, 1)))
7938     other = XEXP (lhs, 0), lhs = XEXP (lhs, 1), rhs = XEXP (rhs, 0);
7939   else if (GET_RTX_CLASS (inner_code) == 'c'
7940            && rtx_equal_p (XEXP (lhs, 1), XEXP (rhs, 0)))
7941     other = XEXP (lhs, 1), lhs = XEXP (lhs, 0), rhs = XEXP (rhs, 1);
7942   else if (rtx_equal_p (XEXP (lhs, 1), XEXP (rhs, 1)))
7943     other = XEXP (lhs, 1), lhs = XEXP (lhs, 0), rhs = XEXP (rhs, 0);
7944   else
7945     return x;
7946
7947   /* Form the new inner operation, seeing if it simplifies first.  */
7948   tem = gen_binary (code, GET_MODE (x), lhs, rhs);
7949
7950   /* There is one exception to the general way of distributing:
7951      (a ^ b) | (a ^ c) -> (~a) & (b ^ c)  */
7952   if (code == XOR && inner_code == IOR)
7953     {
7954       inner_code = AND;
7955       other = simplify_gen_unary (NOT, GET_MODE (x), other, GET_MODE (x));
7956     }
7957
7958   /* We may be able to continuing distributing the result, so call
7959      ourselves recursively on the inner operation before forming the
7960      outer operation, which we return.  */
7961   return gen_binary (inner_code, GET_MODE (x),
7962                      apply_distributive_law (tem), other);
7963 }
7964 \f
7965 /* We have X, a logical `and' of VAROP with the constant CONSTOP, to be done
7966    in MODE.
7967
7968    Return an equivalent form, if different from X.  Otherwise, return X.  If
7969    X is zero, we are to always construct the equivalent form.  */
7970
7971 static rtx
7972 simplify_and_const_int (rtx x, enum machine_mode mode, rtx varop,
7973                         unsigned HOST_WIDE_INT constop)
7974 {
7975   unsigned HOST_WIDE_INT nonzero;
7976   int i;
7977
7978   /* Simplify VAROP knowing that we will be only looking at some of the
7979      bits in it.
7980
7981      Note by passing in CONSTOP, we guarantee that the bits not set in
7982      CONSTOP are not significant and will never be examined.  We must
7983      ensure that is the case by explicitly masking out those bits
7984      before returning.  */
7985   varop = force_to_mode (varop, mode, constop, NULL_RTX, 0);
7986
7987   /* If VAROP is a CLOBBER, we will fail so return it.  */
7988   if (GET_CODE (varop) == CLOBBER)
7989     return varop;
7990
7991   /* If VAROP is a CONST_INT, then we need to apply the mask in CONSTOP
7992      to VAROP and return the new constant.  */
7993   if (GET_CODE (varop) == CONST_INT)
7994     return GEN_INT (trunc_int_for_mode (INTVAL (varop) & constop, mode));
7995
7996   /* See what bits may be nonzero in VAROP.  Unlike the general case of
7997      a call to nonzero_bits, here we don't care about bits outside
7998      MODE.  */
7999
8000   nonzero = nonzero_bits (varop, mode) & GET_MODE_MASK (mode);
8001
8002   /* Turn off all bits in the constant that are known to already be zero.
8003      Thus, if the AND isn't needed at all, we will have CONSTOP == NONZERO_BITS
8004      which is tested below.  */
8005
8006   constop &= nonzero;
8007
8008   /* If we don't have any bits left, return zero.  */
8009   if (constop == 0)
8010     return const0_rtx;
8011
8012   /* If VAROP is a NEG of something known to be zero or 1 and CONSTOP is
8013      a power of two, we can replace this with an ASHIFT.  */
8014   if (GET_CODE (varop) == NEG && nonzero_bits (XEXP (varop, 0), mode) == 1
8015       && (i = exact_log2 (constop)) >= 0)
8016     return simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (varop, 0), i);
8017
8018   /* If VAROP is an IOR or XOR, apply the AND to both branches of the IOR
8019      or XOR, then try to apply the distributive law.  This may eliminate
8020      operations if either branch can be simplified because of the AND.
8021      It may also make some cases more complex, but those cases probably
8022      won't match a pattern either with or without this.  */
8023
8024   if (GET_CODE (varop) == IOR || GET_CODE (varop) == XOR)
8025     return
8026       gen_lowpart_for_combine
8027         (mode,
8028          apply_distributive_law
8029          (gen_binary (GET_CODE (varop), GET_MODE (varop),
8030                       simplify_and_const_int (NULL_RTX, GET_MODE (varop),
8031                                               XEXP (varop, 0), constop),
8032                       simplify_and_const_int (NULL_RTX, GET_MODE (varop),
8033                                               XEXP (varop, 1), constop))));
8034
8035   /* If VAROP is PLUS, and the constant is a mask of low bite, distribute
8036      the AND and see if one of the operands simplifies to zero.  If so, we
8037      may eliminate it.  */
8038
8039   if (GET_CODE (varop) == PLUS
8040       && exact_log2 (constop + 1) >= 0)
8041     {
8042       rtx o0, o1;
8043
8044       o0 = simplify_and_const_int (NULL_RTX, mode, XEXP (varop, 0), constop);
8045       o1 = simplify_and_const_int (NULL_RTX, mode, XEXP (varop, 1), constop);
8046       if (o0 == const0_rtx)
8047         return o1;
8048       if (o1 == const0_rtx)
8049         return o0;
8050     }
8051
8052   /* Get VAROP in MODE.  Try to get a SUBREG if not.  Don't make a new SUBREG
8053      if we already had one (just check for the simplest cases).  */
8054   if (x && GET_CODE (XEXP (x, 0)) == SUBREG
8055       && GET_MODE (XEXP (x, 0)) == mode
8056       && SUBREG_REG (XEXP (x, 0)) == varop)
8057     varop = XEXP (x, 0);
8058   else
8059     varop = gen_lowpart_for_combine (mode, varop);
8060
8061   /* If we can't make the SUBREG, try to return what we were given.  */
8062   if (GET_CODE (varop) == CLOBBER)
8063     return x ? x : varop;
8064
8065   /* If we are only masking insignificant bits, return VAROP.  */
8066   if (constop == nonzero)
8067     x = varop;
8068   else
8069     {
8070       /* Otherwise, return an AND.  */
8071       constop = trunc_int_for_mode (constop, mode);
8072       /* See how much, if any, of X we can use.  */
8073       if (x == 0 || GET_CODE (x) != AND || GET_MODE (x) != mode)
8074         x = gen_binary (AND, mode, varop, GEN_INT (constop));
8075
8076       else
8077         {
8078           if (GET_CODE (XEXP (x, 1)) != CONST_INT
8079               || (unsigned HOST_WIDE_INT) INTVAL (XEXP (x, 1)) != constop)
8080             SUBST (XEXP (x, 1), GEN_INT (constop));
8081
8082           SUBST (XEXP (x, 0), varop);
8083         }
8084     }
8085
8086   return x;
8087 }
8088 \f
8089 #define nonzero_bits_with_known(X, MODE) \
8090   cached_nonzero_bits (X, MODE, known_x, known_mode, known_ret)
8091
8092 /* The function cached_nonzero_bits is a wrapper around nonzero_bits1.
8093    It avoids exponential behavior in nonzero_bits1 when X has
8094    identical subexpressions on the first or the second level.  */
8095
8096 static unsigned HOST_WIDE_INT
8097 cached_nonzero_bits (rtx x, enum machine_mode mode, rtx known_x,
8098                      enum machine_mode known_mode,
8099                      unsigned HOST_WIDE_INT known_ret)
8100 {
8101   if (x == known_x && mode == known_mode)
8102     return known_ret;
8103
8104   /* Try to find identical subexpressions.  If found call
8105      nonzero_bits1 on X with the subexpressions as KNOWN_X and the
8106      precomputed value for the subexpression as KNOWN_RET.  */
8107
8108   if (GET_RTX_CLASS (GET_CODE (x)) == '2'
8109       || GET_RTX_CLASS (GET_CODE (x)) == 'c')
8110     {
8111       rtx x0 = XEXP (x, 0);
8112       rtx x1 = XEXP (x, 1);
8113
8114       /* Check the first level.  */
8115       if (x0 == x1)
8116         return nonzero_bits1 (x, mode, x0, mode,
8117                               nonzero_bits_with_known (x0, mode));
8118
8119       /* Check the second level.  */
8120       if ((GET_RTX_CLASS (GET_CODE (x0)) == '2'
8121            || GET_RTX_CLASS (GET_CODE (x0)) == 'c')
8122           && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
8123         return nonzero_bits1 (x, mode, x1, mode,
8124                               nonzero_bits_with_known (x1, mode));
8125
8126       if ((GET_RTX_CLASS (GET_CODE (x1)) == '2'
8127            || GET_RTX_CLASS (GET_CODE (x1)) == 'c')
8128           && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
8129         return nonzero_bits1 (x, mode, x0, mode,
8130                          nonzero_bits_with_known (x0, mode));
8131     }
8132
8133   return nonzero_bits1 (x, mode, known_x, known_mode, known_ret);
8134 }
8135
8136 /* We let num_sign_bit_copies recur into nonzero_bits as that is useful.
8137    We don't let nonzero_bits recur into num_sign_bit_copies, because that
8138    is less useful.  We can't allow both, because that results in exponential
8139    run time recursion.  There is a nullstone testcase that triggered
8140    this.  This macro avoids accidental uses of num_sign_bit_copies.  */
8141 #define cached_num_sign_bit_copies()
8142
8143 /* Given an expression, X, compute which bits in X can be nonzero.
8144    We don't care about bits outside of those defined in MODE.
8145
8146    For most X this is simply GET_MODE_MASK (GET_MODE (MODE)), but if X is
8147    a shift, AND, or zero_extract, we can do better.  */
8148
8149 static unsigned HOST_WIDE_INT
8150 nonzero_bits1 (rtx x, enum machine_mode mode, rtx known_x,
8151                enum machine_mode known_mode,
8152                unsigned HOST_WIDE_INT known_ret)
8153 {
8154   unsigned HOST_WIDE_INT nonzero = GET_MODE_MASK (mode);
8155   unsigned HOST_WIDE_INT inner_nz;
8156   enum rtx_code code;
8157   unsigned int mode_width = GET_MODE_BITSIZE (mode);
8158   rtx tem;
8159
8160   /* For floating-point values, assume all bits are needed.  */
8161   if (FLOAT_MODE_P (GET_MODE (x)) || FLOAT_MODE_P (mode))
8162     return nonzero;
8163
8164   /* If X is wider than MODE, use its mode instead.  */
8165   if (GET_MODE_BITSIZE (GET_MODE (x)) > mode_width)
8166     {
8167       mode = GET_MODE (x);
8168       nonzero = GET_MODE_MASK (mode);
8169       mode_width = GET_MODE_BITSIZE (mode);
8170     }
8171
8172   if (mode_width > HOST_BITS_PER_WIDE_INT)
8173     /* Our only callers in this case look for single bit values.  So
8174        just return the mode mask.  Those tests will then be false.  */
8175     return nonzero;
8176
8177 #ifndef WORD_REGISTER_OPERATIONS
8178   /* If MODE is wider than X, but both are a single word for both the host
8179      and target machines, we can compute this from which bits of the
8180      object might be nonzero in its own mode, taking into account the fact
8181      that on many CISC machines, accessing an object in a wider mode
8182      causes the high-order bits to become undefined.  So they are
8183      not known to be zero.  */
8184
8185   if (GET_MODE (x) != VOIDmode && GET_MODE (x) != mode
8186       && GET_MODE_BITSIZE (GET_MODE (x)) <= BITS_PER_WORD
8187       && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
8188       && GET_MODE_BITSIZE (mode) > GET_MODE_BITSIZE (GET_MODE (x)))
8189     {
8190       nonzero &= nonzero_bits_with_known (x, GET_MODE (x));
8191       nonzero |= GET_MODE_MASK (mode) & ~GET_MODE_MASK (GET_MODE (x));
8192       return nonzero;
8193     }
8194 #endif
8195
8196   code = GET_CODE (x);
8197   switch (code)
8198     {
8199     case REG:
8200 #if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
8201       /* If pointers extend unsigned and this is a pointer in Pmode, say that
8202          all the bits above ptr_mode are known to be zero.  */
8203       if (POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode
8204           && REG_POINTER (x))
8205         nonzero &= GET_MODE_MASK (ptr_mode);
8206 #endif
8207
8208       /* Include declared information about alignment of pointers.  */
8209       /* ??? We don't properly preserve REG_POINTER changes across
8210          pointer-to-integer casts, so we can't trust it except for
8211          things that we know must be pointers.  See execute/960116-1.c.  */
8212       if ((x == stack_pointer_rtx
8213            || x == frame_pointer_rtx
8214            || x == arg_pointer_rtx)
8215           && REGNO_POINTER_ALIGN (REGNO (x)))
8216         {
8217           unsigned HOST_WIDE_INT alignment
8218             = REGNO_POINTER_ALIGN (REGNO (x)) / BITS_PER_UNIT;
8219
8220 #ifdef PUSH_ROUNDING
8221           /* If PUSH_ROUNDING is defined, it is possible for the
8222              stack to be momentarily aligned only to that amount,
8223              so we pick the least alignment.  */
8224           if (x == stack_pointer_rtx && PUSH_ARGS)
8225             alignment = MIN (PUSH_ROUNDING (1), alignment);
8226 #endif
8227
8228           nonzero &= ~(alignment - 1);
8229         }
8230
8231       /* If X is a register whose nonzero bits value is current, use it.
8232          Otherwise, if X is a register whose value we can find, use that
8233          value.  Otherwise, use the previously-computed global nonzero bits
8234          for this register.  */
8235
8236       if (reg_last_set_value[REGNO (x)] != 0
8237           && (reg_last_set_mode[REGNO (x)] == mode
8238               || (GET_MODE_CLASS (reg_last_set_mode[REGNO (x)]) == MODE_INT
8239                   && GET_MODE_CLASS (mode) == MODE_INT))
8240           && (reg_last_set_label[REGNO (x)] == label_tick
8241               || (REGNO (x) >= FIRST_PSEUDO_REGISTER
8242                   && REG_N_SETS (REGNO (x)) == 1
8243                   && ! REGNO_REG_SET_P (ENTRY_BLOCK_PTR->next_bb->global_live_at_start,
8244                                         REGNO (x))))
8245           && INSN_CUID (reg_last_set[REGNO (x)]) < subst_low_cuid)
8246         return reg_last_set_nonzero_bits[REGNO (x)] & nonzero;
8247
8248       tem = get_last_value (x);
8249
8250       if (tem)
8251         {
8252 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
8253           /* If X is narrower than MODE and TEM is a non-negative
8254              constant that would appear negative in the mode of X,
8255              sign-extend it for use in reg_nonzero_bits because some
8256              machines (maybe most) will actually do the sign-extension
8257              and this is the conservative approach.
8258
8259              ??? For 2.5, try to tighten up the MD files in this regard
8260              instead of this kludge.  */
8261
8262           if (GET_MODE_BITSIZE (GET_MODE (x)) < mode_width
8263               && GET_CODE (tem) == CONST_INT
8264               && INTVAL (tem) > 0
8265               && 0 != (INTVAL (tem)
8266                        & ((HOST_WIDE_INT) 1
8267                           << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
8268             tem = GEN_INT (INTVAL (tem)
8269                            | ((HOST_WIDE_INT) (-1)
8270                               << GET_MODE_BITSIZE (GET_MODE (x))));
8271 #endif
8272           return nonzero_bits_with_known (tem, mode) & nonzero;
8273         }
8274       else if (nonzero_sign_valid && reg_nonzero_bits[REGNO (x)])
8275         {
8276           unsigned HOST_WIDE_INT mask = reg_nonzero_bits[REGNO (x)];
8277
8278           if (GET_MODE_BITSIZE (GET_MODE (x)) < mode_width)
8279             /* We don't know anything about the upper bits.  */
8280             mask |= GET_MODE_MASK (mode) ^ GET_MODE_MASK (GET_MODE (x));
8281           return nonzero & mask;
8282         }
8283       else
8284         return nonzero;
8285
8286     case CONST_INT:
8287 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
8288       /* If X is negative in MODE, sign-extend the value.  */
8289       if (INTVAL (x) > 0 && mode_width < BITS_PER_WORD
8290           && 0 != (INTVAL (x) & ((HOST_WIDE_INT) 1 << (mode_width - 1))))
8291         return (INTVAL (x) | ((HOST_WIDE_INT) (-1) << mode_width));
8292 #endif
8293
8294       return INTVAL (x);
8295
8296     case MEM:
8297 #ifdef LOAD_EXTEND_OP
8298       /* In many, if not most, RISC machines, reading a byte from memory
8299          zeros the rest of the register.  Noticing that fact saves a lot
8300          of extra zero-extends.  */
8301       if (LOAD_EXTEND_OP (GET_MODE (x)) == ZERO_EXTEND)
8302         nonzero &= GET_MODE_MASK (GET_MODE (x));
8303 #endif
8304       break;
8305
8306     case EQ:  case NE:
8307     case UNEQ:  case LTGT:
8308     case GT:  case GTU:  case UNGT:
8309     case LT:  case LTU:  case UNLT:
8310     case GE:  case GEU:  case UNGE:
8311     case LE:  case LEU:  case UNLE:
8312     case UNORDERED: case ORDERED:
8313
8314       /* If this produces an integer result, we know which bits are set.
8315          Code here used to clear bits outside the mode of X, but that is
8316          now done above.  */
8317
8318       if (GET_MODE_CLASS (mode) == MODE_INT
8319           && mode_width <= HOST_BITS_PER_WIDE_INT)
8320         nonzero = STORE_FLAG_VALUE;
8321       break;
8322
8323     case NEG:
8324 #if 0
8325       /* Disabled to avoid exponential mutual recursion between nonzero_bits
8326          and num_sign_bit_copies.  */
8327       if (num_sign_bit_copies (XEXP (x, 0), GET_MODE (x))
8328           == GET_MODE_BITSIZE (GET_MODE (x)))
8329         nonzero = 1;
8330 #endif
8331
8332       if (GET_MODE_SIZE (GET_MODE (x)) < mode_width)
8333         nonzero |= (GET_MODE_MASK (mode) & ~GET_MODE_MASK (GET_MODE (x)));
8334       break;
8335
8336     case ABS:
8337 #if 0
8338       /* Disabled to avoid exponential mutual recursion between nonzero_bits
8339          and num_sign_bit_copies.  */
8340       if (num_sign_bit_copies (XEXP (x, 0), GET_MODE (x))
8341           == GET_MODE_BITSIZE (GET_MODE (x)))
8342         nonzero = 1;
8343 #endif
8344       break;
8345
8346     case TRUNCATE:
8347       nonzero &= (nonzero_bits_with_known (XEXP (x, 0), mode)
8348                   & GET_MODE_MASK (mode));
8349       break;
8350
8351     case ZERO_EXTEND:
8352       nonzero &= nonzero_bits_with_known (XEXP (x, 0), mode);
8353       if (GET_MODE (XEXP (x, 0)) != VOIDmode)
8354         nonzero &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
8355       break;
8356
8357     case SIGN_EXTEND:
8358       /* If the sign bit is known clear, this is the same as ZERO_EXTEND.
8359          Otherwise, show all the bits in the outer mode but not the inner
8360          may be nonzero.  */
8361       inner_nz = nonzero_bits_with_known (XEXP (x, 0), mode);
8362       if (GET_MODE (XEXP (x, 0)) != VOIDmode)
8363         {
8364           inner_nz &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
8365           if (inner_nz
8366               & (((HOST_WIDE_INT) 1
8367                   << (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - 1))))
8368             inner_nz |= (GET_MODE_MASK (mode)
8369                          & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0))));
8370         }
8371
8372       nonzero &= inner_nz;
8373       break;
8374
8375     case AND:
8376       nonzero &= (nonzero_bits_with_known (XEXP (x, 0), mode)
8377                   & nonzero_bits_with_known (XEXP (x, 1), mode));
8378       break;
8379
8380     case XOR:   case IOR:
8381     case UMIN:  case UMAX:  case SMIN:  case SMAX:
8382       {
8383         unsigned HOST_WIDE_INT nonzero0 =
8384           nonzero_bits_with_known (XEXP (x, 0), mode);
8385
8386         /* Don't call nonzero_bits for the second time if it cannot change
8387            anything.  */
8388         if ((nonzero & nonzero0) != nonzero)
8389           nonzero &= (nonzero0
8390                       | nonzero_bits_with_known (XEXP (x, 1), mode));
8391       }
8392       break;
8393
8394     case PLUS:  case MINUS:
8395     case MULT:
8396     case DIV:   case UDIV:
8397     case MOD:   case UMOD:
8398       /* We can apply the rules of arithmetic to compute the number of
8399          high- and low-order zero bits of these operations.  We start by
8400          computing the width (position of the highest-order nonzero bit)
8401          and the number of low-order zero bits for each value.  */
8402       {
8403         unsigned HOST_WIDE_INT nz0 =
8404           nonzero_bits_with_known (XEXP (x, 0), mode);
8405         unsigned HOST_WIDE_INT nz1 =
8406           nonzero_bits_with_known (XEXP (x, 1), mode);
8407         int sign_index = GET_MODE_BITSIZE (GET_MODE (x)) - 1;
8408         int width0 = floor_log2 (nz0) + 1;
8409         int width1 = floor_log2 (nz1) + 1;
8410         int low0 = floor_log2 (nz0 & -nz0);
8411         int low1 = floor_log2 (nz1 & -nz1);
8412         HOST_WIDE_INT op0_maybe_minusp
8413           = (nz0 & ((HOST_WIDE_INT) 1 << sign_index));
8414         HOST_WIDE_INT op1_maybe_minusp
8415           = (nz1 & ((HOST_WIDE_INT) 1 << sign_index));
8416         unsigned int result_width = mode_width;
8417         int result_low = 0;
8418
8419         switch (code)
8420           {
8421           case PLUS:
8422             result_width = MAX (width0, width1) + 1;
8423             result_low = MIN (low0, low1);
8424             break;
8425           case MINUS:
8426             result_low = MIN (low0, low1);
8427             break;
8428           case MULT:
8429             result_width = width0 + width1;
8430             result_low = low0 + low1;
8431             break;
8432           case DIV:
8433             if (width1 == 0)
8434               break;
8435             if (! op0_maybe_minusp && ! op1_maybe_minusp)
8436               result_width = width0;
8437             break;
8438           case UDIV:
8439             if (width1 == 0)
8440               break;
8441             result_width = width0;
8442             break;
8443           case MOD:
8444             if (width1 == 0)
8445               break;
8446             if (! op0_maybe_minusp && ! op1_maybe_minusp)
8447               result_width = MIN (width0, width1);
8448             result_low = MIN (low0, low1);
8449             break;
8450           case UMOD:
8451             if (width1 == 0)
8452               break;
8453             result_width = MIN (width0, width1);
8454             result_low = MIN (low0, low1);
8455             break;
8456           default:
8457             abort ();
8458           }
8459
8460         if (result_width < mode_width)
8461           nonzero &= ((HOST_WIDE_INT) 1 << result_width) - 1;
8462
8463         if (result_low > 0)
8464           nonzero &= ~(((HOST_WIDE_INT) 1 << result_low) - 1);
8465
8466 #ifdef POINTERS_EXTEND_UNSIGNED
8467         /* If pointers extend unsigned and this is an addition or subtraction
8468            to a pointer in Pmode, all the bits above ptr_mode are known to be
8469            zero.  */
8470         if (POINTERS_EXTEND_UNSIGNED > 0 && GET_MODE (x) == Pmode
8471             && (code == PLUS || code == MINUS)
8472             && GET_CODE (XEXP (x, 0)) == REG && REG_POINTER (XEXP (x, 0)))
8473           nonzero &= GET_MODE_MASK (ptr_mode);
8474 #endif
8475       }
8476       break;
8477
8478     case ZERO_EXTRACT:
8479       if (GET_CODE (XEXP (x, 1)) == CONST_INT
8480           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
8481         nonzero &= ((HOST_WIDE_INT) 1 << INTVAL (XEXP (x, 1))) - 1;
8482       break;
8483
8484     case SUBREG:
8485       /* If this is a SUBREG formed for a promoted variable that has
8486          been zero-extended, we know that at least the high-order bits
8487          are zero, though others might be too.  */
8488
8489       if (SUBREG_PROMOTED_VAR_P (x) && SUBREG_PROMOTED_UNSIGNED_P (x) > 0)
8490         nonzero = (GET_MODE_MASK (GET_MODE (x))
8491                    & nonzero_bits_with_known (SUBREG_REG (x), GET_MODE (x)));
8492
8493       /* If the inner mode is a single word for both the host and target
8494          machines, we can compute this from which bits of the inner
8495          object might be nonzero.  */
8496       if (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) <= BITS_PER_WORD
8497           && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
8498               <= HOST_BITS_PER_WIDE_INT))
8499         {
8500           nonzero &= nonzero_bits_with_known (SUBREG_REG (x), mode);
8501
8502 #if defined (WORD_REGISTER_OPERATIONS) && defined (LOAD_EXTEND_OP)
8503           /* If this is a typical RISC machine, we only have to worry
8504              about the way loads are extended.  */
8505           if ((LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) == SIGN_EXTEND
8506                ? (((nonzero
8507                     & (((unsigned HOST_WIDE_INT) 1
8508                         << (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) - 1))))
8509                    != 0))
8510                : LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) != ZERO_EXTEND)
8511               || GET_CODE (SUBREG_REG (x)) != MEM)
8512 #endif
8513             {
8514               /* On many CISC machines, accessing an object in a wider mode
8515                  causes the high-order bits to become undefined.  So they are
8516                  not known to be zero.  */
8517               if (GET_MODE_SIZE (GET_MODE (x))
8518                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
8519                 nonzero |= (GET_MODE_MASK (GET_MODE (x))
8520                             & ~GET_MODE_MASK (GET_MODE (SUBREG_REG (x))));
8521             }
8522         }
8523       break;
8524
8525     case ASHIFTRT:
8526     case LSHIFTRT:
8527     case ASHIFT:
8528     case ROTATE:
8529       /* The nonzero bits are in two classes: any bits within MODE
8530          that aren't in GET_MODE (x) are always significant.  The rest of the
8531          nonzero bits are those that are significant in the operand of
8532          the shift when shifted the appropriate number of bits.  This
8533          shows that high-order bits are cleared by the right shift and
8534          low-order bits by left shifts.  */
8535       if (GET_CODE (XEXP (x, 1)) == CONST_INT
8536           && INTVAL (XEXP (x, 1)) >= 0
8537           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
8538         {
8539           enum machine_mode inner_mode = GET_MODE (x);
8540           unsigned int width = GET_MODE_BITSIZE (inner_mode);
8541           int count = INTVAL (XEXP (x, 1));
8542           unsigned HOST_WIDE_INT mode_mask = GET_MODE_MASK (inner_mode);
8543           unsigned HOST_WIDE_INT op_nonzero =
8544             nonzero_bits_with_known (XEXP (x, 0), mode);
8545           unsigned HOST_WIDE_INT inner = op_nonzero & mode_mask;
8546           unsigned HOST_WIDE_INT outer = 0;
8547
8548           if (mode_width > width)
8549             outer = (op_nonzero & nonzero & ~mode_mask);
8550
8551           if (code == LSHIFTRT)
8552             inner >>= count;
8553           else if (code == ASHIFTRT)
8554             {
8555               inner >>= count;
8556
8557               /* If the sign bit may have been nonzero before the shift, we
8558                  need to mark all the places it could have been copied to
8559                  by the shift as possibly nonzero.  */
8560               if (inner & ((HOST_WIDE_INT) 1 << (width - 1 - count)))
8561                 inner |= (((HOST_WIDE_INT) 1 << count) - 1) << (width - count);
8562             }
8563           else if (code == ASHIFT)
8564             inner <<= count;
8565           else
8566             inner = ((inner << (count % width)
8567                       | (inner >> (width - (count % width)))) & mode_mask);
8568
8569           nonzero &= (outer | inner);
8570         }
8571       break;
8572
8573     case FFS:
8574     case POPCOUNT:
8575       /* This is at most the number of bits in the mode.  */
8576       nonzero = ((HOST_WIDE_INT) 2 << (floor_log2 (mode_width))) - 1;
8577       break;
8578
8579     case CLZ:
8580       /* If CLZ has a known value at zero, then the nonzero bits are
8581          that value, plus the number of bits in the mode minus one.  */
8582       if (CLZ_DEFINED_VALUE_AT_ZERO (mode, nonzero))
8583         nonzero |= ((HOST_WIDE_INT) 1 << (floor_log2 (mode_width))) - 1;
8584       else
8585         nonzero = -1;
8586       break;
8587
8588     case CTZ:
8589       /* If CTZ has a known value at zero, then the nonzero bits are
8590          that value, plus the number of bits in the mode minus one.  */
8591       if (CTZ_DEFINED_VALUE_AT_ZERO (mode, nonzero))
8592         nonzero |= ((HOST_WIDE_INT) 1 << (floor_log2 (mode_width))) - 1;
8593       else
8594         nonzero = -1;
8595       break;
8596
8597     case PARITY:
8598       nonzero = 1;
8599       break;
8600
8601     case IF_THEN_ELSE:
8602       nonzero &= (nonzero_bits_with_known (XEXP (x, 1), mode)
8603                   | nonzero_bits_with_known (XEXP (x, 2), mode));
8604       break;
8605
8606     default:
8607       break;
8608     }
8609
8610   return nonzero;
8611 }
8612
8613 /* See the macro definition above.  */
8614 #undef cached_num_sign_bit_copies
8615 \f
8616 #define num_sign_bit_copies_with_known(X, M) \
8617   cached_num_sign_bit_copies (X, M, known_x, known_mode, known_ret)
8618
8619 /* The function cached_num_sign_bit_copies is a wrapper around
8620    num_sign_bit_copies1.  It avoids exponential behavior in
8621    num_sign_bit_copies1 when X has identical subexpressions on the
8622    first or the second level.  */
8623
8624 static unsigned int
8625 cached_num_sign_bit_copies (rtx x, enum machine_mode mode, rtx known_x,
8626                             enum machine_mode known_mode,
8627                             unsigned int known_ret)
8628 {
8629   if (x == known_x && mode == known_mode)
8630     return known_ret;
8631
8632   /* Try to find identical subexpressions.  If found call
8633      num_sign_bit_copies1 on X with the subexpressions as KNOWN_X and
8634      the precomputed value for the subexpression as KNOWN_RET.  */
8635
8636   if (GET_RTX_CLASS (GET_CODE (x)) == '2'
8637       || GET_RTX_CLASS (GET_CODE (x)) == 'c')
8638     {
8639       rtx x0 = XEXP (x, 0);
8640       rtx x1 = XEXP (x, 1);
8641
8642       /* Check the first level.  */
8643       if (x0 == x1)
8644         return
8645           num_sign_bit_copies1 (x, mode, x0, mode,
8646                                 num_sign_bit_copies_with_known (x0, mode));
8647
8648       /* Check the second level.  */
8649       if ((GET_RTX_CLASS (GET_CODE (x0)) == '2'
8650            || GET_RTX_CLASS (GET_CODE (x0)) == 'c')
8651           && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
8652         return
8653           num_sign_bit_copies1 (x, mode, x1, mode,
8654                                 num_sign_bit_copies_with_known (x1, mode));
8655
8656       if ((GET_RTX_CLASS (GET_CODE (x1)) == '2'
8657            || GET_RTX_CLASS (GET_CODE (x1)) == 'c')
8658           && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
8659         return
8660           num_sign_bit_copies1 (x, mode, x0, mode,
8661                                 num_sign_bit_copies_with_known (x0, mode));
8662     }
8663
8664   return num_sign_bit_copies1 (x, mode, known_x, known_mode, known_ret);
8665 }
8666
8667 /* Return the number of bits at the high-order end of X that are known to
8668    be equal to the sign bit.  X will be used in mode MODE; if MODE is
8669    VOIDmode, X will be used in its own mode.  The returned value  will always
8670    be between 1 and the number of bits in MODE.  */
8671
8672 static unsigned int
8673 num_sign_bit_copies1 (rtx x, enum machine_mode mode, rtx known_x,
8674                       enum machine_mode known_mode,
8675                       unsigned int known_ret)
8676 {
8677   enum rtx_code code = GET_CODE (x);
8678   unsigned int bitwidth;
8679   int num0, num1, result;
8680   unsigned HOST_WIDE_INT nonzero;
8681   rtx tem;
8682
8683   /* If we weren't given a mode, use the mode of X.  If the mode is still
8684      VOIDmode, we don't know anything.  Likewise if one of the modes is
8685      floating-point.  */
8686
8687   if (mode == VOIDmode)
8688     mode = GET_MODE (x);
8689
8690   if (mode == VOIDmode || FLOAT_MODE_P (mode) || FLOAT_MODE_P (GET_MODE (x)))
8691     return 1;
8692
8693   bitwidth = GET_MODE_BITSIZE (mode);
8694
8695   /* For a smaller object, just ignore the high bits.  */
8696   if (bitwidth < GET_MODE_BITSIZE (GET_MODE (x)))
8697     {
8698       num0 = num_sign_bit_copies_with_known (x, GET_MODE (x));
8699       return MAX (1,
8700                   num0 - (int) (GET_MODE_BITSIZE (GET_MODE (x)) - bitwidth));
8701     }
8702
8703   if (GET_MODE (x) != VOIDmode && bitwidth > GET_MODE_BITSIZE (GET_MODE (x)))
8704     {
8705 #ifndef WORD_REGISTER_OPERATIONS
8706   /* If this machine does not do all register operations on the entire
8707      register and MODE is wider than the mode of X, we can say nothing
8708      at all about the high-order bits.  */
8709       return 1;
8710 #else
8711       /* Likewise on machines that do, if the mode of the object is smaller
8712          than a word and loads of that size don't sign extend, we can say
8713          nothing about the high order bits.  */
8714       if (GET_MODE_BITSIZE (GET_MODE (x)) < BITS_PER_WORD
8715 #ifdef LOAD_EXTEND_OP
8716           && LOAD_EXTEND_OP (GET_MODE (x)) != SIGN_EXTEND
8717 #endif
8718           )
8719         return 1;
8720 #endif
8721     }
8722
8723   switch (code)
8724     {
8725     case REG:
8726
8727 #if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
8728       /* If pointers extend signed and this is a pointer in Pmode, say that
8729          all the bits above ptr_mode are known to be sign bit copies.  */
8730       if (! POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode && mode == Pmode
8731           && REG_POINTER (x))
8732         return GET_MODE_BITSIZE (Pmode) - GET_MODE_BITSIZE (ptr_mode) + 1;
8733 #endif
8734
8735       if (reg_last_set_value[REGNO (x)] != 0
8736           && reg_last_set_mode[REGNO (x)] == mode
8737           && (reg_last_set_label[REGNO (x)] == label_tick
8738               || (REGNO (x) >= FIRST_PSEUDO_REGISTER
8739                   && REG_N_SETS (REGNO (x)) == 1
8740                   && ! REGNO_REG_SET_P (ENTRY_BLOCK_PTR->next_bb->global_live_at_start,
8741                                         REGNO (x))))
8742           && INSN_CUID (reg_last_set[REGNO (x)]) < subst_low_cuid)
8743         return reg_last_set_sign_bit_copies[REGNO (x)];
8744
8745       tem = get_last_value (x);
8746       if (tem != 0)
8747         return num_sign_bit_copies_with_known (tem, mode);
8748
8749       if (nonzero_sign_valid && reg_sign_bit_copies[REGNO (x)] != 0
8750           && GET_MODE_BITSIZE (GET_MODE (x)) == bitwidth)
8751         return reg_sign_bit_copies[REGNO (x)];
8752       break;
8753
8754     case MEM:
8755 #ifdef LOAD_EXTEND_OP
8756       /* Some RISC machines sign-extend all loads of smaller than a word.  */
8757       if (LOAD_EXTEND_OP (GET_MODE (x)) == SIGN_EXTEND)
8758         return MAX (1, ((int) bitwidth
8759                         - (int) GET_MODE_BITSIZE (GET_MODE (x)) + 1));
8760 #endif
8761       break;
8762
8763     case CONST_INT:
8764       /* If the constant is negative, take its 1's complement and remask.
8765          Then see how many zero bits we have.  */
8766       nonzero = INTVAL (x) & GET_MODE_MASK (mode);
8767       if (bitwidth <= HOST_BITS_PER_WIDE_INT
8768           && (nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
8769         nonzero = (~nonzero) & GET_MODE_MASK (mode);
8770
8771       return (nonzero == 0 ? bitwidth : bitwidth - floor_log2 (nonzero) - 1);
8772
8773     case SUBREG:
8774       /* If this is a SUBREG for a promoted object that is sign-extended
8775          and we are looking at it in a wider mode, we know that at least the
8776          high-order bits are known to be sign bit copies.  */
8777
8778       if (SUBREG_PROMOTED_VAR_P (x) && ! SUBREG_PROMOTED_UNSIGNED_P (x))
8779         {
8780           num0 = num_sign_bit_copies_with_known (SUBREG_REG (x), mode);
8781           return MAX ((int) bitwidth
8782                       - (int) GET_MODE_BITSIZE (GET_MODE (x)) + 1,
8783                       num0);
8784         }
8785
8786       /* For a smaller object, just ignore the high bits.  */
8787       if (bitwidth <= GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))))
8788         {
8789           num0 = num_sign_bit_copies_with_known (SUBREG_REG (x), VOIDmode);
8790           return MAX (1, (num0
8791                           - (int) (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
8792                                    - bitwidth)));
8793         }
8794
8795 #ifdef WORD_REGISTER_OPERATIONS
8796 #ifdef LOAD_EXTEND_OP
8797       /* For paradoxical SUBREGs on machines where all register operations
8798          affect the entire register, just look inside.  Note that we are
8799          passing MODE to the recursive call, so the number of sign bit copies
8800          will remain relative to that mode, not the inner mode.  */
8801
8802       /* This works only if loads sign extend.  Otherwise, if we get a
8803          reload for the inner part, it may be loaded from the stack, and
8804          then we lose all sign bit copies that existed before the store
8805          to the stack.  */
8806
8807       if ((GET_MODE_SIZE (GET_MODE (x))
8808            > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
8809           && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (x))) == SIGN_EXTEND
8810           && GET_CODE (SUBREG_REG (x)) == MEM)
8811         return num_sign_bit_copies_with_known (SUBREG_REG (x), mode);
8812 #endif
8813 #endif
8814       break;
8815
8816     case SIGN_EXTRACT:
8817       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
8818         return MAX (1, (int) bitwidth - INTVAL (XEXP (x, 1)));
8819       break;
8820
8821     case SIGN_EXTEND:
8822       return (bitwidth - GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
8823               + num_sign_bit_copies_with_known (XEXP (x, 0), VOIDmode));
8824
8825     case TRUNCATE:
8826       /* For a smaller object, just ignore the high bits.  */
8827       num0 = num_sign_bit_copies_with_known (XEXP (x, 0), VOIDmode);
8828       return MAX (1, (num0 - (int) (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
8829                                     - bitwidth)));
8830
8831     case NOT:
8832       return num_sign_bit_copies_with_known (XEXP (x, 0), mode);
8833
8834     case ROTATE:       case ROTATERT:
8835       /* If we are rotating left by a number of bits less than the number
8836          of sign bit copies, we can just subtract that amount from the
8837          number.  */
8838       if (GET_CODE (XEXP (x, 1)) == CONST_INT
8839           && INTVAL (XEXP (x, 1)) >= 0
8840           && INTVAL (XEXP (x, 1)) < (int) bitwidth)
8841         {
8842           num0 = num_sign_bit_copies_with_known (XEXP (x, 0), mode);
8843           return MAX (1, num0 - (code == ROTATE ? INTVAL (XEXP (x, 1))
8844                                  : (int) bitwidth - INTVAL (XEXP (x, 1))));
8845         }
8846       break;
8847
8848     case NEG:
8849       /* In general, this subtracts one sign bit copy.  But if the value
8850          is known to be positive, the number of sign bit copies is the
8851          same as that of the input.  Finally, if the input has just one bit
8852          that might be nonzero, all the bits are copies of the sign bit.  */
8853       num0 = num_sign_bit_copies_with_known (XEXP (x, 0), mode);
8854       if (bitwidth > HOST_BITS_PER_WIDE_INT)
8855         return num0 > 1 ? num0 - 1 : 1;
8856
8857       nonzero = nonzero_bits (XEXP (x, 0), mode);
8858       if (nonzero == 1)
8859         return bitwidth;
8860
8861       if (num0 > 1
8862           && (((HOST_WIDE_INT) 1 << (bitwidth - 1)) & nonzero))
8863         num0--;
8864
8865       return num0;
8866
8867     case IOR:   case AND:   case XOR:
8868     case SMIN:  case SMAX:  case UMIN:  case UMAX:
8869       /* Logical operations will preserve the number of sign-bit copies.
8870          MIN and MAX operations always return one of the operands.  */
8871       num0 = num_sign_bit_copies_with_known (XEXP (x, 0), mode);
8872       num1 = num_sign_bit_copies_with_known (XEXP (x, 1), mode);
8873       return MIN (num0, num1);
8874
8875     case PLUS:  case MINUS:
8876       /* For addition and subtraction, we can have a 1-bit carry.  However,
8877          if we are subtracting 1 from a positive number, there will not
8878          be such a carry.  Furthermore, if the positive number is known to
8879          be 0 or 1, we know the result is either -1 or 0.  */
8880
8881       if (code == PLUS && XEXP (x, 1) == constm1_rtx
8882           && bitwidth <= HOST_BITS_PER_WIDE_INT)
8883         {
8884           nonzero = nonzero_bits (XEXP (x, 0), mode);
8885           if ((((HOST_WIDE_INT) 1 << (bitwidth - 1)) & nonzero) == 0)
8886             return (nonzero == 1 || nonzero == 0 ? bitwidth
8887                     : bitwidth - floor_log2 (nonzero) - 1);
8888         }
8889
8890       num0 = num_sign_bit_copies_with_known (XEXP (x, 0), mode);
8891       num1 = num_sign_bit_copies_with_known (XEXP (x, 1), mode);
8892       result = MAX (1, MIN (num0, num1) - 1);
8893
8894 #ifdef POINTERS_EXTEND_UNSIGNED
8895       /* If pointers extend signed and this is an addition or subtraction
8896          to a pointer in Pmode, all the bits above ptr_mode are known to be
8897          sign bit copies.  */
8898       if (! POINTERS_EXTEND_UNSIGNED && GET_MODE (x) == Pmode
8899           && (code == PLUS || code == MINUS)
8900           && GET_CODE (XEXP (x, 0)) == REG && REG_POINTER (XEXP (x, 0)))
8901         result = MAX ((int) (GET_MODE_BITSIZE (Pmode)
8902                              - GET_MODE_BITSIZE (ptr_mode) + 1),
8903                       result);
8904 #endif
8905       return result;
8906
8907     case MULT:
8908       /* The number of bits of the product is the sum of the number of
8909          bits of both terms.  However, unless one of the terms if known
8910          to be positive, we must allow for an additional bit since negating
8911          a negative number can remove one sign bit copy.  */
8912
8913       num0 = num_sign_bit_copies_with_known (XEXP (x, 0), mode);
8914       num1 = num_sign_bit_copies_with_known (XEXP (x, 1), mode);
8915
8916       result = bitwidth - (bitwidth - num0) - (bitwidth - num1);
8917       if (result > 0
8918           && (bitwidth > HOST_BITS_PER_WIDE_INT
8919               || (((nonzero_bits (XEXP (x, 0), mode)
8920                     & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
8921                   && ((nonzero_bits (XEXP (x, 1), mode)
8922                        & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))))
8923         result--;
8924
8925       return MAX (1, result);
8926
8927     case UDIV:
8928       /* The result must be <= the first operand.  If the first operand
8929          has the high bit set, we know nothing about the number of sign
8930          bit copies.  */
8931       if (bitwidth > HOST_BITS_PER_WIDE_INT)
8932         return 1;
8933       else if ((nonzero_bits (XEXP (x, 0), mode)
8934                 & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
8935         return 1;
8936       else
8937         return num_sign_bit_copies_with_known (XEXP (x, 0), mode);
8938
8939     case UMOD:
8940       /* The result must be <= the second operand.  */
8941       return num_sign_bit_copies_with_known (XEXP (x, 1), mode);
8942
8943     case DIV:
8944       /* Similar to unsigned division, except that we have to worry about
8945          the case where the divisor is negative, in which case we have
8946          to add 1.  */
8947       result = num_sign_bit_copies_with_known (XEXP (x, 0), mode);
8948       if (result > 1
8949           && (bitwidth > HOST_BITS_PER_WIDE_INT
8950               || (nonzero_bits (XEXP (x, 1), mode)
8951                   & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))
8952         result--;
8953
8954       return result;
8955
8956     case MOD:
8957       result = num_sign_bit_copies_with_known (XEXP (x, 1), mode);
8958       if (result > 1
8959           && (bitwidth > HOST_BITS_PER_WIDE_INT
8960               || (nonzero_bits (XEXP (x, 1), mode)
8961                   & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0))
8962         result--;
8963
8964       return result;
8965
8966     case ASHIFTRT:
8967       /* Shifts by a constant add to the number of bits equal to the
8968          sign bit.  */
8969       num0 = num_sign_bit_copies_with_known (XEXP (x, 0), mode);
8970       if (GET_CODE (XEXP (x, 1)) == CONST_INT
8971           && INTVAL (XEXP (x, 1)) > 0)
8972         num0 = MIN ((int) bitwidth, num0 + INTVAL (XEXP (x, 1)));
8973
8974       return num0;
8975
8976     case ASHIFT:
8977       /* Left shifts destroy copies.  */
8978       if (GET_CODE (XEXP (x, 1)) != CONST_INT
8979           || INTVAL (XEXP (x, 1)) < 0
8980           || INTVAL (XEXP (x, 1)) >= (int) bitwidth)
8981         return 1;
8982
8983       num0 = num_sign_bit_copies_with_known (XEXP (x, 0), mode);
8984       return MAX (1, num0 - INTVAL (XEXP (x, 1)));
8985
8986     case IF_THEN_ELSE:
8987       num0 = num_sign_bit_copies_with_known (XEXP (x, 1), mode);
8988       num1 = num_sign_bit_copies_with_known (XEXP (x, 2), mode);
8989       return MIN (num0, num1);
8990
8991     case EQ:  case NE:  case GE:  case GT:  case LE:  case LT:
8992     case UNEQ:  case LTGT:  case UNGE:  case UNGT:  case UNLE:  case UNLT:
8993     case GEU: case GTU: case LEU: case LTU:
8994     case UNORDERED: case ORDERED:
8995       /* If the constant is negative, take its 1's complement and remask.
8996          Then see how many zero bits we have.  */
8997       nonzero = STORE_FLAG_VALUE;
8998       if (bitwidth <= HOST_BITS_PER_WIDE_INT
8999           && (nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))) != 0)
9000         nonzero = (~nonzero) & GET_MODE_MASK (mode);
9001
9002       return (nonzero == 0 ? bitwidth : bitwidth - floor_log2 (nonzero) - 1);
9003       break;
9004
9005     default:
9006       break;
9007     }
9008
9009   /* If we haven't been able to figure it out by one of the above rules,
9010      see if some of the high-order bits are known to be zero.  If so,
9011      count those bits and return one less than that amount.  If we can't
9012      safely compute the mask for this mode, always return BITWIDTH.  */
9013
9014   if (bitwidth > HOST_BITS_PER_WIDE_INT)
9015     return 1;
9016
9017   nonzero = nonzero_bits (x, mode);
9018   return (nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))
9019           ? 1 : bitwidth - floor_log2 (nonzero) - 1);
9020 }
9021 \f
9022 /* Return the number of "extended" bits there are in X, when interpreted
9023    as a quantity in MODE whose signedness is indicated by UNSIGNEDP.  For
9024    unsigned quantities, this is the number of high-order zero bits.
9025    For signed quantities, this is the number of copies of the sign bit
9026    minus 1.  In both case, this function returns the number of "spare"
9027    bits.  For example, if two quantities for which this function returns
9028    at least 1 are added, the addition is known not to overflow.
9029
9030    This function will always return 0 unless called during combine, which
9031    implies that it must be called from a define_split.  */
9032
9033 unsigned int
9034 extended_count (rtx x, enum machine_mode mode, int unsignedp)
9035 {
9036   if (nonzero_sign_valid == 0)
9037     return 0;
9038
9039   return (unsignedp
9040           ? (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9041              ? (unsigned int) (GET_MODE_BITSIZE (mode) - 1
9042                                - floor_log2 (nonzero_bits (x, mode)))
9043              : 0)
9044           : num_sign_bit_copies (x, mode) - 1);
9045 }
9046 \f
9047 /* This function is called from `simplify_shift_const' to merge two
9048    outer operations.  Specifically, we have already found that we need
9049    to perform operation *POP0 with constant *PCONST0 at the outermost
9050    position.  We would now like to also perform OP1 with constant CONST1
9051    (with *POP0 being done last).
9052
9053    Return 1 if we can do the operation and update *POP0 and *PCONST0 with
9054    the resulting operation.  *PCOMP_P is set to 1 if we would need to
9055    complement the innermost operand, otherwise it is unchanged.
9056
9057    MODE is the mode in which the operation will be done.  No bits outside
9058    the width of this mode matter.  It is assumed that the width of this mode
9059    is smaller than or equal to HOST_BITS_PER_WIDE_INT.
9060
9061    If *POP0 or OP1 are NIL, it means no operation is required.  Only NEG, PLUS,
9062    IOR, XOR, and AND are supported.  We may set *POP0 to SET if the proper
9063    result is simply *PCONST0.
9064
9065    If the resulting operation cannot be expressed as one operation, we
9066    return 0 and do not change *POP0, *PCONST0, and *PCOMP_P.  */
9067
9068 static int
9069 merge_outer_ops (enum rtx_code *pop0, HOST_WIDE_INT *pconst0, enum rtx_code op1, HOST_WIDE_INT const1, enum machine_mode mode, int *pcomp_p)
9070 {
9071   enum rtx_code op0 = *pop0;
9072   HOST_WIDE_INT const0 = *pconst0;
9073
9074   const0 &= GET_MODE_MASK (mode);
9075   const1 &= GET_MODE_MASK (mode);
9076
9077   /* If OP0 is an AND, clear unimportant bits in CONST1.  */
9078   if (op0 == AND)
9079     const1 &= const0;
9080
9081   /* If OP0 or OP1 is NIL, this is easy.  Similarly if they are the same or
9082      if OP0 is SET.  */
9083
9084   if (op1 == NIL || op0 == SET)
9085     return 1;
9086
9087   else if (op0 == NIL)
9088     op0 = op1, const0 = const1;
9089
9090   else if (op0 == op1)
9091     {
9092       switch (op0)
9093         {
9094         case AND:
9095           const0 &= const1;
9096           break;
9097         case IOR:
9098           const0 |= const1;
9099           break;
9100         case XOR:
9101           const0 ^= const1;
9102           break;
9103         case PLUS:
9104           const0 += const1;
9105           break;
9106         case NEG:
9107           op0 = NIL;
9108           break;
9109         default:
9110           break;
9111         }
9112     }
9113
9114   /* Otherwise, if either is a PLUS or NEG, we can't do anything.  */
9115   else if (op0 == PLUS || op1 == PLUS || op0 == NEG || op1 == NEG)
9116     return 0;
9117
9118   /* If the two constants aren't the same, we can't do anything.  The
9119      remaining six cases can all be done.  */
9120   else if (const0 != const1)
9121     return 0;
9122
9123   else
9124     switch (op0)
9125       {
9126       case IOR:
9127         if (op1 == AND)
9128           /* (a & b) | b == b */
9129           op0 = SET;
9130         else /* op1 == XOR */
9131           /* (a ^ b) | b == a | b */
9132           {;}
9133         break;
9134
9135       case XOR:
9136         if (op1 == AND)
9137           /* (a & b) ^ b == (~a) & b */
9138           op0 = AND, *pcomp_p = 1;
9139         else /* op1 == IOR */
9140           /* (a | b) ^ b == a & ~b */
9141           op0 = AND, const0 = ~const0;
9142         break;
9143
9144       case AND:
9145         if (op1 == IOR)
9146           /* (a | b) & b == b */
9147         op0 = SET;
9148         else /* op1 == XOR */
9149           /* (a ^ b) & b) == (~a) & b */
9150           *pcomp_p = 1;
9151         break;
9152       default:
9153         break;
9154       }
9155
9156   /* Check for NO-OP cases.  */
9157   const0 &= GET_MODE_MASK (mode);
9158   if (const0 == 0
9159       && (op0 == IOR || op0 == XOR || op0 == PLUS))
9160     op0 = NIL;
9161   else if (const0 == 0 && op0 == AND)
9162     op0 = SET;
9163   else if ((unsigned HOST_WIDE_INT) const0 == GET_MODE_MASK (mode)
9164            && op0 == AND)
9165     op0 = NIL;
9166
9167   /* ??? Slightly redundant with the above mask, but not entirely.
9168      Moving this above means we'd have to sign-extend the mode mask
9169      for the final test.  */
9170   const0 = trunc_int_for_mode (const0, mode);
9171
9172   *pop0 = op0;
9173   *pconst0 = const0;
9174
9175   return 1;
9176 }
9177 \f
9178 /* Simplify a shift of VAROP by COUNT bits.  CODE says what kind of shift.
9179    The result of the shift is RESULT_MODE.  X, if nonzero, is an expression
9180    that we started with.
9181
9182    The shift is normally computed in the widest mode we find in VAROP, as
9183    long as it isn't a different number of words than RESULT_MODE.  Exceptions
9184    are ASHIFTRT and ROTATE, which are always done in their original mode,  */
9185
9186 static rtx
9187 simplify_shift_const (rtx x, enum rtx_code code,
9188                       enum machine_mode result_mode, rtx varop,
9189                       int orig_count)
9190 {
9191   enum rtx_code orig_code = code;
9192   unsigned int count;
9193   int signed_count;
9194   enum machine_mode mode = result_mode;
9195   enum machine_mode shift_mode, tmode;
9196   unsigned int mode_words
9197     = (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
9198   /* We form (outer_op (code varop count) (outer_const)).  */
9199   enum rtx_code outer_op = NIL;
9200   HOST_WIDE_INT outer_const = 0;
9201   rtx const_rtx;
9202   int complement_p = 0;
9203   rtx new;
9204
9205   /* Make sure and truncate the "natural" shift on the way in.  We don't
9206      want to do this inside the loop as it makes it more difficult to
9207      combine shifts.  */
9208 #ifdef SHIFT_COUNT_TRUNCATED
9209   if (SHIFT_COUNT_TRUNCATED)
9210     orig_count &= GET_MODE_BITSIZE (mode) - 1;
9211 #endif
9212
9213   /* If we were given an invalid count, don't do anything except exactly
9214      what was requested.  */
9215
9216   if (orig_count < 0 || orig_count >= (int) GET_MODE_BITSIZE (mode))
9217     {
9218       if (x)
9219         return x;
9220
9221       return gen_rtx_fmt_ee (code, mode, varop, GEN_INT (orig_count));
9222     }
9223
9224   count = orig_count;
9225
9226   /* Unless one of the branches of the `if' in this loop does a `continue',
9227      we will `break' the loop after the `if'.  */
9228
9229   while (count != 0)
9230     {
9231       /* If we have an operand of (clobber (const_int 0)), just return that
9232          value.  */
9233       if (GET_CODE (varop) == CLOBBER)
9234         return varop;
9235
9236       /* If we discovered we had to complement VAROP, leave.  Making a NOT
9237          here would cause an infinite loop.  */
9238       if (complement_p)
9239         break;
9240
9241       /* Convert ROTATERT to ROTATE.  */
9242       if (code == ROTATERT)
9243         {
9244           unsigned int bitsize = GET_MODE_BITSIZE (result_mode);;
9245           code = ROTATE;
9246           if (VECTOR_MODE_P (result_mode))
9247             count = bitsize / GET_MODE_NUNITS (result_mode) - count;
9248           else
9249             count = bitsize - count;
9250         }
9251
9252       /* We need to determine what mode we will do the shift in.  If the
9253          shift is a right shift or a ROTATE, we must always do it in the mode
9254          it was originally done in.  Otherwise, we can do it in MODE, the
9255          widest mode encountered.  */
9256       shift_mode
9257         = (code == ASHIFTRT || code == LSHIFTRT || code == ROTATE
9258            ? result_mode : mode);
9259
9260       /* Handle cases where the count is greater than the size of the mode
9261          minus 1.  For ASHIFT, use the size minus one as the count (this can
9262          occur when simplifying (lshiftrt (ashiftrt ..))).  For rotates,
9263          take the count modulo the size.  For other shifts, the result is
9264          zero.
9265
9266          Since these shifts are being produced by the compiler by combining
9267          multiple operations, each of which are defined, we know what the
9268          result is supposed to be.  */
9269
9270       if (count > (unsigned int) (GET_MODE_BITSIZE (shift_mode) - 1))
9271         {
9272           if (code == ASHIFTRT)
9273             count = GET_MODE_BITSIZE (shift_mode) - 1;
9274           else if (code == ROTATE || code == ROTATERT)
9275             count %= GET_MODE_BITSIZE (shift_mode);
9276           else
9277             {
9278               /* We can't simply return zero because there may be an
9279                  outer op.  */
9280               varop = const0_rtx;
9281               count = 0;
9282               break;
9283             }
9284         }
9285
9286       /* An arithmetic right shift of a quantity known to be -1 or 0
9287          is a no-op.  */
9288       if (code == ASHIFTRT
9289           && (num_sign_bit_copies (varop, shift_mode)
9290               == GET_MODE_BITSIZE (shift_mode)))
9291         {
9292           count = 0;
9293           break;
9294         }
9295
9296       /* If we are doing an arithmetic right shift and discarding all but
9297          the sign bit copies, this is equivalent to doing a shift by the
9298          bitsize minus one.  Convert it into that shift because it will often
9299          allow other simplifications.  */
9300
9301       if (code == ASHIFTRT
9302           && (count + num_sign_bit_copies (varop, shift_mode)
9303               >= GET_MODE_BITSIZE (shift_mode)))
9304         count = GET_MODE_BITSIZE (shift_mode) - 1;
9305
9306       /* We simplify the tests below and elsewhere by converting
9307          ASHIFTRT to LSHIFTRT if we know the sign bit is clear.
9308          `make_compound_operation' will convert it to an ASHIFTRT for
9309          those machines (such as VAX) that don't have an LSHIFTRT.  */
9310       if (GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9311           && code == ASHIFTRT
9312           && ((nonzero_bits (varop, shift_mode)
9313                & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (shift_mode) - 1)))
9314               == 0))
9315         code = LSHIFTRT;
9316
9317       if (code == LSHIFTRT
9318           && GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9319           && !(nonzero_bits (varop, shift_mode) >> count))
9320         varop = const0_rtx;
9321       if (code == ASHIFT
9322           && GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9323           && !((nonzero_bits (varop, shift_mode) << count)
9324                & GET_MODE_MASK (shift_mode)))
9325         varop = const0_rtx;
9326
9327       switch (GET_CODE (varop))
9328         {
9329         case SIGN_EXTEND:
9330         case ZERO_EXTEND:
9331         case SIGN_EXTRACT:
9332         case ZERO_EXTRACT:
9333           new = expand_compound_operation (varop);
9334           if (new != varop)
9335             {
9336               varop = new;
9337               continue;
9338             }
9339           break;
9340
9341         case MEM:
9342           /* If we have (xshiftrt (mem ...) C) and C is MODE_WIDTH
9343              minus the width of a smaller mode, we can do this with a
9344              SIGN_EXTEND or ZERO_EXTEND from the narrower memory location.  */
9345           if ((code == ASHIFTRT || code == LSHIFTRT)
9346               && ! mode_dependent_address_p (XEXP (varop, 0))
9347               && ! MEM_VOLATILE_P (varop)
9348               && (tmode = mode_for_size (GET_MODE_BITSIZE (mode) - count,
9349                                          MODE_INT, 1)) != BLKmode)
9350             {
9351               new = adjust_address_nv (varop, tmode,
9352                                        BYTES_BIG_ENDIAN ? 0
9353                                        : count / BITS_PER_UNIT);
9354
9355               varop = gen_rtx_fmt_e (code == ASHIFTRT ? SIGN_EXTEND
9356                                      : ZERO_EXTEND, mode, new);
9357               count = 0;
9358               continue;
9359             }
9360           break;
9361
9362         case USE:
9363           /* Similar to the case above, except that we can only do this if
9364              the resulting mode is the same as that of the underlying
9365              MEM and adjust the address depending on the *bits* endianness
9366              because of the way that bit-field extract insns are defined.  */
9367           if ((code == ASHIFTRT || code == LSHIFTRT)
9368               && (tmode = mode_for_size (GET_MODE_BITSIZE (mode) - count,
9369                                          MODE_INT, 1)) != BLKmode
9370               && tmode == GET_MODE (XEXP (varop, 0)))
9371             {
9372               if (BITS_BIG_ENDIAN)
9373                 new = XEXP (varop, 0);
9374               else
9375                 {
9376                   new = copy_rtx (XEXP (varop, 0));
9377                   SUBST (XEXP (new, 0),
9378                          plus_constant (XEXP (new, 0),
9379                                         count / BITS_PER_UNIT));
9380                 }
9381
9382               varop = gen_rtx_fmt_e (code == ASHIFTRT ? SIGN_EXTEND
9383                                      : ZERO_EXTEND, mode, new);
9384               count = 0;
9385               continue;
9386             }
9387           break;
9388
9389         case SUBREG:
9390           /* If VAROP is a SUBREG, strip it as long as the inner operand has
9391              the same number of words as what we've seen so far.  Then store
9392              the widest mode in MODE.  */
9393           if (subreg_lowpart_p (varop)
9394               && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (varop)))
9395                   > GET_MODE_SIZE (GET_MODE (varop)))
9396               && (unsigned int) ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (varop)))
9397                                   + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
9398                  == mode_words)
9399             {
9400               varop = SUBREG_REG (varop);
9401               if (GET_MODE_SIZE (GET_MODE (varop)) > GET_MODE_SIZE (mode))
9402                 mode = GET_MODE (varop);
9403               continue;
9404             }
9405           break;
9406
9407         case MULT:
9408           /* Some machines use MULT instead of ASHIFT because MULT
9409              is cheaper.  But it is still better on those machines to
9410              merge two shifts into one.  */
9411           if (GET_CODE (XEXP (varop, 1)) == CONST_INT
9412               && exact_log2 (INTVAL (XEXP (varop, 1))) >= 0)
9413             {
9414               varop
9415                 = gen_binary (ASHIFT, GET_MODE (varop), XEXP (varop, 0),
9416                               GEN_INT (exact_log2 (INTVAL (XEXP (varop, 1)))));
9417               continue;
9418             }
9419           break;
9420
9421         case UDIV:
9422           /* Similar, for when divides are cheaper.  */
9423           if (GET_CODE (XEXP (varop, 1)) == CONST_INT
9424               && exact_log2 (INTVAL (XEXP (varop, 1))) >= 0)
9425             {
9426               varop
9427                 = gen_binary (LSHIFTRT, GET_MODE (varop), XEXP (varop, 0),
9428                               GEN_INT (exact_log2 (INTVAL (XEXP (varop, 1)))));
9429               continue;
9430             }
9431           break;
9432
9433         case ASHIFTRT:
9434           /* If we are extracting just the sign bit of an arithmetic
9435              right shift, that shift is not needed.  However, the sign
9436              bit of a wider mode may be different from what would be
9437              interpreted as the sign bit in a narrower mode, so, if
9438              the result is narrower, don't discard the shift.  */
9439           if (code == LSHIFTRT
9440               && count == (unsigned int) (GET_MODE_BITSIZE (result_mode) - 1)
9441               && (GET_MODE_BITSIZE (result_mode)
9442                   >= GET_MODE_BITSIZE (GET_MODE (varop))))
9443             {
9444               varop = XEXP (varop, 0);
9445               continue;
9446             }
9447
9448           /* ... fall through ...  */
9449
9450         case LSHIFTRT:
9451         case ASHIFT:
9452         case ROTATE:
9453           /* Here we have two nested shifts.  The result is usually the
9454              AND of a new shift with a mask.  We compute the result below.  */
9455           if (GET_CODE (XEXP (varop, 1)) == CONST_INT
9456               && INTVAL (XEXP (varop, 1)) >= 0
9457               && INTVAL (XEXP (varop, 1)) < GET_MODE_BITSIZE (GET_MODE (varop))
9458               && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
9459               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
9460             {
9461               enum rtx_code first_code = GET_CODE (varop);
9462               unsigned int first_count = INTVAL (XEXP (varop, 1));
9463               unsigned HOST_WIDE_INT mask;
9464               rtx mask_rtx;
9465
9466               /* We have one common special case.  We can't do any merging if
9467                  the inner code is an ASHIFTRT of a smaller mode.  However, if
9468                  we have (ashift:M1 (subreg:M1 (ashiftrt:M2 FOO C1) 0) C2)
9469                  with C2 == GET_MODE_BITSIZE (M1) - GET_MODE_BITSIZE (M2),
9470                  we can convert it to
9471                  (ashiftrt:M1 (ashift:M1 (and:M1 (subreg:M1 FOO 0 C2) C3) C1).
9472                  This simplifies certain SIGN_EXTEND operations.  */
9473               if (code == ASHIFT && first_code == ASHIFTRT
9474                   && count == (unsigned int)
9475                               (GET_MODE_BITSIZE (result_mode)
9476                                - GET_MODE_BITSIZE (GET_MODE (varop))))
9477                 {
9478                   /* C3 has the low-order C1 bits zero.  */
9479
9480                   mask = (GET_MODE_MASK (mode)
9481                           & ~(((HOST_WIDE_INT) 1 << first_count) - 1));
9482
9483                   varop = simplify_and_const_int (NULL_RTX, result_mode,
9484                                                   XEXP (varop, 0), mask);
9485                   varop = simplify_shift_const (NULL_RTX, ASHIFT, result_mode,
9486                                                 varop, count);
9487                   count = first_count;
9488                   code = ASHIFTRT;
9489                   continue;
9490                 }
9491
9492               /* If this was (ashiftrt (ashift foo C1) C2) and FOO has more
9493                  than C1 high-order bits equal to the sign bit, we can convert
9494                  this to either an ASHIFT or an ASHIFTRT depending on the
9495                  two counts.
9496
9497                  We cannot do this if VAROP's mode is not SHIFT_MODE.  */
9498
9499               if (code == ASHIFTRT && first_code == ASHIFT
9500                   && GET_MODE (varop) == shift_mode
9501                   && (num_sign_bit_copies (XEXP (varop, 0), shift_mode)
9502                       > first_count))
9503                 {
9504                   varop = XEXP (varop, 0);
9505
9506                   signed_count = count - first_count;
9507                   if (signed_count < 0)
9508                     count = -signed_count, code = ASHIFT;
9509                   else
9510                     count = signed_count;
9511
9512                   continue;
9513                 }
9514
9515               /* There are some cases we can't do.  If CODE is ASHIFTRT,
9516                  we can only do this if FIRST_CODE is also ASHIFTRT.
9517
9518                  We can't do the case when CODE is ROTATE and FIRST_CODE is
9519                  ASHIFTRT.
9520
9521                  If the mode of this shift is not the mode of the outer shift,
9522                  we can't do this if either shift is a right shift or ROTATE.
9523
9524                  Finally, we can't do any of these if the mode is too wide
9525                  unless the codes are the same.
9526
9527                  Handle the case where the shift codes are the same
9528                  first.  */
9529
9530               if (code == first_code)
9531                 {
9532                   if (GET_MODE (varop) != result_mode
9533                       && (code == ASHIFTRT || code == LSHIFTRT
9534                           || code == ROTATE))
9535                     break;
9536
9537                   count += first_count;
9538                   varop = XEXP (varop, 0);
9539                   continue;
9540                 }
9541
9542               if (code == ASHIFTRT
9543                   || (code == ROTATE && first_code == ASHIFTRT)
9544                   || GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT
9545                   || (GET_MODE (varop) != result_mode
9546                       && (first_code == ASHIFTRT || first_code == LSHIFTRT
9547                           || first_code == ROTATE
9548                           || code == ROTATE)))
9549                 break;
9550
9551               /* To compute the mask to apply after the shift, shift the
9552                  nonzero bits of the inner shift the same way the
9553                  outer shift will.  */
9554
9555               mask_rtx = GEN_INT (nonzero_bits (varop, GET_MODE (varop)));
9556
9557               mask_rtx
9558                 = simplify_binary_operation (code, result_mode, mask_rtx,
9559                                              GEN_INT (count));
9560
9561               /* Give up if we can't compute an outer operation to use.  */
9562               if (mask_rtx == 0
9563                   || GET_CODE (mask_rtx) != CONST_INT
9564                   || ! merge_outer_ops (&outer_op, &outer_const, AND,
9565                                         INTVAL (mask_rtx),
9566                                         result_mode, &complement_p))
9567                 break;
9568
9569               /* If the shifts are in the same direction, we add the
9570                  counts.  Otherwise, we subtract them.  */
9571               signed_count = count;
9572               if ((code == ASHIFTRT || code == LSHIFTRT)
9573                   == (first_code == ASHIFTRT || first_code == LSHIFTRT))
9574                 signed_count += first_count;
9575               else
9576                 signed_count -= first_count;
9577
9578               /* If COUNT is positive, the new shift is usually CODE,
9579                  except for the two exceptions below, in which case it is
9580                  FIRST_CODE.  If the count is negative, FIRST_CODE should
9581                  always be used  */
9582               if (signed_count > 0
9583                   && ((first_code == ROTATE && code == ASHIFT)
9584                       || (first_code == ASHIFTRT && code == LSHIFTRT)))
9585                 code = first_code, count = signed_count;
9586               else if (signed_count < 0)
9587                 code = first_code, count = -signed_count;
9588               else
9589                 count = signed_count;
9590
9591               varop = XEXP (varop, 0);
9592               continue;
9593             }
9594
9595           /* If we have (A << B << C) for any shift, we can convert this to
9596              (A << C << B).  This wins if A is a constant.  Only try this if
9597              B is not a constant.  */
9598
9599           else if (GET_CODE (varop) == code
9600                    && GET_CODE (XEXP (varop, 1)) != CONST_INT
9601                    && 0 != (new
9602                             = simplify_binary_operation (code, mode,
9603                                                          XEXP (varop, 0),
9604                                                          GEN_INT (count))))
9605             {
9606               varop = gen_rtx_fmt_ee (code, mode, new, XEXP (varop, 1));
9607               count = 0;
9608               continue;
9609             }
9610           break;
9611
9612         case NOT:
9613           /* Make this fit the case below.  */
9614           varop = gen_rtx_XOR (mode, XEXP (varop, 0),
9615                                GEN_INT (GET_MODE_MASK (mode)));
9616           continue;
9617
9618         case IOR:
9619         case AND:
9620         case XOR:
9621           /* If we have (xshiftrt (ior (plus X (const_int -1)) X) C)
9622              with C the size of VAROP - 1 and the shift is logical if
9623              STORE_FLAG_VALUE is 1 and arithmetic if STORE_FLAG_VALUE is -1,
9624              we have an (le X 0) operation.   If we have an arithmetic shift
9625              and STORE_FLAG_VALUE is 1 or we have a logical shift with
9626              STORE_FLAG_VALUE of -1, we have a (neg (le X 0)) operation.  */
9627
9628           if (GET_CODE (varop) == IOR && GET_CODE (XEXP (varop, 0)) == PLUS
9629               && XEXP (XEXP (varop, 0), 1) == constm1_rtx
9630               && (STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
9631               && (code == LSHIFTRT || code == ASHIFTRT)
9632               && count == (unsigned int)
9633                           (GET_MODE_BITSIZE (GET_MODE (varop)) - 1)
9634               && rtx_equal_p (XEXP (XEXP (varop, 0), 0), XEXP (varop, 1)))
9635             {
9636               count = 0;
9637               varop = gen_rtx_LE (GET_MODE (varop), XEXP (varop, 1),
9638                                   const0_rtx);
9639
9640               if (STORE_FLAG_VALUE == 1 ? code == ASHIFTRT : code == LSHIFTRT)
9641                 varop = gen_rtx_NEG (GET_MODE (varop), varop);
9642
9643               continue;
9644             }
9645
9646           /* If we have (shift (logical)), move the logical to the outside
9647              to allow it to possibly combine with another logical and the
9648              shift to combine with another shift.  This also canonicalizes to
9649              what a ZERO_EXTRACT looks like.  Also, some machines have
9650              (and (shift)) insns.  */
9651
9652           if (GET_CODE (XEXP (varop, 1)) == CONST_INT
9653               && (new = simplify_binary_operation (code, result_mode,
9654                                                    XEXP (varop, 1),
9655                                                    GEN_INT (count))) != 0
9656               && GET_CODE (new) == CONST_INT
9657               && merge_outer_ops (&outer_op, &outer_const, GET_CODE (varop),
9658                                   INTVAL (new), result_mode, &complement_p))
9659             {
9660               varop = XEXP (varop, 0);
9661               continue;
9662             }
9663
9664           /* If we can't do that, try to simplify the shift in each arm of the
9665              logical expression, make a new logical expression, and apply
9666              the inverse distributive law.  */
9667           {
9668             rtx lhs = simplify_shift_const (NULL_RTX, code, shift_mode,
9669                                             XEXP (varop, 0), count);
9670             rtx rhs = simplify_shift_const (NULL_RTX, code, shift_mode,
9671                                             XEXP (varop, 1), count);
9672
9673             varop = gen_binary (GET_CODE (varop), shift_mode, lhs, rhs);
9674             varop = apply_distributive_law (varop);
9675
9676             count = 0;
9677           }
9678           break;
9679
9680         case EQ:
9681           /* convert (lshiftrt (eq FOO 0) C) to (xor FOO 1) if STORE_FLAG_VALUE
9682              says that the sign bit can be tested, FOO has mode MODE, C is
9683              GET_MODE_BITSIZE (MODE) - 1, and FOO has only its low-order bit
9684              that may be nonzero.  */
9685           if (code == LSHIFTRT
9686               && XEXP (varop, 1) == const0_rtx
9687               && GET_MODE (XEXP (varop, 0)) == result_mode
9688               && count == (unsigned int) (GET_MODE_BITSIZE (result_mode) - 1)
9689               && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
9690               && ((STORE_FLAG_VALUE
9691                    & ((HOST_WIDE_INT) 1
9692                       < (GET_MODE_BITSIZE (result_mode) - 1))))
9693               && nonzero_bits (XEXP (varop, 0), result_mode) == 1
9694               && merge_outer_ops (&outer_op, &outer_const, XOR,
9695                                   (HOST_WIDE_INT) 1, result_mode,
9696                                   &complement_p))
9697             {
9698               varop = XEXP (varop, 0);
9699               count = 0;
9700               continue;
9701             }
9702           break;
9703
9704         case NEG:
9705           /* (lshiftrt (neg A) C) where A is either 0 or 1 and C is one less
9706              than the number of bits in the mode is equivalent to A.  */
9707           if (code == LSHIFTRT
9708               && count == (unsigned int) (GET_MODE_BITSIZE (result_mode) - 1)
9709               && nonzero_bits (XEXP (varop, 0), result_mode) == 1)
9710             {
9711               varop = XEXP (varop, 0);
9712               count = 0;
9713               continue;
9714             }
9715
9716           /* NEG commutes with ASHIFT since it is multiplication.  Move the
9717              NEG outside to allow shifts to combine.  */
9718           if (code == ASHIFT
9719               && merge_outer_ops (&outer_op, &outer_const, NEG,
9720                                   (HOST_WIDE_INT) 0, result_mode,
9721                                   &complement_p))
9722             {
9723               varop = XEXP (varop, 0);
9724               continue;
9725             }
9726           break;
9727
9728         case PLUS:
9729           /* (lshiftrt (plus A -1) C) where A is either 0 or 1 and C
9730              is one less than the number of bits in the mode is
9731              equivalent to (xor A 1).  */
9732           if (code == LSHIFTRT
9733               && count == (unsigned int) (GET_MODE_BITSIZE (result_mode) - 1)
9734               && XEXP (varop, 1) == constm1_rtx
9735               && nonzero_bits (XEXP (varop, 0), result_mode) == 1
9736               && merge_outer_ops (&outer_op, &outer_const, XOR,
9737                                   (HOST_WIDE_INT) 1, result_mode,
9738                                   &complement_p))
9739             {
9740               count = 0;
9741               varop = XEXP (varop, 0);
9742               continue;
9743             }
9744
9745           /* If we have (xshiftrt (plus FOO BAR) C), and the only bits
9746              that might be nonzero in BAR are those being shifted out and those
9747              bits are known zero in FOO, we can replace the PLUS with FOO.
9748              Similarly in the other operand order.  This code occurs when
9749              we are computing the size of a variable-size array.  */
9750
9751           if ((code == ASHIFTRT || code == LSHIFTRT)
9752               && count < HOST_BITS_PER_WIDE_INT
9753               && nonzero_bits (XEXP (varop, 1), result_mode) >> count == 0
9754               && (nonzero_bits (XEXP (varop, 1), result_mode)
9755                   & nonzero_bits (XEXP (varop, 0), result_mode)) == 0)
9756             {
9757               varop = XEXP (varop, 0);
9758               continue;
9759             }
9760           else if ((code == ASHIFTRT || code == LSHIFTRT)
9761                    && count < HOST_BITS_PER_WIDE_INT
9762                    && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
9763                    && 0 == (nonzero_bits (XEXP (varop, 0), result_mode)
9764                             >> count)
9765                    && 0 == (nonzero_bits (XEXP (varop, 0), result_mode)
9766                             & nonzero_bits (XEXP (varop, 1),
9767                                                  result_mode)))
9768             {
9769               varop = XEXP (varop, 1);
9770               continue;
9771             }
9772
9773           /* (ashift (plus foo C) N) is (plus (ashift foo N) C').  */
9774           if (code == ASHIFT
9775               && GET_CODE (XEXP (varop, 1)) == CONST_INT
9776               && (new = simplify_binary_operation (ASHIFT, result_mode,
9777                                                    XEXP (varop, 1),
9778                                                    GEN_INT (count))) != 0
9779               && GET_CODE (new) == CONST_INT
9780               && merge_outer_ops (&outer_op, &outer_const, PLUS,
9781                                   INTVAL (new), result_mode, &complement_p))
9782             {
9783               varop = XEXP (varop, 0);
9784               continue;
9785             }
9786           break;
9787
9788         case MINUS:
9789           /* If we have (xshiftrt (minus (ashiftrt X C)) X) C)
9790              with C the size of VAROP - 1 and the shift is logical if
9791              STORE_FLAG_VALUE is 1 and arithmetic if STORE_FLAG_VALUE is -1,
9792              we have a (gt X 0) operation.  If the shift is arithmetic with
9793              STORE_FLAG_VALUE of 1 or logical with STORE_FLAG_VALUE == -1,
9794              we have a (neg (gt X 0)) operation.  */
9795
9796           if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
9797               && GET_CODE (XEXP (varop, 0)) == ASHIFTRT
9798               && count == (unsigned int)
9799                           (GET_MODE_BITSIZE (GET_MODE (varop)) - 1)
9800               && (code == LSHIFTRT || code == ASHIFTRT)
9801               && GET_CODE (XEXP (XEXP (varop, 0), 1)) == CONST_INT
9802               && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (varop, 0), 1))
9803                  == count
9804               && rtx_equal_p (XEXP (XEXP (varop, 0), 0), XEXP (varop, 1)))
9805             {
9806               count = 0;
9807               varop = gen_rtx_GT (GET_MODE (varop), XEXP (varop, 1),
9808                                   const0_rtx);
9809
9810               if (STORE_FLAG_VALUE == 1 ? code == ASHIFTRT : code == LSHIFTRT)
9811                 varop = gen_rtx_NEG (GET_MODE (varop), varop);
9812
9813               continue;
9814             }
9815           break;
9816
9817         case TRUNCATE:
9818           /* Change (lshiftrt (truncate (lshiftrt))) to (truncate (lshiftrt))
9819              if the truncate does not affect the value.  */
9820           if (code == LSHIFTRT
9821               && GET_CODE (XEXP (varop, 0)) == LSHIFTRT
9822               && GET_CODE (XEXP (XEXP (varop, 0), 1)) == CONST_INT
9823               && (INTVAL (XEXP (XEXP (varop, 0), 1))
9824                   >= (GET_MODE_BITSIZE (GET_MODE (XEXP (varop, 0)))
9825                       - GET_MODE_BITSIZE (GET_MODE (varop)))))
9826             {
9827               rtx varop_inner = XEXP (varop, 0);
9828
9829               varop_inner
9830                 = gen_rtx_LSHIFTRT (GET_MODE (varop_inner),
9831                                     XEXP (varop_inner, 0),
9832                                     GEN_INT
9833                                     (count + INTVAL (XEXP (varop_inner, 1))));
9834               varop = gen_rtx_TRUNCATE (GET_MODE (varop), varop_inner);
9835               count = 0;
9836               continue;
9837             }
9838           break;
9839
9840         default:
9841           break;
9842         }
9843
9844       break;
9845     }
9846
9847   /* We need to determine what mode to do the shift in.  If the shift is
9848      a right shift or ROTATE, we must always do it in the mode it was
9849      originally done in.  Otherwise, we can do it in MODE, the widest mode
9850      encountered.  The code we care about is that of the shift that will
9851      actually be done, not the shift that was originally requested.  */
9852   shift_mode
9853     = (code == ASHIFTRT || code == LSHIFTRT || code == ROTATE
9854        ? result_mode : mode);
9855
9856   /* We have now finished analyzing the shift.  The result should be
9857      a shift of type CODE with SHIFT_MODE shifting VAROP COUNT places.  If
9858      OUTER_OP is non-NIL, it is an operation that needs to be applied
9859      to the result of the shift.  OUTER_CONST is the relevant constant,
9860      but we must turn off all bits turned off in the shift.
9861
9862      If we were passed a value for X, see if we can use any pieces of
9863      it.  If not, make new rtx.  */
9864
9865   if (x && GET_RTX_CLASS (GET_CODE (x)) == '2'
9866       && GET_CODE (XEXP (x, 1)) == CONST_INT
9867       && (unsigned HOST_WIDE_INT) INTVAL (XEXP (x, 1)) == count)
9868     const_rtx = XEXP (x, 1);
9869   else
9870     const_rtx = GEN_INT (count);
9871
9872   if (x && GET_CODE (XEXP (x, 0)) == SUBREG
9873       && GET_MODE (XEXP (x, 0)) == shift_mode
9874       && SUBREG_REG (XEXP (x, 0)) == varop)
9875     varop = XEXP (x, 0);
9876   else if (GET_MODE (varop) != shift_mode)
9877     varop = gen_lowpart_for_combine (shift_mode, varop);
9878
9879   /* If we can't make the SUBREG, try to return what we were given.  */
9880   if (GET_CODE (varop) == CLOBBER)
9881     return x ? x : varop;
9882
9883   new = simplify_binary_operation (code, shift_mode, varop, const_rtx);
9884   if (new != 0)
9885     x = new;
9886   else
9887     x = gen_rtx_fmt_ee (code, shift_mode, varop, const_rtx);
9888
9889   /* If we have an outer operation and we just made a shift, it is
9890      possible that we could have simplified the shift were it not
9891      for the outer operation.  So try to do the simplification
9892      recursively.  */
9893
9894   if (outer_op != NIL && GET_CODE (x) == code
9895       && GET_CODE (XEXP (x, 1)) == CONST_INT)
9896     x = simplify_shift_const (x, code, shift_mode, XEXP (x, 0),
9897                               INTVAL (XEXP (x, 1)));
9898
9899   /* If we were doing an LSHIFTRT in a wider mode than it was originally,
9900      turn off all the bits that the shift would have turned off.  */
9901   if (orig_code == LSHIFTRT && result_mode != shift_mode)
9902     x = simplify_and_const_int (NULL_RTX, shift_mode, x,
9903                                 GET_MODE_MASK (result_mode) >> orig_count);
9904
9905   /* Do the remainder of the processing in RESULT_MODE.  */
9906   x = gen_lowpart_for_combine (result_mode, x);
9907
9908   /* If COMPLEMENT_P is set, we have to complement X before doing the outer
9909      operation.  */
9910   if (complement_p)
9911     x = simplify_gen_unary (NOT, result_mode, x, result_mode);
9912
9913   if (outer_op != NIL)
9914     {
9915       if (GET_MODE_BITSIZE (result_mode) < HOST_BITS_PER_WIDE_INT)
9916         outer_const = trunc_int_for_mode (outer_const, result_mode);
9917
9918       if (outer_op == AND)
9919         x = simplify_and_const_int (NULL_RTX, result_mode, x, outer_const);
9920       else if (outer_op == SET)
9921         /* This means that we have determined that the result is
9922            equivalent to a constant.  This should be rare.  */
9923         x = GEN_INT (outer_const);
9924       else if (GET_RTX_CLASS (outer_op) == '1')
9925         x = simplify_gen_unary (outer_op, result_mode, x, result_mode);
9926       else
9927         x = gen_binary (outer_op, result_mode, x, GEN_INT (outer_const));
9928     }
9929
9930   return x;
9931 }
9932 \f
9933 /* Like recog, but we receive the address of a pointer to a new pattern.
9934    We try to match the rtx that the pointer points to.
9935    If that fails, we may try to modify or replace the pattern,
9936    storing the replacement into the same pointer object.
9937
9938    Modifications include deletion or addition of CLOBBERs.
9939
9940    PNOTES is a pointer to a location where any REG_UNUSED notes added for
9941    the CLOBBERs are placed.
9942
9943    The value is the final insn code from the pattern ultimately matched,
9944    or -1.  */
9945
9946 static int
9947 recog_for_combine (rtx *pnewpat, rtx insn, rtx *pnotes)
9948 {
9949   rtx pat = *pnewpat;
9950   int insn_code_number;
9951   int num_clobbers_to_add = 0;
9952   int i;
9953   rtx notes = 0;
9954   rtx dummy_insn;
9955
9956   /* If PAT is a PARALLEL, check to see if it contains the CLOBBER
9957      we use to indicate that something didn't match.  If we find such a
9958      thing, force rejection.  */
9959   if (GET_CODE (pat) == PARALLEL)
9960     for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
9961       if (GET_CODE (XVECEXP (pat, 0, i)) == CLOBBER
9962           && XEXP (XVECEXP (pat, 0, i), 0) == const0_rtx)
9963         return -1;
9964
9965   /* *pnewpat does not have to be actual PATTERN (insn), so make a dummy
9966      instruction for pattern recognition.  */
9967   dummy_insn = shallow_copy_rtx (insn);
9968   PATTERN (dummy_insn) = pat;
9969   REG_NOTES (dummy_insn) = 0;
9970
9971   insn_code_number = recog (pat, dummy_insn, &num_clobbers_to_add);
9972
9973   /* If it isn't, there is the possibility that we previously had an insn
9974      that clobbered some register as a side effect, but the combined
9975      insn doesn't need to do that.  So try once more without the clobbers
9976      unless this represents an ASM insn.  */
9977
9978   if (insn_code_number < 0 && ! check_asm_operands (pat)
9979       && GET_CODE (pat) == PARALLEL)
9980     {
9981       int pos;
9982
9983       for (pos = 0, i = 0; i < XVECLEN (pat, 0); i++)
9984         if (GET_CODE (XVECEXP (pat, 0, i)) != CLOBBER)
9985           {
9986             if (i != pos)
9987               SUBST (XVECEXP (pat, 0, pos), XVECEXP (pat, 0, i));
9988             pos++;
9989           }
9990
9991       SUBST_INT (XVECLEN (pat, 0), pos);
9992
9993       if (pos == 1)
9994         pat = XVECEXP (pat, 0, 0);
9995
9996       PATTERN (dummy_insn) = pat;
9997       insn_code_number = recog (pat, dummy_insn, &num_clobbers_to_add);
9998     }
9999
10000   /* Recognize all noop sets, these will be killed by followup pass.  */
10001   if (insn_code_number < 0 && GET_CODE (pat) == SET && set_noop_p (pat))
10002     insn_code_number = NOOP_MOVE_INSN_CODE, num_clobbers_to_add = 0;
10003
10004   /* If we had any clobbers to add, make a new pattern than contains
10005      them.  Then check to make sure that all of them are dead.  */
10006   if (num_clobbers_to_add)
10007     {
10008       rtx newpat = gen_rtx_PARALLEL (VOIDmode,
10009                                      rtvec_alloc (GET_CODE (pat) == PARALLEL
10010                                                   ? (XVECLEN (pat, 0)
10011                                                      + num_clobbers_to_add)
10012                                                   : num_clobbers_to_add + 1));
10013
10014       if (GET_CODE (pat) == PARALLEL)
10015         for (i = 0; i < XVECLEN (pat, 0); i++)
10016           XVECEXP (newpat, 0, i) = XVECEXP (pat, 0, i);
10017       else
10018         XVECEXP (newpat, 0, 0) = pat;
10019
10020       add_clobbers (newpat, insn_code_number);
10021
10022       for (i = XVECLEN (newpat, 0) - num_clobbers_to_add;
10023            i < XVECLEN (newpat, 0); i++)
10024         {
10025           if (GET_CODE (XEXP (XVECEXP (newpat, 0, i), 0)) == REG
10026               && ! reg_dead_at_p (XEXP (XVECEXP (newpat, 0, i), 0), insn))
10027             return -1;
10028           notes = gen_rtx_EXPR_LIST (REG_UNUSED,
10029                                      XEXP (XVECEXP (newpat, 0, i), 0), notes);
10030         }
10031       pat = newpat;
10032     }
10033
10034   *pnewpat = pat;
10035   *pnotes = notes;
10036
10037   return insn_code_number;
10038 }
10039 \f
10040 /* Like gen_lowpart but for use by combine.  In combine it is not possible
10041    to create any new pseudoregs.  However, it is safe to create
10042    invalid memory addresses, because combine will try to recognize
10043    them and all they will do is make the combine attempt fail.
10044
10045    If for some reason this cannot do its job, an rtx
10046    (clobber (const_int 0)) is returned.
10047    An insn containing that will not be recognized.  */
10048
10049 #undef gen_lowpart
10050
10051 static rtx
10052 gen_lowpart_for_combine (enum machine_mode mode, rtx x)
10053 {
10054   rtx result;
10055
10056   if (GET_MODE (x) == mode)
10057     return x;
10058
10059   /* Return identity if this is a CONST or symbolic
10060      reference.  */
10061   if (mode == Pmode
10062       && (GET_CODE (x) == CONST
10063           || GET_CODE (x) == SYMBOL_REF
10064           || GET_CODE (x) == LABEL_REF))
10065     return x;
10066
10067   /* We can only support MODE being wider than a word if X is a
10068      constant integer or has a mode the same size.  */
10069
10070   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
10071       && ! ((GET_MODE (x) == VOIDmode
10072              && (GET_CODE (x) == CONST_INT
10073                  || GET_CODE (x) == CONST_DOUBLE))
10074             || GET_MODE_SIZE (GET_MODE (x)) == GET_MODE_SIZE (mode)))
10075     return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
10076
10077   /* X might be a paradoxical (subreg (mem)).  In that case, gen_lowpart
10078      won't know what to do.  So we will strip off the SUBREG here and
10079      process normally.  */
10080   if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == MEM)
10081     {
10082       x = SUBREG_REG (x);
10083       if (GET_MODE (x) == mode)
10084         return x;
10085     }
10086
10087   result = gen_lowpart_common (mode, x);
10088 #ifdef CANNOT_CHANGE_MODE_CLASS
10089   if (result != 0
10090       && GET_CODE (result) == SUBREG
10091       && GET_CODE (SUBREG_REG (result)) == REG
10092       && REGNO (SUBREG_REG (result)) >= FIRST_PSEUDO_REGISTER)
10093     bitmap_set_bit (&subregs_of_mode, REGNO (SUBREG_REG (result))
10094                                       * MAX_MACHINE_MODE
10095                                       + GET_MODE (result));
10096 #endif
10097
10098   if (result)
10099     return result;
10100
10101   if (GET_CODE (x) == MEM)
10102     {
10103       int offset = 0;
10104
10105       /* Refuse to work on a volatile memory ref or one with a mode-dependent
10106          address.  */
10107       if (MEM_VOLATILE_P (x) || mode_dependent_address_p (XEXP (x, 0)))
10108         return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
10109
10110       /* If we want to refer to something bigger than the original memref,
10111          generate a perverse subreg instead.  That will force a reload
10112          of the original memref X.  */
10113       if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (mode))
10114         return gen_rtx_SUBREG (mode, x, 0);
10115
10116       if (WORDS_BIG_ENDIAN)
10117         offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
10118                   - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
10119
10120       if (BYTES_BIG_ENDIAN)
10121         {
10122           /* Adjust the address so that the address-after-the-data is
10123              unchanged.  */
10124           offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
10125                      - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
10126         }
10127
10128       return adjust_address_nv (x, mode, offset);
10129     }
10130
10131   /* If X is a comparison operator, rewrite it in a new mode.  This
10132      probably won't match, but may allow further simplifications.  */
10133   else if (GET_RTX_CLASS (GET_CODE (x)) == '<')
10134     return gen_rtx_fmt_ee (GET_CODE (x), mode, XEXP (x, 0), XEXP (x, 1));
10135
10136   /* If we couldn't simplify X any other way, just enclose it in a
10137      SUBREG.  Normally, this SUBREG won't match, but some patterns may
10138      include an explicit SUBREG or we may simplify it further in combine.  */
10139   else
10140     {
10141       int offset = 0;
10142       rtx res;
10143       enum machine_mode sub_mode = GET_MODE (x);
10144
10145       offset = subreg_lowpart_offset (mode, sub_mode);
10146       if (sub_mode == VOIDmode)
10147         {
10148           sub_mode = int_mode_for_mode (mode);
10149           x = gen_lowpart_common (sub_mode, x);
10150           if (x == 0)
10151             return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
10152         }
10153       res = simplify_gen_subreg (mode, x, sub_mode, offset);
10154       if (res)
10155         return res;
10156       return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
10157     }
10158 }
10159 \f
10160 /* These routines make binary and unary operations by first seeing if they
10161    fold; if not, a new expression is allocated.  */
10162
10163 static rtx
10164 gen_binary (enum rtx_code code, enum machine_mode mode, rtx op0, rtx op1)
10165 {
10166   rtx result;
10167   rtx tem;
10168
10169   if (GET_RTX_CLASS (code) == 'c'
10170       && swap_commutative_operands_p (op0, op1))
10171     tem = op0, op0 = op1, op1 = tem;
10172
10173   if (GET_RTX_CLASS (code) == '<')
10174     {
10175       enum machine_mode op_mode = GET_MODE (op0);
10176
10177       /* Strip the COMPARE from (REL_OP (compare X Y) 0) to get
10178          just (REL_OP X Y).  */
10179       if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
10180         {
10181           op1 = XEXP (op0, 1);
10182           op0 = XEXP (op0, 0);
10183           op_mode = GET_MODE (op0);
10184         }
10185
10186       if (op_mode == VOIDmode)
10187         op_mode = GET_MODE (op1);
10188       result = simplify_relational_operation (code, op_mode, op0, op1);
10189     }
10190   else
10191     result = simplify_binary_operation (code, mode, op0, op1);
10192
10193   if (result)
10194     return result;
10195
10196   /* Put complex operands first and constants second.  */
10197   if (GET_RTX_CLASS (code) == 'c'
10198       && swap_commutative_operands_p (op0, op1))
10199     return gen_rtx_fmt_ee (code, mode, op1, op0);
10200
10201   /* If we are turning off bits already known off in OP0, we need not do
10202      an AND.  */
10203   else if (code == AND && GET_CODE (op1) == CONST_INT
10204            && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
10205            && (nonzero_bits (op0, mode) & ~INTVAL (op1)) == 0)
10206     return op0;
10207
10208   return gen_rtx_fmt_ee (code, mode, op0, op1);
10209 }
10210 \f
10211 /* Simplify a comparison between *POP0 and *POP1 where CODE is the
10212    comparison code that will be tested.
10213
10214    The result is a possibly different comparison code to use.  *POP0 and
10215    *POP1 may be updated.
10216
10217    It is possible that we might detect that a comparison is either always
10218    true or always false.  However, we do not perform general constant
10219    folding in combine, so this knowledge isn't useful.  Such tautologies
10220    should have been detected earlier.  Hence we ignore all such cases.  */
10221
10222 static enum rtx_code
10223 simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1)
10224 {
10225   rtx op0 = *pop0;
10226   rtx op1 = *pop1;
10227   rtx tem, tem1;
10228   int i;
10229   enum machine_mode mode, tmode;
10230
10231   /* Try a few ways of applying the same transformation to both operands.  */
10232   while (1)
10233     {
10234 #ifndef WORD_REGISTER_OPERATIONS
10235       /* The test below this one won't handle SIGN_EXTENDs on these machines,
10236          so check specially.  */
10237       if (code != GTU && code != GEU && code != LTU && code != LEU
10238           && GET_CODE (op0) == ASHIFTRT && GET_CODE (op1) == ASHIFTRT
10239           && GET_CODE (XEXP (op0, 0)) == ASHIFT
10240           && GET_CODE (XEXP (op1, 0)) == ASHIFT
10241           && GET_CODE (XEXP (XEXP (op0, 0), 0)) == SUBREG
10242           && GET_CODE (XEXP (XEXP (op1, 0), 0)) == SUBREG
10243           && (GET_MODE (SUBREG_REG (XEXP (XEXP (op0, 0), 0)))
10244               == GET_MODE (SUBREG_REG (XEXP (XEXP (op1, 0), 0))))
10245           && GET_CODE (XEXP (op0, 1)) == CONST_INT
10246           && GET_CODE (XEXP (op1, 1)) == CONST_INT
10247           && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
10248           && GET_CODE (XEXP (XEXP (op1, 0), 1)) == CONST_INT
10249           && INTVAL (XEXP (op0, 1)) == INTVAL (XEXP (op1, 1))
10250           && INTVAL (XEXP (op0, 1)) == INTVAL (XEXP (XEXP (op0, 0), 1))
10251           && INTVAL (XEXP (op0, 1)) == INTVAL (XEXP (XEXP (op1, 0), 1))
10252           && (INTVAL (XEXP (op0, 1))
10253               == (GET_MODE_BITSIZE (GET_MODE (op0))
10254                   - (GET_MODE_BITSIZE
10255                      (GET_MODE (SUBREG_REG (XEXP (XEXP (op0, 0), 0))))))))
10256         {
10257           op0 = SUBREG_REG (XEXP (XEXP (op0, 0), 0));
10258           op1 = SUBREG_REG (XEXP (XEXP (op1, 0), 0));
10259         }
10260 #endif
10261
10262       /* If both operands are the same constant shift, see if we can ignore the
10263          shift.  We can if the shift is a rotate or if the bits shifted out of
10264          this shift are known to be zero for both inputs and if the type of
10265          comparison is compatible with the shift.  */
10266       if (GET_CODE (op0) == GET_CODE (op1)
10267           && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
10268           && ((GET_CODE (op0) == ROTATE && (code == NE || code == EQ))
10269               || ((GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFT)
10270                   && (code != GT && code != LT && code != GE && code != LE))
10271               || (GET_CODE (op0) == ASHIFTRT
10272                   && (code != GTU && code != LTU
10273                       && code != GEU && code != LEU)))
10274           && GET_CODE (XEXP (op0, 1)) == CONST_INT
10275           && INTVAL (XEXP (op0, 1)) >= 0
10276           && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
10277           && XEXP (op0, 1) == XEXP (op1, 1))
10278         {
10279           enum machine_mode mode = GET_MODE (op0);
10280           unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
10281           int shift_count = INTVAL (XEXP (op0, 1));
10282
10283           if (GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFTRT)
10284             mask &= (mask >> shift_count) << shift_count;
10285           else if (GET_CODE (op0) == ASHIFT)
10286             mask = (mask & (mask << shift_count)) >> shift_count;
10287
10288           if ((nonzero_bits (XEXP (op0, 0), mode) & ~mask) == 0
10289               && (nonzero_bits (XEXP (op1, 0), mode) & ~mask) == 0)
10290             op0 = XEXP (op0, 0), op1 = XEXP (op1, 0);
10291           else
10292             break;
10293         }
10294
10295       /* If both operands are AND's of a paradoxical SUBREG by constant, the
10296          SUBREGs are of the same mode, and, in both cases, the AND would
10297          be redundant if the comparison was done in the narrower mode,
10298          do the comparison in the narrower mode (e.g., we are AND'ing with 1
10299          and the operand's possibly nonzero bits are 0xffffff01; in that case
10300          if we only care about QImode, we don't need the AND).  This case
10301          occurs if the output mode of an scc insn is not SImode and
10302          STORE_FLAG_VALUE == 1 (e.g., the 386).
10303
10304          Similarly, check for a case where the AND's are ZERO_EXTEND
10305          operations from some narrower mode even though a SUBREG is not
10306          present.  */
10307
10308       else if (GET_CODE (op0) == AND && GET_CODE (op1) == AND
10309                && GET_CODE (XEXP (op0, 1)) == CONST_INT
10310                && GET_CODE (XEXP (op1, 1)) == CONST_INT)
10311         {
10312           rtx inner_op0 = XEXP (op0, 0);
10313           rtx inner_op1 = XEXP (op1, 0);
10314           HOST_WIDE_INT c0 = INTVAL (XEXP (op0, 1));
10315           HOST_WIDE_INT c1 = INTVAL (XEXP (op1, 1));
10316           int changed = 0;
10317
10318           if (GET_CODE (inner_op0) == SUBREG && GET_CODE (inner_op1) == SUBREG
10319               && (GET_MODE_SIZE (GET_MODE (inner_op0))
10320                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner_op0))))
10321               && (GET_MODE (SUBREG_REG (inner_op0))
10322                   == GET_MODE (SUBREG_REG (inner_op1)))
10323               && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (inner_op0)))
10324                   <= HOST_BITS_PER_WIDE_INT)
10325               && (0 == ((~c0) & nonzero_bits (SUBREG_REG (inner_op0),
10326                                              GET_MODE (SUBREG_REG (inner_op0)))))
10327               && (0 == ((~c1) & nonzero_bits (SUBREG_REG (inner_op1),
10328                                              GET_MODE (SUBREG_REG (inner_op1))))))
10329             {
10330               op0 = SUBREG_REG (inner_op0);
10331               op1 = SUBREG_REG (inner_op1);
10332
10333               /* The resulting comparison is always unsigned since we masked
10334                  off the original sign bit.  */
10335               code = unsigned_condition (code);
10336
10337               changed = 1;
10338             }
10339
10340           else if (c0 == c1)
10341             for (tmode = GET_CLASS_NARROWEST_MODE
10342                  (GET_MODE_CLASS (GET_MODE (op0)));
10343                  tmode != GET_MODE (op0); tmode = GET_MODE_WIDER_MODE (tmode))
10344               if ((unsigned HOST_WIDE_INT) c0 == GET_MODE_MASK (tmode))
10345                 {
10346                   op0 = gen_lowpart_for_combine (tmode, inner_op0);
10347                   op1 = gen_lowpart_for_combine (tmode, inner_op1);
10348                   code = unsigned_condition (code);
10349                   changed = 1;
10350                   break;
10351                 }
10352
10353           if (! changed)
10354             break;
10355         }
10356
10357       /* If both operands are NOT, we can strip off the outer operation
10358          and adjust the comparison code for swapped operands; similarly for
10359          NEG, except that this must be an equality comparison.  */
10360       else if ((GET_CODE (op0) == NOT && GET_CODE (op1) == NOT)
10361                || (GET_CODE (op0) == NEG && GET_CODE (op1) == NEG
10362                    && (code == EQ || code == NE)))
10363         op0 = XEXP (op0, 0), op1 = XEXP (op1, 0), code = swap_condition (code);
10364
10365       else
10366         break;
10367     }
10368
10369   /* If the first operand is a constant, swap the operands and adjust the
10370      comparison code appropriately, but don't do this if the second operand
10371      is already a constant integer.  */
10372   if (swap_commutative_operands_p (op0, op1))
10373     {
10374       tem = op0, op0 = op1, op1 = tem;
10375       code = swap_condition (code);
10376     }
10377
10378   /* We now enter a loop during which we will try to simplify the comparison.
10379      For the most part, we only are concerned with comparisons with zero,
10380      but some things may really be comparisons with zero but not start
10381      out looking that way.  */
10382
10383   while (GET_CODE (op1) == CONST_INT)
10384     {
10385       enum machine_mode mode = GET_MODE (op0);
10386       unsigned int mode_width = GET_MODE_BITSIZE (mode);
10387       unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
10388       int equality_comparison_p;
10389       int sign_bit_comparison_p;
10390       int unsigned_comparison_p;
10391       HOST_WIDE_INT const_op;
10392
10393       /* We only want to handle integral modes.  This catches VOIDmode,
10394          CCmode, and the floating-point modes.  An exception is that we
10395          can handle VOIDmode if OP0 is a COMPARE or a comparison
10396          operation.  */
10397
10398       if (GET_MODE_CLASS (mode) != MODE_INT
10399           && ! (mode == VOIDmode
10400                 && (GET_CODE (op0) == COMPARE
10401                     || GET_RTX_CLASS (GET_CODE (op0)) == '<')))
10402         break;
10403
10404       /* Get the constant we are comparing against and turn off all bits
10405          not on in our mode.  */
10406       const_op = INTVAL (op1);
10407       if (mode != VOIDmode)
10408         const_op = trunc_int_for_mode (const_op, mode);
10409       op1 = GEN_INT (const_op);
10410
10411       /* If we are comparing against a constant power of two and the value
10412          being compared can only have that single bit nonzero (e.g., it was
10413          `and'ed with that bit), we can replace this with a comparison
10414          with zero.  */
10415       if (const_op
10416           && (code == EQ || code == NE || code == GE || code == GEU
10417               || code == LT || code == LTU)
10418           && mode_width <= HOST_BITS_PER_WIDE_INT
10419           && exact_log2 (const_op) >= 0
10420           && nonzero_bits (op0, mode) == (unsigned HOST_WIDE_INT) const_op)
10421         {
10422           code = (code == EQ || code == GE || code == GEU ? NE : EQ);
10423           op1 = const0_rtx, const_op = 0;
10424         }
10425
10426       /* Similarly, if we are comparing a value known to be either -1 or
10427          0 with -1, change it to the opposite comparison against zero.  */
10428
10429       if (const_op == -1
10430           && (code == EQ || code == NE || code == GT || code == LE
10431               || code == GEU || code == LTU)
10432           && num_sign_bit_copies (op0, mode) == mode_width)
10433         {
10434           code = (code == EQ || code == LE || code == GEU ? NE : EQ);
10435           op1 = const0_rtx, const_op = 0;
10436         }
10437
10438       /* Do some canonicalizations based on the comparison code.  We prefer
10439          comparisons against zero and then prefer equality comparisons.
10440          If we can reduce the size of a constant, we will do that too.  */
10441
10442       switch (code)
10443         {
10444         case LT:
10445           /* < C is equivalent to <= (C - 1) */
10446           if (const_op > 0)
10447             {
10448               const_op -= 1;
10449               op1 = GEN_INT (const_op);
10450               code = LE;
10451               /* ... fall through to LE case below.  */
10452             }
10453           else
10454             break;
10455
10456         case LE:
10457           /* <= C is equivalent to < (C + 1); we do this for C < 0  */
10458           if (const_op < 0)
10459             {
10460               const_op += 1;
10461               op1 = GEN_INT (const_op);
10462               code = LT;
10463             }
10464
10465           /* If we are doing a <= 0 comparison on a value known to have
10466              a zero sign bit, we can replace this with == 0.  */
10467           else if (const_op == 0
10468                    && mode_width <= HOST_BITS_PER_WIDE_INT
10469                    && (nonzero_bits (op0, mode)
10470                        & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)
10471             code = EQ;
10472           break;
10473
10474         case GE:
10475           /* >= C is equivalent to > (C - 1).  */
10476           if (const_op > 0)
10477             {
10478               const_op -= 1;
10479               op1 = GEN_INT (const_op);
10480               code = GT;
10481               /* ... fall through to GT below.  */
10482             }
10483           else
10484             break;
10485
10486         case GT:
10487           /* > C is equivalent to >= (C + 1); we do this for C < 0.  */
10488           if (const_op < 0)
10489             {
10490               const_op += 1;
10491               op1 = GEN_INT (const_op);
10492               code = GE;
10493             }
10494
10495           /* If we are doing a > 0 comparison on a value known to have
10496              a zero sign bit, we can replace this with != 0.  */
10497           else if (const_op == 0
10498                    && mode_width <= HOST_BITS_PER_WIDE_INT
10499                    && (nonzero_bits (op0, mode)
10500                        & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)
10501             code = NE;
10502           break;
10503
10504         case LTU:
10505           /* < C is equivalent to <= (C - 1).  */
10506           if (const_op > 0)
10507             {
10508               const_op -= 1;
10509               op1 = GEN_INT (const_op);
10510               code = LEU;
10511               /* ... fall through ...  */
10512             }
10513
10514           /* (unsigned) < 0x80000000 is equivalent to >= 0.  */
10515           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
10516                    && (const_op == (HOST_WIDE_INT) 1 << (mode_width - 1)))
10517             {
10518               const_op = 0, op1 = const0_rtx;
10519               code = GE;
10520               break;
10521             }
10522           else
10523             break;
10524
10525         case LEU:
10526           /* unsigned <= 0 is equivalent to == 0 */
10527           if (const_op == 0)
10528             code = EQ;
10529
10530           /* (unsigned) <= 0x7fffffff is equivalent to >= 0.  */
10531           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
10532                    && (const_op == ((HOST_WIDE_INT) 1 << (mode_width - 1)) - 1))
10533             {
10534               const_op = 0, op1 = const0_rtx;
10535               code = GE;
10536             }
10537           break;
10538
10539         case GEU:
10540           /* >= C is equivalent to < (C - 1).  */
10541           if (const_op > 1)
10542             {
10543               const_op -= 1;
10544               op1 = GEN_INT (const_op);
10545               code = GTU;
10546               /* ... fall through ...  */
10547             }
10548
10549           /* (unsigned) >= 0x80000000 is equivalent to < 0.  */
10550           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
10551                    && (const_op == (HOST_WIDE_INT) 1 << (mode_width - 1)))
10552             {
10553               const_op = 0, op1 = const0_rtx;
10554               code = LT;
10555               break;
10556             }
10557           else
10558             break;
10559
10560         case GTU:
10561           /* unsigned > 0 is equivalent to != 0 */
10562           if (const_op == 0)
10563             code = NE;
10564
10565           /* (unsigned) > 0x7fffffff is equivalent to < 0.  */
10566           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
10567                    && (const_op == ((HOST_WIDE_INT) 1 << (mode_width - 1)) - 1))
10568             {
10569               const_op = 0, op1 = const0_rtx;
10570               code = LT;
10571             }
10572           break;
10573
10574         default:
10575           break;
10576         }
10577
10578       /* Compute some predicates to simplify code below.  */
10579
10580       equality_comparison_p = (code == EQ || code == NE);
10581       sign_bit_comparison_p = ((code == LT || code == GE) && const_op == 0);
10582       unsigned_comparison_p = (code == LTU || code == LEU || code == GTU
10583                                || code == GEU);
10584
10585       /* If this is a sign bit comparison and we can do arithmetic in
10586          MODE, say that we will only be needing the sign bit of OP0.  */
10587       if (sign_bit_comparison_p
10588           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
10589         op0 = force_to_mode (op0, mode,
10590                              ((HOST_WIDE_INT) 1
10591                               << (GET_MODE_BITSIZE (mode) - 1)),
10592                              NULL_RTX, 0);
10593
10594       /* Now try cases based on the opcode of OP0.  If none of the cases
10595          does a "continue", we exit this loop immediately after the
10596          switch.  */
10597
10598       switch (GET_CODE (op0))
10599         {
10600         case ZERO_EXTRACT:
10601           /* If we are extracting a single bit from a variable position in
10602              a constant that has only a single bit set and are comparing it
10603              with zero, we can convert this into an equality comparison
10604              between the position and the location of the single bit.  */
10605
10606           if (GET_CODE (XEXP (op0, 0)) == CONST_INT
10607               && XEXP (op0, 1) == const1_rtx
10608               && equality_comparison_p && const_op == 0
10609               && (i = exact_log2 (INTVAL (XEXP (op0, 0)))) >= 0)
10610             {
10611               if (BITS_BIG_ENDIAN)
10612                 {
10613                   enum machine_mode new_mode
10614                     = mode_for_extraction (EP_extzv, 1);
10615                   if (new_mode == MAX_MACHINE_MODE)
10616                     i = BITS_PER_WORD - 1 - i;
10617                   else
10618                     {
10619                       mode = new_mode;
10620                       i = (GET_MODE_BITSIZE (mode) - 1 - i);
10621                     }
10622                 }
10623
10624               op0 = XEXP (op0, 2);
10625               op1 = GEN_INT (i);
10626               const_op = i;
10627
10628               /* Result is nonzero iff shift count is equal to I.  */
10629               code = reverse_condition (code);
10630               continue;
10631             }
10632
10633           /* ... fall through ...  */
10634
10635         case SIGN_EXTRACT:
10636           tem = expand_compound_operation (op0);
10637           if (tem != op0)
10638             {
10639               op0 = tem;
10640               continue;
10641             }
10642           break;
10643
10644         case NOT:
10645           /* If testing for equality, we can take the NOT of the constant.  */
10646           if (equality_comparison_p
10647               && (tem = simplify_unary_operation (NOT, mode, op1, mode)) != 0)
10648             {
10649               op0 = XEXP (op0, 0);
10650               op1 = tem;
10651               continue;
10652             }
10653
10654           /* If just looking at the sign bit, reverse the sense of the
10655              comparison.  */
10656           if (sign_bit_comparison_p)
10657             {
10658               op0 = XEXP (op0, 0);
10659               code = (code == GE ? LT : GE);
10660               continue;
10661             }
10662           break;
10663
10664         case NEG:
10665           /* If testing for equality, we can take the NEG of the constant.  */
10666           if (equality_comparison_p
10667               && (tem = simplify_unary_operation (NEG, mode, op1, mode)) != 0)
10668             {
10669               op0 = XEXP (op0, 0);
10670               op1 = tem;
10671               continue;
10672             }
10673
10674           /* The remaining cases only apply to comparisons with zero.  */
10675           if (const_op != 0)
10676             break;
10677
10678           /* When X is ABS or is known positive,
10679              (neg X) is < 0 if and only if X != 0.  */
10680
10681           if (sign_bit_comparison_p
10682               && (GET_CODE (XEXP (op0, 0)) == ABS
10683                   || (mode_width <= HOST_BITS_PER_WIDE_INT
10684                       && (nonzero_bits (XEXP (op0, 0), mode)
10685                           & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)))
10686             {
10687               op0 = XEXP (op0, 0);
10688               code = (code == LT ? NE : EQ);
10689               continue;
10690             }
10691
10692           /* If we have NEG of something whose two high-order bits are the
10693              same, we know that "(-a) < 0" is equivalent to "a > 0".  */
10694           if (num_sign_bit_copies (op0, mode) >= 2)
10695             {
10696               op0 = XEXP (op0, 0);
10697               code = swap_condition (code);
10698               continue;
10699             }
10700           break;
10701
10702         case ROTATE:
10703           /* If we are testing equality and our count is a constant, we
10704              can perform the inverse operation on our RHS.  */
10705           if (equality_comparison_p && GET_CODE (XEXP (op0, 1)) == CONST_INT
10706               && (tem = simplify_binary_operation (ROTATERT, mode,
10707                                                    op1, XEXP (op0, 1))) != 0)
10708             {
10709               op0 = XEXP (op0, 0);
10710               op1 = tem;
10711               continue;
10712             }
10713
10714           /* If we are doing a < 0 or >= 0 comparison, it means we are testing
10715              a particular bit.  Convert it to an AND of a constant of that
10716              bit.  This will be converted into a ZERO_EXTRACT.  */
10717           if (const_op == 0 && sign_bit_comparison_p
10718               && GET_CODE (XEXP (op0, 1)) == CONST_INT
10719               && mode_width <= HOST_BITS_PER_WIDE_INT)
10720             {
10721               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
10722                                             ((HOST_WIDE_INT) 1
10723                                              << (mode_width - 1
10724                                                  - INTVAL (XEXP (op0, 1)))));
10725               code = (code == LT ? NE : EQ);
10726               continue;
10727             }
10728
10729           /* Fall through.  */
10730
10731         case ABS:
10732           /* ABS is ignorable inside an equality comparison with zero.  */
10733           if (const_op == 0 && equality_comparison_p)
10734             {
10735               op0 = XEXP (op0, 0);
10736               continue;
10737             }
10738           break;
10739
10740         case SIGN_EXTEND:
10741           /* Can simplify (compare (zero/sign_extend FOO) CONST)
10742              to (compare FOO CONST) if CONST fits in FOO's mode and we
10743              are either testing inequality or have an unsigned comparison
10744              with ZERO_EXTEND or a signed comparison with SIGN_EXTEND.  */
10745           if (! unsigned_comparison_p
10746               && (GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0)))
10747                   <= HOST_BITS_PER_WIDE_INT)
10748               && ((unsigned HOST_WIDE_INT) const_op
10749                   < (((unsigned HOST_WIDE_INT) 1
10750                       << (GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0))) - 1)))))
10751             {
10752               op0 = XEXP (op0, 0);
10753               continue;
10754             }
10755           break;
10756
10757         case SUBREG:
10758           /* Check for the case where we are comparing A - C1 with C2,
10759              both constants are smaller than 1/2 the maximum positive
10760              value in MODE, and the comparison is equality or unsigned.
10761              In that case, if A is either zero-extended to MODE or has
10762              sufficient sign bits so that the high-order bit in MODE
10763              is a copy of the sign in the inner mode, we can prove that it is
10764              safe to do the operation in the wider mode.  This simplifies
10765              many range checks.  */
10766
10767           if (mode_width <= HOST_BITS_PER_WIDE_INT
10768               && subreg_lowpart_p (op0)
10769               && GET_CODE (SUBREG_REG (op0)) == PLUS
10770               && GET_CODE (XEXP (SUBREG_REG (op0), 1)) == CONST_INT
10771               && INTVAL (XEXP (SUBREG_REG (op0), 1)) < 0
10772               && (-INTVAL (XEXP (SUBREG_REG (op0), 1))
10773                   < (HOST_WIDE_INT) (GET_MODE_MASK (mode) / 2))
10774               && (unsigned HOST_WIDE_INT) const_op < GET_MODE_MASK (mode) / 2
10775               && (0 == (nonzero_bits (XEXP (SUBREG_REG (op0), 0),
10776                                       GET_MODE (SUBREG_REG (op0)))
10777                         & ~GET_MODE_MASK (mode))
10778                   || (num_sign_bit_copies (XEXP (SUBREG_REG (op0), 0),
10779                                            GET_MODE (SUBREG_REG (op0)))
10780                       > (unsigned int)
10781                         (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0)))
10782                          - GET_MODE_BITSIZE (mode)))))
10783             {
10784               op0 = SUBREG_REG (op0);
10785               continue;
10786             }
10787
10788           /* If the inner mode is narrower and we are extracting the low part,
10789              we can treat the SUBREG as if it were a ZERO_EXTEND.  */
10790           if (subreg_lowpart_p (op0)
10791               && GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0))) < mode_width)
10792             /* Fall through */ ;
10793           else
10794             break;
10795
10796           /* ... fall through ...  */
10797
10798         case ZERO_EXTEND:
10799           if ((unsigned_comparison_p || equality_comparison_p)
10800               && (GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0)))
10801                   <= HOST_BITS_PER_WIDE_INT)
10802               && ((unsigned HOST_WIDE_INT) const_op
10803                   < GET_MODE_MASK (GET_MODE (XEXP (op0, 0)))))
10804             {
10805               op0 = XEXP (op0, 0);
10806               continue;
10807             }
10808           break;
10809
10810         case PLUS:
10811           /* (eq (plus X A) B) -> (eq X (minus B A)).  We can only do
10812              this for equality comparisons due to pathological cases involving
10813              overflows.  */
10814           if (equality_comparison_p
10815               && 0 != (tem = simplify_binary_operation (MINUS, mode,
10816                                                         op1, XEXP (op0, 1))))
10817             {
10818               op0 = XEXP (op0, 0);
10819               op1 = tem;
10820               continue;
10821             }
10822
10823           /* (plus (abs X) (const_int -1)) is < 0 if and only if X == 0.  */
10824           if (const_op == 0 && XEXP (op0, 1) == constm1_rtx
10825               && GET_CODE (XEXP (op0, 0)) == ABS && sign_bit_comparison_p)
10826             {
10827               op0 = XEXP (XEXP (op0, 0), 0);
10828               code = (code == LT ? EQ : NE);
10829               continue;
10830             }
10831           break;
10832
10833         case MINUS:
10834           /* We used to optimize signed comparisons against zero, but that
10835              was incorrect.  Unsigned comparisons against zero (GTU, LEU)
10836              arrive here as equality comparisons, or (GEU, LTU) are
10837              optimized away.  No need to special-case them.  */
10838
10839           /* (eq (minus A B) C) -> (eq A (plus B C)) or
10840              (eq B (minus A C)), whichever simplifies.  We can only do
10841              this for equality comparisons due to pathological cases involving
10842              overflows.  */
10843           if (equality_comparison_p
10844               && 0 != (tem = simplify_binary_operation (PLUS, mode,
10845                                                         XEXP (op0, 1), op1)))
10846             {
10847               op0 = XEXP (op0, 0);
10848               op1 = tem;
10849               continue;
10850             }
10851
10852           if (equality_comparison_p
10853               && 0 != (tem = simplify_binary_operation (MINUS, mode,
10854                                                         XEXP (op0, 0), op1)))
10855             {
10856               op0 = XEXP (op0, 1);
10857               op1 = tem;
10858               continue;
10859             }
10860
10861           /* The sign bit of (minus (ashiftrt X C) X), where C is the number
10862              of bits in X minus 1, is one iff X > 0.  */
10863           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 0)) == ASHIFTRT
10864               && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
10865               && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (op0, 0), 1))
10866                  == mode_width - 1
10867               && rtx_equal_p (XEXP (XEXP (op0, 0), 0), XEXP (op0, 1)))
10868             {
10869               op0 = XEXP (op0, 1);
10870               code = (code == GE ? LE : GT);
10871               continue;
10872             }
10873           break;
10874
10875         case XOR:
10876           /* (eq (xor A B) C) -> (eq A (xor B C)).  This is a simplification
10877              if C is zero or B is a constant.  */
10878           if (equality_comparison_p
10879               && 0 != (tem = simplify_binary_operation (XOR, mode,
10880                                                         XEXP (op0, 1), op1)))
10881             {
10882               op0 = XEXP (op0, 0);
10883               op1 = tem;
10884               continue;
10885             }
10886           break;
10887
10888         case EQ:  case NE:
10889         case UNEQ:  case LTGT:
10890         case LT:  case LTU:  case UNLT:  case LE:  case LEU:  case UNLE:
10891         case GT:  case GTU:  case UNGT:  case GE:  case GEU:  case UNGE:
10892         case UNORDERED: case ORDERED:
10893           /* We can't do anything if OP0 is a condition code value, rather
10894              than an actual data value.  */
10895           if (const_op != 0
10896               || CC0_P (XEXP (op0, 0))
10897               || GET_MODE_CLASS (GET_MODE (XEXP (op0, 0))) == MODE_CC)
10898             break;
10899
10900           /* Get the two operands being compared.  */
10901           if (GET_CODE (XEXP (op0, 0)) == COMPARE)
10902             tem = XEXP (XEXP (op0, 0), 0), tem1 = XEXP (XEXP (op0, 0), 1);
10903           else
10904             tem = XEXP (op0, 0), tem1 = XEXP (op0, 1);
10905
10906           /* Check for the cases where we simply want the result of the
10907              earlier test or the opposite of that result.  */
10908           if (code == NE || code == EQ
10909               || (GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
10910                   && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
10911                   && (STORE_FLAG_VALUE
10912                       & (((HOST_WIDE_INT) 1
10913                           << (GET_MODE_BITSIZE (GET_MODE (op0)) - 1))))
10914                   && (code == LT || code == GE)))
10915             {
10916               enum rtx_code new_code;
10917               if (code == LT || code == NE)
10918                 new_code = GET_CODE (op0);
10919               else
10920                 new_code = combine_reversed_comparison_code (op0);
10921
10922               if (new_code != UNKNOWN)
10923                 {
10924                   code = new_code;
10925                   op0 = tem;
10926                   op1 = tem1;
10927                   continue;
10928                 }
10929             }
10930           break;
10931
10932         case IOR:
10933           /* The sign bit of (ior (plus X (const_int -1)) X) is nonzero
10934              iff X <= 0.  */
10935           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 0)) == PLUS
10936               && XEXP (XEXP (op0, 0), 1) == constm1_rtx
10937               && rtx_equal_p (XEXP (XEXP (op0, 0), 0), XEXP (op0, 1)))
10938             {
10939               op0 = XEXP (op0, 1);
10940               code = (code == GE ? GT : LE);
10941               continue;
10942             }
10943           break;
10944
10945         case AND:
10946           /* Convert (and (xshift 1 X) Y) to (and (lshiftrt Y X) 1).  This
10947              will be converted to a ZERO_EXTRACT later.  */
10948           if (const_op == 0 && equality_comparison_p
10949               && GET_CODE (XEXP (op0, 0)) == ASHIFT
10950               && XEXP (XEXP (op0, 0), 0) == const1_rtx)
10951             {
10952               op0 = simplify_and_const_int
10953                 (op0, mode, gen_rtx_LSHIFTRT (mode,
10954                                               XEXP (op0, 1),
10955                                               XEXP (XEXP (op0, 0), 1)),
10956                  (HOST_WIDE_INT) 1);
10957               continue;
10958             }
10959
10960           /* If we are comparing (and (lshiftrt X C1) C2) for equality with
10961              zero and X is a comparison and C1 and C2 describe only bits set
10962              in STORE_FLAG_VALUE, we can compare with X.  */
10963           if (const_op == 0 && equality_comparison_p
10964               && mode_width <= HOST_BITS_PER_WIDE_INT
10965               && GET_CODE (XEXP (op0, 1)) == CONST_INT
10966               && GET_CODE (XEXP (op0, 0)) == LSHIFTRT
10967               && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
10968               && INTVAL (XEXP (XEXP (op0, 0), 1)) >= 0
10969               && INTVAL (XEXP (XEXP (op0, 0), 1)) < HOST_BITS_PER_WIDE_INT)
10970             {
10971               mask = ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
10972                       << INTVAL (XEXP (XEXP (op0, 0), 1)));
10973               if ((~STORE_FLAG_VALUE & mask) == 0
10974                   && (GET_RTX_CLASS (GET_CODE (XEXP (XEXP (op0, 0), 0))) == '<'
10975                       || ((tem = get_last_value (XEXP (XEXP (op0, 0), 0))) != 0
10976                           && GET_RTX_CLASS (GET_CODE (tem)) == '<')))
10977                 {
10978                   op0 = XEXP (XEXP (op0, 0), 0);
10979                   continue;
10980                 }
10981             }
10982
10983           /* If we are doing an equality comparison of an AND of a bit equal
10984              to the sign bit, replace this with a LT or GE comparison of
10985              the underlying value.  */
10986           if (equality_comparison_p
10987               && const_op == 0
10988               && GET_CODE (XEXP (op0, 1)) == CONST_INT
10989               && mode_width <= HOST_BITS_PER_WIDE_INT
10990               && ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
10991                   == (unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
10992             {
10993               op0 = XEXP (op0, 0);
10994               code = (code == EQ ? GE : LT);
10995               continue;
10996             }
10997
10998           /* If this AND operation is really a ZERO_EXTEND from a narrower
10999              mode, the constant fits within that mode, and this is either an
11000              equality or unsigned comparison, try to do this comparison in
11001              the narrower mode.  */
11002           if ((equality_comparison_p || unsigned_comparison_p)
11003               && GET_CODE (XEXP (op0, 1)) == CONST_INT
11004               && (i = exact_log2 ((INTVAL (XEXP (op0, 1))
11005                                    & GET_MODE_MASK (mode))
11006                                   + 1)) >= 0
11007               && const_op >> i == 0
11008               && (tmode = mode_for_size (i, MODE_INT, 1)) != BLKmode)
11009             {
11010               op0 = gen_lowpart_for_combine (tmode, XEXP (op0, 0));
11011               continue;
11012             }
11013
11014           /* If this is (and:M1 (subreg:M2 X 0) (const_int C1)) where C1
11015              fits in both M1 and M2 and the SUBREG is either paradoxical
11016              or represents the low part, permute the SUBREG and the AND
11017              and try again.  */
11018           if (GET_CODE (XEXP (op0, 0)) == SUBREG)
11019             {
11020               unsigned HOST_WIDE_INT c1;
11021               tmode = GET_MODE (SUBREG_REG (XEXP (op0, 0)));
11022               /* Require an integral mode, to avoid creating something like
11023                  (AND:SF ...).  */
11024               if (SCALAR_INT_MODE_P (tmode)
11025                   /* It is unsafe to commute the AND into the SUBREG if the
11026                      SUBREG is paradoxical and WORD_REGISTER_OPERATIONS is
11027                      not defined.  As originally written the upper bits
11028                      have a defined value due to the AND operation.
11029                      However, if we commute the AND inside the SUBREG then
11030                      they no longer have defined values and the meaning of
11031                      the code has been changed.  */
11032                   && (0
11033 #ifdef WORD_REGISTER_OPERATIONS
11034                       || (mode_width > GET_MODE_BITSIZE (tmode)
11035                           && mode_width <= BITS_PER_WORD)
11036 #endif
11037                       || (mode_width <= GET_MODE_BITSIZE (tmode)
11038                           && subreg_lowpart_p (XEXP (op0, 0))))
11039                   && GET_CODE (XEXP (op0, 1)) == CONST_INT
11040                   && mode_width <= HOST_BITS_PER_WIDE_INT
11041                   && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT
11042                   && ((c1 = INTVAL (XEXP (op0, 1))) & ~mask) == 0
11043                   && (c1 & ~GET_MODE_MASK (tmode)) == 0
11044                   && c1 != mask
11045                   && c1 != GET_MODE_MASK (tmode))
11046                 {
11047                   op0 = gen_binary (AND, tmode,
11048                                     SUBREG_REG (XEXP (op0, 0)),
11049                                     gen_int_mode (c1, tmode));
11050                   op0 = gen_lowpart_for_combine (mode, op0);
11051                   continue;
11052                 }
11053             }
11054
11055           /* Convert (ne (and (lshiftrt (not X)) 1) 0) to
11056              (eq (and (lshiftrt X) 1) 0).  */
11057           if (const_op == 0 && equality_comparison_p
11058               && XEXP (op0, 1) == const1_rtx
11059               && GET_CODE (XEXP (op0, 0)) == LSHIFTRT
11060               && GET_CODE (XEXP (XEXP (op0, 0), 0)) == NOT)
11061             {
11062               op0 = simplify_and_const_int
11063                 (op0, mode,
11064                  gen_rtx_LSHIFTRT (mode, XEXP (XEXP (XEXP (op0, 0), 0), 0),
11065                                    XEXP (XEXP (op0, 0), 1)),
11066                  (HOST_WIDE_INT) 1);
11067               code = (code == NE ? EQ : NE);
11068               continue;
11069             }
11070           break;
11071
11072         case ASHIFT:
11073           /* If we have (compare (ashift FOO N) (const_int C)) and
11074              the high order N bits of FOO (N+1 if an inequality comparison)
11075              are known to be zero, we can do this by comparing FOO with C
11076              shifted right N bits so long as the low-order N bits of C are
11077              zero.  */
11078           if (GET_CODE (XEXP (op0, 1)) == CONST_INT
11079               && INTVAL (XEXP (op0, 1)) >= 0
11080               && ((INTVAL (XEXP (op0, 1)) + ! equality_comparison_p)
11081                   < HOST_BITS_PER_WIDE_INT)
11082               && ((const_op
11083                    & (((HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1))) - 1)) == 0)
11084               && mode_width <= HOST_BITS_PER_WIDE_INT
11085               && (nonzero_bits (XEXP (op0, 0), mode)
11086                   & ~(mask >> (INTVAL (XEXP (op0, 1))
11087                                + ! equality_comparison_p))) == 0)
11088             {
11089               /* We must perform a logical shift, not an arithmetic one,
11090                  as we want the top N bits of C to be zero.  */
11091               unsigned HOST_WIDE_INT temp = const_op & GET_MODE_MASK (mode);
11092
11093               temp >>= INTVAL (XEXP (op0, 1));
11094               op1 = gen_int_mode (temp, mode);
11095               op0 = XEXP (op0, 0);
11096               continue;
11097             }
11098
11099           /* If we are doing a sign bit comparison, it means we are testing
11100              a particular bit.  Convert it to the appropriate AND.  */
11101           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 1)) == CONST_INT
11102               && mode_width <= HOST_BITS_PER_WIDE_INT)
11103             {
11104               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
11105                                             ((HOST_WIDE_INT) 1
11106                                              << (mode_width - 1
11107                                                  - INTVAL (XEXP (op0, 1)))));
11108               code = (code == LT ? NE : EQ);
11109               continue;
11110             }
11111
11112           /* If this an equality comparison with zero and we are shifting
11113              the low bit to the sign bit, we can convert this to an AND of the
11114              low-order bit.  */
11115           if (const_op == 0 && equality_comparison_p
11116               && GET_CODE (XEXP (op0, 1)) == CONST_INT
11117               && (unsigned HOST_WIDE_INT) INTVAL (XEXP (op0, 1))
11118                  == mode_width - 1)
11119             {
11120               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
11121                                             (HOST_WIDE_INT) 1);
11122               continue;
11123             }
11124           break;
11125
11126         case ASHIFTRT:
11127           /* If this is an equality comparison with zero, we can do this
11128              as a logical shift, which might be much simpler.  */
11129           if (equality_comparison_p && const_op == 0
11130               && GET_CODE (XEXP (op0, 1)) == CONST_INT)
11131             {
11132               op0 = simplify_shift_const (NULL_RTX, LSHIFTRT, mode,
11133                                           XEXP (op0, 0),
11134                                           INTVAL (XEXP (op0, 1)));
11135               continue;
11136             }
11137
11138           /* If OP0 is a sign extension and CODE is not an unsigned comparison,
11139              do the comparison in a narrower mode.  */
11140           if (! unsigned_comparison_p
11141               && GET_CODE (XEXP (op0, 1)) == CONST_INT
11142               && GET_CODE (XEXP (op0, 0)) == ASHIFT
11143               && XEXP (op0, 1) == XEXP (XEXP (op0, 0), 1)
11144               && (tmode = mode_for_size (mode_width - INTVAL (XEXP (op0, 1)),
11145                                          MODE_INT, 1)) != BLKmode
11146               && (((unsigned HOST_WIDE_INT) const_op
11147                    + (GET_MODE_MASK (tmode) >> 1) + 1)
11148                   <= GET_MODE_MASK (tmode)))
11149             {
11150               op0 = gen_lowpart_for_combine (tmode, XEXP (XEXP (op0, 0), 0));
11151               continue;
11152             }
11153
11154           /* Likewise if OP0 is a PLUS of a sign extension with a
11155              constant, which is usually represented with the PLUS
11156              between the shifts.  */
11157           if (! unsigned_comparison_p
11158               && GET_CODE (XEXP (op0, 1)) == CONST_INT
11159               && GET_CODE (XEXP (op0, 0)) == PLUS
11160               && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
11161               && GET_CODE (XEXP (XEXP (op0, 0), 0)) == ASHIFT
11162               && XEXP (op0, 1) == XEXP (XEXP (XEXP (op0, 0), 0), 1)
11163               && (tmode = mode_for_size (mode_width - INTVAL (XEXP (op0, 1)),
11164                                          MODE_INT, 1)) != BLKmode
11165               && (((unsigned HOST_WIDE_INT) const_op
11166                    + (GET_MODE_MASK (tmode) >> 1) + 1)
11167                   <= GET_MODE_MASK (tmode)))
11168             {
11169               rtx inner = XEXP (XEXP (XEXP (op0, 0), 0), 0);
11170               rtx add_const = XEXP (XEXP (op0, 0), 1);
11171               rtx new_const = gen_binary (ASHIFTRT, GET_MODE (op0), add_const,
11172                                           XEXP (op0, 1));
11173
11174               op0 = gen_binary (PLUS, tmode,
11175                                 gen_lowpart_for_combine (tmode, inner),
11176                                 new_const);
11177               continue;
11178             }
11179
11180           /* ... fall through ...  */
11181         case LSHIFTRT:
11182           /* If we have (compare (xshiftrt FOO N) (const_int C)) and
11183              the low order N bits of FOO are known to be zero, we can do this
11184              by comparing FOO with C shifted left N bits so long as no
11185              overflow occurs.  */
11186           if (GET_CODE (XEXP (op0, 1)) == CONST_INT
11187               && INTVAL (XEXP (op0, 1)) >= 0
11188               && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
11189               && mode_width <= HOST_BITS_PER_WIDE_INT
11190               && (nonzero_bits (XEXP (op0, 0), mode)
11191                   & (((HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1))) - 1)) == 0
11192               && (((unsigned HOST_WIDE_INT) const_op
11193                    + (GET_CODE (op0) != LSHIFTRT
11194                       ? ((GET_MODE_MASK (mode) >> INTVAL (XEXP (op0, 1)) >> 1)
11195                          + 1)
11196                       : 0))
11197                   <= GET_MODE_MASK (mode) >> INTVAL (XEXP (op0, 1))))
11198             {
11199               /* If the shift was logical, then we must make the condition
11200                  unsigned.  */
11201               if (GET_CODE (op0) == LSHIFTRT)
11202                 code = unsigned_condition (code);
11203
11204               const_op <<= INTVAL (XEXP (op0, 1));
11205               op1 = GEN_INT (const_op);
11206               op0 = XEXP (op0, 0);
11207               continue;
11208             }
11209
11210           /* If we are using this shift to extract just the sign bit, we
11211              can replace this with an LT or GE comparison.  */
11212           if (const_op == 0
11213               && (equality_comparison_p || sign_bit_comparison_p)
11214               && GET_CODE (XEXP (op0, 1)) == CONST_INT
11215               && (unsigned HOST_WIDE_INT) INTVAL (XEXP (op0, 1))
11216                  == mode_width - 1)
11217             {
11218               op0 = XEXP (op0, 0);
11219               code = (code == NE || code == GT ? LT : GE);
11220               continue;
11221             }
11222           break;
11223
11224         default:
11225           break;
11226         }
11227
11228       break;
11229     }
11230
11231   /* Now make any compound operations involved in this comparison.  Then,
11232      check for an outmost SUBREG on OP0 that is not doing anything or is
11233      paradoxical.  The latter transformation must only be performed when
11234      it is known that the "extra" bits will be the same in op0 and op1 or
11235      that they don't matter.  There are three cases to consider:
11236
11237      1. SUBREG_REG (op0) is a register.  In this case the bits are don't
11238      care bits and we can assume they have any convenient value.  So
11239      making the transformation is safe.
11240
11241      2. SUBREG_REG (op0) is a memory and LOAD_EXTEND_OP is not defined.
11242      In this case the upper bits of op0 are undefined.  We should not make
11243      the simplification in that case as we do not know the contents of
11244      those bits.
11245
11246      3. SUBREG_REG (op0) is a memory and LOAD_EXTEND_OP is defined and not
11247      NIL.  In that case we know those bits are zeros or ones.  We must
11248      also be sure that they are the same as the upper bits of op1.
11249
11250      We can never remove a SUBREG for a non-equality comparison because
11251      the sign bit is in a different place in the underlying object.  */
11252
11253   op0 = make_compound_operation (op0, op1 == const0_rtx ? COMPARE : SET);
11254   op1 = make_compound_operation (op1, SET);
11255
11256   if (GET_CODE (op0) == SUBREG && subreg_lowpart_p (op0)
11257       /* Case 3 above, to sometimes allow (subreg (mem x)), isn't
11258          implemented.  */
11259       && GET_CODE (SUBREG_REG (op0)) == REG
11260       && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
11261       && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op0))) == MODE_INT
11262       && (code == NE || code == EQ))
11263     {
11264       if (GET_MODE_SIZE (GET_MODE (op0))
11265           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0))))
11266         {
11267           op0 = SUBREG_REG (op0);
11268           op1 = gen_lowpart_for_combine (GET_MODE (op0), op1);
11269         }
11270       else if ((GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0)))
11271                 <= HOST_BITS_PER_WIDE_INT)
11272                && (nonzero_bits (SUBREG_REG (op0),
11273                                  GET_MODE (SUBREG_REG (op0)))
11274                    & ~GET_MODE_MASK (GET_MODE (op0))) == 0)
11275         {
11276           tem = gen_lowpart_for_combine (GET_MODE (SUBREG_REG (op0)), op1);
11277
11278           if ((nonzero_bits (tem, GET_MODE (SUBREG_REG (op0)))
11279                & ~GET_MODE_MASK (GET_MODE (op0))) == 0)
11280             op0 = SUBREG_REG (op0), op1 = tem;
11281         }
11282     }
11283
11284   /* We now do the opposite procedure: Some machines don't have compare
11285      insns in all modes.  If OP0's mode is an integer mode smaller than a
11286      word and we can't do a compare in that mode, see if there is a larger
11287      mode for which we can do the compare.  There are a number of cases in
11288      which we can use the wider mode.  */
11289
11290   mode = GET_MODE (op0);
11291   if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
11292       && GET_MODE_SIZE (mode) < UNITS_PER_WORD
11293       && ! have_insn_for (COMPARE, mode))
11294     for (tmode = GET_MODE_WIDER_MODE (mode);
11295          (tmode != VOIDmode
11296           && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT);
11297          tmode = GET_MODE_WIDER_MODE (tmode))
11298       if (have_insn_for (COMPARE, tmode))
11299         {
11300           int zero_extended;
11301
11302           /* If the only nonzero bits in OP0 and OP1 are those in the
11303              narrower mode and this is an equality or unsigned comparison,
11304              we can use the wider mode.  Similarly for sign-extended
11305              values, in which case it is true for all comparisons.  */
11306           zero_extended = ((code == EQ || code == NE
11307                             || code == GEU || code == GTU
11308                             || code == LEU || code == LTU)
11309                            && (nonzero_bits (op0, tmode)
11310                                & ~GET_MODE_MASK (mode)) == 0
11311                            && ((GET_CODE (op1) == CONST_INT
11312                                 || (nonzero_bits (op1, tmode)
11313                                     & ~GET_MODE_MASK (mode)) == 0)));
11314
11315           if (zero_extended
11316               || ((num_sign_bit_copies (op0, tmode)
11317                    > (unsigned int) (GET_MODE_BITSIZE (tmode)
11318                                      - GET_MODE_BITSIZE (mode)))
11319                   && (num_sign_bit_copies (op1, tmode)
11320                       > (unsigned int) (GET_MODE_BITSIZE (tmode)
11321                                         - GET_MODE_BITSIZE (mode)))))
11322             {
11323               /* If OP0 is an AND and we don't have an AND in MODE either,
11324                  make a new AND in the proper mode.  */
11325               if (GET_CODE (op0) == AND
11326                   && !have_insn_for (AND, mode))
11327                 op0 = gen_binary (AND, tmode,
11328                                   gen_lowpart_for_combine (tmode,
11329                                                            XEXP (op0, 0)),
11330                                   gen_lowpart_for_combine (tmode,
11331                                                            XEXP (op0, 1)));
11332
11333               op0 = gen_lowpart_for_combine (tmode, op0);
11334               if (zero_extended && GET_CODE (op1) == CONST_INT)
11335                 op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (mode));
11336               op1 = gen_lowpart_for_combine (tmode, op1);
11337               break;
11338             }
11339
11340           /* If this is a test for negative, we can make an explicit
11341              test of the sign bit.  */
11342
11343           if (op1 == const0_rtx && (code == LT || code == GE)
11344               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11345             {
11346               op0 = gen_binary (AND, tmode,
11347                                 gen_lowpart_for_combine (tmode, op0),
11348                                 GEN_INT ((HOST_WIDE_INT) 1
11349                                          << (GET_MODE_BITSIZE (mode) - 1)));
11350               code = (code == LT) ? NE : EQ;
11351               break;
11352             }
11353         }
11354
11355 #ifdef CANONICALIZE_COMPARISON
11356   /* If this machine only supports a subset of valid comparisons, see if we
11357      can convert an unsupported one into a supported one.  */
11358   CANONICALIZE_COMPARISON (code, op0, op1);
11359 #endif
11360
11361   *pop0 = op0;
11362   *pop1 = op1;
11363
11364   return code;
11365 }
11366 \f
11367 /* Like jump.c' reversed_comparison_code, but use combine infrastructure for
11368    searching backward.  */
11369 static enum rtx_code
11370 combine_reversed_comparison_code (rtx exp)
11371 {
11372   enum rtx_code code1 = reversed_comparison_code (exp, NULL);
11373   rtx x;
11374
11375   if (code1 != UNKNOWN
11376       || GET_MODE_CLASS (GET_MODE (XEXP (exp, 0))) != MODE_CC)
11377     return code1;
11378   /* Otherwise try and find where the condition codes were last set and
11379      use that.  */
11380   x = get_last_value (XEXP (exp, 0));
11381   if (!x || GET_CODE (x) != COMPARE)
11382     return UNKNOWN;
11383   return reversed_comparison_code_parts (GET_CODE (exp),
11384                                          XEXP (x, 0), XEXP (x, 1), NULL);
11385 }
11386
11387 /* Return comparison with reversed code of EXP and operands OP0 and OP1.
11388    Return NULL_RTX in case we fail to do the reversal.  */
11389 static rtx
11390 reversed_comparison (rtx exp, enum machine_mode mode, rtx op0, rtx op1)
11391 {
11392   enum rtx_code reversed_code = combine_reversed_comparison_code (exp);
11393   if (reversed_code == UNKNOWN)
11394     return NULL_RTX;
11395   else
11396     return gen_binary (reversed_code, mode, op0, op1);
11397 }
11398 \f
11399 /* Utility function for following routine.  Called when X is part of a value
11400    being stored into reg_last_set_value.  Sets reg_last_set_table_tick
11401    for each register mentioned.  Similar to mention_regs in cse.c  */
11402
11403 static void
11404 update_table_tick (rtx x)
11405 {
11406   enum rtx_code code = GET_CODE (x);
11407   const char *fmt = GET_RTX_FORMAT (code);
11408   int i;
11409
11410   if (code == REG)
11411     {
11412       unsigned int regno = REGNO (x);
11413       unsigned int endregno
11414         = regno + (regno < FIRST_PSEUDO_REGISTER
11415                    ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
11416       unsigned int r;
11417
11418       for (r = regno; r < endregno; r++)
11419         reg_last_set_table_tick[r] = label_tick;
11420
11421       return;
11422     }
11423
11424   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
11425     /* Note that we can't have an "E" in values stored; see
11426        get_last_value_validate.  */
11427     if (fmt[i] == 'e')
11428       {
11429         /* Check for identical subexpressions.  If x contains
11430            identical subexpression we only have to traverse one of
11431            them.  */
11432         if (i == 0
11433             && (GET_RTX_CLASS (code) == '2'
11434                 || GET_RTX_CLASS (code) == 'c'))
11435           {
11436             /* Note that at this point x1 has already been
11437                processed.  */
11438             rtx x0 = XEXP (x, 0);
11439             rtx x1 = XEXP (x, 1);
11440
11441             /* If x0 and x1 are identical then there is no need to
11442                process x0.  */
11443             if (x0 == x1)
11444               break;
11445
11446             /* If x0 is identical to a subexpression of x1 then while
11447                processing x1, x0 has already been processed.  Thus we
11448                are done with x.  */
11449             if ((GET_RTX_CLASS (GET_CODE (x1)) == '2'
11450                  || GET_RTX_CLASS (GET_CODE (x1)) == 'c')
11451                 && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
11452               break;
11453
11454             /* If x1 is identical to a subexpression of x0 then we
11455                still have to process the rest of x0.  */
11456             if ((GET_RTX_CLASS (GET_CODE (x0)) == '2'
11457                  || GET_RTX_CLASS (GET_CODE (x0)) == 'c')
11458                 && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
11459               {
11460                 update_table_tick (XEXP (x0, x1 == XEXP (x0, 0) ? 1 : 0));
11461                 break;
11462               }
11463           }
11464
11465         update_table_tick (XEXP (x, i));
11466       }
11467 }
11468
11469 /* Record that REG is set to VALUE in insn INSN.  If VALUE is zero, we
11470    are saying that the register is clobbered and we no longer know its
11471    value.  If INSN is zero, don't update reg_last_set; this is only permitted
11472    with VALUE also zero and is used to invalidate the register.  */
11473
11474 static void
11475 record_value_for_reg (rtx reg, rtx insn, rtx value)
11476 {
11477   unsigned int regno = REGNO (reg);
11478   unsigned int endregno
11479     = regno + (regno < FIRST_PSEUDO_REGISTER
11480                ? HARD_REGNO_NREGS (regno, GET_MODE (reg)) : 1);
11481   unsigned int i;
11482
11483   /* If VALUE contains REG and we have a previous value for REG, substitute
11484      the previous value.  */
11485   if (value && insn && reg_overlap_mentioned_p (reg, value))
11486     {
11487       rtx tem;
11488
11489       /* Set things up so get_last_value is allowed to see anything set up to
11490          our insn.  */
11491       subst_low_cuid = INSN_CUID (insn);
11492       tem = get_last_value (reg);
11493
11494       /* If TEM is simply a binary operation with two CLOBBERs as operands,
11495          it isn't going to be useful and will take a lot of time to process,
11496          so just use the CLOBBER.  */
11497
11498       if (tem)
11499         {
11500           if ((GET_RTX_CLASS (GET_CODE (tem)) == '2'
11501                || GET_RTX_CLASS (GET_CODE (tem)) == 'c')
11502               && GET_CODE (XEXP (tem, 0)) == CLOBBER
11503               && GET_CODE (XEXP (tem, 1)) == CLOBBER)
11504             tem = XEXP (tem, 0);
11505
11506           value = replace_rtx (copy_rtx (value), reg, tem);
11507         }
11508     }
11509
11510   /* For each register modified, show we don't know its value, that
11511      we don't know about its bitwise content, that its value has been
11512      updated, and that we don't know the location of the death of the
11513      register.  */
11514   for (i = regno; i < endregno; i++)
11515     {
11516       if (insn)
11517         reg_last_set[i] = insn;
11518
11519       reg_last_set_value[i] = 0;
11520       reg_last_set_mode[i] = 0;
11521       reg_last_set_nonzero_bits[i] = 0;
11522       reg_last_set_sign_bit_copies[i] = 0;
11523       reg_last_death[i] = 0;
11524     }
11525
11526   /* Mark registers that are being referenced in this value.  */
11527   if (value)
11528     update_table_tick (value);
11529
11530   /* Now update the status of each register being set.
11531      If someone is using this register in this block, set this register
11532      to invalid since we will get confused between the two lives in this
11533      basic block.  This makes using this register always invalid.  In cse, we
11534      scan the table to invalidate all entries using this register, but this
11535      is too much work for us.  */
11536
11537   for (i = regno; i < endregno; i++)
11538     {
11539       reg_last_set_label[i] = label_tick;
11540       if (value && reg_last_set_table_tick[i] == label_tick)
11541         reg_last_set_invalid[i] = 1;
11542       else
11543         reg_last_set_invalid[i] = 0;
11544     }
11545
11546   /* The value being assigned might refer to X (like in "x++;").  In that
11547      case, we must replace it with (clobber (const_int 0)) to prevent
11548      infinite loops.  */
11549   if (value && ! get_last_value_validate (&value, insn,
11550                                           reg_last_set_label[regno], 0))
11551     {
11552       value = copy_rtx (value);
11553       if (! get_last_value_validate (&value, insn,
11554                                      reg_last_set_label[regno], 1))
11555         value = 0;
11556     }
11557
11558   /* For the main register being modified, update the value, the mode, the
11559      nonzero bits, and the number of sign bit copies.  */
11560
11561   reg_last_set_value[regno] = value;
11562
11563   if (value)
11564     {
11565       enum machine_mode mode = GET_MODE (reg);
11566       subst_low_cuid = INSN_CUID (insn);
11567       reg_last_set_mode[regno] = mode;
11568       if (GET_MODE_CLASS (mode) == MODE_INT
11569           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11570         mode = nonzero_bits_mode;
11571       reg_last_set_nonzero_bits[regno] = nonzero_bits (value, mode);
11572       reg_last_set_sign_bit_copies[regno]
11573         = num_sign_bit_copies (value, GET_MODE (reg));
11574     }
11575 }
11576
11577 /* Called via note_stores from record_dead_and_set_regs to handle one
11578    SET or CLOBBER in an insn.  DATA is the instruction in which the
11579    set is occurring.  */
11580
11581 static void
11582 record_dead_and_set_regs_1 (rtx dest, rtx setter, void *data)
11583 {
11584   rtx record_dead_insn = (rtx) data;
11585
11586   if (GET_CODE (dest) == SUBREG)
11587     dest = SUBREG_REG (dest);
11588
11589   if (GET_CODE (dest) == REG)
11590     {
11591       /* If we are setting the whole register, we know its value.  Otherwise
11592          show that we don't know the value.  We can handle SUBREG in
11593          some cases.  */
11594       if (GET_CODE (setter) == SET && dest == SET_DEST (setter))
11595         record_value_for_reg (dest, record_dead_insn, SET_SRC (setter));
11596       else if (GET_CODE (setter) == SET
11597                && GET_CODE (SET_DEST (setter)) == SUBREG
11598                && SUBREG_REG (SET_DEST (setter)) == dest
11599                && GET_MODE_BITSIZE (GET_MODE (dest)) <= BITS_PER_WORD
11600                && subreg_lowpart_p (SET_DEST (setter)))
11601         record_value_for_reg (dest, record_dead_insn,
11602                               gen_lowpart_for_combine (GET_MODE (dest),
11603                                                        SET_SRC (setter)));
11604       else
11605         record_value_for_reg (dest, record_dead_insn, NULL_RTX);
11606     }
11607   else if (GET_CODE (dest) == MEM
11608            /* Ignore pushes, they clobber nothing.  */
11609            && ! push_operand (dest, GET_MODE (dest)))
11610     mem_last_set = INSN_CUID (record_dead_insn);
11611 }
11612
11613 /* Update the records of when each REG was most recently set or killed
11614    for the things done by INSN.  This is the last thing done in processing
11615    INSN in the combiner loop.
11616
11617    We update reg_last_set, reg_last_set_value, reg_last_set_mode,
11618    reg_last_set_nonzero_bits, reg_last_set_sign_bit_copies, reg_last_death,
11619    and also the similar information mem_last_set (which insn most recently
11620    modified memory) and last_call_cuid (which insn was the most recent
11621    subroutine call).  */
11622
11623 static void
11624 record_dead_and_set_regs (rtx insn)
11625 {
11626   rtx link;
11627   unsigned int i;
11628
11629   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
11630     {
11631       if (REG_NOTE_KIND (link) == REG_DEAD
11632           && GET_CODE (XEXP (link, 0)) == REG)
11633         {
11634           unsigned int regno = REGNO (XEXP (link, 0));
11635           unsigned int endregno
11636             = regno + (regno < FIRST_PSEUDO_REGISTER
11637                        ? HARD_REGNO_NREGS (regno, GET_MODE (XEXP (link, 0)))
11638                        : 1);
11639
11640           for (i = regno; i < endregno; i++)
11641             reg_last_death[i] = insn;
11642         }
11643       else if (REG_NOTE_KIND (link) == REG_INC)
11644         record_value_for_reg (XEXP (link, 0), insn, NULL_RTX);
11645     }
11646
11647   if (GET_CODE (insn) == CALL_INSN)
11648     {
11649       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
11650         if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
11651           {
11652             reg_last_set_value[i] = 0;
11653             reg_last_set_mode[i] = 0;
11654             reg_last_set_nonzero_bits[i] = 0;
11655             reg_last_set_sign_bit_copies[i] = 0;
11656             reg_last_death[i] = 0;
11657           }
11658
11659       last_call_cuid = mem_last_set = INSN_CUID (insn);
11660
11661       /* Don't bother recording what this insn does.  It might set the
11662          return value register, but we can't combine into a call
11663          pattern anyway, so there's no point trying (and it may cause
11664          a crash, if e.g. we wind up asking for last_set_value of a
11665          SUBREG of the return value register).  */
11666       return;
11667     }
11668
11669   note_stores (PATTERN (insn), record_dead_and_set_regs_1, insn);
11670 }
11671
11672 /* If a SUBREG has the promoted bit set, it is in fact a property of the
11673    register present in the SUBREG, so for each such SUBREG go back and
11674    adjust nonzero and sign bit information of the registers that are
11675    known to have some zero/sign bits set.
11676
11677    This is needed because when combine blows the SUBREGs away, the
11678    information on zero/sign bits is lost and further combines can be
11679    missed because of that.  */
11680
11681 static void
11682 record_promoted_value (rtx insn, rtx subreg)
11683 {
11684   rtx links, set;
11685   unsigned int regno = REGNO (SUBREG_REG (subreg));
11686   enum machine_mode mode = GET_MODE (subreg);
11687
11688   if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
11689     return;
11690
11691   for (links = LOG_LINKS (insn); links;)
11692     {
11693       insn = XEXP (links, 0);
11694       set = single_set (insn);
11695
11696       if (! set || GET_CODE (SET_DEST (set)) != REG
11697           || REGNO (SET_DEST (set)) != regno
11698           || GET_MODE (SET_DEST (set)) != GET_MODE (SUBREG_REG (subreg)))
11699         {
11700           links = XEXP (links, 1);
11701           continue;
11702         }
11703
11704       if (reg_last_set[regno] == insn)
11705         {
11706           if (SUBREG_PROMOTED_UNSIGNED_P (subreg) > 0)
11707             reg_last_set_nonzero_bits[regno] &= GET_MODE_MASK (mode);
11708         }
11709
11710       if (GET_CODE (SET_SRC (set)) == REG)
11711         {
11712           regno = REGNO (SET_SRC (set));
11713           links = LOG_LINKS (insn);
11714         }
11715       else
11716         break;
11717     }
11718 }
11719
11720 /* Scan X for promoted SUBREGs.  For each one found,
11721    note what it implies to the registers used in it.  */
11722
11723 static void
11724 check_promoted_subreg (rtx insn, rtx x)
11725 {
11726   if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
11727       && GET_CODE (SUBREG_REG (x)) == REG)
11728     record_promoted_value (insn, x);
11729   else
11730     {
11731       const char *format = GET_RTX_FORMAT (GET_CODE (x));
11732       int i, j;
11733
11734       for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
11735         switch (format[i])
11736           {
11737           case 'e':
11738             check_promoted_subreg (insn, XEXP (x, i));
11739             break;
11740           case 'V':
11741           case 'E':
11742             if (XVEC (x, i) != 0)
11743               for (j = 0; j < XVECLEN (x, i); j++)
11744                 check_promoted_subreg (insn, XVECEXP (x, i, j));
11745             break;
11746           }
11747     }
11748 }
11749 \f
11750 /* Utility routine for the following function.  Verify that all the registers
11751    mentioned in *LOC are valid when *LOC was part of a value set when
11752    label_tick == TICK.  Return 0 if some are not.
11753
11754    If REPLACE is nonzero, replace the invalid reference with
11755    (clobber (const_int 0)) and return 1.  This replacement is useful because
11756    we often can get useful information about the form of a value (e.g., if
11757    it was produced by a shift that always produces -1 or 0) even though
11758    we don't know exactly what registers it was produced from.  */
11759
11760 static int
11761 get_last_value_validate (rtx *loc, rtx insn, int tick, int replace)
11762 {
11763   rtx x = *loc;
11764   const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
11765   int len = GET_RTX_LENGTH (GET_CODE (x));
11766   int i;
11767
11768   if (GET_CODE (x) == REG)
11769     {
11770       unsigned int regno = REGNO (x);
11771       unsigned int endregno
11772         = regno + (regno < FIRST_PSEUDO_REGISTER
11773                    ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
11774       unsigned int j;
11775
11776       for (j = regno; j < endregno; j++)
11777         if (reg_last_set_invalid[j]
11778             /* If this is a pseudo-register that was only set once and not
11779                live at the beginning of the function, it is always valid.  */
11780             || (! (regno >= FIRST_PSEUDO_REGISTER
11781                    && REG_N_SETS (regno) == 1
11782                    && (! REGNO_REG_SET_P
11783                        (ENTRY_BLOCK_PTR->next_bb->global_live_at_start, regno)))
11784                 && reg_last_set_label[j] > tick))
11785           {
11786             if (replace)
11787               *loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
11788             return replace;
11789           }
11790
11791       return 1;
11792     }
11793   /* If this is a memory reference, make sure that there were
11794      no stores after it that might have clobbered the value.  We don't
11795      have alias info, so we assume any store invalidates it.  */
11796   else if (GET_CODE (x) == MEM && ! RTX_UNCHANGING_P (x)
11797            && INSN_CUID (insn) <= mem_last_set)
11798     {
11799       if (replace)
11800         *loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
11801       return replace;
11802     }
11803
11804   for (i = 0; i < len; i++)
11805     {
11806       if (fmt[i] == 'e')
11807         {
11808           /* Check for identical subexpressions.  If x contains
11809              identical subexpression we only have to traverse one of
11810              them.  */
11811           if (i == 1
11812               && (GET_RTX_CLASS (GET_CODE (x)) == '2'
11813                   || GET_RTX_CLASS (GET_CODE (x)) == 'c'))
11814             {
11815               /* Note that at this point x0 has already been checked
11816                  and found valid.  */
11817               rtx x0 = XEXP (x, 0);
11818               rtx x1 = XEXP (x, 1);
11819
11820               /* If x0 and x1 are identical then x is also valid.  */
11821               if (x0 == x1)
11822                 return 1;
11823
11824               /* If x1 is identical to a subexpression of x0 then
11825                  while checking x0, x1 has already been checked.  Thus
11826                  it is valid and so as x.  */
11827               if ((GET_RTX_CLASS (GET_CODE (x0)) == '2'
11828                    || GET_RTX_CLASS (GET_CODE (x0)) == 'c')
11829                   && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
11830                 return 1;
11831
11832               /* If x0 is identical to a subexpression of x1 then x is
11833                  valid iff the rest of x1 is valid.  */
11834               if ((GET_RTX_CLASS (GET_CODE (x1)) == '2'
11835                    || GET_RTX_CLASS (GET_CODE (x1)) == 'c')
11836                   && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
11837                 return
11838                   get_last_value_validate (&XEXP (x1,
11839                                                   x0 == XEXP (x1, 0) ? 1 : 0),
11840                                            insn, tick, replace);
11841             }
11842
11843           if (get_last_value_validate (&XEXP (x, i), insn, tick,
11844                                        replace) == 0)
11845             return 0;
11846         }
11847       /* Don't bother with these.  They shouldn't occur anyway.  */
11848       else if (fmt[i] == 'E')
11849         return 0;
11850     }
11851
11852   /* If we haven't found a reason for it to be invalid, it is valid.  */
11853   return 1;
11854 }
11855
11856 /* Get the last value assigned to X, if known.  Some registers
11857    in the value may be replaced with (clobber (const_int 0)) if their value
11858    is known longer known reliably.  */
11859
11860 static rtx
11861 get_last_value (rtx x)
11862 {
11863   unsigned int regno;
11864   rtx value;
11865
11866   /* If this is a non-paradoxical SUBREG, get the value of its operand and
11867      then convert it to the desired mode.  If this is a paradoxical SUBREG,
11868      we cannot predict what values the "extra" bits might have.  */
11869   if (GET_CODE (x) == SUBREG
11870       && subreg_lowpart_p (x)
11871       && (GET_MODE_SIZE (GET_MODE (x))
11872           <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
11873       && (value = get_last_value (SUBREG_REG (x))) != 0)
11874     return gen_lowpart_for_combine (GET_MODE (x), value);
11875
11876   if (GET_CODE (x) != REG)
11877     return 0;
11878
11879   regno = REGNO (x);
11880   value = reg_last_set_value[regno];
11881
11882   /* If we don't have a value, or if it isn't for this basic block and
11883      it's either a hard register, set more than once, or it's a live
11884      at the beginning of the function, return 0.
11885
11886      Because if it's not live at the beginning of the function then the reg
11887      is always set before being used (is never used without being set).
11888      And, if it's set only once, and it's always set before use, then all
11889      uses must have the same last value, even if it's not from this basic
11890      block.  */
11891
11892   if (value == 0
11893       || (reg_last_set_label[regno] != label_tick
11894           && (regno < FIRST_PSEUDO_REGISTER
11895               || REG_N_SETS (regno) != 1
11896               || (REGNO_REG_SET_P
11897                   (ENTRY_BLOCK_PTR->next_bb->global_live_at_start, regno)))))
11898     return 0;
11899
11900   /* If the value was set in a later insn than the ones we are processing,
11901      we can't use it even if the register was only set once.  */
11902   if (INSN_CUID (reg_last_set[regno]) >= subst_low_cuid)
11903     return 0;
11904
11905   /* If the value has all its registers valid, return it.  */
11906   if (get_last_value_validate (&value, reg_last_set[regno],
11907                                reg_last_set_label[regno], 0))
11908     return value;
11909
11910   /* Otherwise, make a copy and replace any invalid register with
11911      (clobber (const_int 0)).  If that fails for some reason, return 0.  */
11912
11913   value = copy_rtx (value);
11914   if (get_last_value_validate (&value, reg_last_set[regno],
11915                                reg_last_set_label[regno], 1))
11916     return value;
11917
11918   return 0;
11919 }
11920 \f
11921 /* Return nonzero if expression X refers to a REG or to memory
11922    that is set in an instruction more recent than FROM_CUID.  */
11923
11924 static int
11925 use_crosses_set_p (rtx x, int from_cuid)
11926 {
11927   const char *fmt;
11928   int i;
11929   enum rtx_code code = GET_CODE (x);
11930
11931   if (code == REG)
11932     {
11933       unsigned int regno = REGNO (x);
11934       unsigned endreg = regno + (regno < FIRST_PSEUDO_REGISTER
11935                                  ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
11936
11937 #ifdef PUSH_ROUNDING
11938       /* Don't allow uses of the stack pointer to be moved,
11939          because we don't know whether the move crosses a push insn.  */
11940       if (regno == STACK_POINTER_REGNUM && PUSH_ARGS)
11941         return 1;
11942 #endif
11943       for (; regno < endreg; regno++)
11944         if (reg_last_set[regno]
11945             && INSN_CUID (reg_last_set[regno]) > from_cuid)
11946           return 1;
11947       return 0;
11948     }
11949
11950   if (code == MEM && mem_last_set > from_cuid)
11951     return 1;
11952
11953   fmt = GET_RTX_FORMAT (code);
11954
11955   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
11956     {
11957       if (fmt[i] == 'E')
11958         {
11959           int j;
11960           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
11961             if (use_crosses_set_p (XVECEXP (x, i, j), from_cuid))
11962               return 1;
11963         }
11964       else if (fmt[i] == 'e'
11965                && use_crosses_set_p (XEXP (x, i), from_cuid))
11966         return 1;
11967     }
11968   return 0;
11969 }
11970 \f
11971 /* Define three variables used for communication between the following
11972    routines.  */
11973
11974 static unsigned int reg_dead_regno, reg_dead_endregno;
11975 static int reg_dead_flag;
11976
11977 /* Function called via note_stores from reg_dead_at_p.
11978
11979    If DEST is within [reg_dead_regno, reg_dead_endregno), set
11980    reg_dead_flag to 1 if X is a CLOBBER and to -1 it is a SET.  */
11981
11982 static void
11983 reg_dead_at_p_1 (rtx dest, rtx x, void *data ATTRIBUTE_UNUSED)
11984 {
11985   unsigned int regno, endregno;
11986
11987   if (GET_CODE (dest) != REG)
11988     return;
11989
11990   regno = REGNO (dest);
11991   endregno = regno + (regno < FIRST_PSEUDO_REGISTER
11992                       ? HARD_REGNO_NREGS (regno, GET_MODE (dest)) : 1);
11993
11994   if (reg_dead_endregno > regno && reg_dead_regno < endregno)
11995     reg_dead_flag = (GET_CODE (x) == CLOBBER) ? 1 : -1;
11996 }
11997
11998 /* Return nonzero if REG is known to be dead at INSN.
11999
12000    We scan backwards from INSN.  If we hit a REG_DEAD note or a CLOBBER
12001    referencing REG, it is dead.  If we hit a SET referencing REG, it is
12002    live.  Otherwise, see if it is live or dead at the start of the basic
12003    block we are in.  Hard regs marked as being live in NEWPAT_USED_REGS
12004    must be assumed to be always live.  */
12005
12006 static int
12007 reg_dead_at_p (rtx reg, rtx insn)
12008 {
12009   basic_block block;
12010   unsigned int i;
12011
12012   /* Set variables for reg_dead_at_p_1.  */
12013   reg_dead_regno = REGNO (reg);
12014   reg_dead_endregno = reg_dead_regno + (reg_dead_regno < FIRST_PSEUDO_REGISTER
12015                                         ? HARD_REGNO_NREGS (reg_dead_regno,
12016                                                             GET_MODE (reg))
12017                                         : 1);
12018
12019   reg_dead_flag = 0;
12020
12021   /* Check that reg isn't mentioned in NEWPAT_USED_REGS.  */
12022   if (reg_dead_regno < FIRST_PSEUDO_REGISTER)
12023     {
12024       for (i = reg_dead_regno; i < reg_dead_endregno; i++)
12025         if (TEST_HARD_REG_BIT (newpat_used_regs, i))
12026           return 0;
12027     }
12028
12029   /* Scan backwards until we find a REG_DEAD note, SET, CLOBBER, label, or
12030      beginning of function.  */
12031   for (; insn && GET_CODE (insn) != CODE_LABEL && GET_CODE (insn) != BARRIER;
12032        insn = prev_nonnote_insn (insn))
12033     {
12034       note_stores (PATTERN (insn), reg_dead_at_p_1, NULL);
12035       if (reg_dead_flag)
12036         return reg_dead_flag == 1 ? 1 : 0;
12037
12038       if (find_regno_note (insn, REG_DEAD, reg_dead_regno))
12039         return 1;
12040     }
12041
12042   /* Get the basic block that we were in.  */
12043   if (insn == 0)
12044     block = ENTRY_BLOCK_PTR->next_bb;
12045   else
12046     {
12047       FOR_EACH_BB (block)
12048         if (insn == block->head)
12049           break;
12050
12051       if (block == EXIT_BLOCK_PTR)
12052         return 0;
12053     }
12054
12055   for (i = reg_dead_regno; i < reg_dead_endregno; i++)
12056     if (REGNO_REG_SET_P (block->global_live_at_start, i))
12057       return 0;
12058
12059   return 1;
12060 }
12061 \f
12062 /* Note hard registers in X that are used.  This code is similar to
12063    that in flow.c, but much simpler since we don't care about pseudos.  */
12064
12065 static void
12066 mark_used_regs_combine (rtx x)
12067 {
12068   RTX_CODE code = GET_CODE (x);
12069   unsigned int regno;
12070   int i;
12071
12072   switch (code)
12073     {
12074     case LABEL_REF:
12075     case SYMBOL_REF:
12076     case CONST_INT:
12077     case CONST:
12078     case CONST_DOUBLE:
12079     case CONST_VECTOR:
12080     case PC:
12081     case ADDR_VEC:
12082     case ADDR_DIFF_VEC:
12083     case ASM_INPUT:
12084 #ifdef HAVE_cc0
12085     /* CC0 must die in the insn after it is set, so we don't need to take
12086        special note of it here.  */
12087     case CC0:
12088 #endif
12089       return;
12090
12091     case CLOBBER:
12092       /* If we are clobbering a MEM, mark any hard registers inside the
12093          address as used.  */
12094       if (GET_CODE (XEXP (x, 0)) == MEM)
12095         mark_used_regs_combine (XEXP (XEXP (x, 0), 0));
12096       return;
12097
12098     case REG:
12099       regno = REGNO (x);
12100       /* A hard reg in a wide mode may really be multiple registers.
12101          If so, mark all of them just like the first.  */
12102       if (regno < FIRST_PSEUDO_REGISTER)
12103         {
12104           unsigned int endregno, r;
12105
12106           /* None of this applies to the stack, frame or arg pointers.  */
12107           if (regno == STACK_POINTER_REGNUM
12108 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
12109               || regno == HARD_FRAME_POINTER_REGNUM
12110 #endif
12111 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
12112               || (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
12113 #endif
12114               || regno == FRAME_POINTER_REGNUM)
12115             return;
12116
12117           endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
12118           for (r = regno; r < endregno; r++)
12119             SET_HARD_REG_BIT (newpat_used_regs, r);
12120         }
12121       return;
12122
12123     case SET:
12124       {
12125         /* If setting a MEM, or a SUBREG of a MEM, then note any hard regs in
12126            the address.  */
12127         rtx testreg = SET_DEST (x);
12128
12129         while (GET_CODE (testreg) == SUBREG
12130                || GET_CODE (testreg) == ZERO_EXTRACT
12131                || GET_CODE (testreg) == SIGN_EXTRACT
12132                || GET_CODE (testreg) == STRICT_LOW_PART)
12133           testreg = XEXP (testreg, 0);
12134
12135         if (GET_CODE (testreg) == MEM)
12136           mark_used_regs_combine (XEXP (testreg, 0));
12137
12138         mark_used_regs_combine (SET_SRC (x));
12139       }
12140       return;
12141
12142     default:
12143       break;
12144     }
12145
12146   /* Recursively scan the operands of this expression.  */
12147
12148   {
12149     const char *fmt = GET_RTX_FORMAT (code);
12150
12151     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12152       {
12153         if (fmt[i] == 'e')
12154           mark_used_regs_combine (XEXP (x, i));
12155         else if (fmt[i] == 'E')
12156           {
12157             int j;
12158
12159             for (j = 0; j < XVECLEN (x, i); j++)
12160               mark_used_regs_combine (XVECEXP (x, i, j));
12161           }
12162       }
12163   }
12164 }
12165 \f
12166 /* Remove register number REGNO from the dead registers list of INSN.
12167
12168    Return the note used to record the death, if there was one.  */
12169
12170 rtx
12171 remove_death (unsigned int regno, rtx insn)
12172 {
12173   rtx note = find_regno_note (insn, REG_DEAD, regno);
12174
12175   if (note)
12176     {
12177       REG_N_DEATHS (regno)--;
12178       remove_note (insn, note);
12179     }
12180
12181   return note;
12182 }
12183
12184 /* For each register (hardware or pseudo) used within expression X, if its
12185    death is in an instruction with cuid between FROM_CUID (inclusive) and
12186    TO_INSN (exclusive), put a REG_DEAD note for that register in the
12187    list headed by PNOTES.
12188
12189    That said, don't move registers killed by maybe_kill_insn.
12190
12191    This is done when X is being merged by combination into TO_INSN.  These
12192    notes will then be distributed as needed.  */
12193
12194 static void
12195 move_deaths (rtx x, rtx maybe_kill_insn, int from_cuid, rtx to_insn,
12196              rtx *pnotes)
12197 {
12198   const char *fmt;
12199   int len, i;
12200   enum rtx_code code = GET_CODE (x);
12201
12202   if (code == REG)
12203     {
12204       unsigned int regno = REGNO (x);
12205       rtx where_dead = reg_last_death[regno];
12206       rtx before_dead, after_dead;
12207
12208       /* Don't move the register if it gets killed in between from and to.  */
12209       if (maybe_kill_insn && reg_set_p (x, maybe_kill_insn)
12210           && ! reg_referenced_p (x, maybe_kill_insn))
12211         return;
12212
12213       /* WHERE_DEAD could be a USE insn made by combine, so first we
12214          make sure that we have insns with valid INSN_CUID values.  */
12215       before_dead = where_dead;
12216       while (before_dead && INSN_UID (before_dead) > max_uid_cuid)
12217         before_dead = PREV_INSN (before_dead);
12218
12219       after_dead = where_dead;
12220       while (after_dead && INSN_UID (after_dead) > max_uid_cuid)
12221         after_dead = NEXT_INSN (after_dead);
12222
12223       if (before_dead && after_dead
12224           && INSN_CUID (before_dead) >= from_cuid
12225           && (INSN_CUID (after_dead) < INSN_CUID (to_insn)
12226               || (where_dead != after_dead
12227                   && INSN_CUID (after_dead) == INSN_CUID (to_insn))))
12228         {
12229           rtx note = remove_death (regno, where_dead);
12230
12231           /* It is possible for the call above to return 0.  This can occur
12232              when reg_last_death points to I2 or I1 that we combined with.
12233              In that case make a new note.
12234
12235              We must also check for the case where X is a hard register
12236              and NOTE is a death note for a range of hard registers
12237              including X.  In that case, we must put REG_DEAD notes for
12238              the remaining registers in place of NOTE.  */
12239
12240           if (note != 0 && regno < FIRST_PSEUDO_REGISTER
12241               && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
12242                   > GET_MODE_SIZE (GET_MODE (x))))
12243             {
12244               unsigned int deadregno = REGNO (XEXP (note, 0));
12245               unsigned int deadend
12246                 = (deadregno + HARD_REGNO_NREGS (deadregno,
12247                                                  GET_MODE (XEXP (note, 0))));
12248               unsigned int ourend
12249                 = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
12250               unsigned int i;
12251
12252               for (i = deadregno; i < deadend; i++)
12253                 if (i < regno || i >= ourend)
12254                   REG_NOTES (where_dead)
12255                     = gen_rtx_EXPR_LIST (REG_DEAD,
12256                                          regno_reg_rtx[i],
12257                                          REG_NOTES (where_dead));
12258             }
12259
12260           /* If we didn't find any note, or if we found a REG_DEAD note that
12261              covers only part of the given reg, and we have a multi-reg hard
12262              register, then to be safe we must check for REG_DEAD notes
12263              for each register other than the first.  They could have
12264              their own REG_DEAD notes lying around.  */
12265           else if ((note == 0
12266                     || (note != 0
12267                         && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
12268                             < GET_MODE_SIZE (GET_MODE (x)))))
12269                    && regno < FIRST_PSEUDO_REGISTER
12270                    && HARD_REGNO_NREGS (regno, GET_MODE (x)) > 1)
12271             {
12272               unsigned int ourend
12273                 = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
12274               unsigned int i, offset;
12275               rtx oldnotes = 0;
12276
12277               if (note)
12278                 offset = HARD_REGNO_NREGS (regno, GET_MODE (XEXP (note, 0)));
12279               else
12280                 offset = 1;
12281
12282               for (i = regno + offset; i < ourend; i++)
12283                 move_deaths (regno_reg_rtx[i],
12284                              maybe_kill_insn, from_cuid, to_insn, &oldnotes);
12285             }
12286
12287           if (note != 0 && GET_MODE (XEXP (note, 0)) == GET_MODE (x))
12288             {
12289               XEXP (note, 1) = *pnotes;
12290               *pnotes = note;
12291             }
12292           else
12293             *pnotes = gen_rtx_EXPR_LIST (REG_DEAD, x, *pnotes);
12294
12295           REG_N_DEATHS (regno)++;
12296         }
12297
12298       return;
12299     }
12300
12301   else if (GET_CODE (x) == SET)
12302     {
12303       rtx dest = SET_DEST (x);
12304
12305       move_deaths (SET_SRC (x), maybe_kill_insn, from_cuid, to_insn, pnotes);
12306
12307       /* In the case of a ZERO_EXTRACT, a STRICT_LOW_PART, or a SUBREG
12308          that accesses one word of a multi-word item, some
12309          piece of everything register in the expression is used by
12310          this insn, so remove any old death.  */
12311       /* ??? So why do we test for equality of the sizes?  */
12312
12313       if (GET_CODE (dest) == ZERO_EXTRACT
12314           || GET_CODE (dest) == STRICT_LOW_PART
12315           || (GET_CODE (dest) == SUBREG
12316               && (((GET_MODE_SIZE (GET_MODE (dest))
12317                     + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
12318                   == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
12319                        + UNITS_PER_WORD - 1) / UNITS_PER_WORD))))
12320         {
12321           move_deaths (dest, maybe_kill_insn, from_cuid, to_insn, pnotes);
12322           return;
12323         }
12324
12325       /* If this is some other SUBREG, we know it replaces the entire
12326          value, so use that as the destination.  */
12327       if (GET_CODE (dest) == SUBREG)
12328         dest = SUBREG_REG (dest);
12329
12330       /* If this is a MEM, adjust deaths of anything used in the address.
12331          For a REG (the only other possibility), the entire value is
12332          being replaced so the old value is not used in this insn.  */
12333
12334       if (GET_CODE (dest) == MEM)
12335         move_deaths (XEXP (dest, 0), maybe_kill_insn, from_cuid,
12336                      to_insn, pnotes);
12337       return;
12338     }
12339
12340   else if (GET_CODE (x) == CLOBBER)
12341     return;
12342
12343   len = GET_RTX_LENGTH (code);
12344   fmt = GET_RTX_FORMAT (code);
12345
12346   for (i = 0; i < len; i++)
12347     {
12348       if (fmt[i] == 'E')
12349         {
12350           int j;
12351           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
12352             move_deaths (XVECEXP (x, i, j), maybe_kill_insn, from_cuid,
12353                          to_insn, pnotes);
12354         }
12355       else if (fmt[i] == 'e')
12356         move_deaths (XEXP (x, i), maybe_kill_insn, from_cuid, to_insn, pnotes);
12357     }
12358 }
12359 \f
12360 /* Return 1 if X is the target of a bit-field assignment in BODY, the
12361    pattern of an insn.  X must be a REG.  */
12362
12363 static int
12364 reg_bitfield_target_p (rtx x, rtx body)
12365 {
12366   int i;
12367
12368   if (GET_CODE (body) == SET)
12369     {
12370       rtx dest = SET_DEST (body);
12371       rtx target;
12372       unsigned int regno, tregno, endregno, endtregno;
12373
12374       if (GET_CODE (dest) == ZERO_EXTRACT)
12375         target = XEXP (dest, 0);
12376       else if (GET_CODE (dest) == STRICT_LOW_PART)
12377         target = SUBREG_REG (XEXP (dest, 0));
12378       else
12379         return 0;
12380
12381       if (GET_CODE (target) == SUBREG)
12382         target = SUBREG_REG (target);
12383
12384       if (GET_CODE (target) != REG)
12385         return 0;
12386
12387       tregno = REGNO (target), regno = REGNO (x);
12388       if (tregno >= FIRST_PSEUDO_REGISTER || regno >= FIRST_PSEUDO_REGISTER)
12389         return target == x;
12390
12391       endtregno = tregno + HARD_REGNO_NREGS (tregno, GET_MODE (target));
12392       endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
12393
12394       return endregno > tregno && regno < endtregno;
12395     }
12396
12397   else if (GET_CODE (body) == PARALLEL)
12398     for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
12399       if (reg_bitfield_target_p (x, XVECEXP (body, 0, i)))
12400         return 1;
12401
12402   return 0;
12403 }
12404 \f
12405 /* Given a chain of REG_NOTES originally from FROM_INSN, try to place them
12406    as appropriate.  I3 and I2 are the insns resulting from the combination
12407    insns including FROM (I2 may be zero).
12408
12409    Each note in the list is either ignored or placed on some insns, depending
12410    on the type of note.  */
12411
12412 static void
12413 distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2)
12414 {
12415   rtx note, next_note;
12416   rtx tem;
12417
12418   for (note = notes; note; note = next_note)
12419     {
12420       rtx place = 0, place2 = 0;
12421
12422       /* If this NOTE references a pseudo register, ensure it references
12423          the latest copy of that register.  */
12424       if (XEXP (note, 0) && GET_CODE (XEXP (note, 0)) == REG
12425           && REGNO (XEXP (note, 0)) >= FIRST_PSEUDO_REGISTER)
12426         XEXP (note, 0) = regno_reg_rtx[REGNO (XEXP (note, 0))];
12427
12428       next_note = XEXP (note, 1);
12429       switch (REG_NOTE_KIND (note))
12430         {
12431         case REG_BR_PROB:
12432         case REG_BR_PRED:
12433           /* Doesn't matter much where we put this, as long as it's somewhere.
12434              It is preferable to keep these notes on branches, which is most
12435              likely to be i3.  */
12436           place = i3;
12437           break;
12438
12439         case REG_VTABLE_REF:
12440           /* ??? Should remain with *a particular* memory load.  Given the
12441              nature of vtable data, the last insn seems relatively safe.  */
12442           place = i3;
12443           break;
12444
12445         case REG_NON_LOCAL_GOTO:
12446           if (GET_CODE (i3) == JUMP_INSN)
12447             place = i3;
12448           else if (i2 && GET_CODE (i2) == JUMP_INSN)
12449             place = i2;
12450           else
12451             abort ();
12452           break;
12453
12454         case REG_EH_REGION:
12455           /* These notes must remain with the call or trapping instruction.  */
12456           if (GET_CODE (i3) == CALL_INSN)
12457             place = i3;
12458           else if (i2 && GET_CODE (i2) == CALL_INSN)
12459             place = i2;
12460           else if (flag_non_call_exceptions)
12461             {
12462               if (may_trap_p (i3))
12463                 place = i3;
12464               else if (i2 && may_trap_p (i2))
12465                 place = i2;
12466               /* ??? Otherwise assume we've combined things such that we
12467                  can now prove that the instructions can't trap.  Drop the
12468                  note in this case.  */
12469             }
12470           else
12471             abort ();
12472           break;
12473
12474         case REG_NORETURN:
12475         case REG_SETJMP:
12476           /* These notes must remain with the call.  It should not be
12477              possible for both I2 and I3 to be a call.  */
12478           if (GET_CODE (i3) == CALL_INSN)
12479             place = i3;
12480           else if (i2 && GET_CODE (i2) == CALL_INSN)
12481             place = i2;
12482           else
12483             abort ();
12484           break;
12485
12486         case REG_UNUSED:
12487           /* Any clobbers for i3 may still exist, and so we must process
12488              REG_UNUSED notes from that insn.
12489
12490              Any clobbers from i2 or i1 can only exist if they were added by
12491              recog_for_combine.  In that case, recog_for_combine created the
12492              necessary REG_UNUSED notes.  Trying to keep any original
12493              REG_UNUSED notes from these insns can cause incorrect output
12494              if it is for the same register as the original i3 dest.
12495              In that case, we will notice that the register is set in i3,
12496              and then add a REG_UNUSED note for the destination of i3, which
12497              is wrong.  However, it is possible to have REG_UNUSED notes from
12498              i2 or i1 for register which were both used and clobbered, so
12499              we keep notes from i2 or i1 if they will turn into REG_DEAD
12500              notes.  */
12501
12502           /* If this register is set or clobbered in I3, put the note there
12503              unless there is one already.  */
12504           if (reg_set_p (XEXP (note, 0), PATTERN (i3)))
12505             {
12506               if (from_insn != i3)
12507                 break;
12508
12509               if (! (GET_CODE (XEXP (note, 0)) == REG
12510                      ? find_regno_note (i3, REG_UNUSED, REGNO (XEXP (note, 0)))
12511                      : find_reg_note (i3, REG_UNUSED, XEXP (note, 0))))
12512                 place = i3;
12513             }
12514           /* Otherwise, if this register is used by I3, then this register
12515              now dies here, so we must put a REG_DEAD note here unless there
12516              is one already.  */
12517           else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3))
12518                    && ! (GET_CODE (XEXP (note, 0)) == REG
12519                          ? find_regno_note (i3, REG_DEAD,
12520                                             REGNO (XEXP (note, 0)))
12521                          : find_reg_note (i3, REG_DEAD, XEXP (note, 0))))
12522             {
12523               PUT_REG_NOTE_KIND (note, REG_DEAD);
12524               place = i3;
12525             }
12526           break;
12527
12528         case REG_EQUAL:
12529         case REG_EQUIV:
12530         case REG_NOALIAS:
12531           /* These notes say something about results of an insn.  We can
12532              only support them if they used to be on I3 in which case they
12533              remain on I3.  Otherwise they are ignored.
12534
12535              If the note refers to an expression that is not a constant, we
12536              must also ignore the note since we cannot tell whether the
12537              equivalence is still true.  It might be possible to do
12538              slightly better than this (we only have a problem if I2DEST
12539              or I1DEST is present in the expression), but it doesn't
12540              seem worth the trouble.  */
12541
12542           if (from_insn == i3
12543               && (XEXP (note, 0) == 0 || CONSTANT_P (XEXP (note, 0))))
12544             place = i3;
12545           break;
12546
12547         case REG_INC:
12548         case REG_NO_CONFLICT:
12549           /* These notes say something about how a register is used.  They must
12550              be present on any use of the register in I2 or I3.  */
12551           if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3)))
12552             place = i3;
12553
12554           if (i2 && reg_mentioned_p (XEXP (note, 0), PATTERN (i2)))
12555             {
12556               if (place)
12557                 place2 = i2;
12558               else
12559                 place = i2;
12560             }
12561           break;
12562
12563         case REG_LABEL:
12564           /* This can show up in several ways -- either directly in the
12565              pattern, or hidden off in the constant pool with (or without?)
12566              a REG_EQUAL note.  */
12567           /* ??? Ignore the without-reg_equal-note problem for now.  */
12568           if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3))
12569               || ((tem = find_reg_note (i3, REG_EQUAL, NULL_RTX))
12570                   && GET_CODE (XEXP (tem, 0)) == LABEL_REF
12571                   && XEXP (XEXP (tem, 0), 0) == XEXP (note, 0)))
12572             place = i3;
12573
12574           if (i2
12575               && (reg_mentioned_p (XEXP (note, 0), PATTERN (i2))
12576                   || ((tem = find_reg_note (i2, REG_EQUAL, NULL_RTX))
12577                       && GET_CODE (XEXP (tem, 0)) == LABEL_REF
12578                       && XEXP (XEXP (tem, 0), 0) == XEXP (note, 0))))
12579             {
12580               if (place)
12581                 place2 = i2;
12582               else
12583                 place = i2;
12584             }
12585
12586           /* Don't attach REG_LABEL note to a JUMP_INSN which has
12587              JUMP_LABEL already.  Instead, decrement LABEL_NUSES.  */
12588           if (place && GET_CODE (place) == JUMP_INSN && JUMP_LABEL (place))
12589             {
12590               if (JUMP_LABEL (place) != XEXP (note, 0))
12591                 abort ();
12592               if (GET_CODE (JUMP_LABEL (place)) == CODE_LABEL)
12593                 LABEL_NUSES (JUMP_LABEL (place))--;
12594               place = 0;
12595             }
12596           if (place2 && GET_CODE (place2) == JUMP_INSN && JUMP_LABEL (place2))
12597             {
12598               if (JUMP_LABEL (place2) != XEXP (note, 0))
12599                 abort ();
12600               if (GET_CODE (JUMP_LABEL (place2)) == CODE_LABEL)
12601                 LABEL_NUSES (JUMP_LABEL (place2))--;
12602               place2 = 0;
12603             }
12604           break;
12605
12606         case REG_NONNEG:
12607         case REG_WAS_0:
12608           /* These notes say something about the value of a register prior
12609              to the execution of an insn.  It is too much trouble to see
12610              if the note is still correct in all situations.  It is better
12611              to simply delete it.  */
12612           break;
12613
12614         case REG_RETVAL:
12615           /* If the insn previously containing this note still exists,
12616              put it back where it was.  Otherwise move it to the previous
12617              insn.  Adjust the corresponding REG_LIBCALL note.  */
12618           if (GET_CODE (from_insn) != NOTE)
12619             place = from_insn;
12620           else
12621             {
12622               tem = find_reg_note (XEXP (note, 0), REG_LIBCALL, NULL_RTX);
12623               place = prev_real_insn (from_insn);
12624               if (tem && place)
12625                 XEXP (tem, 0) = place;
12626               /* If we're deleting the last remaining instruction of a
12627                  libcall sequence, don't add the notes.  */
12628               else if (XEXP (note, 0) == from_insn)
12629                 tem = place = 0;
12630             }
12631           break;
12632
12633         case REG_LIBCALL:
12634           /* This is handled similarly to REG_RETVAL.  */
12635           if (GET_CODE (from_insn) != NOTE)
12636             place = from_insn;
12637           else
12638             {
12639               tem = find_reg_note (XEXP (note, 0), REG_RETVAL, NULL_RTX);
12640               place = next_real_insn (from_insn);
12641               if (tem && place)
12642                 XEXP (tem, 0) = place;
12643               /* If we're deleting the last remaining instruction of a
12644                  libcall sequence, don't add the notes.  */
12645               else if (XEXP (note, 0) == from_insn)
12646                 tem = place = 0;
12647             }
12648           break;
12649
12650         case REG_DEAD:
12651           /* If the register is used as an input in I3, it dies there.
12652              Similarly for I2, if it is nonzero and adjacent to I3.
12653
12654              If the register is not used as an input in either I3 or I2
12655              and it is not one of the registers we were supposed to eliminate,
12656              there are two possibilities.  We might have a non-adjacent I2
12657              or we might have somehow eliminated an additional register
12658              from a computation.  For example, we might have had A & B where
12659              we discover that B will always be zero.  In this case we will
12660              eliminate the reference to A.
12661
12662              In both cases, we must search to see if we can find a previous
12663              use of A and put the death note there.  */
12664
12665           if (from_insn
12666               && GET_CODE (from_insn) == CALL_INSN
12667               && find_reg_fusage (from_insn, USE, XEXP (note, 0)))
12668             place = from_insn;
12669           else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3)))
12670             place = i3;
12671           else if (i2 != 0 && next_nonnote_insn (i2) == i3
12672                    && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
12673             place = i2;
12674
12675           if (place == 0)
12676             {
12677               basic_block bb = this_basic_block;
12678
12679               for (tem = PREV_INSN (i3); place == 0; tem = PREV_INSN (tem))
12680                 {
12681                   if (! INSN_P (tem))
12682                     {
12683                       if (tem == bb->head)
12684                         break;
12685                       continue;
12686                     }
12687
12688                   /* If the register is being set at TEM, see if that is all
12689                      TEM is doing.  If so, delete TEM.  Otherwise, make this
12690                      into a REG_UNUSED note instead.  */
12691                   if (reg_set_p (XEXP (note, 0), PATTERN (tem)))
12692                     {
12693                       rtx set = single_set (tem);
12694                       rtx inner_dest = 0;
12695 #ifdef HAVE_cc0
12696                       rtx cc0_setter = NULL_RTX;
12697 #endif
12698
12699                       if (set != 0)
12700                         for (inner_dest = SET_DEST (set);
12701                              (GET_CODE (inner_dest) == STRICT_LOW_PART
12702                               || GET_CODE (inner_dest) == SUBREG
12703                               || GET_CODE (inner_dest) == ZERO_EXTRACT);
12704                              inner_dest = XEXP (inner_dest, 0))
12705                           ;
12706
12707                       /* Verify that it was the set, and not a clobber that
12708                          modified the register.
12709
12710                          CC0 targets must be careful to maintain setter/user
12711                          pairs.  If we cannot delete the setter due to side
12712                          effects, mark the user with an UNUSED note instead
12713                          of deleting it.  */
12714
12715                       if (set != 0 && ! side_effects_p (SET_SRC (set))
12716                           && rtx_equal_p (XEXP (note, 0), inner_dest)
12717 #ifdef HAVE_cc0
12718                           && (! reg_mentioned_p (cc0_rtx, SET_SRC (set))
12719                               || ((cc0_setter = prev_cc0_setter (tem)) != NULL
12720                                   && sets_cc0_p (PATTERN (cc0_setter)) > 0))
12721 #endif
12722                           )
12723                         {
12724                           /* Move the notes and links of TEM elsewhere.
12725                              This might delete other dead insns recursively.
12726                              First set the pattern to something that won't use
12727                              any register.  */
12728
12729                           PATTERN (tem) = pc_rtx;
12730
12731                           distribute_notes (REG_NOTES (tem), tem, tem,
12732                                             NULL_RTX);
12733                           distribute_links (LOG_LINKS (tem));
12734
12735                           PUT_CODE (tem, NOTE);
12736                           NOTE_LINE_NUMBER (tem) = NOTE_INSN_DELETED;
12737                           NOTE_SOURCE_FILE (tem) = 0;
12738
12739 #ifdef HAVE_cc0
12740                           /* Delete the setter too.  */
12741                           if (cc0_setter)
12742                             {
12743                               PATTERN (cc0_setter) = pc_rtx;
12744
12745                               distribute_notes (REG_NOTES (cc0_setter),
12746                                                 cc0_setter, cc0_setter,
12747                                                 NULL_RTX);
12748                               distribute_links (LOG_LINKS (cc0_setter));
12749
12750                               PUT_CODE (cc0_setter, NOTE);
12751                               NOTE_LINE_NUMBER (cc0_setter)
12752                                 = NOTE_INSN_DELETED;
12753                               NOTE_SOURCE_FILE (cc0_setter) = 0;
12754                             }
12755 #endif
12756                         }
12757                       /* If the register is both set and used here, put the
12758                          REG_DEAD note here, but place a REG_UNUSED note
12759                          here too unless there already is one.  */
12760                       else if (reg_referenced_p (XEXP (note, 0),
12761                                                  PATTERN (tem)))
12762                         {
12763                           place = tem;
12764
12765                           if (! find_regno_note (tem, REG_UNUSED,
12766                                                  REGNO (XEXP (note, 0))))
12767                             REG_NOTES (tem)
12768                               = gen_rtx_EXPR_LIST (REG_UNUSED, XEXP (note, 0),
12769                                                    REG_NOTES (tem));
12770                         }
12771                       else
12772                         {
12773                           PUT_REG_NOTE_KIND (note, REG_UNUSED);
12774
12775                           /*  If there isn't already a REG_UNUSED note, put one
12776                               here.  */
12777                           if (! find_regno_note (tem, REG_UNUSED,
12778                                                  REGNO (XEXP (note, 0))))
12779                             place = tem;
12780                           break;
12781                         }
12782                     }
12783                   else if (reg_referenced_p (XEXP (note, 0), PATTERN (tem))
12784                            || (GET_CODE (tem) == CALL_INSN
12785                                && find_reg_fusage (tem, USE, XEXP (note, 0))))
12786                     {
12787                       place = tem;
12788
12789                       /* If we are doing a 3->2 combination, and we have a
12790                          register which formerly died in i3 and was not used
12791                          by i2, which now no longer dies in i3 and is used in
12792                          i2 but does not die in i2, and place is between i2
12793                          and i3, then we may need to move a link from place to
12794                          i2.  */
12795                       if (i2 && INSN_UID (place) <= max_uid_cuid
12796                           && INSN_CUID (place) > INSN_CUID (i2)
12797                           && from_insn
12798                           && INSN_CUID (from_insn) > INSN_CUID (i2)
12799                           && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
12800                         {
12801                           rtx links = LOG_LINKS (place);
12802                           LOG_LINKS (place) = 0;
12803                           distribute_links (links);
12804                         }
12805                       break;
12806                     }
12807
12808                   if (tem == bb->head)
12809                     break;
12810                 }
12811
12812               /* We haven't found an insn for the death note and it
12813                  is still a REG_DEAD note, but we have hit the beginning
12814                  of the block.  If the existing life info says the reg
12815                  was dead, there's nothing left to do.  Otherwise, we'll
12816                  need to do a global life update after combine.  */
12817               if (REG_NOTE_KIND (note) == REG_DEAD && place == 0
12818                   && REGNO_REG_SET_P (bb->global_live_at_start,
12819                                       REGNO (XEXP (note, 0))))
12820                 SET_BIT (refresh_blocks, this_basic_block->index);
12821             }
12822
12823           /* If the register is set or already dead at PLACE, we needn't do
12824              anything with this note if it is still a REG_DEAD note.
12825              We can here if it is set at all, not if is it totally replace,
12826              which is what `dead_or_set_p' checks, so also check for it being
12827              set partially.  */
12828
12829           if (place && REG_NOTE_KIND (note) == REG_DEAD)
12830             {
12831               unsigned int regno = REGNO (XEXP (note, 0));
12832
12833               /* Similarly, if the instruction on which we want to place
12834                  the note is a noop, we'll need do a global live update
12835                  after we remove them in delete_noop_moves.  */
12836               if (noop_move_p (place))
12837                 SET_BIT (refresh_blocks, this_basic_block->index);
12838
12839               if (dead_or_set_p (place, XEXP (note, 0))
12840                   || reg_bitfield_target_p (XEXP (note, 0), PATTERN (place)))
12841                 {
12842                   /* Unless the register previously died in PLACE, clear
12843                      reg_last_death.  [I no longer understand why this is
12844                      being done.] */
12845                   if (reg_last_death[regno] != place)
12846                     reg_last_death[regno] = 0;
12847                   place = 0;
12848                 }
12849               else
12850                 reg_last_death[regno] = place;
12851
12852               /* If this is a death note for a hard reg that is occupying
12853                  multiple registers, ensure that we are still using all
12854                  parts of the object.  If we find a piece of the object
12855                  that is unused, we must arrange for an appropriate REG_DEAD
12856                  note to be added for it.  However, we can't just emit a USE
12857                  and tag the note to it, since the register might actually
12858                  be dead; so we recourse, and the recursive call then finds
12859                  the previous insn that used this register.  */
12860
12861               if (place && regno < FIRST_PSEUDO_REGISTER
12862                   && HARD_REGNO_NREGS (regno, GET_MODE (XEXP (note, 0))) > 1)
12863                 {
12864                   unsigned int endregno
12865                     = regno + HARD_REGNO_NREGS (regno,
12866                                                 GET_MODE (XEXP (note, 0)));
12867                   int all_used = 1;
12868                   unsigned int i;
12869
12870                   for (i = regno; i < endregno; i++)
12871                     if ((! refers_to_regno_p (i, i + 1, PATTERN (place), 0)
12872                          && ! find_regno_fusage (place, USE, i))
12873                         || dead_or_set_regno_p (place, i))
12874                       all_used = 0;
12875
12876                   if (! all_used)
12877                     {
12878                       /* Put only REG_DEAD notes for pieces that are
12879                          not already dead or set.  */
12880
12881                       for (i = regno; i < endregno;
12882                            i += HARD_REGNO_NREGS (i, reg_raw_mode[i]))
12883                         {
12884                           rtx piece = regno_reg_rtx[i];
12885                           basic_block bb = this_basic_block;
12886
12887                           if (! dead_or_set_p (place, piece)
12888                               && ! reg_bitfield_target_p (piece,
12889                                                           PATTERN (place)))
12890                             {
12891                               rtx new_note
12892                                 = gen_rtx_EXPR_LIST (REG_DEAD, piece, NULL_RTX);
12893
12894                               distribute_notes (new_note, place, place,
12895                                                 NULL_RTX);
12896                             }
12897                           else if (! refers_to_regno_p (i, i + 1,
12898                                                         PATTERN (place), 0)
12899                                    && ! find_regno_fusage (place, USE, i))
12900                             for (tem = PREV_INSN (place); ;
12901                                  tem = PREV_INSN (tem))
12902                               {
12903                                 if (! INSN_P (tem))
12904                                   {
12905                                     if (tem == bb->head)
12906                                       {
12907                                         SET_BIT (refresh_blocks,
12908                                                  this_basic_block->index);
12909                                         break;
12910                                       }
12911                                     continue;
12912                                   }
12913                                 if (dead_or_set_p (tem, piece)
12914                                     || reg_bitfield_target_p (piece,
12915                                                               PATTERN (tem)))
12916                                   {
12917                                     REG_NOTES (tem)
12918                                       = gen_rtx_EXPR_LIST (REG_UNUSED, piece,
12919                                                            REG_NOTES (tem));
12920                                     break;
12921                                   }
12922                               }
12923
12924                         }
12925
12926                       place = 0;
12927                     }
12928                 }
12929             }
12930           break;
12931
12932         default:
12933           /* Any other notes should not be present at this point in the
12934              compilation.  */
12935           abort ();
12936         }
12937
12938       if (place)
12939         {
12940           XEXP (note, 1) = REG_NOTES (place);
12941           REG_NOTES (place) = note;
12942         }
12943       else if ((REG_NOTE_KIND (note) == REG_DEAD
12944                 || REG_NOTE_KIND (note) == REG_UNUSED)
12945                && GET_CODE (XEXP (note, 0)) == REG)
12946         REG_N_DEATHS (REGNO (XEXP (note, 0)))--;
12947
12948       if (place2)
12949         {
12950           if ((REG_NOTE_KIND (note) == REG_DEAD
12951                || REG_NOTE_KIND (note) == REG_UNUSED)
12952               && GET_CODE (XEXP (note, 0)) == REG)
12953             REG_N_DEATHS (REGNO (XEXP (note, 0)))++;
12954
12955           REG_NOTES (place2) = gen_rtx_fmt_ee (GET_CODE (note),
12956                                                REG_NOTE_KIND (note),
12957                                                XEXP (note, 0),
12958                                                REG_NOTES (place2));
12959         }
12960     }
12961 }
12962 \f
12963 /* Similarly to above, distribute the LOG_LINKS that used to be present on
12964    I3, I2, and I1 to new locations.  This is also called in one case to
12965    add a link pointing at I3 when I3's destination is changed.  */
12966
12967 static void
12968 distribute_links (rtx links)
12969 {
12970   rtx link, next_link;
12971
12972   for (link = links; link; link = next_link)
12973     {
12974       rtx place = 0;
12975       rtx insn;
12976       rtx set, reg;
12977
12978       next_link = XEXP (link, 1);
12979
12980       /* If the insn that this link points to is a NOTE or isn't a single
12981          set, ignore it.  In the latter case, it isn't clear what we
12982          can do other than ignore the link, since we can't tell which
12983          register it was for.  Such links wouldn't be used by combine
12984          anyway.
12985
12986          It is not possible for the destination of the target of the link to
12987          have been changed by combine.  The only potential of this is if we
12988          replace I3, I2, and I1 by I3 and I2.  But in that case the
12989          destination of I2 also remains unchanged.  */
12990
12991       if (GET_CODE (XEXP (link, 0)) == NOTE
12992           || (set = single_set (XEXP (link, 0))) == 0)
12993         continue;
12994
12995       reg = SET_DEST (set);
12996       while (GET_CODE (reg) == SUBREG || GET_CODE (reg) == ZERO_EXTRACT
12997              || GET_CODE (reg) == SIGN_EXTRACT
12998              || GET_CODE (reg) == STRICT_LOW_PART)
12999         reg = XEXP (reg, 0);
13000
13001       /* A LOG_LINK is defined as being placed on the first insn that uses
13002          a register and points to the insn that sets the register.  Start
13003          searching at the next insn after the target of the link and stop
13004          when we reach a set of the register or the end of the basic block.
13005
13006          Note that this correctly handles the link that used to point from
13007          I3 to I2.  Also note that not much searching is typically done here
13008          since most links don't point very far away.  */
13009
13010       for (insn = NEXT_INSN (XEXP (link, 0));
13011            (insn && (this_basic_block->next_bb == EXIT_BLOCK_PTR
13012                      || this_basic_block->next_bb->head != insn));
13013            insn = NEXT_INSN (insn))
13014         if (INSN_P (insn) && reg_overlap_mentioned_p (reg, PATTERN (insn)))
13015           {
13016             if (reg_referenced_p (reg, PATTERN (insn)))
13017               place = insn;
13018             break;
13019           }
13020         else if (GET_CODE (insn) == CALL_INSN
13021                  && find_reg_fusage (insn, USE, reg))
13022           {
13023             place = insn;
13024             break;
13025           }
13026
13027       /* If we found a place to put the link, place it there unless there
13028          is already a link to the same insn as LINK at that point.  */
13029
13030       if (place)
13031         {
13032           rtx link2;
13033
13034           for (link2 = LOG_LINKS (place); link2; link2 = XEXP (link2, 1))
13035             if (XEXP (link2, 0) == XEXP (link, 0))
13036               break;
13037
13038           if (link2 == 0)
13039             {
13040               XEXP (link, 1) = LOG_LINKS (place);
13041               LOG_LINKS (place) = link;
13042
13043               /* Set added_links_insn to the earliest insn we added a
13044                  link to.  */
13045               if (added_links_insn == 0
13046                   || INSN_CUID (added_links_insn) > INSN_CUID (place))
13047                 added_links_insn = place;
13048             }
13049         }
13050     }
13051 }
13052 \f
13053 /* Compute INSN_CUID for INSN, which is an insn made by combine.  */
13054
13055 static int
13056 insn_cuid (rtx insn)
13057 {
13058   while (insn != 0 && INSN_UID (insn) > max_uid_cuid
13059          && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == USE)
13060     insn = NEXT_INSN (insn);
13061
13062   if (INSN_UID (insn) > max_uid_cuid)
13063     abort ();
13064
13065   return INSN_CUID (insn);
13066 }
13067 \f
13068 void
13069 dump_combine_stats (FILE *file)
13070 {
13071   fnotice
13072     (file,
13073      ";; Combiner statistics: %d attempts, %d substitutions (%d requiring new space),\n;; %d successes.\n\n",
13074      combine_attempts, combine_merges, combine_extras, combine_successes);
13075 }
13076
13077 void
13078 dump_combine_total_stats (FILE *file)
13079 {
13080   fnotice
13081     (file,
13082      "\n;; Combiner totals: %d attempts, %d substitutions (%d requiring new space),\n;; %d successes.\n",
13083      total_attempts, total_merges, total_extras, total_successes);
13084 }