[2/2] Add gdb::string_view

Message ID 20180317234902.18278-2-simon.marchi@polymtl.ca
State New
Headers show
Series
  • [1/2] Update ax_cv_cxx_compile_cxx.m4
Related show

Commit Message

Simon Marchi March 17, 2018, 11:49 p.m.
We had a few times the need for a data structure that does essentially
what C++17's std::string_view does, which is to give an std::string-like
interface (only the read-only operations) to an arbitrary character
buffer.

I first copied the string_view file from today's gcc master
(b427286632d7) and adapted it (I don't think there should be any legal
issues since the copyright should already belong to the FSF):

- I removed things related to wstring_view, u16string_view and
  u32string_view (I don't think we need them, but we can always add them
  later).
- I removed usages of _GLIBCXX_BEGIN_NAMESPACE_VERSION and
  _GLIBCXX_END_NAMESPACE_VERSION.
- I put the code in the gdb namespace.  I had to add a few "std::" in front of
  std type usages.
- I added a constructor that builds a string_view from an std::string,
  so that we can pass strings to string_view parameters seamlessly.
  Normally, that's handled by "operator __sv_type" in the std::string
  declaration, but it only exists when building with c++17.
- When building with >= c++17, gdb::string_view is an alias of
  std::string_view.

The result is close enough to the original file that if we ever need to
update it, it should be easy enough to compare it with the new version
in a diff editor and merge the new changes in.

gdb/ChangeLog:

	* common/string_view.h: New file.
	* cli/cli-script.c (user_args) <m_args>: Change element type to
	gdb::string_view.
---
 gdb/cli/cli-script.c     |  17 +-
 gdb/common/string_view.h | 594 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 597 insertions(+), 14 deletions(-)
 create mode 100644 gdb/common/string_view.h

-- 
2.16.2

Comments

Simon Marchi March 18, 2018, 12:10 a.m. | #1
On 2018-03-17 19:49, Simon Marchi wrote:
> We had a few times the need for a data structure that does essentially

> what C++17's std::string_view does, which is to give an std::string-like

> interface (only the read-only operations) to an arbitrary character

> buffer.

>

> I first copied the string_view file from today's gcc master

> (b427286632d7) and adapted it (I don't think there should be any legal

> issues since the copyright should already belong to the FSF):

>

> - I removed things related to wstring_view, u16string_view and

>   u32string_view (I don't think we need them, but we can always add them

>   later).

> - I removed usages of _GLIBCXX_BEGIN_NAMESPACE_VERSION and

>   _GLIBCXX_END_NAMESPACE_VERSION.

> - I put the code in the gdb namespace.  I had to add a few "std::" in front of

>   std type usages.

> - I added a constructor that builds a string_view from an std::string,

>   so that we can pass strings to string_view parameters seamlessly.

>   Normally, that's handled by "operator __sv_type" in the std::string

>   declaration, but it only exists when building with c++17.

> - When building with >= c++17, gdb::string_view is an alias of

>   std::string_view.

>

> The result is close enough to the original file that if we ever need to

> update it, it should be easy enough to compare it with the new version

> in a diff editor and merge the new changes in.


Hmm, when building with older g++ (such as the aarch64 builders on the buildbot,
which have g++ 4.8), it trips on:

  using __idt = std::common_type_t<_Tp>;

