#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
{
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. */
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 ();
git://gcc.gnu.org / gcc.git / blobdiff