* [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
@ 2017-09-14 12:17 Martin Liška
2017-09-15 22:19 ` Jeff Law
0 siblings, 1 reply; 28+ messages in thread
From: Martin Liška @ 2017-09-14 12:17 UTC (permalink / raw)
To: gcc-patches; +Cc: Patrick Palka
[-- Attachment #1: Type: text/plain, Size: 2271 bytes --]
Hello.
As mentioned at Cauldron 2017, second step in switch lowering should be massive
simplification in code that does expansion of balanced tree. Basically it includes
VRP and DCE, which we can for obvious reason do by our own.
The patch does that, and introduces a separate pass for -O0 that's responsible
for lowering at the end of tree pass.
There's a small fallback that I would like to discuss:
1) vrp105.c - there's no longer catches threading opportunity in between default cases:
adding Patrick who can probably help why is the opportunity skipped with expanded tree
2) uninit-18.c where we currently report:
/home/marxin/Programming/gcc/gcc/testsuite/gcc.dg/uninit-18.c:13:12: warning: ‘tmp’ may be used uninitialized in this function [-Wmaybe-uninitialized]
tmp[5] = 7; /* { dg-bogus "may be used uninitialized" } */
Am I right that the pass uses VRP?
Last question is whether the pass is properly moved in optimization pipeline?
Patch can bootstrap on ppc64le-redhat-linux and survives regression tests.
Thanks,
Martin
gcc/ChangeLog:
2017-09-14 Martin Liska <mliska@suse.cz>
* passes.def: Add pass_lower_switch and pass_lower_switch_O0.
* tree-pass.h (make_pass_lower_switch_O0): New function.
* tree-switch-conversion.c (node_has_low_bound): Remove.
(node_has_high_bound): Likewise.
(node_is_bounded): Likewise.
(class pass_lower_switch): Make it a template type and create
two instances.
(pass_lower_switch::execute): Add template argument.
(make_pass_lower_switch): New function.
(make_pass_lower_switch_O0): New function.
(do_jump_if_equal): Remove.
(emit_case_nodes): Simplify to just handle all 3 cases and leave
all the hard work to tree optimization passes.
gcc/testsuite/ChangeLog:
2017-09-14 Martin Liska <mliska@suse.cz>
* gcc.dg/tree-ssa/vrp104.c: Adjust dump file that is scanned.
* gcc.dg/tree-prof/update-loopch.c: Likewise.
---
gcc/passes.def | 4 +-
gcc/testsuite/gcc.dg/tree-prof/update-loopch.c | 2 +-
gcc/testsuite/gcc.dg/tree-ssa/vrp104.c | 2 +-
gcc/tree-pass.h | 1 +
gcc/tree-switch-conversion.c | 604 +++----------------------
5 files changed, 72 insertions(+), 541 deletions(-)
[-- Attachment #2: 0001-Radically-simplify-emission-of-balanced-tree-for-swi.patch --]
[-- Type: text/x-patch, Size: 26516 bytes --]
diff --git a/gcc/passes.def b/gcc/passes.def
index 00e75d2b55a..bb371d9bde5 100644
--- a/gcc/passes.def
+++ b/gcc/passes.def
@@ -314,6 +314,7 @@ along with GCC; see the file COPYING3. If not see
POP_INSERT_PASSES ()
NEXT_PASS (pass_simduid_cleanup);
NEXT_PASS (pass_lower_vector_ssa);
+ NEXT_PASS (pass_lower_switch);
NEXT_PASS (pass_cse_reciprocals);
NEXT_PASS (pass_sprintf_length, true);
NEXT_PASS (pass_reassoc, false /* insert_powi_p */);
@@ -358,6 +359,7 @@ along with GCC; see the file COPYING3. If not see
/* Lower remaining pieces of GIMPLE. */
NEXT_PASS (pass_lower_complex);
NEXT_PASS (pass_lower_vector_ssa);
+ NEXT_PASS (pass_lower_switch);
/* Perform simple scalar cleanup which is constant/copy propagation. */
NEXT_PASS (pass_ccp, true /* nonzero_p */);
NEXT_PASS (pass_post_ipa_warn);
@@ -393,7 +395,7 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_lower_vaarg);
NEXT_PASS (pass_lower_vector);
NEXT_PASS (pass_lower_complex_O0);
- NEXT_PASS (pass_lower_switch);
+ NEXT_PASS (pass_lower_switch_O0);
NEXT_PASS (pass_sancov_O0);
NEXT_PASS (pass_asan_O0);
NEXT_PASS (pass_tsan_O0);
diff --git a/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c b/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
index 73efc878ec0..15baada1081 100644
--- a/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
+++ b/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
@@ -1,4 +1,4 @@
-/* { dg-options "-O2 -fdump-ipa-profile-blocks-details -fdump-tree-switchlower-blocks-details" } */
+/* { dg-options "-O2 -fdump-ipa-profile-blocks-details -fdump-tree-switchlower1-blocks-details" } */
int max = 33333;
int a[8];
int
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp104.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp104.c
index 0a952267b29..71fa3bfa2ca 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/vrp104.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp104.c
@@ -2,7 +2,7 @@
/* { dg-options "-O2 -fdump-tree-switchlower" } */
/* We scan for 2 switches as the dump file reports a transformation,
IL really contains just a single. */
-/* { dg-final { scan-tree-dump-times "switch" 2 "switchlower" } } */
+/* { dg-final { scan-tree-dump-times "switch" 2 "switchlower1" } } */
void foo (void);
void bar (void);
diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h
index 9f76d822abc..6ae65765431 100644
--- a/gcc/tree-pass.h
+++ b/gcc/tree-pass.h
@@ -410,6 +410,7 @@ extern gimple_opt_pass *make_pass_strip_predict_hints (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_complex_O0 (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_complex (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_switch (gcc::context *ctxt);
+extern gimple_opt_pass *make_pass_lower_switch_O0 (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_vector (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_vector_ssa (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_omp (gcc::context *ctxt);
diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c
index 6d7c2c4902f..f67531b2620 100644
--- a/gcc/tree-switch-conversion.c
+++ b/gcc/tree-switch-conversion.c
@@ -1685,9 +1685,6 @@ typedef case_node *case_node_ptr;
static basic_block emit_case_nodes (basic_block, tree, case_node_ptr,
basic_block, tree, profile_probability,
tree, hash_map<tree, tree> *);
-static bool node_has_low_bound (case_node_ptr, tree);
-static bool node_has_high_bound (case_node_ptr, tree);
-static bool node_is_bounded (case_node_ptr, tree);
/* Return the smallest number of different values for which it is best to use a
jump-table instead of a tree of conditional branches. */
@@ -2162,10 +2159,31 @@ try_switch_expansion (gswitch *stmt)
namespace {
-const pass_data pass_data_lower_switch =
+template <bool O0> class pass_lower_switch: public gimple_opt_pass
{
- GIMPLE_PASS, /* type */
- "switchlower", /* name */
+public:
+ pass_lower_switch (gcc::context *ctxt) : gimple_opt_pass (data, ctxt) {}
+
+ static const pass_data data;
+ opt_pass *
+ clone ()
+ {
+ return new pass_lower_switch<O0> (m_ctxt);
+ }
+
+ virtual bool
+ gate (function *)
+ {
+ return !O0 || !optimize;
+ }
+
+ virtual unsigned int execute (function *fun);
+}; // class pass_lower_switch
+
+template <bool O0>
+const pass_data pass_lower_switch<O0>::data = {
+ GIMPLE_PASS, /* type */
+ O0 ? "switchlower_O0" : "switchlower", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_TREE_SWITCH_LOWERING, /* tv_id */
( PROP_cfg | PROP_ssa ), /* properties_required */
@@ -2175,21 +2193,9 @@ const pass_data pass_data_lower_switch =
TODO_update_ssa | TODO_cleanup_cfg, /* todo_flags_finish */
};
-class pass_lower_switch : public gimple_opt_pass
-{
-public:
- pass_lower_switch (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_lower_switch, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return true; }
- virtual unsigned int execute (function *);
-
-}; // class pass_lower_switch
-
+template <bool O0>
unsigned int
-pass_lower_switch::execute (function *fun)
+pass_lower_switch<O0>::execute (function *fun)
{
basic_block bb;
bool expanded = false;
@@ -2227,33 +2233,14 @@ pass_lower_switch::execute (function *fun)
} // anon namespace
gimple_opt_pass *
-make_pass_lower_switch (gcc::context *ctxt)
+make_pass_lower_switch_O0 (gcc::context *ctxt)
{
- return new pass_lower_switch (ctxt);
+ return new pass_lower_switch<true> (ctxt);
}
-
-/* Generate code to jump to LABEL if OP0 and OP1 are equal in mode MODE.
- PROB is the probability of jumping to LABEL. */
-static basic_block
-do_jump_if_equal (basic_block bb, tree op0, tree op1, basic_block label_bb,
- profile_probability prob, hash_map<tree, tree> *phi_mapping)
+gimple_opt_pass *
+make_pass_lower_switch (gcc::context *ctxt)
{
- gcond *cond = gimple_build_cond (EQ_EXPR, op0, op1, NULL_TREE, NULL_TREE);
- gimple_stmt_iterator gsi = gsi_last_bb (bb);
- gsi_insert_before (&gsi, cond, GSI_SAME_STMT);
-
- gcc_assert (single_succ_p (bb));
-
- /* Make a new basic block where false branch will take place. */
- edge false_edge = split_block (bb, cond);
- false_edge->flags = EDGE_FALSE_VALUE;
- false_edge->probability = prob.invert ();
-
- edge true_edge = make_edge (bb, label_bb, EDGE_TRUE_VALUE);
- fix_phi_operands_for_edge (true_edge, phi_mapping);
- true_edge->probability = prob;
-
- return false_edge->dest;
+ return new pass_lower_switch<false> (ctxt);
}
/* Generate code to compare X with Y so that the condition codes are
@@ -2316,28 +2303,7 @@ conditional_probability (profile_probability target_prob,
/* Emit step-by-step code to select a case for the value of INDEX.
The thus generated decision tree follows the form of the
case-node binary tree NODE, whose nodes represent test conditions.
- INDEX_TYPE is the type of the index of the switch.
-
- Care is taken to prune redundant tests from the decision tree
- by detecting any boundary conditions already checked by
- emitted rtx. (See node_has_high_bound, node_has_low_bound
- and node_is_bounded, above.)
-
- Where the test conditions can be shown to be redundant we emit
- an unconditional jump to the target code. As a further
- optimization, the subordinates of a tree node are examined to
- check for bounded nodes. In this case conditional and/or
- unconditional jumps as a result of the boundary check for the
- current node are arranged to target the subordinates associated
- code for out of bound conditions on the current node.
-
- We can assume that when control reaches the code generated here,
- the index value has already been compared with the parents
- of this node, and determined to be on the same side of each parent
- as this node is. Thus, if this node tests for the value 51,
- and a parent tested for 52, we don't need to consider
- the possibility of a value greater than 51. If another parent
- tests for the value 50, then this node need not test anything. */
+ INDEX_TYPE is the type of the index of the switch. */
static basic_block
emit_case_nodes (basic_block bb, tree index, case_node_ptr node,
@@ -2345,482 +2311,44 @@ emit_case_nodes (basic_block bb, tree index, case_node_ptr node,
profile_probability default_prob, tree index_type,
hash_map<tree, tree> *phi_mapping)
{
- /* If INDEX has an unsigned type, we must make unsigned branches. */
- profile_probability probability;
- profile_probability prob = node->prob, subtree_prob = node->subtree_prob;
-
- /* See if our parents have already tested everything for us.
- If they have, emit an unconditional jump for this node. */
- if (node_is_bounded (node, index_type))
- {
- emit_jump (bb, node->case_bb, phi_mapping);
- return NULL;
- }
-
- else if (tree_int_cst_equal (node->low, node->high))
- {
- probability = conditional_probability (prob, subtree_prob + default_prob);
- /* Node is single valued. First see if the index expression matches
- this node and then check our children, if any. */
- bb = do_jump_if_equal (bb, index, node->low, node->case_bb, probability,
- phi_mapping);
- /* Since this case is taken at this point, reduce its weight from
- subtree_weight. */
- subtree_prob -= prob;
- if (node->right != 0 && node->left != 0)
- {
- /* This node has children on both sides.
- Dispatch to one side or the other
- by comparing the index value with this node's value.
- If one subtree is bounded, check that one first,
- so we can avoid real branches in the tree. */
-
- if (node_is_bounded (node->right, index_type))
- {
- probability
- = conditional_probability (node->right->prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- node->right->case_bb, probability,
- phi_mapping);
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
-
- else if (node_is_bounded (node->left, index_type))
- {
- probability
- = conditional_probability (node->left->prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, LT_EXPR,
- node->left->case_bb, probability,
- phi_mapping);
- bb = emit_case_nodes (bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
-
- /* If both children are single-valued cases with no
- children, finish up all the work. This way, we can save
- one ordered comparison. */
- else if (tree_int_cst_equal (node->right->low, node->right->high)
- && node->right->left == 0 && node->right->right == 0
- && tree_int_cst_equal (node->left->low, node->left->high)
- && node->left->left == 0 && node->left->right == 0)
- {
- /* Neither node is bounded. First distinguish the two sides;
- then emit the code for one side at a time. */
-
- /* See if the value matches what the right hand side
- wants. */
- probability
- = conditional_probability (node->right->prob,
- subtree_prob + default_prob);
- bb = do_jump_if_equal (bb, index, node->right->low,
- node->right->case_bb, probability,
- phi_mapping);
-
- /* See if the value matches what the left hand side
- wants. */
- probability
- = conditional_probability (node->left->prob,
- subtree_prob + default_prob);
- bb = do_jump_if_equal (bb, index, node->left->low,
- node->left->case_bb, probability,
- phi_mapping);
- }
-
- else
- {
- /* Neither node is bounded. First distinguish the two sides;
- then emit the code for one side at a time. */
-
- basic_block test_bb = split_edge (single_succ_edge (bb));
- redirect_edge_succ (single_pred_edge (test_bb),
- single_succ_edge (bb)->dest);
-
- /* The default label could be reached either through the right
- subtree or the left subtree. Divide the probability
- equally. */
- probability
- = conditional_probability (node->right->subtree_prob
- + default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- /* See if the value is on the right. */
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- test_bb, probability, phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
-
- /* Value must be on the left.
- Handle the left-hand subtree. */
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- /* If left-hand subtree does nothing,
- go to default. */
-
- if (bb && default_bb)
- emit_jump (bb, default_bb, phi_mapping);
-
- /* Code branches here for the right-hand subtree. */
- bb = emit_case_nodes (test_bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
- }
- else if (node->right != 0 && node->left == 0)
- {
- /* Here we have a right child but no left so we issue a conditional
- branch to default and process the right child.
-
- Omit the conditional branch to default if the right child
- does not have any children and is single valued; it would
- cost too much space to save so little time. */
-
- if (node->right->right || node->right->left
- || !tree_int_cst_equal (node->right->low, node->right->high))
- {
- if (!node_has_low_bound (node, index_type))
- {
- probability
- = conditional_probability (default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, LT_EXPR,
- default_bb, probability,
- phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
- }
-
- bb = emit_case_nodes (bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
- else
- {
- probability
- = conditional_probability (node->right->subtree_prob,
- subtree_prob + default_prob);
- /* We cannot process node->right normally
- since we haven't ruled out the numbers less than
- this node's value. So handle node->right explicitly. */
- bb = do_jump_if_equal (bb, index, node->right->low,
- node->right->case_bb, probability,
- phi_mapping);
- }
- }
-
- else if (node->right == 0 && node->left != 0)
- {
- /* Just one subtree, on the left. */
- if (node->left->left || node->left->right
- || !tree_int_cst_equal (node->left->low, node->left->high))
- {
- if (!node_has_high_bound (node, index_type))
- {
- probability
- = conditional_probability (default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- default_bb, probability,
- phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
- }
-
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
- else
- {
- probability
- = conditional_probability (node->left->subtree_prob,
- subtree_prob + default_prob);
- /* We cannot process node->left normally
- since we haven't ruled out the numbers less than
- this node's value. So handle node->left explicitly. */
- do_jump_if_equal (bb, index, node->left->low, node->left->case_bb,
- probability, phi_mapping);
- }
- }
- }
- else
- {
- /* Node is a range. These cases are very similar to those for a single
- value, except that we do not start by testing whether this node
- is the one to branch to. */
-
- if (node->right != 0 && node->left != 0)
- {
- /* Node has subtrees on both sides.
- If the right-hand subtree is bounded,
- test for it first, since we can go straight there.
- Otherwise, we need to make a branch in the control structure,
- then handle the two subtrees. */
- basic_block test_bb = NULL;
-
- if (node_is_bounded (node->right, index_type))
- {
- /* Right hand node is fully bounded so we can eliminate any
- testing and branch directly to the target code. */
- probability
- = conditional_probability (node->right->subtree_prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- node->right->case_bb, probability,
- phi_mapping);
- }
- else
- {
- /* Right hand node requires testing.
- Branch to a label where we will handle it later. */
-
- test_bb = split_edge (single_succ_edge (bb));
- redirect_edge_succ (single_pred_edge (test_bb),
- single_succ_edge (bb)->dest);
-
- probability
- = conditional_probability (node->right->subtree_prob
- + default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- test_bb, probability, phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
- }
-
- /* Value belongs to this node or to the left-hand subtree. */
-
- probability
- = conditional_probability (prob, subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->low, GE_EXPR,
- node->case_bb, probability,
- phi_mapping);
-
- /* Handle the left-hand subtree. */
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
+ /* If node is null, we are done. */
+ if (node == NULL)
+ return bb;
+
+ /* Branch to a label where we will handle it later. */
+ basic_block test_bb = split_edge (single_succ_edge (bb));
+ redirect_edge_succ (single_pred_edge (test_bb),
+ single_succ_edge (bb)->dest);
+
+ profile_probability probability
+ = node->right ? node->right->subtree_prob : profile_probability::never ();
+ probability
+ = conditional_probability (probability + default_prob.apply_scale (1, 2),
+ node->subtree_prob + default_prob);
+ bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
+ test_bb, probability, phi_mapping);
+ default_prob = default_prob.apply_scale (1, 2);
+
+ /* Value belongs to this node or to the left-hand subtree. */
+ probability
+ = conditional_probability (node->prob, node->subtree_prob + default_prob);
+ bb = emit_cmp_and_jump_insns (bb, index, node->low, GE_EXPR,
+ node->case_bb, probability,
phi_mapping);
- /* If right node had to be handled later, do that now. */
- if (test_bb)
- {
- /* If the left-hand subtree fell through,
- don't let it fall into the right-hand subtree. */
- if (bb && default_bb)
- emit_jump (bb, default_bb, phi_mapping);
-
- bb = emit_case_nodes (test_bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
- }
-
- else if (node->right != 0 && node->left == 0)
- {
- /* Deal with values to the left of this node,
- if they are possible. */
- if (!node_has_low_bound (node, index_type))
- {
- probability
- = conditional_probability (default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->low, LT_EXPR,
- default_bb, probability,
- phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
- }
-
- /* Value belongs to this node or to the right-hand subtree. */
-
- probability
- = conditional_probability (prob, subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, LE_EXPR,
- node->case_bb, probability,
- phi_mapping);
-
- bb = emit_case_nodes (bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
-
- else if (node->right == 0 && node->left != 0)
- {
- /* Deal with values to the right of this node,
- if they are possible. */
- if (!node_has_high_bound (node, index_type))
- {
- probability
- = conditional_probability (default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- default_bb, probability,
- phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
- }
-
- /* Value belongs to this node or to the left-hand subtree. */
+ /* Handle the left-hand subtree. */
+ bb = emit_case_nodes (bb, index, node->left, default_bb,
+ default_label, default_prob, index_type,
+ phi_mapping);
- probability
- = conditional_probability (prob, subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->low, GE_EXPR,
- node->case_bb, probability,
- phi_mapping);
-
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
-
- else
- {
- /* Node has no children so we check low and high bounds to remove
- redundant tests. Only one of the bounds can exist,
- since otherwise this node is bounded--a case tested already. */
- bool high_bound = node_has_high_bound (node, index_type);
- bool low_bound = node_has_low_bound (node, index_type);
-
- if (!high_bound && low_bound)
- {
- probability
- = conditional_probability (default_prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- default_bb, probability,
- phi_mapping);
- }
-
- else if (!low_bound && high_bound)
- {
- probability
- = conditional_probability (default_prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->low, LT_EXPR,
- default_bb, probability,
- phi_mapping);
- }
- else if (!low_bound && !high_bound)
- {
- tree lhs, rhs;
- generate_range_test (bb, index, node->low, node->high,
- &lhs, &rhs);
- probability
- = conditional_probability (default_prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, lhs, rhs, GT_EXPR,
- default_bb, probability,
- phi_mapping);
- }
+ /* If the left-hand subtree fell through,
+ don't let it fall into the right-hand subtree. */
+ if (default_bb)
+ emit_jump (bb, default_bb, phi_mapping);
- emit_jump (bb, node->case_bb, phi_mapping);
- return NULL;
- }
- }
+ bb = emit_case_nodes (test_bb, index, node->right, default_bb,
+ default_label, default_prob, index_type,
+ phi_mapping);
return bb;
}
-
-/* Search the parent sections of the case node tree
- to see if a test for the lower bound of NODE would be redundant.
- INDEX_TYPE is the type of the index expression.
-
- The instructions to generate the case decision tree are
- output in the same order as nodes are processed so it is
- known that if a parent node checks the range of the current
- node minus one that the current node is bounded at its lower
- span. Thus the test would be redundant. */
-
-static bool
-node_has_low_bound (case_node_ptr node, tree index_type)
-{
- tree low_minus_one;
- case_node_ptr pnode;
-
- /* If the lower bound of this node is the lowest value in the index type,
- we need not test it. */
-
- if (tree_int_cst_equal (node->low, TYPE_MIN_VALUE (index_type)))
- return true;
-
- /* If this node has a left branch, the value at the left must be less
- than that at this node, so it cannot be bounded at the bottom and
- we need not bother testing any further. */
-
- if (node->left)
- return false;
-
- low_minus_one = fold_build2 (MINUS_EXPR, TREE_TYPE (node->low), node->low,
- build_int_cst (TREE_TYPE (node->low), 1));
-
- /* If the subtraction above overflowed, we can't verify anything.
- Otherwise, look for a parent that tests our value - 1. */
-
- if (!tree_int_cst_lt (low_minus_one, node->low))
- return false;
-
- for (pnode = node->parent; pnode; pnode = pnode->parent)
- if (tree_int_cst_equal (low_minus_one, pnode->high))
- return true;
-
- return false;
-}
-
-/* Search the parent sections of the case node tree
- to see if a test for the upper bound of NODE would be redundant.
- INDEX_TYPE is the type of the index expression.
-
- The instructions to generate the case decision tree are
- output in the same order as nodes are processed so it is
- known that if a parent node checks the range of the current
- node plus one that the current node is bounded at its upper
- span. Thus the test would be redundant. */
-
-static bool
-node_has_high_bound (case_node_ptr node, tree index_type)
-{
- tree high_plus_one;
- case_node_ptr pnode;
-
- /* If there is no upper bound, obviously no test is needed. */
-
- if (TYPE_MAX_VALUE (index_type) == NULL)
- return true;
-
- /* If the upper bound of this node is the highest value in the type
- of the index expression, we need not test against it. */
-
- if (tree_int_cst_equal (node->high, TYPE_MAX_VALUE (index_type)))
- return true;
-
- /* If this node has a right branch, the value at the right must be greater
- than that at this node, so it cannot be bounded at the top and
- we need not bother testing any further. */
-
- if (node->right)
- return false;
-
- high_plus_one = fold_build2 (PLUS_EXPR, TREE_TYPE (node->high), node->high,
- build_int_cst (TREE_TYPE (node->high), 1));
-
- /* If the addition above overflowed, we can't verify anything.
- Otherwise, look for a parent that tests our value + 1. */
-
- if (!tree_int_cst_lt (node->high, high_plus_one))
- return false;
-
- for (pnode = node->parent; pnode; pnode = pnode->parent)
- if (tree_int_cst_equal (high_plus_one, pnode->low))
- return true;
-
- return false;
-}
-
-/* Search the parent sections of the
- case node tree to see if both tests for the upper and lower
- bounds of NODE would be redundant. */
-
-static bool
-node_is_bounded (case_node_ptr node, tree index_type)
-{
- return (node_has_low_bound (node, index_type)
- && node_has_high_bound (node, index_type));
-}
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2017-09-14 12:17 [PATCH][RFC] Radically simplify emission of balanced tree for switch statements Martin Liška
@ 2017-09-15 22:19 ` Jeff Law
2017-09-20 7:24 ` Martin Liška
2017-10-06 12:26 ` [PATCH] Implement smart multiple switch expansion algorithms Martin Liška
0 siblings, 2 replies; 28+ messages in thread
From: Jeff Law @ 2017-09-15 22:19 UTC (permalink / raw)
To: Martin Liška, gcc-patches
On 09/14/2017 06:17 AM, Martin Liška wrote:
> Hello.
>
> As mentioned at Cauldron 2017, second step in switch lowering should be massive
> simplification in code that does expansion of balanced tree. Basically it includes
> VRP and DCE, which we can for obvious reason do by our own.
>
> The patch does that, and introduces a separate pass for -O0 that's responsible
> for lowering at the end of tree pass.
>
> There's a small fallback that I would like to discuss:
>
> 1) vrp105.c - there's no longer catches threading opportunity in between default cases:
> adding Patrick who can probably help why is the opportunity skipped with expanded tree
Well, VRP knows how to analyze a switch statement and determine when
paths out of one switch imply a particular case will be taken in a later
switch. In this particular case we're trying to verify that the default
case in the first switch threads directly to the default case in the
second (though it seems we ought to be able to totally thread the cases).
Obviously we don't have switches anymore after your lowering pass. But
ISTM we still ought to be able to evaluate how your lowering affects
jump threading on this case. In theory the lowered switch statements
should be easier to thread.
Reality is sadly different. There's two cases to consider. One when i
< 0 (should go to first default, then directly to second default). The
other when i > 1 which should also go to the first default, then
directly to the second default).
When i < 0 we do in fact thread through the second switch and go from
the first default case directly to the second default case.
When i > 1 we still go through the test for the second switch.
These are the key blocks:
;; basic block 2, loop depth 0, freq 10000, maybe hot
;; prev block 0, next block 3, flags: (NEW, REACHABLE, VISITED)
;; pred: ENTRY [always] (FALLTHRU,EXECUTABLE)
i.0_1 = i;
if (i.0_1 > 0)
goto <bb 4>; [50.01%] [count: INV]
else
goto <bb 3>; [49.99%] [count: INV]
;; succ: 3 [50.0% (guessed)] (FALSE_VALUE,EXECUTABLE)
;; 4 [50.0% (guessed)] (TRUE_VALUE,EXECUTABLE)
;; basic block 3, loop depth 0, freq 10000, maybe hot
;; Invalid sum of incoming frequencies 4999, should be 10000
;; prev block 2, next block 4, flags: (NEW, REACHABLE, VISITED)
;; pred: 2 [50.0% (guessed)] (FALSE_VALUE,EXECUTABLE)
if (i.0_1 == 0)
goto <bb 5>; [40.00%] [count: INV]
else
goto <bb 14>; [60.00%] [count: INV]
;; succ: 14 [60.0% (guessed)] (FALSE_VALUE,EXECUTABLE)
;; 5 [40.0% (guessed)] (TRUE_VALUE,EXECUTABLE)
;; basic block 4, loop depth 0, freq 10000, maybe hot
;; Invalid sum of incoming frequencies 5001, should be 10000
;; prev block 3, next block 5, flags: (NEW, REACHABLE, VISITED)
;; pred: 2 [50.0% (guessed)] (TRUE_VALUE,EXECUTABLE)
_13 = i.0_1 != 1;
if (_13 != 0)
goto <bb 13>; [16.68%] [count: INV]
else
goto <bb 6>; [83.32%] [count: INV]
;; succ: 6 [83.3% (guessed)] (FALSE_VALUE,EXECUTABLE)
;; 13 [16.7% (guessed)] (TRUE_VALUE,EXECUTABLE)
[ ... ]
;; basic block 9, loop depth 0, freq 9999, maybe hot
;; Invalid sum of incoming frequencies 3999, should be 9999
;; prev block 8, next block 10, flags: (NEW, REACHABLE, VISITED)
;; pred: 13 [always] (FALLTHRU,EXECUTABLE)
;; 7 [always (guessed)] (TRUE_VALUE,EXECUTABLE)
# prephitmp_19 = PHI <prephitmp_15(13), prephitmp_12(7)>
_2 = prephitmp_19 != 1;
if (_2 != 0)
goto <bb 12>; [16.68%] [count: INV]
else
goto <bb 11>; [83.32%] [count: INV]
;; succ: 11 [83.3% (guessed)] (FALSE_VALUE,EXECUTABLE)
;; 12 [16.7% (guessed)] (TRUE_VALUE,EXECUTABLE)
[ ... ]
;; basic block 13, loop depth 0, freq 1668, maybe hot
;; prev block 12, next block 14, flags: (NEW, REACHABLE, VISITED)
;; pred: 4 [16.7% (guessed)] (TRUE_VALUE,EXECUTABLE)
# prephitmp_15 = PHI <i.0_1(4)>
goto <bb 9>; [100.00%] [count: INV]
;; succ: 9 [always] (FALLTHRU,EXECUTABLE)
WHen bb9 is reached by bb13 we know by back substitution that the assignemnt
_2 = prehitmp_19 != 1
_2 = prehitmp_15 != 1
_2 = i.0_1 != 1
And we should know enough about the range of i.0_1 to determine that is
true which would allow us to thread the jump. But a few things get in
the way.
First, the VRP thread doesn't try hard at all to simplify gimple
assignments. It really just tries to simplify gimple_cond and
gimple_switch. This could be trivially improved.
So if I do the right things by hand we end up trying to evaluate i.0_1
!= 1. So that's good. But we don't get a useful result back from
vrp_evaluate_conditional. WHy? Because the recorded range for i.0_1 is
[1,INF] -- that's the global range for i.0_1 not the range on the path.
Now it turns out this is precisely the problem that I've got code to
address in my queue which fixes a regression I was working on earlier
this year in the gcc-7 cycle. It's backed up behind some improvements
to tree-ssa-uninit.c that Richi and I still need to hash through.
This would likely also be fixed by Andrew's work on ranges. It's
precisely the kind of query its designed to answer.
In summary, your switch lowering does regress the code we get for this
test. But the regression is more a failing of the jump threader than
anything.
>
> 2) uninit-18.c where we currently report:
>
> /home/marxin/Programming/gcc/gcc/testsuite/gcc.dg/uninit-18.c:13:12: warning: ‘tmp’ may be used uninitialized in this function [-Wmaybe-uninitialized]
> tmp[5] = 7; /* { dg-bogus "may be used uninitialized" } */
>
> Am I right that the pass uses VRP?
No, it doesn't use VRP. If you look at the history of uninit-18 it shows:
commit cac06b024306772e2be2d357064f7ca2aa82bde8
Author: rguenth <rguenth@138bc75d-0d04-0410-961f-82ee72b054a4>
Date: Fri Jan 16 13:26:10 2015 +0000
2015-01-16 Richard Biener <rguenther@suse.de>
PR middle-end/64614
* tree-ssa-uninit.c: Include tree-cfg.h.
(MAX_SWITCH_CASES): New define.
(convert_control_dep_chain_into_preds): Handle switch
statements.
(is_pred_expr_subset_of): Handle x == CST vs. (x & CST) != 0.
(normalize_one_pred_1): Do not split bit-manipulations.
Record (x & CST).
* gcc.dg/uninit-18.c: New testcase.
Essentially tree-ssa-uninit.c has some specialized code to handle switch
statements in predicates with BIT_AND_EXPR and uninit-18.c tests that
capability.
Your new switch lowering breaks that relatively specialized code.
You could further enhance uninit to detect this. From the .uninit dump:
MEM[(char *)tmp_2 + 5B] = 7;
is guarded by :
bar_5(D) > 0 (.AND.) (.NOT.) bar_5(D) > 1
[CHECK]: Found unguarded use: MEM[(char *)tmp_2 + 5B] = 7;
So that check is really bar_5 == 1 and in theory if bar_5 == 1, then we
would have assigned a value to tmp. VRP is capable of making that
determination and I think when VRP does that, things simplify enough
that the general predicate code in tree-ssa-uninit.c will DTRT.
I wonder if we could get the tighter test coming out of switch lowering,
or discover it in DOM, then there's a reasonable change
tree-ssa-uninit.c would just DTRT.
Looking at the DOM dumps we have:
Optimizing block #5
1>>> STMT 1 = bar_5(D) le_expr 1
1>>> STMT 0 = bar_5(D) gt_expr 1
Optimizing statement if (bar_5(D) >= 1)
LKUP STMT bar_5(D) ge_expr 1
DOM doesn't usually try to do any kind of range optimization. But this
is a case where it might make sense.
So the first two lines indicate that we know bar5 <= 1 is true and that
bar5 > 1 must be false. Those are expressions we can look up in the
hash table.
So when the lookup bar5 >= 1 fails we could in theory lookup bar5 <= 1
and if that's true, then we know the test could be simplified to bar5 == 1
I don't know how often this would hit in general and when it hits how
often the resulting code is actually better. I can try to do some
instrumentation on that... I wonder if that might help the first case
as well.
>
> Last question is whether the pass is properly moved in optimization pipeline?
> Patch can bootstrap on ppc64le-redhat-linux and survives regression tests.
Well, that's a *real* interesting question. THe two cases above argue
that it's too early. However, I could easily make an argument that the
spot you chose was reasonable -- namely it's after the first set of
threading/vrp/dom passes, but before the second set of threading/vrp/dom
passes.
Let me poke a bit with DOM and see if it can reasonably clean up this
stuff and whether or not the transformation is generally useful.
Jeff
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2017-09-15 22:19 ` Jeff Law
@ 2017-09-20 7:24 ` Martin Liška
2017-09-20 15:00 ` Jeff Law
2017-10-06 12:26 ` [PATCH] Implement smart multiple switch expansion algorithms Martin Liška
1 sibling, 1 reply; 28+ messages in thread
From: Martin Liška @ 2017-09-20 7:24 UTC (permalink / raw)
To: Jeff Law, gcc-patches
On 09/16/2017 12:19 AM, Jeff Law wrote:
> On 09/14/2017 06:17 AM, Martin Liška wrote:
>> Hello.
>>
>> As mentioned at Cauldron 2017, second step in switch lowering should be massive
>> simplification in code that does expansion of balanced tree. Basically it includes
>> VRP and DCE, which we can for obvious reason do by our own.
>>
>> The patch does that, and introduces a separate pass for -O0 that's responsible
>> for lowering at the end of tree pass.
>>
>> There's a small fallback that I would like to discuss:
>>
>> 1) vrp105.c - there's no longer catches threading opportunity in between default cases:
>> adding Patrick who can probably help why is the opportunity skipped with expanded tree
> Well, VRP knows how to analyze a switch statement and determine when
> paths out of one switch imply a particular case will be taken in a later
> switch. In this particular case we're trying to verify that the default
> case in the first switch threads directly to the default case in the
> second (though it seems we ought to be able to totally thread the cases).
>
> Obviously we don't have switches anymore after your lowering pass. But
> ISTM we still ought to be able to evaluate how your lowering affects
> jump threading on this case. In theory the lowered switch statements
> should be easier to thread.
>
> Reality is sadly different. There's two cases to consider. One when i
> < 0 (should go to first default, then directly to second default). The
> other when i > 1 which should also go to the first default, then
> directly to the second default).
>
> When i < 0 we do in fact thread through the second switch and go from
> the first default case directly to the second default case.
>
> When i > 1 we still go through the test for the second switch.
>
> These are the key blocks:
>
> ;; basic block 2, loop depth 0, freq 10000, maybe hot
> ;; prev block 0, next block 3, flags: (NEW, REACHABLE, VISITED)
> ;; pred: ENTRY [always] (FALLTHRU,EXECUTABLE)
> i.0_1 = i;
> if (i.0_1 > 0)
> goto <bb 4>; [50.01%] [count: INV]
> else
> goto <bb 3>; [49.99%] [count: INV]
> ;; succ: 3 [50.0% (guessed)] (FALSE_VALUE,EXECUTABLE)
> ;; 4 [50.0% (guessed)] (TRUE_VALUE,EXECUTABLE)
>
> ;; basic block 3, loop depth 0, freq 10000, maybe hot
> ;; Invalid sum of incoming frequencies 4999, should be 10000
> ;; prev block 2, next block 4, flags: (NEW, REACHABLE, VISITED)
> ;; pred: 2 [50.0% (guessed)] (FALSE_VALUE,EXECUTABLE)
> if (i.0_1 == 0)
> goto <bb 5>; [40.00%] [count: INV]
> else
> goto <bb 14>; [60.00%] [count: INV]
> ;; succ: 14 [60.0% (guessed)] (FALSE_VALUE,EXECUTABLE)
> ;; 5 [40.0% (guessed)] (TRUE_VALUE,EXECUTABLE)
>
> ;; basic block 4, loop depth 0, freq 10000, maybe hot
> ;; Invalid sum of incoming frequencies 5001, should be 10000
> ;; prev block 3, next block 5, flags: (NEW, REACHABLE, VISITED)
> ;; pred: 2 [50.0% (guessed)] (TRUE_VALUE,EXECUTABLE)
> _13 = i.0_1 != 1;
> if (_13 != 0)
> goto <bb 13>; [16.68%] [count: INV]
> else
> goto <bb 6>; [83.32%] [count: INV]
> ;; succ: 6 [83.3% (guessed)] (FALSE_VALUE,EXECUTABLE)
> ;; 13 [16.7% (guessed)] (TRUE_VALUE,EXECUTABLE)
>
> [ ... ]
>
> ;; basic block 9, loop depth 0, freq 9999, maybe hot
> ;; Invalid sum of incoming frequencies 3999, should be 9999
> ;; prev block 8, next block 10, flags: (NEW, REACHABLE, VISITED)
> ;; pred: 13 [always] (FALLTHRU,EXECUTABLE)
> ;; 7 [always (guessed)] (TRUE_VALUE,EXECUTABLE)
> # prephitmp_19 = PHI <prephitmp_15(13), prephitmp_12(7)>
> _2 = prephitmp_19 != 1;
> if (_2 != 0)
> goto <bb 12>; [16.68%] [count: INV]
> else
> goto <bb 11>; [83.32%] [count: INV]
> ;; succ: 11 [83.3% (guessed)] (FALSE_VALUE,EXECUTABLE)
> ;; 12 [16.7% (guessed)] (TRUE_VALUE,EXECUTABLE)
>
> [ ... ]
> ;; basic block 13, loop depth 0, freq 1668, maybe hot
> ;; prev block 12, next block 14, flags: (NEW, REACHABLE, VISITED)
> ;; pred: 4 [16.7% (guessed)] (TRUE_VALUE,EXECUTABLE)
> # prephitmp_15 = PHI <i.0_1(4)>
> goto <bb 9>; [100.00%] [count: INV]
> ;; succ: 9 [always] (FALLTHRU,EXECUTABLE)
>
>
>
> WHen bb9 is reached by bb13 we know by back substitution that the assignemnt
>
> _2 = prehitmp_19 != 1
> _2 = prehitmp_15 != 1
> _2 = i.0_1 != 1
>
> And we should know enough about the range of i.0_1 to determine that is
> true which would allow us to thread the jump. But a few things get in
> the way.
>
> First, the VRP thread doesn't try hard at all to simplify gimple
> assignments. It really just tries to simplify gimple_cond and
> gimple_switch. This could be trivially improved.
>
> So if I do the right things by hand we end up trying to evaluate i.0_1
> != 1. So that's good. But we don't get a useful result back from
> vrp_evaluate_conditional. WHy? Because the recorded range for i.0_1 is
> [1,INF] -- that's the global range for i.0_1 not the range on the path.
>
> Now it turns out this is precisely the problem that I've got code to
> address in my queue which fixes a regression I was working on earlier
> this year in the gcc-7 cycle. It's backed up behind some improvements
> to tree-ssa-uninit.c that Richi and I still need to hash through.
>
> This would likely also be fixed by Andrew's work on ranges. It's
> precisely the kind of query its designed to answer.
>
> In summary, your switch lowering does regress the code we get for this
> test. But the regression is more a failing of the jump threader than
> anything.
>
>>
>> 2) uninit-18.c where we currently report:
>>
>> /home/marxin/Programming/gcc/gcc/testsuite/gcc.dg/uninit-18.c:13:12: warning: ‘tmp’ may be used uninitialized in this function [-Wmaybe-uninitialized]
>> tmp[5] = 7; /* { dg-bogus "may be used uninitialized" } */
>>
>> Am I right that the pass uses VRP?
> No, it doesn't use VRP. If you look at the history of uninit-18 it shows:
> commit cac06b024306772e2be2d357064f7ca2aa82bde8
> Author: rguenth <rguenth@138bc75d-0d04-0410-961f-82ee72b054a4>
> Date: Fri Jan 16 13:26:10 2015 +0000
>
> 2015-01-16 Richard Biener <rguenther@suse.de>
>
> PR middle-end/64614
> * tree-ssa-uninit.c: Include tree-cfg.h.
> (MAX_SWITCH_CASES): New define.
> (convert_control_dep_chain_into_preds): Handle switch
> statements.
> (is_pred_expr_subset_of): Handle x == CST vs. (x & CST) != 0.
> (normalize_one_pred_1): Do not split bit-manipulations.
> Record (x & CST).
>
> * gcc.dg/uninit-18.c: New testcase.
>
> Essentially tree-ssa-uninit.c has some specialized code to handle switch
> statements in predicates with BIT_AND_EXPR and uninit-18.c tests that
> capability.
>
> Your new switch lowering breaks that relatively specialized code.
>
> You could further enhance uninit to detect this. From the .uninit dump:
>
> MEM[(char *)tmp_2 + 5B] = 7;
> is guarded by :
>
> bar_5(D) > 0 (.AND.) (.NOT.) bar_5(D) > 1
>
>
> [CHECK]: Found unguarded use: MEM[(char *)tmp_2 + 5B] = 7;
>
>
> So that check is really bar_5 == 1 and in theory if bar_5 == 1, then we
> would have assigned a value to tmp. VRP is capable of making that
> determination and I think when VRP does that, things simplify enough
> that the general predicate code in tree-ssa-uninit.c will DTRT.
>
> I wonder if we could get the tighter test coming out of switch lowering,
> or discover it in DOM, then there's a reasonable change
> tree-ssa-uninit.c would just DTRT.
>
> Looking at the DOM dumps we have:
>
> Optimizing block #5
>
> 1>>> STMT 1 = bar_5(D) le_expr 1
> 1>>> STMT 0 = bar_5(D) gt_expr 1
> Optimizing statement if (bar_5(D) >= 1)
> LKUP STMT bar_5(D) ge_expr 1
>
>
> DOM doesn't usually try to do any kind of range optimization. But this
> is a case where it might make sense.
>
> So the first two lines indicate that we know bar5 <= 1 is true and that
> bar5 > 1 must be false. Those are expressions we can look up in the
> hash table.
>
> So when the lookup bar5 >= 1 fails we could in theory lookup bar5 <= 1
> and if that's true, then we know the test could be simplified to bar5 == 1
>
> I don't know how often this would hit in general and when it hits how
> often the resulting code is actually better. I can try to do some
> instrumentation on that... I wonder if that might help the first case
> as well.
>
>
>>
>> Last question is whether the pass is properly moved in optimization pipeline?
>> Patch can bootstrap on ppc64le-redhat-linux and survives regression tests.
> Well, that's a *real* interesting question. THe two cases above argue
> that it's too early. However, I could easily make an argument that the
> spot you chose was reasonable -- namely it's after the first set of
> threading/vrp/dom passes, but before the second set of threading/vrp/dom
> passes.
>
> Let me poke a bit with DOM and see if it can reasonably clean up this
> stuff and whether or not the transformation is generally useful.
>
> Jeff
>
Hello.
Thank you Jeff for very verbose explanation what's happening. I'm planning to do
follow-up of this patch that will include clustering for bit-tests and jump tables.
Maybe that will make aforementioned issues even more difficult, but we'll see.
Martin
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2017-09-20 7:24 ` Martin Liška
@ 2017-09-20 15:00 ` Jeff Law
2017-09-21 23:12 ` Bernhard Reutner-Fischer
2018-01-09 14:46 ` Martin Liška
0 siblings, 2 replies; 28+ messages in thread
From: Jeff Law @ 2017-09-20 15:00 UTC (permalink / raw)
To: Martin Liška, gcc-patches
On 09/20/2017 01:24 AM, Martin Liška wrote:
>
> Hello.
>
> Thank you Jeff for very verbose explanation what's happening. I'm planning to do
> follow-up of this patch that will include clustering for bit-tests and jump tables.
> Maybe that will make aforementioned issues even more difficult, but we'll see.
FWIW, the DOM changes to simplify the conditionals seem to help both
cases, trigger reasonably consistently in a bootstrap and for some
subset of the triggers actually result in transformations that allow
other passes to do a better job in the common (-O2) case. So my
inclination is to polish them a bit further get them on the trunk.
My recommendation is to ignore the two regressions for now and focus on
the cleanups you're trying to do.
jeff
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2017-09-20 15:00 ` Jeff Law
@ 2017-09-21 23:12 ` Bernhard Reutner-Fischer
2018-01-09 14:46 ` Martin Liška
1 sibling, 0 replies; 28+ messages in thread
From: Bernhard Reutner-Fischer @ 2017-09-21 23:12 UTC (permalink / raw)
To: gcc-patches, Jeff Law, Martin Liška
On 20 September 2017 17:00:13 CEST, Jeff Law <law@redhat.com> wrote:
>On 09/20/2017 01:24 AM, Martin Liška wrote:
>
>>
>> Hello.
>>
>> Thank you Jeff for very verbose explanation what's happening. I'm
>planning to do
>> follow-up of this patch that will include clustering for bit-tests
>and jump tables.
>> Maybe that will make aforementioned issues even more difficult, but
>we'll see.
>FWIW, the DOM changes to simplify the conditionals seem to help both
>cases, trigger reasonably consistently in a bootstrap and for some
>subset of the triggers actually result in transformations that allow
>other passes to do a better job in the common (-O2) case. So my
>inclination is to polish them a bit further get them on the trunk.
>
>My recommendation is to ignore the two regressions for now and focus on
>the cleanups you're trying to do.
Can you please post CSiBE numbers?
Ideally throwing in gcc-3.4.6 numbers too?
Just curious since I stumbled across suboptimal handling of switch statements some time ago:
gcc.gnu.org/ml/gcc-patches/2007-06/msg01648.html
thanks,
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH] Implement smart multiple switch expansion algorithms.
2017-09-15 22:19 ` Jeff Law
2017-09-20 7:24 ` Martin Liška
@ 2017-10-06 12:26 ` Martin Liška
2017-10-06 16:20 ` [PATCH] Add selftest for vec::reverse David Malcolm
2017-10-06 17:24 ` [PATCH] Implement smart multiple switch expansion algorithms David Malcolm
1 sibling, 2 replies; 28+ messages in thread
From: Martin Liška @ 2017-10-06 12:26 UTC (permalink / raw)
To: Jeff Law, gcc-patches; +Cc: Jan Hubicka
[-- Attachment #1: Type: text/plain, Size: 3121 bytes --]
Hello.
As presented at this year's Cauldron, I rewrote current switch expansion to support
multiple algorithms (jump table and bit-test) that can be used just for a fraction
of cases. Balanced decision tree is built on top of that. I decided to do a bigger
refactoring and put all there 3 mentioned algorithm to its own class.
There's a bigger change in jump_table_cluster::can_be_handled where the constant 10 (3 respectively)
is compared to number of handled values, and not number of cases. Later one is wrong in my opinion.
There are some numbers for cc1plus:
$ bloaty ./objdir2/gcc/cc1plus -- ./objdir/gcc/cc1plus
VM SIZE FILE SIZE
++++++++++++++ GROWING ++++++++++++++
+19% +1.32Mi .rodata +1.32Mi +19%
[ = ] 0 .symtab +7.38Ki +0.5%
[ = ] 0 .strtab +5.18Ki +0.2%
[ = ] 0 .debug_info +743 +0.0%
+0.0% +712 .eh_frame +712 +0.0%
+0.1% +440 .eh_frame_hdr +440 +0.1%
[ = ] 0 .debug_aranges +80 +0.1%
+0.0% +67 .dynstr +67 +0.0%
[ = ] 0 .debug_str +6 +0.0%
-------------- SHRINKING --------------
-1.2% -214Ki .text -214Ki -1.2%
[ = ] 0 .debug_loc -66.7Ki -0.1%
[ = ] 0 .debug_line -14.0Ki -0.2%
[ = ] 0 .debug_ranges -9.56Ki -0.1%
-6.8% -3 [Unmapped] -375 -14.4%
[ = ] 0 .debug_abbrev -46 -0.0%
+3.8% +1.11Mi TOTAL +1.03Mi +0.5%
So it growth and can be easily explained:
insn-attrtab.o:
VM SIZE FILE SIZE
++++++++++++++ GROWING ++++++++++++++
[ = ] 0 .rela.rodata +2.00Mi +215%
+214% +682Ki .rodata +682Ki +214%
[ = ] 0 .rela.debug_loc +29.3Ki +36%
+32% +1.91Ki .eh_frame +1.91Ki +32%
[ = ] 0 .debug_loc +37 +5.6%
[ = ] 0 .debug_str +2 +0.0%
-------------- SHRINKING --------------
-50.1% -63.3Ki .text -63.3Ki -50.1%
[ = ] 0 .debug_line -1.71Ki -10.4%
[ = ] 0 .rela.debug_info -768 -0.3%
[ = ] 0 .rela.text -624 -0.8%
[ = ] 0 .rela.debug_ranges -384 -2.7%
[ = ] 0 .debug_info -87 -0.2%
[ = ] 0 [Unmapped] -2 -8.7%
+137% +621Ki TOTAL +2.63Mi +139%
It's caused by:
...
;; GIMPLE switch case clusters: JT(2710):-1-5090
;; GIMPLE switch case clusters: JT(2710):-1-5090
;; GIMPLE switch case clusters: JT(2967):-1-5090
;; GIMPLE switch case clusters: JT(1033):-1-5017
...
so there are many switch statements with very reasonable density.
and
insn-dfatab.o: +13% +99.4Ki TOTAL +455Ki +14%
insn-latencytab.o: +19% +136Ki TOTAL +609Ki +20%
There shouldn't be any fallout other from what I mentioned in previous email that is
a prerequisite for this patch.
Patch can bootstrap on ppc64le-redhat-linux and survives regression tests.
I'm still planning to come with some numbers and stats. Will do that next week.
Martin
[-- Attachment #2: 0001-Implement-smart-multiple-switch-expansion-algorithms.patch --]
[-- Type: text/x-patch, Size: 135084 bytes --]
From db7ad52eb5d65e41d617fb3ff10ab1bc2cef8d04 Mon Sep 17 00:00:00 2001
From: marxin <mliska@suse.cz>
Date: Wed, 20 Sep 2017 15:22:04 +0200
Subject: [PATCH] Implement smart multiple switch expansion algorithms.
gcc/ChangeLog:
2017-09-29 Martin Liska <mliska@suse.cz>
* tree-switch-conversion.c (MAX_CASE_BIT_TESTS): Remove and move
to header file.
(hoist_edge_and_branch_if_true): Move to ...
(bit_test_cluster::hoist_edge_and_branch_if_true): ... this.
(expand_switch_using_bit_tests_p): Remove.
(struct case_bit_test): Move to header file.
(case_bit_test_cmp): Rename to case_bit_test::cmp.
(emit_case_bit_tests): Move to bit_test_cluster::emit.
(struct switch_conv_info): Transform to switch_conversion class.
(collect_switch_conv_info): Move to ...
(switch_conversion::collect): ... this.
(check_range): Move to ...
(switch_conversion::check_range): ... this.
(check_all_empty_except_final): Likewise.
(switch_conversion::check_all_empty_except_final): Likewise.
(check_final_bb): Likewise.
(switch_conversion::check_final_bb): Likewise.
(create_temp_arrays): Likewise.
(switch_conversion::create_temp_arrays): Likewise.
(free_temp_arrays): Remove.
(gather_default_values): Move to ...
(switch_conversion::gather_default_values): ... this.
(build_constructors): Likewise.
(switch_conversion::build_constructors): Likewise.
(array_value_type): Likewise.
(switch_conversion::array_value_type): Likewise.
(build_one_array): Likewise.
(switch_conversion::build_one_array): Likewise.
(build_arrays): Likewise.
(switch_conversion::build_arrays): Likewise.
(gen_def_assigns): Likewise.
(switch_conversion::gen_def_assigns): Likewise.
(prune_bbs): Likewise.
(switch_conversion::prune_bbs): Likewise.
(fix_phi_nodes): Likewise.
(switch_conversion::fix_phi_nodes): Likewise.
(gen_inbound_check): Likewise.
(switch_conversion::gen_inbound_check): Likewise.
(constructor_contains_same_values_p): Likewise.
(switch_conversion::contains_same_values_p): Likewise.
(process_switch): Likewise.
(switch_conversion::expand): Likewise.
(switch_conversion::~switch_conversion): New function.
(pass_convert_switch::execute): Use new functions.
(group_cluster::~group_cluster): New function.
(struct case_node): Move to header file.
(jump_table_cluster::jump_table_cluster): New function.
(jump_table_cluster::emit): Likewise.
(jump_table_cluster::find_jump_tables): Likewise.
(jump_table_cluster::can_be_handled): Likewise.
(jump_table_cluster::is_beneficial): Likewise.
(bit_test_cluster::bit_test_cluster): Likewise.
(bit_test_cluster::find_bit_tests): Likewise.
(bit_test_cluster::can_be_handled): Likewise.
(bit_test_cluster::is_beneficial): Likewise.
(case_bit_test::cmp): Likewise.
(bit_test_cluster::emit): Likewise.
(emit_case_nodes): Move to ...
(switch_decision_tree::emit_case_nodes): ... this.
(case_values_threshold): Move to
jump_table_cluster::case_values_threshold.
(reset_out_edges_aux): Move to
switch_decision_tree::reset_out_edges_aux.
(compute_cases_per_edge): Move to ...
(switch_decision_tree::compute_cases_per_edge): ... this.
(add_case_node): Remove.
(switch_decision_tree::analyze_switch_statement): New function.
(dump_case_nodes): Move to ...
(switch_decision_tree::dump_case_nodes): ... this.
(balance_case_nodes): Move to ...
(switch_decision_tree::balance_case_nodes): ... this.
(expand_switch_as_decision_tree_p): Remove.
(fix_phi_operands_for_edge): Move to ...
(switch_decision_tree::fix_phi_operands_for_edges): ... this.
(emit_jump): Move to ...
(switch_decision_tree::emit_jump): ... this.
(try_switch_expansion): Move to ...
(switch_decision_tree::try_switch_expansion): ... this.
(emit_case_decision_tree): Remove.
(record_phi_operand_mapping): Move to ...
(switch_decision_tree::record_phi_operand_mapping): ... this.
(switch_decision_tree::emit): New function.
(pass_lower_switch::execute): Make 2 instancens: for -O0 and
other optimization levels.
(emit_cmp_and_jump_insns): Move to ...
(switch_decision_tree::emit_cmp_and_jump_insns): ... this.
(conditional_probability): Remove.
* tree-switch-conversion.h: New file.
* vec.h (vl_ptr>::reverse): New function.
* passes.def: Add pass_lower_switch_O0.
* stmt.c (emit_case_dispatch_table): Fix tree folding.
(expand_case): Likewise.
gcc/testsuite/ChangeLog:
2017-10-05 Martin Liska <mliska@suse.cz>
* gcc.dg/ipa/ipa-icf-13.c: Update scanned pattern.
---
gcc/passes.def | 2 +-
gcc/stmt.c | 17 +-
gcc/testsuite/gcc.dg/ipa/ipa-icf-13.c | 3 +-
gcc/tree-switch-conversion.c | 2304 ++++++++++++++-------------------
gcc/tree-switch-conversion.h | 806 ++++++++++++
gcc/vec.h | 14 +
6 files changed, 1791 insertions(+), 1355 deletions(-)
create mode 100644 gcc/tree-switch-conversion.h
diff --git a/gcc/passes.def b/gcc/passes.def
index bb371d9bde5..ea0c6d37fa1 100644
--- a/gcc/passes.def
+++ b/gcc/passes.def
@@ -395,8 +395,8 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_lower_vaarg);
NEXT_PASS (pass_lower_vector);
NEXT_PASS (pass_lower_complex_O0);
- NEXT_PASS (pass_lower_switch_O0);
NEXT_PASS (pass_sancov_O0);
+ NEXT_PASS (pass_lower_switch_O0);
NEXT_PASS (pass_asan_O0);
NEXT_PASS (pass_tsan_O0);
NEXT_PASS (pass_sanopt);
diff --git a/gcc/stmt.c b/gcc/stmt.c
index 92bd209ad64..4743975a48a 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -776,18 +776,18 @@ emit_case_dispatch_table (tree index_expr, tree index_type,
for (unsigned j = 0; j < case_list.length (); j++)
{
simple_case_node *n = &case_list[j];
+ tree index_type_unsigned = signed_or_unsigned_type_for (1, index_type);
/* Compute the low and high bounds relative to the minimum
value since that should fit in a HOST_WIDE_INT while the
actual values may not. */
- HOST_WIDE_INT i_low
- = tree_to_uhwi (fold_build2 (MINUS_EXPR, index_type,
+ unsigned HOST_WIDE_INT i_low
+ = tree_to_uhwi (fold_build2 (MINUS_EXPR, index_type_unsigned,
n->m_low, minval));
- HOST_WIDE_INT i_high
- = tree_to_uhwi (fold_build2 (MINUS_EXPR, index_type,
+ unsigned HOST_WIDE_INT i_high
+ = tree_to_uhwi (fold_build2 (MINUS_EXPR, index_type_unsigned,
n->m_high, minval));
- HOST_WIDE_INT i;
- for (i = i_low; i <= i_high; i ++)
+ for (unsigned HOST_WIDE_INT i = i_low; i <= i_high; i ++)
labelvec[i]
= gen_rtx_LABEL_REF (Pmode, label_rtx (n->m_code_label));
}
@@ -913,7 +913,10 @@ expand_case (gswitch *stmt)
maxval = fold_convert (index_type, CASE_LOW (elt));
/* Compute span of values. */
- range = fold_build2 (MINUS_EXPR, index_type, maxval, minval);
+ tree index_type_unsigned = signed_or_unsigned_type_for (1, index_type);
+ range = fold_build2 (MINUS_EXPR, index_type_unsigned,
+ fold_convert (index_type_unsigned, maxval),
+ fold_convert (index_type_unsigned, minval));
/* Listify the labels queue and gather some numbers to decide
how to expand this switch(). */
diff --git a/gcc/testsuite/gcc.dg/ipa/ipa-icf-13.c b/gcc/testsuite/gcc.dg/ipa/ipa-icf-13.c
index 09d817c4030..3e59f8e0933 100644
--- a/gcc/testsuite/gcc.dg/ipa/ipa-icf-13.c
+++ b/gcc/testsuite/gcc.dg/ipa/ipa-icf-13.c
@@ -190,4 +190,5 @@ int main(int argc, char **argv)
/* { dg-final { scan-ipa-dump "Semantic equality hit:s1->s2" "icf" } } */
/* { dg-final { scan-ipa-dump "Semantic equality hit:nsd_different_result->nsd_different_result2" "icf" } } */
/* { dg-final { scan-ipa-dump "Semantic equality hit:gcd->nsd" "icf" } } */
-/* { dg-final { scan-ipa-dump "Equal symbols: 3" "icf" } } */
+/* { dg-final { scan-ipa-dump "Semantic equality hit:CSWTCH.*->CSWTCH.*" "icf" } } */
+/* { dg-final { scan-ipa-dump "Equal symbols: 4" "icf" } } */
diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c
index f67531b2620..6e928afc49c 100644
--- a/gcc/tree-switch-conversion.c
+++ b/gcc/tree-switch-conversion.c
@@ -49,629 +49,79 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
#include "alloc-pool.h"
#include "target.h"
#include "tree-into-ssa.h"
-
/* ??? For lang_hooks.types.type_for_mode, but is there a word_mode
type in the GIMPLE type system that is language-independent? */
#include "langhooks.h"
-\f
-/* Maximum number of case bit tests.
- FIXME: This should be derived from PARAM_CASE_VALUES_THRESHOLD and
- targetm.case_values_threshold(), or be its own param. */
-#define MAX_CASE_BIT_TESTS 3
-
-/* Split the basic block at the statement pointed to by GSIP, and insert
- a branch to the target basic block of E_TRUE conditional on tree
- expression COND.
-
- It is assumed that there is already an edge from the to-be-split
- basic block to E_TRUE->dest block. This edge is removed, and the
- profile information on the edge is re-used for the new conditional
- jump.
-
- The CFG is updated. The dominator tree will not be valid after
- this transformation, but the immediate dominators are updated if
- UPDATE_DOMINATORS is true.
-
- Returns the newly created basic block. */
-
-static basic_block
-hoist_edge_and_branch_if_true (gimple_stmt_iterator *gsip,
- tree cond, edge e_true,
- bool update_dominators)
-{
- tree tmp;
- gcond *cond_stmt;
- edge e_false;
- basic_block new_bb, split_bb = gsi_bb (*gsip);
- bool dominated_e_true = false;
-
- gcc_assert (e_true->src == split_bb);
-
- if (update_dominators
- && get_immediate_dominator (CDI_DOMINATORS, e_true->dest) == split_bb)
- dominated_e_true = true;
-
- tmp = force_gimple_operand_gsi (gsip, cond, /*simple=*/true, NULL,
- /*before=*/true, GSI_SAME_STMT);
- cond_stmt = gimple_build_cond_from_tree (tmp, NULL_TREE, NULL_TREE);
- gsi_insert_before (gsip, cond_stmt, GSI_SAME_STMT);
-
- e_false = split_block (split_bb, cond_stmt);
- new_bb = e_false->dest;
- redirect_edge_pred (e_true, split_bb);
-
- e_true->flags &= ~EDGE_FALLTHRU;
- e_true->flags |= EDGE_TRUE_VALUE;
-
- e_false->flags &= ~EDGE_FALLTHRU;
- e_false->flags |= EDGE_FALSE_VALUE;
- e_false->probability = e_true->probability.invert ();
- e_false->count = split_bb->count - e_true->count;
- new_bb->count = e_false->count;
-
- if (update_dominators)
- {
- if (dominated_e_true)
- set_immediate_dominator (CDI_DOMINATORS, e_true->dest, split_bb);
- set_immediate_dominator (CDI_DOMINATORS, e_false->dest, split_bb);
- }
-
- return new_bb;
-}
-
-
-/* Return true if a switch should be expanded as a bit test.
- RANGE is the difference between highest and lowest case.
- UNIQ is number of unique case node targets, not counting the default case.
- COUNT is the number of comparisons needed, not counting the default case. */
-
-static bool
-expand_switch_using_bit_tests_p (tree range,
- unsigned int uniq,
- unsigned int count, bool speed_p)
-{
- return (((uniq == 1 && count >= 3)
- || (uniq == 2 && count >= 5)
- || (uniq == 3 && count >= 6))
- && lshift_cheap_p (speed_p)
- && compare_tree_int (range, GET_MODE_BITSIZE (word_mode)) < 0
- && compare_tree_int (range, 0) > 0);
-}
-\f
-/* Implement switch statements with bit tests
-
-A GIMPLE switch statement can be expanded to a short sequence of bit-wise
-comparisons. "switch(x)" is converted into "if ((1 << (x-MINVAL)) & CST)"
-where CST and MINVAL are integer constants. This is better than a series
-of compare-and-banch insns in some cases, e.g. we can implement:
-
- if ((x==4) || (x==6) || (x==9) || (x==11))
-
-as a single bit test:
-
- if ((1<<x) & ((1<<4)|(1<<6)|(1<<9)|(1<<11)))
-
-This transformation is only applied if the number of case targets is small,
-if CST constains at least 3 bits, and "1 << x" is cheap. The bit tests are
-performed in "word_mode".
-
-The following example shows the code the transformation generates:
-
- int bar(int x)
- {
- switch (x)
- {
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- case 'A': case 'B': case 'C': case 'D': case 'E':
- case 'F':
- return 1;
- }
- return 0;
- }
-
-==>
-
- bar (int x)
- {
- tmp1 = x - 48;
- if (tmp1 > (70 - 48)) goto L2;
- tmp2 = 1 << tmp1;
- tmp3 = 0b11111100000001111111111;
- if ((tmp2 & tmp3) != 0) goto L1 ; else goto L2;
- L1:
- return 1;
- L2:
- return 0;
- }
-
-TODO: There are still some improvements to this transformation that could
-be implemented:
-
-* A narrower mode than word_mode could be used if that is cheaper, e.g.
- for x86_64 where a narrower-mode shift may result in smaller code.
-
-* The compounded constant could be shifted rather than the one. The
- test would be either on the sign bit or on the least significant bit,
- depending on the direction of the shift. On some machines, the test
- for the branch would be free if the bit to test is already set by the
- shift operation.
-
-This transformation was contributed by Roger Sayle, see this e-mail:
- http://gcc.gnu.org/ml/gcc-patches/2003-01/msg01950.html
-*/
-
-/* A case_bit_test represents a set of case nodes that may be
- selected from using a bit-wise comparison. HI and LO hold
- the integer to be tested against, TARGET_EDGE contains the
- edge to the basic block to jump to upon success and BITS
- counts the number of case nodes handled by this test,
- typically the number of bits set in HI:LO. The LABEL field
- is used to quickly identify all cases in this set without
- looking at label_to_block for every case label. */
-
-struct case_bit_test
-{
- wide_int mask;
- edge target_edge;
- tree label;
- int bits;
-};
-
-/* Comparison function for qsort to order bit tests by decreasing
- probability of execution. Our best guess comes from a measured
- profile. If the profile counts are equal, break even on the
- number of case nodes, i.e. the node with the most cases gets
- tested first.
-
- TODO: Actually this currently runs before a profile is available.
- Therefore the case-as-bit-tests transformation should be done
- later in the pass pipeline, or something along the lines of
- "Efficient and effective branch reordering using profile data"
- (Yang et. al., 2002) should be implemented (although, how good
- is a paper is called "Efficient and effective ..." when the
- latter is implied by the former, but oh well...). */
-
-static int
-case_bit_test_cmp (const void *p1, const void *p2)
-{
- const struct case_bit_test *const d1 = (const struct case_bit_test *) p1;
- const struct case_bit_test *const d2 = (const struct case_bit_test *) p2;
-
- if (d2->target_edge->count < d1->target_edge->count)
- return -1;
- if (d2->target_edge->count > d1->target_edge->count)
- return 1;
- if (d2->bits != d1->bits)
- return d2->bits - d1->bits;
-
- /* Stabilize the sort. */
- return LABEL_DECL_UID (d2->label) - LABEL_DECL_UID (d1->label);
-}
-
-/* Expand a switch statement by a short sequence of bit-wise
- comparisons. "switch(x)" is effectively converted into
- "if ((1 << (x-MINVAL)) & CST)" where CST and MINVAL are
- integer constants.
+#include "tree-switch-conversion.h"
- INDEX_EXPR is the value being switched on.
+using namespace tree_switch_conversion;
- MINVAL is the lowest case value of in the case nodes,
- and RANGE is highest value minus MINVAL. MINVAL and RANGE
- are not guaranteed to be of the same type as INDEX_EXPR
- (the gimplifier doesn't change the type of case label values,
- and MINVAL and RANGE are derived from those values).
- MAXVAL is MINVAL + RANGE.
-
- There *MUST* be MAX_CASE_BIT_TESTS or less unique case
- node targets. */
-
-static void
-emit_case_bit_tests (gswitch *swtch, tree index_expr,
- tree minval, tree range, tree maxval)
+switch_conversion::switch_conversion (): m_final_bb (NULL), m_other_count (),
+ m_constructors (NULL), m_default_values (NULL),
+ m_arr_ref_first (NULL), m_arr_ref_last (NULL),
+ m_reason (NULL), m_default_case_nonstandard (false)
{
- struct case_bit_test test[MAX_CASE_BIT_TESTS] = { {} };
- unsigned int i, j, k;
- unsigned int count;
-
- basic_block switch_bb = gimple_bb (swtch);
- basic_block default_bb, new_default_bb, new_bb;
- edge default_edge;
- bool update_dom = dom_info_available_p (CDI_DOMINATORS);
-
- vec<basic_block> bbs_to_fix_dom = vNULL;
-
- tree index_type = TREE_TYPE (index_expr);
- tree unsigned_index_type = unsigned_type_for (index_type);
- unsigned int branch_num = gimple_switch_num_labels (swtch);
-
- gimple_stmt_iterator gsi;
- gassign *shift_stmt;
-
- tree idx, tmp, csui;
- tree word_type_node = lang_hooks.types.type_for_mode (word_mode, 1);
- tree word_mode_zero = fold_convert (word_type_node, integer_zero_node);
- tree word_mode_one = fold_convert (word_type_node, integer_one_node);
- int prec = TYPE_PRECISION (word_type_node);
- wide_int wone = wi::one (prec);
-
- /* Get the edge for the default case. */
- tmp = gimple_switch_default_label (swtch);
- default_bb = label_to_block (CASE_LABEL (tmp));
- default_edge = find_edge (switch_bb, default_bb);
-
- /* Go through all case labels, and collect the case labels, profile
- counts, and other information we need to build the branch tests. */
- count = 0;
- for (i = 1; i < branch_num; i++)
- {
- unsigned int lo, hi;
- tree cs = gimple_switch_label (swtch, i);
- tree label = CASE_LABEL (cs);
- edge e = find_edge (switch_bb, label_to_block (label));
- for (k = 0; k < count; k++)
- if (e == test[k].target_edge)
- break;
-
- if (k == count)
- {
- gcc_checking_assert (count < MAX_CASE_BIT_TESTS);
- test[k].mask = wi::zero (prec);
- test[k].target_edge = e;
- test[k].label = label;
- test[k].bits = 1;
- count++;
- }
- else
- test[k].bits++;
-
- lo = tree_to_uhwi (int_const_binop (MINUS_EXPR,
- CASE_LOW (cs), minval));
- if (CASE_HIGH (cs) == NULL_TREE)
- hi = lo;
- else
- hi = tree_to_uhwi (int_const_binop (MINUS_EXPR,
- CASE_HIGH (cs), minval));
-
- for (j = lo; j <= hi; j++)
- test[k].mask |= wi::lshift (wone, j);
- }
-
- qsort (test, count, sizeof (*test), case_bit_test_cmp);
-
- /* If all values are in the 0 .. BITS_PER_WORD-1 range, we can get rid of
- the minval subtractions, but it might make the mask constants more
- expensive. So, compare the costs. */
- if (compare_tree_int (minval, 0) > 0
- && compare_tree_int (maxval, GET_MODE_BITSIZE (word_mode)) < 0)
- {
- int cost_diff;
- HOST_WIDE_INT m = tree_to_uhwi (minval);
- rtx reg = gen_raw_REG (word_mode, 10000);
- bool speed_p = optimize_bb_for_speed_p (gimple_bb (swtch));
- cost_diff = set_rtx_cost (gen_rtx_PLUS (word_mode, reg,
- GEN_INT (-m)), speed_p);
- for (i = 0; i < count; i++)
- {
- rtx r = immed_wide_int_const (test[i].mask, word_mode);
- cost_diff += set_src_cost (gen_rtx_AND (word_mode, reg, r),
- word_mode, speed_p);
- r = immed_wide_int_const (wi::lshift (test[i].mask, m), word_mode);
- cost_diff -= set_src_cost (gen_rtx_AND (word_mode, reg, r),
- word_mode, speed_p);
- }
- if (cost_diff > 0)
- {
- for (i = 0; i < count; i++)
- test[i].mask = wi::lshift (test[i].mask, m);
- minval = build_zero_cst (TREE_TYPE (minval));
- range = maxval;
- }
- }
-
- /* We generate two jumps to the default case label.
- Split the default edge, so that we don't have to do any PHI node
- updating. */
- new_default_bb = split_edge (default_edge);
-
- if (update_dom)
- {
- bbs_to_fix_dom.create (10);
- bbs_to_fix_dom.quick_push (switch_bb);
- bbs_to_fix_dom.quick_push (default_bb);
- bbs_to_fix_dom.quick_push (new_default_bb);
- }
-
- /* Now build the test-and-branch code. */
-
- gsi = gsi_last_bb (switch_bb);
-
- /* idx = (unsigned)x - minval. */
- idx = fold_convert (unsigned_index_type, index_expr);
- idx = fold_build2 (MINUS_EXPR, unsigned_index_type, idx,
- fold_convert (unsigned_index_type, minval));
- idx = force_gimple_operand_gsi (&gsi, idx,
- /*simple=*/true, NULL_TREE,
- /*before=*/true, GSI_SAME_STMT);
-
- /* if (idx > range) goto default */
- range = force_gimple_operand_gsi (&gsi,
- fold_convert (unsigned_index_type, range),
- /*simple=*/true, NULL_TREE,
- /*before=*/true, GSI_SAME_STMT);
- tmp = fold_build2 (GT_EXPR, boolean_type_node, idx, range);
- new_bb = hoist_edge_and_branch_if_true (&gsi, tmp, default_edge, update_dom);
- if (update_dom)
- bbs_to_fix_dom.quick_push (new_bb);
- gcc_assert (gimple_bb (swtch) == new_bb);
- gsi = gsi_last_bb (new_bb);
-
- /* Any blocks dominated by the GIMPLE_SWITCH, but that are not successors
- of NEW_BB, are still immediately dominated by SWITCH_BB. Make it so. */
- if (update_dom)
- {
- vec<basic_block> dom_bbs;
- basic_block dom_son;
-
- dom_bbs = get_dominated_by (CDI_DOMINATORS, new_bb);
- FOR_EACH_VEC_ELT (dom_bbs, i, dom_son)
- {
- edge e = find_edge (new_bb, dom_son);
- if (e && single_pred_p (e->dest))
- continue;
- set_immediate_dominator (CDI_DOMINATORS, dom_son, switch_bb);
- bbs_to_fix_dom.safe_push (dom_son);
- }
- dom_bbs.release ();
- }
-
- /* csui = (1 << (word_mode) idx) */
- csui = make_ssa_name (word_type_node);
- tmp = fold_build2 (LSHIFT_EXPR, word_type_node, word_mode_one,
- fold_convert (word_type_node, idx));
- tmp = force_gimple_operand_gsi (&gsi, tmp,
- /*simple=*/false, NULL_TREE,
- /*before=*/true, GSI_SAME_STMT);
- shift_stmt = gimple_build_assign (csui, tmp);
- gsi_insert_before (&gsi, shift_stmt, GSI_SAME_STMT);
- update_stmt (shift_stmt);
-
- /* for each unique set of cases:
- if (const & csui) goto target */
- for (k = 0; k < count; k++)
- {
- tmp = wide_int_to_tree (word_type_node, test[k].mask);
- tmp = fold_build2 (BIT_AND_EXPR, word_type_node, csui, tmp);
- tmp = force_gimple_operand_gsi (&gsi, tmp,
- /*simple=*/true, NULL_TREE,
- /*before=*/true, GSI_SAME_STMT);
- tmp = fold_build2 (NE_EXPR, boolean_type_node, tmp, word_mode_zero);
- new_bb = hoist_edge_and_branch_if_true (&gsi, tmp, test[k].target_edge,
- update_dom);
- if (update_dom)
- bbs_to_fix_dom.safe_push (new_bb);
- gcc_assert (gimple_bb (swtch) == new_bb);
- gsi = gsi_last_bb (new_bb);
- }
-
- /* We should have removed all edges now. */
- gcc_assert (EDGE_COUNT (gsi_bb (gsi)->succs) == 0);
-
- /* If nothing matched, go to the default label. */
- make_edge (gsi_bb (gsi), new_default_bb, EDGE_FALLTHRU);
-
- /* The GIMPLE_SWITCH is now redundant. */
- gsi_remove (&gsi, true);
-
- if (update_dom)
- {
- /* Fix up the dominator tree. */
- iterate_fix_dominators (CDI_DOMINATORS, bbs_to_fix_dom, true);
- bbs_to_fix_dom.release ();
- }
}
-\f
-/*
- Switch initialization conversion
-
-The following pass changes simple initializations of scalars in a switch
-statement into initializations from a static array. Obviously, the values
-must be constant and known at compile time and a default branch must be
-provided. For example, the following code:
-
- int a,b;
-
- switch (argc)
- {
- case 1:
- case 2:
- a_1 = 8;
- b_1 = 6;
- break;
- case 3:
- a_2 = 9;
- b_2 = 5;
- break;
- case 12:
- a_3 = 10;
- b_3 = 4;
- break;
- default:
- a_4 = 16;
- b_4 = 1;
- break;
- }
- a_5 = PHI <a_1, a_2, a_3, a_4>
- b_5 = PHI <b_1, b_2, b_3, b_4>
-
-
-is changed into:
-
- static const int = CSWTCH01[] = {6, 6, 5, 1, 1, 1, 1, 1, 1, 1, 1, 4};
- static const int = CSWTCH02[] = {8, 8, 9, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 10};
-
- if (((unsigned) argc) - 1 < 11)
- {
- a_6 = CSWTCH02[argc - 1];
- b_6 = CSWTCH01[argc - 1];
- }
- else
- {
- a_7 = 16;
- b_7 = 1;
- }
- a_5 = PHI <a_6, a_7>
- b_b = PHI <b_6, b_7>
-There are further constraints. Specifically, the range of values across all
-case labels must not be bigger than SWITCH_CONVERSION_BRANCH_RATIO (default
-eight) times the number of the actual switch branches.
-
-This transformation was contributed by Martin Jambor, see this e-mail:
- http://gcc.gnu.org/ml/gcc-patches/2008-07/msg00011.html */
-
-/* The main structure of the pass. */
-struct switch_conv_info
-{
- /* The expression used to decide the switch branch. */
- tree index_expr;
-
- /* The following integer constants store the minimum and maximum value
- covered by the case labels. */
- tree range_min;
- tree range_max;
-
- /* The difference between the above two numbers. Stored here because it
- is used in all the conversion heuristics, as well as for some of the
- transformation, and it is expensive to re-compute it all the time. */
- tree range_size;
-
- /* Basic block that contains the actual GIMPLE_SWITCH. */
- basic_block switch_bb;
-
- /* Basic block that is the target of the default case. */
- basic_block default_bb;
-
- /* The single successor block of all branches out of the GIMPLE_SWITCH,
- if such a block exists. Otherwise NULL. */
- basic_block final_bb;
-
- /* The probability of the default edge in the replaced switch. */
- profile_probability default_prob;
-
- /* The count of the default edge in the replaced switch. */
- profile_count default_count;
-
- /* Combined count of all other (non-default) edges in the replaced switch. */
- profile_count other_count;
-
- /* Number of phi nodes in the final bb (that we'll be replacing). */
- int phi_count;
-
- /* Array of default values, in the same order as phi nodes. */
- tree *default_values;
-
- /* Constructors of new static arrays. */
- vec<constructor_elt, va_gc> **constructors;
-
- /* Array of ssa names that are initialized with a value from a new static
- array. */
- tree *target_inbound_names;
-
- /* Array of ssa names that are initialized with the default value if the
- switch expression is out of range. */
- tree *target_outbound_names;
-
- /* VOP SSA_NAME. */
- tree target_vop;
-
- /* The first load statement that loads a temporary from a new static array.
- */
- gimple *arr_ref_first;
-
- /* The last load statement that loads a temporary from a new static array. */
- gimple *arr_ref_last;
-
- /* String reason why the case wasn't a good candidate that is written to the
- dump file, if there is one. */
- const char *reason;
-
- /* True if default case is not used for any value between range_min and
- range_max inclusive. */
- bool contiguous_range;
-
- /* True if default case does not have the required shape for other case
- labels. */
- bool default_case_nonstandard;
-
- /* Parameters for expand_switch_using_bit_tests. Should be computed
- the same way as in expand_case. */
- unsigned int uniq;
- unsigned int count;
-};
-
-/* Collect information about GIMPLE_SWITCH statement SWTCH into INFO. */
-
-static void
-collect_switch_conv_info (gswitch *swtch, struct switch_conv_info *info)
+void
+switch_conversion::collect (gswitch *swtch)
{
unsigned int branch_num = gimple_switch_num_labels (swtch);
tree min_case, max_case;
- unsigned int count, i;
+ unsigned int i;
edge e, e_default, e_first;
edge_iterator ei;
basic_block first;
- memset (info, 0, sizeof (*info));
+ m_switch = swtch;
/* The gimplifier has already sorted the cases by CASE_LOW and ensured there
is a default label which is the first in the vector.
Collect the bits we can deduce from the CFG. */
- info->index_expr = gimple_switch_index (swtch);
- info->switch_bb = gimple_bb (swtch);
- info->default_bb
+ m_index_expr = gimple_switch_index (swtch);
+ m_switch_bb = gimple_bb (swtch);
+ m_default_bb
= label_to_block (CASE_LABEL (gimple_switch_default_label (swtch)));
- e_default = find_edge (info->switch_bb, info->default_bb);
- info->default_prob = e_default->probability;
- info->default_count = e_default->count;
- FOR_EACH_EDGE (e, ei, info->switch_bb->succs)
+ e_default = find_edge (m_switch_bb, m_default_bb);
+ m_default_prob = e_default->probability;
+ m_default_count = e_default->count;
+ FOR_EACH_EDGE (e, ei, m_switch_bb->succs)
if (e != e_default)
- info->other_count += e->count;
+ m_other_count += e->count;
/* Get upper and lower bounds of case values, and the covered range. */
min_case = gimple_switch_label (swtch, 1);
max_case = gimple_switch_label (swtch, branch_num - 1);
- info->range_min = CASE_LOW (min_case);
+ m_range_min = CASE_LOW (min_case);
if (CASE_HIGH (max_case) != NULL_TREE)
- info->range_max = CASE_HIGH (max_case);
+ m_range_max = CASE_HIGH (max_case);
else
- info->range_max = CASE_LOW (max_case);
+ m_range_max = CASE_LOW (max_case);
- info->contiguous_range = true;
- tree last = CASE_HIGH (min_case) ? CASE_HIGH (min_case) : info->range_min;
+ m_contiguous_range = true;
+ tree last = CASE_HIGH (min_case) ? CASE_HIGH (min_case) : m_range_min;
for (i = 2; i < branch_num; i++)
{
tree elt = gimple_switch_label (swtch, i);
wide_int w = last;
if (w + 1 != CASE_LOW (elt))
{
- info->contiguous_range = false;
+ m_contiguous_range = false;
break;
}
last = CASE_HIGH (elt) ? CASE_HIGH (elt) : CASE_LOW (elt);
}
- if (info->contiguous_range)
+ if (m_contiguous_range)
{
first = label_to_block (CASE_LABEL (gimple_switch_label (swtch, 1)));
- e_first = find_edge (info->switch_bb, first);
+ e_first = find_edge (m_switch_bb, first);
}
else
{
- first = info->default_bb;
+ first = m_default_bb;
e_first = e_default;
}
@@ -681,103 +131,91 @@ collect_switch_conv_info (gswitch *swtch, struct switch_conv_info *info)
if the range is contiguous and default case otherwise as
guess or its destination in case it is a forwarder block. */
if (! single_pred_p (e_first->dest))
- info->final_bb = e_first->dest;
+ m_final_bb = e_first->dest;
else if (single_succ_p (e_first->dest)
&& ! single_pred_p (single_succ (e_first->dest)))
- info->final_bb = single_succ (e_first->dest);
+ m_final_bb = single_succ (e_first->dest);
/* Require that all switch destinations are either that common
FINAL_BB or a forwarder to it, except for the default
case if contiguous range. */
- if (info->final_bb)
- FOR_EACH_EDGE (e, ei, info->switch_bb->succs)
+ if (m_final_bb)
+ FOR_EACH_EDGE (e, ei, m_switch_bb->succs)
{
- if (e->dest == info->final_bb)
+ if (e->dest == m_final_bb)
continue;
if (single_pred_p (e->dest)
&& single_succ_p (e->dest)
- && single_succ (e->dest) == info->final_bb)
+ && single_succ (e->dest) == m_final_bb)
continue;
- if (e == e_default && info->contiguous_range)
+ if (e == e_default && m_contiguous_range)
{
- info->default_case_nonstandard = true;
+ m_default_case_nonstandard = true;
continue;
}
- info->final_bb = NULL;
+ m_final_bb = NULL;
break;
}
- info->range_size
- = int_const_binop (MINUS_EXPR, info->range_max, info->range_min);
+ m_range_size
+ = int_const_binop (MINUS_EXPR, m_range_max, m_range_min);
/* Get a count of the number of case labels. Single-valued case labels
simply count as one, but a case range counts double, since it may
require two compares if it gets lowered as a branching tree. */
- count = 0;
+ m_count = 0;
for (i = 1; i < branch_num; i++)
{
tree elt = gimple_switch_label (swtch, i);
- count++;
+ m_count++;
if (CASE_HIGH (elt)
&& ! tree_int_cst_equal (CASE_LOW (elt), CASE_HIGH (elt)))
- count++;
+ m_count++;
}
- info->count = count;
-
- /* Get the number of unique non-default targets out of the GIMPLE_SWITCH
- block. Assume a CFG cleanup would have already removed degenerate
- switch statements, this allows us to just use EDGE_COUNT. */
- info->uniq = EDGE_COUNT (gimple_bb (swtch)->succs) - 1;
}
-/* Checks whether the range given by individual case statements of the SWTCH
- switch statement isn't too big and whether the number of branches actually
- satisfies the size of the new array. */
-
-static bool
-check_range (struct switch_conv_info *info)
+bool
+switch_conversion::check_range ()
{
- gcc_assert (info->range_size);
- if (!tree_fits_uhwi_p (info->range_size))
+ gcc_assert (m_range_size);
+ if (!tree_fits_uhwi_p (m_range_size))
{
- info->reason = "index range way too large or otherwise unusable";
+ m_reason = "index range way too large or otherwise unusable";
return false;
}
- if (tree_to_uhwi (info->range_size)
- > ((unsigned) info->count * SWITCH_CONVERSION_BRANCH_RATIO))
+ if (tree_to_uhwi (m_range_size)
+ > ((unsigned) m_count * SWITCH_CONVERSION_BRANCH_RATIO))
{
- info->reason = "the maximum range-branch ratio exceeded";
+ m_reason = "the maximum range-branch ratio exceeded";
return false;
}
return true;
}
-/* Checks whether all but the FINAL_BB basic blocks are empty. */
-
-static bool
-check_all_empty_except_final (struct switch_conv_info *info)
+bool
+switch_conversion::check_all_empty_except_final ()
{
- edge e, e_default = find_edge (info->switch_bb, info->default_bb);
+ edge e, e_default = find_edge (m_switch_bb, m_default_bb);
edge_iterator ei;
- FOR_EACH_EDGE (e, ei, info->switch_bb->succs)
+ FOR_EACH_EDGE (e, ei, m_switch_bb->succs)
{
- if (e->dest == info->final_bb)
+ if (e->dest == m_final_bb)
continue;
if (!empty_block_p (e->dest))
{
- if (info->contiguous_range && e == e_default)
+ if (m_contiguous_range && e == e_default)
{
- info->default_case_nonstandard = true;
+ m_default_case_nonstandard = true;
continue;
}
- info->reason = "bad case - a non-final BB not empty";
+ m_reason = "bad case - a non-final BB not empty";
return false;
}
}
@@ -785,18 +223,13 @@ check_all_empty_except_final (struct switch_conv_info *info)
return true;
}
-/* This function checks whether all required values in phi nodes in final_bb
- are constants. Required values are those that correspond to a basic block
- which is a part of the examined switch statement. It returns true if the
- phi nodes are OK, otherwise false. */
-
-static bool
-check_final_bb (gswitch *swtch, struct switch_conv_info *info)
+bool
+switch_conversion::check_final_bb ()
{
gphi_iterator gsi;
- info->phi_count = 0;
- for (gsi = gsi_start_phis (info->final_bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ m_phi_count = 0;
+ for (gsi = gsi_start_phis (m_final_bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gphi *phi = gsi.phi ();
unsigned int i;
@@ -804,16 +237,16 @@ check_final_bb (gswitch *swtch, struct switch_conv_info *info)
if (virtual_operand_p (gimple_phi_result (phi)))
continue;
- info->phi_count++;
+ m_phi_count++;
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
basic_block bb = gimple_phi_arg_edge (phi, i)->src;
- if (bb == info->switch_bb
+ if (bb == m_switch_bb
|| (single_pred_p (bb)
- && single_pred (bb) == info->switch_bb
- && (!info->default_case_nonstandard
+ && single_pred (bb) == m_switch_bb
+ && (!m_default_case_nonstandard
|| empty_block_p (bb))))
{
tree reloc, val;
@@ -841,25 +274,25 @@ check_final_bb (gswitch *swtch, struct switch_conv_info *info)
/* For contiguous range, we can allow non-constant
or one that needs relocation, as long as it is
only reachable from the default case. */
- if (bb == info->switch_bb)
- bb = info->final_bb;
- if (!info->contiguous_range || bb != info->default_bb)
+ if (bb == m_switch_bb)
+ bb = m_final_bb;
+ if (!m_contiguous_range || bb != m_default_bb)
{
- info->reason = reason;
+ m_reason = reason;
return false;
}
- unsigned int branch_num = gimple_switch_num_labels (swtch);
+ unsigned int branch_num = gimple_switch_num_labels (m_switch);
for (unsigned int i = 1; i < branch_num; i++)
{
- tree lab = CASE_LABEL (gimple_switch_label (swtch, i));
+ tree lab = CASE_LABEL (gimple_switch_label (m_switch, i));
if (label_to_block (lab) == bb)
{
- info->reason = reason;
+ m_reason = reason;
return false;
}
}
- info->default_case_nonstandard = true;
+ m_default_case_nonstandard = true;
}
}
}
@@ -868,44 +301,24 @@ check_final_bb (gswitch *swtch, struct switch_conv_info *info)
return true;
}
-/* The following function allocates default_values, target_{in,out}_names and
- constructors arrays. The last one is also populated with pointers to
- vectors that will become constructors of new arrays. */
-
-static void
-create_temp_arrays (struct switch_conv_info *info)
+void
+switch_conversion::create_temp_arrays ()
{
int i;
- info->default_values = XCNEWVEC (tree, info->phi_count * 3);
+ m_default_values = XCNEWVEC (tree, m_phi_count * 3);
/* ??? Macros do not support multi argument templates in their
argument list. We create a typedef to work around that problem. */
typedef vec<constructor_elt, va_gc> *vec_constructor_elt_gc;
- info->constructors = XCNEWVEC (vec_constructor_elt_gc, info->phi_count);
- info->target_inbound_names = info->default_values + info->phi_count;
- info->target_outbound_names = info->target_inbound_names + info->phi_count;
- for (i = 0; i < info->phi_count; i++)
- vec_alloc (info->constructors[i], tree_to_uhwi (info->range_size) + 1);
+ m_constructors = XCNEWVEC (vec_constructor_elt_gc, m_phi_count);
+ m_target_inbound_names = m_default_values + m_phi_count;
+ m_target_outbound_names = m_target_inbound_names + m_phi_count;
+ for (i = 0; i < m_phi_count; i++)
+ vec_alloc (m_constructors[i], tree_to_uhwi (m_range_size) + 1);
}
-/* Free the arrays created by create_temp_arrays(). The vectors that are
- created by that function are not freed here, however, because they have
- already become constructors and must be preserved. */
-
-static void
-free_temp_arrays (struct switch_conv_info *info)
-{
- XDELETEVEC (info->constructors);
- XDELETEVEC (info->default_values);
-}
-
-/* Populate the array of default values in the order of phi nodes.
- DEFAULT_CASE is the CASE_LABEL_EXPR for the default switch branch
- if the range is non-contiguous or the default case has standard
- structure, otherwise it is the first non-default case instead. */
-
-static void
-gather_default_values (tree default_case, struct switch_conv_info *info)
+void
+switch_conversion::gather_default_values (tree default_case)
{
gphi_iterator gsi;
basic_block bb = label_to_block (CASE_LABEL (default_case));
@@ -913,46 +326,42 @@ gather_default_values (tree default_case, struct switch_conv_info *info)
int i = 0;
gcc_assert (CASE_LOW (default_case) == NULL_TREE
- || info->default_case_nonstandard);
+ || m_default_case_nonstandard);
- if (bb == info->final_bb)
- e = find_edge (info->switch_bb, bb);
+ if (bb == m_final_bb)
+ e = find_edge (m_switch_bb, bb);
else
e = single_succ_edge (bb);
- for (gsi = gsi_start_phis (info->final_bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ for (gsi = gsi_start_phis (m_final_bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gphi *phi = gsi.phi ();
if (virtual_operand_p (gimple_phi_result (phi)))
continue;
tree val = PHI_ARG_DEF_FROM_EDGE (phi, e);
gcc_assert (val);
- info->default_values[i++] = val;
+ m_default_values[i++] = val;
}
}
-/* The following function populates the vectors in the constructors array with
- future contents of the static arrays. The vectors are populated in the
- order of phi nodes. SWTCH is the switch statement being converted. */
-
-static void
-build_constructors (gswitch *swtch, struct switch_conv_info *info)
+void
+switch_conversion::build_constructors ()
{
- unsigned i, branch_num = gimple_switch_num_labels (swtch);
- tree pos = info->range_min;
+ unsigned i, branch_num = gimple_switch_num_labels (m_switch);
+ tree pos = m_range_min;
tree pos_one = build_int_cst (TREE_TYPE (pos), 1);
for (i = 1; i < branch_num; i++)
{
- tree cs = gimple_switch_label (swtch, i);
+ tree cs = gimple_switch_label (m_switch, i);
basic_block bb = label_to_block (CASE_LABEL (cs));
edge e;
tree high;
gphi_iterator gsi;
int j;
- if (bb == info->final_bb)
- e = find_edge (info->switch_bb, bb);
+ if (bb == m_final_bb)
+ e = find_edge (m_switch_bb, bb);
else
e = single_succ_edge (bb);
gcc_assert (e);
@@ -960,15 +369,14 @@ build_constructors (gswitch *swtch, struct switch_conv_info *info)
while (tree_int_cst_lt (pos, CASE_LOW (cs)))
{
int k;
- gcc_assert (!info->contiguous_range);
- for (k = 0; k < info->phi_count; k++)
+ for (k = 0; k < m_phi_count; k++)
{
constructor_elt elt;
- elt.index = int_const_binop (MINUS_EXPR, pos, info->range_min);
+ elt.index = int_const_binop (MINUS_EXPR, pos, m_range_min);
elt.value
- = unshare_expr_without_location (info->default_values[k]);
- info->constructors[k]->quick_push (elt);
+ = unshare_expr_without_location (m_default_values[k]);
+ m_constructors[k]->quick_push (elt);
}
pos = int_const_binop (PLUS_EXPR, pos, pos_one);
@@ -980,7 +388,7 @@ build_constructors (gswitch *swtch, struct switch_conv_info *info)
high = CASE_HIGH (cs);
else
high = CASE_LOW (cs);
- for (gsi = gsi_start_phis (info->final_bb);
+ for (gsi = gsi_start_phis (m_final_bb);
!gsi_end_p (gsi); gsi_next (&gsi))
{
gphi *phi = gsi.phi ();
@@ -994,9 +402,9 @@ build_constructors (gswitch *swtch, struct switch_conv_info *info)
{
constructor_elt elt;
- elt.index = int_const_binop (MINUS_EXPR, pos, info->range_min);
+ elt.index = int_const_binop (MINUS_EXPR, pos, m_range_min);
elt.value = unshare_expr_without_location (val);
- info->constructors[j]->quick_push (elt);
+ m_constructors[j]->quick_push (elt);
pos = int_const_binop (PLUS_EXPR, pos, pos_one);
} while (!tree_int_cst_lt (high, pos)
@@ -1006,12 +414,8 @@ build_constructors (gswitch *swtch, struct switch_conv_info *info)
}
}
-/* If all values in the constructor vector are the same, return the value.
- Otherwise return NULL_TREE. Not supposed to be called for empty
- vectors. */
-
-static tree
-constructor_contains_same_values_p (vec<constructor_elt, va_gc> *vec)
+tree
+switch_conversion::contains_same_values_p (vec<constructor_elt, va_gc> *vec)
{
unsigned int i;
tree prev = NULL_TREE;
@@ -1027,15 +431,10 @@ constructor_contains_same_values_p (vec<constructor_elt, va_gc> *vec)
return prev;
}
-/* Return type which should be used for array elements, either TYPE's
- main variant or, for integral types, some smaller integral type
- that can still hold all the constants. */
-
-static tree
-array_value_type (gswitch *swtch, tree type, int num,
- struct switch_conv_info *info)
+tree
+switch_conversion::array_value_type (tree type, int num)
{
- unsigned int i, len = vec_safe_length (info->constructors[num]);
+ unsigned int i, len = vec_safe_length (m_constructors[num]);
constructor_elt *elt;
int sign = 0;
tree smaller_type;
@@ -1055,10 +454,10 @@ array_value_type (gswitch *swtch, tree type, int num,
if (GET_MODE_SIZE (type_mode) <= GET_MODE_SIZE (mode))
return type;
- if (len < (optimize_bb_for_size_p (gimple_bb (swtch)) ? 2 : 32))
+ if (len < (optimize_bb_for_size_p (gimple_bb (m_switch)) ? 2 : 32))
return type;
- FOR_EACH_VEC_SAFE_ELT (info->constructors[num], i, elt)
+ FOR_EACH_VEC_SAFE_ELT (m_constructors[num], i, elt)
{
wide_int cst;
@@ -1104,49 +503,39 @@ array_value_type (gswitch *swtch, tree type, int num,
return smaller_type;
}
-/* Create an appropriate array type and declaration and assemble a static array
- variable. Also create a load statement that initializes the variable in
- question with a value from the static array. SWTCH is the switch statement
- being converted, NUM is the index to arrays of constructors, default values
- and target SSA names for this particular array. ARR_INDEX_TYPE is the type
- of the index of the new array, PHI is the phi node of the final BB that
- corresponds to the value that will be loaded from the created array. TIDX
- is an ssa name of a temporary variable holding the index for loads from the
- new array. */
-
-static void
-build_one_array (gswitch *swtch, int num, tree arr_index_type,
- gphi *phi, tree tidx, struct switch_conv_info *info)
+void
+switch_conversion::build_one_array (int num, tree arr_index_type,
+ gphi *phi, tree tidx)
{
tree name, cst;
gimple *load;
- gimple_stmt_iterator gsi = gsi_for_stmt (swtch);
- location_t loc = gimple_location (swtch);
+ gimple_stmt_iterator gsi = gsi_for_stmt (m_switch);
+ location_t loc = gimple_location (m_switch);
- gcc_assert (info->default_values[num]);
+ gcc_assert (m_default_values[num]);
name = copy_ssa_name (PHI_RESULT (phi));
- info->target_inbound_names[num] = name;
+ m_target_inbound_names[num] = name;
- cst = constructor_contains_same_values_p (info->constructors[num]);
+ cst = contains_same_values_p (m_constructors[num]);
if (cst)
load = gimple_build_assign (name, cst);
else
{
tree array_type, ctor, decl, value_type, fetch, default_type;
- default_type = TREE_TYPE (info->default_values[num]);
- value_type = array_value_type (swtch, default_type, num, info);
+ default_type = TREE_TYPE (m_default_values[num]);
+ value_type = array_value_type (default_type, num);
array_type = build_array_type (value_type, arr_index_type);
if (default_type != value_type)
{
unsigned int i;
constructor_elt *elt;
- FOR_EACH_VEC_SAFE_ELT (info->constructors[num], i, elt)
+ FOR_EACH_VEC_SAFE_ELT (m_constructors[num], i, elt)
elt->value = fold_convert (value_type, elt->value);
}
- ctor = build_constructor (array_type, info->constructors[num]);
+ ctor = build_constructor (array_type, m_constructors[num]);
TREE_CONSTANT (ctor) = true;
TREE_STATIC (ctor) = true;
@@ -1175,15 +564,11 @@ build_one_array (gswitch *swtch, int num, tree arr_index_type,
gsi_insert_before (&gsi, load, GSI_SAME_STMT);
update_stmt (load);
- info->arr_ref_last = load;
+ m_arr_ref_last = load;
}
-/* Builds and initializes static arrays initialized with values gathered from
- the SWTCH switch statement. Also creates statements that load values from
- them. */
-
-static void
-build_arrays (gswitch *swtch, struct switch_conv_info *info)
+void
+switch_conversion::build_arrays ()
{
tree arr_index_type;
tree tidx, sub, utype;
@@ -1191,84 +576,77 @@ build_arrays (gswitch *swtch, struct switch_conv_info *info)
gimple_stmt_iterator gsi;
gphi_iterator gpi;
int i;
- location_t loc = gimple_location (swtch);
+ location_t loc = gimple_location (m_switch);
- gsi = gsi_for_stmt (swtch);
+ gsi = gsi_for_stmt (m_switch);
/* Make sure we do not generate arithmetics in a subrange. */
- utype = TREE_TYPE (info->index_expr);
+ utype = TREE_TYPE (m_index_expr);
if (TREE_TYPE (utype))
utype = lang_hooks.types.type_for_mode (TYPE_MODE (TREE_TYPE (utype)), 1);
else
utype = lang_hooks.types.type_for_mode (TYPE_MODE (utype), 1);
- arr_index_type = build_index_type (info->range_size);
+ arr_index_type = build_index_type (m_range_size);
tidx = make_ssa_name (utype);
sub = fold_build2_loc (loc, MINUS_EXPR, utype,
- fold_convert_loc (loc, utype, info->index_expr),
- fold_convert_loc (loc, utype, info->range_min));
+ fold_convert_loc (loc, utype, m_index_expr),
+ fold_convert_loc (loc, utype, m_range_min));
sub = force_gimple_operand_gsi (&gsi, sub,
false, NULL, true, GSI_SAME_STMT);
stmt = gimple_build_assign (tidx, sub);
gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
update_stmt (stmt);
- info->arr_ref_first = stmt;
+ m_arr_ref_first = stmt;
- for (gpi = gsi_start_phis (info->final_bb), i = 0;
+ for (gpi = gsi_start_phis (m_final_bb), i = 0;
!gsi_end_p (gpi); gsi_next (&gpi))
{
gphi *phi = gpi.phi ();
if (!virtual_operand_p (gimple_phi_result (phi)))
- build_one_array (swtch, i++, arr_index_type, phi, tidx, info);
+ build_one_array (i++, arr_index_type, phi, tidx);
else
{
edge e;
edge_iterator ei;
- FOR_EACH_EDGE (e, ei, info->switch_bb->succs)
+ FOR_EACH_EDGE (e, ei, m_switch_bb->succs)
{
- if (e->dest == info->final_bb)
+ if (e->dest == m_final_bb)
break;
- if (!info->default_case_nonstandard
- || e->dest != info->default_bb)
+ if (!m_default_case_nonstandard
+ || e->dest != m_default_bb)
{
e = single_succ_edge (e->dest);
break;
}
}
- gcc_assert (e && e->dest == info->final_bb);
- info->target_vop = PHI_ARG_DEF_FROM_EDGE (phi, e);
+ gcc_assert (e && e->dest == m_final_bb);
+ m_target_vop = PHI_ARG_DEF_FROM_EDGE (phi, e);
}
}
}
-/* Generates and appropriately inserts loads of default values at the position
- given by BSI. Returns the last inserted statement. */
-
-static gassign *
-gen_def_assigns (gimple_stmt_iterator *gsi, struct switch_conv_info *info)
+gassign *
+switch_conversion::gen_def_assigns (gimple_stmt_iterator *gsi)
{
int i;
gassign *assign = NULL;
- for (i = 0; i < info->phi_count; i++)
+ for (i = 0; i < m_phi_count; i++)
{
- tree name = copy_ssa_name (info->target_inbound_names[i]);
- info->target_outbound_names[i] = name;
- assign = gimple_build_assign (name, info->default_values[i]);
+ tree name = copy_ssa_name (m_target_inbound_names[i]);
+ m_target_outbound_names[i] = name;
+ assign = gimple_build_assign (name, m_default_values[i]);
gsi_insert_before (gsi, assign, GSI_SAME_STMT);
update_stmt (assign);
}
return assign;
}
-/* Deletes the unused bbs and edges that now contain the switch statement and
- its empty branch bbs. BBD is the now dead BB containing the original switch
- statement, FINAL is the last BB of the converted switch statement (in terms
- of succession). */
-
-static void
-prune_bbs (basic_block bbd, basic_block final, basic_block default_bb)
+void
+switch_conversion::prune_bbs (basic_block bbd, basic_block final,
+ basic_block default_bb)
{
edge_iterator ei;
edge e;
@@ -1284,14 +662,8 @@ prune_bbs (basic_block bbd, basic_block final, basic_block default_bb)
delete_basic_block (bbd);
}
-/* Add values to phi nodes in final_bb for the two new edges. E1F is the edge
- from the basic block loading values from an array and E2F from the basic
- block loading default values. BBF is the last switch basic block (see the
- bbf description in the comment below). */
-
-static void
-fix_phi_nodes (edge e1f, edge e2f, basic_block bbf,
- struct switch_conv_info *info)
+void
+switch_conversion::fix_phi_nodes (edge e1f, edge e2f, basic_block bbf)
{
gphi_iterator gsi;
int i;
@@ -1302,41 +674,20 @@ fix_phi_nodes (edge e1f, edge e2f, basic_block bbf,
gphi *phi = gsi.phi ();
tree inbound, outbound;
if (virtual_operand_p (gimple_phi_result (phi)))
- inbound = outbound = info->target_vop;
+ inbound = outbound = m_target_vop;
else
{
- inbound = info->target_inbound_names[i];
- outbound = info->target_outbound_names[i++];
+ inbound = m_target_inbound_names[i];
+ outbound = m_target_outbound_names[i++];
}
add_phi_arg (phi, inbound, e1f, UNKNOWN_LOCATION);
- if (!info->default_case_nonstandard)
+ if (!m_default_case_nonstandard)
add_phi_arg (phi, outbound, e2f, UNKNOWN_LOCATION);
}
}
-/* Creates a check whether the switch expression value actually falls into the
- range given by all the cases. If it does not, the temporaries are loaded
- with default values instead. SWTCH is the switch statement being converted.
-
- bb0 is the bb with the switch statement, however, we'll end it with a
- condition instead.
-
- bb1 is the bb to be used when the range check went ok. It is derived from
- the switch BB
-
- bb2 is the bb taken when the expression evaluated outside of the range
- covered by the created arrays. It is populated by loads of default
- values.
-
- bbF is a fall through for both bb1 and bb2 and contains exactly what
- originally followed the switch statement.
-
- bbD contains the switch statement (in the end). It is unreachable but we
- still need to strip off its edges.
-*/
-
-static void
-gen_inbound_check (gswitch *swtch, struct switch_conv_info *info)
+void
+switch_conversion::gen_inbound_check ()
{
tree label_decl1 = create_artificial_label (UNKNOWN_LOCATION);
tree label_decl2 = create_artificial_label (UNKNOWN_LOCATION);
@@ -1351,30 +702,30 @@ gen_inbound_check (gswitch *swtch, struct switch_conv_info *info)
gimple_stmt_iterator gsi;
basic_block bb0, bb1, bb2, bbf, bbd;
edge e01 = NULL, e02, e21, e1d, e1f, e2f;
- location_t loc = gimple_location (swtch);
+ location_t loc = gimple_location (m_switch);
- gcc_assert (info->default_values);
+ gcc_assert (m_default_values);
- bb0 = gimple_bb (swtch);
+ bb0 = gimple_bb (m_switch);
- tidx = gimple_assign_lhs (info->arr_ref_first);
+ tidx = gimple_assign_lhs (m_arr_ref_first);
utype = TREE_TYPE (tidx);
/* (end of) block 0 */
- gsi = gsi_for_stmt (info->arr_ref_first);
+ gsi = gsi_for_stmt (m_arr_ref_first);
gsi_next (&gsi);
- bound = fold_convert_loc (loc, utype, info->range_size);
+ bound = fold_convert_loc (loc, utype, m_range_size);
cond_stmt = gimple_build_cond (LE_EXPR, tidx, bound, NULL_TREE, NULL_TREE);
gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);
update_stmt (cond_stmt);
/* block 2 */
- if (!info->default_case_nonstandard)
+ if (!m_default_case_nonstandard)
{
label2 = gimple_build_label (label_decl2);
gsi_insert_before (&gsi, label2, GSI_SAME_STMT);
- last_assign = gen_def_assigns (&gsi, info);
+ last_assign = gen_def_assigns (&gsi);
}
/* block 1 */
@@ -1382,7 +733,7 @@ gen_inbound_check (gswitch *swtch, struct switch_conv_info *info)
gsi_insert_before (&gsi, label1, GSI_SAME_STMT);
/* block F */
- gsi = gsi_start_bb (info->final_bb);
+ gsi = gsi_start_bb (m_final_bb);
label3 = gimple_build_label (label_decl3);
gsi_insert_before (&gsi, label3, GSI_SAME_STMT);
@@ -1390,10 +741,10 @@ gen_inbound_check (gswitch *swtch, struct switch_conv_info *info)
e02 = split_block (bb0, cond_stmt);
bb2 = e02->dest;
- if (info->default_case_nonstandard)
+ if (m_default_case_nonstandard)
{
bb1 = bb2;
- bb2 = info->default_bb;
+ bb2 = m_default_bb;
e01 = e02;
e01->flags = EDGE_TRUE_VALUE;
e02 = make_edge (bb0, bb2, EDGE_FALSE_VALUE);
@@ -1417,49 +768,49 @@ gen_inbound_check (gswitch *swtch, struct switch_conv_info *info)
remove_edge (e21);
}
- e1d = split_block (bb1, info->arr_ref_last);
+ e1d = split_block (bb1, m_arr_ref_last);
bbd = e1d->dest;
remove_edge (e1d);
- /* flags and profiles of the edge for in-range values */
- if (!info->default_case_nonstandard)
+ /* Flags and profiles of the edge for in-range values. */
+ if (!m_default_case_nonstandard)
e01 = make_edge (bb0, bb1, EDGE_TRUE_VALUE);
- e01->probability = info->default_prob.invert ();
- e01->count = info->other_count;
+ e01->probability = m_default_prob.invert ();
+ e01->count = m_other_count;
- /* flags and profiles of the edge taking care of out-of-range values */
+ /* Flags and profiles of the edge taking care of out-of-range values. */
e02->flags &= ~EDGE_FALLTHRU;
e02->flags |= EDGE_FALSE_VALUE;
- e02->probability = info->default_prob;
- e02->count = info->default_count;
+ e02->probability = m_default_prob;
+ e02->count = m_default_count;
- bbf = info->final_bb;
+ bbf = m_final_bb;
e1f = make_edge (bb1, bbf, EDGE_FALLTHRU);
e1f->probability = profile_probability::always ();
- e1f->count = info->other_count;
+ e1f->count = m_other_count;
- if (info->default_case_nonstandard)
+ if (m_default_case_nonstandard)
e2f = NULL;
else
{
e2f = make_edge (bb2, bbf, EDGE_FALLTHRU);
e2f->probability = profile_probability::always ();
- e2f->count = info->default_count;
+ e2f->count = m_default_count;
}
- /* frequencies of the new BBs */
+ /* Frequencies of the new BBs. */
bb1->frequency = EDGE_FREQUENCY (e01);
bb2->frequency = EDGE_FREQUENCY (e02);
- if (!info->default_case_nonstandard)
+ if (!m_default_case_nonstandard)
bbf->frequency = EDGE_FREQUENCY (e1f) + EDGE_FREQUENCY (e2f);
/* Tidy blocks that have become unreachable. */
- prune_bbs (bbd, info->final_bb,
- info->default_case_nonstandard ? info->default_bb : NULL);
+ prune_bbs (bbd, m_final_bb,
+ m_default_case_nonstandard ? m_default_bb : NULL);
/* Fixup the PHI nodes in bbF. */
- fix_phi_nodes (e1f, e2f, bbf, info);
+ fix_phi_nodes (e1f, e2f, bbf);
/* Fix the dominator tree, if it is available. */
if (dom_info_available_p (CDI_DOMINATORS))
@@ -1467,7 +818,7 @@ gen_inbound_check (gswitch *swtch, struct switch_conv_info *info)
vec<basic_block> bbs_to_fix_dom;
set_immediate_dominator (CDI_DOMINATORS, bb1, bb0);
- if (!info->default_case_nonstandard)
+ if (!m_default_case_nonstandard)
set_immediate_dominator (CDI_DOMINATORS, bb2, bb0);
if (! get_immediate_dominator (CDI_DOMINATORS, bbf))
/* If bbD was the immediate dominator ... */
@@ -1485,96 +836,72 @@ gen_inbound_check (gswitch *swtch, struct switch_conv_info *info)
}
}
-/* The following function is invoked on every switch statement (the current one
- is given in SWTCH) and runs the individual phases of switch conversion on it
- one after another until one fails or the conversion is completed.
- Returns NULL on success, or a pointer to a string with the reason why the
- conversion failed. */
-
-static const char *
-process_switch (gswitch *swtch)
+const char *
+switch_conversion::expand (gswitch *swtch)
{
- struct switch_conv_info info;
-
/* Group case labels so that we get the right results from the heuristics
that decide on the code generation approach for this switch. */
group_case_labels_stmt (swtch);
/* If this switch is now a degenerate case with only a default label,
- there is nothing left for us to do. */
+ there is nothing left for us to do. */
if (gimple_switch_num_labels (swtch) < 2)
return "switch is a degenerate case";
- collect_switch_conv_info (swtch, &info);
+ collect (swtch);
/* No error markers should reach here (they should be filtered out
during gimplification). */
- gcc_checking_assert (TREE_TYPE (info.index_expr) != error_mark_node);
+ gcc_checking_assert (TREE_TYPE (m_index_expr) != error_mark_node);
/* A switch on a constant should have been optimized in tree-cfg-cleanup. */
- gcc_checking_assert (! TREE_CONSTANT (info.index_expr));
-
- if (info.uniq <= MAX_CASE_BIT_TESTS)
- {
- if (expand_switch_using_bit_tests_p (info.range_size,
- info.uniq, info.count,
- optimize_bb_for_speed_p
- (gimple_bb (swtch))))
- {
- if (dump_file)
- fputs (" expanding as bit test is preferable\n", dump_file);
- emit_case_bit_tests (swtch, info.index_expr, info.range_min,
- info.range_size, info.range_max);
- loops_state_set (LOOPS_NEED_FIXUP);
- return NULL;
- }
-
- if (info.uniq <= 2)
- /* This will be expanded as a decision tree in stmt.c:expand_case. */
- return " expanding as jumps is preferable";
- }
+ gcc_checking_assert (!TREE_CONSTANT (m_index_expr));
/* If there is no common successor, we cannot do the transformation. */
- if (! info.final_bb)
+ if (!m_final_bb)
return "no common successor to all case label target blocks found";
/* Check the case label values are within reasonable range: */
- if (!check_range (&info))
+ if (!check_range ())
{
- gcc_assert (info.reason);
- return info.reason;
+ gcc_assert (m_reason);
+ return m_reason;
}
/* For all the cases, see whether they are empty, the assignments they
represent constant and so on... */
- if (! check_all_empty_except_final (&info))
+ if (!check_all_empty_except_final ())
{
- gcc_assert (info.reason);
- return info.reason;
+ gcc_assert (m_reason);
+ return m_reason;
}
- if (!check_final_bb (swtch, &info))
+ if (!check_final_bb ())
{
- gcc_assert (info.reason);
- return info.reason;
+ gcc_assert (m_reason);
+ return m_reason;
}
/* At this point all checks have passed and we can proceed with the
transformation. */
- create_temp_arrays (&info);
- gather_default_values (info.default_case_nonstandard
+ create_temp_arrays ();
+ gather_default_values (m_default_case_nonstandard
? gimple_switch_label (swtch, 1)
- : gimple_switch_default_label (swtch), &info);
- build_constructors (swtch, &info);
+ : gimple_switch_default_label (swtch));
+ build_constructors ();
- build_arrays (swtch, &info); /* Build the static arrays and assignments. */
- gen_inbound_check (swtch, &info); /* Build the bounds check. */
+ build_arrays (); /* Build the static arrays and assignments. */
+ gen_inbound_check (); /* Build the bounds check. */
- /* Cleanup: */
- free_temp_arrays (&info);
return NULL;
}
+switch_conversion::~switch_conversion ()
+{
+ XDELETEVEC (m_constructors);
+ XDELETEVEC (m_default_values);
+}
+
/* The main function of the pass scans statements for switches and invokes
process_switch on them. */
@@ -1628,8 +955,9 @@ pass_convert_switch::execute (function *fun)
putc ('\n', dump_file);
}
- failure_reason = process_switch (as_a <gswitch *> (stmt));
- if (! failure_reason)
+ switch_conversion sconv;
+ failure_reason = sconv.expand (as_a <gswitch *> (stmt));
+ if (!failure_reason)
{
if (dump_file)
{
@@ -1637,9 +965,10 @@ pass_convert_switch::execute (function *fun)
fputs ("--------------------------------\n", dump_file);
}
- /* Make no effort to update the post-dominator tree. It is actually not
- that hard for the transformations we have performed, but it is not
- supported by iterate_fix_dominators. */
+ /* Make no effort to update the post-dominator tree.
+ It is actually not that hard for the transformations
+ we have performed, but it is not supported
+ by iterate_fix_dominators. */
free_dominance_info (CDI_POST_DOMINATORS);
}
else
@@ -1659,70 +988,453 @@ pass_convert_switch::execute (function *fun)
} // anon namespace
-gimple_opt_pass *
-make_pass_convert_switch (gcc::context *ctxt)
+group_cluster::~group_cluster ()
{
- return new pass_convert_switch (ctxt);
+ for (unsigned i = 0; i < m_cases.length (); i++)
+ delete m_cases[i];
+
+ m_cases.release ();
}
-struct case_node
+jump_table_cluster::jump_table_cluster (vec<cluster *> &clusters,
+ unsigned start, unsigned end)
{
- case_node *left; /* Left son in binary tree. */
- case_node *right; /* Right son in binary tree;
- also node chain. */
- case_node *parent; /* Parent of node in binary tree. */
- tree low; /* Lowest index value for this label. */
- tree high; /* Highest index value for this label. */
- basic_block case_bb; /* Label to jump to when node matches. */
- tree case_label; /* Label to jump to when node matches. */
- profile_probability prob; /* Probability of taking this case. */
- profile_probability subtree_prob; /* Probability of reaching subtree
- rooted at this node. */
-};
+ gcc_checking_assert (end - start + 1 >= 1);
+ m_prob = profile_probability::never ();
+ m_cases.create (end - start + 1);
+ for (unsigned i = start; i <= end; i++)
+ {
+ m_cases.quick_push (static_cast<simple_cluster *> (clusters[i]));
+ m_prob += clusters[i]->m_prob;
+ }
+ m_subtree_prob = m_prob;
+}
+
+void
+jump_table_cluster::emit (tree index_expr, tree,
+ tree default_label_expr, basic_block default_bb)
+{
+ /* For jump table we just emit a new gswitch statement that will
+ be latter lowered to jump table. */
+ auto_vec <tree> labels;
+ labels.create (m_cases.length ());
+
+ make_edge (m_case_bb, default_bb, 0);
+ for (unsigned i = 0; i < m_cases.length (); i++)
+ {
+ labels.quick_push (unshare_expr (m_cases[i]->m_case_label_expr));
+ make_edge (m_case_bb, m_cases[i]->m_case_bb, 0);
+ }
+
+ gswitch *s = gimple_build_switch (index_expr,
+ unshare_expr (default_label_expr), labels);
+ gimple_stmt_iterator gsi = gsi_start_bb (m_case_bb);
+ gsi_insert_after (&gsi, s, GSI_NEW_STMT);
+}
+
+vec<cluster *>
+jump_table_cluster::find_jump_tables (vec<cluster *> &clusters)
+{
+ unsigned l = clusters.length ();
+ auto_vec<min_cluster_item> min;
+ min.reserve (l + 1);
+
+ min.quick_push (min_cluster_item (0, 0, 0));
+
+ for (unsigned i = 1; i <= l; i++)
+ {
+ /* Set minimal # of clusters with i-th item to infinite. */
+ min.quick_push (min_cluster_item (INT_MAX, INT_MAX, INT_MAX));
+
+ for (unsigned j = 0; j < i; j++)
+ {
+ unsigned HOST_WIDE_INT s = min[j].m_non_jt_cases;
+ if (i - j < case_values_threshold ())
+ s += i - j;
+
+ /* Prefer clusters with smaller number of numbers covered. */
+ if ((min[j].m_count + 1 < min[i].m_count
+ || (min[j].m_count + 1 == min[i].m_count
+ && s < min[i].m_non_jt_cases))
+ && can_be_handled (clusters, j, i - 1))
+ min[i] = min_cluster_item (min[j].m_count + 1, j, s);
+ }
+ }
+
+ /* No result. */
+ if (min[l].m_count == INT_MAX)
+ return clusters.copy ();
+
+ vec<cluster *> output;
+ output.create (4);
+
+ /* Find and build the clusters. */
+ for (int end = l;;)
+ {
+ int start = min[end].m_start;
+
+ /* Do not allow clusters with small number of cases. */
+ if (is_beneficial (clusters, start, end - 1))
+ output.safe_push (new jump_table_cluster (clusters, start, end - 1));
+ else
+ for (int i = end - 1; i >= start; i--)
+ output.safe_push (clusters[i]);
+
+ end = start;
+
+ if (start <= 0)
+ break;
+ }
+
+ output.reverse ();
+ return output;
+}
+
+bool
+jump_table_cluster::can_be_handled (const vec<cluster *> &clusters,
+ unsigned start, unsigned end)
+{
+ /* If the switch is relatively small such that the cost of one
+ indirect jump on the target are higher than the cost of a
+ decision tree, go with the decision tree.
+
+ If range of values is much bigger than number of values,
+ or if it is too large to represent in a HOST_WIDE_INT,
+ make a sequence of conditional branches instead of a dispatch.
+
+ The definition of "much bigger" depends on whether we are
+ optimizing for size or for speed. If the former, the maximum
+ ratio range/count = 3, because this was found to be the optimal
+ ratio for size on i686-pc-linux-gnu, see PR11823. The ratio
+ 10 is much older, and was probably selected after an extensive
+ benchmarking investigation on numerous platforms. Or maybe it
+ just made sense to someone at some point in the history of GCC,
+ who knows... */
+ if (!flag_jump_tables)
+ return false;
+
+ unsigned HOST_WIDE_INT max_ratio = optimize_insn_for_size_p () ? 3 : 10;
+
+ unsigned HOST_WIDE_INT range = get_range (clusters[start]->get_low (),
+ clusters[end]->get_high ());
+
+ unsigned HOST_WIDE_INT value_count = 0;
+ for (unsigned i = start; i <= end; i++)
+ value_count += get_range (clusters[i]->get_low (),
+ clusters[i]->get_high ());
+
+ return range <= max_ratio * value_count;
+}
+
+bool
+jump_table_cluster::is_beneficial (const vec<cluster *> &,
+ unsigned start, unsigned end)
+{
+ return end - start + 1 >= case_values_threshold ();
+}
+
+bit_test_cluster::bit_test_cluster (vec<cluster *> &clusters,
+ unsigned start, unsigned end)
+{
+ gcc_checking_assert (end - start + 1 >= 1);
+ m_prob = profile_probability::never ();
+ m_cases.create (end - start + 1);
+ for (unsigned i = start; i <= end; i++)
+ {
+ m_prob += clusters[i]->m_prob;
+ m_cases.safe_push (static_cast<simple_cluster *> (clusters[i]));
+ }
+
+ m_subtree_prob = m_prob;
+}
+
+vec<cluster *>
+bit_test_cluster::find_bit_tests (vec<cluster *> &clusters)
+{
+ vec<cluster *> output;
+ output.create (4);
+
+ unsigned l = clusters.length ();
+ auto_vec<min_cluster_item> min;
+ min.reserve (l + 1);
+
+ min.quick_push (min_cluster_item (0, 0, 0));
+
+ for (unsigned i = 1; i <= l; i++)
+ {
+ /* Set minimal # of clusters with i-th item to infinite. */
+ min.quick_push (min_cluster_item (INT_MAX, INT_MAX, INT_MAX));
+
+ for (unsigned j = 0; j < i; j++)
+ {
+ if (min[j].m_count + 1 < min[i].m_count
+ && can_be_handled (clusters, j, i - 1))
+ min[i] = min_cluster_item (min[j].m_count + 1, j, INT_MAX);
+ }
+ }
+
+ /* No result. */
+ if (min[l].m_count == INT_MAX)
+ return clusters.copy ();
+
+ /* Find and build the clusters. */
+ for (int end = l;;)
+ {
+ int start = min[end].m_start;
+
+ if (is_beneficial (clusters, start, end - 1))
+ output.safe_push (new bit_test_cluster (clusters, start, end - 1));
+ else
+ for (int i = end - 1; i >= start; i--)
+ output.safe_push (clusters[i]);
+
+ end = start;
+
+ if (start <= 0)
+ break;
+ }
+
+ output.reverse ();
+ return output;
+}
+
+bool
+bit_test_cluster::can_be_handled (const vec<cluster *> &clusters,
+ unsigned start, unsigned end)
+{
+ HOST_WIDE_INT range = get_range (clusters[start]->get_low (),
+ clusters[end]->get_high ());
+
+ if (range >= GET_MODE_BITSIZE (word_mode))
+ return false;
+
+ auto_bitmap dest_bbs;
+
+ for (unsigned i = start; i <= end; i++)
+ {
+ simple_cluster *sc = static_cast<simple_cluster *> (clusters[i]);
+ bitmap_set_bit (dest_bbs, sc->m_case_bb->index);
+ }
+
+ return bitmap_count_bits (dest_bbs) <= 3;
+}
+
+bool
+bit_test_cluster::is_beneficial (const vec<cluster *> &clusters,
+ unsigned start, unsigned end)
+{
+ auto_bitmap dest_bbs;
+
+ for (unsigned i = start; i <= end; i++)
+ {
+ simple_cluster *sc = static_cast<simple_cluster *> (clusters[i]);
+ bitmap_set_bit (dest_bbs, sc->m_case_bb->index);
+ }
+
+ unsigned HOST_WIDE_INT uniq = bitmap_count_bits (dest_bbs);
+ unsigned HOST_WIDE_INT count = end - start + 1;
+
+ return (((uniq == 1 && count >= 3)
+ || (uniq == 2 && count >= 5)
+ || (uniq == 3 && count >= 6)));
+}
-typedef case_node *case_node_ptr;
+int
+case_bit_test::cmp (const void *p1, const void *p2)
+{
+ const struct case_bit_test *const d1 = (const struct case_bit_test *) p1;
+ const struct case_bit_test *const d2 = (const struct case_bit_test *) p2;
-static basic_block emit_case_nodes (basic_block, tree, case_node_ptr,
- basic_block, tree, profile_probability,
- tree, hash_map<tree, tree> *);
+ if (d2->bits != d1->bits)
+ return d2->bits - d1->bits;
-/* Return the smallest number of different values for which it is best to use a
- jump-table instead of a tree of conditional branches. */
+ /* Stabilize the sort. */
+ return (LABEL_DECL_UID (CASE_LABEL (d2->label))
+ - LABEL_DECL_UID (CASE_LABEL (d1->label)));
+}
-static unsigned int
-case_values_threshold (void)
+void
+bit_test_cluster::emit (tree index_expr, tree index_type,
+ tree, basic_block default_bb)
{
- unsigned int threshold = PARAM_VALUE (PARAM_CASE_VALUES_THRESHOLD);
+ struct case_bit_test test[m_max_case_bit_tests] = { {} };
+ unsigned int i, j, k;
+ unsigned int count;
+
+ tree unsigned_index_type = unsigned_type_for (index_type);
+
+ gimple_stmt_iterator gsi;
+ gassign *shift_stmt;
+
+ tree idx, tmp, csui;
+ tree word_type_node = lang_hooks.types.type_for_mode (word_mode, 1);
+ tree word_mode_zero = fold_convert (word_type_node, integer_zero_node);
+ tree word_mode_one = fold_convert (word_type_node, integer_one_node);
+ int prec = TYPE_PRECISION (word_type_node);
+ wide_int wone = wi::one (prec);
- if (threshold == 0)
- threshold = targetm.case_values_threshold ();
+ tree minval = get_low ();
+ tree maxval = get_high ();
+ tree range = int_const_binop (MINUS_EXPR, maxval, minval);
+
+ /* Go through all case labels, and collect the case labels, profile
+ counts, and other information we need to build the branch tests. */
+ count = 0;
+ for (i = 0; i < m_cases.length (); i++)
+ {
+ unsigned int lo, hi;
+ simple_cluster *n = static_cast<simple_cluster *> (m_cases[i]);
+ for (k = 0; k < count; k++)
+ if (n->m_case_bb == test[k].target_bb)
+ break;
- return threshold;
+ if (k == count)
+ {
+ gcc_checking_assert (count < m_max_case_bit_tests);
+ test[k].mask = wi::zero (prec);
+ test[k].target_bb = n->m_case_bb;
+ test[k].label = n->m_case_label_expr;
+ test[k].bits = 1;
+ count++;
+ }
+ else
+ test[k].bits++;
+
+ lo = tree_to_uhwi (int_const_binop (MINUS_EXPR, n->get_low (), minval));
+ if (n->get_high () == NULL_TREE)
+ hi = lo;
+ else
+ hi = tree_to_uhwi (int_const_binop (MINUS_EXPR, n->get_high (),
+ minval));
+
+ for (j = lo; j <= hi; j++)
+ test[k].mask |= wi::lshift (wone, j);
+ }
+
+ qsort (test, count, sizeof (*test), case_bit_test::cmp);
+
+ /* If all values are in the 0 .. BITS_PER_WORD-1 range, we can get rid of
+ the minval subtractions, but it might make the mask constants more
+ expensive. So, compare the costs. */
+ if (compare_tree_int (minval, 0) > 0
+ && compare_tree_int (maxval, GET_MODE_BITSIZE (word_mode)) < 0)
+ {
+ int cost_diff;
+ HOST_WIDE_INT m = tree_to_uhwi (minval);
+ rtx reg = gen_raw_REG (word_mode, 10000);
+ bool speed_p = optimize_insn_for_speed_p ();
+ cost_diff = set_rtx_cost (gen_rtx_PLUS (word_mode, reg,
+ GEN_INT (-m)), speed_p);
+ for (i = 0; i < count; i++)
+ {
+ rtx r = immed_wide_int_const (test[i].mask, word_mode);
+ cost_diff += set_src_cost (gen_rtx_AND (word_mode, reg, r),
+ word_mode, speed_p);
+ r = immed_wide_int_const (wi::lshift (test[i].mask, m), word_mode);
+ cost_diff -= set_src_cost (gen_rtx_AND (word_mode, reg, r),
+ word_mode, speed_p);
+ }
+ if (cost_diff > 0)
+ {
+ for (i = 0; i < count; i++)
+ test[i].mask = wi::lshift (test[i].mask, m);
+ minval = build_zero_cst (TREE_TYPE (minval));
+ range = maxval;
+ }
+ }
+
+ /* Now build the test-and-branch code. */
+
+ gsi = gsi_last_bb (m_case_bb);
+
+ /* idx = (unsigned)x - minval. */
+ idx = fold_convert (unsigned_index_type, index_expr);
+ idx = fold_build2 (MINUS_EXPR, unsigned_index_type, idx,
+ fold_convert (unsigned_index_type, minval));
+ idx = force_gimple_operand_gsi (&gsi, idx,
+ /*simple=*/true, NULL_TREE,
+ /*before=*/true, GSI_SAME_STMT);
+
+ /* if (idx > range) goto default */
+ range = force_gimple_operand_gsi (&gsi,
+ fold_convert (unsigned_index_type, range),
+ /*simple=*/true, NULL_TREE,
+ /*before=*/true, GSI_SAME_STMT);
+ tmp = fold_build2 (GT_EXPR, boolean_type_node, idx, range);
+ basic_block new_bb = hoist_edge_and_branch_if_true (&gsi, tmp, default_bb);
+ gsi = gsi_last_bb (new_bb);
+
+ /* csui = (1 << (word_mode) idx) */
+ csui = make_ssa_name (word_type_node);
+ tmp = fold_build2 (LSHIFT_EXPR, word_type_node, word_mode_one,
+ fold_convert (word_type_node, idx));
+ tmp = force_gimple_operand_gsi (&gsi, tmp,
+ /*simple=*/false, NULL_TREE,
+ /*before=*/true, GSI_SAME_STMT);
+ shift_stmt = gimple_build_assign (csui, tmp);
+ gsi_insert_before (&gsi, shift_stmt, GSI_SAME_STMT);
+ update_stmt (shift_stmt);
+
+ /* for each unique set of cases:
+ if (const & csui) goto target */
+ for (k = 0; k < count; k++)
+ {
+ tmp = wide_int_to_tree (word_type_node, test[k].mask);
+ tmp = fold_build2 (BIT_AND_EXPR, word_type_node, csui, tmp);
+ tmp = force_gimple_operand_gsi (&gsi, tmp,
+ /*simple=*/true, NULL_TREE,
+ /*before=*/true, GSI_SAME_STMT);
+ tmp = fold_build2 (NE_EXPR, boolean_type_node, tmp, word_mode_zero);
+ new_bb = hoist_edge_and_branch_if_true (&gsi, tmp, test[k].target_bb);
+ gsi = gsi_last_bb (new_bb);
+ }
+
+ /* We should have removed all edges now. */
+ gcc_assert (EDGE_COUNT (gsi_bb (gsi)->succs) == 0);
+
+ /* If nothing matched, go to the default label. */
+ make_edge (gsi_bb (gsi), default_bb, EDGE_FALLTHRU);
}
-/* Reset the aux field of all outgoing edges of basic block BB. */
+basic_block
+bit_test_cluster::hoist_edge_and_branch_if_true (gimple_stmt_iterator *gsip,
+ tree cond, basic_block case_bb)
+{
+ tree tmp;
+ gcond *cond_stmt;
+ edge e_false;
+ basic_block new_bb, split_bb = gsi_bb (*gsip);
+
+ edge e_true = make_edge (split_bb, case_bb, EDGE_TRUE_VALUE);
+ gcc_assert (e_true->src == split_bb);
+
+ tmp = force_gimple_operand_gsi (gsip, cond, /*simple=*/true, NULL,
+ /*before=*/true, GSI_SAME_STMT);
+ cond_stmt = gimple_build_cond_from_tree (tmp, NULL_TREE, NULL_TREE);
+ gsi_insert_before (gsip, cond_stmt, GSI_SAME_STMT);
+
+ e_false = split_block (split_bb, cond_stmt);
+ new_bb = e_false->dest;
+ redirect_edge_pred (e_true, split_bb);
+
+ e_false->flags &= ~EDGE_FALLTHRU;
+ e_false->flags |= EDGE_FALSE_VALUE;
+ e_false->probability = e_true->probability.invert ();
+ e_false->count = split_bb->count - e_true->count;
+ new_bb->count = e_false->count;
-static inline void
-reset_out_edges_aux (basic_block bb)
-{
- edge e;
- edge_iterator ei;
- FOR_EACH_EDGE (e, ei, bb->succs)
- e->aux = (void *) 0;
+ return new_bb;
}
-/* Compute the number of case labels that correspond to each outgoing edge of
- STMT. Record this information in the aux field of the edge. */
-
-static inline void
-compute_cases_per_edge (gswitch *stmt)
+void
+switch_decision_tree::compute_cases_per_edge ()
{
- basic_block bb = gimple_bb (stmt);
- reset_out_edges_aux (bb);
- int ncases = gimple_switch_num_labels (stmt);
+ basic_block bb = gimple_bb (m_switch);
+ reset_out_edges_aux ();
+ int ncases = gimple_switch_num_labels (m_switch);
for (int i = ncases - 1; i >= 1; --i)
{
- tree elt = gimple_switch_label (stmt, i);
+ tree elt = gimple_switch_label (m_switch, i);
tree lab = CASE_LABEL (elt);
basic_block case_bb = label_to_block_fn (cfun, lab);
edge case_edge = find_edge (bb, case_bb);
@@ -1730,250 +1442,126 @@ compute_cases_per_edge (gswitch *stmt)
}
}
-/* Do the insertion of a case label into case_list. The labels are
- fed to us in descending order from the sorted vector of case labels used
- in the tree part of the middle end. So the list we construct is
- sorted in ascending order.
-
- LABEL is the case label to be inserted. LOW and HIGH are the bounds
- against which the index is compared to jump to LABEL and PROB is the
- estimated probability LABEL is reached from the switch statement. */
-
-static case_node *
-add_case_node (case_node *head, tree low, tree high, basic_block case_bb,
- tree case_label, profile_probability prob,
- object_allocator<case_node> &case_node_pool)
+bool
+switch_decision_tree::analyze_switch_statement ()
{
- case_node *r;
-
- gcc_checking_assert (low);
- gcc_checking_assert (high && (TREE_TYPE (low) == TREE_TYPE (high)));
-
- /* Add this label to the chain. */
- r = case_node_pool.allocate ();
- r->low = low;
- r->high = high;
- r->case_bb = case_bb;
- r->case_label = case_label;
- r->parent = r->left = NULL;
- r->prob = prob;
- r->subtree_prob = prob;
- r->right = head;
- return r;
-}
-
-/* Dump ROOT, a list or tree of case nodes, to file. */
+ unsigned l = gimple_switch_num_labels (m_switch);
+ basic_block bb = gimple_bb (m_switch);
+ auto_vec<cluster *> clusters;
+ clusters.create (l - 1);
-static void
-dump_case_nodes (FILE *f, case_node *root, int indent_step, int indent_level)
-{
- if (root == 0)
- return;
- indent_level++;
+ tree default_label = CASE_LABEL (gimple_switch_default_label (m_switch));
+ basic_block default_bb = label_to_block_fn (cfun, default_label);
+ m_case_bbs.reserve (l);
+ m_case_bbs.quick_push (default_bb);
- dump_case_nodes (f, root->left, indent_step, indent_level);
+ compute_cases_per_edge ();
- fputs (";; ", f);
- fprintf (f, "%*s", indent_step * indent_level, "");
- print_dec (root->low, f, TYPE_SIGN (TREE_TYPE (root->low)));
- if (!tree_int_cst_equal (root->low, root->high))
+ for (unsigned i = 1; i < l; i++)
{
- fprintf (f, " ... ");
- print_dec (root->high, f, TYPE_SIGN (TREE_TYPE (root->high)));
- }
- fputs ("\n", f);
+ tree elt = gimple_switch_label (m_switch, i);
+ tree lab = CASE_LABEL (elt);
+ basic_block case_bb = label_to_block_fn (cfun, lab);
+ edge case_edge = find_edge (bb, case_bb);
+ tree low = CASE_LOW (elt);
+ tree high = CASE_HIGH (elt);
+ if (high == NULL_TREE)
+ high = low;
- dump_case_nodes (f, root->right, indent_step, indent_level);
-}
+ profile_probability p
+ = case_edge->probability.apply_scale (1, (intptr_t) (case_edge->aux));
+ clusters.quick_push (new simple_cluster (low, high, elt, case_bb, p));
+ m_case_bbs.quick_push (case_bb);
+ }
-/* Take an ordered list of case nodes
- and transform them into a near optimal binary tree,
- on the assumption that any target code selection value is as
- likely as any other.
+ reset_out_edges_aux ();
- The transformation is performed by splitting the ordered
- list into two equal sections plus a pivot. The parts are
- then attached to the pivot as left and right branches. Each
- branch is then transformed recursively. */
+ /* Find jump table clusters. */
+ vec<cluster *> output = jump_table_cluster::find_jump_tables (clusters);
-static void
-balance_case_nodes (case_node_ptr *head, case_node_ptr parent)
-{
- case_node_ptr np;
+ /* Find jump table clusters. */
+ vec<cluster *> output2;
+ auto_vec<cluster *> tmp;
+ output2.create (1);
+ tmp.create (1);
- np = *head;
- if (np)
+ for (unsigned i = 0; i < output.length (); i++)
{
- int i = 0;
- int ranges = 0;
- case_node_ptr *npp;
- case_node_ptr left;
-
- /* Count the number of entries on branch. Also count the ranges. */
-
- while (np)
- {
- if (!tree_int_cst_equal (np->low, np->high))
- ranges++;
-
- i++;
- np = np->right;
- }
-
- if (i > 2)
+ cluster *c = output[i];
+ if (c->get_type () != SIMPLE_CASE)
{
- /* Split this list if it is long enough for that to help. */
- npp = head;
- left = *npp;
-
- /* If there are just three nodes, split at the middle one. */
- if (i == 3)
- npp = &(*npp)->right;
- else
+ if (!tmp.is_empty ())
{
- /* Find the place in the list that bisects the list's total cost,
- where ranges count as 2.
- Here I gets half the total cost. */
- i = (i + ranges + 1) / 2;
- while (1)
- {
- /* Skip nodes while their cost does not reach that amount. */
- if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
- i--;
- i--;
- if (i <= 0)
- break;
- npp = &(*npp)->right;
- }
+ vec<cluster *> n = bit_test_cluster::find_bit_tests (tmp);
+ output2.safe_splice (n);
+ n.release ();
+ tmp.truncate (0);
}
- *head = np = *npp;
- *npp = 0;
- np->parent = parent;
- np->left = left;
-
- /* Optimize each of the two split parts. */
- balance_case_nodes (&np->left, np);
- balance_case_nodes (&np->right, np);
- np->subtree_prob = np->prob;
- np->subtree_prob += np->left->subtree_prob;
- np->subtree_prob += np->right->subtree_prob;
+ output2.safe_push (c);
}
else
- {
- /* Else leave this branch as one level,
- but fill in `parent' fields. */
- np = *head;
- np->parent = parent;
- np->subtree_prob = np->prob;
- for (; np->right; np = np->right)
- {
- np->right->parent = np;
- (*head)->subtree_prob += np->right->subtree_prob;
- }
- }
+ tmp.safe_push (c);
}
-}
-
-/* Return true if a switch should be expanded as a decision tree.
- RANGE is the difference between highest and lowest case.
- UNIQ is number of unique case node targets, not counting the default case.
- COUNT is the number of comparisons needed, not counting the default case. */
-
-static bool
-expand_switch_as_decision_tree_p (tree range,
- unsigned int uniq ATTRIBUTE_UNUSED,
- unsigned int count)
-{
- int max_ratio;
- /* If neither casesi or tablejump is available, or flag_jump_tables
- over-ruled us, we really have no choice. */
- if (!targetm.have_casesi () && !targetm.have_tablejump ())
- return true;
- if (!flag_jump_tables)
- return true;
-#ifndef ASM_OUTPUT_ADDR_DIFF_ELT
- if (flag_pic)
- return true;
-#endif
+ /* We still can have a temporary vector to test. */
+ if (!tmp.is_empty ())
+ {
+ vec<cluster *> n = bit_test_cluster::find_bit_tests (tmp);
+ output2.safe_splice (n);
+ n.release ();
+ }
- /* If the switch is relatively small such that the cost of one
- indirect jump on the target are higher than the cost of a
- decision tree, go with the decision tree.
+ if (dump_file)
+ {
+ fprintf (dump_file, ";; GIMPLE switch case clusters: ");
+ for (unsigned i = 0; i < output2.length (); i++)
+ output2[i]->dump (dump_file);
+ fprintf (dump_file, "\n");
+ }
- If range of values is much bigger than number of values,
- or if it is too large to represent in a HOST_WIDE_INT,
- make a sequence of conditional branches instead of a dispatch.
+ output.release ();
- The definition of "much bigger" depends on whether we are
- optimizing for size or for speed. If the former, the maximum
- ratio range/count = 3, because this was found to be the optimal
- ratio for size on i686-pc-linux-gnu, see PR11823. The ratio
- 10 is much older, and was probably selected after an extensive
- benchmarking investigation on numerous platforms. Or maybe it
- just made sense to someone at some point in the history of GCC,
- who knows... */
- max_ratio = optimize_insn_for_size_p () ? 3 : 10;
- if (count < case_values_threshold () || !tree_fits_uhwi_p (range)
- || compare_tree_int (range, max_ratio * count) > 0)
- return true;
+ bool expanded = try_switch_expansion (output2);
- return false;
-}
+ for (unsigned i = 0; i < output2.length (); i++)
+ delete output2[i];
-static void
-fix_phi_operands_for_edge (edge e, hash_map<tree, tree> *phi_mapping)
-{
- basic_block bb = e->dest;
- gphi_iterator gsi;
- for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
- {
- gphi *phi = gsi.phi ();
+ output2.release ();
- tree *definition = phi_mapping->get (gimple_phi_result (phi));
- if (definition)
- add_phi_arg (phi, *definition, e, UNKNOWN_LOCATION);
- }
+ return expanded;
}
-
-/* Add an unconditional jump to CASE_BB that happens in basic block BB. */
-
-static void
-emit_jump (basic_block bb, basic_block case_bb,
- hash_map<tree, tree> *phi_mapping)
+bool
+switch_decision_tree::try_switch_expansion (vec<cluster *> &clusters)
{
- edge e = single_succ_edge (bb);
- redirect_edge_succ (e, case_bb);
- fix_phi_operands_for_edge (e, phi_mapping);
-}
+ tree index_expr = gimple_switch_index (m_switch);
+ tree index_type = TREE_TYPE (index_expr);
+ basic_block bb = gimple_bb (m_switch);
-/* Generate a decision tree, switching on INDEX_EXPR and jumping to
- one of the labels in CASE_LIST or to the DEFAULT_LABEL.
- DEFAULT_PROB is the estimated probability that it jumps to
- DEFAULT_LABEL.
+ if (gimple_switch_num_labels (m_switch) == 1)
+ return false;
- We generate a binary decision tree to select the appropriate target
- code. */
+ /* Find the default case target label. */
+ tree default_label_expr = CASE_LABEL (gimple_switch_default_label (m_switch));
+ m_default_bb = label_to_block_fn (cfun, default_label_expr);
+ edge default_edge = find_edge (bb, m_default_bb);
-static void
-emit_case_decision_tree (gswitch *s, tree index_expr, tree index_type,
- case_node_ptr case_list, basic_block default_bb,
- tree default_label, profile_probability default_prob,
- hash_map<tree, tree> *phi_mapping)
-{
- balance_case_nodes (&case_list, NULL);
+ /* Do the insertion of a case label into m_case_list. The labels are
+ fed to us in descending order from the sorted vector of case labels used
+ in the tree part of the middle end. So the list we construct is
+ sorted in ascending order. */
- if (dump_file)
- dump_function_to_file (current_function_decl, dump_file, dump_flags);
- if (dump_file && (dump_flags & TDF_DETAILS))
+ for (int i = clusters.length () - 1; i >= 0; i--)
{
- int indent_step = ceil_log2 (TYPE_PRECISION (index_type)) + 2;
- fprintf (dump_file, ";; Expanding GIMPLE switch as decision tree:\n");
- dump_case_nodes (dump_file, case_list, indent_step, 0);
+ case_tree_node *r = m_case_list;
+ m_case_list = m_case_node_pool.allocate ();
+ m_case_list->m_right = r;
+ m_case_list->m_c = clusters[i];
}
- basic_block bb = gimple_bb (s);
+ record_phi_operand_mapping ();
+
+ /* Split basic block that contains the gswitch statement. */
gimple_stmt_iterator gsi = gsi_last_bb (bb);
edge e;
if (gsi_end_p (gsi))
@@ -1985,27 +1573,37 @@ emit_case_decision_tree (gswitch *s, tree index_expr, tree index_type,
}
bb = split_edge (e);
- bb = emit_case_nodes (bb, index_expr, case_list, default_bb, default_label,
- default_prob, index_type, phi_mapping);
+ /* Create new basic blocks for non-case clusters where specific expansion
+ needs to happen. */
+ for (unsigned i = 0; i < clusters.length (); i++)
+ if (clusters[i]->get_type () != SIMPLE_CASE)
+ {
+ clusters[i]->m_case_bb = create_empty_bb (bb);
+ clusters[i]->m_case_bb->loop_father = bb->loop_father;
+ }
+
+ emit (bb, index_expr, default_edge->probability, index_type);
- if (bb)
- emit_jump (bb, default_bb, phi_mapping);
+ /* Emit cluster-specific switch handling. */
+ for (unsigned i = 0; i < clusters.length (); i++)
+ if (clusters[i]->get_type () != SIMPLE_CASE)
+ clusters[i]->emit (index_expr, index_type,
+ gimple_switch_default_label (m_switch), m_default_bb);
- /* Remove all edges and do just an edge that will reach default_bb. */
- gsi = gsi_last_bb (gimple_bb (s));
- gsi_remove (&gsi, true);
+ fix_phi_operands_for_edges ();
+
+ return true;
}
-static void
-record_phi_operand_mapping (const vec<basic_block> bbs, basic_block switch_bb,
- hash_map <tree, tree> *map)
+void
+switch_decision_tree::record_phi_operand_mapping ()
{
+ basic_block switch_bb = gimple_bb (m_switch);
/* Record all PHI nodes that have to be fixed after conversion. */
- for (unsigned i = 0; i < bbs.length (); i++)
+ for (unsigned i = 0; i < m_case_bbs.length (); i++)
{
- basic_block bb = bbs[i];
-
gphi_iterator gsi;
+ basic_block bb = m_case_bbs[i];
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gphi *phi = gsi.phi ();
@@ -2017,7 +1615,7 @@ record_phi_operand_mapping (const vec<basic_block> bbs, basic_block switch_bb,
{
tree def = gimple_phi_arg_def (phi, i);
tree result = gimple_phi_result (phi);
- map->put (result, def);
+ m_phi_mapping.put (result, def);
break;
}
}
@@ -2025,133 +1623,174 @@ record_phi_operand_mapping (const vec<basic_block> bbs, basic_block switch_bb,
}
}
-/* Attempt to expand gimple switch STMT to a decision tree. */
-
-static bool
-try_switch_expansion (gswitch *stmt)
+void
+switch_decision_tree::fix_phi_operands_for_edges ()
{
- tree minval = NULL_TREE, maxval = NULL_TREE, range = NULL_TREE;
- basic_block default_bb;
- unsigned int count, uniq;
- int i;
- int ncases = gimple_switch_num_labels (stmt);
- tree index_expr = gimple_switch_index (stmt);
- tree index_type = TREE_TYPE (index_expr);
- tree elt;
- basic_block bb = gimple_bb (stmt);
+ gphi_iterator gsi;
- hash_map<tree, tree> phi_mapping;
- auto_vec<basic_block> case_bbs;
+ for (unsigned i = 0; i < m_case_bbs.length (); i++)
+ {
+ basic_block bb = m_case_bbs[i];
+ for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ {
+ gphi *phi = gsi.phi ();
+ for (unsigned j = 0; j < gimple_phi_num_args (phi); j++)
+ {
+ tree def = gimple_phi_arg_def (phi, j);
+ if (def == NULL_TREE)
+ {
+ edge e = gimple_phi_arg_edge (phi, j);
+ tree *definition
+ = m_phi_mapping.get (gimple_phi_result (phi));
+ gcc_assert (definition);
+ add_phi_arg (phi, *definition, e, UNKNOWN_LOCATION);
+ }
+ }
+ }
+ }
+}
- /* A list of case labels; it is first built as a list and it may then
- be rearranged into a nearly balanced binary tree. */
- case_node *case_list = 0;
+void
+switch_decision_tree::emit (basic_block bb, tree index_expr,
+ profile_probability default_prob, tree index_type)
+{
+ balance_case_nodes (&m_case_list, NULL);
- /* A pool for case nodes. */
- object_allocator<case_node> case_node_pool ("struct case_node pool");
+ if (dump_file)
+ dump_function_to_file (current_function_decl, dump_file, dump_flags);
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ int indent_step = ceil_log2 (TYPE_PRECISION (index_type)) + 2;
+ fprintf (dump_file, ";; Expanding GIMPLE switch as decision tree:\n");
+ gcc_assert (m_case_list != NULL);
+ dump_case_nodes (dump_file, m_case_list, indent_step, 0);
+ }
- /* cleanup_tree_cfg removes all SWITCH_EXPR with their index
- expressions being INTEGER_CST. */
- gcc_assert (TREE_CODE (index_expr) != INTEGER_CST);
+ bb = emit_case_nodes (bb, index_expr, m_case_list, default_prob, index_type);
- if (ncases == 1)
- return false;
+ if (bb)
+ emit_jump (bb, m_default_bb);
- /* Find the default case target label. */
- tree default_label = CASE_LABEL (gimple_switch_default_label (stmt));
- default_bb = label_to_block_fn (cfun, default_label);
- edge default_edge = find_edge (bb, default_bb);
- profile_probability default_prob = default_edge->probability;
- case_bbs.safe_push (default_bb);
-
- /* Get upper and lower bounds of case values. */
- elt = gimple_switch_label (stmt, 1);
- minval = fold_convert (index_type, CASE_LOW (elt));
- elt = gimple_switch_label (stmt, ncases - 1);
- if (CASE_HIGH (elt))
- maxval = fold_convert (index_type, CASE_HIGH (elt));
- else
- maxval = fold_convert (index_type, CASE_LOW (elt));
+ /* Remove all edges and do just an edge that will reach default_bb. */
+ bb = gimple_bb (m_switch);
+ gimple_stmt_iterator gsi = gsi_last_bb (bb);
+ gsi_remove (&gsi, true);
- /* Compute span of values. */
- range = fold_build2 (MINUS_EXPR, index_type, maxval, minval);
+ delete_basic_block (bb);
+}
- /* Listify the labels queue and gather some numbers to decide
- how to expand this switch. */
- uniq = 0;
- count = 0;
- hash_set<tree> seen_labels;
- compute_cases_per_edge (stmt);
+void
+switch_decision_tree::balance_case_nodes (case_tree_node **head,
+ case_tree_node *parent)
+{
+ case_tree_node *np;
- for (i = ncases - 1; i >= 1; --i)
+ np = *head;
+ if (np)
{
- elt = gimple_switch_label (stmt, i);
- tree low = CASE_LOW (elt);
- gcc_assert (low);
- tree high = CASE_HIGH (elt);
- gcc_assert (!high || tree_int_cst_lt (low, high));
- tree lab = CASE_LABEL (elt);
+ int i = 0;
+ int ranges = 0;
+ case_tree_node **npp;
+ case_tree_node *left;
- /* Count the elements.
- A range counts double, since it requires two compares. */
- count++;
- if (high)
- count++;
-
- /* If we have not seen this label yet, then increase the
- number of unique case node targets seen. */
- if (!seen_labels.add (lab))
- uniq++;
-
- /* The bounds on the case range, LOW and HIGH, have to be converted
- to case's index type TYPE. Note that the original type of the
- case index in the source code is usually "lost" during
- gimplification due to type promotion, but the case labels retain the
- original type. Make sure to drop overflow flags. */
- low = fold_convert (index_type, low);
- if (TREE_OVERFLOW (low))
- low = wide_int_to_tree (index_type, low);
-
- /* The canonical from of a case label in GIMPLE is that a simple case
- has an empty CASE_HIGH. For the casesi and tablejump expanders,
- the back ends want simple cases to have high == low. */
- if (!high)
- high = low;
- high = fold_convert (index_type, high);
- if (TREE_OVERFLOW (high))
- high = wide_int_to_tree (index_type, high);
+ /* Count the number of entries on branch. Also count the ranges. */
- basic_block case_bb = label_to_block_fn (cfun, lab);
- edge case_edge = find_edge (bb, case_bb);
- case_list = add_case_node (
- case_list, low, high, case_bb, lab,
- case_edge->probability.apply_scale (1, (intptr_t) (case_edge->aux)),
- case_node_pool);
+ while (np)
+ {
+ if (!tree_int_cst_equal (np->m_c->get_low (), np->m_c->get_high ()))
+ ranges++;
- case_bbs.safe_push (case_bb);
- }
- reset_out_edges_aux (bb);
- record_phi_operand_mapping (case_bbs, bb, &phi_mapping);
+ i++;
+ np = np->m_right;
+ }
- /* cleanup_tree_cfg removes all SWITCH_EXPR with a single
- destination, such as one with a default case only.
- It also removes cases that are out of range for the switch
- type, so we should never get a zero here. */
- gcc_assert (count > 0);
+ if (i > 2)
+ {
+ /* Split this list if it is long enough for that to help. */
+ npp = head;
+ left = *npp;
- /* Decide how to expand this switch.
- The two options at this point are a dispatch table (casesi or
- tablejump) or a decision tree. */
+ /* If there are just three nodes, split at the middle one. */
+ if (i == 3)
+ npp = &(*npp)->m_right;
+ else
+ {
+ /* Find the place in the list that bisects the list's total cost,
+ where ranges count as 2.
+ Here I gets half the total cost. */
+ i = (i + ranges + 1) / 2;
+ while (1)
+ {
+ /* Skip nodes while their cost does not reach that amount. */
+ if (!tree_int_cst_equal ((*npp)->m_c->get_low (),
+ (*npp)->m_c->get_high ()))
+ i--;
+ i--;
+ if (i <= 0)
+ break;
+ npp = &(*npp)->m_right;
+ }
+ }
+ *head = np = *npp;
+ *npp = 0;
+ np->m_parent = parent;
+ np->m_left = left;
- if (expand_switch_as_decision_tree_p (range, uniq, count))
- {
- emit_case_decision_tree (stmt, index_expr, index_type, case_list,
- default_bb, default_label, default_prob,
- &phi_mapping);
- return true;
+ /* Optimize each of the two split parts. */
+ balance_case_nodes (&np->m_left, np);
+ balance_case_nodes (&np->m_right, np);
+ np->m_c->m_subtree_prob = np->m_c->m_prob;
+ np->m_c->m_subtree_prob += np->m_left->m_c->m_subtree_prob;
+ np->m_c->m_subtree_prob += np->m_right->m_c->m_subtree_prob;
+ }
+ else
+ {
+ /* Else leave this branch as one level,
+ but fill in `parent' fields. */
+ np = *head;
+ np->m_parent = parent;
+ np->m_c->m_subtree_prob = np->m_c->m_prob;
+ for (; np->m_right; np = np->m_right)
+ {
+ np->m_right->m_parent = np;
+ (*head)->m_c->m_subtree_prob += np->m_right->m_c->m_subtree_prob;
+ }
+ }
}
+}
+
+gimple_opt_pass *
+make_pass_convert_switch (gcc::context *ctxt)
+{
+ return new pass_convert_switch (ctxt);
+}
+
+/* Dump ROOT, a list or tree of case nodes, to file. */
+
+void
+switch_decision_tree::dump_case_nodes (FILE *f, case_tree_node *root,
+ int indent_step, int indent_level)
+{
+ if (root == 0)
+ return;
+ indent_level++;
+
+ dump_case_nodes (f, root->m_left, indent_step, indent_level);
+
+ fputs (";; ", f);
+ fprintf (f, "%*s", indent_step * indent_level, "");
+ root->m_c->dump (f);
+ root->m_c->m_prob.dump (f);
+ fputs ("\n", f);
+
+ dump_case_nodes (f, root->m_right, indent_step, indent_level);
+}
- return false;
+void
+switch_decision_tree::emit_jump (basic_block bb, basic_block case_bb)
+{
+ edge e = single_succ_edge (bb);
+ redirect_edge_succ (e, case_bb);
}
/* The main function of the pass scans statements for switches and invokes
@@ -2200,23 +1839,35 @@ pass_lower_switch<O0>::execute (function *fun)
basic_block bb;
bool expanded = false;
+ auto_vec<gimple *> switch_statements;
+ switch_statements.create (1);
+
FOR_EACH_BB_FN (bb, fun)
{
gimple *stmt = last_stmt (bb);
if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
+ switch_statements.safe_push (stmt);
+ }
+
+ for (unsigned i = 0; i < switch_statements.length (); i++)
+ {
+ gimple *stmt = switch_statements[i];
+ if (dump_file)
{
- if (dump_file)
- {
- expanded_location loc = expand_location (gimple_location (stmt));
+ expanded_location loc = expand_location (gimple_location (stmt));
- fprintf (dump_file, "beginning to process the following "
- "SWITCH statement (%s:%d) : ------- \n",
- loc.file, loc.line);
- print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
- putc ('\n', dump_file);
- }
+ fprintf (dump_file, "beginning to process the following "
+ "SWITCH statement (%s:%d) : ------- \n",
+ loc.file, loc.line);
+ print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
+ putc ('\n', dump_file);
+ }
- expanded |= try_switch_expansion (as_a<gswitch *> (stmt));
+ gswitch *swtch = dyn_cast<gswitch *> (stmt);
+ if (swtch)
+ {
+ switch_decision_tree dt (swtch);
+ expanded |= dt.analyze_switch_statement ();
}
}
@@ -2243,31 +1894,15 @@ make_pass_lower_switch (gcc::context *ctxt)
return new pass_lower_switch<false> (ctxt);
}
-/* Generate code to compare X with Y so that the condition codes are
- set and to jump to LABEL if the condition is true. If X is a
- constant and Y is not a constant, then the comparison is swapped to
- ensure that the comparison RTL has the canonical form.
-
- UNSIGNEDP nonzero says that X and Y are unsigned; this matters if they
- need to be widened. UNSIGNEDP is also used to select the proper
- branch condition code.
-
- If X and Y have mode BLKmode, then SIZE specifies the size of both X and Y.
-
- MODE is the mode of the inputs (in case they are const_int).
-
- COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.).
- It will be potentially converted into an unsigned variant based on
- UNSIGNEDP to select a proper jump instruction.
-
- PROB is the probability of jumping to LABEL. */
-
-static basic_block
-emit_cmp_and_jump_insns (basic_block bb, tree op0, tree op1,
- tree_code comparison, basic_block label_bb,
- profile_probability prob,
- hash_map<tree, tree> *phi_mapping)
+basic_block
+switch_decision_tree::emit_cmp_and_jump_insns (basic_block bb, tree op0,
+ tree op1, tree_code comparison,
+ basic_block label_bb,
+ profile_probability prob)
{
+ // TODO: it's once called with lhs != index.
+ op1 = fold_convert (TREE_TYPE (op0), op1);
+
gcond *cond = gimple_build_cond (comparison, op0, op1, NULL_TREE, NULL_TREE);
gimple_stmt_iterator gsi = gsi_last_bb (bb);
gsi_insert_after (&gsi, cond, GSI_NEW_STMT);
@@ -2280,36 +1915,16 @@ emit_cmp_and_jump_insns (basic_block bb, tree op0, tree op1,
false_edge->probability = prob.invert ();
edge true_edge = make_edge (bb, label_bb, EDGE_TRUE_VALUE);
- fix_phi_operands_for_edge (true_edge, phi_mapping);
true_edge->probability = prob;
return false_edge->dest;
}
-/* Computes the conditional probability of jumping to a target if the branch
- instruction is executed.
- TARGET_PROB is the estimated probability of jumping to a target relative
- to some basic block BB.
- BASE_PROB is the probability of reaching the branch instruction relative
- to the same basic block BB. */
-
-static inline profile_probability
-conditional_probability (profile_probability target_prob,
- profile_probability base_prob)
-{
- return target_prob / base_prob;
-}
-
-/* Emit step-by-step code to select a case for the value of INDEX.
- The thus generated decision tree follows the form of the
- case-node binary tree NODE, whose nodes represent test conditions.
- INDEX_TYPE is the type of the index of the switch. */
-
-static basic_block
-emit_case_nodes (basic_block bb, tree index, case_node_ptr node,
- basic_block default_bb, tree default_label,
- profile_probability default_prob, tree index_type,
- hash_map<tree, tree> *phi_mapping)
+basic_block
+switch_decision_tree::emit_case_nodes (basic_block bb, tree index,
+ case_tree_node *node,
+ profile_probability default_prob,
+ tree index_type)
{
/* If node is null, we are done. */
if (node == NULL)
@@ -2321,34 +1936,31 @@ emit_case_nodes (basic_block bb, tree index, case_node_ptr node,
single_succ_edge (bb)->dest);
profile_probability probability
- = node->right ? node->right->subtree_prob : profile_probability::never ();
- probability
- = conditional_probability (probability + default_prob.apply_scale (1, 2),
- node->subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- test_bb, probability, phi_mapping);
+ = (node->m_right
+ ? node->m_right->m_c->m_subtree_prob : profile_probability::never ());
+ probability = ((probability + default_prob.apply_scale (1, 2))
+ / (node->m_c->m_subtree_prob + default_prob));
+ bb = emit_cmp_and_jump_insns (bb, index, node->m_c->get_high (), GT_EXPR,
+ test_bb, probability);
default_prob = default_prob.apply_scale (1, 2);
/* Value belongs to this node or to the left-hand subtree. */
- probability
- = conditional_probability (node->prob, node->subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->low, GE_EXPR,
- node->case_bb, probability,
- phi_mapping);
+ probability = node->m_c->m_prob /
+ (node->m_c->m_subtree_prob + default_prob);
+ bb = emit_cmp_and_jump_insns (bb, index, node->m_c->get_low (), GE_EXPR,
+ node->m_c->m_case_bb, probability);
/* Handle the left-hand subtree. */
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
+ bb = emit_case_nodes (bb, index, node->m_left,
+ default_prob, index_type);
/* If the left-hand subtree fell through,
don't let it fall into the right-hand subtree. */
- if (default_bb)
- emit_jump (bb, default_bb, phi_mapping);
+ if (m_default_bb)
+ emit_jump (bb, m_default_bb);
- bb = emit_case_nodes (test_bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
+ bb = emit_case_nodes (test_bb, index, node->m_right,
+ default_prob, index_type);
return bb;
}
diff --git a/gcc/tree-switch-conversion.h b/gcc/tree-switch-conversion.h
new file mode 100644
index 00000000000..45ae11f408d
--- /dev/null
+++ b/gcc/tree-switch-conversion.h
@@ -0,0 +1,806 @@
+/* Tree switch conversion for GNU compiler.
+ Copyright (C) 2017 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
+
+#ifndef TREE_SWITCH_CONVERSION_H
+#define TREE_SWITCH_CONVERSION_H
+
+namespace tree_switch_conversion {
+
+/* Type of cluster. */
+
+enum cluster_type
+{
+ SIMPLE_CASE,
+ JUMP_TABLE,
+ BIT_TEST
+};
+
+#define PRINT_CASE(f,c) print_dec (c, f, TYPE_SIGN (TREE_TYPE (c)))
+
+/* Base class for switch clustering. */
+
+struct cluster
+{
+ /* Cosntructor. */
+ cluster ()
+ {}
+
+ /* Constructor. */
+ cluster (tree case_label_expr, basic_block case_bb, profile_probability prob,
+ profile_probability subtree_prob);
+
+ /* Destructor. */
+ virtual ~cluster ()
+ {}
+
+ /* Return type. */
+ virtual cluster_type get_type () = 0;
+
+ /* Get low value covered by a cluster. */
+ virtual tree get_low () = 0;
+
+ /* Get high value covered by a cluster. */
+ virtual tree get_high () = 0;
+
+ /* Debug content of a cluster. */
+ virtual void debug () = 0;
+
+ /* Dump content of a cluster. */
+ virtual void dump (FILE *f) = 0;
+
+ /* Emit GIMPLE code to handle the cluster. */
+ virtual void emit (tree, tree, tree, basic_block)
+ {}
+
+ /* Return range of a cluster. */
+ static unsigned HOST_WIDE_INT get_range (tree low, tree high)
+ {
+ tree unsigned_type = unsigned_type_for (TREE_TYPE (low));
+ tree r = fold_build2 (MINUS_EXPR, unsigned_type, high, low);
+
+ return tree_to_uhwi (r) + 1;
+ }
+
+ /* Case label. */
+ tree m_case_label_expr;
+
+ /* Basic block of the case. */
+ basic_block m_case_bb;
+
+ /* Probability of taking this cluster. */
+ profile_probability m_prob;
+
+ /* Probability of reaching subtree rooted at this node. */
+ profile_probability m_subtree_prob;
+};
+
+cluster::cluster (tree case_label_expr, basic_block case_bb,
+ profile_probability prob, profile_probability subtree_prob):
+ m_case_label_expr (case_label_expr), m_case_bb (case_bb), m_prob (prob),
+ m_subtree_prob (subtree_prob)
+{
+}
+
+struct simple_cluster: public cluster
+{
+ /* Constructor. */
+ simple_cluster (tree low, tree high, tree case_label_expr,
+ basic_block case_bb, profile_probability prob);
+
+ /* Destructor. */
+ virtual ~simple_cluster ()
+ {}
+
+ virtual cluster_type
+ get_type ()
+ {
+ return SIMPLE_CASE;
+ }
+
+ virtual tree
+ get_low ()
+ {
+ return m_low;
+ }
+
+ virtual tree
+ get_high ()
+ {
+ return m_high;
+ }
+
+ virtual void
+ debug ()
+ {
+ dump (stderr);
+ }
+
+ virtual void
+ dump (FILE *f)
+ {
+ PRINT_CASE (f, get_low ());
+ if (get_low () != get_high ())
+ {
+ fprintf (f, "-");
+ PRINT_CASE (f, get_high ());
+ }
+ fprintf (f, " ");
+ }
+
+ /* Low value of the case. */
+ tree m_low;
+
+ /* High value of the case. */
+ tree m_high;
+};
+
+simple_cluster::simple_cluster (tree low, tree high, tree case_label_expr,
+ basic_block case_bb, profile_probability prob):
+ cluster (case_label_expr, case_bb, prob, prob),
+ m_low (low), m_high (high)
+{
+}
+
+struct group_cluster: public cluster
+{
+ /* Destructor. */
+ virtual ~group_cluster ();
+
+ virtual tree
+ get_low ()
+ {
+ return m_cases[0]->get_low ();
+ }
+
+ virtual tree
+ get_high ()
+ {
+ return m_cases[m_cases.length () - 1]->get_high ();
+ }
+
+ virtual void
+ debug ()
+ {
+ dump (stderr);
+ }
+
+ virtual void
+ dump (FILE *f)
+ {
+ unsigned total_values = 0;
+ for (unsigned i = 0; i < m_cases.length (); i++)
+ total_values += m_cases[i]->get_range (m_cases[i]->get_low (),
+ m_cases[i]->get_high ());
+
+ fprintf (f, "%s(%d):", get_type () == JUMP_TABLE ? "JT" : "BT",
+ total_values);
+ PRINT_CASE (f, get_low ());
+ fprintf (f, "-");
+ PRINT_CASE (f, get_high ());
+ fprintf (f, " ");
+ }
+
+ /* List of simple clusters handled by the group. */
+ vec<simple_cluster *> m_cases;
+};
+
+struct jump_table_cluster: public group_cluster
+{
+ /* Constructor. */
+ jump_table_cluster (vec<cluster *> &clusters, unsigned start, unsigned end);
+
+ virtual cluster_type
+ get_type ()
+ {
+ return JUMP_TABLE;
+ }
+
+ virtual void emit (tree index_expr, tree index_type,
+ tree default_label_expr, basic_block default_bb);
+
+ /* Find jump tables of given CLUSTERS, where all members of the vector
+ are of type simple_cluster. New clusters are returned. */
+ static vec<cluster *> find_jump_tables (vec<cluster *> &clusters);
+
+ /* Return true when cluster starting at START and ending at END (inclusive)
+ can build a jump-table. */
+ static bool can_be_handled (const vec<cluster *> &clusters, unsigned start,
+ unsigned end);
+
+ /* Return true if cluster starting at START and ending at END (inclusive)
+ is profitable transformation. */
+ static bool is_beneficial (const vec<cluster *> &clusters, unsigned start,
+ unsigned end);
+
+ /* Return the smallest number of different values for which it is best
+ to use a jump-table instead of a tree of conditional branches. */
+ static inline unsigned int case_values_threshold (void);
+};
+
+/* A GIMPLE switch statement can be expanded to a short sequence of bit-wise
+comparisons. "switch(x)" is converted into "if ((1 << (x-MINVAL)) & CST)"
+where CST and MINVAL are integer constants. This is better than a series
+of compare-and-banch insns in some cases, e.g. we can implement:
+
+ if ((x==4) || (x==6) || (x==9) || (x==11))
+
+as a single bit test:
+
+ if ((1<<x) & ((1<<4)|(1<<6)|(1<<9)|(1<<11)))
+
+This transformation is only applied if the number of case targets is small,
+if CST constains at least 3 bits, and "1 << x" is cheap. The bit tests are
+performed in "word_mode".
+
+The following example shows the code the transformation generates:
+
+ int bar(int x)
+ {
+ switch (x)
+ {
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ case 'A': case 'B': case 'C': case 'D': case 'E':
+ case 'F':
+ return 1;
+ }
+ return 0;
+ }
+
+==>
+
+ bar (int x)
+ {
+ tmp1 = x - 48;
+ if (tmp1 > (70 - 48)) goto L2;
+ tmp2 = 1 << tmp1;
+ tmp3 = 0b11111100000001111111111;
+ if ((tmp2 & tmp3) != 0) goto L1 ; else goto L2;
+ L1:
+ return 1;
+ L2:
+ return 0;
+ }
+
+TODO: There are still some improvements to this transformation that could
+be implemented:
+
+* A narrower mode than word_mode could be used if that is cheaper, e.g.
+ for x86_64 where a narrower-mode shift may result in smaller code.
+
+* The compounded constant could be shifted rather than the one. The
+ test would be either on the sign bit or on the least significant bit,
+ depending on the direction of the shift. On some machines, the test
+ for the branch would be free if the bit to test is already set by the
+ shift operation.
+
+This transformation was contributed by Roger Sayle, see this e-mail:
+ http://gcc.gnu.org/ml/gcc-patches/2003-01/msg01950.html
+*/
+
+struct bit_test_cluster: public group_cluster
+{
+ /* Constructor. */
+ bit_test_cluster (vec<cluster *> &clusters, unsigned start, unsigned end);
+
+ virtual cluster_type
+ get_type ()
+ {
+ return BIT_TEST;
+ }
+
+/* Expand a switch statement by a short sequence of bit-wise
+ comparisons. "switch(x)" is effectively converted into
+ "if ((1 << (x-MINVAL)) & CST)" where CST and MINVAL are
+ integer constants.
+
+ INDEX_EXPR is the value being switched on.
+
+ MINVAL is the lowest case value of in the case nodes,
+ and RANGE is highest value minus MINVAL. MINVAL and RANGE
+ are not guaranteed to be of the same type as INDEX_EXPR
+ (the gimplifier doesn't change the type of case label values,
+ and MINVAL and RANGE are derived from those values).
+ MAXVAL is MINVAL + RANGE.
+
+ There *MUST* be max_case_bit_tests or less unique case
+ node targets. */
+ virtual void emit (tree index_expr, tree index_type,
+ tree default_label_expr, basic_block default_bb);
+
+ /* Find bit tests of given CLUSTERS, where all members of the vector
+ are of type simple_cluster. New clusters are returned. */
+ static vec<cluster *> find_bit_tests (vec<cluster *> &clusters);
+
+ /* Return true when cluster starting at START and ending at END (inclusive)
+ can build a bit test. */
+ static bool can_be_handled (const vec<cluster *> &clusters, unsigned start,
+ unsigned end);
+
+ /* Return true if cluster starting at START and ending at END (inclusive)
+ is profitable transformation. */
+ static bool is_beneficial (const vec<cluster *> &clusters, unsigned start,
+ unsigned end);
+
+/* Split the basic block at the statement pointed to by GSIP, and insert
+ a branch to the target basic block of E_TRUE conditional on tree
+ expression COND.
+
+ It is assumed that there is already an edge from the to-be-split
+ basic block to E_TRUE->dest block. This edge is removed, and the
+ profile information on the edge is re-used for the new conditional
+ jump.
+
+ The CFG is updated. The dominator tree will not be valid after
+ this transformation, but the immediate dominators are updated if
+ UPDATE_DOMINATORS is true.
+
+ Returns the newly created basic block. */
+ static basic_block hoist_edge_and_branch_if_true (gimple_stmt_iterator *gsip,
+ tree cond,
+ basic_block case_bb);
+
+ /* Maximum number of different basic blocks that can be handlel by
+ a bit test. */
+ static const int m_max_case_bit_tests = 3;
+};
+
+/* Helper struct to find minimal clusters. */
+
+struct min_cluster_item
+{
+ /* Constructor. */
+ min_cluster_item (unsigned count, unsigned start, unsigned non_jt_cases):
+ m_count (count), m_start (start), m_non_jt_cases (non_jt_cases)
+ {}
+
+ /* Count of clusters. */
+ unsigned m_count;
+
+ /* Index where is cluster boundary. */
+ unsigned m_start;
+
+ /* Total number of cases that will not be in a jump table. */
+ unsigned m_non_jt_cases;
+};
+
+/* Helper struct to represent switch decision tree. */
+
+struct case_tree_node
+{
+ /* Empty Constructor. */
+ case_tree_node ();
+
+ /* Left son in binary tree. */
+ case_tree_node *m_left;
+
+ /* Right son in binary tree; also node chain. */
+ case_tree_node *m_right;
+
+ /* Parent of node in binary tree. */
+ case_tree_node *m_parent;
+
+ /* Cluster represented by this tree node. */
+ cluster *m_c;
+};
+
+inline
+case_tree_node::case_tree_node ():
+ m_left (NULL), m_right (NULL), m_parent (NULL), m_c (NULL)
+{
+}
+
+unsigned int
+jump_table_cluster::case_values_threshold (void)
+{
+ unsigned int threshold = PARAM_VALUE (PARAM_CASE_VALUES_THRESHOLD);
+
+ if (threshold == 0)
+ threshold = targetm.case_values_threshold ();
+
+ return threshold;
+}
+
+/* A case_bit_test represents a set of case nodes that may be
+ selected from using a bit-wise comparison. HI and LO hold
+ the integer to be tested against, TARGET_EDGE contains the
+ edge to the basic block to jump to upon success and BITS
+ counts the number of case nodes handled by this test,
+ typically the number of bits set in HI:LO. The LABEL field
+ is used to quickly identify all cases in this set without
+ looking at label_to_block for every case label. */
+
+struct case_bit_test
+{
+ wide_int mask;
+ basic_block target_bb;
+ tree label;
+ int bits;
+
+ /* Comparison function for qsort to order bit tests by decreasing
+ probability of execution. */
+ static int cmp (const void *p1, const void *p2);
+};
+
+struct switch_decision_tree
+{
+ /* Constructor. */
+ switch_decision_tree (gswitch *swtch): m_switch (swtch), m_phi_mapping (),
+ m_case_bbs (), m_case_node_pool ("struct case_node pool"),
+ m_case_list (NULL)
+ {
+ }
+
+ /* Analyze switch statement and return true when the statement is expanded
+ as decision tree. */
+ bool analyze_switch_statement ();
+
+ /* Attempt to expand CLUSTERS as a decision tree. Return true when
+ expanded. */
+ bool try_switch_expansion (vec<cluster *> &clusters);
+
+ /* Reset the aux field of all outgoing edges of switch basic block. */
+ inline void reset_out_edges_aux ();
+
+ /* Compute the number of case labels that correspond to each outgoing edge of
+ switch statement. Record this information in the aux field of the edge.
+ */
+ void compute_cases_per_edge ();
+
+ /* Before switch transformation, record all SSA_NAMEs defined in switch BB
+ and used in a label basic block. */
+ void record_phi_operand_mapping ();
+
+ /* Append new operands to PHI statements that were introduced due to
+ addition of new edges to case labels. */
+ void fix_phi_operands_for_edges ();
+
+ /* Generate a decision tree, switching on INDEX_EXPR and jumping to
+ one of the labels in CASE_LIST or to the DEFAULT_LABEL.
+
+ We generate a binary decision tree to select the appropriate target
+ code. */
+
+ void emit (basic_block bb, tree index_expr,
+ profile_probability default_prob, tree index_type);
+
+ /* Emit step-by-step code to select a case for the value of INDEX.
+ The thus generated decision tree follows the form of the
+ case-node binary tree NODE, whose nodes represent test conditions.
+ DEFAULT_PROB is probability of cases leading to default BB.
+ INDEX_TYPE is the type of the index of the switch. */
+ basic_block emit_case_nodes (basic_block bb, tree index,
+ case_tree_node *node,
+ profile_probability default_prob,
+ tree index_type);
+
+ /* Take an ordered list of case nodes
+ and transform them into a near optimal binary tree,
+ on the assumption that any target code selection value is as
+ likely as any other.
+
+ The transformation is performed by splitting the ordered
+ list into two equal sections plus a pivot. The parts are
+ then attached to the pivot as left and right branches. Each
+ branch is then transformed recursively. */
+ static void balance_case_nodes (case_tree_node **head,
+ case_tree_node *parent);
+
+ /* Dump ROOT, a list or tree of case nodes, to file F. */
+ static void dump_case_nodes (FILE *f, case_tree_node *root, int indent_step,
+ int indent_level);
+
+ /* Add an unconditional jump to CASE_BB that happens in basic block BB. */
+ static void emit_jump (basic_block bb, basic_block case_bb);
+
+ /* Generate code to compare OP0 with OP1 so that the condition codes are
+ set and to jump to LABEL_BB if the condition is true.
+ COMPARISON is the GIMPLE comparison (EQ, NE, GT, etc.).
+ PROB is the probability of jumping to LABEL_BB. */
+
+ static basic_block emit_cmp_and_jump_insns (basic_block bb, tree op0,
+ tree op1, tree_code comparison,
+ basic_block label_bb,
+ profile_probability prob);
+
+ /* Switch statement. */
+ gswitch *m_switch;
+
+ /* Map of PHI nodes that have to be fixed after expansion. */
+ hash_map<tree, tree> m_phi_mapping;
+
+ /* List of basic blocks that belong to labels of the switch. */
+ auto_vec<basic_block> m_case_bbs;
+
+ /* Basic block with default label. */
+ basic_block m_default_bb;
+
+ /* A pool for case nodes. */
+ object_allocator<case_tree_node> m_case_node_pool;
+
+ /* Balanced tree of case nodes. */
+ case_tree_node *m_case_list;
+};
+
+/*
+ Switch initialization conversion
+
+The following pass changes simple initializations of scalars in a switch
+statement into initializations from a static array. Obviously, the values
+must be constant and known at compile time and a default branch must be
+provided. For example, the following code:
+
+ int a,b;
+
+ switch (argc)
+ {
+ case 1:
+ case 2:
+ a_1 = 8;
+ b_1 = 6;
+ break;
+ case 3:
+ a_2 = 9;
+ b_2 = 5;
+ break;
+ case 12:
+ a_3 = 10;
+ b_3 = 4;
+ break;
+ default:
+ a_4 = 16;
+ b_4 = 1;
+ break;
+ }
+ a_5 = PHI <a_1, a_2, a_3, a_4>
+ b_5 = PHI <b_1, b_2, b_3, b_4>
+
+
+is changed into:
+
+ static const int = CSWTCH01[] = {6, 6, 5, 1, 1, 1, 1, 1, 1, 1, 1, 4};
+ static const int = CSWTCH02[] = {8, 8, 9, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 10};
+
+ if (((unsigned) argc) - 1 < 11)
+ {
+ a_6 = CSWTCH02[argc - 1];
+ b_6 = CSWTCH01[argc - 1];
+ }
+ else
+ {
+ a_7 = 16;
+ b_7 = 1;
+ }
+ a_5 = PHI <a_6, a_7>
+ b_b = PHI <b_6, b_7>
+
+There are further constraints. Specifically, the range of values across all
+case labels must not be bigger than SWITCH_CONVERSION_BRANCH_RATIO (default
+eight) times the number of the actual switch branches.
+
+This transformation was contributed by Martin Jambor, see this e-mail:
+ http://gcc.gnu.org/ml/gcc-patches/2008-07/msg00011.html */
+
+/* The main structure of the pass. */
+struct switch_conversion
+{
+ /* Constructor. */
+ switch_conversion ();
+
+ /* Destructor. */
+ ~switch_conversion ();
+
+ /* The following function is invoked on every switch statement (the current
+ one is given in SWTCH) and runs the individual phases of switch
+ conversion on it one after another until one fails or the conversion
+ is completed. Returns NULL on success, or a pointer to a string
+ with the reason why the conversion failed. */
+ const char *expand (gswitch *swtch);
+
+ /* Collection information about SWTCH statement. */
+ void collect (gswitch *swtch);
+
+ /* Checks whether the range given by individual case statements of the switch
+ switch statement isn't too big and whether the number of branches actually
+ satisfies the size of the new array. */
+ bool check_range ();
+
+ /* Checks whether all but the final BB basic blocks are empty. */
+ bool check_all_empty_except_final ();
+
+ /* This function checks whether all required values in phi nodes in final_bb
+ are constants. Required values are those that correspond to a basic block
+ which is a part of the examined switch statement. It returns true if the
+ phi nodes are OK, otherwise false. */
+ bool check_final_bb ();
+
+ /* The following function allocates default_values, target_{in,out}_names and
+ constructors arrays. The last one is also populated with pointers to
+ vectors that will become constructors of new arrays. */
+ void create_temp_arrays ();
+
+ /* Populate the array of default values in the order of phi nodes.
+ DEFAULT_CASE is the CASE_LABEL_EXPR for the default switch branch
+ if the range is non-contiguous or the default case has standard
+ structure, otherwise it is the first non-default case instead. */
+ void gather_default_values (tree default_case);
+
+ /* The following function populates the vectors in the constructors array with
+ future contents of the static arrays. The vectors are populated in the
+ order of phi nodes. */
+ void build_constructors ();
+
+ /* If all values in the constructor vector are the same, return the value.
+ Otherwise return NULL_TREE. Not supposed to be called for empty
+ vectors. */
+ tree contains_same_values_p (vec<constructor_elt, va_gc> *vec);
+
+ /* Return type which should be used for array elements, either TYPE's
+ main variant or, for integral types, some smaller integral type
+ that can still hold all the constants. */
+ tree array_value_type (tree type, int num);
+
+ /* Create an appropriate array type and declaration and assemble a static
+ array variable. Also create a load statement that initializes
+ the variable in question with a value from the static array. SWTCH is
+ the switch statement being converted, NUM is the index to
+ arrays of constructors, default values and target SSA names
+ for this particular array. ARR_INDEX_TYPE is the type of the index
+ of the new array, PHI is the phi node of the final BB that corresponds
+ to the value that will be loaded from the created array. TIDX
+ is an ssa name of a temporary variable holding the index for loads from the
+ new array. */
+ void build_one_array (int num, tree arr_index_type,
+ gphi *phi, tree tidx);
+
+ /* Builds and initializes static arrays initialized with values gathered from
+ the switch statement. Also creates statements that load values from
+ them. */
+ void build_arrays ();
+
+ /* Generates and appropriately inserts loads of default values at the position
+ given by GSI. Returns the last inserted statement. */
+ gassign *gen_def_assigns (gimple_stmt_iterator *gsi);
+
+ /* Deletes the unused bbs and edges that now contain the switch statement and
+ its empty branch bbs. BBD is the now dead BB containing
+ the original switch statement, FINAL is the last BB of the converted
+ switch statement (in terms of succession). */
+ void prune_bbs (basic_block bbd, basic_block final, basic_block default_bb);
+
+ /* Add values to phi nodes in final_bb for the two new edges. E1F is the edge
+ from the basic block loading values from an array and E2F from the basic
+ block loading default values. BBF is the last switch basic block (see the
+ bbf description in the comment below). */
+ void fix_phi_nodes (edge e1f, edge e2f, basic_block bbf);
+
+ /* Creates a check whether the switch expression value actually falls into the
+ range given by all the cases. If it does not, the temporaries are loaded
+ with default values instead. SWTCH is the switch statement being
+ converted.
+
+ bb0 is the bb with the switch statement, however, we'll end it with a
+ condition instead.
+
+ bb1 is the bb to be used when the range check went ok. It is derived from
+ the switch BB
+
+ bb2 is the bb taken when the expression evaluated outside of the range
+ covered by the created arrays. It is populated by loads of default
+ values.
+
+ bbF is a fall through for both bb1 and bb2 and contains exactly what
+ originally followed the switch statement.
+
+ bbD contains the switch statement (in the end). It is unreachable but we
+ still need to strip off its edges. */
+ void gen_inbound_check ();
+
+ /* Switch statement for which switch conversion takes place. */
+ gswitch *m_switch;
+
+ /* The expression used to decide the switch branch. */
+ tree m_index_expr;
+
+ /* The following integer constants store the minimum and maximum value
+ covered by the case labels. */
+ tree m_range_min;
+ tree m_range_max;
+
+ /* The difference between the above two numbers. Stored here because it
+ is used in all the conversion heuristics, as well as for some of the
+ transformation, and it is expensive to re-compute it all the time. */
+ tree m_range_size;
+
+ /* Basic block that contains the actual GIMPLE_SWITCH. */
+ basic_block m_switch_bb;
+
+ /* Basic block that is the target of the default case. */
+ basic_block m_default_bb;
+
+ /* The single successor block of all branches out of the GIMPLE_SWITCH,
+ if such a block exists. Otherwise NULL. */
+ basic_block m_final_bb;
+
+ /* The probability of the default edge in the replaced switch. */
+ profile_probability m_default_prob;
+
+ /* The count of the default edge in the replaced switch. */
+ profile_count m_default_count;
+
+ /* Combined count of all other (non-default) edges in the replaced switch. */
+ profile_count m_other_count;
+
+ /* Number of phi nodes in the final bb (that we'll be replacing). */
+ int m_phi_count;
+
+ /* Constructors of new static arrays. */
+ vec<constructor_elt, va_gc> **m_constructors;
+
+ /* Array of default values, in the same order as phi nodes. */
+ tree *m_default_values;
+
+ /* Array of ssa names that are initialized with a value from a new static
+ array. */
+ tree *m_target_inbound_names;
+
+ /* Array of ssa names that are initialized with the default value if the
+ switch expression is out of range. */
+ tree *m_target_outbound_names;
+
+ /* VOP SSA_NAME. */
+ tree m_target_vop;
+
+ /* The first load statement that loads a temporary from a new static array.
+ */
+ gimple *m_arr_ref_first;
+
+ /* The last load statement that loads a temporary from a new static array. */
+ gimple *m_arr_ref_last;
+
+ /* String reason why the case wasn't a good candidate that is written to the
+ dump file, if there is one. */
+ const char *m_reason;
+
+ /* True if default case is not used for any value between range_min and
+ range_max inclusive. */
+ bool m_contiguous_range;
+
+ /* True if default case does not have the required shape for other case
+ labels. */
+ bool m_default_case_nonstandard;
+
+ /* Count is number of non-default edges. */
+ unsigned int m_count;
+};
+
+void
+switch_decision_tree::reset_out_edges_aux ()
+{
+ basic_block bb = gimple_bb (m_switch);
+ edge e;
+ edge_iterator ei;
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ e->aux = (void *) 0;
+}
+
+} // tree_switch_conversion namespace
+
+#endif // TREE_SWITCH_CONVERSION_H
diff --git a/gcc/vec.h b/gcc/vec.h
index cbdd439571b..72a9f4b106a 100644
--- a/gcc/vec.h
+++ b/gcc/vec.h
@@ -1263,6 +1263,7 @@ public:
T *bsearch (const void *key, int (*compar)(const void *, const void *));
unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
bool contains (const T &search) const;
+ void reverse (void);
bool using_auto_storage () const;
@@ -1774,6 +1775,19 @@ vec<T, va_heap, vl_ptr>::contains (const T &search) const
return m_vec ? m_vec->contains (search) : false;
}
+/* Reverse content of the vector. */
+
+template<typename T>
+inline void
+vec<T, va_heap, vl_ptr>::reverse (void)
+{
+ unsigned l = length ();
+ T *ptr = address ();
+
+ for (unsigned i = 0; i < l / 2; i++)
+ std::swap (ptr[i], ptr[l - i - 1]);
+}
+
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::using_auto_storage () const
--
2.14.2
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH] Add selftest for vec::reverse
2017-10-06 12:26 ` [PATCH] Implement smart multiple switch expansion algorithms Martin Liška
@ 2017-10-06 16:20 ` David Malcolm
2017-12-29 14:39 ` Martin Liška
2017-10-06 17:24 ` [PATCH] Implement smart multiple switch expansion algorithms David Malcolm
1 sibling, 1 reply; 28+ messages in thread
From: David Malcolm @ 2017-10-06 16:20 UTC (permalink / raw)
To: Martin Liška, Jeff Law, gcc-patches; +Cc: Jan Hubicka, David Malcolm
Martin: I noticed that your switch expansion patch added a
vec::reverse ()
method. Here's a proposed selftest for it, mostly to verify
that it handles even vs odd lengths (which it does).
Only lightly tested; hope this is useful.
Dave
gcc/ChangeLog:
* vec.c (selftest::test_reverse): New function.
(selftest::vec_c_tests): Call it.
---
gcc/vec.c | 38 ++++++++++++++++++++++++++++++++++++++
1 file changed, 38 insertions(+)
diff --git a/gcc/vec.c b/gcc/vec.c
index d612703..5d70973 100644
--- a/gcc/vec.c
+++ b/gcc/vec.c
@@ -359,6 +359,43 @@ test_qsort ()
ASSERT_EQ (10, v.length ());
}
+/* Verify that vec::reverse works correctly. */
+
+static void
+test_reverse ()
+{
+ /* Reversing an empty vec ought to be a no-op. */
+ {
+ auto_vec <int> v;
+ ASSERT_EQ (0, v.length ());
+ v.reverse ();
+ ASSERT_EQ (0, v.length ());
+ }
+
+ /* Verify reversing a vec with even length. */
+ {
+ auto_vec <int> v;
+ safe_push_range (v, 0, 4);
+ v.reverse ();
+ ASSERT_EQ (3, v[0]);
+ ASSERT_EQ (2, v[1]);
+ ASSERT_EQ (1, v[2]);
+ ASSERT_EQ (0, v[3]);
+ ASSERT_EQ (4, v.length ());
+ }
+
+ /* Verify reversing a vec with odd length. */
+ {
+ auto_vec <int> v;
+ safe_push_range (v, 0, 3);
+ v.reverse ();
+ ASSERT_EQ (2, v[0]);
+ ASSERT_EQ (1, v[1]);
+ ASSERT_EQ (0, v[2]);
+ ASSERT_EQ (3, v.length ());
+ }
+}
+
/* Run all of the selftests within this file. */
void
@@ -374,6 +411,7 @@ vec_c_tests ()
test_unordered_remove ();
test_block_remove ();
test_qsort ();
+ test_reverse ();
}
} // namespace selftest
--
1.8.5.3
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH] Implement smart multiple switch expansion algorithms.
2017-10-06 12:26 ` [PATCH] Implement smart multiple switch expansion algorithms Martin Liška
2017-10-06 16:20 ` [PATCH] Add selftest for vec::reverse David Malcolm
@ 2017-10-06 17:24 ` David Malcolm
2017-12-29 14:38 ` Martin Liška
1 sibling, 1 reply; 28+ messages in thread
From: David Malcolm @ 2017-10-06 17:24 UTC (permalink / raw)
To: Martin Liška, Jeff Law, gcc-patches; +Cc: Jan Hubicka
On Fri, 2017-10-06 at 14:25 +0200, Martin Liška wrote:
> Hello.
>
> As presented at this year's Cauldron, I rewrote current switch
> expansion to support
> multiple algorithms (jump table and bit-test) that can be used just
> for a fraction
> of cases. Balanced decision tree is built on top of that. I decided
> to do a bigger
> refactoring and put all there 3 mentioned algorithm to its own class.
>
> There's a bigger change in jump_table_cluster::can_be_handled where
> the constant 10 (3 respectively)
> is compared to number of handled values, and not number of cases.
> Later one is wrong in my opinion.
>
> There are some numbers for cc1plus:
>
> $ bloaty ./objdir2/gcc/cc1plus -- ./objdir/gcc/cc1plus
> VM SIZE FILE SIZE
> ++++++++++++++ GROWING ++++++++++++++
> +19% +1.32Mi .rodata +1.32Mi +19%
> [ = ] 0 .symtab +7.38Ki +0.5%
> [ = ] 0 .strtab +5.18Ki +0.2%
> [ = ] 0 .debug_info +743 +0.0%
> +0.0% +712 .eh_frame +712 +0.0%
> +0.1% +440 .eh_frame_hdr +440 +0.1%
> [ = ] 0 .debug_aranges +80 +0.1%
> +0.0% +67 .dynstr +67 +0.0%
> [ = ] 0 .debug_str +6 +0.0%
>
> -------------- SHRINKING --------------
> -1.2% -214Ki .text -214Ki -1.2%
> [ = ] 0 .debug_loc -66.7Ki -0.1%
> [ = ] 0 .debug_line -14.0Ki -0.2%
> [ = ] 0 .debug_ranges -9.56Ki -0.1%
> -6.8% -3 [Unmapped] -375 -14.4%
> [ = ] 0 .debug_abbrev -46 -0.0%
>
> +3.8% +1.11Mi TOTAL +1.03Mi +0.5%
>
> So it growth and can be easily explained:
>
> insn-attrtab.o:
> VM SIZE FILE SIZE
> ++++++++++++++ GROWING ++++++++++++++
> [ = ] 0 .rela.rodata +2.00Mi +215%
> +214% +682Ki .rodata +682Ki +214%
> [ = ] 0 .rela.debug_loc +29.3Ki +36%
> +32% +1.91Ki .eh_frame +1.91Ki +32%
> [ = ] 0 .debug_loc +37 +5.6%
> [ = ] 0 .debug_str +2 +0.0%
>
> -------------- SHRINKING --------------
> -50.1% -63.3Ki .text -63.3Ki -50.1%
> [ = ] 0 .debug_line -1.71Ki -10.4%
> [ = ] 0 .rela.debug_info -768 -0.3%
> [ = ] 0 .rela.text -624 -0.8%
> [ = ] 0 .rela.debug_ranges -384 -2.7%
> [ = ] 0 .debug_info -87 -0.2%
> [ = ] 0 [Unmapped] -2 -8.7%
>
> +137% +621Ki TOTAL +2.63Mi +139%
>
> It's caused by:
> ...
> ;; GIMPLE switch case clusters: JT(2710):-1-5090
> ;; GIMPLE switch case clusters: JT(2710):-1-5090
> ;; GIMPLE switch case clusters: JT(2967):-1-5090
> ;; GIMPLE switch case clusters: JT(1033):-1-5017
> ...
>
> so there are many switch statements with very reasonable density.
>
> and
> insn-dfatab.o: +13% +99.4Ki TOTAL +455Ki +14%
> insn-latencytab.o: +19% +136Ki TOTAL +609Ki +20%
>
> There shouldn't be any fallout other from what I mentioned in
> previous email that is
> a prerequisite for this patch.
>
> Patch can bootstrap on ppc64le-redhat-linux and survives regression
> tests.
>
> I'm still planning to come with some numbers and stats. Will do that
> next week.
>
> Martin
> gcc/ChangeLog:
>
> 2017-09-29 Martin Liska <mliska@suse.cz>
>
> * tree-switch-conversion.c (MAX_CASE_BIT_TESTS): Remove and move
> to header file.
> (hoist_edge_and_branch_if_true): Move to ...
> (bit_test_cluster::hoist_edge_and_branch_if_true): ... this.
I'm not a reviewer, but there's a lot of "churn" in the patch due to
things moving around; there seems to be a mixture of things simply
moving around, functions becoming methods of classes, and some
things changing.
Would it be helpful to split the patch into two: a patch that moves
the functions to where they'll be needed, and then a patch to do the
"actual" (or functional) changes?
[...snip...]
> diff --git a/gcc/tree-switch-conversion.h b/gcc/tree-switch-conversion.h
> new file mode 100644
> index 00000000000..45ae11f408d
> --- /dev/null
> +++ b/gcc/tree-switch-conversion.h
> @@ -0,0 +1,806 @@
> +/* Tree switch conversion for GNU compiler.
> + Copyright (C) 2017 Free Software Foundation, Inc.
Should this be "gimple switch conversion" and
gimple-ssa-switch-conversion.h?
(but presumably this is to mirror tree-switch-conversion.c, and
I don't want to advocate for unnecessary churn)
> +This file is part of GCC.
> +
> +GCC is free software; you can redistribute it and/or modify it under
> +the terms of the GNU General Public License as published by the Free
> +Software Foundation; either version 3, or (at your option) any later
> +version.
> +
> +GCC is distributed in the hope that it will be useful, but WITHOUT ANY
> +WARRANTY; without even the implied warranty of MERCHANTABILITY or
> +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
> +for more details.
> +
> +You should have received a copy of the GNU General Public License
> +along with GCC; see the file COPYING3. If not see
> +<http://www.gnu.org/licenses/>. */
> +
> +#ifndef TREE_SWITCH_CONVERSION_H
> +#define TREE_SWITCH_CONVERSION_H
> +
> +namespace tree_switch_conversion {
> +
> +/* Type of cluster. */
> +
> +enum cluster_type
> +{
> + SIMPLE_CASE,
> + JUMP_TABLE,
> + BIT_TEST
> +};
> +
> +#define PRINT_CASE(f,c) print_dec (c, f, TYPE_SIGN (TREE_TYPE (c)))
> +
> +/* Base class for switch clustering. */
Maybe "Abstract base class for representing a cluster of cases", or
somesuch?
Perhaps an ASCII art inheritance diagram; if I'm reading the code
right, something like:
/* Abstract base class for representing a cluster of cases.
Here is the inheritance hierarachy, and the enum_cluster_type
values for the concrete subclasses:
cluster
|-simple_cluster (SIMPLE_CASE)
`-group_cluster
|-jump_table_cluster (JUMP_TABLE)
`-bit_test_cluster (BIT_TEST). */
Am I right in thinking that the switch initialization conversion
(struct switch_conversion) is currently distinct from the clustering
in this patch? (I'm wondering if there's possible benefit from
combining the two approaches, maybe if one cluster of cases
predominantly assigns to some variables, and another cluster of
cases predominantly assigns to some other variables).
> +
> +struct cluster
> +{
> + /* Cosntructor. */
^^^ Typo
> + cluster ()
> + {}
When is this default ctor used?
Doesn't it leave the various fields uninitialized?
I notice that of the descendant classes, at least jump_table_cluster
doesn't call its base class ctor (if I'm reading the patch right), so I
believe these fields are uninitialized for some of the subclasses.
> +
> + /* Constructor. */
> + cluster (tree case_label_expr, basic_block case_bb, profile_probability prob,
> + profile_probability subtree_prob);
> +
[...snip...]
> +struct simple_cluster: public cluster
> +{
Could this struct have a descriptive comment? e.g.
/* Subclass of cluster representing a simple contiguous range
from [low..high]. */
or somesuch (assuming I've read the intent correctly)
> + /* Constructor. */
> + simple_cluster (tree low, tree high, tree case_label_expr,
> + basic_block case_bb, profile_probability prob);
> +
> + /* Destructor. */
> + virtual ~simple_cluster ()
> + {}
> +
> + virtual cluster_type
> + get_type ()
> + {
> + return SIMPLE_CASE;
> + }
I believe that the "virtual" here is redundant, but that it ought to say
get_type () OVERRIDE FINAL
so tell human readers that it's a vfunc override, and so that C++11
onwards can warn if it's not actually a vfunc override.
> + virtual tree
> + get_low ()
> + {
> + return m_low;
> + }
> +
> + virtual tree
> + get_high ()
> + {
> + return m_high;
> + }
> +
> + virtual void
> + debug ()
> + {
> + dump (stderr);
> + }
> +
> + virtual void
> + dump (FILE *f)
> + {
> + PRINT_CASE (f, get_low ());
> + if (get_low () != get_high ())
> + {
> + fprintf (f, "-");
> + PRINT_CASE (f, get_high ());
> + }
> + fprintf (f, " ");
> + }
Likewise for all of these, I believe.
> + /* Low value of the case. */
> + tree m_low;
> +
> + /* High value of the case. */
> + tree m_high;
> +};
> +
> +simple_cluster::simple_cluster (tree low, tree high, tree case_label_expr,
> + basic_block case_bb, profile_probability prob):
> + cluster (case_label_expr, case_bb, prob, prob),
> + m_low (low), m_high (high)
> +{
> +}
> +struct group_cluster: public cluster
> +{
Again, could this subclass have a descriptive comment, something like.
/* Abstract subclass of cluster, handling a collection of simple_cluster
instances. */
or somesuch (I believe it's abstract because get_type isn't implemented).
> + /* Destructor. */
> + virtual ~group_cluster ();
> +
> + virtual tree
> + get_low ()
> + {
> + return m_cases[0]->get_low ();
> + }
> +
> + virtual tree
> + get_high ()
> + {
> + return m_cases[m_cases.length () - 1]->get_high ();
> + }
> +
> + virtual void
> + debug ()
> + {
> + dump (stderr);
> + }
> +
> + virtual void
> + dump (FILE *f)
> + {
> + unsigned total_values = 0;
> + for (unsigned i = 0; i < m_cases.length (); i++)
> + total_values += m_cases[i]->get_range (m_cases[i]->get_low (),
> + m_cases[i]->get_high ());
> +
> + fprintf (f, "%s(%d):", get_type () == JUMP_TABLE ? "JT" : "BT",
> + total_values);
> + PRINT_CASE (f, get_low ());
> + fprintf (f, "-");
> + PRINT_CASE (f, get_high ());
> + fprintf (f, " ");
> + }
As before, lose the "virtual" and add OVERRIDE FINAL for all of these,
I believe.
> +
> + /* List of simple clusters handled by the group. */
> + vec<simple_cluster *> m_cases;
> +};
> +
> +struct jump_table_cluster: public group_cluster
Suggested descriptive comment:
/* Concrete subclass of group_cluster representing a collection
of cases to be implemented as a jump table.
The "emit" vfunc gernerates a nested switch statement which
is later lowered to a jump table. */
or somesuch.
> +{
> + /* Constructor. */
> + jump_table_cluster (vec<cluster *> &clusters, unsigned start, unsigned end);
> +
> + virtual cluster_type
> + get_type ()
> + {
> + return JUMP_TABLE;
> + }
> +
> + virtual void emit (tree index_expr, tree index_type,
> + tree default_label_expr, basic_block default_bb);
As before, lose the "virtual" and add OVERRIDE FINAL for both of these
(I think it matters much for "emit" given the non-trivial signature and the
empty default implementation).
> + /* Find jump tables of given CLUSTERS, where all members of the vector
> + are of type simple_cluster. New clusters are returned. */
> + static vec<cluster *> find_jump_tables (vec<cluster *> &clusters);
> +
> + /* Return true when cluster starting at START and ending at END (inclusive)
> + can build a jump-table. */
> + static bool can_be_handled (const vec<cluster *> &clusters, unsigned start,
> + unsigned end);
> +
> + /* Return true if cluster starting at START and ending at END (inclusive)
> + is profitable transformation. */
> + static bool is_beneficial (const vec<cluster *> &clusters, unsigned start,
> + unsigned end);
> +
> + /* Return the smallest number of different values for which it is best
> + to use a jump-table instead of a tree of conditional branches. */
> + static inline unsigned int case_values_threshold (void);
> +};
> +
> +/* A GIMPLE switch statement can be expanded to a short sequence of bit-wise
> +comparisons. "switch(x)" is converted into "if ((1 << (x-MINVAL)) & CST)"
> +where CST and MINVAL are integer constants. This is better than a series
> +of compare-and-banch insns in some cases, e.g. we can implement:
> +
> + if ((x==4) || (x==6) || (x==9) || (x==11))
> +
> +as a single bit test:
> +
> + if ((1<<x) & ((1<<4)|(1<<6)|(1<<9)|(1<<11)))
> +
> +This transformation is only applied if the number of case targets is small,
> +if CST constains at least 3 bits, and "1 << x" is cheap. The bit tests are
> +performed in "word_mode".
> +
> +The following example shows the code the transformation generates:
> +
> + int bar(int x)
> + {
> + switch (x)
> + {
> + case '0': case '1': case '2': case '3': case '4':
> + case '5': case '6': case '7': case '8': case '9':
> + case 'A': case 'B': case 'C': case 'D': case 'E':
> + case 'F':
> + return 1;
> + }
> + return 0;
> + }
> +
> +==>
> +
> + bar (int x)
> + {
> + tmp1 = x - 48;
> + if (tmp1 > (70 - 48)) goto L2;
> + tmp2 = 1 << tmp1;
> + tmp3 = 0b11111100000001111111111;
> + if ((tmp2 & tmp3) != 0) goto L1 ; else goto L2;
> + L1:
> + return 1;
> + L2:
> + return 0;
> + }
> +
> +TODO: There are still some improvements to this transformation that could
> +be implemented:
> +
> +* A narrower mode than word_mode could be used if that is cheaper, e.g.
> + for x86_64 where a narrower-mode shift may result in smaller code.
> +
> +* The compounded constant could be shifted rather than the one. The
> + test would be either on the sign bit or on the least significant bit,
> + depending on the direction of the shift. On some machines, the test
> + for the branch would be free if the bit to test is already set by the
> + shift operation.
> +
> +This transformation was contributed by Roger Sayle, see this e-mail:
> + http://gcc.gnu.org/ml/gcc-patches/2003-01/msg01950.html
> +*/
> +
> +struct bit_test_cluster: public group_cluster
> +{
> + /* Constructor. */
> + bit_test_cluster (vec<cluster *> &clusters, unsigned start, unsigned end);
> +
> + virtual cluster_type
> + get_type ()
> + {
> + return BIT_TEST;
> + }
> +
> +/* Expand a switch statement by a short sequence of bit-wise
> + comparisons. "switch(x)" is effectively converted into
> + "if ((1 << (x-MINVAL)) & CST)" where CST and MINVAL are
> + integer constants.
> +
> + INDEX_EXPR is the value being switched on.
> +
> + MINVAL is the lowest case value of in the case nodes,
> + and RANGE is highest value minus MINVAL. MINVAL and RANGE
> + are not guaranteed to be of the same type as INDEX_EXPR
> + (the gimplifier doesn't change the type of case label values,
> + and MINVAL and RANGE are derived from those values).
> + MAXVAL is MINVAL + RANGE.
> +
> + There *MUST* be max_case_bit_tests or less unique case
> + node targets. */
> + virtual void emit (tree index_expr, tree index_type,
> + tree default_label_expr, basic_block default_bb);
As before, lose the "virtual" and add OVERRIDE FINAL for both of these.
> + /* Find bit tests of given CLUSTERS, where all members of the vector
> + are of type simple_cluster. New clusters are returned. */
> + static vec<cluster *> find_bit_tests (vec<cluster *> &clusters);
> +
> + /* Return true when cluster starting at START and ending at END (inclusive)
> + can build a bit test. */
> + static bool can_be_handled (const vec<cluster *> &clusters, unsigned start,
> + unsigned end);
> +
> + /* Return true if cluster starting at START and ending at END (inclusive)
> + is profitable transformation. */
> + static bool is_beneficial (const vec<cluster *> &clusters, unsigned start,
> + unsigned end);
> +
> +/* Split the basic block at the statement pointed to by GSIP, and insert
> + a branch to the target basic block of E_TRUE conditional on tree
> + expression COND.
> +
> + It is assumed that there is already an edge from the to-be-split
> + basic block to E_TRUE->dest block. This edge is removed, and the
> + profile information on the edge is re-used for the new conditional
> + jump.
> +
> + The CFG is updated. The dominator tree will not be valid after
> + this transformation, but the immediate dominators are updated if
> + UPDATE_DOMINATORS is true.
> +
> + Returns the newly created basic block. */
> + static basic_block hoist_edge_and_branch_if_true (gimple_stmt_iterator *gsip,
> + tree cond,
> + basic_block case_bb);
> +
> + /* Maximum number of different basic blocks that can be handlel by
Typo: handlel -> handled
> + a bit test. */
> + static const int m_max_case_bit_tests = 3;
> +};
> +
[...snip...]
Hope this is constructive
Dave
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH] Implement smart multiple switch expansion algorithms.
2017-10-06 17:24 ` [PATCH] Implement smart multiple switch expansion algorithms David Malcolm
@ 2017-12-29 14:38 ` Martin Liška
0 siblings, 0 replies; 28+ messages in thread
From: Martin Liška @ 2017-12-29 14:38 UTC (permalink / raw)
To: David Malcolm, Jeff Law, gcc-patches; +Cc: Jan Hubicka
On 10/06/2017 07:24 PM, David Malcolm wrote:
> On Fri, 2017-10-06 at 14:25 +0200, Martin Liška wrote:
>> Hello.
>>
>> As presented at this year's Cauldron, I rewrote current switch
>> expansion to support
>> multiple algorithms (jump table and bit-test) that can be used just
>> for a fraction
>> of cases. Balanced decision tree is built on top of that. I decided
>> to do a bigger
>> refactoring and put all there 3 mentioned algorithm to its own class.
>>
>> There's a bigger change in jump_table_cluster::can_be_handled where
>> the constant 10 (3 respectively)
>> is compared to number of handled values, and not number of cases.
>> Later one is wrong in my opinion.
>>
>> There are some numbers for cc1plus:
>>
>> $ bloaty ./objdir2/gcc/cc1plus -- ./objdir/gcc/cc1plus
>> VM SIZE FILE SIZE
>> ++++++++++++++ GROWING ++++++++++++++
>> +19% +1.32Mi .rodata +1.32Mi +19%
>> [ = ] 0 .symtab +7.38Ki +0.5%
>> [ = ] 0 .strtab +5.18Ki +0.2%
>> [ = ] 0 .debug_info +743 +0.0%
>> +0.0% +712 .eh_frame +712 +0.0%
>> +0.1% +440 .eh_frame_hdr +440 +0.1%
>> [ = ] 0 .debug_aranges +80 +0.1%
>> +0.0% +67 .dynstr +67 +0.0%
>> [ = ] 0 .debug_str +6 +0.0%
>>
>> -------------- SHRINKING --------------
>> -1.2% -214Ki .text -214Ki -1.2%
>> [ = ] 0 .debug_loc -66.7Ki -0.1%
>> [ = ] 0 .debug_line -14.0Ki -0.2%
>> [ = ] 0 .debug_ranges -9.56Ki -0.1%
>> -6.8% -3 [Unmapped] -375 -14.4%
>> [ = ] 0 .debug_abbrev -46 -0.0%
>>
>> +3.8% +1.11Mi TOTAL +1.03Mi +0.5%
>>
>> So it growth and can be easily explained:
>>
>> insn-attrtab.o:
>> VM SIZE FILE SIZE
>> ++++++++++++++ GROWING ++++++++++++++
>> [ = ] 0 .rela.rodata +2.00Mi +215%
>> +214% +682Ki .rodata +682Ki +214%
>> [ = ] 0 .rela.debug_loc +29.3Ki +36%
>> +32% +1.91Ki .eh_frame +1.91Ki +32%
>> [ = ] 0 .debug_loc +37 +5.6%
>> [ = ] 0 .debug_str +2 +0.0%
>>
>> -------------- SHRINKING --------------
>> -50.1% -63.3Ki .text -63.3Ki -50.1%
>> [ = ] 0 .debug_line -1.71Ki -10.4%
>> [ = ] 0 .rela.debug_info -768 -0.3%
>> [ = ] 0 .rela.text -624 -0.8%
>> [ = ] 0 .rela.debug_ranges -384 -2.7%
>> [ = ] 0 .debug_info -87 -0.2%
>> [ = ] 0 [Unmapped] -2 -8.7%
>>
>> +137% +621Ki TOTAL +2.63Mi +139%
>>
>> It's caused by:
>> ...
>> ;; GIMPLE switch case clusters: JT(2710):-1-5090
>> ;; GIMPLE switch case clusters: JT(2710):-1-5090
>> ;; GIMPLE switch case clusters: JT(2967):-1-5090
>> ;; GIMPLE switch case clusters: JT(1033):-1-5017
>> ...
>>
>> so there are many switch statements with very reasonable density.
>>
>> and
>> insn-dfatab.o: +13% +99.4Ki TOTAL +455Ki +14%
>> insn-latencytab.o: +19% +136Ki TOTAL +609Ki +20%
>>
>> There shouldn't be any fallout other from what I mentioned in
>> previous email that is
>> a prerequisite for this patch.
>>
>> Patch can bootstrap on ppc64le-redhat-linux and survives regression
>> tests.
>>
>> I'm still planning to come with some numbers and stats. Will do that
>> next week.
>>
>> Martin
>
>
>> gcc/ChangeLog:
>>
>> 2017-09-29 Martin Liska <mliska@suse.cz>
>>
>> * tree-switch-conversion.c (MAX_CASE_BIT_TESTS): Remove and move
>> to header file.
>> (hoist_edge_and_branch_if_true): Move to ...
>> (bit_test_cluster::hoist_edge_and_branch_if_true): ... this.
>
> I'm not a reviewer, but there's a lot of "churn" in the patch due to
> things moving around; there seems to be a mixture of things simply
> moving around, functions becoming methods of classes, and some
> things changing.
>
> Would it be helpful to split the patch into two: a patch that moves
> the functions to where they'll be needed, and then a patch to do the
> "actual" (or functional) changes?
Hello.
Sorry for late answer. I fully agree what you wrote David. It would make
the patch more easily readable and reviewable. Let me postpone it to next
stage1, patch separation into 2 pieces will need some effort.
>
> [...snip...]
>
>> diff --git a/gcc/tree-switch-conversion.h b/gcc/tree-switch-conversion.h
>> new file mode 100644
>> index 00000000000..45ae11f408d
>> --- /dev/null
>> +++ b/gcc/tree-switch-conversion.h
>> @@ -0,0 +1,806 @@
>> +/* Tree switch conversion for GNU compiler.
>> + Copyright (C) 2017 Free Software Foundation, Inc.
>
> Should this be "gimple switch conversion" and
> gimple-ssa-switch-conversion.h?
> (but presumably this is to mirror tree-switch-conversion.c, and
> I don't want to advocate for unnecessary churn)
>
>> +This file is part of GCC.
>> +
>> +GCC is free software; you can redistribute it and/or modify it under
>> +the terms of the GNU General Public License as published by the Free
>> +Software Foundation; either version 3, or (at your option) any later
>> +version.
>> +
>> +GCC is distributed in the hope that it will be useful, but WITHOUT ANY
>> +WARRANTY; without even the implied warranty of MERCHANTABILITY or
>> +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
>> +for more details.
>> +
>> +You should have received a copy of the GNU General Public License
>> +along with GCC; see the file COPYING3. If not see
>> +<http://www.gnu.org/licenses/>. */
>> +
>> +#ifndef TREE_SWITCH_CONVERSION_H
>> +#define TREE_SWITCH_CONVERSION_H
>> +
>> +namespace tree_switch_conversion {
>> +
>> +/* Type of cluster. */
>> +
>> +enum cluster_type
>> +{
>> + SIMPLE_CASE,
>> + JUMP_TABLE,
>> + BIT_TEST
>> +};
>> +
>> +#define PRINT_CASE(f,c) print_dec (c, f, TYPE_SIGN (TREE_TYPE (c)))
>> +
>> +/* Base class for switch clustering. */
>
> Maybe "Abstract base class for representing a cluster of cases", or
> somesuch?
I like it!
> Perhaps an ASCII art inheritance diagram; if I'm reading the code
> right, something like:
>
> /* Abstract base class for representing a cluster of cases.
>
> Here is the inheritance hierarachy, and the enum_cluster_type
> values for the concrete subclasses:
>
> cluster
> |-simple_cluster (SIMPLE_CASE)
> `-group_cluster
> |-jump_table_cluster (JUMP_TABLE)
> `-bit_test_cluster (BIT_TEST). */
>
> Am I right in thinking that the switch initialization conversion
> (struct switch_conversion) is currently distinct from the clustering
> in this patch? (I'm wondering if there's possible benefit from
> combining the two approaches, maybe if one cluster of cases
> predominantly assigns to some variables, and another cluster of
> cases predominantly assigns to some other variables).
Exactly, you understand the algorithm well. Yep switch conversion should
be also incorporated as one of strategies for a cluster. Let me work on
that in next stage1.
Thanks also for another nit comment, I will include them.
Martin
>
>> +
>> +struct cluster
>> +{
>> + /* Cosntructor. */
>
> ^^^ Typo
>
>> + cluster ()
>> + {}
>
> When is this default ctor used?
> Doesn't it leave the various fields uninitialized?
>
> I notice that of the descendant classes, at least jump_table_cluster
> doesn't call its base class ctor (if I'm reading the patch right), so I
> believe these fields are uninitialized for some of the subclasses.
>
>> +
>> + /* Constructor. */
>> + cluster (tree case_label_expr, basic_block case_bb, profile_probability prob,
>> + profile_probability subtree_prob);
>> +
>
> [...snip...]
>
>> +struct simple_cluster: public cluster
>> +{
>
> Could this struct have a descriptive comment? e.g.
>
> /* Subclass of cluster representing a simple contiguous range
> from [low..high]. */
>
> or somesuch (assuming I've read the intent correctly)
>
>> + /* Constructor. */
>> + simple_cluster (tree low, tree high, tree case_label_expr,
>> + basic_block case_bb, profile_probability prob);
>> +
>> + /* Destructor. */
>> + virtual ~simple_cluster ()
>> + {}
>> +
>> + virtual cluster_type
>> + get_type ()
>> + {
>> + return SIMPLE_CASE;
>> + }
>
> I believe that the "virtual" here is redundant, but that it ought to say
> get_type () OVERRIDE FINAL
> so tell human readers that it's a vfunc override, and so that C++11
> onwards can warn if it's not actually a vfunc override.
>
>> + virtual tree
>> + get_low ()
>> + {
>> + return m_low;
>> + }
>> +
>> + virtual tree
>> + get_high ()
>> + {
>> + return m_high;
>> + }
>> +
>> + virtual void
>> + debug ()
>> + {
>> + dump (stderr);
>> + }
>> +
>> + virtual void
>> + dump (FILE *f)
>> + {
>> + PRINT_CASE (f, get_low ());
>> + if (get_low () != get_high ())
>> + {
>> + fprintf (f, "-");
>> + PRINT_CASE (f, get_high ());
>> + }
>> + fprintf (f, " ");
>> + }
>
> Likewise for all of these, I believe.
>
>> + /* Low value of the case. */
>> + tree m_low;
>> +
>> + /* High value of the case. */
>> + tree m_high;
>> +};
>> +
>> +simple_cluster::simple_cluster (tree low, tree high, tree case_label_expr,
>> + basic_block case_bb, profile_probability prob):
>> + cluster (case_label_expr, case_bb, prob, prob),
>> + m_low (low), m_high (high)
>> +{
>> +}
>
>> +struct group_cluster: public cluster
>> +{
>
> Again, could this subclass have a descriptive comment, something like.
>
> /* Abstract subclass of cluster, handling a collection of simple_cluster
> instances. */
>
> or somesuch (I believe it's abstract because get_type isn't implemented).
>
>> + /* Destructor. */
>> + virtual ~group_cluster ();
>> +
>> + virtual tree
>> + get_low ()
>> + {
>> + return m_cases[0]->get_low ();
>> + }
>> +
>> + virtual tree
>> + get_high ()
>> + {
>> + return m_cases[m_cases.length () - 1]->get_high ();
>> + }
>> +
>> + virtual void
>> + debug ()
>> + {
>> + dump (stderr);
>> + }
>> +
>> + virtual void
>> + dump (FILE *f)
>> + {
>> + unsigned total_values = 0;
>> + for (unsigned i = 0; i < m_cases.length (); i++)
>> + total_values += m_cases[i]->get_range (m_cases[i]->get_low (),
>> + m_cases[i]->get_high ());
>> +
>> + fprintf (f, "%s(%d):", get_type () == JUMP_TABLE ? "JT" : "BT",
>> + total_values);
>> + PRINT_CASE (f, get_low ());
>> + fprintf (f, "-");
>> + PRINT_CASE (f, get_high ());
>> + fprintf (f, " ");
>> + }
>
> As before, lose the "virtual" and add OVERRIDE FINAL for all of these,
> I believe.
>
>> +
>> + /* List of simple clusters handled by the group. */
>> + vec<simple_cluster *> m_cases;
>> +};
>> +
>> +struct jump_table_cluster: public group_cluster
>
> Suggested descriptive comment:
>
> /* Concrete subclass of group_cluster representing a collection
> of cases to be implemented as a jump table.
> The "emit" vfunc gernerates a nested switch statement which
> is later lowered to a jump table. */
>
> or somesuch.
>
>> +{
>> + /* Constructor. */
>> + jump_table_cluster (vec<cluster *> &clusters, unsigned start, unsigned end);
>> +
>> + virtual cluster_type
>> + get_type ()
>> + {
>> + return JUMP_TABLE;
>> + }
>> +
>> + virtual void emit (tree index_expr, tree index_type,
>> + tree default_label_expr, basic_block default_bb);
>
> As before, lose the "virtual" and add OVERRIDE FINAL for both of these
> (I think it matters much for "emit" given the non-trivial signature and the
> empty default implementation).
>
>> + /* Find jump tables of given CLUSTERS, where all members of the vector
>> + are of type simple_cluster. New clusters are returned. */
>> + static vec<cluster *> find_jump_tables (vec<cluster *> &clusters);
>> +
>> + /* Return true when cluster starting at START and ending at END (inclusive)
>> + can build a jump-table. */
>> + static bool can_be_handled (const vec<cluster *> &clusters, unsigned start,
>> + unsigned end);
>> +
>> + /* Return true if cluster starting at START and ending at END (inclusive)
>> + is profitable transformation. */
>> + static bool is_beneficial (const vec<cluster *> &clusters, unsigned start,
>> + unsigned end);
>> +
>> + /* Return the smallest number of different values for which it is best
>> + to use a jump-table instead of a tree of conditional branches. */
>> + static inline unsigned int case_values_threshold (void);
>> +};
>> +
>> +/* A GIMPLE switch statement can be expanded to a short sequence of bit-wise
>> +comparisons. "switch(x)" is converted into "if ((1 << (x-MINVAL)) & CST)"
>> +where CST and MINVAL are integer constants. This is better than a series
>> +of compare-and-banch insns in some cases, e.g. we can implement:
>> +
>> + if ((x==4) || (x==6) || (x==9) || (x==11))
>> +
>> +as a single bit test:
>> +
>> + if ((1<<x) & ((1<<4)|(1<<6)|(1<<9)|(1<<11)))
>> +
>> +This transformation is only applied if the number of case targets is small,
>> +if CST constains at least 3 bits, and "1 << x" is cheap. The bit tests are
>> +performed in "word_mode".
>> +
>> +The following example shows the code the transformation generates:
>> +
>> + int bar(int x)
>> + {
>> + switch (x)
>> + {
>> + case '0': case '1': case '2': case '3': case '4':
>> + case '5': case '6': case '7': case '8': case '9':
>> + case 'A': case 'B': case 'C': case 'D': case 'E':
>> + case 'F':
>> + return 1;
>> + }
>> + return 0;
>> + }
>> +
>> +==>
>> +
>> + bar (int x)
>> + {
>> + tmp1 = x - 48;
>> + if (tmp1 > (70 - 48)) goto L2;
>> + tmp2 = 1 << tmp1;
>> + tmp3 = 0b11111100000001111111111;
>> + if ((tmp2 & tmp3) != 0) goto L1 ; else goto L2;
>> + L1:
>> + return 1;
>> + L2:
>> + return 0;
>> + }
>> +
>> +TODO: There are still some improvements to this transformation that could
>> +be implemented:
>> +
>> +* A narrower mode than word_mode could be used if that is cheaper, e.g.
>> + for x86_64 where a narrower-mode shift may result in smaller code.
>> +
>> +* The compounded constant could be shifted rather than the one. The
>> + test would be either on the sign bit or on the least significant bit,
>> + depending on the direction of the shift. On some machines, the test
>> + for the branch would be free if the bit to test is already set by the
>> + shift operation.
>> +
>> +This transformation was contributed by Roger Sayle, see this e-mail:
>> + http://gcc.gnu.org/ml/gcc-patches/2003-01/msg01950.html
>> +*/
>> +
>> +struct bit_test_cluster: public group_cluster
>> +{
>> + /* Constructor. */
>> + bit_test_cluster (vec<cluster *> &clusters, unsigned start, unsigned end);
>> +
>> + virtual cluster_type
>> + get_type ()
>> + {
>> + return BIT_TEST;
>> + }
>> +
>> +/* Expand a switch statement by a short sequence of bit-wise
>> + comparisons. "switch(x)" is effectively converted into
>> + "if ((1 << (x-MINVAL)) & CST)" where CST and MINVAL are
>> + integer constants.
>> +
>> + INDEX_EXPR is the value being switched on.
>> +
>> + MINVAL is the lowest case value of in the case nodes,
>> + and RANGE is highest value minus MINVAL. MINVAL and RANGE
>> + are not guaranteed to be of the same type as INDEX_EXPR
>> + (the gimplifier doesn't change the type of case label values,
>> + and MINVAL and RANGE are derived from those values).
>> + MAXVAL is MINVAL + RANGE.
>> +
>> + There *MUST* be max_case_bit_tests or less unique case
>> + node targets. */
>> + virtual void emit (tree index_expr, tree index_type,
>> + tree default_label_expr, basic_block default_bb);
>
> As before, lose the "virtual" and add OVERRIDE FINAL for both of these.
>
>> + /* Find bit tests of given CLUSTERS, where all members of the vector
>> + are of type simple_cluster. New clusters are returned. */
>> + static vec<cluster *> find_bit_tests (vec<cluster *> &clusters);
>> +
>> + /* Return true when cluster starting at START and ending at END (inclusive)
>> + can build a bit test. */
>> + static bool can_be_handled (const vec<cluster *> &clusters, unsigned start,
>> + unsigned end);
>> +
>> + /* Return true if cluster starting at START and ending at END (inclusive)
>> + is profitable transformation. */
>> + static bool is_beneficial (const vec<cluster *> &clusters, unsigned start,
>> + unsigned end);
>> +
>> +/* Split the basic block at the statement pointed to by GSIP, and insert
>> + a branch to the target basic block of E_TRUE conditional on tree
>> + expression COND.
>> +
>> + It is assumed that there is already an edge from the to-be-split
>> + basic block to E_TRUE->dest block. This edge is removed, and the
>> + profile information on the edge is re-used for the new conditional
>> + jump.
>> +
>> + The CFG is updated. The dominator tree will not be valid after
>> + this transformation, but the immediate dominators are updated if
>> + UPDATE_DOMINATORS is true.
>> +
>> + Returns the newly created basic block. */
>> + static basic_block hoist_edge_and_branch_if_true (gimple_stmt_iterator *gsip,
>> + tree cond,
>> + basic_block case_bb);
>> +
>> + /* Maximum number of different basic blocks that can be handlel by
>
> Typo: handlel -> handled
>
>> + a bit test. */
>> + static const int m_max_case_bit_tests = 3;
>> +};
>> +
>
> [...snip...]
>
> Hope this is constructive
> Dave
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH] Add selftest for vec::reverse
2017-10-06 16:20 ` [PATCH] Add selftest for vec::reverse David Malcolm
@ 2017-12-29 14:39 ` Martin Liška
2017-12-29 17:09 ` David Malcolm
0 siblings, 1 reply; 28+ messages in thread
From: Martin Liška @ 2017-12-29 14:39 UTC (permalink / raw)
To: David Malcolm, Jeff Law, gcc-patches; +Cc: Jan Hubicka
On 10/06/2017 06:20 PM, David Malcolm wrote:
> Martin: I noticed that your switch expansion patch added a
> vec::reverse ()
> method. Here's a proposed selftest for it, mostly to verify
> that it handles even vs odd lengths (which it does).
>
> Only lightly tested; hope this is useful.
> Dave
Hi.
I like it! Do you want to commit it before there will be
a consumer of the function?
Martin
>
> gcc/ChangeLog:
> * vec.c (selftest::test_reverse): New function.
> (selftest::vec_c_tests): Call it.
> ---
> gcc/vec.c | 38 ++++++++++++++++++++++++++++++++++++++
> 1 file changed, 38 insertions(+)
>
> diff --git a/gcc/vec.c b/gcc/vec.c
> index d612703..5d70973 100644
> --- a/gcc/vec.c
> +++ b/gcc/vec.c
> @@ -359,6 +359,43 @@ test_qsort ()
> ASSERT_EQ (10, v.length ());
> }
>
> +/* Verify that vec::reverse works correctly. */
> +
> +static void
> +test_reverse ()
> +{
> + /* Reversing an empty vec ought to be a no-op. */
> + {
> + auto_vec <int> v;
> + ASSERT_EQ (0, v.length ());
> + v.reverse ();
> + ASSERT_EQ (0, v.length ());
> + }
> +
> + /* Verify reversing a vec with even length. */
> + {
> + auto_vec <int> v;
> + safe_push_range (v, 0, 4);
> + v.reverse ();
> + ASSERT_EQ (3, v[0]);
> + ASSERT_EQ (2, v[1]);
> + ASSERT_EQ (1, v[2]);
> + ASSERT_EQ (0, v[3]);
> + ASSERT_EQ (4, v.length ());
> + }
> +
> + /* Verify reversing a vec with odd length. */
> + {
> + auto_vec <int> v;
> + safe_push_range (v, 0, 3);
> + v.reverse ();
> + ASSERT_EQ (2, v[0]);
> + ASSERT_EQ (1, v[1]);
> + ASSERT_EQ (0, v[2]);
> + ASSERT_EQ (3, v.length ());
> + }
> +}
> +
> /* Run all of the selftests within this file. */
>
> void
> @@ -374,6 +411,7 @@ vec_c_tests ()
> test_unordered_remove ();
> test_block_remove ();
> test_qsort ();
> + test_reverse ();
> }
>
> } // namespace selftest
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH] Add selftest for vec::reverse
2017-12-29 14:39 ` Martin Liška
@ 2017-12-29 17:09 ` David Malcolm
0 siblings, 0 replies; 28+ messages in thread
From: David Malcolm @ 2017-12-29 17:09 UTC (permalink / raw)
To: Martin Liška, Jeff Law, gcc-patches; +Cc: Jan Hubicka
On Fri, 2017-12-29 at 15:39 +0100, Martin Liška wrote:
> On 10/06/2017 06:20 PM, David Malcolm wrote:
> > Martin: I noticed that your switch expansion patch added a
> > vec::reverse ()
> > method. Here's a proposed selftest for it, mostly to verify
> > that it handles even vs odd lengths (which it does).
> >
> > Only lightly tested; hope this is useful.
> > Dave
>
> Hi.
>
> I like it! Do you want to commit it before there will be
> a consumer of the function?
>
> Martin
Looks like vec::reverse isn't in trunk yet. I don't have a strong
opinion on whether vec::reverse should be added without a "real"
consumer, or added when the consumer is added, but feel free to add my
selftest patch into whichever patch adds vec::reverse.
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2017-09-20 15:00 ` Jeff Law
2017-09-21 23:12 ` Bernhard Reutner-Fischer
@ 2018-01-09 14:46 ` Martin Liška
2018-01-09 18:31 ` Jeff Law
1 sibling, 1 reply; 28+ messages in thread
From: Martin Liška @ 2018-01-09 14:46 UTC (permalink / raw)
To: Jeff Law, gcc-patches
On 09/20/2017 05:00 PM, Jeff Law wrote:
> On 09/20/2017 01:24 AM, Martin Liška wrote:
>
>>
>> Hello.
>>
>> Thank you Jeff for very verbose explanation what's happening. I'm planning to do
>> follow-up of this patch that will include clustering for bit-tests and jump tables.
>> Maybe that will make aforementioned issues even more difficult, but we'll see.
> FWIW, the DOM changes to simplify the conditionals seem to help both
> cases, trigger reasonably consistently in a bootstrap and for some
> subset of the triggers actually result in transformations that allow
> other passes to do a better job in the common (-O2) case. So my
> inclination is to polish them a bit further get them on the trunk.
>
> My recommendation is to ignore the two regressions for now and focus on
> the cleanups you're trying to do.
>
> jeff
>
Hello.
Some time ago I've decided that I'll make patch submission of switch clustering
in next stage1. However, this patch can be applied as is in this stage3. Would
it be possible or is it too late?
Thanks,
Martin
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-01-09 14:46 ` Martin Liška
@ 2018-01-09 18:31 ` Jeff Law
2018-01-10 13:14 ` Richard Biener
0 siblings, 1 reply; 28+ messages in thread
From: Jeff Law @ 2018-01-09 18:31 UTC (permalink / raw)
To: Martin Liška, gcc-patches
On 01/09/2018 07:43 AM, Martin Liška wrote:
> On 09/20/2017 05:00 PM, Jeff Law wrote:
>> On 09/20/2017 01:24 AM, Martin Liška wrote:
>>
>>>
>>> Hello.
>>>
>>> Thank you Jeff for very verbose explanation what's happening. I'm planning to do
>>> follow-up of this patch that will include clustering for bit-tests and jump tables.
>>> Maybe that will make aforementioned issues even more difficult, but we'll see.
>> FWIW, the DOM changes to simplify the conditionals seem to help both
>> cases, trigger reasonably consistently in a bootstrap and for some
>> subset of the triggers actually result in transformations that allow
>> other passes to do a better job in the common (-O2) case. So my
>> inclination is to polish them a bit further get them on the trunk.
>>
>> My recommendation is to ignore the two regressions for now and focus on
>> the cleanups you're trying to do.
>>
>> jeff
>>
>
> Hello.
>
> Some time ago I've decided that I'll make patch submission of switch clustering
> in next stage1. However, this patch can be applied as is in this stage3. Would
> it be possible or is it too late?
I'll let Richi make the call here. FWIW, the DOM changes to avoid the
two missed-optimization regressions you ran into are on the trunk, so
that's no longer a blocking issue.
jeff
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-01-09 18:31 ` Jeff Law
@ 2018-01-10 13:14 ` Richard Biener
2018-01-10 15:04 ` Martin Liška
0 siblings, 1 reply; 28+ messages in thread
From: Richard Biener @ 2018-01-10 13:14 UTC (permalink / raw)
To: Jeff Law; +Cc: Martin Liška, GCC Patches
On Tue, Jan 9, 2018 at 7:29 PM, Jeff Law <law@redhat.com> wrote:
> On 01/09/2018 07:43 AM, Martin Liška wrote:
>> On 09/20/2017 05:00 PM, Jeff Law wrote:
>>> On 09/20/2017 01:24 AM, Martin Liška wrote:
>>>
>>>>
>>>> Hello.
>>>>
>>>> Thank you Jeff for very verbose explanation what's happening. I'm planning to do
>>>> follow-up of this patch that will include clustering for bit-tests and jump tables.
>>>> Maybe that will make aforementioned issues even more difficult, but we'll see.
>>> FWIW, the DOM changes to simplify the conditionals seem to help both
>>> cases, trigger reasonably consistently in a bootstrap and for some
>>> subset of the triggers actually result in transformations that allow
>>> other passes to do a better job in the common (-O2) case. So my
>>> inclination is to polish them a bit further get them on the trunk.
>>>
>>> My recommendation is to ignore the two regressions for now and focus on
>>> the cleanups you're trying to do.
>>>
>>> jeff
>>>
>>
>> Hello.
>>
>> Some time ago I've decided that I'll make patch submission of switch clustering
>> in next stage1. However, this patch can be applied as is in this stage3. Would
>> it be possible or is it too late?
> I'll let Richi make the call here. FWIW, the DOM changes to avoid the
> two missed-optimization regressions you ran into are on the trunk, so
> that's no longer a blocking issue.
If you are fine with waiting then please wait ;)
Richard.
> jeff
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-01-10 13:14 ` Richard Biener
@ 2018-01-10 15:04 ` Martin Liška
2018-01-14 23:23 ` Bernhard Reutner-Fischer
0 siblings, 1 reply; 28+ messages in thread
From: Martin Liška @ 2018-01-10 15:04 UTC (permalink / raw)
To: Richard Biener, Jeff Law; +Cc: GCC Patches
On 01/10/2018 02:13 PM, Richard Biener wrote:
> On Tue, Jan 9, 2018 at 7:29 PM, Jeff Law <law@redhat.com> wrote:
>> On 01/09/2018 07:43 AM, Martin Liška wrote:
>>> On 09/20/2017 05:00 PM, Jeff Law wrote:
>>>> On 09/20/2017 01:24 AM, Martin Liška wrote:
>>>>
>>>>>
>>>>> Hello.
>>>>>
>>>>> Thank you Jeff for very verbose explanation what's happening. I'm planning to do
>>>>> follow-up of this patch that will include clustering for bit-tests and jump tables.
>>>>> Maybe that will make aforementioned issues even more difficult, but we'll see.
>>>> FWIW, the DOM changes to simplify the conditionals seem to help both
>>>> cases, trigger reasonably consistently in a bootstrap and for some
>>>> subset of the triggers actually result in transformations that allow
>>>> other passes to do a better job in the common (-O2) case. So my
>>>> inclination is to polish them a bit further get them on the trunk.
>>>>
>>>> My recommendation is to ignore the two regressions for now and focus on
>>>> the cleanups you're trying to do.
>>>>
>>>> jeff
>>>>
>>>
>>> Hello.
>>>
>>> Some time ago I've decided that I'll make patch submission of switch clustering
>>> in next stage1. However, this patch can be applied as is in this stage3. Would
>>> it be possible or is it too late?
>> I'll let Richi make the call here. FWIW, the DOM changes to avoid the
>> two missed-optimization regressions you ran into are on the trunk, so
>> that's no longer a blocking issue.
>
> If you are fine with waiting then please wait ;)
Yep, it's not urgent.
Thanks.
Martin
>
> Richard.
>
>> jeff
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-01-10 15:04 ` Martin Liška
@ 2018-01-14 23:23 ` Bernhard Reutner-Fischer
2018-05-17 10:39 ` Martin Liška
0 siblings, 1 reply; 28+ messages in thread
From: Bernhard Reutner-Fischer @ 2018-01-14 23:23 UTC (permalink / raw)
To: gcc-patches, Martin Liška, Richard Biener, Jeff Law; +Cc: GCC Patches
On 10 January 2018 15:59:28 CET, "Martin Liška" <mliska@suse.cz> wrote:
>On 01/10/2018 02:13 PM, Richard Biener wrote:
>> On Tue, Jan 9, 2018 at 7:29 PM, Jeff Law <law@redhat.com> wrote:
>>> On 01/09/2018 07:43 AM, Martin Liška wrote:
>>>> On 09/20/2017 05:00 PM, Jeff Law wrote:
>>>>> On 09/20/2017 01:24 AM, Martin Liška wrote:
>>>>>
>>>>>>
>>>>>> Hello.
>>>>>>
>>>>>> Thank you Jeff for very verbose explanation what's happening. I'm
>planning to do
>>>>>> follow-up of this patch that will include clustering for
>bit-tests and jump tables.
>>>>>> Maybe that will make aforementioned issues even more difficult,
>but we'll see.
>>>>> FWIW, the DOM changes to simplify the conditionals seem to help
>both
>>>>> cases, trigger reasonably consistently in a bootstrap and for some
>>>>> subset of the triggers actually result in transformations that
>allow
>>>>> other passes to do a better job in the common (-O2) case. So my
>>>>> inclination is to polish them a bit further get them on the trunk.
>>>>>
>>>>> My recommendation is to ignore the two regressions for now and
>focus on
>>>>> the cleanups you're trying to do.
>>>>>
>>>>> jeff
>>>>>
>>>>
>>>> Hello.
>>>>
>>>> Some time ago I've decided that I'll make patch submission of
>switch clustering
>>>> in next stage1. However, this patch can be applied as is in this
>stage3. Would
>>>> it be possible or is it too late?
>>> I'll let Richi make the call here. FWIW, the DOM changes to avoid
>the
>>> two missed-optimization regressions you ran into are on the trunk,
>so
>>> that's no longer a blocking issue.
>>
>> If you are fine with waiting then please wait ;)
>
>Yep, it's not urgent.
Can you please post CSiBE numbers? Ideally throwing in gcc-3.4.6 numbers too?
thanks,
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-01-14 23:23 ` Bernhard Reutner-Fischer
@ 2018-05-17 10:39 ` Martin Liška
2018-05-18 13:57 ` Rainer Orth
0 siblings, 1 reply; 28+ messages in thread
From: Martin Liška @ 2018-05-17 10:39 UTC (permalink / raw)
To: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law
[-- Attachment #1: Type: text/plain, Size: 11791 bytes --]
On 01/15/2018 12:22 AM, Bernhard Reutner-Fischer wrote:
> Can you please post CSiBE numbers? Ideally throwing in gcc-3.4.6 numbers too?
>
> thanks,
Hi.
I've just retested the patch and looks fine. There are numbers of CSiBE. I'm sorry I don't
have such old version of GCC:
+-------------------+--------+------------------+------------------+-----------------+--------------------+
| object | trunk | Trunk w/ patch | Gcc 7.3.1 | patch vs. trunk | Gcc 7.3.1 vs trunk |
+-------------------+--------+------------------+------------------+-----------------+--------------------+
| buf.c.o | 2531 | 2531 | 2531 | 0 | 0 |
| ccl.c.o | 2520 | 2520 | 2519 | 0 | -1 |
| dfa.c.o | 9909 | 9909 | 9909 | 0 | 0 |
| ecs.c.o | 1432 | 1432 | 1432 | 0 | 0 |
| filter.c.o | 4810 | 4810 | 4810 | 0 | 0 |
| gen.c.o | 28696 | 28696 | 28805 | 0 | 109 |
| libmain.c.o | 88 | 88 | 88 | 0 | 0 |
| libyywrap.c.o | 54 | 54 | 67 | 0 | 13 |
| main.c.o | 22132 | 22132 | 22129 | 0 | -3 |
| misc.c.o | 9765 | 9765 | 9811 | 0 | 46 |
| nfa.c.o | 6449 | 6467 | 6449 | 18 | 0 |
| options.c.o | 1240 | 1240 | 1240 | 0 | 0 |
| parse.c.o | 15737 | 15737 | 15742 | 0 | 5 |
| regex.c.o | 1374 | 1374 | 1374 | 0 | 0 |
| scan.c.o | 66844 | 66896 | 66944 | 52 | 100 |
| scanflags.c.o | 422 | 422 | 435 | 0 | 13 |
| scanopt.c.o | 8170 | 8201 | 8198 | 31 | 28 |
| skel.c.o | 91010 | 91010 | 91010 | 0 | 0 |
| sym.c.o | 1796 | 1796 | 1796 | 0 | 0 |
| tables.c.o | 5000 | 5070 | 4998 | 70 | -2 |
| tables_shared.c.o | 122 | 122 | 122 | 0 | 0 |
| tblcmp.c.o | 5587 | 5587 | 5578 | 0 | -9 |
| yylex.c.o | 2166 | 2332 | 2122 | 166 | -44 |
| blocksort.c.o | 13850 | 13850 | 13862 | 0 | 12 |
| bzip2.c.o | 23540 | 23702 | 23535 | 162 | -5 |
| bzip2recover.c.o | 4863 | 4863 | 4865 | 0 | 2 |
| bzlib.c.o | 21359 | 21433 | 21393 | 74 | 34 |
| compress.c.o | 24424 | 24424 | 24409 | 0 | -15 |
| crctable.c.o | 0 | 0 | 0 | 0 | 0 |
| decompress.c.o | 23467 | 23467 | 23464 | 0 | -3 |
| dlltest.c.o | 1213 | 1213 | 1213 | 0 | 0 |
| huffman.c.o | 2180 | 2180 | 2180 | 0 | 0 |
| mk251.c.o | 103 | 103 | 103 | 0 | 0 |
| randtable.c.o | 0 | 0 | 0 | 0 | 0 |
| spewG.c.o | 477 | 477 | 480 | 0 | 3 |
| unzcrash.c.o | 1284 | 1284 | 1284 | 0 | 0 |
| SUM | 404614 | 405187 | 404897 | 573 | 283 |
| ratio | | 1.00141616454201 | 0.99928428108503 | | |
+-------------------+--------+------------------+------------------+-----------------+--------------------+
So the patch looks fine, only very very slightly binary is produced. I'm going to install the patch so that
I can carry on more complex patches based on this one.
Bernhard: I'm able to build only flex and bzip2. Do you know why? I noticed there are other projects in toplevel
directory.
./csibe.py
-- The C compiler identification is GNU 7.3.1
-- The CXX compiler identification is GNU 7.3.1
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /tmp/csibe/build/native
make: Entering directory '/tmp/csibe/build/native'
make[1]: Entering directory '/tmp/csibe/build/native'
make[2]: Entering directory '/tmp/csibe/build/native'
Scanning dependencies of target bzip2-1.0.6
make[2]: Leaving directory '/tmp/csibe/build/native'
make[2]: Entering directory '/tmp/csibe/build/native'
[ 2%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/blocksort.c.o
[ 5%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/bzip2.c.o
[ 8%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/bzip2recover.c.o
[ 11%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/bzlib.c.o
[ 13%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/compress.c.o
[ 16%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/crctable.c.o
[ 19%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/decompress.c.o
[ 22%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/dlltest.c.o
[ 25%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/huffman.c.o
[ 27%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/mk251.c.o
[ 30%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/randtable.c.o
[ 33%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/spewG.c.o
[ 36%] Building C object gen/bzip2-1.0.6/CMakeFiles/bzip2-1.0.6.dir/__/__/src/bzip2-1.0.6/unzcrash.c.o
make[2]: Leaving directory '/tmp/csibe/build/native'
[ 36%] Built target bzip2-1.0.6
make[2]: Entering directory '/tmp/csibe/build/native'
Scanning dependencies of target flex-2.6.0
make[2]: Leaving directory '/tmp/csibe/build/native'
make[2]: Entering directory '/tmp/csibe/build/native'
[ 38%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/buf.c.o
[ 41%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/ccl.c.o
[ 44%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/dfa.c.o
[ 47%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/ecs.c.o
[ 50%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/filter.c.o
[ 52%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/gen.c.o
[ 55%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/libmain.c.o
[ 58%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/libyywrap.c.o
[ 61%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/main.c.o
[ 63%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/misc.c.o
[ 66%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/nfa.c.o
[ 69%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/options.c.o
[ 72%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/parse.c.o
[ 75%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/regex.c.o
[ 77%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/scan.c.o
[ 80%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/scanflags.c.o
[ 83%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/scanopt.c.o
[ 86%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/skel.c.o
[ 88%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/sym.c.o
[ 91%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/tables.c.o
[ 94%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/tables_shared.c.o
[ 97%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/tblcmp.c.o
[100%] Building C object gen/flex-2.6.0/CMakeFiles/flex-2.6.0.dir/__/__/src/flex-2.6.0/src/yylex.c.o
make[2]: Leaving directory '/tmp/csibe/build/native'
[100%] Built target flex-2.6.0
make[1]: Leaving directory '/tmp/csibe/build/native'
make: Leaving directory '/tmp/csibe/build/native'
make: Entering directory '/tmp/csibe/build/native'
make[1]: Entering directory '/tmp/csibe/build/native'
make[2]: Entering directory '/tmp/csibe/build/native'
make[3]: Entering directory '/tmp/csibe/build/native'
make[3]: Leaving directory '/tmp/csibe/build/native'
[ 60%] Built target flex-2.6.0
make[3]: Entering directory '/tmp/csibe/build/native'
Scanning dependencies of target flex-2.6.0_size
make[3]: Leaving directory '/tmp/csibe/build/native'
make[3]: Entering directory '/tmp/csibe/build/native'
[ 63%] Generating result.csv
make[3]: Leaving directory '/tmp/csibe/build/native'
[ 63%] Built target flex-2.6.0_size
make[3]: Entering directory '/tmp/csibe/build/native'
make[3]: Leaving directory '/tmp/csibe/build/native'
[ 97%] Built target bzip2-1.0.6
make[3]: Entering directory '/tmp/csibe/build/native'
Scanning dependencies of target bzip2-1.0.6_size
make[3]: Leaving directory '/tmp/csibe/build/native'
make[3]: Entering directory '/tmp/csibe/build/native'
[100%] Generating result.csv
make[3]: Leaving directory '/tmp/csibe/build/native'
[100%] Built target bzip2-1.0.6_size
make[3]: Entering directory '/tmp/csibe/build/native'
Scanning dependencies of target size
make[3]: Leaving directory '/tmp/csibe/build/native'
make[3]: Entering directory '/tmp/csibe/build/native'
make[3]: Leaving directory '/tmp/csibe/build/native'
[100%] Built target size
make[2]: Leaving directory '/tmp/csibe/build/native'
make[1]: Leaving directory '/tmp/csibe/build/native'
make: Leaving directory '/tmp/csibe/build/native'
Martin
[-- Attachment #2: 0001-Radically-simplify-emission-of-balanced-tree-for-swi.patch --]
[-- Type: text/x-patch, Size: 27938 bytes --]
From 1ee3fd1cd03a47ad44b7f2b475c3ddcaf2f4c6a9 Mon Sep 17 00:00:00 2001
From: marxin <mliska@suse.cz>
Date: Tue, 5 Sep 2017 12:11:13 +0200
Subject: [PATCH] Radically simplify emission of balanced tree for switch
statements.
gcc/ChangeLog:
2017-09-14 Martin Liska <mliska@suse.cz>
* passes.def: Add pass_lower_switch and pass_lower_switch_O0.
* tree-pass.h (make_pass_lower_switch_O0): New function.
* tree-switch-conversion.c (node_has_low_bound): Remove.
(node_has_high_bound): Likewise.
(node_is_bounded): Likewise.
(class pass_lower_switch): Make it a template type and create
two instances.
(pass_lower_switch::execute): Add template argument.
(make_pass_lower_switch): New function.
(make_pass_lower_switch_O0): New function.
(do_jump_if_equal): Remove.
(emit_case_nodes): Simplify to just handle all 3 cases and leave
all the hard work to tree optimization passes.
gcc/testsuite/ChangeLog:
2017-09-14 Martin Liska <mliska@suse.cz>
* gcc.dg/tree-ssa/vrp104.c: Adjust dump file that is scanned.
* gcc.dg/tree-prof/update-loopch.c: Likewise.
---
gcc/passes.def | 3 +
gcc/testsuite/gcc.dg/tree-prof/update-loopch.c | 2 +-
gcc/testsuite/gcc.dg/tree-ssa/vrp104.c | 2 +-
gcc/tree-pass.h | 1 +
gcc/tree-switch-conversion.c | 604 +++----------------------
5 files changed, 72 insertions(+), 540 deletions(-)
diff --git a/gcc/passes.def b/gcc/passes.def
index 3ebcfc30349..050009464ea 100644
--- a/gcc/passes.def
+++ b/gcc/passes.def
@@ -317,6 +317,7 @@ along with GCC; see the file COPYING3. If not see
POP_INSERT_PASSES ()
NEXT_PASS (pass_simduid_cleanup);
NEXT_PASS (pass_lower_vector_ssa);
+ NEXT_PASS (pass_lower_switch);
NEXT_PASS (pass_cse_reciprocals);
NEXT_PASS (pass_sprintf_length, true);
NEXT_PASS (pass_reassoc, false /* insert_powi_p */);
@@ -362,6 +363,7 @@ along with GCC; see the file COPYING3. If not see
/* Lower remaining pieces of GIMPLE. */
NEXT_PASS (pass_lower_complex);
NEXT_PASS (pass_lower_vector_ssa);
+ NEXT_PASS (pass_lower_switch);
/* Perform simple scalar cleanup which is constant/copy propagation. */
NEXT_PASS (pass_ccp, true /* nonzero_p */);
NEXT_PASS (pass_post_ipa_warn);
@@ -397,6 +399,7 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_lower_vaarg);
NEXT_PASS (pass_lower_vector);
NEXT_PASS (pass_lower_complex_O0);
+ NEXT_PASS (pass_lower_switch_O0);
NEXT_PASS (pass_sancov_O0);
NEXT_PASS (pass_lower_switch);
NEXT_PASS (pass_asan_O0);
diff --git a/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c b/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
index 73efc878ec0..15baada1081 100644
--- a/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
+++ b/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
@@ -1,4 +1,4 @@
-/* { dg-options "-O2 -fdump-ipa-profile-blocks-details -fdump-tree-switchlower-blocks-details" } */
+/* { dg-options "-O2 -fdump-ipa-profile-blocks-details -fdump-tree-switchlower1-blocks-details" } */
int max = 33333;
int a[8];
int
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp104.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp104.c
index d4691fcf041..71fa3bfa2ca 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/vrp104.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp104.c
@@ -2,7 +2,7 @@
/* { dg-options "-O2 -fdump-tree-switchlower" } */
/* We scan for 2 switches as the dump file reports a transformation,
IL really contains just a single. */
-/* { dg-final { scan-tree-dump-times "switch \\(i_" 2 "switchlower" } } */
+/* { dg-final { scan-tree-dump-times "switch" 2 "switchlower1" } } */
void foo (void);
void bar (void);
diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h
index 93a6a99eb7a..7625d1963ff 100644
--- a/gcc/tree-pass.h
+++ b/gcc/tree-pass.h
@@ -413,6 +413,7 @@ extern gimple_opt_pass *make_pass_strip_predict_hints (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_complex_O0 (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_complex (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_switch (gcc::context *ctxt);
+extern gimple_opt_pass *make_pass_lower_switch_O0 (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_vector (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_vector_ssa (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_omp (gcc::context *ctxt);
diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c
index b0470ef1b5e..dc60b34f506 100644
--- a/gcc/tree-switch-conversion.c
+++ b/gcc/tree-switch-conversion.c
@@ -1691,9 +1691,6 @@ typedef case_node *case_node_ptr;
static basic_block emit_case_nodes (basic_block, tree, case_node_ptr,
basic_block, tree, profile_probability,
tree, hash_map<tree, tree> *);
-static bool node_has_low_bound (case_node_ptr, tree);
-static bool node_has_high_bound (case_node_ptr, tree);
-static bool node_is_bounded (case_node_ptr, tree);
/* Return the smallest number of different values for which it is best to use a
jump-table instead of a tree of conditional branches. */
@@ -2169,10 +2166,31 @@ try_switch_expansion (gswitch *stmt)
namespace {
-const pass_data pass_data_lower_switch =
+template <bool O0> class pass_lower_switch: public gimple_opt_pass
{
- GIMPLE_PASS, /* type */
- "switchlower", /* name */
+public:
+ pass_lower_switch (gcc::context *ctxt) : gimple_opt_pass (data, ctxt) {}
+
+ static const pass_data data;
+ opt_pass *
+ clone ()
+ {
+ return new pass_lower_switch<O0> (m_ctxt);
+ }
+
+ virtual bool
+ gate (function *)
+ {
+ return !O0 || !optimize;
+ }
+
+ virtual unsigned int execute (function *fun);
+}; // class pass_lower_switch
+
+template <bool O0>
+const pass_data pass_lower_switch<O0>::data = {
+ GIMPLE_PASS, /* type */
+ O0 ? "switchlower_O0" : "switchlower", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_TREE_SWITCH_LOWERING, /* tv_id */
( PROP_cfg | PROP_ssa ), /* properties_required */
@@ -2182,21 +2200,9 @@ const pass_data pass_data_lower_switch =
TODO_update_ssa | TODO_cleanup_cfg, /* todo_flags_finish */
};
-class pass_lower_switch : public gimple_opt_pass
-{
-public:
- pass_lower_switch (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_lower_switch, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return true; }
- virtual unsigned int execute (function *);
-
-}; // class pass_lower_switch
-
+template <bool O0>
unsigned int
-pass_lower_switch::execute (function *fun)
+pass_lower_switch<O0>::execute (function *fun)
{
basic_block bb;
bool expanded = false;
@@ -2234,33 +2240,14 @@ pass_lower_switch::execute (function *fun)
} // anon namespace
gimple_opt_pass *
-make_pass_lower_switch (gcc::context *ctxt)
+make_pass_lower_switch_O0 (gcc::context *ctxt)
{
- return new pass_lower_switch (ctxt);
+ return new pass_lower_switch<true> (ctxt);
}
-
-/* Generate code to jump to LABEL if OP0 and OP1 are equal in mode MODE.
- PROB is the probability of jumping to LABEL. */
-static basic_block
-do_jump_if_equal (basic_block bb, tree op0, tree op1, basic_block label_bb,
- profile_probability prob, hash_map<tree, tree> *phi_mapping)
+gimple_opt_pass *
+make_pass_lower_switch (gcc::context *ctxt)
{
- gcond *cond = gimple_build_cond (EQ_EXPR, op0, op1, NULL_TREE, NULL_TREE);
- gimple_stmt_iterator gsi = gsi_last_bb (bb);
- gsi_insert_before (&gsi, cond, GSI_SAME_STMT);
-
- gcc_assert (single_succ_p (bb));
-
- /* Make a new basic block where false branch will take place. */
- edge false_edge = split_block (bb, cond);
- false_edge->flags = EDGE_FALSE_VALUE;
- false_edge->probability = prob.invert ();
-
- edge true_edge = make_edge (bb, label_bb, EDGE_TRUE_VALUE);
- fix_phi_operands_for_edge (true_edge, phi_mapping);
- true_edge->probability = prob;
-
- return false_edge->dest;
+ return new pass_lower_switch<false> (ctxt);
}
/* Generate code to compare X with Y so that the condition codes are
@@ -2323,28 +2310,7 @@ conditional_probability (profile_probability target_prob,
/* Emit step-by-step code to select a case for the value of INDEX.
The thus generated decision tree follows the form of the
case-node binary tree NODE, whose nodes represent test conditions.
- INDEX_TYPE is the type of the index of the switch.
-
- Care is taken to prune redundant tests from the decision tree
- by detecting any boundary conditions already checked by
- emitted rtx. (See node_has_high_bound, node_has_low_bound
- and node_is_bounded, above.)
-
- Where the test conditions can be shown to be redundant we emit
- an unconditional jump to the target code. As a further
- optimization, the subordinates of a tree node are examined to
- check for bounded nodes. In this case conditional and/or
- unconditional jumps as a result of the boundary check for the
- current node are arranged to target the subordinates associated
- code for out of bound conditions on the current node.
-
- We can assume that when control reaches the code generated here,
- the index value has already been compared with the parents
- of this node, and determined to be on the same side of each parent
- as this node is. Thus, if this node tests for the value 51,
- and a parent tested for 52, we don't need to consider
- the possibility of a value greater than 51. If another parent
- tests for the value 50, then this node need not test anything. */
+ INDEX_TYPE is the type of the index of the switch. */
static basic_block
emit_case_nodes (basic_block bb, tree index, case_node_ptr node,
@@ -2352,482 +2318,44 @@ emit_case_nodes (basic_block bb, tree index, case_node_ptr node,
profile_probability default_prob, tree index_type,
hash_map<tree, tree> *phi_mapping)
{
- /* If INDEX has an unsigned type, we must make unsigned branches. */
- profile_probability probability;
- profile_probability prob = node->prob, subtree_prob = node->subtree_prob;
-
- /* See if our parents have already tested everything for us.
- If they have, emit an unconditional jump for this node. */
- if (node_is_bounded (node, index_type))
- {
- emit_jump (bb, node->case_bb, phi_mapping);
- return NULL;
- }
-
- else if (tree_int_cst_equal (node->low, node->high))
- {
- probability = conditional_probability (prob, subtree_prob + default_prob);
- /* Node is single valued. First see if the index expression matches
- this node and then check our children, if any. */
- bb = do_jump_if_equal (bb, index, node->low, node->case_bb, probability,
- phi_mapping);
- /* Since this case is taken at this point, reduce its weight from
- subtree_weight. */
- subtree_prob -= prob;
- if (node->right != 0 && node->left != 0)
- {
- /* This node has children on both sides.
- Dispatch to one side or the other
- by comparing the index value with this node's value.
- If one subtree is bounded, check that one first,
- so we can avoid real branches in the tree. */
-
- if (node_is_bounded (node->right, index_type))
- {
- probability
- = conditional_probability (node->right->prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- node->right->case_bb, probability,
- phi_mapping);
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
-
- else if (node_is_bounded (node->left, index_type))
- {
- probability
- = conditional_probability (node->left->prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, LT_EXPR,
- node->left->case_bb, probability,
- phi_mapping);
- bb = emit_case_nodes (bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
-
- /* If both children are single-valued cases with no
- children, finish up all the work. This way, we can save
- one ordered comparison. */
- else if (tree_int_cst_equal (node->right->low, node->right->high)
- && node->right->left == 0 && node->right->right == 0
- && tree_int_cst_equal (node->left->low, node->left->high)
- && node->left->left == 0 && node->left->right == 0)
- {
- /* Neither node is bounded. First distinguish the two sides;
- then emit the code for one side at a time. */
-
- /* See if the value matches what the right hand side
- wants. */
- probability
- = conditional_probability (node->right->prob,
- subtree_prob + default_prob);
- bb = do_jump_if_equal (bb, index, node->right->low,
- node->right->case_bb, probability,
- phi_mapping);
-
- /* See if the value matches what the left hand side
- wants. */
- probability
- = conditional_probability (node->left->prob,
- subtree_prob + default_prob);
- bb = do_jump_if_equal (bb, index, node->left->low,
- node->left->case_bb, probability,
- phi_mapping);
- }
-
- else
- {
- /* Neither node is bounded. First distinguish the two sides;
- then emit the code for one side at a time. */
-
- basic_block test_bb = split_edge (single_succ_edge (bb));
- redirect_edge_succ (single_pred_edge (test_bb),
- single_succ_edge (bb)->dest);
-
- /* The default label could be reached either through the right
- subtree or the left subtree. Divide the probability
- equally. */
- probability
- = conditional_probability (node->right->subtree_prob
- + default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- /* See if the value is on the right. */
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- test_bb, probability, phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
-
- /* Value must be on the left.
- Handle the left-hand subtree. */
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- /* If left-hand subtree does nothing,
- go to default. */
-
- if (bb && default_bb)
- emit_jump (bb, default_bb, phi_mapping);
-
- /* Code branches here for the right-hand subtree. */
- bb = emit_case_nodes (test_bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
- }
- else if (node->right != 0 && node->left == 0)
- {
- /* Here we have a right child but no left so we issue a conditional
- branch to default and process the right child.
-
- Omit the conditional branch to default if the right child
- does not have any children and is single valued; it would
- cost too much space to save so little time. */
-
- if (node->right->right || node->right->left
- || !tree_int_cst_equal (node->right->low, node->right->high))
- {
- if (!node_has_low_bound (node, index_type))
- {
- probability
- = conditional_probability (default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, LT_EXPR,
- default_bb, probability,
- phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
- }
-
- bb = emit_case_nodes (bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
- else
- {
- probability
- = conditional_probability (node->right->subtree_prob,
- subtree_prob + default_prob);
- /* We cannot process node->right normally
- since we haven't ruled out the numbers less than
- this node's value. So handle node->right explicitly. */
- bb = do_jump_if_equal (bb, index, node->right->low,
- node->right->case_bb, probability,
- phi_mapping);
- }
- }
-
- else if (node->right == 0 && node->left != 0)
- {
- /* Just one subtree, on the left. */
- if (node->left->left || node->left->right
- || !tree_int_cst_equal (node->left->low, node->left->high))
- {
- if (!node_has_high_bound (node, index_type))
- {
- probability
- = conditional_probability (default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- default_bb, probability,
- phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
- }
-
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
- else
- {
- probability
- = conditional_probability (node->left->subtree_prob,
- subtree_prob + default_prob);
- /* We cannot process node->left normally
- since we haven't ruled out the numbers less than
- this node's value. So handle node->left explicitly. */
- do_jump_if_equal (bb, index, node->left->low, node->left->case_bb,
- probability, phi_mapping);
- }
- }
- }
- else
- {
- /* Node is a range. These cases are very similar to those for a single
- value, except that we do not start by testing whether this node
- is the one to branch to. */
-
- if (node->right != 0 && node->left != 0)
- {
- /* Node has subtrees on both sides.
- If the right-hand subtree is bounded,
- test for it first, since we can go straight there.
- Otherwise, we need to make a branch in the control structure,
- then handle the two subtrees. */
- basic_block test_bb = NULL;
-
- if (node_is_bounded (node->right, index_type))
- {
- /* Right hand node is fully bounded so we can eliminate any
- testing and branch directly to the target code. */
- probability
- = conditional_probability (node->right->subtree_prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- node->right->case_bb, probability,
- phi_mapping);
- }
- else
- {
- /* Right hand node requires testing.
- Branch to a label where we will handle it later. */
-
- test_bb = split_edge (single_succ_edge (bb));
- redirect_edge_succ (single_pred_edge (test_bb),
- single_succ_edge (bb)->dest);
-
- probability
- = conditional_probability (node->right->subtree_prob
- + default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- test_bb, probability, phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
- }
-
- /* Value belongs to this node or to the left-hand subtree. */
-
- probability
- = conditional_probability (prob, subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->low, GE_EXPR,
- node->case_bb, probability,
- phi_mapping);
-
- /* Handle the left-hand subtree. */
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
+ /* If node is null, we are done. */
+ if (node == NULL)
+ return bb;
+
+ /* Branch to a label where we will handle it later. */
+ basic_block test_bb = split_edge (single_succ_edge (bb));
+ redirect_edge_succ (single_pred_edge (test_bb),
+ single_succ_edge (bb)->dest);
+
+ profile_probability probability
+ = node->right ? node->right->subtree_prob : profile_probability::never ();
+ probability
+ = conditional_probability (probability + default_prob.apply_scale (1, 2),
+ node->subtree_prob + default_prob);
+ bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
+ test_bb, probability, phi_mapping);
+ default_prob = default_prob.apply_scale (1, 2);
+
+ /* Value belongs to this node or to the left-hand subtree. */
+ probability
+ = conditional_probability (node->prob, node->subtree_prob + default_prob);
+ bb = emit_cmp_and_jump_insns (bb, index, node->low, GE_EXPR,
+ node->case_bb, probability,
phi_mapping);
- /* If right node had to be handled later, do that now. */
- if (test_bb)
- {
- /* If the left-hand subtree fell through,
- don't let it fall into the right-hand subtree. */
- if (bb && default_bb)
- emit_jump (bb, default_bb, phi_mapping);
-
- bb = emit_case_nodes (test_bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
- }
-
- else if (node->right != 0 && node->left == 0)
- {
- /* Deal with values to the left of this node,
- if they are possible. */
- if (!node_has_low_bound (node, index_type))
- {
- probability
- = conditional_probability (default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->low, LT_EXPR,
- default_bb, probability,
- phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
- }
-
- /* Value belongs to this node or to the right-hand subtree. */
-
- probability
- = conditional_probability (prob, subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, LE_EXPR,
- node->case_bb, probability,
- phi_mapping);
-
- bb = emit_case_nodes (bb, index, node->right, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
-
- else if (node->right == 0 && node->left != 0)
- {
- /* Deal with values to the right of this node,
- if they are possible. */
- if (!node_has_high_bound (node, index_type))
- {
- probability
- = conditional_probability (default_prob.apply_scale (1, 2),
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- default_bb, probability,
- phi_mapping);
- default_prob = default_prob.apply_scale (1, 2);
- }
-
- /* Value belongs to this node or to the left-hand subtree. */
+ /* Handle the left-hand subtree. */
+ bb = emit_case_nodes (bb, index, node->left, default_bb,
+ default_label, default_prob, index_type,
+ phi_mapping);
- probability
- = conditional_probability (prob, subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->low, GE_EXPR,
- node->case_bb, probability,
- phi_mapping);
-
- bb = emit_case_nodes (bb, index, node->left, default_bb,
- default_label, default_prob, index_type,
- phi_mapping);
- }
-
- else
- {
- /* Node has no children so we check low and high bounds to remove
- redundant tests. Only one of the bounds can exist,
- since otherwise this node is bounded--a case tested already. */
- bool high_bound = node_has_high_bound (node, index_type);
- bool low_bound = node_has_low_bound (node, index_type);
-
- if (!high_bound && low_bound)
- {
- probability
- = conditional_probability (default_prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->high, GT_EXPR,
- default_bb, probability,
- phi_mapping);
- }
-
- else if (!low_bound && high_bound)
- {
- probability
- = conditional_probability (default_prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, index, node->low, LT_EXPR,
- default_bb, probability,
- phi_mapping);
- }
- else if (!low_bound && !high_bound)
- {
- tree lhs, rhs;
- generate_range_test (bb, index, node->low, node->high,
- &lhs, &rhs);
- probability
- = conditional_probability (default_prob,
- subtree_prob + default_prob);
- bb = emit_cmp_and_jump_insns (bb, lhs, rhs, GT_EXPR,
- default_bb, probability,
- phi_mapping);
- }
+ /* If the left-hand subtree fell through,
+ don't let it fall into the right-hand subtree. */
+ if (default_bb)
+ emit_jump (bb, default_bb, phi_mapping);
- emit_jump (bb, node->case_bb, phi_mapping);
- return NULL;
- }
- }
+ bb = emit_case_nodes (test_bb, index, node->right, default_bb,
+ default_label, default_prob, index_type,
+ phi_mapping);
return bb;
}
-
-/* Search the parent sections of the case node tree
- to see if a test for the lower bound of NODE would be redundant.
- INDEX_TYPE is the type of the index expression.
-
- The instructions to generate the case decision tree are
- output in the same order as nodes are processed so it is
- known that if a parent node checks the range of the current
- node minus one that the current node is bounded at its lower
- span. Thus the test would be redundant. */
-
-static bool
-node_has_low_bound (case_node_ptr node, tree index_type)
-{
- tree low_minus_one;
- case_node_ptr pnode;
-
- /* If the lower bound of this node is the lowest value in the index type,
- we need not test it. */
-
- if (tree_int_cst_equal (node->low, TYPE_MIN_VALUE (index_type)))
- return true;
-
- /* If this node has a left branch, the value at the left must be less
- than that at this node, so it cannot be bounded at the bottom and
- we need not bother testing any further. */
-
- if (node->left)
- return false;
-
- low_minus_one = fold_build2 (MINUS_EXPR, TREE_TYPE (node->low), node->low,
- build_int_cst (TREE_TYPE (node->low), 1));
-
- /* If the subtraction above overflowed, we can't verify anything.
- Otherwise, look for a parent that tests our value - 1. */
-
- if (!tree_int_cst_lt (low_minus_one, node->low))
- return false;
-
- for (pnode = node->parent; pnode; pnode = pnode->parent)
- if (tree_int_cst_equal (low_minus_one, pnode->high))
- return true;
-
- return false;
-}
-
-/* Search the parent sections of the case node tree
- to see if a test for the upper bound of NODE would be redundant.
- INDEX_TYPE is the type of the index expression.
-
- The instructions to generate the case decision tree are
- output in the same order as nodes are processed so it is
- known that if a parent node checks the range of the current
- node plus one that the current node is bounded at its upper
- span. Thus the test would be redundant. */
-
-static bool
-node_has_high_bound (case_node_ptr node, tree index_type)
-{
- tree high_plus_one;
- case_node_ptr pnode;
-
- /* If there is no upper bound, obviously no test is needed. */
-
- if (TYPE_MAX_VALUE (index_type) == NULL)
- return true;
-
- /* If the upper bound of this node is the highest value in the type
- of the index expression, we need not test against it. */
-
- if (tree_int_cst_equal (node->high, TYPE_MAX_VALUE (index_type)))
- return true;
-
- /* If this node has a right branch, the value at the right must be greater
- than that at this node, so it cannot be bounded at the top and
- we need not bother testing any further. */
-
- if (node->right)
- return false;
-
- high_plus_one = fold_build2 (PLUS_EXPR, TREE_TYPE (node->high), node->high,
- build_int_cst (TREE_TYPE (node->high), 1));
-
- /* If the addition above overflowed, we can't verify anything.
- Otherwise, look for a parent that tests our value + 1. */
-
- if (!tree_int_cst_lt (node->high, high_plus_one))
- return false;
-
- for (pnode = node->parent; pnode; pnode = pnode->parent)
- if (tree_int_cst_equal (high_plus_one, pnode->low))
- return true;
-
- return false;
-}
-
-/* Search the parent sections of the
- case node tree to see if both tests for the upper and lower
- bounds of NODE would be redundant. */
-
-static bool
-node_is_bounded (case_node_ptr node, tree index_type)
-{
- return (node_has_low_bound (node, index_type)
- && node_has_high_bound (node, index_type));
-}
--
2.16.3
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-17 10:39 ` Martin Liška
@ 2018-05-18 13:57 ` Rainer Orth
2018-05-18 14:19 ` Martin Liška
0 siblings, 1 reply; 28+ messages in thread
From: Rainer Orth @ 2018-05-18 13:57 UTC (permalink / raw)
To: Martin Liška
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law
Hi Martin,
> So the patch looks fine, only very very slightly binary is produced. I'm
> going to install the patch so that
> I can carry on more complex patches based on this one.
it seems you didn't properly test the testsuite part: I see
+UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower "Removing basic block"
+UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower "loop depth 1, count 33333"
+UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not switchlower "Invalid sum"
+UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not switchlower "loop depth 1, count 33332"
everywhere. The log has
gcc.dg/tree-prof/update-loopch.c: dump file does not exist
Obviously you forgot the adapt the dg-final* files for the dumpfile
name. If I do, three of the failures go away, but
FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
remains (on 32 and 64-bit Linux/x86_64).
Please fix.
Rainer
--
-----------------------------------------------------------------------------
Rainer Orth, Center for Biotechnology, Bielefeld University
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-18 13:57 ` Rainer Orth
@ 2018-05-18 14:19 ` Martin Liška
2018-05-21 11:29 ` Rainer Orth
0 siblings, 1 reply; 28+ messages in thread
From: Martin Liška @ 2018-05-18 14:19 UTC (permalink / raw)
To: Rainer Orth
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law
[-- Attachment #1: Type: text/plain, Size: 1225 bytes --]
On 05/18/2018 03:55 PM, Rainer Orth wrote:
> Hi Martin,
>
>> So the patch looks fine, only very very slightly binary is produced. I'm
>> going to install the patch so that
>> I can carry on more complex patches based on this one.
>
> it seems you didn't properly test the testsuite part: I see
>
> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower "Removing basic block"
> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower "loop depth 1, count 33333"
> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not switchlower "Invalid sum"
> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not switchlower "loop depth 1, count 33332"
>
> everywhere. The log has
>
> gcc.dg/tree-prof/update-loopch.c: dump file does not exist
>
> Obviously you forgot the adapt the dg-final* files for the dumpfile
> name. If I do, three of the failures go away, but
>
> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
>
> remains (on 32 and 64-bit Linux/x86_64).
>
> Please fix.
>
> Rainer
>
Thanks for opened eyes, following patch will fix that.
It's quite obvious, I'll install it right after tests will finish.
Martin
[-- Attachment #2: 0001-Remove-redundand-pass-pass_lower_switch.patch --]
[-- Type: text/x-patch, Size: 913 bytes --]
From 7ae0c7d4a81166dbf5e9dff5d35e4c9d63b1c058 Mon Sep 17 00:00:00 2001
From: marxin <mliska@suse.cz>
Date: Fri, 18 May 2018 16:17:57 +0200
Subject: [PATCH] Remove redundand pass pass_lower_switch.
gcc/ChangeLog:
2018-05-18 Martin Liska <mliska@suse.cz>
* passes.def: Remove a redundant pass.
---
gcc/passes.def | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/gcc/passes.def b/gcc/passes.def
index 050009464ea..055d354f959 100644
--- a/gcc/passes.def
+++ b/gcc/passes.def
@@ -399,9 +399,8 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_lower_vaarg);
NEXT_PASS (pass_lower_vector);
NEXT_PASS (pass_lower_complex_O0);
- NEXT_PASS (pass_lower_switch_O0);
NEXT_PASS (pass_sancov_O0);
- NEXT_PASS (pass_lower_switch);
+ NEXT_PASS (pass_lower_switch_O0);
NEXT_PASS (pass_asan_O0);
NEXT_PASS (pass_tsan_O0);
NEXT_PASS (pass_sanopt);
--
2.16.3
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-18 14:19 ` Martin Liška
@ 2018-05-21 11:29 ` Rainer Orth
2018-05-21 14:00 ` Martin Liška
0 siblings, 1 reply; 28+ messages in thread
From: Rainer Orth @ 2018-05-21 11:29 UTC (permalink / raw)
To: Martin Liška
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law
[-- Attachment #1: Type: text/plain, Size: 2738 bytes --]
Hi Martin,
> On 05/18/2018 03:55 PM, Rainer Orth wrote:
>> Hi Martin,
>>
>>> So the patch looks fine, only very very slightly binary is produced. I'm
>>> going to install the patch so that
>>> I can carry on more complex patches based on this one.
>>
>> it seems you didn't properly test the testsuite part: I see
>>
>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower
>> "Removing basic block"
>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower
>> "loop depth 1, count 33333"
>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not
>> switchlower "Invalid sum"
>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not
>> switchlower "loop depth 1, count 33332"
>>
>> everywhere. The log has
>>
>> gcc.dg/tree-prof/update-loopch.c: dump file does not exist
>>
>> Obviously you forgot the adapt the dg-final* files for the dumpfile
>> name. If I do, three of the failures go away, but
>>
>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1
>> "Removing basic block"
>>
>> remains (on 32 and 64-bit Linux/x86_64).
>>
>> Please fix.
>>
>> Rainer
>>
>
> Thanks for opened eyes, following patch will fix that.
> It's quite obvious, I'll install it right after tests will finish.
unfortunately, it didn't fix either issue:
* The switchlower -> switchlower1 renames in the dg-final* lines
(attached) are still necessary to avoid the UNRESOLVED errors.
Although obvious, I haven't installed them since ...
* ... even so
FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
remains.
Rainer
> From 7ae0c7d4a81166dbf5e9dff5d35e4c9d63b1c058 Mon Sep 17 00:00:00 2001
> From: marxin <mliska@suse.cz>
> Date: Fri, 18 May 2018 16:17:57 +0200
> Subject: [PATCH] Remove redundand pass pass_lower_switch.
>
> gcc/ChangeLog:
>
> 2018-05-18 Martin Liska <mliska@suse.cz>
>
> * passes.def: Remove a redundant pass.
> ---
> gcc/passes.def | 3 +--
> 1 file changed, 1 insertion(+), 2 deletions(-)
>
> diff --git a/gcc/passes.def b/gcc/passes.def
> index 050009464ea..055d354f959 100644
> --- a/gcc/passes.def
> +++ b/gcc/passes.def
> @@ -399,9 +399,8 @@ along with GCC; see the file COPYING3. If not see
> NEXT_PASS (pass_lower_vaarg);
> NEXT_PASS (pass_lower_vector);
> NEXT_PASS (pass_lower_complex_O0);
> - NEXT_PASS (pass_lower_switch_O0);
> NEXT_PASS (pass_sancov_O0);
> - NEXT_PASS (pass_lower_switch);
> + NEXT_PASS (pass_lower_switch_O0);
> NEXT_PASS (pass_asan_O0);
> NEXT_PASS (pass_tsan_O0);
> NEXT_PASS (pass_sanopt);
--
-----------------------------------------------------------------------------
Rainer Orth, Center for Biotechnology, Bielefeld University
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: ul.patch --]
[-- Type: text/x-patch, Size: 1117 bytes --]
diff --git a/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c b/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
--- a/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
+++ b/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
@@ -16,7 +16,7 @@ main ()
edge. */
/* autofdo cannot do that precise counts */
/* { dg-final-use-not-autofdo { scan-ipa-dump "loop depth 1, count 33334" "profile"} } */
-/* { dg-final-use-not-autofdo { scan-tree-dump "loop depth 1, count 33333" "switchlower"} } */
-/* { dg-final-use-not-autofdo { scan-tree-dump-not "loop depth 1, count 33332" "switchlower"} } */
-/* { dg-final-use-not-autofdo { scan-tree-dump "Removing basic block" "switchlower"} } */
-/* { dg-final-use { scan-tree-dump-not "Invalid sum" "switchlower"} } */
+/* { dg-final-use-not-autofdo { scan-tree-dump "loop depth 1, count 33333" "switchlower1"} } */
+/* { dg-final-use-not-autofdo { scan-tree-dump-not "loop depth 1, count 33332" "switchlower1"} } */
+/* { dg-final-use-not-autofdo { scan-tree-dump "Removing basic block" "switchlower1"} } */
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "switchlower1"} } */
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-21 11:29 ` Rainer Orth
@ 2018-05-21 14:00 ` Martin Liška
2018-05-21 14:10 ` Rainer Orth
2018-05-24 12:52 ` Rainer Orth
0 siblings, 2 replies; 28+ messages in thread
From: Martin Liška @ 2018-05-21 14:00 UTC (permalink / raw)
To: Rainer Orth
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law
On 05/21/2018 01:18 PM, Rainer Orth wrote:
> Hi Martin,
>
>> On 05/18/2018 03:55 PM, Rainer Orth wrote:
>>> Hi Martin,
>>>
>>>> So the patch looks fine, only very very slightly binary is produced. I'm
>>>> going to install the patch so that
>>>> I can carry on more complex patches based on this one.
>>>
>>> it seems you didn't properly test the testsuite part: I see
>>>
>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower
>>> "Removing basic block"
>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower
>>> "loop depth 1, count 33333"
>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not
>>> switchlower "Invalid sum"
>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not
>>> switchlower "loop depth 1, count 33332"
>>>
>>> everywhere. The log has
>>>
>>> gcc.dg/tree-prof/update-loopch.c: dump file does not exist
>>>
>>> Obviously you forgot the adapt the dg-final* files for the dumpfile
>>> name. If I do, three of the failures go away, but
>>>
>>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1
>>> "Removing basic block"
>>>
>>> remains (on 32 and 64-bit Linux/x86_64).
>>>
>>> Please fix.
>>>
>>> Rainer
>>>
>>
>> Thanks for opened eyes, following patch will fix that.
>> It's quite obvious, I'll install it right after tests will finish.
>
> unfortunately, it didn't fix either issue:
>
> * The switchlower -> switchlower1 renames in the dg-final* lines
> (attached) are still necessary to avoid the UNRESOLVED errors.
> Although obvious, I haven't installed them since ...
>
> * ... even so
>
> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
>
> remains.
>
> Rainer
Hi.
You are right, it's using -O2, thus your patch is right. Please install the patch
after testing. It's obvious fix.
Martin
>
>
>> From 7ae0c7d4a81166dbf5e9dff5d35e4c9d63b1c058 Mon Sep 17 00:00:00 2001
>> From: marxin <mliska@suse.cz>
>> Date: Fri, 18 May 2018 16:17:57 +0200
>> Subject: [PATCH] Remove redundand pass pass_lower_switch.
>>
>> gcc/ChangeLog:
>>
>> 2018-05-18 Martin Liska <mliska@suse.cz>
>>
>> * passes.def: Remove a redundant pass.
>> ---
>> gcc/passes.def | 3 +--
>> 1 file changed, 1 insertion(+), 2 deletions(-)
>>
>> diff --git a/gcc/passes.def b/gcc/passes.def
>> index 050009464ea..055d354f959 100644
>> --- a/gcc/passes.def
>> +++ b/gcc/passes.def
>> @@ -399,9 +399,8 @@ along with GCC; see the file COPYING3. If not see
>> NEXT_PASS (pass_lower_vaarg);
>> NEXT_PASS (pass_lower_vector);
>> NEXT_PASS (pass_lower_complex_O0);
>> - NEXT_PASS (pass_lower_switch_O0);
>> NEXT_PASS (pass_sancov_O0);
>> - NEXT_PASS (pass_lower_switch);
>> + NEXT_PASS (pass_lower_switch_O0);
>> NEXT_PASS (pass_asan_O0);
>> NEXT_PASS (pass_tsan_O0);
>> NEXT_PASS (pass_sanopt);
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-21 14:00 ` Martin Liška
@ 2018-05-21 14:10 ` Rainer Orth
2018-05-21 14:54 ` Sudakshina Das
2018-05-24 12:52 ` Rainer Orth
1 sibling, 1 reply; 28+ messages in thread
From: Rainer Orth @ 2018-05-21 14:10 UTC (permalink / raw)
To: Martin Liška
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law
Hi Martin,
>>> Thanks for opened eyes, following patch will fix that.
>>> It's quite obvious, I'll install it right after tests will finish.
>>
>> unfortunately, it didn't fix either issue:
>>
>> * The switchlower -> switchlower1 renames in the dg-final* lines
>> (attached) are still necessary to avoid the UNRESOLVED errors.
>> Although obvious, I haven't installed them since ...
>>
>> * ... even so
>>
>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
>>
>> remains.
[...]
> You are right, it's using -O2, thus your patch is right. Please install the
> patch
> after testing. It's obvious fix.
But what about the remaining FAIL?
Rainer
--
-----------------------------------------------------------------------------
Rainer Orth, Center for Biotechnology, Bielefeld University
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-21 14:10 ` Rainer Orth
@ 2018-05-21 14:54 ` Sudakshina Das
2018-05-24 19:59 ` Martin Liška
2018-05-25 10:01 ` Martin Liška
0 siblings, 2 replies; 28+ messages in thread
From: Sudakshina Das @ 2018-05-21 14:54 UTC (permalink / raw)
To: Rainer Orth, Martin Liška
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law, nd
On 21/05/18 15:00, Rainer Orth wrote:
> Hi Martin,
>
>>>> Thanks for opened eyes, following patch will fix that.
>>>> It's quite obvious, I'll install it right after tests will finish.
>>>
>>> unfortunately, it didn't fix either issue:
>>>
>>> * The switchlower -> switchlower1 renames in the dg-final* lines
>>> (attached) are still necessary to avoid the UNRESOLVED errors.
>>> Although obvious, I haven't installed them since ...
>>>
>>> * ... even so
>>>
>>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
>>>
>>> remains.
> [...]
>> You are right, it's using -O2, thus your patch is right. Please install the
>> patch
>> after testing. It's obvious fix.
>
> But what about the remaining FAIL?
>
Sorry to add to this, but I have also observed the following failures on
aarch64-none-elf, aarch64-none-linux-gnu and aarch64_be-none-elf
targets bisected to this commit:
FAIL: gcc.dg/sancov/cmp0.c -O0 scan-tree-dump-times optimized
"__builtin___sanitizer_cov_trace_const_cmp" 7
FAIL: gcc.dg/sancov/cmp0.c -O0 scan-tree-dump-times optimized
"__builtin___sanitizer_cov_trace_switch \\(" 2
FAIL: gcc.dg/sancov/cmp0.c -O0 -g scan-tree-dump-times optimized
"__builtin___sanitizer_cov_trace_const_cmp" 7
FAIL: gcc.dg/sancov/cmp0.c -O0 -g scan-tree-dump-times optimized
"__builtin___sanitizer_cov_trace_switch \\(" 2
FAIL: gcc.dg/tree-ssa/pr77445-2.c scan-tree-dump-not thread3 "not
considered"
FAIL: gcc.dg/tree-ssa/ssa-dom-thread-7.c scan-tree-dump-not vrp2 "Jumps
threaded"
Sudi
> Rainer
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-21 14:00 ` Martin Liška
2018-05-21 14:10 ` Rainer Orth
@ 2018-05-24 12:52 ` Rainer Orth
2018-05-24 20:10 ` Martin Liška
1 sibling, 1 reply; 28+ messages in thread
From: Rainer Orth @ 2018-05-24 12:52 UTC (permalink / raw)
To: Martin Liška
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law
Hi Martin,
> On 05/21/2018 01:18 PM, Rainer Orth wrote:
>> Hi Martin,
>>
>>> On 05/18/2018 03:55 PM, Rainer Orth wrote:
>>>> Hi Martin,
>>>>
>>>>> So the patch looks fine, only very very slightly binary is produced. I'm
>>>>> going to install the patch so that
>>>>> I can carry on more complex patches based on this one.
>>>>
>>>> it seems you didn't properly test the testsuite part: I see
>>>>
>>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower
>>>> "Removing basic block"
>>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower
>>>> "loop depth 1, count 33333"
>>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not
>>>> switchlower "Invalid sum"
>>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not
>>>> switchlower "loop depth 1, count 33332"
>>>>
>>>> everywhere. The log has
>>>>
>>>> gcc.dg/tree-prof/update-loopch.c: dump file does not exist
>>>>
>>>> Obviously you forgot the adapt the dg-final* files for the dumpfile
>>>> name. If I do, three of the failures go away, but
>>>>
>>>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1
>>>> "Removing basic block"
>>>>
>>>> remains (on 32 and 64-bit Linux/x86_64).
>>>>
>>>> Please fix.
>>>>
>>>> Rainer
>>>>
>>>
>>> Thanks for opened eyes, following patch will fix that.
>>> It's quite obvious, I'll install it right after tests will finish.
>>
>> unfortunately, it didn't fix either issue:
>>
>> * The switchlower -> switchlower1 renames in the dg-final* lines
>> (attached) are still necessary to avoid the UNRESOLVED errors.
>> Although obvious, I haven't installed them since ...
>>
>> * ... even so
>>
>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
>>
>> remains.
>>
>> Rainer
>
> Hi.
>
> You are right, it's using -O2, thus your patch is right. Please install the
> patch
> after testing. It's obvious fix.
I've now installed the fix for the dumpfile renaming. However, you've
still done nothing about the remaining failure.
Rainer
--
-----------------------------------------------------------------------------
Rainer Orth, Center for Biotechnology, Bielefeld University
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-21 14:54 ` Sudakshina Das
@ 2018-05-24 19:59 ` Martin Liška
2018-05-25 10:01 ` Martin Liška
1 sibling, 0 replies; 28+ messages in thread
From: Martin Liška @ 2018-05-24 19:59 UTC (permalink / raw)
To: Sudakshina Das, Rainer Orth
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law, nd
On 05/21/2018 04:42 PM, Sudakshina Das wrote:
> On 21/05/18 15:00, Rainer Orth wrote:
>> Hi Martin,
>>
>>>>> Thanks for opened eyes, following patch will fix that.
>>>>> It's quite obvious, I'll install it right after tests will finish.
>>>>
>>>> unfortunately, it didn't fix either issue:
>>>>
>>>> * The switchlower -> switchlower1 renames in the dg-final* lines
>>>> Â Â (attached) are still necessary to avoid the UNRESOLVED errors.
>>>> Â Â Although obvious, I haven't installed them since ...
>>>>
>>>> * ... even so
>>>>
>>>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
>>>>
>>>> Â Â remains.
>> [...]
>>> You are right, it's using -O2, thus your patch is right. Please install the
>>> patch
>>> after testing. It's obvious fix.
>>
>> But what about the remaining FAIL?
>>
>
> Sorry to add to this, but I have also observed the following failures on  aarch64-none-elf, aarch64-none-linux-gnu and aarch64_be-none-elf targets bisected to this commit:
>
> FAIL: gcc.dg/sancov/cmp0.c  -O0  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_const_cmp" 7
>
> FAIL: gcc.dg/sancov/cmp0.c  -O0  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_switch \\(" 2
>
> FAIL: gcc.dg/sancov/cmp0.c  -O0 -g  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_const_cmp" 7
>
> FAIL: gcc.dg/sancov/cmp0.c  -O0 -g  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_switch \\(" 2
>
> FAIL: gcc.dg/tree-ssa/pr77445-2.c scan-tree-dump-not thread3 "not considered"
>
> FAIL: gcc.dg/tree-ssa/ssa-dom-thread-7.c scan-tree-dump-not vrp2 "Jumps threaded"
>
> Sudi
Hi.
Sorry for the breakage, I'll fix it in couple of days.
Martin
>
>> Â Â Â Â Rainer
>>
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-24 12:52 ` Rainer Orth
@ 2018-05-24 20:10 ` Martin Liška
0 siblings, 0 replies; 28+ messages in thread
From: Martin Liška @ 2018-05-24 20:10 UTC (permalink / raw)
To: Rainer Orth
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law
On 05/24/2018 02:28 PM, Rainer Orth wrote:
> Hi Martin,
>
>> On 05/21/2018 01:18 PM, Rainer Orth wrote:
>>> Hi Martin,
>>>
>>>> On 05/18/2018 03:55 PM, Rainer Orth wrote:
>>>>> Hi Martin,
>>>>>
>>>>>> So the patch looks fine, only very very slightly binary is produced. I'm
>>>>>> going to install the patch so that
>>>>>> I can carry on more complex patches based on this one.
>>>>>
>>>>> it seems you didn't properly test the testsuite part: I see
>>>>>
>>>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower
>>>>> "Removing basic block"
>>>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower
>>>>> "loop depth 1, count 33333"
>>>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not
>>>>> switchlower "Invalid sum"
>>>>> +UNRESOLVED: gcc.dg/tree-prof/update-loopch.c scan-tree-dump-not
>>>>> switchlower "loop depth 1, count 33332"
>>>>>
>>>>> everywhere. The log has
>>>>>
>>>>> gcc.dg/tree-prof/update-loopch.c: dump file does not exist
>>>>>
>>>>> Obviously you forgot the adapt the dg-final* files for the dumpfile
>>>>> name. If I do, three of the failures go away, but
>>>>>
>>>>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1
>>>>> "Removing basic block"
>>>>>
>>>>> remains (on 32 and 64-bit Linux/x86_64).
>>>>>
>>>>> Please fix.
>>>>>
>>>>> Rainer
>>>>>
>>>>
>>>> Thanks for opened eyes, following patch will fix that.
>>>> It's quite obvious, I'll install it right after tests will finish.
>>>
>>> unfortunately, it didn't fix either issue:
>>>
>>> * The switchlower -> switchlower1 renames in the dg-final* lines
>>> (attached) are still necessary to avoid the UNRESOLVED errors.
>>> Although obvious, I haven't installed them since ...
>>>
>>> * ... even so
>>>
>>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
>>>
>>> remains.
>>>
>>> Rainer
>>
>> Hi.
>>
>> You are right, it's using -O2, thus your patch is right. Please install the
>> patch
>> after testing. It's obvious fix.
>
> I've now installed the fix for the dumpfile renaming. However, you've
> still done nothing about the remaining failure.
Thanks. Is the last remaining one: gcc.dg/tree-prof/update-loopch.c?
Thanks,
Martin
>
> Rainer
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-21 14:54 ` Sudakshina Das
2018-05-24 19:59 ` Martin Liška
@ 2018-05-25 10:01 ` Martin Liška
2018-05-25 10:12 ` Sudakshina Das
1 sibling, 1 reply; 28+ messages in thread
From: Martin Liška @ 2018-05-25 10:01 UTC (permalink / raw)
To: Sudakshina Das, Rainer Orth
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law, nd
On 05/21/2018 04:42 PM, Sudakshina Das wrote:
> On 21/05/18 15:00, Rainer Orth wrote:
>> Hi Martin,
>>
>>>>> Thanks for opened eyes, following patch will fix that.
>>>>> It's quite obvious, I'll install it right after tests will finish.
>>>>
>>>> unfortunately, it didn't fix either issue:
>>>>
>>>> * The switchlower -> switchlower1 renames in the dg-final* lines
>>>> Â Â (attached) are still necessary to avoid the UNRESOLVED errors.
>>>> Â Â Although obvious, I haven't installed them since ...
>>>>
>>>> * ... even so
>>>>
>>>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
>>>>
>>>> Â Â remains.
>> [...]
>>> You are right, it's using -O2, thus your patch is right. Please install the
>>> patch
>>> after testing. It's obvious fix.
>>
>> But what about the remaining FAIL?
>>
>
> Sorry to add to this, but I have also observed the following failures on  aarch64-none-elf, aarch64-none-linux-gnu and aarch64_be-none-elf targets bisected to this commit:
>
> FAIL: gcc.dg/sancov/cmp0.c  -O0  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_const_cmp" 7
>
> FAIL: gcc.dg/sancov/cmp0.c  -O0  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_switch \\(" 2
>
> FAIL: gcc.dg/sancov/cmp0.c  -O0 -g  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_const_cmp" 7
>
> FAIL: gcc.dg/sancov/cmp0.c  -O0 -g  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_switch \\(" 2
Hi.
I've just tested sancov tests on my aarch64 and cmp0.c looks fine. Can you please tell me which -march, -mtune does
your board have?
>
> FAIL: gcc.dg/tree-ssa/pr77445-2.c scan-tree-dump-not thread3 "not considered"
>
> FAIL: gcc.dg/tree-ssa/ssa-dom-thread-7.c scan-tree-dump-not vrp2 "Jumps threaded"
I can confirm these 2. It's kind of expected, I will clean it up before next release. Jeff is aware
of that..
Martin
>
> Sudi
>
>> Â Â Â Â Rainer
>>
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH][RFC] Radically simplify emission of balanced tree for switch statements.
2018-05-25 10:01 ` Martin Liška
@ 2018-05-25 10:12 ` Sudakshina Das
0 siblings, 0 replies; 28+ messages in thread
From: Sudakshina Das @ 2018-05-25 10:12 UTC (permalink / raw)
To: Martin Liška, Rainer Orth
Cc: Bernhard Reutner-Fischer, gcc-patches, Richard Biener, Jeff Law, nd
Hi Martin
On 25/05/18 10:45, Martin Liška wrote:
> On 05/21/2018 04:42 PM, Sudakshina Das wrote:
>> On 21/05/18 15:00, Rainer Orth wrote:
>>> Hi Martin,
>>>
>>>>>> Thanks for opened eyes, following patch will fix that.
>>>>>> It's quite obvious, I'll install it right after tests will finish.
>>>>>
>>>>> unfortunately, it didn't fix either issue:
>>>>>
>>>>> * The switchlower -> switchlower1 renames in the dg-final* lines
>>>>> Â Â (attached) are still necessary to avoid the UNRESOLVED errors.
>>>>> Â Â Although obvious, I haven't installed them since ...
>>>>>
>>>>> * ... even so
>>>>>
>>>>> FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1 "Removing basic block"
>>>>>
>>>>> Â Â remains.
>>> [...]
>>>> You are right, it's using -O2, thus your patch is right. Please install the
>>>> patch
>>>> after testing. It's obvious fix.
>>>
>>> But what about the remaining FAIL?
>>>
>>
>> Sorry to add to this, but I have also observed the following failures on  aarch64-none-elf, aarch64-none-linux-gnu and aarch64_be-none-elf targets bisected to this commit:
>>
>> FAIL: gcc.dg/sancov/cmp0.c  -O0  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_const_cmp" 7
>>
>> FAIL: gcc.dg/sancov/cmp0.c  -O0  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_switch \\(" 2
>>
>> FAIL: gcc.dg/sancov/cmp0.c  -O0 -g  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_const_cmp" 7
>>
>> FAIL: gcc.dg/sancov/cmp0.c  -O0 -g  scan-tree-dump-times optimized "__builtin___sanitizer_cov_trace_switch \\(" 2
>
> Hi.
>
> I've just tested sancov tests on my aarch64 and cmp0.c looks fine. Can you please tell me which -march, -mtune does
> your board have?
>
>>
>> FAIL: gcc.dg/tree-ssa/pr77445-2.c scan-tree-dump-not thread3 "not considered"
>>
>> FAIL: gcc.dg/tree-ssa/ssa-dom-thread-7.c scan-tree-dump-not vrp2 "Jumps threaded"
>
> I can confirm these 2. It's kind of expected, I will clean it up before next release. Jeff is aware
> of that..
>
> Martin
>
From my today's build, I only see the following remaining now:
FAIL: gcc.dg/tree-prof/update-loopch.c scan-tree-dump switchlower1
"Removing basic block"
FAIL: gcc.dg/tree-ssa/pr77445-2.c scan-tree-dump-not thread3 "not
considered"
FAIL: gcc.dg/tree-ssa/ssa-dom-thread-7.c scan-tree-dump-not vrp2 "Jumps
threaded"
Sudi
>>
>> Sudi
>>
>>> Â Â Â Â Rainer
>>>
>>
>
^ permalink raw reply [flat|nested] 28+ messages in thread
end of thread, other threads:[~2018-05-25 10:10 UTC | newest]
Thread overview: 28+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2017-09-14 12:17 [PATCH][RFC] Radically simplify emission of balanced tree for switch statements Martin Liška
2017-09-15 22:19 ` Jeff Law
2017-09-20 7:24 ` Martin Liška
2017-09-20 15:00 ` Jeff Law
2017-09-21 23:12 ` Bernhard Reutner-Fischer
2018-01-09 14:46 ` Martin Liška
2018-01-09 18:31 ` Jeff Law
2018-01-10 13:14 ` Richard Biener
2018-01-10 15:04 ` Martin Liška
2018-01-14 23:23 ` Bernhard Reutner-Fischer
2018-05-17 10:39 ` Martin Liška
2018-05-18 13:57 ` Rainer Orth
2018-05-18 14:19 ` Martin Liška
2018-05-21 11:29 ` Rainer Orth
2018-05-21 14:00 ` Martin Liška
2018-05-21 14:10 ` Rainer Orth
2018-05-21 14:54 ` Sudakshina Das
2018-05-24 19:59 ` Martin Liška
2018-05-25 10:01 ` Martin Liška
2018-05-25 10:12 ` Sudakshina Das
2018-05-24 12:52 ` Rainer Orth
2018-05-24 20:10 ` Martin Liška
2017-10-06 12:26 ` [PATCH] Implement smart multiple switch expansion algorithms Martin Liška
2017-10-06 16:20 ` [PATCH] Add selftest for vec::reverse David Malcolm
2017-12-29 14:39 ` Martin Liška
2017-12-29 17:09 ` David Malcolm
2017-10-06 17:24 ` [PATCH] Implement smart multiple switch expansion algorithms David Malcolm
2017-12-29 14:38 ` Martin Liška
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).