diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 2d12899..f0e9797 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,13 @@
 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
 	ambiguous_line_spec.
 	(list_command): Pass message to ambiguous_line_spec.  Say
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 85de646..d9094fd 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -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 \
diff --git a/gdb/common/array-view.h b/gdb/common/array-view.h
new file mode 100644
index 0000000..85d189c
--- /dev/null
+++ b/gdb/common/array-view.h
@@ -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
diff --git a/gdb/unittests/array-view-selftests.c b/gdb/unittests/array-view-selftests.c
new file mode 100644
index 0000000..c4c95bc
--- /dev/null
+++ b/gdb/unittests/array-view-selftests.c
@@ -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);
+}