It looks like that release of g++ didn't have std::common_type_t.  I guess it
would be possible to avoid using it, and change these:

    operator==(basic_string_view<_CharT, _Traits> __x,
               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept

for

    operator==(basic_string_view<_CharT, _Traits> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept

but I am not aware of what consequences it would have.

Simon
Pedro Alves March 19, 2018, 12:21 p.m. | #2
On 03/18/2018 12:10 AM, Simon Marchi wrote:
> On 2018-03-17 19:49, Simon Marchi wrote:

>> We had a few times the need for a data structure that does essentially

>> what C++17's std::string_view does, which is to give an std::string-like

>> interface (only the read-only operations) to an arbitrary character

>> buffer.


Great, I've been wanting to do something like this for a while.

>>

>> I first copied the string_view file from today's gcc master

>> (b427286632d7) and adapted it (I don't think there should be any legal

>> issues since the copyright should already belong to the FSF):

>>

>> - I removed things related to wstring_view, u16string_view and

>>   u32string_view (I don't think we need them, but we can always add them

>>   later).

>> - I removed usages of _GLIBCXX_BEGIN_NAMESPACE_VERSION and

>>   _GLIBCXX_END_NAMESPACE_VERSION.

>> - I put the code in the gdb namespace.  I had to add a few "std::" in front of

>>   std type usages.

>> - I added a constructor that builds a string_view from an std::string,

>>   so that we can pass strings to string_view parameters seamlessly.

>>   Normally, that's handled by "operator __sv_type" in the std::string

>>   declaration, but it only exists when building with c++17.

>> - When building with >= c++17, gdb::string_view is an alias of

>>   std::string_view.

>>

>> The result is close enough to the original file that if we ever need to

>> update it, it should be easy enough to compare it with the new version

>> in a diff editor and merge the new changes in.

> 

> Hmm, when building with older g++ (such as the aarch64 builders on the buildbot,

> which have g++ 4.8), it trips on:

> 

>   using __idt = std::common_type_t<_Tp>;

> 

> It looks like that release of g++ didn't have std::common_type_t.  I guess it

> would be possible to avoid using it, and change these:


It has std::common_type though.  C++14 std::foo_t types are usually just a
helper/convenience alias template, like:

  /// Alias template for common_type
  template<typename... _Tp>
    using common_type_t = typename common_type<_Tp...>::type;

So it sounds like we can just use the C++11 / ::type form directly, or
add gdb::common_type_t somewhere, like common/traits.h or to our
copy of string_view.

> 

>     operator==(basic_string_view<_CharT, _Traits> __x,

>                __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept

> 

> for

> 

>     operator==(basic_string_view<_CharT, _Traits> __x,

>                basic_string_view<_CharT, _Traits> __y) noexcept

> 

> but I am not aware of what consequences it would have.


Would it be possible to import some of the libstdc++'s relevant
testscases into our unit tests framework, like was done for
gdb::optional [1]?

[1] https://sourceware.org/ml/gdb-patches/2017-04/msg00239.html

Thanks,
Pedro Alves
Simon Marchi March 30, 2018, 5:42 p.m. | #3
On 2018-03-19 08:21, Pedro Alves wrote:
>> Hmm, when building with older g++ (such as the aarch64 builders on the 

>> buildbot,

>> which have g++ 4.8), it trips on:

>> 

>>   using __idt = std::common_type_t<_Tp>;

>> 

>> It looks like that release of g++ didn't have std::common_type_t.  I 

>> guess it

>> would be possible to avoid using it, and change these:

> 

> It has std::common_type though.  C++14 std::foo_t types are usually 

> just a

> helper/convenience alias template, like:

> 

>   /// Alias template for common_type

>   template<typename... _Tp>

>     using common_type_t = typename common_type<_Tp...>::type;

> 

> So it sounds like we can just use the C++11 / ::type form directly, or

> add gdb::common_type_t somewhere, like common/traits.h or to our

> copy of string_view.


Ok thanks I think I got it to work now.

> 

>> 

>>     operator==(basic_string_view<_CharT, _Traits> __x,

>>                __detail::__idt<basic_string_view<_CharT, _Traits>> 

>> __y) noexcept

>> 

>> for

>> 

>>     operator==(basic_string_view<_CharT, _Traits> __x,

>>                basic_string_view<_CharT, _Traits> __y) noexcept

>> 

>> but I am not aware of what consequences it would have.

> 

> Would it be possible to import some of the libstdc++'s relevant

> testscases into our unit tests framework, like was done for

> gdb::optional [1]?

> 

> [1] https://sourceware.org/ml/gdb-patches/2017-04/msg00239.html


Good idea, I did it and it caught a few important compilation issues!

I just need to clean up the patches and I'll send a v2.

Thanks,

Simon

Patch

diff --git a/gdb/cli/cli-script.c b/gdb/cli/cli-script.c
index 366c42227c62..e705b7a8da70 100644
--- a/gdb/cli/cli-script.c
+++ b/gdb/cli/cli-script.c
@@ -32,6 +32,7 @@ 
 #include "extension.h"
 #include "interps.h"
 #include "compile/compile.h"
+#include "common/string_view.h"
 
 #include <vector>
 
@@ -54,18 +55,6 @@  static int command_nest_depth = 1;
 /* This is to prevent certain commands being printed twice.  */
 static int suppress_next_print_command_trace = 0;
 
-/* A non-owning slice of a string.  */
-
-struct string_view
-{
-  string_view (const char *str_, size_t len_)
-    : str (str_), len (len_)
-  {}
-
-  const char *str;
-  size_t len;
-};
-
 /* Structure for arguments to user defined functions.  */
 
 class user_args
@@ -91,7 +80,7 @@  private:
   std::string m_command_line;
 
   /* The arguments.  Each element points inside M_COMMAND_LINE.  */
-  std::vector<string_view> m_args;
+  std::vector<gdb::string_view> m_args;
 };
 
 /* The stack of arguments passed to user defined functions.  We need a
@@ -827,7 +816,7 @@  user_args::insert_args (const char *line) const
 	    error (_("Missing argument %ld in user function."), i);
 	  else
 	    {
-	      new_line.append (m_args[i].str, m_args[i].len);
+	      new_line.append (m_args[i].data (), m_args[i].length ());
 	      line = tmp;
 	    }
 	}
diff --git a/gdb/common/string_view.h b/gdb/common/string_view.h
new file mode 100644
index 000000000000..710049dbf0eb
--- /dev/null
+++ b/gdb/common/string_view.h
@@ -0,0 +1,594 @@ 
+// Components for manipulating non-owning sequences of characters -*- C++ -*-
+
+// Note: This file has been stolen from the gcc repo
+// (libstdc++-v3/include/std/string_view) and has local modifications.
+
+// Copyright (C) 2013-2017 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library 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, or (at your option)
+// any later version.
+
+// This library 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.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+
+//
+// N3762 basic_string_view library
+//
+
+#ifndef STRING_VIEW_H
+#define STRING_VIEW_H 1
+
+#if __cplusplus >= 201703L
+
+#include <string_view>
+
+namespace gdb {
+  using string_view = std::string_view;
+} /* namespace gdb */
+
+#else /* __cplusplus >= 201703L */
+
+#include <limits>
+#include <iosfwd>
+#include <bits/char_traits.h>
+#include <bits/functional_hash.h>
+#include <bits/range_access.h>
+
+namespace gdb {
+  /**
+   *  @class basic_string_view <string_view>
+   *  @brief  A non-owning reference to a string.
+   *
+   *  @ingroup strings
+   *  @ingroup sequences
+   *
+   *  @tparam _CharT  Type of character
+   *  @tparam _Traits  Traits for character type, defaults to
+   *                   char_traits<_CharT>.
+   *
+   *  A basic_string_view looks like this:
+   *
+   *  @code
+   *    _CharT*    _M_str
+   *    size_t     _M_len
+   *  @endcode
+   */
+  template<typename _CharT, typename _Traits = std::char_traits<_CharT>>
+    class basic_string_view
+    {
+    public:
+
+      // types
+      using traits_type = _Traits;
+      using value_type = _CharT;
+      using pointer = const _CharT*;
+      using const_pointer = const _CharT*;
+      using reference = const _CharT&;
+      using const_reference = const _CharT&;
+      using const_iterator = const _CharT*;
+      using iterator = const_iterator;
+      using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+      using reverse_iterator = const_reverse_iterator;
+      using size_type = size_t;
+      using difference_type = ptrdiff_t;
+      static constexpr size_type npos = size_type(-1);
+
+      // [string.view.cons], construct/copy
+
+      constexpr
+      basic_string_view() noexcept
+      : _M_len{0}, _M_str{nullptr}
+      { }
+
+      constexpr basic_string_view(const basic_string_view&) noexcept = default;
+
+      constexpr basic_string_view(const _CharT* __str) noexcept
+      : _M_len{__str == nullptr ? 0 : traits_type::length(__str)},
+	_M_str{__str}
+      { }
+
+      constexpr
+      basic_string_view(const _CharT* __str, size_type __len) noexcept
+      : _M_len{__len}, _M_str{__str}
+      { }
+
+      constexpr
+      basic_string_view(const std::string &__str) noexcept
+      : _M_len{__str.length()}, _M_str{__str.c_str()}
+      { }
+
+      constexpr basic_string_view&
+      operator=(const basic_string_view&) noexcept = default;
+
+      // [string.view.iterators], iterators
+
+      constexpr const_iterator
+      begin() const noexcept
+      { return this->_M_str; }
+
+      constexpr const_iterator
+      end() const noexcept
+      { return this->_M_str + this->_M_len; }
+
+      constexpr const_iterator
+      cbegin() const noexcept
+      { return this->_M_str; }
+
+      constexpr const_iterator
+      cend() const noexcept
+      { return this->_M_str + this->_M_len; }
+
+      constexpr const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+
+      constexpr const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+
+      constexpr const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+
+      constexpr const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+
+      // [string.view.capacity], capacity
+
+      constexpr size_type
+      size() const noexcept
+      { return this->_M_len; }
+
+      constexpr size_type
+      length() const noexcept
+      { return _M_len; }
+
+      constexpr size_type
+      max_size() const noexcept
+      {
+	return (npos - sizeof(size_type) - sizeof(void*))
+		/ sizeof(value_type) / 4;
+      }
+
+      constexpr bool
+      empty() const noexcept
+      { return this->_M_len == 0; }
+
+      // [string.view.access], element access
+
+      constexpr const _CharT&
+      operator[](size_type __pos) const noexcept
+      {
+	// TODO: Assert to restore in a way compatible with the constexpr.
+	// __glibcxx_assert(__pos < this->_M_len);
+	return *(this->_M_str + __pos);
+      }
+
+      constexpr const _CharT&
+      at(size_type __pos) const
+      {
+	if (__pos >= _M_len)
+	  __throw_out_of_range_fmt(__N("basic_string_view::at: __pos "
+				       "(which is %zu) >= this->size() "
+				       "(which is %zu)"), __pos, this->size());
+	return *(this->_M_str + __pos);
+      }
+
+      constexpr const _CharT&
+      front() const noexcept
+      {
+	// TODO: Assert to restore in a way compatible with the constexpr.
+	// __glibcxx_assert(this->_M_len > 0);
+	return *this->_M_str;
+      }
+
+      constexpr const _CharT&
+      back() const noexcept
+      {
+	// TODO: Assert to restore in a way compatible with the constexpr.
+	// __glibcxx_assert(this->_M_len > 0);
+	return *(this->_M_str + this->_M_len - 1);
+      }
+
+      constexpr const _CharT*
+      data() const noexcept
+      { return this->_M_str; }
+
+      // [string.view.modifiers], modifiers:
+
+      constexpr void
+      remove_prefix(size_type __n) noexcept
+      {
+	__glibcxx_assert(this->_M_len >= __n);
+	this->_M_str += __n;
+	this->_M_len -= __n;
+      }
+
+      constexpr void
+      remove_suffix(size_type __n) noexcept
+      { this->_M_len -= __n; }
+
+      constexpr void
+      swap(basic_string_view& __sv) noexcept
+      {
+	auto __tmp = *this;
+	*this = __sv;
+	__sv = __tmp;
+      }
+
+
+      // [string.view.ops], string operations:
+
+      size_type
+      copy(_CharT* __str, size_type __n, size_type __pos = 0) const
+      {
+	__glibcxx_requires_string_len(__str, __n);
+	__pos = _M_check(__pos, "basic_string_view::copy");
+	const size_type __rlen = std::min(__n, _M_len - __pos);
+	for (auto __begin = this->_M_str + __pos,
+	     __end = __begin + __rlen; __begin != __end;)
+	  *__str++ = *__begin++;
+	return __rlen;
+      }
+
+
+      // [string.view.ops], string operations:
+
+      constexpr basic_string_view
+      substr(size_type __pos, size_type __n = npos) const noexcept(false)
+      {
+	__pos = _M_check(__pos, "basic_string_view::substr");
+	const size_type __rlen = std::min(__n, _M_len - __pos);
+	return basic_string_view{_M_str + __pos, __rlen};
+      }
+
+      constexpr int
+      compare(basic_string_view __str) const noexcept
+      {
+	const size_type __rlen = std::min(this->_M_len, __str._M_len);
+	int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen);
+	if (__ret == 0)
+	  __ret = _S_compare(this->_M_len, __str._M_len);
+	return __ret;
+      }
+
+      constexpr int
+      compare(size_type __pos1, size_type __n1, basic_string_view __str) const
+      { return this->substr(__pos1, __n1).compare(__str); }
+
+      constexpr int
+      compare(size_type __pos1, size_type __n1,
+	      basic_string_view __str, size_type __pos2, size_type __n2) const
+      {
+	return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2));
+      }
+
+      constexpr int
+      compare(const _CharT* __str) const noexcept
+      { return this->compare(basic_string_view{__str}); }
+
+      constexpr int
+      compare(size_type __pos1, size_type __n1, const _CharT* __str) const
+      { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }
+
+      constexpr int
+      compare(size_type __pos1, size_type __n1,
+	      const _CharT* __str, size_type __n2) const noexcept(false)
+      {
+	return this->substr(__pos1, __n1)
+		   .compare(basic_string_view(__str, __n2));
+      }
+
+      constexpr size_type
+      find(basic_string_view __str, size_type __pos = 0) const noexcept
+      { return this->find(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      find(_CharT __c, size_type __pos = 0) const noexcept;
+
+      constexpr size_type
+      find(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
+
+      constexpr size_type
+      find(const _CharT* __str, size_type __pos = 0) const noexcept
+      { return this->find(__str, __pos, traits_type::length(__str)); }
+
+      constexpr size_type
+      rfind(basic_string_view __str, size_type __pos = npos) const noexcept
+      { return this->rfind(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      rfind(_CharT __c, size_type __pos = npos) const noexcept;
+
+      constexpr size_type
+      rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
+
+      constexpr size_type
+      rfind(const _CharT* __str, size_type __pos = npos) const noexcept
+      { return this->rfind(__str, __pos, traits_type::length(__str)); }
+
+      constexpr size_type
+      find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
+      { return this->find_first_of(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
+      { return this->find(__c, __pos); }
+
+      constexpr size_type
+      find_first_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
+
+      constexpr size_type
+      find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
+      { return this->find_first_of(__str, __pos, traits_type::length(__str)); }
+
+      constexpr size_type
+      find_last_of(basic_string_view __str,
+		   size_type __pos = npos) const noexcept
+      { return this->find_last_of(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      find_last_of(_CharT __c, size_type __pos=npos) const noexcept
+      { return this->rfind(__c, __pos); }
+
+      constexpr size_type
+      find_last_of(const _CharT* __str, size_type __pos,
+		   size_type __n) const noexcept;
+
+      constexpr size_type
+      find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
+      { return this->find_last_of(__str, __pos, traits_type::length(__str)); }
+
+      constexpr size_type
+      find_first_not_of(basic_string_view __str,
+			size_type __pos = 0) const noexcept
+      { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;
+
+      constexpr size_type
+      find_first_not_of(const _CharT* __str,
+			size_type __pos, size_type __n) const noexcept;
+
+      constexpr size_type
+      find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
+      {
+	return this->find_first_not_of(__str, __pos,
+				       traits_type::length(__str));
+      }
+
+      constexpr size_type
+      find_last_not_of(basic_string_view __str,
+		       size_type __pos = npos) const noexcept
+      { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;
+
+      constexpr size_type
+      find_last_not_of(const _CharT* __str,
+		       size_type __pos, size_type __n) const noexcept;
+
+      constexpr size_type
+      find_last_not_of(const _CharT* __str,
+		       size_type __pos = npos) const noexcept
+      {
+	return this->find_last_not_of(__str, __pos,
+				      traits_type::length(__str));
+      }
+
+      constexpr size_type
+      _M_check(size_type __pos, const char* __s) const noexcept(false)
+      {
+	if (__pos > this->size())
+	  __throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > "
+				       "this->size() (which is %zu)"),
+				   __s, __pos, this->size());
+	return __pos;
+      }
+
+      // NB: _M_limit doesn't check for a bad __pos value.
+      constexpr size_type
+      _M_limit(size_type __pos, size_type __off) const noexcept
+      {
+	const bool __testoff =  __off < this->size() - __pos;
+	return __testoff ? __off : this->size() - __pos;
+      }
+      
+    private:
+
+      static constexpr int
+      _S_compare(size_type __n1, size_type __n2) noexcept
+      {
+	const difference_type __diff = __n1 - __n2;
+	if (__diff > std::numeric_limits<int>::max())
+	  return std::numeric_limits<int>::max();
+	if (__diff < std::numeric_limits<int>::min())
+	  return std::numeric_limits<int>::min();
+	return static_cast<int>(__diff);
+      }
+
+      size_t	    _M_len;
+      const _CharT* _M_str;
+    };
+
+  // [string.view.comparison], non-member basic_string_view comparison function
+
+  namespace __detail
+  {
+    // Identity transform to create a non-deduced context, so that only one
+    // argument participates in template argument deduction and the other
+    // argument gets implicitly converted to the deduced type. See n3766.html.
+    template<typename _Tp>
+      using __idt = std::common_type_t<_Tp>;
+  }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator==(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.size() == __y.size() && __x.compare(__y) == 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator==(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.size() == __y.size() && __x.compare(__y) == 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator==(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.size() == __y.size() && __x.compare(__y) == 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator!=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return !(__x == __y); }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator!=(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return !(__x == __y); }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator!=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return !(__x == __y); }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator< (basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) < 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator< (basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) < 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator< (__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) < 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator> (basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) > 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator> (basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) > 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator> (__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) > 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator<=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator<=(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator<=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator>=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator>=(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator>=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+
+  // [string.view.io], Inserters and extractors
+  template<typename _CharT, typename _Traits>
+    inline std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+	       basic_string_view<_CharT,_Traits> __str)
+    { return __ostream_insert(__os, __str.data(), __str.size()); }
+
+
+  // basic_string_view typedef names
+
+  using string_view = basic_string_view<char>;
+
+  // [string.view.hash], hash support:
+
+  template<typename _Tp>
+    struct hash;
+
+  template<>
+    struct hash<string_view>
+    : public std::__hash_base<size_t, string_view>
+    {
+      size_t
+      operator()(const string_view& __str) const noexcept
+      { return std::_Hash_impl::hash(__str.data(), __str.length()); }
+    };
+
+  inline namespace literals
+  {
+  inline namespace string_view_literals
+  {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+    inline constexpr basic_string_view<char>
+    operator""sv(const char* __str, size_t __len) noexcept
+    { return basic_string_view<char>{__str, __len}; }
+#pragma GCC diagnostic pop
+  } // namespace string_literals
+  } // namespace literals
+
+} /* namespace gdb */
+
+#endif /* __cplusplus >= 201703L */
+
+#endif /* STRING_VIEW_H */