/* Data flow analysis for GNU compiler.
- Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ 1999, 2000, 2001 Free Software Foundation, Inc.
This file is part of GNU CC.
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
/* This file contains the data flow analysis pass of the compiler. It
computes data flow information which tells combine_instructions
which insns to consider combining and controls register allocation.
pseudo register. The bit is 1 if the register is live at the
beginning of the basic block.
- Two types of elements can be added to an insn's REG_NOTES.
+ Two types of elements can be added to an insn's REG_NOTES.
A REG_DEAD note is added to an insn's REG_NOTES for any register
that meets both of two conditions: The value in the register is not
needed in subsequent insns and the insn does not replace the value in
life_analysis sets current_function_sp_is_unchanging if the function
doesn't modify the stack pointer. */
-/* TODO:
+/* TODO:
Split out from life_analysis:
- local property discovery (bb->local_live, bb->local_set)
#include "except.h"
#include "toplev.h"
#include "recog.h"
-#include "insn-flags.h"
#include "expr.h"
#include "ssa.h"
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
-
/* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
the stack pointer does not matter. The value is tested only in
functions that have frame pointers.
#define HAVE_sibcall_epilogue 0
#endif
-/* The contents of the current function definition are allocated
- in this obstack, and all are freed at the end of the function.
- For top-level functions, this is temporary_obstack.
- Separate obstacks are made for nested functions. */
+#ifndef LOCAL_REGNO
+#define LOCAL_REGNO(REGNO) 0
+#endif
+#ifndef EPILOGUE_USES
+#define EPILOGUE_USES(REGNO) 0
+#endif
-extern struct obstack *function_obstack;
+#ifdef HAVE_conditional_execution
+#ifndef REVERSE_CONDEXEC_PREDICATES_P
+#define REVERSE_CONDEXEC_PREDICATES_P(x, y) ((x) == reverse_condition (y))
+#endif
+#endif
+
+/* The obstack on which the flow graph components are allocated. */
+
+struct obstack flow_obstack;
+static char *flow_firstobj;
/* Number of basic blocks in the current function. */
NULL, /* pred */
NULL, /* succ */
NULL, /* local_set */
+ NULL, /* cond_local_set */
NULL, /* global_live_at_start */
NULL, /* global_live_at_end */
NULL, /* aux */
ENTRY_BLOCK, /* index */
0, /* loop_depth */
- -1, -1, /* eh_beg, eh_end */
- 0 /* count */
+ 0, /* count */
+ 0 /* frequency */
},
{
NULL, /* head */
NULL, /* pred */
NULL, /* succ */
NULL, /* local_set */
+ NULL, /* cond_local_set */
NULL, /* global_live_at_start */
NULL, /* global_live_at_end */
NULL, /* aux */
EXIT_BLOCK, /* index */
0, /* loop_depth */
- -1, -1, /* eh_beg, eh_end */
- 0 /* count */
+ 0, /* count */
+ 0 /* frequency */
}
};
are another pair, etc. */
rtx regs_may_share;
+/* Callback that determines if it's ok for a function to have no
+ noreturn attribute. */
+int (*lang_missing_noreturn_ok_p) PARAMS ((tree));
+
/* Set of registers that may be eliminable. These are handled specially
in updating regs_ever_live. */
varray_type basic_block_for_insn;
/* The labels mentioned in non-jump rtl. Valid during find_basic_blocks. */
-/* ??? Should probably be using LABEL_NUSES instead. It would take a
+/* ??? Should probably be using LABEL_NUSES instead. It would take a
bit of surgery to be able to use or co-opt the routines in jump. */
static rtx label_value_list;
/* Holds information for tracking conditional register life information. */
struct reg_cond_life_info
{
- /* An EXPR_LIST of conditions under which a register is dead. */
+ /* A boolean expression of conditions under which a register is dead. */
rtx condition;
+ /* Conditions under which a register is dead at the basic block end. */
+ rtx orig_condition;
+
+ /* A boolean expression of conditions under which a register has been
+ stored into. */
+ rtx stores;
/* ??? Could store mask of bytes that are dead, so that we could finally
track lifetimes of multi-word registers accessed via subregs. */
elimination. */
rtx mem_set_list;
- /* If non-null, record the set of registers set in the basic block. */
+ /* If non-null, record the set of registers set unconditionally in the
+ basic block. */
regset local_set;
+ /* If non-null, record the set of registers set conditionally in the
+ basic block. */
+ regset cond_local_set;
+
#ifdef HAVE_conditional_execution
/* Indexed by register number, holds a reg_cond_life_info for each
register that is not unconditionally live or dead. */
regset reg_cond_reg;
#endif
+ /* The length of mem_set_list. */
+ int mem_set_list_len;
+
/* Non-zero if the value of CC0 is live. */
int cc0_live;
int flags;
};
-/* Store the data structures necessary for depth-first search. */
+/* Maximum length of pbi->mem_set_list before we start dropping
+ new elements on the floor. */
+#define MAX_MEM_SET_LIST_LEN 100
+
+/* Store the data structures necessary for depth-first search. */
struct depth_first_search_dsS {
/* stack for backtracking during the algorithm */
basic_block *stack;
/* number of edges in the stack. That is, positions 0, ..., sp-1
- have edges. */
+ have edges. */
unsigned int sp;
/* record of basic blocks already seen by depth-first search */
};
typedef struct depth_first_search_dsS *depth_first_search_ds;
+/* Have print_rtl_and_abort give the same information that fancy_abort
+ does. */
+#define print_rtl_and_abort() \
+ print_rtl_and_abort_fcn (__FILE__, __LINE__, __FUNCTION__)
+
/* Forward declarations */
static int count_basic_blocks PARAMS ((rtx));
static void find_basic_blocks_1 PARAMS ((rtx));
static rtx find_label_refs PARAMS ((rtx, rtx));
-static void clear_edges PARAMS ((void));
static void make_edges PARAMS ((rtx));
static void make_label_edge PARAMS ((sbitmap *, basic_block,
rtx, int));
-static void make_eh_edge PARAMS ((sbitmap *, eh_nesting_info *,
- basic_block, rtx, int));
-static void mark_critical_edges PARAMS ((void));
-static void move_stray_eh_region_notes PARAMS ((void));
-static void record_active_eh_regions PARAMS ((rtx));
+static void make_eh_edge PARAMS ((sbitmap *, basic_block, rtx));
static void commit_one_edge_insertion PARAMS ((edge));
static void delete_unreachable_blocks PARAMS ((void));
-static void delete_eh_regions PARAMS ((void));
static int can_delete_note_p PARAMS ((rtx));
static void expunge_block PARAMS ((basic_block));
static int can_delete_label_p PARAMS ((rtx));
static int merge_blocks_move_successor_nojumps PARAMS ((basic_block,
basic_block));
static int merge_blocks PARAMS ((edge,basic_block,basic_block));
-static void try_merge_blocks PARAMS ((void));
+static bool try_optimize_cfg PARAMS ((void));
+static bool forwarder_block_p PARAMS ((basic_block));
+static bool can_fallthru PARAMS ((basic_block, basic_block));
+static bool try_redirect_by_replacing_jump PARAMS ((edge, basic_block));
+static bool try_simplify_condjump PARAMS ((basic_block));
+static bool try_forward_edges PARAMS ((basic_block));
static void tidy_fallthru_edges PARAMS ((void));
static int verify_wide_reg_1 PARAMS ((rtx *, void *));
static void verify_wide_reg PARAMS ((int, rtx, rtx));
static void verify_local_live_at_start PARAMS ((regset, basic_block));
-static int set_noop_p PARAMS ((rtx));
static int noop_move_p PARAMS ((rtx));
static void delete_noop_moves PARAMS ((rtx));
static void notice_stack_pointer_modification_1 PARAMS ((rtx, rtx, void *));
static int flush_reg_cond_reg_1 PARAMS ((splay_tree_node, void *));
static void flush_reg_cond_reg PARAMS ((struct propagate_block_info *,
int));
-static rtx ior_reg_cond PARAMS ((rtx, rtx));
+static rtx elim_reg_cond PARAMS ((rtx, unsigned int));
+static rtx ior_reg_cond PARAMS ((rtx, rtx, int));
static rtx not_reg_cond PARAMS ((rtx));
-static rtx nand_reg_cond PARAMS ((rtx, rtx));
+static rtx and_reg_cond PARAMS ((rtx, rtx, int));
#endif
#ifdef AUTO_INC_DEC
static void attempt_auto_inc PARAMS ((struct propagate_block_info *,
rtx, rtx, rtx));
void dump_flow_info PARAMS ((FILE *));
void debug_flow_info PARAMS ((void));
-static void dump_edge_info PARAMS ((FILE *, edge, int));
+static void print_rtl_and_abort_fcn PARAMS ((const char *, int,
+ const char *))
+ ATTRIBUTE_NORETURN;
static void invalidate_mems_from_autoinc PARAMS ((struct propagate_block_info *,
rtx));
+static void invalidate_mems_from_set PARAMS ((struct propagate_block_info *,
+ rtx));
static void remove_fake_successors PARAMS ((basic_block));
-static void flow_nodes_print PARAMS ((const char *, const sbitmap, FILE *));
-static void flow_exits_print PARAMS ((const char *, const edge *, int, FILE *));
-static void flow_loops_cfg_dump PARAMS ((const struct loops *, FILE *));
-static int flow_loop_nested_p PARAMS ((struct loop *, struct loop *));
-static int flow_loop_exits_find PARAMS ((const sbitmap, edge **));
+static void flow_nodes_print PARAMS ((const char *, const sbitmap,
+ FILE *));
+static void flow_edge_list_print PARAMS ((const char *, const edge *,
+ int, FILE *));
+static void flow_loops_cfg_dump PARAMS ((const struct loops *,
+ FILE *));
+static int flow_loop_nested_p PARAMS ((struct loop *,
+ struct loop *));
+static int flow_loop_entry_edges_find PARAMS ((basic_block, const sbitmap,
+ edge **));
+static int flow_loop_exit_edges_find PARAMS ((const sbitmap, edge **));
static int flow_loop_nodes_find PARAMS ((basic_block, basic_block, sbitmap));
-static int flow_depth_first_order_compute PARAMS ((int *, int *));
static void flow_dfs_compute_reverse_init
PARAMS ((depth_first_search_ds));
static void flow_dfs_compute_reverse_add_bb
PARAMS ((depth_first_search_ds));
static void flow_dfs_compute_reverse_finish
PARAMS ((depth_first_search_ds));
-static basic_block flow_loop_pre_header_find PARAMS ((basic_block, const sbitmap *));
+static void flow_loop_pre_header_scan PARAMS ((struct loop *));
+static basic_block flow_loop_pre_header_find PARAMS ((basic_block,
+ const sbitmap *));
static void flow_loop_tree_node_add PARAMS ((struct loop *, struct loop *));
static void flow_loops_tree_build PARAMS ((struct loops *));
static int flow_loop_level_compute PARAMS ((struct loop *, int));
static int flow_loops_level_compute PARAMS ((struct loops *));
+static void allocate_bb_life_data PARAMS ((void));
+static void find_sub_basic_blocks PARAMS ((basic_block));
+static bool redirect_edge_and_branch PARAMS ((edge, basic_block));
+static rtx block_label PARAMS ((basic_block));
\f
/* Find basic blocks of the current function.
F is the first insn of the function and NREGS the number of register
clear_edges ();
- /* Clear bb->aux on all extant basic blocks. We'll use this as a
+ /* Clear bb->aux on all extant basic blocks. We'll use this as a
tag for reuse during create_basic_block, just in case some pass
copies around basic block notes improperly. */
for (i = 0; i < n_basic_blocks; ++i)
by find_basic_blocks_1, since we want to keep the structure pointers
stable across calls to find_basic_blocks. */
/* ??? This whole issue would be much simpler if we called find_basic_blocks
- exactly once, and thereafter we don't have a single long chain of
+ exactly once, and thereafter we don't have a single long chain of
instructions at all until close to the end of compilation when we
actually lay them out. */
VARRAY_BB_INIT (basic_block_info, n_basic_blocks, "basic_block_info");
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
compute_bb_for_insn (max_uid);
/* Discover the edges of our cfg. */
- record_active_eh_regions (f);
make_edges (label_value_list);
/* Do very simple cleanup now, for the benefit of code that runs between
#endif
}
+void
+check_function_return_warnings ()
+{
+ if (warn_missing_noreturn
+ && !TREE_THIS_VOLATILE (cfun->decl)
+ && EXIT_BLOCK_PTR->pred == NULL
+ && (lang_missing_noreturn_ok_p
+ && !lang_missing_noreturn_ok_p (cfun->decl)))
+ warning ("function might be possible candidate for attribute `noreturn'");
+
+ /* If we have a path to EXIT, then we do return. */
+ if (TREE_THIS_VOLATILE (cfun->decl)
+ && EXIT_BLOCK_PTR->pred != NULL)
+ warning ("`noreturn' function does return");
+
+ /* If the clobber_return_insn appears in some basic block, then we
+ do reach the end without returning a value. */
+ else if (warn_return_type
+ && cfun->x_clobber_return_insn != NULL
+ && EXIT_BLOCK_PTR->pred != NULL)
+ {
+ int max_uid = get_max_uid ();
+
+ /* If clobber_return_insn was excised by jump1, then renumber_insns
+ can make max_uid smaller than the number still recorded in our rtx.
+ That's fine, since this is a quick way of verifying that the insn
+ is no longer in the chain. */
+ if (INSN_UID (cfun->x_clobber_return_insn) < max_uid)
+ {
+ /* Recompute insn->block mapping, since the initial mapping is
+ set before we delete unreachable blocks. */
+ compute_bb_for_insn (max_uid);
+
+ if (BLOCK_FOR_INSN (cfun->x_clobber_return_insn) != NULL)
+ warning ("control reaches end of non-void function");
+ }
+ }
+}
+
/* Count the basic blocks of the function. */
-static int
+static int
count_basic_blocks (f)
rtx f;
{
register rtx insn;
register RTX_CODE prev_code;
register int count = 0;
- int eh_region = 0;
- int call_had_abnormal_edge = 0;
+ int saw_abnormal_edge = 0;
prev_code = JUMP_INSN;
for (insn = f; insn; insn = NEXT_INSN (insn))
{
- register RTX_CODE code = GET_CODE (insn);
+ enum rtx_code code = GET_CODE (insn);
if (code == CODE_LABEL
|| (GET_RTX_CLASS (code) == 'i'
&& (prev_code == JUMP_INSN
|| prev_code == BARRIER
- || (prev_code == CALL_INSN && call_had_abnormal_edge))))
- count++;
+ || saw_abnormal_edge)))
+ {
+ saw_abnormal_edge = 0;
+ count++;
+ }
- /* Record whether this call created an edge. */
+ /* Record whether this insn created an edge. */
if (code == CALL_INSN)
{
- rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
- int region = (note ? INTVAL (XEXP (note, 0)) : 1);
-
- call_had_abnormal_edge = 0;
-
- /* If there is an EH region or rethrow, we have an edge. */
- if ((eh_region && region > 0)
- || find_reg_note (insn, REG_EH_RETHROW, NULL_RTX))
- call_had_abnormal_edge = 1;
- else if (nonlocal_goto_handler_labels && region >= 0)
- /* If there is a nonlocal goto label and the specified
- region number isn't -1, we have an edge. (0 means
- no throw, but might have a nonlocal goto). */
- call_had_abnormal_edge = 1;
+ rtx note;
+
+ /* If there is a nonlocal goto label and the specified
+ region number isn't -1, we have an edge. */
+ if (nonlocal_goto_handler_labels
+ && ((note = find_reg_note (insn, REG_EH_REGION, NULL_RTX)) == 0
+ || INTVAL (XEXP (note, 0)) >= 0))
+ saw_abnormal_edge = 1;
+
+ else if (can_throw_internal (insn))
+ saw_abnormal_edge = 1;
}
+ else if (flag_non_call_exceptions
+ && code == INSN
+ && can_throw_internal (insn))
+ saw_abnormal_edge = 1;
if (code != NOTE)
prev_code = code;
- else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
- ++eh_region;
- else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END)
- --eh_region;
}
/* The rest of the compiler works a bit smoother when we don't have to
rtx insn;
for (insn = f; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn) && GET_CODE (insn) != JUMP_INSN)
{
rtx note;
/* Make a list of all labels referred to other than by jumps
- (which just don't have the REG_LABEL notes).
+ (which just don't have the REG_LABEL notes).
Make a special exception for labels followed by an ADDR*VEC,
- as this would be a part of the tablejump setup code.
+ as this would be a part of the tablejump setup code.
+
+ Make a special exception to registers loaded with label
+ values just before jump insns that use them. */
- Make a special exception for the eh_return_stub_label, which
- we know isn't part of any otherwise visible control flow. */
-
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
if (REG_NOTE_KIND (note) == REG_LABEL)
{
rtx lab = XEXP (note, 0), next;
- if (lab == eh_return_stub_label)
- ;
- else if ((next = next_nonnote_insn (lab)) != NULL
+ if ((next = next_nonnote_insn (lab)) != NULL
&& GET_CODE (next) == JUMP_INSN
&& (GET_CODE (PATTERN (next)) == ADDR_VEC
|| GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC))
;
else if (GET_CODE (lab) == NOTE)
;
+ else if (GET_CODE (NEXT_INSN (insn)) == JUMP_INSN
+ && find_reg_note (NEXT_INSN (insn), REG_LABEL, lab))
+ ;
else
lvl = alloc_EXPR_LIST (0, XEXP (note, 0), lvl);
}
return lvl;
}
+/* Assume that someone emitted code with control flow instructions to the
+ basic block. Update the data structure. */
+static void
+find_sub_basic_blocks (bb)
+ basic_block bb;
+{
+ rtx first_insn = bb->head, insn;
+ rtx end = bb->end;
+ edge succ_list = bb->succ;
+ rtx jump_insn = NULL_RTX;
+ int created = 0;
+ int barrier = 0;
+ edge falltru = 0;
+ basic_block first_bb = bb, last_bb;
+ int i;
+
+ if (GET_CODE (first_insn) == LABEL_REF)
+ first_insn = NEXT_INSN (first_insn);
+ first_insn = NEXT_INSN (first_insn);
+ bb->succ = NULL;
+
+ insn = first_insn;
+ /* Scan insn chain and try to find new basic block boundaries. */
+ while (insn != end)
+ {
+ enum rtx_code code = GET_CODE (insn);
+ switch (code)
+ {
+ case JUMP_INSN:
+ /* We need some special care for those expressions. */
+ if (GET_CODE (PATTERN (insn)) == ADDR_VEC
+ || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
+ abort();
+ jump_insn = insn;
+ break;
+ case BARRIER:
+ if (!jump_insn)
+ abort ();
+ barrier = 1;
+ break;
+ /* On code label, split current basic block. */
+ case CODE_LABEL:
+ falltru = split_block (bb, PREV_INSN (insn));
+ if (jump_insn)
+ bb->end = jump_insn;
+ bb = falltru->dest;
+ if (barrier)
+ remove_edge (falltru);
+ barrier = 0;
+ jump_insn = 0;
+ created = 1;
+ if (LABEL_ALTERNATE_NAME (insn))
+ make_edge (NULL, ENTRY_BLOCK_PTR, bb, 0);
+ break;
+ case INSN:
+ /* In case we've previously split insn on the JUMP_INSN, move the
+ block header to proper place. */
+ if (jump_insn)
+ {
+ falltru = split_block (bb, PREV_INSN (insn));
+ bb->end = jump_insn;
+ bb = falltru->dest;
+ if (barrier)
+ abort ();
+ jump_insn = 0;
+ }
+ default:
+ break;
+ }
+ insn = NEXT_INSN (insn);
+ }
+ /* Last basic block must end in the original BB end. */
+ if (jump_insn)
+ abort ();
+
+ /* Wire in the original edges for last basic block. */
+ if (created)
+ {
+ bb->succ = succ_list;
+ while (succ_list)
+ succ_list->src = bb, succ_list = succ_list->succ_next;
+ }
+ else
+ bb->succ = succ_list;
+
+ /* Now re-scan and wire in all edges. This expect simple (conditional)
+ jumps at the end of each new basic blocks. */
+ last_bb = bb;
+ for (i = first_bb->index; i < last_bb->index; i++)
+ {
+ bb = BASIC_BLOCK (i);
+ if (GET_CODE (bb->end) == JUMP_INSN)
+ {
+ mark_jump_label (PATTERN (bb->end), bb->end, 0, 0);
+ make_label_edge (NULL, bb, JUMP_LABEL (bb->end), 0);
+ }
+ insn = NEXT_INSN (insn);
+ }
+}
+
/* Find all basic blocks of the function whose first insn is F.
Collect and return a list of labels whose addresses are taken. This
register rtx insn, next;
int i = 0;
rtx bb_note = NULL_RTX;
- rtx eh_list = NULL_RTX;
rtx lvl = NULL_RTX;
rtx trll = NULL_RTX;
rtx head = NULL_RTX;
rtx end = NULL_RTX;
-
+
/* We process the instructions in a slightly different way than we did
previously. This is so that we see a NOTE_BASIC_BLOCK after we have
closed out the previous block, so that it gets attached at the proper
{
int kind = NOTE_LINE_NUMBER (insn);
- /* Keep a LIFO list of the currently active exception notes. */
- if (kind == NOTE_INSN_EH_REGION_BEG)
- eh_list = alloc_INSN_LIST (insn, eh_list);
- else if (kind == NOTE_INSN_EH_REGION_END)
- {
- rtx t = eh_list;
-
- eh_list = XEXP (eh_list, 1);
- free_INSN_LIST_node (t);
- }
-
- /* Look for basic block notes with which to keep the
+ /* Look for basic block notes with which to keep the
basic_block_info pointers stable. Unthread the note now;
we'll put it back at the right place in create_basic_block.
Or not at all if we've already found a note in this block. */
- else if (kind == NOTE_INSN_BASIC_BLOCK)
+ if (kind == NOTE_INSN_BASIC_BLOCK)
{
if (bb_note == NULL_RTX)
bb_note = insn;
}
case CODE_LABEL:
- /* A basic block starts at a label. If we've closed one off due
+ /* A basic block starts at a label. If we've closed one off due
to a barrier or some such, no need to do it again. */
if (head != NULL_RTX)
{
head = insn;
else
{
- /* ??? Make a special check for table jumps. The way this
+ /* ??? Make a special check for table jumps. The way this
happens is truly and amazingly gross. We are about to
create a basic block that contains just a code label and
an addr*vec jump insn. Worse, an addr_diff_vec creates
its own natural loop.
Prevent this bit of brain damage, pasting things together
- correctly in make_edges.
+ correctly in make_edges.
The correct solution involves emitting the table directly
on the tablejump instruction as a note, or JUMP_LABEL. */
{
/* Record whether this call created an edge. */
rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
- int region = (note ? INTVAL (XEXP (note, 0)) : 1);
- int call_has_abnormal_edge = 0;
+ int region = (note ? INTVAL (XEXP (note, 0)) : 0);
if (GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
{
trll = alloc_EXPR_LIST (0, XEXP (PATTERN (insn), 3), trll);
}
- /* If there is an EH region or rethrow, we have an edge. */
- if ((eh_list && region > 0)
- || find_reg_note (insn, REG_EH_RETHROW, NULL_RTX))
- call_has_abnormal_edge = 1;
- else if (nonlocal_goto_handler_labels && region >= 0)
- /* If there is a nonlocal goto label and the specified
- region number isn't -1, we have an edge. (0 means
- no throw, but might have a nonlocal goto). */
- call_has_abnormal_edge = 1;
-
/* A basic block ends at a call that can either throw or
do a non-local goto. */
- if (call_has_abnormal_edge)
+ if ((nonlocal_goto_handler_labels && region >= 0)
+ || can_throw_internal (insn))
{
new_bb_inclusive:
if (head == NULL_RTX)
bb_note = NULL_RTX;
break;
}
- }
- /* FALLTHRU */
+ }
+ /* Fall through. */
- default:
- if (GET_RTX_CLASS (code) == 'i')
- {
- if (head == NULL_RTX)
- head = insn;
- end = insn;
- }
+ case INSN:
+ /* Non-call exceptions generate new blocks just like calls. */
+ if (flag_non_call_exceptions && can_throw_internal (insn))
+ goto new_bb_inclusive;
+
+ if (head == NULL_RTX)
+ head = insn;
+ end = insn;
break;
+
+ default:
+ abort ();
}
- if (GET_RTX_CLASS (code) == 'i')
+ if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
{
rtx note;
- /* Make a list of all labels referred to other than by jumps
- (which just don't have the REG_LABEL notes).
+ /* Make a list of all labels referred to other than by jumps.
Make a special exception for labels followed by an ADDR*VEC,
- as this would be a part of the tablejump setup code.
+ as this would be a part of the tablejump setup code.
+
+ Make a special exception to registers loaded with label
+ values just before jump insns that use them. */
- Make a special exception for the eh_return_stub_label, which
- we know isn't part of any otherwise visible control flow. */
-
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
if (REG_NOTE_KIND (note) == REG_LABEL)
{
rtx lab = XEXP (note, 0), next;
- if (lab == eh_return_stub_label)
- ;
- else if ((next = next_nonnote_insn (lab)) != NULL
+ if ((next = next_nonnote_insn (lab)) != NULL
&& GET_CODE (next) == JUMP_INSN
&& (GET_CODE (PATTERN (next)) == ADDR_VEC
|| GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC))
;
else if (GET_CODE (lab) == NOTE)
;
+ else if (GET_CODE (NEXT_INSN (insn)) == JUMP_INSN
+ && find_reg_note (NEXT_INSN (insn), REG_LABEL, lab))
+ ;
else
lvl = alloc_EXPR_LIST (0, XEXP (note, 0), lvl);
}
/* Tidy the CFG by deleting unreachable code and whatnot. */
void
-cleanup_cfg (f)
- rtx f;
+cleanup_cfg ()
{
delete_unreachable_blocks ();
- move_stray_eh_region_notes ();
- record_active_eh_regions (f);
- try_merge_blocks ();
+ if (try_optimize_cfg ())
+ delete_unreachable_blocks ();
mark_critical_edges ();
/* Kill the data we won't maintain. */
the same lifetime by allocating it off the function obstack
rather than using malloc. */
- bb = (basic_block) obstack_alloc (function_obstack, sizeof (*bb));
+ bb = (basic_block) obstack_alloc (&flow_obstack, sizeof (*bb));
memset (bb, 0, sizeof (*bb));
if (GET_CODE (head) == CODE_LABEL)
/* Free the memory associated with the edge structures. */
-static void
+void
clear_edges ()
{
int i;
{
basic_block bb = BASIC_BLOCK (i);
- for (e = bb->succ; e ; e = n)
+ for (e = bb->succ; e; e = n)
{
n = e->succ_next;
free (e);
bb->pred = 0;
}
- for (e = ENTRY_BLOCK_PTR->succ; e ; e = n)
+ for (e = ENTRY_BLOCK_PTR->succ; e; e = n)
{
n = e->succ_next;
free (e);
NONLOCAL_LABEL_LIST is a list of non-local labels in the function. Blocks
that are otherwise unreachable may be reachable with a non-local goto.
- BB_EH_END is an array indexed by basic block number in which we record
+ BB_EH_END is an array indexed by basic block number in which we record
the list of exception regions active at the end of the basic block. */
static void
rtx label_value_list;
{
int i;
- eh_nesting_info *eh_nest_info = init_eh_nesting_info ();
sbitmap *edge_cache = NULL;
/* Assume no computed jump; revise as we create edges. */
enum rtx_code code;
int force_fallthru = 0;
+ if (GET_CODE (bb->head) == CODE_LABEL
+ && LABEL_ALTERNATE_NAME (bb->head))
+ make_edge (NULL, ENTRY_BLOCK_PTR, bb, 0);
+
/* Examine the last instruction of the block, and discover the
ways we can leave the block. */
{
rtx tmp;
+ /* Recognize exception handling placeholders. */
+ if (GET_CODE (PATTERN (insn)) == RESX)
+ make_eh_edge (edge_cache, bb, insn);
+
+ /* Recognize a non-local goto as a branch outside the
+ current function. */
+ else if (find_reg_note (insn, REG_NON_LOCAL_GOTO, NULL_RTX))
+ ;
+
/* ??? Recognize a tablejump and do the right thing. */
- 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))
+ 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))
{
rtvec vec;
int j;
for (x = label_value_list; x; x = XEXP (x, 1))
make_label_edge (edge_cache, bb, XEXP (x, 0), EDGE_ABNORMAL);
-
+
for (x = forced_labels; x; x = XEXP (x, 1))
make_label_edge (edge_cache, bb, XEXP (x, 0), EDGE_ABNORMAL);
}
}
}
- /* If this is a sibling call insn, then this is in effect a
+ /* If this is a sibling call insn, then this is in effect a
combined call and return, and so we need an edge to the
exit block. No need to 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))
make_edge (edge_cache, bb, EXIT_BLOCK_PTR,
EDGE_ABNORMAL | EDGE_ABNORMAL_CALL);
- else
/* If this is a CALL_INSN, then mark it as reaching the active EH
- handler for this CALL_INSN. If we're handling asynchronous
+ handler for this CALL_INSN. If we're handling non-call
exceptions then any insn can reach any of the active handlers.
Also mark the CALL_INSN as reaching any nonlocal goto handler. */
- if (code == CALL_INSN || asynchronous_exceptions)
+ else if (code == CALL_INSN || flag_non_call_exceptions)
{
- /* Add any appropriate EH edges. We do this unconditionally
- since there may be a REG_EH_REGION or REG_EH_RETHROW note
- on the call, and this needn't be within an EH region. */
- make_eh_edge (edge_cache, eh_nest_info, bb, insn, bb->eh_end);
-
- /* If we have asynchronous exceptions, do the same for *all*
- exception regions active in the block. */
- if (asynchronous_exceptions
- && bb->eh_beg != bb->eh_end)
- {
- if (bb->eh_beg >= 0)
- make_eh_edge (edge_cache, eh_nest_info, bb,
- NULL_RTX, bb->eh_beg);
-
- for (x = bb->head; x != bb->end; x = NEXT_INSN (x))
- if (GET_CODE (x) == NOTE
- && (NOTE_LINE_NUMBER (x) == NOTE_INSN_EH_REGION_BEG
- || NOTE_LINE_NUMBER (x) == NOTE_INSN_EH_REGION_END))
- {
- int region = NOTE_EH_HANDLER (x);
- make_eh_edge (edge_cache, eh_nest_info, bb,
- NULL_RTX, region);
- }
- }
+ /* Add any appropriate EH edges. */
+ make_eh_edge (edge_cache, bb, insn);
if (code == CALL_INSN && nonlocal_goto_handler_labels)
{
than 0 is guaranteed not to perform a non-local goto. */
rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
if (!note || INTVAL (XEXP (note, 0)) >= 0)
- for (x = nonlocal_goto_handler_labels; x ; x = XEXP (x, 1))
+ for (x = nonlocal_goto_handler_labels; x; x = XEXP (x, 1))
make_label_edge (edge_cache, bb, XEXP (x, 0),
EDGE_ABNORMAL | EDGE_ABNORMAL_CALL);
}
}
- /* We know something about the structure of the function __throw in
- libgcc2.c. It is the only function that ever contains eh_stub
- labels. It modifies its return address so that the last block
- returns to one of the eh_stub labels within it. So we have to
- make additional edges in the flow graph. */
- if (i + 1 == n_basic_blocks && eh_return_stub_label != 0)
- make_label_edge (edge_cache, bb, eh_return_stub_label, EDGE_EH);
-
/* Find out if we can drop through to the next block. */
insn = next_nonnote_insn (insn);
if (!insn || (i + 1 == n_basic_blocks && force_fallthru))
}
}
- free_eh_nesting_info (eh_nest_info);
if (edge_cache)
sbitmap_vector_free (edge_cache);
}
&& dst != EXIT_BLOCK_PTR);
/* Make sure we don't add duplicate edges. */
- if (! use_edge_cache || TEST_BIT (edge_cache[src->index], dst->index))
- for (e = src->succ; e ; e = e->succ_next)
- if (e->dest == dst)
- {
- e->flags |= flags;
- return;
- }
+ switch (use_edge_cache)
+ {
+ default:
+ /* Quick test for non-existance of the edge. */
+ if (! TEST_BIT (edge_cache[src->index], dst->index))
+ break;
+
+ /* The edge exists; early exit if no work to do. */
+ if (flags == 0)
+ return;
+
+ /* FALLTHRU */
+ case 0:
+ for (e = src->succ; e; e = e->succ_next)
+ if (e->dest == dst)
+ {
+ e->flags |= flags;
+ return;
+ }
+ break;
+ }
e = (edge) xcalloc (1, sizeof (*e));
n_edges++;
/* Create the edges generated by INSN in REGION. */
static void
-make_eh_edge (edge_cache, eh_nest_info, src, insn, region)
+make_eh_edge (edge_cache, src, insn)
sbitmap *edge_cache;
- eh_nesting_info *eh_nest_info;
basic_block src;
rtx insn;
- int region;
-{
- handler_info **handler_list;
- int num, is_call;
-
- is_call = (insn && GET_CODE (insn) == CALL_INSN ? EDGE_ABNORMAL_CALL : 0);
- num = reachable_handlers (region, eh_nest_info, insn, &handler_list);
- while (--num >= 0)
- {
- make_label_edge (edge_cache, src, handler_list[num]->handler_label,
- EDGE_ABNORMAL | EDGE_EH | is_call);
- }
-}
-
-/* EH_REGION notes appearing between basic blocks is ambiguous, and even
- dangerous if we intend to move basic blocks around. Move such notes
- into the following block. */
-
-static void
-move_stray_eh_region_notes ()
-{
- int i;
- basic_block b1, b2;
-
- if (n_basic_blocks < 2)
- return;
-
- b2 = BASIC_BLOCK (n_basic_blocks - 1);
- for (i = n_basic_blocks - 2; i >= 0; --i, b2 = b1)
- {
- rtx insn, next, list = NULL_RTX;
-
- b1 = BASIC_BLOCK (i);
- for (insn = NEXT_INSN (b1->end); insn != b2->head; insn = next)
- {
- next = NEXT_INSN (insn);
- if (GET_CODE (insn) == NOTE
- && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG
- || NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
- {
- /* Unlink from the insn chain. */
- NEXT_INSN (PREV_INSN (insn)) = next;
- PREV_INSN (next) = PREV_INSN (insn);
-
- /* Queue it. */
- NEXT_INSN (insn) = list;
- list = insn;
- }
- }
-
- if (list == NULL_RTX)
- continue;
-
- /* Find where to insert these things. */
- insn = b2->head;
- if (GET_CODE (insn) == CODE_LABEL)
- insn = NEXT_INSN (insn);
-
- while (list)
- {
- next = NEXT_INSN (list);
- add_insn_after (list, insn);
- list = next;
- }
- }
-}
-
-/* Recompute eh_beg/eh_end for each basic block. */
-
-static void
-record_active_eh_regions (f)
- rtx f;
{
- rtx insn, eh_list = NULL_RTX;
- int i = 0;
- basic_block bb = BASIC_BLOCK (0);
+ int is_call = (GET_CODE (insn) == CALL_INSN ? EDGE_ABNORMAL_CALL : 0);
+ rtx handlers, i;
- for (insn = f; insn ; insn = NEXT_INSN (insn))
- {
- if (bb->head == insn)
- bb->eh_beg = (eh_list ? NOTE_EH_HANDLER (XEXP (eh_list, 0)) : -1);
+ handlers = reachable_handlers (insn);
- if (GET_CODE (insn) == NOTE)
- {
- int kind = NOTE_LINE_NUMBER (insn);
- if (kind == NOTE_INSN_EH_REGION_BEG)
- eh_list = alloc_INSN_LIST (insn, eh_list);
- else if (kind == NOTE_INSN_EH_REGION_END)
- {
- rtx t = XEXP (eh_list, 1);
- free_INSN_LIST_node (eh_list);
- eh_list = t;
- }
- }
+ for (i = handlers; i; i = XEXP (i, 1))
+ make_label_edge (edge_cache, src, XEXP (i, 0),
+ EDGE_ABNORMAL | EDGE_EH | is_call);
- if (bb->end == insn)
- {
- bb->eh_end = (eh_list ? NOTE_EH_HANDLER (XEXP (eh_list, 0)) : -1);
- i += 1;
- if (i == n_basic_blocks)
- break;
- bb = BASIC_BLOCK (i);
- }
- }
+ free_INSN_LIST_list (&handlers);
}
/* Identify critical edges and set the bits appropriately. */
-static void
+void
mark_critical_edges ()
{
int i, n = n_basic_blocks;
/* (1) Critical edges must have a source with multiple successors. */
if (bb->succ && bb->succ->succ_next)
{
- for (e = bb->succ; e ; e = e->succ_next)
+ for (e = bb->succ; e; e = e->succ_next)
{
/* (2) Critical edges must have a destination with multiple
predecessors. Note that we know there is at least one
}
else
{
- for (e = bb->succ; e ; e = e->succ_next)
+ for (e = bb->succ; e; e = e->succ_next)
e->flags &= ~EDGE_CRITICAL;
}
}
}
\f
+/* Split a block BB after insn INSN creating a new fallthru edge.
+ Return the new edge. Note that to keep other parts of the compiler happy,
+ this function renumbers all the basic blocks so that the new
+ one has a number one greater than the block split. */
+
+edge
+split_block (bb, insn)
+ basic_block bb;
+ rtx insn;
+{
+ basic_block new_bb;
+ edge new_edge;
+ edge e;
+ rtx bb_note;
+ int i, j;
+
+ /* There is no point splitting the block after its end. */
+ if (bb->end == insn)
+ return 0;
+
+ /* Create the new structures. */
+ new_bb = (basic_block) obstack_alloc (&flow_obstack, sizeof (*new_bb));
+ new_edge = (edge) xcalloc (1, sizeof (*new_edge));
+ n_edges++;
+
+ memset (new_bb, 0, sizeof (*new_bb));
+
+ new_bb->head = NEXT_INSN (insn);
+ new_bb->end = bb->end;
+ bb->end = insn;
+
+ new_bb->succ = bb->succ;
+ bb->succ = new_edge;
+ new_bb->pred = new_edge;
+ new_bb->count = bb->count;
+ new_bb->frequency = bb->frequency;
+ new_bb->loop_depth = bb->loop_depth;
+
+ new_edge->src = bb;
+ new_edge->dest = new_bb;
+ new_edge->flags = EDGE_FALLTHRU;
+ new_edge->probability = REG_BR_PROB_BASE;
+ new_edge->count = bb->count;
+
+ /* Redirect the src of the successor edges of bb to point to new_bb. */
+ for (e = new_bb->succ; e; e = e->succ_next)
+ e->src = new_bb;
+
+ /* Place the new block just after the block being split. */
+ VARRAY_GROW (basic_block_info, ++n_basic_blocks);
+
+ /* Some parts of the compiler expect blocks to be number in
+ sequential order so insert the new block immediately after the
+ block being split.. */
+ j = bb->index;
+ for (i = n_basic_blocks - 1; i > j + 1; --i)
+ {
+ basic_block tmp = BASIC_BLOCK (i - 1);
+ BASIC_BLOCK (i) = tmp;
+ tmp->index = i;
+ }
+
+ BASIC_BLOCK (i) = new_bb;
+ new_bb->index = i;
+
+ if (GET_CODE (new_bb->head) == CODE_LABEL)
+ {
+ /* Create the basic block note. */
+ bb_note = emit_note_after (NOTE_INSN_BASIC_BLOCK,
+ new_bb->head);
+ NOTE_BASIC_BLOCK (bb_note) = new_bb;
+ }
+ else
+ {
+ /* Create the basic block note. */
+ bb_note = emit_note_before (NOTE_INSN_BASIC_BLOCK,
+ new_bb->head);
+ NOTE_BASIC_BLOCK (bb_note) = new_bb;
+ new_bb->head = bb_note;
+ }
+
+ update_bb_for_insn (new_bb);
+
+ if (bb->global_live_at_start)
+ {
+ new_bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (&flow_obstack);
+ new_bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (&flow_obstack);
+ COPY_REG_SET (new_bb->global_live_at_end, bb->global_live_at_end);
+
+ /* We now have to calculate which registers are live at the end
+ of the split basic block and at the start of the new basic
+ block. Start with those registers that are known to be live
+ at the end of the original basic block and get
+ propagate_block to determine which registers are live. */
+ COPY_REG_SET (new_bb->global_live_at_start, bb->global_live_at_end);
+ propagate_block (new_bb, new_bb->global_live_at_start, NULL, NULL, 0);
+ COPY_REG_SET (bb->global_live_at_end,
+ new_bb->global_live_at_start);
+ }
+
+ return new_edge;
+}
+
+/* Return label in the head of basic block. Create one if it doesn't exist. */
+static rtx
+block_label (block)
+ basic_block block;
+{
+ if (GET_CODE (block->head) != CODE_LABEL)
+ block->head = emit_label_before (gen_label_rtx (), block->head);
+ return block->head;
+}
+
+/* Return true if the block has no effect and only forwards control flow to
+ its single destination. */
+static bool
+forwarder_block_p (bb)
+ basic_block bb;
+{
+ rtx insn = bb->head;
+ if (bb == EXIT_BLOCK_PTR || bb == ENTRY_BLOCK_PTR
+ || !bb->succ || bb->succ->succ_next)
+ return false;
+
+ while (insn != bb->end)
+ {
+ if (active_insn_p (insn))
+ return false;
+ insn = NEXT_INSN (insn);
+ }
+ return (!active_insn_p (insn)
+ || (GET_CODE (insn) == JUMP_INSN && onlyjump_p (insn)));
+}
+
+/* Return nonzero if we can reach target from src by falling trought. */
+static bool
+can_fallthru (src, target)
+ basic_block src, target;
+{
+ rtx insn = src->end;
+ rtx insn2 = target->head;
+
+ if (!active_insn_p (insn2))
+ insn2 = next_active_insn (insn2);
+ /* ??? Later we may add code to move jump tables offline. */
+ return next_active_insn (insn) == insn2;
+}
+
+/* Attempt to perform edge redirection by replacing possibly complex jump
+ instruction by unconditional jump or removing jump completely.
+ This can apply only if all edges now point to the same block.
+
+ The parameters and return values are equivalent to redirect_edge_and_branch.
+ */
+static bool
+try_redirect_by_replacing_jump (e, target)
+ edge e;
+ basic_block target;
+{
+ basic_block src = e->src;
+ rtx insn = src->end;
+ edge tmp;
+ rtx set;
+ int fallthru = 0;
+ rtx barrier;
+
+ /* Verify that all targets will be TARGET. */
+ for (tmp = src->succ; tmp; tmp = tmp->succ_next)
+ if (tmp->dest != target && tmp != e)
+ break;
+ if (tmp || GET_CODE (insn) != JUMP_INSN)
+ return false;
+
+ /* Avoid removing branch with side effects. */
+ set = single_set (insn);
+ if (!set || side_effects_p (set))
+ return false;
+
+ /* See if we can create the fallthru edge. */
+ if (can_fallthru (src, target))
+ {
+ src->end = PREV_INSN (insn);
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Removing jump %i.\n", INSN_UID (insn));
+ flow_delete_insn (insn);
+ fallthru = 1;
+ insn = src->end;
+ }
+ /* If this already is simplejump, redirect it. */
+ else if (simplejump_p (insn))
+ {
+ if (e->dest == target)
+ return false;
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Redirecting jump %i from %i to %i.\n",
+ INSN_UID (insn), e->dest->index, target->index);
+ redirect_jump (insn, block_label (target), 0);
+ }
+ /* Or replace possibly complicated jump insn by simple jump insn. */
+ else
+ {
+ rtx target_label = block_label (target);
+
+ src->end = PREV_INSN (insn);
+ src->end = emit_jump_insn_after (gen_jump (target_label), src->end);
+ JUMP_LABEL (src->end) = target_label;
+ LABEL_NUSES (target_label)++;
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Replacing insn %i by jump %i\n",
+ INSN_UID (insn), INSN_UID (src->end));
+ flow_delete_insn (insn);
+ insn = src->end;
+ }
+
+ /* Keep only one edge out and set proper flags. */
+ while (src->succ->succ_next)
+ remove_edge (src->succ);
+ e = src->succ;
+ if (fallthru)
+ e->flags = EDGE_FALLTHRU;
+ else
+ e->flags = 0;
+ e->probability = REG_BR_PROB_BASE;
+ e->count = src->count;
+
+ /* Fixup barriers. */
+ barrier = next_nonnote_insn (insn);
+ if (fallthru && GET_CODE (barrier) == BARRIER)
+ flow_delete_insn (barrier);
+ else if (!fallthru && GET_CODE (barrier) != BARRIER)
+ emit_barrier_after (insn);
+
+ /* In case we've zapped an conditional jump, we need to kill the cc0
+ setter too if available. */
+#ifdef HAVE_cc0
+ insn = src->end;
+ if (GET_CODE (insn) == JUMP_INSN)
+ insn = prev_nonnote_insn (insn);
+ if (sets_cc0_p (insn))
+ {
+ if (insn == src->end)
+ src->end = PREV_INSN (insn);
+ flow_delete_insn (insn);
+ }
+#endif
+
+ if (e->dest != target)
+ redirect_edge_succ (e, target);
+ return true;
+}
+
+/* Attempt to change code to redirect edge E to TARGET.
+ Don't do that on expense of adding new instructions or reordering
+ basic blocks.
+
+ Function can be also called with edge destionation equivalent to the
+ TARGET. Then it should try the simplifications and do nothing if
+ none is possible.
+
+ Return true if transformation suceeded. We still return flase in case
+ E already destinated TARGET and we didn't managed to simplify instruction
+ stream. */
+static bool
+redirect_edge_and_branch (e, target)
+ edge e;
+ basic_block target;
+{
+ rtx tmp;
+ rtx old_label = e->dest->head;
+ basic_block src = e->src;
+ rtx insn = src->end;
+
+ if (try_redirect_by_replacing_jump (e, target))
+ return true;
+ /* Do this fast path late, as we want above code to simplify for cases
+ where called on single edge leaving basic block containing nontrivial
+ jump insn. */
+ else if (e->dest == target)
+ return false;
+
+ /* We can only redirect non-fallthru edges of jump insn. */
+ if (e->flags & EDGE_FALLTHRU)
+ return false;
+ if (GET_CODE (insn) != JUMP_INSN)
+ return false;
+
+ /* Recognize a tablejump and adjust all matching cases. */
+ 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))
+ {
+ rtvec vec;
+ int j;
+ rtx new_label = block_label (target);
+
+ if (GET_CODE (PATTERN (tmp)) == ADDR_VEC)
+ vec = XVEC (PATTERN (tmp), 0);
+ else
+ vec = XVEC (PATTERN (tmp), 1);
+
+ for (j = GET_NUM_ELEM (vec) - 1; j >= 0; --j)
+ if (XEXP (RTVEC_ELT (vec, j), 0) == old_label)
+ {
+ RTVEC_ELT (vec, j) = gen_rtx_LABEL_REF (Pmode, new_label);
+ --LABEL_NUSES (old_label);
+ ++LABEL_NUSES (new_label);
+ }
+
+ /* Handle casesi dispatch insns */
+ if ((tmp = single_set (insn)) != NULL
+ && SET_DEST (tmp) == pc_rtx
+ && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
+ && GET_CODE (XEXP (SET_SRC (tmp), 2)) == LABEL_REF
+ && XEXP (XEXP (SET_SRC (tmp), 2), 0) == old_label)
+ {
+ XEXP (SET_SRC (tmp), 2) = gen_rtx_LABEL_REF (VOIDmode,
+ new_label);
+ --LABEL_NUSES (old_label);
+ ++LABEL_NUSES (new_label);
+ }
+ }
+ else
+ {
+ /* ?? We may play the games with moving the named labels from
+ one basic block to the other in case only one computed_jump is
+ available. */
+ if (computed_jump_p (insn))
+ return false;
+
+ /* A return instruction can't be redirected. */
+ if (returnjump_p (insn))
+ return false;
+
+ /* If the insn doesn't go where we think, we're confused. */
+ if (JUMP_LABEL (insn) != old_label)
+ abort ();
+ redirect_jump (insn, block_label (target), 0);
+ }
+
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Edge %i->%i redirected to %i\n",
+ e->src->index, e->dest->index, target->index);
+ if (e->dest != target)
+ {
+ edge s;
+ /* Check whether the edge is already present. */
+ for (s = src->succ; s; s=s->succ_next)
+ if (s->dest == target)
+ break;
+ if (s)
+ {
+ s->flags |= e->flags;
+ s->probability += e->probability;
+ s->count += e->count;
+ remove_edge (e);
+ }
+ else
+ redirect_edge_succ (e, target);
+ }
+ return true;
+}
+
/* Split a (typically critical) edge. Return the new block.
- Abort on abnormal edges.
+ Abort on abnormal edges.
??? The code generally expects to be called on critical edges.
- The case of a block ending in an unconditional jump to a
+ The case of a block ending in an unconditional jump to a
block with multiple predecessors is not handled optimally. */
basic_block
edge edge_out;
rtx bb_note;
int i, j;
-
+
/* Abnormal edges cannot be split. */
if ((edge_in->flags & EDGE_ABNORMAL) != 0)
abort ();
old_pred = edge_in->src;
old_succ = edge_in->dest;
- /* Remove the existing edge from the destination's pred list. */
- {
- edge *pp;
- for (pp = &old_succ->pred; *pp != edge_in; pp = &(*pp)->pred_next)
- continue;
- *pp = edge_in->pred_next;
- edge_in->pred_next = NULL;
- }
-
/* Create the new structures. */
- bb = (basic_block) obstack_alloc (function_obstack, sizeof (*bb));
+ bb = (basic_block) obstack_alloc (&flow_obstack, sizeof (*bb));
edge_out = (edge) xcalloc (1, sizeof (*edge_out));
n_edges++;
/* ??? This info is likely going to be out of date very soon. */
if (old_succ->global_live_at_start)
{
- bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (function_obstack);
- bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (function_obstack);
+ bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (&flow_obstack);
+ bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (&flow_obstack);
COPY_REG_SET (bb->global_live_at_start, old_succ->global_live_at_start);
COPY_REG_SET (bb->global_live_at_end, old_succ->global_live_at_start);
}
/* Wire them up. */
- bb->pred = edge_in;
bb->succ = edge_out;
bb->count = edge_in->count;
+ bb->frequency = (edge_in->probability * edge_in->src->frequency
+ / REG_BR_PROB_BASE);
- edge_in->dest = bb;
edge_in->flags &= ~EDGE_CRITICAL;
edge_out->pred_next = old_succ->pred;
/* Tricky case -- if there existed a fallthru into the successor
(and we're not it) we must add a new unconditional jump around
- the new block we're actually interested in.
+ the new block we're actually interested in.
Further, if that edge is critical, this means a second new basic
block must be created to hold it. In order to simplify correct
if ((edge_in->flags & EDGE_FALLTHRU) == 0)
{
edge e;
- for (e = edge_out->pred_next; e ; e = e->pred_next)
+ for (e = edge_out->pred_next; e; e = e->pred_next)
if (e->flags & EDGE_FALLTHRU)
break;
/* ... let jump know that label is in use, ... */
JUMP_LABEL (pos) = old_succ->head;
++LABEL_NUSES (old_succ->head);
-
+
/* ... and clear fallthru on the outgoing edge. */
e->flags &= ~EDGE_FALLTHRU;
BASIC_BLOCK (i) = bb;
bb->index = i;
- /* Create the basic block note.
+ /* Create the basic block note.
Where we place the note can have a noticable impact on the generated
- code. Consider this cfg:
-
+ code. Consider this cfg:
E
|
NOTE_BASIC_BLOCK (bb_note) = bb;
bb->head = bb->end = bb_note;
- /* Not quite simple -- for non-fallthru edges, we must adjust the
- predecessor's jump instruction to target our new block. */
+ /* For non-fallthry edges, we must adjust the predecessor's
+ jump instruction to target our new block. */
if ((edge_in->flags & EDGE_FALLTHRU) == 0)
{
- rtx tmp, insn = old_pred->end;
- rtx old_label = old_succ->head;
- rtx new_label = gen_label_rtx ();
-
- if (GET_CODE (insn) != JUMP_INSN)
+ if (!redirect_edge_and_branch (edge_in, bb))
abort ();
-
- /* ??? Recognize a tablejump and adjust all matching cases. */
- 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))
- {
- rtvec vec;
- int j;
-
- if (GET_CODE (PATTERN (tmp)) == ADDR_VEC)
- vec = XVEC (PATTERN (tmp), 0);
- else
- vec = XVEC (PATTERN (tmp), 1);
-
- for (j = GET_NUM_ELEM (vec) - 1; j >= 0; --j)
- if (XEXP (RTVEC_ELT (vec, j), 0) == old_label)
- {
- RTVEC_ELT (vec, j) = gen_rtx_LABEL_REF (VOIDmode, new_label);
- --LABEL_NUSES (old_label);
- ++LABEL_NUSES (new_label);
- }
-
- /* Handle casesi dispatch insns */
- if ((tmp = single_set (insn)) != NULL
- && SET_DEST (tmp) == pc_rtx
- && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
- && GET_CODE (XEXP (SET_SRC (tmp), 2)) == LABEL_REF
- && XEXP (XEXP (SET_SRC (tmp), 2), 0) == old_label)
- {
- XEXP (SET_SRC (tmp), 2) = gen_rtx_LABEL_REF (VOIDmode,
- new_label);
- --LABEL_NUSES (old_label);
- ++LABEL_NUSES (new_label);
- }
- }
- else
- {
- /* This would have indicated an abnormal edge. */
- if (computed_jump_p (insn))
- abort ();
-
- /* A return instruction can't be redirected. */
- if (returnjump_p (insn))
- abort ();
-
- /* If the insn doesn't go where we think, we're confused. */
- if (JUMP_LABEL (insn) != old_label)
- abort ();
-
- redirect_jump (insn, new_label, 0);
- }
-
- emit_label_before (new_label, bb_note);
- bb->head = new_label;
}
+ else
+ redirect_edge_succ (edge_in, bb);
return bb;
}
emit_insn (pattern);
e->insns = get_insns ();
- end_sequence();
+ end_sequence ();
}
/* Update the CFG for the instructions queued on edge E. */
else
after = PREV_INSN (tmp);
}
-
+
/* If the source has one successor and the edge is not abnormal,
insert there. Except for the entry block. */
else if ((e->flags & EDGE_ABNORMAL) == 0
bb = e->src;
/* It is possible to have a non-simple jump here. Consider a target
where some forms of unconditional jumps clobber a register. This
- happens on the fr30 for example.
+ happens on the fr30 for example.
We know this block has a single successor, so we can just emit
the queued insns before the jump. */
if (returnjump_p (last))
{
- /* ??? Remove all outgoing edges from BB and add one for EXIT.
+ /* ??? Remove all outgoing edges from BB and add one for EXIT.
This is not currently a problem because this only happens
for the (single) epilogue, which already has a fallthru edge
to EXIT. */
}
else if (GET_CODE (last) == JUMP_INSN)
abort ();
+ find_sub_basic_blocks (bb);
}
/* Update the CFG for all queued instructions. */
#ifdef ENABLE_CHECKING
verify_flow_info ();
#endif
-
+
i = -1;
bb = ENTRY_BLOCK_PTR;
while (1)
{
edge e, next;
- for (e = bb->succ; e ; e = next)
+ for (e = bb->succ; e; e = next)
{
next = e->succ_next;
if (e->insns)
bb = BASIC_BLOCK (i);
}
}
+
+/* Add fake edges to the function exit for any non constant calls in
+ the bitmap of blocks specified by BLOCKS or to the whole CFG if
+ BLOCKS is zero. Return the nuber of blocks that were split. */
+
+int
+flow_call_edges_add (blocks)
+ sbitmap blocks;
+{
+ int i;
+ int blocks_split = 0;
+ int bb_num = 0;
+ basic_block *bbs;
+
+ /* Map bb indicies into basic block pointers since split_block
+ will renumber the basic blocks. */
+
+ bbs = xmalloc (n_basic_blocks * sizeof (*bbs));
+
+ if (! blocks)
+ {
+ for (i = 0; i < n_basic_blocks; i++)
+ bbs[bb_num++] = BASIC_BLOCK (i);
+ }
+ else
+ {
+ EXECUTE_IF_SET_IN_SBITMAP (blocks, 0, i,
+ {
+ bbs[bb_num++] = BASIC_BLOCK (i);
+ });
+ }
+
+
+ /* Now add fake edges to the function exit for any non constant
+ calls since there is no way that we can determine if they will
+ return or not... */
+
+ for (i = 0; i < bb_num; i++)
+ {
+ basic_block bb = bbs[i];
+ rtx insn;
+ rtx prev_insn;
+
+ for (insn = bb->end; ; insn = prev_insn)
+ {
+ prev_insn = PREV_INSN (insn);
+ if (GET_CODE (insn) == CALL_INSN && ! CONST_CALL_P (insn))
+ {
+ edge e;
+
+ /* Note that the following may create a new basic block
+ and renumber the existing basic blocks. */
+ e = split_block (bb, insn);
+ if (e)
+ blocks_split++;
+
+ make_edge (NULL, bb, EXIT_BLOCK_PTR, EDGE_FAKE);
+ }
+ if (insn == bb->head)
+ break;
+ }
+ }
+
+ if (blocks_split)
+ verify_flow_info ();
+
+ free (bbs);
+ return blocks_split;
+}
\f
-/* Delete all unreachable basic blocks. */
+/* Find unreachable blocks. An unreachable block will have NULL in
+ block->aux, a non-NULL value indicates the block is reachable. */
-static void
-delete_unreachable_blocks ()
+void
+find_unreachable_blocks ()
{
- basic_block *worklist, *tos;
- int deleted_handler;
edge e;
int i, n;
+ basic_block *tos, *worklist;
n = n_basic_blocks;
tos = worklist = (basic_block *) xmalloc (sizeof (basic_block) * n);
be only one. It isn't inconcievable that we might one day directly
support Fortran alternate entry points. */
- for (e = ENTRY_BLOCK_PTR->succ; e ; e = e->succ_next)
+ for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
{
*tos++ = e->dest;
/* Mark the block with a handy non-null value. */
e->dest->aux = e;
}
-
+
/* Iterate: find everything reachable from what we've already seen. */
while (tos != worklist)
{
basic_block b = *--tos;
- for (e = b->succ; e ; e = e->succ_next)
+ for (e = b->succ; e; e = e->succ_next)
if (!e->dest->aux)
{
*tos++ = e->dest;
}
}
- /* Delete all unreachable basic blocks. Count down so that we don't
- interfere with the block renumbering that happens in flow_delete_block. */
+ free (worklist);
+}
- deleted_handler = 0;
+/* Delete all unreachable basic blocks. */
+static void
+delete_unreachable_blocks ()
+{
+ int i;
+
+ find_unreachable_blocks ();
+
+ /* Delete all unreachable basic blocks. Count down so that we
+ don't interfere with the block renumbering that happens in
+ flow_delete_block. */
- for (i = n - 1; i >= 0; --i)
+ for (i = n_basic_blocks - 1; i >= 0; --i)
{
basic_block b = BASIC_BLOCK (i);
/* This block was found. Tidy up the mark. */
b->aux = NULL;
else
- deleted_handler |= flow_delete_block (b);
+ flow_delete_block (b);
}
tidy_fallthru_edges ();
-
- /* If we deleted an exception handler, we may have EH region begin/end
- blocks to remove as well. */
- if (deleted_handler)
- delete_eh_regions ();
-
- free (worklist);
-}
-
-/* Find EH regions for which there is no longer a handler, and delete them. */
-
-static void
-delete_eh_regions ()
-{
- rtx insn;
-
- update_rethrow_references ();
-
- for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
- if (GET_CODE (insn) == NOTE)
- {
- if ((NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG) ||
- (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
- {
- int num = NOTE_EH_HANDLER (insn);
- /* A NULL handler indicates a region is no longer needed,
- as long as its rethrow label isn't used. */
- if (get_first_handler (num) == NULL && ! rethrow_used (num))
- {
- NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- NOTE_SOURCE_FILE (insn) = 0;
- }
- }
- }
}
/* Return true if NOTE is not one of the ones that must be kept paired,
NOTE_INSN_EH_REGION_END notes. */
insn = b->head;
-
+
never_reached_warning (insn);
if (GET_CODE (insn) == CODE_LABEL)
- {
- rtx x, *prev = &exception_handler_labels;
-
- for (x = exception_handler_labels; x; x = XEXP (x, 1))
- {
- if (XEXP (x, 0) == insn)
- {
- /* Found a match, splice this label out of the EH label list. */
- *prev = XEXP (x, 1);
- XEXP (x, 1) = NULL_RTX;
- XEXP (x, 0) = NULL_RTX;
-
- /* Remove the handler from all regions */
- remove_handler (insn);
- deleted_handler = 1;
- break;
- }
- prev = &XEXP (x, 1);
- }
- }
+ maybe_remove_eh_handler (insn);
/* Include any jump table following the basic block. */
end = b->end;
/* Selectively delete the entire chain. */
flow_delete_insn_chain (insn, end);
- /* Remove the edges into and out of this block. Note that there may
+ /* Remove the edges into and out of this block. Note that there may
indeed be edges in, if we are removing an unreachable loop. */
{
edge e, next, *q;
- for (e = b->pred; e ; e = next)
+ for (e = b->pred; e; e = next)
{
for (q = &e->src->succ; *q != e; q = &(*q)->succ_next)
continue;
n_edges--;
free (e);
}
- for (e = b->succ; e ; e = next)
+ for (e = b->succ; e; e = next)
{
for (q = &e->dest->pred; *q != e; q = &(*q)->pred_next)
continue;
PREV_INSN (insn) = NULL_RTX;
NEXT_INSN (insn) = NULL_RTX;
INSN_DELETED_P (insn) = 1;
-
+
if (prev)
NEXT_INSN (prev) = next;
if (next)
&& GET_CODE (XEXP (note, 0)) == CODE_LABEL)
LABEL_NUSES (XEXP (note, 0))--;
+ if (GET_CODE (insn) == JUMP_INSN
+ && (GET_CODE (PATTERN (insn)) == ADDR_VEC
+ || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC))
+ {
+ rtx pat = PATTERN (insn);
+ int diff_vec_p = GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC;
+ int len = XVECLEN (pat, diff_vec_p);
+ int i;
+
+ for (i = 0; i < len; i++)
+ LABEL_NUSES (XEXP (XVECEXP (pat, diff_vec_p, i), 0))--;
+ }
+
return next;
}
/* True if a given label can be deleted. */
-static int
+static int
can_delete_label_p (label)
rtx label;
{
if (LABEL_PRESERVE_P (label))
return 0;
- for (x = forced_labels; x ; x = XEXP (x, 1))
+ for (x = forced_labels; x; x = XEXP (x, 1))
if (label == XEXP (x, 0))
return 0;
- for (x = label_value_list; x ; x = XEXP (x, 1))
+ for (x = label_value_list; x; x = XEXP (x, 1))
if (label == XEXP (x, 0))
return 0;
- for (x = exception_handler_labels; x ; x = XEXP (x, 1))
+ for (x = exception_handler_labels; x; x = XEXP (x, 1))
if (label == XEXP (x, 0))
return 0;
/* User declared labels must be preserved. */
if (LABEL_NAME (label) != 0)
return 0;
-
+
return 1;
}
{
rtx x;
- for (x = tail_recursion_label_list; x ; x = XEXP (x, 1))
+ for (x = tail_recursion_label_list; x; x = XEXP (x, 1))
if (label == XEXP (x, 0))
return 1;
{
rtx prev;
- prev = prev_nonnote_insn (a_end);
- if (!prev)
- prev = a->head;
+ for (prev = PREV_INSN (a_end); ; prev = PREV_INSN (prev))
+ if (GET_CODE (prev) != NOTE
+ || NOTE_LINE_NUMBER (prev) == NOTE_INSN_BASIC_BLOCK
+ || prev == a->head)
+ break;
del_first = a_end;
the insn that set cc0. */
if (prev && sets_cc0_p (prev))
{
- rtx tmp = prev;
+ rtx tmp = prev;
prev = prev_nonnote_insn (prev);
if (!prev)
prev = a->head;
remove_edge (a->succ);
/* Adjust the edges out of B for the new owner. */
- for (e = b->succ; e ; e = e->succ_next)
+ for (e = b->succ; e; e = e->succ_next)
e->src = a;
a->succ = b->succ;
/* Swap the records for the two blocks around. Although we are deleting B,
A is now where B was and we want to compact the BB array from where
A used to be. */
- BASIC_BLOCK(a->index) = b;
- BASIC_BLOCK(b->index) = a;
+ BASIC_BLOCK (a->index) = b;
+ BASIC_BLOCK (b->index) = a;
index = a->index;
a->index = b->index;
b->index = index;
-
+
/* Now blocks A and B are contiguous. Merge them. */
merge_blocks_nomove (a, b);
return 1;
}
-/* Attempt to merge basic blocks that are potentially non-adjacent.
+/* Attempt to merge basic blocks that are potentially non-adjacent.
Return true iff the attempt succeeded. */
static int
else
{
edge tmp_edge;
- basic_block d;
int c_has_outgoing_fallthru;
int b_has_incoming_fallthru;
/* We must make sure to not munge nesting of exception regions,
lexical blocks, and loop notes.
-
+
The first is taken care of by requiring that the active eh
region at the end of one block always matches the active eh
region at the beginning of the next block.
-
+
The later two are taken care of by squeezing out all the notes. */
-
+
/* ??? A throw/catch edge (or any abnormal edge) should be rarely
executed and we may want to treat blocks which have two out
edges, one normal, one abnormal as only having one edge for
block merging purposes. */
- for (tmp_edge = c->succ; tmp_edge ; tmp_edge = tmp_edge->succ_next)
+ for (tmp_edge = c->succ; tmp_edge; tmp_edge = tmp_edge->succ_next)
if (tmp_edge->flags & EDGE_FALLTHRU)
break;
c_has_outgoing_fallthru = (tmp_edge != NULL);
- for (tmp_edge = b->pred; tmp_edge ; tmp_edge = tmp_edge->pred_next)
+ for (tmp_edge = b->pred; tmp_edge; tmp_edge = tmp_edge->pred_next)
if (tmp_edge->flags & EDGE_FALLTHRU)
break;
b_has_incoming_fallthru = (tmp_edge != NULL);
- /* If B does not have an incoming fallthru, and the exception regions
- match, then it can be moved immediately before C without introducing
- or modifying jumps.
-
- C can not be the first block, so we do not have to worry about
+ /* If B does not have an incoming fallthru, then it can be moved
+ immediately before C without introducing or modifying jumps.
+ C cannot be the first block, so we do not have to worry about
accessing a non-existent block. */
- d = BASIC_BLOCK (c->index - 1);
- if (! b_has_incoming_fallthru
- && d->eh_end == b->eh_beg
- && b->eh_end == c->eh_beg)
+ if (! b_has_incoming_fallthru)
return merge_blocks_move_predecessor_nojumps (b, c);
- /* Otherwise, we're going to try to move C after B. Make sure the
- exception regions match.
+ /* Otherwise, we're going to try to move C after B. If C does
+ not have an outgoing fallthru, then it can be moved
+ immediately after B without introducing or modifying jumps. */
+ if (! c_has_outgoing_fallthru)
+ return merge_blocks_move_successor_nojumps (b, c);
+
+ /* Otherwise, we'll need to insert an extra jump, and possibly
+ a new block to contain it. */
+ /* ??? Not implemented yet. */
+
+ return 0;
+ }
+}
+
+/* Simplify conditional jump around an jump.
+ Return nonzero in case optimization matched. */
+
+static bool
+try_simplify_condjump (src)
+ basic_block src;
+{
+ basic_block final_block, next_block;
+ rtx insn = src->end;
+ edge branch, fallthru;
+
+ if (!any_condjump_p (insn))
+ return false;
+
+ fallthru = FALLTHRU_EDGE (src);
+
+ /* Following block must be simple forwarder block with single
+ entry and must not be last in the stream. */
+ next_block = fallthru->dest;
+ if (!forwarder_block_p (next_block)
+ || next_block->pred->pred_next
+ || next_block->index == n_basic_blocks - 1)
+ return false;
+
+ /* The branch must target to block afterwards. */
+ final_block = BASIC_BLOCK (next_block->index + 1);
- If B is the last basic block, then we must not try to access the
- block structure for block B + 1. Luckily in that case we do not
- need to worry about matching exception regions. */
- d = (b->index + 1 < n_basic_blocks ? BASIC_BLOCK (b->index + 1) : NULL);
- if (b->eh_end == c->eh_beg
- && (d == NULL || c->eh_end == d->eh_beg))
+ branch = BRANCH_EDGE (src);
+
+ if (branch->dest != final_block)
+ return false;
+
+ /* Avoid jump.c from being overactive on removin ureachable insns. */
+ LABEL_NUSES (JUMP_LABEL (insn))++;
+ if (!invert_jump (insn, block_label (next_block->succ->dest), 1))
+ {
+ LABEL_NUSES (JUMP_LABEL (insn))--;
+ return false;
+ }
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Simplifying condjump %i around jump %i\n",
+ INSN_UID (insn), INSN_UID (next_block->end));
+
+ redirect_edge_succ (branch, final_block);
+ redirect_edge_succ (fallthru, next_block->succ->dest);
+
+ branch->flags |= EDGE_FALLTHRU;
+ fallthru->flags &= ~EDGE_FALLTHRU;
+
+ flow_delete_block (next_block);
+ return true;
+}
+
+/* Attempt to forward edges leaving basic block B.
+ Return nonzero if sucessfull. */
+
+static bool
+try_forward_edges (b)
+ basic_block b;
+{
+ bool changed = 0;
+ edge e;
+ for (e = b->succ; e; e = e->succ_next)
+ {
+ basic_block target = e->dest, first = e->dest;
+ int counter = 0;
+
+ /* Look for the real destination of jump.
+ Avoid inifinite loop in the infinite empty loop by counting
+ up to n_basic_blocks. */
+ while (forwarder_block_p (target)
+ && target->succ->dest != EXIT_BLOCK_PTR
+ && counter < n_basic_blocks)
{
- /* If C does not have an outgoing fallthru, then it can be moved
- immediately after B without introducing or modifying jumps. */
- if (! c_has_outgoing_fallthru)
- return merge_blocks_move_successor_nojumps (b, c);
-
- /* Otherwise, we'll need to insert an extra jump, and possibly
- a new block to contain it. */
- /* ??? Not implemented yet. */
+ /* Bypass trivial infinite loops. */
+ if (target == target->succ->dest)
+ counter = n_basic_blocks;
+ target = target->succ->dest, counter++;
}
- return 0;
+ if (target != first && counter < n_basic_blocks
+ && redirect_edge_and_branch (e, target))
+ {
+ while (first != target)
+ {
+ first->count -= e->count;
+ first->succ->count -= e->count;
+ first->frequency -= ((e->probability * b->frequency
+ + REG_BR_PROB_BASE / 2)
+ / REG_BR_PROB_BASE);
+ first = first->succ->dest;
+ }
+ /* We've possibly removed the edge. */
+ changed = 1;
+ e = b->succ;
+ }
+ else if (rtl_dump_file && counter == n_basic_blocks)
+ fprintf (rtl_dump_file, "Infinite loop in BB %i.\n", target->index);
+ else if (rtl_dump_file && first != target)
+ fprintf (rtl_dump_file,
+ "Forwarding edge %i->%i to %i failed.\n", b->index,
+ e->dest->index, target->index);
}
+ return changed;
}
-/* Top level driver for merge_blocks. */
+/* Do simple CFG optimizations - basic block merging, simplifying of jump
+ instructions etc.
-static void
-try_merge_blocks ()
+ Return nonzero in case some optimizations matched. */
+
+static bool
+try_optimize_cfg ()
{
int i;
+ bool changed_overall = 0;
+ bool changed;
/* Attempt to merge blocks as made possible by edge removal. If a block
- has only one successor, and the successor has only one predecessor,
+ has only one successor, and the successor has only one predecessor,
they may be combined. */
- for (i = 0; i < n_basic_blocks; )
+ do
{
- basic_block c, b = BASIC_BLOCK (i);
- edge s;
+ changed = 0;
+ for (i = 0; i < n_basic_blocks;)
+ {
+ basic_block c, b = BASIC_BLOCK (i);
+ edge s;
+ int changed_here = 0;
- /* A loop because chains of blocks might be combineable. */
- while ((s = b->succ) != NULL
- && s->succ_next == NULL
- && (s->flags & EDGE_EH) == 0
- && (c = s->dest) != EXIT_BLOCK_PTR
- && c->pred->pred_next == NULL
- /* If the jump insn has side effects, we can't kill the edge. */
- && (GET_CODE (b->end) != JUMP_INSN
- || onlyjump_p (b->end))
- && merge_blocks (s, b, c))
- continue;
+ /* Delete trivially dead basic block. */
+ if (b->pred == NULL)
+ {
+ c = BASIC_BLOCK (i - 1);
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Deleting block %i.\n", b->index);
+ flow_delete_block (b);
+ changed = 1;
+ b = c;
+ }
+ /* The fallthru forwarder block can be deleted. */
+ if (b->pred->pred_next == NULL
+ && forwarder_block_p (b)
+ && (b->pred->flags & EDGE_FALLTHRU)
+ && (b->succ->flags & EDGE_FALLTHRU))
+ {
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Deleting fallthru block %i.\n",
+ b->index);
+ c = BASIC_BLOCK (i ? i - 1 : i + 1);
+ redirect_edge_succ (b->pred, b->succ->dest);
+ flow_delete_block (b);
+ changed = 1;
+ b = c;
+ }
- /* Don't get confused by the index shift caused by deleting blocks. */
- i = b->index + 1;
+ /* A loop because chains of blocks might be combineable. */
+ while ((s = b->succ) != NULL
+ && s->succ_next == NULL
+ && (s->flags & EDGE_EH) == 0
+ && (c = s->dest) != EXIT_BLOCK_PTR
+ && c->pred->pred_next == NULL
+ /* If the jump insn has side effects, we can't kill the edge. */
+ && (GET_CODE (b->end) != JUMP_INSN
+ || onlyjump_p (b->end)) && merge_blocks (s, b, c))
+ changed_here = 1;
+
+ if (try_simplify_condjump (b))
+ changed_here = 1;
+
+ /* In the case basic blocks has single outgoing edge, but over by the
+ non-trivial jump instruction, we can replace it by unconditional
+ jump, or delete the jump completely. Use logic of
+ redirect_edge_and_branch to do the dirty job for us.
+
+ We match cases as conditional jumps jumping to the next block or
+ dispatch tables. */
+
+ if (b->succ
+ && b->succ->succ_next == NULL
+ && GET_CODE (b->end) == JUMP_INSN
+ && b->succ->dest != EXIT_BLOCK_PTR
+ && redirect_edge_and_branch (b->succ, b->succ->dest))
+ changed_here = 1;
+
+ if (try_forward_edges (b))
+ changed_here = 1;
+
+ /* Don't get confused by the index shift caused by deleting
+ blocks. */
+ if (!changed_here)
+ i = b->index + 1;
+ else
+ changed = 1;
+ }
+ changed_overall |= changed;
+ changed = 0;
}
+ while (changed);
+#ifdef ENABLE_CHECKING
+ if (changed)
+ verify_flow_info ();
+#endif
+ return changed_overall;
}
/* The given edge should potentially be a fallthru edge. If that is in
NOTE_SOURCE_FILE (q) = 0;
}
else
- b->end = q = PREV_INSN (q);
+ {
+ q = PREV_INSN (q);
+
+ /* We don't want a block to end on a line-number note since that has
+ the potential of changing the code between -g and not -g. */
+ while (GET_CODE (q) == NOTE && NOTE_LINE_NUMBER (q) >= 0)
+ q = PREV_INSN (q);
+ }
+
+ b->end = q;
}
/* Selectively unlink the sequence. */
merge the flags for the duplicate edges. So we do not want to
check that the edge is not a FALLTHRU edge. */
if ((s = b->succ) != NULL
+ && ! (s->flags & EDGE_COMPLEX)
&& s->succ_next == NULL
&& s->dest == c
/* If the jump insn has side effects, we can't tidy the edge. */
CLEAR_HARD_REG_SET (elim_reg_set);
#ifdef ELIMINABLE_REGS
- for (i = 0; i < (int) (sizeof eliminables / sizeof eliminables[0]); i++)
+ for (i = 0; i < (int) ARRAY_SIZE (eliminables); i++)
SET_HARD_REG_BIT (elim_reg_set, eliminables[i].from);
#else
SET_HARD_REG_BIT (elim_reg_set, FRAME_POINTER_REGNUM);
#endif
if (! optimize)
- flags &= PROP_DEATH_NOTES | PROP_REG_INFO;
+ flags &= ~(PROP_LOG_LINKS | PROP_AUTOINC);
/* The post-reload life analysis have (on a global basis) the same
registers live as was computed by reload itself. elimination
Otherwise offsets and such may be incorrect.
Reload will make some registers as live even though they do not
- appear in the rtl.
+ appear in the rtl.
We don't want to create new auto-incs after reload, since they
are unlikely to be useful and can cause problems with shared
flags &= ~(PROP_REG_INFO | PROP_AUTOINC);
/* We want alias analysis information for local dead store elimination. */
- if (flags & PROP_SCAN_DEAD_CODE)
+ if (optimize && (flags & PROP_SCAN_DEAD_CODE))
init_alias_analysis ();
/* Always remove no-op moves. Do this before other processing so
we've already emitted the epilogue so there's no sense searching. */
if (! reload_completed)
notice_stack_pointer_modification (f);
-
+
/* Allocate and zero out data structures that will record the
data from lifetime analysis. */
allocate_reg_life_data ();
is not immediately handy. */
if (flags & PROP_REG_INFO)
- memset (regs_ever_live, 0, sizeof(regs_ever_live));
+ memset (regs_ever_live, 0, sizeof (regs_ever_live));
update_life_info (NULL, UPDATE_LIFE_GLOBAL, flags);
/* Clean up. */
- if (flags & PROP_SCAN_DEAD_CODE)
+ if (optimize && (flags & PROP_SCAN_DEAD_CODE))
end_alias_analysis ();
if (file)
dump_flow_info (file);
free_basic_block_vars (1);
+
+#ifdef ENABLE_CHECKING
+ {
+ rtx insn;
+
+ /* Search for any REG_LABEL notes which reference deleted labels. */
+ for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
+ {
+ rtx inote = find_reg_note (insn, REG_LABEL, NULL_RTX);
+
+ if (inote && GET_CODE (inote) == NOTE_INSN_DELETED_LABEL)
+ abort ();
+ }
+ }
+#endif
}
/* A subroutine of verify_wide_reg, called through for_each_rtx.
{
while (1)
{
- if (GET_RTX_CLASS (GET_CODE (head)) == 'i'
+ if (INSN_P (head)
&& for_each_rtx (&PATTERN (head), verify_wide_reg_1, ®no))
return;
if (head == end)
}
/* We didn't find the register at all. Something's way screwy. */
- abort ();
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Aborting in verify_wide_reg; reg %d\n", regno);
+ print_rtl_and_abort ();
}
/* A subroutine of update_life_info. Verify that there are no untoward
/* After reload, there are no pseudos, nor subregs of multi-word
registers. The regsets should exactly match. */
if (! REG_SET_EQUAL_P (new_live_at_start, bb->global_live_at_start))
- abort ();
+ {
+ if (rtl_dump_file)
+ {
+ fprintf (rtl_dump_file,
+ "live_at_start mismatch in bb %d, aborting\n",
+ bb->index);
+ debug_bitmap_file (rtl_dump_file, bb->global_live_at_start);
+ debug_bitmap_file (rtl_dump_file, new_live_at_start);
+ }
+ print_rtl_and_abort ();
+ }
}
else
{
{
/* No registers should die. */
if (REGNO_REG_SET_P (bb->global_live_at_start, i))
- abort ();
+ {
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file,
+ "Register %d died unexpectedly in block %d\n", i,
+ bb->index);
+ print_rtl_and_abort ();
+ }
+
/* Verify that the now-live register is wider than word_mode. */
verify_wide_reg (i, bb->head, bb->end);
});
/* Updates life information starting with the basic blocks set in BLOCKS.
If BLOCKS is null, consider it to be the universal set.
-
+
If EXTENT is UPDATE_LIFE_LOCAL, such as after splitting or peepholeing,
we are only expecting local modifications to basic blocks. If we find
extra registers live at the beginning of a block, then we either killed
basic_block bb = BASIC_BLOCK (i);
COPY_REG_SET (tmp, bb->global_live_at_end);
- propagate_block (bb, tmp, (regset) NULL, prop_flags);
+ propagate_block (bb, tmp, NULL, NULL, prop_flags);
if (extent == UPDATE_LIFE_LOCAL)
verify_local_live_at_start (tmp, bb);
basic_block bb = BASIC_BLOCK (i);
COPY_REG_SET (tmp, bb->global_live_at_end);
- propagate_block (bb, tmp, (regset) NULL, prop_flags);
+ propagate_block (bb, tmp, NULL, NULL, prop_flags);
if (extent == UPDATE_LIFE_LOCAL)
verify_local_live_at_start (tmp, bb);
FIRST_PSEUDO_REGISTER, i,
{ REG_BASIC_BLOCK (i) = REG_BLOCK_GLOBAL; });
- /* We have a problem with any pseudoreg that lives across the setjmp.
+ /* We have a problem with any pseudoreg that lives across the setjmp.
ANSI says that if a user variable does not change in value between
the setjmp and the longjmp, then the longjmp preserves it. This
includes longjmp from a place where the pseudo appears dead.
if (! keep_head_end_p)
{
- clear_edges ();
- VARRAY_FREE (basic_block_info);
+ if (basic_block_info)
+ {
+ clear_edges ();
+ VARRAY_FREE (basic_block_info);
+ }
n_basic_blocks = 0;
ENTRY_BLOCK_PTR->aux = NULL;
}
}
-/* Return nonzero if the destination of SET equals the source. */
-static int
-set_noop_p (set)
- rtx set;
-{
- rtx src = SET_SRC (set);
- rtx dst = SET_DEST (set);
-
- if (GET_CODE (src) == SUBREG && GET_CODE (dst) == SUBREG)
- {
- if (SUBREG_WORD (src) != SUBREG_WORD (dst))
- return 0;
- src = SUBREG_REG (src);
- dst = SUBREG_REG (dst);
- }
-
- return (GET_CODE (src) == REG && GET_CODE (dst) == REG
- && REGNO (src) == REGNO (dst));
-}
-
/* Return nonzero if an insn consists only of SETs, each of which only sets a
value to itself. */
+
static int
noop_move_p (insn)
rtx insn;
of a push until later in flow. See the comments in rtl.texi
regarding Embedded Side-Effects on Addresses. */
|| (GET_CODE (x) == MEM
- && (GET_CODE (XEXP (x, 0)) == PRE_DEC
- || GET_CODE (XEXP (x, 0)) == PRE_INC
- || GET_CODE (XEXP (x, 0)) == POST_DEC
- || GET_CODE (XEXP (x, 0)) == POST_INC)
+ && GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) == 'a'
&& XEXP (XEXP (x, 0), 0) == stack_pointer_rtx))
current_function_sp_is_unchanging = 0;
}
for (insn = f; insn; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
/* Check if insn modifies the stack pointer. */
note_stores (PATTERN (insn), notice_stack_pointer_modification_1,
/* Mark a register in SET. Hard registers in large modes get all
of their component registers set as well. */
+
static void
mark_reg (reg, xset)
rtx reg;
/* Mark those regs which are needed at the end of the function as live
at the end of the last basic block. */
+
static void
mark_regs_live_at_end (set)
regset set;
{
SET_REGNO_REG_SET (set, FRAME_POINTER_REGNUM);
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
- /* If they are different, also mark the hard frame pointer as live */
- SET_REGNO_REG_SET (set, HARD_FRAME_POINTER_REGNUM);
-#endif
+ /* If they are different, also mark the hard frame pointer as live. */
+ if (! LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM))
+ SET_REGNO_REG_SET (set, HARD_FRAME_POINTER_REGNUM);
+#endif
}
-#ifdef PIC_OFFSET_TABLE_REGNUM
#ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
/* Many architectures have a GP register even without flag_pic.
Assume the pic register is not in use, or will be handled by
other means, if it is not fixed. */
- if (fixed_regs[PIC_OFFSET_TABLE_REGNUM])
+ if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
+ && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
SET_REGNO_REG_SET (set, PIC_OFFSET_TABLE_REGNUM);
#endif
-#endif
/* Mark all global registers, and all registers used by the epilogue
as being live at the end of the function since they may be
referenced by our caller. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
- if (global_regs[i]
-#ifdef EPILOGUE_USES
- || EPILOGUE_USES (i)
-#endif
- )
+ if (global_regs[i] || EPILOGUE_USES (i))
SET_REGNO_REG_SET (set, i);
- /* Mark all call-saved registers that we actaully used. */
if (HAVE_epilogue && reload_completed)
{
+ /* Mark all call-saved registers that we actually used. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
- if (! call_used_regs[i] && regs_ever_live[i])
+ if (regs_ever_live[i] && ! call_used_regs[i] && ! LOCAL_REGNO (i))
SET_REGNO_REG_SET (set, i);
}
+#ifdef EH_RETURN_DATA_REGNO
+ /* Mark the registers that will contain data for the handler. */
+ if (reload_completed && current_function_calls_eh_return)
+ for (i = 0; ; ++i)
+ {
+ unsigned regno = EH_RETURN_DATA_REGNO(i);
+ if (regno == INVALID_REGNUM)
+ break;
+ SET_REGNO_REG_SET (set, regno);
+ }
+#endif
+#ifdef EH_RETURN_STACKADJ_RTX
+ if ((! HAVE_epilogue || ! reload_completed)
+ && current_function_calls_eh_return)
+ {
+ rtx tmp = EH_RETURN_STACKADJ_RTX;
+ if (tmp && REG_P (tmp))
+ mark_reg (tmp, set);
+ }
+#endif
+#ifdef EH_RETURN_HANDLER_RTX
+ if ((! HAVE_epilogue || ! reload_completed)
+ && current_function_calls_eh_return)
+ {
+ rtx tmp = EH_RETURN_HANDLER_RTX;
+ if (tmp && REG_P (tmp))
+ mark_reg (tmp, set);
+ }
+#endif
+
/* Mark function return value. */
diddle_return_value (mark_reg, set);
}
}
/* Propagate global life info around the graph of basic blocks. Begin
- considering blocks with their corresponding bit set in BLOCKS_IN.
+ considering blocks with their corresponding bit set in BLOCKS_IN.
If BLOCKS_IN is null, consider it the universal set.
BLOCKS_OUT is set for every block that was changed. */
int flags;
{
basic_block *queue, *qhead, *qtail, *qend;
- regset tmp, new_live_at_end;
- regset_head tmp_head;
+ regset tmp, new_live_at_end, call_used;
+ regset_head tmp_head, call_used_head;
regset_head new_live_at_end_head;
int i;
tmp = INITIALIZE_REG_SET (tmp_head);
new_live_at_end = INITIALIZE_REG_SET (new_live_at_end_head);
+ call_used = INITIALIZE_REG_SET (call_used_head);
+
+ /* Inconveniently, this is only redily available in hard reg set form. */
+ for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
+ if (call_used_regs[i])
+ SET_REGNO_REG_SET (call_used, i);
/* Create a worklist. Allocate an extra slot for ENTRY_BLOCK, and one
- because the `head == tail' style test for an empty queue doesn't
+ because the `head == tail' style test for an empty queue doesn't
work with a full queue. */
queue = (basic_block *) xmalloc ((n_basic_blocks + 2) * sizeof (*queue));
qtail = queue;
qhead = qend = queue + n_basic_blocks + 2;
- /* Clear out the garbage that might be hanging out in bb->aux. */
- for (i = n_basic_blocks - 1; i >= 0; --i)
- BASIC_BLOCK (i)->aux = NULL;
-
/* Queue the blocks set in the initial mask. Do this in reverse block
- number order so that we are more likely for the first round to do
+ number order so that we are more likely for the first round to do
useful work. We use AUX non-null to flag that the block is queued. */
if (blocks_in)
{
+ /* Clear out the garbage that might be hanging out in bb->aux. */
+ for (i = n_basic_blocks - 1; i >= 0; --i)
+ BASIC_BLOCK (i)->aux = NULL;
+
EXECUTE_IF_SET_IN_SBITMAP (blocks_in, 0, i,
{
basic_block bb = BASIC_BLOCK (i);
if (blocks_out)
sbitmap_zero (blocks_out);
+ /* We work through the queue until there are no more blocks. What
+ is live at the end of this block is precisely the union of what
+ is live at the beginning of all its successors. So, we set its
+ GLOBAL_LIVE_AT_END field based on the GLOBAL_LIVE_AT_START field
+ for its successors. Then, we compute GLOBAL_LIVE_AT_START for
+ this block by walking through the instructions in this block in
+ reverse order and updating as we go. If that changed
+ GLOBAL_LIVE_AT_START, we add the predecessors of the block to the
+ queue; they will now need to recalculate GLOBAL_LIVE_AT_END.
+
+ We are guaranteed to terminate, because GLOBAL_LIVE_AT_START
+ never shrinks. If a register appears in GLOBAL_LIVE_AT_START, it
+ must either be live at the end of the block, or used within the
+ block. In the latter case, it will certainly never disappear
+ from GLOBAL_LIVE_AT_START. In the former case, the register
+ could go away only if it disappeared from GLOBAL_LIVE_AT_START
+ for one of the successor blocks. By induction, that cannot
+ occur. */
while (qhead != qtail)
{
int rescan, changed;
qhead = queue;
bb->aux = NULL;
- /* Begin by propogating live_at_start from the successor blocks. */
+ /* Begin by propagating live_at_start from the successor blocks. */
CLEAR_REG_SET (new_live_at_end);
- for (e = bb->succ; e ; e = e->succ_next)
+ for (e = bb->succ; e; e = e->succ_next)
{
basic_block sb = e->dest;
- IOR_REG_SET (new_live_at_end, sb->global_live_at_start);
+
+ /* Call-clobbered registers die across exception and call edges. */
+ /* ??? Abnormal call edges ignored for the moment, as this gets
+ confused by sibling call edges, which crashes reg-stack. */
+ if (e->flags & EDGE_EH)
+ {
+ bitmap_operation (tmp, sb->global_live_at_start,
+ call_used, BITMAP_AND_COMPL);
+ IOR_REG_SET (new_live_at_end, tmp);
+ }
+ else
+ IOR_REG_SET (new_live_at_end, sb->global_live_at_start);
}
- /* Force the stack pointer to be live -- which might not already be
- the case for blocks within infinite loops. */
+ /* The all-important stack pointer must always be live. */
SET_REGNO_REG_SET (new_live_at_end, STACK_POINTER_REGNUM);
+ /* Before reload, there are a few registers that must be forced
+ live everywhere -- which might not already be the case for
+ blocks within infinite loops. */
+ if (! reload_completed)
+ {
+ /* Any reference to any pseudo before reload is a potential
+ reference of the frame pointer. */
+ SET_REGNO_REG_SET (new_live_at_end, FRAME_POINTER_REGNUM);
+
+#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
+ /* Pseudos with argument area equivalences may require
+ reloading via the argument pointer. */
+ if (fixed_regs[ARG_POINTER_REGNUM])
+ SET_REGNO_REG_SET (new_live_at_end, ARG_POINTER_REGNUM);
+#endif
+
+ /* Any constant, or pseudo with constant equivalences, may
+ require reloading from memory using the pic register. */
+ if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
+ && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
+ SET_REGNO_REG_SET (new_live_at_end, PIC_OFFSET_TABLE_REGNUM);
+ }
+
/* Regs used in phi nodes are not included in
global_live_at_start, since they are live only along a
particular edge. Set those regs that are live because of a
phi node alternative corresponding to this particular block. */
if (in_ssa_form)
- for_each_successor_phi (bb, &set_phi_alternative_reg,
+ for_each_successor_phi (bb, &set_phi_alternative_reg,
new_live_at_end);
if (bb == ENTRY_BLOCK_PTR)
continue;
}
- /* On our first pass through this block, we'll go ahead and continue.
+ /* On our first pass through this block, we'll go ahead and continue.
Recognize first pass by local_set NULL. On subsequent passes, we
get to skip out early if live_at_end wouldn't have changed. */
if (bb->local_set == NULL)
{
- bb->local_set = OBSTACK_ALLOC_REG_SET (function_obstack);
+ bb->local_set = OBSTACK_ALLOC_REG_SET (&flow_obstack);
+ bb->cond_local_set = OBSTACK_ALLOC_REG_SET (&flow_obstack);
rescan = 1;
}
else
if (! rescan)
{
+ /* If any of the registers in the new live_at_end set are
+ conditionally set in this basic block, we must rescan.
+ This is because conditional lifetimes at the end of the
+ block do not just take the live_at_end set into account,
+ but also the liveness at the start of each successor
+ block. We can miss changes in those sets if we only
+ compare the new live_at_end against the previous one. */
+ CLEAR_REG_SET (tmp);
+ rescan = bitmap_operation (tmp, new_live_at_end,
+ bb->cond_local_set, BITMAP_AND);
+ }
+
+ if (! rescan)
+ {
/* Find the set of changed bits. Take this opportunity
to notice that this set is empty and early out. */
CLEAR_REG_SET (tmp);
/* Rescan the block insn by insn to turn (a copy of) live_at_end
into live_at_start. */
- propagate_block (bb, new_live_at_end, bb->local_set, flags);
+ propagate_block (bb, new_live_at_end, bb->local_set,
+ bb->cond_local_set, flags);
/* If live_at start didn't change, no need to go farther. */
if (REG_SET_EQUAL_P (bb->global_live_at_start, new_live_at_end))
/* Queue all predecessors of BB so that we may re-examine
their live_at_end. */
- for (e = bb->pred; e ; e = e->pred_next)
+ for (e = bb->pred; e; e = e->pred_next)
{
basic_block pb = e->src;
if (pb->aux == NULL)
FREE_REG_SET (tmp);
FREE_REG_SET (new_live_at_end);
+ FREE_REG_SET (call_used);
if (blocks_out)
{
{
basic_block bb = BASIC_BLOCK (i);
FREE_REG_SET (bb->local_set);
+ FREE_REG_SET (bb->cond_local_set);
});
}
else
{
basic_block bb = BASIC_BLOCK (i);
FREE_REG_SET (bb->local_set);
+ FREE_REG_SET (bb->cond_local_set);
}
}
/* Allocate the permanent data structures that represent the results
of life analysis. Not static since used also for stupid life analysis. */
-void
+static void
allocate_bb_life_data ()
{
register int i;
{
basic_block bb = BASIC_BLOCK (i);
- bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (function_obstack);
- bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (function_obstack);
+ bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (&flow_obstack);
+ bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (&flow_obstack);
}
ENTRY_BLOCK_PTR->global_live_at_end
- = OBSTACK_ALLOC_REG_SET (function_obstack);
+ = OBSTACK_ALLOC_REG_SET (&flow_obstack);
EXIT_BLOCK_PTR->global_live_at_start
- = OBSTACK_ALLOC_REG_SET (function_obstack);
+ = OBSTACK_ALLOC_REG_SET (&flow_obstack);
- regs_live_at_setjmp = OBSTACK_ALLOC_REG_SET (function_obstack);
+ regs_live_at_setjmp = OBSTACK_ALLOC_REG_SET (&flow_obstack);
}
void
vector oriented regsets would set regset_{size,bytes} here also. */
allocate_reg_info (max_regno, FALSE, FALSE);
- /* Reset all the data we'll collect in propagate_block and its
+ /* Reset all the data we'll collect in propagate_block and its
subroutines. */
for (i = 0; i < max_regno; i++)
{
/* If the insn referred to a label, and that label was attached to
an ADDR_VEC, it's safe to delete the ADDR_VEC. In fact, it's
pretty much mandatory to delete it, because the ADDR_VEC may be
- referencing labels that no longer exist. */
+ referencing labels that no longer exist.
+
+ INSN may reference a deleted label, particularly when a jump
+ table has been optimized into a direct jump. There's no
+ real good way to fix up the reference to the deleted label
+ when the label is deleted, so we just allow it here.
+
+ After dead code elimination is complete, we do search for
+ any REG_LABEL notes which reference deleted labels as a
+ sanity check. */
- if (inote)
+ if (inote && GET_CODE (inote) == CODE_LABEL)
{
rtx label = XEXP (inote, 0);
rtx next;
- if (LABEL_NUSES (label) == 1
+ /* The label may be forced if it has been put in the constant
+ pool. If that is the only use we must discard the table
+ jump following it, but not the label itself. */
+ if (LABEL_NUSES (label) == 1 + LABEL_PRESERVE_P (label)
&& (next = next_nonnote_insn (label)) != NULL
&& GET_CODE (next) == JUMP_INSN
&& (GET_CODE (PATTERN (next)) == ADDR_VEC
if (insn == bb->end)
bb->end = before;
-
+
flow_delete_insn_chain (first, insn);
return before;
}
note = find_reg_note (insn, REG_RETVAL, NULL_RTX);
if (flags & PROP_SCAN_DEAD_CODE)
{
- insn_is_dead = insn_dead_p (pbi, PATTERN (insn), 0,
- REG_NOTES (insn));
+ insn_is_dead = insn_dead_p (pbi, PATTERN (insn), 0, REG_NOTES (insn));
libcall_is_dead = (insn_is_dead && note != 0
&& libcall_dead_p (pbi, note, insn));
}
- /* We almost certainly don't want to delete prologue or epilogue
- instructions. Warn about probable compiler losage. */
- if (insn_is_dead
- && reload_completed
- && (((HAVE_epilogue || HAVE_prologue)
- && prologue_epilogue_contains (insn))
- || (HAVE_sibcall_epilogue
- && sibcall_epilogue_contains (insn)))
- && find_reg_note (insn, REG_MAYBE_DEAD, NULL_RTX) == 0)
- {
- if (flags & PROP_KILL_DEAD_CODE)
- {
- warning ("ICE: would have deleted prologue/epilogue insn");
- if (!inhibit_warnings)
- debug_rtx (insn);
- }
- libcall_is_dead = insn_is_dead = 0;
- }
-
/* If an instruction consists of just dead store(s) on final pass,
delete it. */
if ((flags & PROP_KILL_DEAD_CODE) && insn_is_dead)
{
+ /* If we're trying to delete a prologue or epilogue instruction
+ that isn't flagged as possibly being dead, something is wrong.
+ But if we are keeping the stack pointer depressed, we might well
+ be deleting insns that are used to compute the amount to update
+ it by, so they are fine. */
+ if (reload_completed
+ && !(TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE
+ && (TYPE_RETURNS_STACK_DEPRESSED
+ (TREE_TYPE (current_function_decl))))
+ && (((HAVE_epilogue || HAVE_prologue)
+ && prologue_epilogue_contains (insn))
+ || (HAVE_sibcall_epilogue
+ && sibcall_epilogue_contains (insn)))
+ && find_reg_note (insn, REG_MAYBE_DEAD, NULL_RTX) == 0)
+ abort ();
+
/* Record sets. Do this even for dead instructions, since they
would have killed the values if they hadn't been deleted. */
mark_set_regs (pbi, PATTERN (insn), insn);
pbi->cc0_live = 0;
if (libcall_is_dead)
- {
- prev = propagate_block_delete_libcall (pbi->bb, insn, note);
- insn = NEXT_INSN (prev);
- }
+ prev = propagate_block_delete_libcall (pbi->bb, insn, note);
else
propagate_block_delete_insn (pbi->bb, insn);
/* Non-constant calls clobber memory. */
if (! CONST_CALL_P (insn))
- free_EXPR_LIST_list (&pbi->mem_set_list);
+ {
+ free_EXPR_LIST_list (&pbi->mem_set_list);
+ pbi->mem_set_list_len = 0;
+ }
/* There may be extra registers to be clobbered. */
for (note = CALL_INSN_FUNCTION_USAGE (insn);
the user can use the regsets provided here. */
struct propagate_block_info *
-init_propagate_block_info (bb, live, local_set, flags)
+init_propagate_block_info (bb, live, local_set, cond_local_set, flags)
basic_block bb;
- regset live;
- regset local_set;
+ regset live, local_set, cond_local_set;
int flags;
{
- struct propagate_block_info *pbi = xmalloc (sizeof(*pbi));
+ struct propagate_block_info *pbi = xmalloc (sizeof (*pbi));
pbi->bb = bb;
pbi->reg_live = live;
pbi->mem_set_list = NULL_RTX;
+ pbi->mem_set_list_len = 0;
pbi->local_set = local_set;
+ pbi->cond_local_set = cond_local_set;
pbi->cc0_live = 0;
pbi->flags = flags;
/* If this block ends in a conditional branch, for each register live
from one side of the branch and not the other, record the register
as conditionally dead. */
- if ((flags & (PROP_DEATH_NOTES | PROP_SCAN_DEAD_CODE))
- && GET_CODE (bb->end) == JUMP_INSN
+ if (GET_CODE (bb->end) == JUMP_INSN
&& any_condjump_p (bb->end))
{
regset_head diff_head;
bb_true = bb->succ->dest;
if (bb->succ->succ_next != NULL)
{
- bb_false = bb->succ->succ_next->dest;
+ bb_false = bb->succ->succ_next->dest;
if (bb->succ->flags & EDGE_FALLTHRU)
{
/* Simplest way to do nothing. */
bb_false = bb_true;
}
-
+
/* Extract the condition from the branch. */
set_src = SET_SRC (pc_set (bb->end));
cond_true = XEXP (set_src, 0);
if (bitmap_operation (diff, bb_true->global_live_at_start,
bb_false->global_live_at_start, BITMAP_XOR))
{
- if (GET_CODE (XEXP (cond_true, 0)) != REG)
+ rtx reg = XEXP (cond_true, 0);
+
+ if (GET_CODE (reg) == SUBREG)
+ reg = SUBREG_REG (reg);
+
+ if (GET_CODE (reg) != REG)
abort ();
- SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond_true, 0)));
+
+ SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (reg));
/* For each such register, mark it conditionally dead. */
EXECUTE_IF_SET_IN_REG_SET
cond = cond_false;
else
cond = cond_true;
- rcli->condition = alloc_EXPR_LIST (0, cond, NULL_RTX);
+ rcli->condition = cond;
+ rcli->stores = const0_rtx;
+ rcli->orig_condition = cond;
splay_tree_insert (pbi->reg_cond_dead, i,
(splay_tree_value) rcli);
used later in the block are dead. So make a pass over the block
recording any such that are made and show them dead at the end. We do
a very conservative and simple job here. */
- if ((flags & PROP_SCAN_DEAD_CODE)
+ if (optimize
+ && ! (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE
+ && (TYPE_RETURNS_STACK_DEPRESSED
+ (TREE_TYPE (current_function_decl))))
+ && (flags & PROP_SCAN_DEAD_CODE)
&& (bb->succ == NULL
- || (bb->succ->succ_next == NULL
- && bb->succ->dest == EXIT_BLOCK_PTR)))
+ || (bb->succ->succ_next == NULL
+ && bb->succ->dest == EXIT_BLOCK_PTR
+ && ! current_function_calls_eh_return)))
{
- rtx insn;
+ rtx insn, set;
for (insn = bb->end; insn != bb->head; insn = PREV_INSN (insn))
if (GET_CODE (insn) == INSN
- && GET_CODE (PATTERN (insn)) == SET
- && GET_CODE (SET_DEST (PATTERN (insn))) == MEM)
+ && (set = single_set (insn))
+ && GET_CODE (SET_DEST (set)) == MEM)
{
- rtx mem = SET_DEST (PATTERN (insn));
-
- if (XEXP (mem, 0) == frame_pointer_rtx
- || (GET_CODE (XEXP (mem, 0)) == PLUS
- && XEXP (XEXP (mem, 0), 0) == frame_pointer_rtx
- && GET_CODE (XEXP (XEXP (mem, 0), 1)) == CONST_INT))
- pbi->mem_set_list = alloc_EXPR_LIST (0, mem, pbi->mem_set_list);
+ rtx mem = SET_DEST (set);
+ rtx canon_mem = canon_rtx (mem);
+
+ /* This optimization is performed by faking a store to the
+ memory at the end of the block. This doesn't work for
+ unchanging memories because multiple stores to unchanging
+ memory is illegal and alias analysis doesn't consider it. */
+ if (RTX_UNCHANGING_P (canon_mem))
+ continue;
+
+ if (XEXP (canon_mem, 0) == frame_pointer_rtx
+ || (GET_CODE (XEXP (canon_mem, 0)) == PLUS
+ && XEXP (XEXP (canon_mem, 0), 0) == frame_pointer_rtx
+ && GET_CODE (XEXP (XEXP (canon_mem, 0), 1)) == CONST_INT))
+ {
+#ifdef AUTO_INC_DEC
+ /* Store a copy of mem, otherwise the address may be scrogged
+ by find_auto_inc. This matters because insn_dead_p uses
+ an rtx_equal_p check to determine if two addresses are
+ the same. This works before find_auto_inc, but fails
+ after find_auto_inc, causing discrepencies between the
+ set of live registers calculated during the
+ calculate_global_regs_live phase and what actually exists
+ after flow completes, leading to aborts. */
+ if (flags & PROP_AUTOINC)
+ mem = shallow_copy_rtx (mem);
+#endif
+ pbi->mem_set_list = alloc_EXPR_LIST (0, mem, pbi->mem_set_list);
+ if (++pbi->mem_set_list_len >= MAX_MEM_SET_LIST_LEN)
+ break;
+ }
}
}
When called, REG_LIVE contains those live at the end. On return, it
contains those live at the beginning.
- LOCAL_SET, if non-null, will be set with all registers killed by
- this basic block. */
+ LOCAL_SET, if non-null, will be set with all registers killed
+ unconditionally by this basic block.
+ Likewise, COND_LOCAL_SET, if non-null, will be set with all registers
+ killed conditionally by this basic block. If there is any unconditional
+ set of a register, then the corresponding bit will be set in LOCAL_SET
+ and cleared in COND_LOCAL_SET.
+ It is valid for LOCAL_SET and COND_LOCAL_SET to be the same set. In this
+ case, the resulting set will be equal to the union of the two sets that
+ would otherwise be computed. */
void
-propagate_block (bb, live, local_set, flags)
+propagate_block (bb, live, local_set, cond_local_set, flags)
basic_block bb;
regset live;
regset local_set;
+ regset cond_local_set;
int flags;
{
struct propagate_block_info *pbi;
rtx insn, prev;
-
- pbi = init_propagate_block_info (bb, live, local_set, flags);
+
+ pbi = init_propagate_block_info (bb, live, local_set, cond_local_set, flags);
if (flags & PROP_REG_INFO)
{
register int i;
/* Process the regs live at the end of the block.
- Mark them as not local to any one basic block. */
+ Mark them as not local to any one basic block. */
EXECUTE_IF_SET_IN_REG_SET (live, 0, i,
{ REG_BASIC_BLOCK (i) = REG_BLOCK_GLOBAL; });
}
/* Scan the block an insn at a time from end to beginning. */
- for (insn = bb->end; ; insn = prev)
+ for (insn = bb->end;; insn = prev)
{
/* If this is a call to `setjmp' et al, warn if any
non-volatile datum is live. */
expresions into account. */
if (reload_completed)
{
- for ( ; notes; notes = XEXP (notes, 1))
+ for (; notes; notes = XEXP (notes, 1))
{
if (REG_NOTE_KIND (notes) == REG_INC)
{
if (GET_CODE (r) == CC0)
return ! pbi->cc0_live;
#endif
-
+
/* A SET that is a subroutine call cannot be dead. */
if (GET_CODE (SET_SRC (x)) == CALL)
{
/* Walk the set of memory locations we are currently tracking
and see if one is an identical match to this memory location.
If so, this memory write is dead (remember, we're walking
- backwards from the end of the block to the start). */
- temp = pbi->mem_set_list;
- while (temp)
- {
- if (rtx_equal_p (XEXP (temp, 0), r))
- return 1;
- temp = XEXP (temp, 1);
- }
+ backwards from the end of the block to the start). Since
+ rtx_equal_p does not check the alias set or flags, we also
+ must have the potential for them to conflict (anti_dependence). */
+ for (temp = pbi->mem_set_list; temp != 0; temp = XEXP (temp, 1))
+ if (anti_dependence (r, XEXP (temp, 0)))
+ {
+ rtx mem = XEXP (temp, 0);
+
+ if (rtx_equal_p (mem, r))
+ return 1;
+#ifdef AUTO_INC_DEC
+ /* Check if memory reference matches an auto increment. Only
+ post increment/decrement or modify are valid. */
+ if (GET_MODE (mem) == GET_MODE (r)
+ && (GET_CODE (XEXP (mem, 0)) == POST_DEC
+ || GET_CODE (XEXP (mem, 0)) == POST_INC
+ || GET_CODE (XEXP (mem, 0)) == POST_MODIFY)
+ && GET_MODE (XEXP (mem, 0)) == GET_MODE (r)
+ && rtx_equal_p (XEXP (XEXP (mem, 0), 0), XEXP (r, 0)))
+ return 1;
+#endif
+ }
}
else
{
if (regno == STACK_POINTER_REGNUM)
return 0;
+ /* ??? These bits might be redundant with the force live bits
+ in calculate_global_regs_live. We would delete from
+ sequential sets; whether this actually affects real code
+ for anything but the stack pointer I don't know. */
/* Make sure insns to set the frame pointer aren't deleted. */
if (regno == FRAME_POINTER_REGNUM
&& (! reload_completed || frame_pointer_needed))
return 0;
#endif
-#ifdef PIC_OFFSET_TABLE_REGNUM
- /* Before reload, do not allow sets of the pic register
- to be deleted. Reload can insert references to
- constant pool memory anywhere in the function, making
- the PIC register live where it wasn't before. */
- if (regno == PIC_OFFSET_TABLE_REGNUM && fixed_regs[regno]
- && ! reload_completed)
- return 0;
-#endif
-
/* Otherwise, the set is dead. */
return 1;
}
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
{
if (REG_NOTE_KIND (note) == REG_INC)
- {
- rtx temp = pbi->mem_set_list;
- rtx prev = NULL_RTX;
+ {
+ rtx temp = pbi->mem_set_list;
+ rtx prev = NULL_RTX;
rtx next;
- while (temp)
+ while (temp)
{
next = XEXP (temp, 1);
if (reg_overlap_mentioned_p (XEXP (note, 0), XEXP (temp, 0)))
- {
- /* Splice temp out of list. */
- if (prev)
- XEXP (prev, 1) = next;
- else
- pbi->mem_set_list = next;
+ {
+ /* Splice temp out of list. */
+ if (prev)
+ XEXP (prev, 1) = next;
+ else
+ pbi->mem_set_list = next;
free_EXPR_LIST_node (temp);
- }
+ pbi->mem_set_list_len--;
+ }
else
- prev = temp;
- temp = next;
+ prev = temp;
+ temp = next;
}
}
}
}
+/* EXP is either a MEM or a REG. Remove any dependant entries
+ from pbi->mem_set_list. */
+
+static void
+invalidate_mems_from_set (pbi, exp)
+ struct propagate_block_info *pbi;
+ rtx exp;
+{
+ rtx temp = pbi->mem_set_list;
+ rtx prev = NULL_RTX;
+ rtx next;
+
+ while (temp)
+ {
+ next = XEXP (temp, 1);
+ if ((GET_CODE (exp) == MEM
+ && output_dependence (XEXP (temp, 0), exp))
+ || (GET_CODE (exp) == REG
+ && reg_overlap_mentioned_p (exp, XEXP (temp, 0))))
+ {
+ /* Splice this entry out of the list. */
+ if (prev)
+ XEXP (prev, 1) = next;
+ else
+ pbi->mem_set_list = next;
+ free_EXPR_LIST_node (temp);
+ pbi->mem_set_list_len--;
+ }
+ else
+ prev = temp;
+ temp = next;
+ }
+}
+
/* Process the registers that are set within X. Their bits are set to
1 in the regset DEAD, because they are dead prior to this insn.
sub = COND_EXEC_CODE (sub);
if (GET_CODE (sub) != SET && GET_CODE (sub) != CLOBBER)
break;
- /* FALLTHRU */
+ /* Fall through. */
case SET:
case CLOBBER:
}
}
-/* Process a single SET rtx, X. */
+/* Process a single set, which appears in INSN. REG (which may not
+ actually be a REG, it may also be a SUBREG, PARALLEL, etc.) is
+ being set using the CODE (which may be SET, CLOBBER, or COND_EXEC).
+ If the set is conditional (because it appear in a COND_EXEC), COND
+ will be the condition. */
static void
mark_set_1 (pbi, code, reg, cond, insn, flags)
int flags;
{
int regno_first = -1, regno_last = -1;
- int not_dead = 0;
+ unsigned long not_dead = 0;
int i;
- /* Some targets place small structures in registers for
- return values of functions. We have to detect this
- case specially here to get correct flow information. */
- if (GET_CODE (reg) == PARALLEL
- && GET_MODE (reg) == BLKmode)
- {
- for (i = XVECLEN (reg, 0) - 1; i >= 0; i--)
- mark_set_1 (pbi, code, XVECEXP (reg, 0, i), cond, insn, flags);
- return;
- }
-
/* Modifying just one hardware register of a multi-reg value or just a
byte field of a register does not mean the value from before this insn
is now dead. Of course, if it was dead after it's unused now. */
switch (GET_CODE (reg))
{
+ case PARALLEL:
+ /* Some targets place small structures in registers for return values of
+ functions. We have to detect this case specially here to get correct
+ flow information. */
+ for (i = XVECLEN (reg, 0) - 1; i >= 0; i--)
+ if (XEXP (XVECEXP (reg, 0, i), 0) != 0)
+ mark_set_1 (pbi, code, XEXP (XVECEXP (reg, 0, i), 0), cond, insn,
+ flags);
+ return;
+
case ZERO_EXTRACT:
case SIGN_EXTRACT:
case STRICT_LOW_PART:
|| GET_CODE (reg) == STRICT_LOW_PART);
if (GET_CODE (reg) == MEM)
break;
- not_dead = REGNO_REG_SET_P (pbi->reg_live, REGNO (reg));
- /* FALLTHRU */
+ not_dead = (unsigned long) REGNO_REG_SET_P (pbi->reg_live, REGNO (reg));
+ /* Fall through. */
case REG:
regno_last = regno_first = REGNO (reg);
regno_last = regno_first = REGNO (SUBREG_REG (reg));
if (regno_first < FIRST_PSEUDO_REGISTER)
{
-#ifdef ALTER_HARD_SUBREG
- regno_first = ALTER_HARD_SUBREG (outer_mode, SUBREG_WORD (reg),
- inner_mode, regno_first);
-#else
- regno_first += SUBREG_WORD (reg);
-#endif
+ regno_first += subreg_regno_offset (regno_first, inner_mode,
+ SUBREG_BYTE (reg),
+ outer_mode);
regno_last = (regno_first
+ HARD_REGNO_NREGS (regno_first, outer_mode) - 1);
+ UNITS_PER_WORD - 1) / UNITS_PER_WORD)
< ((GET_MODE_SIZE (inner_mode)
+ UNITS_PER_WORD - 1) / UNITS_PER_WORD))
- not_dead = REGNO_REG_SET_P (pbi->reg_live, regno_first);
+ not_dead = (unsigned long) REGNO_REG_SET_P (pbi->reg_live,
+ regno_first);
reg = SUBREG_REG (reg);
}
break;
}
- /* If this set is a MEM, then it kills any aliased writes.
- If this set is a REG, then it kills any MEMs which use the reg. */
- if (flags & PROP_SCAN_DEAD_CODE)
- {
- if (GET_CODE (reg) == MEM || GET_CODE (reg) == REG)
- {
- rtx temp = pbi->mem_set_list;
- rtx prev = NULL_RTX;
- rtx next;
-
- while (temp)
- {
- next = XEXP (temp, 1);
- if ((GET_CODE (reg) == MEM
- && output_dependence (XEXP (temp, 0), reg))
- || (GET_CODE (reg) == REG
- && reg_overlap_mentioned_p (reg, XEXP (temp, 0))))
- {
- /* Splice this entry out of the list. */
- if (prev)
- XEXP (prev, 1) = next;
- else
- pbi->mem_set_list = next;
- free_EXPR_LIST_node (temp);
- }
- else
- prev = temp;
- temp = next;
- }
- }
-
+ /* If this set is a MEM, then it kills any aliased writes.
+ If this set is a REG, then it kills any MEMs which use the reg. */
+ if (optimize && (flags & PROP_SCAN_DEAD_CODE))
+ {
+ if (GET_CODE (reg) == MEM || GET_CODE (reg) == REG)
+ invalidate_mems_from_set (pbi, reg);
+
/* If the memory reference had embedded side effects (autoincrement
address modes. Then we may need to kill some entries on the
memory set list. */
if (insn && GET_CODE (reg) == MEM)
invalidate_mems_from_autoinc (pbi, insn);
- if (GET_CODE (reg) == MEM && ! side_effects_p (reg)
+ if (pbi->mem_set_list_len < MAX_MEM_SET_LIST_LEN
+ && GET_CODE (reg) == MEM && ! side_effects_p (reg)
/* ??? With more effort we could track conditional memory life. */
&& ! cond
/* We do not know the size of a BLKmode store, so we do not track
them for redundant store elimination. */
&& GET_MODE (reg) != BLKmode
- /* There are no REG_INC notes for SP, so we can't assume we'll see
+ /* There are no REG_INC notes for SP, so we can't assume we'll see
everything that invalidates it. To be safe, don't eliminate any
stores though SP; none of them should be redundant anyway. */
&& ! reg_mentioned_p (stack_pointer_rtx, reg))
- pbi->mem_set_list = alloc_EXPR_LIST (0, reg, pbi->mem_set_list);
+ {
+#ifdef AUTO_INC_DEC
+ /* Store a copy of mem, otherwise the address may be
+ scrogged by find_auto_inc. */
+ if (flags & PROP_AUTOINC)
+ reg = shallow_copy_rtx (reg);
+#endif
+ pbi->mem_set_list = alloc_EXPR_LIST (0, reg, pbi->mem_set_list);
+ pbi->mem_set_list_len++;
+ }
}
if (GET_CODE (reg) == REG
{
int needed_regno = REGNO_REG_SET_P (pbi->reg_live, i);
if (pbi->local_set)
- SET_REGNO_REG_SET (pbi->local_set, i);
+ {
+ /* Order of the set operation matters here since both
+ sets may be the same. */
+ CLEAR_REGNO_REG_SET (pbi->cond_local_set, i);
+ if (cond != NULL_RTX
+ && ! REGNO_REG_SET_P (pbi->local_set, i))
+ SET_REGNO_REG_SET (pbi->cond_local_set, i);
+ else
+ SET_REGNO_REG_SET (pbi->local_set, i);
+ }
if (code != CLOBBER)
SET_REGNO_REG_SET (pbi->new_set, i);
{
for (i = regno_first; i <= regno_last; ++i)
if (! mark_regno_cond_dead (pbi, i, cond))
- not_dead = 1;
+ not_dead |= ((unsigned long) 1) << (i - regno_first);
}
#endif
/* Count (weighted) references, stores, etc. This counts a
register twice if it is modified, but that is correct. */
REG_N_SETS (i) += 1;
- REG_N_REFS (i) += (optimize_size ? 1
- : pbi->bb->loop_depth + 1);
+ REG_N_REFS (i) += 1;
+ REG_FREQ (i) += (optimize_size || !pbi->bb->frequency
+ ? 1 : pbi->bb->frequency);
/* The insns where a reg is live are normally counted
elsewhere, but we want the count to include the insn
where the reg is set, and the normal counting mechanism
would not count it. */
- REG_LIVE_LENGTH (i) += 1;
+ REG_LIVE_LENGTH (i) += 1;
}
/* If this is a hard reg, record this function uses the reg. */
/* Mark the register as being dead. */
if (some_was_live
- && ! not_dead
/* The stack pointer is never dead. Well, not strictly true,
but it's very difficult to tell from here. Hopefully
combine_stack_adjustments will fix up the most egregious
&& regno_first != STACK_POINTER_REGNUM)
{
for (i = regno_first; i <= regno_last; ++i)
- CLEAR_REGNO_REG_SET (pbi->reg_live, i);
+ if (!(not_dead & (((unsigned long) 1) << (i - regno_first))))
+ CLEAR_REGNO_REG_SET (pbi->reg_live, i);
}
}
else if (GET_CODE (reg) == REG)
}
\f
#ifdef HAVE_conditional_execution
-/* Mark REGNO conditionally dead. Return true if the register is
- now unconditionally dead. */
+/* Mark REGNO conditionally dead.
+ Return true if the register is now unconditionally dead. */
static int
mark_regno_cond_dead (pbi, regno, cond)
/* The register was unconditionally live previously.
Record the current condition as the condition under
which it is dead. */
- rcli = (struct reg_cond_life_info *)
- xmalloc (sizeof (*rcli));
- rcli->condition = alloc_EXPR_LIST (0, cond, NULL_RTX);
+ rcli = (struct reg_cond_life_info *) xmalloc (sizeof (*rcli));
+ rcli->condition = cond;
+ rcli->stores = cond;
+ rcli->orig_condition = const0_rtx;
splay_tree_insert (pbi->reg_cond_dead, regno,
(splay_tree_value) rcli);
- SET_REGNO_REG_SET (pbi->reg_cond_reg,
- REGNO (XEXP (cond, 0)));
+ SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
/* Not unconditionaly dead. */
return 0;
}
else
{
- /* The register was conditionally live previously.
+ /* The register was conditionally live previously.
Add the new condition to the old. */
rcli = (struct reg_cond_life_info *) node->value;
ncond = rcli->condition;
- ncond = ior_reg_cond (ncond, cond);
-
- /* If the register is now unconditionally dead,
- remove the entry in the splay_tree. */
- if (ncond == const1_rtx)
+ ncond = ior_reg_cond (ncond, cond, 1);
+ if (rcli->stores == const0_rtx)
+ rcli->stores = cond;
+ else if (rcli->stores != const1_rtx)
+ rcli->stores = ior_reg_cond (rcli->stores, cond, 1);
+
+ /* If the register is now unconditionally dead, remove the entry
+ in the splay_tree. A register is unconditionally dead if the
+ dead condition ncond is true. A register is also unconditionally
+ dead if the sum of all conditional stores is an unconditional
+ store (stores is true), and the dead condition is identically the
+ same as the original dead condition initialized at the end of
+ the block. This is a pointer compare, not an rtx_equal_p
+ compare. */
+ if (ncond == const1_rtx
+ || (ncond == rcli->orig_condition && rcli->stores == const1_rtx))
splay_tree_remove (pbi->reg_cond_dead, regno);
else
{
rcli->condition = ncond;
- SET_REGNO_REG_SET (pbi->reg_cond_reg,
- REGNO (XEXP (cond, 0)));
+ SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
/* Not unconditionaly dead. */
return 0;
splay_tree_value value;
{
struct reg_cond_life_info *rcli = (struct reg_cond_life_info *) value;
- free_EXPR_LIST_list (&rcli->condition);
free (rcli);
}
struct reg_cond_life_info *rcli;
int *xdata = (int *) data;
unsigned int regno = xdata[0];
- rtx c, *prev;
/* Don't need to search if last flushed value was farther on in
the in-order traversal. */
/* Splice out portions of the expression that refer to regno. */
rcli = (struct reg_cond_life_info *) node->value;
- c = *(prev = &rcli->condition);
- while (c)
- {
- if (regno == REGNO (XEXP (XEXP (c, 0), 0)))
- {
- rtx next = XEXP (c, 1);
- free_EXPR_LIST_node (c);
- c = *prev = next;
- }
- else
- c = *(prev = &XEXP (c, 1));
- }
+ rcli->condition = elim_reg_cond (rcli->condition, regno);
+ if (rcli->stores != const0_rtx && rcli->stores != const1_rtx)
+ rcli->stores = elim_reg_cond (rcli->stores, regno);
- /* If the entire condition is now NULL, signal the node to be removed. */
- if (! rcli->condition)
+ /* If the entire condition is now false, signal the node to be removed. */
+ if (rcli->condition == const0_rtx)
{
xdata[1] = node->key;
return -1;
}
- else
- return 0;
+ else if (rcli->condition == const1_rtx)
+ abort ();
+
+ return 0;
}
/* Flush all (sub) expressions referring to REGNO from REG_COND_LIVE. */
CLEAR_REGNO_REG_SET (pbi->reg_cond_reg, regno);
}
-/* Logical arithmetic on predicate conditions. IOR, NOT and NAND.
- We actually use EXPR_LIST to chain the sub-expressions together
- instead of IOR because it's easier to manipulate and we have
- the lists.c functions to reuse nodes.
-
- Return a new rtl expression as appropriate. */
+/* Logical arithmetic on predicate conditions. IOR, NOT and AND.
+ For ior/and, the ADD flag determines whether we want to add the new
+ condition X to the old one unconditionally. If it is zero, we will
+ only return a new expression if X allows us to simplify part of
+ OLD, otherwise we return OLD unchanged to the caller.
+ If ADD is nonzero, we will return a new condition in all cases. The
+ toplevel caller of one of these functions should always pass 1 for
+ ADD. */
static rtx
-ior_reg_cond (old, x)
+ior_reg_cond (old, x, add)
rtx old, x;
+ int add;
{
- enum rtx_code x_code;
- rtx x_reg;
- rtx c;
+ rtx op0, op1;
- /* We expect these conditions to be of the form (eq reg 0). */
- x_code = GET_CODE (x);
- if (GET_RTX_CLASS (x_code) != '<'
- || GET_CODE (x_reg = XEXP (x, 0)) != REG
- || XEXP (x, 1) != const0_rtx)
- abort ();
+ if (GET_RTX_CLASS (GET_CODE (old)) == '<')
+ {
+ if (GET_RTX_CLASS (GET_CODE (x)) == '<'
+ && REVERSE_CONDEXEC_PREDICATES_P (GET_CODE (x), GET_CODE (old))
+ && REGNO (XEXP (x, 0)) == REGNO (XEXP (old, 0)))
+ return const1_rtx;
+ if (GET_CODE (x) == GET_CODE (old)
+ && REGNO (XEXP (x, 0)) == REGNO (XEXP (old, 0)))
+ return old;
+ if (! add)
+ return old;
+ return gen_rtx_IOR (0, old, x);
+ }
- /* Search the expression for an existing sub-expression of X_REG. */
- for (c = old; c ; c = XEXP (c, 1))
+ switch (GET_CODE (old))
{
- rtx y = XEXP (c, 0);
- if (REGNO (XEXP (y, 0)) == REGNO (x_reg))
+ case IOR:
+ op0 = ior_reg_cond (XEXP (old, 0), x, 0);
+ op1 = ior_reg_cond (XEXP (old, 1), x, 0);
+ if (op0 != XEXP (old, 0) || op1 != XEXP (old, 1))
{
- /* If we find X already present in OLD, we need do nothing. */
- if (GET_CODE (y) == x_code)
- return old;
-
- /* If we find X being a compliment of a condition in OLD,
- then the entire condition is true. */
- if (GET_CODE (y) == reverse_condition (x_code))
+ if (op0 == const0_rtx)
+ return op1;
+ if (op1 == const0_rtx)
+ return op0;
+ if (op0 == const1_rtx || op1 == const1_rtx)
return const1_rtx;
+ if (op0 == XEXP (old, 0))
+ op0 = gen_rtx_IOR (0, op0, x);
+ else
+ op1 = gen_rtx_IOR (0, op1, x);
+ return gen_rtx_IOR (0, op0, op1);
}
- }
+ if (! add)
+ return old;
+ return gen_rtx_IOR (0, old, x);
+
+ case AND:
+ op0 = ior_reg_cond (XEXP (old, 0), x, 0);
+ op1 = ior_reg_cond (XEXP (old, 1), x, 0);
+ if (op0 != XEXP (old, 0) || op1 != XEXP (old, 1))
+ {
+ if (op0 == const1_rtx)
+ return op1;
+ if (op1 == const1_rtx)
+ return op0;
+ if (op0 == const0_rtx || op1 == const0_rtx)
+ return const0_rtx;
+ if (op0 == XEXP (old, 0))
+ op0 = gen_rtx_IOR (0, op0, x);
+ else
+ op1 = gen_rtx_IOR (0, op1, x);
+ return gen_rtx_AND (0, op0, op1);
+ }
+ if (! add)
+ return old;
+ return gen_rtx_IOR (0, old, x);
+
+ case NOT:
+ op0 = and_reg_cond (XEXP (old, 0), not_reg_cond (x), 0);
+ if (op0 != XEXP (old, 0))
+ return not_reg_cond (op0);
+ if (! add)
+ return old;
+ return gen_rtx_IOR (0, old, x);
- /* Otherwise just add to the chain. */
- return alloc_EXPR_LIST (0, x, old);
+ default:
+ abort ();
+ }
}
static rtx
rtx x;
{
enum rtx_code x_code;
- rtx x_reg;
- /* We expect these conditions to be of the form (eq reg 0). */
+ if (x == const0_rtx)
+ return const1_rtx;
+ else if (x == const1_rtx)
+ return const0_rtx;
x_code = GET_CODE (x);
- if (GET_RTX_CLASS (x_code) != '<'
- || GET_CODE (x_reg = XEXP (x, 0)) != REG
- || XEXP (x, 1) != const0_rtx)
- abort ();
+ if (x_code == NOT)
+ return XEXP (x, 0);
+ if (GET_RTX_CLASS (x_code) == '<'
+ && GET_CODE (XEXP (x, 0)) == REG)
+ {
+ if (XEXP (x, 1) != const0_rtx)
+ abort ();
- return alloc_EXPR_LIST (0, gen_rtx_fmt_ee (reverse_condition (x_code),
- VOIDmode, x_reg, const0_rtx),
- NULL_RTX);
+ return gen_rtx_fmt_ee (reverse_condition (x_code),
+ VOIDmode, XEXP (x, 0), const0_rtx);
+ }
+ return gen_rtx_NOT (0, x);
}
static rtx
-nand_reg_cond (old, x)
+and_reg_cond (old, x, add)
rtx old, x;
+ int add;
{
- enum rtx_code x_code;
- rtx x_reg;
- rtx c, *prev;
-
- /* We expect these conditions to be of the form (eq reg 0). */
- x_code = GET_CODE (x);
- if (GET_RTX_CLASS (x_code) != '<'
- || GET_CODE (x_reg = XEXP (x, 0)) != REG
- || XEXP (x, 1) != const0_rtx)
- abort ();
+ rtx op0, op1;
- /* Search the expression for an existing sub-expression of X_REG. */
+ if (GET_RTX_CLASS (GET_CODE (old)) == '<')
+ {
+ if (GET_RTX_CLASS (GET_CODE (x)) == '<'
+ && GET_CODE (x) == reverse_condition (GET_CODE (old))
+ && REGNO (XEXP (x, 0)) == REGNO (XEXP (old, 0)))
+ return const0_rtx;
+ if (GET_CODE (x) == GET_CODE (old)
+ && REGNO (XEXP (x, 0)) == REGNO (XEXP (old, 0)))
+ return old;
+ if (! add)
+ return old;
+ return gen_rtx_AND (0, old, x);
+ }
- for (c = *(prev = &old); c ; c = *(prev = &XEXP (c, 1)))
+ switch (GET_CODE (old))
{
- rtx y = XEXP (c, 0);
- if (REGNO (XEXP (y, 0)) == REGNO (x_reg))
+ case IOR:
+ op0 = and_reg_cond (XEXP (old, 0), x, 0);
+ op1 = and_reg_cond (XEXP (old, 1), x, 0);
+ if (op0 != XEXP (old, 0) || op1 != XEXP (old, 1))
{
- /* If we find X already present in OLD, then we need to
- splice it out. */
- if (GET_CODE (y) == x_code)
- {
- *prev = XEXP (c, 1);
- free_EXPR_LIST_node (c);
- return old ? old : const0_rtx;
- }
-
- /* If we find X being a compliment of a condition in OLD,
- then we need do nothing. */
- if (GET_CODE (y) == reverse_condition (x_code))
- return old;
+ if (op0 == const0_rtx)
+ return op1;
+ if (op1 == const0_rtx)
+ return op0;
+ if (op0 == const1_rtx || op1 == const1_rtx)
+ return const1_rtx;
+ if (op0 == XEXP (old, 0))
+ op0 = gen_rtx_AND (0, op0, x);
+ else
+ op1 = gen_rtx_AND (0, op1, x);
+ return gen_rtx_IOR (0, op0, op1);
+ }
+ if (! add)
+ return old;
+ return gen_rtx_AND (0, old, x);
+
+ case AND:
+ op0 = and_reg_cond (XEXP (old, 0), x, 0);
+ op1 = and_reg_cond (XEXP (old, 1), x, 0);
+ if (op0 != XEXP (old, 0) || op1 != XEXP (old, 1))
+ {
+ if (op0 == const1_rtx)
+ return op1;
+ if (op1 == const1_rtx)
+ return op0;
+ if (op0 == const0_rtx || op1 == const0_rtx)
+ return const0_rtx;
+ if (op0 == XEXP (old, 0))
+ op0 = gen_rtx_AND (0, op0, x);
+ else
+ op1 = gen_rtx_AND (0, op1, x);
+ return gen_rtx_AND (0, op0, op1);
}
+ if (! add)
+ return old;
+
+ /* If X is identical to one of the existing terms of the AND,
+ then just return what we already have. */
+ /* ??? There really should be some sort of recursive check here in
+ case there are nested ANDs. */
+ if ((GET_CODE (XEXP (old, 0)) == GET_CODE (x)
+ && REGNO (XEXP (XEXP (old, 0), 0)) == REGNO (XEXP (x, 0)))
+ || (GET_CODE (XEXP (old, 1)) == GET_CODE (x)
+ && REGNO (XEXP (XEXP (old, 1), 0)) == REGNO (XEXP (x, 0))))
+ return old;
+
+ return gen_rtx_AND (0, old, x);
+
+ case NOT:
+ op0 = ior_reg_cond (XEXP (old, 0), not_reg_cond (x), 0);
+ if (op0 != XEXP (old, 0))
+ return not_reg_cond (op0);
+ if (! add)
+ return old;
+ return gen_rtx_AND (0, old, x);
+
+ default:
+ abort ();
+ }
+}
+
+/* Given a condition X, remove references to reg REGNO and return the
+ new condition. The removal will be done so that all conditions
+ involving REGNO are considered to evaluate to false. This function
+ is used when the value of REGNO changes. */
+
+static rtx
+elim_reg_cond (x, regno)
+ rtx x;
+ unsigned int regno;
+{
+ rtx op0, op1;
+
+ if (GET_RTX_CLASS (GET_CODE (x)) == '<')
+ {
+ if (REGNO (XEXP (x, 0)) == regno)
+ return const0_rtx;
+ return x;
}
- /* Otherwise, by implication, the register in question is now live for
- the inverse of the condition X. */
- return alloc_EXPR_LIST (0, gen_rtx_fmt_ee (reverse_condition (x_code),
- VOIDmode, x_reg, const0_rtx),
- old);
+ switch (GET_CODE (x))
+ {
+ case AND:
+ op0 = elim_reg_cond (XEXP (x, 0), regno);
+ op1 = elim_reg_cond (XEXP (x, 1), regno);
+ if (op0 == const0_rtx || op1 == const0_rtx)
+ return const0_rtx;
+ if (op0 == const1_rtx)
+ return op1;
+ if (op1 == const1_rtx)
+ return op0;
+ if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
+ return x;
+ return gen_rtx_AND (0, op0, op1);
+
+ case IOR:
+ op0 = elim_reg_cond (XEXP (x, 0), regno);
+ op1 = elim_reg_cond (XEXP (x, 1), regno);
+ if (op0 == const1_rtx || op1 == const1_rtx)
+ return const1_rtx;
+ if (op0 == const0_rtx)
+ return op1;
+ if (op1 == const0_rtx)
+ return op0;
+ if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
+ return x;
+ return gen_rtx_IOR (0, op0, op1);
+
+ case NOT:
+ op0 = elim_reg_cond (XEXP (x, 0), regno);
+ if (op0 == const0_rtx)
+ return const1_rtx;
+ if (op0 == const1_rtx)
+ return const0_rtx;
+ if (op0 != XEXP (x, 0))
+ return not_reg_cond (op0);
+ return x;
+
+ default:
+ abort ();
+ }
}
#endif /* HAVE_conditional_execution */
\f
Change it to q = p, ...*q..., q = q+size.
Then fall into the usual case. */
rtx insns, temp;
- basic_block bb;
start_sequence ();
emit_move_insn (q, incr_reg);
/* INCR will become a NOTE and INSN won't contain a
use of INCR_REG. If a use of INCR_REG was just placed in
- the insn before INSN, make that the next use.
+ the insn before INSN, make that the next use.
Otherwise, invalidate it. */
if (GET_CODE (PREV_INSN (insn)) == INSN
&& GET_CODE (PATTERN (PREV_INSN (insn))) == SET
auto-inc, so update the status. First, record that this insn
has an implicit side effect. */
- REG_NOTES (insn)
- = alloc_EXPR_LIST (REG_INC, incr_reg, REG_NOTES (insn));
+ REG_NOTES (insn) = alloc_EXPR_LIST (REG_INC, incr_reg, REG_NOTES (insn));
/* Modify the old increment-insn to simply copy
the already-incremented value of our register. */
{
/* If the original source was dead, it's dead now. */
rtx note;
-
- while (note = find_reg_note (incr, REG_DEAD, NULL_RTX))
+
+ while ((note = find_reg_note (incr, REG_DEAD, NULL_RTX)) != NULL_RTX)
{
remove_note (incr, note);
if (XEXP (note, 0) != incr_reg)
/* Count an extra reference to the reg. When a reg is
incremented, spilling it is worse, so we want to make
that less likely. */
- REG_N_REFS (regno) += (optimize_size ? 1 : pbi->bb->loop_depth + 1);
+ REG_FREQ (regno) += (optimize_size || !pbi->bb->frequency
+ ? 1 : pbi->bb->frequency);
/* Count the increment as a setting of the register,
even though it isn't a SET in rtl. */
if (GET_CODE (y) != PLUS)
return;
- if (REGNO (XEXP (y, 0)) == REGNO (addr))
+ if (REG_P (XEXP (y, 0)) && REGNO (XEXP (y, 0)) == REGNO (addr))
inc_val = XEXP (y, 1);
- else if (REGNO (XEXP (y, 1)) == REGNO (addr))
+ else if (REG_P (XEXP (y, 1)) && REGNO (XEXP (y, 1)) == REGNO (addr))
inc_val = XEXP (y, 0);
else
- abort ();
+ return;
if (GET_CODE (inc_val) == CONST_INT)
{
attempt_auto_inc (pbi, gen_rtx_POST_INC (Pmode, addr), insn, x,
incr, addr);
else if (HAVE_POST_DECREMENT
- && (INTVAL (inc_val) == - size && offset == 0))
+ && (INTVAL (inc_val) == -size && offset == 0))
attempt_auto_inc (pbi, gen_rtx_POST_DEC (Pmode, addr), insn, x,
incr, addr);
else if (HAVE_PRE_INCREMENT
attempt_auto_inc (pbi, gen_rtx_PRE_INC (Pmode, addr), insn, x,
incr, addr);
else if (HAVE_PRE_DECREMENT
- && (INTVAL (inc_val) == - size && offset == - size))
+ && (INTVAL (inc_val) == -size && offset == -size))
attempt_auto_inc (pbi, gen_rtx_PRE_DEC (Pmode, addr), insn, x,
incr, addr);
else if (HAVE_POST_MODIFY_DISP && offset == 0)
rtx cond ATTRIBUTE_UNUSED;
rtx insn;
{
- int regno = REGNO (reg);
- int some_was_live = REGNO_REG_SET_P (pbi->reg_live, regno);
- int some_was_dead = ! some_was_live;
- int some_not_set;
- int n;
+ unsigned int regno_first, regno_last, i;
+ int some_was_live, some_was_dead, some_not_set;
- /* A hard reg in a wide mode may really be multiple registers.
- If so, mark all of them just like the first. */
- if (regno < FIRST_PSEUDO_REGISTER)
+ regno_last = regno_first = REGNO (reg);
+ if (regno_first < FIRST_PSEUDO_REGISTER)
+ regno_last += HARD_REGNO_NREGS (regno_first, GET_MODE (reg)) - 1;
+
+ /* Find out if any of this register is live after this instruction. */
+ some_was_live = some_was_dead = 0;
+ for (i = regno_first; i <= regno_last; ++i)
{
- n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
- while (--n > 0)
- {
- int needed_regno = REGNO_REG_SET_P (pbi->reg_live, regno + n);
- some_was_live |= needed_regno;
- some_was_dead |= ! needed_regno;
- }
+ int needed_regno = REGNO_REG_SET_P (pbi->reg_live, i);
+ some_was_live |= needed_regno;
+ some_was_dead |= ! needed_regno;
}
+ /* Find out if any of the register was set this insn. */
+ some_not_set = 0;
+ for (i = regno_first; i <= regno_last; ++i)
+ some_not_set |= ! REGNO_REG_SET_P (pbi->new_set, i);
+
if (pbi->flags & (PROP_LOG_LINKS | PROP_AUTOINC))
{
/* Record where each reg is used, so when the reg is set we know
the next insn that uses it. */
- pbi->reg_next_use[regno] = insn;
+ pbi->reg_next_use[regno_first] = insn;
}
if (pbi->flags & PROP_REG_INFO)
{
- if (regno < FIRST_PSEUDO_REGISTER)
+ if (regno_first < FIRST_PSEUDO_REGISTER)
{
/* If this is a register we are going to try to eliminate,
don't mark it live here. If we are successful in
register to itself. This should be fixed. In the mean
time, hack around it. */
- if (! (TEST_HARD_REG_BIT (elim_reg_set, regno)
- && (regno == FRAME_POINTER_REGNUM
- || regno == ARG_POINTER_REGNUM)))
- {
- int n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
- do
- regs_ever_live[regno + --n] = 1;
- while (n > 0);
- }
+ if (! (TEST_HARD_REG_BIT (elim_reg_set, regno_first)
+ && (regno_first == FRAME_POINTER_REGNUM
+ || regno_first == ARG_POINTER_REGNUM)))
+ for (i = regno_first; i <= regno_last; ++i)
+ regs_ever_live[i] = 1;
}
else
{
/* Keep track of which basic block each reg appears in. */
register int blocknum = pbi->bb->index;
- if (REG_BASIC_BLOCK (regno) == REG_BLOCK_UNKNOWN)
- REG_BASIC_BLOCK (regno) = blocknum;
- else if (REG_BASIC_BLOCK (regno) != blocknum)
- REG_BASIC_BLOCK (regno) = REG_BLOCK_GLOBAL;
+ if (REG_BASIC_BLOCK (regno_first) == REG_BLOCK_UNKNOWN)
+ REG_BASIC_BLOCK (regno_first) = blocknum;
+ else if (REG_BASIC_BLOCK (regno_first) != blocknum)
+ REG_BASIC_BLOCK (regno_first) = REG_BLOCK_GLOBAL;
/* Count (weighted) number of uses of each reg. */
- REG_N_REFS (regno) += (optimize_size ? 1
- : pbi->bb->loop_depth + 1);
+ REG_FREQ (regno_first)
+ += (optimize_size || !pbi->bb->frequency ? 1 : pbi->bb->frequency);
+ REG_N_REFS (regno_first)++;
}
}
- /* Find out if any of the register was set this insn. */
- some_not_set = ! REGNO_REG_SET_P (pbi->new_set, regno);
- if (regno < FIRST_PSEUDO_REGISTER)
- {
- n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
- while (--n > 0)
- some_not_set |= ! REGNO_REG_SET_P (pbi->new_set, regno + n);
- }
-
/* Record and count the insns in which a reg dies. If it is used in
this insn and was dead below the insn then it dies in this insn.
If it was set in this insn, we do not make a REG_DEAD note;
{
/* Check for the case where the register dying partially
overlaps the register set by this insn. */
- if (regno < FIRST_PSEUDO_REGISTER
- && HARD_REGNO_NREGS (regno, GET_MODE (reg)) > 1)
- {
- n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
- while (--n >= 0)
- some_was_live |= REGNO_REG_SET_P (pbi->new_set, regno + n);
- }
+ if (regno_first != regno_last)
+ for (i = regno_first; i <= regno_last; ++i)
+ some_was_live |= REGNO_REG_SET_P (pbi->new_set, i);
/* If none of the words in X is needed, make a REG_DEAD note.
Otherwise, we must make partial REG_DEAD notes. */
if (! some_was_live)
{
if ((pbi->flags & PROP_DEATH_NOTES)
- && ! find_regno_note (insn, REG_DEAD, regno))
+ && ! find_regno_note (insn, REG_DEAD, regno_first))
REG_NOTES (insn)
= alloc_EXPR_LIST (REG_DEAD, reg, REG_NOTES (insn));
if (pbi->flags & PROP_REG_INFO)
- REG_N_DEATHS (regno)++;
+ REG_N_DEATHS (regno_first)++;
}
else
{
/* Don't make a REG_DEAD note for a part of a register
that is set in the insn. */
-
- n = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1;
- for (; n >= regno; n--)
- if (! REGNO_REG_SET_P (pbi->reg_live, n)
- && ! dead_or_set_regno_p (insn, n))
+ for (i = regno_first; i <= regno_last; ++i)
+ if (! REGNO_REG_SET_P (pbi->reg_live, i)
+ && ! dead_or_set_regno_p (insn, i))
REG_NOTES (insn)
= alloc_EXPR_LIST (REG_DEAD,
- gen_rtx_REG (reg_raw_mode[n], n),
+ gen_rtx_REG (reg_raw_mode[i], i),
REG_NOTES (insn));
}
}
- SET_REGNO_REG_SET (pbi->reg_live, regno);
- if (regno < FIRST_PSEUDO_REGISTER)
+ /* Mark the register as being live. */
+ for (i = regno_first; i <= regno_last; ++i)
{
- n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
- while (--n > 0)
- SET_REGNO_REG_SET (pbi->reg_live, regno + n);
- }
+ SET_REGNO_REG_SET (pbi->reg_live, i);
#ifdef HAVE_conditional_execution
- /* If this is a conditional use, record that fact. If it is later
- conditionally set, we'll know to kill the register. */
- if (cond != NULL_RTX)
- {
- splay_tree_node node;
- struct reg_cond_life_info *rcli;
- rtx ncond;
-
- if (some_was_live)
+ /* If this is a conditional use, record that fact. If it is later
+ conditionally set, we'll know to kill the register. */
+ if (cond != NULL_RTX)
{
- node = splay_tree_lookup (pbi->reg_cond_dead, regno);
- if (node == NULL)
- {
- /* The register was unconditionally live previously.
- No need to do anything. */
- }
- else
+ splay_tree_node node;
+ struct reg_cond_life_info *rcli;
+ rtx ncond;
+
+ if (some_was_live)
{
- /* The register was conditionally live previously.
- Subtract the new life cond from the old death cond. */
- rcli = (struct reg_cond_life_info *) node->value;
- ncond = rcli->condition;
- ncond = nand_reg_cond (ncond, cond);
-
- /* If the register is now unconditionally live, remove the
- entry in the splay_tree. */
- if (ncond == const0_rtx)
+ node = splay_tree_lookup (pbi->reg_cond_dead, i);
+ if (node == NULL)
{
- rcli->condition = NULL_RTX;
- splay_tree_remove (pbi->reg_cond_dead, regno);
+ /* The register was unconditionally live previously.
+ No need to do anything. */
}
else
- rcli->condition = ncond;
+ {
+ /* The register was conditionally live previously.
+ Subtract the new life cond from the old death cond. */
+ rcli = (struct reg_cond_life_info *) node->value;
+ ncond = rcli->condition;
+ ncond = and_reg_cond (ncond, not_reg_cond (cond), 1);
+
+ /* If the register is now unconditionally live,
+ remove the entry in the splay_tree. */
+ if (ncond == const0_rtx)
+ splay_tree_remove (pbi->reg_cond_dead, i);
+ else
+ {
+ rcli->condition = ncond;
+ SET_REGNO_REG_SET (pbi->reg_cond_reg,
+ REGNO (XEXP (cond, 0)));
+ }
+ }
+ }
+ else
+ {
+ /* The register was not previously live at all. Record
+ the condition under which it is still dead. */
+ rcli = (struct reg_cond_life_info *) xmalloc (sizeof (*rcli));
+ rcli->condition = not_reg_cond (cond);
+ rcli->stores = const0_rtx;
+ rcli->orig_condition = const0_rtx;
+ splay_tree_insert (pbi->reg_cond_dead, i,
+ (splay_tree_value) rcli);
+
+ SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
}
}
- else
- {
- /* The register was not previously live at all. Record
- the condition under which it is still dead. */
- rcli = (struct reg_cond_life_info *) xmalloc (sizeof (*rcli));
- rcli->condition = not_reg_cond (cond);
- splay_tree_insert (pbi->reg_cond_dead, regno,
- (splay_tree_value) rcli);
- }
- }
- else if (some_was_live)
- {
- splay_tree_node node;
- struct reg_cond_life_info *rcli;
-
- node = splay_tree_lookup (pbi->reg_cond_dead, regno);
- if (node != NULL)
+ else if (some_was_live)
{
- /* The register was conditionally live previously, but is now
- unconditionally so. Remove it from the conditionally dead
- list, so that a conditional set won't cause us to think
+ /* The register may have been conditionally live previously, but
+ is now unconditionally live. Remove it from the conditionally
+ dead list, so that a conditional set won't cause us to think
it dead. */
- rcli = (struct reg_cond_life_info *) node->value;
- rcli->condition = NULL_RTX;
- splay_tree_remove (pbi->reg_cond_dead, regno);
+ splay_tree_remove (pbi->reg_cond_dead, i);
}
- }
-
#endif
+ }
}
/* Scan expression X and store a 1-bit in NEW_LIVE for each reg it uses.
return;
case MEM:
- /* Don't bother watching stores to mems if this is not the
+ /* Don't bother watching stores to mems if this is not the
final pass. We'll not be deleting dead stores this round. */
- if (flags & PROP_SCAN_DEAD_CODE)
+ if (optimize && (flags & PROP_SCAN_DEAD_CODE))
{
- /* Invalidate the data for the last MEM stored, but only if MEM is
+ /* Invalidate the data for the last MEM stored, but only if MEM is
something that can be stored into. */
- if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
+ if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
- ; /* needn't clear the memory set list */
- else
+ /* Needn't clear the memory set list. */
+ ;
+ else
{
rtx temp = pbi->mem_set_list;
rtx prev = NULL_RTX;
else
pbi->mem_set_list = next;
free_EXPR_LIST_node (temp);
+ pbi->mem_set_list_len--;
}
else
prev = temp;
x = SUBREG_REG (x);
if (GET_CODE (x) != REG)
goto retry;
- /* FALLTHRU */
+ /* Fall through. */
case REG:
/* See a register other than being set => mark it as needed. */
mark_used_regs (pbi, SET_SRC (x), cond, insn);
return;
}
-
+
/* Storing in STRICT_LOW_PART is like storing in a reg
in that this SET might be dead, so ignore it in TESTREG.
but in some other ways it is like using the reg.
testreg = XEXP (testreg, 0);
}
- /* If this is a store into a register, recursively scan the
- value being stored. */
+ /* If this is a store into a register or group of registers,
+ recursively scan the value being stored. */
if ((GET_CODE (testreg) == PARALLEL
&& GET_MODE (testreg) == BLKmode)
Consider for instance a volatile asm that changes the fpu rounding
mode. An insn should not be moved across this even if it only uses
- pseudo-regs because it might give an incorrectly rounded result.
+ pseudo-regs because it might give an incorrectly rounded result.
?!? Unfortunately, marking all hard registers as live causes massive
problems for the register allocator and marking all pseudos as live
So for now, just clear the memory set list and mark any regs
we can find in ASM_OPERANDS as used. */
if (code != ASM_OPERANDS || MEM_VOLATILE_P (x))
- free_EXPR_LIST_list (&pbi->mem_set_list);
+ {
+ free_EXPR_LIST_list (&pbi->mem_set_list);
+ pbi->mem_set_list_len = 0;
+ }
- /* For all ASM_OPERANDS, we must traverse the vector of input operands.
+ /* For all ASM_OPERANDS, we must traverse the vector of input operands.
We can not just fall through here since then we would be confused
by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
traditional asms unlike their normal usage. */
{
register const char *fmt = GET_RTX_FORMAT (code);
register int i;
-
+
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
make it do pre-increment or pre-decrement if appropriate. */
rtx x = single_set (insn);
HOST_WIDE_INT amount = ((GET_CODE (SET_SRC (x)) == PLUS ? 1 : -1)
- * INTVAL (XEXP (SET_SRC (x), 1)));
+ * INTVAL (XEXP (SET_SRC (x), 1)));
int regno = REGNO (SET_DEST (x));
rtx y = pbi->reg_next_use[regno];
if (y != 0
+ && SET_DEST (x) != stack_pointer_rtx
&& BLOCK_NUM (y) == BLOCK_NUM (insn)
/* Don't do this if the reg dies, or gets set in y; a standard addressing
mode would be better. */
&& ! dead_or_set_p (y, SET_DEST (x))
&& try_pre_increment (y, SET_DEST (x), amount))
{
- /* We have found a suitable auto-increment
- and already changed insn Y to do it.
- So flush this increment-instruction. */
- PUT_CODE (insn, NOTE);
- NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- NOTE_SOURCE_FILE (insn) = 0;
- /* Count a reference to this reg for the increment
- insn we are deleting. When a reg is incremented.
- spilling it is worse, so we want to make that
- less likely. */
+ /* We have found a suitable auto-increment and already changed
+ insn Y to do it. So flush this increment instruction. */
+ propagate_block_delete_insn (pbi->bb, insn);
+
+ /* Count a reference to this reg for the increment insn we are
+ deleting. When a reg is incremented, spilling it is worse,
+ so we want to make that less likely. */
if (regno >= FIRST_PSEUDO_REGISTER)
{
- REG_N_REFS (regno) += (optimize_size ? 1
- : pbi->bb->loop_depth + 1);
+ REG_FREQ (regno) += (optimize_size || !pbi->bb->frequency
+ ? 1 : pbi->bb->frequency);
REG_N_SETS (regno)++;
}
+
+ /* Flush any remembered memories depending on the value of
+ the incremented register. */
+ invalidate_mems_from_set (pbi, SET_DEST (x));
+
return 1;
}
return 0;
});
}
+/* Print a human-reaable representation of R on the standard error
+ stream. This function is designed to be used from within the
+ debugger. */
+
void
debug_regset (r)
regset r;
if (REG_BASIC_BLOCK (i) >= 0)
fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
if (REG_N_SETS (i))
- fprintf (file, "; set %d time%s", REG_N_SETS (i),
- (REG_N_SETS (i) == 1) ? "" : "s");
+ fprintf (file, "; set %d time%s", REG_N_SETS (i),
+ (REG_N_SETS (i) == 1) ? "" : "s");
if (REG_USERVAR_P (regno_reg_rtx[i]))
- fprintf (file, "; user var");
+ fprintf (file, "; user var");
if (REG_N_DEATHS (i) != 1)
fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
if (REG_N_CALLS_CROSSED (i) == 1)
reg_class_names[(int) class],
reg_class_names[(int) altclass]);
}
- if (REGNO_POINTER_FLAG (i))
+ if (REG_POINTER (regno_reg_rtx[i]))
fprintf (file, "; pointer");
fprintf (file, ".\n");
}
register basic_block bb = BASIC_BLOCK (i);
register edge e;
- fprintf (file, "\nBasic block %d: first insn %d, last %d, loop_depth %d, count %d.\n",
- i, INSN_UID (bb->head), INSN_UID (bb->end), bb->loop_depth, bb->count);
+ fprintf (file, "\nBasic block %d: first insn %d, last %d, loop_depth %d, count ",
+ i, INSN_UID (bb->head), INSN_UID (bb->end), bb->loop_depth);
+ fprintf (file, HOST_WIDEST_INT_PRINT_DEC, (HOST_WIDEST_INT) bb->count);
+ fprintf (file, ", freq %i.\n", bb->frequency);
fprintf (file, "Predecessors: ");
- for (e = bb->pred; e ; e = e->pred_next)
+ for (e = bb->pred; e; e = e->pred_next)
dump_edge_info (file, e, 0);
fprintf (file, "\nSuccessors: ");
- for (e = bb->succ; e ; e = e->succ_next)
+ for (e = bb->succ; e; e = e->succ_next)
dump_edge_info (file, e, 1);
fprintf (file, "\nRegisters live at start:");
fprintf (file, "\nRegisters live at end:");
dump_regset (bb->global_live_at_end, file);
- putc('\n', file);
+ putc ('\n', file);
}
- putc('\n', file);
+ putc ('\n', file);
}
void
dump_flow_info (stderr);
}
-static void
+void
dump_edge_info (file, e, do_succ)
FILE *file;
edge e;
else
fprintf (file, " %d", side->index);
+ if (e->probability)
+ fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
+
if (e->count)
- fprintf (file, " count:%d", e->count);
+ {
+ fprintf (file, " count:");
+ fprintf (file, HOST_WIDEST_INT_PRINT_DEC, (HOST_WIDEST_INT) e->count);
+ }
if (e->flags)
{
if (comma)
fputc (',', file);
- if (i < (int)(sizeof (bitnames) / sizeof (*bitnames)))
+ if (i < (int) ARRAY_SIZE (bitnames))
fputs (bitnames[i], file);
else
fprintf (file, "%d", i);
fputc (')', file);
}
}
-
\f
/* Print out one basic block with live information at start and end. */
+
void
dump_bb (bb, outf)
basic_block bb;
rtx last;
edge e;
- fprintf (outf, ";; Basic block %d, loop depth %d, count %d",
- bb->index, bb->loop_depth, bb->count);
- if (bb->eh_beg != -1 || bb->eh_end != -1)
- fprintf (outf, ", eh regions %d/%d", bb->eh_beg, bb->eh_end);
+ fprintf (outf, ";; Basic block %d, loop depth %d, count ",
+ bb->index, bb->loop_depth);
+ fprintf (outf, HOST_WIDEST_INT_PRINT_DEC, (HOST_WIDEST_INT) bb->count);
putc ('\n', outf);
fputs (";; Predecessors: ", outf);
- for (e = bb->pred; e ; e = e->pred_next)
+ for (e = bb->pred; e; e = e->pred_next)
dump_edge_info (outf, e, 0);
putc ('\n', outf);
debug_bb_n (n)
int n;
{
- dump_bb (BASIC_BLOCK(n), stderr);
+ dump_bb (BASIC_BLOCK (n), stderr);
}
/* Like print_rtl, but also print out live information for the start of each
for (x = bb->head; x != NULL_RTX; x = NEXT_INSN (x))
{
enum bb_state state = IN_MULTIPLE_BB;
- if (in_bb_p[INSN_UID(x)] == NOT_IN_BB)
+ if (in_bb_p[INSN_UID (x)] == NOT_IN_BB)
state = IN_ONE_BB;
- in_bb_p[INSN_UID(x)] = state;
+ in_bb_p[INSN_UID (x)] = state;
if (x == bb->end)
break;
putc ('\n', outf);
}
- if (in_bb_p[INSN_UID(tmp_rtx)] == NOT_IN_BB
+ if (in_bb_p[INSN_UID (tmp_rtx)] == NOT_IN_BB
&& GET_CODE (tmp_rtx) != NOTE
&& GET_CODE (tmp_rtx) != BARRIER)
fprintf (outf, ";; Insn is not within a basic block\n");
- else if (in_bb_p[INSN_UID(tmp_rtx)] == IN_MULTIPLE_BB)
+ else if (in_bb_p[INSN_UID (tmp_rtx)] == IN_MULTIPLE_BB)
fprintf (outf, ";; Insn is in multiple basic blocks\n");
did_output = print_rtl_single (outf, tmp_rtx);
}
}
-/* Compute dominator relationships using new flow graph structures. */
-void
-compute_flow_dominators (dominators, post_dominators)
- sbitmap *dominators;
- sbitmap *post_dominators;
-{
- int bb;
- sbitmap *temp_bitmap;
- edge e;
- basic_block *worklist, *workend, *qin, *qout;
- int qlen;
-
- /* Allocate a worklist array/queue. Entries are only added to the
- list if they were not already on the list. So the size is
- bounded by the number of basic blocks. */
- worklist = (basic_block *) xmalloc (sizeof (basic_block) * n_basic_blocks);
- workend = &worklist[n_basic_blocks];
-
- temp_bitmap = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
- sbitmap_vector_zero (temp_bitmap, n_basic_blocks);
-
- if (dominators)
- {
- /* The optimistic setting of dominators requires us to put every
- block on the work list initially. */
- qin = qout = worklist;
- for (bb = 0; bb < n_basic_blocks; bb++)
- {
- *qin++ = BASIC_BLOCK (bb);
- BASIC_BLOCK (bb)->aux = BASIC_BLOCK (bb);
- }
- qlen = n_basic_blocks;
- qin = worklist;
-
- /* We want a maximal solution, so initially assume everything dominates
- everything else. */
- sbitmap_vector_ones (dominators, n_basic_blocks);
-
- /* Mark successors of the entry block so we can identify them below. */
- for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
- e->dest->aux = ENTRY_BLOCK_PTR;
-
- /* Iterate until the worklist is empty. */
- while (qlen)
- {
- /* Take the first entry off the worklist. */
- basic_block b = *qout++;
- if (qout >= workend)
- qout = worklist;
- qlen--;
-
- bb = b->index;
-
- /* Compute the intersection of the dominators of all the
- predecessor blocks.
-
- If one of the predecessor blocks is the ENTRY block, then the
- intersection of the dominators of the predecessor blocks is
- defined as the null set. We can identify such blocks by the
- special value in the AUX field in the block structure. */
- if (b->aux == ENTRY_BLOCK_PTR)
- {
- /* Do not clear the aux field for blocks which are
- successors of the ENTRY block. That way we we never
- add them to the worklist again.
-
- The intersect of dominators of the preds of this block is
- defined as the null set. */
- sbitmap_zero (temp_bitmap[bb]);
- }
- else
- {
- /* Clear the aux field of this block so it can be added to
- the worklist again if necessary. */
- b->aux = NULL;
- sbitmap_intersection_of_preds (temp_bitmap[bb], dominators, bb);
- }
-
- /* Make sure each block always dominates itself. */
- SET_BIT (temp_bitmap[bb], bb);
-
- /* If the out state of this block changed, then we need to
- add the successors of this block to the worklist if they
- are not already on the worklist. */
- if (sbitmap_a_and_b (dominators[bb], dominators[bb], temp_bitmap[bb]))
- {
- for (e = b->succ; e; e = e->succ_next)
- {
- if (!e->dest->aux && e->dest != EXIT_BLOCK_PTR)
- {
- *qin++ = e->dest;
- if (qin >= workend)
- qin = worklist;
- qlen++;
-
- e->dest->aux = e;
- }
- }
- }
- }
- }
-
- if (post_dominators)
- {
- /* The optimistic setting of dominators requires us to put every
- block on the work list initially. */
- qin = qout = worklist;
- for (bb = 0; bb < n_basic_blocks; bb++)
- {
- *qin++ = BASIC_BLOCK (bb);
- BASIC_BLOCK (bb)->aux = BASIC_BLOCK (bb);
- }
- qlen = n_basic_blocks;
- qin = worklist;
-
- /* We want a maximal solution, so initially assume everything post
- dominates everything else. */
- sbitmap_vector_ones (post_dominators, n_basic_blocks);
-
- /* Mark predecessors of the exit block so we can identify them below. */
- for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
- e->src->aux = EXIT_BLOCK_PTR;
-
- /* Iterate until the worklist is empty. */
- while (qlen)
- {
- /* Take the first entry off the worklist. */
- basic_block b = *qout++;
- if (qout >= workend)
- qout = worklist;
- qlen--;
-
- bb = b->index;
-
- /* Compute the intersection of the post dominators of all the
- successor blocks.
-
- If one of the successor blocks is the EXIT block, then the
- intersection of the dominators of the successor blocks is
- defined as the null set. We can identify such blocks by the
- special value in the AUX field in the block structure. */
- if (b->aux == EXIT_BLOCK_PTR)
- {
- /* Do not clear the aux field for blocks which are
- predecessors of the EXIT block. That way we we never
- add them to the worklist again.
-
- The intersect of dominators of the succs of this block is
- defined as the null set. */
- sbitmap_zero (temp_bitmap[bb]);
- }
- else
- {
- /* Clear the aux field of this block so it can be added to
- the worklist again if necessary. */
- b->aux = NULL;
- sbitmap_intersection_of_succs (temp_bitmap[bb],
- post_dominators, bb);
- }
-
- /* Make sure each block always post dominates itself. */
- SET_BIT (temp_bitmap[bb], bb);
-
- /* If the out state of this block changed, then we need to
- add the successors of this block to the worklist if they
- are not already on the worklist. */
- if (sbitmap_a_and_b (post_dominators[bb],
- post_dominators[bb],
- temp_bitmap[bb]))
- {
- for (e = b->pred; e; e = e->pred_next)
- {
- if (!e->src->aux && e->src != ENTRY_BLOCK_PTR)
- {
- *qin++ = e->src;
- if (qin >= workend)
- qin = worklist;
- qlen++;
-
- e->src->aux = e;
- }
- }
- }
- }
- }
-
- free (worklist);
- free (temp_bitmap);
-}
-
-/* Given DOMINATORS, compute the immediate dominators into IDOM. If a
- block dominates only itself, its entry remains as INVALID_BLOCK. */
+/* Dump the rtl into the current debugging dump file, then abort. */
-void
-compute_immediate_dominators (idom, dominators)
- int *idom;
- sbitmap *dominators;
+static void
+print_rtl_and_abort_fcn (file, line, function)
+ const char *file;
+ int line;
+ const char *function;
{
- sbitmap *tmp;
- int b;
-
- tmp = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
-
- /* Begin with tmp(n) = dom(n) - { n }. */
- for (b = n_basic_blocks; --b >= 0; )
- {
- sbitmap_copy (tmp[b], dominators[b]);
- RESET_BIT (tmp[b], b);
- }
-
- /* Subtract out all of our dominator's dominators. */
- for (b = n_basic_blocks; --b >= 0; )
- {
- sbitmap tmp_b = tmp[b];
- int s;
-
- for (s = n_basic_blocks; --s >= 0; )
- if (TEST_BIT (tmp_b, s))
- sbitmap_difference (tmp_b, tmp_b, tmp[s]);
- }
-
- /* Find the one bit set in the bitmap and put it in the output array. */
- for (b = n_basic_blocks; --b >= 0; )
+ if (rtl_dump_file)
{
- int t;
- EXECUTE_IF_SET_IN_SBITMAP (tmp[b], 0, t, { idom[b] = t; });
+ print_rtl_with_bb (rtl_dump_file, get_insns ());
+ fclose (rtl_dump_file);
}
- sbitmap_vector_free (tmp);
-}
-
-/* Given POSTDOMINATORS, compute the immediate postdominators into
- IDOM. If a block is only dominated by itself, its entry remains as
- INVALID_BLOCK. */
-
-void
-compute_immediate_postdominators (idom, postdominators)
- int *idom;
- sbitmap *postdominators;
-{
- compute_immediate_dominators (idom, postdominators);
+ fancy_abort (file, line, function);
}
/* Recompute register set/reference counts immediately prior to register
int
count_or_remove_death_notes (blocks, kill)
- sbitmap blocks;
- int kill;
+ sbitmap blocks;
+ int kill;
{
int i, count = 0;
bb = BASIC_BLOCK (i);
- for (insn = bb->head; ; insn = NEXT_INSN (insn))
+ for (insn = bb->head;; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
rtx *pprev = ®_NOTES (insn);
rtx link = *pprev;
n = HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg));
count += n;
}
- /* FALLTHRU */
+ /* Fall through. */
case REG_UNUSED:
if (kill)
{
rtx next = XEXP (link, 1);
free_EXPR_LIST_node (link);
- *pprev = link = next;
- break;
+ *pprev = link = next;
+ break;
}
- /* FALLTHRU */
+ /* Fall through. */
default:
pprev = &XEXP (link, 1);
return count;
}
+
+/* Update insns block within BB. */
+
+void
+update_bb_for_insn (bb)
+ basic_block bb;
+{
+ rtx insn;
+
+ if (! basic_block_for_insn)
+ return;
+
+ for (insn = bb->head; ; insn = NEXT_INSN (insn))
+ {
+ set_block_for_insn (insn, bb);
+
+ if (insn == bb->end)
+ break;
+ }
+}
+
+
/* Record INSN's block as BB. */
void
if (uid >= basic_block_for_insn->num_elements)
{
int new_size;
-
+
/* Add one-eighth the size so we don't keep calling xrealloc. */
new_size = uid + (uid + 7) / 8;
VARRAY_BB (basic_block_for_insn, uid) = bb;
}
-/* Record INSN's block number as BB. */
-/* ??? This has got to go. */
+/* When a new insn has been inserted into an existing block, it will
+ sometimes emit more than a single insn. This routine will set the
+ block number for the specified insn, and look backwards in the insn
+ chain to see if there are any other uninitialized insns immediately
+ previous to this one, and set the block number for them too. */
void
-set_block_num (insn, bb)
+set_block_for_new_insns (insn, bb)
rtx insn;
- int bb;
+ basic_block bb;
{
- set_block_for_insn (insn, BASIC_BLOCK (bb));
+ set_block_for_insn (insn, bb);
+
+ /* Scan the previous instructions setting the block number until we find
+ an instruction that has the block number set, or we find a note
+ of any kind. */
+ for (insn = PREV_INSN (insn); insn != NULL_RTX; insn = PREV_INSN (insn))
+ {
+ if (GET_CODE (insn) == NOTE)
+ break;
+ if (INSN_UID (insn) >= basic_block_for_insn->num_elements
+ || BLOCK_FOR_INSN (insn) == 0)
+ set_block_for_insn (insn, bb);
+ else
+ break;
+ }
}
\f
/* Verify the CFG consistency. This function check some CFG invariants and
aborts when something is wrong. Hope that this function will help to
convert many optimization passes to preserve CFG consistent.
- Currently it does following checks:
+ Currently it does following checks:
- test head/end pointers
- overlapping of basic blocks
- tails of basic blocks (ensure that boundary is necesary)
- scans body of the basic block for JUMP_INSN, CODE_LABEL
and NOTE_INSN_BASIC_BLOCK
- - check that all insns are in the basic blocks
+ - check that all insns are in the basic blocks
(except the switch handling code, barriers and notes)
- check that all returns are followed by barriers
/* Work backwards from the end to the head of the basic block
to verify the head is in the RTL chain. */
- for ( ; x != NULL_RTX; x = PREV_INSN (x))
+ for (; x != NULL_RTX; x = PREV_INSN (x))
{
/* While walking over the insn chain, verify insns appear
in only one basic block and initialize the BB_INFO array
{
if (e->src != bb)
{
- fprintf (stderr, "verify_flow_info: Basic block %d succ edge is corrupted\n",
+ fprintf (stderr,
+ "verify_flow_info: Basic block %d succ edge is corrupted\n",
bb->index);
fprintf (stderr, "Predecessor: ");
dump_edge_info (stderr, e, 0);
basic_block bb = NOTE_BASIC_BLOCK (x);
num_bb_notes++;
if (bb->index != last_bb_num_seen + 1)
- fatal ("Basic blocks not numbered consecutively");
+ /* Basic blocks not numbered consecutively. */
+ abort ();
+
last_bb_num_seen = bb->index;
}
}
}
- if (GET_RTX_CLASS (GET_CODE (x)) == 'i'
+ if (INSN_P (x)
&& GET_CODE (x) == JUMP_INSN
&& returnjump_p (x) && ! condjump_p (x)
&& ! (NEXT_INSN (x) && GET_CODE (NEXT_INSN (x)) == BARRIER))
}
if (num_bb_notes != n_basic_blocks)
- fatal ("number of bb notes in insn chain (%d) != n_basic_blocks (%d)",
- num_bb_notes, n_basic_blocks);
+ internal_error
+ ("number of bb notes in insn chain (%d) != n_basic_blocks (%d)",
+ num_bb_notes, n_basic_blocks);
if (err)
abort ();
}
\f
/* Functions to access an edge list with a vector representation.
- Enough data is kept such that given an index number, the
+ Enough data is kept such that given an index number, the
pred and succ that edge represents can be determined, or
given a pred and a succ, its index number can be returned.
- This allows algorithms which consume a lot of memory to
+ This allows algorithms which consume a lot of memory to
represent the normally full matrix of edge (pred,succ) with a
single indexed vector, edge (EDGE_INDEX (pred, succ)), with no
wasted space in the client code due to sparse flow graphs. */
-/* This functions initializes the edge list. Basically the entire
+/* This functions initializes the edge list. Basically the entire
flowgraph is processed, and all edges are assigned a number,
and the data structure is filled in. */
+
struct edge_list *
create_edge_list ()
{
elist->index_to_edge[num_edges] = e;
num_edges++;
}
-
+
for (x = 0; x < n_basic_blocks; x++)
{
basic_block bb = BASIC_BLOCK (x);
}
/* This function free's memory associated with an edge list. */
+
void
free_edge_list (elist)
struct edge_list *elist;
}
/* This function provides debug output showing an edge list. */
-void
+
+void
print_edge_list (f, elist)
FILE *f;
struct edge_list *elist;
{
int x;
- fprintf(f, "Compressed edge list, %d BBs + entry & exit, and %d edges\n",
- elist->num_blocks - 2, elist->num_edges);
+ fprintf (f, "Compressed edge list, %d BBs + entry & exit, and %d edges\n",
+ elist->num_blocks - 2, elist->num_edges);
for (x = 0; x < elist->num_edges; x++)
{
fprintf (f, " %-4d - edge(", x);
if (INDEX_EDGE_PRED_BB (elist, x) == ENTRY_BLOCK_PTR)
- fprintf (f,"entry,");
+ fprintf (f, "entry,");
else
- fprintf (f,"%d,", INDEX_EDGE_PRED_BB (elist, x)->index);
+ fprintf (f, "%d,", INDEX_EDGE_PRED_BB (elist, x)->index);
if (INDEX_EDGE_SUCC_BB (elist, x) == EXIT_BLOCK_PTR)
- fprintf (f,"exit)\n");
+ fprintf (f, "exit)\n");
else
- fprintf (f,"%d)\n", INDEX_EDGE_SUCC_BB (elist, x)->index);
+ fprintf (f, "%d)\n", INDEX_EDGE_SUCC_BB (elist, x)->index);
}
}
/* This function provides an internal consistency check of an edge list,
- verifying that all edges are present, and that there are no
+ verifying that all edges are present, and that there are no
extra edges. */
+
void
verify_edge_list (f, elist)
FILE *f;
index = EDGE_INDEX (elist, e->src, e->dest);
if (index == EDGE_INDEX_NO_EDGE)
{
- fprintf (f, "*p* No index for edge from %d to %d\n",pred, succ);
+ fprintf (f, "*p* No index for edge from %d to %d\n", pred, succ);
continue;
}
if (INDEX_EDGE_PRED_BB (elist, index)->index != pred)
index = EDGE_INDEX (elist, e->src, e->dest);
if (index == EDGE_INDEX_NO_EDGE)
{
- fprintf (f, "*p* No index for edge from %d to %d\n",pred, succ);
+ fprintf (f, "*p* No index for edge from %d to %d\n", pred, succ);
continue;
}
if (INDEX_EDGE_PRED_BB (elist, index)->index != pred)
}
/* We've verified that all the edges are in the list, no lets make sure
there are no spurious edges in the list. */
-
- for (pred = 0 ; pred < n_basic_blocks; pred++)
- for (succ = 0 ; succ < n_basic_blocks; succ++)
+
+ for (pred = 0; pred < n_basic_blocks; pred++)
+ for (succ = 0; succ < n_basic_blocks; succ++)
{
- basic_block p = BASIC_BLOCK (pred);
- basic_block s = BASIC_BLOCK (succ);
+ basic_block p = BASIC_BLOCK (pred);
+ basic_block s = BASIC_BLOCK (succ);
- int found_edge = 0;
+ int found_edge = 0;
- for (e = p->succ; e; e = e->succ_next)
- if (e->dest == s)
+ for (e = p->succ; e; e = e->succ_next)
+ if (e->dest == s)
{
found_edge = 1;
break;
}
- for (e = s->pred; e; e = e->pred_next)
- if (e->src == p)
+ for (e = s->pred; e; e = e->pred_next)
+ if (e->src == p)
{
found_edge = 1;
break;
}
- if (EDGE_INDEX (elist, BASIC_BLOCK (pred), BASIC_BLOCK (succ))
+ if (EDGE_INDEX (elist, BASIC_BLOCK (pred), BASIC_BLOCK (succ))
== EDGE_INDEX_NO_EDGE && found_edge != 0)
fprintf (f, "*** Edge (%d, %d) appears to not have an index\n",
- pred, succ);
- if (EDGE_INDEX (elist, BASIC_BLOCK (pred), BASIC_BLOCK (succ))
+ pred, succ);
+ if (EDGE_INDEX (elist, BASIC_BLOCK (pred), BASIC_BLOCK (succ))
!= EDGE_INDEX_NO_EDGE && found_edge == 0)
fprintf (f, "*** Edge (%d, %d) has index %d, but there is no edge\n",
- pred, succ, EDGE_INDEX (elist, BASIC_BLOCK (pred),
+ pred, succ, EDGE_INDEX (elist, BASIC_BLOCK (pred),
BASIC_BLOCK (succ)));
}
- for (succ = 0 ; succ < n_basic_blocks; succ++)
- {
- basic_block p = ENTRY_BLOCK_PTR;
- basic_block s = BASIC_BLOCK (succ);
+ for (succ = 0; succ < n_basic_blocks; succ++)
+ {
+ basic_block p = ENTRY_BLOCK_PTR;
+ basic_block s = BASIC_BLOCK (succ);
- int found_edge = 0;
+ int found_edge = 0;
- for (e = p->succ; e; e = e->succ_next)
- if (e->dest == s)
- {
- found_edge = 1;
- break;
- }
- for (e = s->pred; e; e = e->pred_next)
- if (e->src == p)
- {
- found_edge = 1;
- break;
- }
- if (EDGE_INDEX (elist, ENTRY_BLOCK_PTR, BASIC_BLOCK (succ))
- == EDGE_INDEX_NO_EDGE && found_edge != 0)
- fprintf (f, "*** Edge (entry, %d) appears to not have an index\n",
- succ);
- if (EDGE_INDEX (elist, ENTRY_BLOCK_PTR, BASIC_BLOCK (succ))
- != EDGE_INDEX_NO_EDGE && found_edge == 0)
- fprintf (f, "*** Edge (entry, %d) has index %d, but no edge exists\n",
- succ, EDGE_INDEX (elist, ENTRY_BLOCK_PTR,
- BASIC_BLOCK (succ)));
- }
- for (pred = 0 ; pred < n_basic_blocks; pred++)
- {
- basic_block p = BASIC_BLOCK (pred);
- basic_block s = EXIT_BLOCK_PTR;
+ for (e = p->succ; e; e = e->succ_next)
+ if (e->dest == s)
+ {
+ found_edge = 1;
+ break;
+ }
+ for (e = s->pred; e; e = e->pred_next)
+ if (e->src == p)
+ {
+ found_edge = 1;
+ break;
+ }
+ if (EDGE_INDEX (elist, ENTRY_BLOCK_PTR, BASIC_BLOCK (succ))
+ == EDGE_INDEX_NO_EDGE && found_edge != 0)
+ fprintf (f, "*** Edge (entry, %d) appears to not have an index\n",
+ succ);
+ if (EDGE_INDEX (elist, ENTRY_BLOCK_PTR, BASIC_BLOCK (succ))
+ != EDGE_INDEX_NO_EDGE && found_edge == 0)
+ fprintf (f, "*** Edge (entry, %d) has index %d, but no edge exists\n",
+ succ, EDGE_INDEX (elist, ENTRY_BLOCK_PTR,
+ BASIC_BLOCK (succ)));
+ }
+ for (pred = 0; pred < n_basic_blocks; pred++)
+ {
+ basic_block p = BASIC_BLOCK (pred);
+ basic_block s = EXIT_BLOCK_PTR;
- int found_edge = 0;
+ int found_edge = 0;
- for (e = p->succ; e; e = e->succ_next)
- if (e->dest == s)
- {
- found_edge = 1;
- break;
- }
- for (e = s->pred; e; e = e->pred_next)
- if (e->src == p)
- {
- found_edge = 1;
- break;
- }
- if (EDGE_INDEX (elist, BASIC_BLOCK (pred), EXIT_BLOCK_PTR)
- == EDGE_INDEX_NO_EDGE && found_edge != 0)
- fprintf (f, "*** Edge (%d, exit) appears to not have an index\n",
- pred);
- if (EDGE_INDEX (elist, BASIC_BLOCK (pred), EXIT_BLOCK_PTR)
- != EDGE_INDEX_NO_EDGE && found_edge == 0)
- fprintf (f, "*** Edge (%d, exit) has index %d, but no edge exists\n",
- pred, EDGE_INDEX (elist, BASIC_BLOCK (pred),
- EXIT_BLOCK_PTR));
- }
+ for (e = p->succ; e; e = e->succ_next)
+ if (e->dest == s)
+ {
+ found_edge = 1;
+ break;
+ }
+ for (e = s->pred; e; e = e->pred_next)
+ if (e->src == p)
+ {
+ found_edge = 1;
+ break;
+ }
+ if (EDGE_INDEX (elist, BASIC_BLOCK (pred), EXIT_BLOCK_PTR)
+ == EDGE_INDEX_NO_EDGE && found_edge != 0)
+ fprintf (f, "*** Edge (%d, exit) appears to not have an index\n",
+ pred);
+ if (EDGE_INDEX (elist, BASIC_BLOCK (pred), EXIT_BLOCK_PTR)
+ != EDGE_INDEX_NO_EDGE && found_edge == 0)
+ fprintf (f, "*** Edge (%d, exit) has index %d, but no edge exists\n",
+ pred, EDGE_INDEX (elist, BASIC_BLOCK (pred),
+ EXIT_BLOCK_PTR));
+ }
}
/* This routine will determine what, if any, edge there is between
a specified predecessor and successor. */
+
int
find_edge_index (edge_list, pred, succ)
struct edge_list *edge_list;
}
/* This function will remove an edge from the flow graph. */
+
void
remove_edge (e)
edge e;
/* This routine will remove any fake successor edges for a basic block.
When the edge is removed, it is also removed from whatever predecessor
list it is in. */
+
static void
remove_fake_successors (bb)
basic_block bb;
{
edge e;
- for (e = bb->succ; e ; )
+ for (e = bb->succ; e;)
{
edge tmp = e;
e = e->succ_next;
/* This routine will remove all fake edges from the flow graph. If
we remove all fake successors, it will automatically remove all
fake predecessors. */
+
void
remove_fake_edges ()
{
/* This function will add a fake edge between any block which has no
successors, and the exit block. Some data flow equations require these
edges to exist. */
+
void
add_noreturn_fake_exit_edges ()
{
The current implementation is ugly, not attempting to minimize the
number of inserted fake edges. To reduce the number of fake edges
to insert, add fake edges from _innermost_ loops containing only
- nodes not reachable from the exit block. */
+ nodes not reachable from the exit block. */
+
void
connect_infinite_loops_to_exit ()
{
basic_block unvisited_block;
/* Perform depth-first search in the reverse graph to find nodes
- reachable from the exit block. */
+ reachable from the exit block. */
struct depth_first_search_dsS dfs_ds;
flow_dfs_compute_reverse_init (&dfs_ds);
flow_dfs_compute_reverse_add_bb (&dfs_ds, EXIT_BLOCK_PTR);
-
- /* Repeatedly add fake edges, updating the unreachable nodes. */
+
+ /* Repeatedly add fake edges, updating the unreachable nodes. */
while (1)
{
unvisited_block = flow_dfs_compute_reverse_execute (&dfs_ds);
}
/* Redirect an edge's successor from one block to another. */
+
void
redirect_edge_succ (e, new_succ)
edge e;
edge *pe;
/* Disconnect the edge from the old successor block. */
- for (pe = &e->dest->pred; *pe != e ; pe = &(*pe)->pred_next)
+ for (pe = &e->dest->pred; *pe != e; pe = &(*pe)->pred_next)
continue;
*pe = (*pe)->pred_next;
}
/* Redirect an edge's predecessor from one block to another. */
+
void
redirect_edge_pred (e, new_pred)
edge e;
edge *pe;
/* Disconnect the edge from the old predecessor block. */
- for (pe = &e->src->succ; *pe != e ; pe = &(*pe)->succ_next)
+ for (pe = &e->src->succ; *pe != e; pe = &(*pe)->succ_next)
continue;
*pe = (*pe)->succ_next;
}
\f
/* Dump the list of basic blocks in the bitmap NODES. */
-static void
+
+static void
flow_nodes_print (str, nodes, file)
const char *str;
const sbitmap nodes;
{
int node;
+ if (! nodes)
+ return;
+
fprintf (file, "%s { ", str);
EXECUTE_IF_SET_IN_SBITMAP (nodes, 0, node, {fprintf (file, "%d ", node);});
fputs ("}\n", file);
}
-/* Dump the list of exiting edges in the array EDGES. */
-static void
-flow_exits_print (str, edges, num_edges, file)
+/* Dump the list of edges in the array EDGE_LIST. */
+
+static void
+flow_edge_list_print (str, edge_list, num_edges, file)
const char *str;
- const edge *edges;
+ const edge *edge_list;
int num_edges;
FILE *file;
{
int i;
+ if (! edge_list)
+ return;
+
fprintf (file, "%s { ", str);
for (i = 0; i < num_edges; i++)
- fprintf (file, "%d->%d ", edges[i]->src->index, edges[i]->dest->index);
+ fprintf (file, "%d->%d ", edge_list[i]->src->index,
+ edge_list[i]->dest->index);
fputs ("}\n", file);
}
/* Dump loop related CFG information. */
+
static void
flow_loops_cfg_dump (loops, file)
const struct loops *loops;
fprintf (file, ";; %d succs { ", i);
for (succ = BASIC_BLOCK (i)->succ; succ; succ = succ->succ_next)
fprintf (file, "%d ", succ->dest->index);
- flow_nodes_print ("} dom", loops->cfg.dom[i], file);
+ flow_nodes_print ("} dom", loops->cfg.dom[i], file);
}
-
/* Dump the DFS node order. */
if (loops->cfg.dfs_order)
{
}
}
-
/* Return non-zero if the nodes of LOOP are a subset of OUTER. */
+
static int
flow_loop_nested_p (outer, loop)
struct loop *outer;
}
-/* Dump the loop information specified by LOOPS to the stream FILE. */
-void
-flow_loops_dump (loops, file, verbose)
+/* Dump the loop information specified by LOOP to the stream FILE
+ using auxiliary dump callback function LOOP_DUMP_AUX if non null. */
+void
+flow_loop_dump (loop, file, loop_dump_aux, verbose)
+ const struct loop *loop;
+ FILE *file;
+ void (*loop_dump_aux) PARAMS((const struct loop *, FILE *, int));
+ int verbose;
+{
+ if (! loop || ! loop->header)
+ return;
+
+ fprintf (file, ";;\n;; Loop %d (%d to %d):%s%s\n",
+ loop->num, INSN_UID (loop->first->head),
+ INSN_UID (loop->last->end),
+ loop->shared ? " shared" : "",
+ loop->invalid ? " invalid" : "");
+ fprintf (file, ";; header %d, latch %d, pre-header %d, first %d, last %d\n",
+ loop->header->index, loop->latch->index,
+ loop->pre_header ? loop->pre_header->index : -1,
+ loop->first->index, loop->last->index);
+ fprintf (file, ";; depth %d, level %d, outer %ld\n",
+ loop->depth, loop->level,
+ (long) (loop->outer ? loop->outer->num : -1));
+
+ if (loop->pre_header_edges)
+ flow_edge_list_print (";; pre-header edges", loop->pre_header_edges,
+ loop->num_pre_header_edges, file);
+ flow_edge_list_print (";; entry edges", loop->entry_edges,
+ loop->num_entries, file);
+ fprintf (file, ";; %d", loop->num_nodes);
+ flow_nodes_print (" nodes", loop->nodes, file);
+ flow_edge_list_print (";; exit edges", loop->exit_edges,
+ loop->num_exits, file);
+ if (loop->exits_doms)
+ flow_nodes_print (";; exit doms", loop->exits_doms, file);
+ if (loop_dump_aux)
+ loop_dump_aux (loop, file, verbose);
+}
+
+
+/* Dump the loop information specified by LOOPS to the stream FILE,
+ using auxiliary dump callback function LOOP_DUMP_AUX if non null. */
+void
+flow_loops_dump (loops, file, loop_dump_aux, verbose)
const struct loops *loops;
FILE *file;
+ void (*loop_dump_aux) PARAMS((const struct loop *, FILE *, int));
int verbose;
{
int i;
if (! num_loops || ! file)
return;
- fprintf (file, ";; %d loops found, %d levels\n",
+ fprintf (file, ";; %d loops found, %d levels\n",
num_loops, loops->levels);
for (i = 0; i < num_loops; i++)
{
struct loop *loop = &loops->array[i];
- fprintf (file, ";; loop %d (%d to %d):\n;; header %d, latch %d, pre-header %d, depth %d, level %d, outer %ld\n",
- i, INSN_UID (loop->header->head), INSN_UID (loop->latch->end),
- loop->header->index, loop->latch->index,
- loop->pre_header ? loop->pre_header->index : -1,
- loop->depth, loop->level,
- (long) (loop->outer ? (loop->outer - loops->array) : -1));
- fprintf (file, ";; %d", loop->num_nodes);
- flow_nodes_print (" nodes", loop->nodes, file);
- fprintf (file, ";; %d", loop->num_exits);
- flow_exits_print (" exits", loop->exits, loop->num_exits, file);
+ flow_loop_dump (loop, file, loop_dump_aux, verbose);
if (loop->shared)
{
must be disjoint. */
disjoint = ! flow_loop_nested_p (smaller ? loop : oloop,
smaller ? oloop : loop);
- fprintf (file,
+ fprintf (file,
";; loop header %d shared by loops %d, %d %s\n",
loop->header->index, i, j,
disjoint ? "disjoint" : "nested");
}
}
}
-
- if (verbose)
- {
- /* Print diagnostics to compare our concept of a loop with
- what the loop notes say. */
- if (GET_CODE (PREV_INSN (loop->first->head)) != NOTE
- || NOTE_LINE_NUMBER (PREV_INSN (loop->first->head))
- != NOTE_INSN_LOOP_BEG)
- fprintf (file, ";; No NOTE_INSN_LOOP_BEG at %d\n",
- INSN_UID (PREV_INSN (loop->first->head)));
- if (GET_CODE (NEXT_INSN (loop->last->end)) != NOTE
- || NOTE_LINE_NUMBER (NEXT_INSN (loop->last->end))
- != NOTE_INSN_LOOP_END)
- fprintf (file, ";; No NOTE_INSN_LOOP_END at %d\n",
- INSN_UID (NEXT_INSN (loop->last->end)));
- }
}
if (verbose)
/* Free all the memory allocated for LOOPS. */
-void
+
+void
flow_loops_free (loops)
- struct loops *loops;
+ struct loops *loops;
{
if (loops->array)
{
for (i = 0; i < loops->num; i++)
{
struct loop *loop = &loops->array[i];
-
+
+ if (loop->pre_header_edges)
+ free (loop->pre_header_edges);
if (loop->nodes)
sbitmap_free (loop->nodes);
- if (loop->exits)
- free (loop->exits);
+ if (loop->entry_edges)
+ free (loop->entry_edges);
+ if (loop->exit_edges)
+ free (loop->exit_edges);
+ if (loop->exits_doms)
+ sbitmap_free (loop->exits_doms);
}
free (loops->array);
loops->array = NULL;
-
+
if (loops->cfg.dom)
sbitmap_vector_free (loops->cfg.dom);
if (loops->cfg.dfs_order)
free (loops->cfg.dfs_order);
- sbitmap_free (loops->shared_headers);
+ if (loops->shared_headers)
+ sbitmap_free (loops->shared_headers);
+ }
+}
+
+
+/* Find the entry edges into the loop with header HEADER and nodes
+ NODES and store in ENTRY_EDGES array. Return the number of entry
+ edges from the loop. */
+
+static int
+flow_loop_entry_edges_find (header, nodes, entry_edges)
+ basic_block header;
+ const sbitmap nodes;
+ edge **entry_edges;
+{
+ edge e;
+ int num_entries;
+
+ *entry_edges = NULL;
+
+ num_entries = 0;
+ for (e = header->pred; e; e = e->pred_next)
+ {
+ basic_block src = e->src;
+
+ if (src == ENTRY_BLOCK_PTR || ! TEST_BIT (nodes, src->index))
+ num_entries++;
+ }
+
+ if (! num_entries)
+ abort ();
+
+ *entry_edges = (edge *) xmalloc (num_entries * sizeof (edge *));
+
+ num_entries = 0;
+ for (e = header->pred; e; e = e->pred_next)
+ {
+ basic_block src = e->src;
+
+ if (src == ENTRY_BLOCK_PTR || ! TEST_BIT (nodes, src->index))
+ (*entry_edges)[num_entries++] = e;
}
+
+ return num_entries;
}
-/* Find the exits from the loop using the bitmap of loop nodes NODES
- and store in EXITS array. Return the number of exits from the
- loop. */
+/* Find the exit edges from the loop using the bitmap of loop nodes
+ NODES and store in EXIT_EDGES array. Return the number of
+ exit edges from the loop. */
+
static int
-flow_loop_exits_find (nodes, exits)
+flow_loop_exit_edges_find (nodes, exit_edges)
const sbitmap nodes;
- edge **exits;
+ edge **exit_edges;
{
edge e;
int node;
int num_exits;
- *exits = NULL;
+ *exit_edges = NULL;
/* Check all nodes within the loop to see if there are any
successors not in the loop. Note that a node may have multiple
- exiting edges. */
+ exiting edges ????? A node can have one jumping edge and one fallthru
+ edge so only one of these can exit the loop. */
num_exits = 0;
EXECUTE_IF_SET_IN_SBITMAP (nodes, 0, node, {
for (e = BASIC_BLOCK (node)->succ; e; e = e->succ_next)
{
- basic_block dest = e->dest;
+ basic_block dest = e->dest;
if (dest == EXIT_BLOCK_PTR || ! TEST_BIT (nodes, dest->index))
num_exits++;
if (! num_exits)
return 0;
- *exits = (edge *) xmalloc (num_exits * sizeof (edge *));
+ *exit_edges = (edge *) xmalloc (num_exits * sizeof (edge *));
/* Store all exiting edges into an array. */
num_exits = 0;
EXECUTE_IF_SET_IN_SBITMAP (nodes, 0, node, {
for (e = BASIC_BLOCK (node)->succ; e; e = e->succ_next)
{
- basic_block dest = e->dest;
+ basic_block dest = e->dest;
if (dest == EXIT_BLOCK_PTR || ! TEST_BIT (nodes, dest->index))
- (*exits)[num_exits++] = e;
+ (*exit_edges)[num_exits++] = e;
}
});
/* Find the nodes contained within the loop with header HEADER and
latch LATCH and store in NODES. Return the number of nodes within
the loop. */
-static int
+
+static int
flow_loop_nodes_find (header, latch, nodes)
basic_block header;
basic_block latch;
for (e = node->pred; e; e = e->pred_next)
{
basic_block ancestor = e->src;
-
+
/* If each ancestor not marked as part of loop, add to set of
loop nodes and push on to stack. */
if (ancestor != ENTRY_BLOCK_PTR
return num_nodes;
}
-
/* Compute the depth first search order and store in the array
DFS_ORDER if non-zero, marking the nodes visited in VISITED. If
RC_ORDER is non-zero, return the reverse completion number for each
node. Returns the number of nodes visited. A depth first search
tries to get as far away from the starting point as quickly as
possible. */
-static int
+
+int
flow_depth_first_order_compute (dfs_order, rc_order)
int *dfs_order;
int *rc_order;
/* None of the nodes in the CFG have been visited yet. */
sbitmap_zero (visited);
-
+
/* Push the first edge on to the stack. */
stack[sp++] = ENTRY_BLOCK_PTR->succ;
e = stack[sp - 1];
src = e->src;
dest = e->dest;
-
+
/* Check if the edge destination has been visited yet. */
if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index))
{
/* Mark that we have visited the destination. */
SET_BIT (visited, dest->index);
-
+
if (dfs_order)
dfs_order[dfsnum++] = dest->index;
- if (dest->succ)
- {
- /* Since the DEST node has been visited for the first
- time, check its successors. */
- stack[sp++] = dest->succ;
- }
- else
- {
- /* There are no successors for the DEST node so assign
- its reverse completion number. */
+ if (dest->succ)
+ {
+ /* Since the DEST node has been visited for the first
+ time, check its successors. */
+ stack[sp++] = dest->succ;
+ }
+ else
+ {
+ /* There are no successors for the DEST node so assign
+ its reverse completion number. */
if (rc_order)
rc_order[rcnum--] = dest->index;
- }
+ }
}
else
{
if (! e->succ_next && src != ENTRY_BLOCK_PTR)
- {
- /* There are no more successors for the SRC node
- so assign its reverse completion number. */
+ {
+ /* There are no more successors for the SRC node
+ so assign its reverse completion number. */
if (rc_order)
rc_order[rcnum--] = src->index;
- }
-
+ }
+
if (e->succ_next)
stack[sp - 1] = e->succ_next;
else
return dfsnum;
}
-
/* Compute the depth first search order on the _reverse_ graph and
store in the array DFS_ORDER, marking the nodes visited in VISITED.
Returns the number of nodes visited.
Thus, the user will probably call ..._init(), call ..._add_bb() to
add a beginning basic block to the stack, call ..._execute(),
possibly add another bb to the stack and again call ..._execute(),
- ..., and finally call _finish(). */
+ ..., and finally call _finish(). */
/* Initialize the data structures used for depth-first search on the
reverse graph. If INITIALIZE_STACK is nonzero, the exit block is
{
/* Allocate stack for back-tracking up CFG. */
data->stack =
- (basic_block *) xmalloc ((n_basic_blocks - (INVALID_BLOCK+1))
+ (basic_block *) xmalloc ((n_basic_blocks - (INVALID_BLOCK + 1))
* sizeof (basic_block));
data->sp = 0;
/* Allocate bitmap to track nodes that have been visited. */
- data->visited_blocks
- = sbitmap_alloc (n_basic_blocks - (INVALID_BLOCK + 1));
+ data->visited_blocks = sbitmap_alloc (n_basic_blocks - (INVALID_BLOCK + 1));
/* None of the nodes in the CFG have been visited yet. */
sbitmap_zero (data->visited_blocks);
/* Add the specified basic block to the top of the dfs data
structures. When the search continues, it will start at the
- block. */
+ block. */
static void
flow_dfs_compute_reverse_add_bb (data, bb)
with the block at the stack's top and ending when the stack is
empty. Visited nodes are marked. Returns an unvisited basic
block, or NULL if there is none available. */
+
static basic_block
flow_dfs_compute_reverse_execute (data)
depth_first_search_ds data;
{
bb = data->stack[--data->sp];
- /* Mark that we have visited this node. */
- if (!TEST_BIT (data->visited_blocks, bb->index - (INVALID_BLOCK+1)))
+ /* Mark that we have visited this node. */
+ if (!TEST_BIT (data->visited_blocks, bb->index - (INVALID_BLOCK + 1)))
{
- SET_BIT (data->visited_blocks, bb->index - (INVALID_BLOCK+1));
+ SET_BIT (data->visited_blocks, bb->index - (INVALID_BLOCK + 1));
- /* Perform depth-first search on adjacent vertices. */
+ /* Perform depth-first search on adjacent vertices. */
for (e = bb->pred; e; e = e->pred_next)
flow_dfs_compute_reverse_add_bb (data, e->src);
}
}
- /* Determine if there are unvisited basic blocks. */
- for (i = n_basic_blocks - (INVALID_BLOCK+1); --i >= 0; )
+ /* Determine if there are unvisited basic blocks. */
+ for (i = n_basic_blocks - (INVALID_BLOCK + 1); --i >= 0;)
if (!TEST_BIT (data->visited_blocks, i))
- return BASIC_BLOCK (i + (INVALID_BLOCK+1));
+ return BASIC_BLOCK (i + (INVALID_BLOCK + 1));
return NULL;
}
/* Destroy the data structures needed for depth-first search on the
- reverse graph. */
+ reverse graph. */
static void
flow_dfs_compute_reverse_finish (data)
return;
}
+
+/* Find the root node of the loop pre-header extended basic block and
+ the edges along the trace from the root node to the loop header. */
+
+static void
+flow_loop_pre_header_scan (loop)
+ struct loop *loop;
+{
+ int num = 0;
+ basic_block ebb;
+
+ loop->num_pre_header_edges = 0;
+
+ if (loop->num_entries != 1)
+ return;
+
+ ebb = loop->entry_edges[0]->src;
+
+ if (ebb != ENTRY_BLOCK_PTR)
+ {
+ edge e;
+
+ /* Count number of edges along trace from loop header to
+ root of pre-header extended basic block. Usually this is
+ only one or two edges. */
+ num++;
+ while (ebb->pred->src != ENTRY_BLOCK_PTR && ! ebb->pred->pred_next)
+ {
+ ebb = ebb->pred->src;
+ num++;
+ }
+
+ loop->pre_header_edges = (edge *) xmalloc (num * sizeof (edge *));
+ loop->num_pre_header_edges = num;
+
+ /* Store edges in order that they are followed. The source
+ of the first edge is the root node of the pre-header extended
+ basic block and the destination of the last last edge is
+ the loop header. */
+ for (e = loop->entry_edges[0]; num; e = e->src->pred)
+ {
+ loop->pre_header_edges[--num] = e;
+ }
+ }
+}
+
+
/* Return the block for the pre-header of the loop with header
HEADER where DOM specifies the dominator information. Return NULL if
there is no pre-header. */
+
static basic_block
flow_loop_pre_header_find (header, dom)
basic_block header;
- const sbitmap *dom;
+ const sbitmap *dom;
{
basic_block pre_header;
edge e;
for (e = header->pred; e; e = e->pred_next)
{
basic_block node = e->src;
-
+
if (node != ENTRY_BLOCK_PTR
&& ! TEST_BIT (dom[node->index], header->index))
{
pre_header = node;
else
{
- /* There are multiple edges into the header from outside
+ /* There are multiple edges into the header from outside
the loop so there is no pre-header block. */
pre_header = NULL;
break;
return pre_header;
}
-
/* Add LOOP to the loop hierarchy tree where PREVLOOP was the loop
previously added. The insertion algorithm assumes that the loops
are added in the order found by a depth first search of the CFG. */
+
static void
flow_loop_tree_node_add (prevloop, loop)
struct loop *prevloop;
}
prevloop = prevloop->outer;
}
-
+
prevloop->next = loop;
loop->outer = NULL;
}
-
/* Build the loop hierarchy tree for LOOPS. */
+
static void
flow_loops_tree_build (loops)
- struct loops *loops;
+ struct loops *loops;
{
int i;
int num_loops;
return;
/* Root the loop hierarchy tree with the first loop found.
- Since we used a depth first search this should be the
+ Since we used a depth first search this should be the
outermost loop. */
loops->tree = &loops->array[0];
loops->tree->outer = loops->tree->inner = loops->tree->next = NULL;
flow_loop_tree_node_add (&loops->array[i - 1], &loops->array[i]);
}
-
/* Helper function to compute loop nesting depth and enclosed loop level
- for the natural loop specified by LOOP at the loop depth DEPTH.
+ for the natural loop specified by LOOP at the loop depth DEPTH.
Returns the loop level. */
+
static int
flow_loop_level_compute (loop, depth)
struct loop *loop;
return level;
}
-
/* Compute the loop nesting depth and enclosed loop level for the loop
hierarchy tree specfied by LOOPS. Return the maximum enclosed loop
level. */
}
+/* Scan a single natural loop specified by LOOP collecting information
+ about it specified by FLAGS. */
+
+int
+flow_loop_scan (loops, loop, flags)
+ struct loops *loops;
+ struct loop *loop;
+ int flags;
+{
+ /* Determine prerequisites. */
+ if ((flags & LOOP_EXITS_DOMS) && ! loop->exit_edges)
+ flags |= LOOP_EXIT_EDGES;
+
+ if (flags & LOOP_ENTRY_EDGES)
+ {
+ /* Find edges which enter the loop header.
+ Note that the entry edges should only
+ enter the header of a natural loop. */
+ loop->num_entries
+ = flow_loop_entry_edges_find (loop->header,
+ loop->nodes,
+ &loop->entry_edges);
+ }
+
+ if (flags & LOOP_EXIT_EDGES)
+ {
+ /* Find edges which exit the loop. */
+ loop->num_exits
+ = flow_loop_exit_edges_find (loop->nodes,
+ &loop->exit_edges);
+ }
+
+ if (flags & LOOP_EXITS_DOMS)
+ {
+ int j;
+
+ /* Determine which loop nodes dominate all the exits
+ of the loop. */
+ loop->exits_doms = sbitmap_alloc (n_basic_blocks);
+ sbitmap_copy (loop->exits_doms, loop->nodes);
+ for (j = 0; j < loop->num_exits; j++)
+ sbitmap_a_and_b (loop->exits_doms, loop->exits_doms,
+ loops->cfg.dom[loop->exit_edges[j]->src->index]);
+
+ /* The header of a natural loop must dominate
+ all exits. */
+ if (! TEST_BIT (loop->exits_doms, loop->header->index))
+ abort ();
+ }
+
+ if (flags & LOOP_PRE_HEADER)
+ {
+ /* Look to see if the loop has a pre-header node. */
+ loop->pre_header
+ = flow_loop_pre_header_find (loop->header, loops->cfg.dom);
+
+ /* Find the blocks within the extended basic block of
+ the loop pre-header. */
+ flow_loop_pre_header_scan (loop);
+ }
+ return 1;
+}
+
+
/* Find all the natural loops in the function and save in LOOPS structure
and recalculate loop_depth information in basic block structures.
+ FLAGS controls which loop information is collected.
Return the number of natural loops found. */
-int
-flow_loops_find (loops)
- struct loops *loops;
+int
+flow_loops_find (loops, flags)
+ struct loops *loops;
+ int flags;
{
int i;
int b;
sbitmap *dom;
int *dfs_order;
int *rc_order;
-
- loops->num = 0;
- loops->array = NULL;
- loops->tree = NULL;
- dfs_order = NULL;
- rc_order = NULL;
+
+ /* This function cannot be repeatedly called with different
+ flags to build up the loop information. The loop tree
+ must always be built if this function is called. */
+ if (! (flags & LOOP_TREE))
+ abort ();
+
+ memset (loops, 0, sizeof (*loops));
/* Taking care of this degenerate case makes the rest of
this code simpler. */
if (n_basic_blocks == 0)
return 0;
+ dfs_order = NULL;
+ rc_order = NULL;
+
/* Compute the dominators. */
dom = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
- compute_flow_dominators (dom, NULL);
+ calculate_dominance_info (NULL, dom, CDI_DOMINATORS);
/* Count the number of loop edges (back edges). This should be the
- same as the number of natural loops. Also clear the loop_depth
- and as we work from inner->outer in a loop nest we call
- find_loop_nodes_find which will increment loop_depth for nodes
- within the current loop, which happens to enclose inner loops. */
+ same as the number of natural loops. */
num_loops = 0;
for (b = 0; b < n_basic_blocks; b++)
{
- BASIC_BLOCK (b)->loop_depth = 0;
- for (e = BASIC_BLOCK (b)->pred; e; e = e->pred_next)
+ basic_block header;
+
+ header = BASIC_BLOCK (b);
+ header->loop_depth = 0;
+
+ for (e = header->pred; e; e = e->pred_next)
{
basic_block latch = e->src;
-
+
/* Look for back edges where a predecessor is dominated
by this block. A natural loop has a single entry
node (header) that dominates all the nodes in the
loop. It also has single back edge to the header
from a latch node. Note that multiple natural loops
may share the same header. */
+ if (b != header->index)
+ abort ();
+
if (latch != ENTRY_BLOCK_PTR && TEST_BIT (dom[latch->index], b))
num_loops++;
}
}
-
+
if (num_loops)
{
/* Compute depth first search order of the CFG so that outer
rc_order = (int *) xmalloc (n_basic_blocks * sizeof (int));
flow_depth_first_order_compute (dfs_order, rc_order);
+ /* Save CFG derived information to avoid recomputing it. */
+ loops->cfg.dom = dom;
+ loops->cfg.dfs_order = dfs_order;
+ loops->cfg.rc_order = rc_order;
+
/* Allocate loop structures. */
loops->array
= (struct loop *) xcalloc (num_loops, sizeof (struct loop));
-
+
headers = sbitmap_alloc (n_basic_blocks);
sbitmap_zero (headers);
{
basic_block header;
- /* Search the nodes of the CFG in DFS order that we can find
- outer loops first. */
+ /* Search the nodes of the CFG in reverse completion order
+ so that we can find outer loops first. */
header = BASIC_BLOCK (rc_order[b]);
-
+
/* Look for all the possible latch blocks for this header. */
for (e = header->pred; e; e = e->pred_next)
{
basic_block latch = e->src;
-
+
/* Look for back edges where a predecessor is dominated
by this block. A natural loop has a single entry
node (header) that dominates all the nodes in the
&& TEST_BIT (dom[latch->index], header->index))
{
struct loop *loop;
-
+
loop = loops->array + num_loops;
-
+
loop->header = header;
loop->latch = latch;
loop->num = num_loops;
-
- /* Keep track of blocks that are loop headers so
- that we can tell which loops should be merged. */
- if (TEST_BIT (headers, header->index))
- SET_BIT (loops->shared_headers, header->index);
- SET_BIT (headers, header->index);
-
- /* Find nodes contained within the loop. */
- loop->nodes = sbitmap_alloc (n_basic_blocks);
- loop->num_nodes
- = flow_loop_nodes_find (header, latch, loop->nodes);
-
- /* Compute first and last blocks within the loop.
- These are often the same as the loop header and
- loop latch respectively, but this is not always
- the case. */
- loop->first
- = BASIC_BLOCK (sbitmap_first_set_bit (loop->nodes));
- loop->last
- = BASIC_BLOCK (sbitmap_last_set_bit (loop->nodes));
-
- /* Find edges which exit the loop. Note that a node
- may have several exit edges. */
- loop->num_exits
- = flow_loop_exits_find (loop->nodes, &loop->exits);
-
- /* Look to see if the loop has a pre-header node. */
- loop->pre_header
- = flow_loop_pre_header_find (header, dom);
num_loops++;
}
}
}
-
+
+ for (i = 0; i < num_loops; i++)
+ {
+ struct loop *loop = &loops->array[i];
+
+ /* Keep track of blocks that are loop headers so
+ that we can tell which loops should be merged. */
+ if (TEST_BIT (headers, loop->header->index))
+ SET_BIT (loops->shared_headers, loop->header->index);
+ SET_BIT (headers, loop->header->index);
+
+ /* Find nodes contained within the loop. */
+ loop->nodes = sbitmap_alloc (n_basic_blocks);
+ loop->num_nodes
+ = flow_loop_nodes_find (loop->header, loop->latch, loop->nodes);
+
+ /* Compute first and last blocks within the loop.
+ These are often the same as the loop header and
+ loop latch respectively, but this is not always
+ the case. */
+ loop->first
+ = BASIC_BLOCK (sbitmap_first_set_bit (loop->nodes));
+ loop->last
+ = BASIC_BLOCK (sbitmap_last_set_bit (loop->nodes));
+
+ flow_loop_scan (loops, loop, flags);
+ }
+
/* Natural loops with shared headers may either be disjoint or
nested. Disjoint loops with shared headers cannot be inner
loops and should be merged. For now just mark loops that share
loops->num = num_loops;
- /* Save CFG derived information to avoid recomputing it. */
- loops->cfg.dom = dom;
- loops->cfg.dfs_order = dfs_order;
- loops->cfg.rc_order = rc_order;
-
/* Build the loop hierarchy tree. */
flow_loops_tree_build (loops);
}
+/* Update the information regarding the loops in the CFG
+ specified by LOOPS. */
+int
+flow_loops_update (loops, flags)
+ struct loops *loops;
+ int flags;
+{
+ /* One day we may want to update the current loop data. For now
+ throw away the old stuff and rebuild what we need. */
+ if (loops->array)
+ flow_loops_free (loops);
+
+ return flow_loops_find (loops, flags);
+}
+
+
/* Return non-zero if edge E enters header of LOOP from outside of LOOP. */
int
|| ! TEST_BIT (loop->nodes, e->src->index);
}
-
-/* Clear LOG_LINKS fields of insns in a chain.
+/* Clear LOG_LINKS fields of insns in a chain.
Also clear the global_live_at_{start,end} fields of the basic block
structures. */
int b;
for (i = insns; i; i = NEXT_INSN (i))
- if (GET_RTX_CLASS (GET_CODE (i)) == 'i')
+ if (INSN_P (i))
LOG_LINKS (i) = 0;
for (b = 0; b < n_basic_blocks; b++)
});
}
+/* Called once at intialization time. */
+
+void
+init_flow ()
+{
+ static int initialized;
+
+ if (!initialized)
+ {
+ gcc_obstack_init (&flow_obstack);
+ flow_firstobj = (char *) obstack_alloc (&flow_obstack, 0);
+ initialized = 1;
+ }
+ else
+ {
+ obstack_free (&flow_obstack, flow_firstobj);
+ flow_firstobj = (char *) obstack_alloc (&flow_obstack, 0);
+ }
+}
OSDN Git Service
