diff options
Diffstat (limited to 'gcc/tree-ssa-ter.c')
| -rw-r--r-- | gcc/tree-ssa-ter.c | 101 |
1 files changed, 43 insertions, 58 deletions
diff --git a/gcc/tree-ssa-ter.c b/gcc/tree-ssa-ter.c index e02867520c8..099c19742e4 100644 --- a/gcc/tree-ssa-ter.c +++ b/gcc/tree-ssa-ter.c @@ -89,7 +89,7 @@ along with GCC; see the file COPYING3. If not see TER implements this but stepping through the instructions in a block and tracking potential expressions for replacement, and the partitions they are dependent on. Expressions are represented by the SSA_NAME_VERSION of the - DEF on the LHS of a GIMPLE_MODIFY_STMT and the expression is the RHS. + DEF on the LHS of a GIMPLE_ASSIGN and the expression is the RHS. When a stmt is determined to be a possible replacement expression, the following steps are taken: @@ -159,7 +159,7 @@ typedef struct temp_expr_table_d { var_map map; bitmap *partition_dependencies; /* Partitions expr is dependent on. */ - tree *replaceable_expressions; /* Replacement expression table. */ + gimple *replaceable_expressions; /* Replacement expression table. */ bitmap *expr_decl_uids; /* Base uids of exprs. */ bitmap *kill_list; /* Expr's killed by a partition. */ int virtual_partition; /* Pseudo partition for virtual ops. */ @@ -216,10 +216,10 @@ new_temp_expr_table (var_map map) /* Free TER table T. If there are valid replacements, return the expression vector. */ -static tree * +static gimple * free_temp_expr_table (temp_expr_table_p t) { - tree *ret = NULL; + gimple *ret = NULL; unsigned i; #ifdef ENABLE_CHECKING @@ -255,7 +255,7 @@ version_to_be_replaced_p (temp_expr_table_p tab, int version) { if (!tab->replaceable_expressions) return false; - return tab->replaceable_expressions[version] != NULL_TREE; + return tab->replaceable_expressions[version] != NULL; } @@ -360,20 +360,20 @@ add_dependence (temp_expr_table_p tab, int version, tree var) /* Return TRUE if expression STMT is suitable for replacement. */ static inline bool -is_replaceable_p (tree stmt) +is_replaceable_p (gimple stmt) { - tree call_expr; use_operand_p use_p; - tree def, use_stmt; + tree def; + gimple use_stmt; location_t locus1, locus2; tree block1, block2; /* Only consider modify stmts. */ - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_assign (stmt)) return false; /* If the statement may throw an exception, it cannot be replaced. */ - if (tree_could_throw_p (stmt)) + if (stmt_could_throw_p (stmt)) return false; /* Punt if there is more than 1 def. */ @@ -386,33 +386,21 @@ is_replaceable_p (tree stmt) return false; /* If the use isn't in this block, it wont be replaced either. */ - if (bb_for_stmt (use_stmt) != bb_for_stmt (stmt)) + if (gimple_bb (use_stmt) != gimple_bb (stmt)) return false; - if (GIMPLE_STMT_P (stmt)) - { - locus1 = GIMPLE_STMT_LOCUS (stmt); - block1 = GIMPLE_STMT_BLOCK (stmt); - } - else - { - locus1 = *EXPR_LOCUS (stmt); - block1 = TREE_BLOCK (stmt); - } - if (GIMPLE_STMT_P (use_stmt)) - { - locus2 = GIMPLE_STMT_LOCUS (use_stmt); - block2 = GIMPLE_STMT_BLOCK (use_stmt); - } - if (TREE_CODE (use_stmt) == PHI_NODE) + locus1 = gimple_location (stmt); + block1 = gimple_block (stmt); + + if (gimple_code (use_stmt) == GIMPLE_PHI) { locus2 = 0; block2 = NULL_TREE; } else { - locus2 = *EXPR_LOCUS (use_stmt); - block2 = TREE_BLOCK (use_stmt); + locus2 = gimple_location (use_stmt); + block2 = gimple_block (use_stmt); } if (!optimize @@ -420,7 +408,7 @@ is_replaceable_p (tree stmt) return false; /* Used in this block, but at the TOP of the block, not the end. */ - if (TREE_CODE (use_stmt) == PHI_NODE) + if (gimple_code (use_stmt) == GIMPLE_PHI) return false; /* There must be no VDEFs. */ @@ -428,26 +416,26 @@ is_replaceable_p (tree stmt) return false; /* Without alias info we can't move around loads. */ - if (stmt_ann (stmt)->references_memory && !optimize) + if (gimple_references_memory_p (stmt) && !optimize) return false; /* Float expressions must go through memory if float-store is on. */ if (flag_float_store - && FLOAT_TYPE_P (TREE_TYPE (GENERIC_TREE_OPERAND (stmt, 1)))) + && FLOAT_TYPE_P (gimple_expr_type (stmt))) return false; /* An assignment with a register variable on the RHS is not replaceable. */ - if (TREE_CODE (GENERIC_TREE_OPERAND (stmt, 1)) == VAR_DECL - && DECL_HARD_REGISTER (GENERIC_TREE_OPERAND (stmt, 1))) + if (gimple_assign_rhs_code (stmt) == VAR_DECL + && DECL_HARD_REGISTER (gimple_assign_rhs1 (stmt))) return false; /* No function calls can be replaced. */ - if ((call_expr = get_call_expr_in (stmt)) != NULL_TREE) + if (is_gimple_call (stmt)) return false; /* Leave any stmt with volatile operands alone as well. */ - if (stmt_ann (stmt)->has_volatile_ops) + if (gimple_has_volatile_ops (stmt)) return false; return true; @@ -480,7 +468,7 @@ finished_with_expr (temp_expr_table_p tab, int version, bool free_expr) /* Create an expression entry for a replaceable expression. */ static void -process_replaceable (temp_expr_table_p tab, tree stmt) +process_replaceable (temp_expr_table_p tab, gimple stmt) { tree var, def, basevar; int version; @@ -574,7 +562,7 @@ mark_replaceable (temp_expr_table_p tab, tree var, bool more_replacing) /* Set the replaceable expression. */ if (!tab->replaceable_expressions) - tab->replaceable_expressions = XCNEWVEC (tree, num_ssa_names + 1); + tab->replaceable_expressions = XCNEWVEC (gimple, num_ssa_names + 1); tab->replaceable_expressions[version] = SSA_NAME_DEF_STMT (var); } @@ -585,20 +573,20 @@ mark_replaceable (temp_expr_table_p tab, tree var, bool more_replacing) static void find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb) { - block_stmt_iterator bsi; - tree stmt, def, use; - stmt_ann_t ann; + gimple_stmt_iterator bsi; + gimple stmt; + tree def, use; int partition; var_map map = tab->map; ssa_op_iter iter; bool stmt_replaceable; - for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) + for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) { - stmt = bsi_stmt (bsi); - ann = stmt_ann (stmt); + stmt = gsi_stmt (bsi); stmt_replaceable = is_replaceable_p (stmt); + /* Determine if this stmt finishes an existing expression. */ FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE) { @@ -627,7 +615,7 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb) /* Mark expression as replaceable unless stmt is volatile or the def variable has the same root variable as something in the substitution list. */ - if (ann->has_volatile_ops || same_root_var) + if (gimple_has_volatile_ops (stmt) || same_root_var) finished_with_expr (tab, ver, true); else mark_replaceable (tab, use, stmt_replaceable); @@ -665,12 +653,12 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb) NULL is returned by the function, otherwise an expression vector indexed by SSA_NAME version numbers. */ -extern tree * +extern gimple * find_replaceable_exprs (var_map map) { basic_block bb; temp_expr_table_p table; - tree *ret; + gimple *ret; table = new_temp_expr_table (map); FOR_EACH_BB (bb) @@ -700,23 +688,20 @@ find_replaceable_exprs (var_map map) /* Dump TER expression table EXPR to file F. */ -extern void -dump_replaceable_exprs (FILE *f, tree *expr) +void +dump_replaceable_exprs (FILE *f, gimple *expr) { - tree stmt, var; - int x; + tree var; + unsigned x; fprintf (f, "\nReplacing Expressions\n"); - for (x = 0; x < (int)num_ssa_names; x++) + for (x = 0; x < num_ssa_names; x++) if (expr[x]) { - stmt = expr[x]; - var = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_DEF); - gcc_assert (var != NULL_TREE); + var = ssa_name (x); print_generic_expr (f, var, TDF_SLIM); fprintf (f, " replace with --> "); - print_generic_expr (f, GENERIC_TREE_OPERAND (stmt, 1), - TDF_SLIM); + print_gimple_stmt (f, expr[x], 0, TDF_SLIM); fprintf (f, "\n"); } fprintf (f, "\n"); @@ -728,7 +713,7 @@ dump_replaceable_exprs (FILE *f, tree *expr) exclusively to debug TER. F is the place to send debug info and T is the table being debugged. */ -extern void +void debug_ter (FILE *f, temp_expr_table_p t) { unsigned x, y; |