+2005-05-27 Kazu Hirata <kazu@cs.umass.edu>
+
+ * basic-block.h (basic_block_def): Add phi_nodes and
+ predictions. Remove tree_annotations.
+ * predict.c (tree_predicted_by_p, tree_predict_edge,
+ combine_predictions_for_bb): Adjust references to predictions.
+ * tree-cfg.c (init_empty_tree_cfg, create_bb): Don't call
+ create_block_annotation.
+ (create_block_annotation, free_blocks_annotatios,
+ clear_blocks_annotations): Remove.
+ (dump_cfg_stats): Don't print out the memory spent on
+ bb_ann_d.
+ (delete_tree_cfg_annotations): Don't call free_blocks_annotations.
+ * tree-flow-inline.h (bb_ann): Remove.
+ (phi_nodes, set_phi_nodes): Update references to phi_nodes.
+ * tree-flow.h (bb_ann_d): Remove.
+ * tree-if-conv.c (process_phi_nodes): Update a reference to
+ phi_nodes.
+ * tree-phinodes.c (reserve_phi_args_for_new_edge,
+ create_phi_node, remove_phi_node): Likewise.
+ * tree-pretty-print.c (dump_generic_bb_buff): Don't call bb_ann.
+ * tree-ssa-dom.c (threaded_blocks): New.
+ (tree_ssa_dominator_optimize): Initialize, clear, and free
+ threaded_blocks. Update a call to thread_through_all_blocks.
+ (thread_across_edge): Use threaded_blocks instead of setting
+ incoming_edge_threaded.
+ * tree-ssa-threadupdate.c (threaded_through_all_blocks): Take
+ a bitmap of blocks that are threaded through.
+ * tree.h: Move the prototype of threaded_through_blocks to
+ tree-flow.h.
+
2005-05-27 Jan Hubicka <jh@suse.cz>
* cgraph.c: Include tree-gimple.h
/* Declared in tree-flow.h. */
struct bb_ann_d;
+/* Declared in tree-flow.h. */
+struct edge_prediction;
+
/* A basic block is a sequence of instructions with only entry and
only one exit. If any one of the instructions are executed, they
will all be executed, and in sequence from first to last.
/* The data used by basic block copying and reordering functions. */
struct reorder_block_def * rbi;
- /* Annotations used at the tree level. */
- struct bb_ann_d *tree_annotations;
+ /* Chain of PHI nodes for this block. */
+ tree phi_nodes;
+
+ /* A list of predictions. */
+ struct edge_prediction *predictions;
/* Expected number of executions: calculated in profile.c. */
gcov_type count;
bool
tree_predicted_by_p (basic_block bb, enum br_predictor predictor)
{
- struct edge_prediction *i = bb_ann (bb)->predictions;
- for (i = bb_ann (bb)->predictions; i; i = i->next)
+ struct edge_prediction *i;
+ for (i = bb->predictions; i; i = i->next)
if (i->predictor == predictor)
return true;
return false;
{
struct edge_prediction *i = ggc_alloc (sizeof (struct edge_prediction));
- i->next = bb_ann (e->src)->predictions;
- bb_ann (e->src)->predictions = i;
+ i->next = e->src->predictions;
+ e->src->predictions = i;
i->probability = probability;
i->predictor = predictor;
i->edge = e;
{
if (!bb->count)
set_even_probabilities (bb);
- bb_ann (bb)->predictions = NULL;
+ bb->predictions = NULL;
if (file)
fprintf (file, "%i edges in bb %i predicted to even probabilities\n",
nedges, bb->index);
/* We implement "first match" heuristics and use probability guessed
by predictor with smallest index. */
- for (pred = bb_ann (bb)->predictions; pred; pred = pred->next)
+ for (pred = bb->predictions; pred; pred = pred->next)
{
int predictor = pred->predictor;
int probability = pred->probability;
combined_probability = best_probability;
dump_prediction (file, PRED_COMBINED, combined_probability, bb, true);
- for (pred = bb_ann (bb)->predictions; pred; pred = pred->next)
+ for (pred = bb->predictions; pred; pred = pred->next)
{
int predictor = pred->predictor;
int probability = pred->probability;
dump_prediction (file, predictor, probability, bb,
!first_match || best_predictor == predictor);
}
- bb_ann (bb)->predictions = NULL;
+ bb->predictions = NULL;
if (!bb->count)
{
/* Basic blocks and flowgraphs. */
static basic_block create_bb (void *, void *, basic_block);
-static void create_block_annotation (basic_block);
-static void free_blocks_annotations (void);
-static void clear_blocks_annotations (void);
static void make_blocks (tree);
static void factor_computed_gotos (void);
ENTRY_BLOCK_PTR->next_bb = EXIT_BLOCK_PTR;
EXIT_BLOCK_PTR->prev_bb = ENTRY_BLOCK_PTR;
-
- create_block_annotation (ENTRY_BLOCK_PTR);
- create_block_annotation (EXIT_BLOCK_PTR);
}
/*---------------------------------------------------------------------------
}
-/* Create annotations for a single basic block. */
-
-static void
-create_block_annotation (basic_block bb)
-{
- /* Verify that the tree_annotations field is clear. */
- gcc_assert (!bb->tree_annotations);
- bb->tree_annotations = ggc_alloc_cleared (sizeof (struct bb_ann_d));
-}
-
-
-/* Free the annotations for all the basic blocks. */
-
-static void free_blocks_annotations (void)
-{
- clear_blocks_annotations ();
-}
-
-
-/* Clear the annotations for all the basic blocks. */
-
-static void
-clear_blocks_annotations (void)
-{
- basic_block bb;
-
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
- bb->tree_annotations = NULL;
-}
-
-
/* Build a flowgraph for the statement_list STMT_LIST. */
static void
/* Add the newly created block to the array. */
BASIC_BLOCK (last_basic_block) = bb;
- create_block_annotation (bb);
-
n_basic_blocks++;
last_basic_block++;
total += size;
fprintf (file, fmt_str_1, "Edges", num_edges, SCALE (size), LABEL (size));
- size = n_basic_blocks * sizeof (struct bb_ann_d);
- total += size;
- fprintf (file, fmt_str_1, "Basic block annotations", n_basic_blocks,
- SCALE (size), LABEL (size));
-
fprintf (file, "---------------------------------------------------------\n");
fprintf (file, fmt_str_3, "Total memory used by CFG data", SCALE (total),
LABEL (total));
delete_tree_cfg_annotations (void)
{
basic_block bb;
- if (n_basic_blocks > 0)
- free_blocks_annotations ();
label_to_block_map = NULL;
FOR_EACH_BB (bb)
return ann ? ann->addresses_taken : NULL;
}
-/* Return the basic_block annotation for BB. */
-static inline bb_ann_t
-bb_ann (basic_block bb)
-{
- return (bb_ann_t)bb->tree_annotations;
-}
-
/* Return the PHI nodes for basic block BB, or NULL if there are no
PHI nodes. */
static inline tree
phi_nodes (basic_block bb)
{
- return bb_ann (bb)->phi_nodes;
+ return bb->phi_nodes;
}
/* Set list of phi nodes of a basic block BB to L. */
{
tree phi;
- bb_ann (bb)->phi_nodes = l;
+ bb->phi_nodes = l;
for (phi = l; phi; phi = PHI_CHAIN (phi))
set_bb_for_stmt (phi, bb);
}
int probability;
};
-/*---------------------------------------------------------------------------
- Block annotations stored in basic_block.tree_annotations
----------------------------------------------------------------------------*/
-struct bb_ann_d GTY(())
-{
- /* Chain of PHI nodes for this block. */
- tree phi_nodes;
-
- /* Nonzero if one or more incoming edges to this block should be threaded
- to an outgoing edge of this block. */
- unsigned incoming_edge_threaded : 1;
-
- struct edge_prediction *predictions;
-};
-
-typedef struct bb_ann_d *bb_ann_t;
-
/* Accessors for basic block annotations. */
-static inline bb_ann_t bb_ann (basic_block);
static inline tree phi_nodes (basic_block);
static inline void set_phi_nodes (basic_block, tree);
/* In tree-ssa-loop-ivopts.c */
extern bool expr_invariant_in_loop_p (struct loop *, tree);
+/* In tree-ssa-threadupdate.c. */
+extern bool thread_through_all_blocks (bitmap);
+
/* In gimplify.c */
tree force_gimple_operand (tree, tree *, bool, tree);
tree force_gimple_operand_bsi (block_stmt_iterator *, tree, bool, tree);
release_phi_node (phi);
phi = next;
}
- bb_ann (bb)->phi_nodes = NULL;
+ bb->phi_nodes = NULL;
}
return;
}
int len = EDGE_COUNT (bb->preds);
int cap = ideal_phi_node_len (len + 4);
- for (loc = &(bb_ann (bb)->phi_nodes);
+ for (loc = &(bb->phi_nodes);
*loc;
loc = &PHI_CHAIN (*loc))
{
/* Add the new PHI node to the list of PHI nodes for block BB. */
PHI_CHAIN (phi) = phi_nodes (bb);
- bb_ann (bb)->phi_nodes = phi;
+ bb->phi_nodes = phi;
/* Associate BB to the PHI node. */
set_bb_for_stmt (phi, bb);
}
else
{
- for (loc = &(bb_ann (bb_for_stmt (phi))->phi_nodes);
+ for (loc = &(bb_for_stmt (phi)->phi_nodes);
*loc != phi;
loc = &PHI_CHAIN (*loc))
;
dump_bb_header (buffer, bb, indent, flags);
- if (bb_ann (bb))
- dump_phi_nodes (buffer, bb, indent, flags);
+ dump_phi_nodes (buffer, bb, indent, flags);
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
know their exact value. */
static bitmap nonzero_vars;
+/* Bitmap of blocks that are scheduled to be threaded through. This
+ is used to communicate with thread_through_blocks. */
+static bitmap threaded_blocks;
+
/* Stack of SSA_NAMEs which need their NONZERO_VARS property cleared
when the current block is finalized.
vrp_variables_stack = VEC_alloc (tree, heap, 20);
stmts_to_rescan = VEC_alloc (tree, heap, 20);
nonzero_vars = BITMAP_ALLOC (NULL);
+ threaded_blocks = BITMAP_ALLOC (NULL);
need_eh_cleanup = BITMAP_ALLOC (NULL);
/* Setup callbacks for the generic dominator tree walker. */
free_all_edge_infos ();
/* Thread jumps, creating duplicate blocks as needed. */
- cfg_altered |= thread_through_all_blocks ();
+ cfg_altered |= thread_through_all_blocks (threaded_blocks);
/* Removal of statements may make some EH edges dead. Purge
such edges from the CFG as needed. */
/* Reinitialize the various tables. */
bitmap_clear (nonzero_vars);
+ bitmap_clear (threaded_blocks);
htab_empty (avail_exprs);
htab_empty (vrp_data);
/* Free nonzero_vars. */
BITMAP_FREE (nonzero_vars);
+ BITMAP_FREE (threaded_blocks);
BITMAP_FREE (need_eh_cleanup);
VEC_free (tree, heap, avail_exprs_stack);
else
edge_info = allocate_edge_info (e);
edge_info->redirection_target = taken_edge;
- bb_ann (e->dest)->incoming_edge_threaded = true;
+ bitmap_set_bit (threaded_blocks, e->dest->index);
}
}
}
Returns true if one or more edges were threaded, false otherwise. */
bool
-thread_through_all_blocks (void)
+thread_through_all_blocks (bitmap threaded_blocks)
{
- basic_block bb;
bool retval = false;
+ unsigned int i;
+ bitmap_iterator bi;
rediscover_loops_after_threading = false;
- FOR_EACH_BB (bb)
+ EXECUTE_IF_SET_IN_BITMAP (threaded_blocks, 0, i, bi)
{
- if (bb_ann (bb)->incoming_edge_threaded
- && EDGE_COUNT (bb->preds) > 0)
- {
- retval |= thread_block (bb);
- bb_ann (bb)->incoming_edge_threaded = false;
-
- }
+ basic_block bb = BASIC_BLOCK (i);
+
+ if (EDGE_COUNT (bb->preds) > 0)
+ retval |= thread_block (bb);
}
return retval;
restricted to creating gimple expressions. */
extern bool in_gimple_form;
-/* In tree-ssa-threadupdate.c. */
-extern bool thread_through_all_blocks (void);
-
/* In tree-gimple.c. */
extern tree get_base_address (tree t);
projects / thirdparty / gcc.git / commitdiff
