contrib/gcc/loop.c

   1 /* Perform various loop optimizations, including strength reduction.
   2    Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /* This is the loop optimization pass of the compiler.
  23    It finds invariant computations within loops and moves them
  24    to the beginning of the loop.  Then it identifies basic and
  25    general induction variables.  Strength reduction is applied to the general
  26    induction variables, and induction variable elimination is applied to
  27    the basic induction variables.
  28
  29    It also finds cases where
  30    a register is set within the loop by zero-extending a narrower value
  31    and changes these to zero the entire register once before the loop
  32    and merely copy the low part within the loop.
  33
  34    Most of the complexity is in heuristics to decide when it is worth
  35    while to do these things.  */
  36
  37 #include "config.h"
  38 #include "system.h"
  39 #include "rtl.h"
  40 #include "tm_p.h"
  41 #include "obstack.h"
  42 #include "function.h"
  43 #include "expr.h"
  44 #include "hard-reg-set.h"
  45 #include "basic-block.h"
  46 #include "insn-config.h"
  47 #include "regs.h"
  48 #include "recog.h"
  49 #include "flags.h"
  50 #include "real.h"
  51 #include "loop.h"
  52 #include "cselib.h"
  53 #include "except.h"
  54 #include "toplev.h"
  55 #include "predict.h"
  56 #include "insn-flags.h"
  57 #include "optabs.h"
  58
  59 /* Not really meaningful values, but at least something.  */
  60 #ifndef SIMULTANEOUS_PREFETCHES
  61 #define SIMULTANEOUS_PREFETCHES 3
  62 #endif
  63 #ifndef PREFETCH_BLOCK
  64 #define PREFETCH_BLOCK 32
  65 #endif
  66 #ifndef HAVE_prefetch
  67 #define HAVE_prefetch 0
  68 #define CODE_FOR_prefetch 0
  69 #define gen_prefetch(a,b,c) (abort(), NULL_RTX)
  70 #endif
  71
  72 /* Give up the prefetch optimizations once we exceed a given threshhold.
  73    It is unlikely that we would be able to optimize something in a loop
  74    with so many detected prefetches.  */
  75 #define MAX_PREFETCHES 100
  76 /* The number of prefetch blocks that are beneficial to fetch at once before
  77    a loop with a known (and low) iteration count.  */
  78 #define PREFETCH_BLOCKS_BEFORE_LOOP_MAX  6
  79 /* For very tiny loops it is not worthwhile to prefetch even before the loop,
  80    since it is likely that the data are already in the cache.  */
  81 #define PREFETCH_BLOCKS_BEFORE_LOOP_MIN  2
  82 /* The minimal number of prefetch blocks that a loop must consume to make
  83    the emitting of prefetch instruction in the body of loop worthwhile.  */
  84 #define PREFETCH_BLOCKS_IN_LOOP_MIN  6
  85
  86 /* Parameterize some prefetch heuristics so they can be turned on and off
  87    easily for performance testing on new architecures.  These can be
  88    defined in target-dependent files.  */
  89
  90 /* Prefetch is worthwhile only when loads/stores are dense.  */
  91 #ifndef PREFETCH_ONLY_DENSE_MEM
  92 #define PREFETCH_ONLY_DENSE_MEM 1
  93 #endif
  94
  95 /* Define what we mean by "dense" loads and stores; This value divided by 256
  96    is the minimum percentage of memory references that worth prefetching.  */
  97 #ifndef PREFETCH_DENSE_MEM
  98 #define PREFETCH_DENSE_MEM 220
  99 #endif
 100
 101 /* Do not prefetch for a loop whose iteration count is known to be low.  */
 102 #ifndef PREFETCH_NO_LOW_LOOPCNT
 103 #define PREFETCH_NO_LOW_LOOPCNT 1
 104 #endif
 105
 106 /* Define what we mean by a "low" iteration count.  */
 107 #ifndef PREFETCH_LOW_LOOPCNT
 108 #define PREFETCH_LOW_LOOPCNT 32
 109 #endif
 110
 111 /* Do not prefetch for a loop that contains a function call; such a loop is
 112    probably not an internal loop.  */
 113 #ifndef PREFETCH_NO_CALL
 114 #define PREFETCH_NO_CALL 1
 115 #endif
 116
 117 /* Do not prefetch accesses with an extreme stride.  */
 118 #ifndef PREFETCH_NO_EXTREME_STRIDE
 119 #define PREFETCH_NO_EXTREME_STRIDE 1
 120 #endif
 121
 122 /* Define what we mean by an "extreme" stride.  */
 123 #ifndef PREFETCH_EXTREME_STRIDE
 124 #define PREFETCH_EXTREME_STRIDE 4096
 125 #endif
 126
 127 /* Do not handle reversed order prefetches (negative stride).  */
 128 #ifndef PREFETCH_NO_REVERSE_ORDER
 129 #define PREFETCH_NO_REVERSE_ORDER 1
 130 #endif
 131
 132 /* Prefetch even if the GIV is not always executed.  */
 133 #ifndef PREFETCH_NOT_ALWAYS
 134 #define PREFETCH_NOT_ALWAYS 0
 135 #endif
 136
 137 /* If the loop requires more prefetches than the target can process in
 138    parallel then don't prefetch anything in that loop.  */
 139 #ifndef PREFETCH_LIMIT_TO_SIMULTANEOUS
 140 #define PREFETCH_LIMIT_TO_SIMULTANEOUS 1
 141 #endif
 142
 143 #define LOOP_REG_LIFETIME(LOOP, REGNO) \
 144 ((REGNO_LAST_LUID (REGNO) - REGNO_FIRST_LUID (REGNO)))
 145
 146 #define LOOP_REG_GLOBAL_P(LOOP, REGNO) \
 147 ((REGNO_LAST_LUID (REGNO) > INSN_LUID ((LOOP)->end) \
 148  || REGNO_FIRST_LUID (REGNO) < INSN_LUID ((LOOP)->start)))
 149
 150 #define LOOP_REGNO_NREGS(REGNO, SET_DEST) \
 151 ((REGNO) < FIRST_PSEUDO_REGISTER \
 152  ? HARD_REGNO_NREGS ((REGNO), GET_MODE (SET_DEST)) : 1)
 153
 154
 155 /* Vector mapping INSN_UIDs to luids.
 156    The luids are like uids but increase monotonically always.
 157    We use them to see whether a jump comes from outside a given loop.  */
 158
 159 int *uid_luid;
 160
 161 /* Indexed by INSN_UID, contains the ordinal giving the (innermost) loop
 162    number the insn is contained in.  */
 163
 164 struct loop **uid_loop;
 165
 166 /* 1 + largest uid of any insn.  */
 167
 168 int max_uid_for_loop;
 169
 170 /* 1 + luid of last insn.  */
 171
 172 static int max_luid;
 173
 174 /* Number of loops detected in current function.  Used as index to the
 175    next few tables.  */
 176
 177 static int max_loop_num;
 178
 179 /* Bound on pseudo register number before loop optimization.
 180    A pseudo has valid regscan info if its number is < max_reg_before_loop.  */
 181 unsigned int max_reg_before_loop;
 182
 183 /* The value to pass to the next call of reg_scan_update.  */
 184 static int loop_max_reg;
 185
 186 #define obstack_chunk_alloc xmalloc
 187 #define obstack_chunk_free free
 188 \f
 189 /* During the analysis of a loop, a chain of `struct movable's
 190    is made to record all the movable insns found.
 191    Then the entire chain can be scanned to decide which to move.  */
 192
 193 struct movable
 194 {
 195   rtx insn;                     /* A movable insn */
 196   rtx set_src;                  /* The expression this reg is set from.  */
 197   rtx set_dest;                 /* The destination of this SET.  */
 198   rtx dependencies;             /* When INSN is libcall, this is an EXPR_LIST
 199                                    of any registers used within the LIBCALL.  */
 200   int consec;                   /* Number of consecutive following insns
 201                                    that must be moved with this one.  */
 202   unsigned int regno;           /* The register it sets */
 203   short lifetime;               /* lifetime of that register;
 204                                    may be adjusted when matching movables
 205                                    that load the same value are found.  */
 206   short savings;                /* Number of insns we can move for this reg,
 207                                    including other movables that force this
 208                                    or match this one.  */
 209   unsigned int cond : 1;        /* 1 if only conditionally movable */
 210   unsigned int force : 1;       /* 1 means MUST move this insn */
 211   unsigned int global : 1;      /* 1 means reg is live outside this loop */
 212                 /* If PARTIAL is 1, GLOBAL means something different:
 213                    that the reg is live outside the range from where it is set
 214                    to the following label.  */
 215   unsigned int done : 1;        /* 1 inhibits further processing of this */
 216
 217   unsigned int partial : 1;     /* 1 means this reg is used for zero-extending.
 218                                    In particular, moving it does not make it
 219                                    invariant.  */
 220   unsigned int move_insn : 1;   /* 1 means that we call emit_move_insn to
 221                                    load SRC, rather than copying INSN.  */
 222   unsigned int move_insn_first:1;/* Same as above, if this is necessary for the
 223                                     first insn of a consecutive sets group.  */
 224   unsigned int is_equiv : 1;    /* 1 means a REG_EQUIV is present on INSN.  */
 225   enum machine_mode savemode;   /* Nonzero means it is a mode for a low part
 226                                    that we should avoid changing when clearing
 227                                    the rest of the reg.  */
 228   struct movable *match;        /* First entry for same value */
 229   struct movable *forces;       /* An insn that must be moved if this is */
 230   struct movable *next;
 231 };
 232
 233
 234 FILE *loop_dump_stream;
 235
 236 /* Forward declarations.  */
 237
 238 static void invalidate_loops_containing_label PARAMS ((rtx));
 239 static void find_and_verify_loops PARAMS ((rtx, struct loops *));
 240 static void mark_loop_jump PARAMS ((rtx, struct loop *));
 241 static void prescan_loop PARAMS ((struct loop *));
 242 static int reg_in_basic_block_p PARAMS ((rtx, rtx));
 243 static int consec_sets_invariant_p PARAMS ((const struct loop *,
 244                                             rtx, int, rtx));
 245 static int labels_in_range_p PARAMS ((rtx, int));
 246 static void count_one_set PARAMS ((struct loop_regs *, rtx, rtx, rtx *));
 247 static void note_addr_stored PARAMS ((rtx, rtx, void *));
 248 static void note_set_pseudo_multiple_uses PARAMS ((rtx, rtx, void *));
 249 static int loop_reg_used_before_p PARAMS ((const struct loop *, rtx, rtx));
 250 static void scan_loop PARAMS ((struct loop*, int));
 251 #if 0
 252 static void replace_call_address PARAMS ((rtx, rtx, rtx));
 253 #endif
 254 static rtx skip_consec_insns PARAMS ((rtx, int));
 255 static int libcall_benefit PARAMS ((rtx));
 256 static void ignore_some_movables PARAMS ((struct loop_movables *));
 257 static void force_movables PARAMS ((struct loop_movables *));
 258 static void combine_movables PARAMS ((struct loop_movables *,
 259                                       struct loop_regs *));
 260 static int num_unmoved_movables PARAMS ((const struct loop *));
 261 static int regs_match_p PARAMS ((rtx, rtx, struct loop_movables *));
 262 static int rtx_equal_for_loop_p PARAMS ((rtx, rtx, struct loop_movables *,
 263                                          struct loop_regs *));
 264 static void add_label_notes PARAMS ((rtx, rtx));
 265 static void move_movables PARAMS ((struct loop *loop, struct loop_movables *,
 266                                    int, int));
 267 static void loop_movables_add PARAMS((struct loop_movables *,
 268                                       struct movable *));
 269 static void loop_movables_free PARAMS((struct loop_movables *));
 270 static int count_nonfixed_reads PARAMS ((const struct loop *, rtx));
 271 static void loop_bivs_find PARAMS((struct loop *));
 272 static void loop_bivs_init_find PARAMS((struct loop *));
 273 static void loop_bivs_check PARAMS((struct loop *));
 274 static void loop_givs_find PARAMS((struct loop *));
 275 static void loop_givs_check PARAMS((struct loop *));
 276 static int loop_biv_eliminable_p PARAMS((struct loop *, struct iv_class *,
 277                                          int, int));
 278 static int loop_giv_reduce_benefit PARAMS((struct loop *, struct iv_class *,
 279                                            struct induction *, rtx));
 280 static void loop_givs_dead_check PARAMS((struct loop *, struct iv_class *));
 281 static void loop_givs_reduce PARAMS((struct loop *, struct iv_class *));
 282 static void loop_givs_rescan PARAMS((struct loop *, struct iv_class *,
 283                                      rtx *));
 284 static void loop_ivs_free PARAMS((struct loop *));
 285 static void strength_reduce PARAMS ((struct loop *, int));
 286 static void find_single_use_in_loop PARAMS ((struct loop_regs *, rtx, rtx));
 287 static int valid_initial_value_p PARAMS ((rtx, rtx, int, rtx));
 288 static void find_mem_givs PARAMS ((const struct loop *, rtx, rtx, int, int));
 289 static void record_biv PARAMS ((struct loop *, struct induction *,
 290                                 rtx, rtx, rtx, rtx, rtx *,
 291                                 int, int));
 292 static void check_final_value PARAMS ((const struct loop *,
 293                                        struct induction *));
 294 static void loop_ivs_dump PARAMS((const struct loop *, FILE *, int));
 295 static void loop_iv_class_dump PARAMS((const struct iv_class *, FILE *, int));
 296 static void loop_biv_dump PARAMS((const struct induction *, FILE *, int));
 297 static void loop_giv_dump PARAMS((const struct induction *, FILE *, int));
 298 static void record_giv PARAMS ((const struct loop *, struct induction *,
 299                                 rtx, rtx, rtx, rtx, rtx, rtx, int,
 300                                 enum g_types, int, int, rtx *));
 301 static void update_giv_derive PARAMS ((const struct loop *, rtx));
 302 static void check_ext_dependent_givs PARAMS ((struct iv_class *,
 303                                               struct loop_info *));
 304 static int basic_induction_var PARAMS ((const struct loop *, rtx,
 305                                         enum machine_mode, rtx, rtx,
 306                                         rtx *, rtx *, rtx **));
 307 static rtx simplify_giv_expr PARAMS ((const struct loop *, rtx, rtx *, int *));
 308 static int general_induction_var PARAMS ((const struct loop *loop, rtx, rtx *,
 309                                           rtx *, rtx *, rtx *, int, int *,
 310                                           enum machine_mode));
 311 static int consec_sets_giv PARAMS ((const struct loop *, int, rtx,
 312                                     rtx, rtx, rtx *, rtx *, rtx *, rtx *));
 313 static int check_dbra_loop PARAMS ((struct loop *, int));
 314 static rtx express_from_1 PARAMS ((rtx, rtx, rtx));
 315 static rtx combine_givs_p PARAMS ((struct induction *, struct induction *));
 316 static int cmp_combine_givs_stats PARAMS ((const PTR, const PTR));
 317 static void combine_givs PARAMS ((struct loop_regs *, struct iv_class *));
 318 static int product_cheap_p PARAMS ((rtx, rtx));
 319 static int maybe_eliminate_biv PARAMS ((const struct loop *, struct iv_class *,
 320                                         int, int, int));
 321 static int maybe_eliminate_biv_1 PARAMS ((const struct loop *, rtx, rtx,
 322                                           struct iv_class *, int,
 323                                           basic_block, rtx));
 324 static int last_use_this_basic_block PARAMS ((rtx, rtx));
 325 static void record_initial PARAMS ((rtx, rtx, void *));
 326 static void update_reg_last_use PARAMS ((rtx, rtx));
 327 static rtx next_insn_in_loop PARAMS ((const struct loop *, rtx));
 328 static void loop_regs_scan PARAMS ((const struct loop *, int));
 329 static int count_insns_in_loop PARAMS ((const struct loop *));
 330 static void load_mems PARAMS ((const struct loop *));
 331 static int insert_loop_mem PARAMS ((rtx *, void *));
 332 static int replace_loop_mem PARAMS ((rtx *, void *));
 333 static void replace_loop_mems PARAMS ((rtx, rtx, rtx));
 334 static int replace_loop_reg PARAMS ((rtx *, void *));
 335 static void replace_loop_regs PARAMS ((rtx insn, rtx, rtx));
 336 static void note_reg_stored PARAMS ((rtx, rtx, void *));
 337 static void try_copy_prop PARAMS ((const struct loop *, rtx, unsigned int));
 338 static void try_swap_copy_prop PARAMS ((const struct loop *, rtx,
 339                                          unsigned int));
 340 static int replace_label PARAMS ((rtx *, void *));
 341 static rtx check_insn_for_givs PARAMS((struct loop *, rtx, int, int));
 342 static rtx check_insn_for_bivs PARAMS((struct loop *, rtx, int, int));
 343 static rtx gen_add_mult PARAMS ((rtx, rtx, rtx, rtx));
 344 static void loop_regs_update PARAMS ((const struct loop *, rtx));
 345 static int iv_add_mult_cost PARAMS ((rtx, rtx, rtx, rtx));
 346
 347 static rtx loop_insn_emit_after PARAMS((const struct loop *, basic_block,
 348                                         rtx, rtx));
 349 static rtx loop_call_insn_emit_before PARAMS((const struct loop *,
 350                                               basic_block, rtx, rtx));
 351 static rtx loop_call_insn_hoist PARAMS((const struct loop *, rtx));
 352 static rtx loop_insn_sink_or_swim PARAMS((const struct loop *, rtx));
 353
 354 static void loop_dump_aux PARAMS ((const struct loop *, FILE *, int));
 355 static void loop_delete_insns PARAMS ((rtx, rtx));
 356 static HOST_WIDE_INT remove_constant_addition PARAMS ((rtx *));
 357 void debug_ivs PARAMS ((const struct loop *));
 358 void debug_iv_class PARAMS ((const struct iv_class *));
 359 void debug_biv PARAMS ((const struct induction *));
 360 void debug_giv PARAMS ((const struct induction *));
 361 void debug_loop PARAMS ((const struct loop *));
 362 void debug_loops PARAMS ((const struct loops *));
 363
 364 typedef struct rtx_pair
 365 {
 366   rtx r1;
 367   rtx r2;
 368 } rtx_pair;
 369
 370 typedef struct loop_replace_args
 371 {
 372   rtx match;
 373   rtx replacement;
 374   rtx insn;
 375 } loop_replace_args;
 376
 377 /* Nonzero iff INSN is between START and END, inclusive.  */
 378 #define INSN_IN_RANGE_P(INSN, START, END)       \
 379   (INSN_UID (INSN) < max_uid_for_loop           \
 380    && INSN_LUID (INSN) >= INSN_LUID (START)     \
 381    && INSN_LUID (INSN) <= INSN_LUID (END))
 382
 383 /* Indirect_jump_in_function is computed once per function.  */
 384 static int indirect_jump_in_function;
 385 static int indirect_jump_in_function_p PARAMS ((rtx));
 386
 387 static int compute_luids PARAMS ((rtx, rtx, int));
 388
 389 static int biv_elimination_giv_has_0_offset PARAMS ((struct induction *,
 390                                                      struct induction *,
 391                                                      rtx));
 392 \f
 393 /* Benefit penalty, if a giv is not replaceable, i.e. must emit an insn to
 394    copy the value of the strength reduced giv to its original register.  */
 395 static int copy_cost;
 396
 397 /* Cost of using a register, to normalize the benefits of a giv.  */
 398 static int reg_address_cost;
 399
 400 void
 401 init_loop ()
 402 {
 403   rtx reg = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 1);
 404
 405   reg_address_cost = address_cost (reg, SImode);
 406
 407   copy_cost = COSTS_N_INSNS (1);
 408 }
 409 \f
 410 /* Compute the mapping from uids to luids.
 411    LUIDs are numbers assigned to insns, like uids,
 412    except that luids increase monotonically through the code.
 413    Start at insn START and stop just before END.  Assign LUIDs
 414    starting with PREV_LUID + 1.  Return the last assigned LUID + 1.  */
 415 static int
 416 compute_luids (start, end, prev_luid)
 417      rtx start, end;
 418      int prev_luid;
 419 {
 420   int i;
 421   rtx insn;
 422
 423   for (insn = start, i = prev_luid; insn != end; insn = NEXT_INSN (insn))
 424     {
 425       if (INSN_UID (insn) >= max_uid_for_loop)
 426         continue;
 427       /* Don't assign luids to line-number NOTEs, so that the distance in
 428          luids between two insns is not affected by -g.  */
 429       if (GET_CODE (insn) != NOTE
 430           || NOTE_LINE_NUMBER (insn) <= 0)
 431         uid_luid[INSN_UID (insn)] = ++i;
 432       else
 433         /* Give a line number note the same luid as preceding insn.  */
 434         uid_luid[INSN_UID (insn)] = i;
 435     }
 436   return i + 1;
 437 }
 438 \f
 439 /* Entry point of this file.  Perform loop optimization
 440    on the current function.  F is the first insn of the function
 441    and DUMPFILE is a stream for output of a trace of actions taken
 442    (or 0 if none should be output).  */
 443
 444 void
 445 loop_optimize (f, dumpfile, flags)
 446      /* f is the first instruction of a chain of insns for one function */
 447      rtx f;
 448      FILE *dumpfile;
 449      int flags;
 450 {
 451   rtx insn;
 452   int i;
 453   struct loops loops_data;
 454   struct loops *loops = &loops_data;
 455   struct loop_info *loops_info;
 456
 457   loop_dump_stream = dumpfile;
 458
 459   init_recog_no_volatile ();
 460
 461   max_reg_before_loop = max_reg_num ();
 462   loop_max_reg = max_reg_before_loop;
 463
 464   regs_may_share = 0;
 465
 466   /* Count the number of loops.  */
 467
 468   max_loop_num = 0;
 469   for (insn = f; insn; insn = NEXT_INSN (insn))
 470     {
 471       if (GET_CODE (insn) == NOTE
 472           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
 473         max_loop_num++;
 474     }
 475
 476   /* Don't waste time if no loops.  */
 477   if (max_loop_num == 0)
 478     return;
 479
 480   loops->num = max_loop_num;
 481
 482   /* Get size to use for tables indexed by uids.
 483      Leave some space for labels allocated by find_and_verify_loops.  */
 484   max_uid_for_loop = get_max_uid () + 1 + max_loop_num * 32;
 485
 486   uid_luid = (int *) xcalloc (max_uid_for_loop, sizeof (int));
 487   uid_loop = (struct loop **) xcalloc (max_uid_for_loop,
 488                                        sizeof (struct loop *));
 489
 490   /* Allocate storage for array of loops.  */
 491   loops->array = (struct loop *)
 492     xcalloc (loops->num, sizeof (struct loop));
 493
 494   /* Find and process each loop.
 495      First, find them, and record them in order of their beginnings.  */
 496   find_and_verify_loops (f, loops);
 497
 498   /* Allocate and initialize auxiliary loop information.  */
 499   loops_info = xcalloc (loops->num, sizeof (struct loop_info));
 500   for (i = 0; i < loops->num; i++)
 501     loops->array[i].aux = loops_info + i;
 502
 503   /* Now find all register lifetimes.  This must be done after
 504      find_and_verify_loops, because it might reorder the insns in the
 505      function.  */
 506   reg_scan (f, max_reg_before_loop, 1);
 507
 508   /* This must occur after reg_scan so that registers created by gcse
 509      will have entries in the register tables.
 510
 511      We could have added a call to reg_scan after gcse_main in toplev.c,
 512      but moving this call to init_alias_analysis is more efficient.  */
 513   init_alias_analysis ();
 514
 515   /* See if we went too far.  Note that get_max_uid already returns
 516      one more that the maximum uid of all insn.  */
 517   if (get_max_uid () > max_uid_for_loop)
 518     abort ();
 519   /* Now reset it to the actual size we need.  See above.  */
 520   max_uid_for_loop = get_max_uid ();
 521
 522   /* find_and_verify_loops has already called compute_luids, but it
 523      might have rearranged code afterwards, so we need to recompute
 524      the luids now.  */
 525   max_luid = compute_luids (f, NULL_RTX, 0);
 526
 527   /* Don't leave gaps in uid_luid for insns that have been
 528      deleted.  It is possible that the first or last insn
 529      using some register has been deleted by cross-jumping.
 530      Make sure that uid_luid for that former insn's uid
 531      points to the general area where that insn used to be.  */
 532   for (i = 0; i < max_uid_for_loop; i++)
 533     {
 534       uid_luid[0] = uid_luid[i];
 535       if (uid_luid[0] != 0)
 536         break;
 537     }
 538   for (i = 0; i < max_uid_for_loop; i++)
 539     if (uid_luid[i] == 0)
 540       uid_luid[i] = uid_luid[i - 1];
 541
 542   /* Determine if the function has indirect jump.  On some systems
 543      this prevents low overhead loop instructions from being used.  */
 544   indirect_jump_in_function = indirect_jump_in_function_p (f);
 545
 546   /* Now scan the loops, last ones first, since this means inner ones are done
 547      before outer ones.  */
 548   for (i = max_loop_num - 1; i >= 0; i--)
 549     {
 550       struct loop *loop = &loops->array[i];
 551
 552       if (! loop->invalid && loop->end)
 553         scan_loop (loop, flags);
 554     }
 555
 556   /* If there were lexical blocks inside the loop, they have been
 557      replicated.  We will now have more than one NOTE_INSN_BLOCK_BEG
 558      and NOTE_INSN_BLOCK_END for each such block.  We must duplicate
 559      the BLOCKs as well.  */
 560   if (write_symbols != NO_DEBUG)
 561     reorder_blocks ();
 562
 563   end_alias_analysis ();
 564
 565   /* Clean up.  */
 566   free (uid_luid);
 567   free (uid_loop);
 568   free (loops_info);
 569   free (loops->array);
 570 }
 571 \f
 572 /* Returns the next insn, in execution order, after INSN.  START and
 573    END are the NOTE_INSN_LOOP_BEG and NOTE_INSN_LOOP_END for the loop,
 574    respectively.  LOOP->TOP, if non-NULL, is the top of the loop in the
 575    insn-stream; it is used with loops that are entered near the
 576    bottom.  */
 577
 578 static rtx
 579 next_insn_in_loop (loop, insn)
 580      const struct loop *loop;
 581      rtx insn;
 582 {
 583   insn = NEXT_INSN (insn);
 584
 585   if (insn == loop->end)
 586     {
 587       if (loop->top)
 588         /* Go to the top of the loop, and continue there.  */
 589         insn = loop->top;
 590       else
 591         /* We're done.  */
 592         insn = NULL_RTX;
 593     }
 594
 595   if (insn == loop->scan_start)
 596     /* We're done.  */
 597     insn = NULL_RTX;
 598
 599   return insn;
 600 }
 601
 602 /* Optimize one loop described by LOOP.  */
 603
 604 /* ??? Could also move memory writes out of loops if the destination address
 605    is invariant, the source is invariant, the memory write is not volatile,
 606    and if we can prove that no read inside the loop can read this address
 607    before the write occurs.  If there is a read of this address after the
 608    write, then we can also mark the memory read as invariant.  */
 609
 610 static void
 611 scan_loop (loop, flags)
 612      struct loop *loop;
 613      int flags;
 614 {
 615   struct loop_info *loop_info = LOOP_INFO (loop);
 616   struct loop_regs *regs = LOOP_REGS (loop);
 617   int i;
 618   rtx loop_start = loop->start;
 619   rtx loop_end = loop->end;
 620   rtx p;
 621   /* 1 if we are scanning insns that could be executed zero times.  */
 622   int maybe_never = 0;
 623   /* 1 if we are scanning insns that might never be executed
 624      due to a subroutine call which might exit before they are reached.  */
 625   int call_passed = 0;
 626   /* Jump insn that enters the loop, or 0 if control drops in.  */
 627   rtx loop_entry_jump = 0;
 628   /* Number of insns in the loop.  */
 629   int insn_count;
 630   int tem;
 631   rtx temp, update_start, update_end;
 632   /* The SET from an insn, if it is the only SET in the insn.  */
 633   rtx set, set1;
 634   /* Chain describing insns movable in current loop.  */
 635   struct loop_movables *movables = LOOP_MOVABLES (loop);
 636   /* Ratio of extra register life span we can justify
 637      for saving an instruction.  More if loop doesn't call subroutines
 638      since in that case saving an insn makes more difference
 639      and more registers are available.  */
 640   int threshold;
 641   /* Nonzero if we are scanning instructions in a sub-loop.  */
 642   int loop_depth = 0;
 643
 644   loop->top = 0;
 645
 646   movables->head = 0;
 647   movables->last = 0;
 648
 649   /* Determine whether this loop starts with a jump down to a test at
 650      the end.  This will occur for a small number of loops with a test
 651      that is too complex to duplicate in front of the loop.
 652
 653      We search for the first insn or label in the loop, skipping NOTEs.
 654      However, we must be careful not to skip past a NOTE_INSN_LOOP_BEG
 655      (because we might have a loop executed only once that contains a
 656      loop which starts with a jump to its exit test) or a NOTE_INSN_LOOP_END
 657      (in case we have a degenerate loop).
 658
 659      Note that if we mistakenly think that a loop is entered at the top
 660      when, in fact, it is entered at the exit test, the only effect will be
 661      slightly poorer optimization.  Making the opposite error can generate
 662      incorrect code.  Since very few loops now start with a jump to the
 663      exit test, the code here to detect that case is very conservative.  */
 664
 665   for (p = NEXT_INSN (loop_start);
 666        p != loop_end
 667          && GET_CODE (p) != CODE_LABEL && ! INSN_P (p)
 668          && (GET_CODE (p) != NOTE
 669              || (NOTE_LINE_NUMBER (p) != NOTE_INSN_LOOP_BEG
 670                  && NOTE_LINE_NUMBER (p) != NOTE_INSN_LOOP_END));
 671        p = NEXT_INSN (p))
 672     ;
 673
 674   loop->scan_start = p;
 675
 676   /* If loop end is the end of the current function, then emit a
 677      NOTE_INSN_DELETED after loop_end and set loop->sink to the dummy
 678      note insn.  This is the position we use when sinking insns out of
 679      the loop.  */
 680   if (NEXT_INSN (loop->end) != 0)
 681     loop->sink = NEXT_INSN (loop->end);
 682   else
 683     loop->sink = emit_note_after (NOTE_INSN_DELETED, loop->end);
 684
 685   /* Set up variables describing this loop.  */
 686   prescan_loop (loop);
 687   threshold = (loop_info->has_call ? 1 : 2) * (1 + n_non_fixed_regs);
 688
 689   /* If loop has a jump before the first label,
 690      the true entry is the target of that jump.
 691      Start scan from there.
 692      But record in LOOP->TOP the place where the end-test jumps
 693      back to so we can scan that after the end of the loop.  */
 694   if (GET_CODE (p) == JUMP_INSN)
 695     {
 696       loop_entry_jump = p;
 697
 698       /* Loop entry must be unconditional jump (and not a RETURN)  */
 699       if (any_uncondjump_p (p)
 700           && JUMP_LABEL (p) != 0
 701           /* Check to see whether the jump actually
 702              jumps out of the loop (meaning it's no loop).
 703              This case can happen for things like
 704              do {..} while (0).  If this label was generated previously
 705              by loop, we can't tell anything about it and have to reject
 706              the loop.  */
 707           && INSN_IN_RANGE_P (JUMP_LABEL (p), loop_start, loop_end))
 708         {
 709           loop->top = next_label (loop->scan_start);
 710           loop->scan_start = JUMP_LABEL (p);
 711         }
 712     }
 713
 714   /* If LOOP->SCAN_START was an insn created by loop, we don't know its luid
 715      as required by loop_reg_used_before_p.  So skip such loops.  (This
 716      test may never be true, but it's best to play it safe.)
 717
 718      Also, skip loops where we do not start scanning at a label.  This
 719      test also rejects loops starting with a JUMP_INSN that failed the
 720      test above.  */
 721
 722   if (INSN_UID (loop->scan_start) >= max_uid_for_loop
 723       || GET_CODE (loop->scan_start) != CODE_LABEL)
 724     {
 725       if (loop_dump_stream)
 726         fprintf (loop_dump_stream, "\nLoop from %d to %d is phony.\n\n",
 727                  INSN_UID (loop_start), INSN_UID (loop_end));
 728       return;
 729     }
 730
 731   /* Allocate extra space for REGs that might be created by load_mems.
 732      We allocate a little extra slop as well, in the hopes that we
 733      won't have to reallocate the regs array.  */
 734   loop_regs_scan (loop, loop_info->mems_idx + 16);
 735   insn_count = count_insns_in_loop (loop);
 736
 737   if (loop_dump_stream)
 738     {
 739       fprintf (loop_dump_stream, "\nLoop from %d to %d: %d real insns.\n",
 740                INSN_UID (loop_start), INSN_UID (loop_end), insn_count);
 741       if (loop->cont)
 742         fprintf (loop_dump_stream, "Continue at insn %d.\n",
 743                  INSN_UID (loop->cont));
 744     }
 745
 746   /* Scan through the loop finding insns that are safe to move.
 747      Set REGS->ARRAY[I].SET_IN_LOOP negative for the reg I being set, so that
 748      this reg will be considered invariant for subsequent insns.
 749      We consider whether subsequent insns use the reg
 750      in deciding whether it is worth actually moving.
 751
 752      MAYBE_NEVER is nonzero if we have passed a conditional jump insn
 753      and therefore it is possible that the insns we are scanning
 754      would never be executed.  At such times, we must make sure
 755      that it is safe to execute the insn once instead of zero times.
 756      When MAYBE_NEVER is 0, all insns will be executed at least once
 757      so that is not a problem.  */
 758
 759   for (p = next_insn_in_loop (loop, loop->scan_start);
 760        p != NULL_RTX;
 761        p = next_insn_in_loop (loop, p))
 762     {
 763       if (GET_CODE (p) == INSN
 764           && (set = single_set (p))
 765           && GET_CODE (SET_DEST (set)) == REG
 766 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
 767           && SET_DEST (set) != pic_offset_table_rtx
 768 #endif
 769           && ! regs->array[REGNO (SET_DEST (set))].may_not_optimize)
 770         {
 771           int tem1 = 0;
 772           int tem2 = 0;
 773           int move_insn = 0;
 774           rtx src = SET_SRC (set);
 775           rtx dependencies = 0;
 776
 777           /* Figure out what to use as a source of this insn.  If a REG_EQUIV
 778              note is given or if a REG_EQUAL note with a constant operand is
 779              specified, use it as the source and mark that we should move
 780              this insn by calling emit_move_insn rather that duplicating the
 781              insn.
 782
 783              Otherwise, only use the REG_EQUAL contents if a REG_RETVAL note
 784              is present.  */
 785           temp = find_reg_note (p, REG_EQUIV, NULL_RTX);
 786           if (temp)
 787             src = XEXP (temp, 0), move_insn = 1;
 788           else
 789             {
 790               temp = find_reg_note (p, REG_EQUAL, NULL_RTX);
 791               if (temp && CONSTANT_P (XEXP (temp, 0)))
 792                 src = XEXP (temp, 0), move_insn = 1;
 793               if (temp && find_reg_note (p, REG_RETVAL, NULL_RTX))
 794                 {
 795                   src = XEXP (temp, 0);
 796                   /* A libcall block can use regs that don't appear in
 797                      the equivalent expression.  To move the libcall,
 798                      we must move those regs too.  */
 799                   dependencies = libcall_other_reg (p, src);
 800                 }
 801             }
 802
 803           /* For parallels, add any possible uses to the depencies, as we can't move
 804              the insn without resolving them first.  */
 805           if (GET_CODE (PATTERN (p)) == PARALLEL)
 806             {
 807               for (i = 0; i < XVECLEN (PATTERN (p), 0); i++)
 808                 {
 809                   rtx x = XVECEXP (PATTERN (p), 0, i);
 810                   if (GET_CODE (x) == USE)
 811                     dependencies = gen_rtx_EXPR_LIST (VOIDmode, XEXP (x, 0), dependencies);
 812                 }
 813             }
 814
 815           /* Don't try to optimize a register that was made
 816              by loop-optimization for an inner loop.
 817              We don't know its life-span, so we can't compute the benefit.  */
 818           if (REGNO (SET_DEST (set)) >= max_reg_before_loop)
 819             ;
 820           else if (/* The register is used in basic blocks other
 821                       than the one where it is set (meaning that
 822                       something after this point in the loop might
 823                       depend on its value before the set).  */
 824                    ! reg_in_basic_block_p (p, SET_DEST (set))
 825                    /* And the set is not guaranteed to be executed once
 826                       the loop starts, or the value before the set is
 827                       needed before the set occurs...
 828
 829                       ??? Note we have quadratic behaviour here, mitigated
 830                       by the fact that the previous test will often fail for
 831                       large loops.  Rather than re-scanning the entire loop
 832                       each time for register usage, we should build tables
 833                       of the register usage and use them here instead.  */
 834                    && (maybe_never
 835                        || loop_reg_used_before_p (loop, set, p)))
 836             /* It is unsafe to move the set.
 837
 838                This code used to consider it OK to move a set of a variable
 839                which was not created by the user and not used in an exit test.
 840                That behavior is incorrect and was removed.  */
 841             ;
 842           else if ((tem = loop_invariant_p (loop, src))
 843                    && (dependencies == 0
 844                        || (tem2 = loop_invariant_p (loop, dependencies)) != 0)
 845                    && (regs->array[REGNO (SET_DEST (set))].set_in_loop == 1
 846                        || (tem1
 847                            = consec_sets_invariant_p
 848                            (loop, SET_DEST (set),
 849                             regs->array[REGNO (SET_DEST (set))].set_in_loop,
 850                             p)))
 851                    /* If the insn can cause a trap (such as divide by zero),
 852                       can't move it unless it's guaranteed to be executed
 853                       once loop is entered.  Even a function call might
 854                       prevent the trap insn from being reached
 855                       (since it might exit!)  */
 856                    && ! ((maybe_never || call_passed)
 857                          && may_trap_p (src)))
 858             {
 859               struct movable *m;
 860               int regno = REGNO (SET_DEST (set));
 861
 862               /* A potential lossage is where we have a case where two insns
 863                  can be combined as long as they are both in the loop, but
 864                  we move one of them outside the loop.  For large loops,
 865                  this can lose.  The most common case of this is the address
 866                  of a function being called.
 867
 868                  Therefore, if this register is marked as being used exactly
 869                  once if we are in a loop with calls (a "large loop"), see if
 870                  we can replace the usage of this register with the source
 871                  of this SET.  If we can, delete this insn.
 872
 873                  Don't do this if P has a REG_RETVAL note or if we have
 874                  SMALL_REGISTER_CLASSES and SET_SRC is a hard register.  */
 875
 876               if (loop_info->has_call
 877                   && regs->array[regno].single_usage != 0
 878                   && regs->array[regno].single_usage != const0_rtx
 879                   && REGNO_FIRST_UID (regno) == INSN_UID (p)
 880                   && (REGNO_LAST_UID (regno)
 881                       == INSN_UID (regs->array[regno].single_usage))
 882                   && regs->array[regno].set_in_loop == 1
 883                   && GET_CODE (SET_SRC (set)) != ASM_OPERANDS
 884                   && ! side_effects_p (SET_SRC (set))
 885                   && ! find_reg_note (p, REG_RETVAL, NULL_RTX)
 886                   && (! SMALL_REGISTER_CLASSES
 887                       || (! (GET_CODE (SET_SRC (set)) == REG
 888                              && REGNO (SET_SRC (set)) < FIRST_PSEUDO_REGISTER)))
 889                   /* This test is not redundant; SET_SRC (set) might be
 890                      a call-clobbered register and the life of REGNO
 891                      might span a call.  */
 892                   && ! modified_between_p (SET_SRC (set), p,
 893                                            regs->array[regno].single_usage)
 894                   && no_labels_between_p (p, regs->array[regno].single_usage)
 895                   && validate_replace_rtx (SET_DEST (set), SET_SRC (set),
 896                                            regs->array[regno].single_usage))
 897                 {
 898                   /* Replace any usage in a REG_EQUAL note.  Must copy the
 899                      new source, so that we don't get rtx sharing between the
 900                      SET_SOURCE and REG_NOTES of insn p.  */
 901                   REG_NOTES (regs->array[regno].single_usage)
 902                     = replace_rtx (REG_NOTES (regs->array[regno].single_usage),
 903                                    SET_DEST (set), copy_rtx (SET_SRC (set)));
 904
 905                   delete_insn (p);
 906                   for (i = 0; i < LOOP_REGNO_NREGS (regno, SET_DEST (set)); i++)
 907                     regs->array[regno+i].set_in_loop = 0;
 908                   continue;
 909                 }
 910
 911               m = (struct movable *) xmalloc (sizeof (struct movable));
 912               m->next = 0;
 913               m->insn = p;
 914               m->set_src = src;
 915               m->dependencies = dependencies;
 916               m->set_dest = SET_DEST (set);
 917               m->force = 0;
 918               m->consec = regs->array[REGNO (SET_DEST (set))].set_in_loop - 1;
 919               m->done = 0;
 920               m->forces = 0;
 921               m->partial = 0;
 922               m->move_insn = move_insn;
 923               m->move_insn_first = 0;
 924               m->is_equiv = (find_reg_note (p, REG_EQUIV, NULL_RTX) != 0);
 925               m->savemode = VOIDmode;
 926               m->regno = regno;
 927               /* Set M->cond if either loop_invariant_p
 928                  or consec_sets_invariant_p returned 2
 929                  (only conditionally invariant).  */
 930               m->cond = ((tem | tem1 | tem2) > 1);
 931               m->global =  LOOP_REG_GLOBAL_P (loop, regno);
 932               m->match = 0;
 933               m->lifetime = LOOP_REG_LIFETIME (loop, regno);
 934               m->savings = regs->array[regno].n_times_set;
 935               if (find_reg_note (p, REG_RETVAL, NULL_RTX))
 936                 m->savings += libcall_benefit (p);
 937               for (i = 0; i < LOOP_REGNO_NREGS (regno, SET_DEST (set)); i++)
 938                 regs->array[regno+i].set_in_loop = move_insn ? -2 : -1;
 939               /* Add M to the end of the chain MOVABLES.  */
 940               loop_movables_add (movables, m);
 941
 942               if (m->consec > 0)
 943                 {
 944                   /* It is possible for the first instruction to have a
 945                      REG_EQUAL note but a non-invariant SET_SRC, so we must
 946                      remember the status of the first instruction in case
 947                      the last instruction doesn't have a REG_EQUAL note.  */
 948                   m->move_insn_first = m->move_insn;
 949
 950                   /* Skip this insn, not checking REG_LIBCALL notes.  */
 951                   p = next_nonnote_insn (p);
 952                   /* Skip the consecutive insns, if there are any.  */
 953                   p = skip_consec_insns (p, m->consec);
 954                   /* Back up to the last insn of the consecutive group.  */
 955                   p = prev_nonnote_insn (p);
 956
 957                   /* We must now reset m->move_insn, m->is_equiv, and possibly
 958                      m->set_src to correspond to the effects of all the
 959                      insns.  */
 960                   temp = find_reg_note (p, REG_EQUIV, NULL_RTX);
 961                   if (temp)
 962                     m->set_src = XEXP (temp, 0), m->move_insn = 1;
 963                   else
 964                     {
 965                       temp = find_reg_note (p, REG_EQUAL, NULL_RTX);
 966                       if (temp && CONSTANT_P (XEXP (temp, 0)))
 967                         m->set_src = XEXP (temp, 0), m->move_insn = 1;
 968                       else
 969                         m->move_insn = 0;
 970
 971                     }
 972                   m->is_equiv = (find_reg_note (p, REG_EQUIV, NULL_RTX) != 0);
 973                 }
 974             }
 975           /* If this register is always set within a STRICT_LOW_PART
 976              or set to zero, then its high bytes are constant.
 977              So clear them outside the loop and within the loop
 978              just load the low bytes.
 979              We must check that the machine has an instruction to do so.
 980              Also, if the value loaded into the register
 981              depends on the same register, this cannot be done.  */
 982           else if (SET_SRC (set) == const0_rtx
 983                    && GET_CODE (NEXT_INSN (p)) == INSN
 984                    && (set1 = single_set (NEXT_INSN (p)))
 985                    && GET_CODE (set1) == SET
 986                    && (GET_CODE (SET_DEST (set1)) == STRICT_LOW_PART)
 987                    && (GET_CODE (XEXP (SET_DEST (set1), 0)) == SUBREG)
 988                    && (SUBREG_REG (XEXP (SET_DEST (set1), 0))
 989                        == SET_DEST (set))
 990                    && !reg_mentioned_p (SET_DEST (set), SET_SRC (set1)))
 991             {
 992               int regno = REGNO (SET_DEST (set));
 993               if (regs->array[regno].set_in_loop == 2)
 994                 {
 995                   struct movable *m;
 996                   m = (struct movable *) xmalloc (sizeof (struct movable));
 997                   m->next = 0;
 998                   m->insn = p;
 999                   m->set_dest = SET_DEST (set);
1000                   m->dependencies = 0;
1001                   m->force = 0;
1002                   m->consec = 0;
1003                   m->done = 0;
1004                   m->forces = 0;
1005                   m->move_insn = 0;
1006                   m->move_insn_first = 0;
1007                   m->partial = 1;
1008                   /* If the insn may not be executed on some cycles,
1009                      we can't clear the whole reg; clear just high part.
1010                      Not even if the reg is used only within this loop.
1011                      Consider this:
1012                      while (1)
1013                        while (s != t) {
1014                          if (foo ()) x = *s;
1015                          use (x);
1016                        }
1017                      Clearing x before the inner loop could clobber a value
1018                      being saved from the last time around the outer loop.
1019                      However, if the reg is not used outside this loop
1020                      and all uses of the register are in the same
1021                      basic block as the store, there is no problem.
1022
1023                      If this insn was made by loop, we don't know its
1024                      INSN_LUID and hence must make a conservative
1025                      assumption.  */
1026                   m->global = (INSN_UID (p) >= max_uid_for_loop
1027                                || LOOP_REG_GLOBAL_P (loop, regno)
1028                                || (labels_in_range_p
1029                                    (p, REGNO_FIRST_LUID (regno))));
1030                   if (maybe_never && m->global)
1031                     m->savemode = GET_MODE (SET_SRC (set1));
1032                   else
1033                     m->savemode = VOIDmode;
1034                   m->regno = regno;
1035                   m->cond = 0;
1036                   m->match = 0;
1037                   m->lifetime = LOOP_REG_LIFETIME (loop, regno);
1038                   m->savings = 1;
1039                   for (i = 0; i < LOOP_REGNO_NREGS (regno, SET_DEST (set)); i++)
1040                     regs->array[regno+i].set_in_loop = -1;
1041                   /* Add M to the end of the chain MOVABLES.  */
1042                   loop_movables_add (movables, m);
1043                 }
1044             }
1045         }
1046       /* Past a call insn, we get to insns which might not be executed
1047          because the call might exit.  This matters for insns that trap.
1048          Constant and pure call insns always return, so they don't count.  */
1049       else if (GET_CODE (p) == CALL_INSN && ! CONST_OR_PURE_CALL_P (p))
1050         call_passed = 1;
1051       /* Past a label or a jump, we get to insns for which we
1052          can't count on whether or how many times they will be
1053          executed during each iteration.  Therefore, we can
1054          only move out sets of trivial variables
1055          (those not used after the loop).  */
1056       /* Similar code appears twice in strength_reduce.  */
1057       else if ((GET_CODE (p) == CODE_LABEL || GET_CODE (p) == JUMP_INSN)
1058                /* If we enter the loop in the middle, and scan around to the
1059                   beginning, don't set maybe_never for that.  This must be an
1060                   unconditional jump, otherwise the code at the top of the
1061                   loop might never be executed.  Unconditional jumps are
1062                   followed by a barrier then the loop_end.  */
1063                && ! (GET_CODE (p) == JUMP_INSN && JUMP_LABEL (p) == loop->top
1064                      && NEXT_INSN (NEXT_INSN (p)) == loop_end
1065                      && any_uncondjump_p (p)))
1066         maybe_never = 1;
1067       else if (GET_CODE (p) == NOTE)
1068         {
1069           /* At the virtual top of a converted loop, insns are again known to
1070              be executed: logically, the loop begins here even though the exit
1071              code has been duplicated.  */
1072           if (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_VTOP && loop_depth == 0)
1073             maybe_never = call_passed = 0;
1074           else if (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_BEG)
1075             loop_depth++;
1076           else if (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_END)
1077             loop_depth--;
1078         }
1079     }
1080
1081   /* If one movable subsumes another, ignore that other.  */
1082
1083   ignore_some_movables (movables);
1084
1085   /* For each movable insn, see if the reg that it loads
1086      leads when it dies right into another conditionally movable insn.
1087      If so, record that the second insn "forces" the first one,
1088      since the second can be moved only if the first is.  */
1089
1090   force_movables (movables);
1091
1092   /* See if there are multiple movable insns that load the same value.
1093      If there are, make all but the first point at the first one
1094      through the `match' field, and add the priorities of them
1095      all together as the priority of the first.  */
1096
1097   combine_movables (movables, regs);
1098
1099   /* Now consider each movable insn to decide whether it is worth moving.
1100      Store 0 in regs->array[I].set_in_loop for each reg I that is moved.
1101
1102      Generally this increases code size, so do not move moveables when
1103      optimizing for code size.  */
1104
1105   if (! optimize_size)
1106     {
1107       move_movables (loop, movables, threshold, insn_count);
1108
1109       /* Recalculate regs->array if move_movables has created new
1110          registers.  */
1111       if (max_reg_num () > regs->num)
1112         {
1113           loop_regs_scan (loop, 0);
1114           for (update_start = loop_start;
1115                PREV_INSN (update_start)
1116                && GET_CODE (PREV_INSN (update_start)) != CODE_LABEL;
1117                update_start = PREV_INSN (update_start))
1118             ;
1119           update_end = NEXT_INSN (loop_end);
1120
1121           reg_scan_update (update_start, update_end, loop_max_reg);
1122           loop_max_reg = max_reg_num ();
1123         }
1124     }
1125
1126   /* Now candidates that still are negative are those not moved.
1127      Change regs->array[I].set_in_loop to indicate that those are not actually
1128      invariant.  */
1129   for (i = 0; i < regs->num; i++)
1130     if (regs->array[i].set_in_loop < 0)
1131       regs->array[i].set_in_loop = regs->array[i].n_times_set;
1132
1133   /* Now that we've moved some things out of the loop, we might be able to
1134      hoist even more memory references.  */
1135   load_mems (loop);
1136
1137   /* Recalculate regs->array if load_mems has created new registers.  */
1138   if (max_reg_num () > regs->num)
1139     loop_regs_scan (loop, 0);
1140
1141   for (update_start = loop_start;
1142        PREV_INSN (update_start)
1143          && GET_CODE (PREV_INSN (update_start)) != CODE_LABEL;
1144        update_start = PREV_INSN (update_start))
1145     ;
1146   update_end = NEXT_INSN (loop_end);
1147
1148   reg_scan_update (update_start, update_end, loop_max_reg);
1149   loop_max_reg = max_reg_num ();
1150
1151   if (flag_strength_reduce)
1152     {
1153       if (update_end && GET_CODE (update_end) == CODE_LABEL)
1154         /* Ensure our label doesn't go away.  */
1155         LABEL_NUSES (update_end)++;
1156
1157       strength_reduce (loop, flags);
1158
1159       reg_scan_update (update_start, update_end, loop_max_reg);
1160       loop_max_reg = max_reg_num ();
1161
1162       if (update_end && GET_CODE (update_end) == CODE_LABEL
1163           && --LABEL_NUSES (update_end) == 0)
1164         delete_related_insns (update_end);
1165     }
1166
1167
1168   /* The movable information is required for strength reduction.  */
1169   loop_movables_free (movables);
1170
1171   free (regs->array);
1172   regs->array = 0;
1173   regs->num = 0;
1174 }
1175 \f
1176 /* Add elements to *OUTPUT to record all the pseudo-regs
1177    mentioned in IN_THIS but not mentioned in NOT_IN_THIS.  */
1178
1179 void
1180 record_excess_regs (in_this, not_in_this, output)
1181      rtx in_this, not_in_this;
1182      rtx *output;
1183 {
1184   enum rtx_code code;
1185   const char *fmt;
1186   int i;
1187
1188   code = GET_CODE (in_this);
1189
1190   switch (code)
1191     {
1192     case PC:
1193     case CC0:
1194     case CONST_INT:
1195     case CONST_DOUBLE:
1196     case CONST:
1197     case SYMBOL_REF:
1198     case LABEL_REF:
1199       return;
1200
1201     case REG:
1202       if (REGNO (in_this) >= FIRST_PSEUDO_REGISTER
1203           && ! reg_mentioned_p (in_this, not_in_this))
1204         *output = gen_rtx_EXPR_LIST (VOIDmode, in_this, *output);
1205       return;
1206
1207     default:
1208       break;
1209     }
1210
1211   fmt = GET_RTX_FORMAT (code);
1212   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1213     {
1214       int j;
1215
1216       switch (fmt[i])
1217         {
1218         case 'E':
1219           for (j = 0; j < XVECLEN (in_this, i); j++)
1220             record_excess_regs (XVECEXP (in_this, i, j), not_in_this, output);
1221           break;
1222
1223         case 'e':
1224           record_excess_regs (XEXP (in_this, i), not_in_this, output);
1225           break;
1226         }
1227     }
1228 }
1229 \f
1230 /* Check what regs are referred to in the libcall block ending with INSN,
1231    aside from those mentioned in the equivalent value.
1232    If there are none, return 0.
1233    If there are one or more, return an EXPR_LIST containing all of them.  */
1234
1235 rtx
1236 libcall_other_reg (insn, equiv)
1237      rtx insn, equiv;
1238 {
1239   rtx note = find_reg_note (insn, REG_RETVAL, NULL_RTX);
1240   rtx p = XEXP (note, 0);
1241   rtx output = 0;
1242
1243   /* First, find all the regs used in the libcall block
1244      that are not mentioned as inputs to the result.  */
1245
1246   while (p != insn)
1247     {
1248       if (GET_CODE (p) == INSN || GET_CODE (p) == JUMP_INSN
1249           || GET_CODE (p) == CALL_INSN)
1250         record_excess_regs (PATTERN (p), equiv, &output);
1251       p = NEXT_INSN (p);
1252     }
1253
1254   return output;
1255 }
1256 \f
1257 /* Return 1 if all uses of REG
1258    are between INSN and the end of the basic block.  */
1259
1260 static int
1261 reg_in_basic_block_p (insn, reg)
1262      rtx insn, reg;
1263 {
1264   int regno = REGNO (reg);
1265   rtx p;
1266
1267   if (REGNO_FIRST_UID (regno) != INSN_UID (insn))
1268     return 0;
1269
1270   /* Search this basic block for the already recorded last use of the reg.  */
1271   for (p = insn; p; p = NEXT_INSN (p))
1272     {
1273       switch (GET_CODE (p))
1274         {
1275         case NOTE:
1276           break;
1277
1278         case INSN:
1279         case CALL_INSN:
1280           /* Ordinary insn: if this is the last use, we win.  */
1281           if (REGNO_LAST_UID (regno) == INSN_UID (p))
1282             return 1;
1283           break;
1284
1285         case JUMP_INSN:
1286           /* Jump insn: if this is the last use, we win.  */
1287           if (REGNO_LAST_UID (regno) == INSN_UID (p))
1288             return 1;
1289           /* Otherwise, it's the end of the basic block, so we lose.  */
1290           return 0;
1291
1292         case CODE_LABEL:
1293         case BARRIER:
1294           /* It's the end of the basic block, so we lose.  */
1295           return 0;
1296
1297         default:
1298           break;
1299         }
1300     }
1301
1302   /* The "last use" that was recorded can't be found after the first
1303      use.  This can happen when the last use was deleted while
1304      processing an inner loop, this inner loop was then completely
1305      unrolled, and the outer loop is always exited after the inner loop,
1306      so that everything after the first use becomes a single basic block.  */
1307   return 1;
1308 }
1309 \f
1310 /* Compute the benefit of eliminating the insns in the block whose
1311    last insn is LAST.  This may be a group of insns used to compute a
1312    value directly or can contain a library call.  */
1313
1314 static int
1315 libcall_benefit (last)
1316      rtx last;
1317 {
1318   rtx insn;
1319   int benefit = 0;
1320
1321   for (insn = XEXP (find_reg_note (last, REG_RETVAL, NULL_RTX), 0);
1322        insn != last; insn = NEXT_INSN (insn))
1323     {
1324       if (GET_CODE (insn) == CALL_INSN)
1325         benefit += 10;          /* Assume at least this many insns in a library
1326                                    routine.  */
1327       else if (GET_CODE (insn) == INSN
1328                && GET_CODE (PATTERN (insn)) != USE
1329                && GET_CODE (PATTERN (insn)) != CLOBBER)
1330         benefit++;
1331     }
1332
1333   return benefit;
1334 }
1335 \f
1336 /* Skip COUNT insns from INSN, counting library calls as 1 insn.  */
1337
1338 static rtx
1339 skip_consec_insns (insn, count)
1340      rtx insn;
1341      int count;
1342 {
1343   for (; count > 0; count--)
1344     {
1345       rtx temp;
1346
1347       /* If first insn of libcall sequence, skip to end.  */
1348       /* Do this at start of loop, since INSN is guaranteed to
1349          be an insn here.  */
1350       if (GET_CODE (insn) != NOTE
1351           && (temp = find_reg_note (insn, REG_LIBCALL, NULL_RTX)))
1352         insn = XEXP (temp, 0);
1353
1354       do
1355         insn = NEXT_INSN (insn);
1356       while (GET_CODE (insn) == NOTE);
1357     }
1358
1359   return insn;
1360 }
1361
1362 /* Ignore any movable whose insn falls within a libcall
1363    which is part of another movable.
1364    We make use of the fact that the movable for the libcall value
1365    was made later and so appears later on the chain.  */
1366
1367 static void
1368 ignore_some_movables (movables)
1369      struct loop_movables *movables;
1370 {
1371   struct movable *m, *m1;
1372
1373   for (m = movables->head; m; m = m->next)
1374     {
1375       /* Is this a movable for the value of a libcall?  */
1376       rtx note = find_reg_note (m->insn, REG_RETVAL, NULL_RTX);
1377       if (note)
1378         {
1379           rtx insn;
1380           /* Check for earlier movables inside that range,
1381              and mark them invalid.  We cannot use LUIDs here because
1382              insns created by loop.c for prior loops don't have LUIDs.
1383              Rather than reject all such insns from movables, we just
1384              explicitly check each insn in the libcall (since invariant
1385              libcalls aren't that common).  */
1386           for (insn = XEXP (note, 0); insn != m->insn; insn = NEXT_INSN (insn))
1387             for (m1 = movables->head; m1 != m; m1 = m1->next)
1388               if (m1->insn == insn)
1389                 m1->done = 1;
1390         }
1391     }
1392 }
1393
1394 /* For each movable insn, see if the reg that it loads
1395    leads when it dies right into another conditionally movable insn.
1396    If so, record that the second insn "forces" the first one,
1397    since the second can be moved only if the first is.  */
1398
1399 static void
1400 force_movables (movables)
1401      struct loop_movables *movables;
1402 {
1403   struct movable *m, *m1;
1404
1405   for (m1 = movables->head; m1; m1 = m1->next)
1406     /* Omit this if moving just the (SET (REG) 0) of a zero-extend.  */
1407     if (!m1->partial && !m1->done)
1408       {
1409         int regno = m1->regno;
1410         for (m = m1->next; m; m = m->next)
1411           /* ??? Could this be a bug?  What if CSE caused the
1412              register of M1 to be used after this insn?
1413              Since CSE does not update regno_last_uid,
1414              this insn M->insn might not be where it dies.
1415              But very likely this doesn't matter; what matters is
1416              that M's reg is computed from M1's reg.  */
1417           if (INSN_UID (m->insn) == REGNO_LAST_UID (regno)
1418               && !m->done)
1419             break;
1420         if (m != 0 && m->set_src == m1->set_dest
1421             /* If m->consec, m->set_src isn't valid.  */
1422             && m->consec == 0)
1423           m = 0;
1424
1425         /* Increase the priority of the moving the first insn
1426            since it permits the second to be moved as well.  */
1427         if (m != 0)
1428           {
1429             m->forces = m1;
1430             m1->lifetime += m->lifetime;
1431             m1->savings += m->savings;
1432           }
1433       }
1434 }
1435 \f
1436 /* Find invariant expressions that are equal and can be combined into
1437    one register.  */
1438
1439 static void
1440 combine_movables (movables, regs)
1441      struct loop_movables *movables;
1442      struct loop_regs *regs;
1443 {
1444   struct movable *m;
1445   char *matched_regs = (char *) xmalloc (regs->num);
1446   enum machine_mode mode;
1447
1448   /* Regs that are set more than once are not allowed to match
1449      or be matched.  I'm no longer sure why not.  */
1450   /* Perhaps testing m->consec_sets would be more appropriate here?  */
1451
1452   for (m = movables->head; m; m = m->next)
1453     if (m->match == 0 && regs->array[m->regno].n_times_set == 1
1454         && !m->partial)
1455       {
1456         struct movable *m1;
1457         int regno = m->regno;
1458
1459         memset (matched_regs, 0, regs->num);
1460         matched_regs[regno] = 1;
1461
1462         /* We want later insns to match the first one.  Don't make the first
1463            one match any later ones.  So start this loop at m->next.  */
1464         for (m1 = m->next; m1; m1 = m1->next)
1465           /* ??? HACK!  move_movables does not verify that the replacement
1466              is valid, which can have disasterous effects with hard regs
1467              and match_dup.  Turn combination off for now.  */
1468           if (0 && m != m1 && m1->match == 0
1469               && regs->array[m1->regno].n_times_set == 1
1470               /* A reg used outside the loop mustn't be eliminated.  */
1471               && !m1->global
1472               /* A reg used for zero-extending mustn't be eliminated.  */
1473               && !m1->partial
1474               && (matched_regs[m1->regno]
1475                   ||
1476                   (
1477                    /* Can combine regs with different modes loaded from the
1478                       same constant only if the modes are the same or
1479                       if both are integer modes with M wider or the same
1480                       width as M1.  The check for integer is redundant, but
1481                       safe, since the only case of differing destination
1482                       modes with equal sources is when both sources are
1483                       VOIDmode, i.e., CONST_INT.  */
1484                    (GET_MODE (m->set_dest) == GET_MODE (m1->set_dest)
1485                     || (GET_MODE_CLASS (GET_MODE (m->set_dest)) == MODE_INT
1486                         && GET_MODE_CLASS (GET_MODE (m1->set_dest)) == MODE_INT
1487                         && (GET_MODE_BITSIZE (GET_MODE (m->set_dest))
1488                             >= GET_MODE_BITSIZE (GET_MODE (m1->set_dest)))))
1489                    /* See if the source of M1 says it matches M.  */
1490                    && ((GET_CODE (m1->set_src) == REG
1491                         && matched_regs[REGNO (m1->set_src)])
1492                        || rtx_equal_for_loop_p (m->set_src, m1->set_src,
1493                                                 movables, regs))))
1494               && ((m->dependencies == m1->dependencies)
1495                   || rtx_equal_p (m->dependencies, m1->dependencies)))
1496             {
1497               m->lifetime += m1->lifetime;
1498               m->savings += m1->savings;
1499               m1->done = 1;
1500               m1->match = m;
1501               matched_regs[m1->regno] = 1;
1502             }
1503       }
1504
1505   /* Now combine the regs used for zero-extension.
1506      This can be done for those not marked `global'
1507      provided their lives don't overlap.  */
1508
1509   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1510        mode = GET_MODE_WIDER_MODE (mode))
1511     {
1512       struct movable *m0 = 0;
1513
1514       /* Combine all the registers for extension from mode MODE.
1515          Don't combine any that are used outside this loop.  */
1516       for (m = movables->head; m; m = m->next)
1517         if (m->partial && ! m->global
1518             && mode == GET_MODE (SET_SRC (PATTERN (NEXT_INSN (m->insn)))))
1519           {
1520             struct movable *m1;
1521
1522             int first = REGNO_FIRST_LUID (m->regno);
1523             int last = REGNO_LAST_LUID (m->regno);
1524
1525             if (m0 == 0)
1526               {
1527                 /* First one: don't check for overlap, just record it.  */
1528                 m0 = m;
1529                 continue;
1530               }
1531
1532             /* Make sure they extend to the same mode.
1533                (Almost always true.)  */
1534             if (GET_MODE (m->set_dest) != GET_MODE (m0->set_dest))
1535               continue;
1536
1537             /* We already have one: check for overlap with those
1538                already combined together.  */
1539             for (m1 = movables->head; m1 != m; m1 = m1->next)
1540               if (m1 == m0 || (m1->partial && m1->match == m0))
1541                 if (! (REGNO_FIRST_LUID (m1->regno) > last
1542                        || REGNO_LAST_LUID (m1->regno) < first))
1543                   goto overlap;
1544
1545             /* No overlap: we can combine this with the others.  */
1546             m0->lifetime += m->lifetime;
1547             m0->savings += m->savings;
1548             m->done = 1;
1549             m->match = m0;
1550
1551           overlap:
1552             ;
1553           }
1554     }
1555
1556   /* Clean up.  */
1557   free (matched_regs);
1558 }
1559
1560 /* Returns the number of movable instructions in LOOP that were not
1561    moved outside the loop.  */
1562
1563 static int
1564 num_unmoved_movables (loop)
1565      const struct loop *loop;
1566 {
1567   int num = 0;
1568   struct movable *m;
1569
1570   for (m = LOOP_MOVABLES (loop)->head; m; m = m->next)
1571     if (!m->done)
1572       ++num;
1573
1574   return num;
1575 }
1576
1577 \f
1578 /* Return 1 if regs X and Y will become the same if moved.  */
1579
1580 static int
1581 regs_match_p (x, y, movables)
1582      rtx x, y;
1583      struct loop_movables *movables;
1584 {
1585   unsigned int xn = REGNO (x);
1586   unsigned int yn = REGNO (y);
1587   struct movable *mx, *my;
1588
1589   for (mx = movables->head; mx; mx = mx->next)
1590     if (mx->regno == xn)
1591       break;
1592
1593   for (my = movables->head; my; my = my->next)
1594     if (my->regno == yn)
1595       break;
1596
1597   return (mx && my
1598           && ((mx->match == my->match && mx->match != 0)
1599               || mx->match == my
1600               || mx == my->match));
1601 }
1602
1603 /* Return 1 if X and Y are identical-looking rtx's.
1604    This is the Lisp function EQUAL for rtx arguments.
1605
1606    If two registers are matching movables or a movable register and an
1607    equivalent constant, consider them equal.  */
1608
1609 static int
1610 rtx_equal_for_loop_p (x, y, movables, regs)
1611      rtx x, y;
1612      struct loop_movables *movables;
1613      struct loop_regs *regs;
1614 {
1615   int i;
1616   int j;
1617   struct movable *m;
1618   enum rtx_code code;
1619   const char *fmt;
1620
1621   if (x == y)
1622     return 1;
1623   if (x == 0 || y == 0)
1624     return 0;
1625
1626   code = GET_CODE (x);
1627
1628   /* If we have a register and a constant, they may sometimes be
1629      equal.  */
1630   if (GET_CODE (x) == REG && regs->array[REGNO (x)].set_in_loop == -2
1631       && CONSTANT_P (y))
1632     {
1633       for (m = movables->head; m; m = m->next)
1634         if (m->move_insn && m->regno == REGNO (x)
1635             && rtx_equal_p (m->set_src, y))
1636           return 1;
1637     }
1638   else if (GET_CODE (y) == REG && regs->array[REGNO (y)].set_in_loop == -2
1639            && CONSTANT_P (x))
1640     {
1641       for (m = movables->head; m; m = m->next)
1642         if (m->move_insn && m->regno == REGNO (y)
1643             && rtx_equal_p (m->set_src, x))
1644           return 1;
1645     }
1646
1647   /* Otherwise, rtx's of different codes cannot be equal.  */
1648   if (code != GET_CODE (y))
1649     return 0;
1650
1651   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
1652      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
1653
1654   if (GET_MODE (x) != GET_MODE (y))
1655     return 0;
1656
1657   /* These three types of rtx's can be compared nonrecursively.  */
1658   if (code == REG)
1659     return (REGNO (x) == REGNO (y) || regs_match_p (x, y, movables));
1660
1661   if (code == LABEL_REF)
1662     return XEXP (x, 0) == XEXP (y, 0);
1663   if (code == SYMBOL_REF)
1664     return XSTR (x, 0) == XSTR (y, 0);
1665
1666   /* Compare the elements.  If any pair of corresponding elements
1667      fail to match, return 0 for the whole things.  */
1668
1669   fmt = GET_RTX_FORMAT (code);
1670   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1671     {
1672       switch (fmt[i])
1673         {
1674         case 'w':
1675           if (XWINT (x, i) != XWINT (y, i))
1676             return 0;
1677           break;
1678
1679         case 'i':
1680           if (XINT (x, i) != XINT (y, i))
1681             return 0;
1682           break;
1683
1684         case 'E':
1685           /* Two vectors must have the same length.  */
1686           if (XVECLEN (x, i) != XVECLEN (y, i))
1687             return 0;
1688
1689           /* And the corresponding elements must match.  */
1690           for (j = 0; j < XVECLEN (x, i); j++)
1691             if (rtx_equal_for_loop_p (XVECEXP (x, i, j), XVECEXP (y, i, j),
1692                                       movables, regs) == 0)
1693               return 0;
1694           break;
1695
1696         case 'e':
1697           if (rtx_equal_for_loop_p (XEXP (x, i), XEXP (y, i), movables, regs)
1698               == 0)
1699             return 0;
1700           break;
1701
1702         case 's':
1703           if (strcmp (XSTR (x, i), XSTR (y, i)))
1704             return 0;
1705           break;
1706
1707         case 'u':
1708           /* These are just backpointers, so they don't matter.  */
1709           break;
1710
1711         case '0':
1712           break;
1713
1714           /* It is believed that rtx's at this level will never
1715              contain anything but integers and other rtx's,
1716              except for within LABEL_REFs and SYMBOL_REFs.  */
1717         default:
1718           abort ();
1719         }
1720     }
1721   return 1;
1722 }
1723 \f
1724 /* If X contains any LABEL_REF's, add REG_LABEL notes for them to all
1725    insns in INSNS which use the reference.  LABEL_NUSES for CODE_LABEL
1726    references is incremented once for each added note.  */
1727
1728 static void
1729 add_label_notes (x, insns)
1730      rtx x;
1731      rtx insns;
1732 {
1733   enum rtx_code code = GET_CODE (x);
1734   int i, j;
1735   const char *fmt;
1736   rtx insn;
1737
1738   if (code == LABEL_REF && !LABEL_REF_NONLOCAL_P (x))
1739     {
1740       /* This code used to ignore labels that referred to dispatch tables to
1741          avoid flow generating (slighly) worse code.
1742
1743          We no longer ignore such label references (see LABEL_REF handling in
1744          mark_jump_label for additional information).  */
1745       for (insn = insns; insn; insn = NEXT_INSN (insn))
1746         if (reg_mentioned_p (XEXP (x, 0), insn))
1747           {
1748             REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL, XEXP (x, 0),
1749                                                   REG_NOTES (insn));
1750             if (LABEL_P (XEXP (x, 0)))
1751               LABEL_NUSES (XEXP (x, 0))++;
1752           }
1753     }
1754
1755   fmt = GET_RTX_FORMAT (code);
1756   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1757     {
1758       if (fmt[i] == 'e')
1759         add_label_notes (XEXP (x, i), insns);
1760       else if (fmt[i] == 'E')
1761         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1762           add_label_notes (XVECEXP (x, i, j), insns);
1763     }
1764 }
1765 \f
1766 /* Scan MOVABLES, and move the insns that deserve to be moved.
1767    If two matching movables are combined, replace one reg with the
1768    other throughout.  */
1769
1770 static void
1771 move_movables (loop, movables, threshold, insn_count)
1772      struct loop *loop;
1773      struct loop_movables *movables;
1774      int threshold;
1775      int insn_count;
1776 {
1777   struct loop_regs *regs = LOOP_REGS (loop);
1778   int nregs = regs->num;
1779   rtx new_start = 0;
1780   struct movable *m;
1781   rtx p;
1782   rtx loop_start = loop->start;
1783   rtx loop_end = loop->end;
1784   /* Map of pseudo-register replacements to handle combining
1785      when we move several insns that load the same value
1786      into different pseudo-registers.  */
1787   rtx *reg_map = (rtx *) xcalloc (nregs, sizeof (rtx));
1788   char *already_moved = (char *) xcalloc (nregs, sizeof (char));
1789
1790   for (m = movables->head; m; m = m->next)
1791     {
1792       /* Describe this movable insn.  */
1793
1794       if (loop_dump_stream)
1795         {
1796           fprintf (loop_dump_stream, "Insn %d: regno %d (life %d), ",
1797                    INSN_UID (m->insn), m->regno, m->lifetime);
1798           if (m->consec > 0)
1799             fprintf (loop_dump_stream, "consec %d, ", m->consec);
1800           if (m->cond)
1801             fprintf (loop_dump_stream, "cond ");
1802           if (m->force)
1803             fprintf (loop_dump_stream, "force ");
1804           if (m->global)
1805             fprintf (loop_dump_stream, "global ");
1806           if (m->done)
1807             fprintf (loop_dump_stream, "done ");
1808           if (m->move_insn)
1809             fprintf (loop_dump_stream, "move-insn ");
1810           if (m->match)
1811             fprintf (loop_dump_stream, "matches %d ",
1812                      INSN_UID (m->match->insn));
1813           if (m->forces)
1814             fprintf (loop_dump_stream, "forces %d ",
1815                      INSN_UID (m->forces->insn));
1816         }
1817
1818       /* Ignore the insn if it's already done (it matched something else).
1819          Otherwise, see if it is now safe to move.  */
1820
1821       if (!m->done
1822           && (! m->cond
1823               || (1 == loop_invariant_p (loop, m->set_src)
1824                   && (m->dependencies == 0
1825                       || 1 == loop_invariant_p (loop, m->dependencies))
1826                   && (m->consec == 0
1827                       || 1 == consec_sets_invariant_p (loop, m->set_dest,
1828                                                        m->consec + 1,
1829                                                        m->insn))))
1830           && (! m->forces || m->forces->done))
1831         {
1832           int regno;
1833           rtx p;
1834           int savings = m->savings;
1835
1836           /* We have an insn that is safe to move.
1837              Compute its desirability.  */
1838
1839           p = m->insn;
1840           regno = m->regno;
1841
1842           if (loop_dump_stream)
1843             fprintf (loop_dump_stream, "savings %d ", savings);
1844
1845           if (regs->array[regno].moved_once && loop_dump_stream)
1846             fprintf (loop_dump_stream, "halved since already moved ");
1847
1848           /* An insn MUST be moved if we already moved something else
1849              which is safe only if this one is moved too: that is,
1850              if already_moved[REGNO] is nonzero.  */
1851
1852           /* An insn is desirable to move if the new lifetime of the
1853              register is no more than THRESHOLD times the old lifetime.
1854              If it's not desirable, it means the loop is so big
1855              that moving won't speed things up much,
1856              and it is liable to make register usage worse.  */
1857
1858           /* It is also desirable to move if it can be moved at no
1859              extra cost because something else was already moved.  */
1860
1861           if (already_moved[regno]
1862               || flag_move_all_movables
1863               || (threshold * savings * m->lifetime) >=
1864                  (regs->array[regno].moved_once ? insn_count * 2 : insn_count)
1865               || (m->forces && m->forces->done
1866                   && regs->array[m->forces->regno].n_times_set == 1))
1867             {
1868               int count;
1869               struct movable *m1;
1870               rtx first = NULL_RTX;
1871
1872               /* Now move the insns that set the reg.  */
1873
1874               if (m->partial && m->match)
1875                 {
1876                   rtx newpat, i1;
1877                   rtx r1, r2;
1878                   /* Find the end of this chain of matching regs.
1879                      Thus, we load each reg in the chain from that one reg.
1880                      And that reg is loaded with 0 directly,
1881                      since it has ->match == 0.  */
1882                   for (m1 = m; m1->match; m1 = m1->match);
1883                   newpat = gen_move_insn (SET_DEST (PATTERN (m->insn)),
1884                                           SET_DEST (PATTERN (m1->insn)));
1885                   i1 = loop_insn_hoist (loop, newpat);
1886
1887                   /* Mark the moved, invariant reg as being allowed to
1888                      share a hard reg with the other matching invariant.  */
1889                   REG_NOTES (i1) = REG_NOTES (m->insn);
1890                   r1 = SET_DEST (PATTERN (m->insn));
1891                   r2 = SET_DEST (PATTERN (m1->insn));
1892                   regs_may_share
1893                     = gen_rtx_EXPR_LIST (VOIDmode, r1,
1894                                          gen_rtx_EXPR_LIST (VOIDmode, r2,
1895                                                             regs_may_share));
1896                   delete_insn (m->insn);
1897
1898                   if (new_start == 0)
1899                     new_start = i1;
1900
1901                   if (loop_dump_stream)
1902                     fprintf (loop_dump_stream, " moved to %d", INSN_UID (i1));
1903                 }
1904               /* If we are to re-generate the item being moved with a
1905                  new move insn, first delete what we have and then emit
1906                  the move insn before the loop.  */
1907               else if (m->move_insn)
1908                 {
1909                   rtx i1, temp, seq;
1910
1911                   for (count = m->consec; count >= 0; count--)
1912                     {
1913                       /* If this is the first insn of a library call sequence,
1914                          skip to the end.  */
1915                       if (GET_CODE (p) != NOTE
1916                           && (temp = find_reg_note (p, REG_LIBCALL, NULL_RTX)))
1917                         p = XEXP (temp, 0);
1918
1919                       /* If this is the last insn of a libcall sequence, then
1920                          delete every insn in the sequence except the last.
1921                          The last insn is handled in the normal manner.  */
1922                       if (GET_CODE (p) != NOTE
1923                           && (temp = find_reg_note (p, REG_RETVAL, NULL_RTX)))
1924                         {
1925                           temp = XEXP (temp, 0);
1926                           while (temp != p)
1927                             temp = delete_insn (temp);
1928                         }
1929
1930                       temp = p;
1931                       p = delete_insn (p);
1932
1933                       /* simplify_giv_expr expects that it can walk the insns
1934                          at m->insn forwards and see this old sequence we are
1935                          tossing here.  delete_insn does preserve the next
1936                          pointers, but when we skip over a NOTE we must fix
1937                          it up.  Otherwise that code walks into the non-deleted
1938                          insn stream.  */
1939                       while (p && GET_CODE (p) == NOTE)
1940                         p = NEXT_INSN (temp) = NEXT_INSN (p);
1941                     }
1942
1943                   start_sequence ();
1944                   emit_move_insn (m->set_dest, m->set_src);
1945                   temp = get_insns ();
1946                   seq = gen_sequence ();
1947                   end_sequence ();
1948
1949                   add_label_notes (m->set_src, temp);
1950
1951                   i1 = loop_insn_hoist (loop, seq);
1952                   if (! find_reg_note (i1, REG_EQUAL, NULL_RTX))
1953                     set_unique_reg_note (i1,
1954                                          m->is_equiv ? REG_EQUIV : REG_EQUAL,
1955                                          m->set_src);
1956
1957                   if (loop_dump_stream)
1958                     fprintf (loop_dump_stream, " moved to %d", INSN_UID (i1));
1959
1960                   /* The more regs we move, the less we like moving them.  */
1961                   threshold -= 3;
1962                 }
1963               else
1964                 {
1965                   for (count = m->consec; count >= 0; count--)
1966                     {
1967                       rtx i1, temp;
1968
1969                       /* If first insn of libcall sequence, skip to end.  */
1970                       /* Do this at start of loop, since p is guaranteed to
1971                          be an insn here.  */
1972                       if (GET_CODE (p) != NOTE
1973                           && (temp = find_reg_note (p, REG_LIBCALL, NULL_RTX)))
1974                         p = XEXP (temp, 0);
1975
1976                       /* If last insn of libcall sequence, move all
1977                          insns except the last before the loop.  The last
1978                          insn is handled in the normal manner.  */
1979                       if (GET_CODE (p) != NOTE
1980                           && (temp = find_reg_note (p, REG_RETVAL, NULL_RTX)))
1981                         {
1982                           rtx fn_address = 0;
1983                           rtx fn_reg = 0;
1984                           rtx fn_address_insn = 0;
1985
1986                           first = 0;
1987                           for (temp = XEXP (temp, 0); temp != p;
1988                                temp = NEXT_INSN (temp))
1989                             {
1990                               rtx body;
1991                               rtx n;
1992                               rtx next;
1993
1994                               if (GET_CODE (temp) == NOTE)
1995                                 continue;
1996
1997                               body = PATTERN (temp);
1998
1999                               /* Find the next insn after TEMP,
2000                                  not counting USE or NOTE insns.  */
2001                               for (next = NEXT_INSN (temp); next != p;
2002                                    next = NEXT_INSN (next))
2003                                 if (! (GET_CODE (next) == INSN
2004                                        && GET_CODE (PATTERN (next)) == USE)
2005                                     && GET_CODE (next) != NOTE)
2006                                   break;
2007
2008                               /* If that is the call, this may be the insn
2009                                  that loads the function address.
2010
2011                                  Extract the function address from the insn
2012                                  that loads it into a register.
2013                                  If this insn was cse'd, we get incorrect code.
2014
2015                                  So emit a new move insn that copies the
2016                                  function address into the register that the
2017                                  call insn will use.  flow.c will delete any
2018                                  redundant stores that we have created.  */
2019                               if (GET_CODE (next) == CALL_INSN
2020                                   && GET_CODE (body) == SET
2021                                   && GET_CODE (SET_DEST (body)) == REG
2022                                   && (n = find_reg_note (temp, REG_EQUAL,
2023                                                          NULL_RTX)))
2024                                 {
2025                                   fn_reg = SET_SRC (body);
2026                                   if (GET_CODE (fn_reg) != REG)
2027                                     fn_reg = SET_DEST (body);
2028                                   fn_address = XEXP (n, 0);
2029                                   fn_address_insn = temp;
2030                                 }
2031                               /* We have the call insn.
2032                                  If it uses the register we suspect it might,
2033                                  load it with the correct address directly.  */
2034                               if (GET_CODE (temp) == CALL_INSN
2035                                   && fn_address != 0
2036                                   && reg_referenced_p (fn_reg, body))
2037                                 loop_insn_emit_after (loop, 0, fn_address_insn,
2038                                                       gen_move_insn
2039                                                       (fn_reg, fn_address));
2040
2041                               if (GET_CODE (temp) == CALL_INSN)
2042                                 {
2043                                   i1 = loop_call_insn_hoist (loop, body);
2044                                   /* Because the USAGE information potentially
2045                                      contains objects other than hard registers
2046                                      we need to copy it.  */
2047                                   if (CALL_INSN_FUNCTION_USAGE (temp))
2048                                     CALL_INSN_FUNCTION_USAGE (i1)
2049                                       = copy_rtx (CALL_INSN_FUNCTION_USAGE (temp));
2050                                 }
2051                               else
2052                                 i1 = loop_insn_hoist (loop, body);
2053                               if (first == 0)
2054                                 first = i1;
2055                               if (temp == fn_address_insn)
2056                                 fn_address_insn = i1;
2057                               REG_NOTES (i1) = REG_NOTES (temp);
2058                               REG_NOTES (temp) = NULL;
2059                               delete_insn (temp);
2060                             }
2061                           if (new_start == 0)
2062                             new_start = first;
2063                         }
2064                       if (m->savemode != VOIDmode)
2065                         {
2066                           /* P sets REG to zero; but we should clear only
2067                              the bits that are not covered by the mode
2068                              m->savemode.  */
2069                           rtx reg = m->set_dest;
2070                           rtx sequence;
2071                           rtx tem;
2072
2073                           start_sequence ();
2074                           tem = expand_simple_binop
2075                             (GET_MODE (reg), AND, reg,
2076                              GEN_INT ((((HOST_WIDE_INT) 1
2077                                         << GET_MODE_BITSIZE (m->savemode)))
2078                                       - 1),
2079                              reg, 1, OPTAB_LIB_WIDEN);
2080                           if (tem == 0)
2081                             abort ();
2082                           if (tem != reg)
2083                             emit_move_insn (reg, tem);
2084                           sequence = gen_sequence ();
2085                           end_sequence ();
2086                           i1 = loop_insn_hoist (loop, sequence);
2087                         }
2088                       else if (GET_CODE (p) == CALL_INSN)
2089                         {
2090                           i1 = loop_call_insn_hoist (loop, PATTERN (p));
2091                           /* Because the USAGE information potentially
2092                              contains objects other than hard registers
2093                              we need to copy it.  */
2094                           if (CALL_INSN_FUNCTION_USAGE (p))
2095                             CALL_INSN_FUNCTION_USAGE (i1)
2096                               = copy_rtx (CALL_INSN_FUNCTION_USAGE (p));
2097                         }
2098                       else if (count == m->consec && m->move_insn_first)
2099                         {
2100                           rtx seq;
2101                           /* The SET_SRC might not be invariant, so we must
2102                              use the REG_EQUAL note.  */
2103                           start_sequence ();
2104                           emit_move_insn (m->set_dest, m->set_src);
2105                           temp = get_insns ();
2106                           seq = gen_sequence ();
2107                           end_sequence ();
2108
2109                           add_label_notes (m->set_src, temp);
2110
2111                           i1 = loop_insn_hoist (loop, seq);
2112                           if (! find_reg_note (i1, REG_EQUAL, NULL_RTX))
2113                             set_unique_reg_note (i1, m->is_equiv ? REG_EQUIV
2114                                                      : REG_EQUAL, m->set_src);
2115                         }
2116                       else
2117                         i1 = loop_insn_hoist (loop, PATTERN (p));
2118
2119                       if (REG_NOTES (i1) == 0)
2120                         {
2121                           REG_NOTES (i1) = REG_NOTES (p);
2122                           REG_NOTES (p) = NULL;
2123
2124                           /* If there is a REG_EQUAL note present whose value
2125                              is not loop invariant, then delete it, since it
2126                              may cause problems with later optimization passes.
2127                              It is possible for cse to create such notes
2128                              like this as a result of record_jump_cond.  */
2129
2130                           if ((temp = find_reg_note (i1, REG_EQUAL, NULL_RTX))
2131                               && ! loop_invariant_p (loop, XEXP (temp, 0)))
2132                             remove_note (i1, temp);
2133                         }
2134
2135                       if (new_start == 0)
2136                         new_start = i1;
2137
2138                       if (loop_dump_stream)
2139                         fprintf (loop_dump_stream, " moved to %d",
2140                                  INSN_UID (i1));
2141
2142                       /* If library call, now fix the REG_NOTES that contain
2143                          insn pointers, namely REG_LIBCALL on FIRST
2144                          and REG_RETVAL on I1.  */
2145                       if ((temp = find_reg_note (i1, REG_RETVAL, NULL_RTX)))
2146                         {
2147                           XEXP (temp, 0) = first;
2148                           temp = find_reg_note (first, REG_LIBCALL, NULL_RTX);
2149                           XEXP (temp, 0) = i1;
2150                         }
2151
2152                       temp = p;
2153                       delete_insn (p);
2154                       p = NEXT_INSN (p);
2155
2156                       /* simplify_giv_expr expects that it can walk the insns
2157                          at m->insn forwards and see this old sequence we are
2158                          tossing here.  delete_insn does preserve the next
2159                          pointers, but when we skip over a NOTE we must fix
2160                          it up.  Otherwise that code walks into the non-deleted
2161                          insn stream.  */
2162                       while (p && GET_CODE (p) == NOTE)
2163                         p = NEXT_INSN (temp) = NEXT_INSN (p);
2164                     }
2165
2166                   /* The more regs we move, the less we like moving them.  */
2167                   threshold -= 3;
2168                 }
2169
2170               /* Any other movable that loads the same register
2171                  MUST be moved.  */
2172               already_moved[regno] = 1;
2173
2174               /* This reg has been moved out of one loop.  */
2175               regs->array[regno].moved_once = 1;
2176
2177               /* The reg set here is now invariant.  */
2178               if (! m->partial)
2179                 {
2180                   int i;
2181                   for (i = 0; i < LOOP_REGNO_NREGS (regno, m->set_dest); i++)
2182                     regs->array[regno+i].set_in_loop = 0;
2183                 }
2184
2185               m->done = 1;
2186
2187               /* Change the length-of-life info for the register
2188                  to say it lives at least the full length of this loop.
2189                  This will help guide optimizations in outer loops.  */
2190
2191               if (REGNO_FIRST_LUID (regno) > INSN_LUID (loop_start))
2192                 /* This is the old insn before all the moved insns.
2193                    We can't use the moved insn because it is out of range
2194                    in uid_luid.  Only the old insns have luids.  */
2195                 REGNO_FIRST_UID (regno) = INSN_UID (loop_start);
2196               if (REGNO_LAST_LUID (regno) < INSN_LUID (loop_end))
2197                 REGNO_LAST_UID (regno) = INSN_UID (loop_end);
2198
2199               /* Combine with this moved insn any other matching movables.  */
2200
2201               if (! m->partial)
2202                 for (m1 = movables->head; m1; m1 = m1->next)
2203                   if (m1->match == m)
2204                     {
2205                       rtx temp;
2206
2207                       /* Schedule the reg loaded by M1
2208                          for replacement so that shares the reg of M.
2209                          If the modes differ (only possible in restricted
2210                          circumstances, make a SUBREG.
2211
2212                          Note this assumes that the target dependent files
2213                          treat REG and SUBREG equally, including within
2214                          GO_IF_LEGITIMATE_ADDRESS and in all the
2215                          predicates since we never verify that replacing the
2216                          original register with a SUBREG results in a
2217                          recognizable insn.  */
2218                       if (GET_MODE (m->set_dest) == GET_MODE (m1->set_dest))
2219                         reg_map[m1->regno] = m->set_dest;
2220                       else
2221                         reg_map[m1->regno]
2222                           = gen_lowpart_common (GET_MODE (m1->set_dest),
2223                                                 m->set_dest);
2224
2225                       /* Get rid of the matching insn
2226                          and prevent further processing of it.  */
2227                       m1->done = 1;
2228
2229                       /* if library call, delete all insns.  */
2230                       if ((temp = find_reg_note (m1->insn, REG_RETVAL,
2231                                                  NULL_RTX)))
2232                         delete_insn_chain (XEXP (temp, 0), m1->insn);
2233                       else
2234                         delete_insn (m1->insn);
2235
2236                       /* Any other movable that loads the same register
2237                          MUST be moved.  */
2238                       already_moved[m1->regno] = 1;
2239
2240                       /* The reg merged here is now invariant,
2241                          if the reg it matches is invariant.  */
2242                       if (! m->partial)
2243                         {
2244                           int i;
2245                           for (i = 0;
2246                                i < LOOP_REGNO_NREGS (regno, m1->set_dest);
2247                                i++)
2248                             regs->array[m1->regno+i].set_in_loop = 0;
2249                         }
2250                     }
2251             }
2252           else if (loop_dump_stream)
2253             fprintf (loop_dump_stream, "not desirable");
2254         }
2255       else if (loop_dump_stream && !m->match)
2256         fprintf (loop_dump_stream, "not safe");
2257
2258       if (loop_dump_stream)
2259         fprintf (loop_dump_stream, "\n");
2260     }
2261
2262   if (new_start == 0)
2263     new_start = loop_start;
2264
2265   /* Go through all the instructions in the loop, making
2266      all the register substitutions scheduled in REG_MAP.  */
2267   for (p = new_start; p != loop_end; p = NEXT_INSN (p))
2268     if (GET_CODE (p) == INSN || GET_CODE (p) == JUMP_INSN
2269         || GET_CODE (p) == CALL_INSN)
2270       {
2271         replace_regs (PATTERN (p), reg_map, nregs, 0);
2272         replace_regs (REG_NOTES (p), reg_map, nregs, 0);
2273         INSN_CODE (p) = -1;
2274       }
2275
2276   /* Clean up.  */
2277   free (reg_map);
2278   free (already_moved);
2279 }
2280
2281
2282 static void
2283 loop_movables_add (movables, m)
2284      struct loop_movables *movables;
2285      struct movable *m;
2286 {
2287   if (movables->head == 0)
2288     movables->head = m;
2289   else
2290     movables->last->next = m;
2291   movables->last = m;
2292 }
2293
2294
2295 static void
2296 loop_movables_free (movables)
2297      struct loop_movables *movables;
2298 {
2299   struct movable *m;
2300   struct movable *m_next;
2301
2302   for (m = movables->head; m; m = m_next)
2303     {
2304       m_next = m->next;
2305       free (m);
2306     }
2307 }
2308 \f
2309 #if 0
2310 /* Scan X and replace the address of any MEM in it with ADDR.
2311    REG is the address that MEM should have before the replacement.  */
2312
2313 static void
2314 replace_call_address (x, reg, addr)
2315      rtx x, reg, addr;
2316 {
2317   enum rtx_code code;
2318   int i;
2319   const char *fmt;
2320
2321   if (x == 0)
2322     return;
2323   code = GET_CODE (x);
2324   switch (code)
2325     {
2326     case PC:
2327     case CC0:
2328     case CONST_INT:
2329     case CONST_DOUBLE:
2330     case CONST:
2331     case SYMBOL_REF:
2332     case LABEL_REF:
2333     case REG:
2334       return;
2335
2336     case SET:
2337       /* Short cut for very common case.  */
2338       replace_call_address (XEXP (x, 1), reg, addr);
2339       return;
2340
2341     case CALL:
2342       /* Short cut for very common case.  */
2343       replace_call_address (XEXP (x, 0), reg, addr);
2344       return;
2345
2346     case MEM:
2347       /* If this MEM uses a reg other than the one we expected,
2348          something is wrong.  */
2349       if (XEXP (x, 0) != reg)
2350         abort ();
2351       XEXP (x, 0) = addr;
2352       return;
2353
2354     default:
2355       break;
2356     }
2357
2358   fmt = GET_RTX_FORMAT (code);
2359   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2360     {
2361       if (fmt[i] == 'e')
2362         replace_call_address (XEXP (x, i), reg, addr);
2363       else if (fmt[i] == 'E')
2364         {
2365           int j;
2366           for (j = 0; j < XVECLEN (x, i); j++)
2367             replace_call_address (XVECEXP (x, i, j), reg, addr);
2368         }
2369     }
2370 }
2371 #endif
2372 \f
2373 /* Return the number of memory refs to addresses that vary
2374    in the rtx X.  */
2375
2376 static int
2377 count_nonfixed_reads (loop, x)
2378      const struct loop *loop;
2379      rtx x;
2380 {
2381   enum rtx_code code;
2382   int i;
2383   const char *fmt;
2384   int value;
2385
2386   if (x == 0)
2387     return 0;
2388
2389   code = GET_CODE (x);
2390   switch (code)
2391     {
2392     case PC:
2393     case CC0:
2394     case CONST_INT:
2395     case CONST_DOUBLE:
2396     case CONST:
2397     case SYMBOL_REF:
2398     case LABEL_REF:
2399     case REG:
2400       return 0;
2401
2402     case MEM:
2403       return ((loop_invariant_p (loop, XEXP (x, 0)) != 1)
2404               + count_nonfixed_reads (loop, XEXP (x, 0)));
2405
2406     default:
2407       break;
2408     }
2409
2410   value = 0;
2411   fmt = GET_RTX_FORMAT (code);
2412   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2413     {
2414       if (fmt[i] == 'e')
2415         value += count_nonfixed_reads (loop, XEXP (x, i));
2416       if (fmt[i] == 'E')
2417         {
2418           int j;
2419           for (j = 0; j < XVECLEN (x, i); j++)
2420             value += count_nonfixed_reads (loop, XVECEXP (x, i, j));
2421         }
2422     }
2423   return value;
2424 }
2425 \f
2426 /* Scan a loop setting the elements `cont', `vtop', `loops_enclosed',
2427    `has_call', `has_nonconst_call', `has_volatile', `has_tablejump',
2428    `unknown_address_altered', `unknown_constant_address_altered', and
2429    `num_mem_sets' in LOOP.  Also, fill in the array `mems' and the
2430    list `store_mems' in LOOP.  */
2431
2432 static void
2433 prescan_loop (loop)
2434      struct loop *loop;
2435 {
2436   int level = 1;
2437   rtx insn;
2438   struct loop_info *loop_info = LOOP_INFO (loop);
2439   rtx start = loop->start;
2440   rtx end = loop->end;
2441   /* The label after END.  Jumping here is just like falling off the
2442      end of the loop.  We use next_nonnote_insn instead of next_label
2443      as a hedge against the (pathological) case where some actual insn
2444      might end up between the two.  */
2445   rtx exit_target = next_nonnote_insn (end);
2446
2447   loop_info->has_indirect_jump = indirect_jump_in_function;
2448   loop_info->pre_header_has_call = 0;
2449   loop_info->has_call = 0;
2450   loop_info->has_nonconst_call = 0;
2451   loop_info->has_volatile = 0;
2452   loop_info->has_tablejump = 0;
2453   loop_info->has_multiple_exit_targets = 0;
2454   loop->level = 1;
2455
2456   loop_info->unknown_address_altered = 0;
2457   loop_info->unknown_constant_address_altered = 0;
2458   loop_info->store_mems = NULL_RTX;
2459   loop_info->first_loop_store_insn = NULL_RTX;
2460   loop_info->mems_idx = 0;
2461   loop_info->num_mem_sets = 0;
2462
2463
2464   for (insn = start; insn && GET_CODE (insn) != CODE_LABEL;
2465        insn = PREV_INSN (insn))
2466     {
2467       if (GET_CODE (insn) == CALL_INSN)
2468         {
2469           loop_info->pre_header_has_call = 1;
2470           break;
2471         }
2472     }
2473
2474   for (insn = NEXT_INSN (start); insn != NEXT_INSN (end);
2475        insn = NEXT_INSN (insn))
2476     {
2477       switch (GET_CODE (insn))
2478         {
2479         case NOTE:
2480           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
2481             {
2482               ++level;
2483               /* Count number of loops contained in this one.  */
2484               loop->level++;
2485             }
2486           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
2487             --level;
2488           break;
2489
2490         case CALL_INSN:
2491           if (! CONST_OR_PURE_CALL_P (insn))
2492             {
2493               loop_info->unknown_address_altered = 1;
2494               loop_info->has_nonconst_call = 1;
2495             }
2496           else if (pure_call_p (insn))
2497             loop_info->has_nonconst_call = 1;
2498           loop_info->has_call = 1;
2499           if (can_throw_internal (insn))
2500             loop_info->has_multiple_exit_targets = 1;
2501           break;
2502
2503         case JUMP_INSN:
2504           if (! loop_info->has_multiple_exit_targets)
2505             {
2506               rtx set = pc_set (insn);
2507
2508               if (set)
2509                 {
2510                   rtx src = SET_SRC (set);
2511                   rtx label1, label2;
2512
2513                   if (GET_CODE (src) == IF_THEN_ELSE)
2514                     {
2515                       label1 = XEXP (src, 1);
2516                       label2 = XEXP (src, 2);
2517                     }
2518                   else
2519                     {
2520                       label1 = src;
2521                       label2 = NULL_RTX;
2522                     }
2523
2524                   do
2525                     {
2526                       if (label1 && label1 != pc_rtx)
2527                         {
2528                           if (GET_CODE (label1) != LABEL_REF)
2529                             {
2530                               /* Something tricky.  */
2531                               loop_info->has_multiple_exit_targets = 1;
2532                               break;
2533                             }
2534                           else if (XEXP (label1, 0) != exit_target
2535                                    && LABEL_OUTSIDE_LOOP_P (label1))
2536                             {
2537                               /* A jump outside the current loop.  */
2538                               loop_info->has_multiple_exit_targets = 1;
2539                               break;
2540                             }
2541                         }
2542
2543                       label1 = label2;
2544                       label2 = NULL_RTX;
2545                     }
2546                   while (label1);
2547                 }
2548               else
2549                 {
2550                   /* A return, or something tricky.  */
2551                   loop_info->has_multiple_exit_targets = 1;
2552                 }
2553             }
2554           /* FALLTHRU */
2555
2556         case INSN:
2557           if (volatile_refs_p (PATTERN (insn)))
2558             loop_info->has_volatile = 1;
2559
2560           if (GET_CODE (insn) == JUMP_INSN
2561               && (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
2562                   || GET_CODE (PATTERN (insn)) == ADDR_VEC))
2563             loop_info->has_tablejump = 1;
2564
2565           note_stores (PATTERN (insn), note_addr_stored, loop_info);
2566           if (! loop_info->first_loop_store_insn && loop_info->store_mems)
2567             loop_info->first_loop_store_insn = insn;
2568
2569           if (flag_non_call_exceptions && can_throw_internal (insn))
2570             loop_info->has_multiple_exit_targets = 1;
2571           break;
2572
2573         default:
2574           break;
2575         }
2576     }
2577
2578   /* Now, rescan the loop, setting up the LOOP_MEMS array.  */
2579   if (/* An exception thrown by a called function might land us
2580          anywhere.  */
2581       ! loop_info->has_nonconst_call
2582       /* We don't want loads for MEMs moved to a location before the
2583          one at which their stack memory becomes allocated.  (Note
2584          that this is not a problem for malloc, etc., since those
2585          require actual function calls.  */
2586       && ! current_function_calls_alloca
2587       /* There are ways to leave the loop other than falling off the
2588          end.  */
2589       && ! loop_info->has_multiple_exit_targets)
2590     for (insn = NEXT_INSN (start); insn != NEXT_INSN (end);
2591          insn = NEXT_INSN (insn))
2592       for_each_rtx (&insn, insert_loop_mem, loop_info);
2593
2594   /* BLKmode MEMs are added to LOOP_STORE_MEM as necessary so
2595      that loop_invariant_p and load_mems can use true_dependence
2596      to determine what is really clobbered.  */
2597   if (loop_info->unknown_address_altered)
2598     {
2599       rtx mem = gen_rtx_MEM (BLKmode, const0_rtx);
2600
2601       loop_info->store_mems
2602         = gen_rtx_EXPR_LIST (VOIDmode, mem, loop_info->store_mems);
2603     }
2604   if (loop_info->unknown_constant_address_altered)
2605     {
2606       rtx mem = gen_rtx_MEM (BLKmode, const0_rtx);
2607
2608       RTX_UNCHANGING_P (mem) = 1;
2609       loop_info->store_mems
2610         = gen_rtx_EXPR_LIST (VOIDmode, mem, loop_info->store_mems);
2611     }
2612 }
2613 \f
2614 /* Invalidate all loops containing LABEL.  */
2615
2616 static void
2617 invalidate_loops_containing_label (label)
2618      rtx label;
2619 {
2620   struct loop *loop;
2621   for (loop = uid_loop[INSN_UID (label)]; loop; loop = loop->outer)
2622     loop->invalid = 1;
2623 }
2624
2625 /* Scan the function looking for loops.  Record the start and end of each loop.
2626    Also mark as invalid loops any loops that contain a setjmp or are branched
2627    to from outside the loop.  */
2628
2629 static void
2630 find_and_verify_loops (f, loops)
2631      rtx f;
2632      struct loops *loops;
2633 {
2634   rtx insn;
2635   rtx label;
2636   int num_loops;
2637   struct loop *current_loop;
2638   struct loop *next_loop;
2639   struct loop *loop;
2640
2641   num_loops = loops->num;
2642
2643   compute_luids (f, NULL_RTX, 0);
2644
2645   /* If there are jumps to undefined labels,
2646      treat them as jumps out of any/all loops.
2647      This also avoids writing past end of tables when there are no loops.  */
2648   uid_loop[0] = NULL;
2649
2650   /* Find boundaries of loops, mark which loops are contained within
2651      loops, and invalidate loops that have setjmp.  */
2652
2653   num_loops = 0;
2654   current_loop = NULL;
2655   for (insn = f; insn; insn = NEXT_INSN (insn))
2656     {
2657       if (GET_CODE (insn) == NOTE)
2658         switch (NOTE_LINE_NUMBER (insn))
2659           {
2660           case NOTE_INSN_LOOP_BEG:
2661             next_loop = loops->array + num_loops;
2662             next_loop->num = num_loops;
2663             num_loops++;
2664             next_loop->start = insn;
2665             next_loop->outer = current_loop;
2666             current_loop = next_loop;
2667             break;
2668
2669           case NOTE_INSN_LOOP_CONT:
2670             current_loop->cont = insn;
2671             break;
2672
2673           case NOTE_INSN_LOOP_VTOP:
2674             current_loop->vtop = insn;
2675             break;
2676
2677           case NOTE_INSN_LOOP_END:
2678             if (! current_loop)
2679               abort ();
2680
2681             current_loop->end = insn;
2682             current_loop = current_loop->outer;
2683             break;
2684
2685           default:
2686             break;
2687           }
2688
2689       if (GET_CODE (insn) == CALL_INSN
2690           && find_reg_note (insn, REG_SETJMP, NULL))
2691         {
2692           /* In this case, we must invalidate our current loop and any
2693              enclosing loop.  */
2694           for (loop = current_loop; loop; loop = loop->outer)
2695             {
2696               loop->invalid = 1;
2697               if (loop_dump_stream)
2698                 fprintf (loop_dump_stream,
2699                          "\nLoop at %d ignored due to setjmp.\n",
2700                          INSN_UID (loop->start));
2701             }
2702         }
2703
2704       /* Note that this will mark the NOTE_INSN_LOOP_END note as being in the
2705          enclosing loop, but this doesn't matter.  */
2706       uid_loop[INSN_UID (insn)] = current_loop;
2707     }
2708
2709   /* Any loop containing a label used in an initializer must be invalidated,
2710      because it can be jumped into from anywhere.  */
2711   for (label = forced_labels; label; label = XEXP (label, 1))
2712     invalidate_loops_containing_label (XEXP (label, 0));
2713
2714   /* Any loop containing a label used for an exception handler must be
2715      invalidated, because it can be jumped into from anywhere.  */
2716   for_each_eh_label (invalidate_loops_containing_label);
2717
2718   /* Now scan all insn's in the function.  If any JUMP_INSN branches into a
2719      loop that it is not contained within, that loop is marked invalid.
2720      If any INSN or CALL_INSN uses a label's address, then the loop containing
2721      that label is marked invalid, because it could be jumped into from
2722      anywhere.
2723
2724      Also look for blocks of code ending in an unconditional branch that
2725      exits the loop.  If such a block is surrounded by a conditional
2726      branch around the block, move the block elsewhere (see below) and
2727      invert the jump to point to the code block.  This may eliminate a
2728      label in our loop and will simplify processing by both us and a
2729      possible second cse pass.  */
2730
2731   for (insn = f; insn; insn = NEXT_INSN (insn))
2732     if (INSN_P (insn))
2733       {
2734         struct loop *this_loop = uid_loop[INSN_UID (insn)];
2735
2736         if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
2737           {
2738             rtx note = find_reg_note (insn, REG_LABEL, NULL_RTX);
2739             if (note)
2740               invalidate_loops_containing_label (XEXP (note, 0));
2741           }
2742
2743         if (GET_CODE (insn) != JUMP_INSN)
2744           continue;
2745
2746         mark_loop_jump (PATTERN (insn), this_loop);
2747
2748         /* See if this is an unconditional branch outside the loop.  */
2749         if (this_loop
2750             && (GET_CODE (PATTERN (insn)) == RETURN
2751                 || (any_uncondjump_p (insn)
2752                     && onlyjump_p (insn)
2753                     && (uid_loop[INSN_UID (JUMP_LABEL (insn))]
2754                         != this_loop)))
2755             && get_max_uid () < max_uid_for_loop)
2756           {
2757             rtx p;
2758             rtx our_next = next_real_insn (insn);
2759             rtx last_insn_to_move = NEXT_INSN (insn);
2760             struct loop *dest_loop;
2761             struct loop *outer_loop = NULL;
2762
2763             /* Go backwards until we reach the start of the loop, a label,
2764                or a JUMP_INSN.  */
2765             for (p = PREV_INSN (insn);
2766                  GET_CODE (p) != CODE_LABEL
2767                  && ! (GET_CODE (p) == NOTE
2768                        && NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_BEG)
2769                  && GET_CODE (p) != JUMP_INSN;
2770                  p = PREV_INSN (p))
2771               ;
2772
2773             /* Check for the case where we have a jump to an inner nested
2774                loop, and do not perform the optimization in that case.  */
2775
2776             if (JUMP_LABEL (insn))
2777               {
2778                 dest_loop = uid_loop[INSN_UID (JUMP_LABEL (insn))];
2779                 if (dest_loop)
2780                   {
2781                     for (outer_loop = dest_loop; outer_loop;
2782                          outer_loop = outer_loop->outer)
2783                       if (outer_loop == this_loop)
2784                         break;
2785                   }
2786               }
2787
2788             /* Make sure that the target of P is within the current loop.  */
2789
2790             if (GET_CODE (p) == JUMP_INSN && JUMP_LABEL (p)
2791                 && uid_loop[INSN_UID (JUMP_LABEL (p))] != this_loop)
2792               outer_loop = this_loop;
2793
2794             /* If we stopped on a JUMP_INSN to the next insn after INSN,
2795                we have a block of code to try to move.
2796
2797                We look backward and then forward from the target of INSN
2798                to find a BARRIER at the same loop depth as the target.
2799                If we find such a BARRIER, we make a new label for the start
2800                of the block, invert the jump in P and point it to that label,
2801                and move the block of code to the spot we found.  */
2802
2803             if (! outer_loop
2804                 && GET_CODE (p) == JUMP_INSN
2805                 && JUMP_LABEL (p) != 0
2806                 /* Just ignore jumps to labels that were never emitted.
2807                    These always indicate compilation errors.  */
2808                 && INSN_UID (JUMP_LABEL (p)) != 0
2809                 && any_condjump_p (p) && onlyjump_p (p)
2810                 && next_real_insn (JUMP_LABEL (p)) == our_next
2811                 /* If it's not safe to move the sequence, then we
2812                    mustn't try.  */
2813                 && insns_safe_to_move_p (p, NEXT_INSN (insn),
2814                                          &last_insn_to_move))
2815               {
2816                 rtx target
2817                   = JUMP_LABEL (insn) ? JUMP_LABEL (insn) : get_last_insn ();
2818                 struct loop *target_loop = uid_loop[INSN_UID (target)];
2819                 rtx loc, loc2;
2820                 rtx tmp;
2821
2822                 /* Search for possible garbage past the conditional jumps
2823                    and look for the last barrier.  */
2824                 for (tmp = last_insn_to_move;
2825                      tmp && GET_CODE (tmp) != CODE_LABEL; tmp = NEXT_INSN (tmp))
2826                   if (GET_CODE (tmp) == BARRIER)
2827                     last_insn_to_move = tmp;
2828
2829                 for (loc = target; loc; loc = PREV_INSN (loc))
2830                   if (GET_CODE (loc) == BARRIER
2831                       /* Don't move things inside a tablejump.  */
2832                       && ((loc2 = next_nonnote_insn (loc)) == 0
2833                           || GET_CODE (loc2) != CODE_LABEL
2834                           || (loc2 = next_nonnote_insn (loc2)) == 0
2835                           || GET_CODE (loc2) != JUMP_INSN
2836                           || (GET_CODE (PATTERN (loc2)) != ADDR_VEC
2837                               && GET_CODE (PATTERN (loc2)) != ADDR_DIFF_VEC))
2838                       && uid_loop[INSN_UID (loc)] == target_loop)
2839                     break;
2840
2841                 if (loc == 0)
2842                   for (loc = target; loc; loc = NEXT_INSN (loc))
2843                     if (GET_CODE (loc) == BARRIER
2844                         /* Don't move things inside a tablejump.  */
2845                         && ((loc2 = next_nonnote_insn (loc)) == 0
2846                             || GET_CODE (loc2) != CODE_LABEL
2847                             || (loc2 = next_nonnote_insn (loc2)) == 0
2848                             || GET_CODE (loc2) != JUMP_INSN
2849                             || (GET_CODE (PATTERN (loc2)) != ADDR_VEC
2850                                 && GET_CODE (PATTERN (loc2)) != ADDR_DIFF_VEC))
2851                         && uid_loop[INSN_UID (loc)] == target_loop)
2852                       break;
2853
2854                 if (loc)
2855                   {
2856                     rtx cond_label = JUMP_LABEL (p);
2857                     rtx new_label = get_label_after (p);
2858
2859                     /* Ensure our label doesn't go away.  */
2860                     LABEL_NUSES (cond_label)++;
2861
2862                     /* Verify that uid_loop is large enough and that
2863                        we can invert P.  */
2864                     if (invert_jump (p, new_label, 1))
2865                       {
2866                         rtx q, r;
2867
2868                         /* If no suitable BARRIER was found, create a suitable
2869                            one before TARGET.  Since TARGET is a fall through
2870                            path, we'll need to insert an jump around our block
2871                            and add a BARRIER before TARGET.
2872
2873                            This creates an extra unconditional jump outside
2874                            the loop.  However, the benefits of removing rarely
2875                            executed instructions from inside the loop usually
2876                            outweighs the cost of the extra unconditional jump
2877                            outside the loop.  */
2878                         if (loc == 0)
2879                           {
2880                             rtx temp;
2881
2882                             temp = gen_jump (JUMP_LABEL (insn));
2883                             temp = emit_jump_insn_before (temp, target);
2884                             JUMP_LABEL (temp) = JUMP_LABEL (insn);
2885                             LABEL_NUSES (JUMP_LABEL (insn))++;
2886                             loc = emit_barrier_before (target);
2887                           }
2888
2889                         /* Include the BARRIER after INSN and copy the
2890                            block after LOC.  */
2891                         if (squeeze_notes (&new_label, &last_insn_to_move))
2892                           abort ();
2893                         reorder_insns (new_label, last_insn_to_move, loc);
2894
2895                         /* All those insns are now in TARGET_LOOP.  */
2896                         for (q = new_label;
2897                              q != NEXT_INSN (last_insn_to_move);
2898                              q = NEXT_INSN (q))
2899                           uid_loop[INSN_UID (q)] = target_loop;
2900
2901                         /* The label jumped to by INSN is no longer a loop
2902                            exit.  Unless INSN does not have a label (e.g.,
2903                            it is a RETURN insn), search loop->exit_labels
2904                            to find its label_ref, and remove it.  Also turn
2905                            off LABEL_OUTSIDE_LOOP_P bit.  */
2906                         if (JUMP_LABEL (insn))
2907                           {
2908                             for (q = 0, r = this_loop->exit_labels;
2909                                  r;
2910                                  q = r, r = LABEL_NEXTREF (r))
2911                               if (XEXP (r, 0) == JUMP_LABEL (insn))
2912                                 {
2913                                   LABEL_OUTSIDE_LOOP_P (r) = 0;
2914                                   if (q)
2915                                     LABEL_NEXTREF (q) = LABEL_NEXTREF (r);
2916                                   else
2917                                     this_loop->exit_labels = LABEL_NEXTREF (r);
2918                                   break;
2919                                 }
2920
2921                             for (loop = this_loop; loop && loop != target_loop;
2922                                  loop = loop->outer)
2923                               loop->exit_count--;
2924
2925                             /* If we didn't find it, then something is
2926                                wrong.  */
2927                             if (! r)
2928                               abort ();
2929                           }
2930
2931                         /* P is now a jump outside the loop, so it must be put
2932                            in loop->exit_labels, and marked as such.
2933                            The easiest way to do this is to just call
2934                            mark_loop_jump again for P.  */
2935                         mark_loop_jump (PATTERN (p), this_loop);
2936
2937                         /* If INSN now jumps to the insn after it,
2938                            delete INSN.  */
2939                         if (JUMP_LABEL (insn) != 0
2940                             && (next_real_insn (JUMP_LABEL (insn))
2941                                 == next_real_insn (insn)))
2942                           delete_related_insns (insn);
2943                       }
2944
2945                     /* Continue the loop after where the conditional
2946                        branch used to jump, since the only branch insn
2947                        in the block (if it still remains) is an inter-loop
2948                        branch and hence needs no processing.  */
2949                     insn = NEXT_INSN (cond_label);
2950
2951                     if (--LABEL_NUSES (cond_label) == 0)
2952                       delete_related_insns (cond_label);
2953
2954                     /* This loop will be continued with NEXT_INSN (insn).  */
2955                     insn = PREV_INSN (insn);
2956                   }
2957               }
2958           }
2959       }
2960 }
2961
2962 /* If any label in X jumps to a loop different from LOOP_NUM and any of the
2963    loops it is contained in, mark the target loop invalid.
2964
2965    For speed, we assume that X is part of a pattern of a JUMP_INSN.  */
2966
2967 static void
2968 mark_loop_jump (x, loop)
2969      rtx x;
2970      struct loop *loop;
2971 {
2972   struct loop *dest_loop;
2973   struct loop *outer_loop;
2974   int i;
2975
2976   switch (GET_CODE (x))
2977     {
2978     case PC:
2979     case USE:
2980     case CLOBBER:
2981     case REG:
2982     case MEM:
2983     case CONST_INT:
2984     case CONST_DOUBLE:
2985     case RETURN:
2986       return;
2987
2988     case CONST:
2989       /* There could be a label reference in here.  */
2990       mark_loop_jump (XEXP (x, 0), loop);
2991       return;
2992
2993     case PLUS:
2994     case MINUS:
2995     case MULT:
2996       mark_loop_jump (XEXP (x, 0), loop);
2997       mark_loop_jump (XEXP (x, 1), loop);
2998       return;
2999
3000     case LO_SUM:
3001       /* This may refer to a LABEL_REF or SYMBOL_REF.  */
3002       mark_loop_jump (XEXP (x, 1), loop);
3003       return;
3004
3005     case SIGN_EXTEND:
3006     case ZERO_EXTEND:
3007       mark_loop_jump (XEXP (x, 0), loop);
3008       return;
3009
3010     case LABEL_REF:
3011       dest_loop = uid_loop[INSN_UID (XEXP (x, 0))];
3012
3013       /* Link together all labels that branch outside the loop.  This
3014          is used by final_[bg]iv_value and the loop unrolling code.  Also
3015          mark this LABEL_REF so we know that this branch should predict
3016          false.  */
3017
3018       /* A check to make sure the label is not in an inner nested loop,
3019          since this does not count as a loop exit.  */
3020       if (dest_loop)
3021         {
3022           for (outer_loop = dest_loop; outer_loop;
3023                outer_loop = outer_loop->outer)
3024             if (outer_loop == loop)
3025               break;
3026         }
3027       else
3028         outer_loop = NULL;
3029
3030       if (loop && ! outer_loop)
3031         {
3032           LABEL_OUTSIDE_LOOP_P (x) = 1;
3033           LABEL_NEXTREF (x) = loop->exit_labels;
3034           loop->exit_labels = x;
3035
3036           for (outer_loop = loop;
3037                outer_loop && outer_loop != dest_loop;
3038                outer_loop = outer_loop->outer)
3039             outer_loop->exit_count++;
3040         }
3041
3042       /* If this is inside a loop, but not in the current loop or one enclosed
3043          by it, it invalidates at least one loop.  */
3044
3045       if (! dest_loop)
3046         return;
3047
3048       /* We must invalidate every nested loop containing the target of this
3049          label, except those that also contain the jump insn.  */
3050
3051       for (; dest_loop; dest_loop = dest_loop->outer)
3052         {
3053           /* Stop when we reach a loop that also contains the jump insn.  */
3054           for (outer_loop = loop; outer_loop; outer_loop = outer_loop->outer)
3055             if (dest_loop == outer_loop)
3056               return;
3057
3058           /* If we get here, we know we need to invalidate a loop.  */
3059           if (loop_dump_stream && ! dest_loop->invalid)
3060             fprintf (loop_dump_stream,
3061                      "\nLoop at %d ignored due to multiple entry points.\n",
3062                      INSN_UID (dest_loop->start));
3063
3064           dest_loop->invalid = 1;
3065         }
3066       return;
3067
3068     case SET:
3069       /* If this is not setting pc, ignore.  */
3070       if (SET_DEST (x) == pc_rtx)
3071         mark_loop_jump (SET_SRC (x), loop);
3072       return;
3073
3074     case IF_THEN_ELSE:
3075       mark_loop_jump (XEXP (x, 1), loop);
3076       mark_loop_jump (XEXP (x, 2), loop);
3077       return;
3078
3079     case PARALLEL:
3080     case ADDR_VEC:
3081       for (i = 0; i < XVECLEN (x, 0); i++)
3082         mark_loop_jump (XVECEXP (x, 0, i), loop);
3083       return;
3084
3085     case ADDR_DIFF_VEC:
3086       for (i = 0; i < XVECLEN (x, 1); i++)
3087         mark_loop_jump (XVECEXP (x, 1, i), loop);
3088       return;
3089
3090     default:
3091       /* Strictly speaking this is not a jump into the loop, only a possible
3092          jump out of the loop.  However, we have no way to link the destination
3093          of this jump onto the list of exit labels.  To be safe we mark this
3094          loop and any containing loops as invalid.  */
3095       if (loop)
3096         {
3097           for (outer_loop = loop; outer_loop; outer_loop = outer_loop->outer)
3098             {
3099               if (loop_dump_stream && ! outer_loop->invalid)
3100                 fprintf (loop_dump_stream,
3101                          "\nLoop at %d ignored due to unknown exit jump.\n",
3102                          INSN_UID (outer_loop->start));
3103               outer_loop->invalid = 1;
3104             }
3105         }
3106       return;
3107     }
3108 }
3109 \f
3110 /* Return nonzero if there is a label in the range from
3111    insn INSN to and including the insn whose luid is END
3112    INSN must have an assigned luid (i.e., it must not have
3113    been previously created by loop.c).  */
3114
3115 static int
3116 labels_in_range_p (insn, end)
3117      rtx insn;
3118      int end;
3119 {
3120   while (insn && INSN_LUID (insn) <= end)
3121     {
3122       if (GET_CODE (insn) == CODE_LABEL)
3123         return 1;
3124       insn = NEXT_INSN (insn);
3125     }
3126
3127   return 0;
3128 }
3129
3130 /* Record that a memory reference X is being set.  */
3131
3132 static void
3133 note_addr_stored (x, y, data)
3134      rtx x;
3135      rtx y ATTRIBUTE_UNUSED;
3136      void *data ATTRIBUTE_UNUSED;
3137 {
3138   struct loop_info *loop_info = data;
3139
3140   if (x == 0 || GET_CODE (x) != MEM)
3141     return;
3142
3143   /* Count number of memory writes.
3144      This affects heuristics in strength_reduce.  */
3145   loop_info->num_mem_sets++;
3146
3147   /* BLKmode MEM means all memory is clobbered.  */
3148   if (GET_MODE (x) == BLKmode)
3149     {
3150       if (RTX_UNCHANGING_P (x))
3151         loop_info->unknown_constant_address_altered = 1;
3152       else
3153         loop_info->unknown_address_altered = 1;
3154
3155       return;
3156     }
3157
3158   loop_info->store_mems = gen_rtx_EXPR_LIST (VOIDmode, x,
3159                                              loop_info->store_mems);
3160 }
3161
3162 /* X is a value modified by an INSN that references a biv inside a loop
3163    exit test (ie, X is somehow related to the value of the biv).  If X
3164    is a pseudo that is used more than once, then the biv is (effectively)
3165    used more than once.  DATA is a pointer to a loop_regs structure.  */
3166
3167 static void
3168 note_set_pseudo_multiple_uses (x, y, data)
3169      rtx x;
3170      rtx y ATTRIBUTE_UNUSED;
3171      void *data;
3172 {
3173   struct loop_regs *regs = (struct loop_regs *) data;
3174
3175   if (x == 0)
3176     return;
3177
3178   while (GET_CODE (x) == STRICT_LOW_PART
3179          || GET_CODE (x) == SIGN_EXTRACT
3180          || GET_CODE (x) == ZERO_EXTRACT
3181          || GET_CODE (x) == SUBREG)
3182     x = XEXP (x, 0);
3183
3184   if (GET_CODE (x) != REG || REGNO (x) < FIRST_PSEUDO_REGISTER)
3185     return;
3186
3187   /* If we do not have usage information, or if we know the register
3188      is used more than once, note that fact for check_dbra_loop.  */
3189   if (REGNO (x) >= max_reg_before_loop
3190       || ! regs->array[REGNO (x)].single_usage
3191       || regs->array[REGNO (x)].single_usage == const0_rtx)
3192     regs->multiple_uses = 1;
3193 }
3194 \f
3195 /* Return nonzero if the rtx X is invariant over the current loop.
3196
3197    The value is 2 if we refer to something only conditionally invariant.
3198
3199    A memory ref is invariant if it is not volatile and does not conflict
3200    with anything stored in `loop_info->store_mems'.  */
3201
3202 int
3203 loop_invariant_p (loop, x)
3204      const struct loop *loop;
3205      rtx x;
3206 {
3207   struct loop_info *loop_info = LOOP_INFO (loop);
3208   struct loop_regs *regs = LOOP_REGS (loop);
3209   int i;
3210   enum rtx_code code;
3211   const char *fmt;
3212   int conditional = 0;
3213   rtx mem_list_entry;
3214
3215   if (x == 0)
3216     return 1;
3217   code = GET_CODE (x);
3218   switch (code)
3219     {
3220     case CONST_INT:
3221     case CONST_DOUBLE:
3222     case SYMBOL_REF:
3223     case CONST:
3224       return 1;
3225
3226     case LABEL_REF:
3227       /* A LABEL_REF is normally invariant, however, if we are unrolling
3228          loops, and this label is inside the loop, then it isn't invariant.
3229          This is because each unrolled copy of the loop body will have
3230          a copy of this label.  If this was invariant, then an insn loading
3231          the address of this label into a register might get moved outside
3232          the loop, and then each loop body would end up using the same label.
3233
3234          We don't know the loop bounds here though, so just fail for all
3235          labels.  */
3236       if (flag_unroll_loops)
3237         return 0;
3238       else
3239         return 1;
3240
3241     case PC:
3242     case CC0:
3243     case UNSPEC_VOLATILE:
3244       return 0;
3245
3246     case REG:
3247       /* We used to check RTX_UNCHANGING_P (x) here, but that is invalid
3248          since the reg might be set by initialization within the loop.  */
3249
3250       if ((x == frame_pointer_rtx || x == hard_frame_pointer_rtx
3251            || x == arg_pointer_rtx || x == pic_offset_table_rtx)
3252           && ! current_function_has_nonlocal_goto)
3253         return 1;
3254
3255       if (LOOP_INFO (loop)->has_call
3256           && REGNO (x) < FIRST_PSEUDO_REGISTER && call_used_regs[REGNO (x)])
3257         return 0;
3258
3259       if (regs->array[REGNO (x)].set_in_loop < 0)
3260         return 2;
3261
3262       return regs->array[REGNO (x)].set_in_loop == 0;
3263
3264     case MEM:
3265       /* Volatile memory references must be rejected.  Do this before
3266          checking for read-only items, so that volatile read-only items
3267          will be rejected also.  */
3268       if (MEM_VOLATILE_P (x))
3269         return 0;
3270
3271       /* See if there is any dependence between a store and this load.  */
3272       mem_list_entry = loop_info->store_mems;
3273       while (mem_list_entry)
3274         {
3275           if (true_dependence (XEXP (mem_list_entry, 0), VOIDmode,
3276                                x, rtx_varies_p))
3277             return 0;
3278
3279           mem_list_entry = XEXP (mem_list_entry, 1);
3280         }
3281
3282       /* It's not invalidated by a store in memory
3283          but we must still verify the address is invariant.  */
3284       break;
3285
3286     case ASM_OPERANDS:
3287       /* Don't mess with insns declared volatile.  */
3288       if (MEM_VOLATILE_P (x))
3289         return 0;
3290       break;
3291
3292     default:
3293       break;
3294     }
3295
3296   fmt = GET_RTX_FORMAT (code);
3297   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3298     {
3299       if (fmt[i] == 'e')
3300         {
3301           int tem = loop_invariant_p (loop, XEXP (x, i));
3302           if (tem == 0)
3303             return 0;
3304           if (tem == 2)
3305             conditional = 1;
3306         }
3307       else if (fmt[i] == 'E')
3308         {
3309           int j;
3310           for (j = 0; j < XVECLEN (x, i); j++)
3311             {
3312               int tem = loop_invariant_p (loop, XVECEXP (x, i, j));
3313               if (tem == 0)
3314                 return 0;
3315               if (tem == 2)
3316                 conditional = 1;
3317             }
3318
3319         }
3320     }
3321
3322   return 1 + conditional;
3323 }
3324 \f
3325 /* Return nonzero if all the insns in the loop that set REG
3326    are INSN and the immediately following insns,
3327    and if each of those insns sets REG in an invariant way
3328    (not counting uses of REG in them).
3329
3330    The value is 2 if some of these insns are only conditionally invariant.
3331
3332    We assume that INSN itself is the first set of REG
3333    and that its source is invariant.  */
3334
3335 static int
3336 consec_sets_invariant_p (loop, reg, n_sets, insn)
3337      const struct loop *loop;
3338      int n_sets;
3339      rtx reg, insn;
3340 {
3341   struct loop_regs *regs = LOOP_REGS (loop);
3342   rtx p = insn;
3343   unsigned int regno = REGNO (reg);
3344   rtx temp;
3345   /* Number of sets we have to insist on finding after INSN.  */
3346   int count = n_sets - 1;
3347   int old = regs->array[regno].set_in_loop;
3348   int value = 0;
3349   int this;
3350
3351   /* If N_SETS hit the limit, we can't rely on its value.  */
3352   if (n_sets == 127)
3353     return 0;
3354
3355   regs->array[regno].set_in_loop = 0;
3356
3357   while (count > 0)
3358     {
3359       enum rtx_code code;
3360       rtx set;
3361
3362       p = NEXT_INSN (p);
3363       code = GET_CODE (p);
3364
3365       /* If library call, skip to end of it.  */
3366       if (code == INSN && (temp = find_reg_note (p, REG_LIBCALL, NULL_RTX)))
3367         p = XEXP (temp, 0);
3368
3369       this = 0;
3370       if (code == INSN
3371           && (set = single_set (p))
3372           && GET_CODE (SET_DEST (set)) == REG
3373           && REGNO (SET_DEST (set)) == regno)
3374         {
3375           this = loop_invariant_p (loop, SET_SRC (set));
3376           if (this != 0)
3377             value |= this;
3378           else if ((temp = find_reg_note (p, REG_EQUAL, NULL_RTX)))
3379             {
3380               /* If this is a libcall, then any invariant REG_EQUAL note is OK.
3381                  If this is an ordinary insn, then only CONSTANT_P REG_EQUAL
3382                  notes are OK.  */
3383               this = (CONSTANT_P (XEXP (temp, 0))
3384                       || (find_reg_note (p, REG_RETVAL, NULL_RTX)
3385                           && loop_invariant_p (loop, XEXP (temp, 0))));
3386               if (this != 0)
3387                 value |= this;
3388             }
3389         }
3390       if (this != 0)
3391         count--;
3392       else if (code != NOTE)
3393         {
3394           regs->array[regno].set_in_loop = old;
3395           return 0;
3396         }
3397     }
3398
3399   regs->array[regno].set_in_loop = old;
3400   /* If loop_invariant_p ever returned 2, we return 2.  */
3401   return 1 + (value & 2);
3402 }
3403
3404 #if 0
3405 /* I don't think this condition is sufficient to allow INSN
3406    to be moved, so we no longer test it.  */
3407
3408 /* Return 1 if all insns in the basic block of INSN and following INSN
3409    that set REG are invariant according to TABLE.  */
3410
3411 static int
3412 all_sets_invariant_p (reg, insn, table)
3413      rtx reg, insn;
3414      short *table;
3415 {
3416   rtx p = insn;
3417   int regno = REGNO (reg);
3418
3419   while (1)
3420     {
3421       enum rtx_code code;
3422       p = NEXT_INSN (p);
3423       code = GET_CODE (p);
3424       if (code == CODE_LABEL || code == JUMP_INSN)
3425         return 1;
3426       if (code == INSN && GET_CODE (PATTERN (p)) == SET
3427           && GET_CODE (SET_DEST (PATTERN (p))) == REG
3428           && REGNO (SET_DEST (PATTERN (p))) == regno)
3429         {
3430           if (! loop_invariant_p (loop, SET_SRC (PATTERN (p)), table))
3431             return 0;
3432         }
3433     }
3434 }
3435 #endif /* 0 */
3436 \f
3437 /* Look at all uses (not sets) of registers in X.  For each, if it is
3438    the single use, set USAGE[REGNO] to INSN; if there was a previous use in
3439    a different insn, set USAGE[REGNO] to const0_rtx.  */
3440
3441 static void
3442 find_single_use_in_loop (regs, insn, x)
3443      struct loop_regs *regs;
3444      rtx insn;
3445      rtx x;
3446 {
3447   enum rtx_code code = GET_CODE (x);
3448   const char *fmt = GET_RTX_FORMAT (code);
3449   int i, j;
3450
3451   if (code == REG)
3452     regs->array[REGNO (x)].single_usage
3453       = (regs->array[REGNO (x)].single_usage != 0
3454          && regs->array[REGNO (x)].single_usage != insn)
3455         ? const0_rtx : insn;
3456
3457   else if (code == SET)
3458     {
3459       /* Don't count SET_DEST if it is a REG; otherwise count things
3460          in SET_DEST because if a register is partially modified, it won't
3461          show up as a potential movable so we don't care how USAGE is set
3462          for it.  */
3463       if (GET_CODE (SET_DEST (x)) != REG)
3464         find_single_use_in_loop (regs, insn, SET_DEST (x));
3465       find_single_use_in_loop (regs, insn, SET_SRC (x));
3466     }
3467   else
3468     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3469       {
3470         if (fmt[i] == 'e' && XEXP (x, i) != 0)
3471           find_single_use_in_loop (regs, insn, XEXP (x, i));
3472         else if (fmt[i] == 'E')
3473           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3474             find_single_use_in_loop (regs, insn, XVECEXP (x, i, j));
3475       }
3476 }
3477 \f
3478 /* Count and record any set in X which is contained in INSN.  Update
3479    REGS->array[I].MAY_NOT_OPTIMIZE and LAST_SET for any register I set
3480    in X.  */
3481
3482 static void
3483 count_one_set (regs, insn, x, last_set)
3484      struct loop_regs *regs;
3485      rtx insn, x;
3486      rtx *last_set;
3487 {
3488   if (GET_CODE (x) == CLOBBER && GET_CODE (XEXP (x, 0)) == REG)
3489     /* Don't move a reg that has an explicit clobber.
3490        It's not worth the pain to try to do it correctly.  */
3491     regs->array[REGNO (XEXP (x, 0))].may_not_optimize = 1;
3492
3493   if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
3494     {
3495       rtx dest = SET_DEST (x);
3496       while (GET_CODE (dest) == SUBREG
3497              || GET_CODE (dest) == ZERO_EXTRACT
3498              || GET_CODE (dest) == SIGN_EXTRACT
3499              || GET_CODE (dest) == STRICT_LOW_PART)
3500         dest = XEXP (dest, 0);
3501       if (GET_CODE (dest) == REG)
3502         {
3503           int i;
3504           int regno = REGNO (dest);
3505           for (i = 0; i < LOOP_REGNO_NREGS (regno, dest); i++)
3506             {
3507               /* If this is the first setting of this reg
3508                  in current basic block, and it was set before,
3509                  it must be set in two basic blocks, so it cannot
3510                  be moved out of the loop.  */
3511               if (regs->array[regno].set_in_loop > 0
3512                   && last_set == 0)
3513                 regs->array[regno+i].may_not_optimize = 1;
3514               /* If this is not first setting in current basic block,
3515                  see if reg was used in between previous one and this.
3516                  If so, neither one can be moved.  */
3517               if (last_set[regno] != 0
3518                   && reg_used_between_p (dest, last_set[regno], insn))
3519                 regs->array[regno+i].may_not_optimize = 1;
3520               if (regs->array[regno+i].set_in_loop < 127)
3521                 ++regs->array[regno+i].set_in_loop;
3522               last_set[regno+i] = insn;
3523             }
3524         }
3525     }
3526 }
3527 \f
3528 /* Given a loop that is bounded by LOOP->START and LOOP->END and that
3529    is entered at LOOP->SCAN_START, return 1 if the register set in SET
3530    contained in insn INSN is used by any insn that precedes INSN in
3531    cyclic order starting from the loop entry point.
3532
3533    We don't want to use INSN_LUID here because if we restrict INSN to those
3534    that have a valid INSN_LUID, it means we cannot move an invariant out
3535    from an inner loop past two loops.  */
3536
3537 static int
3538 loop_reg_used_before_p (loop, set, insn)
3539      const struct loop *loop;
3540      rtx set, insn;
3541 {
3542   rtx reg = SET_DEST (set);
3543   rtx p;
3544
3545   /* Scan forward checking for register usage.  If we hit INSN, we
3546      are done.  Otherwise, if we hit LOOP->END, wrap around to LOOP->START.  */
3547   for (p = loop->scan_start; p != insn; p = NEXT_INSN (p))
3548     {
3549       if (INSN_P (p) && reg_overlap_mentioned_p (reg, PATTERN (p)))
3550         return 1;
3551
3552       if (p == loop->end)
3553         p = loop->start;
3554     }
3555
3556   return 0;
3557 }
3558 \f
3559
3560 /* Information we collect about arrays that we might want to prefetch.  */
3561 struct prefetch_info
3562 {
3563   struct iv_class *class;       /* Class this prefetch is based on.  */
3564   struct induction *giv;        /* GIV this prefetch is based on.  */
3565   rtx base_address;             /* Start prefetching from this address plus
3566                                    index.  */
3567   HOST_WIDE_INT index;
3568   HOST_WIDE_INT stride;         /* Prefetch stride in bytes in each
3569                                    iteration.  */
3570   unsigned int bytes_accesed;   /* Sum of sizes of all acceses to this
3571                                    prefetch area in one iteration.  */
3572   unsigned int total_bytes;     /* Total bytes loop will access in this block.
3573                                    This is set only for loops with known
3574                                    iteration counts and is 0xffffffff
3575                                    otherwise.  */
3576   unsigned int write : 1;       /* 1 for read/write prefetches.  */
3577   unsigned int prefetch_in_loop : 1;
3578                                 /* 1 for those chosen for prefetching.  */
3579   unsigned int prefetch_before_loop : 1;
3580                                 /* 1 for those chosen for prefetching.  */
3581 };
3582
3583 /* Data used by check_store function.  */
3584 struct check_store_data
3585 {
3586   rtx mem_address;
3587   int mem_write;
3588 };
3589
3590 static void check_store PARAMS ((rtx, rtx, void *));
3591 static void emit_prefetch_instructions PARAMS ((struct loop *));
3592 static int rtx_equal_for_prefetch_p PARAMS ((rtx, rtx));
3593
3594 /* Set mem_write when mem_address is found.  Used as callback to
3595    note_stores.  */
3596 static void
3597 check_store (x, pat, data)
3598      rtx x, pat ATTRIBUTE_UNUSED;
3599      void *data;
3600 {
3601   struct check_store_data *d = (struct check_store_data *) data;
3602
3603   if ((GET_CODE (x) == MEM) && rtx_equal_p (d->mem_address, XEXP (x, 0)))
3604     d->mem_write = 1;
3605 }
3606 \f
3607 /* Like rtx_equal_p, but attempts to swap commutative operands.  This is
3608    important to get some addresses combined.  Later more sophisticated
3609    transformations can be added when necesary.
3610
3611    ??? Same trick with swapping operand is done at several other places.
3612    It can be nice to develop some common way to handle this.  */
3613
3614 static int
3615 rtx_equal_for_prefetch_p (x, y)
3616      rtx x, y;
3617 {
3618   int i;
3619   int j;
3620   enum rtx_code code = GET_CODE (x);
3621   const char *fmt;
3622
3623   if (x == y)
3624     return 1;
3625   if (code != GET_CODE (y))
3626     return 0;
3627
3628   code = GET_CODE (x);
3629
3630   if (GET_RTX_CLASS (code) == 'c')
3631     {
3632       return ((rtx_equal_for_prefetch_p (XEXP (x, 0), XEXP (y, 0))
3633                && rtx_equal_for_prefetch_p (XEXP (x, 1), XEXP (y, 1)))
3634               || (rtx_equal_for_prefetch_p (XEXP (x, 0), XEXP (y, 1))
3635                   && rtx_equal_for_prefetch_p (XEXP (x, 1), XEXP (y, 0))));
3636     }
3637   /* Compare the elements.  If any pair of corresponding elements fails to
3638      match, return 0 for the whole thing.  */
3639
3640   fmt = GET_RTX_FORMAT (code);
3641   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3642     {
3643       switch (fmt[i])
3644         {
3645         case 'w':
3646           if (XWINT (x, i) != XWINT (y, i))
3647             return 0;
3648           break;
3649
3650         case 'i':
3651           if (XINT (x, i) != XINT (y, i))
3652             return 0;
3653           break;
3654
3655         case 'E':
3656           /* Two vectors must have the same length.  */
3657           if (XVECLEN (x, i) != XVECLEN (y, i))
3658             return 0;
3659
3660           /* And the corresponding elements must match.  */
3661           for (j = 0; j < XVECLEN (x, i); j++)
3662             if (rtx_equal_for_prefetch_p (XVECEXP (x, i, j),
3663                                           XVECEXP (y, i, j)) == 0)
3664               return 0;
3665           break;
3666
3667         case 'e':
3668           if (rtx_equal_for_prefetch_p (XEXP (x, i), XEXP (y, i)) == 0)
3669             return 0;
3670           break;
3671
3672         case 's':
3673           if (strcmp (XSTR (x, i), XSTR (y, i)))
3674             return 0;
3675           break;
3676
3677         case 'u':
3678           /* These are just backpointers, so they don't matter.  */
3679           break;
3680
3681         case '0':
3682           break;
3683
3684           /* It is believed that rtx's at this level will never
3685              contain anything but integers and other rtx's,
3686              except for within LABEL_REFs and SYMBOL_REFs.  */
3687         default:
3688           abort ();
3689         }
3690     }
3691   return 1;
3692 }
3693 \f
3694 /* Remove constant addition value from the expression X (when present)
3695    and return it.  */
3696
3697 static HOST_WIDE_INT
3698 remove_constant_addition (x)
3699      rtx *x;
3700 {
3701   HOST_WIDE_INT addval = 0;
3702   rtx exp = *x;
3703
3704   /* Avoid clobbering a shared CONST expression.  */
3705   if (GET_CODE (exp) == CONST)
3706     {
3707       if (GET_CODE (XEXP (exp, 0)) == PLUS
3708           && GET_CODE (XEXP (XEXP (exp, 0), 0)) == SYMBOL_REF
3709           && GET_CODE (XEXP (XEXP (exp, 0), 1)) == CONST_INT)
3710         {
3711           *x = XEXP (XEXP (exp, 0), 0);
3712           return INTVAL (XEXP (XEXP (exp, 0), 1));
3713         }
3714       return 0;
3715     }
3716
3717   if (GET_CODE (exp) == CONST_INT)
3718     {
3719       addval = INTVAL (exp);
3720       *x = const0_rtx;
3721     }
3722
3723   /* For plus expression recurse on ourself.  */
3724   else if (GET_CODE (exp) == PLUS)
3725     {
3726       addval += remove_constant_addition (&XEXP (exp, 0));
3727       addval += remove_constant_addition (&XEXP (exp, 1));
3728
3729       /* In case our parameter was constant, remove extra zero from the
3730          expression.  */
3731       if (XEXP (exp, 0) == const0_rtx)
3732         *x = XEXP (exp, 1);
3733       else if (XEXP (exp, 1) == const0_rtx)
3734         *x = XEXP (exp, 0);
3735     }
3736
3737   return addval;
3738 }
3739
3740 /* Attempt to identify accesses to arrays that are most likely to cause cache
3741    misses, and emit prefetch instructions a few prefetch blocks forward.
3742
3743    To detect the arrays we use the GIV information that was collected by the
3744    strength reduction pass.
3745
3746    The prefetch instructions are generated after the GIV information is done
3747    and before the strength reduction process. The new GIVs are injected into
3748    the strength reduction tables, so the prefetch addresses are optimized as
3749    well.
3750
3751    GIVs are split into base address, stride, and constant addition values.
3752    GIVs with the same address, stride and close addition values are combined
3753    into a single prefetch.  Also writes to GIVs are detected, so that prefetch
3754    for write instructions can be used for the block we write to, on machines
3755    that support write prefetches.
3756
3757    Several heuristics are used to determine when to prefetch.  They are
3758    controlled by defined symbols that can be overridden for each target.  */
3759
3760 static void
3761 emit_prefetch_instructions (loop)
3762      struct loop *loop;
3763 {
3764   int num_prefetches = 0;
3765   int num_real_prefetches = 0;
3766   int num_real_write_prefetches = 0;
3767   int ahead;
3768   int i;
3769   struct iv_class *bl;
3770   struct induction *iv;
3771   struct prefetch_info info[MAX_PREFETCHES];
3772   struct loop_ivs *ivs = LOOP_IVS (loop);
3773
3774   if (!HAVE_prefetch)
3775     return;
3776
3777   /* Consider only loops w/o calls.  When a call is done, the loop is probably
3778      slow enough to read the memory.  */
3779   if (PREFETCH_NO_CALL && LOOP_INFO (loop)->has_call)
3780     {
3781       if (loop_dump_stream)
3782         fprintf (loop_dump_stream, "Prefetch: ignoring loop - has call.\n");
3783
3784       return;
3785     }
3786
3787   if (PREFETCH_NO_LOW_LOOPCNT
3788       && LOOP_INFO (loop)->n_iterations
3789       && LOOP_INFO (loop)->n_iterations <= PREFETCH_LOW_LOOPCNT)
3790     {
3791       if (loop_dump_stream)
3792         fprintf (loop_dump_stream,
3793                  "Prefetch: ignoring loop - not enought iterations.\n");
3794       return;
3795     }
3796
3797   /* Search all induction variables and pick those interesting for the prefetch
3798      machinery.  */
3799   for (bl = ivs->list; bl; bl = bl->next)
3800     {
3801       struct induction *biv = bl->biv, *biv1;
3802       int basestride = 0;
3803
3804       biv1 = biv;
3805
3806       /* Expect all BIVs to be executed in each iteration.  This makes our
3807          analysis more conservative.  */
3808       while (biv1)
3809         {
3810           /* Discard non-constant additions that we can't handle well yet, and
3811              BIVs that are executed multiple times; such BIVs ought to be
3812              handled in the nested loop.  We accept not_every_iteration BIVs,
3813              since these only result in larger strides and make our
3814              heuristics more conservative.
3815              ??? What does the last sentence mean?  */
3816           if (GET_CODE (biv->add_val) != CONST_INT)
3817             {
3818               if (loop_dump_stream)
3819                 {
3820                   fprintf (loop_dump_stream,
3821                            "Prefetch: biv %i ignored: non-constant addition at insn %i:",
3822                            REGNO (biv->src_reg), INSN_UID (biv->insn));
3823                   print_rtl (loop_dump_stream, biv->add_val);
3824                   fprintf (loop_dump_stream, "\n");
3825                 }
3826               break;
3827             }
3828
3829           if (biv->maybe_multiple)
3830             {
3831               if (loop_dump_stream)
3832                 {
3833                   fprintf (loop_dump_stream,
3834                            "Prefetch: biv %i ignored: maybe_multiple at insn %i:",
3835                            REGNO (biv->src_reg), INSN_UID (biv->insn));
3836                   print_rtl (loop_dump_stream, biv->add_val);
3837                   fprintf (loop_dump_stream, "\n");
3838                 }
3839               break;
3840             }
3841
3842           basestride += INTVAL (biv1->add_val);
3843           biv1 = biv1->next_iv;
3844         }
3845
3846       if (biv1 || !basestride)
3847         continue;
3848
3849       for (iv = bl->giv; iv; iv = iv->next_iv)
3850         {
3851           rtx address;
3852           rtx temp;
3853           HOST_WIDE_INT index = 0;
3854           int add = 1;
3855           HOST_WIDE_INT stride;
3856           struct check_store_data d;
3857           int size = GET_MODE_SIZE (GET_MODE (iv));
3858
3859           /* There are several reasons why an induction variable is not
3860              interesting to us.  */
3861           if (iv->giv_type != DEST_ADDR
3862               /* We are interested only in constant stride memory references
3863                  in order to be able to compute density easily.  */
3864               || GET_CODE (iv->mult_val) != CONST_INT
3865               /* Don't handle reversed order prefetches, since they are usually
3866                  ineffective.  Later we may be able to reverse such BIVs.  */
3867               || (PREFETCH_NO_REVERSE_ORDER
3868                   && (stride = INTVAL (iv->mult_val) * basestride) < 0)
3869               /* Prefetching of accesses with such an extreme stride is probably
3870                  not worthwhile, either.  */
3871               || (PREFETCH_NO_EXTREME_STRIDE
3872                   && stride > PREFETCH_EXTREME_STRIDE)
3873               /* Ignore GIVs with varying add values; we can't predict the
3874                  value for the next iteration.  */
3875               || !loop_invariant_p (loop, iv->add_val)
3876               /* Ignore GIVs in the nested loops; they ought to have been
3877                  handled already.  */
3878               || iv->maybe_multiple)
3879             {
3880               if (loop_dump_stream)
3881                 fprintf (loop_dump_stream, "Prefetch: Ignoring giv at %i\n",
3882                          INSN_UID (iv->insn));
3883               continue;
3884             }
3885
3886           /* Determine the pointer to the basic array we are examining.  It is
3887              the sum of the BIV's initial value and the GIV's add_val.  */
3888           index = 0;
3889
3890           address = copy_rtx (iv->add_val);
3891           temp = copy_rtx (bl->initial_value);
3892
3893           address = simplify_gen_binary (PLUS, Pmode, temp, address);
3894           index = remove_constant_addition (&address);
3895
3896           index += size;
3897           d.mem_write = 0;
3898           d.mem_address = *iv->location;
3899
3900           /* When the GIV is not always executed, we might be better off by
3901              not dirtying the cache pages.  */
3902           if (PREFETCH_NOT_ALWAYS || iv->always_executed)
3903             note_stores (PATTERN (iv->insn), check_store, &d);
3904
3905           /* Attempt to find another prefetch to the same array and see if we
3906              can merge this one.  */
3907           for (i = 0; i < num_prefetches; i++)
3908             if (rtx_equal_for_prefetch_p (address, info[i].base_address)
3909                 && stride == info[i].stride)
3910               {
3911                 /* In case both access same array (same location
3912                    just with small difference in constant indexes), merge
3913                    the prefetches.  Just do the later and the earlier will
3914                    get prefetched from previous iteration.
3915                    4096 is artificial threshold.  It should not be too small,
3916                    but also not bigger than small portion of memory usually
3917                    traversed by single loop.  */
3918                 if (index >= info[i].index && index - info[i].index < 4096)
3919                   {
3920                     info[i].write |= d.mem_write;
3921                     info[i].bytes_accesed += size;
3922                     info[i].index = index;
3923                     info[i].giv = iv;
3924                     info[i].class = bl;
3925                     info[num_prefetches].base_address = address;
3926                     add = 0;
3927                     break;
3928                   }
3929
3930                 if (index < info[i].index && info[i].index - index < 4096)
3931                   {
3932                     info[i].write |= d.mem_write;
3933                     info[i].bytes_accesed += size;
3934                     add = 0;
3935                     break;
3936                   }
3937               }
3938
3939           /* Merging failed.  */
3940           if (add)
3941             {
3942               info[num_prefetches].giv = iv;
3943               info[num_prefetches].class = bl;
3944               info[num_prefetches].index = index;
3945               info[num_prefetches].stride = stride;
3946               info[num_prefetches].base_address = address;
3947               info[num_prefetches].write = d.mem_write;
3948               info[num_prefetches].bytes_accesed = size;
3949               num_prefetches++;
3950               if (num_prefetches >= MAX_PREFETCHES)
3951                 {
3952                   if (loop_dump_stream)
3953                     fprintf (loop_dump_stream,
3954                              "Maximal number of prefetches exceeded.\n");
3955                   return;
3956                 }
3957             }
3958         }
3959     }
3960
3961   for (i = 0; i < num_prefetches; i++)
3962     {
3963       /* Attempt to calculate the number of bytes fetched by the loop.
3964          Avoid overflow.  */
3965       if (LOOP_INFO (loop)->n_iterations
3966           && ((unsigned HOST_WIDE_INT) (0xffffffff / info[i].stride)
3967               >= LOOP_INFO (loop)->n_iterations))
3968         info[i].total_bytes = info[i].stride * LOOP_INFO (loop)->n_iterations;
3969       else
3970         info[i].total_bytes = 0xffffffff;
3971
3972       /* Prefetch is worthwhile only when the loads/stores are dense.  */
3973       if (PREFETCH_ONLY_DENSE_MEM
3974           && info[i].bytes_accesed * 256 / info[i].stride > PREFETCH_DENSE_MEM
3975           && (info[i].total_bytes / PREFETCH_BLOCK
3976               >= PREFETCH_BLOCKS_BEFORE_LOOP_MIN))
3977         {
3978           info[i].prefetch_before_loop = 1;
3979           info[i].prefetch_in_loop
3980             = (info[i].total_bytes / PREFETCH_BLOCK
3981                > PREFETCH_BLOCKS_BEFORE_LOOP_MAX);
3982         }
3983       else
3984         info[i].prefetch_in_loop = 0, info[i].prefetch_before_loop = 0;
3985
3986       if (info[i].prefetch_in_loop)
3987         {
3988           num_real_prefetches += ((info[i].stride + PREFETCH_BLOCK - 1)
3989                                   / PREFETCH_BLOCK);
3990           if (info[i].write)
3991             num_real_write_prefetches
3992               += (info[i].stride + PREFETCH_BLOCK - 1) / PREFETCH_BLOCK;
3993         }
3994     }
3995
3996   if (loop_dump_stream)
3997     {
3998       for (i = 0; i < num_prefetches; i++)
3999         {
4000           fprintf (loop_dump_stream, "Prefetch insn %i address: ",
4001                    INSN_UID (info[i].giv->insn));
4002           print_rtl (loop_dump_stream, info[i].base_address);
4003           fprintf (loop_dump_stream, " Index: ");
4004           fprintf (loop_dump_stream, HOST_WIDE_INT_PRINT_DEC, info[i].index);
4005           fprintf (loop_dump_stream, " stride: ");
4006           fprintf (loop_dump_stream, HOST_WIDE_INT_PRINT_DEC, info[i].stride);
4007           fprintf (loop_dump_stream,
4008                    " density: %i%% total_bytes: %u%sin loop: %s before: %s\n",
4009                    (int) (info[i].bytes_accesed * 100 / info[i].stride),
4010                    info[i].total_bytes,
4011                    info[i].write ? " read/write " : " read only ",
4012                    info[i].prefetch_in_loop ? "yes" : "no",
4013                    info[i].prefetch_before_loop ? "yes" : "no");
4014         }
4015
4016       fprintf (loop_dump_stream, "Real prefetches needed: %i (write: %i)\n",
4017                num_real_prefetches, num_real_write_prefetches);
4018     }
4019
4020   if (!num_real_prefetches)
4021     return;
4022
4023   ahead = SIMULTANEOUS_PREFETCHES / num_real_prefetches;
4024
4025   if (!ahead)
4026     return;
4027
4028   for (i = 0; i < num_prefetches; i++)
4029     {
4030       if (info[i].prefetch_in_loop)
4031         {
4032           int y;
4033
4034           for (y = 0; y < ((info[i].stride + PREFETCH_BLOCK - 1)
4035                            / PREFETCH_BLOCK); y++)
4036             {
4037               rtx loc = copy_rtx (*info[i].giv->location);
4038               rtx insn;
4039               int bytes_ahead = PREFETCH_BLOCK * (ahead + y);
4040               rtx before_insn = info[i].giv->insn;
4041               rtx prev_insn = PREV_INSN (info[i].giv->insn);
4042               rtx seq;
4043
4044               /* We can save some effort by offsetting the address on
4045                  architectures with offsettable memory references.  */
4046               if (offsettable_address_p (0, VOIDmode, loc))
4047                 loc = plus_constant (loc, bytes_ahead);
4048               else
4049                 {
4050                   rtx reg = gen_reg_rtx (Pmode);
4051                   loop_iv_add_mult_emit_before (loop, loc, const1_rtx,
4052                                                 GEN_INT (bytes_ahead), reg,
4053                                                 0, before_insn);
4054                   loc = reg;
4055                 }
4056
4057               start_sequence ();
4058               /* Make sure the address operand is valid for prefetch.  */
4059               if (! (*insn_data[(int)CODE_FOR_prefetch].operand[0].predicate)
4060                     (loc,
4061                      insn_data[(int)CODE_FOR_prefetch].operand[0].mode))
4062                 loc = force_reg (Pmode, loc);
4063               emit_insn (gen_prefetch (loc, GEN_INT (info[i].write),
4064                                        GEN_INT (3)));
4065               seq = gen_sequence ();
4066               end_sequence ();
4067               emit_insn_before (seq, before_insn);
4068
4069               /* Check all insns emitted and record the new GIV
4070                  information.  */
4071               insn = NEXT_INSN (prev_insn);
4072               while (insn != before_insn)
4073                 {
4074                   insn = check_insn_for_givs (loop, insn,
4075                                               info[i].giv->always_executed,
4076                                               info[i].giv->maybe_multiple);
4077                   insn = NEXT_INSN (insn);
4078                 }
4079             }
4080         }
4081
4082       if (info[i].prefetch_before_loop)
4083         {
4084           int y;
4085
4086           /* Emit INSNs before the loop to fetch the first cache lines.  */
4087           for (y = 0;
4088                (!info[i].prefetch_in_loop || y < ahead)
4089                && y * PREFETCH_BLOCK < (int) info[i].total_bytes; y ++)
4090             {
4091               rtx reg = gen_reg_rtx (Pmode);
4092               rtx loop_start = loop->start;
4093               rtx add_val = simplify_gen_binary (PLUS, Pmode,
4094                                                  info[i].giv->add_val,
4095                                                  GEN_INT (y * PREFETCH_BLOCK));
4096
4097               loop_iv_add_mult_emit_before (loop, info[i].class->initial_value,
4098                                             info[i].giv->mult_val,
4099                                             add_val, reg, 0, loop_start);
4100               emit_insn_before (gen_prefetch (reg, GEN_INT (info[i].write),
4101                                               GEN_INT (3)),
4102                                 loop_start);
4103             }
4104         }
4105     }
4106
4107   return;
4108 }
4109 \f
4110 /* A "basic induction variable" or biv is a pseudo reg that is set
4111    (within this loop) only by incrementing or decrementing it.  */
4112 /* A "general induction variable" or giv is a pseudo reg whose
4113    value is a linear function of a biv.  */
4114
4115 /* Bivs are recognized by `basic_induction_var';
4116    Givs by `general_induction_var'.  */
4117
4118 /* Communication with routines called via `note_stores'.  */
4119
4120 static rtx note_insn;
4121
4122 /* Dummy register to have non-zero DEST_REG for DEST_ADDR type givs.  */
4123
4124 static rtx addr_placeholder;
4125
4126 /* ??? Unfinished optimizations, and possible future optimizations,
4127    for the strength reduction code.  */
4128
4129 /* ??? The interaction of biv elimination, and recognition of 'constant'
4130    bivs, may cause problems.  */
4131
4132 /* ??? Add heuristics so that DEST_ADDR strength reduction does not cause
4133    performance problems.
4134
4135    Perhaps don't eliminate things that can be combined with an addressing
4136    mode.  Find all givs that have the same biv, mult_val, and add_val;
4137    then for each giv, check to see if its only use dies in a following
4138    memory address.  If so, generate a new memory address and check to see
4139    if it is valid.   If it is valid, then store the modified memory address,
4140    otherwise, mark the giv as not done so that it will get its own iv.  */
4141
4142 /* ??? Could try to optimize branches when it is known that a biv is always
4143    positive.  */
4144
4145 /* ??? When replace a biv in a compare insn, we should replace with closest
4146    giv so that an optimized branch can still be recognized by the combiner,
4147    e.g. the VAX acb insn.  */
4148
4149 /* ??? Many of the checks involving uid_luid could be simplified if regscan
4150    was rerun in loop_optimize whenever a register was added or moved.
4151    Also, some of the optimizations could be a little less conservative.  */
4152 \f
4153 /* Scan the loop body and call FNCALL for each insn.  In the addition to the
4154    LOOP and INSN parameters pass MAYBE_MULTIPLE and NOT_EVERY_ITERATION to the
4155    callback.
4156
4157    NOT_EVERY_ITERATION if current insn is not executed at least once for every
4158    loop iteration except for the last one.
4159
4160    MAYBE_MULTIPLE is 1 if current insn may be executed more than once for every
4161    loop iteration.
4162  */
4163 void
4164 for_each_insn_in_loop (loop, fncall)
4165      struct loop *loop;
4166      loop_insn_callback fncall;
4167 {
4168   /* This is 1 if current insn is not executed at least once for every loop
4169      iteration.  */
4170   int not_every_iteration = 0;
4171   int maybe_multiple = 0;
4172   int past_loop_latch = 0;
4173   int loop_depth = 0;
4174   rtx p;
4175
4176   /* If loop_scan_start points to the loop exit test, we have to be wary of
4177      subversive use of gotos inside expression statements.  */
4178   if (prev_nonnote_insn (loop->scan_start) != prev_nonnote_insn (loop->start))
4179     maybe_multiple = back_branch_in_range_p (loop, loop->scan_start);
4180
4181   /* Scan through loop to find all possible bivs.  */
4182
4183   for (p = next_insn_in_loop (loop, loop->scan_start);
4184        p != NULL_RTX;
4185        p = next_insn_in_loop (loop, p))
4186     {
4187       p = fncall (loop, p, not_every_iteration, maybe_multiple);
4188
4189       /* Past CODE_LABEL, we get to insns that may be executed multiple
4190          times.  The only way we can be sure that they can't is if every
4191          jump insn between here and the end of the loop either
4192          returns, exits the loop, is a jump to a location that is still
4193          behind the label, or is a jump to the loop start.  */
4194
4195       if (GET_CODE (p) == CODE_LABEL)
4196         {
4197           rtx insn = p;
4198
4199           maybe_multiple = 0;
4200
4201           while (1)
4202             {
4203               insn = NEXT_INSN (insn);
4204               if (insn == loop->scan_start)
4205                 break;
4206               if (insn == loop->end)
4207                 {
4208                   if (loop->top != 0)
4209                     insn = loop->top;
4210                   else
4211                     break;
4212                   if (insn == loop->scan_start)
4213                     break;
4214                 }
4215
4216               if (GET_CODE (insn) == JUMP_INSN
4217                   && GET_CODE (PATTERN (insn)) != RETURN
4218                   && (!any_condjump_p (insn)
4219                       || (JUMP_LABEL (insn) != 0
4220                           && JUMP_LABEL (insn) != loop->scan_start
4221                           && !loop_insn_first_p (p, JUMP_LABEL (insn)))))
4222                 {
4223                   maybe_multiple = 1;
4224                   break;
4225                 }
4226             }
4227         }
4228
4229       /* Past a jump, we get to insns for which we can't count
4230          on whether they will be executed during each iteration.  */
4231       /* This code appears twice in strength_reduce.  There is also similar
4232          code in scan_loop.  */
4233       if (GET_CODE (p) == JUMP_INSN
4234       /* If we enter the loop in the middle, and scan around to the
4235          beginning, don't set not_every_iteration for that.
4236          This can be any kind of jump, since we want to know if insns
4237          will be executed if the loop is executed.  */
4238           && !(JUMP_LABEL (p) == loop->top
4239              && ((NEXT_INSN (NEXT_INSN (p)) == loop->end
4240                   && any_uncondjump_p (p))
4241                  || (NEXT_INSN (p) == loop->end && any_condjump_p (p)))))
4242         {
4243           rtx label = 0;
4244
4245           /* If this is a jump outside the loop, then it also doesn't
4246              matter.  Check to see if the target of this branch is on the
4247              loop->exits_labels list.  */
4248
4249           for (label = loop->exit_labels; label; label = LABEL_NEXTREF (label))
4250             if (XEXP (label, 0) == JUMP_LABEL (p))
4251               break;
4252
4253           if (!label)
4254             not_every_iteration = 1;
4255         }
4256
4257       else if (GET_CODE (p) == NOTE)
4258         {
4259           /* At the virtual top of a converted loop, insns are again known to
4260              be executed each iteration: logically, the loop begins here
4261              even though the exit code has been duplicated.
4262
4263              Insns are also again known to be executed each iteration at
4264              the LOOP_CONT note.  */
4265           if ((NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_VTOP
4266                || NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_CONT)
4267               && loop_depth == 0)
4268             not_every_iteration = 0;
4269           else if (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_BEG)
4270             loop_depth++;
4271           else if (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_END)
4272             loop_depth--;
4273         }
4274
4275       /* Note if we pass a loop latch.  If we do, then we can not clear
4276          NOT_EVERY_ITERATION below when we pass the last CODE_LABEL in
4277          a loop since a jump before the last CODE_LABEL may have started
4278          a new loop iteration.
4279
4280          Note that LOOP_TOP is only set for rotated loops and we need
4281          this check for all loops, so compare against the CODE_LABEL
4282          which immediately follows LOOP_START.  */
4283       if (GET_CODE (p) == JUMP_INSN
4284           && JUMP_LABEL (p) == NEXT_INSN (loop->start))
4285         past_loop_latch = 1;
4286
4287       /* Unlike in the code motion pass where MAYBE_NEVER indicates that
4288          an insn may never be executed, NOT_EVERY_ITERATION indicates whether
4289          or not an insn is known to be executed each iteration of the
4290          loop, whether or not any iterations are known to occur.
4291
4292          Therefore, if we have just passed a label and have no more labels
4293          between here and the test insn of the loop, and we have not passed
4294          a jump to the top of the loop, then we know these insns will be
4295          executed each iteration.  */
4296
4297       if (not_every_iteration
4298           && !past_loop_latch
4299           && GET_CODE (p) == CODE_LABEL
4300           && no_labels_between_p (p, loop->end)
4301           && loop_insn_first_p (p, loop->cont))
4302         not_every_iteration = 0;
4303     }
4304 }
4305 \f
4306 static void
4307 loop_bivs_find (loop)
4308      struct loop *loop;
4309 {
4310   struct loop_regs *regs = LOOP_REGS (loop);
4311   struct loop_ivs *ivs = LOOP_IVS (loop);
4312   /* Temporary list pointers for traversing ivs->list.  */
4313   struct iv_class *bl, **backbl;
4314
4315   ivs->list = 0;
4316
4317   for_each_insn_in_loop (loop, check_insn_for_bivs);
4318
4319   /* Scan ivs->list to remove all regs that proved not to be bivs.
4320      Make a sanity check against regs->n_times_set.  */
4321   for (backbl = &ivs->list, bl = *backbl; bl; bl = bl->next)
4322     {
4323       if (REG_IV_TYPE (ivs, bl->regno) != BASIC_INDUCT
4324           /* Above happens if register modified by subreg, etc.  */
4325           /* Make sure it is not recognized as a basic induction var: */
4326           || regs->array[bl->regno].n_times_set != bl->biv_count
4327           /* If never incremented, it is invariant that we decided not to
4328              move.  So leave it alone.  */
4329           || ! bl->incremented)
4330         {
4331           if (loop_dump_stream)
4332             fprintf (loop_dump_stream, "Biv %d: discarded, %s\n",
4333                      bl->regno,
4334                      (REG_IV_TYPE (ivs, bl->regno) != BASIC_INDUCT
4335                       ? "not induction variable"
4336                       : (! bl->incremented ? "never incremented"
4337                          : "count error")));
4338
4339           REG_IV_TYPE (ivs, bl->regno) = NOT_BASIC_INDUCT;
4340           *backbl = bl->next;
4341         }
4342       else
4343         {
4344           backbl = &bl->next;
4345
4346           if (loop_dump_stream)
4347             fprintf (loop_dump_stream, "Biv %d: verified\n", bl->regno);
4348         }
4349     }
4350 }
4351
4352
4353 /* Determine how BIVS are initialised by looking through pre-header
4354    extended basic block.  */
4355 static void
4356 loop_bivs_init_find (loop)
4357      struct loop *loop;
4358 {
4359   struct loop_ivs *ivs = LOOP_IVS (loop);
4360   /* Temporary list pointers for traversing ivs->list.  */
4361   struct iv_class *bl;
4362   int call_seen;
4363   rtx p;
4364
4365   /* Find initial value for each biv by searching backwards from loop_start,
4366      halting at first label.  Also record any test condition.  */
4367
4368   call_seen = 0;
4369   for (p = loop->start; p && GET_CODE (p) != CODE_LABEL; p = PREV_INSN (p))
4370     {
4371       rtx test;
4372
4373       note_insn = p;
4374
4375       if (GET_CODE (p) == CALL_INSN)
4376         call_seen = 1;
4377
4378       if (INSN_P (p))
4379         note_stores (PATTERN (p), record_initial, ivs);
4380
4381       /* Record any test of a biv that branches around the loop if no store
4382          between it and the start of loop.  We only care about tests with
4383          constants and registers and only certain of those.  */
4384       if (GET_CODE (p) == JUMP_INSN
4385           && JUMP_LABEL (p) != 0
4386           && next_real_insn (JUMP_LABEL (p)) == next_real_insn (loop->end)
4387           && (test = get_condition_for_loop (loop, p)) != 0
4388           && GET_CODE (XEXP (test, 0)) == REG
4389           && REGNO (XEXP (test, 0)) < max_reg_before_loop
4390           && (bl = REG_IV_CLASS (ivs, REGNO (XEXP (test, 0)))) != 0
4391           && valid_initial_value_p (XEXP (test, 1), p, call_seen, loop->start)
4392           && bl->init_insn == 0)
4393         {
4394           /* If an NE test, we have an initial value!  */
4395           if (GET_CODE (test) == NE)
4396             {
4397               bl->init_insn = p;
4398               bl->init_set = gen_rtx_SET (VOIDmode,
4399                                           XEXP (test, 0), XEXP (test, 1));
4400             }
4401           else
4402             bl->initial_test = test;
4403         }
4404     }
4405 }
4406
4407
4408 /* Look at the each biv and see if we can say anything better about its
4409    initial value from any initializing insns set up above.  (This is done
4410    in two passes to avoid missing SETs in a PARALLEL.)  */
4411 static void
4412 loop_bivs_check (loop)
4413      struct loop *loop;
4414 {
4415   struct loop_ivs *ivs = LOOP_IVS (loop);
4416   /* Temporary list pointers for traversing ivs->list.  */
4417   struct iv_class *bl;
4418   struct iv_class **backbl;
4419
4420   for (backbl = &ivs->list; (bl = *backbl); backbl = &bl->next)
4421     {
4422       rtx src;
4423       rtx note;
4424
4425       if (! bl->init_insn)
4426         continue;
4427
4428       /* IF INIT_INSN has a REG_EQUAL or REG_EQUIV note and the value
4429          is a constant, use the value of that.  */
4430       if (((note = find_reg_note (bl->init_insn, REG_EQUAL, 0)) != NULL
4431            && CONSTANT_P (XEXP (note, 0)))
4432           || ((note = find_reg_note (bl->init_insn, REG_EQUIV, 0)) != NULL
4433               && CONSTANT_P (XEXP (note, 0))))
4434         src = XEXP (note, 0);
4435       else
4436         src = SET_SRC (bl->init_set);
4437
4438       if (loop_dump_stream)
4439         fprintf (loop_dump_stream,
4440                  "Biv %d: initialized at insn %d: initial value ",
4441                  bl->regno, INSN_UID (bl->init_insn));
4442
4443       if ((GET_MODE (src) == GET_MODE (regno_reg_rtx[bl->regno])
4444            || GET_MODE (src) == VOIDmode)
4445           && valid_initial_value_p (src, bl->init_insn,
4446                                     LOOP_INFO (loop)->pre_header_has_call,
4447                                     loop->start))
4448         {
4449           bl->initial_value = src;
4450
4451           if (loop_dump_stream)
4452             {
4453               print_simple_rtl (loop_dump_stream, src);
4454               fputc ('\n', loop_dump_stream);
4455             }
4456         }
4457       /* If we can't make it a giv,
4458          let biv keep initial value of "itself".  */
4459       else if (loop_dump_stream)
4460         fprintf (loop_dump_stream, "is complex\n");
4461     }
4462 }
4463
4464
4465 /* Search the loop for general induction variables.  */
4466
4467 static void
4468 loop_givs_find (loop)
4469      struct loop* loop;
4470 {
4471   for_each_insn_in_loop (loop, check_insn_for_givs);
4472 }
4473
4474
4475 /* For each giv for which we still don't know whether or not it is
4476    replaceable, check to see if it is replaceable because its final value
4477    can be calculated.  */
4478
4479 static void
4480 loop_givs_check (loop)
4481      struct loop *loop;
4482 {
4483   struct loop_ivs *ivs = LOOP_IVS (loop);
4484   struct iv_class *bl;
4485
4486   for (bl = ivs->list; bl; bl = bl->next)
4487     {
4488       struct induction *v;
4489
4490       for (v = bl->giv; v; v = v->next_iv)
4491         if (! v->replaceable && ! v->not_replaceable)
4492           check_final_value (loop, v);
4493     }
4494 }
4495
4496
4497 /* Return non-zero if it is possible to eliminate the biv BL provided
4498    all givs are reduced.  This is possible if either the reg is not
4499    used outside the loop, or we can compute what its final value will
4500    be.  */
4501
4502 static int
4503 loop_biv_eliminable_p (loop, bl, threshold, insn_count)
4504      struct loop *loop;
4505      struct iv_class *bl;
4506      int threshold;
4507      int insn_count;
4508 {
4509   /* For architectures with a decrement_and_branch_until_zero insn,
4510      don't do this if we put a REG_NONNEG note on the endtest for this
4511      biv.  */
4512
4513 #ifdef HAVE_decrement_and_branch_until_zero
4514   if (bl->nonneg)
4515     {
4516       if (loop_dump_stream)
4517         fprintf (loop_dump_stream,
4518                  "Cannot eliminate nonneg biv %d.\n", bl->regno);
4519       return 0;
4520     }
4521 #endif
4522
4523   /* Check that biv is used outside loop or if it has a final value.
4524      Compare against bl->init_insn rather than loop->start.  We aren't
4525      concerned with any uses of the biv between init_insn and
4526      loop->start since these won't be affected by the value of the biv
4527      elsewhere in the function, so long as init_insn doesn't use the
4528      biv itself.  */
4529
4530   if ((REGNO_LAST_LUID (bl->regno) < INSN_LUID (loop->end)
4531        && bl->init_insn
4532        && INSN_UID (bl->init_insn) < max_uid_for_loop
4533        && REGNO_FIRST_LUID (bl->regno) >= INSN_LUID (bl->init_insn)
4534        && ! reg_mentioned_p (bl->biv->dest_reg, SET_SRC (bl->init_set)))
4535       || (bl->final_value = final_biv_value (loop, bl)))
4536     return maybe_eliminate_biv (loop, bl, 0, threshold, insn_count);
4537
4538   if (loop_dump_stream)
4539     {
4540       fprintf (loop_dump_stream,
4541                "Cannot eliminate biv %d.\n",
4542                bl->regno);
4543       fprintf (loop_dump_stream,
4544                "First use: insn %d, last use: insn %d.\n",
4545                REGNO_FIRST_UID (bl->regno),
4546                REGNO_LAST_UID (bl->regno));
4547     }
4548   return 0;
4549 }
4550
4551
4552 /* Reduce each giv of BL that we have decided to reduce.  */
4553
4554 static void
4555 loop_givs_reduce (loop, bl)
4556      struct loop *loop;
4557      struct iv_class *bl;
4558 {
4559   struct induction *v;
4560
4561   for (v = bl->giv; v; v = v->next_iv)
4562     {
4563       struct induction *tv;
4564       if (! v->ignore && v->same == 0)
4565         {
4566           int auto_inc_opt = 0;
4567
4568           /* If the code for derived givs immediately below has already
4569              allocated a new_reg, we must keep it.  */
4570           if (! v->new_reg)
4571             v->new_reg = gen_reg_rtx (v->mode);
4572
4573 #ifdef AUTO_INC_DEC
4574           /* If the target has auto-increment addressing modes, and
4575              this is an address giv, then try to put the increment
4576              immediately after its use, so that flow can create an
4577              auto-increment addressing mode.  */
4578           if (v->giv_type == DEST_ADDR && bl->biv_count == 1
4579               && bl->biv->always_executed && ! bl->biv->maybe_multiple
4580               /* We don't handle reversed biv's because bl->biv->insn
4581                  does not have a valid INSN_LUID.  */
4582               && ! bl->reversed
4583               && v->always_executed && ! v->maybe_multiple
4584               && INSN_UID (v->insn) < max_uid_for_loop)
4585             {
4586               /* If other giv's have been combined with this one, then
4587                  this will work only if all uses of the other giv's occur
4588                  before this giv's insn.  This is difficult to check.
4589
4590                  We simplify this by looking for the common case where
4591                  there is one DEST_REG giv, and this giv's insn is the
4592                  last use of the dest_reg of that DEST_REG giv.  If the
4593                  increment occurs after the address giv, then we can
4594                  perform the optimization.  (Otherwise, the increment
4595                  would have to go before other_giv, and we would not be
4596                  able to combine it with the address giv to get an
4597                  auto-inc address.)  */
4598               if (v->combined_with)
4599                 {
4600                   struct induction *other_giv = 0;
4601
4602                   for (tv = bl->giv; tv; tv = tv->next_iv)
4603                     if (tv->same == v)
4604                       {
4605                         if (other_giv)
4606                           break;
4607                         else
4608                           other_giv = tv;
4609                       }
4610                   if (! tv && other_giv
4611                       && REGNO (other_giv->dest_reg) < max_reg_before_loop
4612                       && (REGNO_LAST_UID (REGNO (other_giv->dest_reg))
4613                           == INSN_UID (v->insn))
4614                       && INSN_LUID (v->insn) < INSN_LUID (bl->biv->insn))
4615                     auto_inc_opt = 1;
4616                 }
4617               /* Check for case where increment is before the address
4618                  giv.  Do this test in "loop order".  */
4619               else if ((INSN_LUID (v->insn) > INSN_LUID (bl->biv->insn)
4620                         && (INSN_LUID (v->insn) < INSN_LUID (loop->scan_start)
4621                             || (INSN_LUID (bl->biv->insn)
4622                                 > INSN_LUID (loop->scan_start))))
4623                        || (INSN_LUID (v->insn) < INSN_LUID (loop->scan_start)
4624                            && (INSN_LUID (loop->scan_start)
4625                                < INSN_LUID (bl->biv->insn))))
4626                 auto_inc_opt = -1;
4627               else
4628                 auto_inc_opt = 1;
4629
4630 #ifdef HAVE_cc0
4631               {
4632                 rtx prev;
4633
4634                 /* We can't put an insn immediately after one setting
4635                    cc0, or immediately before one using cc0.  */
4636                 if ((auto_inc_opt == 1 && sets_cc0_p (PATTERN (v->insn)))
4637                     || (auto_inc_opt == -1
4638                         && (prev = prev_nonnote_insn (v->insn)) != 0
4639                         && INSN_P (prev)
4640                         && sets_cc0_p (PATTERN (prev))))
4641                   auto_inc_opt = 0;
4642               }
4643 #endif
4644
4645               if (auto_inc_opt)
4646                 v->auto_inc_opt = 1;
4647             }
4648 #endif
4649
4650           /* For each place where the biv is incremented, add an insn
4651              to increment the new, reduced reg for the giv.  */
4652           for (tv = bl->biv; tv; tv = tv->next_iv)
4653             {
4654               rtx insert_before;
4655
4656               if (! auto_inc_opt)
4657                 insert_before = tv->insn;
4658               else if (auto_inc_opt == 1)
4659                 insert_before = NEXT_INSN (v->insn);
4660               else
4661                 insert_before = v->insn;
4662
4663               if (tv->mult_val == const1_rtx)
4664                 loop_iv_add_mult_emit_before (loop, tv->add_val, v->mult_val,
4665                                               v->new_reg, v->new_reg,
4666                                               0, insert_before);
4667               else /* tv->mult_val == const0_rtx */
4668                 /* A multiply is acceptable here
4669                    since this is presumed to be seldom executed.  */
4670                 loop_iv_add_mult_emit_before (loop, tv->add_val, v->mult_val,
4671                                               v->add_val, v->new_reg,
4672                                               0, insert_before);
4673             }
4674
4675           /* Add code at loop start to initialize giv's reduced reg.  */
4676
4677           loop_iv_add_mult_hoist (loop,
4678                                   extend_value_for_giv (v, bl->initial_value),
4679                                   v->mult_val, v->add_val, v->new_reg);
4680         }
4681     }
4682 }
4683
4684
4685 /* Check for givs whose first use is their definition and whose
4686    last use is the definition of another giv.  If so, it is likely
4687    dead and should not be used to derive another giv nor to
4688    eliminate a biv.  */
4689
4690 static void
4691 loop_givs_dead_check (loop, bl)
4692      struct loop *loop ATTRIBUTE_UNUSED;
4693      struct iv_class *bl;
4694 {
4695   struct induction *v;
4696
4697   for (v = bl->giv; v; v = v->next_iv)
4698     {
4699       if (v->ignore
4700           || (v->same && v->same->ignore))
4701         continue;
4702
4703       if (v->giv_type == DEST_REG
4704           && REGNO_FIRST_UID (REGNO (v->dest_reg)) == INSN_UID (v->insn))
4705         {
4706           struct induction *v1;
4707
4708           for (v1 = bl->giv; v1; v1 = v1->next_iv)
4709             if (REGNO_LAST_UID (REGNO (v->dest_reg)) == INSN_UID (v1->insn))
4710               v->maybe_dead = 1;
4711         }
4712     }
4713 }
4714
4715
4716 static void
4717 loop_givs_rescan (loop, bl, reg_map)
4718      struct loop *loop;
4719      struct iv_class *bl;
4720      rtx *reg_map;
4721 {
4722   struct induction *v;
4723
4724   for (v = bl->giv; v; v = v->next_iv)
4725     {
4726       if (v->same && v->same->ignore)
4727         v->ignore = 1;
4728
4729       if (v->ignore)
4730         continue;
4731
4732       /* Update expression if this was combined, in case other giv was
4733          replaced.  */
4734       if (v->same)
4735         v->new_reg = replace_rtx (v->new_reg,
4736                                   v->same->dest_reg, v->same->new_reg);
4737
4738       /* See if this register is known to be a pointer to something.  If
4739          so, see if we can find the alignment.  First see if there is a
4740          destination register that is a pointer.  If so, this shares the
4741          alignment too.  Next see if we can deduce anything from the
4742          computational information.  If not, and this is a DEST_ADDR
4743          giv, at least we know that it's a pointer, though we don't know
4744          the alignment.  */
4745       if (GET_CODE (v->new_reg) == REG
4746           && v->giv_type == DEST_REG
4747           && REG_POINTER (v->dest_reg))
4748         mark_reg_pointer (v->new_reg,
4749                           REGNO_POINTER_ALIGN (REGNO (v->dest_reg)));
4750       else if (GET_CODE (v->new_reg) == REG
4751                && REG_POINTER (v->src_reg))
4752         {
4753           unsigned int align = REGNO_POINTER_ALIGN (REGNO (v->src_reg));
4754
4755           if (align == 0
4756               || GET_CODE (v->add_val) != CONST_INT
4757               || INTVAL (v->add_val) % (align / BITS_PER_UNIT) != 0)
4758             align = 0;
4759
4760           mark_reg_pointer (v->new_reg, align);
4761         }
4762       else if (GET_CODE (v->new_reg) == REG
4763                && GET_CODE (v->add_val) == REG
4764                && REG_POINTER (v->add_val))
4765         {
4766           unsigned int align = REGNO_POINTER_ALIGN (REGNO (v->add_val));
4767
4768           if (align == 0 || GET_CODE (v->mult_val) != CONST_INT
4769               || INTVAL (v->mult_val) % (align / BITS_PER_UNIT) != 0)
4770             align = 0;
4771
4772           mark_reg_pointer (v->new_reg, align);
4773         }
4774       else if (GET_CODE (v->new_reg) == REG && v->giv_type == DEST_ADDR)
4775         mark_reg_pointer (v->new_reg, 0);
4776
4777       if (v->giv_type == DEST_ADDR)
4778         /* Store reduced reg as the address in the memref where we found
4779            this giv.  */
4780         validate_change (v->insn, v->location, v->new_reg, 0);
4781       else if (v->replaceable)
4782         {
4783           reg_map[REGNO (v->dest_reg)] = v->new_reg;
4784         }
4785       else
4786         {
4787           /* Not replaceable; emit an insn to set the original giv reg from
4788              the reduced giv, same as above.  */
4789           loop_insn_emit_after (loop, 0, v->insn,
4790                                 gen_move_insn (v->dest_reg, v->new_reg));
4791         }
4792
4793       /* When a loop is reversed, givs which depend on the reversed
4794          biv, and which are live outside the loop, must be set to their
4795          correct final value.  This insn is only needed if the giv is
4796          not replaceable.  The correct final value is the same as the
4797          value that the giv starts the reversed loop with.  */
4798       if (bl->reversed && ! v->replaceable)
4799         loop_iv_add_mult_sink (loop,
4800                                extend_value_for_giv (v, bl->initial_value),
4801                                v->mult_val, v->add_val, v->dest_reg);
4802       else if (v->final_value)
4803         loop_insn_sink_or_swim (loop,
4804                                 gen_move_insn (v->dest_reg, v->final_value));
4805
4806       if (loop_dump_stream)
4807         {
4808           fprintf (loop_dump_stream, "giv at %d reduced to ",
4809                    INSN_UID (v->insn));
4810           print_simple_rtl (loop_dump_stream, v->new_reg);
4811           fprintf (loop_dump_stream, "\n");
4812         }
4813     }
4814 }
4815
4816
4817 static int
4818 loop_giv_reduce_benefit (loop, bl, v, test_reg)
4819      struct loop *loop ATTRIBUTE_UNUSED;
4820      struct iv_class *bl;
4821      struct induction *v;
4822      rtx test_reg;
4823 {
4824   int add_cost;
4825   int benefit;
4826
4827   benefit = v->benefit;
4828   PUT_MODE (test_reg, v->mode);
4829   add_cost = iv_add_mult_cost (bl->biv->add_val, v->mult_val,
4830                                test_reg, test_reg);
4831
4832   /* Reduce benefit if not replaceable, since we will insert a
4833      move-insn to replace the insn that calculates this giv.  Don't do
4834      this unless the giv is a user variable, since it will often be
4835      marked non-replaceable because of the duplication of the exit
4836      code outside the loop.  In such a case, the copies we insert are
4837      dead and will be deleted.  So they don't have a cost.  Similar
4838      situations exist.  */
4839   /* ??? The new final_[bg]iv_value code does a much better job of
4840      finding replaceable giv's, and hence this code may no longer be
4841      necessary.  */
4842   if (! v->replaceable && ! bl->eliminable
4843       && REG_USERVAR_P (v->dest_reg))
4844     benefit -= copy_cost;
4845
4846   /* Decrease the benefit to count the add-insns that we will insert
4847      to increment the reduced reg for the giv.  ??? This can
4848      overestimate the run-time cost of the additional insns, e.g. if
4849      there are multiple basic blocks that increment the biv, but only
4850      one of these blocks is executed during each iteration.  There is
4851      no good way to detect cases like this with the current structure
4852      of the loop optimizer.  This code is more accurate for
4853      determining code size than run-time benefits.  */
4854   benefit -= add_cost * bl->biv_count;
4855
4856   /* Decide whether to strength-reduce this giv or to leave the code
4857      unchanged (recompute it from the biv each time it is used).  This
4858      decision can be made independently for each giv.  */
4859
4860 #ifdef AUTO_INC_DEC
4861   /* Attempt to guess whether autoincrement will handle some of the
4862      new add insns; if so, increase BENEFIT (undo the subtraction of
4863      add_cost that was done above).  */
4864   if (v->giv_type == DEST_ADDR
4865       /* Increasing the benefit is risky, since this is only a guess.
4866          Avoid increasing register pressure in cases where there would
4867          be no other benefit from reducing this giv.  */
4868       && benefit > 0
4869       && GET_CODE (v->mult_val) == CONST_INT)
4870     {
4871       int size = GET_MODE_SIZE (GET_MODE (v->mem));
4872
4873       if (HAVE_POST_INCREMENT
4874           && INTVAL (v->mult_val) == size)
4875         benefit += add_cost * bl->biv_count;
4876       else if (HAVE_PRE_INCREMENT
4877                && INTVAL (v->mult_val) == size)
4878         benefit += add_cost * bl->biv_count;
4879       else if (HAVE_POST_DECREMENT
4880                && -INTVAL (v->mult_val) == size)
4881         benefit += add_cost * bl->biv_count;
4882       else if (HAVE_PRE_DECREMENT
4883                && -INTVAL (v->mult_val) == size)
4884         benefit += add_cost * bl->biv_count;
4885     }
4886 #endif
4887
4888   return benefit;
4889 }
4890
4891
4892 /* Free IV structures for LOOP.  */
4893
4894 static void
4895 loop_ivs_free (loop)
4896      struct loop *loop;
4897 {
4898   struct loop_ivs *ivs = LOOP_IVS (loop);
4899   struct iv_class *iv = ivs->list;
4900
4901   free (ivs->regs);
4902
4903   while (iv)
4904     {
4905       struct iv_class *next = iv->next;
4906       struct induction *induction;
4907       struct induction *next_induction;
4908
4909       for (induction = iv->biv; induction; induction = next_induction)
4910         {
4911           next_induction = induction->next_iv;
4912           free (induction);
4913         }
4914       for (induction = iv->giv; induction; induction = next_induction)
4915         {
4916           next_induction = induction->next_iv;
4917           free (induction);
4918         }
4919
4920       free (iv);
4921       iv = next;
4922     }
4923 }
4924
4925
4926 /* Perform strength reduction and induction variable elimination.
4927
4928    Pseudo registers created during this function will be beyond the
4929    last valid index in several tables including
4930    REGS->ARRAY[I].N_TIMES_SET and REGNO_LAST_UID.  This does not cause a
4931    problem here, because the added registers cannot be givs outside of
4932    their loop, and hence will never be reconsidered.  But scan_loop
4933    must check regnos to make sure they are in bounds.  */
4934
4935 static void
4936 strength_reduce (loop, flags)
4937      struct loop *loop;
4938      int flags;
4939 {
4940   struct loop_info *loop_info = LOOP_INFO (loop);
4941   struct loop_regs *regs = LOOP_REGS (loop);
4942   struct loop_ivs *ivs = LOOP_IVS (loop);
4943   rtx p;
4944   /* Temporary list pointer for traversing ivs->list.  */
4945   struct iv_class *bl;
4946   /* Ratio of extra register life span we can justify
4947      for saving an instruction.  More if loop doesn't call subroutines
4948      since in that case saving an insn makes more difference
4949      and more registers are available.  */
4950   /* ??? could set this to last value of threshold in move_movables */
4951   int threshold = (loop_info->has_call ? 1 : 2) * (3 + n_non_fixed_regs);
4952   /* Map of pseudo-register replacements.  */
4953   rtx *reg_map = NULL;
4954   int reg_map_size;
4955   int unrolled_insn_copies = 0;
4956   rtx test_reg = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 1);
4957   int insn_count = count_insns_in_loop (loop);
4958
4959   addr_placeholder = gen_reg_rtx (Pmode);
4960
4961   ivs->n_regs = max_reg_before_loop;
4962   ivs->regs = (struct iv *) xcalloc (ivs->n_regs, sizeof (struct iv));
4963
4964   /* Find all BIVs in loop.  */
4965   loop_bivs_find (loop);
4966
4967   /* Exit if there are no bivs.  */
4968   if (! ivs->list)
4969     {
4970       /* Can still unroll the loop anyways, but indicate that there is no
4971          strength reduction info available.  */
4972       if (flags & LOOP_UNROLL)
4973         unroll_loop (loop, insn_count, 0);
4974
4975       loop_ivs_free (loop);
4976       return;
4977     }
4978
4979   /* Determine how BIVS are initialised by looking through pre-header
4980      extended basic block.  */
4981   loop_bivs_init_find (loop);
4982
4983   /* Look at the each biv and see if we can say anything better about its
4984      initial value from any initializing insns set up above.  */
4985   loop_bivs_check (loop);
4986
4987   /* Search the loop for general induction variables.  */
4988   loop_givs_find (loop);
4989
4990   /* Try to calculate and save the number of loop iterations.  This is
4991      set to zero if the actual number can not be calculated.  This must
4992      be called after all giv's have been identified, since otherwise it may
4993      fail if the iteration variable is a giv.  */
4994   loop_iterations (loop);
4995
4996 #ifdef HAVE_prefetch
4997   if (flags & LOOP_PREFETCH)
4998     emit_prefetch_instructions (loop);
4999 #endif
5000
5001   /* Now for each giv for which we still don't know whether or not it is
5002      replaceable, check to see if it is replaceable because its final value
5003      can be calculated.  This must be done after loop_iterations is called,
5004      so that final_giv_value will work correctly.  */
5005   loop_givs_check (loop);
5006
5007   /* Try to prove that the loop counter variable (if any) is always
5008      nonnegative; if so, record that fact with a REG_NONNEG note
5009      so that "decrement and branch until zero" insn can be used.  */
5010   check_dbra_loop (loop, insn_count);
5011
5012   /* Create reg_map to hold substitutions for replaceable giv regs.
5013      Some givs might have been made from biv increments, so look at
5014      ivs->reg_iv_type for a suitable size.  */
5015   reg_map_size = ivs->n_regs;
5016   reg_map = (rtx *) xcalloc (reg_map_size, sizeof (rtx));
5017
5018   /* Examine each iv class for feasibility of strength reduction/induction
5019      variable elimination.  */
5020
5021   for (bl = ivs->list; bl; bl = bl->next)
5022     {
5023       struct induction *v;
5024       int benefit;
5025
5026       /* Test whether it will be possible to eliminate this biv
5027          provided all givs are reduced.  */
5028       bl->eliminable = loop_biv_eliminable_p (loop, bl, threshold, insn_count);
5029
5030       /* This will be true at the end, if all givs which depend on this
5031          biv have been strength reduced.
5032          We can't (currently) eliminate the biv unless this is so.  */
5033       bl->all_reduced = 1;
5034
5035       /* Check each extension dependent giv in this class to see if its
5036          root biv is safe from wrapping in the interior mode.  */
5037       check_ext_dependent_givs (bl, loop_info);
5038
5039       /* Combine all giv's for this iv_class.  */
5040       combine_givs (regs, bl);
5041
5042       for (v = bl->giv; v; v = v->next_iv)
5043         {
5044           struct induction *tv;
5045
5046           if (v->ignore || v->same)
5047             continue;
5048
5049           benefit = loop_giv_reduce_benefit (loop, bl, v, test_reg);
5050
5051           /* If an insn is not to be strength reduced, then set its ignore
5052              flag, and clear bl->all_reduced.  */
5053
5054           /* A giv that depends on a reversed biv must be reduced if it is
5055              used after the loop exit, otherwise, it would have the wrong
5056              value after the loop exit.  To make it simple, just reduce all
5057              of such giv's whether or not we know they are used after the loop
5058              exit.  */
5059
5060           if (! flag_reduce_all_givs
5061               && v->lifetime * threshold * benefit < insn_count
5062               && ! bl->reversed)
5063             {
5064               if (loop_dump_stream)
5065                 fprintf (loop_dump_stream,
5066                          "giv of insn %d not worth while, %d vs %d.\n",
5067                          INSN_UID (v->insn),
5068                          v->lifetime * threshold * benefit, insn_count);
5069               v->ignore = 1;
5070               bl->all_reduced = 0;
5071             }
5072           else
5073             {
5074               /* Check that we can increment the reduced giv without a
5075                  multiply insn.  If not, reject it.  */
5076
5077               for (tv = bl->biv; tv; tv = tv->next_iv)
5078                 if (tv->mult_val == const1_rtx
5079                     && ! product_cheap_p (tv->add_val, v->mult_val))
5080                   {
5081                     if (loop_dump_stream)
5082                       fprintf (loop_dump_stream,
5083                                "giv of insn %d: would need a multiply.\n",
5084                                INSN_UID (v->insn));
5085                     v->ignore = 1;
5086                     bl->all_reduced = 0;
5087                     break;
5088                   }
5089             }
5090         }
5091
5092       /* Check for givs whose first use is their definition and whose
5093          last use is the definition of another giv.  If so, it is likely
5094          dead and should not be used to derive another giv nor to
5095          eliminate a biv.  */
5096       loop_givs_dead_check (loop, bl);
5097
5098       /* Reduce each giv that we decided to reduce.  */
5099       loop_givs_reduce (loop, bl);
5100
5101       /* Rescan all givs.  If a giv is the same as a giv not reduced, mark it
5102          as not reduced.
5103
5104          For each giv register that can be reduced now: if replaceable,
5105          substitute reduced reg wherever the old giv occurs;
5106          else add new move insn "giv_reg = reduced_reg".  */
5107       loop_givs_rescan (loop, bl, reg_map);
5108
5109       /* All the givs based on the biv bl have been reduced if they
5110          merit it.  */
5111
5112       /* For each giv not marked as maybe dead that has been combined with a
5113          second giv, clear any "maybe dead" mark on that second giv.
5114          v->new_reg will either be or refer to the register of the giv it
5115          combined with.
5116
5117          Doing this clearing avoids problems in biv elimination where
5118          a giv's new_reg is a complex value that can't be put in the
5119          insn but the giv combined with (with a reg as new_reg) is
5120          marked maybe_dead.  Since the register will be used in either
5121          case, we'd prefer it be used from the simpler giv.  */
5122
5123       for (v = bl->giv; v; v = v->next_iv)
5124         if (! v->maybe_dead && v->same)
5125           v->same->maybe_dead = 0;
5126
5127       /* Try to eliminate the biv, if it is a candidate.
5128          This won't work if ! bl->all_reduced,
5129          since the givs we planned to use might not have been reduced.
5130
5131          We have to be careful that we didn't initially think we could
5132          eliminate this biv because of a giv that we now think may be
5133          dead and shouldn't be used as a biv replacement.
5134
5135          Also, there is the possibility that we may have a giv that looks
5136          like it can be used to eliminate a biv, but the resulting insn
5137          isn't valid.  This can happen, for example, on the 88k, where a
5138          JUMP_INSN can compare a register only with zero.  Attempts to
5139          replace it with a compare with a constant will fail.
5140
5141          Note that in cases where this call fails, we may have replaced some
5142          of the occurrences of the biv with a giv, but no harm was done in
5143          doing so in the rare cases where it can occur.  */
5144
5145       if (bl->all_reduced == 1 && bl->eliminable
5146           && maybe_eliminate_biv (loop, bl, 1, threshold, insn_count))
5147         {
5148           /* ?? If we created a new test to bypass the loop entirely,
5149              or otherwise drop straight in, based on this test, then
5150              we might want to rewrite it also.  This way some later
5151              pass has more hope of removing the initialization of this
5152              biv entirely.  */
5153
5154           /* If final_value != 0, then the biv may be used after loop end
5155              and we must emit an insn to set it just in case.
5156
5157              Reversed bivs already have an insn after the loop setting their
5158              value, so we don't need another one.  We can't calculate the
5159              proper final value for such a biv here anyways.  */
5160           if (bl->final_value && ! bl->reversed)
5161               loop_insn_sink_or_swim (loop, gen_move_insn
5162                                       (bl->biv->dest_reg, bl->final_value));
5163
5164           if (loop_dump_stream)
5165             fprintf (loop_dump_stream, "Reg %d: biv eliminated\n",
5166                      bl->regno);
5167         }
5168       /* See above note wrt final_value.  But since we couldn't eliminate
5169          the biv, we must set the value after the loop instead of before.  */
5170       else if (bl->final_value && ! bl->reversed)
5171         loop_insn_sink (loop, gen_move_insn (bl->biv->dest_reg,
5172                                              bl->final_value));
5173     }
5174
5175   /* Go through all the instructions in the loop, making all the
5176      register substitutions scheduled in REG_MAP.  */
5177
5178   for (p = loop->start; p != loop->end; p = NEXT_INSN (p))
5179     if (GET_CODE (p) == INSN || GET_CODE (p) == JUMP_INSN
5180         || GET_CODE (p) == CALL_INSN)
5181       {
5182         replace_regs (PATTERN (p), reg_map, reg_map_size, 0);
5183         replace_regs (REG_NOTES (p), reg_map, reg_map_size, 0);
5184         INSN_CODE (p) = -1;
5185       }
5186
5187   if (loop_info->n_iterations > 0)
5188     {
5189       /* When we completely unroll a loop we will likely not need the increment
5190          of the loop BIV and we will not need the conditional branch at the
5191          end of the loop.  */
5192       unrolled_insn_copies = insn_count - 2;
5193
5194 #ifdef HAVE_cc0
5195       /* When we completely unroll a loop on a HAVE_cc0 machine we will not
5196          need the comparison before the conditional branch at the end of the
5197          loop.  */
5198       unrolled_insn_copies -= 1;
5199 #endif
5200
5201       /* We'll need one copy for each loop iteration.  */
5202       unrolled_insn_copies *= loop_info->n_iterations;
5203
5204       /* A little slop to account for the ability to remove initialization
5205          code, better CSE, and other secondary benefits of completely
5206          unrolling some loops.  */
5207       unrolled_insn_copies -= 1;
5208
5209       /* Clamp the value.  */
5210       if (unrolled_insn_copies < 0)
5211         unrolled_insn_copies = 0;
5212     }
5213
5214   /* Unroll loops from within strength reduction so that we can use the
5215      induction variable information that strength_reduce has already
5216      collected.  Always unroll loops that would be as small or smaller
5217      unrolled than when rolled.  */
5218   if ((flags & LOOP_UNROLL)
5219       || (!(flags & LOOP_FIRST_PASS)
5220           && loop_info->n_iterations > 0
5221           && unrolled_insn_copies <= insn_count))
5222     unroll_loop (loop, insn_count, 1);
5223
5224 #ifdef HAVE_doloop_end
5225   if (HAVE_doloop_end && (flags & LOOP_BCT) && flag_branch_on_count_reg)
5226     doloop_optimize (loop);
5227 #endif  /* HAVE_doloop_end  */
5228
5229   /* In case number of iterations is known, drop branch prediction note
5230      in the branch.  Do that only in second loop pass, as loop unrolling
5231      may change the number of iterations performed.  */
5232   if ((flags & LOOP_BCT)
5233       && loop_info->n_iterations / loop_info->unroll_number > 1)
5234     {
5235       int n = loop_info->n_iterations / loop_info->unroll_number;
5236       predict_insn (PREV_INSN (loop->end),
5237                     PRED_LOOP_ITERATIONS,
5238                     REG_BR_PROB_BASE - REG_BR_PROB_BASE / n);
5239     }
5240
5241   if (loop_dump_stream)
5242     fprintf (loop_dump_stream, "\n");
5243
5244   loop_ivs_free (loop);
5245   if (reg_map)
5246     free (reg_map);
5247 }
5248 \f
5249 /*Record all basic induction variables calculated in the insn.  */
5250 static rtx
5251 check_insn_for_bivs (loop, p, not_every_iteration, maybe_multiple)
5252      struct loop *loop;
5253      rtx p;
5254      int not_every_iteration;
5255      int maybe_multiple;
5256 {
5257   struct loop_ivs *ivs = LOOP_IVS (loop);
5258   rtx set;
5259   rtx dest_reg;
5260   rtx inc_val;
5261   rtx mult_val;
5262   rtx *location;
5263
5264   if (GET_CODE (p) == INSN
5265       && (set = single_set (p))
5266       && GET_CODE (SET_DEST (set)) == REG)
5267     {
5268       dest_reg = SET_DEST (set);
5269       if (REGNO (dest_reg) < max_reg_before_loop
5270           && REGNO (dest_reg) >= FIRST_PSEUDO_REGISTER
5271           && REG_IV_TYPE (ivs, REGNO (dest_reg)) != NOT_BASIC_INDUCT)
5272         {
5273           if (basic_induction_var (loop, SET_SRC (set),
5274                                    GET_MODE (SET_SRC (set)),
5275                                    dest_reg, p, &inc_val, &mult_val,
5276                                    &location))
5277             {
5278               /* It is a possible basic induction variable.
5279                  Create and initialize an induction structure for it.  */
5280
5281               struct induction *v
5282                 = (struct induction *) xmalloc (sizeof (struct induction));
5283
5284               record_biv (loop, v, p, dest_reg, inc_val, mult_val, location,
5285                           not_every_iteration, maybe_multiple);
5286               REG_IV_TYPE (ivs, REGNO (dest_reg)) = BASIC_INDUCT;
5287             }
5288           else if (REGNO (dest_reg) < ivs->n_regs)
5289             REG_IV_TYPE (ivs, REGNO (dest_reg)) = NOT_BASIC_INDUCT;
5290         }
5291     }
5292   return p;
5293 }
5294 \f
5295 /* Record all givs calculated in the insn.
5296    A register is a giv if: it is only set once, it is a function of a
5297    biv and a constant (or invariant), and it is not a biv.  */
5298 static rtx
5299 check_insn_for_givs (loop, p, not_every_iteration, maybe_multiple)
5300      struct loop *loop;
5301      rtx p;
5302      int not_every_iteration;
5303      int maybe_multiple;
5304 {
5305   struct loop_regs *regs = LOOP_REGS (loop);
5306
5307   rtx set;
5308   /* Look for a general induction variable in a register.  */
5309   if (GET_CODE (p) == INSN
5310       && (set = single_set (p))
5311       && GET_CODE (SET_DEST (set)) == REG
5312       && ! regs->array[REGNO (SET_DEST (set))].may_not_optimize)
5313     {
5314       rtx src_reg;
5315       rtx dest_reg;
5316       rtx add_val;
5317       rtx mult_val;
5318       rtx ext_val;
5319       int benefit;
5320       rtx regnote = 0;
5321       rtx last_consec_insn;
5322
5323       dest_reg = SET_DEST (set);
5324       if (REGNO (dest_reg) < FIRST_PSEUDO_REGISTER)
5325         return p;
5326
5327       if (/* SET_SRC is a giv.  */
5328           (general_induction_var (loop, SET_SRC (set), &src_reg, &add_val,
5329                                   &mult_val, &ext_val, 0, &benefit, VOIDmode)
5330            /* Equivalent expression is a giv.  */
5331            || ((regnote = find_reg_note (p, REG_EQUAL, NULL_RTX))
5332                && general_induction_var (loop, XEXP (regnote, 0), &src_reg,
5333                                          &add_val, &mult_val, &ext_val, 0,
5334                                          &benefit, VOIDmode)))
5335           /* Don't try to handle any regs made by loop optimization.
5336              We have nothing on them in regno_first_uid, etc.  */
5337           && REGNO (dest_reg) < max_reg_before_loop
5338           /* Don't recognize a BASIC_INDUCT_VAR here.  */
5339           && dest_reg != src_reg
5340           /* This must be the only place where the register is set.  */
5341           && (regs->array[REGNO (dest_reg)].n_times_set == 1
5342               /* or all sets must be consecutive and make a giv.  */
5343               || (benefit = consec_sets_giv (loop, benefit, p,
5344                                              src_reg, dest_reg,
5345                                              &add_val, &mult_val, &ext_val,
5346                                              &last_consec_insn))))
5347         {
5348           struct induction *v
5349             = (struct induction *) xmalloc (sizeof (struct induction));
5350
5351           /* If this is a library call, increase benefit.  */
5352           if (find_reg_note (p, REG_RETVAL, NULL_RTX))
5353             benefit += libcall_benefit (p);
5354
5355           /* Skip the consecutive insns, if there are any.  */
5356           if (regs->array[REGNO (dest_reg)].n_times_set != 1)
5357             p = last_consec_insn;
5358
5359           record_giv (loop, v, p, src_reg, dest_reg, mult_val, add_val,
5360                       ext_val, benefit, DEST_REG, not_every_iteration,
5361                       maybe_multiple, (rtx*) 0);
5362
5363         }
5364     }
5365
5366 #ifndef DONT_REDUCE_ADDR
5367   /* Look for givs which are memory addresses.  */
5368   /* This resulted in worse code on a VAX 8600.  I wonder if it
5369      still does.  */
5370   if (GET_CODE (p) == INSN)
5371     find_mem_givs (loop, PATTERN (p), p, not_every_iteration,
5372                    maybe_multiple);
5373 #endif
5374
5375   /* Update the status of whether giv can derive other givs.  This can
5376      change when we pass a label or an insn that updates a biv.  */
5377   if (GET_CODE (p) == INSN || GET_CODE (p) == JUMP_INSN
5378       || GET_CODE (p) == CODE_LABEL)
5379     update_giv_derive (loop, p);
5380   return p;
5381 }
5382 \f
5383 /* Return 1 if X is a valid source for an initial value (or as value being
5384    compared against in an initial test).
5385
5386    X must be either a register or constant and must not be clobbered between
5387    the current insn and the start of the loop.
5388
5389    INSN is the insn containing X.  */
5390
5391 static int
5392 valid_initial_value_p (x, insn, call_seen, loop_start)
5393      rtx x;
5394      rtx insn;
5395      int call_seen;
5396      rtx loop_start;
5397 {
5398   if (CONSTANT_P (x))
5399     return 1;
5400
5401   /* Only consider pseudos we know about initialized in insns whose luids
5402      we know.  */
5403   if (GET_CODE (x) != REG
5404       || REGNO (x) >= max_reg_before_loop)
5405     return 0;
5406
5407   /* Don't use call-clobbered registers across a call which clobbers it.  On
5408      some machines, don't use any hard registers at all.  */
5409   if (REGNO (x) < FIRST_PSEUDO_REGISTER
5410       && (SMALL_REGISTER_CLASSES
5411           || (call_used_regs[REGNO (x)] && call_seen)))
5412     return 0;
5413
5414   /* Don't use registers that have been clobbered before the start of the
5415      loop.  */
5416   if (reg_set_between_p (x, insn, loop_start))
5417     return 0;
5418
5419   return 1;
5420 }
5421 \f
5422 /* Scan X for memory refs and check each memory address
5423    as a possible giv.  INSN is the insn whose pattern X comes from.
5424    NOT_EVERY_ITERATION is 1 if the insn might not be executed during
5425    every loop iteration.  MAYBE_MULTIPLE is 1 if the insn might be executed
5426    more thanonce in each loop iteration.  */
5427
5428 static void
5429 find_mem_givs (loop, x, insn, not_every_iteration, maybe_multiple)
5430      const struct loop *loop;
5431      rtx x;
5432      rtx insn;
5433      int not_every_iteration, maybe_multiple;
5434 {
5435   int i, j;
5436   enum rtx_code code;
5437   const char *fmt;
5438
5439   if (x == 0)
5440     return;
5441
5442   code = GET_CODE (x);
5443   switch (code)
5444     {
5445     case REG:
5446     case CONST_INT:
5447     case CONST:
5448     case CONST_DOUBLE:
5449     case SYMBOL_REF:
5450     case LABEL_REF:
5451     case PC:
5452     case CC0:
5453     case ADDR_VEC:
5454     case ADDR_DIFF_VEC:
5455     case USE:
5456     case CLOBBER:
5457       return;
5458
5459     case MEM:
5460       {
5461         rtx src_reg;
5462         rtx add_val;
5463         rtx mult_val;
5464         rtx ext_val;
5465         int benefit;
5466
5467         /* This code used to disable creating GIVs with mult_val == 1 and
5468            add_val == 0.  However, this leads to lost optimizations when
5469            it comes time to combine a set of related DEST_ADDR GIVs, since
5470            this one would not be seen.  */
5471
5472         if (general_induction_var (loop, XEXP (x, 0), &src_reg, &add_val,
5473                                    &mult_val, &ext_val, 1, &benefit,
5474                                    GET_MODE (x)))
5475           {
5476             /* Found one; record it.  */
5477             struct induction *v
5478               = (struct induction *) xmalloc (sizeof (struct induction));
5479
5480             record_giv (loop, v, insn, src_reg, addr_placeholder, mult_val,
5481                         add_val, ext_val, benefit, DEST_ADDR,
5482                         not_every_iteration, maybe_multiple, &XEXP (x, 0));
5483
5484             v->mem = x;
5485           }
5486       }
5487       return;
5488
5489     default:
5490       break;
5491     }
5492
5493   /* Recursively scan the subexpressions for other mem refs.  */
5494
5495   fmt = GET_RTX_FORMAT (code);
5496   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5497     if (fmt[i] == 'e')
5498       find_mem_givs (loop, XEXP (x, i), insn, not_every_iteration,
5499                      maybe_multiple);
5500     else if (fmt[i] == 'E')
5501       for (j = 0; j < XVECLEN (x, i); j++)
5502         find_mem_givs (loop, XVECEXP (x, i, j), insn, not_every_iteration,
5503                        maybe_multiple);
5504 }
5505 \f
5506 /* Fill in the data about one biv update.
5507    V is the `struct induction' in which we record the biv.  (It is
5508    allocated by the caller, with alloca.)
5509    INSN is the insn that sets it.
5510    DEST_REG is the biv's reg.
5511
5512    MULT_VAL is const1_rtx if the biv is being incremented here, in which case
5513    INC_VAL is the increment.  Otherwise, MULT_VAL is const0_rtx and the biv is
5514    being set to INC_VAL.
5515
5516    NOT_EVERY_ITERATION is nonzero if this biv update is not know to be
5517    executed every iteration; MAYBE_MULTIPLE is nonzero if this biv update
5518    can be executed more than once per iteration.  If MAYBE_MULTIPLE
5519    and NOT_EVERY_ITERATION are both zero, we know that the biv update is
5520    executed exactly once per iteration.  */
5521
5522 static void
5523 record_biv (loop, v, insn, dest_reg, inc_val, mult_val, location,
5524             not_every_iteration, maybe_multiple)
5525      struct loop *loop;
5526      struct induction *v;
5527      rtx insn;
5528      rtx dest_reg;
5529      rtx inc_val;
5530      rtx mult_val;
5531      rtx *location;
5532      int not_every_iteration;
5533      int maybe_multiple;
5534 {
5535   struct loop_ivs *ivs = LOOP_IVS (loop);
5536   struct iv_class *bl;
5537
5538   v->insn = insn;
5539   v->src_reg = dest_reg;
5540   v->dest_reg = dest_reg;
5541   v->mult_val = mult_val;
5542   v->add_val = inc_val;
5543   v->ext_dependent = NULL_RTX;
5544   v->location = location;
5545   v->mode = GET_MODE (dest_reg);
5546   v->always_computable = ! not_every_iteration;
5547   v->always_executed = ! not_every_iteration;
5548   v->maybe_multiple = maybe_multiple;
5549
5550   /* Add this to the reg's iv_class, creating a class
5551      if this is the first incrementation of the reg.  */
5552
5553   bl = REG_IV_CLASS (ivs, REGNO (dest_reg));
5554   if (bl == 0)
5555     {
5556       /* Create and initialize new iv_class.  */
5557
5558       bl = (struct iv_class *) xmalloc (sizeof (struct iv_class));
5559
5560       bl->regno = REGNO (dest_reg);
5561       bl->biv = 0;
5562       bl->giv = 0;
5563       bl->biv_count = 0;
5564       bl->giv_count = 0;
5565
5566       /* Set initial value to the reg itself.  */
5567       bl->initial_value = dest_reg;
5568       bl->final_value = 0;
5569       /* We haven't seen the initializing insn yet */
5570       bl->init_insn = 0;
5571       bl->init_set = 0;
5572       bl->initial_test = 0;
5573       bl->incremented = 0;
5574       bl->eliminable = 0;
5575       bl->nonneg = 0;
5576       bl->reversed = 0;
5577       bl->total_benefit = 0;
5578
5579       /* Add this class to ivs->list.  */
5580       bl->next = ivs->list;
5581       ivs->list = bl;
5582
5583       /* Put it in the array of biv register classes.  */
5584       REG_IV_CLASS (ivs, REGNO (dest_reg)) = bl;
5585     }
5586
5587   /* Update IV_CLASS entry for this biv.  */
5588   v->next_iv = bl->biv;
5589   bl->biv = v;
5590   bl->biv_count++;
5591   if (mult_val == const1_rtx)
5592     bl->incremented = 1;
5593
5594   if (loop_dump_stream)
5595     loop_biv_dump (v, loop_dump_stream, 0);
5596 }
5597 \f
5598 /* Fill in the data about one giv.
5599    V is the `struct induction' in which we record the giv.  (It is
5600    allocated by the caller, with alloca.)
5601    INSN is the insn that sets it.
5602    BENEFIT estimates the savings from deleting this insn.
5603    TYPE is DEST_REG or DEST_ADDR; it says whether the giv is computed
5604    into a register or is used as a memory address.
5605
5606    SRC_REG is the biv reg which the giv is computed from.
5607    DEST_REG is the giv's reg (if the giv is stored in a reg).
5608    MULT_VAL and ADD_VAL are the coefficients used to compute the giv.
5609    LOCATION points to the place where this giv's value appears in INSN.  */
5610
5611 static void
5612 record_giv (loop, v, insn, src_reg, dest_reg, mult_val, add_val, ext_val,
5613             benefit, type, not_every_iteration, maybe_multiple, location)
5614      const struct loop *loop;
5615      struct induction *v;
5616      rtx insn;
5617      rtx src_reg;
5618      rtx dest_reg;
5619      rtx mult_val, add_val, ext_val;
5620      int benefit;
5621      enum g_types type;
5622      int not_every_iteration, maybe_multiple;
5623      rtx *location;
5624 {
5625   struct loop_ivs *ivs = LOOP_IVS (loop);
5626   struct induction *b;
5627   struct iv_class *bl;
5628   rtx set = single_set (insn);
5629   rtx temp;
5630
5631   /* Attempt to prove constantness of the values.  Don't let simplity_rtx
5632      undo the MULT canonicalization that we performed earlier.  */
5633   temp = simplify_rtx (add_val);
5634   if (temp
5635       && ! (GET_CODE (add_val) == MULT
5636             && GET_CODE (temp) == ASHIFT))
5637     add_val = temp;
5638
5639   v->insn = insn;
5640   v->src_reg = src_reg;
5641   v->giv_type = type;
5642   v->dest_reg = dest_reg;
5643   v->mult_val = mult_val;
5644   v->add_val = add_val;
5645   v->ext_dependent = ext_val;
5646   v->benefit = benefit;
5647   v->location = location;
5648   v->cant_derive = 0;
5649   v->combined_with = 0;
5650   v->maybe_multiple = maybe_multiple;
5651   v->maybe_dead = 0;
5652   v->derive_adjustment = 0;
5653   v->same = 0;
5654   v->ignore = 0;
5655   v->new_reg = 0;
5656   v->final_value = 0;
5657   v->same_insn = 0;
5658   v->auto_inc_opt = 0;
5659   v->unrolled = 0;
5660   v->shared = 0;
5661
5662   /* The v->always_computable field is used in update_giv_derive, to
5663      determine whether a giv can be used to derive another giv.  For a
5664      DEST_REG giv, INSN computes a new value for the giv, so its value
5665      isn't computable if INSN insn't executed every iteration.
5666      However, for a DEST_ADDR giv, INSN merely uses the value of the giv;
5667      it does not compute a new value.  Hence the value is always computable
5668      regardless of whether INSN is executed each iteration.  */
5669
5670   if (type == DEST_ADDR)
5671     v->always_computable = 1;
5672   else
5673     v->always_computable = ! not_every_iteration;
5674
5675   v->always_executed = ! not_every_iteration;
5676
5677   if (type == DEST_ADDR)
5678     {
5679       v->mode = GET_MODE (*location);
5680       v->lifetime = 1;
5681     }
5682   else /* type == DEST_REG */
5683     {
5684       v->mode = GET_MODE (SET_DEST (set));
5685
5686       v->lifetime = LOOP_REG_LIFETIME (loop, REGNO (dest_reg));
5687
5688       /* If the lifetime is zero, it means that this register is
5689          really a dead store.  So mark this as a giv that can be
5690          ignored.  This will not prevent the biv from being eliminated.  */
5691       if (v->lifetime == 0)
5692         v->ignore = 1;
5693
5694       REG_IV_TYPE (ivs, REGNO (dest_reg)) = GENERAL_INDUCT;
5695       REG_IV_INFO (ivs, REGNO (dest_reg)) = v;
5696     }
5697
5698   /* Add the giv to the class of givs computed from one biv.  */
5699
5700   bl = REG_IV_CLASS (ivs, REGNO (src_reg));
5701   if (bl)
5702     {
5703       v->next_iv = bl->giv;
5704       bl->giv = v;
5705       /* Don't count DEST_ADDR.  This is supposed to count the number of
5706          insns that calculate givs.  */
5707       if (type == DEST_REG)
5708         bl->giv_count++;
5709       bl->total_benefit += benefit;
5710     }
5711   else
5712     /* Fatal error, biv missing for this giv?  */
5713     abort ();
5714
5715   if (type == DEST_ADDR)
5716     v->replaceable = 1;
5717   else
5718     {
5719       /* The giv can be replaced outright by the reduced register only if all
5720          of the following conditions are true:
5721          - the insn that sets the giv is always executed on any iteration
5722            on which the giv is used at all
5723            (there are two ways to deduce this:
5724             either the insn is executed on every iteration,
5725             or all uses follow that insn in the same basic block),
5726          - the giv is not used outside the loop
5727          - no assignments to the biv occur during the giv's lifetime.  */
5728
5729       if (REGNO_FIRST_UID (REGNO (dest_reg)) == INSN_UID (insn)
5730           /* Previous line always fails if INSN was moved by loop opt.  */
5731           && REGNO_LAST_LUID (REGNO (dest_reg))
5732           < INSN_LUID (loop->end)
5733           && (! not_every_iteration
5734               || last_use_this_basic_block (dest_reg, insn)))
5735         {
5736           /* Now check that there are no assignments to the biv within the
5737              giv's lifetime.  This requires two separate checks.  */
5738
5739           /* Check each biv update, and fail if any are between the first
5740              and last use of the giv.
5741
5742              If this loop contains an inner loop that was unrolled, then
5743              the insn modifying the biv may have been emitted by the loop
5744              unrolling code, and hence does not have a valid luid.  Just
5745              mark the biv as not replaceable in this case.  It is not very
5746              useful as a biv, because it is used in two different loops.
5747              It is very unlikely that we would be able to optimize the giv
5748              using this biv anyways.  */
5749
5750           v->replaceable = 1;
5751           for (b = bl->biv; b; b = b->next_iv)
5752             {
5753               if (INSN_UID (b->insn) >= max_uid_for_loop
5754                   || ((INSN_LUID (b->insn)
5755                        >= REGNO_FIRST_LUID (REGNO (dest_reg)))
5756                       && (INSN_LUID (b->insn)
5757                           <= REGNO_LAST_LUID (REGNO (dest_reg)))))
5758                 {
5759                   v->replaceable = 0;
5760                   v->not_replaceable = 1;
5761                   break;
5762                 }
5763             }
5764
5765           /* If there are any backwards branches that go from after the
5766              biv update to before it, then this giv is not replaceable.  */
5767           if (v->replaceable)
5768             for (b = bl->biv; b; b = b->next_iv)
5769               if (back_branch_in_range_p (loop, b->insn))
5770                 {
5771                   v->replaceable = 0;
5772                   v->not_replaceable = 1;
5773                   break;
5774                 }
5775         }
5776       else
5777         {
5778           /* May still be replaceable, we don't have enough info here to
5779              decide.  */
5780           v->replaceable = 0;
5781           v->not_replaceable = 0;
5782         }
5783     }
5784
5785   /* Record whether the add_val contains a const_int, for later use by
5786      combine_givs.  */
5787   {
5788     rtx tem = add_val;
5789
5790     v->no_const_addval = 1;
5791     if (tem == const0_rtx)
5792       ;
5793     else if (CONSTANT_P (add_val))
5794       v->no_const_addval = 0;
5795     if (GET_CODE (tem) == PLUS)
5796       {
5797         while (1)
5798           {
5799             if (GET_CODE (XEXP (tem, 0)) == PLUS)
5800               tem = XEXP (tem, 0);
5801             else if (GET_CODE (XEXP (tem, 1)) == PLUS)
5802               tem = XEXP (tem, 1);
5803             else
5804               break;
5805           }
5806         if (CONSTANT_P (XEXP (tem, 1)))
5807           v->no_const_addval = 0;
5808       }
5809   }
5810
5811   if (loop_dump_stream)
5812     loop_giv_dump (v, loop_dump_stream, 0);
5813 }
5814
5815 /* All this does is determine whether a giv can be made replaceable because
5816    its final value can be calculated.  This code can not be part of record_giv
5817    above, because final_giv_value requires that the number of loop iterations
5818    be known, and that can not be accurately calculated until after all givs
5819    have been identified.  */
5820
5821 static void
5822 check_final_value (loop, v)
5823      const struct loop *loop;
5824      struct induction *v;
5825 {
5826   struct loop_ivs *ivs = LOOP_IVS (loop);
5827   struct iv_class *bl;
5828   rtx final_value = 0;
5829
5830   bl = REG_IV_CLASS (ivs, REGNO (v->src_reg));
5831
5832   /* DEST_ADDR givs will never reach here, because they are always marked
5833      replaceable above in record_giv.  */
5834
5835   /* The giv can be replaced outright by the reduced register only if all
5836      of the following conditions are true:
5837      - the insn that sets the giv is always executed on any iteration
5838        on which the giv is used at all
5839        (there are two ways to deduce this:
5840         either the insn is executed on every iteration,
5841         or all uses follow that insn in the same basic block),
5842      - its final value can be calculated (this condition is different
5843        than the one above in record_giv)
5844      - it's not used before the it's set
5845      - no assignments to the biv occur during the giv's lifetime.  */
5846
5847 #if 0
5848   /* This is only called now when replaceable is known to be false.  */
5849   /* Clear replaceable, so that it won't confuse final_giv_value.  */
5850   v->replaceable = 0;
5851 #endif
5852
5853   if ((final_value = final_giv_value (loop, v))
5854       && (v->always_executed || last_use_this_basic_block (v->dest_reg, v->insn)))
5855     {
5856       int biv_increment_seen = 0, before_giv_insn = 0;
5857       rtx p = v->insn;
5858       rtx last_giv_use;
5859
5860       v->replaceable = 1;
5861
5862       /* When trying to determine whether or not a biv increment occurs
5863          during the lifetime of the giv, we can ignore uses of the variable
5864          outside the loop because final_value is true.  Hence we can not
5865          use regno_last_uid and regno_first_uid as above in record_giv.  */
5866
5867       /* Search the loop to determine whether any assignments to the
5868          biv occur during the giv's lifetime.  Start with the insn
5869          that sets the giv, and search around the loop until we come
5870          back to that insn again.
5871
5872          Also fail if there is a jump within the giv's lifetime that jumps
5873          to somewhere outside the lifetime but still within the loop.  This
5874          catches spaghetti code where the execution order is not linear, and
5875          hence the above test fails.  Here we assume that the giv lifetime
5876          does not extend from one iteration of the loop to the next, so as
5877          to make the test easier.  Since the lifetime isn't known yet,
5878          this requires two loops.  See also record_giv above.  */
5879
5880       last_giv_use = v->insn;
5881
5882       while (1)
5883         {
5884           p = NEXT_INSN (p);
5885           if (p == loop->end)
5886             {
5887               before_giv_insn = 1;
5888               p = NEXT_INSN (loop->start);
5889             }
5890           if (p == v->insn)
5891             break;
5892
5893           if (GET_CODE (p) == INSN || GET_CODE (p) == JUMP_INSN
5894               || GET_CODE (p) == CALL_INSN)
5895             {
5896               /* It is possible for the BIV increment to use the GIV if we
5897                  have a cycle.  Thus we must be sure to check each insn for
5898                  both BIV and GIV uses, and we must check for BIV uses
5899                  first.  */
5900
5901               if (! biv_increment_seen
5902                   && reg_set_p (v->src_reg, PATTERN (p)))
5903                 biv_increment_seen = 1;
5904
5905               if (reg_mentioned_p (v->dest_reg, PATTERN (p)))
5906                 {
5907                   if (biv_increment_seen || before_giv_insn)
5908                     {
5909                       v->replaceable = 0;
5910                       v->not_replaceable = 1;
5911                       break;
5912                     }
5913                   last_giv_use = p;
5914                 }
5915             }
5916         }
5917
5918       /* Now that the lifetime of the giv is known, check for branches
5919          from within the lifetime to outside the lifetime if it is still
5920          replaceable.  */
5921
5922       if (v->replaceable)
5923         {
5924           p = v->insn;
5925           while (1)
5926             {
5927               p = NEXT_INSN (p);
5928               if (p == loop->end)
5929                 p = NEXT_INSN (loop->start);
5930               if (p == last_giv_use)
5931                 break;
5932
5933               if (GET_CODE (p) == JUMP_INSN && JUMP_LABEL (p)
5934                   && LABEL_NAME (JUMP_LABEL (p))
5935                   && ((loop_insn_first_p (JUMP_LABEL (p), v->insn)
5936                        && loop_insn_first_p (loop->start, JUMP_LABEL (p)))
5937                       || (loop_insn_first_p (last_giv_use, JUMP_LABEL (p))
5938                           && loop_insn_first_p (JUMP_LABEL (p), loop->end))))
5939                 {
5940                   v->replaceable = 0;
5941                   v->not_replaceable = 1;
5942
5943                   if (loop_dump_stream)
5944                     fprintf (loop_dump_stream,
5945                              "Found branch outside giv lifetime.\n");
5946
5947                   break;
5948                 }
5949             }
5950         }
5951
5952       /* If it is replaceable, then save the final value.  */
5953       if (v->replaceable)
5954         v->final_value = final_value;
5955     }
5956
5957   if (loop_dump_stream && v->replaceable)
5958     fprintf (loop_dump_stream, "Insn %d: giv reg %d final_value replaceable\n",
5959              INSN_UID (v->insn), REGNO (v->dest_reg));
5960 }
5961 \f
5962 /* Update the status of whether a giv can derive other givs.
5963
5964    We need to do something special if there is or may be an update to the biv
5965    between the time the giv is defined and the time it is used to derive
5966    another giv.
5967
5968    In addition, a giv that is only conditionally set is not allowed to
5969    derive another giv once a label has been passed.
5970
5971    The cases we look at are when a label or an update to a biv is passed.  */
5972
5973 static void
5974 update_giv_derive (loop, p)
5975      const struct loop *loop;
5976      rtx p;
5977 {
5978   struct loop_ivs *ivs = LOOP_IVS (loop);
5979   struct iv_class *bl;
5980   struct induction *biv, *giv;
5981   rtx tem;
5982   int dummy;
5983
5984   /* Search all IV classes, then all bivs, and finally all givs.
5985
5986      There are three cases we are concerned with.  First we have the situation
5987      of a giv that is only updated conditionally.  In that case, it may not
5988      derive any givs after a label is passed.
5989
5990      The second case is when a biv update occurs, or may occur, after the
5991      definition of a giv.  For certain biv updates (see below) that are
5992      known to occur between the giv definition and use, we can adjust the
5993      giv definition.  For others, or when the biv update is conditional,
5994      we must prevent the giv from deriving any other givs.  There are two
5995      sub-cases within this case.
5996
5997      If this is a label, we are concerned with any biv update that is done
5998      conditionally, since it may be done after the giv is defined followed by
5999      a branch here (actually, we need to pass both a jump and a label, but
6000      this extra tracking doesn't seem worth it).
6001
6002      If this is a jump, we are concerned about any biv update that may be
6003      executed multiple times.  We are actually only concerned about
6004      backward jumps, but it is probably not worth performing the test
6005      on the jump again here.
6006
6007      If this is a biv update, we must adjust the giv status to show that a
6008      subsequent biv update was performed.  If this adjustment cannot be done,
6009      the giv cannot derive further givs.  */
6010
6011   for (bl = ivs->list; bl; bl = bl->next)
6012     for (biv = bl->biv; biv; biv = biv->next_iv)
6013       if (GET_CODE (p) == CODE_LABEL || GET_CODE (p) == JUMP_INSN
6014           || biv->insn == p)
6015         {
6016           for (giv = bl->giv; giv; giv = giv->next_iv)
6017             {
6018               /* If cant_derive is already true, there is no point in
6019                  checking all of these conditions again.  */
6020               if (giv->cant_derive)
6021                 continue;
6022
6023               /* If this giv is conditionally set and we have passed a label,
6024                  it cannot derive anything.  */
6025               if (GET_CODE (p) == CODE_LABEL && ! giv->always_computable)
6026                 giv->cant_derive = 1;
6027
6028               /* Skip givs that have mult_val == 0, since
6029                  they are really invariants.  Also skip those that are
6030                  replaceable, since we know their lifetime doesn't contain
6031                  any biv update.  */
6032               else if (giv->mult_val == const0_rtx || giv->replaceable)
6033                 continue;
6034
6035               /* The only way we can allow this giv to derive another
6036                  is if this is a biv increment and we can form the product
6037                  of biv->add_val and giv->mult_val.  In this case, we will
6038                  be able to compute a compensation.  */
6039               else if (biv->insn == p)
6040                 {
6041                   rtx ext_val_dummy;
6042
6043                   tem = 0;
6044                   if (biv->mult_val == const1_rtx)
6045                     tem = simplify_giv_expr (loop,
6046                                              gen_rtx_MULT (giv->mode,
6047                                                            biv->add_val,
6048                                                            giv->mult_val),
6049                                              &ext_val_dummy, &dummy);
6050
6051                   if (tem && giv->derive_adjustment)
6052                     tem = simplify_giv_expr
6053                       (loop,
6054                        gen_rtx_PLUS (giv->mode, tem, giv->derive_adjustment),
6055                        &ext_val_dummy, &dummy);
6056
6057                   if (tem)
6058                     giv->derive_adjustment = tem;
6059                   else
6060                     giv->cant_derive = 1;
6061                 }
6062               else if ((GET_CODE (p) == CODE_LABEL && ! biv->always_computable)
6063                        || (GET_CODE (p) == JUMP_INSN && biv->maybe_multiple))
6064                 giv->cant_derive = 1;
6065             }
6066         }
6067 }
6068 \f
6069 /* Check whether an insn is an increment legitimate for a basic induction var.
6070    X is the source of insn P, or a part of it.
6071    MODE is the mode in which X should be interpreted.
6072
6073    DEST_REG is the putative biv, also the destination of the insn.
6074    We accept patterns of these forms:
6075      REG = REG + INVARIANT (includes REG = REG - CONSTANT)
6076      REG = INVARIANT + REG
6077
6078    If X is suitable, we return 1, set *MULT_VAL to CONST1_RTX,
6079    store the additive term into *INC_VAL, and store the place where
6080    we found the additive term into *LOCATION.
6081
6082    If X is an assignment of an invariant into DEST_REG, we set
6083    *MULT_VAL to CONST0_RTX, and store the invariant into *INC_VAL.
6084
6085    We also want to detect a BIV when it corresponds to a variable
6086    whose mode was promoted via PROMOTED_MODE.  In that case, an increment
6087    of the variable may be a PLUS that adds a SUBREG of that variable to
6088    an invariant and then sign- or zero-extends the result of the PLUS
6089    into the variable.
6090
6091    Most GIVs in such cases will be in the promoted mode, since that is the
6092    probably the natural computation mode (and almost certainly the mode
6093    used for addresses) on the machine.  So we view the pseudo-reg containing
6094    the variable as the BIV, as if it were simply incremented.
6095
6096    Note that treating the entire pseudo as a BIV will result in making
6097    simple increments to any GIVs based on it.  However, if the variable
6098    overflows in its declared mode but not its promoted mode, the result will
6099    be incorrect.  This is acceptable if the variable is signed, since
6100    overflows in such cases are undefined, but not if it is unsigned, since
6101    those overflows are defined.  So we only check for SIGN_EXTEND and
6102    not ZERO_EXTEND.
6103
6104    If we cannot find a biv, we return 0.  */
6105
6106 static int
6107 basic_induction_var (loop, x, mode, dest_reg, p, inc_val, mult_val, location)
6108      const struct loop *loop;
6109      rtx x;
6110      enum machine_mode mode;
6111      rtx dest_reg;
6112      rtx p;
6113      rtx *inc_val;
6114      rtx *mult_val;
6115      rtx **location;
6116 {
6117   enum rtx_code code;
6118   rtx *argp, arg;
6119   rtx insn, set = 0;
6120
6121   code = GET_CODE (x);
6122   *location = NULL;
6123   switch (code)
6124     {
6125     case PLUS:
6126       if (rtx_equal_p (XEXP (x, 0), dest_reg)
6127           || (GET_CODE (XEXP (x, 0)) == SUBREG
6128               && SUBREG_PROMOTED_VAR_P (XEXP (x, 0))
6129               && SUBREG_REG (XEXP (x, 0)) == dest_reg))
6130         {
6131           argp = &XEXP (x, 1);
6132         }
6133       else if (rtx_equal_p (XEXP (x, 1), dest_reg)
6134                || (GET_CODE (XEXP (x, 1)) == SUBREG
6135                    && SUBREG_PROMOTED_VAR_P (XEXP (x, 1))
6136                    && SUBREG_REG (XEXP (x, 1)) == dest_reg))
6137         {
6138           argp = &XEXP (x, 0);
6139         }
6140       else
6141         return 0;
6142
6143       arg = *argp;
6144       if (loop_invariant_p (loop, arg) != 1)
6145         return 0;
6146
6147       *inc_val = convert_modes (GET_MODE (dest_reg), GET_MODE (x), arg, 0);
6148       *mult_val = const1_rtx;
6149       *location = argp;
6150       return 1;
6151
6152     case SUBREG:
6153       /* If what's inside the SUBREG is a BIV, then the SUBREG.  This will
6154          handle addition of promoted variables.
6155          ??? The comment at the start of this function is wrong: promoted
6156          variable increments don't look like it says they do.  */
6157       return basic_induction_var (loop, SUBREG_REG (x),
6158                                   GET_MODE (SUBREG_REG (x)),
6159                                   dest_reg, p, inc_val, mult_val, location);
6160
6161     case REG:
6162       /* If this register is assigned in a previous insn, look at its
6163          source, but don't go outside the loop or past a label.  */
6164
6165       /* If this sets a register to itself, we would repeat any previous
6166          biv increment if we applied this strategy blindly.  */
6167       if (rtx_equal_p (dest_reg, x))
6168         return 0;
6169
6170       insn = p;
6171       while (1)
6172         {
6173           rtx dest;
6174           do
6175             {
6176               insn = PREV_INSN (insn);
6177             }
6178           while (insn && GET_CODE (insn) == NOTE
6179                  && NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_BEG);
6180
6181           if (!insn)
6182             break;
6183           set = single_set (insn);
6184           if (set == 0)
6185             break;
6186           dest = SET_DEST (set);
6187           if (dest == x
6188               || (GET_CODE (dest) == SUBREG
6189                   && (GET_MODE_SIZE (GET_MODE (dest)) <= UNITS_PER_WORD)
6190                   && (GET_MODE_CLASS (GET_MODE (dest)) == MODE_INT)
6191                   && SUBREG_REG (dest) == x))
6192             return basic_induction_var (loop, SET_SRC (set),
6193                                         (GET_MODE (SET_SRC (set)) == VOIDmode
6194                                          ? GET_MODE (x)
6195                                          : GET_MODE (SET_SRC (set))),
6196                                         dest_reg, insn,
6197                                         inc_val, mult_val, location);
6198
6199           while (GET_CODE (dest) == SIGN_EXTRACT
6200                  || GET_CODE (dest) == ZERO_EXTRACT
6201                  || GET_CODE (dest) == SUBREG
6202                  || GET_CODE (dest) == STRICT_LOW_PART)
6203             dest = XEXP (dest, 0);
6204           if (dest == x)
6205             break;
6206         }
6207       /* Fall through.  */
6208
6209       /* Can accept constant setting of biv only when inside inner most loop.
6210          Otherwise, a biv of an inner loop may be incorrectly recognized
6211          as a biv of the outer loop,
6212          causing code to be moved INTO the inner loop.  */
6213     case MEM:
6214       if (loop_invariant_p (loop, x) != 1)
6215         return 0;
6216     case CONST_INT:
6217     case SYMBOL_REF:
6218     case CONST:
6219       /* convert_modes aborts if we try to convert to or from CCmode, so just
6220          exclude that case.  It is very unlikely that a condition code value
6221          would be a useful iterator anyways.  convert_modes aborts if we try to
6222          convert a float mode to non-float or vice versa too.  */
6223       if (loop->level == 1
6224           && GET_MODE_CLASS (mode) == GET_MODE_CLASS (GET_MODE (dest_reg))
6225           && GET_MODE_CLASS (mode) != MODE_CC)
6226         {
6227           /* Possible bug here?  Perhaps we don't know the mode of X.  */
6228           *inc_val = convert_modes (GET_MODE (dest_reg), mode, x, 0);
6229           *mult_val = const0_rtx;
6230           return 1;
6231         }
6232       else
6233         return 0;
6234
6235     case SIGN_EXTEND:
6236       return basic_induction_var (loop, XEXP (x, 0), GET_MODE (XEXP (x, 0)),
6237                                   dest_reg, p, inc_val, mult_val, location);
6238
6239     case ASHIFTRT:
6240       /* Similar, since this can be a sign extension.  */
6241       for (insn = PREV_INSN (p);
6242            (insn && GET_CODE (insn) == NOTE
6243             && NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_BEG);
6244            insn = PREV_INSN (insn))
6245         ;
6246
6247       if (insn)
6248         set = single_set (insn);
6249
6250       if (! rtx_equal_p (dest_reg, XEXP (x, 0))
6251           && set && SET_DEST (set) == XEXP (x, 0)
6252           && GET_CODE (XEXP (x, 1)) == CONST_INT
6253           && INTVAL (XEXP (x, 1)) >= 0
6254           && GET_CODE (SET_SRC (set)) == ASHIFT
6255           && XEXP (x, 1) == XEXP (SET_SRC (set), 1))
6256         return basic_induction_var (loop, XEXP (SET_SRC (set), 0),
6257                                     GET_MODE (XEXP (x, 0)),
6258                                     dest_reg, insn, inc_val, mult_val,
6259                                     location);
6260       return 0;
6261
6262     default:
6263       return 0;
6264     }
6265 }
6266 \f
6267 /* A general induction variable (giv) is any quantity that is a linear
6268    function   of a basic induction variable,
6269    i.e. giv = biv * mult_val + add_val.
6270    The coefficients can be any loop invariant quantity.
6271    A giv need not be computed directly from the biv;
6272    it can be computed by way of other givs.  */
6273
6274 /* Determine whether X computes a giv.
6275    If it does, return a nonzero value
6276      which is the benefit from eliminating the computation of X;
6277    set *SRC_REG to the register of the biv that it is computed from;
6278    set *ADD_VAL and *MULT_VAL to the coefficients,
6279      such that the value of X is biv * mult + add;  */
6280
6281 static int
6282 general_induction_var (loop, x, src_reg, add_val, mult_val, ext_val,
6283                        is_addr, pbenefit, addr_mode)
6284      const struct loop *loop;
6285      rtx x;
6286      rtx *src_reg;
6287      rtx *add_val;
6288      rtx *mult_val;
6289      rtx *ext_val;
6290      int is_addr;
6291      int *pbenefit;
6292      enum machine_mode addr_mode;
6293 {
6294   struct loop_ivs *ivs = LOOP_IVS (loop);
6295   rtx orig_x = x;
6296
6297   /* If this is an invariant, forget it, it isn't a giv.  */
6298   if (loop_invariant_p (loop, x) == 1)
6299     return 0;
6300
6301   *pbenefit = 0;
6302   *ext_val = NULL_RTX;
6303   x = simplify_giv_expr (loop, x, ext_val, pbenefit);
6304   if (x == 0)
6305     return 0;
6306
6307   switch (GET_CODE (x))
6308     {
6309     case USE:
6310     case CONST_INT:
6311       /* Since this is now an invariant and wasn't before, it must be a giv
6312          with MULT_VAL == 0.  It doesn't matter which BIV we associate this
6313          with.  */
6314       *src_reg = ivs->list->biv->dest_reg;
6315       *mult_val = const0_rtx;
6316       *add_val = x;
6317       break;
6318
6319     case REG:
6320       /* This is equivalent to a BIV.  */
6321       *src_reg = x;
6322       *mult_val = const1_rtx;
6323       *add_val = const0_rtx;
6324       break;
6325
6326     case PLUS:
6327       /* Either (plus (biv) (invar)) or
6328          (plus (mult (biv) (invar_1)) (invar_2)).  */
6329       if (GET_CODE (XEXP (x, 0)) == MULT)
6330         {
6331           *src_reg = XEXP (XEXP (x, 0), 0);
6332           *mult_val = XEXP (XEXP (x, 0), 1);
6333         }
6334       else
6335         {
6336           *src_reg = XEXP (x, 0);
6337           *mult_val = const1_rtx;
6338         }
6339       *add_val = XEXP (x, 1);
6340       break;
6341
6342     case MULT:
6343       /* ADD_VAL is zero.  */
6344       *src_reg = XEXP (x, 0);
6345       *mult_val = XEXP (x, 1);
6346       *add_val = const0_rtx;
6347       break;
6348
6349     default:
6350       abort ();
6351     }
6352
6353   /* Remove any enclosing USE from ADD_VAL and MULT_VAL (there will be
6354      unless they are CONST_INT).  */
6355   if (GET_CODE (*add_val) == USE)
6356     *add_val = XEXP (*add_val, 0);
6357   if (GET_CODE (*mult_val) == USE)
6358     *mult_val = XEXP (*mult_val, 0);
6359
6360   if (is_addr)
6361     *pbenefit += address_cost (orig_x, addr_mode) - reg_address_cost;
6362   else
6363     *pbenefit += rtx_cost (orig_x, SET);
6364
6365   /* Always return true if this is a giv so it will be detected as such,
6366      even if the benefit is zero or negative.  This allows elimination
6367      of bivs that might otherwise not be eliminated.  */
6368   return 1;
6369 }
6370 \f
6371 /* Given an expression, X, try to form it as a linear function of a biv.
6372    We will canonicalize it to be of the form
6373         (plus (mult (BIV) (invar_1))
6374               (invar_2))
6375    with possible degeneracies.
6376
6377    The invariant expressions must each be of a form that can be used as a
6378    machine operand.  We surround then with a USE rtx (a hack, but localized
6379    and certainly unambiguous!) if not a CONST_INT for simplicity in this
6380    routine; it is the caller's responsibility to strip them.
6381
6382    If no such canonicalization is possible (i.e., two biv's are used or an
6383    expression that is neither invariant nor a biv or giv), this routine
6384    returns 0.
6385
6386    For a non-zero return, the result will have a code of CONST_INT, USE,
6387    REG (for a BIV), PLUS, or MULT.  No other codes will occur.
6388
6389    *BENEFIT will be incremented by the benefit of any sub-giv encountered.  */
6390
6391 static rtx sge_plus PARAMS ((enum machine_mode, rtx, rtx));
6392 static rtx sge_plus_constant PARAMS ((rtx, rtx));
6393
6394 static rtx
6395 simplify_giv_expr (loop, x, ext_val, benefit)
6396      const struct loop *loop;
6397      rtx x;
6398      rtx *ext_val;
6399      int *benefit;
6400 {
6401   struct loop_ivs *ivs = LOOP_IVS (loop);
6402   struct loop_regs *regs = LOOP_REGS (loop);
6403   enum machine_mode mode = GET_MODE (x);
6404   rtx arg0, arg1;
6405   rtx tem;
6406
6407   /* If this is not an integer mode, or if we cannot do arithmetic in this
6408      mode, this can't be a giv.  */
6409   if (mode != VOIDmode
6410       && (GET_MODE_CLASS (mode) != MODE_INT
6411           || GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT))
6412     return NULL_RTX;
6413
6414   switch (GET_CODE (x))
6415     {
6416     case PLUS:
6417       arg0 = simplify_giv_expr (loop, XEXP (x, 0), ext_val, benefit);
6418       arg1 = simplify_giv_expr (loop, XEXP (x, 1), ext_val, benefit);
6419       if (arg0 == 0 || arg1 == 0)
6420         return NULL_RTX;
6421
6422       /* Put constant last, CONST_INT last if both constant.  */
6423       if ((GET_CODE (arg0) == USE
6424            || GET_CODE (arg0) == CONST_INT)
6425           && ! ((GET_CODE (arg0) == USE
6426                  && GET_CODE (arg1) == USE)
6427                 || GET_CODE (arg1) == CONST_INT))
6428         tem = arg0, arg0 = arg1, arg1 = tem;
6429
6430       /* Handle addition of zero, then addition of an invariant.  */
6431       if (arg1 == const0_rtx)
6432         return arg0;
6433       else if (GET_CODE (arg1) == CONST_INT || GET_CODE (arg1) == USE)
6434         switch (GET_CODE (arg0))
6435           {
6436           case CONST_INT:
6437           case USE:
6438             /* Adding two invariants must result in an invariant, so enclose
6439                addition operation inside a USE and return it.  */
6440             if (GET_CODE (arg0) == USE)
6441               arg0 = XEXP (arg0, 0);
6442             if (GET_CODE (arg1) == USE)
6443               arg1 = XEXP (arg1, 0);
6444
6445             if (GET_CODE (arg0) == CONST_INT)
6446               tem = arg0, arg0 = arg1, arg1 = tem;
6447             if (GET_CODE (arg1) == CONST_INT)
6448               tem = sge_plus_constant (arg0, arg1);
6449             else
6450               tem = sge_plus (mode, arg0, arg1);
6451
6452             if (GET_CODE (tem) != CONST_INT)
6453               tem = gen_rtx_USE (mode, tem);
6454             return tem;
6455
6456           case REG:
6457           case MULT:
6458             /* biv + invar or mult + invar.  Return sum.  */
6459             return gen_rtx_PLUS (mode, arg0, arg1);
6460
6461           case PLUS:
6462             /* (a + invar_1) + invar_2.  Associate.  */
6463             return
6464               simplify_giv_expr (loop,
6465                                  gen_rtx_PLUS (mode,
6466                                                XEXP (arg0, 0),
6467                                                gen_rtx_PLUS (mode,
6468                                                              XEXP (arg0, 1),
6469                                                              arg1)),
6470                                  ext_val, benefit);
6471
6472           default:
6473             abort ();
6474           }
6475
6476       /* Each argument must be either REG, PLUS, or MULT.  Convert REG to
6477          MULT to reduce cases.  */
6478       if (GET_CODE (arg0) == REG)
6479         arg0 = gen_rtx_MULT (mode, arg0, const1_rtx);
6480       if (GET_CODE (arg1) == REG)
6481         arg1 = gen_rtx_MULT (mode, arg1, const1_rtx);
6482
6483       /* Now have PLUS + PLUS, PLUS + MULT, MULT + PLUS, or MULT + MULT.
6484          Put a MULT first, leaving PLUS + PLUS, MULT + PLUS, or MULT + MULT.
6485          Recurse to associate the second PLUS.  */
6486       if (GET_CODE (arg1) == MULT)
6487         tem = arg0, arg0 = arg1, arg1 = tem;
6488
6489       if (GET_CODE (arg1) == PLUS)
6490         return
6491           simplify_giv_expr (loop,
6492                              gen_rtx_PLUS (mode,
6493                                            gen_rtx_PLUS (mode, arg0,
6494                                                          XEXP (arg1, 0)),
6495                                            XEXP (arg1, 1)),
6496                              ext_val, benefit);
6497
6498       /* Now must have MULT + MULT.  Distribute if same biv, else not giv.  */
6499       if (GET_CODE (arg0) != MULT || GET_CODE (arg1) != MULT)
6500         return NULL_RTX;
6501
6502       if (!rtx_equal_p (arg0, arg1))
6503         return NULL_RTX;
6504
6505       return simplify_giv_expr (loop,
6506                                 gen_rtx_MULT (mode,
6507                                               XEXP (arg0, 0),
6508                                               gen_rtx_PLUS (mode,
6509                                                             XEXP (arg0, 1),
6510                                                             XEXP (arg1, 1))),
6511                                 ext_val, benefit);
6512
6513     case MINUS:
6514       /* Handle "a - b" as "a + b * (-1)".  */
6515       return simplify_giv_expr (loop,
6516                                 gen_rtx_PLUS (mode,
6517                                               XEXP (x, 0),
6518                                               gen_rtx_MULT (mode,
6519                                                             XEXP (x, 1),
6520                                                             constm1_rtx)),
6521                                 ext_val, benefit);
6522
6523     case MULT:
6524       arg0 = simplify_giv_expr (loop, XEXP (x, 0), ext_val, benefit);
6525       arg1 = simplify_giv_expr (loop, XEXP (x, 1), ext_val, benefit);
6526       if (arg0 == 0 || arg1 == 0)
6527         return NULL_RTX;
6528
6529       /* Put constant last, CONST_INT last if both constant.  */
6530       if ((GET_CODE (arg0) == USE || GET_CODE (arg0) == CONST_INT)
6531           && GET_CODE (arg1) != CONST_INT)
6532         tem = arg0, arg0 = arg1, arg1 = tem;
6533
6534       /* If second argument is not now constant, not giv.  */
6535       if (GET_CODE (arg1) != USE && GET_CODE (arg1) != CONST_INT)
6536         return NULL_RTX;
6537
6538       /* Handle multiply by 0 or 1.  */
6539       if (arg1 == const0_rtx)
6540         return const0_rtx;
6541
6542       else if (arg1 == const1_rtx)
6543         return arg0;
6544
6545       switch (GET_CODE (arg0))
6546         {
6547         case REG:
6548           /* biv * invar.  Done.  */
6549           return gen_rtx_MULT (mode, arg0, arg1);
6550
6551         case CONST_INT:
6552           /* Product of two constants.  */
6553           return GEN_INT (INTVAL (arg0) * INTVAL (arg1));
6554
6555         case USE:
6556           /* invar * invar is a giv, but attempt to simplify it somehow.  */
6557           if (GET_CODE (arg1) != CONST_INT)
6558             return NULL_RTX;
6559
6560           arg0 = XEXP (arg0, 0);
6561           if (GET_CODE (arg0) == MULT)
6562             {
6563               /* (invar_0 * invar_1) * invar_2.  Associate.  */
6564               return simplify_giv_expr (loop,
6565                                         gen_rtx_MULT (mode,
6566                                                       XEXP (arg0, 0),
6567                                                       gen_rtx_MULT (mode,
6568                                                                     XEXP (arg0,
6569                                                                           1),
6570                                                                     arg1)),
6571                                         ext_val, benefit);
6572             }
6573           /* Porpagate the MULT expressions to the intermost nodes.  */
6574           else if (GET_CODE (arg0) == PLUS)
6575             {
6576               /* (invar_0 + invar_1) * invar_2.  Distribute.  */
6577               return simplify_giv_expr (loop,
6578                                         gen_rtx_PLUS (mode,
6579                                                       gen_rtx_MULT (mode,
6580                                                                     XEXP (arg0,
6581                                                                           0),
6582                                                                     arg1),
6583                                                       gen_rtx_MULT (mode,
6584                                                                     XEXP (arg0,
6585                                                                           1),
6586                                                                     arg1)),
6587                                         ext_val, benefit);
6588             }
6589           return gen_rtx_USE (mode, gen_rtx_MULT (mode, arg0, arg1));
6590
6591         case MULT:
6592           /* (a * invar_1) * invar_2.  Associate.  */
6593           return simplify_giv_expr (loop,
6594                                     gen_rtx_MULT (mode,
6595                                                   XEXP (arg0, 0),
6596                                                   gen_rtx_MULT (mode,
6597                                                                 XEXP (arg0, 1),
6598                                                                 arg1)),
6599                                     ext_val, benefit);
6600
6601         case PLUS:
6602           /* (a + invar_1) * invar_2.  Distribute.  */
6603           return simplify_giv_expr (loop,
6604                                     gen_rtx_PLUS (mode,
6605                                                   gen_rtx_MULT (mode,
6606                                                                 XEXP (arg0, 0),
6607                                                                 arg1),
6608                                                   gen_rtx_MULT (mode,
6609                                                                 XEXP (arg0, 1),
6610                                                                 arg1)),
6611                                     ext_val, benefit);
6612
6613         default:
6614           abort ();
6615         }
6616
6617     case ASHIFT:
6618       /* Shift by constant is multiply by power of two.  */
6619       if (GET_CODE (XEXP (x, 1)) != CONST_INT)
6620         return 0;
6621
6622       return
6623         simplify_giv_expr (loop,
6624                            gen_rtx_MULT (mode,
6625                                          XEXP (x, 0),
6626                                          GEN_INT ((HOST_WIDE_INT) 1
6627                                                   << INTVAL (XEXP (x, 1)))),
6628                            ext_val, benefit);
6629
6630     case NEG:
6631       /* "-a" is "a * (-1)" */
6632       return simplify_giv_expr (loop,
6633                                 gen_rtx_MULT (mode, XEXP (x, 0), constm1_rtx),
6634                                 ext_val, benefit);
6635
6636     case NOT:
6637       /* "~a" is "-a - 1". Silly, but easy.  */
6638       return simplify_giv_expr (loop,
6639                                 gen_rtx_MINUS (mode,
6640                                                gen_rtx_NEG (mode, XEXP (x, 0)),
6641                                                const1_rtx),
6642                                 ext_val, benefit);
6643
6644     case USE:
6645       /* Already in proper form for invariant.  */
6646       return x;
6647
6648     case SIGN_EXTEND:
6649     case ZERO_EXTEND:
6650     case TRUNCATE:
6651       /* Conditionally recognize extensions of simple IVs.  After we've
6652          computed loop traversal counts and verified the range of the
6653          source IV, we'll reevaluate this as a GIV.  */
6654       if (*ext_val == NULL_RTX)
6655         {
6656           arg0 = simplify_giv_expr (loop, XEXP (x, 0), ext_val, benefit);
6657           if (arg0 && *ext_val == NULL_RTX && GET_CODE (arg0) == REG)
6658             {
6659               *ext_val = gen_rtx_fmt_e (GET_CODE (x), mode, arg0);
6660               return arg0;
6661             }
6662         }
6663       goto do_default;
6664
6665     case REG:
6666       /* If this is a new register, we can't deal with it.  */
6667       if (REGNO (x) >= max_reg_before_loop)
6668         return 0;
6669
6670       /* Check for biv or giv.  */
6671       switch (REG_IV_TYPE (ivs, REGNO (x)))
6672         {
6673         case BASIC_INDUCT:
6674           return x;
6675         case GENERAL_INDUCT:
6676           {
6677             struct induction *v = REG_IV_INFO (ivs, REGNO (x));
6678
6679             /* Form expression from giv and add benefit.  Ensure this giv
6680                can derive another and subtract any needed adjustment if so.  */
6681
6682             /* Increasing the benefit here is risky.  The only case in which it
6683                is arguably correct is if this is the only use of V.  In other
6684                cases, this will artificially inflate the benefit of the current
6685                giv, and lead to suboptimal code.  Thus, it is disabled, since
6686                potentially not reducing an only marginally beneficial giv is
6687                less harmful than reducing many givs that are not really
6688                beneficial.  */
6689             {
6690               rtx single_use = regs->array[REGNO (x)].single_usage;
6691               if (single_use && single_use != const0_rtx)
6692                 *benefit += v->benefit;
6693             }
6694
6695             if (v->cant_derive)
6696               return 0;
6697
6698             tem = gen_rtx_PLUS (mode, gen_rtx_MULT (mode,
6699                                                     v->src_reg, v->mult_val),
6700                                 v->add_val);
6701
6702             if (v->derive_adjustment)
6703               tem = gen_rtx_MINUS (mode, tem, v->derive_adjustment);
6704             arg0 = simplify_giv_expr (loop, tem, ext_val, benefit);
6705             if (*ext_val)
6706               {
6707                 if (!v->ext_dependent)
6708                   return arg0;
6709               }
6710             else
6711               {
6712                 *ext_val = v->ext_dependent;
6713                 return arg0;
6714               }
6715             return 0;
6716           }
6717
6718         default:
6719         do_default:
6720           /* If it isn't an induction variable, and it is invariant, we
6721              may be able to simplify things further by looking through
6722              the bits we just moved outside the loop.  */
6723           if (loop_invariant_p (loop, x) == 1)
6724             {
6725               struct movable *m;
6726               struct loop_movables *movables = LOOP_MOVABLES (loop);
6727
6728               for (m = movables->head; m; m = m->next)
6729                 if (rtx_equal_p (x, m->set_dest))
6730                   {
6731                     /* Ok, we found a match.  Substitute and simplify.  */
6732
6733                     /* If we match another movable, we must use that, as
6734                        this one is going away.  */
6735                     if (m->match)
6736                       return simplify_giv_expr (loop, m->match->set_dest,
6737                                                 ext_val, benefit);
6738
6739                     /* If consec is non-zero, this is a member of a group of
6740                        instructions that were moved together.  We handle this
6741                        case only to the point of seeking to the last insn and
6742                        looking for a REG_EQUAL.  Fail if we don't find one.  */
6743                     if (m->consec != 0)
6744                       {
6745                         int i = m->consec;
6746                         tem = m->insn;
6747                         do
6748                           {
6749                             tem = NEXT_INSN (tem);
6750                           }
6751                         while (--i > 0);
6752
6753                         tem = find_reg_note (tem, REG_EQUAL, NULL_RTX);
6754                         if (tem)
6755                           tem = XEXP (tem, 0);
6756                       }
6757                     else
6758                       {
6759                         tem = single_set (m->insn);
6760                         if (tem)
6761                           tem = SET_SRC (tem);
6762                       }
6763
6764                     if (tem)
6765                       {
6766                         /* What we are most interested in is pointer
6767                            arithmetic on invariants -- only take
6768                            patterns we may be able to do something with.  */
6769                         if (GET_CODE (tem) == PLUS
6770                             || GET_CODE (tem) == MULT
6771                             || GET_CODE (tem) == ASHIFT
6772                             || GET_CODE (tem) == CONST_INT
6773                             || GET_CODE (tem) == SYMBOL_REF)
6774                           {
6775                             tem = simplify_giv_expr (loop, tem, ext_val,
6776                                                      benefit);
6777                             if (tem)
6778                               return tem;
6779                           }
6780                         else if (GET_CODE (tem) == CONST
6781                                  && GET_CODE (XEXP (tem, 0)) == PLUS
6782                                  && GET_CODE (XEXP (XEXP (tem, 0), 0)) == SYMBOL_REF
6783                                  && GET_CODE (XEXP (XEXP (tem, 0), 1)) == CONST_INT)
6784                           {
6785                             tem = simplify_giv_expr (loop, XEXP (tem, 0),
6786                                                      ext_val, benefit);
6787                             if (tem)
6788                               return tem;
6789                           }
6790                       }
6791                     break;
6792                   }
6793             }
6794           break;
6795         }
6796
6797       /* Fall through to general case.  */
6798     default:
6799       /* If invariant, return as USE (unless CONST_INT).
6800          Otherwise, not giv.  */
6801       if (GET_CODE (x) == USE)
6802         x = XEXP (x, 0);
6803
6804       if (loop_invariant_p (loop, x) == 1)
6805         {
6806           if (GET_CODE (x) == CONST_INT)
6807             return x;
6808           if (GET_CODE (x) == CONST
6809               && GET_CODE (XEXP (x, 0)) == PLUS
6810               && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
6811               && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
6812             x = XEXP (x, 0);
6813           return gen_rtx_USE (mode, x);
6814         }
6815       else
6816         return 0;
6817     }
6818 }
6819
6820 /* This routine folds invariants such that there is only ever one
6821    CONST_INT in the summation.  It is only used by simplify_giv_expr.  */
6822
6823 static rtx
6824 sge_plus_constant (x, c)
6825      rtx x, c;
6826 {
6827   if (GET_CODE (x) == CONST_INT)
6828     return GEN_INT (INTVAL (x) + INTVAL (c));
6829   else if (GET_CODE (x) != PLUS)
6830     return gen_rtx_PLUS (GET_MODE (x), x, c);
6831   else if (GET_CODE (XEXP (x, 1)) == CONST_INT)
6832     {
6833       return gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0),
6834                            GEN_INT (INTVAL (XEXP (x, 1)) + INTVAL (c)));
6835     }
6836   else if (GET_CODE (XEXP (x, 0)) == PLUS
6837            || GET_CODE (XEXP (x, 1)) != PLUS)
6838     {
6839       return gen_rtx_PLUS (GET_MODE (x),
6840                            sge_plus_constant (XEXP (x, 0), c), XEXP (x, 1));
6841     }
6842   else
6843     {
6844       return gen_rtx_PLUS (GET_MODE (x),
6845                            sge_plus_constant (XEXP (x, 1), c), XEXP (x, 0));
6846     }
6847 }
6848
6849 static rtx
6850 sge_plus (mode, x, y)
6851      enum machine_mode mode;
6852      rtx x, y;
6853 {
6854   while (GET_CODE (y) == PLUS)
6855     {
6856       rtx a = XEXP (y, 0);
6857       if (GET_CODE (a) == CONST_INT)
6858         x = sge_plus_constant (x, a);
6859       else
6860         x = gen_rtx_PLUS (mode, x, a);
6861       y = XEXP (y, 1);
6862     }
6863   if (GET_CODE (y) == CONST_INT)
6864     x = sge_plus_constant (x, y);
6865   else
6866     x = gen_rtx_PLUS (mode, x, y);
6867   return x;
6868 }
6869 \f
6870 /* Help detect a giv that is calculated by several consecutive insns;
6871    for example,
6872       giv = biv * M
6873       giv = giv + A
6874    The caller has already identified the first insn P as having a giv as dest;
6875    we check that all other insns that set the same register follow
6876    immediately after P, that they alter nothing else,
6877    and that the result of the last is still a giv.
6878
6879    The value is 0 if the reg set in P is not really a giv.
6880    Otherwise, the value is the amount gained by eliminating
6881    all the consecutive insns that compute the value.
6882
6883    FIRST_BENEFIT is the amount gained by eliminating the first insn, P.
6884    SRC_REG is the reg of the biv; DEST_REG is the reg of the giv.
6885
6886    The coefficients of the ultimate giv value are stored in
6887    *MULT_VAL and *ADD_VAL.  */
6888
6889 static int
6890 consec_sets_giv (loop, first_benefit, p, src_reg, dest_reg,
6891                  add_val, mult_val, ext_val, last_consec_insn)
6892      const struct loop *loop;
6893      int first_benefit;
6894      rtx p;
6895      rtx src_reg;
6896      rtx dest_reg;
6897      rtx *add_val;
6898      rtx *mult_val;
6899      rtx *ext_val;
6900      rtx *last_consec_insn;
6901 {
6902   struct loop_ivs *ivs = LOOP_IVS (loop);
6903   struct loop_regs *regs = LOOP_REGS (loop);
6904   int count;
6905   enum rtx_code code;
6906   int benefit;
6907   rtx temp;
6908   rtx set;
6909
6910   /* Indicate that this is a giv so that we can update the value produced in
6911      each insn of the multi-insn sequence.
6912
6913      This induction structure will be used only by the call to
6914      general_induction_var below, so we can allocate it on our stack.
6915      If this is a giv, our caller will replace the induct var entry with
6916      a new induction structure.  */
6917   struct induction *v;
6918
6919   if (REG_IV_TYPE (ivs, REGNO (dest_reg)) != UNKNOWN_INDUCT)
6920     return 0;
6921
6922   v = (struct induction *) alloca (sizeof (struct induction));
6923   v->src_reg = src_reg;
6924   v->mult_val = *mult_val;
6925   v->add_val = *add_val;
6926   v->benefit = first_benefit;
6927   v->cant_derive = 0;
6928   v->derive_adjustment = 0;
6929   v->ext_dependent = NULL_RTX;
6930
6931   REG_IV_TYPE (ivs, REGNO (dest_reg)) = GENERAL_INDUCT;
6932   REG_IV_INFO (ivs, REGNO (dest_reg)) = v;
6933
6934   count = regs->array[REGNO (dest_reg)].n_times_set - 1;
6935
6936   while (count > 0)
6937     {
6938       p = NEXT_INSN (p);
6939       code = GET_CODE (p);
6940
6941       /* If libcall, skip to end of call sequence.  */
6942       if (code == INSN && (temp = find_reg_note (p, REG_LIBCALL, NULL_RTX)))
6943         p = XEXP (temp, 0);
6944
6945       if (code == INSN
6946           && (set = single_set (p))
6947           && GET_CODE (SET_DEST (set)) == REG
6948           && SET_DEST (set) == dest_reg
6949           && (general_induction_var (loop, SET_SRC (set), &src_reg,
6950                                      add_val, mult_val, ext_val, 0,
6951                                      &benefit, VOIDmode)
6952               /* Giv created by equivalent expression.  */
6953               || ((temp = find_reg_note (p, REG_EQUAL, NULL_RTX))
6954                   && general_induction_var (loop, XEXP (temp, 0), &src_reg,
6955                                             add_val, mult_val, ext_val, 0,
6956                                             &benefit, VOIDmode)))
6957           && src_reg == v->src_reg)
6958         {
6959           if (find_reg_note (p, REG_RETVAL, NULL_RTX))
6960             benefit += libcall_benefit (p);
6961
6962           count--;
6963           v->mult_val = *mult_val;
6964           v->add_val = *add_val;
6965           v->benefit += benefit;
6966         }
6967       else if (code != NOTE)
6968         {
6969           /* Allow insns that set something other than this giv to a
6970              constant.  Such insns are needed on machines which cannot
6971              include long constants and should not disqualify a giv.  */
6972           if (code == INSN
6973               && (set = single_set (p))
6974               && SET_DEST (set) != dest_reg
6975               && CONSTANT_P (SET_SRC (set)))
6976             continue;
6977
6978           REG_IV_TYPE (ivs, REGNO (dest_reg)) = UNKNOWN_INDUCT;
6979           return 0;
6980         }
6981     }
6982
6983   REG_IV_TYPE (ivs, REGNO (dest_reg)) = UNKNOWN_INDUCT;
6984   *last_consec_insn = p;
6985   return v->benefit;
6986 }
6987 \f
6988 /* Return an rtx, if any, that expresses giv G2 as a function of the register
6989    represented by G1.  If no such expression can be found, or it is clear that
6990    it cannot possibly be a valid address, 0 is returned.
6991
6992    To perform the computation, we note that
6993         G1 = x * v + a          and
6994         G2 = y * v + b
6995    where `v' is the biv.
6996
6997    So G2 = (y/b) * G1 + (b - a*y/x).
6998
6999    Note that MULT = y/x.
7000
7001    Update: A and B are now allowed to be additive expressions such that
7002    B contains all variables in A.  That is, computing B-A will not require
7003    subtracting variables.  */
7004
7005 static rtx
7006 express_from_1 (a, b, mult)
7007      rtx a, b, mult;
7008 {
7009   /* If MULT is zero, then A*MULT is zero, and our expression is B.  */
7010
7011   if (mult == const0_rtx)
7012     return b;
7013
7014   /* If MULT is not 1, we cannot handle A with non-constants, since we
7015      would then be required to subtract multiples of the registers in A.
7016      This is theoretically possible, and may even apply to some Fortran
7017      constructs, but it is a lot of work and we do not attempt it here.  */
7018
7019   if (mult != const1_rtx && GET_CODE (a) != CONST_INT)
7020     return NULL_RTX;
7021
7022   /* In general these structures are sorted top to bottom (down the PLUS
7023      chain), but not left to right across the PLUS.  If B is a higher
7024      order giv than A, we can strip one level and recurse.  If A is higher
7025      order, we'll eventually bail out, but won't know that until the end.
7026      If they are the same, we'll strip one level around this loop.  */
7027
7028   while (GET_CODE (a) == PLUS && GET_CODE (b) == PLUS)
7029     {
7030       rtx ra, rb, oa, ob, tmp;
7031
7032       ra = XEXP (a, 0), oa = XEXP (a, 1);
7033       if (GET_CODE (ra) == PLUS)
7034         tmp = ra, ra = oa, oa = tmp;
7035
7036       rb = XEXP (b, 0), ob = XEXP (b, 1);
7037       if (GET_CODE (rb) == PLUS)
7038         tmp = rb, rb = ob, ob = tmp;
7039
7040       if (rtx_equal_p (ra, rb))
7041         /* We matched: remove one reg completely.  */
7042         a = oa, b = ob;
7043       else if (GET_CODE (ob) != PLUS && rtx_equal_p (ra, ob))
7044         /* An alternate match.  */
7045         a = oa, b = rb;
7046       else if (GET_CODE (oa) != PLUS && rtx_equal_p (oa, rb))
7047         /* An alternate match.  */
7048         a = ra, b = ob;
7049       else
7050         {
7051           /* Indicates an extra register in B.  Strip one level from B and
7052              recurse, hoping B was the higher order expression.  */
7053           ob = express_from_1 (a, ob, mult);
7054           if (ob == NULL_RTX)
7055             return NULL_RTX;
7056           return gen_rtx_PLUS (GET_MODE (b), rb, ob);
7057         }
7058     }
7059
7060   /* Here we are at the last level of A, go through the cases hoping to
7061      get rid of everything but a constant.  */
7062
7063   if (GET_CODE (a) == PLUS)
7064     {
7065       rtx ra, oa;
7066
7067       ra = XEXP (a, 0), oa = XEXP (a, 1);
7068       if (rtx_equal_p (oa, b))
7069         oa = ra;
7070       else if (!rtx_equal_p (ra, b))
7071         return NULL_RTX;
7072
7073       if (GET_CODE (oa) != CONST_INT)
7074         return NULL_RTX;
7075
7076       return GEN_INT (-INTVAL (oa) * INTVAL (mult));
7077     }
7078   else if (GET_CODE (a) == CONST_INT)
7079     {
7080       return plus_constant (b, -INTVAL (a) * INTVAL (mult));
7081     }
7082   else if (CONSTANT_P (a))
7083     {
7084       enum machine_mode mode_a = GET_MODE (a);
7085       enum machine_mode mode_b = GET_MODE (b);
7086       enum machine_mode mode = mode_b == VOIDmode ? mode_a : mode_b;
7087       return simplify_gen_binary (MINUS, mode, b, a);
7088     }
7089   else if (GET_CODE (b) == PLUS)
7090     {
7091       if (rtx_equal_p (a, XEXP (b, 0)))
7092         return XEXP (b, 1);
7093       else if (rtx_equal_p (a, XEXP (b, 1)))
7094         return XEXP (b, 0);
7095       else
7096         return NULL_RTX;
7097     }
7098   else if (rtx_equal_p (a, b))
7099     return const0_rtx;
7100
7101   return NULL_RTX;
7102 }
7103
7104 rtx
7105 express_from (g1, g2)
7106      struct induction *g1, *g2;
7107 {
7108   rtx mult, add;
7109
7110   /* The value that G1 will be multiplied by must be a constant integer.  Also,
7111      the only chance we have of getting a valid address is if b*c/a (see above
7112      for notation) is also an integer.  */
7113   if (GET_CODE (g1->mult_val) == CONST_INT
7114       && GET_CODE (g2->mult_val) == CONST_INT)
7115     {
7116       if (g1->mult_val == const0_rtx
7117           || INTVAL (g2->mult_val) % INTVAL (g1->mult_val) != 0)
7118         return NULL_RTX;
7119       mult = GEN_INT (INTVAL (g2->mult_val) / INTVAL (g1->mult_val));
7120     }
7121   else if (rtx_equal_p (g1->mult_val, g2->mult_val))
7122     mult = const1_rtx;
7123   else
7124     {
7125       /* ??? Find out if the one is a multiple of the other?  */
7126       return NULL_RTX;
7127     }
7128
7129   add = express_from_1 (g1->add_val, g2->add_val, mult);
7130   if (add == NULL_RTX)
7131     {
7132       /* Failed.  If we've got a multiplication factor between G1 and G2,
7133          scale G1's addend and try again.  */
7134       if (INTVAL (mult) > 1)
7135         {
7136           rtx g1_add_val = g1->add_val;
7137           if (GET_CODE (g1_add_val) == MULT
7138               && GET_CODE (XEXP (g1_add_val, 1)) == CONST_INT)
7139             {
7140               HOST_WIDE_INT m;
7141               m = INTVAL (mult) * INTVAL (XEXP (g1_add_val, 1));
7142               g1_add_val = gen_rtx_MULT (GET_MODE (g1_add_val),
7143                                          XEXP (g1_add_val, 0), GEN_INT (m));
7144             }
7145           else
7146             {
7147               g1_add_val = gen_rtx_MULT (GET_MODE (g1_add_val), g1_add_val,
7148                                          mult);
7149             }
7150
7151           add = express_from_1 (g1_add_val, g2->add_val, const1_rtx);
7152         }
7153     }
7154   if (add == NULL_RTX)
7155     return NULL_RTX;
7156
7157   /* Form simplified final result.  */
7158   if (mult == const0_rtx)
7159     return add;
7160   else if (mult == const1_rtx)
7161     mult = g1->dest_reg;
7162   else
7163     mult = gen_rtx_MULT (g2->mode, g1->dest_reg, mult);
7164
7165   if (add == const0_rtx)
7166     return mult;
7167   else
7168     {
7169       if (GET_CODE (add) == PLUS
7170           && CONSTANT_P (XEXP (add, 1)))
7171         {
7172           rtx tem = XEXP (add, 1);
7173           mult = gen_rtx_PLUS (g2->mode, mult, XEXP (add, 0));
7174           add = tem;
7175         }
7176
7177       return gen_rtx_PLUS (g2->mode, mult, add);
7178     }
7179 }
7180 \f
7181 /* Return an rtx, if any, that expresses giv G2 as a function of the register
7182    represented by G1.  This indicates that G2 should be combined with G1 and
7183    that G2 can use (either directly or via an address expression) a register
7184    used to represent G1.  */
7185
7186 static rtx
7187 combine_givs_p (g1, g2)
7188      struct induction *g1, *g2;
7189 {
7190   rtx comb, ret;
7191
7192   /* With the introduction of ext dependent givs, we must care for modes.
7193      G2 must not use a wider mode than G1.  */
7194   if (GET_MODE_SIZE (g1->mode) < GET_MODE_SIZE (g2->mode))
7195     return NULL_RTX;
7196
7197   ret = comb = express_from (g1, g2);
7198   if (comb == NULL_RTX)
7199     return NULL_RTX;
7200   if (g1->mode != g2->mode)
7201     ret = gen_lowpart (g2->mode, comb);
7202
7203   /* If these givs are identical, they can be combined.  We use the results
7204      of express_from because the addends are not in a canonical form, so
7205      rtx_equal_p is a weaker test.  */
7206   /* But don't combine a DEST_REG giv with a DEST_ADDR giv; we want the
7207      combination to be the other way round.  */
7208   if (comb == g1->dest_reg
7209       && (g1->giv_type == DEST_REG || g2->giv_type == DEST_ADDR))
7210     {
7211       return ret;
7212     }
7213
7214   /* If G2 can be expressed as a function of G1 and that function is valid
7215      as an address and no more expensive than using a register for G2,
7216      the expression of G2 in terms of G1 can be used.  */
7217   if (ret != NULL_RTX
7218       && g2->giv_type == DEST_ADDR
7219       && memory_address_p (GET_MODE (g2->mem), ret)
7220       /* ??? Looses, especially with -fforce-addr, where *g2->location
7221          will always be a register, and so anything more complicated
7222          gets discarded.  */
7223 #if 0
7224 #ifdef ADDRESS_COST
7225       && ADDRESS_COST (tem) <= ADDRESS_COST (*g2->location)
7226 #else
7227       && rtx_cost (tem, MEM) <= rtx_cost (*g2->location, MEM)
7228 #endif
7229 #endif
7230       )
7231     {
7232       return ret;
7233     }
7234
7235   return NULL_RTX;
7236 }
7237 \f
7238 /* Check each extension dependent giv in this class to see if its
7239    root biv is safe from wrapping in the interior mode, which would
7240    make the giv illegal.  */
7241
7242 static void
7243 check_ext_dependent_givs (bl, loop_info)
7244      struct iv_class *bl;
7245      struct loop_info *loop_info;
7246 {
7247   int ze_ok = 0, se_ok = 0, info_ok = 0;
7248   enum machine_mode biv_mode = GET_MODE (bl->biv->src_reg);
7249   HOST_WIDE_INT start_val;
7250   unsigned HOST_WIDE_INT u_end_val = 0;
7251   unsigned HOST_WIDE_INT u_start_val = 0;
7252   rtx incr = pc_rtx;
7253   struct induction *v;
7254
7255   /* Make sure the iteration data is available.  We must have
7256      constants in order to be certain of no overflow.  */
7257   /* ??? An unknown iteration count with an increment of +-1
7258      combined with friendly exit tests of against an invariant
7259      value is also ameanable to optimization.  Not implemented.  */
7260   if (loop_info->n_iterations > 0
7261       && bl->initial_value
7262       && GET_CODE (bl->initial_value) == CONST_INT
7263       && (incr = biv_total_increment (bl))
7264       && GET_CODE (incr) == CONST_INT
7265       /* Make sure the host can represent the arithmetic.  */
7266       && HOST_BITS_PER_WIDE_INT >= GET_MODE_BITSIZE (biv_mode))
7267     {
7268       unsigned HOST_WIDE_INT abs_incr, total_incr;
7269       HOST_WIDE_INT s_end_val;
7270       int neg_incr;
7271
7272       info_ok = 1;
7273       start_val = INTVAL (bl->initial_value);
7274       u_start_val = start_val;
7275
7276       neg_incr = 0, abs_incr = INTVAL (incr);
7277       if (INTVAL (incr) < 0)
7278         neg_incr = 1, abs_incr = -abs_incr;
7279       total_incr = abs_incr * loop_info->n_iterations;
7280
7281       /* Check for host arithmatic overflow.  */
7282       if (total_incr / loop_info->n_iterations == abs_incr)
7283         {
7284           unsigned HOST_WIDE_INT u_max;
7285           HOST_WIDE_INT s_max;
7286
7287           u_end_val = start_val + (neg_incr ? -total_incr : total_incr);
7288           s_end_val = u_end_val;
7289           u_max = GET_MODE_MASK (biv_mode);
7290           s_max = u_max >> 1;
7291
7292           /* Check zero extension of biv ok.  */
7293           if (start_val >= 0
7294               /* Check for host arithmatic overflow.  */
7295               && (neg_incr
7296                   ? u_end_val < u_start_val
7297                   : u_end_val > u_start_val)
7298               /* Check for target arithmetic overflow.  */
7299               && (neg_incr
7300                   ? 1 /* taken care of with host overflow */
7301                   : u_end_val <= u_max))
7302             {
7303               ze_ok = 1;
7304             }
7305
7306           /* Check sign extension of biv ok.  */
7307           /* ??? While it is true that overflow with signed and pointer
7308              arithmetic is undefined, I fear too many programmers don't
7309              keep this fact in mind -- myself included on occasion.
7310              So leave alone with the signed overflow optimizations.  */
7311           if (start_val >= -s_max - 1
7312               /* Check for host arithmatic overflow.  */
7313               && (neg_incr
7314                   ? s_end_val < start_val
7315                   : s_end_val > start_val)
7316               /* Check for target arithmetic overflow.  */
7317               && (neg_incr
7318                   ? s_end_val >= -s_max - 1
7319                   : s_end_val <= s_max))
7320             {
7321               se_ok = 1;
7322             }
7323         }
7324     }
7325
7326   /* Invalidate givs that fail the tests.  */
7327   for (v = bl->giv; v; v = v->next_iv)
7328     if (v->ext_dependent)
7329       {
7330         enum rtx_code code = GET_CODE (v->ext_dependent);
7331         int ok = 0;
7332
7333         switch (code)
7334           {
7335           case SIGN_EXTEND:
7336             ok = se_ok;
7337             break;
7338           case ZERO_EXTEND:
7339             ok = ze_ok;
7340             break;
7341
7342           case TRUNCATE:
7343             /* We don't know whether this value is being used as either
7344                signed or unsigned, so to safely truncate we must satisfy
7345                both.  The initial check here verifies the BIV itself;
7346                once that is successful we may check its range wrt the
7347                derived GIV.  */
7348             if (se_ok && ze_ok)
7349               {
7350                 enum machine_mode outer_mode = GET_MODE (v->ext_dependent);
7351                 unsigned HOST_WIDE_INT max = GET_MODE_MASK (outer_mode) >> 1;
7352
7353                 /* We know from the above that both endpoints are nonnegative,
7354                    and that there is no wrapping.  Verify that both endpoints
7355                    are within the (signed) range of the outer mode.  */
7356                 if (u_start_val <= max && u_end_val <= max)
7357                   ok = 1;
7358               }
7359             break;
7360
7361           default:
7362             abort ();
7363           }
7364
7365         if (ok)
7366           {
7367             if (loop_dump_stream)
7368               {
7369                 fprintf (loop_dump_stream,
7370                          "Verified ext dependent giv at %d of reg %d\n",
7371                          INSN_UID (v->insn), bl->regno);
7372               }
7373           }
7374         else
7375           {
7376             if (loop_dump_stream)
7377               {
7378                 const char *why;
7379
7380                 if (info_ok)
7381                   why = "biv iteration values overflowed";
7382                 else
7383                   {
7384                     if (incr == pc_rtx)
7385                       incr = biv_total_increment (bl);
7386                     if (incr == const1_rtx)
7387                       why = "biv iteration info incomplete; incr by 1";
7388                     else
7389                       why = "biv iteration info incomplete";
7390                   }
7391
7392                 fprintf (loop_dump_stream,
7393                          "Failed ext dependent giv at %d, %s\n",
7394                          INSN_UID (v->insn), why);
7395               }
7396             v->ignore = 1;
7397             bl->all_reduced = 0;
7398           }
7399       }
7400 }
7401
7402 /* Generate a version of VALUE in a mode appropriate for initializing V.  */
7403
7404 rtx
7405 extend_value_for_giv (v, value)
7406      struct induction *v;
7407      rtx value;
7408 {
7409   rtx ext_dep = v->ext_dependent;
7410
7411   if (! ext_dep)
7412     return value;
7413
7414   /* Recall that check_ext_dependent_givs verified that the known bounds
7415      of a biv did not overflow or wrap with respect to the extension for
7416      the giv.  Therefore, constants need no additional adjustment.  */
7417   if (CONSTANT_P (value) && GET_MODE (value) == VOIDmode)
7418     return value;
7419
7420   /* Otherwise, we must adjust the value to compensate for the
7421      differing modes of the biv and the giv.  */
7422   return gen_rtx_fmt_e (GET_CODE (ext_dep), GET_MODE (ext_dep), value);
7423 }
7424 \f
7425 struct combine_givs_stats
7426 {
7427   int giv_number;
7428   int total_benefit;
7429 };
7430
7431 static int
7432 cmp_combine_givs_stats (xp, yp)
7433      const PTR xp;
7434      const PTR yp;
7435 {
7436   const struct combine_givs_stats * const x =
7437     (const struct combine_givs_stats *) xp;
7438   const struct combine_givs_stats * const y =
7439     (const struct combine_givs_stats *) yp;
7440   int d;
7441   d = y->total_benefit - x->total_benefit;
7442   /* Stabilize the sort.  */
7443   if (!d)
7444     d = x->giv_number - y->giv_number;
7445   return d;
7446 }
7447
7448 /* Check all pairs of givs for iv_class BL and see if any can be combined with
7449    any other.  If so, point SAME to the giv combined with and set NEW_REG to
7450    be an expression (in terms of the other giv's DEST_REG) equivalent to the
7451    giv.  Also, update BENEFIT and related fields for cost/benefit analysis.  */
7452
7453 static void
7454 combine_givs (regs, bl)
7455      struct loop_regs *regs;
7456      struct iv_class *bl;
7457 {
7458   /* Additional benefit to add for being combined multiple times.  */
7459   const int extra_benefit = 3;
7460
7461   struct induction *g1, *g2, **giv_array;
7462   int i, j, k, giv_count;
7463   struct combine_givs_stats *stats;
7464   rtx *can_combine;
7465
7466   /* Count givs, because bl->giv_count is incorrect here.  */
7467   giv_count = 0;
7468   for (g1 = bl->giv; g1; g1 = g1->next_iv)
7469     if (!g1->ignore)
7470       giv_count++;
7471
7472   giv_array
7473     = (struct induction **) alloca (giv_count * sizeof (struct induction *));
7474   i = 0;
7475   for (g1 = bl->giv; g1; g1 = g1->next_iv)
7476     if (!g1->ignore)
7477       giv_array[i++] = g1;
7478
7479   stats = (struct combine_givs_stats *) xcalloc (giv_count, sizeof (*stats));
7480   can_combine = (rtx *) xcalloc (giv_count, giv_count * sizeof (rtx));
7481
7482   for (i = 0; i < giv_count; i++)
7483     {
7484       int this_benefit;
7485       rtx single_use;
7486
7487       g1 = giv_array[i];
7488       stats[i].giv_number = i;
7489
7490       /* If a DEST_REG GIV is used only once, do not allow it to combine
7491          with anything, for in doing so we will gain nothing that cannot
7492          be had by simply letting the GIV with which we would have combined
7493          to be reduced on its own.  The losage shows up in particular with
7494          DEST_ADDR targets on hosts with reg+reg addressing, though it can
7495          be seen elsewhere as well.  */
7496       if (g1->giv_type == DEST_REG
7497           && (single_use = regs->array[REGNO (g1->dest_reg)].single_usage)
7498           && single_use != const0_rtx)
7499         continue;
7500
7501       this_benefit = g1->benefit;
7502       /* Add an additional weight for zero addends.  */
7503       if (g1->no_const_addval)
7504         this_benefit += 1;
7505
7506       for (j = 0; j < giv_count; j++)
7507         {
7508           rtx this_combine;
7509
7510           g2 = giv_array[j];
7511           if (g1 != g2
7512               && (this_combine = combine_givs_p (g1, g2)) != NULL_RTX)
7513             {
7514               can_combine[i * giv_count + j] = this_combine;
7515               this_benefit += g2->benefit + extra_benefit;
7516             }
7517         }
7518       stats[i].total_benefit = this_benefit;
7519     }
7520
7521   /* Iterate, combining until we can't.  */
7522 restart:
7523   qsort (stats, giv_count, sizeof (*stats), cmp_combine_givs_stats);
7524
7525   if (loop_dump_stream)
7526     {
7527       fprintf (loop_dump_stream, "Sorted combine statistics:\n");
7528       for (k = 0; k < giv_count; k++)
7529         {
7530           g1 = giv_array[stats[k].giv_number];
7531           if (!g1->combined_with && !g1->same)
7532             fprintf (loop_dump_stream, " {%d, %d}",
7533                      INSN_UID (giv_array[stats[k].giv_number]->insn),
7534                      stats[k].total_benefit);
7535         }
7536       putc ('\n', loop_dump_stream);
7537     }
7538
7539   for (k = 0; k < giv_count; k++)
7540     {
7541       int g1_add_benefit = 0;
7542
7543       i = stats[k].giv_number;
7544       g1 = giv_array[i];
7545
7546       /* If it has already been combined, skip.  */
7547       if (g1->combined_with || g1->same)
7548         continue;
7549
7550       for (j = 0; j < giv_count; j++)
7551         {
7552           g2 = giv_array[j];
7553           if (g1 != g2 && can_combine[i * giv_count + j]
7554               /* If it has already been combined, skip.  */
7555               && ! g2->same && ! g2->combined_with)
7556             {
7557               int l;
7558
7559               g2->new_reg = can_combine[i * giv_count + j];
7560               g2->same = g1;
7561               /* For destination, we now may replace by mem expression instead
7562                  of register.  This changes the costs considerably, so add the
7563                  compensation.  */
7564               if (g2->giv_type == DEST_ADDR)
7565                 g2->benefit = (g2->benefit + reg_address_cost
7566                                - address_cost (g2->new_reg,
7567                                GET_MODE (g2->mem)));
7568               g1->combined_with++;
7569               g1->lifetime += g2->lifetime;
7570
7571               g1_add_benefit += g2->benefit;
7572
7573               /* ??? The new final_[bg]iv_value code does a much better job
7574                  of finding replaceable giv's, and hence this code may no
7575                  longer be necessary.  */
7576               if (! g2->replaceable && REG_USERVAR_P (g2->dest_reg))
7577                 g1_add_benefit -= copy_cost;
7578
7579               /* To help optimize the next set of combinations, remove
7580                  this giv from the benefits of other potential mates.  */
7581               for (l = 0; l < giv_count; ++l)
7582                 {
7583                   int m = stats[l].giv_number;
7584                   if (can_combine[m * giv_count + j])
7585                     stats[l].total_benefit -= g2->benefit + extra_benefit;
7586                 }
7587
7588               if (loop_dump_stream)
7589                 fprintf (loop_dump_stream,
7590                          "giv at %d combined with giv at %d; new benefit %d + %d, lifetime %d\n",
7591                          INSN_UID (g2->insn), INSN_UID (g1->insn),
7592                          g1->benefit, g1_add_benefit, g1->lifetime);
7593             }
7594         }
7595
7596       /* To help optimize the next set of combinations, remove
7597          this giv from the benefits of other potential mates.  */
7598       if (g1->combined_with)
7599         {
7600           for (j = 0; j < giv_count; ++j)
7601             {
7602               int m = stats[j].giv_number;
7603               if (can_combine[m * giv_count + i])
7604                 stats[j].total_benefit -= g1->benefit + extra_benefit;
7605             }
7606
7607           g1->benefit += g1_add_benefit;
7608
7609           /* We've finished with this giv, and everything it touched.
7610              Restart the combination so that proper weights for the
7611              rest of the givs are properly taken into account.  */
7612           /* ??? Ideally we would compact the arrays at this point, so
7613              as to not cover old ground.  But sanely compacting
7614              can_combine is tricky.  */
7615           goto restart;
7616         }
7617     }
7618
7619   /* Clean up.  */
7620   free (stats);
7621   free (can_combine);
7622 }
7623 \f
7624 /* Generate sequence for REG = B * M + A.  */
7625
7626 static rtx
7627 gen_add_mult (b, m, a, reg)
7628      rtx b;          /* initial value of basic induction variable */
7629      rtx m;          /* multiplicative constant */
7630      rtx a;          /* additive constant */
7631      rtx reg;        /* destination register */
7632 {
7633   rtx seq;
7634   rtx result;
7635
7636   start_sequence ();
7637   /* Use unsigned arithmetic.  */
7638   result = expand_mult_add (b, reg, m, a, GET_MODE (reg), 1);
7639   if (reg != result)
7640     emit_move_insn (reg, result);
7641   seq = gen_sequence ();
7642   end_sequence ();
7643
7644   return seq;
7645 }
7646
7647
7648 /* Update registers created in insn sequence SEQ.  */
7649
7650 static void
7651 loop_regs_update (loop, seq)
7652      const struct loop *loop ATTRIBUTE_UNUSED;
7653      rtx seq;
7654 {
7655   /* Update register info for alias analysis.  */
7656
7657   if (GET_CODE (seq) == SEQUENCE)
7658     {
7659       int i;
7660       for (i = 0; i < XVECLEN (seq, 0); ++i)
7661         {
7662           rtx set = single_set (XVECEXP (seq, 0, i));
7663           if (set && GET_CODE (SET_DEST (set)) == REG)
7664             record_base_value (REGNO (SET_DEST (set)), SET_SRC (set), 0);
7665         }
7666     }
7667   else
7668     {
7669       if (GET_CODE (seq) == SET
7670           && GET_CODE (SET_DEST (seq)) == REG)
7671         record_base_value (REGNO (SET_DEST (seq)), SET_SRC (seq), 0);
7672     }
7673 }
7674
7675
7676 /* EMIT code before BEFORE_BB/BEFORE_INSN to set REG = B * M + A.  */
7677
7678 void
7679 loop_iv_add_mult_emit_before (loop, b, m, a, reg, before_bb, before_insn)
7680      const struct loop *loop;
7681      rtx b;          /* initial value of basic induction variable */
7682      rtx m;          /* multiplicative constant */
7683      rtx a;          /* additive constant */
7684      rtx reg;        /* destination register */
7685      basic_block before_bb;
7686      rtx before_insn;
7687 {
7688   rtx seq;
7689
7690   if (! before_insn)
7691     {
7692       loop_iv_add_mult_hoist (loop, b, m, a, reg);
7693       return;
7694     }
7695
7696   /* Use copy_rtx to prevent unexpected sharing of these rtx.  */
7697   seq = gen_add_mult (copy_rtx (b), copy_rtx (m), copy_rtx (a), reg);
7698
7699   /* Increase the lifetime of any invariants moved further in code.  */
7700   update_reg_last_use (a, before_insn);
7701   update_reg_last_use (b, before_insn);
7702   update_reg_last_use (m, before_insn);
7703
7704   loop_insn_emit_before (loop, before_bb, before_insn, seq);
7705
7706   /* It is possible that the expansion created lots of new registers.
7707      Iterate over the sequence we just created and record them all.  */
7708   loop_regs_update (loop, seq);
7709 }
7710
7711
7712 /* Emit insns in loop pre-header to set REG = B * M + A.  */
7713
7714 void
7715 loop_iv_add_mult_sink (loop, b, m, a, reg)
7716      const struct loop *loop;
7717      rtx b;          /* initial value of basic induction variable */
7718      rtx m;          /* multiplicative constant */
7719      rtx a;          /* additive constant */
7720      rtx reg;        /* destination register */
7721 {
7722   rtx seq;
7723
7724   /* Use copy_rtx to prevent unexpected sharing of these rtx.  */
7725   seq = gen_add_mult (copy_rtx (b), copy_rtx (m), copy_rtx (a), reg);
7726
7727   /* Increase the lifetime of any invariants moved further in code.
7728      ???? Is this really necessary?  */
7729   update_reg_last_use (a, loop->sink);
7730   update_reg_last_use (b, loop->sink);
7731   update_reg_last_use (m, loop->sink);
7732
7733   loop_insn_sink (loop, seq);
7734
7735   /* It is possible that the expansion created lots of new registers.
7736      Iterate over the sequence we just created and record them all.  */
7737   loop_regs_update (loop, seq);
7738 }
7739
7740
7741 /* Emit insns after loop to set REG = B * M + A.  */
7742
7743 void
7744 loop_iv_add_mult_hoist (loop, b, m, a, reg)
7745      const struct loop *loop;
7746      rtx b;          /* initial value of basic induction variable */
7747      rtx m;          /* multiplicative constant */
7748      rtx a;          /* additive constant */
7749      rtx reg;        /* destination register */
7750 {
7751   rtx seq;
7752
7753   /* Use copy_rtx to prevent unexpected sharing of these rtx.  */
7754   seq = gen_add_mult (copy_rtx (b), copy_rtx (m), copy_rtx (a), reg);
7755
7756   loop_insn_hoist (loop, seq);
7757
7758   /* It is possible that the expansion created lots of new registers.
7759      Iterate over the sequence we just created and record them all.  */
7760   loop_regs_update (loop, seq);
7761 }
7762
7763
7764
7765 /* Similar to gen_add_mult, but compute cost rather than generating
7766    sequence.  */
7767
7768 static int
7769 iv_add_mult_cost (b, m, a, reg)
7770      rtx b;          /* initial value of basic induction variable */
7771      rtx m;          /* multiplicative constant */
7772      rtx a;          /* additive constant */
7773      rtx reg;        /* destination register */
7774 {
7775   int cost = 0;
7776   rtx last, result;
7777
7778   start_sequence ();
7779   result = expand_mult_add (b, reg, m, a, GET_MODE (reg), 1);
7780   if (reg != result)
7781     emit_move_insn (reg, result);
7782   last = get_last_insn ();
7783   while (last)
7784     {
7785       rtx t = single_set (last);
7786       if (t)
7787         cost += rtx_cost (SET_SRC (t), SET);
7788       last = PREV_INSN (last);
7789     }
7790   end_sequence ();
7791   return cost;
7792 }
7793 \f
7794 /* Test whether A * B can be computed without
7795    an actual multiply insn.  Value is 1 if so.  */
7796
7797 static int
7798 product_cheap_p (a, b)
7799      rtx a;
7800      rtx b;
7801 {
7802   int i;
7803   rtx tmp;
7804   int win = 1;
7805
7806   /* If only one is constant, make it B.  */
7807   if (GET_CODE (a) == CONST_INT)
7808     tmp = a, a = b, b = tmp;
7809
7810   /* If first constant, both constant, so don't need multiply.  */
7811   if (GET_CODE (a) == CONST_INT)
7812     return 1;
7813
7814   /* If second not constant, neither is constant, so would need multiply.  */
7815   if (GET_CODE (b) != CONST_INT)
7816     return 0;
7817
7818   /* One operand is constant, so might not need multiply insn.  Generate the
7819      code for the multiply and see if a call or multiply, or long sequence
7820      of insns is generated.  */
7821
7822   start_sequence ();
7823   expand_mult (GET_MODE (a), a, b, NULL_RTX, 1);
7824   tmp = gen_sequence ();
7825   end_sequence ();
7826
7827   if (GET_CODE (tmp) == SEQUENCE)
7828     {
7829       if (XVEC (tmp, 0) == 0)
7830         win = 1;
7831       else if (XVECLEN (tmp, 0) > 3)
7832         win = 0;
7833       else
7834         for (i = 0; i < XVECLEN (tmp, 0); i++)
7835           {
7836             rtx insn = XVECEXP (tmp, 0, i);
7837
7838             if (GET_CODE (insn) != INSN
7839                 || (GET_CODE (PATTERN (insn)) == SET
7840                     && GET_CODE (SET_SRC (PATTERN (insn))) == MULT)
7841                 || (GET_CODE (PATTERN (insn)) == PARALLEL
7842                     && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET
7843                     && GET_CODE (SET_SRC (XVECEXP (PATTERN (insn), 0, 0))) == MULT))
7844               {
7845                 win = 0;
7846                 break;
7847               }
7848           }
7849     }
7850   else if (GET_CODE (tmp) == SET
7851            && GET_CODE (SET_SRC (tmp)) == MULT)
7852     win = 0;
7853   else if (GET_CODE (tmp) == PARALLEL
7854            && GET_CODE (XVECEXP (tmp, 0, 0)) == SET
7855            && GET_CODE (SET_SRC (XVECEXP (tmp, 0, 0))) == MULT)
7856     win = 0;
7857
7858   return win;
7859 }
7860 \f
7861 /* Check to see if loop can be terminated by a "decrement and branch until
7862    zero" instruction.  If so, add a REG_NONNEG note to the branch insn if so.
7863    Also try reversing an increment loop to a decrement loop
7864    to see if the optimization can be performed.
7865    Value is nonzero if optimization was performed.  */
7866
7867 /* This is useful even if the architecture doesn't have such an insn,
7868    because it might change a loops which increments from 0 to n to a loop
7869    which decrements from n to 0.  A loop that decrements to zero is usually
7870    faster than one that increments from zero.  */
7871
7872 /* ??? This could be rewritten to use some of the loop unrolling procedures,
7873    such as approx_final_value, biv_total_increment, loop_iterations, and
7874    final_[bg]iv_value.  */
7875
7876 static int
7877 check_dbra_loop (loop, insn_count)
7878      struct loop *loop;
7879      int insn_count;
7880 {
7881   struct loop_info *loop_info = LOOP_INFO (loop);
7882   struct loop_regs *regs = LOOP_REGS (loop);
7883   struct loop_ivs *ivs = LOOP_IVS (loop);
7884   struct iv_class *bl;
7885   rtx reg;
7886   rtx jump_label;
7887   rtx final_value;
7888   rtx start_value;
7889   rtx new_add_val;
7890   rtx comparison;
7891   rtx before_comparison;
7892   rtx p;
7893   rtx jump;
7894   rtx first_compare;
7895   int compare_and_branch;
7896   rtx loop_start = loop->start;
7897   rtx loop_end = loop->end;
7898
7899   /* If last insn is a conditional branch, and the insn before tests a
7900      register value, try to optimize it.  Otherwise, we can't do anything.  */
7901
7902   jump = PREV_INSN (loop_end);
7903   comparison = get_condition_for_loop (loop, jump);
7904   if (comparison == 0)
7905     return 0;
7906   if (!onlyjump_p (jump))
7907     return 0;
7908
7909   /* Try to compute whether the compare/branch at the loop end is one or
7910      two instructions.  */
7911   get_condition (jump, &first_compare);
7912   if (first_compare == jump)
7913     compare_and_branch = 1;
7914   else if (first_compare == prev_nonnote_insn (jump))
7915     compare_and_branch = 2;
7916   else
7917     return 0;
7918
7919   {
7920     /* If more than one condition is present to control the loop, then
7921        do not proceed, as this function does not know how to rewrite
7922        loop tests with more than one condition.
7923
7924        Look backwards from the first insn in the last comparison
7925        sequence and see if we've got another comparison sequence.  */
7926
7927     rtx jump1;
7928     if ((jump1 = prev_nonnote_insn (first_compare)) != loop->cont)
7929       if (GET_CODE (jump1) == JUMP_INSN)
7930         return 0;
7931   }
7932
7933   /* Check all of the bivs to see if the compare uses one of them.
7934      Skip biv's set more than once because we can't guarantee that
7935      it will be zero on the last iteration.  Also skip if the biv is
7936      used between its update and the test insn.  */
7937
7938   for (bl = ivs->list; bl; bl = bl->next)
7939     {
7940       if (bl->biv_count == 1
7941           && ! bl->biv->maybe_multiple
7942           && bl->biv->dest_reg == XEXP (comparison, 0)
7943           && ! reg_used_between_p (regno_reg_rtx[bl->regno], bl->biv->insn,
7944                                    first_compare))
7945         break;
7946     }
7947
7948   if (! bl)
7949     return 0;
7950
7951   /* Look for the case where the basic induction variable is always
7952      nonnegative, and equals zero on the last iteration.
7953      In this case, add a reg_note REG_NONNEG, which allows the
7954      m68k DBRA instruction to be used.  */
7955
7956   if (((GET_CODE (comparison) == GT
7957         && GET_CODE (XEXP (comparison, 1)) == CONST_INT
7958         && INTVAL (XEXP (comparison, 1)) == -1)
7959        || (GET_CODE (comparison) == NE && XEXP (comparison, 1) == const0_rtx))
7960       && GET_CODE (bl->biv->add_val) == CONST_INT
7961       && INTVAL (bl->biv->add_val) < 0)
7962     {
7963       /* Initial value must be greater than 0,
7964          init_val % -dec_value == 0 to ensure that it equals zero on
7965          the last iteration */
7966
7967       if (GET_CODE (bl->initial_value) == CONST_INT
7968           && INTVAL (bl->initial_value) > 0
7969           && (INTVAL (bl->initial_value)
7970               % (-INTVAL (bl->biv->add_val))) == 0)
7971         {
7972           /* register always nonnegative, add REG_NOTE to branch */
7973           if (! find_reg_note (jump, REG_NONNEG, NULL_RTX))
7974             REG_NOTES (jump)
7975               = gen_rtx_EXPR_LIST (REG_NONNEG, bl->biv->dest_reg,
7976                                    REG_NOTES (jump));
7977           bl->nonneg = 1;
7978
7979           return 1;
7980         }
7981
7982       /* If the decrement is 1 and the value was tested as >= 0 before
7983          the loop, then we can safely optimize.  */
7984       for (p = loop_start; p; p = PREV_INSN (p))
7985         {
7986           if (GET_CODE (p) == CODE_LABEL)
7987             break;
7988           if (GET_CODE (p) != JUMP_INSN)
7989             continue;
7990
7991           before_comparison = get_condition_for_loop (loop, p);
7992           if (before_comparison
7993               && XEXP (before_comparison, 0) == bl->biv->dest_reg
7994               && GET_CODE (before_comparison) == LT
7995               && XEXP (before_comparison, 1) == const0_rtx
7996               && ! reg_set_between_p (bl->biv->dest_reg, p, loop_start)
7997               && INTVAL (bl->biv->add_val) == -1)
7998             {
7999               if (! find_reg_note (jump, REG_NONNEG, NULL_RTX))
8000                 REG_NOTES (jump)
8001                   = gen_rtx_EXPR_LIST (REG_NONNEG, bl->biv->dest_reg,
8002                                        REG_NOTES (jump));
8003               bl->nonneg = 1;
8004
8005               return 1;
8006             }
8007         }
8008     }
8009   else if (GET_CODE (bl->biv->add_val) == CONST_INT
8010            && INTVAL (bl->biv->add_val) > 0)
8011     {
8012       /* Try to change inc to dec, so can apply above optimization.  */
8013       /* Can do this if:
8014          all registers modified are induction variables or invariant,
8015          all memory references have non-overlapping addresses
8016          (obviously true if only one write)
8017          allow 2 insns for the compare/jump at the end of the loop.  */
8018       /* Also, we must avoid any instructions which use both the reversed
8019          biv and another biv.  Such instructions will fail if the loop is
8020          reversed.  We meet this condition by requiring that either
8021          no_use_except_counting is true, or else that there is only
8022          one biv.  */
8023       int num_nonfixed_reads = 0;
8024       /* 1 if the iteration var is used only to count iterations.  */
8025       int no_use_except_counting = 0;
8026       /* 1 if the loop has no memory store, or it has a single memory store
8027          which is reversible.  */
8028       int reversible_mem_store = 1;
8029
8030       if (bl->giv_count == 0
8031           && !loop->exit_count
8032           && !loop_info->has_multiple_exit_targets)
8033         {
8034           rtx bivreg = regno_reg_rtx[bl->regno];
8035           struct iv_class *blt;
8036
8037           /* If there are no givs for this biv, and the only exit is the
8038              fall through at the end of the loop, then
8039              see if perhaps there are no uses except to count.  */
8040           no_use_except_counting = 1;
8041           for (p = loop_start; p != loop_end; p = NEXT_INSN (p))
8042             if (INSN_P (p))
8043               {
8044                 rtx set = single_set (p);
8045
8046                 if (set && GET_CODE (SET_DEST (set)) == REG
8047                     && REGNO (SET_DEST (set)) == bl->regno)
8048                   /* An insn that sets the biv is okay.  */
8049                   ;
8050                 else if ((p == prev_nonnote_insn (prev_nonnote_insn (loop_end))
8051                           || p == prev_nonnote_insn (loop_end))
8052                          && reg_mentioned_p (bivreg, PATTERN (p)))
8053                   {
8054                     /* If either of these insns uses the biv and sets a pseudo
8055                        that has more than one usage, then the biv has uses
8056                        other than counting since it's used to derive a value
8057                        that is used more than one time.  */
8058                     note_stores (PATTERN (p), note_set_pseudo_multiple_uses,
8059                                  regs);
8060                     if (regs->multiple_uses)
8061                       {
8062                         no_use_except_counting = 0;
8063                         break;
8064                       }
8065                   }
8066                 else if (reg_mentioned_p (bivreg, PATTERN (p)))
8067                   {
8068                     no_use_except_counting = 0;
8069                     break;
8070                   }
8071               }
8072
8073           /* A biv has uses besides counting if it is used to set
8074              another biv.  */
8075           for (blt = ivs->list; blt; blt = blt->next)
8076             if (blt->init_set
8077                 && reg_mentioned_p (bivreg, SET_SRC (blt->init_set)))
8078               {
8079                 no_use_except_counting = 0;
8080                 break;
8081               }
8082         }
8083
8084       if (no_use_except_counting)
8085         /* No need to worry about MEMs.  */
8086         ;
8087       else if (loop_info->num_mem_sets <= 1)
8088         {
8089           for (p = loop_start; p != loop_end; p = NEXT_INSN (p))
8090             if (INSN_P (p))
8091               num_nonfixed_reads += count_nonfixed_reads (loop, PATTERN (p));
8092
8093           /* If the loop has a single store, and the destination address is
8094              invariant, then we can't reverse the loop, because this address
8095              might then have the wrong value at loop exit.
8096              This would work if the source was invariant also, however, in that
8097              case, the insn should have been moved out of the loop.  */
8098
8099           if (loop_info->num_mem_sets == 1)
8100             {
8101               struct induction *v;
8102
8103               /* If we could prove that each of the memory locations
8104                  written to was different, then we could reverse the
8105                  store -- but we don't presently have any way of
8106                  knowing that.  */
8107               reversible_mem_store = 0;
8108
8109               /* If the store depends on a register that is set after the
8110                  store, it depends on the initial value, and is thus not
8111                  reversible.  */
8112               for (v = bl->giv; reversible_mem_store && v; v = v->next_iv)
8113                 {
8114                   if (v->giv_type == DEST_REG
8115                       && reg_mentioned_p (v->dest_reg,
8116                                           PATTERN (loop_info->first_loop_store_insn))
8117                       && loop_insn_first_p (loop_info->first_loop_store_insn,
8118                                             v->insn))
8119                     reversible_mem_store = 0;
8120                 }
8121             }
8122         }
8123       else
8124         return 0;
8125
8126       /* This code only acts for innermost loops.  Also it simplifies
8127          the memory address check by only reversing loops with
8128          zero or one memory access.
8129          Two memory accesses could involve parts of the same array,
8130          and that can't be reversed.
8131          If the biv is used only for counting, than we don't need to worry
8132          about all these things.  */
8133
8134       if ((num_nonfixed_reads <= 1
8135            && ! loop_info->has_nonconst_call
8136            && ! loop_info->has_volatile
8137            && reversible_mem_store
8138            && (bl->giv_count + bl->biv_count + loop_info->num_mem_sets
8139                + num_unmoved_movables (loop) + compare_and_branch == insn_count)
8140            && (bl == ivs->list && bl->next == 0))
8141           || no_use_except_counting)
8142         {
8143           rtx tem;
8144
8145           /* Loop can be reversed.  */
8146           if (loop_dump_stream)
8147             fprintf (loop_dump_stream, "Can reverse loop\n");
8148
8149           /* Now check other conditions:
8150
8151              The increment must be a constant, as must the initial value,
8152              and the comparison code must be LT.
8153
8154              This test can probably be improved since +/- 1 in the constant
8155              can be obtained by changing LT to LE and vice versa; this is
8156              confusing.  */
8157
8158           if (comparison
8159               /* for constants, LE gets turned into LT */
8160               && (GET_CODE (comparison) == LT
8161                   || (GET_CODE (comparison) == LE
8162                       && no_use_except_counting)))
8163             {
8164               HOST_WIDE_INT add_val, add_adjust, comparison_val = 0;
8165               rtx initial_value, comparison_value;
8166               int nonneg = 0;
8167               enum rtx_code cmp_code;
8168               int comparison_const_width;
8169               unsigned HOST_WIDE_INT comparison_sign_mask;
8170
8171               add_val = INTVAL (bl->biv->add_val);
8172               comparison_value = XEXP (comparison, 1);
8173               if (GET_MODE (comparison_value) == VOIDmode)
8174                 comparison_const_width
8175                   = GET_MODE_BITSIZE (GET_MODE (XEXP (comparison, 0)));
8176               else
8177                 comparison_const_width
8178                   = GET_MODE_BITSIZE (GET_MODE (comparison_value));
8179               if (comparison_const_width > HOST_BITS_PER_WIDE_INT)
8180                 comparison_const_width = HOST_BITS_PER_WIDE_INT;
8181               comparison_sign_mask
8182                 = (unsigned HOST_WIDE_INT) 1 << (comparison_const_width - 1);
8183
8184               /* If the comparison value is not a loop invariant, then we
8185                  can not reverse this loop.
8186
8187                  ??? If the insns which initialize the comparison value as
8188                  a whole compute an invariant result, then we could move
8189                  them out of the loop and proceed with loop reversal.  */
8190               if (! loop_invariant_p (loop, comparison_value))
8191                 return 0;
8192
8193               if (GET_CODE (comparison_value) == CONST_INT)
8194                 comparison_val = INTVAL (comparison_value);
8195               initial_value = bl->initial_value;
8196
8197               /* Normalize the initial value if it is an integer and
8198                  has no other use except as a counter.  This will allow
8199                  a few more loops to be reversed.  */
8200               if (no_use_except_counting
8201                   && GET_CODE (comparison_value) == CONST_INT
8202                   && GET_CODE (initial_value) == CONST_INT)
8203                 {
8204                   comparison_val = comparison_val - INTVAL (bl->initial_value);
8205                   /* The code below requires comparison_val to be a multiple
8206                      of add_val in order to do the loop reversal, so
8207                      round up comparison_val to a multiple of add_val.
8208                      Since comparison_value is constant, we know that the
8209                      current comparison code is LT.  */
8210                   comparison_val = comparison_val + add_val - 1;
8211                   comparison_val
8212                     -= (unsigned HOST_WIDE_INT) comparison_val % add_val;
8213                   /* We postpone overflow checks for COMPARISON_VAL here;
8214                      even if there is an overflow, we might still be able to
8215                      reverse the loop, if converting the loop exit test to
8216                      NE is possible.  */
8217                   initial_value = const0_rtx;
8218                 }
8219
8220               /* First check if we can do a vanilla loop reversal.  */
8221               if (initial_value == const0_rtx
8222                   /* If we have a decrement_and_branch_on_count,
8223                      prefer the NE test, since this will allow that
8224                      instruction to be generated.  Note that we must
8225                      use a vanilla loop reversal if the biv is used to
8226                      calculate a giv or has a non-counting use.  */
8227 #if ! defined (HAVE_decrement_and_branch_until_zero) \
8228 && defined (HAVE_decrement_and_branch_on_count)
8229                   && (! (add_val == 1 && loop->vtop
8230                          && (bl->biv_count == 0
8231                              || no_use_except_counting)))
8232 #endif
8233                   && GET_CODE (comparison_value) == CONST_INT
8234                      /* Now do postponed overflow checks on COMPARISON_VAL.  */
8235                   && ! (((comparison_val - add_val) ^ INTVAL (comparison_value))
8236                         & comparison_sign_mask))
8237                 {
8238                   /* Register will always be nonnegative, with value
8239                      0 on last iteration */
8240                   add_adjust = add_val;
8241                   nonneg = 1;
8242                   cmp_code = GE;
8243                 }
8244               else if (add_val == 1 && loop->vtop
8245                        && (bl->biv_count == 0
8246                            || no_use_except_counting))
8247                 {
8248                   add_adjust = 0;
8249                   cmp_code = NE;
8250                 }
8251               else
8252                 return 0;
8253
8254               if (GET_CODE (comparison) == LE)
8255                 add_adjust -= add_val;
8256
8257               /* If the initial value is not zero, or if the comparison
8258                  value is not an exact multiple of the increment, then we
8259                  can not reverse this loop.  */
8260               if (initial_value == const0_rtx
8261                   && GET_CODE (comparison_value) == CONST_INT)
8262                 {
8263                   if (((unsigned HOST_WIDE_INT) comparison_val % add_val) != 0)
8264                     return 0;
8265                 }
8266               else
8267                 {
8268                   if (! no_use_except_counting || add_val != 1)
8269                     return 0;
8270                 }
8271
8272               final_value = comparison_value;
8273
8274               /* Reset these in case we normalized the initial value
8275                  and comparison value above.  */
8276               if (GET_CODE (comparison_value) == CONST_INT
8277                   && GET_CODE (initial_value) == CONST_INT)
8278                 {
8279                   comparison_value = GEN_INT (comparison_val);
8280                   final_value
8281                     = GEN_INT (comparison_val + INTVAL (bl->initial_value));
8282                 }
8283               bl->initial_value = initial_value;
8284
8285               /* Save some info needed to produce the new insns.  */
8286               reg = bl->biv->dest_reg;
8287               jump_label = condjump_label (PREV_INSN (loop_end));
8288               new_add_val = GEN_INT (-INTVAL (bl->biv->add_val));
8289
8290               /* Set start_value; if this is not a CONST_INT, we need
8291                  to generate a SUB.
8292                  Initialize biv to start_value before loop start.
8293                  The old initializing insn will be deleted as a
8294                  dead store by flow.c.  */
8295               if (initial_value == const0_rtx
8296                   && GET_CODE (comparison_value) == CONST_INT)
8297                 {
8298                   start_value = GEN_INT (comparison_val - add_adjust);
8299                   loop_insn_hoist (loop, gen_move_insn (reg, start_value));
8300                 }
8301               else if (GET_CODE (initial_value) == CONST_INT)
8302                 {
8303                   enum machine_mode mode = GET_MODE (reg);
8304                   rtx offset = GEN_INT (-INTVAL (initial_value) - add_adjust);
8305                   rtx add_insn = gen_add3_insn (reg, comparison_value, offset);
8306
8307                   if (add_insn == 0)
8308                     return 0;
8309
8310                   start_value
8311                     = gen_rtx_PLUS (mode, comparison_value, offset);
8312                   loop_insn_hoist (loop, add_insn);
8313                   if (GET_CODE (comparison) == LE)
8314                     final_value = gen_rtx_PLUS (mode, comparison_value,
8315                                                 GEN_INT (add_val));
8316                 }
8317               else if (! add_adjust)
8318                 {
8319                   enum machine_mode mode = GET_MODE (reg);
8320                   rtx sub_insn = gen_sub3_insn (reg, comparison_value,
8321                                                 initial_value);
8322
8323                   if (sub_insn == 0)
8324                     return 0;
8325                   start_value
8326                     = gen_rtx_MINUS (mode, comparison_value, initial_value);
8327                   loop_insn_hoist (loop, sub_insn);
8328                 }
8329               else
8330                 /* We could handle the other cases too, but it'll be
8331                    better to have a testcase first.  */
8332                 return 0;
8333
8334               /* We may not have a single insn which can increment a reg, so
8335                  create a sequence to hold all the insns from expand_inc.  */
8336               start_sequence ();
8337               expand_inc (reg, new_add_val);
8338               tem = gen_sequence ();
8339               end_sequence ();
8340
8341               p = loop_insn_emit_before (loop, 0, bl->biv->insn, tem);
8342               delete_insn (bl->biv->insn);
8343
8344               /* Update biv info to reflect its new status.  */
8345               bl->biv->insn = p;
8346               bl->initial_value = start_value;
8347               bl->biv->add_val = new_add_val;
8348
8349               /* Update loop info.  */
8350               loop_info->initial_value = reg;
8351               loop_info->initial_equiv_value = reg;
8352               loop_info->final_value = const0_rtx;
8353               loop_info->final_equiv_value = const0_rtx;
8354               loop_info->comparison_value = const0_rtx;
8355               loop_info->comparison_code = cmp_code;
8356               loop_info->increment = new_add_val;
8357
8358               /* Inc LABEL_NUSES so that delete_insn will
8359                  not delete the label.  */
8360               LABEL_NUSES (XEXP (jump_label, 0))++;
8361
8362               /* Emit an insn after the end of the loop to set the biv's
8363                  proper exit value if it is used anywhere outside the loop.  */
8364               if ((REGNO_LAST_UID (bl->regno) != INSN_UID (first_compare))
8365                   || ! bl->init_insn
8366                   || REGNO_FIRST_UID (bl->regno) != INSN_UID (bl->init_insn))
8367                 loop_insn_sink (loop, gen_move_insn (reg, final_value));
8368
8369               /* Delete compare/branch at end of loop.  */
8370               delete_related_insns (PREV_INSN (loop_end));
8371               if (compare_and_branch == 2)
8372                 delete_related_insns (first_compare);
8373
8374               /* Add new compare/branch insn at end of loop.  */
8375               start_sequence ();
8376               emit_cmp_and_jump_insns (reg, const0_rtx, cmp_code, NULL_RTX,
8377                                        GET_MODE (reg), 0,
8378                                        XEXP (jump_label, 0));
8379               tem = gen_sequence ();
8380               end_sequence ();
8381               emit_jump_insn_before (tem, loop_end);
8382
8383               for (tem = PREV_INSN (loop_end);
8384                    tem && GET_CODE (tem) != JUMP_INSN;
8385                    tem = PREV_INSN (tem))
8386                 ;
8387
8388               if (tem)
8389                 JUMP_LABEL (tem) = XEXP (jump_label, 0);
8390
8391               if (nonneg)
8392                 {
8393                   if (tem)
8394                     {
8395                       /* Increment of LABEL_NUSES done above.  */
8396                       /* Register is now always nonnegative,
8397                          so add REG_NONNEG note to the branch.  */
8398                       REG_NOTES (tem) = gen_rtx_EXPR_LIST (REG_NONNEG, reg,
8399                                                            REG_NOTES (tem));
8400                     }
8401                   bl->nonneg = 1;
8402                 }
8403
8404               /* No insn may reference both the reversed and another biv or it
8405                  will fail (see comment near the top of the loop reversal
8406                  code).
8407                  Earlier on, we have verified that the biv has no use except
8408                  counting, or it is the only biv in this function.
8409                  However, the code that computes no_use_except_counting does
8410                  not verify reg notes.  It's possible to have an insn that
8411                  references another biv, and has a REG_EQUAL note with an
8412                  expression based on the reversed biv.  To avoid this case,
8413                  remove all REG_EQUAL notes based on the reversed biv
8414                  here.  */
8415               for (p = loop_start; p != loop_end; p = NEXT_INSN (p))
8416                 if (INSN_P (p))
8417                   {
8418                     rtx *pnote;
8419                     rtx set = single_set (p);
8420                     /* If this is a set of a GIV based on the reversed biv, any
8421                        REG_EQUAL notes should still be correct.  */
8422                     if (! set
8423                         || GET_CODE (SET_DEST (set)) != REG
8424                         || (size_t) REGNO (SET_DEST (set)) >= ivs->n_regs
8425                         || REG_IV_TYPE (ivs, REGNO (SET_DEST (set))) != GENERAL_INDUCT
8426                         || REG_IV_INFO (ivs, REGNO (SET_DEST (set)))->src_reg != bl->biv->src_reg)
8427                       for (pnote = &REG_NOTES (p); *pnote;)
8428                         {
8429                           if (REG_NOTE_KIND (*pnote) == REG_EQUAL
8430                               && reg_mentioned_p (regno_reg_rtx[bl->regno],
8431                                                   XEXP (*pnote, 0)))
8432                             *pnote = XEXP (*pnote, 1);
8433                           else
8434                             pnote = &XEXP (*pnote, 1);
8435                         }
8436                   }
8437
8438               /* Mark that this biv has been reversed.  Each giv which depends
8439                  on this biv, and which is also live past the end of the loop
8440                  will have to be fixed up.  */
8441
8442               bl->reversed = 1;
8443
8444               if (loop_dump_stream)
8445                 {
8446                   fprintf (loop_dump_stream, "Reversed loop");
8447                   if (bl->nonneg)
8448                     fprintf (loop_dump_stream, " and added reg_nonneg\n");
8449                   else
8450                     fprintf (loop_dump_stream, "\n");
8451                 }
8452
8453               return 1;
8454             }
8455         }
8456     }
8457
8458   return 0;
8459 }
8460 \f
8461 /* Verify whether the biv BL appears to be eliminable,
8462    based on the insns in the loop that refer to it.
8463
8464    If ELIMINATE_P is non-zero, actually do the elimination.
8465
8466    THRESHOLD and INSN_COUNT are from loop_optimize and are used to
8467    determine whether invariant insns should be placed inside or at the
8468    start of the loop.  */
8469
8470 static int
8471 maybe_eliminate_biv (loop, bl, eliminate_p, threshold, insn_count)
8472      const struct loop *loop;
8473      struct iv_class *bl;
8474      int eliminate_p;
8475      int threshold, insn_count;
8476 {
8477   struct loop_ivs *ivs = LOOP_IVS (loop);
8478   rtx reg = bl->biv->dest_reg;
8479   rtx p;
8480
8481   /* Scan all insns in the loop, stopping if we find one that uses the
8482      biv in a way that we cannot eliminate.  */
8483
8484   for (p = loop->start; p != loop->end; p = NEXT_INSN (p))
8485     {
8486       enum rtx_code code = GET_CODE (p);
8487       basic_block where_bb = 0;
8488       rtx where_insn = threshold >= insn_count ? 0 : p;
8489
8490       /* If this is a libcall that sets a giv, skip ahead to its end.  */
8491       if (GET_RTX_CLASS (code) == 'i')
8492         {
8493           rtx note = find_reg_note (p, REG_LIBCALL, NULL_RTX);
8494
8495           if (note)
8496             {
8497               rtx last = XEXP (note, 0);
8498               rtx set = single_set (last);
8499
8500               if (set && GET_CODE (SET_DEST (set)) == REG)
8501                 {
8502                   unsigned int regno = REGNO (SET_DEST (set));
8503
8504                   if (regno < ivs->n_regs
8505                       && REG_IV_TYPE (ivs, regno) == GENERAL_INDUCT
8506                       && REG_IV_INFO (ivs, regno)->src_reg == bl->biv->src_reg)
8507                     p = last;
8508                 }
8509             }
8510         }
8511       if ((code == INSN || code == JUMP_INSN || code == CALL_INSN)
8512           && reg_mentioned_p (reg, PATTERN (p))
8513           && ! maybe_eliminate_biv_1 (loop, PATTERN (p), p, bl,
8514                                       eliminate_p, where_bb, where_insn))
8515         {
8516           if (loop_dump_stream)
8517             fprintf (loop_dump_stream,
8518                      "Cannot eliminate biv %d: biv used in insn %d.\n",
8519                      bl->regno, INSN_UID (p));
8520           break;
8521         }
8522     }
8523
8524   if (p == loop->end)
8525     {
8526       if (loop_dump_stream)
8527         fprintf (loop_dump_stream, "biv %d %s eliminated.\n",
8528                  bl->regno, eliminate_p ? "was" : "can be");
8529       return 1;
8530     }
8531
8532   return 0;
8533 }
8534 \f
8535 /* INSN and REFERENCE are instructions in the same insn chain.
8536    Return non-zero if INSN is first.  */
8537
8538 int
8539 loop_insn_first_p (insn, reference)
8540      rtx insn, reference;
8541 {
8542   rtx p, q;
8543
8544   for (p = insn, q = reference;;)
8545     {
8546       /* Start with test for not first so that INSN == REFERENCE yields not
8547          first.  */
8548       if (q == insn || ! p)
8549         return 0;
8550       if (p == reference || ! q)
8551         return 1;
8552
8553       /* Either of P or Q might be a NOTE.  Notes have the same LUID as the
8554          previous insn, hence the <= comparison below does not work if
8555          P is a note.  */
8556       if (INSN_UID (p) < max_uid_for_loop
8557           && INSN_UID (q) < max_uid_for_loop
8558           && GET_CODE (p) != NOTE)
8559         return INSN_LUID (p) <= INSN_LUID (q);
8560
8561       if (INSN_UID (p) >= max_uid_for_loop
8562           || GET_CODE (p) == NOTE)
8563         p = NEXT_INSN (p);
8564       if (INSN_UID (q) >= max_uid_for_loop)
8565         q = NEXT_INSN (q);
8566     }
8567 }
8568
8569 /* We are trying to eliminate BIV in INSN using GIV.  Return non-zero if
8570    the offset that we have to take into account due to auto-increment /
8571    div derivation is zero.  */
8572 static int
8573 biv_elimination_giv_has_0_offset (biv, giv, insn)
8574      struct induction *biv, *giv;
8575      rtx insn;
8576 {
8577   /* If the giv V had the auto-inc address optimization applied
8578      to it, and INSN occurs between the giv insn and the biv
8579      insn, then we'd have to adjust the value used here.
8580      This is rare, so we don't bother to make this possible.  */
8581   if (giv->auto_inc_opt
8582       && ((loop_insn_first_p (giv->insn, insn)
8583            && loop_insn_first_p (insn, biv->insn))
8584           || (loop_insn_first_p (biv->insn, insn)
8585               && loop_insn_first_p (insn, giv->insn))))
8586     return 0;
8587
8588   return 1;
8589 }
8590
8591 /* If BL appears in X (part of the pattern of INSN), see if we can
8592    eliminate its use.  If so, return 1.  If not, return 0.
8593
8594    If BIV does not appear in X, return 1.
8595
8596    If ELIMINATE_P is non-zero, actually do the elimination.
8597    WHERE_INSN/WHERE_BB indicate where extra insns should be added.
8598    Depending on how many items have been moved out of the loop, it
8599    will either be before INSN (when WHERE_INSN is non-zero) or at the
8600    start of the loop (when WHERE_INSN is zero).  */
8601
8602 static int
8603 maybe_eliminate_biv_1 (loop, x, insn, bl, eliminate_p, where_bb, where_insn)
8604      const struct loop *loop;
8605      rtx x, insn;
8606      struct iv_class *bl;
8607      int eliminate_p;
8608      basic_block where_bb;
8609      rtx where_insn;
8610 {
8611   enum rtx_code code = GET_CODE (x);
8612   rtx reg = bl->biv->dest_reg;
8613   enum machine_mode mode = GET_MODE (reg);
8614   struct induction *v;
8615   rtx arg, tem;
8616 #ifdef HAVE_cc0
8617   rtx new;
8618 #endif
8619   int arg_operand;
8620   const char *fmt;
8621   int i, j;
8622
8623   switch (code)
8624     {
8625     case REG:
8626       /* If we haven't already been able to do something with this BIV,
8627          we can't eliminate it.  */
8628       if (x == reg)
8629         return 0;
8630       return 1;
8631
8632     case SET:
8633       /* If this sets the BIV, it is not a problem.  */
8634       if (SET_DEST (x) == reg)
8635         return 1;
8636
8637       /* If this is an insn that defines a giv, it is also ok because
8638          it will go away when the giv is reduced.  */
8639       for (v = bl->giv; v; v = v->next_iv)
8640         if (v->giv_type == DEST_REG && SET_DEST (x) == v->dest_reg)
8641           return 1;
8642
8643 #ifdef HAVE_cc0
8644       if (SET_DEST (x) == cc0_rtx && SET_SRC (x) == reg)
8645         {
8646           /* Can replace with any giv that was reduced and
8647              that has (MULT_VAL != 0) and (ADD_VAL == 0).
8648              Require a constant for MULT_VAL, so we know it's nonzero.
8649              ??? We disable this optimization to avoid potential
8650              overflows.  */
8651
8652           for (v = bl->giv; v; v = v->next_iv)
8653             if (GET_CODE (v->mult_val) == CONST_INT && v->mult_val != const0_rtx
8654                 && v->add_val == const0_rtx
8655                 && ! v->ignore && ! v->maybe_dead && v->always_computable
8656                 && v->mode == mode
8657                 && 0)
8658               {
8659                 if (! biv_elimination_giv_has_0_offset (bl->biv, v, insn))
8660                   continue;
8661
8662                 if (! eliminate_p)
8663                   return 1;
8664
8665                 /* If the giv has the opposite direction of change,
8666                    then reverse the comparison.  */
8667                 if (INTVAL (v->mult_val) < 0)
8668                   new = gen_rtx_COMPARE (GET_MODE (v->new_reg),
8669                                          const0_rtx, v->new_reg);
8670                 else
8671                   new = v->new_reg;
8672
8673                 /* We can probably test that giv's reduced reg.  */
8674                 if (validate_change (insn, &SET_SRC (x), new, 0))
8675                   return 1;
8676               }
8677
8678           /* Look for a giv with (MULT_VAL != 0) and (ADD_VAL != 0);
8679              replace test insn with a compare insn (cmp REDUCED_GIV ADD_VAL).
8680              Require a constant for MULT_VAL, so we know it's nonzero.
8681              ??? Do this only if ADD_VAL is a pointer to avoid a potential
8682              overflow problem.  */
8683
8684           for (v = bl->giv; v; v = v->next_iv)
8685             if (GET_CODE (v->mult_val) == CONST_INT
8686                 && v->mult_val != const0_rtx
8687                 && ! v->ignore && ! v->maybe_dead && v->always_computable
8688                 && v->mode == mode
8689                 && (GET_CODE (v->add_val) == SYMBOL_REF
8690                     || GET_CODE (v->add_val) == LABEL_REF
8691                     || GET_CODE (v->add_val) == CONST
8692                     || (GET_CODE (v->add_val) == REG
8693                         && REG_POINTER (v->add_val))))
8694               {
8695                 if (! biv_elimination_giv_has_0_offset (bl->biv, v, insn))
8696                   continue;
8697
8698                 if (! eliminate_p)
8699                   return 1;
8700
8701                 /* If the giv has the opposite direction of change,
8702                    then reverse the comparison.  */
8703                 if (INTVAL (v->mult_val) < 0)
8704                   new = gen_rtx_COMPARE (VOIDmode, copy_rtx (v->add_val),
8705                                          v->new_reg);
8706                 else
8707                   new = gen_rtx_COMPARE (VOIDmode, v->new_reg,
8708                                          copy_rtx (v->add_val));
8709
8710                 /* Replace biv with the giv's reduced register.  */
8711                 update_reg_last_use (v->add_val, insn);
8712                 if (validate_change (insn, &SET_SRC (PATTERN (insn)), new, 0))
8713                   return 1;
8714
8715                 /* Insn doesn't support that constant or invariant.  Copy it
8716                    into a register (it will be a loop invariant.)  */
8717                 tem = gen_reg_rtx (GET_MODE (v->new_reg));
8718
8719                 loop_insn_emit_before (loop, 0, where_insn,
8720                                        gen_move_insn (tem,
8721                                                       copy_rtx (v->add_val)));
8722
8723                 /* Substitute the new register for its invariant value in
8724                    the compare expression.  */
8725                 XEXP (new, (INTVAL (v->mult_val) < 0) ? 0 : 1) = tem;
8726                 if (validate_change (insn, &SET_SRC (PATTERN (insn)), new, 0))
8727                   return 1;
8728               }
8729         }
8730 #endif
8731       break;
8732
8733     case COMPARE:
8734     case EQ:  case NE:
8735     case GT:  case GE:  case GTU:  case GEU:
8736     case LT:  case LE:  case LTU:  case LEU:
8737       /* See if either argument is the biv.  */
8738       if (XEXP (x, 0) == reg)
8739         arg = XEXP (x, 1), arg_operand = 1;
8740       else if (XEXP (x, 1) == reg)
8741         arg = XEXP (x, 0), arg_operand = 0;
8742       else
8743         break;
8744
8745       if (CONSTANT_P (arg))
8746         {
8747           /* First try to replace with any giv that has constant positive
8748              mult_val and constant add_val.  We might be able to support
8749              negative mult_val, but it seems complex to do it in general.  */
8750
8751           for (v = bl->giv; v; v = v->next_iv)
8752             if (GET_CODE (v->mult_val) == CONST_INT
8753                 && INTVAL (v->mult_val) > 0
8754                 && (GET_CODE (v->add_val) == SYMBOL_REF
8755                     || GET_CODE (v->add_val) == LABEL_REF
8756                     || GET_CODE (v->add_val) == CONST
8757                     || (GET_CODE (v->add_val) == REG
8758                         && REG_POINTER (v->add_val)))
8759                 && ! v->ignore && ! v->maybe_dead && v->always_computable
8760                 && v->mode == mode)
8761               {
8762                 if (! biv_elimination_giv_has_0_offset (bl->biv, v, insn))
8763                   continue;
8764
8765                 if (! eliminate_p)
8766                   return 1;
8767
8768                 /* Replace biv with the giv's reduced reg.  */
8769                 validate_change (insn, &XEXP (x, 1 - arg_operand), v->new_reg, 1);
8770
8771                 /* If all constants are actually constant integers and
8772                    the derived constant can be directly placed in the COMPARE,
8773                    do so.  */
8774                 if (GET_CODE (arg) == CONST_INT
8775                     && GET_CODE (v->mult_val) == CONST_INT
8776                     && GET_CODE (v->add_val) == CONST_INT)
8777                   {
8778                     validate_change (insn, &XEXP (x, arg_operand),
8779                                      GEN_INT (INTVAL (arg)
8780                                               * INTVAL (v->mult_val)
8781                                               + INTVAL (v->add_val)), 1);
8782                   }
8783                 else
8784                   {
8785                     /* Otherwise, load it into a register.  */
8786                     tem = gen_reg_rtx (mode);
8787                     loop_iv_add_mult_emit_before (loop, arg,
8788                                                   v->mult_val, v->add_val,
8789                                                   tem, where_bb, where_insn);
8790                     validate_change (insn, &XEXP (x, arg_operand), tem, 1);
8791                   }
8792                 if (apply_change_group ())
8793                   return 1;
8794               }
8795
8796           /* Look for giv with positive constant mult_val and nonconst add_val.
8797              Insert insns to calculate new compare value.
8798              ??? Turn this off due to possible overflow.  */
8799
8800           for (v = bl->giv; v; v = v->next_iv)
8801             if (GET_CODE (v->mult_val) == CONST_INT
8802                 && INTVAL (v->mult_val) > 0
8803                 && ! v->ignore && ! v->maybe_dead && v->always_computable
8804                 && v->mode == mode
8805                 && 0)
8806               {
8807                 rtx tem;
8808
8809                 if (! biv_elimination_giv_has_0_offset (bl->biv, v, insn))
8810                   continue;
8811
8812                 if (! eliminate_p)
8813                   return 1;
8814
8815                 tem = gen_reg_rtx (mode);
8816
8817                 /* Replace biv with giv's reduced register.  */
8818                 validate_change (insn, &XEXP (x, 1 - arg_operand),
8819                                  v->new_reg, 1);
8820
8821                 /* Compute value to compare against.  */
8822                 loop_iv_add_mult_emit_before (loop, arg,
8823                                               v->mult_val, v->add_val,
8824                                               tem, where_bb, where_insn);
8825                 /* Use it in this insn.  */
8826                 validate_change (insn, &XEXP (x, arg_operand), tem, 1);
8827                 if (apply_change_group ())
8828                   return 1;
8829               }
8830         }
8831       else if (GET_CODE (arg) == REG || GET_CODE (arg) == MEM)
8832         {
8833           if (loop_invariant_p (loop, arg) == 1)
8834             {
8835               /* Look for giv with constant positive mult_val and nonconst
8836                  add_val. Insert insns to compute new compare value.
8837                  ??? Turn this off due to possible overflow.  */
8838
8839               for (v = bl->giv; v; v = v->next_iv)
8840                 if (GET_CODE (v->mult_val) == CONST_INT && INTVAL (v->mult_val) > 0
8841                     && ! v->ignore && ! v->maybe_dead && v->always_computable
8842                     && v->mode == mode
8843                     && 0)
8844                   {
8845                     rtx tem;
8846
8847                     if (! biv_elimination_giv_has_0_offset (bl->biv, v, insn))
8848                       continue;
8849
8850                     if (! eliminate_p)
8851                       return 1;
8852
8853                     tem = gen_reg_rtx (mode);
8854
8855                     /* Replace biv with giv's reduced register.  */
8856                     validate_change (insn, &XEXP (x, 1 - arg_operand),
8857                                      v->new_reg, 1);
8858
8859                     /* Compute value to compare against.  */
8860                     loop_iv_add_mult_emit_before (loop, arg,
8861                                                   v->mult_val, v->add_val,
8862                                                   tem, where_bb, where_insn);
8863                     validate_change (insn, &XEXP (x, arg_operand), tem, 1);
8864                     if (apply_change_group ())
8865                       return 1;
8866                   }
8867             }
8868
8869           /* This code has problems.  Basically, you can't know when
8870              seeing if we will eliminate BL, whether a particular giv
8871              of ARG will be reduced.  If it isn't going to be reduced,
8872              we can't eliminate BL.  We can try forcing it to be reduced,
8873              but that can generate poor code.
8874
8875              The problem is that the benefit of reducing TV, below should
8876              be increased if BL can actually be eliminated, but this means
8877              we might have to do a topological sort of the order in which
8878              we try to process biv.  It doesn't seem worthwhile to do
8879              this sort of thing now.  */
8880
8881 #if 0
8882           /* Otherwise the reg compared with had better be a biv.  */
8883           if (GET_CODE (arg) != REG
8884               || REG_IV_TYPE (ivs, REGNO (arg)) != BASIC_INDUCT)
8885             return 0;
8886
8887           /* Look for a pair of givs, one for each biv,
8888              with identical coefficients.  */
8889           for (v = bl->giv; v; v = v->next_iv)
8890             {
8891               struct induction *tv;
8892
8893               if (v->ignore || v->maybe_dead || v->mode != mode)
8894                 continue;
8895
8896               for (tv = REG_IV_CLASS (ivs, REGNO (arg))->giv; tv;
8897                    tv = tv->next_iv)
8898                 if (! tv->ignore && ! tv->maybe_dead
8899                     && rtx_equal_p (tv->mult_val, v->mult_val)
8900                     && rtx_equal_p (tv->add_val, v->add_val)
8901                     && tv->mode == mode)
8902                   {
8903                     if (! biv_elimination_giv_has_0_offset (bl->biv, v, insn))
8904                       continue;
8905
8906                     if (! eliminate_p)
8907                       return 1;
8908
8909                     /* Replace biv with its giv's reduced reg.  */
8910                     XEXP (x, 1 - arg_operand) = v->new_reg;
8911                     /* Replace other operand with the other giv's
8912                        reduced reg.  */
8913                     XEXP (x, arg_operand) = tv->new_reg;
8914                     return 1;
8915                   }
8916             }
8917 #endif
8918         }
8919
8920       /* If we get here, the biv can't be eliminated.  */
8921       return 0;
8922
8923     case MEM:
8924       /* If this address is a DEST_ADDR giv, it doesn't matter if the
8925          biv is used in it, since it will be replaced.  */
8926       for (v = bl->giv; v; v = v->next_iv)
8927         if (v->giv_type == DEST_ADDR && v->location == &XEXP (x, 0))
8928           return 1;
8929       break;
8930
8931     default:
8932       break;
8933     }
8934
8935   /* See if any subexpression fails elimination.  */
8936   fmt = GET_RTX_FORMAT (code);
8937   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
8938     {
8939       switch (fmt[i])
8940         {
8941         case 'e':
8942           if (! maybe_eliminate_biv_1 (loop, XEXP (x, i), insn, bl,
8943                                        eliminate_p, where_bb, where_insn))
8944             return 0;
8945           break;
8946
8947         case 'E':
8948           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
8949             if (! maybe_eliminate_biv_1 (loop, XVECEXP (x, i, j), insn, bl,
8950                                          eliminate_p, where_bb, where_insn))
8951               return 0;
8952           break;
8953         }
8954     }
8955
8956   return 1;
8957 }
8958 \f
8959 /* Return nonzero if the last use of REG
8960    is in an insn following INSN in the same basic block.  */
8961
8962 static int
8963 last_use_this_basic_block (reg, insn)
8964      rtx reg;
8965      rtx insn;
8966 {
8967   rtx n;
8968   for (n = insn;
8969        n && GET_CODE (n) != CODE_LABEL && GET_CODE (n) != JUMP_INSN;
8970        n = NEXT_INSN (n))
8971     {
8972       if (REGNO_LAST_UID (REGNO (reg)) == INSN_UID (n))
8973         return 1;
8974     }
8975   return 0;
8976 }
8977 \f
8978 /* Called via `note_stores' to record the initial value of a biv.  Here we
8979    just record the location of the set and process it later.  */
8980
8981 static void
8982 record_initial (dest, set, data)
8983      rtx dest;
8984      rtx set;
8985      void *data ATTRIBUTE_UNUSED;
8986 {
8987   struct loop_ivs *ivs = (struct loop_ivs *) data;
8988   struct iv_class *bl;
8989
8990   if (GET_CODE (dest) != REG
8991       || REGNO (dest) >= ivs->n_regs
8992       || REG_IV_TYPE (ivs, REGNO (dest)) != BASIC_INDUCT)
8993     return;
8994
8995   bl = REG_IV_CLASS (ivs, REGNO (dest));
8996
8997   /* If this is the first set found, record it.  */
8998   if (bl->init_insn == 0)
8999     {
9000       bl->init_insn = note_insn;
9001       bl->init_set = set;
9002     }
9003 }
9004 \f
9005 /* If any of the registers in X are "old" and currently have a last use earlier
9006    than INSN, update them to have a last use of INSN.  Their actual last use
9007    will be the previous insn but it will not have a valid uid_luid so we can't
9008    use it.  X must be a source expression only.  */
9009
9010 static void
9011 update_reg_last_use (x, insn)
9012      rtx x;
9013      rtx insn;
9014 {
9015   /* Check for the case where INSN does not have a valid luid.  In this case,
9016      there is no need to modify the regno_last_uid, as this can only happen
9017      when code is inserted after the loop_end to set a pseudo's final value,
9018      and hence this insn will never be the last use of x.
9019      ???? This comment is not correct.  See for example loop_givs_reduce.
9020      This may insert an insn before another new insn.  */
9021   if (GET_CODE (x) == REG && REGNO (x) < max_reg_before_loop
9022       && INSN_UID (insn) < max_uid_for_loop
9023       && REGNO_LAST_LUID (REGNO (x)) < INSN_LUID (insn))
9024     {
9025       REGNO_LAST_UID (REGNO (x)) = INSN_UID (insn);
9026     }
9027   else
9028     {
9029       int i, j;
9030       const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
9031       for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
9032         {
9033           if (fmt[i] == 'e')
9034             update_reg_last_use (XEXP (x, i), insn);
9035           else if (fmt[i] == 'E')
9036             for (j = XVECLEN (x, i) - 1; j >= 0; j--)
9037               update_reg_last_use (XVECEXP (x, i, j), insn);
9038         }
9039     }
9040 }
9041 \f
9042 /* Given an insn INSN and condition COND, return the condition in a
9043    canonical form to simplify testing by callers.  Specifically:
9044
9045    (1) The code will always be a comparison operation (EQ, NE, GT, etc.).
9046    (2) Both operands will be machine operands; (cc0) will have been replaced.
9047    (3) If an operand is a constant, it will be the second operand.
9048    (4) (LE x const) will be replaced with (LT x <const+1>) and similarly
9049        for GE, GEU, and LEU.
9050
9051    If the condition cannot be understood, or is an inequality floating-point
9052    comparison which needs to be reversed, 0 will be returned.
9053
9054    If REVERSE is non-zero, then reverse the condition prior to canonizing it.
9055
9056    If EARLIEST is non-zero, it is a pointer to a place where the earliest
9057    insn used in locating the condition was found.  If a replacement test
9058    of the condition is desired, it should be placed in front of that
9059    insn and we will be sure that the inputs are still valid.
9060
9061    If WANT_REG is non-zero, we wish the condition to be relative to that
9062    register, if possible.  Therefore, do not canonicalize the condition
9063    further.  */
9064
9065 rtx
9066 canonicalize_condition (insn, cond, reverse, earliest, want_reg)
9067      rtx insn;
9068      rtx cond;
9069      int reverse;
9070      rtx *earliest;
9071      rtx want_reg;
9072 {
9073   enum rtx_code code;
9074   rtx prev = insn;
9075   rtx set;
9076   rtx tem;
9077   rtx op0, op1;
9078   int reverse_code = 0;
9079   enum machine_mode mode;
9080
9081   code = GET_CODE (cond);
9082   mode = GET_MODE (cond);
9083   op0 = XEXP (cond, 0);
9084   op1 = XEXP (cond, 1);
9085
9086   if (reverse)
9087     code = reversed_comparison_code (cond, insn);
9088   if (code == UNKNOWN)
9089     return 0;
9090
9091   if (earliest)
9092     *earliest = insn;
9093
9094   /* If we are comparing a register with zero, see if the register is set
9095      in the previous insn to a COMPARE or a comparison operation.  Perform
9096      the same tests as a function of STORE_FLAG_VALUE as find_comparison_args
9097      in cse.c  */
9098
9099   while (GET_RTX_CLASS (code) == '<'
9100          && op1 == CONST0_RTX (GET_MODE (op0))
9101          && op0 != want_reg)
9102     {
9103       /* Set non-zero when we find something of interest.  */
9104       rtx x = 0;
9105
9106 #ifdef HAVE_cc0
9107       /* If comparison with cc0, import actual comparison from compare
9108          insn.  */
9109       if (op0 == cc0_rtx)
9110         {
9111           if ((prev = prev_nonnote_insn (prev)) == 0
9112               || GET_CODE (prev) != INSN
9113               || (set = single_set (prev)) == 0
9114               || SET_DEST (set) != cc0_rtx)
9115             return 0;
9116
9117           op0 = SET_SRC (set);
9118           op1 = CONST0_RTX (GET_MODE (op0));
9119           if (earliest)
9120             *earliest = prev;
9121         }
9122 #endif
9123
9124       /* If this is a COMPARE, pick up the two things being compared.  */
9125       if (GET_CODE (op0) == COMPARE)
9126         {
9127           op1 = XEXP (op0, 1);
9128           op0 = XEXP (op0, 0);
9129           continue;
9130         }
9131       else if (GET_CODE (op0) != REG)
9132         break;
9133
9134       /* Go back to the previous insn.  Stop if it is not an INSN.  We also
9135          stop if it isn't a single set or if it has a REG_INC note because
9136          we don't want to bother dealing with it.  */
9137
9138       if ((prev = prev_nonnote_insn (prev)) == 0
9139           || GET_CODE (prev) != INSN
9140           || FIND_REG_INC_NOTE (prev, NULL_RTX))
9141         break;
9142
9143       set = set_of (op0, prev);
9144
9145       if (set
9146           && (GET_CODE (set) != SET
9147               || !rtx_equal_p (SET_DEST (set), op0)))
9148         break;
9149
9150       /* If this is setting OP0, get what it sets it to if it looks
9151          relevant.  */
9152       if (set)
9153         {
9154           enum machine_mode inner_mode = GET_MODE (SET_DEST (set));
9155
9156           /* ??? We may not combine comparisons done in a CCmode with
9157              comparisons not done in a CCmode.  This is to aid targets
9158              like Alpha that have an IEEE compliant EQ instruction, and
9159              a non-IEEE compliant BEQ instruction.  The use of CCmode is
9160              actually artificial, simply to prevent the combination, but
9161              should not affect other platforms.
9162
9163              However, we must allow VOIDmode comparisons to match either
9164              CCmode or non-CCmode comparison, because some ports have
9165              modeless comparisons inside branch patterns.
9166
9167              ??? This mode check should perhaps look more like the mode check
9168              in simplify_comparison in combine.  */
9169
9170           if ((GET_CODE (SET_SRC (set)) == COMPARE
9171                || (((code == NE
9172                      || (code == LT
9173                          && GET_MODE_CLASS (inner_mode) == MODE_INT
9174                          && (GET_MODE_BITSIZE (inner_mode)
9175                              <= HOST_BITS_PER_WIDE_INT)
9176                          && (STORE_FLAG_VALUE
9177                              & ((HOST_WIDE_INT) 1
9178                                 << (GET_MODE_BITSIZE (inner_mode) - 1))))
9179 #ifdef FLOAT_STORE_FLAG_VALUE
9180                      || (code == LT
9181                          && GET_MODE_CLASS (inner_mode) == MODE_FLOAT
9182                          && (REAL_VALUE_NEGATIVE
9183                              (FLOAT_STORE_FLAG_VALUE (inner_mode))))
9184 #endif
9185                      ))
9186                    && GET_RTX_CLASS (GET_CODE (SET_SRC (set))) == '<'))
9187               && (((GET_MODE_CLASS (mode) == MODE_CC)
9188                    == (GET_MODE_CLASS (inner_mode) == MODE_CC))
9189                   || mode == VOIDmode || inner_mode == VOIDmode))
9190             x = SET_SRC (set);
9191           else if (((code == EQ
9192                      || (code == GE
9193                          && (GET_MODE_BITSIZE (inner_mode)
9194                              <= HOST_BITS_PER_WIDE_INT)
9195                          && GET_MODE_CLASS (inner_mode) == MODE_INT
9196                          && (STORE_FLAG_VALUE
9197                              & ((HOST_WIDE_INT) 1
9198                                 << (GET_MODE_BITSIZE (inner_mode) - 1))))
9199 #ifdef FLOAT_STORE_FLAG_VALUE
9200                      || (code == GE
9201                          && GET_MODE_CLASS (inner_mode) == MODE_FLOAT
9202                          && (REAL_VALUE_NEGATIVE
9203                              (FLOAT_STORE_FLAG_VALUE (inner_mode))))
9204 #endif
9205                      ))
9206                    && GET_RTX_CLASS (GET_CODE (SET_SRC (set))) == '<'
9207                    && (((GET_MODE_CLASS (mode) == MODE_CC)
9208                         == (GET_MODE_CLASS (inner_mode) == MODE_CC))
9209                        || mode == VOIDmode || inner_mode == VOIDmode))
9210
9211             {
9212               reverse_code = 1;
9213               x = SET_SRC (set);
9214             }
9215           else
9216             break;
9217         }
9218
9219       else if (reg_set_p (op0, prev))
9220         /* If this sets OP0, but not directly, we have to give up.  */
9221         break;
9222
9223       if (x)
9224         {
9225           if (GET_RTX_CLASS (GET_CODE (x)) == '<')
9226             code = GET_CODE (x);
9227           if (reverse_code)
9228             {
9229               code = reversed_comparison_code (x, prev);
9230               if (code == UNKNOWN)
9231                 return 0;
9232               reverse_code = 0;
9233             }
9234
9235           op0 = XEXP (x, 0), op1 = XEXP (x, 1);
9236           if (earliest)
9237             *earliest = prev;
9238         }
9239     }
9240
9241   /* If constant is first, put it last.  */
9242   if (CONSTANT_P (op0))
9243     code = swap_condition (code), tem = op0, op0 = op1, op1 = tem;
9244
9245   /* If OP0 is the result of a comparison, we weren't able to find what
9246      was really being compared, so fail.  */
9247   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
9248     return 0;
9249
9250   /* Canonicalize any ordered comparison with integers involving equality
9251      if we can do computations in the relevant mode and we do not
9252      overflow.  */
9253
9254   if (GET_CODE (op1) == CONST_INT
9255       && GET_MODE (op0) != VOIDmode
9256       && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
9257     {
9258       HOST_WIDE_INT const_val = INTVAL (op1);
9259       unsigned HOST_WIDE_INT uconst_val = const_val;
9260       unsigned HOST_WIDE_INT max_val
9261         = (unsigned HOST_WIDE_INT) GET_MODE_MASK (GET_MODE (op0));
9262
9263       switch (code)
9264         {
9265         case LE:
9266           if ((unsigned HOST_WIDE_INT) const_val != max_val >> 1)
9267             code = LT, op1 = gen_int_mode (const_val + 1, GET_MODE (op0));
9268           break;
9269
9270         /* When cross-compiling, const_val might be sign-extended from
9271            BITS_PER_WORD to HOST_BITS_PER_WIDE_INT */
9272         case GE:
9273           if ((HOST_WIDE_INT) (const_val & max_val)
9274               != (((HOST_WIDE_INT) 1
9275                    << (GET_MODE_BITSIZE (GET_MODE (op0)) - 1))))
9276             code = GT, op1 = gen_int_mode (const_val - 1, GET_MODE (op0));
9277           break;
9278
9279         case LEU:
9280           if (uconst_val < max_val)
9281             code = LTU, op1 = gen_int_mode (uconst_val + 1, GET_MODE (op0));
9282           break;
9283
9284         case GEU:
9285           if (uconst_val != 0)
9286             code = GTU, op1 = gen_int_mode (uconst_val - 1, GET_MODE (op0));
9287           break;
9288
9289         default:
9290           break;
9291         }
9292     }
9293
9294 #ifdef HAVE_cc0
9295   /* Never return CC0; return zero instead.  */
9296   if (op0 == cc0_rtx)
9297     return 0;
9298 #endif
9299
9300   return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
9301 }
9302
9303 /* Given a jump insn JUMP, return the condition that will cause it to branch
9304    to its JUMP_LABEL.  If the condition cannot be understood, or is an
9305    inequality floating-point comparison which needs to be reversed, 0 will
9306    be returned.
9307
9308    If EARLIEST is non-zero, it is a pointer to a place where the earliest
9309    insn used in locating the condition was found.  If a replacement test
9310    of the condition is desired, it should be placed in front of that
9311    insn and we will be sure that the inputs are still valid.  */
9312
9313 rtx
9314 get_condition (jump, earliest)
9315      rtx jump;
9316      rtx *earliest;
9317 {
9318   rtx cond;
9319   int reverse;
9320   rtx set;
9321
9322   /* If this is not a standard conditional jump, we can't parse it.  */
9323   if (GET_CODE (jump) != JUMP_INSN
9324       || ! any_condjump_p (jump))
9325     return 0;
9326   set = pc_set (jump);
9327
9328   cond = XEXP (SET_SRC (set), 0);
9329
9330   /* If this branches to JUMP_LABEL when the condition is false, reverse
9331      the condition.  */
9332   reverse
9333     = GET_CODE (XEXP (SET_SRC (set), 2)) == LABEL_REF
9334       && XEXP (XEXP (SET_SRC (set), 2), 0) == JUMP_LABEL (jump);
9335
9336   return canonicalize_condition (jump, cond, reverse, earliest, NULL_RTX);
9337 }
9338
9339 /* Similar to above routine, except that we also put an invariant last
9340    unless both operands are invariants.  */
9341
9342 rtx
9343 get_condition_for_loop (loop, x)
9344      const struct loop *loop;
9345      rtx x;
9346 {
9347   rtx comparison = get_condition (x, (rtx*) 0);
9348
9349   if (comparison == 0
9350       || ! loop_invariant_p (loop, XEXP (comparison, 0))
9351       || loop_invariant_p (loop, XEXP (comparison, 1)))
9352     return comparison;
9353
9354   return gen_rtx_fmt_ee (swap_condition (GET_CODE (comparison)), VOIDmode,
9355                          XEXP (comparison, 1), XEXP (comparison, 0));
9356 }
9357
9358 /* Scan the function and determine whether it has indirect (computed) jumps.
9359
9360    This is taken mostly from flow.c; similar code exists elsewhere
9361    in the compiler.  It may be useful to put this into rtlanal.c.  */
9362 static int
9363 indirect_jump_in_function_p (start)
9364      rtx start;
9365 {
9366   rtx insn;
9367
9368   for (insn = start; insn; insn = NEXT_INSN (insn))
9369     if (computed_jump_p (insn))
9370       return 1;
9371
9372   return 0;
9373 }
9374
9375 /* Add MEM to the LOOP_MEMS array, if appropriate.  See the
9376    documentation for LOOP_MEMS for the definition of `appropriate'.
9377    This function is called from prescan_loop via for_each_rtx.  */
9378
9379 static int
9380 insert_loop_mem (mem, data)
9381      rtx *mem;
9382      void *data ATTRIBUTE_UNUSED;
9383 {
9384   struct loop_info *loop_info = data;
9385   int i;
9386   rtx m = *mem;
9387
9388   if (m == NULL_RTX)
9389     return 0;
9390
9391   switch (GET_CODE (m))
9392     {
9393     case MEM:
9394       break;
9395
9396     case CLOBBER:
9397       /* We're not interested in MEMs that are only clobbered.  */
9398       return -1;
9399
9400     case CONST_DOUBLE:
9401       /* We're not interested in the MEM associated with a
9402          CONST_DOUBLE, so there's no need to traverse into this.  */
9403       return -1;
9404
9405     case EXPR_LIST:
9406       /* We're not interested in any MEMs that only appear in notes.  */
9407       return -1;
9408
9409     default:
9410       /* This is not a MEM.  */
9411       return 0;
9412     }
9413
9414   /* See if we've already seen this MEM.  */
9415   for (i = 0; i < loop_info->mems_idx; ++i)
9416     if (rtx_equal_p (m, loop_info->mems[i].mem))
9417       {
9418         if (GET_MODE (m) != GET_MODE (loop_info->mems[i].mem))
9419           /* The modes of the two memory accesses are different.  If
9420              this happens, something tricky is going on, and we just
9421              don't optimize accesses to this MEM.  */
9422           loop_info->mems[i].optimize = 0;
9423
9424         return 0;
9425       }
9426
9427   /* Resize the array, if necessary.  */
9428   if (loop_info->mems_idx == loop_info->mems_allocated)
9429     {
9430       if (loop_info->mems_allocated != 0)
9431         loop_info->mems_allocated *= 2;
9432       else
9433         loop_info->mems_allocated = 32;
9434
9435       loop_info->mems = (loop_mem_info *)
9436         xrealloc (loop_info->mems,
9437                   loop_info->mems_allocated * sizeof (loop_mem_info));
9438     }
9439
9440   /* Actually insert the MEM.  */
9441   loop_info->mems[loop_info->mems_idx].mem = m;
9442   /* We can't hoist this MEM out of the loop if it's a BLKmode MEM
9443      because we can't put it in a register.  We still store it in the
9444      table, though, so that if we see the same address later, but in a
9445      non-BLK mode, we'll not think we can optimize it at that point.  */
9446   loop_info->mems[loop_info->mems_idx].optimize = (GET_MODE (m) != BLKmode);
9447   loop_info->mems[loop_info->mems_idx].reg = NULL_RTX;
9448   ++loop_info->mems_idx;
9449
9450   return 0;
9451 }
9452
9453
9454 /* Allocate REGS->ARRAY or reallocate it if it is too small.
9455
9456    Increment REGS->ARRAY[I].SET_IN_LOOP at the index I of each
9457    register that is modified by an insn between FROM and TO.  If the
9458    value of an element of REGS->array[I].SET_IN_LOOP becomes 127 or
9459    more, stop incrementing it, to avoid overflow.
9460
9461    Store in REGS->ARRAY[I].SINGLE_USAGE the single insn in which
9462    register I is used, if it is only used once.  Otherwise, it is set
9463    to 0 (for no uses) or const0_rtx for more than one use.  This
9464    parameter may be zero, in which case this processing is not done.
9465
9466    Set REGS->ARRAY[I].MAY_NOT_OPTIMIZE nonzero if we should not
9467    optimize register I.  */
9468
9469 static void
9470 loop_regs_scan (loop, extra_size)
9471      const struct loop *loop;
9472      int extra_size;
9473 {
9474   struct loop_regs *regs = LOOP_REGS (loop);
9475   int old_nregs;
9476   /* last_set[n] is nonzero iff reg n has been set in the current
9477    basic block.  In that case, it is the insn that last set reg n.  */
9478   rtx *last_set;
9479   rtx insn;
9480   int i;
9481
9482   old_nregs = regs->num;
9483   regs->num = max_reg_num ();
9484
9485   /* Grow the regs array if not allocated or too small.  */
9486   if (regs->num >= regs->size)
9487     {
9488       regs->size = regs->num + extra_size;
9489
9490       regs->array = (struct loop_reg *)
9491         xrealloc (regs->array, regs->size * sizeof (*regs->array));
9492
9493       /* Zero the new elements.  */
9494       memset (regs->array + old_nregs, 0,
9495               (regs->size - old_nregs) * sizeof (*regs->array));
9496     }
9497
9498   /* Clear previously scanned fields but do not clear n_times_set.  */
9499   for (i = 0; i < old_nregs; i++)
9500     {
9501       regs->array[i].set_in_loop = 0;
9502       regs->array[i].may_not_optimize = 0;
9503       regs->array[i].single_usage = NULL_RTX;
9504     }
9505
9506   last_set = (rtx *) xcalloc (regs->num, sizeof (rtx));
9507
9508   /* Scan the loop, recording register usage.  */
9509   for (insn = loop->top ? loop->top : loop->start; insn != loop->end;
9510        insn = NEXT_INSN (insn))
9511     {
9512       if (INSN_P (insn))
9513         {
9514           /* Record registers that have exactly one use.  */
9515           find_single_use_in_loop (regs, insn, PATTERN (insn));
9516
9517           /* Include uses in REG_EQUAL notes.  */
9518           if (REG_NOTES (insn))
9519             find_single_use_in_loop (regs, insn, REG_NOTES (insn));
9520
9521           if (GET_CODE (PATTERN (insn)) == SET
9522               || GET_CODE (PATTERN (insn)) == CLOBBER)
9523             count_one_set (regs, insn, PATTERN (insn), last_set);
9524           else if (GET_CODE (PATTERN (insn)) == PARALLEL)
9525             {
9526               int i;
9527               for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
9528                 count_one_set (regs, insn, XVECEXP (PATTERN (insn), 0, i),
9529                                last_set);
9530             }
9531         }
9532
9533       if (GET_CODE (insn) == CODE_LABEL || GET_CODE (insn) == JUMP_INSN)
9534         memset (last_set, 0, regs->num * sizeof (rtx));
9535     }
9536
9537   /* Invalidate all hard registers clobbered by calls.  With one exception:
9538      a call-clobbered PIC register is still function-invariant for our
9539      purposes, since we can hoist any PIC calculations out of the loop.
9540      Thus the call to rtx_varies_p.  */
9541   if (LOOP_INFO (loop)->has_call)
9542     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
9543       if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i)
9544           && rtx_varies_p (gen_rtx_REG (Pmode, i), /*for_alias=*/1))
9545         {
9546           regs->array[i].may_not_optimize = 1;
9547           regs->array[i].set_in_loop = 1;
9548         }
9549
9550 #ifdef AVOID_CCMODE_COPIES
9551   /* Don't try to move insns which set CC registers if we should not
9552      create CCmode register copies.  */
9553   for (i = regs->num - 1; i >= FIRST_PSEUDO_REGISTER; i--)
9554     if (GET_MODE_CLASS (GET_MODE (regno_reg_rtx[i])) == MODE_CC)
9555       regs->array[i].may_not_optimize = 1;
9556 #endif
9557
9558   /* Set regs->array[I].n_times_set for the new registers.  */
9559   for (i = old_nregs; i < regs->num; i++)
9560     regs->array[i].n_times_set = regs->array[i].set_in_loop;
9561
9562   free (last_set);
9563 }
9564
9565 /* Returns the number of real INSNs in the LOOP.  */
9566
9567 static int
9568 count_insns_in_loop (loop)
9569      const struct loop *loop;
9570 {
9571   int count = 0;
9572   rtx insn;
9573
9574   for (insn = loop->top ? loop->top : loop->start; insn != loop->end;
9575        insn = NEXT_INSN (insn))
9576     if (INSN_P (insn))
9577       ++count;
9578
9579   return count;
9580 }
9581
9582 /* Move MEMs into registers for the duration of the loop.  */
9583
9584 static void
9585 load_mems (loop)
9586      const struct loop *loop;
9587 {
9588   struct loop_info *loop_info = LOOP_INFO (loop);
9589   struct loop_regs *regs = LOOP_REGS (loop);
9590   int maybe_never = 0;
9591   int i;
9592   rtx p, prev_ebb_head;
9593   rtx label = NULL_RTX;
9594   rtx end_label;
9595   /* Nonzero if the next instruction may never be executed.  */
9596   int next_maybe_never = 0;
9597   unsigned int last_max_reg = max_reg_num ();
9598
9599   if (loop_info->mems_idx == 0)
9600     return;
9601
9602   /* We cannot use next_label here because it skips over normal insns.  */
9603   end_label = next_nonnote_insn (loop->end);
9604   if (end_label && GET_CODE (end_label) != CODE_LABEL)
9605     end_label = NULL_RTX;
9606
9607   /* Check to see if it's possible that some instructions in the loop are
9608      never executed.  Also check if there is a goto out of the loop other
9609      than right after the end of the loop.  */
9610   for (p = next_insn_in_loop (loop, loop->scan_start);
9611        p != NULL_RTX;
9612        p = next_insn_in_loop (loop, p))
9613     {
9614       if (GET_CODE (p) == CODE_LABEL)
9615         maybe_never = 1;
9616       else if (GET_CODE (p) == JUMP_INSN
9617                /* If we enter the loop in the middle, and scan
9618                   around to the beginning, don't set maybe_never
9619                   for that.  This must be an unconditional jump,
9620                   otherwise the code at the top of the loop might
9621                   never be executed.  Unconditional jumps are
9622                   followed a by barrier then loop end.  */
9623                && ! (GET_CODE (p) == JUMP_INSN
9624                      && JUMP_LABEL (p) == loop->top
9625                      && NEXT_INSN (NEXT_INSN (p)) == loop->end
9626                      && any_uncondjump_p (p)))
9627         {
9628           /* If this is a jump outside of the loop but not right
9629              after the end of the loop, we would have to emit new fixup
9630              sequences for each such label.  */
9631           if (/* If we can't tell where control might go when this
9632                  JUMP_INSN is executed, we must be conservative.  */
9633               !JUMP_LABEL (p)
9634               || (JUMP_LABEL (p) != end_label
9635                   && (INSN_UID (JUMP_LABEL (p)) >= max_uid_for_loop
9636                       || INSN_LUID (JUMP_LABEL (p)) < INSN_LUID (loop->start)
9637                       || INSN_LUID (JUMP_LABEL (p)) > INSN_LUID (loop->end))))
9638             return;
9639
9640           if (!any_condjump_p (p))
9641             /* Something complicated.  */
9642             maybe_never = 1;
9643           else
9644             /* If there are any more instructions in the loop, they
9645                might not be reached.  */
9646             next_maybe_never = 1;
9647         }
9648       else if (next_maybe_never)
9649         maybe_never = 1;
9650     }
9651
9652   /* Find start of the extended basic block that enters the loop.  */
9653   for (p = loop->start;
9654        PREV_INSN (p) && GET_CODE (p) != CODE_LABEL;
9655        p = PREV_INSN (p))
9656     ;
9657   prev_ebb_head = p;
9658
9659   cselib_init ();
9660
9661   /* Build table of mems that get set to constant values before the
9662      loop.  */
9663   for (; p != loop->start; p = NEXT_INSN (p))
9664     cselib_process_insn (p);
9665
9666   /* Actually move the MEMs.  */
9667   for (i = 0; i < loop_info->mems_idx; ++i)
9668     {
9669       regset_head load_copies;
9670       regset_head store_copies;
9671       int written = 0;
9672       rtx reg;
9673       rtx mem = loop_info->mems[i].mem;
9674       rtx mem_list_entry;
9675
9676       if (MEM_VOLATILE_P (mem)
9677           || loop_invariant_p (loop, XEXP (mem, 0)) != 1)
9678         /* There's no telling whether or not MEM is modified.  */
9679         loop_info->mems[i].optimize = 0;
9680
9681       /* Go through the MEMs written to in the loop to see if this
9682          one is aliased by one of them.  */
9683       mem_list_entry = loop_info->store_mems;
9684       while (mem_list_entry)
9685         {
9686           if (rtx_equal_p (mem, XEXP (mem_list_entry, 0)))
9687             written = 1;
9688           else if (true_dependence (XEXP (mem_list_entry, 0), VOIDmode,
9689                                     mem, rtx_varies_p))
9690             {
9691               /* MEM is indeed aliased by this store.  */
9692               loop_info->mems[i].optimize = 0;
9693               break;
9694             }
9695           mem_list_entry = XEXP (mem_list_entry, 1);
9696         }
9697
9698       if (flag_float_store && written
9699           && GET_MODE_CLASS (GET_MODE (mem)) == MODE_FLOAT)
9700         loop_info->mems[i].optimize = 0;
9701
9702       /* If this MEM is written to, we must be sure that there
9703          are no reads from another MEM that aliases this one.  */
9704       if (loop_info->mems[i].optimize && written)
9705         {
9706           int j;
9707
9708           for (j = 0; j < loop_info->mems_idx; ++j)
9709             {
9710               if (j == i)
9711                 continue;
9712               else if (true_dependence (mem,
9713                                         VOIDmode,
9714                                         loop_info->mems[j].mem,
9715                                         rtx_varies_p))
9716                 {
9717                   /* It's not safe to hoist loop_info->mems[i] out of
9718                      the loop because writes to it might not be
9719                      seen by reads from loop_info->mems[j].  */
9720                   loop_info->mems[i].optimize = 0;
9721                   break;
9722                 }
9723             }
9724         }
9725
9726       if (maybe_never && may_trap_p (mem))
9727         /* We can't access the MEM outside the loop; it might
9728            cause a trap that wouldn't have happened otherwise.  */
9729         loop_info->mems[i].optimize = 0;
9730
9731       if (!loop_info->mems[i].optimize)
9732         /* We thought we were going to lift this MEM out of the
9733            loop, but later discovered that we could not.  */
9734         continue;
9735
9736       INIT_REG_SET (&load_copies);
9737       INIT_REG_SET (&store_copies);
9738
9739       /* Allocate a pseudo for this MEM.  We set REG_USERVAR_P in
9740          order to keep scan_loop from moving stores to this MEM
9741          out of the loop just because this REG is neither a
9742          user-variable nor used in the loop test.  */
9743       reg = gen_reg_rtx (GET_MODE (mem));
9744       REG_USERVAR_P (reg) = 1;
9745       loop_info->mems[i].reg = reg;
9746
9747       /* Now, replace all references to the MEM with the
9748          corresponding pseudos.  */
9749       maybe_never = 0;
9750       for (p = next_insn_in_loop (loop, loop->scan_start);
9751            p != NULL_RTX;
9752            p = next_insn_in_loop (loop, p))
9753         {
9754           if (INSN_P (p))
9755             {
9756               rtx set;
9757
9758               set = single_set (p);
9759
9760               /* See if this copies the mem into a register that isn't
9761                  modified afterwards.  We'll try to do copy propagation
9762                  a little further on.  */
9763               if (set
9764                   /* @@@ This test is _way_ too conservative.  */
9765                   && ! maybe_never
9766                   && GET_CODE (SET_DEST (set)) == REG
9767                   && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER
9768                   && REGNO (SET_DEST (set)) < last_max_reg
9769                   && regs->array[REGNO (SET_DEST (set))].n_times_set == 1
9770                   && rtx_equal_p (SET_SRC (set), mem))
9771                 SET_REGNO_REG_SET (&load_copies, REGNO (SET_DEST (set)));
9772
9773               /* See if this copies the mem from a register that isn't
9774                  modified afterwards.  We'll try to remove the
9775                  redundant copy later on by doing a little register
9776                  renaming and copy propagation.   This will help
9777                  to untangle things for the BIV detection code.  */
9778               if (set
9779                   && ! maybe_never
9780                   && GET_CODE (SET_SRC (set)) == REG
9781                   && REGNO (SET_SRC (set)) >= FIRST_PSEUDO_REGISTER
9782                   && REGNO (SET_SRC (set)) < last_max_reg
9783                   && regs->array[REGNO (SET_SRC (set))].n_times_set == 1
9784                   && rtx_equal_p (SET_DEST (set), mem))
9785                 SET_REGNO_REG_SET (&store_copies, REGNO (SET_SRC (set)));
9786
9787               /* Replace the memory reference with the shadow register.  */
9788               replace_loop_mems (p, loop_info->mems[i].mem,
9789                                  loop_info->mems[i].reg);
9790             }
9791
9792           if (GET_CODE (p) == CODE_LABEL
9793               || GET_CODE (p) == JUMP_INSN)
9794             maybe_never = 1;
9795         }
9796
9797       if (! apply_change_group ())
9798         /* We couldn't replace all occurrences of the MEM.  */
9799         loop_info->mems[i].optimize = 0;
9800       else
9801         {
9802           /* Load the memory immediately before LOOP->START, which is
9803              the NOTE_LOOP_BEG.  */
9804           cselib_val *e = cselib_lookup (mem, VOIDmode, 0);
9805           rtx set;
9806           rtx best = mem;
9807           int j;
9808           struct elt_loc_list *const_equiv = 0;
9809
9810           if (e)
9811             {
9812               struct elt_loc_list *equiv;
9813               struct elt_loc_list *best_equiv = 0;
9814               for (equiv = e->locs; equiv; equiv = equiv->next)
9815                 {
9816                   if (CONSTANT_P (equiv->loc))
9817                     const_equiv = equiv;
9818                   else if (GET_CODE (equiv->loc) == REG
9819                            /* Extending hard register lifetimes causes crash
9820                               on SRC targets.  Doing so on non-SRC is
9821                               probably also not good idea, since we most
9822                               probably have pseudoregister equivalence as
9823                               well.  */
9824                            && REGNO (equiv->loc) >= FIRST_PSEUDO_REGISTER)
9825                     best_equiv = equiv;
9826                 }
9827               /* Use the constant equivalence if that is cheap enough.  */
9828               if (! best_equiv)
9829                 best_equiv = const_equiv;
9830               else if (const_equiv
9831                        && (rtx_cost (const_equiv->loc, SET)
9832                            <= rtx_cost (best_equiv->loc, SET)))
9833                 {
9834                   best_equiv = const_equiv;
9835                   const_equiv = 0;
9836                 }
9837
9838               /* If best_equiv is nonzero, we know that MEM is set to a
9839                  constant or register before the loop.  We will use this
9840                  knowledge to initialize the shadow register with that
9841                  constant or reg rather than by loading from MEM.  */
9842               if (best_equiv)
9843                 best = copy_rtx (best_equiv->loc);
9844             }
9845
9846           set = gen_move_insn (reg, best);
9847           set = loop_insn_hoist (loop, set);
9848           if (REG_P (best))
9849             {
9850               for (p = prev_ebb_head; p != loop->start; p = NEXT_INSN (p))
9851                 if (REGNO_LAST_UID (REGNO (best)) == INSN_UID (p))
9852                   {
9853                     REGNO_LAST_UID (REGNO (best)) = INSN_UID (set);
9854                     break;
9855                   }
9856             }
9857
9858           if (const_equiv)
9859             set_unique_reg_note (set, REG_EQUAL, copy_rtx (const_equiv->loc));
9860
9861           if (written)
9862             {
9863               if (label == NULL_RTX)
9864                 {
9865                   label = gen_label_rtx ();
9866                   emit_label_after (label, loop->end);
9867                 }
9868
9869               /* Store the memory immediately after END, which is
9870                  the NOTE_LOOP_END.  */
9871               set = gen_move_insn (copy_rtx (mem), reg);
9872               loop_insn_emit_after (loop, 0, label, set);
9873             }
9874
9875           if (loop_dump_stream)
9876             {
9877               fprintf (loop_dump_stream, "Hoisted regno %d %s from ",
9878                        REGNO (reg), (written ? "r/w" : "r/o"));
9879               print_rtl (loop_dump_stream, mem);
9880               fputc ('\n', loop_dump_stream);
9881             }
9882
9883           /* Attempt a bit of copy propagation.  This helps untangle the
9884              data flow, and enables {basic,general}_induction_var to find
9885              more bivs/givs.  */
9886           EXECUTE_IF_SET_IN_REG_SET
9887             (&load_copies, FIRST_PSEUDO_REGISTER, j,
9888              {
9889                try_copy_prop (loop, reg, j);
9890              });
9891           CLEAR_REG_SET (&load_copies);
9892
9893           EXECUTE_IF_SET_IN_REG_SET
9894             (&store_copies, FIRST_PSEUDO_REGISTER, j,
9895              {
9896                try_swap_copy_prop (loop, reg, j);
9897              });
9898           CLEAR_REG_SET (&store_copies);
9899         }
9900     }
9901
9902   if (label != NULL_RTX && end_label != NULL_RTX)
9903     {
9904       /* Now, we need to replace all references to the previous exit
9905          label with the new one.  */
9906       rtx_pair rr;
9907       rr.r1 = end_label;
9908       rr.r2 = label;
9909
9910       for (p = loop->start; p != loop->end; p = NEXT_INSN (p))
9911         {
9912           for_each_rtx (&p, replace_label, &rr);
9913
9914           /* If this is a JUMP_INSN, then we also need to fix the JUMP_LABEL
9915              field.  This is not handled by for_each_rtx because it doesn't
9916              handle unprinted ('0') fields.  We need to update JUMP_LABEL
9917              because the immediately following unroll pass will use it.
9918              replace_label would not work anyways, because that only handles
9919              LABEL_REFs.  */
9920           if (GET_CODE (p) == JUMP_INSN && JUMP_LABEL (p) == end_label)
9921             JUMP_LABEL (p) = label;
9922         }
9923     }
9924
9925   cselib_finish ();
9926 }
9927
9928 /* For communication between note_reg_stored and its caller.  */
9929 struct note_reg_stored_arg
9930 {
9931   int set_seen;
9932   rtx reg;
9933 };
9934
9935 /* Called via note_stores, record in SET_SEEN whether X, which is written,
9936    is equal to ARG.  */
9937 static void
9938 note_reg_stored (x, setter, arg)
9939      rtx x, setter ATTRIBUTE_UNUSED;
9940      void *arg;
9941 {
9942   struct note_reg_stored_arg *t = (struct note_reg_stored_arg *) arg;
9943   if (t->reg == x)
9944     t->set_seen = 1;
9945 }
9946
9947 /* Try to replace every occurrence of pseudo REGNO with REPLACEMENT.
9948    There must be exactly one insn that sets this pseudo; it will be
9949    deleted if all replacements succeed and we can prove that the register
9950    is not used after the loop.  */
9951
9952 static void
9953 try_copy_prop (loop, replacement, regno)
9954      const struct loop *loop;
9955      rtx replacement;
9956      unsigned int regno;
9957 {
9958   /* This is the reg that we are copying from.  */
9959   rtx reg_rtx = regno_reg_rtx[regno];
9960   rtx init_insn = 0;
9961   rtx insn;
9962   /* These help keep track of whether we replaced all uses of the reg.  */
9963   int replaced_last = 0;
9964   int store_is_first = 0;
9965
9966   for (insn = next_insn_in_loop (loop, loop->scan_start);
9967        insn != NULL_RTX;
9968        insn = next_insn_in_loop (loop, insn))
9969     {
9970       rtx set;
9971
9972       /* Only substitute within one extended basic block from the initializing
9973          insn.  */
9974       if (GET_CODE (insn) == CODE_LABEL && init_insn)
9975         break;
9976
9977       if (! INSN_P (insn))
9978         continue;
9979
9980       /* Is this the initializing insn?  */
9981       set = single_set (insn);
9982       if (set
9983           && GET_CODE (SET_DEST (set)) == REG
9984           && REGNO (SET_DEST (set)) == regno)
9985         {
9986           if (init_insn)
9987             abort ();
9988
9989           init_insn = insn;
9990           if (REGNO_FIRST_UID (regno) == INSN_UID (insn))
9991             store_is_first = 1;
9992         }
9993
9994       /* Only substitute after seeing the initializing insn.  */
9995       if (init_insn && insn != init_insn)
9996         {
9997           struct note_reg_stored_arg arg;
9998
9999           replace_loop_regs (insn, reg_rtx, replacement);
10000           if (REGNO_LAST_UID (regno) == INSN_UID (insn))
10001             replaced_last = 1;
10002
10003           /* Stop replacing when REPLACEMENT is modified.  */
10004           arg.reg = replacement;
10005           arg.set_seen = 0;
10006           note_stores (PATTERN (insn), note_reg_stored, &arg);
10007           if (arg.set_seen)
10008             {
10009               rtx note = find_reg_note (insn, REG_EQUAL, NULL);
10010
10011               /* It is possible that we've turned previously valid REG_EQUAL to
10012                  invalid, as we change the REGNO to REPLACEMENT and unlike REGNO,
10013                  REPLACEMENT is modified, we get different meaning.  */
10014               if (note && reg_mentioned_p (replacement, XEXP (note, 0)))
10015                 remove_note (insn, note);
10016               break;
10017             }
10018         }
10019     }
10020   if (! init_insn)
10021     abort ();
10022   if (apply_change_group ())
10023     {
10024       if (loop_dump_stream)
10025         fprintf (loop_dump_stream, "  Replaced reg %d", regno);
10026       if (store_is_first && replaced_last)
10027         {
10028           rtx first;
10029           rtx retval_note;
10030
10031           /* Assume we're just deleting INIT_INSN.  */
10032           first = init_insn;
10033           /* Look for REG_RETVAL note.  If we're deleting the end of
10034              the libcall sequence, the whole sequence can go.  */
10035           retval_note = find_reg_note (init_insn, REG_RETVAL, NULL_RTX);
10036           /* If we found a REG_RETVAL note, find the first instruction
10037              in the sequence.  */
10038           if (retval_note)
10039             first = XEXP (retval_note, 0);
10040
10041           /* Delete the instructions.  */
10042           loop_delete_insns (first, init_insn);
10043         }
10044       if (loop_dump_stream)
10045         fprintf (loop_dump_stream, ".\n");
10046     }
10047 }
10048
10049 /* Replace all the instructions from FIRST up to and including LAST
10050    with NOTE_INSN_DELETED notes.  */
10051
10052 static void
10053 loop_delete_insns (first, last)
10054      rtx first;
10055      rtx last;
10056 {
10057   while (1)
10058     {
10059       if (loop_dump_stream)
10060         fprintf (loop_dump_stream, ", deleting init_insn (%d)",
10061                  INSN_UID (first));
10062       delete_insn (first);
10063
10064       /* If this was the LAST instructions we're supposed to delete,
10065          we're done.  */
10066       if (first == last)
10067         break;
10068
10069       first = NEXT_INSN (first);
10070     }
10071 }
10072
10073 /* Try to replace occurrences of pseudo REGNO with REPLACEMENT within
10074    loop LOOP if the order of the sets of these registers can be
10075    swapped.  There must be exactly one insn within the loop that sets
10076    this pseudo followed immediately by a move insn that sets
10077    REPLACEMENT with REGNO.  */
10078 static void
10079 try_swap_copy_prop (loop, replacement, regno)
10080      const struct loop *loop;
10081      rtx replacement;
10082      unsigned int regno;
10083 {
10084   rtx insn;
10085   rtx set = NULL_RTX;
10086   unsigned int new_regno;
10087
10088   new_regno = REGNO (replacement);
10089
10090   for (insn = next_insn_in_loop (loop, loop->scan_start);
10091        insn != NULL_RTX;
10092        insn = next_insn_in_loop (loop, insn))
10093     {
10094       /* Search for the insn that copies REGNO to NEW_REGNO?  */
10095       if (INSN_P (insn)
10096           && (set = single_set (insn))
10097           && GET_CODE (SET_DEST (set)) == REG
10098           && REGNO (SET_DEST (set)) == new_regno
10099           && GET_CODE (SET_SRC (set)) == REG
10100           && REGNO (SET_SRC (set)) == regno)
10101         break;
10102     }
10103
10104   if (insn != NULL_RTX)
10105     {
10106       rtx prev_insn;
10107       rtx prev_set;
10108
10109       /* Some DEF-USE info would come in handy here to make this
10110          function more general.  For now, just check the previous insn
10111          which is the most likely candidate for setting REGNO.  */
10112
10113       prev_insn = PREV_INSN (insn);
10114
10115       if (INSN_P (insn)
10116           && (prev_set = single_set (prev_insn))
10117           && GET_CODE (SET_DEST (prev_set)) == REG
10118           && REGNO (SET_DEST (prev_set)) == regno)
10119         {
10120           /* We have:
10121              (set (reg regno) (expr))
10122              (set (reg new_regno) (reg regno))
10123
10124              so try converting this to:
10125              (set (reg new_regno) (expr))
10126              (set (reg regno) (reg new_regno))
10127
10128              The former construct is often generated when a global
10129              variable used for an induction variable is shadowed by a
10130              register (NEW_REGNO).  The latter construct improves the
10131              chances of GIV replacement and BIV elimination.  */
10132
10133           validate_change (prev_insn, &SET_DEST (prev_set),
10134                            replacement, 1);
10135           validate_change (insn, &SET_DEST (set),
10136                            SET_SRC (set), 1);
10137           validate_change (insn, &SET_SRC (set),
10138                            replacement, 1);
10139
10140           if (apply_change_group ())
10141             {
10142               if (loop_dump_stream)
10143                 fprintf (loop_dump_stream,
10144                          "  Swapped set of reg %d at %d with reg %d at %d.\n",
10145                          regno, INSN_UID (insn),
10146                          new_regno, INSN_UID (prev_insn));
10147
10148               /* Update first use of REGNO.  */
10149               if (REGNO_FIRST_UID (regno) == INSN_UID (prev_insn))
10150                 REGNO_FIRST_UID (regno) = INSN_UID (insn);
10151
10152               /* Now perform copy propagation to hopefully
10153                  remove all uses of REGNO within the loop.  */
10154               try_copy_prop (loop, replacement, regno);
10155             }
10156         }
10157     }
10158 }
10159
10160 /* Replace MEM with its associated pseudo register.  This function is
10161    called from load_mems via for_each_rtx.  DATA is actually a pointer
10162    to a structure describing the instruction currently being scanned
10163    and the MEM we are currently replacing.  */
10164
10165 static int
10166 replace_loop_mem (mem, data)
10167      rtx *mem;
10168      void *data;
10169 {
10170   loop_replace_args *args = (loop_replace_args *) data;
10171   rtx m = *mem;
10172
10173   if (m == NULL_RTX)
10174     return 0;
10175
10176   switch (GET_CODE (m))
10177     {
10178     case MEM:
10179       break;
10180
10181     case CONST_DOUBLE:
10182       /* We're not interested in the MEM associated with a
10183          CONST_DOUBLE, so there's no need to traverse into one.  */
10184       return -1;
10185
10186     default:
10187       /* This is not a MEM.  */
10188       return 0;
10189     }
10190
10191   if (!rtx_equal_p (args->match, m))
10192     /* This is not the MEM we are currently replacing.  */
10193     return 0;
10194
10195   /* Actually replace the MEM.  */
10196   validate_change (args->insn, mem, args->replacement, 1);
10197
10198   return 0;
10199 }
10200
10201 static void
10202 replace_loop_mems (insn, mem, reg)
10203      rtx insn;
10204      rtx mem;
10205      rtx reg;
10206 {
10207   loop_replace_args args;
10208
10209   args.insn = insn;
10210   args.match = mem;
10211   args.replacement = reg;
10212
10213   for_each_rtx (&insn, replace_loop_mem, &args);
10214 }
10215
10216 /* Replace one register with another.  Called through for_each_rtx; PX points
10217    to the rtx being scanned.  DATA is actually a pointer to
10218    a structure of arguments.  */
10219
10220 static int
10221 replace_loop_reg (px, data)
10222      rtx *px;
10223      void *data;
10224 {
10225   rtx x = *px;
10226   loop_replace_args *args = (loop_replace_args *) data;
10227
10228   if (x == NULL_RTX)
10229     return 0;
10230
10231   if (x == args->match)
10232     validate_change (args->insn, px, args->replacement, 1);
10233
10234   return 0;
10235 }
10236
10237 static void
10238 replace_loop_regs (insn, reg, replacement)
10239      rtx insn;
10240      rtx reg;
10241      rtx replacement;
10242 {
10243   loop_replace_args args;
10244
10245   args.insn = insn;
10246   args.match = reg;
10247   args.replacement = replacement;
10248
10249   for_each_rtx (&insn, replace_loop_reg, &args);
10250 }
10251
10252 /* Replace occurrences of the old exit label for the loop with the new
10253    one.  DATA is an rtx_pair containing the old and new labels,
10254    respectively.  */
10255
10256 static int
10257 replace_label (x, data)
10258      rtx *x;
10259      void *data;
10260 {
10261   rtx l = *x;
10262   rtx old_label = ((rtx_pair *) data)->r1;
10263   rtx new_label = ((rtx_pair *) data)->r2;
10264
10265   if (l == NULL_RTX)
10266     return 0;
10267
10268   if (GET_CODE (l) != LABEL_REF)
10269     return 0;
10270
10271   if (XEXP (l, 0) != old_label)
10272     return 0;
10273
10274   XEXP (l, 0) = new_label;
10275   ++LABEL_NUSES (new_label);
10276   --LABEL_NUSES (old_label);
10277
10278   return 0;
10279 }
10280 \f
10281 /* Emit insn for PATTERN after WHERE_INSN in basic block WHERE_BB
10282    (ignored in the interim).  */
10283
10284 static rtx
10285 loop_insn_emit_after (loop, where_bb, where_insn, pattern)
10286      const struct loop *loop ATTRIBUTE_UNUSED;
10287      basic_block where_bb ATTRIBUTE_UNUSED;
10288      rtx where_insn;
10289      rtx pattern;
10290 {
10291   return emit_insn_after (pattern, where_insn);
10292 }
10293
10294
10295 /* If WHERE_INSN is non-zero emit insn for PATTERN before WHERE_INSN
10296    in basic block WHERE_BB (ignored in the interim) within the loop
10297    otherwise hoist PATTERN into the loop pre-header.  */
10298
10299 rtx
10300 loop_insn_emit_before (loop, where_bb, where_insn, pattern)
10301      const struct loop *loop;
10302      basic_block where_bb ATTRIBUTE_UNUSED;
10303      rtx where_insn;
10304      rtx pattern;
10305 {
10306   if (! where_insn)
10307     return loop_insn_hoist (loop, pattern);
10308   return emit_insn_before (pattern, where_insn);
10309 }
10310
10311
10312 /* Emit call insn for PATTERN before WHERE_INSN in basic block
10313    WHERE_BB (ignored in the interim) within the loop.  */
10314
10315 static rtx
10316 loop_call_insn_emit_before (loop, where_bb, where_insn, pattern)
10317      const struct loop *loop ATTRIBUTE_UNUSED;
10318      basic_block where_bb ATTRIBUTE_UNUSED;
10319      rtx where_insn;
10320      rtx pattern;
10321 {
10322   return emit_call_insn_before (pattern, where_insn);
10323 }
10324
10325
10326 /* Hoist insn for PATTERN into the loop pre-header.  */
10327
10328 rtx
10329 loop_insn_hoist (loop, pattern)
10330      const struct loop *loop;
10331      rtx pattern;
10332 {
10333   return loop_insn_emit_before (loop, 0, loop->start, pattern);
10334 }
10335
10336
10337 /* Hoist call insn for PATTERN into the loop pre-header.  */
10338
10339 static rtx
10340 loop_call_insn_hoist (loop, pattern)
10341      const struct loop *loop;
10342      rtx pattern;
10343 {
10344   return loop_call_insn_emit_before (loop, 0, loop->start, pattern);
10345 }
10346
10347
10348 /* Sink insn for PATTERN after the loop end.  */
10349
10350 rtx
10351 loop_insn_sink (loop, pattern)
10352      const struct loop *loop;
10353      rtx pattern;
10354 {
10355   return loop_insn_emit_before (loop, 0, loop->sink, pattern);
10356 }
10357
10358
10359 /* If the loop has multiple exits, emit insn for PATTERN before the
10360    loop to ensure that it will always be executed no matter how the
10361    loop exits.  Otherwise, emit the insn for PATTERN after the loop,
10362    since this is slightly more efficient.  */
10363
10364 static rtx
10365 loop_insn_sink_or_swim (loop, pattern)
10366      const struct loop *loop;
10367      rtx pattern;
10368 {
10369   if (loop->exit_count)
10370     return loop_insn_hoist (loop, pattern);
10371   else
10372     return loop_insn_sink (loop, pattern);
10373 }
10374 \f
10375 static void
10376 loop_ivs_dump (loop, file, verbose)
10377      const struct loop *loop;
10378      FILE *file;
10379      int verbose;
10380 {
10381   struct iv_class *bl;
10382   int iv_num = 0;
10383
10384   if (! loop || ! file)
10385     return;
10386
10387   for (bl = LOOP_IVS (loop)->list; bl; bl = bl->next)
10388     iv_num++;
10389
10390   fprintf (file, "Loop %d: %d IV classes\n", loop->num, iv_num);
10391
10392   for (bl = LOOP_IVS (loop)->list; bl; bl = bl->next)
10393     {
10394       loop_iv_class_dump (bl, file, verbose);
10395       fputc ('\n', file);
10396     }
10397 }
10398
10399
10400 static void
10401 loop_iv_class_dump (bl, file, verbose)
10402      const struct iv_class *bl;
10403      FILE *file;
10404      int verbose ATTRIBUTE_UNUSED;
10405 {
10406   struct induction *v;
10407   rtx incr;
10408   int i;
10409
10410   if (! bl || ! file)
10411     return;
10412
10413   fprintf (file, "IV class for reg %d, benefit %d\n",
10414            bl->regno, bl->total_benefit);
10415
10416   fprintf (file, " Init insn %d", INSN_UID (bl->init_insn));
10417   if (bl->initial_value)
10418     {
10419       fprintf (file, ", init val: ");
10420       print_simple_rtl (file, bl->initial_value);
10421     }
10422   if (bl->initial_test)
10423     {
10424       fprintf (file, ", init test: ");
10425       print_simple_rtl (file, bl->initial_test);
10426     }
10427   fputc ('\n', file);
10428
10429   if (bl->final_value)
10430     {
10431       fprintf (file, " Final val: ");
10432       print_simple_rtl (file, bl->final_value);
10433       fputc ('\n', file);
10434     }
10435
10436   if ((incr = biv_total_increment (bl)))
10437     {
10438       fprintf (file, " Total increment: ");
10439       print_simple_rtl (file, incr);
10440       fputc ('\n', file);
10441     }
10442
10443   /* List the increments.  */
10444   for (i = 0, v = bl->biv; v; v = v->next_iv, i++)
10445     {
10446       fprintf (file, " Inc%d: insn %d, incr: ", i, INSN_UID (v->insn));
10447       print_simple_rtl (file, v->add_val);
10448       fputc ('\n', file);
10449     }
10450
10451   /* List the givs.  */
10452   for (i = 0, v = bl->giv; v; v = v->next_iv, i++)
10453     {
10454       fprintf (file, " Giv%d: insn %d, benefit %d, ",
10455                i, INSN_UID (v->insn), v->benefit);
10456       if (v->giv_type == DEST_ADDR)
10457           print_simple_rtl (file, v->mem);
10458       else
10459           print_simple_rtl (file, single_set (v->insn));
10460       fputc ('\n', file);
10461     }
10462 }
10463
10464
10465 static void
10466 loop_biv_dump (v, file, verbose)
10467      const struct induction *v;
10468      FILE *file;
10469      int verbose;
10470 {
10471   if (! v || ! file)
10472     return;
10473
10474   fprintf (file,
10475            "Biv %d: insn %d",
10476            REGNO (v->dest_reg), INSN_UID (v->insn));
10477   fprintf (file, " const ");
10478   print_simple_rtl (file, v->add_val);
10479
10480   if (verbose && v->final_value)
10481     {
10482       fputc ('\n', file);
10483       fprintf (file, " final ");
10484       print_simple_rtl (file, v->final_value);
10485     }
10486
10487   fputc ('\n', file);
10488 }
10489
10490
10491 static void
10492 loop_giv_dump (v, file, verbose)
10493      const struct induction *v;
10494      FILE *file;
10495      int verbose;
10496 {
10497   if (! v || ! file)
10498     return;
10499
10500   if (v->giv_type == DEST_REG)
10501     fprintf (file, "Giv %d: insn %d",
10502              REGNO (v->dest_reg),  INSN_UID (v->insn));
10503   else
10504     fprintf (file, "Dest address: insn %d",
10505              INSN_UID (v->insn));
10506
10507   fprintf (file, " src reg %d benefit %d",
10508            REGNO (v->src_reg), v->benefit);
10509   fprintf (file, " lifetime %d",
10510            v->lifetime);
10511
10512   if (v->replaceable)
10513     fprintf (file, " replaceable");
10514
10515   if (v->no_const_addval)
10516     fprintf (file, " ncav");
10517
10518   if (v->ext_dependent)
10519     {
10520       switch (GET_CODE (v->ext_dependent))
10521         {
10522         case SIGN_EXTEND:
10523           fprintf (file, " ext se");
10524           break;
10525         case ZERO_EXTEND:
10526           fprintf (file, " ext ze");
10527           break;
10528         case TRUNCATE:
10529           fprintf (file, " ext tr");
10530           break;
10531         default:
10532           abort ();
10533         }
10534     }
10535
10536   fputc ('\n', file);
10537   fprintf (file, " mult ");
10538   print_simple_rtl (file, v->mult_val);
10539
10540   fputc ('\n', file);
10541   fprintf (file, " add  ");
10542   print_simple_rtl (file, v->add_val);
10543
10544   if (verbose && v->final_value)
10545     {
10546       fputc ('\n', file);
10547       fprintf (file, " final ");
10548       print_simple_rtl (file, v->final_value);
10549     }
10550
10551   fputc ('\n', file);
10552 }
10553
10554
10555 void
10556 debug_ivs (loop)
10557      const struct loop *loop;
10558 {
10559   loop_ivs_dump (loop, stderr, 1);
10560 }
10561
10562
10563 void
10564 debug_iv_class (bl)
10565      const struct iv_class *bl;
10566 {
10567   loop_iv_class_dump (bl, stderr, 1);
10568 }
10569
10570
10571 void
10572 debug_biv (v)
10573      const struct induction *v;
10574 {
10575   loop_biv_dump (v, stderr, 1);
10576 }
10577
10578
10579 void
10580 debug_giv (v)
10581      const struct induction *v;
10582 {
10583   loop_giv_dump (v, stderr, 1);
10584 }
10585
10586
10587 #define LOOP_BLOCK_NUM_1(INSN) \
10588 ((INSN) ? (BLOCK_FOR_INSN (INSN) ? BLOCK_NUM (INSN) : - 1) : -1)
10589
10590 /* The notes do not have an assigned block, so look at the next insn.  */
10591 #define LOOP_BLOCK_NUM(INSN) \
10592 ((INSN) ? (GET_CODE (INSN) == NOTE \
10593             ? LOOP_BLOCK_NUM_1 (next_nonnote_insn (INSN)) \
10594             : LOOP_BLOCK_NUM_1 (INSN)) \
10595         : -1)
10596
10597 #define LOOP_INSN_UID(INSN) ((INSN) ? INSN_UID (INSN) : -1)
10598
10599 static void
10600 loop_dump_aux (loop, file, verbose)
10601      const struct loop *loop;
10602      FILE *file;
10603      int verbose ATTRIBUTE_UNUSED;
10604 {
10605   rtx label;
10606
10607   if (! loop || ! file)
10608     return;
10609
10610   /* Print diagnostics to compare our concept of a loop with
10611      what the loop notes say.  */
10612   if (! PREV_INSN (loop->first->head)
10613       || GET_CODE (PREV_INSN (loop->first->head)) != NOTE
10614       || NOTE_LINE_NUMBER (PREV_INSN (loop->first->head))
10615       != NOTE_INSN_LOOP_BEG)
10616     fprintf (file, ";;  No NOTE_INSN_LOOP_BEG at %d\n",
10617              INSN_UID (PREV_INSN (loop->first->head)));
10618   if (! NEXT_INSN (loop->last->end)
10619       || GET_CODE (NEXT_INSN (loop->last->end)) != NOTE
10620       || NOTE_LINE_NUMBER (NEXT_INSN (loop->last->end))
10621       != NOTE_INSN_LOOP_END)
10622     fprintf (file, ";;  No NOTE_INSN_LOOP_END at %d\n",
10623              INSN_UID (NEXT_INSN (loop->last->end)));
10624
10625   if (loop->start)
10626     {
10627       fprintf (file,
10628                ";;  start %d (%d), cont dom %d (%d), cont %d (%d), vtop %d (%d), end %d (%d)\n",
10629                LOOP_BLOCK_NUM (loop->start),
10630                LOOP_INSN_UID (loop->start),
10631                LOOP_BLOCK_NUM (loop->cont),
10632                LOOP_INSN_UID (loop->cont),
10633                LOOP_BLOCK_NUM (loop->cont),
10634                LOOP_INSN_UID (loop->cont),
10635                LOOP_BLOCK_NUM (loop->vtop),
10636                LOOP_INSN_UID (loop->vtop),
10637                LOOP_BLOCK_NUM (loop->end),
10638                LOOP_INSN_UID (loop->end));
10639       fprintf (file, ";;  top %d (%d), scan start %d (%d)\n",
10640                LOOP_BLOCK_NUM (loop->top),
10641                LOOP_INSN_UID (loop->top),
10642                LOOP_BLOCK_NUM (loop->scan_start),
10643                LOOP_INSN_UID (loop->scan_start));
10644       fprintf (file, ";;  exit_count %d", loop->exit_count);
10645       if (loop->exit_count)
10646         {
10647           fputs (", labels:", file);
10648           for (label = loop->exit_labels; label; label = LABEL_NEXTREF (label))
10649             {
10650               fprintf (file, " %d ",
10651                        LOOP_INSN_UID (XEXP (label, 0)));
10652             }
10653         }
10654       fputs ("\n", file);
10655
10656       /* This can happen when a marked loop appears as two nested loops,
10657          say from while (a || b) {}.  The inner loop won't match
10658          the loop markers but the outer one will.  */
10659       if (LOOP_BLOCK_NUM (loop->cont) != loop->latch->index)
10660         fprintf (file, ";;  NOTE_INSN_LOOP_CONT not in loop latch\n");
10661     }
10662 }
10663
10664 /* Call this function from the debugger to dump LOOP.  */
10665
10666 void
10667 debug_loop (loop)
10668      const struct loop *loop;
10669 {
10670   flow_loop_dump (loop, stderr, loop_dump_aux, 1);
10671 }
10672
10673 /* Call this function from the debugger to dump LOOPS.  */
10674
10675 void
10676 debug_loops (loops)
10677      const struct loops *loops;
10678 {
10679   flow_loops_dump (loops, stderr, loop_dump_aux, 1);
10680 }