mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-17 20:11:06 +08:00
Code Issues Packages Projects Releases Wiki Activity

checking: avoid verify_type_variant crash on incomplete type.

Browse Source 
Here, we end up calling gen_type_die_with_usage for a type that's in the
middle of finish_struct_1, after we set TYPE_NEEDS_CONSTRUCTING on it but
before we copy all the flags to the variants--and, significantly, before we
set its TYPE_SIZE.  It seems reasonable to only look at
TYPE_NEEDS_CONSTRUCTING on complete types, since we aren't going to try to
create an object of an incomplete type any other way.

	PR c++/92601
	* tree.c (verify_type_variant): Only verify TYPE_NEEDS_CONSTRUCTING
	of complete types.
This commit is contained in:
Jason Merrill 2020-01-25 23:09:57 -05:00
parent 0f6f39ed73
commit 091fe099ba
3 changed files with 71 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gcc/ChangeLog
View File

@ -1,3 +1,9 @@
2020-01-26 Jason Merrill <jason@redhat.com>
PR c++/92601
* tree.c (verify_type_variant): Only verify TYPE_NEEDS_CONSTRUCTING
of complete types.
2020-01-26 Darius Galis <darius.galis@cyberthorstudios.com>
* config/rx/rx.md (setmemsi): Added rx_allow_string_insns constraint

64
gcc/testsuite/g++.dg/debug/verify1.C Normal file
View File

@ -0,0 +1,64 @@
// PR c++/92601
// { dg-additional-options "-g -fchecking -std=c++17" }
typedef int size_t;
template <typename, int __v> struct integral_constant {
static constexpr int value = __v;
};
template <typename> struct A;
template <typename _Tp> using __remove_cv_t = typename A<_Tp>::type;
template <typename _Tp, typename _Up>
struct B : integral_constant<bool, __is_same_as(_Tp, _Up)> {};
template <typename...> class tuple;
template <typename> struct A {
using type = tuple<const char *, const char *>;
};
template <typename> struct C { typedef __remove_cv_t<int> __type; };
template <typename _Tp> class D {
public:
typedef typename C<_Tp>::__type type;
};
template <bool> struct enable_if;
template <int> struct F {};
template <typename, typename> class G {
public:
int operator*();
void operator++();
};
template <typename _Iterator, typename _Container>
bool operator!=(G<_Iterator, _Container>, G<_Iterator, _Container>);
template <typename> class H;
template <typename = H<tuple<const char *, const char *>>> class vector {
public:
typedef G<int, vector> iterator;
iterator begin();
iterator end();
};
template <typename> struct pack_c { typedef pack_c type; };
template <typename, typename> struct make_index_pack_join;
template <size_t... Left, size_t... Right>
struct make_index_pack_join<pack_c<size_t, Left...>, pack_c<size_t, Right...>>
: pack_c<size_t> {};
template <int N>
struct I
: make_index_pack_join<typename I<N / 2>::type, typename I<N / 2>::type> {};
template <> struct I<1> : pack_c<size_t> {};
template <typename TTuple, typename>
struct are_tuples_compatible_not_same
: F<B<typename D<TTuple>::type, int>::value> {};
template <typename...> struct tuple_impl;
template <size_t... Is, typename... Ts>
struct tuple_impl<pack_c<size_t, Is...>, Ts...> {
template <typename UTuple, typename enable_if<are_tuples_compatible_not_same<
tuple<>, UTuple>::value>::type>
tuple_impl(UTuple &&);
};
template <typename... Ts> class tuple {
tuple_impl<typename I<sizeof...(Ts)>::type> _impl;
tuple(tuple &) = default;
};
vector message_handler_registrations;
void fn1() {
for (auto t : message_handler_registrations)
;
}

2
gcc/tree.c
View File

@ -13881,9 +13881,9 @@ verify_type_variant (const_tree t, tree tv)
debug_tree (TYPE_SIZE_UNIT (t));
return false;
}
verify_variant_match (TYPE_NEEDS_CONSTRUCTING);
}
verify_variant_match (TYPE_PRECISION);
verify_variant_match (TYPE_NEEDS_CONSTRUCTING);
if (RECORD_OR_UNION_TYPE_P (t))
verify_variant_match (TYPE_TRANSPARENT_AGGR);
else if (TREE_CODE (t) == ARRAY_TYPE)