/* Define control flow data structures for the CFG.
- Copyright (C) 1987-2014 Free Software Foundation, Inc.
+ Copyright (C) 1987-2024 Free Software Foundation, Inc.
This file is part of GCC.
#ifndef GCC_BASIC_BLOCK_H
#define GCC_BASIC_BLOCK_H
-#include "predict.h"
-#include "vec.h"
-#include "hashtab.h"
-#include "hash-set.h"
-#include "machmode.h"
-#include "tm.h"
-#include "hard-reg-set.h"
-#include "input.h"
-#include "function.h"
-#include "cfgrtl.h"
-#include "cfg.h"
-#include "cfganal.h"
-#include "lcm.h"
-
-/* Use gcov_type to hold basic block counters. Should be at least
- 64bit. Although a counter cannot be negative, we use a signed
- type, because erroneous negative counts can be generated when the
- flow graph is manipulated by various optimizations. A signed type
- makes those easy to detect. */
+#include <profile-count.h>
/* Control flow edge information. */
-struct GTY((user)) edge_def {
+class GTY((user)) edge_def {
+public:
/* The two blocks at the ends of the edge. */
basic_block src;
basic_block dest;
} insns;
/* Auxiliary info specific to a pass. */
- PTR aux;
+ void *aux;
/* Location of any goto implicit in the edge. */
location_t goto_locus;
unsigned int dest_idx;
int flags; /* see cfg-flags.def */
- int probability; /* biased by REG_BR_PROB_BASE */
- gcov_type count; /* Expected number of executions calculated
- in profile.c */
+ profile_probability probability;
+
+ /* Return count of edge E. */
+ inline profile_count count () const;
};
/* Masks for edge.flags. */
#define EDGE_COMPLEX \
(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE)
-/* Structure to gather statistic about profile consistency, per pass.
- An array of this structure, indexed by pass static number, is allocated
- in passes.c. The structure is defined here so that different CFG modes
- can do their book-keeping via CFG hooks.
-
- For every field[2], field[0] is the count before the pass runs, and
- field[1] is the post-pass count. This allows us to monitor the effect
- of each individual pass on the profile consistency.
-
- This structure is not supposed to be used by anything other than passes.c
- and one CFG hook per CFG mode. */
-struct profile_record
-{
- /* The number of basic blocks where sum(freq) of the block's predecessors
- doesn't match reasonably well with the incoming frequency. */
- int num_mismatched_freq_in[2];
- /* Likewise for a basic block's successors. */
- int num_mismatched_freq_out[2];
- /* The number of basic blocks where sum(count) of the block's predecessors
- doesn't match reasonably well with the incoming frequency. */
- int num_mismatched_count_in[2];
- /* Likewise for a basic block's successors. */
- int num_mismatched_count_out[2];
- /* A weighted cost of the run-time of the function body. */
- gcov_type time[2];
- /* A weighted cost of the size of the function body. */
- int size[2];
- /* True iff this pass actually was run. */
- bool run;
-};
-
-
struct GTY(()) rtl_bb_info {
/* The first insn of the block is embedded into bb->il.x. */
/* The last insn of the block. */
vec<edge, va_gc> *succs;
/* Auxiliary info specific to a pass. */
- PTR GTY ((skip (""))) aux;
+ void *GTY ((skip (""))) aux;
/* Innermost loop containing the block. */
- struct loop *loop_father;
+ class loop *loop_father;
/* The dominance and postdominance information node. */
struct et_node * GTY ((skip (""))) dom[2];
/* The index of this block. */
int index;
- /* Expected number of executions: calculated in profile.c. */
- gcov_type count;
-
- /* Expected frequency. Normalized to be in range 0 to BB_FREQ_MAX. */
- int frequency;
-
- /* The discriminator for this block. The discriminator distinguishes
- among several basic blocks that share a common locus, allowing for
- more accurate sample-based profiling. */
- int discriminator;
+ /* Expected number of executions: calculated in profile.cc. */
+ profile_count count;
};
/* This ensures that struct gimple_bb_info is smaller than
struct rtl_bb_info, so that inlining the former into basic_block_def
is the better choice. */
-typedef int __assert_gimple_bb_smaller_rtl_bb
- [(int) sizeof (struct rtl_bb_info)
- - (int) sizeof (struct gimple_bb_info)];
-
+STATIC_ASSERT (sizeof (rtl_bb_info) >= sizeof (gimple_bb_info));
#define BB_FREQ_MAX 10000
#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. */
-};
-
-/* What sort of profiling information we have. */
-enum profile_status_d
-{
- PROFILE_ABSENT,
- PROFILE_GUESSED,
- PROFILE_READ,
- PROFILE_LAST /* Last value, used by profile streaming. */
-};
-
-/* 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
- source compatibility following the definition of this struct. */
-struct GTY(()) control_flow_graph {
- /* Block pointers for the exit and entry of a function.
- These are always the head and tail of the basic block list. */
- basic_block x_entry_block_ptr;
- basic_block x_exit_block_ptr;
-
- /* Index by basic block number, get basic block struct info. */
- vec<basic_block, va_gc> *x_basic_block_info;
-
- /* Number of basic blocks in this flow graph. */
- int x_n_basic_blocks;
-
- /* Number of edges in this flow graph. */
- int x_n_edges;
-
- /* The first free basic block number. */
- int x_last_basic_block;
-
- /* UIDs for LABEL_DECLs. */
- int last_label_uid;
-
- /* Mapping of labels to their associated blocks. At present
- only used for the gimple CFG. */
- vec<basic_block, va_gc> *x_label_to_block_map;
-
- enum profile_status_d 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];
-
- /* Maximal number of entities in the single jumptable. Used to estimate
- final flowgraph size. */
- int max_jumptable_ents;
-};
-
/* Defines for accessing the fields of the CFG structure for function FN. */
#define ENTRY_BLOCK_PTR_FOR_FN(FN) ((FN)->cfg->x_entry_block_ptr)
#define EXIT_BLOCK_PTR_FOR_FN(FN) ((FN)->cfg->x_exit_block_ptr)
/* The two blocks that are always in the cfg. */
#define NUM_FIXED_BLOCKS (2)
-
-extern edge redirect_edge_succ_nodup (edge, basic_block);
-
-/* Structure to group all of the information to process IF-THEN and
- IF-THEN-ELSE blocks for the conditional execution support. This
- needs to be in a public file in case the IFCVT macros call
- functions passing the ce_if_block data structure. */
-
-struct ce_if_block
-{
- basic_block test_bb; /* First test block. */
- basic_block then_bb; /* THEN block. */
- basic_block else_bb; /* ELSE block or NULL. */
- basic_block join_bb; /* Join THEN/ELSE blocks. */
- basic_block last_test_bb; /* Last bb to hold && or || tests. */
- int num_multiple_test_blocks; /* # of && and || basic blocks. */
- int num_and_and_blocks; /* # of && blocks. */
- int num_or_or_blocks; /* # of || blocks. */
- int num_multiple_test_insns; /* # of insns in && and || blocks. */
- int and_and_p; /* Complex test is &&. */
- int num_then_insns; /* # of insns in THEN block. */
- int num_else_insns; /* # of insns in ELSE block. */
- int pass; /* Pass number. */
-};
-
-/* The base value for branch probability notes and edge probabilities. */
-#define REG_BR_PROB_BASE 10000
-
/* This is the value which indicates no edge is present. */
#define EDGE_INDEX_NO_EDGE -1
#define BRANCH_EDGE(bb) (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \
? EDGE_SUCC ((bb), 1) : EDGE_SUCC ((bb), 0))
-#define RDIV(X,Y) (((X) + (Y) / 2) / (Y))
/* Return expected execution frequency of the edge E. */
-#define EDGE_FREQUENCY(e) RDIV ((e)->src->frequency * (e)->probability, \
- REG_BR_PROB_BASE)
+#define EDGE_FREQUENCY(e) e->count ().to_frequency (cfun)
/* Compute a scale factor (or probability) suitable for scaling of
gcov_type values via apply_probability() and apply_scale(). */
/* Returns true if BB has precisely one successor. */
-static inline bool
+inline bool
single_succ_p (const_basic_block bb)
{
return EDGE_COUNT (bb->succs) == 1;
/* Returns true if BB has precisely one predecessor. */
-static inline bool
+inline bool
single_pred_p (const_basic_block bb)
{
return EDGE_COUNT (bb->preds) == 1;
/* Returns the single successor edge of basic block BB. Aborts if
BB does not have exactly one successor. */
-static inline edge
+inline edge
single_succ_edge (const_basic_block bb)
{
gcc_checking_assert (single_succ_p (bb));
/* Returns the single predecessor edge of basic block BB. Aborts
if BB does not have exactly one predecessor. */
-static inline edge
+inline edge
single_pred_edge (const_basic_block bb)
{
gcc_checking_assert (single_pred_p (bb));
/* Returns the single successor block of basic block BB. Aborts
if BB does not have exactly one successor. */
-static inline basic_block
+inline basic_block
single_succ (const_basic_block bb)
{
return single_succ_edge (bb)->dest;
/* Returns the single predecessor block of basic block BB. Aborts
if BB does not have exactly one predecessor.*/
-static inline basic_block
+inline basic_block
single_pred (const_basic_block bb)
{
return single_pred_edge (bb)->src;
vec<edge, va_gc> **container;
};
-static inline vec<edge, va_gc> *
+inline vec<edge, va_gc> *
ei_container (edge_iterator i)
{
gcc_checking_assert (i.container);
#define ei_last(iter) ei_last_1 (&(iter))
/* Return an iterator pointing to the start of an edge vector. */
-static inline edge_iterator
+inline edge_iterator
ei_start_1 (vec<edge, va_gc> **ev)
{
edge_iterator i;
/* Return an iterator pointing to the last element of an edge
vector. */
-static inline edge_iterator
+inline edge_iterator
ei_last_1 (vec<edge, va_gc> **ev)
{
edge_iterator i;
}
/* Is the iterator `i' at the end of the sequence? */
-static inline bool
+inline bool
ei_end_p (edge_iterator i)
{
return (i.index == EDGE_COUNT (ei_container (i)));
/* Is the iterator `i' at one position before the end of the
sequence? */
-static inline bool
+inline bool
ei_one_before_end_p (edge_iterator i)
{
return (i.index + 1 == EDGE_COUNT (ei_container (i)));
}
/* Advance the iterator to the next element. */
-static inline void
+inline void
ei_next (edge_iterator *i)
{
gcc_checking_assert (i->index < EDGE_COUNT (ei_container (*i)));
}
/* Move the iterator to the previous element. */
-static inline void
+inline void
ei_prev (edge_iterator *i)
{
gcc_checking_assert (i->index > 0);
}
/* Return the edge pointed to by the iterator `i'. */
-static inline edge
+inline edge
ei_edge (edge_iterator i)
{
return EDGE_I (ei_container (i), i.index);
/* Return an edge pointed to by the iterator. Do it safely so that
NULL is returned when the iterator is pointing at the end of the
sequence. */
-static inline edge
+inline edge
ei_safe_edge (edge_iterator i)
{
return !ei_end_p (i) ? ei_edge (i) : NULL;
*Edge P is set to the next edge if we are to continue to iterate
and NULL otherwise. */
-static inline bool
+inline bool
ei_cond (edge_iterator ei, edge *p)
{
if (!ei_end_p (ei))
insns. */
#define CLEANUP_CFGLAYOUT 32 /* Do cleanup in cfglayout mode. */
#define CLEANUP_CFG_CHANGED 64 /* The caller changed the CFG. */
-
-extern void dump_flow_info (FILE *, int);
-
-/* In predict.c */
-extern bool maybe_hot_bb_p (struct function *, const_basic_block);
-extern bool maybe_hot_edge_p (edge);
-extern bool probably_never_executed_bb_p (struct function *, const_basic_block);
-extern bool probably_never_executed_edge_p (struct function *, edge);
-extern bool optimize_bb_for_size_p (const_basic_block);
-extern bool optimize_bb_for_speed_p (const_basic_block);
-extern bool optimize_edge_for_size_p (edge);
-extern bool optimize_edge_for_speed_p (edge);
-extern bool optimize_loop_for_size_p (struct loop *);
-extern bool optimize_loop_for_speed_p (struct loop *);
-extern bool optimize_loop_nest_for_size_p (struct loop *);
-extern bool optimize_loop_nest_for_speed_p (struct loop *);
-extern bool gimple_predicted_by_p (const_basic_block, enum br_predictor);
-extern bool rtl_predicted_by_p (const_basic_block, enum br_predictor);
-extern void gimple_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 (const_edge);
-extern bool br_prob_note_reliable_p (const_rtx);
-extern bool predictable_edge_p (edge);
-
-/* In cfgbuild.c. */
-extern void find_many_sub_basic_blocks (sbitmap);
-extern void rtl_make_eh_edge (sbitmap, basic_block, rtx);
-
-enum replace_direction { dir_none, dir_forward, dir_backward, dir_both };
-
-/* In cfgcleanup.c. */
-extern bool cleanup_cfg (int);
-extern int flow_find_cross_jump (basic_block, basic_block, rtx_insn **,
- rtx_insn **, enum replace_direction*);
-extern int flow_find_head_matching_sequence (basic_block, basic_block,
- rtx_insn **, rtx_insn **, int);
-
-extern bool delete_unreachable_blocks (void);
-
-extern bool inside_basic_block_p (const rtx_insn *);
-extern bool control_flow_insn_p (const rtx_insn *);
-extern rtx_insn *get_last_bb_insn (basic_block);
-
-/* In dominance.c */
-
-enum cdi_direction
-{
- CDI_DOMINATORS = 1,
- CDI_POST_DOMINATORS = 2
-};
-
-extern enum dom_state dom_info_state (function *, enum cdi_direction);
-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 (function *, enum cdi_direction);
-extern bool dom_info_available_p (enum cdi_direction);
-extern void calculate_dominance_info (enum cdi_direction);
-extern void free_dominance_info (function *, 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 basic_block nearest_common_dominator_for_set (enum cdi_direction,
- bitmap);
-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, const_basic_block, const_basic_block);
-extern vec<basic_block> get_dominated_by (enum cdi_direction, basic_block);
-extern vec<basic_block> get_dominated_by_region (enum cdi_direction,
- basic_block *,
- unsigned);
-extern vec<basic_block> get_dominated_to_depth (enum cdi_direction,
- basic_block, int);
-extern vec<basic_block> get_all_dominated_blocks (enum cdi_direction,
- 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 recompute_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,
- vec<basic_block> , bool);
-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);
-unsigned bb_dom_dfs_in (enum cdi_direction, basic_block);
-unsigned bb_dom_dfs_out (enum cdi_direction, basic_block);
-
-#include "cfghooks.h"
+#define CLEANUP_NO_PARTITIONING 128 /* Do not try to fix partitions. */
+#define CLEANUP_FORCE_FAST_DCE 0x100 /* Force run_fast_dce to be called
+ at least once. */
/* Return true if BB is in a transaction. */
-static inline bool
+inline bool
bb_in_transaction (basic_block bb)
{
return bb->flags & BB_IN_TRANSACTION;
}
/* Return true when one of the predecessor edges of BB is marked with EDGE_EH. */
-static inline bool
+inline bool
bb_has_eh_pred (basic_block bb)
{
edge e;
}
/* Return true when one of the predecessor edges of BB is marked with EDGE_ABNORMAL. */
-static inline bool
+inline bool
bb_has_abnormal_pred (basic_block bb)
{
edge e;
}
/* Return the fallthru edge in EDGES if it exists, NULL otherwise. */
-static inline edge
+inline edge
find_fallthru_edge (vec<edge, va_gc> *edges)
{
edge e;
return e;
}
-/* In cfgloopmanip.c. */
-extern edge mfb_kj_edge;
-extern bool mfb_keep_just (edge);
-
-/* In cfgexpand.c. */
-extern void rtl_profile_for_bb (basic_block);
-extern void rtl_profile_for_edge (edge);
-extern void default_rtl_profile (void);
-
-/* In profile.c. */
-typedef struct gcov_working_set_info gcov_working_set_t;
-extern gcov_working_set_t *find_working_set (unsigned pct_times_10);
-
/* Check tha probability is sane. */
-static inline void
+inline void
check_probability (int prob)
{
gcc_checking_assert (prob >= 0 && prob <= REG_BR_PROB_BASE);
/* Given PROB1 and PROB2, return PROB1*PROB2/REG_BR_PROB_BASE.
Used to combine BB probabilities. */
-static inline int
+inline int
combine_probabilities (int prob1, int prob2)
{
check_probability (prob1);
interface when potentially scaling up, so that SCALE is not
constrained to be < REG_BR_PROB_BASE. */
-static inline gcov_type
+inline gcov_type
apply_scale (gcov_type freq, gcov_type scale)
{
return RDIV (freq * scale, REG_BR_PROB_BASE);
/* Apply probability PROB on frequency or count FREQ. */
-static inline gcov_type
+inline gcov_type
apply_probability (gcov_type freq, int prob)
{
check_probability (prob);
/* Return inverse probability for PROB. */
-static inline int
+inline int
inverse_probability (int prob1)
{
check_probability (prob1);
/* Return true if BB has at least one abnormal outgoing edge. */
-static inline bool
+inline bool
has_abnormal_or_eh_outgoing_edge_p (basic_block bb)
{
edge e;
return false;
}
+
+/* Return true when one of the predecessor edges of BB is marked with
+ EDGE_ABNORMAL_CALL or EDGE_EH. */
+
+inline bool
+has_abnormal_call_or_eh_pred_edge_p (basic_block bb)
+{
+ edge e;
+ edge_iterator ei;
+
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
+ return true;
+
+ return false;
+}
+
+/* Return count of edge E. */
+inline profile_count edge_def::count () const
+{
+ return src->count.apply_probability (probability);
+}
+
#endif /* GCC_BASIC_BLOCK_H */
projects / thirdparty / gcc.git / blobdiff