Patchwork Make inf_ptrace_trad Linux-only, move to separate file

login
register
mail settings
Submitter Pedro Alves
Date April 12, 2018, 5:47 p.m.
Message ID <20180412174722.32321-1-palves@redhat.com>
Download mbox | patch
Permalink /patch/26697/
State New
Headers show

Comments

Pedro Alves - April 12, 2018, 5:47 p.m.
There are only two inf_ptrace_trad_target users, MIPS GNU/Linux and
Alpha GNU/Linux.  They both call it via linux_trad_target.

Move this code out of inf-ptrace.c to a GNU/Linux-specific new file.

Making this code be GNU/Linux-specific simplifies C++ification of
target_ops, because we can make the trad target inherit linux_nat
instead of inheriting inf_ptrace.  That'll be visible in a later patch.

Note this makes linux_target_install_ops an extern function, but that
is temporary -- the function will disappear once target_ops is made a
C++ class with virtual methods, later in the series.  Also, I did not
rename the functions in the new file for a similar reason.  They'll be
renamed again anyway in a couple of patches.

gdb/ChangeLog:
yyyy-mm-dd  Pedro Alves  <palves@redhat.com>

	* alpha-linux-nat.c: Include "linux-nat-trad.h" instead of
	"linux-nat.h".
	* configure.nat (alpha-linux, linux-mips): Add linux-nat-trad.o.
	* inf-ptrace.c (inf_ptrace_register_u_offset)
	(inf_ptrace_fetch_register, inf_ptrace_fetch_registers)
	(inf_ptrace_store_register, inf_ptrace_store_registers)
	(inf_ptrace_trad_target): Move to ...
	* linux-nat-trad.c: ... this new file.
	* linux-nat-trad.h: New file.
	* linux-nat.c (linux_target_install_ops): Make extern.
	(linux_trad_target): Delete.
	* linux-nat.h (linux_trad_target): Delete declaration.
	(linux_target_install_ops): Declare.
	* mips-linux-nat.c: Include "linux-nat-trad.h" instead of
	"linux-nat.h".
---
 gdb/alpha-linux-nat.c |   2 +-
 gdb/configure.nat     |   6 +-
 gdb/inf-ptrace.c      | 135 ------------------------------------------
 gdb/linux-nat-trad.c  | 160 ++++++++++++++++++++++++++++++++++++++++++++++++++
 gdb/linux-nat-trad.h  |  30 ++++++++++
 gdb/linux-nat.c       |  13 +---
 gdb/linux-nat.h       |   7 +--
 gdb/mips-linux-nat.c  |   2 +-
 8 files changed, 199 insertions(+), 156 deletions(-)
 create mode 100644 gdb/linux-nat-trad.c
 create mode 100644 gdb/linux-nat-trad.h

Patch

diff --git a/gdb/alpha-linux-nat.c b/gdb/alpha-linux-nat.c
index 7afce023af..8d46af4176 100644
--- a/gdb/alpha-linux-nat.c
+++ b/gdb/alpha-linux-nat.c
@@ -19,7 +19,7 @@ 
 #include "defs.h"
 #include "target.h"
 #include "regcache.h"
-#include "linux-nat.h"
+#include "linux-nat-trad.h"
 
 #include "alpha-tdep.h"
 
diff --git a/gdb/configure.nat b/gdb/configure.nat
index 8e14892722..cefc6692c1 100644
--- a/gdb/configure.nat
+++ b/gdb/configure.nat
@@ -115,7 +115,7 @@  case ${gdb_host} in
 	case ${gdb_host_cpu} in
 	    alpha)
 		# Host: Little-endian Alpha running Linux
-		NATDEPFILES="${NATDEPFILES} alpha-linux-nat.o"
+		NATDEPFILES="${NATDEPFILES} linux-nat-trad.o alpha-linux-nat.o"
 		# doublest.c currently assumes some properties of FP arithmetic
 		# on the host which require this.
 		MH_CFLAGS='-mieee'
@@ -255,8 +255,8 @@  case ${gdb_host} in
 		;;
 	    mips)
 		# Host: Linux/MIPS
