/* Control flow graph building code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
\f
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "tree.h"
#include "rtl.h"
#include "hard-reg-set.h"
#include "except.h"
#include "toplev.h"
#include "timevar.h"
-#include "obstack.h"
static int count_basic_blocks PARAMS ((rtx));
static void find_basic_blocks_1 PARAMS ((rtx));
static void make_eh_edge PARAMS ((sbitmap *, basic_block, rtx));
static void find_bb_boundaries PARAMS ((basic_block));
static void compute_outgoing_frequencies PARAMS ((basic_block));
-static bool inside_basic_block_p PARAMS ((rtx));
-static bool control_flow_insn_p PARAMS ((rtx));
\f
/* Return true if insn is something that should be contained inside basic
block. */
-static bool
+bool
inside_basic_block_p (insn)
rtx insn;
{
/* Return true if INSN may cause control flow transfer, so it should be last in
the basic block. */
-static bool
+bool
control_flow_insn_p (insn)
rtx insn;
{
for (insn = f; insn; insn = NEXT_INSN (insn))
{
- /* Code labels and barriers causes curent basic block to be
+ /* Code labels and barriers causes current basic block to be
terminated at previous real insn. */
if ((GET_CODE (insn) == CODE_LABEL || GET_CODE (insn) == BARRIER)
&& saw_insn)
/* Heavy use of computed goto in machine-generated code can lead to
nearly fully-connected CFGs. In that case we spend a significant
amount of time searching the edge lists for duplicates. */
- if (forced_labels || label_value_list)
+ if (forced_labels || label_value_list || cfun->max_jumptable_ents > 100)
{
edge_cache = sbitmap_vector_alloc (last_basic_block, last_basic_block);
sbitmap_vector_zero (edge_cache, last_basic_block);
enum rtx_code code;
int force_fallthru = 0;
- if (GET_CODE (bb->head) == CODE_LABEL && LABEL_ALTERNATE_NAME (bb->head))
+ if (GET_CODE (bb->head) == CODE_LABEL && LABEL_ALT_ENTRY_P (bb->head))
cached_make_edge (NULL, ENTRY_BLOCK_PTR, bb, 0);
/* Examine the last instruction of the block, and discover the
else if (find_reg_note (insn, REG_NON_LOCAL_GOTO, NULL_RTX))
;
- /* ??? Recognize a tablejump and do the right thing. */
- else if ((tmp = JUMP_LABEL (insn)) != NULL_RTX
- && (tmp = NEXT_INSN (tmp)) != NULL_RTX
- && GET_CODE (tmp) == JUMP_INSN
- && (GET_CODE (PATTERN (tmp)) == ADDR_VEC
- || GET_CODE (PATTERN (tmp)) == ADDR_DIFF_VEC))
+ /* Recognize a tablejump and do the right thing. */
+ else if (tablejump_p (insn, NULL, &tmp))
{
rtvec vec;
int j;
worry about EH edges, since we wouldn't have created the sibling call
in the first place. */
if (code == CALL_INSN && SIBLING_CALL_P (insn))
- cached_make_edge (edge_cache, bb, EXIT_BLOCK_PTR,
- EDGE_ABNORMAL | EDGE_ABNORMAL_CALL);
+ cached_make_edge (edge_cache, bb, EXIT_BLOCK_PTR, EDGE_SIBCALL);
/* If this is a CALL_INSN, then mark it as reaching the active EH
handler for this CALL_INSN. If we're handling non-call
}
/* Find out if we can drop through to the next block. */
- insn = next_nonnote_insn (insn);
+ insn = NEXT_INSN (insn);
+ while (insn
+ && GET_CODE (insn) == NOTE
+ && NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK)
+ insn = NEXT_INSN (insn);
+
if (!insn || (bb->next_bb == EXIT_BLOCK_PTR && force_fallthru))
cached_make_edge (edge_cache, bb, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
else if (bb->next_bb != EXIT_BLOCK_PTR)
{
- rtx tmp = bb->next_bb->head;
- if (GET_CODE (tmp) == NOTE)
- tmp = next_nonnote_insn (tmp);
- if (force_fallthru || insn == tmp)
+ if (force_fallthru || insn == bb->next_bb->head)
cached_make_edge (edge_cache, bb, bb->next_bb, EDGE_FALLTHRU);
}
}
find_basic_blocks_1 (f);
- /* Record the block to which an insn belongs. */
- /* ??? This should be done another way, by which (perhaps) a label is
- tagged directly with the basic block that it starts. It is used for
- more than that currently, but IMO that is the only valid use. */
-
- compute_bb_for_insn ();
-
/* Discover the edges of our cfg. */
make_edges (label_value_list, ENTRY_BLOCK_PTR->next_bb, EXIT_BLOCK_PTR->prev_bb, 0);
bb = fallthru->dest;
remove_edge (fallthru);
flow_transfer_insn = NULL_RTX;
- if (LABEL_ALTERNATE_NAME (insn))
+ if (LABEL_ALT_ENTRY_P (insn))
make_edge (ENTRY_BLOCK_PTR, bb, 0);
}
{
bb->count = 0;
bb->frequency = 0;
- for (e = bb->pred; e; e=e->pred_next)
+ for (e = bb->pred; e; e = e->pred_next)
{
bb->count += e->count;
bb->frequency += EDGE_FREQUENCY (e);
{
b->count = 0;
b->frequency = 0;
- for (e = b->pred; e; e=e->pred_next)
+ for (e = b->pred; e; e = e->pred_next)
{
b->count += e->count;
b->frequency += EDGE_FREQUENCY (e);