gdb: move displaced_step_dump_bytes into gdbsupport (and rename)

It was pointed out during review of another patch that the function
displaced_step_dump_bytes really isn't specific to displaced stepping,
and should really get a more generic name and move into gdbsupport/.

This commit does just that.  The function is renamed to
bytes_to_string and is moved into gdbsupport/common-utils.{cc,h}.  The
function implementation doesn't really change. Much...

... I have updated the function to take an array view, which makes it
slightly easier to call in a couple of places where we already have a
gdb::bytes_vector.  I've then added an inline wrapper to convert a raw
pointer and length into an array view, which is used in places where
we don't easily have a gdb::bytes_vector (or similar).

Updated all users of displaced_step_dump_bytes.

There should be no user visible changes after this commit.

Finally, I ended up having to add an include of gdb_assert.h into
array-view.h.  When I include array-view.h into common-utils.h I ran
into build problems because array-view.h calls gdb_assert.

Approved-By: Simon Marchi <simon.marchi@efficios.com>

diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index 81665e52d29715c4f121e52e73af5d090157be2c..228b7518cb0961136bda275e97d55025d64be42f 100644 (file)
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -1526,7 +1526,7 @@ amd64_displaced_step_copy_insn (struct gdbarch *gdbarch,
 
   displaced_debug_printf ("copy %s->%s: %s",
                          paddress (gdbarch, from), paddress (gdbarch, to),
-                         displaced_step_dump_bytes (buf, len).c_str ());
+                         bytes_to_string (buf, len).c_str ());
 
   /* This is a work around for a problem with g++ 4.8.  */
   return displaced_step_copy_insn_closure_up (dsc.release ());

diff --git a/gdb/displaced-stepping.c b/gdb/displaced-stepping.c
index 3fefdf322d8f6aeaf0c870ecab5f94f46b39ecd1..c26888404b38e23049ce719d13548154730120e4 100644 (file)
--- a/gdb/displaced-stepping.c
+++ b/gdb/displaced-stepping.c
@@ -122,8 +122,7 @@ displaced_step_buffers::prepare (thread_info *thread, CORE_ADDR &displaced_pc)
 
   displaced_debug_printf ("saved %s: %s",
                          paddress (arch, buffer->addr),
-                         displaced_step_dump_bytes
-                         (buffer->saved_copy.data (), len).c_str ());
+                         bytes_to_string (buffer->saved_copy).c_str ());
 
   /* Save this in a local variable first, so it's released if code below
      throws.  */

diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index 96c04c1a3d6a7870b125ea3ab2106546aa60d26e..e93479c35a3086ca011db1e69b3104fcb5e9be6b 100644 (file)
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -830,7 +830,7 @@ i386_displaced_step_copy_insn (struct gdbarch *gdbarch,
 
   displaced_debug_printf ("%s->%s: %s",
                          paddress (gdbarch, from), paddress (gdbarch, to),
-                         displaced_step_dump_bytes (buf, len).c_str ());
+                         bytes_to_string (buf, len).c_str ());
 
   /* This is a work around for a problem with g++ 4.8.  */
   return displaced_step_copy_insn_closure_up (closure.release ());

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 5ccdc0c87497d90edec859acd67e3c0fdf8e25ea..8a8439f6da55bbfacd160a3315a4ebd149cc15ff 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1725,24 +1725,6 @@ displaced_step_reset (displaced_step_thread_state *displaced)
 
 using displaced_step_reset_cleanup = FORWARD_SCOPE_EXIT (displaced_step_reset);
 
-/* See infrun.h.  */
-
-std::string
-displaced_step_dump_bytes (const gdb_byte *buf, size_t len)
-{
-  std::string ret;
-
-  for (size_t i = 0; i < len; i++)
-    {
-      if (i == 0)
-       ret += string_printf ("%02x", buf[i]);
-      else
-       ret += string_printf (" %02x", buf[i]);
-    }
-
-  return ret;
-}
-
 /* Prepare to single-step, using displaced stepping.
 
    Note that we cannot use displaced stepping when we have a signal to
@@ -1820,8 +1802,7 @@ displaced_step_prepare_throw (thread_info *tp)
          gdb::byte_vector insn_buf (dislen);
          read_memory (original_pc, insn_buf.data (), insn_buf.size ());
 
-         std::string insn_bytes
-           = displaced_step_dump_bytes (insn_buf.data (), insn_buf.size ());
+         std::string insn_bytes = bytes_to_string (insn_buf);
 
          displaced_debug_printf ("original insn %s: %s \t %s",
                                  paddress (gdbarch, original_pc),
@@ -1902,8 +1883,7 @@ displaced_step_prepare_throw (thread_info *tp)
          gdb::byte_vector insn_buf (dislen);
          read_memory (addr, insn_buf.data (), insn_buf.size ());
 
-         std::string insn_bytes
-           = displaced_step_dump_bytes (insn_buf.data (), insn_buf.size ());
+         std::string insn_bytes = bytes_to_string (insn_buf);
          std::string insn_str = tmp_stream.release ();
          displaced_debug_printf ("replacement insn %s: %s \t %s",
                                  paddress (gdbarch, addr),

diff --git a/gdb/infrun.h b/gdb/infrun.h
index 5219063586d23c6ff0ab405e095978d7a23e7e69..9b3c896293993877757f2c4b6ef10eeae92e1314 100644 (file)
--- a/gdb/infrun.h
+++ b/gdb/infrun.h
@@ -270,9 +270,6 @@ extern void update_signals_program_target (void);
    $_exitsignal.  */
 extern void clear_exit_convenience_vars (void);
 
