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