diff options
Diffstat (limited to 'gcc/gimple-ssa-evrp.c')
| -rw-r--r-- | gcc/gimple-ssa-evrp.c | 221 |
1 files changed, 218 insertions, 3 deletions
diff --git a/gcc/gimple-ssa-evrp.c b/gcc/gimple-ssa-evrp.c index 60bf82a..6be32d7a 100644 --- a/gcc/gimple-ssa-evrp.c +++ b/gcc/gimple-ssa-evrp.c @@ -41,6 +41,10 @@ along with GCC; see the file COPYING3. If not see #include "tree-cfgcleanup.h" #include "vr-values.h" #include "gimple-ssa-evrp-analyze.h" +#include "gimple-range.h" + +// This is the classic EVRP folder which uses a dominator walk and pushes +// ranges into the next block if it is a single predecessor block. class evrp_folder : public substitute_and_fold_engine { @@ -98,12 +102,195 @@ public: m_range_analyzer.set_defs_to_varying (stmt); } -private: +protected: DISABLE_COPY_AND_ASSIGN (evrp_folder); evrp_range_analyzer m_range_analyzer; simplify_using_ranges simplifier; }; +// This is a ranger based folder which continues to use the dominator +// walk to access the substitute and fold machinery. Ranges are calculated +// on demand. + +class rvrp_folder : public substitute_and_fold_engine +{ +public: + + rvrp_folder () : substitute_and_fold_engine (), m_simplifier () + { + if (flag_evrp_mode & EVRP_MODE_TRACE) + m_ranger = new trace_ranger (); + else + m_ranger = new gimple_ranger (); + m_simplifier.set_range_query (m_ranger); + } + + ~rvrp_folder () + { + if (dump_file && (dump_flags & TDF_DETAILS)) + m_ranger->dump (dump_file); + delete m_ranger; + } + + tree value_of_expr (tree name, gimple *s = NULL) OVERRIDE + { + return m_ranger->value_of_expr (name, s); + } + + tree value_on_edge (edge e, tree name) OVERRIDE + { + return m_ranger->value_on_edge (e, name); + } + + tree value_of_stmt (gimple *s, tree name = NULL) OVERRIDE + { + return m_ranger->value_of_stmt (s, name); + } + + bool fold_stmt (gimple_stmt_iterator *gsi) OVERRIDE + { + return m_simplifier.simplify (gsi); + } + +private: + DISABLE_COPY_AND_ASSIGN (rvrp_folder); + gimple_ranger *m_ranger; + simplify_using_ranges m_simplifier; +}; + +// In a hybrid folder, start with an EVRP folder, and add the required +// fold_stmt bits to either try the ranger first or second. +// +// The 3 value_* routines will always query both EVRP and the ranger for +// a result, and ensure they return the same value. If either returns a value +// when the other doesn't, it is flagged in the listing, and the discoverd +// value is returned. +// +// The simplifier is unable to process 2 different sources, thus we try to +// use one engine, and if it fails to simplify, try using the other engine. +// It is reported when the first attempt fails and the second succeeds. + +class hybrid_folder : public evrp_folder +{ +public: + hybrid_folder (bool evrp_first) + { + if (flag_evrp_mode & EVRP_MODE_TRACE) + m_ranger = new trace_ranger (); + else + m_ranger = new gimple_ranger (); + + if (evrp_first) + { + first = &m_range_analyzer; + second = m_ranger; + } + else + { + first = m_ranger; + second = &m_range_analyzer; + } + } + + ~hybrid_folder () + { + if (dump_file && (dump_flags & TDF_DETAILS)) + m_ranger->dump (dump_file); + delete m_ranger; + } + + bool fold_stmt (gimple_stmt_iterator *gsi) OVERRIDE + { + simplifier.set_range_query (first); + if (simplifier.simplify (gsi)) + return true; + + simplifier.set_range_query (second); + if (simplifier.simplify (gsi)) + { + if (dump_file) + fprintf (dump_file, "EVRP:hybrid: Second query simplifed stmt\n"); + return true; + } + return false; + } + + tree value_of_expr (tree name, gimple *) OVERRIDE; + tree value_on_edge (edge, tree name) OVERRIDE; + tree value_of_stmt (gimple *, tree name) OVERRIDE; + +private: + DISABLE_COPY_AND_ASSIGN (hybrid_folder); + gimple_ranger *m_ranger; + range_query *first; + range_query *second; + tree choose_value (tree evrp_val, tree ranger_val); +}; + + +tree +hybrid_folder::value_of_expr (tree op, gimple *stmt) +{ + tree evrp_ret = evrp_folder::value_of_expr (op, stmt); + tree ranger_ret = m_ranger->value_of_expr (op, stmt); + return choose_value (evrp_ret, ranger_ret); +} + +tree +hybrid_folder::value_on_edge (edge e, tree op) +{ + tree evrp_ret = evrp_folder::value_on_edge (e, op); + tree ranger_ret = m_ranger->value_on_edge (e, op); + return choose_value (evrp_ret, ranger_ret); +} + +tree +hybrid_folder::value_of_stmt (gimple *stmt, tree op) +{ + tree evrp_ret = evrp_folder::value_of_stmt (stmt, op); + tree ranger_ret = m_ranger->value_of_stmt (stmt, op); + return choose_value (evrp_ret, ranger_ret); +} + +// Given trees returned by EVRP and Ranger, choose/report the value to use +// by the folder. + +tree +hybrid_folder::choose_value (tree evrp_val, tree ranger_val) +{ + if (!ranger_val) + { + // If neither returned a value, return NULL_TREE. + if (!evrp_val) + return NULL_TREE; + + // Otherwise EVRP found something. + if (dump_file) + { + fprintf (dump_file, "EVRP:hybrid: EVRP found singleton "); + print_generic_expr (dump_file, evrp_val); + fprintf (dump_file, "\n"); + } + return evrp_val; + } + + // Otherwise ranger found a value, if they match we're good. + if (evrp_val && !compare_values (evrp_val, ranger_val)) + return evrp_val; + + // We should never get different singletons. + gcc_checking_assert (!evrp_val); + + // Now ranger has found a value, but EVRP did not. + if (dump_file) + { + fprintf (dump_file, "EVRP:hybrid: RVRP found singleton "); + print_generic_expr (dump_file, ranger_val); + fprintf (dump_file, "\n"); + } + return ranger_val; +} + /* Main entry point for the early vrp pass which is a simplified non-iterative version of vrp where basic blocks are visited in dominance order. Value ranges discovered in early vrp will also be used by ipa-vrp. */ @@ -120,8 +307,36 @@ execute_early_vrp () scev_initialize (); calculate_dominance_info (CDI_DOMINATORS); - evrp_folder folder; - folder.substitute_and_fold (); + // only the last 2 bits matter for choosing the folder. + switch (flag_evrp_mode & EVRP_MODE_RVRP_FIRST) + { + case EVRP_MODE_EVRP_ONLY: + { + evrp_folder folder; + folder.substitute_and_fold (); + break; + } + case EVRP_MODE_RVRP_ONLY: + { + rvrp_folder folder; + folder.substitute_and_fold (); + break; + } + case EVRP_MODE_EVRP_FIRST: + { + hybrid_folder folder (true); + folder.substitute_and_fold (); + break; + } + case EVRP_MODE_RVRP_FIRST: + { + hybrid_folder folder (false); + folder.substitute_and_fold (); + break; + } + default: + gcc_unreachable (); + } scev_finalize (); loop_optimizer_finalize (); |