#ifndef GCC_BASIC_BLOCK_H
#define GCC_BASIC_BLOCK_H
#include "bitmap.h"
#include "sbitmap.h"
#include "varray.h"
#include "partition.h"
#include "hard-reg-set.h"
#include "predict.h"
#include "vec.h"
#include "errors.h"
typedef bitmap_head regset_head;
typedef bitmap regset;
#define ALLOC_REG_SET(OBSTACK) BITMAP_ALLOC (OBSTACK)
#define FREE_REG_SET(REGSET) BITMAP_FREE (REGSET)
#define INIT_REG_SET(HEAD) bitmap_initialize (HEAD, ®_obstack)
#define CLEAR_REG_SET(HEAD) bitmap_clear (HEAD)
#define COPY_REG_SET(TO, FROM) bitmap_copy (TO, FROM)
#define REG_SET_EQUAL_P(A, B) bitmap_equal_p (A, B)
#define AND_REG_SET(TO, FROM) bitmap_and_into (TO, FROM)
#define AND_COMPL_REG_SET(TO, FROM) bitmap_and_compl_into (TO, FROM)
#define IOR_REG_SET(TO, FROM) bitmap_ior_into (TO, FROM)
#define XOR_REG_SET(TO, FROM) bitmap_xor_into (TO, FROM)
#define IOR_AND_COMPL_REG_SET(TO, FROM1, FROM2) \
bitmap_ior_and_compl_into (TO, FROM1, FROM2)
#define CLEAR_REGNO_REG_SET(HEAD, REG) bitmap_clear_bit (HEAD, REG)
#define SET_REGNO_REG_SET(HEAD, REG) bitmap_set_bit (HEAD, REG)
#define REGNO_REG_SET_P(TO, REG) bitmap_bit_p (TO, REG)
extern void reg_set_to_hard_reg_set (HARD_REG_SET *, bitmap);
#define REG_SET_TO_HARD_REG_SET(TO, FROM) \
do { \
CLEAR_HARD_REG_SET (TO); \
reg_set_to_hard_reg_set (&TO, FROM); \
} while (0)
typedef bitmap_iterator reg_set_iterator;
#define EXECUTE_IF_SET_IN_REG_SET(REGSET, MIN, REGNUM, RSI) \
EXECUTE_IF_SET_IN_BITMAP (REGSET, MIN, REGNUM, RSI)
#define EXECUTE_IF_AND_COMPL_IN_REG_SET(REGSET1, REGSET2, MIN, REGNUM, RSI) \
EXECUTE_IF_AND_COMPL_IN_BITMAP (REGSET1, REGSET2, MIN, REGNUM, RSI)
#define EXECUTE_IF_AND_IN_REG_SET(REGSET1, REGSET2, MIN, REGNUM, RSI) \
EXECUTE_IF_AND_IN_BITMAP (REGSET1, REGSET2, MIN, REGNUM, RSI) \
typedef HOST_WIDEST_INT gcov_type;
struct edge_def GTY(())
{
struct basic_block_def *src;
struct basic_block_def *dest;
union edge_def_insns {
rtx GTY ((tag ("0"))) r;
tree GTY ((tag ("1"))) t;
} GTY ((desc ("ir_type ()"))) insns;
PTR GTY ((skip (""))) aux;
source_locus goto_locus;
int flags;
int probability;
gcov_type count;
unsigned int dest_idx;
};
typedef struct edge_def *edge;
DEF_VEC_GC_P(edge);
#define EDGE_FALLTHRU 1
#define EDGE_ABNORMAL 2
#define EDGE_ABNORMAL_CALL 4
#define EDGE_EH 8
#define EDGE_FAKE 16
#define EDGE_DFS_BACK 32
#define EDGE_CAN_FALLTHRU 64
#define EDGE_IRREDUCIBLE_LOOP 128
#define EDGE_SIBCALL 256
#define EDGE_LOOP_EXIT 512
#define EDGE_TRUE_VALUE 1024
#define EDGE_FALSE_VALUE 2048
#define EDGE_EXECUTABLE 4096
#define EDGE_CROSSING 8192
#define EDGE_ALL_FLAGS 16383
#define EDGE_COMPLEX (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH)
extern const struct gcov_ctr_summary *profile_info;
struct loop;
struct loops;
struct bb_ann_d;
struct basic_block_def GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb")))
{
rtx head_;
rtx end_;
tree stmt_list;
VEC(edge) *preds;
VEC(edge) *succs;
bitmap GTY ((skip (""))) global_live_at_start;
bitmap GTY ((skip (""))) global_live_at_end;
PTR GTY ((skip (""))) aux;
struct loop * GTY ((skip (""))) loop_father;
struct et_node * GTY ((skip (""))) dom[2];
struct basic_block_def *prev_bb;
struct basic_block_def *next_bb;
struct reorder_block_def * GTY ((skip (""))) rbi;
struct bb_ann_d *tree_annotations;
gcov_type count;
int index;
int loop_depth;
int frequency;
int flags;
};
typedef struct basic_block_def *basic_block;
typedef struct reorder_block_def
{
rtx header;
rtx footer;
basic_block next;
basic_block original;
basic_block copy;
int duplicated;
int copy_number;
int visited;
} *reorder_block_def_p;
#define BB_FREQ_MAX 10000
#define BB_DIRTY 1
#define BB_NEW 2
#define BB_REACHABLE 4
#define BB_VISITED 8
#define BB_IRREDUCIBLE_LOOP 16
#define BB_SUPERBLOCK 32
#define BB_DISABLE_SCHEDULE 64
#define BB_HOT_PARTITION 128
#define BB_COLD_PARTITION 256
#define BB_UNPARTITIONED 0
#define BB_PARTITION(bb) ((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION))
#define BB_SET_PARTITION(bb, part) do { \
basic_block bb_ = (bb); \
bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) \
| (part)); \
} while (0)
#define BB_COPY_PARTITION(dstbb, srcbb) \
BB_SET_PARTITION (dstbb, BB_PARTITION (srcbb))
extern int n_basic_blocks;
extern int last_basic_block;
extern int n_edges;
extern enum profile_status
{
PROFILE_ABSENT,
PROFILE_GUESSED,
PROFILE_READ
} profile_status;
extern GTY(()) varray_type basic_block_info;
#define BASIC_BLOCK(N) (VARRAY_BB (basic_block_info, (N)))
#define FOR_BB_BETWEEN(BB, FROM, TO, DIR) \
for (BB = FROM; BB != TO; BB = BB->DIR)
#define FOR_EACH_BB(BB) \
FOR_BB_BETWEEN (BB, ENTRY_BLOCK_PTR->next_bb, EXIT_BLOCK_PTR, next_bb)
#define FOR_EACH_BB_REVERSE(BB) \
FOR_BB_BETWEEN (BB, EXIT_BLOCK_PTR->prev_bb, ENTRY_BLOCK_PTR, prev_bb)
#define FOR_BB_INSNS(BB, INSN) \
for ((INSN) = BB_HEAD (BB); \
(INSN) != NEXT_INSN (BB_END (BB)); \
(INSN) = NEXT_INSN (INSN))
#define FOR_BB_INSNS_REVERSE(BB, INSN) \
for ((INSN) = BB_END (BB); \
(INSN) != PREV_INSN (BB_HEAD (BB)); \
(INSN) = PREV_INSN (INSN))
#define FOR_ALL_BB(BB) \
for (BB = ENTRY_BLOCK_PTR; BB; BB = BB->next_bb)
extern regset regs_live_at_setjmp;
extern GTY(()) rtx label_value_list;
extern bitmap_obstack reg_obstack;
#define REG_BLOCK_UNKNOWN -1
#define REG_BLOCK_GLOBAL -2
#define REG_BASIC_BLOCK(N) (VARRAY_REG (reg_n_info, N)->basic_block)
#define BB_HEAD(B) (B)->head_
#define BB_END(B) (B)->end_
#define ENTRY_BLOCK (-1)
#define EXIT_BLOCK (-2)
#define INVALID_BLOCK (-3)
extern GTY(()) basic_block ENTRY_BLOCK_PTR;
extern GTY(()) basic_block EXIT_BLOCK_PTR;
#define BLOCK_NUM(INSN) (BLOCK_FOR_INSN (INSN)->index + 0)
#define set_block_for_insn(INSN, BB) (BLOCK_FOR_INSN (INSN) = BB)
extern void compute_bb_for_insn (void);
extern void free_bb_for_insn (void);
extern void update_bb_for_insn (basic_block);
extern void free_basic_block_vars (void);
extern void insert_insn_on_edge (rtx, edge);
bool safe_insert_insn_on_edge (rtx, edge);
extern void commit_edge_insertions (void);
extern void commit_edge_insertions_watch_calls (void);
extern void remove_fake_edges (void);
extern void remove_fake_exit_edges (void);
extern void add_noreturn_fake_exit_edges (void);
extern void connect_infinite_loops_to_exit (void);
extern edge unchecked_make_edge (basic_block, basic_block, int);
extern edge cached_make_edge (sbitmap *, basic_block, basic_block, int);
extern edge make_edge (basic_block, basic_block, int);
extern edge make_single_succ_edge (basic_block, basic_block, int);
extern void remove_edge (edge);
extern void redirect_edge_succ (edge, basic_block);
extern edge redirect_edge_succ_nodup (edge, basic_block);
extern void redirect_edge_pred (edge, basic_block);
extern basic_block create_basic_block_structure (rtx, rtx, rtx, basic_block);
extern void clear_bb_flags (void);
extern void flow_reverse_top_sort_order_compute (int *);
extern int flow_depth_first_order_compute (int *, int *);
extern int dfs_enumerate_from (basic_block, int,
bool (*)(basic_block, void *),
basic_block *, int, void *);
extern void compute_dominance_frontiers (bitmap *);
extern void dump_edge_info (FILE *, edge, int);
extern void brief_dump_cfg (FILE *);
extern void clear_edges (void);
extern rtx first_insn_after_basic_block_note (basic_block);
typedef struct ce_if_block
{
basic_block test_bb;
basic_block then_bb;
basic_block else_bb;
basic_block join_bb;
basic_block last_test_bb;
int num_multiple_test_blocks;
int num_and_and_blocks;
int num_or_or_blocks;
int num_multiple_test_insns;
int and_and_p;
int num_then_insns;
int num_else_insns;
int pass;
#ifdef IFCVT_EXTRA_FIELDS
IFCVT_EXTRA_FIELDS
#endif
} ce_if_block_t;
struct edge_list
{
int num_blocks;
int num_edges;
edge *index_to_edge;
};
#define EDGE_INDEX_NO_EDGE -1
#define EDGE_INDEX(el, pred, succ) (find_edge_index ((el), (pred), (succ)))
#define INDEX_EDGE_PRED_BB(el, index) ((el)->index_to_edge[(index)]->src)
#define INDEX_EDGE_SUCC_BB(el, index) ((el)->index_to_edge[(index)]->dest)
#define INDEX_EDGE(el, index) ((el)->index_to_edge[(index)])
#define NUM_EDGES(el) ((el)->num_edges)
#define FALLTHRU_EDGE(bb) (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \
? EDGE_SUCC ((bb), 0) : EDGE_SUCC ((bb), 1))
#define BRANCH_EDGE(bb) (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \
? EDGE_SUCC ((bb), 1) : EDGE_SUCC ((bb), 0))
#define EDGE_FREQUENCY(e) (((e)->src->frequency \
* (e)->probability \
+ REG_BR_PROB_BASE / 2) \
/ REG_BR_PROB_BASE)
#define EDGE_CRITICAL_P(e) (EDGE_COUNT ((e)->src->succs) >= 2 \
&& EDGE_COUNT ((e)->dest->preds) >= 2)
#define EDGE_COUNT(ev) VEC_length (edge, (ev))
#define EDGE_I(ev,i) VEC_index (edge, (ev), (i))
#define EDGE_PRED(bb,i) VEC_index (edge, (bb)->preds, (i))
#define EDGE_SUCC(bb,i) VEC_index (edge, (bb)->succs, (i))
typedef struct {
unsigned index;
VEC(edge) **container;
} edge_iterator;
static inline VEC(edge) *
ei_container (edge_iterator i)
{
gcc_assert (i.container);
return *i.container;
}
#define ei_start(iter) ei_start_1 (&(iter))
#define ei_last(iter) ei_last_1 (&(iter))
static inline edge_iterator
ei_start_1 (VEC(edge) **ev)
{
edge_iterator i;
i.index = 0;
i.container = ev;
return i;
}
static inline edge_iterator
ei_last_1 (VEC(edge) **ev)
{
edge_iterator i;
i.index = EDGE_COUNT (*ev) - 1;
i.container = ev;
return i;
}
static inline bool
ei_end_p (edge_iterator i)
{
return (i.index == EDGE_COUNT (ei_container (i)));
}
static inline bool
ei_one_before_end_p (edge_iterator i)
{
return (i.index + 1 == EDGE_COUNT (ei_container (i)));
}
static inline void
ei_next (edge_iterator *i)
{
gcc_assert (i->index < EDGE_COUNT (ei_container (*i)));
i->index++;
}
static inline void
ei_prev (edge_iterator *i)
{
gcc_assert (i->index > 0);
i->index--;
}
static inline edge
ei_edge (edge_iterator i)
{
return EDGE_I (ei_container (i), i.index);
}
static inline edge
ei_safe_edge (edge_iterator i)
{
return !ei_end_p (i) ? ei_edge (i) : NULL;
}
#define FOR_EACH_EDGE(EDGE,ITER,EDGE_VEC) \
for ((EDGE) = NULL, (ITER) = ei_start ((EDGE_VEC)); \
((EDGE) = ei_safe_edge ((ITER))); \
ei_next (&(ITER)))
struct edge_list * create_edge_list (void);
void free_edge_list (struct edge_list *);
void print_edge_list (FILE *, struct edge_list *);
void verify_edge_list (FILE *, struct edge_list *);
int find_edge_index (struct edge_list *, basic_block, basic_block);
edge find_edge (basic_block, basic_block);
enum update_life_extent
{
UPDATE_LIFE_LOCAL = 0,
UPDATE_LIFE_GLOBAL = 1,
UPDATE_LIFE_GLOBAL_RM_NOTES = 2
};
#define PROP_DEATH_NOTES 1
#define PROP_LOG_LINKS 2
#define PROP_REG_INFO 4
#define PROP_KILL_DEAD_CODE 8
#define PROP_SCAN_DEAD_CODE 16
#define PROP_ALLOW_CFG_CHANGES 32
#define PROP_AUTOINC 64
#define PROP_EQUAL_NOTES 128
#define PROP_SCAN_DEAD_STORES 256
#define PROP_ASM_SCAN 512
#define PROP_FINAL (PROP_DEATH_NOTES | PROP_LOG_LINKS \
| PROP_REG_INFO | PROP_KILL_DEAD_CODE \
| PROP_SCAN_DEAD_CODE | PROP_AUTOINC \
| PROP_ALLOW_CFG_CHANGES \
| PROP_SCAN_DEAD_STORES)
#define PROP_POSTRELOAD (PROP_DEATH_NOTES \
| PROP_KILL_DEAD_CODE \
| PROP_SCAN_DEAD_CODE \
| PROP_SCAN_DEAD_STORES)
#define CLEANUP_EXPENSIVE 1
#define CLEANUP_CROSSJUMP 2
#define CLEANUP_POST_REGSTACK 4
#define CLEANUP_PRE_LOOP 8
#define CLEANUP_UPDATE_LIFE 16
#define CLEANUP_THREADING 32
#define CLEANUP_NO_INSN_DEL 64
#define CLEANUP_CFGLAYOUT 128
#define CLEANUP_LOG_LINKS 256
extern void life_analysis (FILE *, int);
extern int update_life_info (sbitmap, enum update_life_extent, int);
extern int update_life_info_in_dirty_blocks (enum update_life_extent, int);
extern int count_or_remove_death_notes (sbitmap, int);
extern int propagate_block (basic_block, regset, regset, regset, int);
struct propagate_block_info;
extern rtx propagate_one_insn (struct propagate_block_info *, rtx);
extern struct propagate_block_info *init_propagate_block_info
(basic_block, regset, regset, regset, int);
extern void free_propagate_block_info (struct propagate_block_info *);
extern struct edge_list *pre_edge_lcm (FILE *, int, sbitmap *, sbitmap *,
sbitmap *, sbitmap *, sbitmap **,
sbitmap **);
extern struct edge_list *pre_edge_rev_lcm (FILE *, int, sbitmap *,
sbitmap *, sbitmap *,
sbitmap *, sbitmap **,
sbitmap **);
extern void compute_available (sbitmap *, sbitmap *, sbitmap *, sbitmap *);
extern int optimize_mode_switching (FILE *);
extern void estimate_probability (struct loops *);
extern void expected_value_to_br_prob (void);
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 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 init_flow (void);
extern void debug_bb (basic_block);
extern basic_block debug_bb_n (int);
extern void dump_regset (regset, FILE *);
extern void debug_regset (regset);
extern void allocate_reg_life_data (void);
extern void expunge_block (basic_block);
extern void link_block (basic_block, basic_block);
extern void unlink_block (basic_block);
extern void compact_blocks (void);
extern basic_block alloc_block (void);
extern void find_unreachable_blocks (void);
extern int delete_noop_moves (void);
extern basic_block force_nonfallthru (edge);
extern rtx block_label (basic_block);
extern bool forwarder_block_p (basic_block);
extern bool purge_all_dead_edges (int);
extern bool purge_dead_edges (basic_block);
extern void find_sub_basic_blocks (basic_block);
extern void find_many_sub_basic_blocks (sbitmap);
extern void rtl_make_eh_edge (sbitmap *, basic_block, rtx);
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_edge_list_print (const char *, const edge *, int, FILE *);
extern void alloc_aux_for_block (basic_block, int);
extern void alloc_aux_for_blocks (int);
extern void clear_aux_for_blocks (void);
extern void free_aux_for_blocks (void);
extern void alloc_aux_for_edge (edge, int);
extern void alloc_aux_for_edges (int);
extern void clear_aux_for_edges (void);
extern void free_aux_for_edges (void);
extern void find_basic_blocks (rtx);
extern bool cleanup_cfg (int);
extern bool delete_unreachable_blocks (void);
extern bool merge_seq_blocks (void);
typedef struct conflict_graph_def *conflict_graph;
typedef int (*conflict_graph_enum_fn) (int, int, void *);
extern conflict_graph conflict_graph_new
(int);
extern void conflict_graph_delete (conflict_graph);
extern int conflict_graph_add (conflict_graph, int, int);
extern int conflict_graph_conflict_p (conflict_graph, int, int);
extern void conflict_graph_enum (conflict_graph, int, conflict_graph_enum_fn,
void *);
extern void conflict_graph_merge_regs (conflict_graph, int, int);
extern void conflict_graph_print (conflict_graph, FILE*);
extern bool mark_dfs_back_edges (void);
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 void reorder_basic_blocks (unsigned int);
extern void duplicate_computed_gotos (void);
extern void partition_hot_cold_basic_blocks (void);
extern void alloc_rbi_pool (void);
extern void initialize_bb_rbi (basic_block bb);
extern void free_rbi_pool (void);
enum cdi_direction
{
CDI_DOMINATORS,
CDI_POST_DOMINATORS
};
enum dom_state
{
DOM_NONE,
DOM_NO_FAST_QUERY,
DOM_OK
};
extern enum dom_state dom_computed[2];
extern bool dom_info_available_p (enum cdi_direction);
extern void calculate_dominance_info (enum cdi_direction);
extern void free_dominance_info (enum cdi_direction);
extern basic_block nearest_common_dominator (enum cdi_direction,
basic_block, basic_block);
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 int get_dominated_by (enum cdi_direction, basic_block, basic_block **);
extern unsigned get_dominated_by_region (enum cdi_direction, basic_block *,
unsigned, basic_block *);
extern void add_to_dominance_info (enum cdi_direction, basic_block);
extern void delete_from_dominance_info (enum cdi_direction, basic_block);
basic_block recount_dominator (enum cdi_direction, basic_block);
extern void redirect_immediate_dominators (enum cdi_direction, basic_block,
basic_block);
extern void iterate_fix_dominators (enum cdi_direction, basic_block *, int);
extern void verify_dominators (enum cdi_direction);
extern basic_block first_dom_son (enum cdi_direction, basic_block);
extern basic_block next_dom_son (enum cdi_direction, basic_block);
extern edge try_redirect_by_replacing_jump (edge, basic_block, bool);
extern void break_superblocks (void);
extern void check_bb_profile (basic_block, FILE *);
extern void update_bb_profile_for_threading (basic_block, int, gcov_type, edge);
#include "cfghooks.h"
#endif