OSDN Git Service

PR middle-end/22239
[pf3gnuchains/gcc-fork.git] / gcc / loop.c
1 /* Perform various loop optimizations, including strength reduction.
2    Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995,
3    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING.  If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA.  */
22
23 /* This is the loop optimization pass of the compiler.
24    It finds invariant computations within loops and moves them
25    to the beginning of the loop.  Then it identifies basic and
26    general induction variables.
27
28    Basic induction variables (BIVs) are a pseudo registers which are set within
29    a loop only by incrementing or decrementing its value.  General induction
30    variables (GIVs) are pseudo registers with a value which is a linear function
31    of a basic induction variable.  BIVs are recognized by `basic_induction_var';
32    GIVs by `general_induction_var'.
33
34    Once induction variables are identified, strength reduction is applied to the
35    general induction variables, and induction variable elimination is applied to
36    the basic induction variables.
37
38    It also finds cases where
39    a register is set within the loop by zero-extending a narrower value
40    and changes these to zero the entire register once before the loop
41    and merely copy the low part within the loop.
42
43    Most of the complexity is in heuristics to decide when it is worth
44    while to do these things.  */
45
46 #include "config.h"
47 #include "system.h"
48 #include "coretypes.h"
49 #include "tm.h"
50 #include "rtl.h"
51 #include "tm_p.h"
52 #include "function.h"
53 #include "expr.h"
54 #include "hard-reg-set.h"
55 #include "basic-block.h"
56 #include "insn-config.h"
57 #include "regs.h"
58 #include "recog.h"
59 #include "flags.h"
60 #include "real.h"
61 #include "cselib.h"
62 #include "except.h"
63 #include "toplev.h"
64 #include "predict.h"
65 #include "insn-flags.h"
66 #include "optabs.h"
67 #include "cfgloop.h"
68 #include "ggc.h"
69 #include "timevar.h"
70 #include "tree-pass.h"
71
72 /* Get the loop info pointer of a loop.  */
73 #define LOOP_INFO(LOOP) ((struct loop_info *) (LOOP)->aux)
74
75 /* Get a pointer to the loop movables structure.  */
76 #define LOOP_MOVABLES(LOOP) (&LOOP_INFO (LOOP)->movables)
77
78 /* Get a pointer to the loop registers structure.  */
79 #define LOOP_REGS(LOOP) (&LOOP_INFO (LOOP)->regs)
80
81 /* Get a pointer to the loop induction variables structure.  */
82 #define LOOP_IVS(LOOP) (&LOOP_INFO (LOOP)->ivs)
83
84 /* Get the luid of an insn.  Catch the error of trying to reference the LUID
85    of an insn added during loop, since these don't have LUIDs.  */
86
87 #define INSN_LUID(INSN)                 \
88   (gcc_assert (INSN_UID (INSN) < max_uid_for_loop), uid_luid[INSN_UID (INSN)])
89
90 #define REGNO_FIRST_LUID(REGNO)                 \
91   (REGNO_FIRST_UID (REGNO) < max_uid_for_loop   \
92         ? uid_luid[REGNO_FIRST_UID (REGNO)]     \
93         : 0)
94 #define REGNO_LAST_LUID(REGNO)                  \
95   (REGNO_LAST_UID (REGNO) < max_uid_for_loop    \
96         ? uid_luid[REGNO_LAST_UID (REGNO)]      \
97         : INT_MAX)
98
99 /* A "basic induction variable" or biv is a pseudo reg that is set
100    (within this loop) only by incrementing or decrementing it.  */
101 /* A "general induction variable" or giv is a pseudo reg whose
102    value is a linear function of a biv.  */
103
104 /* Bivs are recognized by `basic_induction_var';
105    Givs by `general_induction_var'.  */
106
107 /* An enum for the two different types of givs, those that are used
108    as memory addresses and those that are calculated into registers.  */
109 enum g_types
110 {
111   DEST_ADDR,
112   DEST_REG
113 };
114
115
116 /* A `struct induction' is created for every instruction that sets
117    an induction variable (either a biv or a giv).  */
118
119 struct induction
120 {
121   rtx insn;                     /* The insn that sets a biv or giv */
122   rtx new_reg;                  /* New register, containing strength reduced
123                                    version of this giv.  */
124   rtx src_reg;                  /* Biv from which this giv is computed.
125                                    (If this is a biv, then this is the biv.) */
126   enum g_types giv_type;        /* Indicate whether DEST_ADDR or DEST_REG */
127   rtx dest_reg;                 /* Destination register for insn: this is the
128                                    register which was the biv or giv.
129                                    For a biv, this equals src_reg.
130                                    For a DEST_ADDR type giv, this is 0.  */
131   rtx *location;                /* Place in the insn where this giv occurs.
132                                    If GIV_TYPE is DEST_REG, this is 0.  */
133                                 /* For a biv, this is the place where add_val
134                                    was found.  */
135   enum machine_mode mode;       /* The mode of this biv or giv */
136   rtx mem;                      /* For DEST_ADDR, the memory object.  */
137   rtx mult_val;                 /* Multiplicative factor for src_reg.  */
138   rtx add_val;                  /* Additive constant for that product.  */
139   int benefit;                  /* Gain from eliminating this insn.  */
140   rtx final_value;              /* If the giv is used outside the loop, and its
141                                    final value could be calculated, it is put
142                                    here, and the giv is made replaceable.  Set
143                                    the giv to this value before the loop.  */
144   unsigned combined_with;       /* The number of givs this giv has been
145                                    combined with.  If nonzero, this giv
146                                    cannot combine with any other giv.  */
147   unsigned replaceable : 1;     /* 1 if we can substitute the strength-reduced
148                                    variable for the original variable.
149                                    0 means they must be kept separate and the
150                                    new one must be copied into the old pseudo
151                                    reg each time the old one is set.  */
152   unsigned not_replaceable : 1; /* Used to prevent duplicating work.  This is
153                                    1 if we know that the giv definitely can
154                                    not be made replaceable, in which case we
155                                    don't bother checking the variable again
156                                    even if further info is available.
157                                    Both this and the above can be zero.  */
158   unsigned ignore : 1;          /* 1 prohibits further processing of giv */
159   unsigned always_computable : 1;/* 1 if this value is computable every
160                                     iteration.  */
161   unsigned always_executed : 1; /* 1 if this set occurs each iteration.  */
162   unsigned maybe_multiple : 1;  /* Only used for a biv and  1 if this biv
163                                    update may be done multiple times per
164                                    iteration.  */
165   unsigned cant_derive : 1;     /* For giv's, 1 if this giv cannot derive
166                                    another giv.  This occurs in many cases
167                                    where a giv's lifetime spans an update to
168                                    a biv.  */
169   unsigned maybe_dead : 1;      /* 1 if this giv might be dead.  In that case,
170                                    we won't use it to eliminate a biv, it
171                                    would probably lose.  */
172   unsigned auto_inc_opt : 1;    /* 1 if this giv had its increment output next
173                                    to it to try to form an auto-inc address.  */
174   unsigned shared : 1;
175   unsigned no_const_addval : 1; /* 1 if add_val does not contain a const.  */
176   int lifetime;                 /* Length of life of this giv */
177   rtx derive_adjustment;        /* If nonzero, is an adjustment to be
178                                    subtracted from add_val when this giv
179                                    derives another.  This occurs when the
180                                    giv spans a biv update by incrementation.  */
181   rtx ext_dependent;            /* If nonzero, is a sign or zero extension
182                                    if a biv on which this giv is dependent.  */
183   struct induction *next_iv;    /* For givs, links together all givs that are
184                                    based on the same biv.  For bivs, links
185                                    together all biv entries that refer to the
186                                    same biv register.  */
187   struct induction *same;       /* For givs, if the giv has been combined with
188                                    another giv, this points to the base giv.
189                                    The base giv will have COMBINED_WITH nonzero.
190                                    For bivs, if the biv has the same LOCATION
191                                    than another biv, this points to the base
192                                    biv.  */
193   struct induction *same_insn;  /* If there are multiple identical givs in
194                                    the same insn, then all but one have this
195                                    field set, and they all point to the giv
196                                    that doesn't have this field set.  */
197   rtx last_use;                 /* For a giv made from a biv increment, this is
198                                    a substitute for the lifetime information.  */
199 };
200
201
202 /* A `struct iv_class' is created for each biv.  */
203
204 struct iv_class
205 {
206   unsigned int regno;           /* Pseudo reg which is the biv.  */
207   int biv_count;                /* Number of insns setting this reg.  */
208   struct induction *biv;        /* List of all insns that set this reg.  */
209   int giv_count;                /* Number of DEST_REG givs computed from this
210                                    biv.  The resulting count is only used in
211                                    check_dbra_loop.  */
212   struct induction *giv;        /* List of all insns that compute a giv
213                                    from this reg.  */
214   int total_benefit;            /* Sum of BENEFITs of all those givs.  */
215   rtx initial_value;            /* Value of reg at loop start.  */
216   rtx initial_test;             /* Test performed on BIV before loop.  */
217   rtx final_value;              /* Value of reg at loop end, if known.  */
218   struct iv_class *next;        /* Links all class structures together.  */
219   rtx init_insn;                /* insn which initializes biv, 0 if none.  */
220   rtx init_set;                 /* SET of INIT_INSN, if any.  */
221   unsigned incremented : 1;     /* 1 if somewhere incremented/decremented */
222   unsigned eliminable : 1;      /* 1 if plausible candidate for
223                                    elimination.  */
224   unsigned nonneg : 1;          /* 1 if we added a REG_NONNEG note for
225                                    this.  */
226   unsigned reversed : 1;        /* 1 if we reversed the loop that this
227                                    biv controls.  */
228   unsigned all_reduced : 1;     /* 1 if all givs using this biv have
229                                    been reduced.  */
230 };
231
232
233 /* Definitions used by the basic induction variable discovery code.  */
234 enum iv_mode
235 {
236   UNKNOWN_INDUCT,
237   BASIC_INDUCT,
238   NOT_BASIC_INDUCT,
239   GENERAL_INDUCT
240 };
241
242
243 /* A `struct iv' is created for every register.  */
244
245 struct iv
246 {
247   enum iv_mode type;
248   union
249   {
250     struct iv_class *class;
251     struct induction *info;
252   } iv;
253 };
254
255
256 #define REG_IV_TYPE(ivs, n) ivs->regs[n].type
257 #define REG_IV_INFO(ivs, n) ivs->regs[n].iv.info
258 #define REG_IV_CLASS(ivs, n) ivs->regs[n].iv.class
259
260
261 struct loop_ivs
262 {
263   /* Indexed by register number, contains pointer to `struct
264      iv' if register is an induction variable.  */
265   struct iv *regs;
266
267   /* Size of regs array.  */
268   unsigned int n_regs;
269
270   /* The head of a list which links together (via the next field)
271      every iv class for the current loop.  */
272   struct iv_class *list;
273 };
274
275
276 typedef struct loop_mem_info
277 {
278   rtx mem;      /* The MEM itself.  */
279   rtx reg;      /* Corresponding pseudo, if any.  */
280   int optimize; /* Nonzero if we can optimize access to this MEM.  */
281 } loop_mem_info;
282
283
284
285 struct loop_reg
286 {
287   /* Number of times the reg is set during the loop being scanned.
288      During code motion, a negative value indicates a reg that has
289      been made a candidate; in particular -2 means that it is an
290      candidate that we know is equal to a constant and -1 means that
291      it is a candidate not known equal to a constant.  After code
292      motion, regs moved have 0 (which is accurate now) while the
293      failed candidates have the original number of times set.
294
295      Therefore, at all times, == 0 indicates an invariant register;
296      < 0 a conditionally invariant one.  */
297   int set_in_loop;
298
299   /* Original value of set_in_loop; same except that this value
300      is not set negative for a reg whose sets have been made candidates
301      and not set to 0 for a reg that is moved.  */
302   int n_times_set;
303
304   /* Contains the insn in which a register was used if it was used
305      exactly once; contains const0_rtx if it was used more than once.  */
306   rtx single_usage;
307
308   /* Nonzero indicates that the register cannot be moved or strength
309      reduced.  */
310   char may_not_optimize;
311
312   /* Nonzero means reg N has already been moved out of one loop.
313      This reduces the desire to move it out of another.  */
314   char moved_once;
315 };
316
317
318 struct loop_regs
319 {
320   int num;                      /* Number of regs used in table.  */
321   int size;                     /* Size of table.  */
322   struct loop_reg *array;       /* Register usage info. array.  */
323   int multiple_uses;            /* Nonzero if a reg has multiple uses.  */
324 };
325
326
327
328 struct loop_movables
329 {
330   /* Head of movable chain.  */
331   struct movable *head;
332   /* Last movable in chain.  */
333   struct movable *last;
334 };
335
336
337 /* Information pertaining to a loop.  */
338
339 struct loop_info
340 {
341   /* Nonzero if there is a subroutine call in the current loop.  */
342   int has_call;
343   /* Nonzero if there is a libcall in the current loop.  */
344   int has_libcall;
345   /* Nonzero if there is a non constant call in the current loop.  */
346   int has_nonconst_call;
347   /* Nonzero if there is a prefetch instruction in the current loop.  */
348   int has_prefetch;
349   /* Nonzero if there is a volatile memory reference in the current
350      loop.  */
351   int has_volatile;
352   /* Nonzero if there is a tablejump in the current loop.  */
353   int has_tablejump;
354   /* Nonzero if there are ways to leave the loop other than falling
355      off the end.  */
356   int has_multiple_exit_targets;
357   /* Nonzero if there is an indirect jump in the current function.  */
358   int has_indirect_jump;
359   /* Register or constant initial loop value.  */
360   rtx initial_value;
361   /* Register or constant value used for comparison test.  */
362   rtx comparison_value;
363   /* Register or constant approximate final value.  */
364   rtx final_value;
365   /* Register or constant initial loop value with term common to
366      final_value removed.  */
367   rtx initial_equiv_value;
368   /* Register or constant final loop value with term common to
369      initial_value removed.  */
370   rtx final_equiv_value;
371   /* Register corresponding to iteration variable.  */
372   rtx iteration_var;
373   /* Constant loop increment.  */
374   rtx increment;
375   enum rtx_code comparison_code;
376   /* Holds the number of loop iterations.  It is zero if the number
377      could not be calculated.  Must be unsigned since the number of
378      iterations can be as high as 2^wordsize - 1.  For loops with a
379      wider iterator, this number will be zero if the number of loop
380      iterations is too large for an unsigned integer to hold.  */
381   unsigned HOST_WIDE_INT n_iterations;
382   int used_count_register;
383   /* The loop iterator induction variable.  */
384   struct iv_class *iv;
385   /* List of MEMs that are stored in this loop.  */
386   rtx store_mems;
387   /* Array of MEMs that are used (read or written) in this loop, but
388      cannot be aliased by anything in this loop, except perhaps
389      themselves.  In other words, if mems[i] is altered during
390      the loop, it is altered by an expression that is rtx_equal_p to
391      it.  */
392   loop_mem_info *mems;
393   /* The index of the next available slot in MEMS.  */
394   int mems_idx;
395   /* The number of elements allocated in MEMS.  */
396   int mems_allocated;
397   /* Nonzero if we don't know what MEMs were changed in the current
398      loop.  This happens if the loop contains a call (in which case
399      `has_call' will also be set) or if we store into more than
400      NUM_STORES MEMs.  */
401   int unknown_address_altered;
402   /* The above doesn't count any readonly memory locations that are
403      stored.  This does.  */
404   int unknown_constant_address_altered;
405   /* Count of memory write instructions discovered in the loop.  */
406   int num_mem_sets;
407   /* The insn where the first of these was found.  */
408   rtx first_loop_store_insn;
409   /* The chain of movable insns in loop.  */
410   struct loop_movables movables;
411   /* The registers used the in loop.  */
412   struct loop_regs regs;
413   /* The induction variable information in loop.  */
414   struct loop_ivs ivs;
415   /* Nonzero if call is in pre_header extended basic block.  */
416   int pre_header_has_call;
417 };
418
419 /* Not really meaningful values, but at least something.  */
420 #ifndef SIMULTANEOUS_PREFETCHES
421 #define SIMULTANEOUS_PREFETCHES 3
422 #endif
423 #ifndef PREFETCH_BLOCK
424 #define PREFETCH_BLOCK 32
425 #endif
426 #ifndef HAVE_prefetch
427 #define HAVE_prefetch 0
428 #define CODE_FOR_prefetch 0
429 #define gen_prefetch(a,b,c) (gcc_unreachable (), NULL_RTX)
430 #endif
431
432 /* Give up the prefetch optimizations once we exceed a given threshold.
433    It is unlikely that we would be able to optimize something in a loop
434    with so many detected prefetches.  */
435 #define MAX_PREFETCHES 100
436 /* The number of prefetch blocks that are beneficial to fetch at once before
437    a loop with a known (and low) iteration count.  */
438 #define PREFETCH_BLOCKS_BEFORE_LOOP_MAX  6
439 /* For very tiny loops it is not worthwhile to prefetch even before the loop,
440    since it is likely that the data are already in the cache.  */
441 #define PREFETCH_BLOCKS_BEFORE_LOOP_MIN  2
442
443 /* Parameterize some prefetch heuristics so they can be turned on and off
444    easily for performance testing on new architectures.  These can be
445    defined in target-dependent files.  */
446
447 /* Prefetch is worthwhile only when loads/stores are dense.  */
448 #ifndef PREFETCH_ONLY_DENSE_MEM
449 #define PREFETCH_ONLY_DENSE_MEM 1
450 #endif
451
452 /* Define what we mean by "dense" loads and stores; This value divided by 256
453    is the minimum percentage of memory references that worth prefetching.  */
454 #ifndef PREFETCH_DENSE_MEM
455 #define PREFETCH_DENSE_MEM 220
456 #endif
457
458 /* Do not prefetch for a loop whose iteration count is known to be low.  */
459 #ifndef PREFETCH_NO_LOW_LOOPCNT
460 #define PREFETCH_NO_LOW_LOOPCNT 1
461 #endif
462
463 /* Define what we mean by a "low" iteration count.  */
464 #ifndef PREFETCH_LOW_LOOPCNT
465 #define PREFETCH_LOW_LOOPCNT 32
466 #endif
467
468 /* Do not prefetch for a loop that contains a function call; such a loop is
469    probably not an internal loop.  */
470 #ifndef PREFETCH_NO_CALL
471 #define PREFETCH_NO_CALL 1
472 #endif
473
474 /* Do not prefetch accesses with an extreme stride.  */
475 #ifndef PREFETCH_NO_EXTREME_STRIDE
476 #define PREFETCH_NO_EXTREME_STRIDE 1
477 #endif
478
479 /* Define what we mean by an "extreme" stride.  */
480 #ifndef PREFETCH_EXTREME_STRIDE
481 #define PREFETCH_EXTREME_STRIDE 4096
482 #endif
483
484 /* Define a limit to how far apart indices can be and still be merged
485    into a single prefetch.  */
486 #ifndef PREFETCH_EXTREME_DIFFERENCE
487 #define PREFETCH_EXTREME_DIFFERENCE 4096
488 #endif
489
490 /* Issue prefetch instructions before the loop to fetch data to be used
491    in the first few loop iterations.  */
492 #ifndef PREFETCH_BEFORE_LOOP
493 #define PREFETCH_BEFORE_LOOP 1
494 #endif
495
496 /* Do not handle reversed order prefetches (negative stride).  */
497 #ifndef PREFETCH_NO_REVERSE_ORDER
498 #define PREFETCH_NO_REVERSE_ORDER 1
499 #endif
500
501 /* Prefetch even if the GIV is in conditional code.  */
502 #ifndef PREFETCH_CONDITIONAL
503 #define PREFETCH_CONDITIONAL 1
504 #endif
505
506 #define LOOP_REG_LIFETIME(LOOP, REGNO) \
507 ((REGNO_LAST_LUID (REGNO) - REGNO_FIRST_LUID (REGNO)))
508
509 #define LOOP_REG_GLOBAL_P(LOOP, REGNO) \
510 ((REGNO_LAST_LUID (REGNO) > INSN_LUID ((LOOP)->end) \
511  || REGNO_FIRST_LUID (REGNO) < INSN_LUID ((LOOP)->start)))
512
513 #define LOOP_REGNO_NREGS(REGNO, SET_DEST) \
514 ((REGNO) < FIRST_PSEUDO_REGISTER \
515  ? (int) hard_regno_nregs[(REGNO)][GET_MODE (SET_DEST)] : 1)
516
517
518 /* Vector mapping INSN_UIDs to luids.
519    The luids are like uids but increase monotonically always.
520    We use them to see whether a jump comes from outside a given loop.  */
521
522 static int *uid_luid;
523
524 /* Indexed by INSN_UID, contains the ordinal giving the (innermost) loop
525    number the insn is contained in.  */
526
527 static struct loop **uid_loop;
528
529 /* 1 + largest uid of any insn.  */
530
531 static int max_uid_for_loop;
532
533 /* Number of loops detected in current function.  Used as index to the
534    next few tables.  */
535
536 static int max_loop_num;
537
538 /* Bound on pseudo register number before loop optimization.
539    A pseudo has valid regscan info if its number is < max_reg_before_loop.  */
540 static unsigned int max_reg_before_loop;
541
542 /* The value to pass to the next call of reg_scan_update.  */
543 static int loop_max_reg;
544 \f
545 /* During the analysis of a loop, a chain of `struct movable's
546    is made to record all the movable insns found.
547    Then the entire chain can be scanned to decide which to move.  */
548
549 struct movable
550 {
551   rtx insn;                     /* A movable insn */
552   rtx set_src;                  /* The expression this reg is set from.  */
553   rtx set_dest;                 /* The destination of this SET.  */
554   rtx dependencies;             /* When INSN is libcall, this is an EXPR_LIST
555                                    of any registers used within the LIBCALL.  */
556   int consec;                   /* Number of consecutive following insns
557                                    that must be moved with this one.  */
558   unsigned int regno;           /* The register it sets */
559   short lifetime;               /* lifetime of that register;
560                                    may be adjusted when matching movables
561                                    that load the same value are found.  */
562   short savings;                /* Number of insns we can move for this reg,
563                                    including other movables that force this
564                                    or match this one.  */
565   ENUM_BITFIELD(machine_mode) savemode : 8;   /* Nonzero means it is a mode for
566                                    a low part that we should avoid changing when
567                                    clearing the rest of the reg.  */
568   unsigned int cond : 1;        /* 1 if only conditionally movable */
569   unsigned int force : 1;       /* 1 means MUST move this insn */
570   unsigned int global : 1;      /* 1 means reg is live outside this loop */
571                 /* If PARTIAL is 1, GLOBAL means something different:
572                    that the reg is live outside the range from where it is set
573                    to the following label.  */
574   unsigned int done : 1;        /* 1 inhibits further processing of this */
575
576   unsigned int partial : 1;     /* 1 means this reg is used for zero-extending.
577                                    In particular, moving it does not make it
578                                    invariant.  */
579   unsigned int move_insn : 1;   /* 1 means that we call emit_move_insn to
580                                    load SRC, rather than copying INSN.  */
581   unsigned int move_insn_first:1;/* Same as above, if this is necessary for the
582                                     first insn of a consecutive sets group.  */
583   unsigned int is_equiv : 1;    /* 1 means a REG_EQUIV is present on INSN.  */
584   unsigned int insert_temp : 1;  /* 1 means we copy to a new pseudo and replace
585                                     the original insn with a copy from that
586                                     pseudo, rather than deleting it.  */
587   struct movable *match;        /* First entry for same value */
588   struct movable *forces;       /* An insn that must be moved if this is */
589   struct movable *next;
590 };
591
592
593 static FILE *loop_dump_stream;
594
595 /* Forward declarations.  */
596
597 static void invalidate_loops_containing_label (rtx);
598 static void find_and_verify_loops (rtx, struct loops *);
599 static void mark_loop_jump (rtx, struct loop *);
600 static void prescan_loop (struct loop *);
601 static int reg_in_basic_block_p (rtx, rtx);
602 static int consec_sets_invariant_p (const struct loop *, rtx, int, rtx);
603 static int labels_in_range_p (rtx, int);
604 static void count_one_set (struct loop_regs *, rtx, rtx, rtx *);
605 static void note_addr_stored (rtx, rtx, void *);
606 static void note_set_pseudo_multiple_uses (rtx, rtx, void *);
607 static int loop_reg_used_before_p (const struct loop *, rtx, rtx);
608 static rtx find_regs_nested (rtx, rtx);
609 static void scan_loop (struct loop*, int);
610 #if 0
611 static void replace_call_address (rtx, rtx, rtx);
612 #endif
613 static rtx skip_consec_insns (rtx, int);
614 static int libcall_benefit (rtx);
615 static rtx libcall_other_reg (rtx, rtx);
616 static void record_excess_regs (rtx, rtx, rtx *);
617 static void ignore_some_movables (struct loop_movables *);
618 static void force_movables (struct loop_movables *);
619 static void combine_movables (struct loop_movables *, struct loop_regs *);
620 static int num_unmoved_movables (const struct loop *);
621 static int regs_match_p (rtx, rtx, struct loop_movables *);
622 static int rtx_equal_for_loop_p (rtx, rtx, struct loop_movables *,
623                                  struct loop_regs *);
624 static void add_label_notes (rtx, rtx);
625 static void move_movables (struct loop *loop, struct loop_movables *, int,
626                            int);
627 static void loop_movables_add (struct loop_movables *, struct movable *);
628 static void loop_movables_free (struct loop_movables *);
629 static int count_nonfixed_reads (const struct loop *, rtx);
630 static void loop_bivs_find (struct loop *);
631 static void loop_bivs_init_find (struct loop *);
632 static void loop_bivs_check (struct loop *);
633 static void loop_givs_find (struct loop *);
634 static void loop_givs_check (struct loop *);
635 static int loop_biv_eliminable_p (struct loop *, struct iv_class *, int, int);
636 static int loop_giv_reduce_benefit (struct loop *, struct iv_class *,
637                                     struct induction *, rtx);
638 static void loop_givs_dead_check (struct loop *, struct iv_class *);
639 static void loop_givs_reduce (struct loop *, struct iv_class *);
640 static void loop_givs_rescan (struct loop *, struct iv_class *, rtx *);
641 static void loop_ivs_free (struct loop *);
642 static void strength_reduce (struct loop *, int);
643 static void find_single_use_in_loop (struct loop_regs *, rtx, rtx);
644 static int valid_initial_value_p (rtx, rtx, int, rtx);
645 static void find_mem_givs (const struct loop *, rtx, rtx, int, int);
646 static void record_biv (struct loop *, struct induction *, rtx, rtx, rtx,
647                         rtx, rtx *, int, int);
648 static void check_final_value (const struct loop *, struct induction *);
649 static void loop_ivs_dump (const struct loop *, FILE *, int);
650 static void loop_iv_class_dump (const struct iv_class *, FILE *, int);
651 static void loop_biv_dump (const struct induction *, FILE *, int);
652 static void loop_giv_dump (const struct induction *, FILE *, int);
653 static void record_giv (const struct loop *, struct induction *, rtx, rtx,
654                         rtx, rtx, rtx, rtx, int, enum g_types, int, int,
655                         rtx *);
656 static void update_giv_derive (const struct loop *, rtx);
657 static HOST_WIDE_INT get_monotonic_increment (struct iv_class *);
658 static bool biased_biv_fits_mode_p (const struct loop *, struct iv_class *,
659                                     HOST_WIDE_INT, enum machine_mode,
660                                     unsigned HOST_WIDE_INT);
661 static bool biv_fits_mode_p (const struct loop *, struct iv_class *,
662                              HOST_WIDE_INT, enum machine_mode, bool);
663 static bool extension_within_bounds_p (const struct loop *, struct iv_class *,
664                                        HOST_WIDE_INT, rtx);
665 static void check_ext_dependent_givs (const struct loop *, struct iv_class *);
666 static int basic_induction_var (const struct loop *, rtx, enum machine_mode,
667                                 rtx, rtx, rtx *, rtx *, rtx **);
668 static rtx simplify_giv_expr (const struct loop *, rtx, rtx *, int *);
669 static int general_induction_var (const struct loop *loop, rtx, rtx *, rtx *,
670                                   rtx *, rtx *, int, int *, enum machine_mode);
671 static int consec_sets_giv (const struct loop *, int, rtx, rtx, rtx, rtx *,
672                             rtx *, rtx *, rtx *);
673 static int check_dbra_loop (struct loop *, int);
674 static rtx express_from_1 (rtx, rtx, rtx);
675 static rtx combine_givs_p (struct induction *, struct induction *);
676 static int cmp_combine_givs_stats (const void *, const void *);
677 static void combine_givs (struct loop_regs *, struct iv_class *);
678 static int product_cheap_p (rtx, rtx);
679 static int maybe_eliminate_biv (const struct loop *, struct iv_class *, int,
680                                 int, int);
681 static int maybe_eliminate_biv_1 (const struct loop *, rtx, rtx,
682                                   struct iv_class *, int, basic_block, rtx);
683 static int last_use_this_basic_block (rtx, rtx);
684 static void record_initial (rtx, rtx, void *);
685 static void update_reg_last_use (rtx, rtx);
686 static rtx next_insn_in_loop (const struct loop *, rtx);
687 static void loop_regs_scan (const struct loop *, int);
688 static int count_insns_in_loop (const struct loop *);
689 static int find_mem_in_note_1 (rtx *, void *);
690 static rtx find_mem_in_note (rtx);
691 static void load_mems (const struct loop *);
692 static int insert_loop_mem (rtx *, void *);
693 static int replace_loop_mem (rtx *, void *);
694 static void replace_loop_mems (rtx, rtx, rtx, int);
695 static int replace_loop_reg (rtx *, void *);
696 static void replace_loop_regs (rtx insn, rtx, rtx);
697 static void note_reg_stored (rtx, rtx, void *);
698 static void try_copy_prop (const struct loop *, rtx, unsigned int);
699 static void try_swap_copy_prop (const struct loop *, rtx, unsigned int);
700 static rtx check_insn_for_givs (struct loop *, rtx, int, int);
701 static rtx check_insn_for_bivs (struct loop *, rtx, int, int);
702 static rtx gen_add_mult (rtx, rtx, rtx, rtx);
703 static void loop_regs_update (const struct loop *, rtx);
704 static int iv_add_mult_cost (rtx, rtx, rtx, rtx);
705 static int loop_invariant_p (const struct loop *, rtx);
706 static rtx loop_insn_hoist (const struct loop *, rtx);
707 static void loop_iv_add_mult_emit_before (const struct loop *, rtx, rtx, rtx,
708                                           rtx, basic_block, rtx);
709 static rtx loop_insn_emit_before (const struct loop *, basic_block,
710                                   rtx, rtx);
711 static int loop_insn_first_p (rtx, rtx);
712 static rtx get_condition_for_loop (const struct loop *, rtx);
713 static void loop_iv_add_mult_sink (const struct loop *, rtx, rtx, rtx, rtx);
714 static void loop_iv_add_mult_hoist (const struct loop *, rtx, rtx, rtx, rtx);
715 static rtx extend_value_for_giv (struct induction *, rtx);
716 static rtx loop_insn_sink (const struct loop *, rtx);
717
718 static rtx loop_insn_emit_after (const struct loop *, basic_block, rtx, rtx);
719 static rtx loop_call_insn_emit_before (const struct loop *, basic_block,
720                                        rtx, rtx);
721 static rtx loop_call_insn_hoist (const struct loop *, rtx);
722 static rtx loop_insn_sink_or_swim (const struct loop *, rtx);
723
724 static void loop_dump_aux (const struct loop *, FILE *, int);
725 static void loop_delete_insns (rtx, rtx);
726 static HOST_WIDE_INT remove_constant_addition (rtx *);
727 static rtx gen_load_of_final_value (rtx, rtx);
728 void debug_ivs (const struct loop *);
729 void debug_iv_class (const struct iv_class *);
730 void debug_biv (const struct induction *);
731 void debug_giv (const struct induction *);
732 void debug_loop (const struct loop *);
733 void debug_loops (const struct loops *);
734
735 typedef struct loop_replace_args
736 {
737   rtx match;
738   rtx replacement;
739   rtx insn;
740 } loop_replace_args;
741
742 /* Nonzero iff INSN is between START and END, inclusive.  */
743 #define INSN_IN_RANGE_P(INSN, START, END)       \
744   (INSN_UID (INSN) < max_uid_for_loop           \
745    && INSN_LUID (INSN) >= INSN_LUID (START)     \
746    && INSN_LUID (INSN) <= INSN_LUID (END))
747
748 /* Indirect_jump_in_function is computed once per function.  */
749 static int indirect_jump_in_function;
750 static int indirect_jump_in_function_p (rtx);
751
752 static int compute_luids (rtx, rtx, int);
753
754 static int biv_elimination_giv_has_0_offset (struct induction *,
755                                              struct induction *, rtx);
756 \f
757 /* Benefit penalty, if a giv is not replaceable, i.e. must emit an insn to
758    copy the value of the strength reduced giv to its original register.  */
759 static int copy_cost;
760
761 /* Cost of using a register, to normalize the benefits of a giv.  */
762 static int reg_address_cost;
763
764 void
765 init_loop (void)
766 {
767   rtx reg = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 1);
768
769   reg_address_cost = address_cost (reg, SImode);
770
771   copy_cost = COSTS_N_INSNS (1);
772 }
773 \f
774 /* Compute the mapping from uids to luids.
775    LUIDs are numbers assigned to insns, like uids,
776    except that luids increase monotonically through the code.
777    Start at insn START and stop just before END.  Assign LUIDs
778    starting with PREV_LUID + 1.  Return the last assigned LUID + 1.  */
779 static int
780 compute_luids (rtx start, rtx end, int prev_luid)
781 {
782   int i;
783   rtx insn;
784
785   for (insn = start, i = prev_luid; insn != end; insn = NEXT_INSN (insn))
786     {
787       if (INSN_UID (insn) >= max_uid_for_loop)
788         continue;
789       /* Don't assign luids to line-number NOTEs, so that the distance in
790          luids between two insns is not affected by -g.  */
791       if (!NOTE_P (insn)
792           || NOTE_LINE_NUMBER (insn) <= 0)
793         uid_luid[INSN_UID (insn)] = ++i;
794       else
795         /* Give a line number note the same luid as preceding insn.  */
796         uid_luid[INSN_UID (insn)] = i;
797     }
798   return i + 1;
799 }
800 \f
801 /* Entry point of this file.  Perform loop optimization
802    on the current function.  F is the first insn of the function
803    and DUMPFILE is a stream for output of a trace of actions taken
804    (or 0 if none should be output).  */
805
806 void
807 loop_optimize (rtx f, FILE *dumpfile, int flags)
808 {
809   rtx insn;
810   int i;
811   struct loops loops_data;
812   struct loops *loops = &loops_data;
813   struct loop_info *loops_info;
814
815   loop_dump_stream = dumpfile;
816
817   init_recog_no_volatile ();
818
819   max_reg_before_loop = max_reg_num ();
820   loop_max_reg = max_reg_before_loop;
821
822   regs_may_share = 0;
823
824   /* Count the number of loops.  */
825
826   max_loop_num = 0;
827   for (insn = f; insn; insn = NEXT_INSN (insn))
828     {
829       if (NOTE_P (insn)
830           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
831         max_loop_num++;
832     }
833
834   /* Don't waste time if no loops.  */
835   if (max_loop_num == 0)
836     return;
837
838   loops->num = max_loop_num;
839
840   /* Get size to use for tables indexed by uids.
841      Leave some space for labels allocated by find_and_verify_loops.  */
842   max_uid_for_loop = get_max_uid () + 1 + max_loop_num * 32;
843
844   uid_luid = xcalloc (max_uid_for_loop, sizeof (int));
845   uid_loop = xcalloc (max_uid_for_loop, sizeof (struct loop *));
846
847   /* Allocate storage for array of loops.  */
848   loops->array = xcalloc (loops->num, sizeof (struct loop));
849
850   /* Find and process each loop.
851      First, find them, and record them in order of their beginnings.  */
852   find_and_verify_loops (f, loops);
853
854   /* Allocate and initialize auxiliary loop information.  */
855   loops_info = xcalloc (loops->num, sizeof (struct loop_info));
856   for (i = 0; i < (int) loops->num; i++)
857     loops->array[i].aux = loops_info + i;
858
859   /* Now find all register lifetimes.  This must be done after
860      find_and_verify_loops, because it might reorder the insns in the
861      function.  */
862   reg_scan (f, max_reg_before_loop);
863
864   /* This must occur after reg_scan so that registers created by gcse
865      will have entries in the register tables.
866
867      We could have added a call to reg_scan after gcse_main in toplev.c,
868      but moving this call to init_alias_analysis is more efficient.  */
869   init_alias_analysis ();
870
871   /* See if we went too far.  Note that get_max_uid already returns
872      one more that the maximum uid of all insn.  */
873   gcc_assert (get_max_uid () <= max_uid_for_loop);
874   /* Now reset it to the actual size we need.  See above.  */
875   max_uid_for_loop = get_max_uid ();
876
877   /* find_and_verify_loops has already called compute_luids, but it
878      might have rearranged code afterwards, so we need to recompute
879      the luids now.  */
880   compute_luids (f, NULL_RTX, 0);
881
882   /* Don't leave gaps in uid_luid for insns that have been
883      deleted.  It is possible that the first or last insn
884      using some register has been deleted by cross-jumping.
885      Make sure that uid_luid for that former insn's uid
886      points to the general area where that insn used to be.  */
887   for (i = 0; i < max_uid_for_loop; i++)
888     {
889       uid_luid[0] = uid_luid[i];
890       if (uid_luid[0] != 0)
891         break;
892     }
893   for (i = 0; i < max_uid_for_loop; i++)
894     if (uid_luid[i] == 0)
895       uid_luid[i] = uid_luid[i - 1];
896
897   /* Determine if the function has indirect jump.  On some systems
898      this prevents low overhead loop instructions from being used.  */
899   indirect_jump_in_function = indirect_jump_in_function_p (f);
900
901   /* Now scan the loops, last ones first, since this means inner ones are done
902      before outer ones.  */
903   for (i = max_loop_num - 1; i >= 0; i--)
904     {
905       struct loop *loop = &loops->array[i];
906
907       if (! loop->invalid && loop->end)
908         {
909           scan_loop (loop, flags);
910           ggc_collect ();
911         }
912     }
913
914   end_alias_analysis ();
915
916   /* Clean up.  */
917   for (i = 0; i < (int) loops->num; i++)
918     free (loops_info[i].mems);
919   
920   free (uid_luid);
921   free (uid_loop);
922   free (loops_info);
923   free (loops->array);
924 }
925 \f
926 /* Returns the next insn, in execution order, after INSN.  START and
927    END are the NOTE_INSN_LOOP_BEG and NOTE_INSN_LOOP_END for the loop,
928    respectively.  LOOP->TOP, if non-NULL, is the top of the loop in the
929    insn-stream; it is used with loops that are entered near the
930    bottom.  */
931
932 static rtx
933 next_insn_in_loop (const struct loop *loop, rtx insn)
934 {
935   insn = NEXT_INSN (insn);
936
937   if (insn == loop->end)
938     {
939       if (loop->top)
940         /* Go to the top of the loop, and continue there.  */
941         insn = loop->top;
942       else
943         /* We're done.  */
944         insn = NULL_RTX;
945     }
946
947   if (insn == loop->scan_start)
948     /* We're done.  */
949     insn = NULL_RTX;
950
951   return insn;
952 }
953
954 /* Find any register references hidden inside X and add them to
955    the dependency list DEPS.  This is used to look inside CLOBBER (MEM
956    when checking whether a PARALLEL can be pulled out of a loop.  */
957
958 static rtx
959 find_regs_nested (rtx deps, rtx x)
960 {
961   enum rtx_code code = GET_CODE (x);
962   if (code == REG)
963     deps = gen_rtx_EXPR_LIST (VOIDmode, x, deps);
964   else
965     {
966       const char *fmt = GET_RTX_FORMAT (code);
967       int i, j;
968       for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
969         {
970           if (fmt[i] == 'e')
971             deps = find_regs_nested (deps, XEXP (x, i));
972           else if (fmt[i] == 'E')
973             for (j = 0; j < XVECLEN (x, i); j++)
974               deps = find_regs_nested (deps, XVECEXP (x, i, j));
975         }
976     }
977   return deps;
978 }
979
980 /* Optimize one loop described by LOOP.  */
981
982 /* ??? Could also move memory writes out of loops if the destination address
983    is invariant, the source is invariant, the memory write is not volatile,
984    and if we can prove that no read inside the loop can read this address
985    before the write occurs.  If there is a read of this address after the
986    write, then we can also mark the memory read as invariant.  */
987
988 static void
989 scan_loop (struct loop *loop, int flags)
990 {
991   struct loop_info *loop_info = LOOP_INFO (loop);
992   struct loop_regs *regs = LOOP_REGS (loop);
993   int i;
994   rtx loop_start = loop->start;
995   rtx loop_end = loop->end;
996   rtx p;
997   /* 1 if we are scanning insns that could be executed zero times.  */
998   int maybe_never = 0;
999   /* 1 if we are scanning insns that might never be executed
1000      due to a subroutine call which might exit before they are reached.  */
1001   int call_passed = 0;
1002   /* Number of insns in the loop.  */
1003   int insn_count;
1004   int tem;
1005   rtx temp, update_start, update_end;
1006   /* The SET from an insn, if it is the only SET in the insn.  */
1007   rtx set, set1;
1008   /* Chain describing insns movable in current loop.  */
1009   struct loop_movables *movables = LOOP_MOVABLES (loop);
1010   /* Ratio of extra register life span we can justify
1011      for saving an instruction.  More if loop doesn't call subroutines
1012      since in that case saving an insn makes more difference
1013      and more registers are available.  */
1014   int threshold;
1015   int in_libcall;
1016
1017   loop->top = 0;
1018
1019   movables->head = 0;
1020   movables->last = 0;
1021
1022   /* Determine whether this loop starts with a jump down to a test at
1023      the end.  This will occur for a small number of loops with a test
1024      that is too complex to duplicate in front of the loop.
1025
1026      We search for the first insn or label in the loop, skipping NOTEs.
1027      However, we must be careful not to skip past a NOTE_INSN_LOOP_BEG
1028      (because we might have a loop executed only once that contains a
1029      loop which starts with a jump to its exit test) or a NOTE_INSN_LOOP_END
1030      (in case we have a degenerate loop).
1031
1032      Note that if we mistakenly think that a loop is entered at the top
1033      when, in fact, it is entered at the exit test, the only effect will be
1034      slightly poorer optimization.  Making the opposite error can generate
1035      incorrect code.  Since very few loops now start with a jump to the
1036      exit test, the code here to detect that case is very conservative.  */
1037
1038   for (p = NEXT_INSN (loop_start);
1039        p != loop_end
1040          && !LABEL_P (p) && ! INSN_P (p)
1041          && (!NOTE_P (p)
1042              || (NOTE_LINE_NUMBER (p) != NOTE_INSN_LOOP_BEG
1043                  && NOTE_LINE_NUMBER (p) != NOTE_INSN_LOOP_END));
1044        p = NEXT_INSN (p))
1045     ;
1046
1047   loop->scan_start = p;
1048
1049   /* If loop end is the end of the current function, then emit a
1050      NOTE_INSN_DELETED after loop_end and set loop->sink to the dummy
1051      note insn.  This is the position we use when sinking insns out of
1052      the loop.  */
1053   if (NEXT_INSN (loop->end) != 0)
1054     loop->sink = NEXT_INSN (loop->end);
1055   else
1056     loop->sink = emit_note_after (NOTE_INSN_DELETED, loop->end);
1057
1058   /* Set up variables describing this loop.  */
1059   prescan_loop (loop);
1060   threshold = (loop_info->has_call ? 1 : 2) * (1 + n_non_fixed_regs);
1061
1062   /* If loop has a jump before the first label,
1063      the true entry is the target of that jump.
1064      Start scan from there.
1065      But record in LOOP->TOP the place where the end-test jumps
1066      back to so we can scan that after the end of the loop.  */
1067   if (JUMP_P (p)
1068       /* Loop entry must be unconditional jump (and not a RETURN)  */
1069       && any_uncondjump_p (p)
1070       && JUMP_LABEL (p) != 0
1071       /* Check to see whether the jump actually
1072          jumps out of the loop (meaning it's no loop).
1073          This case can happen for things like
1074          do {..} while (0).  If this label was generated previously
1075          by loop, we can't tell anything about it and have to reject
1076          the loop.  */
1077       && INSN_IN_RANGE_P (JUMP_LABEL (p), loop_start, loop_end))
1078     {
1079       loop->top = next_label (loop->scan_start);
1080       loop->scan_start = JUMP_LABEL (p);
1081     }
1082
1083   /* If LOOP->SCAN_START was an insn created by loop, we don't know its luid
1084      as required by loop_reg_used_before_p.  So skip such loops.  (This
1085      test may never be true, but it's best to play it safe.)
1086
1087      Also, skip loops where we do not start scanning at a label.  This
1088      test also rejects loops starting with a JUMP_INSN that failed the
1089      test above.  */
1090
1091   if (INSN_UID (loop->scan_start) >= max_uid_for_loop
1092       || !LABEL_P (loop->scan_start))
1093     {
1094       if (loop_dump_stream)
1095         fprintf (loop_dump_stream, "\nLoop from %d to %d is phony.\n\n",
1096                  INSN_UID (loop_start), INSN_UID (loop_end));
1097       return;
1098     }
1099
1100   /* Allocate extra space for REGs that might be created by load_mems.
1101      We allocate a little extra slop as well, in the hopes that we
1102      won't have to reallocate the regs array.  */
1103   loop_regs_scan (loop, loop_info->mems_idx + 16);
1104   insn_count = count_insns_in_loop (loop);
1105
1106   if (loop_dump_stream)
1107     fprintf (loop_dump_stream, "\nLoop from %d to %d: %d real insns.\n",
1108              INSN_UID (loop_start), INSN_UID (loop_end), insn_count);
1109
1110   /* Scan through the loop finding insns that are safe to move.
1111      Set REGS->ARRAY[I].SET_IN_LOOP negative for the reg I being set, so that
1112      this reg will be considered invariant for subsequent insns.
1113      We consider whether subsequent insns use the reg
1114      in deciding whether it is worth actually moving.
1115
1116      MAYBE_NEVER is nonzero if we have passed a conditional jump insn
1117      and therefore it is possible that the insns we are scanning
1118      would never be executed.  At such times, we must make sure
1119      that it is safe to execute the insn once instead of zero times.
1120      When MAYBE_NEVER is 0, all insns will be executed at least once
1121      so that is not a problem.  */
1122
1123   for (in_libcall = 0, p = next_insn_in_loop (loop, loop->scan_start);
1124        p != NULL_RTX;
1125        p = next_insn_in_loop (loop, p))
1126     {
1127       if (in_libcall && INSN_P (p) && find_reg_note (p, REG_RETVAL, NULL_RTX))
1128         in_libcall--;
1129       if (NONJUMP_INSN_P (p))
1130         {
1131           /* Do not scan past an optimization barrier.  */
1132           if (GET_CODE (PATTERN (p)) == ASM_INPUT)
1133             break;
1134           temp = find_reg_note (p, REG_LIBCALL, NULL_RTX);
1135           if (temp)
1136             in_libcall++;
1137           if (! in_libcall
1138               && (set = single_set (p))
1139               && REG_P (SET_DEST (set))
1140               && SET_DEST (set) != frame_pointer_rtx
1141 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
1142               && SET_DEST (set) != pic_offset_table_rtx
1143 #endif
1144               && ! regs->array[REGNO (SET_DEST (set))].may_not_optimize)
1145             {
1146               int tem1 = 0;
1147               int tem2 = 0;
1148               int move_insn = 0;
1149               int insert_temp = 0;
1150               rtx src = SET_SRC (set);
1151               rtx dependencies = 0;
1152
1153               /* Figure out what to use as a source of this insn.  If a
1154                  REG_EQUIV note is given or if a REG_EQUAL note with a
1155                  constant operand is specified, use it as the source and
1156                  mark that we should move this insn by calling
1157                  emit_move_insn rather that duplicating the insn.
1158
1159                  Otherwise, only use the REG_EQUAL contents if a REG_RETVAL
1160                  note is present.  */
1161               temp = find_reg_note (p, REG_EQUIV, NULL_RTX);
1162               if (temp)
1163                 src = XEXP (temp, 0), move_insn = 1;
1164               else
1165                 {
1166                   temp = find_reg_note (p, REG_EQUAL, NULL_RTX);
1167                   if (temp && CONSTANT_P (XEXP (temp, 0)))
1168                     src = XEXP (temp, 0), move_insn = 1;
1169                   if (temp && find_reg_note (p, REG_RETVAL, NULL_RTX))
1170                     {
1171                       src = XEXP (temp, 0);
1172                       /* A libcall block can use regs that don't appear in
1173                          the equivalent expression.  To move the libcall,
1174                          we must move those regs too.  */
1175                       dependencies = libcall_other_reg (p, src);
1176                     }
1177                 }
1178
1179               /* For parallels, add any possible uses to the dependencies, as
1180                  we can't move the insn without resolving them first.
1181                  MEMs inside CLOBBERs may also reference registers; these
1182                  count as implicit uses.  */
1183               if (GET_CODE (PATTERN (p)) == PARALLEL)
1184                 {
1185                   for (i = 0; i < XVECLEN (PATTERN (p), 0); i++)
1186                     {
1187                       rtx x = XVECEXP (PATTERN (p), 0, i);
1188                       if (GET_CODE (x) == USE)
1189                         dependencies
1190                           = gen_rtx_EXPR_LIST (VOIDmode, XEXP (x, 0),
1191                                                dependencies);
1192                       else if (GET_CODE (x) == CLOBBER 
1193                                && MEM_P (XEXP (x, 0)))
1194                         dependencies = find_regs_nested (dependencies, 
1195                                                   XEXP (XEXP (x, 0), 0));
1196                     }
1197                 }
1198
1199               if (/* The register is used in basic blocks other
1200                       than the one where it is set (meaning that
1201                       something after this point in the loop might
1202                       depend on its value before the set).  */
1203                    ! reg_in_basic_block_p (p, SET_DEST (set))
1204                    /* And the set is not guaranteed to be executed once
1205                       the loop starts, or the value before the set is
1206                       needed before the set occurs...
1207
1208                       ??? Note we have quadratic behavior here, mitigated
1209                       by the fact that the previous test will often fail for
1210                       large loops.  Rather than re-scanning the entire loop
1211                       each time for register usage, we should build tables
1212                       of the register usage and use them here instead.  */
1213                    && (maybe_never
1214                        || loop_reg_used_before_p (loop, set, p)))
1215                 /* It is unsafe to move the set.  However, it may be OK to
1216                    move the source into a new pseudo, and substitute a
1217                    reg-to-reg copy for the original insn.
1218
1219                    This code used to consider it OK to move a set of a variable
1220                    which was not created by the user and not used in an exit
1221                    test.
1222                    That behavior is incorrect and was removed.  */
1223                 insert_temp = 1;
1224
1225               /* Don't try to optimize a MODE_CC set with a constant
1226                  source.  It probably will be combined with a conditional
1227                  jump.  */
1228               if (GET_MODE_CLASS (GET_MODE (SET_DEST (set))) == MODE_CC
1229                   && CONSTANT_P (src))
1230                 ;
1231               /* Don't try to optimize a register that was made
1232                  by loop-optimization for an inner loop.
1233                  We don't know its life-span, so we can't compute
1234                  the benefit.  */
1235               else if (REGNO (SET_DEST (set)) >= max_reg_before_loop)
1236                 ;
1237               /* Don't move the source and add a reg-to-reg copy:
1238                  - with -Os (this certainly increases size),
1239                  - if the mode doesn't support copy operations (obviously),
1240                  - if the source is already a reg (the motion will gain nothing),
1241                  - if the source is a legitimate constant (likewise).  */
1242               else if (insert_temp
1243                        && (optimize_size
1244                            || ! can_copy_p (GET_MODE (SET_SRC (set)))
1245                            || REG_P (SET_SRC (set))
1246                            || (CONSTANT_P (SET_SRC (set))
1247                                && LEGITIMATE_CONSTANT_P (SET_SRC (set)))))
1248                 ;
1249               else if ((tem = loop_invariant_p (loop, src))
1250                        && (dependencies == 0
1251                            || (tem2
1252                                = loop_invariant_p (loop, dependencies)) != 0)
1253                        && (regs->array[REGNO (SET_DEST (set))].set_in_loop == 1
1254                            || (tem1
1255                                = consec_sets_invariant_p
1256                                (loop, SET_DEST (set),
1257                                 regs->array[REGNO (SET_DEST (set))].set_in_loop,
1258                                 p)))
1259                        /* If the insn can cause a trap (such as divide by zero),
1260                           can't move it unless it's guaranteed to be executed
1261                           once loop is entered.  Even a function call might
1262                           prevent the trap insn from being reached
1263                           (since it might exit!)  */
1264                        && ! ((maybe_never || call_passed)
1265                              && may_trap_p (src)))
1266                 {
1267                   struct movable *m;
1268                   int regno = REGNO (SET_DEST (set));
1269
1270                   /* A potential lossage is where we have a case where two insns
1271                      can be combined as long as they are both in the loop, but
1272                      we move one of them outside the loop.  For large loops,
1273                      this can lose.  The most common case of this is the address
1274                      of a function being called.
1275
1276                      Therefore, if this register is marked as being used
1277                      exactly once if we are in a loop with calls
1278                      (a "large loop"), see if we can replace the usage of
1279                      this register with the source of this SET.  If we can,
1280                      delete this insn.
1281
1282                      Don't do this if P has a REG_RETVAL note or if we have
1283                      SMALL_REGISTER_CLASSES and SET_SRC is a hard register.  */
1284
1285                   if (loop_info->has_call
1286                       && regs->array[regno].single_usage != 0
1287                       && regs->array[regno].single_usage != const0_rtx
1288                       && REGNO_FIRST_UID (regno) == INSN_UID (p)
1289                       && (REGNO_LAST_UID (regno)
1290                           == INSN_UID (regs->array[regno].single_usage))
1291                       && regs->array[regno].set_in_loop == 1
1292                       && GET_CODE (SET_SRC (set)) != ASM_OPERANDS
1293                       && ! side_effects_p (SET_SRC (set))
1294                       && ! find_reg_note (p, REG_RETVAL, NULL_RTX)
1295                       && (! SMALL_REGISTER_CLASSES
1296                           || (! (REG_P (SET_SRC (set))
1297                                  && (REGNO (SET_SRC (set))
1298                                      < FIRST_PSEUDO_REGISTER))))
1299                       && regno >= FIRST_PSEUDO_REGISTER 
1300                       /* This test is not redundant; SET_SRC (set) might be
1301                          a call-clobbered register and the life of REGNO
1302                          might span a call.  */
1303                       && ! modified_between_p (SET_SRC (set), p,
1304                                                regs->array[regno].single_usage)
1305                       && no_labels_between_p (p,
1306                                               regs->array[regno].single_usage)
1307                       && validate_replace_rtx (SET_DEST (set), SET_SRC (set),
1308                                                regs->array[regno].single_usage))
1309                     {
1310                       /* Replace any usage in a REG_EQUAL note.  Must copy
1311                          the new source, so that we don't get rtx sharing
1312                          between the SET_SOURCE and REG_NOTES of insn p.  */
1313                       REG_NOTES (regs->array[regno].single_usage)
1314                         = (replace_rtx
1315                            (REG_NOTES (regs->array[regno].single_usage),
1316                             SET_DEST (set), copy_rtx (SET_SRC (set))));
1317
1318                       delete_insn (p);
1319                       for (i = 0; i < LOOP_REGNO_NREGS (regno, SET_DEST (set));
1320                            i++)
1321                         regs->array[regno+i].set_in_loop = 0;
1322                       continue;
1323                     }
1324
1325                   m = xmalloc (sizeof (struct movable));
1326                   m->next = 0;
1327                   m->insn = p;
1328                   m->set_src = src;
1329                   m->dependencies = dependencies;
1330                   m->set_dest = SET_DEST (set);
1331                   m->force = 0;
1332                   m->consec
1333                     = regs->array[REGNO (SET_DEST (set))].set_in_loop - 1;
1334                   m->done = 0;
1335                   m->forces = 0;
1336                   m->partial = 0;
1337                   m->move_insn = move_insn;
1338                   m->move_insn_first = 0;
1339                   m->insert_temp = insert_temp;
1340                   m->is_equiv = (find_reg_note (p, REG_EQUIV, NULL_RTX) != 0);
1341                   m->savemode = VOIDmode;
1342                   m->regno = regno;
1343                   /* Set M->cond if either loop_invariant_p
1344                      or consec_sets_invariant_p returned 2
1345                      (only conditionally invariant).  */
1346                   m->cond = ((tem | tem1 | tem2) > 1);
1347                   m->global =  LOOP_REG_GLOBAL_P (loop, regno);
1348                   m->match = 0;
1349                   m->lifetime = LOOP_REG_LIFETIME (loop, regno);
1350                   m->savings = regs->array[regno].n_times_set;
1351                   if (find_reg_note (p, REG_RETVAL, NULL_RTX))
1352                     m->savings += libcall_benefit (p);
1353                   for (i = 0; i < LOOP_REGNO_NREGS (regno, SET_DEST (set)); i++)
1354                     regs->array[regno+i].set_in_loop = move_insn ? -2 : -1;
1355                   /* Add M to the end of the chain MOVABLES.  */
1356                   loop_movables_add (movables, m);
1357
1358                   if (m->consec > 0)
1359                     {
1360                       /* It is possible for the first instruction to have a
1361                          REG_EQUAL note but a non-invariant SET_SRC, so we must
1362                          remember the status of the first instruction in case
1363                          the last instruction doesn't have a REG_EQUAL note.  */
1364                       m->move_insn_first = m->move_insn;
1365
1366                       /* Skip this insn, not checking REG_LIBCALL notes.  */
1367                       p = next_nonnote_insn (p);
1368                       /* Skip the consecutive insns, if there are any.  */
1369                       p = skip_consec_insns (p, m->consec);
1370                       /* Back up to the last insn of the consecutive group.  */
1371                       p = prev_nonnote_insn (p);
1372
1373                       /* We must now reset m->move_insn, m->is_equiv, and
1374                          possibly m->set_src to correspond to the effects of
1375                          all the insns.  */
1376                       temp = find_reg_note (p, REG_EQUIV, NULL_RTX);
1377                       if (temp)
1378                         m->set_src = XEXP (temp, 0), m->move_insn = 1;
1379                       else
1380                         {
1381                           temp = find_reg_note (p, REG_EQUAL, NULL_RTX);
1382                           if (temp && CONSTANT_P (XEXP (temp, 0)))
1383                             m->set_src = XEXP (temp, 0), m->move_insn = 1;
1384                           else
1385                             m->move_insn = 0;
1386
1387                         }
1388                       m->is_equiv
1389                         = (find_reg_note (p, REG_EQUIV, NULL_RTX) != 0);
1390                     }
1391                 }
1392               /* If this register is always set within a STRICT_LOW_PART
1393                  or set to zero, then its high bytes are constant.
1394                  So clear them outside the loop and within the loop
1395                  just load the low bytes.
1396                  We must check that the machine has an instruction to do so.
1397                  Also, if the value loaded into the register
1398                  depends on the same register, this cannot be done.  */
1399               else if (SET_SRC (set) == const0_rtx
1400                        && NONJUMP_INSN_P (NEXT_INSN (p))
1401                        && (set1 = single_set (NEXT_INSN (p)))
1402                        && GET_CODE (set1) == SET
1403                        && (GET_CODE (SET_DEST (set1)) == STRICT_LOW_PART)
1404                        && (GET_CODE (XEXP (SET_DEST (set1), 0)) == SUBREG)
1405                        && (SUBREG_REG (XEXP (SET_DEST (set1), 0))
1406                            == SET_DEST (set))
1407                        && !reg_mentioned_p (SET_DEST (set), SET_SRC (set1)))
1408                 {
1409                   int regno = REGNO (SET_DEST (set));
1410                   if (regs->array[regno].set_in_loop == 2)
1411                     {
1412                       struct movable *m;
1413                       m = xmalloc (sizeof (struct movable));
1414                       m->next = 0;
1415                       m->insn = p;
1416                       m->set_dest = SET_DEST (set);
1417                       m->dependencies = 0;
1418                       m->force = 0;
1419                       m->consec = 0;
1420                       m->done = 0;
1421                       m->forces = 0;
1422                       m->move_insn = 0;
1423                       m->move_insn_first = 0;
1424                       m->insert_temp = insert_temp;
1425                       m->partial = 1;
1426                       /* If the insn may not be executed on some cycles,
1427                          we can't clear the whole reg; clear just high part.
1428                          Not even if the reg is used only within this loop.
1429                          Consider this:
1430                          while (1)
1431                            while (s != t) {
1432                              if (foo ()) x = *s;
1433                              use (x);
1434                            }
1435                          Clearing x before the inner loop could clobber a value
1436                          being saved from the last time around the outer loop.
1437                          However, if the reg is not used outside this loop
1438                          and all uses of the register are in the same
1439                          basic block as the store, there is no problem.
1440
1441                          If this insn was made by loop, we don't know its
1442                          INSN_LUID and hence must make a conservative
1443                          assumption.  */
1444                       m->global = (INSN_UID (p) >= max_uid_for_loop
1445                                    || LOOP_REG_GLOBAL_P (loop, regno)
1446                                    || (labels_in_range_p
1447                                        (p, REGNO_FIRST_LUID (regno))));
1448                       if (maybe_never && m->global)
1449                         m->savemode = GET_MODE (SET_SRC (set1));
1450                       else
1451                         m->savemode = VOIDmode;
1452                       m->regno = regno;
1453                       m->cond = 0;
1454                       m->match = 0;
1455                       m->lifetime = LOOP_REG_LIFETIME (loop, regno);
1456                       m->savings = 1;
1457                       for (i = 0;
1458                            i < LOOP_REGNO_NREGS (regno, SET_DEST (set));
1459                            i++)
1460                         regs->array[regno+i].set_in_loop = -1;
1461                       /* Add M to the end of the chain MOVABLES.  */
1462                       loop_movables_add (movables, m);
1463                     }
1464                 }
1465             }
1466         }
1467       /* Past a call insn, we get to insns which might not be executed
1468          because the call might exit.  This matters for insns that trap.
1469          Constant and pure call insns always return, so they don't count.  */
1470       else if (CALL_P (p) && ! CONST_OR_PURE_CALL_P (p))
1471         call_passed = 1;
1472       /* Past a label or a jump, we get to insns for which we
1473          can't count on whether or how many times they will be
1474          executed during each iteration.  Therefore, we can
1475          only move out sets of trivial variables
1476          (those not used after the loop).  */
1477       /* Similar code appears twice in strength_reduce.  */
1478       else if ((LABEL_P (p) || JUMP_P (p))
1479                /* If we enter the loop in the middle, and scan around to the
1480                   beginning, don't set maybe_never for that.  This must be an
1481                   unconditional jump, otherwise the code at the top of the
1482                   loop might never be executed.  Unconditional jumps are
1483                   followed by a barrier then the loop_end.  */
1484                && ! (JUMP_P (p) && JUMP_LABEL (p) == loop->top
1485                      && NEXT_INSN (NEXT_INSN (p)) == loop_end
1486                      && any_uncondjump_p (p)))
1487         maybe_never = 1;
1488     }
1489
1490   /* If one movable subsumes another, ignore that other.  */
1491
1492   ignore_some_movables (movables);
1493
1494   /* For each movable insn, see if the reg that it loads
1495      leads when it dies right into another conditionally movable insn.
1496      If so, record that the second insn "forces" the first one,
1497      since the second can be moved only if the first is.  */
1498
1499   force_movables (movables);
1500
1501   /* See if there are multiple movable insns that load the same value.
1502      If there are, make all but the first point at the first one
1503      through the `match' field, and add the priorities of them
1504      all together as the priority of the first.  */
1505
1506   combine_movables (movables, regs);
1507
1508   /* Now consider each movable insn to decide whether it is worth moving.
1509      Store 0 in regs->array[I].set_in_loop for each reg I that is moved.
1510
1511      For machines with few registers this increases code size, so do not
1512      move moveables when optimizing for code size on such machines.
1513      (The 18 below is the value for i386.)  */
1514
1515   if (!optimize_size
1516       || (reg_class_size[GENERAL_REGS] > 18 && !loop_info->has_call))
1517     {
1518       move_movables (loop, movables, threshold, insn_count);
1519
1520       /* Recalculate regs->array if move_movables has created new
1521          registers.  */
1522       if (max_reg_num () > regs->num)
1523         {
1524           loop_regs_scan (loop, 0);
1525           for (update_start = loop_start;
1526                PREV_INSN (update_start)
1527                && !LABEL_P (PREV_INSN (update_start));
1528                update_start = PREV_INSN (update_start))
1529             ;
1530           update_end = NEXT_INSN (loop_end);
1531
1532           reg_scan_update (update_start, update_end, loop_max_reg);
1533           loop_max_reg = max_reg_num ();
1534         }
1535     }
1536
1537   /* Now candidates that still are negative are those not moved.
1538      Change regs->array[I].set_in_loop to indicate that those are not actually
1539      invariant.  */
1540   for (i = 0; i < regs->num; i++)
1541     if (regs->array[i].set_in_loop < 0)
1542       regs->array[i].set_in_loop = regs->array[i].n_times_set;
1543
1544   /* Now that we've moved some things out of the loop, we might be able to
1545      hoist even more memory references.  */
1546   load_mems (loop);
1547
1548   /* Recalculate regs->array if load_mems has created new registers.  */
1549   if (max_reg_num () > regs->num)
1550     loop_regs_scan (loop, 0);
1551
1552   for (update_start = loop_start;
1553        PREV_INSN (update_start)
1554          && !LABEL_P (PREV_INSN (update_start));
1555        update_start = PREV_INSN (update_start))
1556     ;
1557   update_end = NEXT_INSN (loop_end);
1558
1559   reg_scan_update (update_start, update_end, loop_max_reg);
1560   loop_max_reg = max_reg_num ();
1561
1562   if (flag_strength_reduce)
1563     {
1564       if (update_end && LABEL_P (update_end))
1565         /* Ensure our label doesn't go away.  */
1566         LABEL_NUSES (update_end)++;
1567
1568       strength_reduce (loop, flags);
1569
1570       reg_scan_update (update_start, update_end, loop_max_reg);
1571       loop_max_reg = max_reg_num ();
1572
1573       if (update_end && LABEL_P (update_end)
1574           && --LABEL_NUSES (update_end) == 0)
1575         delete_related_insns (update_end);
1576     }
1577
1578
1579   /* The movable information is required for strength reduction.  */
1580   loop_movables_free (movables);
1581
1582   free (regs->array);
1583   regs->array = 0;
1584   regs->num = 0;
1585 }
1586 \f
1587 /* Add elements to *OUTPUT to record all the pseudo-regs
1588    mentioned in IN_THIS but not mentioned in NOT_IN_THIS.  */
1589
1590 static void
1591 record_excess_regs (rtx in_this, rtx not_in_this, rtx *output)
1592 {
1593   enum rtx_code code;
1594   const char *fmt;
1595   int i;
1596
1597   code = GET_CODE (in_this);
1598
1599   switch (code)
1600     {
1601     case PC:
1602     case CC0:
1603     case CONST_INT:
1604     case CONST_DOUBLE:
1605     case CONST:
1606     case SYMBOL_REF:
1607     case LABEL_REF:
1608       return;
1609
1610     case REG:
1611       if (REGNO (in_this) >= FIRST_PSEUDO_REGISTER
1612           && ! reg_mentioned_p (in_this, not_in_this))
1613         *output = gen_rtx_EXPR_LIST (VOIDmode, in_this, *output);
1614       return;
1615
1616     default:
1617       break;
1618     }
1619
1620   fmt = GET_RTX_FORMAT (code);
1621   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1622     {
1623       int j;
1624
1625       switch (fmt[i])
1626         {
1627         case 'E':
1628           for (j = 0; j < XVECLEN (in_this, i); j++)
1629             record_excess_regs (XVECEXP (in_this, i, j), not_in_this, output);
1630           break;
1631
1632         case 'e':
1633           record_excess_regs (XEXP (in_this, i), not_in_this, output);
1634           break;
1635         }
1636     }
1637 }
1638 \f
1639 /* Check what regs are referred to in the libcall block ending with INSN,
1640    aside from those mentioned in the equivalent value.
1641    If there are none, return 0.
1642    If there are one or more, return an EXPR_LIST containing all of them.  */
1643
1644 static rtx
1645 libcall_other_reg (rtx insn, rtx equiv)
1646 {
1647   rtx note = find_reg_note (insn, REG_RETVAL, NULL_RTX);
1648   rtx p = XEXP (note, 0);
1649   rtx output = 0;
1650
1651   /* First, find all the regs used in the libcall block
1652      that are not mentioned as inputs to the result.  */
1653
1654   while (p != insn)
1655     {
1656       if (INSN_P (p))
1657         record_excess_regs (PATTERN (p), equiv, &output);
1658       p = NEXT_INSN (p);
1659     }
1660
1661   return output;
1662 }
1663 \f
1664 /* Return 1 if all uses of REG
1665    are between INSN and the end of the basic block.  */
1666
1667 static int
1668 reg_in_basic_block_p (rtx insn, rtx reg)
1669 {
1670   int regno = REGNO (reg);
1671   rtx p;
1672
1673   if (REGNO_FIRST_UID (regno) != INSN_UID (insn))
1674     return 0;
1675
1676   /* Search this basic block for the already recorded last use of the reg.  */
1677   for (p = insn; p; p = NEXT_INSN (p))
1678     {
1679       switch (GET_CODE (p))
1680         {
1681         case NOTE:
1682           break;
1683
1684         case INSN:
1685         case CALL_INSN:
1686           /* Ordinary insn: if this is the last use, we win.  */
1687           if (REGNO_LAST_UID (regno) == INSN_UID (p))
1688             return 1;
1689           break;
1690
1691         case JUMP_INSN:
1692           /* Jump insn: if this is the last use, we win.  */
1693           if (REGNO_LAST_UID (regno) == INSN_UID (p))
1694             return 1;
1695           /* Otherwise, it's the end of the basic block, so we lose.  */
1696           return 0;
1697
1698         case CODE_LABEL:
1699         case BARRIER:
1700           /* It's the end of the basic block, so we lose.  */
1701           return 0;
1702
1703         default:
1704           break;
1705         }
1706     }
1707
1708   /* The "last use" that was recorded can't be found after the first
1709      use.  This can happen when the last use was deleted while
1710      processing an inner loop, this inner loop was then completely
1711      unrolled, and the outer loop is always exited after the inner loop,
1712      so that everything after the first use becomes a single basic block.  */
1713   return 1;
1714 }
1715 \f
1716 /* Compute the benefit of eliminating the insns in the block whose
1717    last insn is LAST.  This may be a group of insns used to compute a
1718    value directly or can contain a library call.  */
1719
1720 static int
1721 libcall_benefit (rtx last)
1722 {
1723   rtx insn;
1724   int benefit = 0;
1725
1726   for (insn = XEXP (find_reg_note (last, REG_RETVAL, NULL_RTX), 0);
1727        insn != last; insn = NEXT_INSN (insn))
1728     {
1729       if (CALL_P (insn))
1730         benefit += 10;          /* Assume at least this many insns in a library
1731                                    routine.  */
1732       else if (NONJUMP_INSN_P (insn)
1733                && GET_CODE (PATTERN (insn)) != USE
1734                && GET_CODE (PATTERN (insn)) != CLOBBER)
1735         benefit++;
1736     }
1737
1738   return benefit;
1739 }
1740 \f
1741 /* Skip COUNT insns from INSN, counting library calls as 1 insn.  */
1742
1743 static rtx
1744 skip_consec_insns (rtx insn, int count)
1745 {
1746   for (; count > 0; count--)
1747     {
1748       rtx temp;
1749
1750       /* If first insn of libcall sequence, skip to end.  */
1751       /* Do this at start of loop, since INSN is guaranteed to
1752          be an insn here.  */
1753       if (!NOTE_P (insn)
1754           && (temp = find_reg_note (insn, REG_LIBCALL, NULL_RTX)))
1755         insn = XEXP (temp, 0);
1756
1757       do
1758         insn = NEXT_INSN (insn);
1759       while (NOTE_P (insn));
1760     }
1761
1762   return insn;
1763 }
1764
1765 /* Ignore any movable whose insn falls within a libcall
1766    which is part of another movable.
1767    We make use of the fact that the movable for the libcall value
1768    was made later and so appears later on the chain.  */
1769
1770 static void
1771 ignore_some_movables (struct loop_movables *movables)
1772 {
1773   struct movable *m, *m1;
1774
1775   for (m = movables->head; m; m = m->next)
1776     {
1777       /* Is this a movable for the value of a libcall?  */
1778       rtx note = find_reg_note (m->insn, REG_RETVAL, NULL_RTX);
1779       if (note)
1780         {
1781           rtx insn;
1782           /* Check for earlier movables inside that range,
1783              and mark them invalid.  We cannot use LUIDs here because
1784              insns created by loop.c for prior loops don't have LUIDs.
1785              Rather than reject all such insns from movables, we just
1786              explicitly check each insn in the libcall (since invariant
1787              libcalls aren't that common).  */
1788           for (insn = XEXP (note, 0); insn != m->insn; insn = NEXT_INSN (insn))
1789             for (m1 = movables->head; m1 != m; m1 = m1->next)
1790               if (m1->insn == insn)
1791                 m1->done = 1;
1792         }
1793     }
1794 }
1795
1796 /* For each movable insn, see if the reg that it loads
1797    leads when it dies right into another conditionally movable insn.
1798    If so, record that the second insn "forces" the first one,
1799    since the second can be moved only if the first is.  */
1800
1801 static void
1802 force_movables (struct loop_movables *movables)
1803 {
1804   struct movable *m, *m1;
1805
1806   for (m1 = movables->head; m1; m1 = m1->next)
1807     /* Omit this if moving just the (SET (REG) 0) of a zero-extend.  */
1808     if (!m1->partial && !m1->done)
1809       {
1810         int regno = m1->regno;
1811         for (m = m1->next; m; m = m->next)
1812           /* ??? Could this be a bug?  What if CSE caused the
1813              register of M1 to be used after this insn?
1814              Since CSE does not update regno_last_uid,
1815              this insn M->insn might not be where it dies.
1816              But very likely this doesn't matter; what matters is
1817              that M's reg is computed from M1's reg.  */
1818           if (INSN_UID (m->insn) == REGNO_LAST_UID (regno)
1819               && !m->done)
1820             break;
1821         if (m != 0 && m->set_src == m1->set_dest
1822             /* If m->consec, m->set_src isn't valid.  */
1823             && m->consec == 0)
1824           m = 0;
1825
1826         /* Increase the priority of the moving the first insn
1827            since it permits the second to be moved as well.
1828            Likewise for insns already forced by the first insn.  */
1829         if (m != 0)
1830           {
1831             struct movable *m2;
1832
1833             m->forces = m1;
1834             for (m2 = m1; m2; m2 = m2->forces)
1835               {
1836                 m2->lifetime += m->lifetime;
1837                 m2->savings += m->savings;
1838               }
1839           }
1840       }
1841 }
1842 \f
1843 /* Find invariant expressions that are equal and can be combined into
1844    one register.  */
1845
1846 static void
1847 combine_movables (struct loop_movables *movables, struct loop_regs *regs)
1848 {
1849   struct movable *m;
1850   char *matched_regs = xmalloc (regs->num);
1851   enum machine_mode mode;
1852
1853   /* Regs that are set more than once are not allowed to match
1854      or be matched.  I'm no longer sure why not.  */
1855   /* Only pseudo registers are allowed to match or be matched,
1856      since move_movables does not validate the change.  */
1857   /* Perhaps testing m->consec_sets would be more appropriate here?  */
1858
1859   for (m = movables->head; m; m = m->next)
1860     if (m->match == 0 && regs->array[m->regno].n_times_set == 1
1861         && m->regno >= FIRST_PSEUDO_REGISTER
1862         && !m->insert_temp
1863         && !m->partial)
1864       {
1865         struct movable *m1;
1866         int regno = m->regno;
1867
1868         memset (matched_regs, 0, regs->num);
1869         matched_regs[regno] = 1;
1870
1871         /* We want later insns to match the first one.  Don't make the first
1872            one match any later ones.  So start this loop at m->next.  */
1873         for (m1 = m->next; m1; m1 = m1->next)
1874           if (m != m1 && m1->match == 0
1875               && !m1->insert_temp
1876               && regs->array[m1->regno].n_times_set == 1
1877               && m1->regno >= FIRST_PSEUDO_REGISTER
1878               /* A reg used outside the loop mustn't be eliminated.  */
1879               && !m1->global
1880               /* A reg used for zero-extending mustn't be eliminated.  */
1881               && !m1->partial
1882               && (matched_regs[m1->regno]
1883                   ||
1884                   (
1885                    /* Can combine regs with different modes loaded from the
1886                       same constant only if the modes are the same or
1887                       if both are integer modes with M wider or the same
1888                       width as M1.  The check for integer is redundant, but
1889                       safe, since the only case of differing destination
1890                       modes with equal sources is when both sources are
1891                       VOIDmode, i.e., CONST_INT.  */
1892                    (GET_MODE (m->set_dest) == GET_MODE (m1->set_dest)
1893                     || (GET_MODE_CLASS (GET_MODE (m->set_dest)) == MODE_INT
1894                         && GET_MODE_CLASS (GET_MODE (m1->set_dest)) == MODE_INT
1895                         && (GET_MODE_BITSIZE (GET_MODE (m->set_dest))
1896                             >= GET_MODE_BITSIZE (GET_MODE (m1->set_dest)))))
1897                    /* See if the source of M1 says it matches M.  */
1898                    && ((REG_P (m1->set_src)
1899                         && matched_regs[REGNO (m1->set_src)])
1900                        || rtx_equal_for_loop_p (m->set_src, m1->set_src,
1901                                                 movables, regs))))
1902               && ((m->dependencies == m1->dependencies)
1903                   || rtx_equal_p (m->dependencies, m1->dependencies)))
1904             {
1905               m->lifetime += m1->lifetime;
1906               m->savings += m1->savings;
1907               m1->done = 1;
1908               m1->match = m;
1909               matched_regs[m1->regno] = 1;
1910             }
1911       }
1912
1913   /* Now combine the regs used for zero-extension.
1914      This can be done for those not marked `global'
1915      provided their lives don't overlap.  */
1916
1917   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1918        mode = GET_MODE_WIDER_MODE (mode))
1919     {
1920       struct movable *m0 = 0;
1921
1922       /* Combine all the registers for extension from mode MODE.
1923          Don't combine any that are used outside this loop.  */
1924       for (m = movables->head; m; m = m->next)
1925         if (m->partial && ! m->global
1926             && mode == GET_MODE (SET_SRC (PATTERN (NEXT_INSN (m->insn)))))
1927           {
1928             struct movable *m1;
1929
1930             int first = REGNO_FIRST_LUID (m->regno);
1931             int last = REGNO_LAST_LUID (m->regno);
1932
1933             if (m0 == 0)
1934               {
1935                 /* First one: don't check for overlap, just record it.  */
1936                 m0 = m;
1937                 continue;
1938               }
1939
1940             /* Make sure they extend to the same mode.
1941                (Almost always true.)  */
1942             if (GET_MODE (m->set_dest) != GET_MODE (m0->set_dest))
1943               continue;
1944
1945             /* We already have one: check for overlap with those
1946                already combined together.  */
1947             for (m1 = movables->head; m1 != m; m1 = m1->next)
1948               if (m1 == m0 || (m1->partial && m1->match == m0))
1949                 if (! (REGNO_FIRST_LUID (m1->regno) > last
1950                        || REGNO_LAST_LUID (m1->regno) < first))
1951                   goto overlap;
1952
1953             /* No overlap: we can combine this with the others.  */
1954             m0->lifetime += m->lifetime;
1955             m0->savings += m->savings;
1956             m->done = 1;
1957             m->match = m0;
1958
1959           overlap:
1960             ;
1961           }
1962     }
1963
1964   /* Clean up.  */
1965   free (matched_regs);
1966 }
1967
1968 /* Returns the number of movable instructions in LOOP that were not
1969    moved outside the loop.  */
1970
1971 static int
1972 num_unmoved_movables (const struct loop *loop)
1973 {
1974   int num = 0;
1975   struct movable *m;
1976
1977   for (m = LOOP_MOVABLES (loop)->head; m; m = m->next)
1978     if (!m->done)
1979       ++num;
1980
1981   return num;
1982 }
1983
1984 \f
1985 /* Return 1 if regs X and Y will become the same if moved.  */
1986
1987 static int
1988 regs_match_p (rtx x, rtx y, struct loop_movables *movables)
1989 {
1990   unsigned int xn = REGNO (x);
1991   unsigned int yn = REGNO (y);
1992   struct movable *mx, *my;
1993
1994   for (mx = movables->head; mx; mx = mx->next)
1995     if (mx->regno == xn)
1996       break;
1997
1998   for (my = movables->head; my; my = my->next)
1999     if (my->regno == yn)
2000       break;
2001
2002   return (mx && my
2003           && ((mx->match == my->match && mx->match != 0)
2004               || mx->match == my
2005               || mx == my->match));
2006 }
2007
2008 /* Return 1 if X and Y are identical-looking rtx's.
2009    This is the Lisp function EQUAL for rtx arguments.
2010
2011    If two registers are matching movables or a movable register and an
2012    equivalent constant, consider them equal.  */
2013
2014 static int
2015 rtx_equal_for_loop_p (rtx x, rtx y, struct loop_movables *movables,
2016                       struct loop_regs *regs)
2017 {
2018   int i;
2019   int j;
2020   struct movable *m;
2021   enum rtx_code code;
2022   const char *fmt;
2023
2024   if (x == y)
2025     return 1;
2026   if (x == 0 || y == 0)
2027     return 0;
2028
2029   code = GET_CODE (x);
2030
2031   /* If we have a register and a constant, they may sometimes be
2032      equal.  */
2033   if (REG_P (x) && regs->array[REGNO (x)].set_in_loop == -2
2034       && CONSTANT_P (y))
2035     {
2036       for (m = movables->head; m; m = m->next)
2037         if (m->move_insn && m->regno == REGNO (x)
2038             && rtx_equal_p (m->set_src, y))
2039           return 1;
2040     }
2041   else if (REG_P (y) && regs->array[REGNO (y)].set_in_loop == -2
2042            && CONSTANT_P (x))
2043     {
2044       for (m = movables->head; m; m = m->next)
2045         if (m->move_insn && m->regno == REGNO (y)
2046             && rtx_equal_p (m->set_src, x))
2047           return 1;
2048     }
2049
2050   /* Otherwise, rtx's of different codes cannot be equal.  */
2051   if (code != GET_CODE (y))
2052     return 0;
2053
2054   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
2055      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
2056
2057   if (GET_MODE (x) != GET_MODE (y))
2058     return 0;
2059
2060   /* These three types of rtx's can be compared nonrecursively.  */
2061   if (code == REG)
2062     return (REGNO (x) == REGNO (y) || regs_match_p (x, y, movables));
2063
2064   if (code == LABEL_REF)
2065     return XEXP (x, 0) == XEXP (y, 0);
2066   if (code == SYMBOL_REF)
2067     return XSTR (x, 0) == XSTR (y, 0);
2068
2069   /* Compare the elements.  If any pair of corresponding elements
2070      fail to match, return 0 for the whole things.  */
2071
2072   fmt = GET_RTX_FORMAT (code);
2073   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2074     {
2075       switch (fmt[i])
2076         {
2077         case 'w':
2078           if (XWINT (x, i) != XWINT (y, i))
2079             return 0;
2080           break;
2081
2082         case 'i':
2083           if (XINT (x, i) != XINT (y, i))
2084             return 0;
2085           break;
2086
2087         case 'E':
2088           /* Two vectors must have the same length.  */
2089           if (XVECLEN (x, i) != XVECLEN (y, i))
2090             return 0;
2091
2092           /* And the corresponding elements must match.  */
2093           for (j = 0; j < XVECLEN (x, i); j++)
2094             if (rtx_equal_for_loop_p (XVECEXP (x, i, j), XVECEXP (y, i, j),
2095                                       movables, regs) == 0)
2096               return 0;
2097           break;
2098
2099         case 'e':
2100           if (rtx_equal_for_loop_p (XEXP (x, i), XEXP (y, i), movables, regs)
2101               == 0)
2102             return 0;
2103           break;
2104
2105         case 's':
2106           if (strcmp (XSTR (x, i), XSTR (y, i)))
2107             return 0;
2108           break;
2109
2110         case 'u':
2111           /* These are just backpointers, so they don't matter.  */
2112           break;
2113
2114         case '0':
2115           break;
2116
2117           /* It is believed that rtx's at this level will never
2118              contain anything but integers and other rtx's,
2119              except for within LABEL_REFs and SYMBOL_REFs.  */
2120         default:
2121           gcc_unreachable ();
2122         }
2123     }
2124   return 1;
2125 }
2126 \f
2127 /* If X contains any LABEL_REF's, add REG_LABEL notes for them to all
2128    insns in INSNS which use the reference.  LABEL_NUSES for CODE_LABEL
2129    references is incremented once for each added note.  */
2130
2131 static void
2132 add_label_notes (rtx x, rtx insns)
2133 {
2134   enum rtx_code code = GET_CODE (x);
2135   int i, j;
2136   const char *fmt;
2137   rtx insn;
2138
2139   if (code == LABEL_REF && !LABEL_REF_NONLOCAL_P (x))
2140     {
2141       /* This code used to ignore labels that referred to dispatch tables to
2142          avoid flow generating (slightly) worse code.
2143
2144          We no longer ignore such label references (see LABEL_REF handling in
2145          mark_jump_label for additional information).  */
2146       for (insn = insns; insn; insn = NEXT_INSN (insn))
2147         if (reg_mentioned_p (XEXP (x, 0), insn))
2148           {
2149             REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL, XEXP (x, 0),
2150                                                   REG_NOTES (insn));
2151             if (LABEL_P (XEXP (x, 0)))
2152               LABEL_NUSES (XEXP (x, 0))++;
2153           }
2154     }
2155
2156   fmt = GET_RTX_FORMAT (code);
2157   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2158     {
2159       if (fmt[i] == 'e')
2160         add_label_notes (XEXP (x, i), insns);
2161       else if (fmt[i] == 'E')
2162         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2163           add_label_notes (XVECEXP (x, i, j), insns);
2164     }
2165 }
2166 \f
2167 /* Scan MOVABLES, and move the insns that deserve to be moved.
2168    If two matching movables are combined, replace one reg with the
2169    other throughout.  */
2170
2171 static void
2172 move_movables (struct loop *loop, struct loop_movables *movables,
2173                int threshold, int insn_count)
2174 {
2175   struct loop_regs *regs = LOOP_REGS (loop);
2176   int nregs = regs->num;
2177   rtx new_start = 0;
2178   struct movable *m;
2179   rtx p;
2180   rtx loop_start = loop->start;
2181   rtx loop_end = loop->end;
2182   /* Map of pseudo-register replacements to handle combining
2183      when we move several insns that load the same value
2184      into different pseudo-registers.  */
2185   rtx *reg_map = xcalloc (nregs, sizeof (rtx));
2186   char *already_moved = xcalloc (nregs, sizeof (char));
2187
2188   for (m = movables->head; m; m = m->next)
2189     {
2190       /* Describe this movable insn.  */
2191
2192       if (loop_dump_stream)
2193         {
2194           fprintf (loop_dump_stream, "Insn %d: regno %d (life %d), ",
2195                    INSN_UID (m->insn), m->regno, m->lifetime);
2196           if (m->consec > 0)
2197             fprintf (loop_dump_stream, "consec %d, ", m->consec);
2198           if (m->cond)
2199             fprintf (loop_dump_stream, "cond ");
2200           if (m->force)
2201             fprintf (loop_dump_stream, "force ");
2202           if (m->global)
2203             fprintf (loop_dump_stream, "global ");
2204           if (m->done)
2205             fprintf (loop_dump_stream, "done ");
2206           if (m->move_insn)
2207             fprintf (loop_dump_stream, "move-insn ");
2208           if (m->match)
2209             fprintf (loop_dump_stream, "matches %d ",
2210                      INSN_UID (m->match->insn));
2211           if (m->forces)
2212             fprintf (loop_dump_stream, "forces %d ",
2213                      INSN_UID (m->forces->insn));
2214         }
2215
2216       /* Ignore the insn if it's already done (it matched something else).
2217          Otherwise, see if it is now safe to move.  */
2218
2219       if (!m->done
2220           && (! m->cond
2221               || (1 == loop_invariant_p (loop, m->set_src)
2222                   && (m->dependencies == 0
2223                       || 1 == loop_invariant_p (loop, m->dependencies))
2224                   && (m->consec == 0
2225                       || 1 == consec_sets_invariant_p (loop, m->set_dest,
2226                                                        m->consec + 1,
2227                                                        m->insn))))
2228           && (! m->forces || m->forces->done))
2229         {
2230           int regno;
2231           rtx p;
2232           int savings = m->savings;
2233
2234           /* We have an insn that is safe to move.
2235              Compute its desirability.  */
2236
2237           p = m->insn;
2238           regno = m->regno;
2239
2240           if (loop_dump_stream)
2241             fprintf (loop_dump_stream, "savings %d ", savings);
2242
2243           if (regs->array[regno].moved_once && loop_dump_stream)
2244             fprintf (loop_dump_stream, "halved since already moved ");
2245
2246           /* An insn MUST be moved if we already moved something else
2247              which is safe only if this one is moved too: that is,
2248              if already_moved[REGNO] is nonzero.  */
2249
2250           /* An insn is desirable to move if the new lifetime of the
2251              register is no more than THRESHOLD times the old lifetime.
2252              If it's not desirable, it means the loop is so big
2253              that moving won't speed things up much,
2254              and it is liable to make register usage worse.  */
2255
2256           /* It is also desirable to move if it can be moved at no
2257              extra cost because something else was already moved.  */
2258
2259           if (already_moved[regno]
2260               || (threshold * savings * m->lifetime) >=
2261                  (regs->array[regno].moved_once ? insn_count * 2 : insn_count)
2262               || (m->forces && m->forces->done
2263                   && regs->array[m->forces->regno].n_times_set == 1))
2264             {
2265               int count;
2266               struct movable *m1;
2267               rtx first = NULL_RTX;
2268               rtx newreg = NULL_RTX;
2269
2270               if (m->insert_temp)
2271                 newreg = gen_reg_rtx (GET_MODE (m->set_dest));
2272
2273               /* Now move the insns that set the reg.  */
2274
2275               if (m->partial && m->match)
2276                 {
2277                   rtx newpat, i1;
2278                   rtx r1, r2;
2279                   /* Find the end of this chain of matching regs.
2280                      Thus, we load each reg in the chain from that one reg.
2281                      And that reg is loaded with 0 directly,
2282                      since it has ->match == 0.  */
2283                   for (m1 = m; m1->match; m1 = m1->match);
2284                   newpat = gen_move_insn (SET_DEST (PATTERN (m->insn)),
2285                                           SET_DEST (PATTERN (m1->insn)));
2286                   i1 = loop_insn_hoist (loop, newpat);
2287
2288                   /* Mark the moved, invariant reg as being allowed to
2289                      share a hard reg with the other matching invariant.  */
2290                   REG_NOTES (i1) = REG_NOTES (m->insn);
2291                   r1 = SET_DEST (PATTERN (m->insn));
2292                   r2 = SET_DEST (PATTERN (m1->insn));
2293                   regs_may_share
2294                     = gen_rtx_EXPR_LIST (VOIDmode, r1,
2295                                          gen_rtx_EXPR_LIST (VOIDmode, r2,
2296                                                             regs_may_share));
2297                   delete_insn (m->insn);
2298
2299                   if (new_start == 0)
2300                     new_start = i1;
2301
2302                   if (loop_dump_stream)
2303                     fprintf (loop_dump_stream, " moved to %d", INSN_UID (i1));
2304                 }
2305               /* If we are to re-generate the item being moved with a
2306                  new move insn, first delete what we have and then emit
2307                  the move insn before the loop.  */
2308               else if (m->move_insn)
2309                 {
2310                   rtx i1, temp, seq;
2311
2312                   for (count = m->consec; count >= 0; count--)
2313                     {
2314                       if (!NOTE_P (p))
2315                         {
2316                           /* If this is the first insn of a library
2317                              call sequence, something is very
2318                              wrong.  */
2319                           gcc_assert (!find_reg_note
2320                                       (p, REG_LIBCALL, NULL_RTX));
2321
2322                           /* If this is the last insn of a libcall
2323                              sequence, then delete every insn in the
2324                              sequence except the last.  The last insn
2325                              is handled in the normal manner.  */
2326                           temp = find_reg_note (p, REG_RETVAL, NULL_RTX);
2327                           
2328                           if (temp)
2329                             {
2330                               temp = XEXP (temp, 0);
2331                               while (temp != p)
2332                                 temp = delete_insn (temp);
2333                             }
2334                         }
2335
2336                       temp = p;
2337                       p = delete_insn (p);
2338
2339                       /* simplify_giv_expr expects that it can walk the insns
2340                          at m->insn forwards and see this old sequence we are
2341                          tossing here.  delete_insn does preserve the next
2342                          pointers, but when we skip over a NOTE we must fix
2343                          it up.  Otherwise that code walks into the non-deleted
2344                          insn stream.  */
2345                       while (p && NOTE_P (p))
2346                         p = NEXT_INSN (temp) = NEXT_INSN (p);
2347
2348                       if (m->insert_temp)
2349                         {
2350                           /* Replace the original insn with a move from
2351                              our newly created temp.  */
2352                           start_sequence ();
2353                           emit_move_insn (m->set_dest, newreg);
2354                           seq = get_insns ();
2355                           end_sequence ();
2356                           emit_insn_before (seq, p);
2357                         }
2358                     }
2359
2360                   start_sequence ();
2361                   emit_move_insn (m->insert_temp ? newreg : m->set_dest,
2362                                   m->set_src);
2363                   seq = get_insns ();
2364                   end_sequence ();
2365
2366                   add_label_notes (m->set_src, seq);
2367
2368                   i1 = loop_insn_hoist (loop, seq);
2369                   if (! find_reg_note (i1, REG_EQUAL, NULL_RTX))
2370                     set_unique_reg_note (i1,
2371                                          m->is_equiv ? REG_EQUIV : REG_EQUAL,
2372                                          m->set_src);
2373
2374                   if (loop_dump_stream)
2375                     fprintf (loop_dump_stream, " moved to %d", INSN_UID (i1));
2376
2377                   /* The more regs we move, the less we like moving them.  */
2378                   threshold -= 3;
2379                 }
2380               else
2381                 {
2382                   for (count = m->consec; count >= 0; count--)
2383                     {
2384                       rtx i1, temp;
2385
2386                       /* If first insn of libcall sequence, skip to end.  */
2387                       /* Do this at start of loop, since p is guaranteed to
2388                          be an insn here.  */
2389                       if (!NOTE_P (p)
2390                           && (temp = find_reg_note (p, REG_LIBCALL, NULL_RTX)))
2391                         p = XEXP (temp, 0);
2392
2393                       /* If last insn of libcall sequence, move all
2394                          insns except the last before the loop.  The last
2395                          insn is handled in the normal manner.  */
2396                       if (!NOTE_P (p)
2397                           && (temp = find_reg_note (p, REG_RETVAL, NULL_RTX)))
2398                         {
2399                           rtx fn_address = 0;
2400                           rtx fn_reg = 0;
2401                           rtx fn_address_insn = 0;
2402
2403                           first = 0;
2404                           for (temp = XEXP (temp, 0); temp != p;
2405                                temp = NEXT_INSN (temp))
2406                             {
2407                               rtx body;
2408                               rtx n;
2409                               rtx next;
2410
2411                               if (NOTE_P (temp))
2412                                 continue;
2413
2414                               body = PATTERN (temp);
2415
2416                               /* Find the next insn after TEMP,
2417                                  not counting USE or NOTE insns.  */
2418                               for (next = NEXT_INSN (temp); next != p;
2419                                    next = NEXT_INSN (next))
2420                                 if (! (NONJUMP_INSN_P (next)
2421                                        && GET_CODE (PATTERN (next)) == USE)
2422                                     && !NOTE_P (next))
2423                                   break;
2424
2425                               /* If that is the call, this may be the insn
2426                                  that loads the function address.
2427
2428                                  Extract the function address from the insn
2429                                  that loads it into a register.
2430                                  If this insn was cse'd, we get incorrect code.
2431
2432                                  So emit a new move insn that copies the
2433                                  function address into the register that the
2434                                  call insn will use.  flow.c will delete any
2435                                  redundant stores that we have created.  */
2436                               if (CALL_P (next)
2437                                   && GET_CODE (body) == SET
2438                                   && REG_P (SET_DEST (body))
2439                                   && (n = find_reg_note (temp, REG_EQUAL,
2440                                                          NULL_RTX)))
2441                                 {
2442                                   fn_reg = SET_SRC (body);
2443                                   if (!REG_P (fn_reg))
2444                                     fn_reg = SET_DEST (body);
2445                                   fn_address = XEXP (n, 0);
2446                                   fn_address_insn = temp;
2447                                 }
2448                               /* We have the call insn.
2449                                  If it uses the register we suspect it might,
2450                                  load it with the correct address directly.  */
2451                               if (CALL_P (temp)
2452                                   && fn_address != 0
2453                                   && reg_referenced_p (fn_reg, body))
2454                                 loop_insn_emit_after (loop, 0, fn_address_insn,
2455                                                       gen_move_insn
2456                                                       (fn_reg, fn_address));
2457
2458                               if (CALL_P (temp))
2459                                 {
2460                                   i1 = loop_call_insn_hoist (loop, body);
2461                                   /* Because the USAGE information potentially
2462                                      contains objects other than hard registers
2463                                      we need to copy it.  */
2464                                   if (CALL_INSN_FUNCTION_USAGE (temp))
2465                                     CALL_INSN_FUNCTION_USAGE (i1)
2466                                       = copy_rtx (CALL_INSN_FUNCTION_USAGE (temp));
2467                                 }
2468                               else
2469                                 i1 = loop_insn_hoist (loop, body);
2470                               if (first == 0)
2471                                 first = i1;
2472                               if (temp == fn_address_insn)
2473                                 fn_address_insn = i1;
2474                               REG_NOTES (i1) = REG_NOTES (temp);
2475                               REG_NOTES (temp) = NULL;
2476                               delete_insn (temp);
2477                             }
2478                           if (new_start == 0)
2479                             new_start = first;
2480                         }
2481                       if (m->savemode != VOIDmode)
2482                         {
2483                           /* P sets REG to zero; but we should clear only
2484                              the bits that are not covered by the mode
2485                              m->savemode.  */
2486                           rtx reg = m->set_dest;
2487                           rtx sequence;
2488                           rtx tem;
2489
2490                           start_sequence ();
2491                           tem = expand_simple_binop
2492                             (GET_MODE (reg), AND, reg,
2493                              GEN_INT ((((HOST_WIDE_INT) 1
2494                                         << GET_MODE_BITSIZE (m->savemode)))
2495                                       - 1),
2496                              reg, 1, OPTAB_LIB_WIDEN);
2497                           gcc_assert (tem);
2498                           if (tem != reg)
2499                             emit_move_insn (reg, tem);
2500                           sequence = get_insns ();
2501                           end_sequence ();
2502                           i1 = loop_insn_hoist (loop, sequence);
2503                         }
2504                       else if (CALL_P (p))
2505                         {
2506                           i1 = loop_call_insn_hoist (loop, PATTERN (p));
2507                           /* Because the USAGE information potentially
2508                              contains objects other than hard registers
2509                              we need to copy it.  */
2510                           if (CALL_INSN_FUNCTION_USAGE (p))
2511                             CALL_INSN_FUNCTION_USAGE (i1)
2512                               = copy_rtx (CALL_INSN_FUNCTION_USAGE (p));
2513                         }
2514                       else if (count == m->consec && m->move_insn_first)
2515                         {
2516                           rtx seq;
2517                           /* The SET_SRC might not be invariant, so we must
2518                              use the REG_EQUAL note.  */
2519                           start_sequence ();
2520                           emit_move_insn (m->insert_temp ? newreg : m->set_dest,
2521                                           m->set_src);
2522                           seq = get_insns ();
2523                           end_sequence ();
2524
2525                           add_label_notes (m->set_src, seq);
2526
2527                           i1 = loop_insn_hoist (loop, seq);
2528                           if (! find_reg_note (i1, REG_EQUAL, NULL_RTX))
2529                             set_unique_reg_note (i1, m->is_equiv ? REG_EQUIV
2530                                                      : REG_EQUAL, m->set_src);
2531                         }
2532                       else if (m->insert_temp)
2533                         {
2534                           rtx *reg_map2 = xcalloc (REGNO (newreg),
2535                                                    sizeof(rtx));
2536                           reg_map2 [m->regno] = newreg;
2537
2538                           i1 = loop_insn_hoist (loop, copy_rtx (PATTERN (p)));
2539                           replace_regs (i1, reg_map2, REGNO (newreg), 1);
2540                           free (reg_map2);
2541                         }
2542                       else
2543                         i1 = loop_insn_hoist (loop, PATTERN (p));
2544
2545                       if (REG_NOTES (i1) == 0)
2546                         {
2547                           REG_NOTES (i1) = REG_NOTES (p);
2548                           REG_NOTES (p) = NULL;
2549
2550                           /* If there is a REG_EQUAL note present whose value
2551                              is not loop invariant, then delete it, since it
2552                              may cause problems with later optimization passes.
2553                              It is possible for cse to create such notes
2554                              like this as a result of record_jump_cond.  */
2555
2556                           if ((temp = find_reg_note (i1, REG_EQUAL, NULL_RTX))
2557                               && ! loop_invariant_p (loop, XEXP (temp, 0)))
2558                             remove_note (i1, temp);
2559                         }
2560
2561                       if (new_start == 0)
2562                         new_start = i1;
2563
2564                       if (loop_dump_stream)
2565                         fprintf (loop_dump_stream, " moved to %d",
2566                                  INSN_UID (i1));
2567
2568                       /* If library call, now fix the REG_NOTES that contain
2569                          insn pointers, namely REG_LIBCALL on FIRST
2570                          and REG_RETVAL on I1.  */
2571                       if ((temp = find_reg_note (i1, REG_RETVAL, NULL_RTX)))
2572                         {
2573                           XEXP (temp, 0) = first;
2574                           temp = find_reg_note (first, REG_LIBCALL, NULL_RTX);
2575                           XEXP (temp, 0) = i1;
2576                         }
2577
2578                       temp = p;
2579                       delete_insn (p);
2580                       p = NEXT_INSN (p);
2581
2582                       /* simplify_giv_expr expects that it can walk the insns
2583                          at m->insn forwards and see this old sequence we are
2584                          tossing here.  delete_insn does preserve the next
2585                          pointers, but when we skip over a NOTE we must fix
2586                          it up.  Otherwise that code walks into the non-deleted
2587                          insn stream.  */
2588                       while (p && NOTE_P (p))
2589                         p = NEXT_INSN (temp) = NEXT_INSN (p);
2590
2591                       if (m->insert_temp)
2592                         {
2593                           rtx seq;
2594                           /* Replace the original insn with a move from
2595                              our newly created temp.  */
2596                           start_sequence ();
2597                           emit_move_insn (m->set_dest, newreg);
2598                           seq = get_insns ();
2599                           end_sequence ();
2600                           emit_insn_before (seq, p);
2601                         }
2602                     }
2603
2604                   /* The more regs we move, the less we like moving them.  */
2605                   threshold -= 3;
2606                 }
2607
2608               m->done = 1;
2609
2610               if (!m->insert_temp)
2611                 {
2612                   /* Any other movable that loads the same register
2613                      MUST be moved.  */
2614                   already_moved[regno] = 1;
2615
2616                   /* This reg has been moved out of one loop.  */
2617                   regs->array[regno].moved_once = 1;
2618
2619                   /* The reg set here is now invariant.  */
2620                   if (! m->partial)
2621                     {
2622                       int i;
2623                       for (i = 0; i < LOOP_REGNO_NREGS (regno, m->set_dest); i++)
2624                         regs->array[regno+i].set_in_loop = 0;
2625                     }
2626
2627                   /* Change the length-of-life info for the register
2628                      to say it lives at least the full length of this loop.
2629                      This will help guide optimizations in outer loops.  */
2630
2631                   if (REGNO_FIRST_LUID (regno) > INSN_LUID (loop_start))
2632                     /* This is the old insn before all the moved insns.
2633                        We can't use the moved insn because it is out of range
2634                        in uid_luid.  Only the old insns have luids.  */
2635                     REGNO_FIRST_UID (regno) = INSN_UID (loop_start);
2636                   if (REGNO_LAST_LUID (regno) < INSN_LUID (loop_end))
2637                     REGNO_LAST_UID (regno) = INSN_UID (loop_end);
2638                 }
2639
2640               /* Combine with this moved insn any other matching movables.  */
2641
2642               if (! m->partial)
2643                 for (m1 = movables->head; m1; m1 = m1->next)
2644                   if (m1->match == m)
2645                     {
2646                       rtx temp;
2647
2648                       /* Schedule the reg loaded by M1
2649                          for replacement so that shares the reg of M.
2650                          If the modes differ (only possible in restricted
2651                          circumstances, make a SUBREG.
2652
2653                          Note this assumes that the target dependent files
2654                          treat REG and SUBREG equally, including within
2655                          GO_IF_LEGITIMATE_ADDRESS and in all the
2656                          predicates since we never verify that replacing the
2657                          original register with a SUBREG results in a
2658                          recognizable insn.  */
2659                       if (GET_MODE (m->set_dest) == GET_MODE (m1->set_dest))
2660                         reg_map[m1->regno] = m->set_dest;
2661                       else
2662                         reg_map[m1->regno]
2663                           = gen_lowpart_common (GET_MODE (m1->set_dest),
2664                                                 m->set_dest);
2665
2666                       /* Get rid of the matching insn
2667                          and prevent further processing of it.  */
2668                       m1->done = 1;
2669
2670                       /* If library call, delete all insns.  */
2671                       if ((temp = find_reg_note (m1->insn, REG_RETVAL,
2672                                                  NULL_RTX)))
2673                         delete_insn_chain (XEXP (temp, 0), m1->insn);
2674                       else
2675                         delete_insn (m1->insn);
2676
2677                       /* Any other movable that loads the same register
2678                          MUST be moved.  */
2679                       already_moved[m1->regno] = 1;
2680
2681                       /* The reg merged here is now invariant,
2682                          if the reg it matches is invariant.  */
2683                       if (! m->partial)
2684                         {
2685                           int i;
2686                           for (i = 0;
2687                                i < LOOP_REGNO_NREGS (regno, m1->set_dest);
2688                                i++)
2689                             regs->array[m1->regno+i].set_in_loop = 0;
2690                         }
2691                     }
2692             }
2693           else if (loop_dump_stream)
2694             fprintf (loop_dump_stream, "not desirable");
2695         }
2696       else if (loop_dump_stream && !m->match)
2697         fprintf (loop_dump_stream, "not safe");
2698
2699       if (loop_dump_stream)
2700         fprintf (loop_dump_stream, "\n");
2701     }
2702
2703   if (new_start == 0)
2704     new_start = loop_start;
2705
2706   /* Go through all the instructions in the loop, making
2707      all the register substitutions scheduled in REG_MAP.  */
2708   for (p = new_start; p != loop_end; p = NEXT_INSN (p))
2709     if (INSN_P (p))
2710       {
2711         replace_regs (PATTERN (p), reg_map, nregs, 0);
2712         replace_regs (REG_NOTES (p), reg_map, nregs, 0);
2713         INSN_CODE (p) = -1;
2714       }
2715
2716   /* Clean up.  */
2717   free (reg_map);
2718   free (already_moved);
2719 }
2720
2721
2722 static void
2723 loop_movables_add (struct loop_movables *movables, struct movable *m)
2724 {
2725   if (movables->head == 0)
2726     movables->head = m;
2727   else
2728     movables->last->next = m;
2729   movables->last = m;
2730 }
2731
2732
2733 static void
2734 loop_movables_free (struct loop_movables *movables)
2735 {
2736   struct movable *m;
2737   struct movable *m_next;
2738
2739   for (m = movables->head; m; m = m_next)
2740     {
2741       m_next = m->next;
2742       free (m);
2743     }
2744 }
2745 \f
2746 #if 0
2747 /* Scan X and replace the address of any MEM in it with ADDR.
2748    REG is the address that MEM should have before the replacement.  */
2749
2750 static void
2751 replace_call_address (rtx x, rtx reg, rtx addr)
2752 {
2753   enum rtx_code code;
2754   int i;
2755   const char *fmt;
2756
2757   if (x == 0)
2758     return;
2759   code = GET_CODE (x);
2760   switch (code)
2761     {
2762     case PC:
2763     case CC0:
2764     case CONST_INT:
2765     case CONST_DOUBLE:
2766     case CONST:
2767     case SYMBOL_REF:
2768     case LABEL_REF:
2769     case REG:
2770       return;
2771
2772     case SET:
2773       /* Short cut for very common case.  */
2774       replace_call_address (XEXP (x, 1), reg, addr);
2775       return;
2776
2777     case CALL:
2778       /* Short cut for very common case.  */
2779       replace_call_address (XEXP (x, 0), reg, addr);
2780       return;
2781
2782     case MEM:
2783       /* If this MEM uses a reg other than the one we expected,
2784          something is wrong.  */
2785       gcc_assert (XEXP (x, 0) == reg);
2786       XEXP (x, 0) = addr;
2787       return;
2788
2789     default:
2790       break;
2791     }
2792
2793   fmt = GET_RTX_FORMAT (code);
2794   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2795     {
2796       if (fmt[i] == 'e')
2797         replace_call_address (XEXP (x, i), reg, addr);
2798       else if (fmt[i] == 'E')
2799         {
2800           int j;
2801           for (j = 0; j < XVECLEN (x, i); j++)
2802             replace_call_address (XVECEXP (x, i, j), reg, addr);
2803         }
2804     }
2805 }
2806 #endif
2807 \f
2808 /* Return the number of memory refs to addresses that vary
2809    in the rtx X.  */
2810
2811 static int
2812 count_nonfixed_reads (const struct loop *loop, rtx x)
2813 {
2814   enum rtx_code code;
2815   int i;
2816   const char *fmt;
2817   int value;
2818
2819   if (x == 0)
2820     return 0;
2821
2822   code = GET_CODE (x);
2823   switch (code)
2824     {
2825     case PC:
2826     case CC0:
2827     case CONST_INT:
2828     case CONST_DOUBLE:
2829     case CONST:
2830     case SYMBOL_REF:
2831     case LABEL_REF:
2832     case REG:
2833       return 0;
2834
2835     case MEM:
2836       return ((loop_invariant_p (loop, XEXP (x, 0)) != 1)
2837               + count_nonfixed_reads (loop, XEXP (x, 0)));
2838
2839     default:
2840       break;
2841     }
2842
2843   value = 0;
2844   fmt = GET_RTX_FORMAT (code);
2845   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2846     {
2847       if (fmt[i] == 'e')
2848         value += count_nonfixed_reads (loop, XEXP (x, i));
2849       if (fmt[i] == 'E')
2850         {
2851           int j;
2852           for (j = 0; j < XVECLEN (x, i); j++)
2853             value += count_nonfixed_reads (loop, XVECEXP (x, i, j));
2854         }
2855     }
2856   return value;
2857 }
2858 \f
2859 /* Scan a loop setting the elements `loops_enclosed',
2860    `has_call', `has_nonconst_call', `has_volatile', `has_tablejump',
2861    `unknown_address_altered', `unknown_constant_address_altered', and
2862    `num_mem_sets' in LOOP.  Also, fill in the array `mems' and the
2863    list `store_mems' in LOOP.  */
2864
2865 static void
2866 prescan_loop (struct loop *loop)
2867 {
2868   int level = 1;
2869   rtx insn;
2870   struct loop_info *loop_info = LOOP_INFO (loop);
2871   rtx start = loop->start;
2872   rtx end = loop->end;
2873   /* The label after END.  Jumping here is just like falling off the
2874      end of the loop.  We use next_nonnote_insn instead of next_label
2875      as a hedge against the (pathological) case where some actual insn
2876      might end up between the two.  */
2877   rtx exit_target = next_nonnote_insn (end);
2878
2879   loop_info->has_indirect_jump = indirect_jump_in_function;
2880   loop_info->pre_header_has_call = 0;
2881   loop_info->has_call = 0;
2882   loop_info->has_nonconst_call = 0;
2883   loop_info->has_prefetch = 0;
2884   loop_info->has_volatile = 0;
2885   loop_info->has_tablejump = 0;
2886   loop_info->has_multiple_exit_targets = 0;
2887   loop->level = 1;
2888
2889   loop_info->unknown_address_altered = 0;
2890   loop_info->unknown_constant_address_altered = 0;
2891   loop_info->store_mems = NULL_RTX;
2892   loop_info->first_loop_store_insn = NULL_RTX;
2893   loop_info->mems_idx = 0;
2894   loop_info->num_mem_sets = 0;
2895
2896   for (insn = start; insn && !LABEL_P (insn);
2897        insn = PREV_INSN (insn))
2898     {
2899       if (CALL_P (insn))
2900         {
2901           loop_info->pre_header_has_call = 1;
2902           break;
2903         }
2904     }
2905
2906   for (insn = NEXT_INSN (start); insn != NEXT_INSN (end);
2907        insn = NEXT_INSN (insn))
2908     {
2909       switch (GET_CODE (insn))
2910         {
2911         case NOTE:
2912           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
2913             {
2914               ++level;
2915               /* Count number of loops contained in this one.  */
2916               loop->level++;
2917             }
2918           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
2919             --level;
2920           break;
2921
2922         case CALL_INSN:
2923           if (! CONST_OR_PURE_CALL_P (insn))
2924             {
2925               loop_info->unknown_address_altered = 1;
2926               loop_info->has_nonconst_call = 1;
2927             }
2928           else if (pure_call_p (insn))
2929             loop_info->has_nonconst_call = 1;
2930           loop_info->has_call = 1;
2931           if (can_throw_internal (insn))
2932             loop_info->has_multiple_exit_targets = 1;
2933           break;
2934
2935         case JUMP_INSN:
2936           if (! loop_info->has_multiple_exit_targets)
2937             {
2938               rtx set = pc_set (insn);
2939
2940               if (set)
2941                 {
2942                   rtx src = SET_SRC (set);
2943                   rtx label1, label2;
2944
2945                   if (GET_CODE (src) == IF_THEN_ELSE)
2946                     {
2947                       label1 = XEXP (src, 1);
2948                       label2 = XEXP (src, 2);
2949                     }
2950                   else
2951                     {
2952                       label1 = src;
2953                       label2 = NULL_RTX;
2954                     }
2955
2956                   do
2957                     {
2958                       if (label1 && label1 != pc_rtx)
2959                         {
2960                           if (GET_CODE (label1) != LABEL_REF)
2961                             {
2962                               /* Something tricky.  */
2963                               loop_info->has_multiple_exit_targets = 1;
2964                               break;
2965                             }
2966                           else if (XEXP (label1, 0) != exit_target
2967                                    && LABEL_OUTSIDE_LOOP_P (label1))
2968                             {
2969                               /* A jump outside the current loop.  */
2970                               loop_info->has_multiple_exit_targets = 1;
2971                               break;
2972                             }
2973                         }
2974
2975                       label1 = label2;
2976                       label2 = NULL_RTX;
2977                     }
2978                   while (label1);
2979                 }
2980               else
2981                 {
2982                   /* A return, or something tricky.  */
2983                   loop_info->has_multiple_exit_targets = 1;
2984                 }
2985             }
2986           /* Fall through.  */
2987
2988         case INSN:
2989           if (volatile_refs_p (PATTERN (insn)))
2990             loop_info->has_volatile = 1;
2991
2992           if (JUMP_P (insn)
2993               && (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
2994                   || GET_CODE (PATTERN (insn)) == ADDR_VEC))
2995             loop_info->has_tablejump = 1;
2996
2997           note_stores (PATTERN (insn), note_addr_stored, loop_info);
2998           if (! loop_info->first_loop_store_insn && loop_info->store_mems)
2999             loop_info->first_loop_store_insn = insn;
3000
3001           if (flag_non_call_exceptions && can_throw_internal (insn))
3002             loop_info->has_multiple_exit_targets = 1;
3003           break;
3004
3005         default:
3006           break;
3007         }
3008     }
3009
3010   /* Now, rescan the loop, setting up the LOOP_MEMS array.  */
3011   if (/* An exception thrown by a called function might land us
3012          anywhere.  */
3013       ! loop_info->has_nonconst_call
3014       /* We don't want loads for MEMs moved to a location before the
3015          one at which their stack memory becomes allocated.  (Note
3016          that this is not a problem for malloc, etc., since those
3017          require actual function calls.  */
3018       && ! current_function_calls_alloca
3019       /* There are ways to leave the loop other than falling off the
3020          end.  */
3021       && ! loop_info->has_multiple_exit_targets)
3022     for (insn = NEXT_INSN (start); insn != NEXT_INSN (end);
3023          insn = NEXT_INSN (insn))
3024       for_each_rtx (&insn, insert_loop_mem, loop_info);
3025
3026   /* BLKmode MEMs are added to LOOP_STORE_MEM as necessary so
3027      that loop_invariant_p and load_mems can use true_dependence
3028      to determine what is really clobbered.  */
3029   if (loop_info->unknown_address_altered)
3030     {
3031       rtx mem = gen_rtx_MEM (BLKmode, const0_rtx);
3032
3033       loop_info->store_mems
3034         = gen_rtx_EXPR_LIST (VOIDmode, mem, loop_info->store_mems);
3035     }
3036   if (loop_info->unknown_constant_address_altered)
3037     {
3038       rtx mem = gen_rtx_MEM (BLKmode, const0_rtx);
3039       MEM_READONLY_P (mem) = 1;
3040       loop_info->store_mems
3041         = gen_rtx_EXPR_LIST (VOIDmode, mem, loop_info->store_mems);
3042     }
3043 }
3044 \f
3045 /* Invalidate all loops containing LABEL.  */
3046
3047 static void
3048 invalidate_loops_containing_label (rtx label)
3049 {
3050   struct loop *loop;
3051   for (loop = uid_loop[INSN_UID (label)]; loop; loop = loop->outer)
3052     loop->invalid = 1;
3053 }
3054
3055 /* Scan the function looking for loops.  Record the start and end of each loop.
3056    Also mark as invalid loops any loops that contain a setjmp or are branched
3057    to from outside the loop.  */
3058
3059 static void
3060 find_and_verify_loops (rtx f, struct loops *loops)
3061 {
3062   rtx insn;
3063   rtx label;
3064   int num_loops;
3065   struct loop *current_loop;
3066   struct loop *next_loop;
3067   struct loop *loop;
3068
3069   num_loops = loops->num;
3070
3071   compute_luids (f, NULL_RTX, 0);
3072
3073   /* If there are jumps to undefined labels,
3074      treat them as jumps out of any/all loops.
3075      This also avoids writing past end of tables when there are no loops.  */
3076   uid_loop[0] = NULL;
3077
3078   /* Find boundaries of loops, mark which loops are contained within
3079      loops, and invalidate loops that have setjmp.  */
3080
3081   num_loops = 0;
3082   current_loop = NULL;
3083   for (insn = f; insn; insn = NEXT_INSN (insn))
3084     {
3085       if (NOTE_P (insn))
3086         switch (NOTE_LINE_NUMBER (insn))
3087           {
3088           case NOTE_INSN_LOOP_BEG:
3089             next_loop = loops->array + num_loops;
3090             next_loop->num = num_loops;
3091             num_loops++;
3092             next_loop->start = insn;
3093             next_loop->outer = current_loop;
3094             current_loop = next_loop;
3095             break;
3096
3097           case NOTE_INSN_LOOP_END:
3098             gcc_assert (current_loop);
3099
3100             current_loop->end = insn;
3101             current_loop = current_loop->outer;
3102             break;
3103
3104           default:
3105             break;
3106           }
3107
3108       if (CALL_P (insn)
3109           && find_reg_note (insn, REG_SETJMP, NULL))
3110         {
3111           /* In this case, we must invalidate our current loop and any
3112              enclosing loop.  */
3113           for (loop = current_loop; loop; loop = loop->outer)
3114             {
3115               loop->invalid = 1;
3116               if (loop_dump_stream)
3117                 fprintf (loop_dump_stream,
3118                          "\nLoop at %d ignored due to setjmp.\n",
3119                          INSN_UID (loop->start));
3120             }
3121         }
3122
3123       /* Note that this will mark the NOTE_INSN_LOOP_END note as being in the
3124          enclosing loop, but this doesn't matter.  */
3125       uid_loop[INSN_UID (insn)] = current_loop;
3126     }
3127
3128   /* Any loop containing a label used in an initializer must be invalidated,
3129      because it can be jumped into from anywhere.  */
3130   for (label = forced_labels; label; label = XEXP (label, 1))
3131     invalidate_loops_containing_label (XEXP (label, 0));
3132
3133   /* Any loop containing a label used for an exception handler must be
3134      invalidated, because it can be jumped into from anywhere.  */
3135   for_each_eh_label (invalidate_loops_containing_label);
3136
3137   /* Now scan all insn's in the function.  If any JUMP_INSN branches into a
3138      loop that it is not contained within, that loop is marked invalid.
3139      If any INSN or CALL_INSN uses a label's address, then the loop containing
3140      that label is marked invalid, because it could be jumped into from
3141      anywhere.
3142
3143      Also look for blocks of code ending in an unconditional branch that
3144      exits the loop.  If such a block is surrounded by a conditional
3145      branch around the block, move the block elsewhere (see below) and
3146      invert the jump to point to the code block.  This may eliminate a
3147      label in our loop and will simplify processing by both us and a
3148      possible second cse pass.  */
3149
3150   for (insn = f; insn; insn = NEXT_INSN (insn))
3151     if (INSN_P (insn))
3152       {
3153         struct loop *this_loop = uid_loop[INSN_UID (insn)];
3154
3155         if (NONJUMP_INSN_P (insn) || CALL_P (insn))
3156           {
3157             rtx note = find_reg_note (insn, REG_LABEL, NULL_RTX);
3158             if (note)
3159               invalidate_loops_containing_label (XEXP (note, 0));
3160           }
3161
3162         if (!JUMP_P (insn))
3163           continue;
3164
3165         mark_loop_jump (PATTERN (insn), this_loop);
3166
3167         /* See if this is an unconditional branch outside the loop.  */
3168         if (this_loop
3169             && (GET_CODE (PATTERN (insn)) == RETURN
3170                 || (any_uncondjump_p (insn)
3171                     && onlyjump_p (insn)
3172                     && (uid_loop[INSN_UID (JUMP_LABEL (insn))]
3173                         != this_loop)))
3174             && get_max_uid () < max_uid_for_loop)
3175           {
3176             rtx p;
3177             rtx our_next = next_real_insn (insn);
3178             rtx last_insn_to_move = NEXT_INSN (insn);
3179             struct loop *dest_loop;
3180             struct loop *outer_loop = NULL;
3181
3182             /* Go backwards until we reach the start of the loop, a label,
3183                or a JUMP_INSN.  */
3184             for (p = PREV_INSN (insn);
3185                  !LABEL_P (p)
3186                  && ! (NOTE_P (p)
3187                        && NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_BEG)
3188                  && !JUMP_P (p);
3189                  p = PREV_INSN (p))
3190               ;
3191
3192             /* Check for the case where we have a jump to an inner nested
3193                loop, and do not perform the optimization in that case.  */
3194
3195             if (JUMP_LABEL (insn))
3196               {
3197                 dest_loop = uid_loop[INSN_UID (JUMP_LABEL (insn))];
3198                 if (dest_loop)
3199                   {
3200                     for (outer_loop = dest_loop; outer_loop;
3201                          outer_loop = outer_loop->outer)
3202                       if (outer_loop == this_loop)
3203                         break;
3204                   }
3205               }
3206
3207             /* Make sure that the target of P is within the current loop.  */
3208
3209             if (JUMP_P (p) && JUMP_LABEL (p)
3210                 && uid_loop[INSN_UID (JUMP_LABEL (p))] != this_loop)
3211               outer_loop = this_loop;
3212
3213             /* If we stopped on a JUMP_INSN to the next insn after INSN,
3214                we have a block of code to try to move.
3215
3216                We look backward and then forward from the target of INSN
3217                to find a BARRIER at the same loop depth as the target.
3218                If we find such a BARRIER, we make a new label for the start
3219                of the block, invert the jump in P and point it to that label,
3220                and move the block of code to the spot we found.  */
3221
3222             if (! outer_loop
3223                 && JUMP_P (p)
3224                 && JUMP_LABEL (p) != 0
3225                 /* Just ignore jumps to labels that were never emitted.
3226                    These always indicate compilation errors.  */
3227                 && INSN_UID (JUMP_LABEL (p)) != 0
3228                 && any_condjump_p (p) && onlyjump_p (p)
3229                 && next_real_insn (JUMP_LABEL (p)) == our_next
3230                 /* If it's not safe to move the sequence, then we
3231                    mustn't try.  */
3232                 && insns_safe_to_move_p (p, NEXT_INSN (insn),
3233                                          &last_insn_to_move))
3234               {
3235                 rtx target
3236                   = JUMP_LABEL (insn) ? JUMP_LABEL (insn) : get_last_insn ();
3237                 struct loop *target_loop = uid_loop[INSN_UID (target)];
3238                 rtx loc, loc2;