* 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
16 files changed:
+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
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. */
/* 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. */
/* 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. */
/* Index by basic block number, determine whether the block can be reached
through a computed jump. */
\f
/* Stuff for recording basic block info. */
\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)
/* 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);
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;
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);
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;
}
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
/* 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)
this_basic_block++;
if (GET_CODE (insn) == CODE_LABEL)
for (insn = NEXT_INSN (i3);
insn && (this_basic_block == n_basic_blocks - 1
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'
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
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))
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++)
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)
break;
if (block == n_basic_blocks)
tem);
/* If this insn was emitted between blocks, then update
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
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)))
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. */
/* Element N is first insn in basic block N.
This info lasts until we finish compiling the function. */
+rtx *x_basic_block_head;
/* Element N is last insn in basic block N.
This info lasts until we finish compiling the function. */
/* Element N is last insn in basic block N.
This info lasts until we finish compiling the function. */
/* Element N indicates whether basic block N can be reached through a
computed jump. */
/* 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
/* 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. */
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. */
/* 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));
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)))
{
|| (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)
basic_block_loop_depth[i] = depth;
if (code == CODE_LABEL)
else if (GET_RTX_CLASS (code) == 'i')
{
else if (GET_RTX_CLASS (code) == 'i')
{
- basic_block_end[i] = insn;
basic_block_loop_depth[i] = depth;
}
basic_block_loop_depth[i] = depth;
}
/* See if control drops into the next block. */
if (i + 1 < n_basic_blocks)
{
/* 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))
;
insn && GET_CODE (insn) == NOTE; insn = PREV_INSN (insn))
;
- insn = basic_block_end[i];
if (GET_CODE (insn) == JUMP_INSN)
mark_label_ref (i, PATTERN (insn));
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). */
/* 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')
insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
- rtx tmp = basic_block_head[i];
+ rtx tmp = BLOCK_HEAD (i);
for (;;)
{
BLOCK_NUM (tmp) = j;
for (;;)
{
BLOCK_NUM (tmp) = j;
- if (tmp == basic_block_end[i])
+ if (tmp == BLOCK_END (i))
break;
tmp = NEXT_INSN (tmp);
}
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];
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
}
/* 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
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. */
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];
if (GET_CODE (insn) == CODE_LABEL)
{
rtx x, *prev = &exception_handler_labels;
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. */
/* Walk the insns of the block, building a chain of NOTEs that need to be
kept. */
- insn = basic_block_head[i];
for (;;)
{
if (GET_CODE (insn) == BARRIER)
for (;;)
{
if (GET_CODE (insn) == BARRIER)
- if (insn == basic_block_end[i])
+ if (insn == BLOCK_END (i))
break;
insn = NEXT_INSN (insn);
}
break;
insn = NEXT_INSN (insn);
}
place. */
if (kept_head == 0)
{
place. */
if (kept_head == 0)
{
- NEXT_INSN (PREV_INSN (basic_block_head[i])) = insn;
+ NEXT_INSN (PREV_INSN (BLOCK_HEAD (i))) = insn;
- PREV_INSN (insn) = PREV_INSN (basic_block_head[i]);
+ PREV_INSN (insn) = PREV_INSN (BLOCK_HEAD (i));
- set_last_insn (PREV_INSN (basic_block_head[i]));
+ set_last_insn (PREV_INSN (BLOCK_HEAD(i)));
- 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;
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
NEXT_INSN (kept_tail) = insn;
/* This must happen after NEXT_INSN (kept_tail) has been reinitialized
if (block_live_static[j])
{
rtx label;
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
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.
/* 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
are not to be freed. */
void
- 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],
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);
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],
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);
(regset) 0, i);
#ifdef USE_C_ALLOCA
alloca (0);
new insn(s) and do the updates. */
emit_insns_before (insns, insn);
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
/* 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;
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;
{
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))
/* Include the new prologue insns in the first block. Ignore them
if they form a basic block unto themselves. */
/* 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);
/* 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. */
/* 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);
/* Retain a map of the epilogue insns. */
epilogue = record_insns (GET_CODE (seq) == SEQUENCE ? seq : tail);
if (next)
PREV_INSN (next) = prev;
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. */
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);
}
add_insn_after (note, insn);
}
if (next)
PREV_INSN (next) = prev;
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
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);
}
add_insn_before (note, insn);
}
mem_first_set = NEVER_SET;
mem_last_set = NEVER_SET;
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
insn = NEXT_INSN (insn))
{
#ifdef NON_SAVING_SETJMP
/* The next pass builds the hash table. */
/* 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')
insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
start of the block]. */
reset_opr_set_tables ();
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) ...)? */
insn = NEXT_INSN (insn))
{
/* Is insn of form (set (pseudo-reg) ...)? */
start of the block]. */
reset_opr_set_tables ();
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')
insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
- insn = basic_block_head[b];
/* Scan the code of this basic block, noting which allocnos
and hard regs are born or die. When one is born,
/* 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]);
}
mark_reg_death (regs_set[n_regs_set]);
}
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
break;
insn = NEXT_INSN (insn);
}
break;
insn = NEXT_INSN (insn);
}
- if (first == basic_block_head[b])
+ if (first == BLOCK_HEAD (b))
{
int i;
CLEAR_REG_SET (live_relevant_regs);
{
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
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;
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;
{
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))
This pass must update information that subsequent passes expect to
be correct. Namely: reg_n_refs, reg_n_sets, reg_n_deaths,
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 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++)
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')
{
code = GET_CODE (insn);
if (GET_RTX_CLASS (code) == 'i')
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
int block, *num_bbs, *num_insns;
{
(*num_bbs)++;
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
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;
/* 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
/* 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. */
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. */
/* 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);
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)
insn != next_tail;
insn = NEXT_INSN (insn))
if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 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
/* 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",
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");
(reload_completed ? "after" : "before"));
fprintf (dump, ";; ======================================================\n");
fprintf (dump, "\n");
last = prev_head;
/* Initialize INSN_QUEUE, LIST and NEW_NEEDS. */
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);
? 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. */
new_needs |= NEED_TAIL;
/* loop until all the insns in BB are scheduled. */
/* Update source block boundaries. */
b1 = INSN_BLOCK (temp);
/* 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);
{
/* 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. */
{
/* 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. */
{
/* 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);
/* update target block boundaries. */
if (new_needs & NEED_HEAD)
/* update target block boundaries. */
if (new_needs & NEED_HEAD)
- basic_block_head[b] = head;
if (new_needs & NEED_TAIL)
if (new_needs & NEED_TAIL)
- basic_block_end[b] = tail;
/* debugging */
if (sched_verbose)
{
fprintf (dump, ";; total time = %d\n;; new basic block head = %d\n",
/* 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",
fprintf (dump, ";; new basic block end = %d\n\n",
- INSN_UID (basic_block_end[b]));
+ INSN_UID (BLOCK_END (b)));
}
return (sched_n_insns);
}
return (sched_n_insns);
- for (insn = basic_block_head[b];; insn = next)
+ for (insn = BLOCK_HEAD (b);; insn = next)
{
rtx set, last, first, notes;
{
rtx set, last, first, notes;
next = NEXT_INSN (insn);
if (GET_CODE (insn) != INSN)
{
next = NEXT_INSN (insn);
if (GET_CODE (insn) != INSN)
{
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
set = single_set (insn);
if (set && rtx_equal_p (SET_SRC (set), SET_DEST (set)))
{
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
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;
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;
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
luid = 0;
for (b = 0; b < n_basic_blocks; b++)
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++;
{
INSN_BLOCK (insn) = b;
INSN_LUID (insn) = luid++;
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
rtx insn;
for (b = 0; b < n_basic_blocks; b++)
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))
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
determine the correct line number for the first insn of the block. */
for (b = 0; b < n_basic_blocks; b++)
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;
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. */
/* ??? 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
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)))
&& !(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++)
/* 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
/* 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')
++block;
if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
REG_N_CALLS_CROSSED (regno) = 0;
REG_LIVE_LENGTH (regno) = 2;
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);
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. */
/* Count the instructions in the basic block. */
- insn = basic_block_end[b];
while (1)
{
if (GET_CODE (insn) != NOTE)
if (++insn_count > max_uid)
abort ();
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);
}
break;
insn = PREV_INSN (insn);
}
and assigns quantities to registers.
It computes which registers to tie. */
and assigns quantities to registers.
It computes which registers to tie. */
- insn = basic_block_head[b];
while (1)
{
register rtx body = PATTERN (insn);
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);
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);
break;
insn = NEXT_INSN (insn);
{
int b;
for (b = 0; b < n_basic_blocks; b++)
{
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. */
}
/* This makes one more setting of new insns's dest. */
bb = regmove_bb_head[insn_uid];
if (bb >= 0)
{
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[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 = (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. */
/* A forward/backward pass. Replace output operands with input operands. */
ends. Fix that here. */
for (i = 0; i < n_basic_blocks; i++)
{
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
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);
new = next, next = NEXT_INSN (new);
- basic_block_end[i] = new;
struct insn_chain *next = c->next;
rtx insn = c->insn;
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;
if (c == reload_insn_chain)
reload_insn_chain = next;
/* Keep basic block info up to date. */
if (n_basic_blocks)
{
/* 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,
}
/* 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--)
{
CLEAR_HARD_REG_SET (ever_live_at_start);
for (i = n_basic_blocks - 1; i >= 0; i--)
{
- insn = basic_block_head[i];
if (GET_CODE (insn) == CODE_LABEL)
{
HARD_REG_SET live;
if (GET_CODE (insn) == CODE_LABEL)
{
HARD_REG_SET live;
insn = next_nonnote_insn (insn))
{
for (i = 0; i < n_basic_blocks; i++)
insn = next_nonnote_insn (insn))
{
for (i = 0; i < n_basic_blocks; i++)
- if (insn == basic_block_head[i])
+ if (insn == BLOCK_HEAD (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
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)
b = tinfo->block;
if (b == -1)
/* Get starting and ending insn, handling the case where each might
be a SEQUENCE. */
/* 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
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,
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 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. */
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
/* 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",
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));
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. */
/* 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')
{
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];
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)
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;
/* 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);
? 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;
new_needs |= NEED_TAIL;
new_ready = n_ready;
#endif
if (new_needs & NEED_HEAD)
#endif
if (new_needs & NEED_HEAD)
- basic_block_head[b] = head;
PREV_INSN (head) = prev_head;
NEXT_INSN (prev_head) = head;
if (new_needs & NEED_TAIL)
PREV_INSN (head) = prev_head;
NEXT_INSN (prev_head) = head;
if (new_needs & NEED_TAIL)
- basic_block_end[b] = tail;
NEXT_INSN (tail) = next_tail;
PREV_INSN (next_tail) = tail;
NEXT_INSN (tail) = next_tail;
PREV_INSN (next_tail) = tail;
rtx line, note, prev, new;
int notes = 0;
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
/* 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",
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)));
determine the correct line number for the first insn of the block. */
for (b = 0; b < n_basic_blocks; b++)
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;
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. */
/* ??? 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
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)))
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++)
{
for (b = 0; b < n_basic_blocks; b++)
{
- for (insn = basic_block_head[b]; ; insn = next)
+ for (insn = BLOCK_HEAD (b); ; insn = next)
next = NEXT_INSN (insn);
if (GET_CODE (insn) != INSN)
{
next = NEXT_INSN (insn);
if (GET_CODE (insn) != INSN)
{
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
set = single_set (insn);
if (set && rtx_equal_p (SET_SRC (set), SET_DEST (set)))
{
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
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;
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;
- if (insn == basic_block_end[b])
+ if (insn == BLOCK_END (b))
projects / gcc.git / commitdiff