Just remove the assert which I now know how it can trigger without causing harm.
Bootstrapped and tested on x86_64-unknown-linux-gnu, applied. Richard. 2015-08-13 Richard Biener <rguent...@suse.de> PR tree-optimization/67191 * tree-ssa-sccvn.c (sccvn_dom_walker::before_dom_children): Remove assert we value-numbered last stmts operand because it can validly trigger for unreachable code. * gcc.dg/torture/pr67191.c: New testcase. * g++.dg/torture/pr67191.C: Likewise. Index: gcc/tree-ssa-sccvn.c =================================================================== --- gcc/tree-ssa-sccvn.c (revision 226851) +++ gcc/tree-ssa-sccvn.c (working copy) @@ -4429,6 +4429,9 @@ sccvn_dom_walker::before_dom_children (b return; } + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "Visiting BB %d\n", bb->index); + /* If we have a single predecessor record the equivalence from a possible condition on the predecessor edge. */ if (single_pred_p (bb)) @@ -4502,17 +4505,10 @@ sccvn_dom_walker::before_dom_children (b if (dump_file && (dump_flags & TDF_DETAILS)) { - fprintf (dump_file, "Visiting stmt ending BB %d: ", bb->index); + fprintf (dump_file, "Visiting control stmt ending BB %d: ", bb->index); print_gimple_stmt (dump_file, stmt, 0, 0); } - /* Value-number the last stmts SSA uses. */ - ssa_op_iter i; - tree op; - FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE) - gcc_assert (VN_INFO (op)->visited - || SSA_NAME_IS_DEFAULT_DEF (op)); - /* ??? We can even handle stmts with outgoing EH or ABNORMAL edges if value-numbering can prove they are not reachable. Handling computed gotos is also possible. */ Index: gcc/testsuite/gcc.dg/torture/pr67191.c =================================================================== --- gcc/testsuite/gcc.dg/torture/pr67191.c (revision 0) +++ gcc/testsuite/gcc.dg/torture/pr67191.c (revision 0) @@ -0,0 +1,13 @@ +/* { dg-do compile } */ + +int a; +void f(void) +{ + int b; + for(a=1; a;); + for(; b; b++) + lbl: + b || a; + if(a) + goto lbl; +} Index: gcc/testsuite/g++.dg/torture/pr67191.C =================================================================== --- gcc/testsuite/g++.dg/torture/pr67191.C (revision 0) +++ gcc/testsuite/g++.dg/torture/pr67191.C (revision 0) @@ -0,0 +1,117 @@ +// { dg-do compile } + +template <typename> class A; +template <typename _Tp> using __allocator_base = _Tp; +template <class T, class = T, class = int, class = __allocator_base<int>> +class B; +template <class T, class H, class P, class A> +bool operator==(B<T, H, P, A> const &, B<T, H, P, A> const &); +template <class T, class H, class P, class A> +bool operator!=(B<T, H, P, A> const &, B<T, H, P, A> const &); +typedef B<int> int_multiset; +int a; +template <typename> struct C { + C(int) {} +}; +template <typename> struct D; +template <typename> struct K; +struct L : C<A<D<int>>>, C<A<K<int>>> { + template <typename First, typename Second> + L(First, Second) + : C<A<D<int>>>(0), C<A<K<int>>>(0) {} +}; +template <typename Node> struct F { + typedef typename Node::node_pointer node_pointer; + node_pointer node_; + F(); + F(typename Node::link_pointer p1) : node_(static_cast<node_pointer>(p1)) {} + void operator++() { node_ = 0; } + int operator!=(F p1) { return node_ != p1.node_; } +}; +struct G { + typedef G *link_pointer; +}; +struct H { + static int new_bucket_count(int) { + int b; + int *c = 0; + if (a) + b = *c; + return b; + } +}; +class functions { +public: + functions(int, int) {} + ~functions(); +}; +template <typename Types> struct table : functions { + typedef typename Types::policy policy; + typedef Types node_allocator; + typedef F<typename Types::node> iterator; + L allocators_; + int bucket_count_; + int size_; + typename Types::link_pointer get_previous_start() const; + iterator begin() const { return size_ ? get_previous_start() : 0; } + table(int, typename Types::hasher, typename Types::key_equal, node_allocator) + : functions(0, 0), allocators_(0, 0), + bucket_count_(policy::new_bucket_count(0)), size_() {} +}; +template <typename> struct K : G { typedef K *node_pointer; }; +struct I { + typedef G *link_pointer; +}; +struct J { + typedef I::link_pointer link_pointer; +}; +template <typename> struct D { + typedef int hasher; + typedef int key_equal; + typedef K<int> node; + typedef J::link_pointer link_pointer; + typedef H policy; +}; +struct M : table<D<int>> { + node_allocator grouped_table_impl_a; + M(int, int) : table(0, 0, 0, grouped_table_impl_a) {} + void equals(M const &) const { + for (iterator d = begin(); d.node_;) { + iterator e; + group_equals(e); + } + } + static int group_equals(iterator p1) { + int f; + iterator g; + for (; g != p1; ++g) + if (find()) + if (f) + return 0; + } + static int find(); +}; +template <class, class, class, class> class B { + M table_; + +public: + B(unsigned long = 0); + friend bool operator==<>(B const &, B const &); + friend bool operator!=<>(B const &, B const &); +}; +template <class T, class H, class P, class A> +B<T, H, P, A>::B(unsigned long) + : table_(0, 0) {} + template <class T, class H, class P, class A> + bool operator==(B<T, H, P, A> const &p1, B<T, H, P, A> const &p2) { + p1.table_.equals(p2.table_); + } +template <class T, class H, class P, class A> +bool operator!=(B<T, H, P, A> const &p1, B<T, H, P, A> const &p2) { + p1.table_.equals(p2.table_); +} +void use_multiset_fwd_declared_function_typerun() { + int_multiset x, y; + x == y; + x != y; +}