* basic-block.h (basic_block_head): Rename to x_basic_block_head.
(basic_block_end): Rename to x_basic_block_end.
(BLOCK_HEAD, BLOCK_END): Update.
* caller-save.c: Change basic_block_head/end references to
BLOCK_HEAD/END.
* combine.c, flow.c, function.c, gcse.c, global.c: Likewise.
* graph.c, haifa-sched.c, local-alloc.c, regclass.c: Likewise.
* regmove.c, reload1.c, reorg.c, sched.c: Likewise.
From-SVN: r24622
+Mon Jan 11 22:36:01 1999 Richard Henderson <rth@cygnus.com>
+
+ * basic-block.h (basic_block_head): Rename to x_basic_block_head.
+ (basic_block_end): Rename to x_basic_block_end.
+ (BLOCK_HEAD, BLOCK_END): Update.
+
+ * caller-save.c: Change basic_block_head/end references to
+ BLOCK_HEAD/END.
+ * combine.c, flow.c, function.c, gcse.c, global.c: Likewise.
+ * graph.c, haifa-sched.c, local-alloc.c, regclass.c: Likewise.
+ * regmove.c, reload1.c, reorg.c, sched.c: Likewise.
+
Sat Jan 9 23:54:09 1999 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* gcc.c (xstrerror): Renamed from my_strerror. All callers
/* Index by basic block number, get first insn in the block. */
-extern rtx *basic_block_head;
+extern rtx *x_basic_block_head;
/* Index by basic block number, get last insn in the block. */
-extern rtx *basic_block_end;
+extern rtx *x_basic_block_end;
/* Index by basic block number, determine whether the block can be reached
through a computed jump. */
\f
/* Stuff for recording basic block info. */
-#define BLOCK_HEAD(B) basic_block_head[(B)]
-#define BLOCK_END(B) basic_block_end[(B)]
+#define BLOCK_HEAD(B) x_basic_block_head[(B)]
+#define BLOCK_END(B) x_basic_block_end[(B)]
/* Special block numbers [markers] for entry and exit. */
#define ENTRY_BLOCK (-1)
registers from the live sets. */
COPY_REG_SET (new->live_before, chain->live_before);
COPY_REG_SET (new->live_after, chain->live_before);
- if (chain->insn == basic_block_head[chain->block])
- basic_block_head[chain->block] = new->insn;
+ if (chain->insn == BLOCK_HEAD (chain->block))
+ BLOCK_HEAD (chain->block) = new->insn;
}
else
{
registers from the live sets, and observe REG_UNUSED notes. */
COPY_REG_SET (new->live_before, chain->live_after);
COPY_REG_SET (new->live_after, chain->live_after);
- if (chain->insn == basic_block_end[chain->block])
- basic_block_end[chain->block] = new->insn;
+ if (chain->insn == BLOCK_END (chain->block))
+ BLOCK_END (chain->block) = new->insn;
}
new->block = chain->block;
new->is_caller_save_insn = 1;
/* If INSN starts a new basic block, update our basic block number. */
if (this_basic_block + 1 < n_basic_blocks
- && basic_block_head[this_basic_block + 1] == insn)
+ && BLOCK_HEAD (this_basic_block + 1) == insn)
this_basic_block++;
if (GET_CODE (insn) == CODE_LABEL)
for (insn = NEXT_INSN (i3);
insn && (this_basic_block == n_basic_blocks - 1
- || insn != basic_block_head[this_basic_block + 1]);
+ || insn != BLOCK_HEAD (this_basic_block + 1));
insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
SET_DEST (XVECEXP (PATTERN (i2), 0, i))))
for (temp = NEXT_INSN (i2);
temp && (this_basic_block == n_basic_blocks - 1
- || basic_block_head[this_basic_block] != temp);
+ || BLOCK_HEAD (this_basic_block) != temp);
temp = NEXT_INSN (temp))
if (temp != i3 && GET_RTX_CLASS (GET_CODE (temp)) == 'i')
for (link = LOG_LINKS (temp); link; link = XEXP (link, 1))
else
{
for (block = 0; block < n_basic_blocks; block++)
- if (insn == basic_block_head[block])
+ if (insn == BLOCK_HEAD (block))
break;
if (block == n_basic_blocks)
tem);
/* If this insn was emitted between blocks, then update
- basic_block_head of the current block to include it. */
- if (basic_block_end[this_basic_block - 1] == tem)
- basic_block_head[this_basic_block] = place;
+ BLOCK_HEAD of the current block to include it. */
+ if (BLOCK_END (this_basic_block - 1) == tem)
+ BLOCK_HEAD (this_basic_block) = place;
}
}
for (insn = NEXT_INSN (XEXP (link, 0));
(insn && (this_basic_block == n_basic_blocks - 1
- || basic_block_head[this_basic_block + 1] != insn));
+ || BLOCK_HEAD (this_basic_block + 1) != insn));
insn = NEXT_INSN (insn))
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
&& reg_overlap_mentioned_p (reg, PATTERN (insn)))
/* Element N is first insn in basic block N.
This info lasts until we finish compiling the function. */
-rtx *basic_block_head;
+rtx *x_basic_block_head;
/* Element N is last insn in basic block N.
This info lasts until we finish compiling the function. */
-rtx *basic_block_end;
+rtx *x_basic_block_end;
/* Element N indicates whether basic block N can be reached through a
computed jump. */
/* If the previous insn was a call that did not create an
abnormal edge, we want to add a nop so that the CALL_INSN
- itself is not at basic_block_end. This allows us to easily
+ itself is not at basic block end. This allows us to easily
distinguish between normal calls and those which create
abnormal edges in the flow graph. */
/* Allocate some tables that last till end of compiling this function
and some needed only in find_basic_blocks and life_analysis. */
- basic_block_head = XNMALLOC (rtx, n_basic_blocks);
- basic_block_end = XNMALLOC (rtx, n_basic_blocks);
+ x_basic_block_head = XNMALLOC (rtx, n_basic_blocks);
+ x_basic_block_end = XNMALLOC (rtx, n_basic_blocks);
basic_block_succ = XNMALLOC (int_list_ptr, n_basic_blocks);
basic_block_pred = XNMALLOC (int_list_ptr, n_basic_blocks);
bzero ((char *)basic_block_succ, n_basic_blocks * sizeof (int_list_ptr));
|| (prev_code == CALL_INSN && call_had_abnormal_edge)
|| prev_code == BARRIER)))
{
- basic_block_head[++i] = insn;
- basic_block_end[i] = insn;
+ BLOCK_HEAD (++i) = insn;
+ BLOCK_END (i) = insn;
basic_block_loop_depth[i] = depth;
if (code == CODE_LABEL)
else if (GET_RTX_CLASS (code) == 'i')
{
- basic_block_end[i] = insn;
+ BLOCK_END (i) = insn;
basic_block_loop_depth[i] = depth;
}
/* See if control drops into the next block. */
if (i + 1 < n_basic_blocks)
{
- for (insn = PREV_INSN (basic_block_head[i + 1]);
+ for (insn = PREV_INSN (BLOCK_HEAD (i + 1));
insn && GET_CODE (insn) == NOTE; insn = PREV_INSN (insn))
;
add_edge (i, i + 1);
}
- insn = basic_block_end[i];
+ insn = BLOCK_END (i);
if (GET_CODE (insn) == JUMP_INSN)
mark_label_ref (i, PATTERN (insn));
/* Now scan the insns for this block, we may need to make edges for some of
them to various non-obvious locations (exception handlers, nonlocal
labels, etc). */
- for (insn = basic_block_head[i];
- insn != NEXT_INSN (basic_block_end[i]);
+ for (insn = BLOCK_HEAD (i);
+ insn != NEXT_INSN (BLOCK_END (i));
insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
if (i != j)
{
- rtx tmp = basic_block_head[i];
+ rtx tmp = BLOCK_HEAD (i);
for (;;)
{
BLOCK_NUM (tmp) = j;
- if (tmp == basic_block_end[i])
+ if (tmp == BLOCK_END (i))
break;
tmp = NEXT_INSN (tmp);
}
- basic_block_head[j] = basic_block_head[i];
- basic_block_end[j] = basic_block_end[i];
+ BLOCK_HEAD (j) = BLOCK_HEAD (i);
+ BLOCK_END (j) = BLOCK_END (i);
basic_block_pred[j] = basic_block_pred[i];
basic_block_succ[j] = basic_block_succ[i];
basic_block_loop_depth[j] = basic_block_loop_depth[i];
}
/* Delete the insns in a (non-live) block. We physically delete every
- non-note insn except the start and end (so basic_block_head/end needn't
+ non-note insn except the start and end (so BLOCK_HEAD/END needn't
be updated), we turn the latter into NOTE_INSN_DELETED notes.
We use to "delete" the insns by turning them into notes, but we may be
We need to remove the label from the exception_handler_label
list and remove the associated NOTE_EH_REGION_BEG and
NOTE_EH_REGION_END notes. */
- insn = basic_block_head[i];
+ insn = BLOCK_HEAD (i);
if (GET_CODE (insn) == CODE_LABEL)
{
rtx x, *prev = &exception_handler_labels;
/* Walk the insns of the block, building a chain of NOTEs that need to be
kept. */
- insn = basic_block_head[i];
+ insn = BLOCK_HEAD (i);
for (;;)
{
if (GET_CODE (insn) == BARRIER)
kept_tail = insn;
}
}
- if (insn == basic_block_end[i])
+ if (insn == BLOCK_END (i))
break;
insn = NEXT_INSN (insn);
}
place. */
if (kept_head == 0)
{
- NEXT_INSN (PREV_INSN (basic_block_head[i])) = insn;
+ NEXT_INSN (PREV_INSN (BLOCK_HEAD (i))) = insn;
if (insn != 0)
- PREV_INSN (insn) = PREV_INSN (basic_block_head[i]);
+ PREV_INSN (insn) = PREV_INSN (BLOCK_HEAD (i));
else
- set_last_insn (PREV_INSN (basic_block_head[i]));
+ set_last_insn (PREV_INSN (BLOCK_HEAD(i)));
}
else
{
- NEXT_INSN (PREV_INSN (basic_block_head[i])) = kept_head;
+ NEXT_INSN (PREV_INSN (BLOCK_HEAD (i))) = kept_head;
if (insn != 0)
PREV_INSN (insn) = kept_tail;
- PREV_INSN (kept_head) = PREV_INSN (basic_block_head[i]);
+ PREV_INSN (kept_head) = PREV_INSN (BLOCK_HEAD (i));
NEXT_INSN (kept_tail) = insn;
/* This must happen after NEXT_INSN (kept_tail) has been reinitialized
if (block_live_static[j])
{
rtx label;
- insn = basic_block_end[i - 1];
+ insn = BLOCK_END (i - 1);
if (GET_CODE (insn) == JUMP_INSN
/* An unconditional jump is the only possibility
we must check for, since a conditional one
/* Free the variables allocated by find_basic_blocks.
- KEEP_HEAD_END_P is non-zero if basic_block_head and basic_block_end
+ KEEP_HEAD_END_P is non-zero if BLOCK_HEAD and BLOCK_END
are not to be freed. */
void
uid_volatile = 0;
}
- if (! keep_head_end_p && basic_block_head)
+ if (! keep_head_end_p && x_basic_block_head)
{
- free (basic_block_head);
- basic_block_head = 0;
- free (basic_block_end);
- basic_block_end = 0;
+ free (x_basic_block_head);
+ x_basic_block_head = 0;
+ free (x_basic_block_end);
+ x_basic_block_end = 0;
}
}
COPY_REG_SET (basic_block_live_at_start[i],
basic_block_live_at_end[i]);
propagate_block (basic_block_live_at_start[i],
- basic_block_head[i], basic_block_end[i], 0,
+ BLOCK_HEAD (i), BLOCK_END (i), 0,
first_pass ? basic_block_significant[i]
: (regset) 0,
i);
for (i = 0; i < n_basic_blocks; i++)
{
propagate_block (basic_block_live_at_end[i],
- basic_block_head[i], basic_block_end[i], 1,
+ BLOCK_HEAD (i), BLOCK_END (i), 1,
(regset) 0, i);
#ifdef USE_C_ALLOCA
alloca (0);
new insn(s) and do the updates. */
emit_insns_before (insns, insn);
- if (basic_block_head[BLOCK_NUM (insn)] == insn)
- basic_block_head[BLOCK_NUM (insn)] = insns;
+ if (BLOCK_HEAD (BLOCK_NUM (insn)) == insn)
+ BLOCK_HEAD (BLOCK_NUM (insn)) = insns;
/* INCR will become a NOTE and INSN won't contain a
use of ADDR. If a use of ADDR was just placed in
for (i = n_basic_blocks-1; i >= 0; i--)
{
rtx x;
- start[INSN_UID (basic_block_head[i])] = i;
- end[INSN_UID (basic_block_end[i])] = i;
- for (x = basic_block_head[i]; x != NULL_RTX; x = NEXT_INSN (x))
+ start[INSN_UID (BLOCK_HEAD (i))] = i;
+ end[INSN_UID (BLOCK_END (i))] = i;
+ for (x = BLOCK_HEAD (i); x != NULL_RTX; x = NEXT_INSN (x))
{
in_bb_p[ INSN_UID(x)]
= (in_bb_p[ INSN_UID(x)] == NOT_IN_BB)
? IN_ONE_BB : IN_MULTIPLE_BB;
- if (x == basic_block_end[i])
+ if (x == BLOCK_END (i))
break;
}
}
/* Include the new prologue insns in the first block. Ignore them
if they form a basic block unto themselves. */
- if (basic_block_head && n_basic_blocks
- && GET_CODE (basic_block_head[0]) != CODE_LABEL)
- basic_block_head[0] = NEXT_INSN (f);
+ if (x_basic_block_head && n_basic_blocks
+ && GET_CODE (BLOCK_HEAD (0)) != CODE_LABEL)
+ BLOCK_HEAD (0) = NEXT_INSN (f);
/* Retain a map of the prologue insns. */
prologue = record_insns (GET_CODE (seq) == SEQUENCE ? seq : head);
/* Include the new epilogue insns in the last block. Ignore
them if they form a basic block unto themselves. */
- if (basic_block_end && n_basic_blocks
- && GET_CODE (basic_block_end[n_basic_blocks - 1]) != JUMP_INSN)
- basic_block_end[n_basic_blocks - 1] = tail;
+ if (x_basic_block_end && n_basic_blocks
+ && GET_CODE (BLOCK_END (n_basic_blocks - 1)) != JUMP_INSN)
+ BLOCK_END (n_basic_blocks - 1) = tail;
/* Retain a map of the epilogue insns. */
epilogue = record_insns (GET_CODE (seq) == SEQUENCE ? seq : tail);
if (next)
PREV_INSN (next) = prev;
- /* Whether or not we can depend on basic_block_head,
+ /* Whether or not we can depend on BLOCK_HEAD,
attempt to keep it up-to-date. */
- if (basic_block_head[0] == note)
- basic_block_head[0] = next;
+ if (BLOCK_HEAD (0) == note)
+ BLOCK_HEAD (0) = next;
add_insn_after (note, insn);
}
if (next)
PREV_INSN (next) = prev;
- /* Whether or not we can depend on basic_block_head,
+ /* Whether or not we can depend on BLOCK_HEAD,
attempt to keep it up-to-date. */
if (n_basic_blocks
- && basic_block_head[n_basic_blocks-1] == insn)
- basic_block_head[n_basic_blocks-1] = note;
+ && BLOCK_HEAD (n_basic_blocks-1) == insn)
+ BLOCK_HEAD (n_basic_blocks-1) = note;
add_insn_before (note, insn);
}
mem_first_set = NEVER_SET;
mem_last_set = NEVER_SET;
- for (insn = basic_block_head[bb];
- insn && insn != NEXT_INSN (basic_block_end[bb]);
+ for (insn = BLOCK_HEAD (bb);
+ insn && insn != NEXT_INSN (BLOCK_END (bb));
insn = NEXT_INSN (insn))
{
#ifdef NON_SAVING_SETJMP
/* The next pass builds the hash table. */
- for (insn = basic_block_head[bb], in_libcall_block = 0;
- insn && insn != NEXT_INSN (basic_block_end[bb]);
+ for (insn = BLOCK_HEAD (bb), in_libcall_block = 0;
+ insn && insn != NEXT_INSN (BLOCK_END (bb));
insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
start of the block]. */
reset_opr_set_tables ();
- for (insn = basic_block_head[bb];
- insn != NULL && insn != NEXT_INSN (basic_block_end[bb]);
+ for (insn = BLOCK_HEAD (bb);
+ insn != NULL && insn != NEXT_INSN (BLOCK_END (bb));
insn = NEXT_INSN (insn))
{
/* Is insn of form (set (pseudo-reg) ...)? */
start of the block]. */
reset_opr_set_tables ();
- for (insn = basic_block_head[bb];
- insn != NULL && insn != NEXT_INSN (basic_block_end[bb]);
+ for (insn = BLOCK_HEAD (bb);
+ insn != NULL && insn != NEXT_INSN (BLOCK_END (bb));
insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
#endif
}
- insn = basic_block_head[b];
+ insn = BLOCK_HEAD (b);
/* Scan the code of this basic block, noting which allocnos
and hard regs are born or die. When one is born,
mark_reg_death (regs_set[n_regs_set]);
}
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
insn = NEXT_INSN (insn);
}
{
struct insn_chain *c;
- if (first == basic_block_head[b])
+ if (first == BLOCK_HEAD (b))
{
int i;
CLEAR_REG_SET (live_relevant_regs);
}
}
- if (first == basic_block_end[b])
+ if (first == BLOCK_END (b))
b++;
/* Stop after we pass the end of the last basic block. Verify that
for (i = n_basic_blocks - 1; i >= 0; --i)
{
rtx x;
- start[INSN_UID (basic_block_head[i])] = i;
- end[INSN_UID (basic_block_end[i])] = i;
- for (x = basic_block_head[i]; x != NULL_RTX; x = NEXT_INSN (x))
+ start[INSN_UID (BLOCK_HEAD (i))] = i;
+ end[INSN_UID (BLOCK_END (i))] = i;
+ for (x = BLOCK_HEAD (i); x != NULL_RTX; x = NEXT_INSN (x))
{
in_bb_p[INSN_UID (x)]
= (in_bb_p[INSN_UID (x)] == NOT_IN_BB)
? IN_ONE_BB : IN_MULTIPLE_BB;
- if (x == basic_block_end[i])
+ if (x == BLOCK_END (i))
break;
}
}
This pass must update information that subsequent passes expect to
be correct. Namely: reg_n_refs, reg_n_sets, reg_n_deaths,
- reg_n_calls_crossed, and reg_live_length. Also, basic_block_head,
- basic_block_end.
+ reg_n_calls_crossed, and reg_live_length. Also, BLOCK_HEAD,
+ BLOCK_END.
The information in the line number notes is carefully retained by
this pass. Notes that refer to the starting and ending of
the cfg not well structured. */
/* check for labels referred to other thn by jumps */
for (b = 0; b < n_basic_blocks; b++)
- for (insn = basic_block_head[b];; insn = NEXT_INSN (insn))
+ for (insn = BLOCK_HEAD (b);; insn = NEXT_INSN (insn))
{
code = GET_CODE (insn);
if (GET_RTX_CLASS (code) == 'i')
return 1;
}
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
}
int block, *num_bbs, *num_insns;
{
(*num_bbs)++;
- (*num_insns) += (INSN_LUID (basic_block_end[block]) -
- INSN_LUID (basic_block_head[block]));
+ (*num_insns) += (INSN_LUID (BLOCK_END (block)) -
+ INSN_LUID (BLOCK_HEAD (block)));
if ((*num_bbs > MAX_RGN_BLOCKS) || (*num_insns > MAX_RGN_INSNS))
return 1;
else
/* Estimate # insns, and count # blocks in the region. */
num_bbs = 1;
- num_insns = (INSN_LUID (basic_block_end[i])
- - INSN_LUID (basic_block_head[i]));
+ num_insns = (INSN_LUID (BLOCK_END (i))
+ - INSN_LUID (BLOCK_HEAD (i)));
/* Find all loop latches (blocks which back edges to the loop
b = BB_TO_BLOCK (bb);
/* HEAD and TAIL delimit the basic block being scheduled. */
- head = basic_block_head[b];
- tail = basic_block_end[b];
+ head = BLOCK_HEAD (b);
+ tail = BLOCK_END (b);
/* Don't include any notes or labels at the beginning of the
basic block, or notes at the ends of basic blocks. */
get_block_head_tail (bb, &head, &tail);
next_tail = NEXT_INSN (tail);
- for (insn = basic_block_head[BB_TO_BLOCK (bb)];
+ for (insn = BLOCK_HEAD (BB_TO_BLOCK (bb));
insn != next_tail;
insn = NEXT_INSN (insn))
if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
b = BB_TO_BLOCK (bb);
- head = basic_block_head[b];
- next_tail = NEXT_INSN (basic_block_end[b]);
+ head = BLOCK_HEAD (b);
+ next_tail = NEXT_INSN (BLOCK_END (b));
/* Determine the current line-number. We want to know the current
line number of the first insn of the block here, in case it is
fprintf (dump, ";; ======================================================\n");
fprintf (dump,
";; -- basic block %d from %d to %d -- %s reload\n",
- b, INSN_UID (basic_block_head[b]),
- INSN_UID (basic_block_end[b]),
+ b, INSN_UID (BLOCK_HEAD (b)), INSN_UID (BLOCK_END (b)),
(reload_completed ? "after" : "before"));
fprintf (dump, ";; ======================================================\n");
fprintf (dump, "\n");
last = prev_head;
/* Initialize INSN_QUEUE, LIST and NEW_NEEDS. */
- new_needs = (NEXT_INSN (prev_head) == basic_block_head[b]
+ new_needs = (NEXT_INSN (prev_head) == BLOCK_HEAD (b)
? NEED_HEAD : NEED_NOTHING);
- if (PREV_INSN (next_tail) == basic_block_end[b])
+ if (PREV_INSN (next_tail) == BLOCK_END (b))
new_needs |= NEED_TAIL;
/* loop until all the insns in BB are scheduled. */
/* Update source block boundaries. */
b1 = INSN_BLOCK (temp);
- if (temp == basic_block_head[b1]
- && insn == basic_block_end[b1])
+ if (temp == BLOCK_HEAD (b1)
+ && insn == BLOCK_END (b1))
{
/* We moved all the insns in the basic block.
Emit a note after the last insn and update the
begin/end boundaries to point to the note. */
emit_note_after (NOTE_INSN_DELETED, insn);
- basic_block_end[b1] = NEXT_INSN (insn);
- basic_block_head[b1] = NEXT_INSN (insn);
+ BLOCK_END (b1) = NEXT_INSN (insn);
+ BLOCK_HEAD (b1) = NEXT_INSN (insn);
}
- else if (insn == basic_block_end[b1])
+ else if (insn == BLOCK_END (b1))
{
/* We took insns from the end of the basic block,
so update the end of block boundary so that it
points to the first insn we did not move. */
- basic_block_end[b1] = PREV_INSN (temp);
+ BLOCK_END (b1) = PREV_INSN (temp);
}
- else if (temp == basic_block_head[b1])
+ else if (temp == BLOCK_HEAD (b1))
{
/* We took insns from the start of the basic block,
so update the start of block boundary so that
it points to the first insn we did not move. */
- basic_block_head[b1] = NEXT_INSN (insn);
+ BLOCK_HEAD (b1) = NEXT_INSN (insn);
}
}
else
/* update target block boundaries. */
if (new_needs & NEED_HEAD)
- basic_block_head[b] = head;
+ BLOCK_HEAD (b) = head;
if (new_needs & NEED_TAIL)
- basic_block_end[b] = tail;
+ BLOCK_END (b) = tail;
/* debugging */
if (sched_verbose)
{
fprintf (dump, ";; total time = %d\n;; new basic block head = %d\n",
- clock_var, INSN_UID (basic_block_head[b]));
+ clock_var, INSN_UID (BLOCK_HEAD (b)));
fprintf (dump, ";; new basic block end = %d\n\n",
- INSN_UID (basic_block_end[b]));
+ INSN_UID (BLOCK_END (b)));
}
return (sched_n_insns);
{
rtx insn, next;
- for (insn = basic_block_head[b];; insn = next)
+ for (insn = BLOCK_HEAD (b);; insn = next)
{
rtx set, last, first, notes;
next = NEXT_INSN (insn);
if (GET_CODE (insn) != INSN)
{
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
continue;
set = single_set (insn);
if (set && rtx_equal_p (SET_SRC (set), SET_DEST (set)))
{
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
/* Nops get in the way while scheduling, so delete them now if
PUT_CODE (insn, NOTE);
NOTE_SOURCE_FILE (insn) = 0;
NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- if (insn == basic_block_head[b])
- basic_block_head[b] = first;
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_HEAD (b))
+ BLOCK_HEAD (b) = first;
+ if (insn == BLOCK_END (b))
{
- basic_block_end[b] = last;
+ BLOCK_END (b) = last;
break;
}
}
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
}
}
luid = 0;
for (b = 0; b < n_basic_blocks; b++)
- for (insn = basic_block_head[b];; insn = NEXT_INSN (insn))
+ for (insn = BLOCK_HEAD (b);; insn = NEXT_INSN (insn))
{
INSN_BLOCK (insn) = b;
INSN_LUID (insn) = luid++;
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
}
rtx insn;
for (b = 0; b < n_basic_blocks; b++)
- for (insn = basic_block_head[b];; insn = NEXT_INSN (insn))
+ for (insn = BLOCK_HEAD (b);; insn = NEXT_INSN (insn))
{
rtx link, prev;
}
}
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
}
}
determine the correct line number for the first insn of the block. */
for (b = 0; b < n_basic_blocks; b++)
- for (line = basic_block_head[b]; line; line = PREV_INSN (line))
+ for (line = BLOCK_HEAD (b); line; line = PREV_INSN (line))
if (GET_CODE (line) == NOTE && NOTE_LINE_NUMBER (line) > 0)
{
line_note_head[b] = line;
/* ??? Add a NOTE after the last insn of the last basic block. It is not
known why this is done. */
- insn = basic_block_end[n_basic_blocks - 1];
+ insn = BLOCK_END (n_basic_blocks - 1);
if (NEXT_INSN (insn) == 0
|| (GET_CODE (insn) != NOTE
&& GET_CODE (insn) != CODE_LABEL
- /* Don't emit a NOTE if it would end up between an unconditional
- jump and a BARRIER. */
+ /* Don't emit a NOTE if it would end up between an unconditional
+ jump and a BARRIER. */
&& !(GET_CODE (insn) == JUMP_INSN
&& GET_CODE (NEXT_INSN (insn)) == BARRIER)))
- emit_note_after (NOTE_INSN_DELETED, basic_block_end[n_basic_blocks - 1]);
+ emit_note_after (NOTE_INSN_DELETED, BLOCK_END (n_basic_blocks - 1));
/* Schedule every region in the subroutine */
for (rgn = 0; rgn < nr_regions; rgn++)
/* Keep track of which basic block we are in. */
if (block + 1 < n_basic_blocks
- && basic_block_head[block + 1] == insn)
+ && BLOCK_HEAD (block + 1) == insn)
++block;
if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
REG_N_CALLS_CROSSED (regno) = 0;
REG_LIVE_LENGTH (regno) = 2;
- if (block >= 0 && insn == basic_block_head[block])
- basic_block_head[block] = PREV_INSN (insn);
+ if (block >= 0 && insn == BLOCK_HEAD (block))
+ BLOCK_HEAD (block) = PREV_INSN (insn);
for (l = 0; l < n_basic_blocks; l++)
CLEAR_REGNO_REG_SET (basic_block_live_at_start[l], regno);
/* Count the instructions in the basic block. */
- insn = basic_block_end[b];
+ insn = BLOCK_END (b);
while (1)
{
if (GET_CODE (insn) != NOTE)
if (++insn_count > max_uid)
abort ();
- if (insn == basic_block_head[b])
+ if (insn == BLOCK_HEAD (b))
break;
insn = PREV_INSN (insn);
}
and assigns quantities to registers.
It computes which registers to tie. */
- insn = basic_block_head[b];
+ insn = BLOCK_HEAD (b);
while (1)
{
register rtx body = PATTERN (insn);
IOR_HARD_REG_SET (regs_live_at[2 * insn_number], regs_live);
IOR_HARD_REG_SET (regs_live_at[2 * insn_number + 1], regs_live);
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
insn = NEXT_INSN (insn);
{
int b;
for (b = 0; b < n_basic_blocks; b++)
- if (insn == basic_block_head[b])
- basic_block_head[b] = newinsn;
+ if (insn == BLOCK_HEAD (b))
+ BLOCK_HEAD (b) = newinsn;
}
/* This makes one more setting of new insns's dest. */
bb = regmove_bb_head[insn_uid];
if (bb >= 0)
{
- basic_block_head[bb] = move_insn;
+ BLOCK_HEAD (bb) = move_insn;
regmove_bb_head[insn_uid] = -1;
}
regmove_bb_head = (int *)alloca (sizeof (int) * (old_max_uid + 1));
for (i = old_max_uid; i >= 0; i--) regmove_bb_head[i] = -1;
for (i = 0; i < n_basic_blocks; i++)
- regmove_bb_head[INSN_UID (basic_block_head[i])] = i;
+ regmove_bb_head[INSN_UID (BLOCK_HEAD (i))] = i;
/* A forward/backward pass. Replace output operands with input operands. */
ends. Fix that here. */
for (i = 0; i < n_basic_blocks; i++)
{
- rtx end = basic_block_end[i];
+ rtx end = BLOCK_END (i);
rtx new = end;
rtx next = NEXT_INSN (new);
while (next != 0 && INSN_UID (next) >= old_max_uid
- && (i == n_basic_blocks - 1 || basic_block_head[i + 1] != next))
+ && (i == n_basic_blocks - 1 || BLOCK_HEAD (i + 1) != next))
new = next, next = NEXT_INSN (new);
- basic_block_end[i] = new;
+ BLOCK_END (i) = new;
}
}
struct insn_chain *next = c->next;
rtx insn = c->insn;
- if (insn == basic_block_head[c->block])
- basic_block_head[c->block] = NEXT_INSN (insn);
- if (insn == basic_block_end[c->block])
- basic_block_end[c->block] = PREV_INSN (insn);
+ if (insn == BLOCK_HEAD (c->block))
+ BLOCK_HEAD (c->block) = NEXT_INSN (insn);
+ if (insn == BLOCK_END (c->block))
+ BLOCK_END (c->block) = PREV_INSN (insn);
if (c == reload_insn_chain)
reload_insn_chain = next;
/* Keep basic block info up to date. */
if (n_basic_blocks)
{
- if (basic_block_head[chain->block] == insn)
- basic_block_head[chain->block] = NEXT_INSN (before_insn);
- if (basic_block_end[chain->block] == insn)
- basic_block_end[chain->block] = PREV_INSN (following_insn);
+ if (BLOCK_HEAD (chain->block) == insn)
+ BLOCK_HEAD (chain->block) = NEXT_INSN (before_insn);
+ if (BLOCK_END (chain->block) == insn)
+ BLOCK_END (chain->block) = PREV_INSN (following_insn);
}
/* For all the spill regs newly reloaded in this instruction,
CLEAR_HARD_REG_SET (ever_live_at_start);
for (i = n_basic_blocks - 1; i >= 0; i--)
{
- insn = basic_block_head[i];
+ insn = BLOCK_HEAD (i);
if (GET_CODE (insn) == CODE_LABEL)
{
HARD_REG_SET live;
insn = next_nonnote_insn (insn))
{
for (i = 0; i < n_basic_blocks; i++)
- if (insn == basic_block_head[i])
+ if (insn == BLOCK_HEAD (i))
return i;
}
we can get it from there unless the insn at the start of the basic block
has been deleted. */
if (tinfo && tinfo->block != -1
- && ! INSN_DELETED_P (basic_block_head[tinfo->block]))
+ && ! INSN_DELETED_P (BLOCK_HEAD (tinfo->block)))
b = tinfo->block;
if (b == -1)
/* Get starting and ending insn, handling the case where each might
be a SEQUENCE. */
- start_insn = (b == 0 ? get_insns () : basic_block_head[b]);
+ start_insn = (b == 0 ? get_insns () : BLOCK_HEAD (b));
stop_insn = target;
if (GET_CODE (start_insn) == INSN
This pass must update information that subsequent passes expect to be
correct. Namely: reg_n_refs, reg_n_sets, reg_n_deaths,
- reg_n_calls_crossed, and reg_live_length. Also, basic_block_head,
- basic_block_end.
+ reg_n_calls_crossed, and reg_live_length. Also, BLOCK_HEAD,
+ BLOCK_END.
The information in the line number notes is carefully retained by
this pass. Notes that refer to the starting and ending of
int new_needs;
/* HEAD and TAIL delimit the region being scheduled. */
- rtx head = basic_block_head[b];
- rtx tail = basic_block_end[b];
+ rtx head = BLOCK_HEAD (b);
+ rtx tail = BLOCK_END (b);
/* PREV_HEAD and NEXT_TAIL are the boundaries of the insns
being scheduled. When the insns have been ordered,
these insns delimit where the new insns are to be
if (file)
fprintf (file, ";;\t -- basic block number %d from %d to %d --\n",
- b, INSN_UID (basic_block_head[b]), INSN_UID (basic_block_end[b]));
+ b, INSN_UID (BLOCK_HEAD (b)), INSN_UID (BLOCK_END (b)));
i = max_reg_num ();
reg_last_uses = (rtx *) alloca (i * sizeof (rtx));
/* We don't want to remove any REG_DEAD notes as the code below
does. */
- for (insn = basic_block_head[b]; insn != head;
+ for (insn = BLOCK_HEAD (b); insn != head;
insn = NEXT_INSN (insn))
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
{
block may have changed the current line number. */
rtx line = line_note_head[b];
- for (insn = basic_block_head[b];
+ for (insn = BLOCK_HEAD (b);
insn != next_tail;
insn = NEXT_INSN (insn))
if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
/* Where we start inserting insns is after TAIL. */
last = next_tail;
- new_needs = (NEXT_INSN (prev_head) == basic_block_head[b]
+ new_needs = (NEXT_INSN (prev_head) == BLOCK_HEAD (b)
? NEED_HEAD : NEED_NOTHING);
- if (PREV_INSN (next_tail) == basic_block_end[b])
+ if (PREV_INSN (next_tail) == BLOCK_END (b))
new_needs |= NEED_TAIL;
new_ready = n_ready;
#endif
if (new_needs & NEED_HEAD)
- basic_block_head[b] = head;
+ BLOCK_HEAD (b) = head;
PREV_INSN (head) = prev_head;
NEXT_INSN (prev_head) = head;
if (new_needs & NEED_TAIL)
- basic_block_end[b] = tail;
+ BLOCK_END (b) = tail;
NEXT_INSN (tail) = next_tail;
PREV_INSN (next_tail) = tail;
rtx line, note, prev, new;
int notes = 0;
- head = basic_block_head[b];
- next_tail = NEXT_INSN (basic_block_end[b]);
+ head = BLOCK_HEAD (b);
+ next_tail = NEXT_INSN (BLOCK_END (b));
/* Determine the current line-number. We want to know the current
line number of the first insn of the block here, in case it is
if (file)
{
fprintf (file, ";; total time = %d\n;; new basic block head = %d\n;; new basic block end = %d\n\n",
- clock, INSN_UID (basic_block_head[b]), INSN_UID (basic_block_end[b]));
+ clock, INSN_UID (BLOCK_HEAD (b)), INSN_UID (BLOCK_END (b)));
}
/* Yow! We're done! */
determine the correct line number for the first insn of the block. */
for (b = 0; b < n_basic_blocks; b++)
- for (line = basic_block_head[b]; line; line = PREV_INSN (line))
+ for (line = BLOCK_HEAD (b); line; line = PREV_INSN (line))
if (GET_CODE (line) == NOTE && NOTE_LINE_NUMBER (line) > 0)
{
line_note_head[b] = line;
/* ??? Perhaps it's done to ensure NEXT_TAIL in schedule_block is a
valid insn. */
- insn = basic_block_end[n_basic_blocks-1];
+ insn = BLOCK_END (n_basic_blocks-1);
if (NEXT_INSN (insn) == 0
|| (GET_CODE (insn) != NOTE
&& GET_CODE (insn) != CODE_LABEL
jump and a BARRIER. */
&& ! (GET_CODE (insn) == JUMP_INSN
&& GET_CODE (NEXT_INSN (insn)) == BARRIER)))
- emit_note_after (NOTE_INSN_DELETED, basic_block_end[n_basic_blocks-1]);
+ emit_note_after (NOTE_INSN_DELETED, BLOCK_END (n_basic_blocks-1));
for (b = 0; b < n_basic_blocks; b++)
{
note_list = 0;
- for (insn = basic_block_head[b]; ; insn = next)
+ for (insn = BLOCK_HEAD (b); ; insn = next)
{
rtx prev;
rtx set;
next = NEXT_INSN (insn);
if (GET_CODE (insn) != INSN)
{
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
continue;
set = single_set (insn);
if (set && rtx_equal_p (SET_SRC (set), SET_DEST (set)))
{
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
/* Nops get in the way while scheduling, so delete them now if
PUT_CODE (insn, NOTE);
NOTE_SOURCE_FILE (insn) = 0;
NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- if (insn == basic_block_head[b])
- basic_block_head[b] = first;
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_HEAD (b))
+ BLOCK_HEAD (b) = first;
+ if (insn == BLOCK_END (b))
{
- basic_block_end[b] = last;
+ BLOCK_END (b) = last;
break;
}
}
}
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
}
projects / gcc.git / commitdiff