mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-23 01:53:38 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

gdbsupport: assume that compiler supports std::{is_trivially_constructible,is_trivially_copyable}

Browse Source 
This code was there to support g++ 4, which didn't support
std::is_trivially_constructible and std::is_trivially_copyable.  Since
we now require g++ >= 9, I think it's fair to assume that GDB will
always be compiled with a compiler that supports those.

Change-Id: Ie7c1649139a2f48bf662cac92d7f3e38fb1f1ba1
This commit is contained in:
Simon Marchi 2024-02-21 11:46:52 -05:00 committed by Simon Marchi
parent aca8a74923
commit 23acbfee6a
8 changed files with 0 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gdb/trad-frame.c
View File

@ -61,9 +61,7 @@ trad_frame_reset_saved_regs (struct gdbarch *gdbarch,
trad_frame_saved_reg *
trad_frame_alloc_saved_regs (struct gdbarch *gdbarch)
{
#ifdef HAVE_IS_TRIVIALLY_CONSTRUCTIBLE
static_assert (std::is_trivially_constructible<trad_frame_saved_reg>::value);
#endif
int numregs = gdbarch_num_cooked_regs (gdbarch);
trad_frame_saved_reg *this_saved_regs

4
gdb/unittests/array-view-selftests.c
View File

@ -30,15 +30,11 @@ namespace array_view_tests {
#define CHECK_TRAIT(TRAIT) \
static_assert (std::TRAIT<gdb::array_view<gdb_byte>>::value, "")
#if HAVE_IS_TRIVIALLY_COPYABLE
CHECK_TRAIT (is_trivially_copyable);
CHECK_TRAIT (is_trivially_move_assignable);
CHECK_TRAIT (is_trivially_move_constructible);
CHECK_TRAIT (is_trivially_destructible);
#endif
#undef CHECK_TRAIT
/* Wrapper around std::is_convertible to make the code using it a bit

4
gdb/unittests/enum-flags-selftests.c
View File

@ -63,14 +63,10 @@ DEF_ENUM_FLAGS_TYPE (RE, EF);
DEF_ENUM_FLAGS_TYPE (RE2, EF2);
DEF_ENUM_FLAGS_TYPE (URE, UEF);
#if HAVE_IS_TRIVIALLY_COPYABLE
/* So that std::vectors of types that have enum_flags fields can
reallocate efficiently memcpy. */
static_assert (std::is_trivially_copyable<EF>::value);
#endif
/* A couple globals used as lvalues in the CHECK_VALID expressions
below. Their names (and types) match the uppercase type names
exposed by CHECK_VALID just to make the expressions easier to

4
gdb/unittests/packed-selftests.c
View File

@ -46,16 +46,12 @@ static_assert (alignof (packed<test_enum, 4>) == 1);
#define CHECK_TRAIT(TRAIT) \
static_assert (std::TRAIT<packed<test_enum, 1>>::value, "")
#if HAVE_IS_TRIVIALLY_COPYABLE
CHECK_TRAIT (is_trivially_copyable);
CHECK_TRAIT (is_trivially_copy_constructible);
CHECK_TRAIT (is_trivially_move_constructible);
CHECK_TRAIT (is_trivially_copy_assignable);
CHECK_TRAIT (is_trivially_move_assignable);
#endif
#undef CHECK_TRAIT
/* Entry point. */

2
gdbsupport/check-defines.el
View File

@ -35,8 +35,6 @@
(put (intern "HAVE_USEFUL_SBRK") :check-ok t)
(put (intern "HAVE_SOCKETS") :check-ok t)
(put (intern "HAVE_F_GETFD") :check-ok t)
(put (intern "HAVE_IS_TRIVIALLY_COPYABLE") :check-ok t)
(put (intern "HAVE_IS_TRIVIALLY_CONSTRUCTIBLE") :check-ok t)
(put (intern "HAVE_DOS_BASED_FILE_SYSTEM") :check-ok t)
(defun check-read-config.in (file)

2
gdbsupport/packed.h
View File

@ -80,9 +80,7 @@ public:
static_assert (alignof (packed) == 1);
/* Make sure packed can be wrapped with std::atomic. */
#if HAVE_IS_TRIVIALLY_COPYABLE
static_assert (std::is_trivially_copyable<packed>::value);
#endif
static_assert (std::is_copy_constructible<packed>::value);
static_assert (std::is_move_constructible<packed>::value);
static_assert (std::is_copy_assignable<packed>::value);

8
gdbsupport/poison.h
View File

@ -56,8 +56,6 @@ template <typename T,
typename = gdb::Requires<gdb::Not<IsMemsettable<T>>>>
void *memset (T *s, int c, size_t n) = delete;
#if HAVE_IS_TRIVIALLY_COPYABLE
/* Similarly, poison memcpy and memmove of non trivially-copyable
types, which is undefined. */
@ -83,17 +81,11 @@ template <typename D, typename S,
typename = gdb::Requires<gdb::Not<BothAreRelocatable<D, S>>>>
void *memmove (D *dest, const S *src, size_t n) = delete;
#endif /* HAVE_IS_TRIVIALLY_COPYABLE */
/* Poison XNEW and friends to catch usages of malloc-style allocations on
objects that require new/delete. */
template<typename T>
#if HAVE_IS_TRIVIALLY_CONSTRUCTIBLE
using IsMallocable = std::is_trivially_constructible<T>;
#else
using IsMallocable = std::true_type;
#endif
template<typename T>
using IsFreeable = gdb::Or<std::is_trivially_destructible<T>, std::is_void<T>>;

21
gdbsupport/traits.h
View File

@ -20,27 +20,6 @@
#include <type_traits>
/* GCC does not understand __has_feature. */
#if !defined(__has_feature)
# define __has_feature(x) 0
#endif
/* HAVE_IS_TRIVIALLY_COPYABLE is defined as 1 iff
std::is_trivially_copyable is available. GCC only implemented it
in GCC 5. */
#if (__has_feature(is_trivially_copyable) \
|| (defined __GNUC__ && __GNUC__ >= 5))
# define HAVE_IS_TRIVIALLY_COPYABLE 1
#endif
/* HAVE_IS_TRIVIALLY_CONSTRUCTIBLE is defined as 1 iff
std::is_trivially_constructible is available. GCC only implemented it
in GCC 5. */
#if (__has_feature(is_trivially_constructible) \
|| (defined __GNUC__ && __GNUC__ >= 5))
# define HAVE_IS_TRIVIALLY_CONSTRUCTIBLE 1
#endif
namespace gdb {
/* Implementation of the detection idiom: