re PR middle-end/57140 (Segmentation fault in backtrace_dwarf_add)

2013-05-02  Richard Biener  <rguenther@suse.de>

	PR middle-end/57140
	* tree-inline.c (copy_loops): Properly handle removed loops.
	(copy_cfg_body): Mark destination loops for fixup if source
	loops needed fixup.

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

From-SVN: r198548

4 files changed, 208 insertions, 2 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index cd257b1..d4397af 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2013-05-02  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/57140
+	* tree-inline.c (copy_loops): Properly handle removed loops.
+	(copy_cfg_body): Mark destination loops for fixup if source
+	loops needed fixup.
+
 2013-05-02  Greta Yorsh  <Greta.Yorsh@arm.com>
 
 	PR target/56732
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 28a1f43..0dcb015 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2013-05-02  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/57140
+	* g++.dg/torture/pr57140.C: New testcase.
+
 2013-05-02  Greta Yorsh  <Greta.Yorsh@arm.com>
 
 	PR target/56732
diff --git a/gcc/testsuite/g++.dg/torture/pr57140.C b/gcc/testsuite/g++.dg/torture/pr57140.C
new file mode 100644
index 0000000..2ea2f9c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/torture/pr57140.C
@@ -0,0 +1,186 @@
+// { dg-do compile }
+
+namespace std {
+    typedef long unsigned int size_t;
+    template<typename>     class allocator;
+    template<class _CharT>     struct char_traits;
+    template<typename _CharT, typename _Traits = char_traits<_CharT>,            typename _Alloc = allocator<_CharT> >     class basic_string;
+    typedef basic_string<char> string;
+}
+namespace std __attribute__ ((__visibility__ ("default"))) {
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+    template<typename _Tp>     class new_allocator     {
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default"))) {
+    template<typename _Tp>     class allocator: public __gnu_cxx::new_allocator<_Tp>     {
+    public:
+	template<typename _Tp1>         struct rebind         {
+	    typedef allocator<_Tp1> other;
+	};
+    };
+}
+namespace std {
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+}
+namespace std __attribute__ ((__visibility__ ("default"))) {
+    template<typename _CharT, typename _Traits, typename _Alloc>     class basic_string     {
+	struct _Alloc_hider : _Alloc       {
+	    _Alloc_hider(_CharT* __dat, const _Alloc& __a)  : _Alloc(__a), _M_p(__dat) {
+	    }
+	    _CharT* _M_p;
+	};
+	mutable _Alloc_hider _M_dataplus;
+    public:
+	basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
+    };
+    template<typename _CharT, typename _Traits, typename _Alloc>     inline bool     operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,         const _CharT* __rhs)     {
+    }
+}
+extern "C" {
+}
+namespace std __attribute__ ((__visibility__ ("default"))) {
+    namespace __detail   {
+	struct _List_node_base     {
+	    _List_node_base* _M_next;
+	};
+    }
+    template<typename _Tp>     struct _List_node : public __detail::_List_node_base     {
+    };
+    template<typename _Tp>     struct _List_iterator     {
+	typedef _List_iterator<_Tp> _Self;
+	typedef _Tp& reference;
+	reference       operator*() const       {
+	}
+	bool       operator!=(const _Self& __x) const       {
+	}
+    };
+    template<typename _Tp, typename _Alloc>     class _List_base     {
+    protected:
+	typedef typename _Alloc::template rebind<_List_node<_Tp> >::other         _Node_alloc_type;
+	struct _List_impl       : public _Node_alloc_type       {
+	    __detail::_List_node_base _M_node;
+	    _List_impl()  : _Node_alloc_type(), _M_node()  {
+	    }
+	    _List_impl(const _Node_alloc_type& __a)  : _Node_alloc_type(__a), _M_node()  {
+	    }
+	};
+	_List_impl _M_impl;
+	~_List_base()       {
+	}
+	void       _M_clear();
+    };
+    template<typename _Tp, typename _Alloc = std::allocator<_Tp> >     class list : protected _List_base<_Tp, _Alloc>     {
+	typedef _List_iterator<_Tp> iterator;
+	typedef size_t size_type;
+    public:
+	iterator       begin()       {
+	}
+	iterator       end()       {
+	}
+	bool       empty() const       {
+	}
+	size_type       size() const       {
+	}
+	void       swap(list& __x)       {
+	}
+	template<typename _StrictWeakOrdering>         void         merge(list& __x, _StrictWeakOrdering __comp);
+	template<typename _StrictWeakOrdering>         void         sort(_StrictWeakOrdering);
+    };
+    template<typename _Tp, typename _Alloc>     template <typename _StrictWeakOrdering>       void       list<_Tp, _Alloc>::       merge(list& __x, _StrictWeakOrdering __comp)       {
+	if (this != &__x)    {
+	    iterator __first1 = begin();
+	    iterator __last1 = end();
+	    iterator __first2 = __x.begin();
+	    iterator __last2 = __x.end();
+	    while (__first1 != __last1 && __first2 != __last2)        if (__comp(*__first2, *__first1))   {
+		iterator __next = __first2;
+		__first2 = __next;
+	    }
+	}
+    }
+    template<typename _Tp, typename _Alloc>     template <typename _StrictWeakOrdering>       void       list<_Tp, _Alloc>::       sort(_StrictWeakOrdering __comp)       {
+	if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node      && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)    {
+	    list __carry;
+	    list __tmp[64];
+	    list * __fill = &__tmp[0];
+	    list * __counter;
+	    do        {
+		for(__counter = &__tmp[0];
+		    __counter != __fill && !__counter->empty();
+		    ++__counter)     {       __counter->merge(__carry, __comp);       __carry.swap(*__counter);     }
+	    }
+	    while ( !empty() );
+	    for (__counter = &__tmp[1];
+		 __counter != __fill;
+		 ++__counter)        __counter->merge(*(__counter - 1), __comp);
+	}
+    }
+}
+namespace gloox {
+    class Tag   {
+    };
+    class StanzaExtension   {
+    };
+}
+namespace gloox {
+}
+using namespace gloox;
+class AbstractPurpleRequest {
+};
+class AdhocCommandHandler : public AbstractPurpleRequest {
+};
+class AdhocTag : public Tag {
+};
+class AbstractConfigInterfaceHandler {
+};
+namespace gloox {
+    class DataFormField   {
+    public:
+	const std::string& value() const {
+	}
+    };
+    class DataFormFieldContainer   {
+    public:
+	bool hasField( const std::string& field ) const         {
+	}
+	DataFormField* field( const std::string& field ) const;
+    };
+    class DataForm : public StanzaExtension, public DataFormFieldContainer   {
+    };
+}
+enum {
+    SORT_BY_JID,  SORT_BY_UIN,  SORT_BY_BUDDIES, };
+struct SortData {
+};
+struct ListData {
+    std::list<SortData> output;
+    int sort_by;
+};
+class AdhocAdmin : public AdhocCommandHandler, public AbstractConfigInterfaceHandler {
+    AdhocTag *handleAdhocTag(Tag *stanzaTag);
+    AdhocTag *handleUnregisterUserForm(Tag *tag, const DataForm &form);
+    AdhocTag *handleListUsersForm(Tag *tag, const DataForm &form);
+    ListData m_listUsersData;
+};
+namespace gloox {
+}
+static bool compareIDataASC(SortData &a, SortData &b) {
+}
+AdhocTag *AdhocAdmin::handleListUsersForm(Tag *tag, const DataForm &form) {
+    ListData &data = m_listUsersData;
+    if (data.output.size() == 0) {
+	if (!form.hasField("users_vip") || !form.hasField("show_jid") || !form.hasField("show_uin")    || !form.hasField("show_buddies") || !form.hasField("show_sort_by") || !form.hasField("show_sort_order")    || !form.hasField("show_max_per_page")   ) {
+	}
+	bool sort_asc = form.field("show_sort_order")->value() == "asc";
+	if (data.sort_by == SORT_BY_BUDDIES) {
+	    if (sort_asc)     data.output.sort(compareIDataASC);
+	}
+	else {
+	}
+    }
+}
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index a650f0d..b5339c4 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -2208,8 +2208,11 @@ copy_loops (bitmap blocks_to_copy,
 
 	  /* Assign the new loop its header and latch and associate
 	     those with the new loop.  */
-	  dest_loop->header = (basic_block)src_loop->header->aux;
-	  dest_loop->header->loop_father = dest_loop;
+	  if (src_loop->header != NULL)
+	    {
+	      dest_loop->header = (basic_block)src_loop->header->aux;
+	      dest_loop->header->loop_father = dest_loop;
+	    }
 	  if (src_loop->latch != NULL)
 	    {
 	      dest_loop->latch = (basic_block)src_loop->latch->aux;
@@ -2336,6 +2339,11 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency_scale,
       loops_state_set (LOOPS_NEED_FIXUP);
     }
 
+  /* If the loop tree in the source function needed fixup, mark the
+     destination loop tree for fixup, too.  */
+  if (loops_for_fn (src_cfun)->state & LOOPS_NEED_FIXUP)
+    loops_state_set (LOOPS_NEED_FIXUP);
+
   if (gimple_in_ssa_p (cfun))
     FOR_ALL_BB_FN (bb, cfun_to_copy)
       if (!blocks_to_copy