FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Introduce gdb::array_view

Browse source 
An array_view is an abstraction that provides a non-owning view over a
sequence of contiguous objects.

A way to put it is that array_view is to std::vector (and std::array
and built-in arrays with rank==1) like std::string_view is to
std::string.

The main intent of array_view is to use it as function input parameter
type, making it possible to pass in any sequence of contiguous
objects, irrespective of whether the objects live on the stack or heap
and what actual container owns them.  Implicit construction from the
element type is supported too, making it easy to call functions that
expect an array of elements when you only have one element (usually on
the stack).  For example:

 struct A { .... };
 void function (gdb::array_view<A> as);

 std::vector<A> std_vec = ...;
 std::array<A, N> std_array = ...;
 A array[] = {...};
 A elem;

 function (std_vec);
 function (std_array);
 function (array);
 function (elem);

Views can be either mutable or const.  A const view is simply created
by specifying a const T as array_view template parameter, in which
case operator[] of non-const array_view objects ends up returning
const references.  (Making the array_view itself const is analogous to
making a pointer itself be const.  I.e., disables re-seating the
view/pointer.)  Normally functions will pass around array_views by
value.

Uses of gdb::array_view (other than the ones in the unit tests) will
be added in a follow up patch.

gdb/ChangeLog
2017-09-04  Pedro Alves  <palves@redhat.com>

	* Makefile.in (SUBDIR_UNITTESTS_SRCS): Add
	unittests/array-view-selftests.c.
	(SUBDIR_UNITTESTS_OBS): Add array-view-selftests.o.
	* common/array-view.h: New file.
	* unittests/array-view-selftests.c: New file.
This commit is contained in:
Pedro Alves 2017-09-04 17:10:12 +01:00
parent e439fa140a
commit 7c44b49cb6
4 changed files with 683 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

8
gdb/ChangeLog
View file

@ -1,3 +1,11 @@
2017-09-04 Pedro Alves <palves@redhat.com>
* Makefile.in (SUBDIR_UNITTESTS_SRCS): Add
unittests/array-view-selftests.c.
(SUBDIR_UNITTESTS_OBS): Add array-view-selftests.o.
* common/array-view.h: New file.
* unittests/array-view-selftests.c: New file.
2017-09-04 Pedro Alves <palves@redhat.com>
* cli/cli-cmds.c (edit_command): Pass message to

2
gdb/Makefile.in
View file

@ -526,6 +526,7 @@ SUBDIR_PYTHON_LDFLAGS =
SUBDIR_PYTHON_CFLAGS =
SUBDIR_UNITTESTS_SRCS = \
unittests/array-view-selftests.c \
unittests/environ-selftests.c \
unittests/function-view-selftests.c \
unittests/offset-type-selftests.c \
@ -534,6 +535,7 @@ SUBDIR_UNITTESTS_SRCS = \
unittests/scoped_restore-selftests.c
SUBDIR_UNITTESTS_OBS = \
array-view-selftests.o \
environ-selftests.o \
function-view-selftests.o \
offset-type-selftests.o \

179
gdb/common/array-view.h Normal file
View file

