/* Define control and data flow tables, and regsets.
Copyright (C) 1987, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- 2005, 2006, 2007 Free Software Foundation, Inc.
+ 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
This file is part of GCC.
#define REGNO_REG_SET_P(TO, REG) bitmap_bit_p (TO, REG)
/* Copy the hard registers in a register set to the hard register set. */
-extern void reg_set_to_hard_reg_set (HARD_REG_SET *, bitmap);
+extern void reg_set_to_hard_reg_set (HARD_REG_SET *, const_bitmap);
#define REG_SET_TO_HARD_REG_SET(TO, FROM) \
do { \
CLEAR_HARD_REG_SET (TO); \
PTR GTY ((skip (""))) aux;
/* Location of any goto implicit in the edge, during tree-ssa. */
- source_locus goto_locus;
+ location_t goto_locus;
+
+ /* The index number corresponding to this edge in the edge vector
+ dest->preds. */
+ unsigned int dest_idx;
int flags; /* see EDGE_* below */
int probability; /* biased by REG_BR_PROB_BASE */
gcov_type count; /* Expected number of executions calculated
in profile.c */
-
- /* The index number corresponding to this edge in the edge vector
- dest->preds. */
- unsigned int dest_idx;
};
typedef struct edge_def *edge;
+typedef const struct edge_def *const_edge;
DEF_VEC_P(edge);
DEF_VEC_ALLOC_P(edge,gc);
DEF_VEC_ALLOC_P(edge,heap);
};
typedef struct basic_block_def *basic_block;
+typedef const struct basic_block_def *const_basic_block;
DEF_VEC_P(basic_block);
DEF_VEC_ALLOC_P(basic_block,gc);
#define BB_COPY_PARTITION(dstbb, srcbb) \
BB_SET_PARTITION (dstbb, BB_PARTITION (srcbb))
+/* State of dominance information. */
+
+enum dom_state
+{
+ DOM_NONE, /* Not computed at all. */
+ DOM_NO_FAST_QUERY, /* The data is OK, but the fast query data are not usable. */
+ DOM_OK /* Everything is ok. */
+};
+
/* A structure to group all the per-function control flow graph data.
The x_* prefixing is necessary because otherwise references to the
fields of this struct are interpreted as the defines for backward
PROFILE_GUESSED,
PROFILE_READ
} x_profile_status;
+
+ /* Whether the dominators and the postdominators are available. */
+ enum dom_state x_dom_computed[2];
+
+ /* Number of basic blocks in the dominance tree. */
+ unsigned x_n_bbs_in_dom_tree[2];
};
/* Defines for accessing the fields of the CFG structure for function FN. */
extern int inverted_post_order_compute (int *);
extern int pre_and_rev_post_order_compute (int *, int *, bool);
extern int dfs_enumerate_from (basic_block, int,
- bool (*)(basic_block, void *),
- basic_block *, int, void *);
+ bool (*)(const_basic_block, const void *),
+ basic_block *, int, const void *);
extern void compute_dominance_frontiers (bitmap *);
extern void dump_bb_info (basic_block, bool, bool, int, const char *, FILE *);
extern void dump_edge_info (FILE *, edge, int);
/* Returns true if BB has precisely one successor. */
static inline bool
-single_succ_p (basic_block bb)
+single_succ_p (const_basic_block bb)
{
return EDGE_COUNT (bb->succs) == 1;
}
/* Returns true if BB has precisely one predecessor. */
static inline bool
-single_pred_p (basic_block bb)
+single_pred_p (const_basic_block bb)
{
return EDGE_COUNT (bb->preds) == 1;
}
BB does not have exactly one successor. */
static inline edge
-single_succ_edge (basic_block bb)
+single_succ_edge (const_basic_block bb)
{
gcc_assert (single_succ_p (bb));
return EDGE_SUCC (bb, 0);
if BB does not have exactly one predecessor. */
static inline edge
-single_pred_edge (basic_block bb)
+single_pred_edge (const_basic_block bb)
{
gcc_assert (single_pred_p (bb));
return EDGE_PRED (bb, 0);
if BB does not have exactly one successor. */
static inline basic_block
-single_succ (basic_block bb)
+single_succ (const_basic_block bb)
{
return single_succ_edge (bb)->dest;
}
if BB does not have exactly one predecessor.*/
static inline basic_block
-single_pred (basic_block bb)
+single_pred (const_basic_block bb)
{
return single_pred_edge (bb)->src;
}
insns. */
#define CLEANUP_CFGLAYOUT 32 /* Do cleanup in cfglayout mode. */
-/* The following are ORed in on top of the CLEANUP* flags in calls to
- struct_equiv_block_eq. */
-#define STRUCT_EQUIV_START 64 /* Initializes the search range. */
-#define STRUCT_EQUIV_RERUN 128 /* Rerun to find register use in
- found equivalence. */
-#define STRUCT_EQUIV_FINAL 256 /* Make any changes necessary to get
- actual equivalence. */
-#define STRUCT_EQUIV_NEED_FULL_BLOCK 512 /* struct_equiv_block_eq is required
- to match only full blocks */
-#define STRUCT_EQUIV_MATCH_JUMPS 1024 /* Also include the jumps at the end of the block in the comparison. */
-
/* In lcm.c */
extern struct edge_list *pre_edge_lcm (int, sbitmap *, sbitmap *,
sbitmap *, sbitmap *, sbitmap **,
extern void compute_available (sbitmap *, sbitmap *, sbitmap *, sbitmap *);
/* In predict.c */
-extern bool maybe_hot_bb_p (basic_block);
-extern bool probably_cold_bb_p (basic_block);
-extern bool probably_never_executed_bb_p (basic_block);
-extern bool tree_predicted_by_p (basic_block, enum br_predictor);
-extern bool rtl_predicted_by_p (basic_block, enum br_predictor);
+extern bool maybe_hot_bb_p (const_basic_block);
+extern bool probably_cold_bb_p (const_basic_block);
+extern bool probably_never_executed_bb_p (const_basic_block);
+extern bool tree_predicted_by_p (const_basic_block, enum br_predictor);
+extern bool rtl_predicted_by_p (const_basic_block, enum br_predictor);
extern void tree_predict_edge (edge, enum br_predictor, int);
extern void rtl_predict_edge (edge, enum br_predictor, int);
extern void predict_edge_def (edge, enum br_predictor, enum prediction);
extern void guess_outgoing_edge_probabilities (basic_block);
extern void remove_predictions_associated_with_edge (edge);
-extern bool edge_probability_reliable_p (edge);
-extern bool br_prob_note_reliable_p (rtx);
+extern bool edge_probability_reliable_p (const_edge);
+extern bool br_prob_note_reliable_p (const_rtx);
/* In cfg.c */
extern void dump_regset (regset, FILE *);
/* In cfganal.c */
extern void find_unreachable_blocks (void);
-extern bool forwarder_block_p (basic_block);
+extern bool forwarder_block_p (const_basic_block);
extern bool can_fallthru (basic_block, basic_block);
extern bool could_fall_through (basic_block, basic_block);
-extern void flow_nodes_print (const char *, const sbitmap, FILE *);
+extern void flow_nodes_print (const char *, const_sbitmap, FILE *);
extern void flow_edge_list_print (const char *, const edge *, int, FILE *);
/* In cfgrtl.c */
extern void set_edge_can_fallthru_flag (void);
extern void update_br_prob_note (basic_block);
extern void fixup_abnormal_edges (void);
-extern bool inside_basic_block_p (rtx);
-extern bool control_flow_insn_p (rtx);
+extern bool inside_basic_block_p (const_rtx);
+extern bool control_flow_insn_p (const_rtx);
extern rtx get_last_bb_insn (basic_block);
/* In bb-reorder.c */
CDI_POST_DOMINATORS = 2
};
-enum dom_state
-{
- DOM_NONE, /* Not computed at all. */
- DOM_NO_FAST_QUERY, /* The data is OK, but the fast query data are not usable. */
- DOM_OK /* Everything is ok. */
-};
-
extern enum dom_state dom_info_state (enum cdi_direction);
extern void set_dom_info_availability (enum cdi_direction, enum dom_state);
extern bool dom_info_available_p (enum cdi_direction);
extern void set_immediate_dominator (enum cdi_direction, basic_block,
basic_block);
extern basic_block get_immediate_dominator (enum cdi_direction, basic_block);
-extern bool dominated_by_p (enum cdi_direction, basic_block, basic_block);
+extern bool dominated_by_p (enum cdi_direction, const_basic_block, const_basic_block);
extern VEC (basic_block, heap) *get_dominated_by (enum cdi_direction, basic_block);
extern VEC (basic_block, heap) *get_dominated_by_region (enum cdi_direction,
basic_block *,
#include "cfghooks.h"
-/* In struct-equiv.c */
-
-/* Constants used to size arrays in struct equiv_info (currently only one).
- When these limits are exceeded, struct_equiv returns zero.
- The maximum number of pseudo registers that are different in the two blocks,
- but appear in equivalent places and are dead at the end (or where one of
- a pair is dead at the end). */
-#define STRUCT_EQUIV_MAX_LOCAL 16
-/* The maximum number of references to an input register that struct_equiv
- can handle. */
-
-/* Structure used to track state during struct_equiv that can be rolled
- back when we find we can't match an insn, or if we want to match part
- of it in a different way.
- This information pertains to the pair of partial blocks that has been
- matched so far. Since this pair is structurally equivalent, this is
- conceptually just one partial block expressed in two potentially
- different ways. */
-struct struct_equiv_checkpoint
-{
- int ninsns; /* Insns are matched so far. */
- int local_count; /* Number of block-local registers. */
- int input_count; /* Number of inputs to the block. */
-
- /* X_START and Y_START are the first insns (in insn stream order)
- of the partial blocks that have been considered for matching so far.
- Since we are scanning backwards, they are also the instructions that
- are currently considered - or the last ones that have been considered -
- for matching (Unless we tracked back to these because a preceding
- instruction failed to match). */
- rtx x_start, y_start;
-
- /* INPUT_VALID indicates if we have actually set up X_INPUT / Y_INPUT
- during the current pass; we keep X_INPUT / Y_INPUT around between passes
- so that we can match REG_EQUAL / REG_EQUIV notes referring to these. */
- bool input_valid;
-
- /* Some information would be expensive to exactly checkpoint, so we
- merely increment VERSION any time information about local
- registers, inputs and/or register liveness changes. When backtracking,
- it is decremented for changes that can be undone, and if a discrepancy
- remains, NEED_RERUN in the relevant struct equiv_info is set to indicate
- that a new pass should be made over the entire block match to get
- accurate register information. */
- int version;
-};
-
-/* A struct equiv_info is used to pass information to struct_equiv and
- to gather state while two basic blocks are checked for structural
- equivalence. */
-
-struct equiv_info
-{
- /* Fields set up by the caller to struct_equiv_block_eq */
-
- basic_block x_block, y_block; /* The two blocks being matched. */
-
- /* MODE carries the mode bits from cleanup_cfg if we are called from
- try_crossjump_to_edge, and additionally it carries the
- STRUCT_EQUIV_* bits described above. */
- int mode;
-
- /* INPUT_COST is the cost that adding an extra input to the matched blocks
- is supposed to have, and is taken into account when considering if the
- matched sequence should be extended backwards. input_cost < 0 means
- don't accept any inputs at all. */
- int input_cost;
-
-
- /* Fields to track state inside of struct_equiv_block_eq. Some of these
- are also outputs. */
-
- /* X_INPUT and Y_INPUT are used by struct_equiv to record a register that
- is used as an input parameter, i.e. where different registers are used
- as sources. This is only used for a register that is live at the end
- of the blocks, or in some identical code at the end of the blocks;
- Inputs that are dead at the end go into X_LOCAL / Y_LOCAL. */
- rtx x_input, y_input;
- /* When a previous pass has identified a valid input, INPUT_REG is set
- by struct_equiv_block_eq, and it is henceforth replaced in X_BLOCK
- for the input. */
- rtx input_reg;
-
- /* COMMON_LIVE keeps track of the registers which are currently live
- (as we scan backwards from the end) and have the same numbers in both
- blocks. N.B. a register that is in common_live is unsuitable to become
- a local reg. */
- regset common_live;
- /* Likewise, X_LOCAL_LIVE / Y_LOCAL_LIVE keep track of registers that are
- local to one of the blocks; these registers must not be accepted as
- identical when encountered in both blocks. */
- regset x_local_live, y_local_live;
-
- /* EQUIV_USED indicates for which insns a REG_EQUAL or REG_EQUIV note is
- being used, to avoid having to backtrack in the next pass, so that we
- get accurate life info for this insn then. For each such insn,
- the bit with the number corresponding to the CUR.NINSNS value at the
- time of scanning is set. */
- bitmap equiv_used;
-
- /* Current state that can be saved & restored easily. */
- struct struct_equiv_checkpoint cur;
- /* BEST_MATCH is used to store the best match so far, weighing the
- cost of matched insns COSTS_N_INSNS (CUR.NINSNS) against the cost
- CUR.INPUT_COUNT * INPUT_COST of setting up the inputs. */
- struct struct_equiv_checkpoint best_match;
- /* If a checkpoint restore failed, or an input conflict newly arises,
- NEED_RERUN is set. This has to be tested by the caller to re-run
- the comparison if the match appears otherwise sound. The state kept in
- x_start, y_start, equiv_used and check_input_conflict ensures that
- we won't loop indefinitely. */
- bool need_rerun;
- /* If there is indication of an input conflict at the end,
- CHECK_INPUT_CONFLICT is set so that we'll check for input conflicts
- for each insn in the next pass. This is needed so that we won't discard
- a partial match if there is a longer match that has to be abandoned due
- to an input conflict. */
- bool check_input_conflict;
- /* HAD_INPUT_CONFLICT is set if CHECK_INPUT_CONFLICT was already set and we
- have passed a point where there were multiple dying inputs. This helps
- us decide if we should set check_input_conflict for the next pass. */
- bool had_input_conflict;
-
- /* LIVE_UPDATE controls if we want to change any life info at all. We
- set it to false during REG_EQUAL / REG_EUQIV note comparison of the final
- pass so that we don't introduce new registers just for the note; if we
- can't match the notes without the current register information, we drop
- them. */
- bool live_update;
-
- /* X_LOCAL and Y_LOCAL are used to gather register numbers of register pairs
- that are local to X_BLOCK and Y_BLOCK, with CUR.LOCAL_COUNT being the index
- to the next free entry. */
- rtx x_local[STRUCT_EQUIV_MAX_LOCAL], y_local[STRUCT_EQUIV_MAX_LOCAL];
- /* LOCAL_RVALUE is nonzero if the corresponding X_LOCAL / Y_LOCAL entry
- was a source operand (including STRICT_LOW_PART) for the last invocation
- of struct_equiv mentioning it, zero if it was a destination-only operand.
- Since we are scanning backwards, this means the register is input/local
- for the (partial) block scanned so far. */
- bool local_rvalue[STRUCT_EQUIV_MAX_LOCAL];
-
-
- /* Additional fields that are computed for the convenience of the caller. */
-
- /* DYING_INPUTS is set to the number of local registers that turn out
- to be inputs to the (possibly partial) block. */
- int dying_inputs;
- /* X_END and Y_END are the last insns in X_BLOCK and Y_BLOCK, respectively,
- that are being compared. A final jump insn will not be included. */
- rtx x_end, y_end;
-
- /* If we are matching tablejumps, X_LABEL in X_BLOCK corresponds to
- Y_LABEL in Y_BLOCK. */
- rtx x_label, y_label;
-
-};
-
-extern bool insns_match_p (rtx, rtx, struct equiv_info *);
-extern int struct_equiv_block_eq (int, struct equiv_info *);
-extern bool struct_equiv_init (int, struct equiv_info *);
-extern bool rtx_equiv_p (rtx *, rtx, int, struct equiv_info *);
-
-/* In cfgrtl.c */
-extern bool condjump_equiv_p (struct equiv_info *, bool);
-
/* Return true when one of the predecessor edges of BB is marked with EDGE_EH. */
static inline bool
bb_has_eh_pred (basic_block bb)
return false;
}
+/* Return true when one of the predecessor edges of BB is marked with EDGE_ABNORMAL. */
+static inline bool
+bb_has_abnormal_pred (basic_block bb)
+{
+ edge e;
+ edge_iterator ei;
+
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ {
+ if (e->flags & EDGE_ABNORMAL)
+ return true;
+ }
+ return false;
+}
+
/* In cfgloopmanip.c. */
extern edge mfb_kj_edge;
bool mfb_keep_just (edge);
OSDN Git Service
