2004-05-12 Paolo Bonzini <bonzini@gnu.org>
[gcc/gcc.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, 2004 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 "tree.h"
79 #include "tm_p.h"
80 #include "flags.h"
81 #include "regs.h"
82 #include "hard-reg-set.h"
83 #include "basic-block.h"
84 #include "insn-config.h"
85 #include "function.h"
86 /* Include expr.h after insn-config.h so we get HAVE_conditional_move.  */
87 #include "expr.h"
88 #include "insn-attr.h"
89 #include "recog.h"
90 #include "real.h"
91 #include "toplev.h"
92 #include "target.h"
93
94 /* Number of attempts to combine instructions in this function.  */
95
96 static int combine_attempts;
97
98 /* Number of attempts that got as far as substitution in this function.  */
99
100 static int combine_merges;
101
102 /* Number of instructions combined with added SETs in this function.  */
103
104 static int combine_extras;
105
106 /* Number of instructions combined in this function.  */
107
108 static int combine_successes;
109
110 /* Totals over entire compilation.  */
111
112 static int total_attempts, total_merges, total_extras, total_successes;
113
114 \f
115 /* Vector mapping INSN_UIDs to cuids.
116    The cuids are like uids but increase monotonically always.
117    Combine always uses cuids so that it can compare them.
118    But actually renumbering the uids, which we used to do,
119    proves to be a bad idea because it makes it hard to compare
120    the dumps produced by earlier passes with those from later passes.  */
121
122 static int *uid_cuid;
123 static int max_uid_cuid;
124
125 /* Get the cuid of an insn.  */
126
127 #define INSN_CUID(INSN) \
128 (INSN_UID (INSN) > max_uid_cuid ? insn_cuid (INSN) : uid_cuid[INSN_UID (INSN)])
129
130 /* In case BITS_PER_WORD == HOST_BITS_PER_WIDE_INT, shifting by
131    BITS_PER_WORD would invoke undefined behavior.  Work around it.  */
132
133 #define UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD(val) \
134   (((unsigned HOST_WIDE_INT) (val) << (BITS_PER_WORD - 1)) << 1)
135
136 #define nonzero_bits(X, M) \
137   cached_nonzero_bits (X, M, NULL_RTX, VOIDmode, 0)
138
139 #define num_sign_bit_copies(X, M) \
140   cached_num_sign_bit_copies (X, M, NULL_RTX, VOIDmode, 0)
141
142 /* Maximum register number, which is the size of the tables below.  */
143
144 static unsigned int combine_max_regno;
145
146 struct reg_stat {
147   /* Record last point of death of (hard or pseudo) register n.  */
148   rtx                           last_death;
149
150   /* Record last point of modification of (hard or pseudo) register n.  */
151   rtx                           last_set;
152
153   /* The next group of fields allows the recording of the last value assigned
154      to (hard or pseudo) register n.  We use this information to see if an
155      operation being processed is redundant given a prior operation performed
156      on the register.  For example, an `and' with a constant is redundant if
157      all the zero bits are already known to be turned off.
158
159      We use an approach similar to that used by cse, but change it in the
160      following ways:
161
162      (1) We do not want to reinitialize at each label.
163      (2) It is useful, but not critical, to know the actual value assigned
164          to a register.  Often just its form is helpful.
165
166      Therefore, we maintain the following fields:
167
168      last_set_value             the last value assigned
169      last_set_label             records the value of label_tick when the
170                                 register was assigned
171      last_set_table_tick        records the value of label_tick when a
172                                 value using the register is assigned
173      last_set_invalid           set to nonzero when it is not valid
174                                 to use the value of this register in some
175                                 register's value
176
177      To understand the usage of these tables, it is important to understand
178      the distinction between the value in last_set_value being valid and
179      the register being validly contained in some other expression in the
180      table.
181
182      (The next two parameters are out of date).
183
184      reg_stat[i].last_set_value is valid if it is nonzero, and either
185      reg_n_sets[i] is 1 or reg_stat[i].last_set_label == label_tick.
186
187      Register I may validly appear in any expression returned for the value
188      of another register if reg_n_sets[i] is 1.  It may also appear in the
189      value for register J if reg_stat[j].last_set_invalid is zero, or
190      reg_stat[i].last_set_label < reg_stat[j].last_set_label.
191
192      If an expression is found in the table containing a register which may
193      not validly appear in an expression, the register is replaced by
194      something that won't match, (clobber (const_int 0)).  */
195
196   /* Record last value assigned to (hard or pseudo) register n.  */
197
198   rtx                           last_set_value;
199
200   /* Record the value of label_tick when an expression involving register n
201      is placed in last_set_value.  */
202
203   int                           last_set_table_tick;
204
205   /* Record the value of label_tick when the value for register n is placed in
206      last_set_value.  */
207
208   int                           last_set_label;
209
210   /* These fields are maintained in parallel with last_set_value and are
211      used to store the mode in which the register was last set, te bits
212      that were known to be zero when it was last set, and the number of
213      sign bits copies it was known to have when it was last set.  */
214
215   unsigned HOST_WIDE_INT        last_set_nonzero_bits;
216   char                          last_set_sign_bit_copies;
217   ENUM_BITFIELD(machine_mode)   last_set_mode : 8; 
218
219   /* Set nonzero if references to register n in expressions should not be
220      used.  last_set_invalid is set nonzero when this register is being
221      assigned to and last_set_table_tick == label_tick.  */
222
223   char                          last_set_invalid;
224
225   /* Some registers that are set more than once and used in more than one
226      basic block are nevertheless always set in similar ways.  For example,
227      a QImode register may be loaded from memory in two places on a machine
228      where byte loads zero extend.
229
230      We record in the following fields if a register has some leading bits
231      that are always equal to the sign bit, and what we know about the
232      nonzero bits of a register, specifically which bits are known to be
233      zero.
234
235      If an entry is zero, it means that we don't know anything special.  */
236
237   unsigned char                 sign_bit_copies;
238
239   unsigned HOST_WIDE_INT        nonzero_bits;
240 };
241
242 static struct reg_stat *reg_stat;
243
244 /* Record the cuid of the last insn that invalidated memory
245    (anything that writes memory, and subroutine calls, but not pushes).  */
246
247 static int mem_last_set;
248
249 /* Record the cuid of the last CALL_INSN
250    so we can tell whether a potential combination crosses any calls.  */
251
252 static int last_call_cuid;
253
254 /* When `subst' is called, this is the insn that is being modified
255    (by combining in a previous insn).  The PATTERN of this insn
256    is still the old pattern partially modified and it should not be
257    looked at, but this may be used to examine the successors of the insn
258    to judge whether a simplification is valid.  */
259
260 static rtx subst_insn;
261
262 /* This is the lowest CUID that `subst' is currently dealing with.
263    get_last_value will not return a value if the register was set at or
264    after this CUID.  If not for this mechanism, we could get confused if
265    I2 or I1 in try_combine were an insn that used the old value of a register
266    to obtain a new value.  In that case, we might erroneously get the
267    new value of the register when we wanted the old one.  */
268
269 static int subst_low_cuid;
270
271 /* This contains any hard registers that are used in newpat; reg_dead_at_p
272    must consider all these registers to be always live.  */
273
274 static HARD_REG_SET newpat_used_regs;
275
276 /* This is an insn to which a LOG_LINKS entry has been added.  If this
277    insn is the earlier than I2 or I3, combine should rescan starting at
278    that location.  */
279
280 static rtx added_links_insn;
281
282 /* Basic block in which we are performing combines.  */
283 static basic_block this_basic_block;
284
285 /* A bitmap indicating which blocks had registers go dead at entry.
286    After combine, we'll need to re-do global life analysis with
287    those blocks as starting points.  */
288 static sbitmap refresh_blocks;
289 \f
290 /* Incremented for each label.  */
291
292 static int label_tick;
293
294 /* Mode used to compute significance in reg_stat[].nonzero_bits.  It is the
295    largest integer mode that can fit in HOST_BITS_PER_WIDE_INT.  */
296
297 static enum machine_mode nonzero_bits_mode;
298
299 /* Nonzero when reg_stat[].nonzero_bits and reg_stat[].sign_bit_copies can
300    be safely used.  It is zero while computing them and after combine has
301    completed.  This former test prevents propagating values based on
302    previously set values, which can be incorrect if a variable is modified
303    in a loop.  */
304
305 static int nonzero_sign_valid;
306
307 \f
308 /* Record one modification to rtl structure
309    to be undone by storing old_contents into *where.
310    is_int is 1 if the contents are an int.  */
311
312 struct undo
313 {
314   struct undo *next;
315   int is_int;
316   union {rtx r; int i;} old_contents;
317   union {rtx *r; int *i;} where;
318 };
319
320 /* Record a bunch of changes to be undone, up to MAX_UNDO of them.
321    num_undo says how many are currently recorded.
322
323    other_insn is nonzero if we have modified some other insn in the process
324    of working on subst_insn.  It must be verified too.  */
325
326 struct undobuf
327 {
328   struct undo *undos;
329   struct undo *frees;
330   rtx other_insn;
331 };
332
333 static struct undobuf undobuf;
334
335 /* Number of times the pseudo being substituted for
336    was found and replaced.  */
337
338 static int n_occurrences;
339
340 static void do_SUBST (rtx *, rtx);
341 static void do_SUBST_INT (int *, int);
342 static void init_reg_last (void);
343 static void setup_incoming_promotions (void);
344 static void set_nonzero_bits_and_sign_copies (rtx, rtx, void *);
345 static int cant_combine_insn_p (rtx);
346 static int can_combine_p (rtx, rtx, rtx, rtx, rtx *, 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);
355 static rtx simplify_if_then_else (rtx);
356 static rtx simplify_set (rtx);
357 static rtx simplify_logical (rtx);
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 static int unmentioned_reg_p_1 (rtx *, void *);
414 static bool unmentioned_reg_p (rtx, rtx);
415 \f
416 /* Substitute NEWVAL, an rtx expression, into INTO, a place in some
417    insn.  The substitution can be undone by undo_all.  If INTO is already
418    set to NEWVAL, do not record this change.  Because computing NEWVAL might
419    also call SUBST, we have to compute it before we put anything into
420    the undo table.  */
421
422 static void
423 do_SUBST (rtx *into, rtx newval)
424 {
425   struct undo *buf;
426   rtx oldval = *into;
427
428   if (oldval == newval)
429     return;
430
431   /* We'd like to catch as many invalid transformations here as
432      possible.  Unfortunately, there are way too many mode changes
433      that are perfectly valid, so we'd waste too much effort for
434      little gain doing the checks here.  Focus on catching invalid
435      transformations involving integer constants.  */
436   if (GET_MODE_CLASS (GET_MODE (oldval)) == MODE_INT
437       && GET_CODE (newval) == CONST_INT)
438     {
439       /* Sanity check that we're replacing oldval with a CONST_INT
440          that is a valid sign-extension for the original mode.  */
441       if (INTVAL (newval) != trunc_int_for_mode (INTVAL (newval),
442                                                  GET_MODE (oldval)))
443         abort ();
444
445       /* Replacing the operand of a SUBREG or a ZERO_EXTEND with a
446          CONST_INT is not valid, because after the replacement, the
447          original mode would be gone.  Unfortunately, we can't tell
448          when do_SUBST is called to replace the operand thereof, so we
449          perform this test on oldval instead, checking whether an
450          invalid replacement took place before we got here.  */
451       if ((GET_CODE (oldval) == SUBREG
452            && GET_CODE (SUBREG_REG (oldval)) == CONST_INT)
453           || (GET_CODE (oldval) == ZERO_EXTEND
454               && GET_CODE (XEXP (oldval, 0)) == CONST_INT))
455         abort ();
456     }
457
458   if (undobuf.frees)
459     buf = undobuf.frees, undobuf.frees = buf->next;
460   else
461     buf = xmalloc (sizeof (struct undo));
462
463   buf->is_int = 0;
464   buf->where.r = into;
465   buf->old_contents.r = oldval;
466   *into = newval;
467
468   buf->next = undobuf.undos, undobuf.undos = buf;
469 }
470
471 #define SUBST(INTO, NEWVAL)     do_SUBST(&(INTO), (NEWVAL))
472
473 /* Similar to SUBST, but NEWVAL is an int expression.  Note that substitution
474    for the value of a HOST_WIDE_INT value (including CONST_INT) is
475    not safe.  */
476
477 static void
478 do_SUBST_INT (int *into, int newval)
479 {
480   struct undo *buf;
481   int oldval = *into;
482
483   if (oldval == newval)
484     return;
485
486   if (undobuf.frees)
487     buf = undobuf.frees, undobuf.frees = buf->next;
488   else
489     buf = xmalloc (sizeof (struct undo));
490
491   buf->is_int = 1;
492   buf->where.i = into;
493   buf->old_contents.i = oldval;
494   *into = newval;
495
496   buf->next = undobuf.undos, undobuf.undos = buf;
497 }
498
499 #define SUBST_INT(INTO, NEWVAL)  do_SUBST_INT(&(INTO), (NEWVAL))
500 \f
501 /* Main entry point for combiner.  F is the first insn of the function.
502    NREGS is the first unused pseudo-reg number.
503
504    Return nonzero if the combiner has turned an indirect jump
505    instruction into a direct jump.  */
506 int
507 combine_instructions (rtx f, unsigned int nregs)
508 {
509   rtx insn, next;
510 #ifdef HAVE_cc0
511   rtx prev;
512 #endif
513   int i;
514   rtx links, nextlinks;
515
516   int new_direct_jump_p = 0;
517
518   combine_attempts = 0;
519   combine_merges = 0;
520   combine_extras = 0;
521   combine_successes = 0;
522
523   combine_max_regno = nregs;
524
525   /* It is not safe to use ordinary gen_lowpart in combine.
526      See comments in gen_lowpart_for_combine.  */
527   gen_lowpart = gen_lowpart_for_combine;
528
529   reg_stat = xcalloc (nregs, sizeof (struct reg_stat));
530
531   init_recog_no_volatile ();
532
533   /* Compute maximum uid value so uid_cuid can be allocated.  */
534
535   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
536     if (INSN_UID (insn) > i)
537       i = INSN_UID (insn);
538
539   uid_cuid = xmalloc ((i + 1) * sizeof (int));
540   max_uid_cuid = i;
541
542   nonzero_bits_mode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
543
544   /* Don't use reg_stat[].nonzero_bits when computing it.  This can cause
545      problems when, for example, we have j <<= 1 in a loop.  */
546
547   nonzero_sign_valid = 0;
548
549   /* Compute the mapping from uids to cuids.
550      Cuids are numbers assigned to insns, like uids,
551      except that cuids increase monotonically through the code.
552
553      Scan all SETs and see if we can deduce anything about what
554      bits are known to be zero for some registers and how many copies
555      of the sign bit are known to exist for those registers.
556
557      Also set any known values so that we can use it while searching
558      for what bits are known to be set.  */
559
560   label_tick = 1;
561
562   setup_incoming_promotions ();
563
564   refresh_blocks = sbitmap_alloc (last_basic_block);
565   sbitmap_zero (refresh_blocks);
566
567   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
568     {
569       uid_cuid[INSN_UID (insn)] = ++i;
570       subst_low_cuid = i;
571       subst_insn = insn;
572
573       if (INSN_P (insn))
574         {
575           note_stores (PATTERN (insn), set_nonzero_bits_and_sign_copies,
576                        NULL);
577           record_dead_and_set_regs (insn);
578
579 #ifdef AUTO_INC_DEC
580           for (links = REG_NOTES (insn); links; links = XEXP (links, 1))
581             if (REG_NOTE_KIND (links) == REG_INC)
582               set_nonzero_bits_and_sign_copies (XEXP (links, 0), NULL_RTX,
583                                                 NULL);
584 #endif
585         }
586
587       if (GET_CODE (insn) == CODE_LABEL)
588         label_tick++;
589     }
590
591   nonzero_sign_valid = 1;
592
593   /* Now scan all the insns in forward order.  */
594
595   label_tick = 1;
596   last_call_cuid = 0;
597   mem_last_set = 0;
598   init_reg_last ();
599   setup_incoming_promotions ();
600
601   FOR_EACH_BB (this_basic_block)
602     {
603       for (insn = BB_HEAD (this_basic_block);
604            insn != NEXT_INSN (BB_END (this_basic_block));
605            insn = next ? next : NEXT_INSN (insn))
606         {
607           next = 0;
608
609           if (GET_CODE (insn) == CODE_LABEL)
610             label_tick++;
611
612           else if (INSN_P (insn))
613             {
614               /* See if we know about function return values before this
615                  insn based upon SUBREG flags.  */
616               check_promoted_subreg (insn, PATTERN (insn));
617
618               /* Try this insn with each insn it links back to.  */
619
620               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
621                 if ((next = try_combine (insn, XEXP (links, 0),
622                                          NULL_RTX, &new_direct_jump_p)) != 0)
623                   goto retry;
624
625               /* Try each sequence of three linked insns ending with this one.  */
626
627               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
628                 {
629                   rtx link = XEXP (links, 0);
630
631                   /* If the linked insn has been replaced by a note, then there
632                      is no point in pursuing this chain any further.  */
633                   if (GET_CODE (link) == NOTE)
634                     continue;
635
636                   for (nextlinks = LOG_LINKS (link);
637                        nextlinks;
638                        nextlinks = XEXP (nextlinks, 1))
639                     if ((next = try_combine (insn, link,
640                                              XEXP (nextlinks, 0),
641                                              &new_direct_jump_p)) != 0)
642                       goto retry;
643                 }
644
645 #ifdef HAVE_cc0
646               /* Try to combine a jump insn that uses CC0
647                  with a preceding insn that sets CC0, and maybe with its
648                  logical predecessor as well.
649                  This is how we make decrement-and-branch insns.
650                  We need this special code because data flow connections
651                  via CC0 do not get entered in LOG_LINKS.  */
652
653               if (GET_CODE (insn) == JUMP_INSN
654                   && (prev = prev_nonnote_insn (insn)) != 0
655                   && GET_CODE (prev) == INSN
656                   && sets_cc0_p (PATTERN (prev)))
657                 {
658                   if ((next = try_combine (insn, prev,
659                                            NULL_RTX, &new_direct_jump_p)) != 0)
660                     goto retry;
661
662                   for (nextlinks = LOG_LINKS (prev); nextlinks;
663                        nextlinks = XEXP (nextlinks, 1))
664                     if ((next = try_combine (insn, prev,
665                                              XEXP (nextlinks, 0),
666                                              &new_direct_jump_p)) != 0)
667                       goto retry;
668                 }
669
670               /* Do the same for an insn that explicitly references CC0.  */
671               if (GET_CODE (insn) == INSN
672                   && (prev = prev_nonnote_insn (insn)) != 0
673                   && GET_CODE (prev) == INSN
674                   && sets_cc0_p (PATTERN (prev))
675                   && GET_CODE (PATTERN (insn)) == SET
676                   && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (insn))))
677                 {
678                   if ((next = try_combine (insn, prev,
679                                            NULL_RTX, &new_direct_jump_p)) != 0)
680                     goto retry;
681
682                   for (nextlinks = LOG_LINKS (prev); nextlinks;
683                        nextlinks = XEXP (nextlinks, 1))
684                     if ((next = try_combine (insn, prev,
685                                              XEXP (nextlinks, 0),
686                                              &new_direct_jump_p)) != 0)
687                       goto retry;
688                 }
689
690               /* Finally, see if any of the insns that this insn links to
691                  explicitly references CC0.  If so, try this insn, that insn,
692                  and its predecessor if it sets CC0.  */
693               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
694                 if (GET_CODE (XEXP (links, 0)) == INSN
695                     && GET_CODE (PATTERN (XEXP (links, 0))) == SET
696                     && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (XEXP (links, 0))))
697                     && (prev = prev_nonnote_insn (XEXP (links, 0))) != 0
698                     && GET_CODE (prev) == INSN
699                     && sets_cc0_p (PATTERN (prev))
700                     && (next = try_combine (insn, XEXP (links, 0),
701                                             prev, &new_direct_jump_p)) != 0)
702                   goto retry;
703 #endif
704
705               /* Try combining an insn with two different insns whose results it
706                  uses.  */
707               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
708                 for (nextlinks = XEXP (links, 1); nextlinks;
709                      nextlinks = XEXP (nextlinks, 1))
710                   if ((next = try_combine (insn, XEXP (links, 0),
711                                            XEXP (nextlinks, 0),
712                                            &new_direct_jump_p)) != 0)
713                     goto retry;
714
715               /* Try this insn with each REG_EQUAL note it links back to.  */
716               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
717                 {
718                   rtx set, note;
719                   rtx temp = XEXP (links, 0);
720                   if ((set = single_set (temp)) != 0
721                       && (note = find_reg_equal_equiv_note (temp)) != 0
722                       && GET_CODE (XEXP (note, 0)) != EXPR_LIST
723                       /* Avoid using a register that may already been marked
724                          dead by an earlier instruction.  */
725                       && ! unmentioned_reg_p (XEXP (note, 0), SET_SRC (set)))
726                     {
727                       /* Temporarily replace the set's source with the
728                          contents of the REG_EQUAL note.  The insn will
729                          be deleted or recognized by try_combine.  */
730                       rtx orig = SET_SRC (set);
731                       SET_SRC (set) = XEXP (note, 0);
732                       next = try_combine (insn, temp, NULL_RTX,
733                                           &new_direct_jump_p);
734                       if (next)
735                         goto retry;
736                       SET_SRC (set) = orig;
737                     }
738                 }
739
740               if (GET_CODE (insn) != NOTE)
741                 record_dead_and_set_regs (insn);
742
743             retry:
744               ;
745             }
746         }
747     }
748   clear_bb_flags ();
749
750   EXECUTE_IF_SET_IN_SBITMAP (refresh_blocks, 0, i,
751                              BASIC_BLOCK (i)->flags |= BB_DIRTY);
752   new_direct_jump_p |= purge_all_dead_edges (0);
753   delete_noop_moves (f);
754
755   update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
756                                     PROP_DEATH_NOTES | PROP_SCAN_DEAD_CODE
757                                     | PROP_KILL_DEAD_CODE);
758
759   /* Clean up.  */
760   sbitmap_free (refresh_blocks);
761   free (reg_stat);
762   free (uid_cuid);
763
764   {
765     struct undo *undo, *next;
766     for (undo = undobuf.frees; undo; undo = next)
767       {
768         next = undo->next;
769         free (undo);
770       }
771     undobuf.frees = 0;
772   }
773
774   total_attempts += combine_attempts;
775   total_merges += combine_merges;
776   total_extras += combine_extras;
777   total_successes += combine_successes;
778
779   nonzero_sign_valid = 0;
780   gen_lowpart = gen_lowpart_general;
781
782   /* Make recognizer allow volatile MEMs again.  */
783   init_recog ();
784
785   return new_direct_jump_p;
786 }
787
788 /* Wipe the last_xxx fields of reg_stat in preparation for another pass.  */
789
790 static void
791 init_reg_last (void)
792 {
793   unsigned int i;
794   for (i = 0; i < combine_max_regno; i++)
795     memset (reg_stat + i, 0, offsetof (struct reg_stat, sign_bit_copies));
796 }
797 \f
798 /* Set up any promoted values for incoming argument registers.  */
799
800 static void
801 setup_incoming_promotions (void)
802 {
803   unsigned int regno;
804   rtx reg;
805   enum machine_mode mode;
806   int unsignedp;
807   rtx first = get_insns ();
808
809   if (targetm.calls.promote_function_args (TREE_TYPE (cfun->decl)))
810     {
811       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
812         /* Check whether this register can hold an incoming pointer
813            argument.  FUNCTION_ARG_REGNO_P tests outgoing register
814            numbers, so translate if necessary due to register windows.  */
815         if (FUNCTION_ARG_REGNO_P (OUTGOING_REGNO (regno))
816             && (reg = promoted_input_arg (regno, &mode, &unsignedp)) != 0)
817           {
818             record_value_for_reg
819               (reg, first, gen_rtx_fmt_e ((unsignedp ? ZERO_EXTEND
820                                            : SIGN_EXTEND),
821                                           GET_MODE (reg),
822                                           gen_rtx_CLOBBER (mode, const0_rtx)));
823           }
824     }
825 }
826 \f
827 /* Called via note_stores.  If X is a pseudo that is narrower than
828    HOST_BITS_PER_WIDE_INT and is being set, record what bits are known zero.
829
830    If we are setting only a portion of X and we can't figure out what
831    portion, assume all bits will be used since we don't know what will
832    be happening.
833
834    Similarly, set how many bits of X are known to be copies of the sign bit
835    at all locations in the function.  This is the smallest number implied
836    by any set of X.  */
837
838 static void
839 set_nonzero_bits_and_sign_copies (rtx x, rtx set,
840                                   void *data ATTRIBUTE_UNUSED)
841 {
842   unsigned int num;
843
844   if (GET_CODE (x) == REG
845       && REGNO (x) >= FIRST_PSEUDO_REGISTER
846       /* If this register is undefined at the start of the file, we can't
847          say what its contents were.  */
848       && ! REGNO_REG_SET_P (ENTRY_BLOCK_PTR->next_bb->global_live_at_start, REGNO (x))
849       && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
850     {
851       if (set == 0 || GET_CODE (set) == CLOBBER)
852         {
853           reg_stat[REGNO (x)].nonzero_bits = GET_MODE_MASK (GET_MODE (x));
854           reg_stat[REGNO (x)].sign_bit_copies = 1;
855           return;
856         }
857
858       /* If this is a complex assignment, see if we can convert it into a
859          simple assignment.  */
860       set = expand_field_assignment (set);
861
862       /* If this is a simple assignment, or we have a paradoxical SUBREG,
863          set what we know about X.  */
864
865       if (SET_DEST (set) == x
866           || (GET_CODE (SET_DEST (set)) == SUBREG
867               && (GET_MODE_SIZE (GET_MODE (SET_DEST (set)))
868                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (set)))))
869               && SUBREG_REG (SET_DEST (set)) == x))
870         {
871           rtx src = SET_SRC (set);
872
873 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
874           /* If X is narrower than a word and SRC is a non-negative
875              constant that would appear negative in the mode of X,
876              sign-extend it for use in reg_stat[].nonzero_bits because some
877              machines (maybe most) will actually do the sign-extension
878              and this is the conservative approach.
879
880              ??? For 2.5, try to tighten up the MD files in this regard
881              instead of this kludge.  */
882
883           if (GET_MODE_BITSIZE (GET_MODE (x)) < BITS_PER_WORD
884               && GET_CODE (src) == CONST_INT
885               && INTVAL (src) > 0
886               && 0 != (INTVAL (src)
887                        & ((HOST_WIDE_INT) 1
888                           << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
889             src = GEN_INT (INTVAL (src)
890                            | ((HOST_WIDE_INT) (-1)
891                               << GET_MODE_BITSIZE (GET_MODE (x))));
892 #endif
893
894           /* Don't call nonzero_bits if it cannot change anything.  */
895           if (reg_stat[REGNO (x)].nonzero_bits != ~(unsigned HOST_WIDE_INT) 0)
896             reg_stat[REGNO (x)].nonzero_bits
897               |= nonzero_bits (src, nonzero_bits_mode);
898           num = num_sign_bit_copies (SET_SRC (set), GET_MODE (x));
899           if (reg_stat[REGNO (x)].sign_bit_copies == 0
900               || reg_stat[REGNO (x)].sign_bit_copies > num)
901             reg_stat[REGNO (x)].sign_bit_copies = num;
902         }
903       else
904         {
905           reg_stat[REGNO (x)].nonzero_bits = GET_MODE_MASK (GET_MODE (x));
906           reg_stat[REGNO (x)].sign_bit_copies = 1;
907         }
908     }
909 }
910 \f
911 /* See if INSN can be combined into I3.  PRED and SUCC are optionally
912    insns that were previously combined into I3 or that will be combined
913    into the merger of INSN and I3.
914
915    Return 0 if the combination is not allowed for any reason.
916
917    If the combination is allowed, *PDEST will be set to the single
918    destination of INSN and *PSRC to the single source, and this function
919    will return 1.  */
920
921 static int
922 can_combine_p (rtx insn, rtx i3, rtx pred ATTRIBUTE_UNUSED, rtx succ,
923                rtx *pdest, rtx *psrc)
924 {
925   int i;
926   rtx set = 0, src, dest;
927   rtx p;
928 #ifdef AUTO_INC_DEC
929   rtx link;
930 #endif
931   int all_adjacent = (succ ? (next_active_insn (insn) == succ
932                               && next_active_insn (succ) == i3)
933                       : next_active_insn (insn) == i3);
934
935   /* Can combine only if previous insn is a SET of a REG, a SUBREG or CC0.
936      or a PARALLEL consisting of such a SET and CLOBBERs.
937
938      If INSN has CLOBBER parallel parts, ignore them for our processing.
939      By definition, these happen during the execution of the insn.  When it
940      is merged with another insn, all bets are off.  If they are, in fact,
941      needed and aren't also supplied in I3, they may be added by
942      recog_for_combine.  Otherwise, it won't match.
943
944      We can also ignore a SET whose SET_DEST is mentioned in a REG_UNUSED
945      note.
946
947      Get the source and destination of INSN.  If more than one, can't
948      combine.  */
949
950   if (GET_CODE (PATTERN (insn)) == SET)
951     set = PATTERN (insn);
952   else if (GET_CODE (PATTERN (insn)) == PARALLEL
953            && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
954     {
955       for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
956         {
957           rtx elt = XVECEXP (PATTERN (insn), 0, i);
958           rtx note;
959
960           switch (GET_CODE (elt))
961             {
962             /* This is important to combine floating point insns
963                for the SH4 port.  */
964             case USE:
965               /* Combining an isolated USE doesn't make sense.
966                  We depend here on combinable_i3pat to reject them.  */
967               /* The code below this loop only verifies that the inputs of
968                  the SET in INSN do not change.  We call reg_set_between_p
969                  to verify that the REG in the USE does not change between
970                  I3 and INSN.
971                  If the USE in INSN was for a pseudo register, the matching
972                  insn pattern will likely match any register; combining this
973                  with any other USE would only be safe if we knew that the
974                  used registers have identical values, or if there was
975                  something to tell them apart, e.g. different modes.  For
976                  now, we forgo such complicated tests and simply disallow
977                  combining of USES of pseudo registers with any other USE.  */
978               if (GET_CODE (XEXP (elt, 0)) == REG
979                   && GET_CODE (PATTERN (i3)) == PARALLEL)
980                 {
981                   rtx i3pat = PATTERN (i3);
982                   int i = XVECLEN (i3pat, 0) - 1;
983                   unsigned int regno = REGNO (XEXP (elt, 0));
984
985                   do
986                     {
987                       rtx i3elt = XVECEXP (i3pat, 0, i);
988
989                       if (GET_CODE (i3elt) == USE
990                           && GET_CODE (XEXP (i3elt, 0)) == REG
991                           && (REGNO (XEXP (i3elt, 0)) == regno
992                               ? reg_set_between_p (XEXP (elt, 0),
993                                                    PREV_INSN (insn), i3)
994                               : regno >= FIRST_PSEUDO_REGISTER))
995                         return 0;
996                     }
997                   while (--i >= 0);
998                 }
999               break;
1000
1001               /* We can ignore CLOBBERs.  */
1002             case CLOBBER:
1003               break;
1004
1005             case SET:
1006               /* Ignore SETs whose result isn't used but not those that
1007                  have side-effects.  */
1008               if (find_reg_note (insn, REG_UNUSED, SET_DEST (elt))
1009                   && (!(note = find_reg_note (insn, REG_EH_REGION, NULL_RTX))
1010                       || INTVAL (XEXP (note, 0)) <= 0)
1011                   && ! side_effects_p (elt))
1012                 break;
1013
1014               /* If we have already found a SET, this is a second one and
1015                  so we cannot combine with this insn.  */
1016               if (set)
1017                 return 0;
1018
1019               set = elt;
1020               break;
1021
1022             default:
1023               /* Anything else means we can't combine.  */
1024               return 0;
1025             }
1026         }
1027
1028       if (set == 0
1029           /* If SET_SRC is an ASM_OPERANDS we can't throw away these CLOBBERs,
1030              so don't do anything with it.  */
1031           || GET_CODE (SET_SRC (set)) == ASM_OPERANDS)
1032         return 0;
1033     }
1034   else
1035     return 0;
1036
1037   if (set == 0)
1038     return 0;
1039
1040   set = expand_field_assignment (set);
1041   src = SET_SRC (set), dest = SET_DEST (set);
1042
1043   /* Don't eliminate a store in the stack pointer.  */
1044   if (dest == stack_pointer_rtx
1045       /* Don't combine with an insn that sets a register to itself if it has
1046          a REG_EQUAL note.  This may be part of a REG_NO_CONFLICT sequence.  */
1047       || (rtx_equal_p (src, dest) && find_reg_note (insn, REG_EQUAL, NULL_RTX))
1048       /* Can't merge an ASM_OPERANDS.  */
1049       || GET_CODE (src) == ASM_OPERANDS
1050       /* Can't merge a function call.  */
1051       || GET_CODE (src) == CALL
1052       /* Don't eliminate a function call argument.  */
1053       || (GET_CODE (i3) == CALL_INSN
1054           && (find_reg_fusage (i3, USE, dest)
1055               || (GET_CODE (dest) == REG
1056                   && REGNO (dest) < FIRST_PSEUDO_REGISTER
1057                   && global_regs[REGNO (dest)])))
1058       /* Don't substitute into an incremented register.  */
1059       || FIND_REG_INC_NOTE (i3, dest)
1060       || (succ && FIND_REG_INC_NOTE (succ, dest))
1061 #if 0
1062       /* Don't combine the end of a libcall into anything.  */
1063       /* ??? This gives worse code, and appears to be unnecessary, since no
1064          pass after flow uses REG_LIBCALL/REG_RETVAL notes.  Local-alloc does
1065          use REG_RETVAL notes for noconflict blocks, but other code here
1066          makes sure that those insns don't disappear.  */
1067       || find_reg_note (insn, REG_RETVAL, NULL_RTX)
1068 #endif
1069       /* Make sure that DEST is not used after SUCC but before I3.  */
1070       || (succ && ! all_adjacent
1071           && reg_used_between_p (dest, succ, i3))
1072       /* Make sure that the value that is to be substituted for the register
1073          does not use any registers whose values alter in between.  However,
1074          If the insns are adjacent, a use can't cross a set even though we
1075          think it might (this can happen for a sequence of insns each setting
1076          the same destination; last_set of that register might point to
1077          a NOTE).  If INSN has a REG_EQUIV note, the register is always
1078          equivalent to the memory so the substitution is valid even if there
1079          are intervening stores.  Also, don't move a volatile asm or
1080          UNSPEC_VOLATILE across any other insns.  */
1081       || (! all_adjacent
1082           && (((GET_CODE (src) != MEM
1083                 || ! find_reg_note (insn, REG_EQUIV, src))
1084                && use_crosses_set_p (src, INSN_CUID (insn)))
1085               || (GET_CODE (src) == ASM_OPERANDS && MEM_VOLATILE_P (src))
1086               || GET_CODE (src) == UNSPEC_VOLATILE))
1087       /* If there is a REG_NO_CONFLICT note for DEST in I3 or SUCC, we get
1088          better register allocation by not doing the combine.  */
1089       || find_reg_note (i3, REG_NO_CONFLICT, dest)
1090       || (succ && find_reg_note (succ, REG_NO_CONFLICT, dest))
1091       /* Don't combine across a CALL_INSN, because that would possibly
1092          change whether the life span of some REGs crosses calls or not,
1093          and it is a pain to update that information.
1094          Exception: if source is a constant, moving it later can't hurt.
1095          Accept that special case, because it helps -fforce-addr a lot.  */
1096       || (INSN_CUID (insn) < last_call_cuid && ! CONSTANT_P (src)))
1097     return 0;
1098
1099   /* DEST must either be a REG or CC0.  */
1100   if (GET_CODE (dest) == REG)
1101     {
1102       /* If register alignment is being enforced for multi-word items in all
1103          cases except for parameters, it is possible to have a register copy
1104          insn referencing a hard register that is not allowed to contain the
1105          mode being copied and which would not be valid as an operand of most
1106          insns.  Eliminate this problem by not combining with such an insn.
1107
1108          Also, on some machines we don't want to extend the life of a hard
1109          register.  */
1110
1111       if (GET_CODE (src) == REG
1112           && ((REGNO (dest) < FIRST_PSEUDO_REGISTER
1113                && ! HARD_REGNO_MODE_OK (REGNO (dest), GET_MODE (dest)))
1114               /* Don't extend the life of a hard register unless it is
1115                  user variable (if we have few registers) or it can't
1116                  fit into the desired register (meaning something special
1117                  is going on).
1118                  Also avoid substituting a return register into I3, because
1119                  reload can't handle a conflict with constraints of other
1120                  inputs.  */
1121               || (REGNO (src) < FIRST_PSEUDO_REGISTER
1122                   && ! HARD_REGNO_MODE_OK (REGNO (src), GET_MODE (src)))))
1123         return 0;
1124     }
1125   else if (GET_CODE (dest) != CC0)
1126     return 0;
1127
1128   /* Don't substitute for a register intended as a clobberable operand.
1129      Similarly, don't substitute an expression containing a register that
1130      will be clobbered in I3.  */
1131   if (GET_CODE (PATTERN (i3)) == PARALLEL)
1132     for (i = XVECLEN (PATTERN (i3), 0) - 1; i >= 0; i--)
1133       if (GET_CODE (XVECEXP (PATTERN (i3), 0, i)) == CLOBBER
1134           && (reg_overlap_mentioned_p (XEXP (XVECEXP (PATTERN (i3), 0, i), 0),
1135                                        src)
1136               || rtx_equal_p (XEXP (XVECEXP (PATTERN (i3), 0, i), 0), dest)))
1137         return 0;
1138
1139   /* If INSN contains anything volatile, or is an `asm' (whether volatile
1140      or not), reject, unless nothing volatile comes between it and I3 */
1141
1142   if (GET_CODE (src) == ASM_OPERANDS || volatile_refs_p (src))
1143     {
1144       /* Make sure succ doesn't contain a volatile reference.  */
1145       if (succ != 0 && volatile_refs_p (PATTERN (succ)))
1146         return 0;
1147
1148       for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p))
1149         if (INSN_P (p) && p != succ && volatile_refs_p (PATTERN (p)))
1150           return 0;
1151     }
1152
1153   /* If INSN is an asm, and DEST is a hard register, reject, since it has
1154      to be an explicit register variable, and was chosen for a reason.  */
1155
1156   if (GET_CODE (src) == ASM_OPERANDS
1157       && GET_CODE (dest) == REG && REGNO (dest) < FIRST_PSEUDO_REGISTER)
1158     return 0;
1159
1160   /* If there are any volatile insns between INSN and I3, reject, because
1161      they might affect machine state.  */
1162
1163   for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p))
1164     if (INSN_P (p) && p != succ && volatile_insn_p (PATTERN (p)))
1165       return 0;
1166
1167   /* If INSN or I2 contains an autoincrement or autodecrement,
1168      make sure that register is not used between there and I3,
1169      and not already used in I3 either.
1170      Also insist that I3 not be a jump; if it were one
1171      and the incremented register were spilled, we would lose.  */
1172
1173 #ifdef AUTO_INC_DEC
1174   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1175     if (REG_NOTE_KIND (link) == REG_INC
1176         && (GET_CODE (i3) == JUMP_INSN
1177             || reg_used_between_p (XEXP (link, 0), insn, i3)
1178             || reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i3))))
1179       return 0;
1180 #endif
1181
1182 #ifdef HAVE_cc0
1183   /* Don't combine an insn that follows a CC0-setting insn.
1184      An insn that uses CC0 must not be separated from the one that sets it.
1185      We do, however, allow I2 to follow a CC0-setting insn if that insn
1186      is passed as I1; in that case it will be deleted also.
1187      We also allow combining in this case if all the insns are adjacent
1188      because that would leave the two CC0 insns adjacent as well.
1189      It would be more logical to test whether CC0 occurs inside I1 or I2,
1190      but that would be much slower, and this ought to be equivalent.  */
1191
1192   p = prev_nonnote_insn (insn);
1193   if (p && p != pred && GET_CODE (p) == INSN && sets_cc0_p (PATTERN (p))
1194       && ! all_adjacent)
1195     return 0;
1196 #endif
1197
1198   /* If we get here, we have passed all the tests and the combination is
1199      to be allowed.  */
1200
1201   *pdest = dest;
1202   *psrc = src;
1203
1204   return 1;
1205 }
1206 \f
1207 /* LOC is the location within I3 that contains its pattern or the component
1208    of a PARALLEL of the pattern.  We validate that it is valid for combining.
1209
1210    One problem is if I3 modifies its output, as opposed to replacing it
1211    entirely, we can't allow the output to contain I2DEST or I1DEST as doing
1212    so would produce an insn that is not equivalent to the original insns.
1213
1214    Consider:
1215
1216          (set (reg:DI 101) (reg:DI 100))
1217          (set (subreg:SI (reg:DI 101) 0) <foo>)
1218
1219    This is NOT equivalent to:
1220
1221          (parallel [(set (subreg:SI (reg:DI 100) 0) <foo>)
1222                     (set (reg:DI 101) (reg:DI 100))])
1223
1224    Not only does this modify 100 (in which case it might still be valid
1225    if 100 were dead in I2), it sets 101 to the ORIGINAL value of 100.
1226
1227    We can also run into a problem if I2 sets a register that I1
1228    uses and I1 gets directly substituted into I3 (not via I2).  In that
1229    case, we would be getting the wrong value of I2DEST into I3, so we
1230    must reject the combination.  This case occurs when I2 and I1 both
1231    feed into I3, rather than when I1 feeds into I2, which feeds into I3.
1232    If I1_NOT_IN_SRC is nonzero, it means that finding I1 in the source
1233    of a SET must prevent combination from occurring.
1234
1235    Before doing the above check, we first try to expand a field assignment
1236    into a set of logical operations.
1237
1238    If PI3_DEST_KILLED is nonzero, it is a pointer to a location in which
1239    we place a register that is both set and used within I3.  If more than one
1240    such register is detected, we fail.
1241
1242    Return 1 if the combination is valid, zero otherwise.  */
1243
1244 static int
1245 combinable_i3pat (rtx i3, rtx *loc, rtx i2dest, rtx i1dest,
1246                   int i1_not_in_src, rtx *pi3dest_killed)
1247 {
1248   rtx x = *loc;
1249
1250   if (GET_CODE (x) == SET)
1251     {
1252       rtx set = x ;
1253       rtx dest = SET_DEST (set);
1254       rtx src = SET_SRC (set);
1255       rtx inner_dest = dest;
1256
1257       while (GET_CODE (inner_dest) == STRICT_LOW_PART
1258              || GET_CODE (inner_dest) == SUBREG
1259              || GET_CODE (inner_dest) == ZERO_EXTRACT)
1260         inner_dest = XEXP (inner_dest, 0);
1261
1262       /* Check for the case where I3 modifies its output, as discussed
1263          above.  We don't want to prevent pseudos from being combined
1264          into the address of a MEM, so only prevent the combination if
1265          i1 or i2 set the same MEM.  */
1266       if ((inner_dest != dest &&
1267            (GET_CODE (inner_dest) != MEM
1268             || rtx_equal_p (i2dest, inner_dest)
1269             || (i1dest && rtx_equal_p (i1dest, inner_dest)))
1270            && (reg_overlap_mentioned_p (i2dest, inner_dest)
1271                || (i1dest && reg_overlap_mentioned_p (i1dest, inner_dest))))
1272
1273           /* This is the same test done in can_combine_p except we can't test
1274              all_adjacent; we don't have to, since this instruction will stay
1275              in place, thus we are not considering increasing the lifetime of
1276              INNER_DEST.
1277
1278              Also, if this insn sets a function argument, combining it with
1279              something that might need a spill could clobber a previous
1280              function argument; the all_adjacent test in can_combine_p also
1281              checks this; here, we do a more specific test for this case.  */
1282
1283           || (GET_CODE (inner_dest) == REG
1284               && REGNO (inner_dest) < FIRST_PSEUDO_REGISTER
1285               && (! HARD_REGNO_MODE_OK (REGNO (inner_dest),
1286                                         GET_MODE (inner_dest))))
1287           || (i1_not_in_src && reg_overlap_mentioned_p (i1dest, src)))
1288         return 0;
1289
1290       /* If DEST is used in I3, it is being killed in this insn,
1291          so record that for later.
1292          Never add REG_DEAD notes for the FRAME_POINTER_REGNUM or the
1293          STACK_POINTER_REGNUM, since these are always considered to be
1294          live.  Similarly for ARG_POINTER_REGNUM if it is fixed.  */
1295       if (pi3dest_killed && GET_CODE (dest) == REG
1296           && reg_referenced_p (dest, PATTERN (i3))
1297           && REGNO (dest) != FRAME_POINTER_REGNUM
1298 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1299           && REGNO (dest) != HARD_FRAME_POINTER_REGNUM
1300 #endif
1301 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
1302           && (REGNO (dest) != ARG_POINTER_REGNUM
1303               || ! fixed_regs [REGNO (dest)])
1304 #endif
1305           && REGNO (dest) != STACK_POINTER_REGNUM)
1306         {
1307           if (*pi3dest_killed)
1308             return 0;
1309
1310           *pi3dest_killed = dest;
1311         }
1312     }
1313
1314   else if (GET_CODE (x) == PARALLEL)
1315     {
1316       int i;
1317
1318       for (i = 0; i < XVECLEN (x, 0); i++)
1319         if (! combinable_i3pat (i3, &XVECEXP (x, 0, i), i2dest, i1dest,
1320                                 i1_not_in_src, pi3dest_killed))
1321           return 0;
1322     }
1323
1324   return 1;
1325 }
1326 \f
1327 /* Return 1 if X is an arithmetic expression that contains a multiplication
1328    and division.  We don't count multiplications by powers of two here.  */
1329
1330 static int
1331 contains_muldiv (rtx x)
1332 {
1333   switch (GET_CODE (x))
1334     {
1335     case MOD:  case DIV:  case UMOD:  case UDIV:
1336       return 1;
1337
1338     case MULT:
1339       return ! (GET_CODE (XEXP (x, 1)) == CONST_INT
1340                 && exact_log2 (INTVAL (XEXP (x, 1))) >= 0);
1341     default:
1342       if (BINARY_P (x))
1343         return contains_muldiv (XEXP (x, 0))
1344             || contains_muldiv (XEXP (x, 1));
1345
1346       if (UNARY_P (x))
1347         return contains_muldiv (XEXP (x, 0));
1348
1349       return 0;
1350     }
1351 }
1352 \f
1353 /* Determine whether INSN can be used in a combination.  Return nonzero if
1354    not.  This is used in try_combine to detect early some cases where we
1355    can't perform combinations.  */
1356
1357 static int
1358 cant_combine_insn_p (rtx insn)
1359 {
1360   rtx set;
1361   rtx src, dest;
1362
1363   /* If this isn't really an insn, we can't do anything.
1364      This can occur when flow deletes an insn that it has merged into an
1365      auto-increment address.  */
1366   if (! INSN_P (insn))
1367     return 1;
1368
1369   /* Never combine loads and stores involving hard regs that are likely
1370      to be spilled.  The register allocator can usually handle such
1371      reg-reg moves by tying.  If we allow the combiner to make
1372      substitutions of likely-spilled regs, we may abort in reload.
1373      As an exception, we allow combinations involving fixed regs; these are
1374      not available to the register allocator so there's no risk involved.  */
1375
1376   set = single_set (insn);
1377   if (! set)
1378     return 0;
1379   src = SET_SRC (set);
1380   dest = SET_DEST (set);
1381   if (GET_CODE (src) == SUBREG)
1382     src = SUBREG_REG (src);
1383   if (GET_CODE (dest) == SUBREG)
1384     dest = SUBREG_REG (dest);
1385   if (REG_P (src) && REG_P (dest)
1386       && ((REGNO (src) < FIRST_PSEUDO_REGISTER
1387            && ! fixed_regs[REGNO (src)]
1388            && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (REGNO (src))))
1389           || (REGNO (dest) < FIRST_PSEUDO_REGISTER
1390               && ! fixed_regs[REGNO (dest)]
1391               && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (REGNO (dest))))))
1392     return 1;
1393
1394   return 0;
1395 }
1396
1397 /* Adjust INSN after we made a change to its destination.
1398
1399    Changing the destination can invalidate notes that say something about
1400    the results of the insn and a LOG_LINK pointing to the insn.  */
1401
1402 static void
1403 adjust_for_new_dest (rtx insn)
1404 {
1405   rtx *loc;
1406
1407   /* For notes, be conservative and simply remove them.  */
1408   loc = &REG_NOTES (insn);
1409   while (*loc)
1410     {
1411       enum reg_note kind = REG_NOTE_KIND (*loc);
1412       if (kind == REG_EQUAL || kind == REG_EQUIV)
1413         *loc = XEXP (*loc, 1);
1414       else
1415         loc = &XEXP (*loc, 1);
1416     }
1417
1418   /* The new insn will have a destination that was previously the destination
1419      of an insn just above it.  Call distribute_links to make a LOG_LINK from
1420      the next use of that destination.  */
1421   distribute_links (gen_rtx_INSN_LIST (VOIDmode, insn, NULL_RTX));
1422 }
1423
1424 /* Try to combine the insns I1 and I2 into I3.
1425    Here I1 and I2 appear earlier than I3.
1426    I1 can be zero; then we combine just I2 into I3.
1427
1428    If we are combining three insns and the resulting insn is not recognized,
1429    try splitting it into two insns.  If that happens, I2 and I3 are retained
1430    and I1 is pseudo-deleted by turning it into a NOTE.  Otherwise, I1 and I2
1431    are pseudo-deleted.
1432
1433    Return 0 if the combination does not work.  Then nothing is changed.
1434    If we did the combination, return the insn at which combine should
1435    resume scanning.
1436
1437    Set NEW_DIRECT_JUMP_P to a nonzero value if try_combine creates a
1438    new direct jump instruction.  */
1439
1440 static rtx
1441 try_combine (rtx i3, rtx i2, rtx i1, int *new_direct_jump_p)
1442 {
1443   /* New patterns for I3 and I2, respectively.  */
1444   rtx newpat, newi2pat = 0;
1445   int substed_i2 = 0, substed_i1 = 0;
1446   /* Indicates need to preserve SET in I1 or I2 in I3 if it is not dead.  */
1447   int added_sets_1, added_sets_2;
1448   /* Total number of SETs to put into I3.  */
1449   int total_sets;
1450   /* Nonzero if I2's body now appears in I3.  */
1451   int i2_is_used;
1452   /* INSN_CODEs for new I3, new I2, and user of condition code.  */
1453   int insn_code_number, i2_code_number = 0, other_code_number = 0;
1454   /* Contains I3 if the destination of I3 is used in its source, which means
1455      that the old life of I3 is being killed.  If that usage is placed into
1456      I2 and not in I3, a REG_DEAD note must be made.  */
1457   rtx i3dest_killed = 0;
1458   /* SET_DEST and SET_SRC of I2 and I1.  */
1459   rtx i2dest, i2src, i1dest = 0, i1src = 0;
1460   /* PATTERN (I2), or a copy of it in certain cases.  */
1461   rtx i2pat;
1462   /* Indicates if I2DEST or I1DEST is in I2SRC or I1_SRC.  */
1463   int i2dest_in_i2src = 0, i1dest_in_i1src = 0, i2dest_in_i1src = 0;
1464   int i1_feeds_i3 = 0;
1465   /* Notes that must be added to REG_NOTES in I3 and I2.  */
1466   rtx new_i3_notes, new_i2_notes;
1467   /* Notes that we substituted I3 into I2 instead of the normal case.  */
1468   int i3_subst_into_i2 = 0;
1469   /* Notes that I1, I2 or I3 is a MULT operation.  */
1470   int have_mult = 0;
1471
1472   int maxreg;
1473   rtx temp;
1474   rtx link;
1475   int i;
1476
1477   /* Exit early if one of the insns involved can't be used for
1478      combinations.  */
1479   if (cant_combine_insn_p (i3)
1480       || cant_combine_insn_p (i2)
1481       || (i1 && cant_combine_insn_p (i1))
1482       /* We also can't do anything if I3 has a
1483          REG_LIBCALL note since we don't want to disrupt the contiguity of a
1484          libcall.  */
1485 #if 0
1486       /* ??? This gives worse code, and appears to be unnecessary, since no
1487          pass after flow uses REG_LIBCALL/REG_RETVAL notes.  */
1488       || find_reg_note (i3, REG_LIBCALL, NULL_RTX)
1489 #endif
1490       )
1491     return 0;
1492
1493   combine_attempts++;
1494   undobuf.other_insn = 0;
1495
1496   /* Reset the hard register usage information.  */
1497   CLEAR_HARD_REG_SET (newpat_used_regs);
1498
1499   /* If I1 and I2 both feed I3, they can be in any order.  To simplify the
1500      code below, set I1 to be the earlier of the two insns.  */
1501   if (i1 && INSN_CUID (i1) > INSN_CUID (i2))
1502     temp = i1, i1 = i2, i2 = temp;
1503
1504   added_links_insn = 0;
1505
1506   /* First check for one important special-case that the code below will
1507      not handle.  Namely, the case where I1 is zero, I2 is a PARALLEL
1508      and I3 is a SET whose SET_SRC is a SET_DEST in I2.  In that case,
1509      we may be able to replace that destination with the destination of I3.
1510      This occurs in the common code where we compute both a quotient and
1511      remainder into a structure, in which case we want to do the computation
1512      directly into the structure to avoid register-register copies.
1513
1514      Note that this case handles both multiple sets in I2 and also
1515      cases where I2 has a number of CLOBBER or PARALLELs.
1516
1517      We make very conservative checks below and only try to handle the
1518      most common cases of this.  For example, we only handle the case
1519      where I2 and I3 are adjacent to avoid making difficult register
1520      usage tests.  */
1521
1522   if (i1 == 0 && GET_CODE (i3) == INSN && GET_CODE (PATTERN (i3)) == SET
1523       && GET_CODE (SET_SRC (PATTERN (i3))) == REG
1524       && REGNO (SET_SRC (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
1525       && find_reg_note (i3, REG_DEAD, SET_SRC (PATTERN (i3)))
1526       && GET_CODE (PATTERN (i2)) == PARALLEL
1527       && ! side_effects_p (SET_DEST (PATTERN (i3)))
1528       /* If the dest of I3 is a ZERO_EXTRACT or STRICT_LOW_PART, the code
1529          below would need to check what is inside (and reg_overlap_mentioned_p
1530          doesn't support those codes anyway).  Don't allow those destinations;
1531          the resulting insn isn't likely to be recognized anyway.  */
1532       && GET_CODE (SET_DEST (PATTERN (i3))) != ZERO_EXTRACT
1533       && GET_CODE (SET_DEST (PATTERN (i3))) != STRICT_LOW_PART
1534       && ! reg_overlap_mentioned_p (SET_SRC (PATTERN (i3)),
1535                                     SET_DEST (PATTERN (i3)))
1536       && next_real_insn (i2) == i3)
1537     {
1538       rtx p2 = PATTERN (i2);
1539
1540       /* Make sure that the destination of I3,
1541          which we are going to substitute into one output of I2,
1542          is not used within another output of I2.  We must avoid making this:
1543          (parallel [(set (mem (reg 69)) ...)
1544                     (set (reg 69) ...)])
1545          which is not well-defined as to order of actions.
1546          (Besides, reload can't handle output reloads for this.)
1547
1548          The problem can also happen if the dest of I3 is a memory ref,
1549          if another dest in I2 is an indirect memory ref.  */
1550       for (i = 0; i < XVECLEN (p2, 0); i++)
1551         if ((GET_CODE (XVECEXP (p2, 0, i)) == SET
1552              || GET_CODE (XVECEXP (p2, 0, i)) == CLOBBER)
1553             && reg_overlap_mentioned_p (SET_DEST (PATTERN (i3)),
1554                                         SET_DEST (XVECEXP (p2, 0, i))))
1555           break;
1556
1557       if (i == XVECLEN (p2, 0))
1558         for (i = 0; i < XVECLEN (p2, 0); i++)
1559           if ((GET_CODE (XVECEXP (p2, 0, i)) == SET
1560                || GET_CODE (XVECEXP (p2, 0, i)) == CLOBBER)
1561               && SET_DEST (XVECEXP (p2, 0, i)) == SET_SRC (PATTERN (i3)))
1562             {
1563               combine_merges++;
1564
1565               subst_insn = i3;
1566               subst_low_cuid = INSN_CUID (i2);
1567
1568               added_sets_2 = added_sets_1 = 0;
1569               i2dest = SET_SRC (PATTERN (i3));
1570
1571               /* Replace the dest in I2 with our dest and make the resulting
1572                  insn the new pattern for I3.  Then skip to where we
1573                  validate the pattern.  Everything was set up above.  */
1574               SUBST (SET_DEST (XVECEXP (p2, 0, i)),
1575                      SET_DEST (PATTERN (i3)));
1576
1577               newpat = p2;
1578               i3_subst_into_i2 = 1;
1579               goto validate_replacement;
1580             }
1581     }
1582
1583   /* If I2 is setting a double-word pseudo to a constant and I3 is setting
1584      one of those words to another constant, merge them by making a new
1585      constant.  */
1586   if (i1 == 0
1587       && (temp = single_set (i2)) != 0
1588       && (GET_CODE (SET_SRC (temp)) == CONST_INT
1589           || GET_CODE (SET_SRC (temp)) == CONST_DOUBLE)
1590       && GET_CODE (SET_DEST (temp)) == REG
1591       && GET_MODE_CLASS (GET_MODE (SET_DEST (temp))) == MODE_INT
1592       && GET_MODE_SIZE (GET_MODE (SET_DEST (temp))) == 2 * UNITS_PER_WORD
1593       && GET_CODE (PATTERN (i3)) == SET
1594       && GET_CODE (SET_DEST (PATTERN (i3))) == SUBREG
1595       && SUBREG_REG (SET_DEST (PATTERN (i3))) == SET_DEST (temp)
1596       && GET_MODE_CLASS (GET_MODE (SET_DEST (PATTERN (i3)))) == MODE_INT
1597       && GET_MODE_SIZE (GET_MODE (SET_DEST (PATTERN (i3)))) == UNITS_PER_WORD
1598       && GET_CODE (SET_SRC (PATTERN (i3))) == CONST_INT)
1599     {
1600       HOST_WIDE_INT lo, hi;
1601
1602       if (GET_CODE (SET_SRC (temp)) == CONST_INT)
1603         lo = INTVAL (SET_SRC (temp)), hi = lo < 0 ? -1 : 0;
1604       else
1605         {
1606           lo = CONST_DOUBLE_LOW (SET_SRC (temp));
1607           hi = CONST_DOUBLE_HIGH (SET_SRC (temp));
1608         }
1609
1610       if (subreg_lowpart_p (SET_DEST (PATTERN (i3))))
1611         {
1612           /* We don't handle the case of the target word being wider
1613              than a host wide int.  */
1614           if (HOST_BITS_PER_WIDE_INT < BITS_PER_WORD)
1615             abort ();
1616
1617           lo &= ~(UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD (1) - 1);
1618           lo |= (INTVAL (SET_SRC (PATTERN (i3)))
1619                  & (UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD (1) - 1));
1620         }
1621       else if (HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
1622         hi = INTVAL (SET_SRC (PATTERN (i3)));
1623       else if (HOST_BITS_PER_WIDE_INT >= 2 * BITS_PER_WORD)
1624         {
1625           int sign = -(int) ((unsigned HOST_WIDE_INT) lo
1626                              >> (HOST_BITS_PER_WIDE_INT - 1));
1627
1628           lo &= ~ (UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD
1629                    (UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD (1) - 1));
1630           lo |= (UWIDE_SHIFT_LEFT_BY_BITS_PER_WORD
1631                  (INTVAL (SET_SRC (PATTERN (i3)))));
1632           if (hi == sign)
1633             hi = lo < 0 ? -1 : 0;
1634         }
1635       else
1636         /* We don't handle the case of the higher word not fitting
1637            entirely in either hi or lo.  */
1638         abort ();
1639
1640       combine_merges++;
1641       subst_insn = i3;
1642       subst_low_cuid = INSN_CUID (i2);
1643       added_sets_2 = added_sets_1 = 0;
1644       i2dest = SET_DEST (temp);
1645
1646       SUBST (SET_SRC (temp),
1647              immed_double_const (lo, hi, GET_MODE (SET_DEST (temp))));
1648
1649       newpat = PATTERN (i2);
1650       goto validate_replacement;
1651     }
1652
1653 #ifndef HAVE_cc0
1654   /* If we have no I1 and I2 looks like:
1655         (parallel [(set (reg:CC X) (compare:CC OP (const_int 0)))
1656                    (set Y OP)])
1657      make up a dummy I1 that is
1658         (set Y OP)
1659      and change I2 to be
1660         (set (reg:CC X) (compare:CC Y (const_int 0)))
1661
1662      (We can ignore any trailing CLOBBERs.)
1663
1664      This undoes a previous combination and allows us to match a branch-and-
1665      decrement insn.  */
1666
1667   if (i1 == 0 && GET_CODE (PATTERN (i2)) == PARALLEL
1668       && XVECLEN (PATTERN (i2), 0) >= 2
1669       && GET_CODE (XVECEXP (PATTERN (i2), 0, 0)) == SET
1670       && (GET_MODE_CLASS (GET_MODE (SET_DEST (XVECEXP (PATTERN (i2), 0, 0))))
1671           == MODE_CC)
1672       && GET_CODE (SET_SRC (XVECEXP (PATTERN (i2), 0, 0))) == COMPARE
1673       && XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 1) == const0_rtx
1674       && GET_CODE (XVECEXP (PATTERN (i2), 0, 1)) == SET
1675       && GET_CODE (SET_DEST (XVECEXP (PATTERN (i2), 0, 1))) == REG
1676       && rtx_equal_p (XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 0),
1677                       SET_SRC (XVECEXP (PATTERN (i2), 0, 1))))
1678     {
1679       for (i = XVECLEN (PATTERN (i2), 0) - 1; i >= 2; i--)
1680         if (GET_CODE (XVECEXP (PATTERN (i2), 0, i)) != CLOBBER)
1681           break;
1682
1683       if (i == 1)
1684         {
1685           /* We make I1 with the same INSN_UID as I2.  This gives it
1686              the same INSN_CUID for value tracking.  Our fake I1 will
1687              never appear in the insn stream so giving it the same INSN_UID
1688              as I2 will not cause a problem.  */
1689
1690           i1 = gen_rtx_INSN (VOIDmode, INSN_UID (i2), NULL_RTX, i2,
1691                              BLOCK_FOR_INSN (i2), INSN_LOCATOR (i2),
1692                              XVECEXP (PATTERN (i2), 0, 1), -1, NULL_RTX,
1693                              NULL_RTX);
1694
1695           SUBST (PATTERN (i2), XVECEXP (PATTERN (i2), 0, 0));
1696           SUBST (XEXP (SET_SRC (PATTERN (i2)), 0),
1697                  SET_DEST (PATTERN (i1)));
1698         }
1699     }
1700 #endif
1701
1702   /* Verify that I2 and I1 are valid for combining.  */
1703   if (! can_combine_p (i2, i3, i1, NULL_RTX, &i2dest, &i2src)
1704       || (i1 && ! can_combine_p (i1, i3, NULL_RTX, i2, &i1dest, &i1src)))
1705     {
1706       undo_all ();
1707       return 0;
1708     }
1709
1710   /* Record whether I2DEST is used in I2SRC and similarly for the other
1711      cases.  Knowing this will help in register status updating below.  */
1712   i2dest_in_i2src = reg_overlap_mentioned_p (i2dest, i2src);
1713   i1dest_in_i1src = i1 && reg_overlap_mentioned_p (i1dest, i1src);
1714   i2dest_in_i1src = i1 && reg_overlap_mentioned_p (i2dest, i1src);
1715
1716   /* See if I1 directly feeds into I3.  It does if I1DEST is not used
1717      in I2SRC.  */
1718   i1_feeds_i3 = i1 && ! reg_overlap_mentioned_p (i1dest, i2src);
1719
1720   /* Ensure that I3's pattern can be the destination of combines.  */
1721   if (! combinable_i3pat (i3, &PATTERN (i3), i2dest, i1dest,
1722                           i1 && i2dest_in_i1src && i1_feeds_i3,
1723                           &i3dest_killed))
1724     {
1725       undo_all ();
1726       return 0;
1727     }
1728
1729   /* See if any of the insns is a MULT operation.  Unless one is, we will
1730      reject a combination that is, since it must be slower.  Be conservative
1731      here.  */
1732   if (GET_CODE (i2src) == MULT
1733       || (i1 != 0 && GET_CODE (i1src) == MULT)
1734       || (GET_CODE (PATTERN (i3)) == SET
1735           && GET_CODE (SET_SRC (PATTERN (i3))) == MULT))
1736     have_mult = 1;
1737
1738   /* If I3 has an inc, then give up if I1 or I2 uses the reg that is inc'd.
1739      We used to do this EXCEPT in one case: I3 has a post-inc in an
1740      output operand.  However, that exception can give rise to insns like
1741         mov r3,(r3)+
1742      which is a famous insn on the PDP-11 where the value of r3 used as the
1743      source was model-dependent.  Avoid this sort of thing.  */
1744
1745 #if 0
1746   if (!(GET_CODE (PATTERN (i3)) == SET
1747         && GET_CODE (SET_SRC (PATTERN (i3))) == REG
1748         && GET_CODE (SET_DEST (PATTERN (i3))) == MEM
1749         && (GET_CODE (XEXP (SET_DEST (PATTERN (i3)), 0)) == POST_INC
1750             || GET_CODE (XEXP (SET_DEST (PATTERN (i3)), 0)) == POST_DEC)))
1751     /* It's not the exception.  */
1752 #endif
1753 #ifdef AUTO_INC_DEC
1754     for (link = REG_NOTES (i3); link; link = XEXP (link, 1))
1755       if (REG_NOTE_KIND (link) == REG_INC
1756           && (reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i2))
1757               || (i1 != 0
1758                   && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i1)))))
1759         {
1760           undo_all ();
1761           return 0;
1762         }
1763 #endif
1764
1765   /* See if the SETs in I1 or I2 need to be kept around in the merged
1766      instruction: whenever the value set there is still needed past I3.
1767      For the SETs in I2, this is easy: we see if I2DEST dies or is set in I3.
1768
1769      For the SET in I1, we have two cases:  If I1 and I2 independently
1770      feed into I3, the set in I1 needs to be kept around if I1DEST dies
1771      or is set in I3.  Otherwise (if I1 feeds I2 which feeds I3), the set
1772      in I1 needs to be kept around unless I1DEST dies or is set in either
1773      I2 or I3.  We can distinguish these cases by seeing if I2SRC mentions
1774      I1DEST.  If so, we know I1 feeds into I2.  */
1775
1776   added_sets_2 = ! dead_or_set_p (i3, i2dest);
1777
1778   added_sets_1
1779     = i1 && ! (i1_feeds_i3 ? dead_or_set_p (i3, i1dest)
1780                : (dead_or_set_p (i3, i1dest) || dead_or_set_p (i2, i1dest)));
1781
1782   /* If the set in I2 needs to be kept around, we must make a copy of
1783      PATTERN (I2), so that when we substitute I1SRC for I1DEST in
1784      PATTERN (I2), we are only substituting for the original I1DEST, not into
1785      an already-substituted copy.  This also prevents making self-referential
1786      rtx.  If I2 is a PARALLEL, we just need the piece that assigns I2SRC to
1787      I2DEST.  */
1788
1789   i2pat = (GET_CODE (PATTERN (i2)) == PARALLEL
1790            ? gen_rtx_SET (VOIDmode, i2dest, i2src)
1791            : PATTERN (i2));
1792
1793   if (added_sets_2)
1794     i2pat = copy_rtx (i2pat);
1795
1796   combine_merges++;
1797
1798   /* Substitute in the latest insn for the regs set by the earlier ones.  */
1799
1800   maxreg = max_reg_num ();
1801
1802   subst_insn = i3;
1803
1804   /* It is possible that the source of I2 or I1 may be performing an
1805      unneeded operation, such as a ZERO_EXTEND of something that is known
1806      to have the high part zero.  Handle that case by letting subst look at
1807      the innermost one of them.
1808
1809      Another way to do this would be to have a function that tries to
1810      simplify a single insn instead of merging two or more insns.  We don't
1811      do this because of the potential of infinite loops and because
1812      of the potential extra memory required.  However, doing it the way
1813      we are is a bit of a kludge and doesn't catch all cases.
1814
1815      But only do this if -fexpensive-optimizations since it slows things down
1816      and doesn't usually win.  */
1817
1818   if (flag_expensive_optimizations)
1819     {
1820       /* Pass pc_rtx so no substitutions are done, just simplifications.  */
1821       if (i1)
1822         {
1823           subst_low_cuid = INSN_CUID (i1);
1824           i1src = subst (i1src, pc_rtx, pc_rtx, 0, 0);
1825         }
1826       else
1827         {
1828           subst_low_cuid = INSN_CUID (i2);
1829           i2src = subst (i2src, pc_rtx, pc_rtx, 0, 0);
1830         }
1831     }
1832
1833 #ifndef HAVE_cc0
1834   /* Many machines that don't use CC0 have insns that can both perform an
1835      arithmetic operation and set the condition code.  These operations will
1836      be represented as a PARALLEL with the first element of the vector
1837      being a COMPARE of an arithmetic operation with the constant zero.
1838      The second element of the vector will set some pseudo to the result
1839      of the same arithmetic operation.  If we simplify the COMPARE, we won't
1840      match such a pattern and so will generate an extra insn.   Here we test
1841      for this case, where both the comparison and the operation result are
1842      needed, and make the PARALLEL by just replacing I2DEST in I3SRC with
1843      I2SRC.  Later we will make the PARALLEL that contains I2.  */
1844
1845   if (i1 == 0 && added_sets_2 && GET_CODE (PATTERN (i3)) == SET
1846       && GET_CODE (SET_SRC (PATTERN (i3))) == COMPARE
1847       && XEXP (SET_SRC (PATTERN (i3)), 1) == const0_rtx
1848       && rtx_equal_p (XEXP (SET_SRC (PATTERN (i3)), 0), i2dest))
1849     {
1850 #ifdef SELECT_CC_MODE
1851       rtx *cc_use;
1852       enum machine_mode compare_mode;
1853 #endif
1854
1855       newpat = PATTERN (i3);
1856       SUBST (XEXP (SET_SRC (newpat), 0), i2src);
1857
1858       i2_is_used = 1;
1859
1860 #ifdef SELECT_CC_MODE
1861       /* See if a COMPARE with the operand we substituted in should be done
1862          with the mode that is currently being used.  If not, do the same
1863          processing we do in `subst' for a SET; namely, if the destination
1864          is used only once, try to replace it with a register of the proper
1865          mode and also replace the COMPARE.  */
1866       if (undobuf.other_insn == 0
1867           && (cc_use = find_single_use (SET_DEST (newpat), i3,
1868                                         &undobuf.other_insn))
1869           && ((compare_mode = SELECT_CC_MODE (GET_CODE (*cc_use),
1870                                               i2src, const0_rtx))
1871               != GET_MODE (SET_DEST (newpat))))
1872         {
1873           unsigned int regno = REGNO (SET_DEST (newpat));
1874           rtx new_dest = gen_rtx_REG (compare_mode, regno);
1875
1876           if (regno < FIRST_PSEUDO_REGISTER
1877               || (REG_N_SETS (regno) == 1 && ! added_sets_2
1878                   && ! REG_USERVAR_P (SET_DEST (newpat))))
1879             {
1880               if (regno >= FIRST_PSEUDO_REGISTER)
1881                 SUBST (regno_reg_rtx[regno], new_dest);
1882
1883               SUBST (SET_DEST (newpat), new_dest);
1884               SUBST (XEXP (*cc_use, 0), new_dest);
1885               SUBST (SET_SRC (newpat),
1886                      gen_rtx_COMPARE (compare_mode, i2src, const0_rtx));
1887             }
1888           else
1889             undobuf.other_insn = 0;
1890         }
1891 #endif
1892     }
1893   else
1894 #endif
1895     {
1896       n_occurrences = 0;                /* `subst' counts here */
1897
1898       /* If I1 feeds into I2 (not into I3) and I1DEST is in I1SRC, we
1899          need to make a unique copy of I2SRC each time we substitute it
1900          to avoid self-referential rtl.  */
1901
1902       subst_low_cuid = INSN_CUID (i2);
1903       newpat = subst (PATTERN (i3), i2dest, i2src, 0,
1904                       ! i1_feeds_i3 && i1dest_in_i1src);
1905       substed_i2 = 1;
1906
1907       /* Record whether i2's body now appears within i3's body.  */
1908       i2_is_used = n_occurrences;
1909     }
1910
1911   /* If we already got a failure, don't try to do more.  Otherwise,
1912      try to substitute in I1 if we have it.  */
1913
1914   if (i1 && GET_CODE (newpat) != CLOBBER)
1915     {
1916       /* Before we can do this substitution, we must redo the test done
1917          above (see detailed comments there) that ensures  that I1DEST
1918          isn't mentioned in any SETs in NEWPAT that are field assignments.  */
1919
1920       if (! combinable_i3pat (NULL_RTX, &newpat, i1dest, NULL_RTX,
1921                               0, (rtx*) 0))
1922         {
1923           undo_all ();
1924           return 0;
1925         }
1926
1927       n_occurrences = 0;
1928       subst_low_cuid = INSN_CUID (i1);
1929       newpat = subst (newpat, i1dest, i1src, 0, 0);
1930       substed_i1 = 1;
1931     }
1932
1933   /* Fail if an autoincrement side-effect has been duplicated.  Be careful
1934      to count all the ways that I2SRC and I1SRC can be used.  */
1935   if ((FIND_REG_INC_NOTE (i2, NULL_RTX) != 0
1936        && i2_is_used + added_sets_2 > 1)
1937       || (i1 != 0 && FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
1938           && (n_occurrences + added_sets_1 + (added_sets_2 && ! i1_feeds_i3)
1939               > 1))
1940       /* Fail if we tried to make a new register (we used to abort, but there's
1941          really no reason to).  */
1942       || max_reg_num () != maxreg
1943       /* Fail if we couldn't do something and have a CLOBBER.  */
1944       || GET_CODE (newpat) == CLOBBER
1945       /* Fail if this new pattern is a MULT and we didn't have one before
1946          at the outer level.  */
1947       || (GET_CODE (newpat) == SET && GET_CODE (SET_SRC (newpat)) == MULT
1948           && ! have_mult))
1949     {
1950       undo_all ();
1951       return 0;
1952     }
1953
1954   /* If the actions of the earlier insns must be kept
1955      in addition to substituting them into the latest one,
1956      we must make a new PARALLEL for the latest insn
1957      to hold additional the SETs.  */
1958
1959   if (added_sets_1 || added_sets_2)
1960     {
1961       combine_extras++;
1962
1963       if (GET_CODE (newpat) == PARALLEL)
1964         {
1965           rtvec old = XVEC (newpat, 0);
1966           total_sets = XVECLEN (newpat, 0) + added_sets_1 + added_sets_2;
1967           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
1968           memcpy (XVEC (newpat, 0)->elem, &old->elem[0],
1969                   sizeof (old->elem[0]) * old->num_elem);
1970         }
1971       else
1972         {
1973           rtx old = newpat;
1974           total_sets = 1 + added_sets_1 + added_sets_2;
1975           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
1976           XVECEXP (newpat, 0, 0) = old;
1977         }
1978
1979       if (added_sets_1)
1980         XVECEXP (newpat, 0, --total_sets)
1981           = (GET_CODE (PATTERN (i1)) == PARALLEL
1982              ? gen_rtx_SET (VOIDmode, i1dest, i1src) : PATTERN (i1));
1983
1984       if (added_sets_2)
1985         {
1986           /* If there is no I1, use I2's body as is.  We used to also not do
1987              the subst call below if I2 was substituted into I3,
1988              but that could lose a simplification.  */
1989           if (i1 == 0)
1990             XVECEXP (newpat, 0, --total_sets) = i2pat;
1991           else
1992             /* See comment where i2pat is assigned.  */
1993             XVECEXP (newpat, 0, --total_sets)
1994               = subst (i2pat, i1dest, i1src, 0, 0);
1995         }
1996     }
1997
1998   /* We come here when we are replacing a destination in I2 with the
1999      destination of I3.  */
2000  validate_replacement:
2001
2002   /* Note which hard regs this insn has as inputs.  */
2003   mark_used_regs_combine (newpat);
2004
2005   /* Is the result of combination a valid instruction?  */
2006   insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2007
2008   /* If the result isn't valid, see if it is a PARALLEL of two SETs where
2009      the second SET's destination is a register that is unused and isn't
2010      marked as an instruction that might trap in an EH region.  In that case,
2011      we just need the first SET.   This can occur when simplifying a divmod
2012      insn.  We *must* test for this case here because the code below that
2013      splits two independent SETs doesn't handle this case correctly when it
2014      updates the register status.
2015
2016      It's pointless doing this if we originally had two sets, one from
2017      i3, and one from i2.  Combining then splitting the parallel results
2018      in the original i2 again plus an invalid insn (which we delete).
2019      The net effect is only to move instructions around, which makes
2020      debug info less accurate.
2021
2022      Also check the case where the first SET's destination is unused.
2023      That would not cause incorrect code, but does cause an unneeded
2024      insn to remain.  */
2025
2026   if (insn_code_number < 0
2027       && !(added_sets_2 && i1 == 0)
2028       && GET_CODE (newpat) == PARALLEL
2029       && XVECLEN (newpat, 0) == 2
2030       && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
2031       && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
2032       && asm_noperands (newpat) < 0)
2033     {
2034       rtx set0 = XVECEXP (newpat, 0, 0);
2035       rtx set1 = XVECEXP (newpat, 0, 1);
2036       rtx note;
2037
2038       if (((GET_CODE (SET_DEST (set1)) == REG
2039             && find_reg_note (i3, REG_UNUSED, SET_DEST (set1)))
2040            || (GET_CODE (SET_DEST (set1)) == SUBREG
2041                && find_reg_note (i3, REG_UNUSED, SUBREG_REG (SET_DEST (set1)))))
2042           && (!(note = find_reg_note (i3, REG_EH_REGION, NULL_RTX))
2043               || INTVAL (XEXP (note, 0)) <= 0)
2044           && ! side_effects_p (SET_SRC (set1)))
2045         {
2046           newpat = set0;
2047           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2048         }
2049
2050       else if (((GET_CODE (SET_DEST (set0)) == REG
2051                  && find_reg_note (i3, REG_UNUSED, SET_DEST (set0)))
2052                 || (GET_CODE (SET_DEST (set0)) == SUBREG
2053                     && find_reg_note (i3, REG_UNUSED,
2054                                       SUBREG_REG (SET_DEST (set0)))))
2055                && (!(note = find_reg_note (i3, REG_EH_REGION, NULL_RTX))
2056                    || INTVAL (XEXP (note, 0)) <= 0)
2057                && ! side_effects_p (SET_SRC (set0)))
2058         {
2059           newpat = set1;
2060           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2061
2062           if (insn_code_number >= 0)
2063             {
2064               /* If we will be able to accept this, we have made a
2065                  change to the destination of I3.  This requires us to
2066                  do a few adjustments.  */
2067
2068               PATTERN (i3) = newpat;
2069               adjust_for_new_dest (i3);
2070             }
2071         }
2072     }
2073
2074   /* If we were combining three insns and the result is a simple SET
2075      with no ASM_OPERANDS that wasn't recognized, try to split it into two
2076      insns.  There are two ways to do this.  It can be split using a
2077      machine-specific method (like when you have an addition of a large
2078      constant) or by combine in the function find_split_point.  */
2079
2080   if (i1 && insn_code_number < 0 && GET_CODE (newpat) == SET
2081       && asm_noperands (newpat) < 0)
2082     {
2083       rtx m_split, *split;
2084       rtx ni2dest = i2dest;
2085
2086       /* See if the MD file can split NEWPAT.  If it can't, see if letting it
2087          use I2DEST as a scratch register will help.  In the latter case,
2088          convert I2DEST to the mode of the source of NEWPAT if we can.  */
2089
2090       m_split = split_insns (newpat, i3);
2091
2092       /* We can only use I2DEST as a scratch reg if it doesn't overlap any
2093          inputs of NEWPAT.  */
2094
2095       /* ??? If I2DEST is not safe, and I1DEST exists, then it would be
2096          possible to try that as a scratch reg.  This would require adding
2097          more code to make it work though.  */
2098
2099       if (m_split == 0 && ! reg_overlap_mentioned_p (ni2dest, newpat))
2100         {
2101           /* If I2DEST is a hard register or the only use of a pseudo,
2102              we can change its mode.  */
2103           if (GET_MODE (SET_DEST (newpat)) != GET_MODE (i2dest)
2104               && GET_MODE (SET_DEST (newpat)) != VOIDmode
2105               && GET_CODE (i2dest) == REG
2106               && (REGNO (i2dest) < FIRST_PSEUDO_REGISTER
2107                   || (REG_N_SETS (REGNO (i2dest)) == 1 && ! added_sets_2
2108                       && ! REG_USERVAR_P (i2dest))))
2109             ni2dest = gen_rtx_REG (GET_MODE (SET_DEST (newpat)),
2110                                    REGNO (i2dest));
2111
2112           m_split = split_insns (gen_rtx_PARALLEL
2113                                  (VOIDmode,
2114                                   gen_rtvec (2, newpat,
2115                                              gen_rtx_CLOBBER (VOIDmode,
2116                                                               ni2dest))),
2117                                  i3);
2118           /* If the split with the mode-changed register didn't work, try
2119              the original register.  */
2120           if (! m_split && ni2dest != i2dest)
2121             {
2122               ni2dest = i2dest;
2123               m_split = split_insns (gen_rtx_PARALLEL
2124                                      (VOIDmode,
2125                                       gen_rtvec (2, newpat,
2126                                                  gen_rtx_CLOBBER (VOIDmode,
2127                                                                   i2dest))),
2128                                      i3);
2129             }
2130         }
2131
2132       if (m_split && NEXT_INSN (m_split) == NULL_RTX)
2133         {
2134           m_split = PATTERN (m_split);
2135           insn_code_number = recog_for_combine (&m_split, i3, &new_i3_notes);
2136           if (insn_code_number >= 0)
2137             newpat = m_split;
2138         }
2139       else if (m_split && NEXT_INSN (NEXT_INSN (m_split)) == NULL_RTX
2140                && (next_real_insn (i2) == i3
2141                    || ! use_crosses_set_p (PATTERN (m_split), INSN_CUID (i2))))
2142         {
2143           rtx i2set, i3set;
2144           rtx newi3pat = PATTERN (NEXT_INSN (m_split));
2145           newi2pat = PATTERN (m_split);
2146
2147           i3set = single_set (NEXT_INSN (m_split));
2148           i2set = single_set (m_split);
2149
2150           /* In case we changed the mode of I2DEST, replace it in the
2151              pseudo-register table here.  We can't do it above in case this
2152              code doesn't get executed and we do a split the other way.  */
2153
2154           if (REGNO (i2dest) >= FIRST_PSEUDO_REGISTER)
2155             SUBST (regno_reg_rtx[REGNO (i2dest)], ni2dest);
2156
2157           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2158
2159           /* If I2 or I3 has multiple SETs, we won't know how to track
2160              register status, so don't use these insns.  If I2's destination
2161              is used between I2 and I3, we also can't use these insns.  */
2162
2163           if (i2_code_number >= 0 && i2set && i3set
2164               && (next_real_insn (i2) == i3
2165                   || ! reg_used_between_p (SET_DEST (i2set), i2, i3)))
2166             insn_code_number = recog_for_combine (&newi3pat, i3,
2167                                                   &new_i3_notes);
2168           if (insn_code_number >= 0)
2169             newpat = newi3pat;
2170
2171           /* It is possible that both insns now set the destination of I3.
2172              If so, we must show an extra use of it.  */
2173
2174           if (insn_code_number >= 0)
2175             {
2176               rtx new_i3_dest = SET_DEST (i3set);
2177               rtx new_i2_dest = SET_DEST (i2set);
2178
2179               while (GET_CODE (new_i3_dest) == ZERO_EXTRACT
2180                      || GET_CODE (new_i3_dest) == STRICT_LOW_PART
2181                      || GET_CODE (new_i3_dest) == SUBREG)
2182                 new_i3_dest = XEXP (new_i3_dest, 0);
2183
2184               while (GET_CODE (new_i2_dest) == ZERO_EXTRACT
2185                      || GET_CODE (new_i2_dest) == STRICT_LOW_PART
2186                      || GET_CODE (new_i2_dest) == SUBREG)
2187                 new_i2_dest = XEXP (new_i2_dest, 0);
2188
2189               if (GET_CODE (new_i3_dest) == REG
2190                   && GET_CODE (new_i2_dest) == REG
2191                   && REGNO (new_i3_dest) == REGNO (new_i2_dest))
2192                 REG_N_SETS (REGNO (new_i2_dest))++;
2193             }
2194         }
2195
2196       /* If we can split it and use I2DEST, go ahead and see if that
2197          helps things be recognized.  Verify that none of the registers
2198          are set between I2 and I3.  */
2199       if (insn_code_number < 0 && (split = find_split_point (&newpat, i3)) != 0
2200 #ifdef HAVE_cc0
2201           && GET_CODE (i2dest) == REG
2202 #endif
2203           /* We need I2DEST in the proper mode.  If it is a hard register
2204              or the only use of a pseudo, we can change its mode.  */
2205           && (GET_MODE (*split) == GET_MODE (i2dest)
2206               || GET_MODE (*split) == VOIDmode
2207               || REGNO (i2dest) < FIRST_PSEUDO_REGISTER
2208               || (REG_N_SETS (REGNO (i2dest)) == 1 && ! added_sets_2
2209                   && ! REG_USERVAR_P (i2dest)))
2210           && (next_real_insn (i2) == i3
2211               || ! use_crosses_set_p (*split, INSN_CUID (i2)))
2212           /* We can't overwrite I2DEST if its value is still used by
2213              NEWPAT.  */
2214           && ! reg_referenced_p (i2dest, newpat))
2215         {
2216           rtx newdest = i2dest;
2217           enum rtx_code split_code = GET_CODE (*split);
2218           enum machine_mode split_mode = GET_MODE (*split);
2219
2220           /* Get NEWDEST as a register in the proper mode.  We have already
2221              validated that we can do this.  */
2222           if (GET_MODE (i2dest) != split_mode && split_mode != VOIDmode)
2223             {
2224               newdest = gen_rtx_REG (split_mode, REGNO (i2dest));
2225
2226               if (REGNO (i2dest) >= FIRST_PSEUDO_REGISTER)
2227                 SUBST (regno_reg_rtx[REGNO (i2dest)], newdest);
2228             }
2229
2230           /* If *SPLIT is a (mult FOO (const_int pow2)), convert it to
2231              an ASHIFT.  This can occur if it was inside a PLUS and hence
2232              appeared to be a memory address.  This is a kludge.  */
2233           if (split_code == MULT
2234               && GET_CODE (XEXP (*split, 1)) == CONST_INT
2235               && INTVAL (XEXP (*split, 1)) > 0
2236               && (i = exact_log2 (INTVAL (XEXP (*split, 1)))) >= 0)
2237             {
2238               SUBST (*split, gen_rtx_ASHIFT (split_mode,
2239                                              XEXP (*split, 0), GEN_INT (i)));
2240               /* Update split_code because we may not have a multiply
2241                  anymore.  */
2242               split_code = GET_CODE (*split);
2243             }
2244
2245 #ifdef INSN_SCHEDULING
2246           /* If *SPLIT is a paradoxical SUBREG, when we split it, it should
2247              be written as a ZERO_EXTEND.  */
2248           if (split_code == SUBREG && GET_CODE (SUBREG_REG (*split)) == MEM)
2249             {
2250 #ifdef LOAD_EXTEND_OP
2251               /* Or as a SIGN_EXTEND if LOAD_EXTEND_OP says that that's
2252                  what it really is.  */
2253               if (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (*split)))
2254                   == SIGN_EXTEND)
2255                 SUBST (*split, gen_rtx_SIGN_EXTEND (split_mode,
2256                                                     SUBREG_REG (*split)));
2257               else
2258 #endif
2259                 SUBST (*split, gen_rtx_ZERO_EXTEND (split_mode,
2260                                                     SUBREG_REG (*split)));
2261             }
2262 #endif
2263
2264           newi2pat = gen_rtx_SET (VOIDmode, newdest, *split);
2265           SUBST (*split, newdest);
2266           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2267
2268           /* If the split point was a MULT and we didn't have one before,
2269              don't use one now.  */
2270           if (i2_code_number >= 0 && ! (split_code == MULT && ! have_mult))
2271             insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2272         }
2273     }
2274
2275   /* Check for a case where we loaded from memory in a narrow mode and
2276      then sign extended it, but we need both registers.  In that case,
2277      we have a PARALLEL with both loads from the same memory location.
2278      We can split this into a load from memory followed by a register-register
2279      copy.  This saves at least one insn, more if register allocation can
2280      eliminate the copy.
2281
2282      We cannot do this if the destination of the first assignment is a
2283      condition code register or cc0.  We eliminate this case by making sure
2284      the SET_DEST and SET_SRC have the same mode.
2285
2286      We cannot do this if the destination of the second assignment is
2287      a register that we have already assumed is zero-extended.  Similarly
2288      for a SUBREG of such a register.  */
2289
2290   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
2291            && GET_CODE (newpat) == PARALLEL
2292            && XVECLEN (newpat, 0) == 2
2293            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
2294            && GET_CODE (SET_SRC (XVECEXP (newpat, 0, 0))) == SIGN_EXTEND
2295            && (GET_MODE (SET_DEST (XVECEXP (newpat, 0, 0)))
2296                == GET_MODE (SET_SRC (XVECEXP (newpat, 0, 0))))
2297            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
2298            && rtx_equal_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2299                            XEXP (SET_SRC (XVECEXP (newpat, 0, 0)), 0))
2300            && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2301                                    INSN_CUID (i2))
2302            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
2303            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
2304            && ! (temp = SET_DEST (XVECEXP (newpat, 0, 1)),
2305                  (GET_CODE (temp) == REG
2306                   && reg_stat[REGNO (temp)].nonzero_bits != 0
2307                   && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
2308                   && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
2309                   && (reg_stat[REGNO (temp)].nonzero_bits
2310                       != GET_MODE_MASK (word_mode))))
2311            && ! (GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) == SUBREG
2312                  && (temp = SUBREG_REG (SET_DEST (XVECEXP (newpat, 0, 1))),
2313                      (GET_CODE (temp) == REG
2314                       && reg_stat[REGNO (temp)].nonzero_bits != 0
2315                       && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
2316                       && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
2317                       && (reg_stat[REGNO (temp)].nonzero_bits
2318                           != GET_MODE_MASK (word_mode)))))
2319            && ! reg_overlap_mentioned_p (SET_DEST (XVECEXP (newpat, 0, 1)),
2320                                          SET_SRC (XVECEXP (newpat, 0, 1)))
2321            && ! find_reg_note (i3, REG_UNUSED,
2322                                SET_DEST (XVECEXP (newpat, 0, 0))))
2323     {
2324       rtx ni2dest;
2325
2326       newi2pat = XVECEXP (newpat, 0, 0);
2327       ni2dest = SET_DEST (XVECEXP (newpat, 0, 0));
2328       newpat = XVECEXP (newpat, 0, 1);
2329       SUBST (SET_SRC (newpat),
2330              gen_lowpart (GET_MODE (SET_SRC (newpat)), ni2dest));
2331       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2332
2333       if (i2_code_number >= 0)
2334         insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2335
2336       if (insn_code_number >= 0)
2337         {
2338           rtx insn;
2339           rtx link;
2340
2341           /* If we will be able to accept this, we have made a change to the
2342              destination of I3.  This requires us to do a few adjustments.  */
2343           PATTERN (i3) = newpat;
2344           adjust_for_new_dest (i3);
2345
2346           /* I3 now uses what used to be its destination and which is
2347              now I2's destination.  That means we need a LOG_LINK from
2348              I3 to I2.  But we used to have one, so we still will.
2349
2350              However, some later insn might be using I2's dest and have
2351              a LOG_LINK pointing at I3.  We must remove this link.
2352              The simplest way to remove the link is to point it at I1,
2353              which we know will be a NOTE.  */
2354
2355           for (insn = NEXT_INSN (i3);
2356                insn && (this_basic_block->next_bb == EXIT_BLOCK_PTR
2357                         || insn != BB_HEAD (this_basic_block->next_bb));
2358                insn = NEXT_INSN (insn))
2359             {
2360               if (INSN_P (insn) && reg_referenced_p (ni2dest, PATTERN (insn)))
2361                 {
2362                   for (link = LOG_LINKS (insn); link;
2363                        link = XEXP (link, 1))
2364                     if (XEXP (link, 0) == i3)
2365                       XEXP (link, 0) = i1;
2366
2367                   break;
2368                 }
2369             }
2370         }
2371     }
2372
2373   /* Similarly, check for a case where we have a PARALLEL of two independent
2374      SETs but we started with three insns.  In this case, we can do the sets
2375      as two separate insns.  This case occurs when some SET allows two
2376      other insns to combine, but the destination of that SET is still live.  */
2377
2378   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
2379            && GET_CODE (newpat) == PARALLEL
2380            && XVECLEN (newpat, 0) == 2
2381            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
2382            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != ZERO_EXTRACT
2383            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != STRICT_LOW_PART
2384            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
2385            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
2386            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
2387            && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2388                                    INSN_CUID (i2))
2389            /* Don't pass sets with (USE (MEM ...)) dests to the following.  */
2390            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != USE
2391            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != USE
2392            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 1)),
2393                                   XVECEXP (newpat, 0, 0))
2394            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 0)),
2395                                   XVECEXP (newpat, 0, 1))
2396            && ! (contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 0)))
2397                  && contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 1)))))
2398     {
2399       /* Normally, it doesn't matter which of the two is done first,
2400          but it does if one references cc0.  In that case, it has to
2401          be first.  */
2402 #ifdef HAVE_cc0
2403       if (reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 0)))
2404         {
2405           newi2pat = XVECEXP (newpat, 0, 0);
2406           newpat = XVECEXP (newpat, 0, 1);
2407         }
2408       else
2409 #endif
2410         {
2411           newi2pat = XVECEXP (newpat, 0, 1);
2412           newpat = XVECEXP (newpat, 0, 0);
2413         }
2414
2415       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
2416
2417       if (i2_code_number >= 0)
2418         insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
2419     }
2420
2421   /* If it still isn't recognized, fail and change things back the way they
2422      were.  */
2423   if ((insn_code_number < 0
2424        /* Is the result a reasonable ASM_OPERANDS?  */
2425        && (! check_asm_operands (newpat) || added_sets_1 || added_sets_2)))
2426     {
2427       undo_all ();
2428       return 0;
2429     }
2430
2431   /* If we had to change another insn, make sure it is valid also.  */
2432   if (undobuf.other_insn)
2433     {
2434       rtx other_pat = PATTERN (undobuf.other_insn);
2435       rtx new_other_notes;
2436       rtx note, next;
2437
2438       CLEAR_HARD_REG_SET (newpat_used_regs);
2439
2440       other_code_number = recog_for_combine (&other_pat, undobuf.other_insn,
2441                                              &new_other_notes);
2442
2443       if (other_code_number < 0 && ! check_asm_operands (other_pat))
2444         {
2445           undo_all ();
2446           return 0;
2447         }
2448
2449       PATTERN (undobuf.other_insn) = other_pat;
2450
2451       /* If any of the notes in OTHER_INSN were REG_UNUSED, ensure that they
2452          are still valid.  Then add any non-duplicate notes added by
2453          recog_for_combine.  */
2454       for (note = REG_NOTES (undobuf.other_insn); note; note = next)
2455         {
2456           next = XEXP (note, 1);
2457
2458           if (REG_NOTE_KIND (note) == REG_UNUSED
2459               && ! reg_set_p (XEXP (note, 0), PATTERN (undobuf.other_insn)))
2460             {
2461               if (GET_CODE (XEXP (note, 0)) == REG)
2462                 REG_N_DEATHS (REGNO (XEXP (note, 0)))--;
2463
2464               remove_note (undobuf.other_insn, note);
2465             }
2466         }
2467
2468       for (note = new_other_notes; note; note = XEXP (note, 1))
2469         if (GET_CODE (XEXP (note, 0)) == REG)
2470           REG_N_DEATHS (REGNO (XEXP (note, 0)))++;
2471
2472       distribute_notes (new_other_notes, undobuf.other_insn,
2473                         undobuf.other_insn, NULL_RTX);
2474     }
2475 #ifdef HAVE_cc0
2476   /* If I2 is the CC0 setter and I3 is the CC0 user then check whether
2477      they are adjacent to each other or not.  */
2478   {
2479     rtx p = prev_nonnote_insn (i3);
2480     if (p && p != i2 && GET_CODE (p) == INSN && newi2pat
2481         && sets_cc0_p (newi2pat))
2482       {
2483         undo_all ();
2484         return 0;
2485       }
2486   }
2487 #endif
2488
2489   /* We now know that we can do this combination.  Merge the insns and
2490      update the status of registers and LOG_LINKS.  */
2491
2492   {
2493     rtx i3notes, i2notes, i1notes = 0;
2494     rtx i3links, i2links, i1links = 0;
2495     rtx midnotes = 0;
2496     unsigned int regno;
2497
2498     /* Get the old REG_NOTES and LOG_LINKS from all our insns and
2499        clear them.  */
2500     i3notes = REG_NOTES (i3), i3links = LOG_LINKS (i3);
2501     i2notes = REG_NOTES (i2), i2links = LOG_LINKS (i2);
2502     if (i1)
2503       i1notes = REG_NOTES (i1), i1links = LOG_LINKS (i1);
2504
2505     /* Ensure that we do not have something that should not be shared but
2506        occurs multiple times in the new insns.  Check this by first
2507        resetting all the `used' flags and then copying anything is shared.  */
2508
2509     reset_used_flags (i3notes);
2510     reset_used_flags (i2notes);
2511     reset_used_flags (i1notes);
2512     reset_used_flags (newpat);
2513     reset_used_flags (newi2pat);
2514     if (undobuf.other_insn)
2515       reset_used_flags (PATTERN (undobuf.other_insn));
2516
2517     i3notes = copy_rtx_if_shared (i3notes);
2518     i2notes = copy_rtx_if_shared (i2notes);
2519     i1notes = copy_rtx_if_shared (i1notes);
2520     newpat = copy_rtx_if_shared (newpat);
2521     newi2pat = copy_rtx_if_shared (newi2pat);
2522     if (undobuf.other_insn)
2523       reset_used_flags (PATTERN (undobuf.other_insn));
2524
2525     INSN_CODE (i3) = insn_code_number;
2526     PATTERN (i3) = newpat;
2527
2528     if (GET_CODE (i3) == CALL_INSN && CALL_INSN_FUNCTION_USAGE (i3))
2529       {
2530         rtx call_usage = CALL_INSN_FUNCTION_USAGE (i3);
2531
2532         reset_used_flags (call_usage);
2533         call_usage = copy_rtx (call_usage);
2534
2535         if (substed_i2)
2536           replace_rtx (call_usage, i2dest, i2src);
2537
2538         if (substed_i1)
2539           replace_rtx (call_usage, i1dest, i1src);
2540
2541         CALL_INSN_FUNCTION_USAGE (i3) = call_usage;
2542       }
2543
2544     if (undobuf.other_insn)
2545       INSN_CODE (undobuf.other_insn) = other_code_number;
2546
2547     /* We had one special case above where I2 had more than one set and
2548        we replaced a destination of one of those sets with the destination
2549        of I3.  In that case, we have to update LOG_LINKS of insns later
2550        in this basic block.  Note that this (expensive) case is rare.
2551
2552        Also, in this case, we must pretend that all REG_NOTEs for I2
2553        actually came from I3, so that REG_UNUSED notes from I2 will be
2554        properly handled.  */
2555
2556     if (i3_subst_into_i2)
2557       {
2558         for (i = 0; i < XVECLEN (PATTERN (i2), 0); i++)
2559           if (GET_CODE (XVECEXP (PATTERN (i2), 0, i)) != USE
2560               && GET_CODE (SET_DEST (XVECEXP (PATTERN (i2), 0, i))) == REG
2561               && SET_DEST (XVECEXP (PATTERN (i2), 0, i)) != i2dest
2562               && ! find_reg_note (i2, REG_UNUSED,
2563                                   SET_DEST (XVECEXP (PATTERN (i2), 0, i))))
2564             for (temp = NEXT_INSN (i2);
2565                  temp && (this_basic_block->next_bb == EXIT_BLOCK_PTR
2566                           || BB_HEAD (this_basic_block) != temp);
2567                  temp = NEXT_INSN (temp))
2568               if (temp != i3 && INSN_P (temp))
2569                 for (link = LOG_LINKS (temp); link; link = XEXP (link, 1))
2570                   if (XEXP (link, 0) == i2)
2571                     XEXP (link, 0) = i3;
2572
2573         if (i3notes)
2574           {
2575             rtx link = i3notes;
2576             while (XEXP (link, 1))
2577               link = XEXP (link, 1);
2578             XEXP (link, 1) = i2notes;
2579           }
2580         else
2581           i3notes = i2notes;
2582         i2notes = 0;
2583       }
2584
2585     LOG_LINKS (i3) = 0;
2586     REG_NOTES (i3) = 0;
2587     LOG_LINKS (i2) = 0;
2588     REG_NOTES (i2) = 0;
2589
2590     if (newi2pat)
2591       {
2592         INSN_CODE (i2) = i2_code_number;
2593         PATTERN (i2) = newi2pat;
2594       }
2595     else
2596       {
2597         PUT_CODE (i2, NOTE);
2598         NOTE_LINE_NUMBER (i2) = NOTE_INSN_DELETED;
2599         NOTE_SOURCE_FILE (i2) = 0;
2600       }
2601
2602     if (i1)
2603       {
2604         LOG_LINKS (i1) = 0;
2605         REG_NOTES (i1) = 0;
2606         PUT_CODE (i1, NOTE);
2607         NOTE_LINE_NUMBER (i1) = NOTE_INSN_DELETED;
2608         NOTE_SOURCE_FILE (i1) = 0;
2609       }
2610
2611     /* Get death notes for everything that is now used in either I3 or
2612        I2 and used to die in a previous insn.  If we built two new
2613        patterns, move from I1 to I2 then I2 to I3 so that we get the
2614        proper movement on registers that I2 modifies.  */
2615
2616     if (newi2pat)
2617       {
2618         move_deaths (newi2pat, NULL_RTX, INSN_CUID (i1), i2, &midnotes);
2619         move_deaths (newpat, newi2pat, INSN_CUID (i1), i3, &midnotes);
2620       }
2621     else
2622       move_deaths (newpat, NULL_RTX, i1 ? INSN_CUID (i1) : INSN_CUID (i2),
2623                    i3, &midnotes);
2624
2625     /* Distribute all the LOG_LINKS and REG_NOTES from I1, I2, and I3.  */
2626     if (i3notes)
2627       distribute_notes (i3notes, i3, i3, newi2pat ? i2 : NULL_RTX);
2628     if (i2notes)
2629       distribute_notes (i2notes, i2, i3, newi2pat ? i2 : NULL_RTX);
2630     if (i1notes)
2631       distribute_notes (i1notes, i1, i3, newi2pat ? i2 : NULL_RTX);
2632     if (midnotes)
2633       distribute_notes (midnotes, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX);
2634
2635     /* Distribute any notes added to I2 or I3 by recog_for_combine.  We
2636        know these are REG_UNUSED and want them to go to the desired insn,
2637        so we always pass it as i3.  We have not counted the notes in
2638        reg_n_deaths yet, so we need to do so now.  */
2639
2640     if (newi2pat && new_i2_notes)
2641       {
2642         for (temp = new_i2_notes; temp; temp = XEXP (temp, 1))
2643           if (GET_CODE (XEXP (temp, 0)) == REG)
2644             REG_N_DEATHS (REGNO (XEXP (temp, 0)))++;
2645
2646         distribute_notes (new_i2_notes, i2, i2, NULL_RTX);
2647       }
2648
2649     if (new_i3_notes)
2650       {
2651         for (temp = new_i3_notes; temp; temp = XEXP (temp, 1))
2652           if (GET_CODE (XEXP (temp, 0)) == REG)
2653             REG_N_DEATHS (REGNO (XEXP (temp, 0)))++;
2654
2655         distribute_notes (new_i3_notes, i3, i3, NULL_RTX);
2656       }
2657
2658     /* If I3DEST was used in I3SRC, it really died in I3.  We may need to
2659        put a REG_DEAD note for it somewhere.  If NEWI2PAT exists and sets
2660        I3DEST, the death must be somewhere before I2, not I3.  If we passed I3
2661        in that case, it might delete I2.  Similarly for I2 and I1.
2662        Show an additional death due to the REG_DEAD note we make here.  If
2663        we discard it in distribute_notes, we will decrement it again.  */
2664
2665     if (i3dest_killed)
2666       {
2667         if (GET_CODE (i3dest_killed) == REG)
2668           REG_N_DEATHS (REGNO (i3dest_killed))++;
2669
2670         if (newi2pat && reg_set_p (i3dest_killed, newi2pat))
2671           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i3dest_killed,
2672                                                NULL_RTX),
2673                             NULL_RTX, i2, NULL_RTX);
2674         else
2675           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i3dest_killed,
2676                                                NULL_RTX),
2677                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX);
2678       }
2679
2680     if (i2dest_in_i2src)
2681       {
2682         if (GET_CODE (i2dest) == REG)
2683           REG_N_DEATHS (REGNO (i2dest))++;
2684
2685         if (newi2pat && reg_set_p (i2dest, newi2pat))
2686           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i2dest, NULL_RTX),
2687                             NULL_RTX, i2, NULL_RTX);
2688         else
2689           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i2dest, NULL_RTX),
2690                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX);
2691       }
2692
2693     if (i1dest_in_i1src)
2694       {
2695         if (GET_CODE (i1dest) == REG)
2696           REG_N_DEATHS (REGNO (i1dest))++;
2697
2698         if (newi2pat && reg_set_p (i1dest, newi2pat))
2699           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i1dest, NULL_RTX),
2700                             NULL_RTX, i2, NULL_RTX);
2701         else
2702           distribute_notes (gen_rtx_EXPR_LIST (REG_DEAD, i1dest, NULL_RTX),
2703                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX);
2704       }
2705
2706     distribute_links (i3links);
2707     distribute_links (i2links);
2708     distribute_links (i1links);
2709
2710     if (GET_CODE (i2dest) == REG)
2711       {
2712         rtx link;
2713         rtx i2_insn = 0, i2_val = 0, set;
2714
2715         /* The insn that used to set this register doesn't exist, and
2716            this life of the register may not exist either.  See if one of
2717            I3's links points to an insn that sets I2DEST.  If it does,
2718            that is now the last known value for I2DEST. If we don't update
2719            this and I2 set the register to a value that depended on its old
2720            contents, we will get confused.  If this insn is used, thing
2721            will be set correctly in combine_instructions.  */
2722
2723         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
2724           if ((set = single_set (XEXP (link, 0))) != 0
2725               && rtx_equal_p (i2dest, SET_DEST (set)))
2726             i2_insn = XEXP (link, 0), i2_val = SET_SRC (set);
2727
2728         record_value_for_reg (i2dest, i2_insn, i2_val);
2729
2730         /* If the reg formerly set in I2 died only once and that was in I3,
2731            zero its use count so it won't make `reload' do any work.  */
2732         if (! added_sets_2
2733             && (newi2pat == 0 || ! reg_mentioned_p (i2dest, newi2pat))
2734             && ! i2dest_in_i2src)
2735           {
2736             regno = REGNO (i2dest);
2737             REG_N_SETS (regno)--;
2738           }
2739       }
2740
2741     if (i1 && GET_CODE (i1dest) == REG)
2742       {
2743         rtx link;
2744         rtx i1_insn = 0, i1_val = 0, set;
2745
2746         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
2747           if ((set = single_set (XEXP (link, 0))) != 0
2748               && rtx_equal_p (i1dest, SET_DEST (set)))
2749             i1_insn = XEXP (link, 0), i1_val = SET_SRC (set);
2750
2751         record_value_for_reg (i1dest, i1_insn, i1_val);
2752
2753         regno = REGNO (i1dest);
2754         if (! added_sets_1 && ! i1dest_in_i1src)
2755           REG_N_SETS (regno)--;
2756       }
2757
2758     /* Update reg_stat[].nonzero_bits et al for any changes that may have
2759        been made to this insn.  The order of
2760        set_nonzero_bits_and_sign_copies() is important.  Because newi2pat
2761        can affect nonzero_bits of newpat */
2762     if (newi2pat)
2763       note_stores (newi2pat, set_nonzero_bits_and_sign_copies, NULL);
2764     note_stores (newpat, set_nonzero_bits_and_sign_copies, NULL);
2765
2766     /* Set new_direct_jump_p if a new return or simple jump instruction
2767        has been created.
2768
2769        If I3 is now an unconditional jump, ensure that it has a
2770        BARRIER following it since it may have initially been a
2771        conditional jump.  It may also be the last nonnote insn.  */
2772
2773     if (returnjump_p (i3) || any_uncondjump_p (i3))
2774       {
2775         *new_direct_jump_p = 1;
2776         mark_jump_label (PATTERN (i3), i3, 0);
2777
2778         if ((temp = next_nonnote_insn (i3)) == NULL_RTX
2779             || GET_CODE (temp) != BARRIER)
2780           emit_barrier_after (i3);
2781       }
2782
2783     if (undobuf.other_insn != NULL_RTX
2784         && (returnjump_p (undobuf.other_insn)
2785             || any_uncondjump_p (undobuf.other_insn)))
2786       {
2787         *new_direct_jump_p = 1;
2788
2789         if ((temp = next_nonnote_insn (undobuf.other_insn)) == NULL_RTX
2790             || GET_CODE (temp) != BARRIER)
2791           emit_barrier_after (undobuf.other_insn);
2792       }
2793
2794     /* An NOOP jump does not need barrier, but it does need cleaning up
2795        of CFG.  */
2796     if (GET_CODE (newpat) == SET
2797         && SET_SRC (newpat) == pc_rtx
2798         && SET_DEST (newpat) == pc_rtx)
2799       *new_direct_jump_p = 1;
2800   }
2801
2802   combine_successes++;
2803   undo_commit ();
2804
2805   if (added_links_insn
2806       && (newi2pat == 0 || INSN_CUID (added_links_insn) < INSN_CUID (i2))
2807       && INSN_CUID (added_links_insn) < INSN_CUID (i3))
2808     return added_links_insn;
2809   else
2810     return newi2pat ? i2 : i3;
2811 }
2812 \f
2813 /* Undo all the modifications recorded in undobuf.  */
2814
2815 static void
2816 undo_all (void)
2817 {
2818   struct undo *undo, *next;
2819
2820   for (undo = undobuf.undos; undo; undo = next)
2821     {
2822       next = undo->next;
2823       if (undo->is_int)
2824         *undo->where.i = undo->old_contents.i;
2825       else
2826         *undo->where.r = undo->old_contents.r;
2827
2828       undo->next = undobuf.frees;
2829       undobuf.frees = undo;
2830     }
2831
2832   undobuf.undos = 0;
2833 }
2834
2835 /* We've committed to accepting the changes we made.  Move all
2836    of the undos to the free list.  */
2837
2838 static void
2839 undo_commit (void)
2840 {
2841   struct undo *undo, *next;
2842
2843   for (undo = undobuf.undos; undo; undo = next)
2844     {
2845       next = undo->next;
2846       undo->next = undobuf.frees;
2847       undobuf.frees = undo;
2848     }
2849   undobuf.undos = 0;
2850 }
2851
2852 \f
2853 /* Find the innermost point within the rtx at LOC, possibly LOC itself,
2854    where we have an arithmetic expression and return that point.  LOC will
2855    be inside INSN.
2856
2857    try_combine will call this function to see if an insn can be split into
2858    two insns.  */
2859
2860 static rtx *
2861 find_split_point (rtx *loc, rtx insn)
2862 {
2863   rtx x = *loc;
2864   enum rtx_code code = GET_CODE (x);
2865   rtx *split;
2866   unsigned HOST_WIDE_INT len = 0;
2867   HOST_WIDE_INT pos = 0;
2868   int unsignedp = 0;
2869   rtx inner = NULL_RTX;
2870
2871   /* First special-case some codes.  */
2872   switch (code)
2873     {
2874     case SUBREG:
2875 #ifdef INSN_SCHEDULING
2876       /* If we are making a paradoxical SUBREG invalid, it becomes a split
2877          point.  */
2878       if (GET_CODE (SUBREG_REG (x)) == MEM)
2879         return loc;
2880 #endif
2881       return find_split_point (&SUBREG_REG (x), insn);
2882
2883     case MEM:
2884 #ifdef HAVE_lo_sum
2885       /* If we have (mem (const ..)) or (mem (symbol_ref ...)), split it
2886          using LO_SUM and HIGH.  */
2887       if (GET_CODE (XEXP (x, 0)) == CONST
2888           || GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
2889         {
2890           SUBST (XEXP (x, 0),
2891                  gen_rtx_LO_SUM (Pmode,
2892                                  gen_rtx_HIGH (Pmode, XEXP (x, 0)),
2893                                  XEXP (x, 0)));
2894           return &XEXP (XEXP (x, 0), 0);
2895         }
2896 #endif
2897
2898       /* If we have a PLUS whose second operand is a constant and the
2899          address is not valid, perhaps will can split it up using
2900          the machine-specific way to split large constants.  We use
2901          the first pseudo-reg (one of the virtual regs) as a placeholder;
2902          it will not remain in the result.  */
2903       if (GET_CODE (XEXP (x, 0)) == PLUS
2904           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
2905           && ! memory_address_p (GET_MODE (x), XEXP (x, 0)))
2906         {
2907           rtx reg = regno_reg_rtx[FIRST_PSEUDO_REGISTER];
2908           rtx seq = split_insns (gen_rtx_SET (VOIDmode, reg, XEXP (x, 0)),
2909                                  subst_insn);
2910
2911           /* This should have produced two insns, each of which sets our
2912              placeholder.  If the source of the second is a valid address,
2913              we can make put both sources together and make a split point
2914              in the middle.  */
2915
2916           if (seq
2917               && NEXT_INSN (seq) != NULL_RTX
2918               && NEXT_INSN (NEXT_INSN (seq)) == NULL_RTX
2919               && GET_CODE (seq) == INSN
2920               && GET_CODE (PATTERN (seq)) == SET
2921               && SET_DEST (PATTERN (seq)) == reg
2922               && ! reg_mentioned_p (reg,
2923                                     SET_SRC (PATTERN (seq)))
2924               && GET_CODE (NEXT_INSN (seq)) == INSN
2925               && GET_CODE (PATTERN (NEXT_INSN (seq))) == SET
2926               && SET_DEST (PATTERN (NEXT_INSN (seq))) == reg
2927               && memory_address_p (GET_MODE (x),
2928                                    SET_SRC (PATTERN (NEXT_INSN (seq)))))
2929             {
2930               rtx src1 = SET_SRC (PATTERN (seq));
2931               rtx src2 = SET_SRC (PATTERN (NEXT_INSN (seq)));
2932
2933               /* Replace the placeholder in SRC2 with SRC1.  If we can
2934                  find where in SRC2 it was placed, that can become our
2935                  split point and we can replace this address with SRC2.
2936                  Just try two obvious places.  */
2937
2938               src2 = replace_rtx (src2, reg, src1);
2939               split = 0;
2940               if (XEXP (src2, 0) == src1)
2941                 split = &XEXP (src2, 0);
2942               else if (GET_RTX_FORMAT (GET_CODE (XEXP (src2, 0)))[0] == 'e'
2943                        && XEXP (XEXP (src2, 0), 0) == src1)
2944                 split = &XEXP (XEXP (src2, 0), 0);
2945
2946               if (split)
2947                 {
2948                   SUBST (XEXP (x, 0), src2);
2949                   return split;
2950                 }
2951             }
2952
2953           /* If that didn't work, perhaps the first operand is complex and
2954              needs to be computed separately, so make a split point there.
2955              This will occur on machines that just support REG + CONST
2956              and have a constant moved through some previous computation.  */
2957
2958           else if (!OBJECT_P (XEXP (XEXP (x, 0), 0))
2959                    && ! (GET_CODE (XEXP (XEXP (x, 0), 0)) == SUBREG
2960                          && OBJECT_P (SUBREG_REG (XEXP (XEXP (x, 0), 0)))))
2961             return &XEXP (XEXP (x, 0), 0);
2962         }
2963       break;
2964
2965     case SET:
2966 #ifdef HAVE_cc0
2967       /* If SET_DEST is CC0 and SET_SRC is not an operand, a COMPARE, or a
2968          ZERO_EXTRACT, the most likely reason why this doesn't match is that
2969          we need to put the operand into a register.  So split at that
2970          point.  */
2971
2972       if (SET_DEST (x) == cc0_rtx
2973           && GET_CODE (SET_SRC (x)) != COMPARE
2974           && GET_CODE (SET_SRC (x)) != ZERO_EXTRACT
2975           && !OBJECT_P (SET_SRC (x))
2976           && ! (GET_CODE (SET_SRC (x)) == SUBREG
2977                 && OBJECT_P (SUBREG_REG (SET_SRC (x)))))
2978         return &SET_SRC (x);
2979 #endif
2980
2981       /* See if we can split SET_SRC as it stands.  */
2982       split = find_split_point (&SET_SRC (x), insn);
2983       if (split && split != &SET_SRC (x))
2984         return split;
2985
2986       /* See if we can split SET_DEST as it stands.  */
2987       split = find_split_point (&SET_DEST (x), insn);
2988       if (split && split != &SET_DEST (x))
2989         return split;
2990
2991       /* See if this is a bitfield assignment with everything constant.  If
2992          so, this is an IOR of an AND, so split it into that.  */
2993       if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
2994           && (GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)))
2995               <= HOST_BITS_PER_WIDE_INT)
2996           && GET_CODE (XEXP (SET_DEST (x), 1)) == CONST_INT
2997           && GET_CODE (XEXP (SET_DEST (x), 2)) == CONST_INT
2998           && GET_CODE (SET_SRC (x)) == CONST_INT
2999           && ((INTVAL (XEXP (SET_DEST (x), 1))
3000                + INTVAL (XEXP (SET_DEST (x), 2)))
3001               <= GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0))))
3002           && ! side_effects_p (XEXP (SET_DEST (x), 0)))
3003         {
3004           HOST_WIDE_INT pos = INTVAL (XEXP (SET_DEST (x), 2));
3005           unsigned HOST_WIDE_INT len = INTVAL (XEXP (SET_DEST (x), 1));
3006           unsigned HOST_WIDE_INT src = INTVAL (SET_SRC (x));
3007           rtx dest = XEXP (SET_DEST (x), 0);
3008           enum machine_mode mode = GET_MODE (dest);
3009           unsigned HOST_WIDE_INT mask = ((HOST_WIDE_INT) 1 << len) - 1;
3010
3011           if (BITS_BIG_ENDIAN)
3012             pos = GET_MODE_BITSIZE (mode) - len - pos;
3013
3014           if (src == mask)
3015             SUBST (SET_SRC (x),
3016                    gen_binary (IOR, mode, dest, GEN_INT (src << pos)));
3017           else
3018             SUBST (SET_SRC (x),
3019                    gen_binary (IOR, mode,
3020                                gen_binary (AND, mode, dest,
3021                                            gen_int_mode (~(mask << pos),
3022                                                          mode)),
3023                                GEN_INT (src << pos)));
3024
3025           SUBST (SET_DEST (x), dest);
3026
3027           split = find_split_point (&SET_SRC (x), insn);
3028           if (split && split != &SET_SRC (x))
3029             return split;
3030         }
3031
3032       /* Otherwise, see if this is an operation that we can split into two.
3033          If so, try to split that.  */
3034       code = GET_CODE (SET_SRC (x));
3035
3036       switch (code)
3037         {
3038         case AND:
3039           /* If we are AND'ing with a large constant that is only a single
3040              bit and the result is only being used in a context where we
3041              need to know if it is zero or nonzero, replace it with a bit
3042              extraction.  This will avoid the large constant, which might
3043              have taken more than one insn to make.  If the constant were
3044              not a valid argument to the AND but took only one insn to make,
3045              this is no worse, but if it took more than one insn, it will
3046              be better.  */
3047
3048           if (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
3049               && GET_CODE (XEXP (SET_SRC (x), 0)) == REG
3050               && (pos = exact_log2 (INTVAL (XEXP (SET_SRC (x), 1)))) >= 7
3051               && GET_CODE (SET_DEST (x)) == REG
3052               && (split = find_single_use (SET_DEST (x), insn, (rtx*) 0)) != 0
3053               && (GET_CODE (*split) == EQ || GET_CODE (*split) == NE)
3054               && XEXP (*split, 0) == SET_DEST (x)
3055               && XEXP (*split, 1) == const0_rtx)
3056             {
3057               rtx extraction = make_extraction (GET_MODE (SET_DEST (x)),
3058                                                 XEXP (SET_SRC (x), 0),
3059                                                 pos, NULL_RTX, 1, 1, 0, 0);
3060               if (extraction != 0)
3061                 {
3062                   SUBST (SET_SRC (x), extraction);
3063                   return find_split_point (loc, insn);
3064                 }
3065             }
3066           break;
3067
3068         case NE:
3069           /* If STORE_FLAG_VALUE is -1, this is (NE X 0) and only one bit of X
3070              is known to be on, this can be converted into a NEG of a shift.  */
3071           if (STORE_FLAG_VALUE == -1 && XEXP (SET_SRC (x), 1) == const0_rtx
3072               && GET_MODE (SET_SRC (x)) == GET_MODE (XEXP (SET_SRC (x), 0))
3073               && 1 <= (pos = exact_log2
3074                        (nonzero_bits (XEXP (SET_SRC (x), 0),
3075                                       GET_MODE (XEXP (SET_SRC (x), 0))))))
3076             {
3077               enum machine_mode mode = GET_MODE (XEXP (SET_SRC (x), 0));
3078
3079               SUBST (SET_SRC (x),
3080                      gen_rtx_NEG (mode,
3081                                   gen_rtx_LSHIFTRT (mode,
3082                                                     XEXP (SET_SRC (x), 0),
3083                                                     GEN_INT (pos))));
3084
3085               split = find_split_point (&SET_SRC (x), insn);
3086               if (split && split != &SET_SRC (x))
3087                 return split;
3088             }
3089           break;
3090
3091         case SIGN_EXTEND:
3092           inner = XEXP (SET_SRC (x), 0);
3093
3094           /* We can't optimize if either mode is a partial integer
3095              mode as we don't know how many bits are significant
3096              in those modes.  */
3097           if (GET_MODE_CLASS (GET_MODE (inner)) == MODE_PARTIAL_INT
3098               || GET_MODE_CLASS (GET_MODE (SET_SRC (x))) == MODE_PARTIAL_INT)
3099             break;
3100
3101           pos = 0;
3102           len = GET_MODE_BITSIZE (GET_MODE (inner));
3103           unsignedp = 0;
3104           break;
3105
3106         case SIGN_EXTRACT:
3107         case ZERO_EXTRACT:
3108           if (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
3109               && GET_CODE (XEXP (SET_SRC (x), 2)) == CONST_INT)
3110             {
3111               inner = XEXP (SET_SRC (x), 0);
3112               len = INTVAL (XEXP (SET_SRC (x), 1));
3113               pos = INTVAL (XEXP (SET_SRC (x), 2));
3114
3115               if (BITS_BIG_ENDIAN)
3116                 pos = GET_MODE_BITSIZE (GET_MODE (inner)) - len - pos;
3117               unsignedp = (code == ZERO_EXTRACT);
3118             }
3119           break;
3120
3121         default:
3122           break;
3123         }
3124
3125       if (len && pos >= 0 && pos + len <= GET_MODE_BITSIZE (GET_MODE (inner)))
3126         {
3127           enum machine_mode mode = GET_MODE (SET_SRC (x));
3128
3129           /* For unsigned, we have a choice of a shift followed by an
3130              AND or two shifts.  Use two shifts for field sizes where the
3131              constant might be too large.  We assume here that we can
3132              always at least get 8-bit constants in an AND insn, which is
3133              true for every current RISC.  */
3134
3135           if (unsignedp && len <= 8)
3136             {
3137               SUBST (SET_SRC (x),
3138                      gen_rtx_AND (mode,
3139                                   gen_rtx_LSHIFTRT
3140                                   (mode, gen_lowpart (mode, inner),
3141                                    GEN_INT (pos)),
3142                                   GEN_INT (((HOST_WIDE_INT) 1 << len) - 1)));
3143
3144               split = find_split_point (&SET_SRC (x), insn);
3145               if (split && split != &SET_SRC (x))
3146                 return split;
3147             }
3148           else
3149             {
3150               SUBST (SET_SRC (x),
3151                      gen_rtx_fmt_ee
3152                      (unsignedp ? LSHIFTRT : ASHIFTRT, mode,
3153                       gen_rtx_ASHIFT (mode,
3154                                       gen_lowpart (mode, inner),
3155                                       GEN_INT (GET_MODE_BITSIZE (mode)
3156                                                - len - pos)),
3157                       GEN_INT (GET_MODE_BITSIZE (mode) - len)));
3158
3159               split = find_split_point (&SET_SRC (x), insn);
3160               if (split && split != &SET_SRC (x))
3161                 return split;
3162             }
3163         }
3164
3165       /* See if this is a simple operation with a constant as the second
3166          operand.  It might be that this constant is out of range and hence
3167          could be used as a split point.  */
3168       if (BINARY_P (SET_SRC (x))
3169           && CONSTANT_P (XEXP (SET_SRC (x), 1))
3170           && (OBJECT_P (XEXP (SET_SRC (x), 0))
3171               || (GET_CODE (XEXP (SET_SRC (x), 0)) == SUBREG
3172                   && OBJECT_P (SUBREG_REG (XEXP (SET_SRC (x), 0))))))
3173         return &XEXP (SET_SRC (x), 1);
3174
3175       /* Finally, see if this is a simple operation with its first operand
3176          not in a register.  The operation might require this operand in a
3177          register, so return it as a split point.  We can always do this
3178          because if the first operand were another operation, we would have
3179          already found it as a split point.  */
3180       if ((BINARY_P (SET_SRC (x)) || UNARY_P (SET_SRC (x)))
3181           && ! register_operand (XEXP (SET_SRC (x), 0), VOIDmode))
3182         return &XEXP (SET_SRC (x), 0);
3183
3184       return 0;
3185
3186     case AND:
3187     case IOR:
3188       /* We write NOR as (and (not A) (not B)), but if we don't have a NOR,
3189          it is better to write this as (not (ior A B)) so we can split it.
3190          Similarly for IOR.  */
3191       if (GET_CODE (XEXP (x, 0)) == NOT && GET_CODE (XEXP (x, 1)) == NOT)
3192         {
3193           SUBST (*loc,
3194                  gen_rtx_NOT (GET_MODE (x),
3195                               gen_rtx_fmt_ee (code == IOR ? AND : IOR,
3196                                               GET_MODE (x),
3197                                               XEXP (XEXP (x, 0), 0),
3198                                               XEXP (XEXP (x, 1), 0))));
3199           return find_split_point (loc, insn);
3200         }
3201
3202       /* Many RISC machines have a large set of logical insns.  If the
3203          second operand is a NOT, put it first so we will try to split the
3204          other operand first.  */
3205       if (GET_CODE (XEXP (x, 1)) == NOT)
3206         {
3207           rtx tem = XEXP (x, 0);
3208           SUBST (XEXP (x, 0), XEXP (x, 1));
3209           SUBST (XEXP (x, 1), tem);
3210         }
3211       break;
3212
3213     default:
3214       break;
3215     }
3216
3217   /* Otherwise, select our actions depending on our rtx class.  */
3218   switch (GET_RTX_CLASS (code))
3219     {
3220     case RTX_BITFIELD_OPS:              /* This is ZERO_EXTRACT and SIGN_EXTRACT.  */
3221     case RTX_TERNARY:
3222       split = find_split_point (&XEXP (x, 2), insn);
3223       if (split)
3224         return split;
3225       /* ... fall through ...  */
3226     case RTX_BIN_ARITH:
3227     case RTX_COMM_ARITH:
3228     case RTX_COMPARE:
3229     case RTX_COMM_COMPARE:
3230       split = find_split_point (&XEXP (x, 1), insn);
3231       if (split)
3232         return split;
3233       /* ... fall through ...  */
3234     case RTX_UNARY:
3235       /* Some machines have (and (shift ...) ...) insns.  If X is not
3236          an AND, but XEXP (X, 0) is, use it as our split point.  */
3237       if (GET_CODE (x) != AND && GET_CODE (XEXP (x, 0)) == AND)
3238         return &XEXP (x, 0);
3239
3240       split = find_split_point (&XEXP (x, 0), insn);
3241       if (split)
3242         return split;
3243       return loc;
3244
3245     default:
3246       /* Otherwise, we don't have a split point.  */
3247       return 0;
3248     }
3249 }
3250 \f
3251 /* Throughout X, replace FROM with TO, and return the result.
3252    The result is TO if X is FROM;
3253    otherwise the result is X, but its contents may have been modified.
3254    If they were modified, a record was made in undobuf so that
3255    undo_all will (among other things) return X to its original state.
3256
3257    If the number of changes necessary is too much to record to undo,
3258    the excess changes are not made, so the result is invalid.
3259    The changes already made can still be undone.
3260    undobuf.num_undo is incremented for such changes, so by testing that
3261    the caller can tell whether the result is valid.
3262
3263    `n_occurrences' is incremented each time FROM is replaced.
3264
3265    IN_DEST is nonzero if we are processing the SET_DEST of a SET.
3266
3267    UNIQUE_COPY is nonzero if each substitution must be unique.  We do this
3268    by copying if `n_occurrences' is nonzero.  */
3269
3270 static rtx
3271 subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
3272 {
3273   enum rtx_code code = GET_CODE (x);
3274   enum machine_mode op0_mode = VOIDmode;
3275   const char *fmt;
3276   int len, i;
3277   rtx new;
3278
3279 /* Two expressions are equal if they are identical copies of a shared
3280    RTX or if they are both registers with the same register number
3281    and mode.  */
3282
3283 #define COMBINE_RTX_EQUAL_P(X,Y)                        \
3284   ((X) == (Y)                                           \
3285    || (GET_CODE (X) == REG && GET_CODE (Y) == REG       \
3286        && REGNO (X) == REGNO (Y) && GET_MODE (X) == GET_MODE (Y)))
3287
3288   if (! in_dest && COMBINE_RTX_EQUAL_P (x, from))
3289     {
3290       n_occurrences++;
3291       return (unique_copy && n_occurrences > 1 ? copy_rtx (to) : to);
3292     }
3293
3294   /* If X and FROM are the same register but different modes, they will
3295      not have been seen as equal above.  However, flow.c will make a
3296      LOG_LINKS entry for that case.  If we do nothing, we will try to
3297      rerecognize our original insn and, when it succeeds, we will
3298      delete the feeding insn, which is incorrect.
3299
3300      So force this insn not to match in this (rare) case.  */
3301   if (! in_dest && code == REG && GET_CODE (from) == REG
3302       && REGNO (x) == REGNO (from))
3303     return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
3304
3305   /* If this is an object, we are done unless it is a MEM or LO_SUM, both
3306      of which may contain things that can be combined.  */
3307   if (code != MEM && code != LO_SUM && OBJECT_P (x))
3308     return x;
3309
3310   /* It is possible to have a subexpression appear twice in the insn.
3311      Suppose that FROM is a register that appears within TO.
3312      Then, after that subexpression has been scanned once by `subst',
3313      the second time it is scanned, TO may be found.  If we were
3314      to scan TO here, we would find FROM within it and create a
3315      self-referent rtl structure which is completely wrong.  */
3316   if (COMBINE_RTX_EQUAL_P (x, to))
3317     return to;
3318
3319   /* Parallel asm_operands need special attention because all of the
3320      inputs are shared across the arms.  Furthermore, unsharing the
3321      rtl results in recognition failures.  Failure to handle this case
3322      specially can result in circular rtl.
3323
3324      Solve this by doing a normal pass across the first entry of the
3325      parallel, and only processing the SET_DESTs of the subsequent
3326      entries.  Ug.  */
3327
3328   if (code == PARALLEL
3329       && GET_CODE (XVECEXP (x, 0, 0)) == SET
3330       && GET_CODE (SET_SRC (XVECEXP (x, 0, 0))) == ASM_OPERANDS)
3331     {
3332       new = subst (XVECEXP (x, 0, 0), from, to, 0, unique_copy);
3333
3334       /* If this substitution failed, this whole thing fails.  */
3335       if (GET_CODE (new) == CLOBBER
3336           && XEXP (new, 0) == const0_rtx)
3337         return new;
3338
3339       SUBST (XVECEXP (x, 0, 0), new);
3340
3341       for (i = XVECLEN (x, 0) - 1; i >= 1; i--)
3342         {
3343           rtx dest = SET_DEST (XVECEXP (x, 0, i));
3344
3345           if (GET_CODE (dest) != REG
3346               && GET_CODE (dest) != CC0
3347               && GET_CODE (dest) != PC)
3348             {
3349               new = subst (dest, from, to, 0, unique_copy);
3350
3351               /* If this substitution failed, this whole thing fails.  */
3352               if (GET_CODE (new) == CLOBBER
3353                   && XEXP (new, 0) == const0_rtx)
3354                 return new;
3355
3356               SUBST (SET_DEST (XVECEXP (x, 0, i)), new);
3357             }
3358         }
3359     }
3360   else
3361     {
3362       len = GET_RTX_LENGTH (code);
3363       fmt = GET_RTX_FORMAT (code);
3364
3365       /* We don't need to process a SET_DEST that is a register, CC0,
3366          or PC, so set up to skip this common case.  All other cases
3367          where we want to suppress replacing something inside a
3368          SET_SRC are handled via the IN_DEST operand.  */
3369       if (code == SET
3370           && (GET_CODE (SET_DEST (x)) == REG
3371               || GET_CODE (SET_DEST (x)) == CC0
3372               || GET_CODE (SET_DEST (x)) == PC))
3373         fmt = "ie";
3374
3375       /* Get the mode of operand 0 in case X is now a SIGN_EXTEND of a
3376          constant.  */
3377       if (fmt[0] == 'e')
3378         op0_mode = GET_MODE (XEXP (x, 0));
3379
3380       for (i = 0; i < len; i++)
3381         {
3382           if (fmt[i] == 'E')
3383             {
3384               int j;
3385               for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3386                 {
3387                   if (COMBINE_RTX_EQUAL_P (XVECEXP (x, i, j), from))
3388                     {
3389                       new = (unique_copy && n_occurrences
3390                              ? copy_rtx (to) : to);
3391                       n_occurrences++;
3392                     }
3393                   else
3394                     {
3395                       new = subst (XVECEXP (x, i, j), from, to, 0,
3396                                    unique_copy);
3397
3398                       /* If this substitution failed, this whole thing
3399                          fails.  */
3400                       if (GET_CODE (new) == CLOBBER
3401                           && XEXP (new, 0) == const0_rtx)
3402                         return new;
3403                     }
3404
3405                   SUBST (XVECEXP (x, i, j), new);
3406                 }
3407             }
3408           else if (fmt[i] == 'e')
3409             {
3410               /* If this is a register being set, ignore it.  */
3411               new = XEXP (x, i);
3412               if (in_dest
3413                   && (code == SUBREG || code == STRICT_LOW_PART
3414                       || code == ZERO_EXTRACT)
3415                   && i == 0
3416                   && GET_CODE (new) == REG)
3417                 ;
3418
3419               else if (COMBINE_RTX_EQUAL_P (XEXP (x, i), from))
3420                 {
3421                   /* In general, don't install a subreg involving two
3422                      modes not tieable.  It can worsen register
3423                      allocation, and can even make invalid reload
3424                      insns, since the reg inside may need to be copied
3425                      from in the outside mode, and that may be invalid
3426                      if it is an fp reg copied in integer mode.
3427
3428                      We allow two exceptions to this: It is valid if
3429                      it is inside another SUBREG and the mode of that
3430                      SUBREG and the mode of the inside of TO is
3431                      tieable and it is valid if X is a SET that copies
3432                      FROM to CC0.  */
3433
3434                   if (GET_CODE (to) == SUBREG
3435                       && ! MODES_TIEABLE_P (GET_MODE (to),
3436                                             GET_MODE (SUBREG_REG (to)))
3437                       && ! (code == SUBREG
3438                             && MODES_TIEABLE_P (GET_MODE (x),
3439                                                 GET_MODE (SUBREG_REG (to))))
3440 #ifdef HAVE_cc0
3441                       && ! (code == SET && i == 1 && XEXP (x, 0) == cc0_rtx)
3442 #endif
3443                       )
3444                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
3445
3446 #ifdef CANNOT_CHANGE_MODE_CLASS
3447                   if (code == SUBREG
3448                       && GET_CODE (to) == REG
3449                       && REGNO (to) < FIRST_PSEUDO_REGISTER
3450                       && REG_CANNOT_CHANGE_MODE_P (REGNO (to),
3451                                                    GET_MODE (to),
3452                                                    GET_MODE (x)))
3453                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
3454 #endif
3455
3456                   new = (unique_copy && n_occurrences ? copy_rtx (to) : to);
3457                   n_occurrences++;
3458                 }
3459               else
3460                 /* If we are in a SET_DEST, suppress most cases unless we
3461                    have gone inside a MEM, in which case we want to
3462                    simplify the address.  We assume here that things that
3463                    are actually part of the destination have their inner
3464                    parts in the first expression.  This is true for SUBREG,
3465                    STRICT_LOW_PART, and ZERO_EXTRACT, which are the only
3466                    things aside from REG and MEM that should appear in a
3467                    SET_DEST.  */
3468                 new = subst (XEXP (x, i), from, to,
3469                              (((in_dest
3470                                 && (code == SUBREG || code == STRICT_LOW_PART
3471                                     || code == ZERO_EXTRACT))
3472                                || code == SET)
3473                               && i == 0), unique_copy);
3474
3475               /* If we found that we will have to reject this combination,
3476                  indicate that by returning the CLOBBER ourselves, rather than
3477                  an expression containing it.  This will speed things up as
3478                  well as prevent accidents where two CLOBBERs are considered
3479                  to be equal, thus producing an incorrect simplification.  */
3480
3481               if (GET_CODE (new) == CLOBBER && XEXP (new, 0) == const0_rtx)
3482                 return new;
3483
3484               if (GET_CODE (x) == SUBREG
3485                   && (GET_CODE (new) == CONST_INT
3486                       || GET_CODE (new) == CONST_DOUBLE))
3487                 {
3488                   enum machine_mode mode = GET_MODE (x);
3489
3490                   x = simplify_subreg (GET_MODE (x), new,
3491                                        GET_MODE (SUBREG_REG (x)),
3492                                        SUBREG_BYTE (x));
3493                   if (! x)
3494                     x = gen_rtx_CLOBBER (mode, const0_rtx);
3495                 }
3496               else if (GET_CODE (new) == CONST_INT
3497                        && GET_CODE (x) == ZERO_EXTEND)
3498                 {
3499                   x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
3500                                                 new, GET_MODE (XEXP (x, 0)));
3501                   if (! x)
3502                     abort ();
3503                 }
3504               else
3505                 SUBST (XEXP (x, i), new);
3506             }
3507         }
3508     }
3509
3510   /* Try to simplify X.  If the simplification changed the code, it is likely
3511      that further simplification will help, so loop, but limit the number
3512      of repetitions that will be performed.  */
3513
3514   for (i = 0; i < 4; i++)
3515     {
3516       /* If X is sufficiently simple, don't bother trying to do anything
3517          with it.  */
3518       if (code != CONST_INT && code != REG && code != CLOBBER)
3519         x = combine_simplify_rtx (x, op0_mode, in_dest);
3520
3521       if (GET_CODE (x) == code)
3522         break;
3523
3524       code = GET_CODE (x);
3525
3526       /* We no longer know the original mode of operand 0 since we
3527          have changed the form of X)  */
3528       op0_mode = VOIDmode;
3529     }
3530
3531   return x;
3532 }
3533 \f
3534 /* Simplify X, a piece of RTL.  We just operate on the expression at the
3535    outer level; call `subst' to simplify recursively.  Return the new
3536    expression.
3537
3538    OP0_MODE is the original mode of XEXP (x, 0).  IN_DEST is nonzero
3539    if we are inside a SET_DEST.  */
3540
3541 static rtx
3542 combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int in_dest)
3543 {
3544   enum rtx_code code = GET_CODE (x);
3545   enum machine_mode mode = GET_MODE (x);
3546   rtx temp;
3547   rtx reversed;
3548   int i;
3549
3550   /* If this is a commutative operation, put a constant last and a complex
3551      expression first.  We don't need to do this for comparisons here.  */
3552   if (COMMUTATIVE_ARITH_P (x)
3553       && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
3554     {
3555       temp = XEXP (x, 0);
3556       SUBST (XEXP (x, 0), XEXP (x, 1));
3557       SUBST (XEXP (x, 1), temp);
3558     }
3559
3560   /* If this is a PLUS, MINUS, or MULT, and the first operand is the
3561      sign extension of a PLUS with a constant, reverse the order of the sign
3562      extension and the addition. Note that this not the same as the original
3563      code, but overflow is undefined for signed values.  Also note that the
3564      PLUS will have been partially moved "inside" the sign-extension, so that
3565      the first operand of X will really look like:
3566          (ashiftrt (plus (ashift A C4) C5) C4).
3567      We convert this to
3568          (plus (ashiftrt (ashift A C4) C2) C4)
3569      and replace the first operand of X with that expression.  Later parts
3570      of this function may simplify the expression further.
3571
3572      For example, if we start with (mult (sign_extend (plus A C1)) C2),
3573      we swap the SIGN_EXTEND and PLUS.  Later code will apply the
3574      distributive law to produce (plus (mult (sign_extend X) C1) C3).
3575
3576      We do this to simplify address expressions.  */
3577
3578   if ((code == PLUS || code == MINUS || code == MULT)
3579       && GET_CODE (XEXP (x, 0)) == ASHIFTRT
3580       && GET_CODE (XEXP (XEXP (x, 0), 0)) == PLUS
3581       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == ASHIFT
3582       && GET_CODE (XEXP (XEXP (XEXP (XEXP (x, 0), 0), 0), 1)) == CONST_INT
3583       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3584       && XEXP (XEXP (XEXP (XEXP (x, 0), 0), 0), 1) == XEXP (XEXP (x, 0), 1)
3585       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
3586       && (temp = simplify_binary_operation (ASHIFTRT, mode,
3587                                             XEXP (XEXP (XEXP (x, 0), 0), 1),
3588                                             XEXP (XEXP (x, 0), 1))) != 0)
3589     {
3590       rtx new
3591         = simplify_shift_const (NULL_RTX, ASHIFT, mode,
3592                                 XEXP (XEXP (XEXP (XEXP (x, 0), 0), 0), 0),
3593                                 INTVAL (XEXP (XEXP (x, 0), 1)));
3594
3595       new = simplify_shift_const (NULL_RTX, ASHIFTRT, mode, new,
3596                                   INTVAL (XEXP (XEXP (x, 0), 1)));
3597
3598       SUBST (XEXP (x, 0), gen_binary (PLUS, mode, new, temp));
3599     }
3600
3601   /* If this is a simple operation applied to an IF_THEN_ELSE, try
3602      applying it to the arms of the IF_THEN_ELSE.  This often simplifies
3603      things.  Check for cases where both arms are testing the same
3604      condition.
3605
3606      Don't do anything if all operands are very simple.  */
3607
3608   if ((BINARY_P (x)
3609        && ((!OBJECT_P (XEXP (x, 0))
3610             && ! (GET_CODE (XEXP (x, 0)) == SUBREG
3611                   && OBJECT_P (SUBREG_REG (XEXP (x, 0)))))
3612            || (!OBJECT_P (XEXP (x, 1))
3613                && ! (GET_CODE (XEXP (x, 1)) == SUBREG
3614                      && OBJECT_P (SUBREG_REG (XEXP (x, 1)))))))
3615       || (UNARY_P (x)
3616           && (!OBJECT_P (XEXP (x, 0))
3617                && ! (GET_CODE (XEXP (x, 0)) == SUBREG
3618                      && OBJECT_P (SUBREG_REG (XEXP (x, 0)))))))
3619     {
3620       rtx cond, true_rtx, false_rtx;
3621
3622       cond = if_then_else_cond (x, &true_rtx, &false_rtx);
3623       if (cond != 0
3624           /* If everything is a comparison, what we have is highly unlikely
3625              to be simpler, so don't use it.  */
3626           && ! (COMPARISON_P (x)
3627                 && (COMPARISON_P (true_rtx) || COMPARISON_P (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 && COMPARISON_P (cond))
3633             return x;
3634
3635           /* Simplify the alternative arms; this may collapse the true and
3636              false arms to store-flag values.  Be careful to use copy_rtx
3637              here since true_rtx or false_rtx might share RTL with x as a
3638              result of the if_then_else_cond call above.  */
3639           true_rtx = subst (copy_rtx (true_rtx), pc_rtx, pc_rtx, 0, 0);
3640           false_rtx = subst (copy_rtx (false_rtx), pc_rtx, pc_rtx, 0, 0);
3641
3642           /* If true_rtx and false_rtx are not general_operands, an if_then_else
3643              is unlikely to be simpler.  */
3644           if (general_operand (true_rtx, VOIDmode)
3645               && general_operand (false_rtx, VOIDmode))
3646             {
3647               enum rtx_code reversed;
3648
3649               /* Restarting if we generate a store-flag expression will cause
3650                  us to loop.  Just drop through in this case.  */
3651
3652               /* If the result values are STORE_FLAG_VALUE and zero, we can
3653                  just make the comparison operation.  */
3654               if (true_rtx == const_true_rtx && false_rtx == const0_rtx)
3655                 x = gen_binary (cond_code, mode, cond, cop1);
3656               else if (true_rtx == const0_rtx && false_rtx == const_true_rtx
3657                        && ((reversed = reversed_comparison_code_parts
3658                                         (cond_code, cond, cop1, NULL))
3659                            != UNKNOWN))
3660                 x = gen_binary (reversed, mode, cond, cop1);
3661
3662               /* Likewise, we can make the negate of a comparison operation
3663                  if the result values are - STORE_FLAG_VALUE and zero.  */
3664               else if (GET_CODE (true_rtx) == CONST_INT
3665                        && INTVAL (true_rtx) == - STORE_FLAG_VALUE
3666                        && false_rtx == const0_rtx)
3667                 x = simplify_gen_unary (NEG, mode,
3668                                         gen_binary (cond_code, mode, cond,
3669                                                     cop1),
3670                                         mode);
3671               else if (GET_CODE (false_rtx) == CONST_INT
3672                        && INTVAL (false_rtx) == - STORE_FLAG_VALUE
3673                        && true_rtx == const0_rtx
3674                        && ((reversed = reversed_comparison_code_parts
3675                                         (cond_code, cond, cop1, NULL))
3676                            != UNKNOWN))
3677                 x = simplify_gen_unary (NEG, mode,
3678                                         gen_binary (reversed, mode,
3679                                                     cond, cop1),
3680                                         mode);
3681               else
3682                 return gen_rtx_IF_THEN_ELSE (mode,
3683                                              gen_binary (cond_code, VOIDmode,
3684                                                          cond, cop1),
3685                                              true_rtx, false_rtx);
3686
3687               code = GET_CODE (x);
3688               op0_mode = VOIDmode;
3689             }
3690         }
3691     }
3692
3693   /* Try to fold this expression in case we have constants that weren't
3694      present before.  */
3695   temp = 0;
3696   switch (GET_RTX_CLASS (code))
3697     {
3698     case RTX_UNARY:
3699       if (op0_mode == VOIDmode)
3700         op0_mode = GET_MODE (XEXP (x, 0));
3701       temp = simplify_unary_operation (code, mode, XEXP (x, 0), op0_mode);
3702       break;
3703     case RTX_COMPARE:
3704     case RTX_COMM_COMPARE:
3705       {
3706         enum machine_mode cmp_mode = GET_MODE (XEXP (x, 0));
3707         if (cmp_mode == VOIDmode)
3708           {
3709             cmp_mode = GET_MODE (XEXP (x, 1));
3710             if (cmp_mode == VOIDmode)
3711               cmp_mode = op0_mode;
3712           }
3713         temp = simplify_relational_operation (code, mode, cmp_mode,
3714                                               XEXP (x, 0), XEXP (x, 1));
3715       }
3716       break;
3717     case RTX_COMM_ARITH:
3718     case RTX_BIN_ARITH:
3719       temp = simplify_binary_operation (code, mode, XEXP (x, 0), XEXP (x, 1));
3720       break;
3721     case RTX_BITFIELD_OPS:
3722     case RTX_TERNARY:
3723       temp = simplify_ternary_operation (code, mode, op0_mode, XEXP (x, 0),
3724                                          XEXP (x, 1), XEXP (x, 2));
3725       break;
3726     default:
3727       break;
3728     }
3729
3730   if (temp)
3731     {
3732       x = temp;
3733       code = GET_CODE (temp);
3734       op0_mode = VOIDmode;
3735       mode = GET_MODE (temp);
3736     }
3737
3738   /* First see if we can apply the inverse distributive law.  */
3739   if (code == PLUS || code == MINUS
3740       || code == AND || code == IOR || code == XOR)
3741     {
3742       x = apply_distributive_law (x);
3743       code = GET_CODE (x);
3744       op0_mode = VOIDmode;
3745     }
3746
3747   /* If CODE is an associative operation not otherwise handled, see if we
3748      can associate some operands.  This can win if they are constants or
3749      if they are logically related (i.e. (a & b) & a).  */
3750   if ((code == PLUS || code == MINUS || code == MULT || code == DIV
3751        || code == AND || code == IOR || code == XOR
3752        || code == SMAX || code == SMIN || code == UMAX || code == UMIN)
3753       && ((INTEGRAL_MODE_P (mode) && code != DIV)
3754           || (flag_unsafe_math_optimizations && FLOAT_MODE_P (mode))))
3755     {
3756       if (GET_CODE (XEXP (x, 0)) == code)
3757         {
3758           rtx other = XEXP (XEXP (x, 0), 0);
3759           rtx inner_op0 = XEXP (XEXP (x, 0), 1);
3760           rtx inner_op1 = XEXP (x, 1);
3761           rtx inner;
3762
3763           /* Make sure we pass the constant operand if any as the second
3764              one if this is a commutative operation.  */
3765           if (CONSTANT_P (inner_op0) && COMMUTATIVE_ARITH_P (x))
3766             {
3767               rtx tem = inner_op0;
3768               inner_op0 = inner_op1;
3769               inner_op1 = tem;
3770             }
3771           inner = simplify_binary_operation (code == MINUS ? PLUS
3772                                              : code == DIV ? MULT
3773                                              : code,
3774                                              mode, inner_op0, inner_op1);
3775
3776           /* For commutative operations, try the other pair if that one
3777              didn't simplify.  */
3778           if (inner == 0 && COMMUTATIVE_ARITH_P (x))
3779             {
3780               other = XEXP (XEXP (x, 0), 1);
3781               inner = simplify_binary_operation (code, mode,
3782                                                  XEXP (XEXP (x, 0), 0),
3783                                                  XEXP (x, 1));
3784             }
3785
3786           if (inner)
3787             return gen_binary (code, mode, other, inner);
3788         }
3789     }
3790
3791   /* A little bit of algebraic simplification here.  */
3792   switch (code)
3793     {
3794     case MEM:
3795       /* Ensure that our address has any ASHIFTs converted to MULT in case
3796          address-recognizing predicates are called later.  */
3797       temp = make_compound_operation (XEXP (x, 0), MEM);
3798       SUBST (XEXP (x, 0), temp);
3799       break;
3800
3801     case SUBREG:
3802       if (op0_mode == VOIDmode)
3803         op0_mode = GET_MODE (SUBREG_REG (x));
3804
3805       /* See if this can be moved to simplify_subreg.  */
3806       if (CONSTANT_P (SUBREG_REG (x))
3807           && subreg_lowpart_offset (mode, op0_mode) == SUBREG_BYTE (x)
3808              /* Don't call gen_lowpart if the inner mode
3809                 is VOIDmode and we cannot simplify it, as SUBREG without
3810                 inner mode is invalid.  */
3811           && (GET_MODE (SUBREG_REG (x)) != VOIDmode
3812               || gen_lowpart_common (mode, SUBREG_REG (x))))
3813         return gen_lowpart (mode, SUBREG_REG (x));
3814
3815       if (GET_MODE_CLASS (GET_MODE (SUBREG_REG (x))) == MODE_CC)
3816         break;
3817       {
3818         rtx temp;
3819         temp = simplify_subreg (mode, SUBREG_REG (x), op0_mode,
3820                                 SUBREG_BYTE (x));
3821         if (temp)
3822           return temp;
3823       }