@ -0,0 +1,179 @@
/* Copyright (C) 2017 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef COMMON_ARRAY_VIEW_H
#define COMMON_ARRAY_VIEW_H
#include "traits.h"
#include <type_traits>
/* An array_view is an abstraction that provides a non-owning view
over a sequence of contiguous objects.
A way to put it is that array_view is to std::vector (and
std::array and built-in arrays with rank==1) like std::string_view
is to std::string.
The main intent of array_view is to use it as function input
parameter type, making it possible to pass in any sequence of
contiguous objects, irrespective of whether the objects live on the
stack or heap and what actual container owns them. Implicit
construction from the element type is supported too, making it easy
to call functions that expect an array of elements when you only
have one element (usually on the stack). For example:
struct A { .... };
void function (gdb::array_view<A> as);
std::vector<A> std_vec = ...;
std::array<A, N> std_array = ...;
A array[] = {...};
A elem;
function (std_vec);
function (std_array);
function (array);
function (elem);
Views can be either mutable or const. A const view is simply
created by specifying a const T as array_view template parameter,
in which case operator[] of non-const array_view objects ends up
returning const references. Making the array_view itself const is
analogous to making a pointer itself be const. I.e., disables
re-seating the view/pointer.
Since array_view objects are small (pointer plus size), and
designed to be trivially copyable, they should generally be passed
around by value.
You can find unit tests covering the whole API in
unittests/array-view-selftests.c. */
namespace gdb {
template <typename T>
class array_view
{
/* True iff decayed T is the same as decayed U. E.g., we want to
say that 'T&' is the same as 'const T'. */
template <typename U>
using IsDecayedT = typename std::is_same<typename std::decay<T>::type,
typename std::decay<U>::type>;
/* True iff decayed T is the same as decayed U, and 'U *' is
implicitly convertible to 'T *'. This is a requirement for
several methods. */
template <typename U>
using DecayedConvertible = gdb::And<IsDecayedT<U>,
std::is_convertible<U *, T *>>;
public:
using value_type = T;
using reference = T &;
using const_reference = const T &;
using size_type = size_t;
/* Default construction creates an empty view. */
constexpr array_view () noexcept
: m_array (nullptr), m_size (0)
{}
/* Create an array view over a single object of the type of an
array_view element. The created view as size==1. This is
templated on U to allow constructing a array_view<const T> over a
(non-const) T. The "convertible" requirement makes sure that you
can't create an array_view<T> over a const T. */
template<typename U,
typename = Requires<DecayedConvertible<U>>>
constexpr array_view (U &elem) noexcept
: m_array (&elem), m_size (1)
{}
/* Same as above, for rvalue references. */
template<typename U,
typename = Requires<DecayedConvertible<U>>>
constexpr array_view (U &&elem) noexcept
: m_array (&elem), m_size (1)
{}
/* Create an array view from a pointer to an array and an element
count. */
template<typename U,
typename = Requires<DecayedConvertible<U>>>
constexpr array_view (U *array, size_t size) noexcept
: m_array (array), m_size (size)
{}
/* Create an array view from a range. This is templated on both U
an V to allow passing in a mix of 'const T *' and 'T *'. */
template<typename U, typename V,
typename = Requires<DecayedConvertible<U>>,
typename = Requires<DecayedConvertible<V>>>
constexpr array_view (U *begin, V *end) noexcept
: m_array (begin), m_size (end - begin)
{}
/* Create an array view from an array. */
template<typename U, size_t Size,
typename = Requires<DecayedConvertible<U>>>
constexpr array_view (U (&array)[Size]) noexcept
: m_array (array), m_size (Size)
{}
/* Create an array view from a contiguous container. E.g.,
std::vector and std::array. */
template<typename Container,
typename = Requires<gdb::Not<IsDecayedT<Container>>>,
typename
= Requires<std::is_convertible
<decltype (std::declval<Container> ().data ()),
T *>>,
typename
= Requires<std::is_convertible
<decltype (std::declval<Container> ().size ()),
size_type>>>
constexpr array_view (Container &&c) noexcept
: m_array (c.data ()), m_size (c.size ())
{}
/* Observer methods. Some of these can't be constexpr until we
require C++14. */
/*constexpr14*/ T *data () noexcept { return m_array; }
constexpr const T *data () const noexcept { return m_array; }
/*constexpr14*/ T *begin () noexcept { return m_array; }
constexpr const T *begin () const noexcept { return m_array; }
/*constexpr14*/ T *end () noexcept { return m_array + m_size; }
constexpr const T *end () const noexcept { return m_array + m_size; }
/*constexpr14*/ reference operator[] (size_t index) noexcept
{ return m_array[index]; }
constexpr const_reference operator[] (size_t index) const noexcept
{ return m_array[index]; }
constexpr size_type size () const noexcept { return m_size; }
constexpr bool empty () const noexcept { return m_size == 0; }
private:
T *m_array;
size_type m_size;
};
} /* namespace gdb */
#endif

494
gdb/unittests/array-view-selftests.c Normal file
View file

