[2/5] Don't memcpy non-trivially-copyable types: Make enum_flags triv. copyable
Commit Message
On 04/20/2017 04:34 AM, Simon Marchi wrote:
> On 2017-04-12 22:27, Pedro Alves wrote:
>> + /* Define copy/move ctor/op= as defaulted so that enum_flags is
>> + trivially copyable. */
>> + enum_flags (const enum_flags &other) = default;
>> + enum_flags (enum_flags &&) noexcept = default;
>> + enum_flags &operator= (const enum_flags &other) = default;
>> + enum_flags &operator= (enum_flags &&) = default;
>
> What's the difference between defining these as default, and not
> defining them at all (which I assume will still make the compiler emit
> the default versions)?
Yeah, there's no difference. I'll just remove them, since it clearly
confuses things otherwise. Thanks.
> Do you want to add a static_assert(is_pod...) for that class? For now
> we have the VECs that will warn us if it becomes non-POD, but eventually
> they'll be gone.
I do, but enum_flags is a template, and we need to add the assertion to
some template instantiation. I'd like to add it in the enum
flags unit tests file, currently here [1]:
https://github.com/palves/gdb/blob/palves/cxx11-enum-flags/gdb/enum-flags-selftests.c
which I need to rebase and repost. I should be reposting that soon.
[1] - I'll move it to unittests/
Thanks,
Pedro Alves
From 23bcc18f470ee4364bd362a8b78c6c1415a9dadb Mon Sep 17 00:00:00 2001
From: Pedro Alves <palves@redhat.com>
Date: Tue, 25 Apr 2017 01:27:42 +0100
Subject: [PATCH] Don't memcpy non-trivially-copyable types: Make enum_flags
triv. copyable
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
The delete-memcpy-with-non-trivial-types patch exposed many instances
of this problem:
src/gdb/btrace.h: In function ‘btrace_insn_s* VEC_btrace_insn_s_quick_insert(VEC_btrace_insn_s*, unsigned int, const btrace_insn_s*, const char*, unsigned int)’:
src/gdb/common/vec.h:948:62: error: use of deleted function ‘void* memmove(T*, const U*, size_t) [with T = btrace_insn; U = btrace_insn; <template-parameter-1-3> = void; size_t = long unsigned int]’
memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \
^
src/gdb/common/vec.h:436:1: note: in expansion of macro ‘DEF_VEC_FUNC_O’
DEF_VEC_FUNC_O(T) \
^
src/gdb/btrace.h:84:1: note: in expansion of macro ‘DEF_VEC_O’
DEF_VEC_O (btrace_insn_s);
^
[...]
src/gdb/common/vec.h:1060:31: error: use of deleted function ‘void* memcpy(T*, const U*, size_t) [with T = btrace_insn; U = btrace_insn; <template-parameter-1-3> = void; size_t = long unsigned int]’
sizeof (T) * vec2_->num); \
^
src/gdb/common/vec.h:437:1: note: in expansion of macro ‘DEF_VEC_ALLOC_FUNC_O’
DEF_VEC_ALLOC_FUNC_O(T) \
^
src/gdb/btrace.h:84:1: note: in expansion of macro ‘DEF_VEC_O’
DEF_VEC_O (btrace_insn_s);
^
So, VECs (given it's C roots) rely on memcpy/memcpy of VEC elements to
be well defined, in order to grow/reallocate its internal elements
array. This means that we can only put trivially copyable types in
VECs. E.g., if a type requires using a custom copy/move ctor to
relocate, then we can't put it in a VEC (so we use std::vector
instead). But, as shown above, we're violating that requirement.
btrace_insn is currently not trivially copyable, because it contains
an enum_flags field, and that is itself not trivially copyable. This
patch corrects that, by simply removing the user-provided copy
constructor and assignment operator. The compiler-generated versions
work just fine.
Note that std::vector relies on std::is_trivially_copyable too to know
whether it can reallocate its elements with memcpy/memmove instead of
having to call copy/move ctors and dtors, so if we have types in
std::vectors that weren't trivially copyable because of enum_flags,
this will make such vectors more efficient.
gdb/ChangeLog:
2017-04-25 Pedro Alves <palves@redhat.com>
* common/enum-flags.h (enum_flags): Don't implement copy ctor and
assignment operator.
---
gdb/ChangeLog | 5 +++++
gdb/common/enum-flags.h | 10 ----------
2 files changed, 5 insertions(+), 10 deletions(-)
@@ -1,3 +1,8 @@
+2017-04-25 Pedro Alves <palves@redhat.com>
+
+ * common/enum-flags.h (enum_flags): Don't implement copy ctor and
+ assignment operator.
+
2017-04-24 Yao Qi <yao.qi@linaro.org>
* doublest.c (convert_doublest_to_floatformat): Call
@@ -120,16 +120,6 @@ public:
: m_enum_value ((enum_type) 0)
{}
- enum_flags (const enum_flags &other)
- : m_enum_value (other.m_enum_value)
- {}
-
- enum_flags &operator= (const enum_flags &other)
- {
- m_enum_value = other.m_enum_value;
- return *this;
- }
-
/* If you get an error saying these two overloads are ambiguous,
then you tried to mix values of different enum types. */
enum_flags (enum_type e)