@@ -468,7 +468,6 @@ static void mark_oprs_set (rtx);
static void alloc_cprop_mem (int, int);
static void free_cprop_mem (void);
static void compute_transp (const_rtx, int, sbitmap *, int);
-static void compute_transpout (void);
static void compute_local_properties (sbitmap *, sbitmap *, sbitmap *,
struct hash_table_d *);
static void compute_cprop_data (void);
@@ -3172,11 +3171,6 @@ bypass_conditional_jumps (void)
/* Nonzero for expressions that are transparent in the block. */
static sbitmap *transp;
-/* Nonzero for expressions that are transparent at the end of the block.
- This is only zero for expressions killed by abnormal critical edge
- created by a calls. */
-static sbitmap *transpout;
-
/* Nonzero for expressions that are computed (available) in the block. */
static sbitmap *comp;
@@ -3240,17 +3234,15 @@ free_pre_mem (void)
pre_optimal = pre_redundant = pre_insert_map = pre_delete_map = NULL;
}
-/* Top level routine to do the dataflow analysis needed by PRE. */
+/* Remove potentially trapping expressions from anticipatable and transparent
+ sets of basic blocks that have incoming abnormal edge. */
static void
-compute_pre_data (void)
+prune_trapping_expressions (void)
{
sbitmap trapping_expr;
- basic_block bb;
unsigned int ui;
-
- compute_local_properties (transp, comp, antloc, &expr_hash_table);
- sbitmap_vector_zero (ae_kill, last_basic_block);
+ basic_block bb;
/* Collect expressions which might trap. */
trapping_expr = sbitmap_alloc (expr_hash_table.n_elems);
@@ -3263,11 +3255,6 @@ compute_pre_data (void)
SET_BIT (trapping_expr, e->bitmap_index);
}
- /* Compute ae_kill for each basic block using:
-
- ~(TRANSP | COMP)
- */
-
FOR_EACH_BB (bb)
{
edge e;
@@ -3280,11 +3267,35 @@ compute_pre_data (void)
FOR_EACH_EDGE (e, ei, bb->preds)
if (e->flags & EDGE_ABNORMAL)
{
- sbitmap_difference (antloc[bb->index], antloc[bb->index], trapping_expr);
- sbitmap_difference (transp[bb->index], transp[bb->index], trapping_expr);
+ sbitmap_difference (antloc[bb->index],
+ antloc[bb->index], trapping_expr);
+ sbitmap_difference (transp[bb->index],
+ transp[bb->index], trapping_expr);
break;
}
+ }
+
+ sbitmap_free (trapping_expr);
+}
+
+/* Top level routine to do the dataflow analysis needed by PRE. */
+
+static void
+compute_pre_data (void)
+{
+ basic_block bb;
+
+ compute_local_properties (transp, comp, antloc, &expr_hash_table);
+ prune_trapping_expressions ();
+ sbitmap_vector_zero (ae_kill, last_basic_block);
+ /* Compute ae_kill for each basic block using:
+
+ ~(TRANSP | COMP)
+ */
+
+ FOR_EACH_BB (bb)
+ {
sbitmap_a_or_b (ae_kill[bb->index], transp[bb->index], comp[bb->index]);
sbitmap_not (ae_kill[bb->index], ae_kill[bb->index]);
}
@@ -3295,7 +3306,6 @@ compute_pre_data (void)
antloc = NULL;
sbitmap_vector_free (ae_kill);
ae_kill = NULL;
- sbitmap_free (trapping_expr);
}
/* PRE utilities */
@@ -4050,52 +4060,6 @@ add_label_notes (rtx x, rtx insn)
}
}
-/* Compute transparent outgoing information for each block.
-
- An expression is transparent to an edge unless it is killed by
- the edge itself. This can only happen with abnormal control flow,
- when the edge is traversed through a call. This happens with
- non-local labels and exceptions.
-
- This would not be necessary if we split the edge. While this is
- normally impossible for abnormal critical edges, with some effort
- it should be possible with exception handling, since we still have
- control over which handler should be invoked. But due to increased
- EH table sizes, this may not be worthwhile. */
-
-static void
-compute_transpout (void)
-{
- basic_block bb;
- unsigned int i;
- struct expr *expr;
-
- sbitmap_vector_ones (transpout, last_basic_block);
-
- FOR_EACH_BB (bb)
- {
- /* Note that flow inserted a nop at the end of basic blocks that
- end in call instructions for reasons other than abnormal
- control flow. */
- if (! CALL_P (BB_END (bb)))
- continue;
-
- for (i = 0; i < expr_hash_table.size; i++)
- for (expr = expr_hash_table.table[i]; expr ; expr = expr->next_same_hash)
- if (MEM_P (expr->expr))
- {
- if (GET_CODE (XEXP (expr->expr, 0)) == SYMBOL_REF
- && CONSTANT_POOL_ADDRESS_P (XEXP (expr->expr, 0)))
- continue;
-
- /* ??? Optimally, we would use interprocedural alias
- analysis to determine if this mem is actually killed
- by this call. */
- RESET_BIT (transpout[bb->index], expr->bitmap_index);
- }
- }
-}
-
/* Code Hoisting variables and subroutines. */
/* Very busy expressions. */
@@ -4124,7 +4088,6 @@ alloc_code_hoist_mem (int n_blocks, int n_exprs)
hoist_vbein = sbitmap_vector_alloc (n_blocks, n_exprs);
hoist_vbeout = sbitmap_vector_alloc (n_blocks, n_exprs);
hoist_exprs = sbitmap_vector_alloc (n_blocks, n_exprs);
- transpout = sbitmap_vector_alloc (n_blocks, n_exprs);
}
/* Free vars used for code hoisting analysis. */
@@ -4139,7 +4102,6 @@ free_code_hoist_mem (void)
sbitmap_vector_free (hoist_vbein);
sbitmap_vector_free (hoist_vbeout);
sbitmap_vector_free (hoist_exprs);
- sbitmap_vector_free (transpout);
free_dominance_info (CDI_DOMINATORS);
}
@@ -4192,7 +4154,7 @@ static void
compute_code_hoist_data (void)
{
compute_local_properties (transp, comp, antloc, &expr_hash_table);
- compute_transpout ();
+ prune_trapping_expressions ();
compute_code_hoist_vbeinout ();
calculate_dominance_info (CDI_DOMINATORS);
if (dump_file)
@@ -4294,8 +4256,7 @@ hoist_code (void)
{
int hoistable = 0;
- if (TEST_BIT (hoist_vbeout[bb->index], i)
- && TEST_BIT (transpout[bb->index], i))
+ if (TEST_BIT (hoist_vbeout[bb->index], i))
{
/* We've found a potentially hoistable expression, now
we look at every block BB dominates to see if it