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

vec.h: Guard most of static assertions for GCC >= 5

Browse source 
As reported by Jonathan on IRC, my vec.h patch broke build with GCC 4.8.x
or 4.9.x as system compiler, e.g. on CFarm.
The problem is that while all of
std::is_trivially_{destructible,copyable,default_constructible} traits
are in C++, only std::is_trivially_destructible has been implemented in GCC
4.8, the latter two were added only in GCC 5.
Only std::is_trivially_destructible is the really important one though,
which is used to decide what pop returns and whether to invoke the
destructors or not.  The rest are solely used in static_asserts and as such
I think it is acceptable if we don't assert those when built with GCC 4.8
or 4.9, anybody doing bootstrap from those system compilers or doing builds
with newer GCC will catch that.

So, the following patch guards those for 5+.
If we switch to C++14 later on and start requiring newer version of system
GCC as well (do we require GCC >= 5 which claims the last C++14 language
features, or what provides all C++14 library features, or GCC >= 6 which
uses -std=c++14 by default?), this patch then can be reverted.

2023-09-29  Jakub Jelinek  <jakub@redhat.com>

	* vec.h (quick_insert, ordered_remove, unordered_remove,
	block_remove, qsort, sort, stablesort, quick_grow): Guard
	std::is_trivially_{copyable,default_constructible} and
	vec_detail::is_trivially_copyable_or_pair static assertions
	with GCC_VERSION >= 5000.
	(vec_detail::is_trivially_copyable_or_pair): Guard definition
	with GCC_VERSION >= 5000.
This commit is contained in:
Jakub Jelinek 2023-09-29 15:14:52 +02:00
parent a680274616
commit e40f330101
1 changed files with 21 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
gcc/vec.h
View file

@ -1086,7 +1086,12 @@ vec<T, A, vl_embed>::quick_insert (unsigned ix, const T &obj)
{
gcc_checking_assert (length () < allocated ());
gcc_checking_assert (ix <= length ());
#if GCC_VERSION >= 5000
/* GCC 4.8 and 4.9 only implement std::is_trivially_destructible,
but not std::is_trivially_copyable nor
std::is_trivially_default_constructible. */
static_assert (std::is_trivially_copyable <T>::value, "");
#endif
T *slot = &address ()[ix];
memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T));
*slot = obj;
@ -1102,7 +1107,9 @@ inline void
vec<T, A, vl_embed>::ordered_remove (unsigned ix)
{
gcc_checking_assert (ix < length ());
#if GCC_VERSION >= 5000
static_assert (std::is_trivially_copyable <T>::value, "");
#endif
T *slot = &address ()[ix];
memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T));
}
@ -1150,7 +1157,9 @@ inline void
vec<T, A, vl_embed>::unordered_remove (unsigned ix)
{
gcc_checking_assert (ix < length ());
#if GCC_VERSION >= 5000
static_assert (std::is_trivially_copyable <T>::value, "");
#endif
T *p = address ();
p[ix] = p[--m_vecpfx.m_num];
}
@ -1164,13 +1173,16 @@ inline void
vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len)
{
gcc_checking_assert (ix + len <= length ());
#if GCC_VERSION >= 5000
static_assert (std::is_trivially_copyable <T>::value, "");
#endif
T *slot = &address ()[ix];
m_vecpfx.m_num -= len;
memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T));
}
#if GCC_VERSION >= 5000
namespace vec_detail
{
/* gcc_{qsort,qsort_r,stablesort_r} implementation under the hood
@ -1189,6 +1201,7 @@ namespace vec_detail
: std::integral_constant<bool, std::is_trivially_copyable<T>::value
&& std::is_trivially_copyable<U>::value> { };
}
#endif
/* Sort the contents of this vector with qsort. CMP is the comparison
function to pass to qsort. */
@ -1197,7 +1210,9 @@ template<typename T, typename A>
inline void
vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *))
{
#if GCC_VERSION >= 5000
static_assert (vec_detail::is_trivially_copyable_or_pair <T>::value, "");
#endif
if (length () > 1)
gcc_qsort (address (), length (), sizeof (T), cmp);
}
@ -1210,7 +1225,9 @@ inline void
vec<T, A, vl_embed>::sort (int (*cmp) (const void *, const void *, void *),
void *data)
{
#if GCC_VERSION >= 5000
static_assert (vec_detail::is_trivially_copyable_or_pair <T>::value, "");
#endif
if (length () > 1)
gcc_sort_r (address (), length (), sizeof (T), cmp, data);
}
@ -1223,7 +1240,9 @@ inline void
vec<T, A, vl_embed>::stablesort (int (*cmp) (const void *, const void *,
void *), void *data)
{
#if GCC_VERSION >= 5000
static_assert (vec_detail::is_trivially_copyable_or_pair <T>::value, "");
#endif
if (length () > 1)
gcc_stablesort_r (address (), length (), sizeof (T), cmp, data);
}
@ -1396,7 +1415,9 @@ inline void
vec<T, A, vl_embed>::quick_grow (unsigned len)
{
gcc_checking_assert (length () <= len && len <= m_vecpfx.m_alloc);
#if GCC_VERSION >= 5000
// static_assert (std::is_trivially_default_constructible <T>::value, "");
#endif
m_vecpfx.m_num = len;
}