2012-10-25 Richard Biener <rguenther@suse.de>

	PR tree-optimization/54902
	* tree-ssa-pre.c (fini_pre): Return TODO.
	(execute_pre): Adjust.
	* tree-ssa-tailmerge.c (tail_merge_optimize): Delete unreachable
	blocks before computing dominators.

	* g++.dg/torture/pr54902.C: New testcase.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/gcc-4_7-branch@192803 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 51e53cb..2eb7b8b 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+2012-10-25  Richard Biener  <rguenther@suse.de>
+
+       PR tree-optimization/54902
+       * tree-ssa-pre.c (fini_pre): Return TODO.
+       (execute_pre): Adjust.
+       * tree-ssa-tailmerge.c (tail_merge_optimize): Delete unreachable
+       blocks before computing dominators.
+
 2012-10-24  Uros Bizjak  <ubizjak@gmail.com>
 
        Backport from mainline

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index b954c9b..07df245 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2012-10-25  Richard Biener  <rguenther@suse.de>
+
+       PR tree-optimization/54902
+       * g++.dg/torture/pr54902.C: New testcase.
+
 2012-10-22  Eric Botcazou  <ebotcazou@adacore.com>
 
        * gnat.dg/modular4.adb: New test.

diff --git a/gcc/testsuite/g++.dg/torture/pr54902.C b/gcc/testsuite/g++.dg/torture/pr54902.C
new file mode 100644 (file)
index 0000000..790ffe5
--- /dev/null
+++ b/gcc/testsuite/g++.dg/torture/pr54902.C
@@ -0,0 +1,131 @@
+// { dg-do compile }
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+    template<typename _Iterator>     struct iterator_traits     {
+    };
+    template<typename _Tp>     struct iterator_traits<_Tp*>     {
+       typedef _Tp& reference;
+    };
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+    using std::iterator_traits;
+    template<typename _Iterator, typename _Container>     class __normal_iterator     {
+       _Iterator _M_current;
+       typedef iterator_traits<_Iterator> __traits_type;
+    public:
+       typedef typename __traits_type::reference reference;
+       explicit       __normal_iterator(const _Iterator& __i) : _M_current(__i) {
+       }
+       reference       operator*() const       {
+           return *_M_current;
+       }
+       __normal_iterator       operator++(int)       {
+           return __normal_iterator(_M_current++);
+       }
+    };
+    template<typename _Tp>     class new_allocator     {
+    public:
+       typedef _Tp* pointer;
+       template<typename _Tp1>         struct rebind         {
+           typedef new_allocator<_Tp1> other;
+       };
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default"))) {
+    template<typename _Tp>     class allocator: public __gnu_cxx::new_allocator<_Tp>     {
+    };
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+    template<typename _Alloc>   struct __alloc_traits   {
+       typedef typename _Alloc::pointer pointer;
+       template<typename _Tp>       struct rebind       {
+           typedef typename _Alloc::template rebind<_Tp>::other other;
+       };
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default"))) {
+    template<typename _Tp, typename _Alloc>     struct _Vector_base     {
+       typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template         rebind<_Tp>::other _Tp_alloc_type;
+       typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer         pointer;
+       struct _Vector_impl       : public _Tp_alloc_type       {
+           pointer _M_start;
+       };
+       _Vector_impl _M_impl;
+    };
+    template<typename _Tp, typename _Alloc = std::allocator<_Tp> >     class vector : protected _Vector_base<_Tp, _Alloc>     {
+       typedef _Vector_base<_Tp, _Alloc> _Base;
+    public:
+       typedef typename _Base::pointer pointer;
+       typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
+       iterator       begin()       {
+           return iterator(this->_M_impl._M_start);
+       }
+    };
+}
+class myServer {
+    static std::vector<myServer *> server_list;
+    class Callback;
+    class myFolder *currentFolder;
+    static bool eventloop(Callback *);
+};
+extern "C" {
+    typedef unsigned int uint32_t;
+    typedef uint32_t unicode_char;
+    extern int strcmp (__const char *__s1, __const char *__s2)      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+};
+class CursesObj {
+};
+class Curses : public CursesObj {
+public:
+    class Key {
+    public:
+       unicode_char ukey;
+       const char *keycode;
+       Key(unicode_char ch) : ukey(ch), keycode(0) {
+       }
+       bool plain() const {
+       }
+       bool nokey() const {
+       }
+       bool operator==(const Key &k) const   {
+           return strcmp(keycode ? keycode:
+                         "",           k.keycode ? k.keycode:
+                         "") == 0 &&     ukey == k.ukey;
+       }
+    };
+    static bool processKey(const Key &k);
+};
+class CursesContainer : public Curses {
+};
+class myFolder {
+public:
+    void checkExpunged();
+};
+class Typeahead {
+public:
+    static Typeahead *typeahead;
+    bool empty()  {
+    }
+    Curses::Key pop()  {
+    }
+};
+class CursesScreen : public CursesContainer {
+public:
+    Key getKey();
+};
+using namespace std;
+extern CursesScreen *cursesScreen;
+bool myServer::eventloop(myServer::Callback *callback) {
+    Curses::Key k1=    (callback == __null && !Typeahead::typeahead->empty()     ? Typeahead::typeahead->pop()     : cursesScreen->getKey());
+    if (callback == __null || (k1.plain() && k1.ukey == '\x03'))   {
+       if (!k1.nokey())    {
+           bool rc=Curses::processKey(k1);
+           if (rc)     {      while (k1.plain() && k1 == '\x03' &&             !Typeahead::typeahead->empty())       Typeahead::typeahead->pop();     }
+       }
+    }
+    vector<myServer *>::iterator b=server_list.begin();
+    while (1)   {
+       myServer *p= *b++;
+       if (p->currentFolder)     p->currentFolder->checkExpunged();
+    }
+}

diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index b42faef..2ddd798 100644 (file)
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -4820,11 +4820,12 @@ init_pre (bool do_fre)
 
 /* Deallocate data structures used by PRE.  */
 
-static void
+static unsigned 
 fini_pre (bool do_fre)
 {
   bool do_eh_cleanup = !bitmap_empty_p (need_eh_cleanup);
   bool do_ab_cleanup = !bitmap_empty_p (need_ab_cleanup);
+  unsigned todo = 0;
 
   free (postorder);
   VEC_free (bitmap_set_t, heap, value_expressions);
@@ -4851,10 +4852,12 @@ fini_pre (bool do_fre)
   BITMAP_FREE (need_ab_cleanup);
 
   if (do_eh_cleanup || do_ab_cleanup)
-    cleanup_tree_cfg ();
+    todo = TODO_cleanup_cfg;
 
   if (!do_fre)
     loop_optimizer_finalize ();
+
+  return todo;
 }
 
 /* Main entry point to the SSA-PRE pass.  DO_FRE is true if the caller
@@ -4933,7 +4936,7 @@ execute_pre (bool do_fre)
     }
 
   scev_finalize ();
-  fini_pre (do_fre);
+  todo |= fini_pre (do_fre);
 
   if (!do_fre)
     /* TODO: tail_merge_optimize may merge all predecessors of a block, in which

diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c
index 25ec43e..4be35f6 100644 (file)
--- a/gcc/tree-ssa-tail-merge.c
+++ b/gcc/tree-ssa-tail-merge.c
@@ -1559,7 +1559,12 @@ tail_merge_optimize (unsigned int todo)
 
   timevar_push (TV_TREE_TAIL_MERGE);
 
-  calculate_dominance_info (CDI_DOMINATORS);
+  if (!dom_info_available_p (CDI_DOMINATORS))
+    {
+      /* PRE can leave us with unreachable blocks, remove them now.  */
+      delete_unreachable_blocks ();
+      calculate_dominance_info (CDI_DOMINATORS);
+    }
   init_worklist ();
 
   while (!VEC_empty (same_succ, worklist))