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