mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2025-02-11 13:02:10 +08:00
Code Issues Packages Projects Releases Wiki Activity
2988a36005
binutils-gdb/gdb/unittests/array-view-selftests.c
Simon Marchi 4bce7cdaf4 gdbsupport: add array_view copy function 
An assertion was recently added to array_view::operator[] to ensure we
don't do out of bounds accesses.  However, when the array_view is copied
to or from using memcpy, it bypasses that safety.

To address this, add a `copy` free function that copies data from an
array view to another, ensuring that the destination and source array
views have the same size.  When copying to or from parts of an
array_view, we are expected to use gdb::array_view::slice, which does
its own bounds check.  With all that, any copy operation that goes out
of bounds should be caught by an assertion at runtime.

copy is implemented using std::copy and std::copy_backward, which, at
least on libstdc++, appears to pick memmove when copying trivial data.
So in the end there shouldn't be much difference vs using a bare memcpy,
as we do right now.  When copying non-trivial data, std::copy and
std::copy_backward assigns each element in a loop.

To properly support overlapping ranges, we must use std::copy or
std::copy_backward, depending on whether the destination is before the
source or vice-versa.  std::copy and std::copy_backward don't support
copying exactly overlapping ranges (where the source range is equal to
the destination range).  But in this case, no copy is needed anyway, so
we do nothing.

The order of parameters of the new copy function is based on std::copy
and std::copy_backward, where the source comes before the destination.

Change a few randomly selected spots to use the new function, to show
how it can be used.

Add a test for the new function, testing both with arrays of a trivial
type (int) and of a non-trivial type (foo).  Test non-overlapping
ranges as well as three kinds of overlapping ranges: source before dest,
dest before source, and dest == source.

Change-Id: Ibeaca04e0028410fd44ce82f72e60058d6230a03
2021-12-03 16:37:36 -05:00

663 lines
18 KiB
C
Raw Blame History

/* Self tests for array_view for GDB, the GNU debugger.
Copyright (C) 2017-2021 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 "gdbsupport/selftest.h"
#include "gdbsupport/array-view.h"
#include <array>
#include <vector>
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>> ());
}
/* Check that there's no container->view conversion for containers of derived
types or subclasses. */
template<template<typename ...> class Container>
static constexpr bool
check_ctor_from_container ()
{
using gdb::array_view;
return ( is_convertible <Container<A>, array_view<A>> ()
&& !is_convertible <Container<B>, array_view<A>> ()
&& !is_convertible <Container<C>, array_view<A>> ()
&& !is_convertible <Container<A>, array_view<B>> ()
&& is_convertible <Container<B>, array_view<B>> ()
&& !is_convertible <Container<C>, array_view<B>> ());
}
} /* namespace no_slicing */
/* std::array with only one template argument, so we can pass it to
check_ctor_from_container. */
template<typename T> using StdArray1 = std::array<T, 1>;
static_assert (no_slicing::check (), "");
static_assert (no_slicing::check_ctor_from_container<std::vector> (), "");
static_assert (no_slicing::check_ctor_from_container<StdArray1> (), "");
static_assert (no_slicing::check_ctor_from_container<gdb::array_view> (), "");
/* 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. */
static 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> vec2 = {0x11, 0x22};
gdb::array_view<gdb_byte> view = vec2;
gdb::array_view<const gdb_byte> cview = vec2;
/* Check that op[] on a non-const view of non-const T returns a
mutable reference. */
view[0] = 0x33;
SELF_CHECK (vec2[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);
}
/* gdb::make_array_view, int length. */
{
gdb_byte data[] = {0x55, 0x66, 0x77, 0x88};
int len = sizeof (data) / sizeof (data[0]);
auto view = gdb::make_array_view (data, len);
SELF_CHECK (view.data () == data);
SELF_CHECK (view.size () == len);
for (size_t i = 0; i < len; i++)
SELF_CHECK (view[i] == data[i]);
}
/* Test slicing. */
{
gdb_byte data[] = {0x55, 0x66, 0x77, 0x88, 0x99};
gdb::array_view<gdb_byte> view = data;
{
auto slc = view.slice (1, 3);
SELF_CHECK (slc.data () == data + 1);
SELF_CHECK (slc.size () == 3);
SELF_CHECK (slc[0] == data[1]);
SELF_CHECK (slc[0] == view[1]);
}
{
auto slc = view.slice (2);
SELF_CHECK (slc.data () == data + 2);
SELF_CHECK (slc.size () == 3);
SELF_CHECK (slc[0] == view[2]);
SELF_CHECK (slc[0] == data[2]);
}
}
}
template <typename T>
void
run_copy_test ()
{
/* Test non-overlapping copy. */
{
const std::vector<T> src_v = {1, 2, 3, 4};
std::vector<T> dest_v (4, -1);
SELF_CHECK (dest_v != src_v);
copy (gdb::array_view<const T> (src_v), gdb::array_view<T> (dest_v));
SELF_CHECK (dest_v == src_v);
}
/* Test overlapping copy, where the source is before the destination. */
{
std::vector<T> vec = {1, 2, 3, 4, 5, 6, 7, 8};
gdb::array_view<T> v = vec;
copy (v.slice (1, 4),
v.slice (2, 4));
std::vector<T> expected = {1, 2, 2, 3, 4, 5, 7, 8};
SELF_CHECK (vec == expected);
}
/* Test overlapping copy, where the source is after the destination. */
{
std::vector<T> vec = {1, 2, 3, 4, 5, 6, 7, 8};
gdb::array_view<T> v = vec;
copy (v.slice (2, 4),
v.slice (1, 4));
std::vector<T> expected = {1, 3, 4, 5, 6, 6, 7, 8};
SELF_CHECK (vec == expected);
}
/* Test overlapping copy, where the source is the same as the destination. */
{
std::vector<T> vec = {1, 2, 3, 4, 5, 6, 7, 8};
gdb::array_view<T> v = vec;
copy (v.slice (2, 4),
v.slice (2, 4));
std::vector<T> expected = {1, 2, 3, 4, 5, 6, 7, 8};
SELF_CHECK (vec == expected);
}
}
/* Class with a non-trivial copy assignment operator, used to test the
array_view copy function. */
struct foo
{
/* Can be implicitly constructed from an int, such that we can use the same
templated test function to test against array_view<int> and
array_view<foo>. */
foo (int n)
: n (n)
{}
/* Needed to avoid -Wdeprecated-copy-with-user-provided-copy error with
Clang. */
foo (const foo &other) = default;
void operator= (const foo &other)
{
this->n = other.n;
this->n_assign_op_called++;
}
bool operator==(const foo &other) const
{
return this->n == other.n;
}
int n;
/* Number of times the assignment operator has been called. */
static int n_assign_op_called;
};
int foo::n_assign_op_called = 0;
/* Test the array_view copy free function. */
static void
run_copy_tests ()
{
/* Test with a trivial type. */
run_copy_test<int> ();
/* Test with a non-trivial type. */
foo::n_assign_op_called = 0;
run_copy_test<foo> ();
/* Make sure that for the non-trivial type foo, the assignment operator was
called an amount of times that makes sense. */
SELF_CHECK (foo::n_assign_op_called == 12);
}
} /* namespace array_view_tests */
} /* namespace selftests */
void _initialize_array_view_selftests ();
void
_initialize_array_view_selftests ()
{
selftests::register_test ("array_view",
selftests::array_view_tests::run_tests);
selftests::register_test ("array_view-copy",
selftests::array_view_tests::run_copy_tests);
}
Reference in New Issue View Git Blame Copy Permalink