Fix ipa-devirt ICE

[Jan Hubicka <hubicka at ucw dot cz>]

Hi,
this patch fixes ICE on type inconsistent code.  The ICE happens because of
gcc_unreachable I forgot in code during development.  I added way to mark calls
as inconsistent that is useful to redirect them to UNREACHABLE.

Bootstrapped/regtested x86_64-linux, comitted.

Honza

	* testsuite/g++.dg/torture/pr60659.C: New testcase.
	* ipa-devirt.c (get_polymorphic_call_info): Do not ICE on type inconsistent
	code and instead mark the context inconsistent.
	(possible_polymorphic_call_targets): For inconsistent contexts
	return empty complete list.
Index: testsuite/g++.dg/torture/pr60659.C
===================================================================
--- testsuite/g++.dg/torture/pr60659.C	(revision 0)
+++ testsuite/g++.dg/torture/pr60659.C	(revision 0)
@@ -0,0 +1,58 @@
+// { dg-do compile }
+template <typename _InputIterator> void __distance (_InputIterator);
+template <typename _InputIterator>
+void distance (_InputIterator, _InputIterator p2)
+{
+  __distance (p2);
+}
+
+namespace boost
+{
+template <class Iterator> struct A
+{
+  typedef typename Iterator::difference_type type;
+};
+template <class T> typename T::const_iterator end (T &);
+template <class T> typename T::const_iterator begin (T &);
+template <class T> struct D : A<typename T::const_iterator>
+{
+};
+template <class T> typename D<T>::type distance (const T &p1)
+{
+  distance (boost::begin (p1), boost::end (p1));
+  return 0;
+}
+template <class IteratorT> class B
+{
+public:
+  typedef B type;
+  typedef IteratorT const_iterator;
+};
+}
+
+typedef int storage_t[];
+struct F;
+template <template <typename> class> struct G
+{
+  G (const G &p1) { p1.m_fn1 ().m_fn1 (0); }
+  const F &m_fn1 () const
+  {
+    const void *a;
+    a = &data_m;
+    return *static_cast<const F *>(a);
+  }
+  storage_t *data_m;
+};
+
+struct F
+{
+  virtual F *m_fn1 (void *) const;
+};
+template <typename> struct H;
+struct C : G<H>
+{
+  typedef int difference_type;
+};
+boost::B<C> AllTransVideos ();
+int b = boost::distance (AllTransVideos ());
+
Index: ipa-devirt.c
===================================================================
--- ipa-devirt.c	(revision 208915)
+++ ipa-devirt.c	(working copy)
@@ -1214,7 +1214,13 @@ get_polymorphic_call_info (tree fndecl,
 		     not part of outer type.  */
 		  if (!contains_type_p (TREE_TYPE (base),
 					context->offset + offset2, *otr_type))
-		    return base_pointer;
+		    {
+		      /* Use OTR_TOKEN = INT_MAX as a marker of probably type inconsistent
+			 code sequences; we arrange the calls to be builtin_unreachable
+			 later.  */
+		      *otr_token = INT_MAX;
+		      return base_pointer;
+		    }
 		  get_polymorphic_call_info_for_decl (context, base,
 						      context->offset + offset2);
 		  return NULL;
@@ -1288,8 +1294,10 @@ get_polymorphic_call_info (tree fndecl,
 	  if (!contains_type_p (context->outer_type, context->offset,
 			        *otr_type))
 	    { 
-	      context->outer_type = NULL;
-	      gcc_unreachable ();
+	      /* Use OTR_TOKEN = INT_MAX as a marker of probably type inconsistent
+		 code sequences; we arrange the calls to be builtin_unreachable
+		 later.  */
+	      *otr_token = INT_MAX;
 	      return base_pointer;
 	    }
 	  context->maybe_derived_type = false;
@@ -1389,6 +1397,9 @@ devirt_variable_node_removal_hook (varpo
    temporarily change to one of base types.  INCLUDE_DERIVER_TYPES make
    us to walk the inheritance graph for all derivations.
 
+   OTR_TOKEN == INT_MAX is used to mark calls that are provably
+   undefined and should be redirected to unreachable.
+
    If COMPLETEP is non-NULL, store true if the list is complete. 
    CACHE_TOKEN (if non-NULL) will get stored to an unique ID of entry
    in the target cache.  If user needs to visit every target list
@@ -1422,6 +1433,7 @@ possible_polymorphic_call_targets (tree
   bool complete;
   bool can_refer;
 
+  /* If ODR is not initialized, return empty incomplete list.  */
   if (!odr_hash.is_created ())
     {
       if (completep)
@@ -1431,11 +1443,28 @@ possible_polymorphic_call_targets (tree
       return nodes;
     }
 
+  /* If we hit type inconsistency, just return empty list of targets.  */
+  if (otr_token == INT_MAX)
+    {
+      if (completep)
+	*completep = true;
+      if (nonconstruction_targetsp)
+	*nonconstruction_targetsp = 0;
+      return nodes;
+    }
+
   type = get_odr_type (otr_type, true);
 
   /* Lookup the outer class type we want to walk.  */
-  if (context.outer_type)
-    get_class_context (&context, otr_type);
+  if (context.outer_type
+      && !get_class_context (&context, otr_type))
+    {
+      if (completep)
+	*completep = false;
+      if (nonconstruction_targetsp)
+	*nonconstruction_targetsp = 0;
+      return nodes;
+    }
 
   /* We canonicalize our query, so we do not need extra hashtable entries.  */