procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

c++: error-recovery ICE with unstable satisfaction [PR109752]

Browse source 
After diagnosing and recovering from unstable satisfaction, it's
possible to evaluate an atom for the first time noisily rather than
quietly.  The satisfaction cache tries to handle this situation
gracefully, but apparently not gracefully enough: we inserted an empty
slot into the cache, and left it empty, which later makes
hash_table::check_complete_insertion unhappy.  This patch fixes this by
removing the empty slot in this case.

	PR c++/109752

gcc/cp/ChangeLog:

	* constraint.cc (satisfaction_cache::satisfaction_cache): In the
	unexpected case of evaluating an atom for the first time noisily,
	remove the cache slot that we inserted.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp2a/concepts-pr109752.C: New test.
This commit is contained in:
Patrick Palka 2023-05-09 15:07:00 -04:00
parent c13906f258
commit bbb6cf926f
2 changed files with 36 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
gcc/cp/constraint.cc
View file

@ -2687,9 +2687,16 @@ satisfaction_cache
*slot = entry;
}
else
/* We shouldn't get here, but if we do, let's just leave 'entry'
empty, effectively disabling the cache. */
return;
{
/* We're evaluating this atom for the first time, and doing so noisily.
This shouldn't happen outside of error recovery situations involving
unstable satisfaction. Let's just leave 'entry' empty, effectively
disabling the cache, and remove the empty slot. */
gcc_checking_assert (seen_error ());
/* Appease hash_table::check_complete_insertion. */
*slot = ggc_alloc<sat_entry> ();
sat_cache->clear_slot (slot);
}
}
/* Returns the cached satisfaction result if we have one and we're not

26
gcc/testsuite/g++.dg/cpp2a/concepts-pr109752.C Normal file
View file

@ -0,0 +1,26 @@
// PR c++/109752
// { dg-do compile { target c++20 } }
template <typename _Tp, typename... _Args>
inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...);
template<typename _Tp, typename _Up>
concept __weakly_eq_cmp_with
= requires(_Tp __t, _Up __u) { { __u != __t } ; // { dg-error "changed from" }
};
template<typename _Tp>
concept regular = is_constructible_v<_Tp> && __weakly_eq_cmp_with<_Tp, _Tp>;
template<typename _Iter> concept incrementable = true
&& regular<_Iter>
&& requires(_Iter __i) { { __i++ } ;}
;
template<typename D>
struct iterator_interface
{
friend constexpr bool operator>=(D lhs, D rhs) requires __weakly_eq_cmp_with<D, D> { return true; }
};
template<typename T>
struct iterator : iterator_interface<iterator<T>>
{
bool operator==(iterator) const;
};
static_assert(incrementable<iterator<int>>); // { dg-error "assert" }