These are some minor cleanups and renames that surfaced after the hybrid_threader work.
gcc/ChangeLog: * gimple-range-path.cc (path_range_query::precompute_ranges_in_block): Rename to... (path_range_query::compute_ranges_in_block): ...this. (path_range_query::precompute_ranges): Rename to... (path_range_query::compute_ranges): ...this. (path_range_query::precompute_relations): Rename to... (path_range_query::compute_relations): ...this. (path_range_query::precompute_phi_relations): Rename to... (path_range_query::compute_phi_relations): ...this. * gimple-range-path.h: Rename precompute* to compute*. * tree-ssa-threadbackward.c (back_threader::find_taken_edge_switch): Same. (back_threader::find_taken_edge_cond): Same. * tree-ssa-threadedge.c (hybrid_jt_simplifier::compute_ranges_from_state): Same. (hybrid_jt_state::register_equivs_stmt): Inline... * tree-ssa-threadedge.h: ...here. --- gcc/gimple-range-path.cc | 28 ++++++++++++++-------------- gcc/gimple-range-path.h | 14 +++++--------- gcc/tree-ssa-threadbackward.c | 4 ++-- gcc/tree-ssa-threadedge.c | 8 +------- gcc/tree-ssa-threadedge.h | 7 +++++-- 5 files changed, 27 insertions(+), 34 deletions(-) diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc index 0738a5ca159..71e04e4deba 100644 --- a/gcc/gimple-range-path.cc +++ b/gcc/gimple-range-path.cc @@ -293,11 +293,11 @@ path_range_query::range_defined_in_block (irange &r, tree name, basic_block bb) return true; } -// Precompute ranges defined in the current block, or ranges -// that are exported on an edge to the next block. +// Compute ranges defined in the current block, or exported to the +// next block. void -path_range_query::precompute_ranges_in_block (basic_block bb) +path_range_query::compute_ranges_in_block (basic_block bb) { bitmap_iterator bi; int_range_max r, cached_range; @@ -452,14 +452,14 @@ path_range_query::add_copies_to_imports () } } -// Precompute the ranges for IMPORTS along PATH. +// Compute the ranges for IMPORTS along PATH. // // IMPORTS are the set of SSA names, any of which could potentially // change the value of the final conditional in PATH. void -path_range_query::precompute_ranges (const vec<basic_block> &path, - const bitmap_head *imports) +path_range_query::compute_ranges (const vec<basic_block> &path, + const bitmap_head *imports) { if (DEBUG_SOLVER) fprintf (dump_file, "\n*********** path_range_query ******************\n"); @@ -472,12 +472,12 @@ path_range_query::precompute_ranges (const vec<basic_block> &path, { add_copies_to_imports (); m_oracle->reset_path (); - precompute_relations (path); + compute_relations (path); } if (DEBUG_SOLVER) { - fprintf (dump_file, "\npath_range_query: precompute_ranges for path: "); + fprintf (dump_file, "\npath_range_query: compute_ranges for path: "); for (unsigned i = path.length (); i > 0; --i) { basic_block bb = path[i - 1]; @@ -504,7 +504,7 @@ path_range_query::precompute_ranges (const vec<basic_block> &path, bitmap_set_bit (m_imports, SSA_NAME_VERSION (name)); } - precompute_ranges_in_block (bb); + compute_ranges_in_block (bb); adjust_for_non_null_uses (bb); if (at_exit ()) @@ -611,12 +611,12 @@ path_range_query::range_of_stmt (irange &r, gimple *stmt, tree) return true; } -// Precompute relations on a path. This involves two parts: relations +// Compute relations on a path. This involves two parts: relations // along the conditionals joining a path, and relations determined by // examining PHIs. void -path_range_query::precompute_relations (const vec<basic_block> &path) +path_range_query::compute_relations (const vec<basic_block> &path) { if (!dom_info_available_p (CDI_DOMINATORS)) return; @@ -628,7 +628,7 @@ path_range_query::precompute_relations (const vec<basic_block> &path) basic_block bb = path[i - 1]; gimple *stmt = last_stmt (bb); - precompute_phi_relations (bb, prev); + compute_phi_relations (bb, prev); // Compute relations in outgoing edges along the path. Skip the // final conditional which we don't know yet. @@ -656,14 +656,14 @@ path_range_query::precompute_relations (const vec<basic_block> &path) } } -// Precompute relations for each PHI in BB. For example: +// Compute relations for each PHI in BB. For example: // // x_5 = PHI<y_9(5),...> // // If the path flows through BB5, we can register that x_5 == y_9. void -path_range_query::precompute_phi_relations (basic_block bb, basic_block prev) +path_range_query::compute_phi_relations (basic_block bb, basic_block prev) { if (prev == NULL) return; diff --git a/gcc/gimple-range-path.h b/gcc/gimple-range-path.h index f7d9832ac8c..cf49c6dc086 100644 --- a/gcc/gimple-range-path.h +++ b/gcc/gimple-range-path.h @@ -26,9 +26,6 @@ along with GCC; see the file COPYING3. If not see // will calculate the range of an SSA or STMT as if the BBs in the // path would have been executed in order. // -// Only SSA names passed in IMPORTS are precomputed, and can be -// queried. -// // Note that the blocks are in reverse order, thus the exit block is // path[0]. @@ -37,8 +34,7 @@ class path_range_query : public range_query public: path_range_query (class gimple_ranger &ranger, bool resolve); virtual ~path_range_query (); - void precompute_ranges (const vec<basic_block> &path, - const bitmap_head *imports); + void compute_ranges (const vec<basic_block> &, const bitmap_head *imports); bool range_of_expr (irange &r, tree name, gimple * = NULL) override; bool range_of_stmt (irange &r, gimple *, tree name = NULL) override; bool unreachable_path_p (); @@ -56,13 +52,13 @@ private: bool get_cache (irange &r, tree name); void clear_cache (tree name); - // Methods to precompute ranges for the given path. + // Methods to compute ranges for the given path. bool range_defined_in_block (irange &, tree name, basic_block bb); - void precompute_ranges_in_block (basic_block bb); + void compute_ranges_in_block (basic_block bb); void adjust_for_non_null_uses (basic_block bb); void ssa_range_in_phi (irange &r, gphi *phi); - void precompute_relations (const vec<basic_block> &); - void precompute_phi_relations (basic_block bb, basic_block prev); + void compute_relations (const vec<basic_block> &); + void compute_phi_relations (basic_block bb, basic_block prev); void add_copies_to_imports (); bool add_to_imports (tree name, bitmap imports); diff --git a/gcc/tree-ssa-threadbackward.c b/gcc/tree-ssa-threadbackward.c index 95542079faf..e6819fe148c 100644 --- a/gcc/tree-ssa-threadbackward.c +++ b/gcc/tree-ssa-threadbackward.c @@ -192,7 +192,7 @@ back_threader::find_taken_edge_switch (const vec<basic_block> &path, tree name = gimple_switch_index (sw); int_range_max r; - m_solver.precompute_ranges (path, m_imports); + m_solver.compute_ranges (path, m_imports); m_solver.range_of_expr (r, name, sw); if (r.undefined_p ()) @@ -216,7 +216,7 @@ back_threader::find_taken_edge_cond (const vec<basic_block> &path, { int_range_max r; - m_solver.precompute_ranges (path, m_imports); + m_solver.compute_ranges (path, m_imports); m_solver.range_of_stmt (r, cond); if (m_solver.unreachable_path_p ()) diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c index 29ed60a98b0..0b59cb4845c 100644 --- a/gcc/tree-ssa-threadedge.c +++ b/gcc/tree-ssa-threadedge.c @@ -1402,12 +1402,6 @@ jt_state::register_equivs_stmt (gimple *stmt, basic_block bb, // Hybrid threader implementation. -void -hybrid_jt_state::register_equivs_stmt (gimple *, basic_block, jt_simplifier *) -{ - // Ranger has no need to simplify anything to improve equivalences. -} - hybrid_jt_simplifier::hybrid_jt_simplifier (gimple_ranger *r, path_range_query *q) { @@ -1466,5 +1460,5 @@ hybrid_jt_simplifier::compute_ranges_from_state (gimple *stmt, jt_state *state) bitmap_set_bit (imports, SSA_NAME_VERSION (op)); } } - m_query->precompute_ranges (m_path, imports); + m_query->compute_ranges (m_path, imports); } diff --git a/gcc/tree-ssa-threadedge.h b/gcc/tree-ssa-threadedge.h index ac605a3ac30..c46a5c6c489 100644 --- a/gcc/tree-ssa-threadedge.h +++ b/gcc/tree-ssa-threadedge.h @@ -56,16 +56,19 @@ public: class hybrid_jt_state : public jt_state { private: - void register_equivs_stmt (gimple *, basic_block, jt_simplifier *) override; + void register_equivs_stmt (gimple *, basic_block, jt_simplifier *) override + { + // Ranger has no need to simplify anything. + } }; class hybrid_jt_simplifier : public jt_simplifier { public: hybrid_jt_simplifier (class gimple_ranger *r, class path_range_query *q); + tree simplify (gimple *stmt, gimple *, basic_block, jt_state *) override; private: - tree simplify (gimple *stmt, gimple *, basic_block, jt_state *) override; void compute_ranges_from_state (gimple *stmt, jt_state *); gimple_ranger *m_ranger; -- 2.31.1