The function attempts to provide a topological sorting of expressions
in a bitmap set but it fails short of that because we have no knowledge
of the entries of the value graph. The following makes sure to first
compute those. This should reduce the amount of iteration we do.
Bootstrapped and tested on x86_64-unknown-linux-gnu, pushed.
PR tree-optimization/125040
* tree-ssa-pre.cc (sorted_array_from_bitmap_set): Compute
the set of entries to the value graph before building the
final sorted expression set.
---
gcc/tree-ssa-pre.cc | 34 +++++++++++++++++++++++++++++++++-
1 file changed, 33 insertions(+), 1 deletion(-)
diff --git a/gcc/tree-ssa-pre.cc b/gcc/tree-ssa-pre.cc
index ab0491e55e0..79f1639e143 100644
--- a/gcc/tree-ssa-pre.cc
+++ b/gcc/tree-ssa-pre.cc
@@ -1076,11 +1076,43 @@ sorted_array_from_bitmap_set (bitmap_set_t set, bool
for_insertion)
result.truncate (0);
}
+ bool single_p = true;
auto_bitmap val_visited (&grand_bitmap_obstack);
bitmap_tree_view (val_visited);
FOR_EACH_VALUE_ID_IN_SET (set, i, bi)
if (bitmap_set_bit (val_visited, i))
- pre_expr_DFS (i, set, exclusions, val_visited, result);
+ {
+ if (!result.is_empty ())
+ {
+ single_p = false;
+ result.truncate (0);
+ }
+ pre_expr_DFS (i, set, exclusions, val_visited, result);
+ /* Mark i as entry that is not forward reachable. Note we do
+ have cycles in the value graph so eventually i reaches itself. */
+ bitmap_clear_bit (val_visited, i);
+ }
+ /* If we didn't by luck visit only a single entry to the value
+ graph visit now all not forward reachable values. */
+ if (!single_p)
+ {
+ result.truncate (0);
+ auto_bitmap val_visited2 (&grand_bitmap_obstack);
+ bitmap_tree_view (val_visited2);
+ FOR_EACH_VALUE_ID_IN_SET (set, i, bi)
+ if (!bitmap_bit_p (val_visited, i))
+ {
+ if (bitmap_set_bit (val_visited2, i))
+ pre_expr_DFS (i, set, exclusions, val_visited2, result);
+ else
+ gcc_unreachable ();
+ }
+ if (flag_checking)
+ {
+ bitmap_list_view (val_visited2);
+ gcc_assert (bitmap_equal_p (&set->values, val_visited2));
+ }
+ }
return result;
}
--
2.51.0