-		NATDEPFILES="${NATDEPFILES} mips-linux-nat.o \
-		mips-linux-watch.o"
+		NATDEPFILES="${NATDEPFILES} linux-nat-trad.o \
+		mips-linux-nat.o mips-linux-watch.o"
 		;;
 	    pa)
 		# Host: Hewlett-Packard PA-RISC machine, running Linux
diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c
index e20388658f..7c4d597be9 100644
--- a/gdb/inf-ptrace.c
+++ b/gdb/inf-ptrace.c
@@ -699,138 +699,3 @@  inf_ptrace_target (void)
   return t;
 }
 
-
-/* Pointer to a function that returns the offset within the user area
-   where a particular register is stored.  */
-static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
-
-/* Fetch register REGNUM from the inferior.  */
-
-static void
-inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
-{
-  struct gdbarch *gdbarch = regcache->arch ();
-  CORE_ADDR addr;
-  size_t size;
-  PTRACE_TYPE_RET *buf;
-  pid_t pid;
-  int i;
-
-  /* This isn't really an address, but ptrace thinks of it as one.  */
-  addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
-  if (addr == (CORE_ADDR)-1
-      || gdbarch_cannot_fetch_register (gdbarch, regnum))
-    {
-      regcache_raw_supply (regcache, regnum, NULL);
-      return;
-    }
-
-  pid = get_ptrace_pid (regcache_get_ptid (regcache));
-
-  size = register_size (gdbarch, regnum);
-  gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
-  buf = (PTRACE_TYPE_RET *) alloca (size);
-
-  /* Read the register contents from the inferior a chunk at a time.  */
-  for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
-    {
-      errno = 0;
-      buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
-      if (errno != 0)
-	error (_("Couldn't read register %s (#%d): %s."),
-	       gdbarch_register_name (gdbarch, regnum),
-	       regnum, safe_strerror (errno));
-
-      addr += sizeof (PTRACE_TYPE_RET);
-    }
-  regcache_raw_supply (regcache, regnum, buf);
-}
-
-/* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
-   for all registers.  */
-
-static void
-inf_ptrace_fetch_registers (struct target_ops *ops,
-			    struct regcache *regcache, int regnum)
-{
-  if (regnum == -1)
-    for (regnum = 0;
-	 regnum < gdbarch_num_regs (regcache->arch ());
-	 regnum++)
-      inf_ptrace_fetch_register (regcache, regnum);
-  else
-    inf_ptrace_fetch_register (regcache, regnum);
-}
-
-/* Store register REGNUM into the inferior.  */
-
-static void
-inf_ptrace_store_register (const struct regcache *regcache, int regnum)
-{
-  struct gdbarch *gdbarch = regcache->arch ();
-  CORE_ADDR addr;
-  size_t size;
-  PTRACE_TYPE_RET *buf;
-  pid_t pid;
-  int i;
-
-  /* This isn't really an address, but ptrace thinks of it as one.  */
-  addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
-  if (addr == (CORE_ADDR)-1 
-      || gdbarch_cannot_store_register (gdbarch, regnum))
-    return;
-
-  pid = get_ptrace_pid (regcache_get_ptid (regcache));
-
-  size = register_size (gdbarch, regnum);
-  gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
-  buf = (PTRACE_TYPE_RET *) alloca (size);
-
-  /* Write the register contents into the inferior a chunk at a time.  */
-  regcache_raw_collect (regcache, regnum, buf);
-  for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
-    {
-      errno = 0;
-      ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
-      if (errno != 0)
-	error (_("Couldn't write register %s (#%d): %s."),
-	       gdbarch_register_name (gdbarch, regnum),
-	       regnum, safe_strerror (errno));
-
-      addr += sizeof (PTRACE_TYPE_RET);
-    }
-}
-
-/* Store register REGNUM back into the inferior.  If REGNUM is -1, do
-   this for all registers.  */
-
-static void
-inf_ptrace_store_registers (struct target_ops *ops,
-			    struct regcache *regcache, int regnum)
-{
-  if (regnum == -1)
-    for (regnum = 0;
-	 regnum < gdbarch_num_regs (regcache->arch ());
-	 regnum++)
-      inf_ptrace_store_register (regcache, regnum);
-  else
-    inf_ptrace_store_register (regcache, regnum);
-}
-
-/* Create a "traditional" ptrace target.  REGISTER_U_OFFSET should be
-   a function returning the offset within the user area where a
-   particular register is stored.  */
-
-struct target_ops *
-inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
-					(struct gdbarch *, int, int))
-{
-  struct target_ops *t = inf_ptrace_target();
-
-  gdb_assert (register_u_offset);
-  inf_ptrace_register_u_offset = register_u_offset;
-  t->to_fetch_registers = inf_ptrace_fetch_registers;
-  t->to_store_registers = inf_ptrace_store_registers;
-
-  return t;
-}
diff --git a/gdb/linux-nat-trad.c b/gdb/linux-nat-trad.c
new file mode 100644
index 0000000000..75130be0f4
--- /dev/null
+++ b/gdb/linux-nat-trad.c
@@ -0,0 +1,160 @@ 
+/* Generic GNU/Linux target using traditional ptrace register access.
+
+   Copyright (C) 1988-2018 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 "linux-nat-trad.h"
+
+#include "nat/gdb_ptrace.h"
+#include "inf-ptrace.h"
+
+/* Pointer to a function that returns the offset within the user area
+   where a particular register is stored.  */
+static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
+
+/* Fetch register REGNUM from the inferior.  */
+
+static void
+inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
+{
+  struct gdbarch *gdbarch = regcache->arch ();
+  CORE_ADDR addr;
+  size_t size;
+  PTRACE_TYPE_RET *buf;
+  pid_t pid;
+  int i;
+
+  /* This isn't really an address, but ptrace thinks of it as one.  */
+  addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
+  if (addr == (CORE_ADDR)-1
+      || gdbarch_cannot_fetch_register (gdbarch, regnum))
+    {
+      regcache_raw_supply (regcache, regnum, NULL);
+      return;
+    }
+
+  pid = get_ptrace_pid (regcache_get_ptid (regcache));
+
+  size = register_size (gdbarch, regnum);
+  gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
+  buf = (PTRACE_TYPE_RET *) alloca (size);
+
+  /* Read the register contents from the inferior a chunk at a time.  */
+  for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
+    {
+      errno = 0;
+      buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
+      if (errno != 0)
+	error (_("Couldn't read register %s (#%d): %s."),
+	       gdbarch_register_name (gdbarch, regnum),
+	       regnum, safe_strerror (errno));
+
+      addr += sizeof (PTRACE_TYPE_RET);
+    }
+  regcache_raw_supply (regcache, regnum, buf);
+}
+
+/* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
+   for all registers.  */
+
+static void
+inf_ptrace_fetch_registers (struct target_ops *ops,
+			    struct regcache *regcache, int regnum)
+{
+  if (regnum == -1)
+    for (regnum = 0;
+	 regnum < gdbarch_num_regs (regcache->arch ());
+	 regnum++)
+      inf_ptrace_fetch_register (regcache, regnum);
+  else
+    inf_ptrace_fetch_register (regcache, regnum);
+}
+
+/* Store register REGNUM into the inferior.  */
+
+static void
+inf_ptrace_store_register (const struct regcache *regcache, int regnum)
+{
+  struct gdbarch *gdbarch = regcache->arch ();
+  CORE_ADDR addr;
+  size_t size;
+  PTRACE_TYPE_RET *buf;
+  pid_t pid;
+  int i;
+
+  /* This isn't really an address, but ptrace thinks of it as one.  */
+  addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
+  if (addr == (CORE_ADDR)-1
+      || gdbarch_cannot_store_register (gdbarch, regnum))
+    return;
+
+  pid = get_ptrace_pid (regcache_get_ptid (regcache));
+
+  size = register_size (gdbarch, regnum);
+  gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
+  buf = (PTRACE_TYPE_RET *) alloca (size);
+
+  /* Write the register contents into the inferior a chunk at a time.  */
+  regcache_raw_collect (regcache, regnum, buf);
+  for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
+    {
+      errno = 0;
+      ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
+      if (errno != 0)
+	error (_("Couldn't write register %s (#%d): %s."),
+	       gdbarch_register_name (gdbarch, regnum),
+	       regnum, safe_strerror (errno));
+
+      addr += sizeof (PTRACE_TYPE_RET);
+    }
+}
+
+/* Store register REGNUM back into the inferior.  If REGNUM is -1, do
+   this for all registers.  */
+
+static void
+inf_ptrace_store_registers (struct target_ops *ops,
+			    struct regcache *regcache, int regnum)
+{
+  if (regnum == -1)
+    for (regnum = 0;
+	 regnum < gdbarch_num_regs (regcache->arch ());
+	 regnum++)
+      inf_ptrace_store_register (regcache, regnum);
+  else
+    inf_ptrace_store_register (regcache, regnum);
+}
+
+/* Create a "traditional" Linux/ptrace target.  REGISTER_U_OFFSET
+   should be a function returning the offset within the user area
+   where a particular register is stored.  */
+
+struct target_ops *
+linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
+{
+  struct target_ops *t = inf_ptrace_target();
+
+  gdb_assert (register_u_offset);
+  inf_ptrace_register_u_offset = register_u_offset;
+  t->to_fetch_registers = inf_ptrace_fetch_registers;
+  t->to_store_registers = inf_ptrace_store_registers;
+
+  linux_target_install_ops (t);
+
+  return t;
+}
diff --git a/gdb/linux-nat-trad.h b/gdb/linux-nat-trad.h
new file mode 100644
index 0000000000..3b4a6c8595
--- /dev/null
+++ b/gdb/linux-nat-trad.h
@@ -0,0 +1,30 @@ 
+/* Generic GNU/Linux target using traditional ptrace register access.
+
+   Copyright (C) 2000-2018 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 LINUX_NAT_TRAD_H
+#define LINUX_NAT_TRAD_H
+
+#include "linux-nat.h"
+
+/* Create a generic GNU/Linux target using traditional
+   ptrace register access.  */
+struct target_ops *linux_trad_target
+  (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int));
+
+#endif /* LINUX_NAT_TRAD_H */
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 5a4abb1834..c23f83e057 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -4338,7 +4338,7 @@  linux_child_static_tracepoint_markers_by_strid (struct target_ops *self,
 /* Create a prototype generic GNU/Linux target.  The client can override
    it with local methods.  */
 
-static void
+void
 linux_target_install_ops (struct target_ops *t)
 {
   t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
@@ -4371,17 +4371,6 @@  linux_target (void)
   return t;
 }
 
-struct target_ops *
-linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
-{
-  struct target_ops *t;
-
-  t = inf_ptrace_trad_target (register_u_offset);
-  linux_target_install_ops (t);
-
-  return t;
-}
-
 /* target_is_async_p implementation.  */
 
 static int
diff --git a/gdb/linux-nat.h b/gdb/linux-nat.h
index 9df3548c6b..03c2021911 100644
--- a/gdb/linux-nat.h
+++ b/gdb/linux-nat.h
@@ -153,10 +153,9 @@  extern void linux_unstop_all_lwps (void);
    override it with local methods.  */
 struct target_ops * linux_target (void);
 
-/* Create a generic GNU/Linux target using traditional 
-   ptrace register access.  */
-struct target_ops *
-linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int));
+/* Make a prototype generic GNU/Linux target.  The client can override
+   it with local methods.  */
+void linux_target_install_ops (struct target_ops *t);
 
 /* Register the customized GNU/Linux target.  This should be used
    instead of calling add_target directly.  */
diff --git a/gdb/mips-linux-nat.c b/gdb/mips-linux-nat.c
index 68fd1f83c3..17e70b603b 100644
--- a/gdb/mips-linux-nat.c
+++ b/gdb/mips-linux-nat.c
@@ -24,7 +24,7 @@ 
 #include "mips-tdep.h"
 #include "target.h"
 #include "regcache.h"
-#include "linux-nat.h"
+#include "linux-nat-trad.h"
 #include "mips-linux-tdep.h"
 #include "target-descriptions.h"