@ -0,0 +1,494 @@
/* Self tests for array_view for GDB, the GNU debugger.
Copyright (C) 2017 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "selftest.h"
#include "common/array-view.h"
namespace selftests {
namespace array_view_tests {
/* Triviality checks. */
#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
shorter. (With C++14 we'd use a variable template instead.) */
template<typename From, typename To>
static constexpr bool
is_convertible ()
{
return std::is_convertible<From, To>::value;
}
/* Check for implicit conversion to immutable and mutable views. */
static constexpr bool
check_convertible ()
{
using T = gdb_byte;
using gdb::array_view;
return (true
/* immutable array_view */
&& is_convertible<const T (&) [1], array_view<const T>> ()
&& is_convertible<T (&) [1], array_view<const T>> ()
&& is_convertible<const T, array_view<const T>> ()
&& is_convertible<T, array_view<const T>> ()
/* mutable array_view */
&& is_convertible<T (&) [1], array_view<T>> ()
&& !is_convertible<const T (&) [1], array_view<T>> ()
&& is_convertible<T, array_view<T>> ()
&& !is_convertible<const T, array_view<T>> ()
/* While float is implicitly convertible to gdb_byte, we
don't want implicit float->array_view<gdb_byte>
conversion. */
&& !is_convertible<float, array_view<const T>> ()
&& !is_convertible<float, array_view<T>> ());
}
static_assert (check_convertible (), "");
namespace no_slicing
{
struct A { int i; };
struct B : A { int j; };
struct C : A { int l; };
/* Check that there's no array->view conversion for arrays of derived
types or subclasses. */
static constexpr bool
check ()
{
using gdb::array_view;
return (true
/* array->view */
&& is_convertible <A (&)[1], array_view<A>> ()
&& !is_convertible <B (&)[1], array_view<A>> ()
&& !is_convertible <C (&)[1], array_view<A>> ()
&& !is_convertible <A (&)[1], array_view<B>> ()
&& is_convertible <B (&)[1], array_view<B>> ()
&& !is_convertible <C (&)[1], array_view<B>> ()
/* elem->view */
&& is_convertible <A, array_view<A>> ()
&& !is_convertible <B, array_view<A>> ()
&& !is_convertible <C, array_view<A>> ()
&& !is_convertible <A, array_view<B>> ()
&& is_convertible <B, array_view<B>> ()
&& !is_convertible <C, array_view<B>> ());
}
} /* namespace no_slicing */
static_assert (no_slicing::check (), "");
/* Check that array_view implicitly converts from std::vector. */
static constexpr bool
check_convertible_from_std_vector ()
{
using gdb::array_view;
using T = gdb_byte;
/* Note there's no such thing as std::vector<const T>. */
return (true
&& is_convertible <std::vector<T>, array_view<T>> ()
&& is_convertible <std::vector<T>, array_view<const T>> ());
}
static_assert (check_convertible_from_std_vector (), "");
/* Check that array_view implicitly converts from std::array. */
static constexpr bool
check_convertible_from_std_array ()
{
using gdb::array_view;
using T = gdb_byte;
/* Note: a non-const T view can't refer to a const T array. */
return (true
&& is_convertible <std::array<T, 1>, array_view<T>> ()
&& is_convertible <std::array<T, 1>, array_view<const T>> ()
&& !is_convertible <std::array<const T, 1>, array_view<T>> ()
&& is_convertible <std::array<const T, 1>, array_view<const T>> ());
}
static_assert (check_convertible_from_std_array (), "");
/* Check that VIEW views C (a container like std::vector/std::array)
correctly. */
template<typename View, typename Container>
static bool
check_container_view (const View &view, const Container &c)
{
if (view.empty ())
return false;
if (view.size () != c.size ())
return false;
if (view.data () != c.data ())
return false;
for (size_t i = 0; i < c.size (); i++)
{
if (&view[i] != &c[i])
return false;
if (view[i] != c[i])
return false;
}
return true;
}
/* Check that VIEW views E (an object of the type of a view element)
correctly. */
template<typename View, typename Elem>
static bool
check_elem_view (const View &view, const Elem &e)
{
if (view.empty ())
return false;
if (view.size () != 1)
return false;
if (view.data () != &e)
return false;
if (&view[0] != &e)
return false;
if (view[0] != e)
return false;
return true;
}
/* Check for operator[]. The first overload is taken iff
'view<T>()[0] = T()' is a valid expression. */
template<typename View,
typename = decltype (std::declval<View> ()[0]
= std::declval<typename View::value_type> ())>
static bool
check_op_subscript (const View &view)
{
return true;
}
/* This overload is taken iff 'view<T>()[0] = T()' is not a valid
expression. */
static bool
check_op_subscript (...)
{
return false;
}
/* Check construction with pointer + size. This is a template in
order to test both gdb_byte and const gdb_byte. */
template<typename T>
static void
check_ptr_size_ctor ()
{
T data[] = {0x11, 0x22, 0x33, 0x44};
gdb::array_view<T> view (data + 1, 2);
SELF_CHECK (!view.empty ());
SELF_CHECK (view.size () == 2);
SELF_CHECK (view.data () == &data[1]);
SELF_CHECK (view[0] == data[1]);
SELF_CHECK (view[1] == data[2]);
gdb::array_view<const T> cview (data + 1, 2);
SELF_CHECK (!cview.empty ());
SELF_CHECK (cview.size () == 2);
SELF_CHECK (cview.data () == &data[1]);
SELF_CHECK (cview[0] == data[1]);
SELF_CHECK (cview[1] == data[2]);
}
/* Asserts std::is_constructible. */
template<typename T, typename... Args>
static constexpr bool
require_not_constructible ()
{
static_assert (!std::is_constructible<T, Args...>::value, "");
/* constexpr functions can't return void in C++11 (N3444). */
return true;
};
/* Check the array_view<T>(PTR, SIZE) ctor, when T is a pointer. */
void
check_ptr_size_ctor2 ()
{
struct A {};
A an_a;
A *array[] = { &an_a };
const A * const carray[] = { &an_a };
gdb::array_view<A *> v1 = {array, ARRAY_SIZE (array)};
gdb::array_view<A *> v2 = {array, (char) ARRAY_SIZE (array)};
gdb::array_view<A * const> v3 = {array, ARRAY_SIZE (array)};
gdb::array_view<const A * const> cv1 = {carray, ARRAY_SIZE (carray)};
require_not_constructible<gdb::array_view<A *>, decltype (carray), size_t> ();
SELF_CHECK (v1[0] == array[0]);
SELF_CHECK (v2[0] == array[0]);
SELF_CHECK (v3[0] == array[0]);
SELF_CHECK (!v1.empty ());
SELF_CHECK (v1.size () == 1);
SELF_CHECK (v1.data () == &array[0]);
SELF_CHECK (cv1[0] == carray[0]);
SELF_CHECK (!cv1.empty ());
SELF_CHECK (cv1.size () == 1);
SELF_CHECK (cv1.data () == &carray[0]);
}
/* Check construction with a pair of pointers. This is a template in
order to test both gdb_byte and const gdb_byte. */
template<typename T>
static void
check_ptr_ptr_ctor ()
{
T data[] = {0x11, 0x22, 0x33, 0x44};
gdb::array_view<T> view (data + 1, data + 3);
SELF_CHECK (!view.empty ());
SELF_CHECK (view.size () == 2);
SELF_CHECK (view.data () == &data[1]);
SELF_CHECK (view[0] == data[1]);
SELF_CHECK (view[1] == data[2]);
gdb_byte array[] = {0x11, 0x22, 0x33, 0x44};
const gdb_byte *p1 = array;
gdb_byte *p2 = array + ARRAY_SIZE (array);
gdb::array_view<const gdb_byte> view2 (p1, p2);
}
/* Check construction with a pair of pointers of mixed constness. */
static void
check_ptr_ptr_mixed_cv ()
{
gdb_byte array[] = {0x11, 0x22, 0x33, 0x44};
const gdb_byte *cp = array;
gdb_byte *p = array;
gdb::array_view<const gdb_byte> view1 (cp, p);
gdb::array_view<const gdb_byte> view2 (p, cp);
SELF_CHECK (view1.empty ());
SELF_CHECK (view2.empty ());
}
/* Check range-for support (i.e., begin()/end()). This is a template
in order to test both gdb_byte and const gdb_byte. */
template<typename T>
static void
check_range_for ()
{
T data[] = {1, 2, 3, 4};
gdb::array_view<T> view (data);
typename std::decay<T>::type sum = 0;
for (auto &elem : view)
sum += elem;
SELF_CHECK (sum == 1 + 2 + 3 + 4);
}
/* Entry point. */
static void
run_tests ()
{
/* Empty views. */
{
constexpr gdb::array_view<gdb_byte> view1;
constexpr gdb::array_view<const gdb_byte> view2;
static_assert (view1.empty (), "");
static_assert (view1.data () == nullptr, "");
static_assert (view1.size () == 0, "");
static_assert (view2.empty (), "");
static_assert (view2.size () == 0, "");
static_assert (view2.data () == nullptr, "");
}
std::vector<gdb_byte> vec = {0x11, 0x22, 0x33, 0x44 };
std::array<gdb_byte, 4> array = {{0x11, 0x22, 0x33, 0x44}};
/* Various tests of views over std::vector. */
{
gdb::array_view<gdb_byte> view = vec;
SELF_CHECK (check_container_view (view, vec));
gdb::array_view<const gdb_byte> cview = vec;
SELF_CHECK (check_container_view (cview, vec));
}
/* Likewise, over std::array. */
{
gdb::array_view<gdb_byte> view = array;
SELF_CHECK (check_container_view (view, array));
gdb::array_view<gdb_byte> cview = array;
SELF_CHECK (check_container_view (cview, array));
}
/* op=(std::vector/std::array/elem) */
{
gdb::array_view<gdb_byte> view;
view = vec;
SELF_CHECK (check_container_view (view, vec));
view = std::move (vec);
SELF_CHECK (check_container_view (view, vec));
view = array;
SELF_CHECK (check_container_view (view, array));
view = std::move (array);
SELF_CHECK (check_container_view (view, array));
gdb_byte elem = 0;
view = elem;
SELF_CHECK (check_elem_view (view, elem));
view = std::move (elem);
SELF_CHECK (check_elem_view (view, elem));
}
/* Test copy/move ctor and mutable->immutable conversion. */
{
gdb_byte data[] = {0x11, 0x22, 0x33, 0x44};
gdb::array_view<gdb_byte> view1 = data;
gdb::array_view<gdb_byte> view2 = view1;
gdb::array_view<gdb_byte> view3 = std::move (view1);
gdb::array_view<const gdb_byte> cview1 = data;
gdb::array_view<const gdb_byte> cview2 = cview1;
gdb::array_view<const gdb_byte> cview3 = std::move (cview1);
SELF_CHECK (view1[0] == data[0]);
SELF_CHECK (view2[0] == data[0]);
SELF_CHECK (view3[0] == data[0]);
SELF_CHECK (cview1[0] == data[0]);
SELF_CHECK (cview2[0] == data[0]);
SELF_CHECK (cview3[0] == data[0]);
}
/* Same, but op=(view). */
{
gdb_byte data[] = {0x55, 0x66, 0x77, 0x88};
gdb::array_view<gdb_byte> view1;
gdb::array_view<gdb_byte> view2;
gdb::array_view<gdb_byte> view3;
gdb::array_view<const gdb_byte> cview1;
gdb::array_view<const gdb_byte> cview2;
gdb::array_view<const gdb_byte> cview3;
view1 = data;
view2 = view1;
view3 = std::move (view1);
cview1 = data;
cview2 = cview1;
cview3 = std::move (cview1);
SELF_CHECK (view1[0] == data[0]);
SELF_CHECK (view2[0] == data[0]);
SELF_CHECK (view3[0] == data[0]);
SELF_CHECK (cview1[0] == data[0]);
SELF_CHECK (cview2[0] == data[0]);
SELF_CHECK (cview3[0] == data[0]);
}
/* op[] */
{
std::vector<gdb_byte> vec = {0x11, 0x22};
gdb::array_view<gdb_byte> view = vec;
gdb::array_view<const gdb_byte> cview = vec;
/* Check that op[] on a non-const view of non-const T returns a
mutable reference. */
view[0] = 0x33;
SELF_CHECK (vec[0] == 0x33);
/* OTOH, check that assigning through op[] on a view of const T
wouldn't compile. */
SELF_CHECK (!check_op_subscript (cview));
/* For completeness. */
SELF_CHECK (check_op_subscript (view));
}
check_ptr_size_ctor<const gdb_byte> ();
check_ptr_size_ctor<gdb_byte> ();
check_ptr_size_ctor2 ();
check_ptr_ptr_ctor<const gdb_byte> ();
check_ptr_ptr_ctor<gdb_byte> ();
check_ptr_ptr_mixed_cv ();
check_range_for<gdb_byte> ();
check_range_for<const gdb_byte> ();
/* Check that the right ctor overloads are taken when the element is
a container. */
{
using Vec = std::vector<gdb_byte>;
Vec vecs[3];
gdb::array_view<Vec> view_array = vecs;
SELF_CHECK (view_array.size () == 3);
Vec elem;
gdb::array_view<Vec> view_elem = elem;
SELF_CHECK (view_elem.size () == 1);
}
}
} /* namespace array_view_tests */
} /* namespace selftests */
void
_initialize_array_view_selftests ()
{
selftests::register_test (selftests::array_view_tests::run_tests);
}