Skip to content

R
riscv-gcc-1
Commit 3c748bb6 by Michael Hayes Committed by Jeff Law
Options

loop.c (this_loop_info): New variable. 

        * loop.c (this_loop_info): New variable.
        (loop_has_call, loop_has_volatile, loop_has_tablejump,
        loop_continue, loops_enclosed): Replace with fields in this_loop_info.
        All uses updated.
        (prescan_loop, strength_reduce): New argument loop_info.  All callers
        updated.
        (scan_loop): New variable loop_info, initialise to address of
        this_loop_info.
        (prescan_loop): Set loop_info->vtop if find NOTE_INSN_LOOP_VTOP.
        Delete variable loop_has_multiple_exit targets and replace with
        field in this_loop_info.
        (find_and_verify_loops): Rename this_loop to this_loop_num.
        (strength_reduce): Delete loop_iteration_info.  Replace variable
        loop_info with function argument of same name.
        (insert_bct): Rework test for loop being completely unrolled.

        * loop.h (struct loop_info): New fields num, loops_enclosed,
        has_call, has_volatile, has_tablejump, has_multiple_exit_targets,
        has_indirect_jump, and cont.  Redefine use of unroll_number.
        (loop_unroll_number): Delete.

        * unroll.c (unroll_loop): Store loop unroll count in unroll_number
        field of loop_info.
        (loop_iterations): Delete variable vtop and instead use
        loop_info->vtop computed in prescan_loop.

