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. */