-/* Dump LEN bytes at BUF in hex to a string and return it.  */
-extern std::string displaced_step_dump_bytes (const gdb_byte *buf, size_t len);
-
 extern void update_observer_mode (void);
 
 extern void signal_catch_update (const unsigned int *);

diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index 8b400047cfba4e522d4d32d990e40213b3c898a9..b071f38c960502f4cba82e0d9c73e00145c984ce 100644 (file)
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -940,7 +940,7 @@ ppc_displaced_step_copy_insn (struct gdbarch *gdbarch,
 
   displaced_debug_printf ("copy %s->%s: %s",
                          paddress (gdbarch, from), paddress (gdbarch, to),
-                         displaced_step_dump_bytes (buf, len).c_str ());
+                         bytes_to_string (buf, len).c_str ());
 
   /* This is a work around for a problem with g++ 4.8.  */
   return displaced_step_copy_insn_closure_up (closure.release ());

diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index cab1757c5ab9c1be5faf9598c8281c6240d5a183..081a8b68867b53c22e70c0eccdf5a06e0c00611c 100644 (file)
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -469,7 +469,7 @@ s390_displaced_step_copy_insn (struct gdbarch *gdbarch,
 
   displaced_debug_printf ("copy %s->%s: %s",
                          paddress (gdbarch, from), paddress (gdbarch, to),
-                         displaced_step_dump_bytes (buf, len).c_str ());
+                         bytes_to_string (buf, len).c_str ());
 
   /* This is a work around for a problem with g++ 4.8.  */
   return displaced_step_copy_insn_closure_up (closure.release ());

diff --git a/gdbsupport/array-view.h b/gdbsupport/array-view.h
index 3d8248b08b77e07987e50ca1f0158a04333e7472..d07c8bc53fc00663bf0a5137999c43564a7005be 100644 (file)
--- a/gdbsupport/array-view.h
+++ b/gdbsupport/array-view.h
@@ -21,6 +21,7 @@
 #include "traits.h"
 #include <algorithm>
 #include <type_traits>
+#include "gdbsupport/gdb_assert.h"
 
 /* An array_view is an abstraction that provides a non-owning view
    over a sequence of contiguous objects.

diff --git a/gdbsupport/common-utils.cc b/gdbsupport/common-utils.cc
index e382fb28d8fb97a6b1bd7b8ee84ca70c2c4433ec..4a96f2c0e119f3693467dc002fb3a7036db75501 100644 (file)
--- a/gdbsupport/common-utils.cc
+++ b/gdbsupport/common-utils.cc
@@ -445,3 +445,21 @@ hex2bin (const char *hex)
 
   return bin;
 }
+
+/* See gdbsupport/common-utils.h.  */
+
+std::string
+bytes_to_string (gdb::array_view<const gdb_byte> bytes)
+{
+  std::string ret;
+
+  for (size_t i = 0; i < bytes.size (); i++)
+    {
+      if (i == 0)
+       ret += string_printf ("%02x", bytes[i]);
+      else
+       ret += string_printf (" %02x", bytes[i]);
+    }
+
+  return ret;
+}

diff --git a/gdbsupport/common-utils.h b/gdbsupport/common-utils.h
index 97dcb9fa8ce16f7e5295421d33fd0d31e667781a..4ceb44d88b88bf5f6ee0cc5a263f71afe2ab88d9 100644 (file)
--- a/gdbsupport/common-utils.h
+++ b/gdbsupport/common-utils.h
@@ -24,6 +24,7 @@
 #include <vector>
 #include "gdbsupport/byte-vector.h"
 #include "gdbsupport/gdb_unique_ptr.h"
+#include "gdbsupport/array-view.h"
 #include "poison.h"
 #include "gdb_string_view.h"
 
@@ -194,6 +195,21 @@ extern int hex2bin (const char *hex, gdb_byte *bin, int count);
 /* Like the above, but return a gdb::byte_vector.  */
 gdb::byte_vector hex2bin (const char *hex);
 
+/* Build a string containing the contents of BYTES.  Each byte is
+   represented as a 2 character hex string, with spaces separating each
+   individual byte.  */
+
+extern std::string bytes_to_string (gdb::array_view<const gdb_byte> bytes);
+
+/* See bytes_to_string above.  This takes a BUFFER pointer and LENGTH
+   rather than an array view.  */
+
+static inline std::string bytes_to_string (const gdb_byte *buffer,
+                                          size_t length)
+{
+  return bytes_to_string ({buffer, length});
+}
+
 /* A fast hashing function.  This can be used to hash data in a fast way
    when the length is known.  If no fast hashing library is available, falls
    back to iterative_hash from libiberty.  START_VALUE can be set to