From-SVN: r28961
parent ceb45eb8
Showing with 141 additions and 127 deletions
gcc/ChangeLog
1999-08-29 Michael Hayes <m.hayes@elec.canterbury.ac.nz>
* loop.c (this_loop_info): New variable.
(loop_has_call, loop_has_volatile, loop_has_tablejump,
loop_continue, loops_enclosed): Replace with fields in this_loop_info.
All uses updated.
(prescan_loop, strength_reduce): New argument loop_info. All callers
updated.
(scan_loop): New variable loop_info, initialise to address of
this_loop_info.
(prescan_loop): Set loop_info->vtop if find NOTE_INSN_LOOP_VTOP.
Delete variable loop_has_multiple_exit targets and replace with
field in this_loop_info.
(find_and_verify_loops): Rename this_loop to this_loop_num.
(strength_reduce): Delete loop_iteration_info. Replace variable
loop_info with function argument of same name.
(insert_bct): Rework test for loop being completely unrolled.
* loop.h (struct loop_info): New fields num, loops_enclosed,
has_call, has_volatile, has_tablejump, has_multiple_exit_targets,
has_indirect_jump, and cont. Redefine use of unroll_number.
(loop_unroll_number): Delete.
* unroll.c (unroll_loop): Store loop unroll count in unroll_number
field of loop_info.
(loop_iterations): Delete variable vtop and instead use
loop_info->vtop computed in prescan_loop.
Sun Aug 29 03:27:23 1999 Scott Weikart <scott@igc.apc.org>
* fix-header.c (main): Do not pass a null pointer to strcmp.
......
gcc/loop.c
......@@ -51,6 +51,11 @@ Boston, MA 02111-1307, USA. */
#include "except.h"
#include "toplev.h"
/* Information about the loop being processed used to compute
the number of loop iterations for loop unrolling and doloop
optimization. */
static struct loop_info this_loop_info;
/* Vector mapping INSN_UIDs to luids.
The luids are like uids but increase monotonically always.
We use them to see whether a jump comes from outside a given loop. */
......@@ -121,25 +126,6 @@ rtx *loop_number_exit_labels;
int *loop_number_exit_count;
/* Nonzero if there is a subroutine call in the current loop. */
static int loop_has_call;
/* Nonzero if there is a volatile memory reference in the current
loop. */
static int loop_has_volatile;
/* Nonzero if there is a tablejump in the current loop. */
static int loop_has_tablejump;
/* Added loop_continue which is the NOTE_INSN_LOOP_CONT of the
current loop. A continue statement will generate a branch to
NEXT_INSN (loop_continue). */
static rtx loop_continue;
/* Indexed by register number, contains the number of times the reg
is set during the loop being scanned.
During code motion, a negative value indicates a reg that has been
......@@ -203,9 +189,10 @@ static int loop_mems_idx;
static int loop_mems_allocated;
/* Nonzero if we don't know what MEMs were changed in the current loop.
This happens if the loop contains a call (in which case `loop_has_call'
will also be set) or if we store into more than NUM_STORES MEMs. */
/* Nonzero if we don't know what MEMs were changed in the current
loop. This happens if the loop contains a call (in which case
`loop_info->has_call' will also be set) or if we store into more
than NUM_STORES MEMs. */
static int unknown_address_altered;
......@@ -215,9 +202,6 @@ static int num_movables;
/* Count of memory write instructions discovered in the loop. */
static int num_mem_sets;
/* Number of loops contained within the current one, including itself. */
static int loops_enclosed;
/* Bound on pseudo register number before loop optimization.
A pseudo has valid regscan info if its number is < max_reg_before_loop. */
int max_reg_before_loop;
......@@ -289,7 +273,7 @@ FILE *loop_dump_stream;
static void verify_dominator PROTO((int));
static void find_and_verify_loops PROTO((rtx));
static void mark_loop_jump PROTO((rtx, int));
static void prescan_loop PROTO((rtx, rtx));
static void prescan_loop PROTO((rtx, rtx, struct loop_info *));
static int reg_in_basic_block_p PROTO((rtx, rtx));
static int consec_sets_invariant_p PROTO((rtx, int, rtx));
static int labels_in_range_p PROTO((rtx, int));
......@@ -313,7 +297,8 @@ static int rtx_equal_for_loop_p PROTO((rtx, rtx, struct movable *));
static void add_label_notes PROTO((rtx, rtx));
static void move_movables PROTO((struct movable *, int, int, rtx, rtx, int));
static int count_nonfixed_reads PROTO((rtx));
static void strength_reduce PROTO((rtx, rtx, rtx, int, rtx, rtx, rtx, int, int));
static void strength_reduce PROTO((rtx, rtx, rtx, int, rtx, rtx,
struct loop_info *, rtx, int, int));
static void find_single_use_in_loop PROTO((rtx, rtx, varray_type));
static int valid_initial_value_p PROTO((rtx, rtx, int, rtx));
static void find_mem_givs PROTO((rtx, rtx, int, rtx, rtx));
......@@ -665,6 +650,7 @@ scan_loop (loop_start, end, loop_cont, unroll_p, bct_p)
/* Nonzero if we are scanning instructions in a sub-loop. */
int loop_depth = 0;
int nregs;
struct loop_info *loop_info = &this_loop_info;
/* Determine whether this loop starts with a jump down to a test at
the end. This will occur for a small number of loops with a test
......@@ -694,8 +680,8 @@ scan_loop (loop_start, end, loop_cont, unroll_p, bct_p)
scan_start = p;
/* Set up variables describing this loop. */
prescan_loop (loop_start, end);
threshold = (loop_has_call ? 1 : 2) * (1 + n_non_fixed_regs);
prescan_loop (loop_start, end, loop_info);
threshold = (loop_info->has_call ? 1 : 2) * (1 + n_non_fixed_regs);
/* If loop has a jump before the first label,
the true entry is the target of that jump.
......@@ -778,9 +764,9 @@ scan_loop (loop_start, end, loop_cont, unroll_p, bct_p)
{
fprintf (loop_dump_stream, "\nLoop from %d to %d: %d real insns.\n",
INSN_UID (loop_start), INSN_UID (end), insn_count);
if (loop_continue)
if (loop_info->cont)
fprintf (loop_dump_stream, "Continue at insn %d.\n",
INSN_UID (loop_continue));
INSN_UID (loop_info->cont));
}
/* Scan through the loop finding insns that are safe to move.
......@@ -907,7 +893,7 @@ scan_loop (loop_start, end, loop_cont, unroll_p, bct_p)
Don't do this if P has a REG_RETVAL note or if we have
SMALL_REGISTER_CLASSES and SET_SRC is a hard register. */
if (loop_has_call
if (loop_info->has_call
&& VARRAY_RTX (reg_single_usage, regno) != 0
&& VARRAY_RTX (reg_single_usage, regno) != const0_rtx
&& REGNO_FIRST_UID (regno) == INSN_UID (p)
......@@ -1171,7 +1157,8 @@ scan_loop (loop_start, end, loop_cont, unroll_p, bct_p)
{
the_movables = movables;
strength_reduce (scan_start, end, loop_top,
insn_count, loop_start, end, loop_cont, unroll_p, bct_p);
insn_count, loop_start, end,
loop_info, loop_cont, unroll_p, bct_p);
}
VARRAY_FREE (reg_single_usage);
......@@ -1692,7 +1679,7 @@ rtx_equal_for_loop_p (x, y, movables)
}
/* If X contains any LABEL_REF's, add REG_LABEL notes for them to all
insns in INSNS which use thet reference. */
insns in INSNS which use the reference. */
static void
add_label_notes (x, insns)
......@@ -2392,37 +2379,40 @@ constant_high_bytes (p, loop_start)
}
#endif
/* Scan a loop setting the variables `unknown_address_altered',
`num_mem_sets', `loop_continue', `loops_enclosed', `loop_has_call',
`loop_has_volatile', and `loop_has_tablejump'.
Also, fill in the array `loop_mems' and the list `loop_store_mems'. */
/* Scan a loop setting the elements `cont', `vtop', `loops_enclosed',
`has_call', `has_volatile', and `has_tablejump' within LOOP_INFO.
Set the global variables `unknown_address_altered' and
`num_mem_sets'. Also, fill in the array `loop_mems' and the list
`loop_store_mems'. */
static void
prescan_loop (start, end)
prescan_loop (start, end, loop_info)
rtx start, end;
struct loop_info *loop_info;
{
register int level = 1;
rtx insn;
int loop_has_multiple_exit_targets = 0;
/* The label after END. Jumping here is just like falling off the
end of the loop. We use next_nonnote_insn instead of next_label
as a hedge against the (pathological) case where some actual insn
might end up between the two. */
rtx exit_target = next_nonnote_insn (end);
if (exit_target == NULL_RTX || GET_CODE (exit_target) != CODE_LABEL)
loop_has_multiple_exit_targets = 1;
loop_info->num = uid_loop_num [INSN_UID (start)];
loop_info->has_indirect_jump = indirect_jump_in_function;
loop_info->has_call = 0;
loop_info->has_volatile = 0;
loop_info->has_tablejump = 0;
loop_info->loops_enclosed = 1;
loop_info->has_multiple_exit_targets = 0;
loop_info->cont = 0;
loop_info->vtop = 0;
unknown_address_altered = 0;
loop_has_call = 0;
loop_has_volatile = 0;
loop_has_tablejump = 0;
loop_store_mems = NULL_RTX;
first_loop_store_insn = NULL_RTX;
loop_mems_idx = 0;
num_mem_sets = 0;
loops_enclosed = 1;
loop_continue = 0;
for (insn = NEXT_INSN (start); insn != NEXT_INSN (end);
insn = NEXT_INSN (insn))
......@@ -2433,7 +2423,7 @@ prescan_loop (start, end)
{
++level;
/* Count number of loops contained in this one. */
loops_enclosed++;
loop_info->loops_enclosed++;
}
else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
{
......@@ -2447,14 +2437,23 @@ prescan_loop (start, end)
else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT)
{
if (level == 1)
loop_continue = insn;
loop_info->cont = insn;
}
else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_VTOP)
{
/* If there is a NOTE_INSN_LOOP_VTOP, then this is a for
or while style loop, with a loop exit test at the
start. Thus, we can assume that the loop condition
was true when the loop was entered. */
if (level == 1)
loop_info->vtop = insn;
}
}
else if (GET_CODE (insn) == CALL_INSN)
{
if (! CONST_CALL_P (insn))
unknown_address_altered = 1;
loop_has_call = 1;
loop_info->has_call = 1;
}
else if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
{
......@@ -2462,18 +2461,18 @@ prescan_loop (start, end)
rtx label2 = NULL_RTX;
if (volatile_refs_p (PATTERN (insn)))
loop_has_volatile = 1;
loop_info->has_volatile = 1;
if (GET_CODE (insn) == JUMP_INSN
&& (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
|| GET_CODE (PATTERN (insn)) == ADDR_VEC))
loop_has_tablejump = 1;
loop_info->has_tablejump = 1;
note_stores (PATTERN (insn), note_addr_stored);
if (! first_loop_store_insn && loop_store_mems)
first_loop_store_insn = insn;
if (! loop_has_multiple_exit_targets
if (! loop_info->has_multiple_exit_targets
&& GET_CODE (insn) == JUMP_INSN
&& GET_CODE (PATTERN (insn)) == SET
&& SET_DEST (PATTERN (insn)) == pc_rtx)
......@@ -2494,14 +2493,14 @@ prescan_loop (start, end)
if (GET_CODE (label1) != LABEL_REF)
{
/* Something tricky. */
loop_has_multiple_exit_targets = 1;
loop_info->has_multiple_exit_targets = 1;
break;
}
else if (XEXP (label1, 0) != exit_target
&& LABEL_OUTSIDE_LOOP_P (label1))
{
/* A jump outside the current loop. */
loop_has_multiple_exit_targets = 1;
loop_info->has_multiple_exit_targets = 1;
break;
}
}
......@@ -2512,7 +2511,7 @@ prescan_loop (start, end)
}
}
else if (GET_CODE (insn) == RETURN)
loop_has_multiple_exit_targets = 1;
loop_info->has_multiple_exit_targets = 1;
}
/* Now, rescan the loop, setting up the LOOP_MEMS array. */
......@@ -2520,7 +2519,7 @@ prescan_loop (start, end)
!unknown_address_altered
/* An exception thrown by a called function might land us
anywhere. */
&& !loop_has_call
&& !loop_info->has_call
/* We don't want loads for MEMs moved to a location before the
one at which their stack memory becomes allocated. (Note
that this is not a problem for malloc, etc., since those
......@@ -2528,7 +2527,7 @@ prescan_loop (start, end)
&& !current_function_calls_alloca
/* There are ways to leave the loop other than falling off the
end. */
&& !loop_has_multiple_exit_targets)
&& !loop_info->has_multiple_exit_targets)
for (insn = NEXT_INSN (start); insn != NEXT_INSN (end);
insn = NEXT_INSN (insn))
for_each_rtx (&insn, insert_loop_mem, 0);
......@@ -2662,41 +2661,41 @@ find_and_verify_loops (f)
&& GET_CODE (PATTERN (insn)) != RETURN
&& current_loop >= 0)
{
int this_loop;
int this_loop_num;
rtx label = JUMP_LABEL (insn);
if (! condjump_p (insn) && ! condjump_in_parallel_p (insn))
label = NULL_RTX;
this_loop = current_loop;
this_loop_num = current_loop;
do
{
/* First see if we care about this loop. */
if (loop_number_loop_cont[this_loop]
&& loop_number_cont_dominator[this_loop] != const0_rtx)
if (loop_number_loop_cont[this_loop_num]
&& loop_number_cont_dominator[this_loop_num] != const0_rtx)
{
/* If the jump destination is not known, invalidate
loop_number_const_dominator. */
if (! label)
loop_number_cont_dominator[this_loop] = const0_rtx;
loop_number_cont_dominator[this_loop_num] = const0_rtx;
else
/* Check if the destination is between loop start and
cont. */
if ((INSN_LUID (label)
< INSN_LUID (loop_number_loop_cont[this_loop]))
< INSN_LUID (loop_number_loop_cont[this_loop_num]))
&& (INSN_LUID (label)
> INSN_LUID (loop_number_loop_starts[this_loop]))
> INSN_LUID (loop_number_loop_starts[this_loop_num]))
/* And if there is no later destination already
recorded. */
&& (! loop_number_cont_dominator[this_loop]
&& (! loop_number_cont_dominator[this_loop_num]
|| (INSN_LUID (label)
> INSN_LUID (loop_number_cont_dominator
[this_loop]))))
loop_number_cont_dominator[this_loop] = label;
[this_loop_num]))))
loop_number_cont_dominator[this_loop_num] = label;
}
this_loop = loop_outer_loop[this_loop];
this_loop_num = loop_outer_loop[this_loop_num];
}
while (this_loop >= 0);
while (this_loop_num >= 0);
}
/* Note that this will mark the NOTE_INSN_LOOP_END note as being in the
......@@ -3207,7 +3206,7 @@ invariant_p (x)
&& ! current_function_has_nonlocal_goto)
return 1;
if (loop_has_call
if (this_loop_info.has_call
&& REGNO (x) < FIRST_PSEUDO_REGISTER && call_used_regs[REGNO (x)])
return 0;
......@@ -3662,13 +3661,14 @@ static rtx addr_placeholder;
static void
strength_reduce (scan_start, end, loop_top, insn_count,
loop_start, loop_end, loop_cont, unroll_p, bct_p)
loop_start, loop_end, loop_info, loop_cont, unroll_p, bct_p)
rtx scan_start;
rtx end;
rtx loop_top;
int insn_count;
rtx loop_start;
rtx loop_end;
struct loop_info *loop_info;
rtx loop_cont;
int unroll_p, bct_p ATTRIBUTE_UNUSED;
{
......@@ -3694,7 +3694,7 @@ strength_reduce (scan_start, end, loop_top, insn_count,
since in that case saving an insn makes more difference
and more registers are available. */
/* ??? could set this to last value of threshold in move_movables */
int threshold = (loop_has_call ? 1 : 2) * (3 + n_non_fixed_regs);
int threshold = (loop_info->has_call ? 1 : 2) * (3 + n_non_fixed_regs);
/* Map of pseudo-register replacements. */
rtx *reg_map;
int reg_map_size;
......@@ -3703,8 +3703,6 @@ strength_reduce (scan_start, end, loop_top, insn_count,
rtx end_insert_before;
int loop_depth = 0;
int n_extra_increment;
struct loop_info loop_iteration_info;
struct loop_info *loop_info = &loop_iteration_info;
int unrolled_insn_copies;
/* If scan_start points to the loop exit test, we have to be wary of
......@@ -4158,7 +4156,7 @@ strength_reduce (scan_start, end, loop_top, insn_count,
/* If the loop contains volatile memory references do not allow any
replacements to take place, since this could loose the volatile markers. */
if (n_extra_increment && ! loop_has_volatile)
if (n_extra_increment && ! loop_info->has_volatile)
{
int nregs = first_increment_giv + n_extra_increment;
......@@ -4572,7 +4570,7 @@ strength_reduce (scan_start, end, loop_top, insn_count,
int benefit;
int all_reduced;
rtx final_value = 0;
unsigned nregs;
unsigned int nregs;
/* Test whether it will be possible to eliminate this biv
provided all givs are reduced. This is possible if either
......@@ -6034,7 +6032,7 @@ basic_induction_var (x, mode, dest_reg, p, inc_val, mult_val, location)
/* convert_modes aborts if we try to convert to or from CCmode, so just
exclude that case. It is very unlikely that a condition code value
would be a useful iterator anyways. */
if (loops_enclosed == 1
if (this_loop_info.loops_enclosed == 1
&& GET_MODE_CLASS (mode) != MODE_CC
&& GET_MODE_CLASS (GET_MODE (dest_reg)) != MODE_CC)
{
......@@ -7896,8 +7894,8 @@ check_dbra_loop (loop_end, insn_count, loop_start, loop_info)
about all these things. */
if ((num_nonfixed_reads <= 1
&& !loop_has_call
&& !loop_has_volatile
&& ! loop_info->has_call
&& ! loop_info->has_volatile
&& reversible_mem_store
&& (bl->giv_count + bl->biv_count + num_mem_sets
+ num_movables + compare_and_branch == insn_count)
......@@ -7925,7 +7923,7 @@ check_dbra_loop (loop_end, insn_count, loop_start, loop_info)
|| (GET_CODE (comparison) == LE
&& no_use_except_counting)))
{
HOST_WIDE_INT add_val, add_adjust, comparison_val = 0;
HOST_WIDE_INT add_val, add_adjust, comparison_val;
rtx initial_value, comparison_value;
int nonneg = 0;
enum rtx_code cmp_code;
......@@ -7983,12 +7981,13 @@ check_dbra_loop (loop_end, insn_count, loop_start, loop_info)
/* First check if we can do a vanilla loop reversal. */
if (initial_value == const0_rtx
/* If we have a decrement_and_branch_on_count, prefer
the NE test, since this will allow that instruction to
be generated. Note that we must use a vanilla loop
reversal if the biv is used to calculate a giv or has
a non-counting use. */
#if ! defined (HAVE_decrement_and_branch_until_zero) && defined (HAVE_decrement_and_branch_on_count)
/* If we have a decrement_and_branch_on_count,
prefer the NE test, since this will allow that
instruction to be generated. Note that we must
use a vanilla loop reversal if the biv is used to
calculate a giv or has a non-counting use. */
#if ! defined (HAVE_decrement_and_branch_until_zero) \
&& defined (HAVE_decrement_and_branch_on_count)
&& (! (add_val == 1 && loop_info->vtop
&& (bl->biv_count == 0
|| no_use_except_counting)))
......@@ -9116,7 +9115,7 @@ insert_bct (loop_start, loop_end, loop_info)
int loop_num = uid_loop_num [INSN_UID (loop_start)];
/* It's impossible to instrument a competely unrolled loop. */
if (loop_info->unroll_number == -1)
if (loop_info->unroll_number == loop_info->n_iterations)
return;
/* Make sure that the count register is not in use. */
......@@ -9153,7 +9152,7 @@ insert_bct (loop_start, loop_end, loop_info)
/* Make sure that the loop does not contain a function call
(the count register might be altered by the called function). */
if (loop_has_call)
if (loop_info->has_call)
{
if (loop_dump_stream)
fprintf (loop_dump_stream,
......@@ -9164,7 +9163,7 @@ insert_bct (loop_start, loop_end, loop_info)
/* Make sure that the loop does not jump via a table.
(the count register might be used to perform the branch on table). */
if (loop_has_tablejump)
if (loop_info->has_tablejump)
{
if (loop_dump_stream)
fprintf (loop_dump_stream,
......
gcc/loop.h
......@@ -158,6 +158,22 @@ struct iv_class {
struct loop_info
{
/* Loop number. */
int num;
/* Loops enclosed by this loop including itself. */
int loops_enclosed;
/* Nonzero if there is a subroutine call in the current loop. */
int has_call;
/* Nonzero if there is a volatile memory reference in the current
loop. */
int has_volatile;
/* Nonzero if there is a tablejump in the current loop. */
int has_tablejump;
/* Nonzero if there are ways to leave the loop other than falling
off the end. */
int has_multiple_exit_targets;
/* Nonzero if there is an indirect jump in the current function. */
int has_indirect_jump;
/* Register or constant initial loop value. */
rtx initial_value;
/* Register or constant value used for comparison test. */
......@@ -181,15 +197,13 @@ struct loop_info
wider iterator, this number will be zero if the number of loop
iterations is too large for an unsigned integer to hold. */
unsigned HOST_WIDE_INT n_iterations;
/* The loop unrolling factor.
Potential values:
0: unrolled
1: not unrolled.
-1: completely unrolled
>0: holds the unroll exact factor. */
/* The number of times the loop body was unrolled. */
unsigned int unroll_number;
/* Non-zero if the loop has a NOTE_INSN_LOOP_VTOP. */
rtx vtop;
/* Non-zero if the loop has a NOTE_INSN_LOOP_CONT.
A continue statement will generate a branch to NEXT_INSN (cont). */
rtx cont;
};
/* Definitions used by the basic induction variable discovery code. */
......@@ -240,10 +254,10 @@ rtx final_giv_value PROTO((struct induction *, rtx, rtx,
unsigned HOST_WIDE_INT));
void emit_unrolled_add PROTO((rtx, rtx, rtx));
int back_branch_in_range_p PROTO((rtx, rtx, rtx));
int loop_insn_first_p PROTO((rtx, rtx));
extern int *loop_unroll_number;
int loop_insn_first_p PROTO((rtx, rtx));
/* Forward declarations for non-static functions declared in stmt.c. */
void find_loop_tree_blocks PROTO((void));
void unroll_block_trees PROTO((void));
gcc/unroll.c
......@@ -1117,11 +1117,7 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
/* At this point, we are guaranteed to unroll the loop. */
/* Keep track of the unroll factor for the loop. */
if (unroll_type == UNROLL_COMPLETELY)
loop_info->unroll_number = -1;
else
loop_info->unroll_number = unroll_number;
loop_info->unroll_number = unroll_number;
/* For each biv and giv, determine whether it can be safely split into
a different variable for each unrolled copy of the loop body.
......@@ -3500,7 +3496,6 @@ loop_find_equiv_value (loop_start, reg)
return ret;
}
/* Return a simplified rtx for the expression OP - REG.
REG must appear in OP, and OP must be a register or the sum of a register
......@@ -3566,7 +3561,6 @@ find_common_reg_term (op0, op1)
return NULL_RTX;
}
/* Calculate the number of loop iterations. Returns the exact number of loop
iterations if it can be calculated, otherwise returns zero. */
......@@ -3584,7 +3578,6 @@ loop_iterations (loop_start, loop_end, loop_info)
int increment_dir;
int unsigned_p, compare_dir, final_larger;
rtx last_loop_insn;
rtx vtop;
rtx reg_term;
loop_info->n_iterations = 0;
......@@ -3596,7 +3589,6 @@ loop_iterations (loop_start, loop_end, loop_info)
loop_info->increment = 0;
loop_info->iteration_var = 0;
loop_info->unroll_number = 1;
loop_info->vtop = 0;
/* We used to use prev_nonnote_insn here, but that fails because it might
accidentally get the branch for a contained loop if the branch for this
......@@ -3645,25 +3637,6 @@ loop_iterations (loop_start, loop_end, loop_info)
iteration_var = XEXP (comparison, 0);
comparison_value = XEXP (comparison, 1);
/* Check if there is a NOTE_INSN_LOOP_VTOP note. If there is,
that means that this is a for or while style loop, with
a loop exit test at the start. Thus, we can assume that
the loop condition was true when the loop was entered.
We start at the end and search backwards for the previous
NOTE. If there is no NOTE_INSN_LOOP_VTOP for this loop,
the search will stop at the NOTE_INSN_LOOP_CONT. */
vtop = loop_end;
do
vtop = PREV_INSN (vtop);
while (GET_CODE (vtop) != NOTE
|| NOTE_LINE_NUMBER (vtop) > 0
|| NOTE_LINE_NUMBER (vtop) == NOTE_REPEATED_LINE_NUMBER
|| NOTE_LINE_NUMBER (vtop) == NOTE_INSN_DELETED);
if (NOTE_LINE_NUMBER (vtop) != NOTE_INSN_LOOP_VTOP)
vtop = NULL_RTX;
loop_info->vtop = vtop;
if (GET_CODE (iteration_var) != REG)
{
if (loop_dump_stream)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment