This is the beginning of a series of patches where the goal is to turn
the target ops vector into a class and all the target op function
pointers into methods of this class.
Currently, the target ops is a struct of function pointers. At the
end of the series, it becomes a class with methods, and the existing
low target definitions become subclasses. That is, we end up with the
following class hierarchy:
process_stratum_target
^
|-- linux-low
|-- lynx-low
|-- nto-low
|-- win32-low
process_stratum_target either defines the default behavior for the
target ops or leaves them as pure virtual for the subclasses to
override.
The transformation is done by first introducing a helper class, called
'process_target', that is initially empty. An instance of this class
is added to the end of the current target ops vector. This new field
is called 'pt'. We will gradually carry target ops to the new class,
one by one, whereas the invocation of the target op will be converted
to a method call on 'pt'.
For instance, target op 'attach' is currently invoked as
(*the_target->attach) (args)
After moving 'attach' as a method to 'process_target', it will be
invoked as
the_target->pt->attach (args)
In this process, the concrete target vector definitions
(e.g. linux-low, win32-low, nto-low, etc.) are turned into derived
classes of 'process_target', so that they can either inherit the
default behavior of the target ops or can override the method.
We prefer to make this transition gradually rather than in a single
giant patch, to yield bite-size patches. The goal is that after each
patch gdbserver will still be buildable and testable.
The general rule of thumb when converting a target op to a method is
this:
(1) If the function call is protected with a NULL-check with an
obvious default behavior, simply implement that default behavior in
the base class (e.g.: supports_non_stop).
(2) If there is no NULL-check guard, the method becomes pure
virtual, and the derived targets are required to implement the method
(e.g.: attach).
(3) If there is a NULL-check but no apparent default behavior, or if
the NULL-check is utilized to populate a feature support packet,
introduce a 'supports_XYZ' method (e.g.: pid_to_exec_file).
The overall strategy is to preserve the existing behavior as much as
possible.
When we're done moving all the target ops into 'process_target', the
target op vector will contain nothing but the field 'pt'. At that
point, the auxiliary class 'process_target' will simply meld into
'process_stratum_target' and the method calls of the form
'the_target->pt->xyz' will be turned into 'the_target->xyz'.
The "linux-low" target has been built and reg-tested on X86_64 Linux
(Ubuntu). The "win32-low" target has been built (but not tested) via
cross-compilation to a x86_64-w64-mingw32 target. The "lynx-low" and
"nto-low" targets were neither built nor tested.
gdbserver/ChangeLog:
2020-02-10 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
* target.h (class process_target): New class definition.
(struct process_stratum_target) <pt>: New field with type
'process_target*'.
* linux-low.h (class linux_process_target): Define as a derived
class of 'process_target'.
* linux-low.cc (linux_target_ops): Add a linux_process_target*
as the 'pt' field.
* lynx-low.h (class lynx_process_target): Define as a derived
class of 'process_target'.
* lynx-low.cc (lynx_target_ops): Add a lynx_process_target*
as the 'pt' field.
* nto-low.h (class nto_process_target): Define as a derived
class of 'process_target'.
* nto-low.cc (nto_target_ops): Add an nto_process_target*
as the 'pt' field.
* win32-low.h (class win32_process_target): Define as a derived
class of 'process_target'.
* win32-low.cc (win32_target_ops): Add a win32_process_target*
as the 'pt' field.
---
gdbserver/linux-low.cc | 5 +++++
gdbserver/linux-low.h | 8 ++++++++
gdbserver/lynx-low.cc | 39 +++++++++++++++++++++++++++++++++++++++
gdbserver/lynx-low.h | 8 ++++++++
gdbserver/nto-low.cc | 10 ++++++++++
gdbserver/nto-low.h | 8 ++++++++
gdbserver/target.h | 12 ++++++++++++
gdbserver/win32-low.cc | 11 +++++++++++
gdbserver/win32-low.h | 8 ++++++++
9 files changed, 109 insertions(+)
@@ -7354,6 +7354,10 @@ linux_get_hwcap2 (int wordsize)
return hwcap2;
}
+/* The linux target ops object. */
+
+static linux_process_target the_linux_target;
+
static process_stratum_target linux_target_ops = {
linux_create_inferior,
linux_post_create_inferior,
@@ -7457,6 +7461,7 @@ static process_stratum_target linux_target_ops = {
#else
NULL,
#endif
+ &the_linux_target,
};
#ifdef HAVE_LINUX_REGSETS
@@ -264,6 +264,14 @@ struct linux_target_ops
extern struct linux_target_ops the_low_target;
+/* Target ops definitions for a Linux target. */
+
+class linux_process_target : public process_target
+{
+public:
+
+};
+
#define get_thread_lwp(thr) ((struct lwp_info *) (thread_target_data (thr)))
#define get_lwp_thread(lwp) ((lwp)->thread)
@@ -719,6 +719,10 @@ lynx_request_interrupt (void)
kill (lynx_ptid_get_pid (inferior_ptid), SIGINT);
}
+/* The LynxOS target ops object. */
+
+static lynx_process_target the_lynx_target;
+
/* The LynxOS target_ops vector. */
static process_stratum_target lynx_target_ops = {
@@ -765,6 +769,41 @@ static process_stratum_target lynx_target_ops = {
NULL, /* supports_exec_events */
NULL, /* handle_new_gdb_connection */
NULL, /* handle_monitor_command */
+ NULL, /* core_of_thread */
+ NULL, /* read_loadmap */
+ NULL, /* process_qsupported */
+ NULL, /* supports_tracepoints */
+ NULL, /* read_pc */
+ NULL, /* write_pc */
+ NULL, /* thread_stopped */
+ NULL, /* get_tib_address */
+ NULL, /* pause_all */
+ NULL, /* unpause_all */
+ NULL, /* stabilize_threads */
+ NULL, /* install_fast_tracepoint_jump_pad */
+ NULL, /* emit_ops */
+ NULL, /* supports_disable_randomization */
+ NULL, /* get_min_fast_tracepoint_insn_len */
+ NULL, /* qxfer_libraries_svr4 */
+ NULL, /* support_agent */
+ NULL, /* enable_btrace */
+ NULL, /* disable_btrace */
+ NULL, /* read_btrace */
+ NULL, /* read_btrace_conf */
+ NULL, /* supports_range_stepping */
+ NULL, /* pid_to_exec_file */
+ NULL, /* multifs_open */
+ NULL, /* multifs_unlink */
+ NULL, /* multifs_readlink */
+ NULL, /* breakpoint_kind_from_pc */
+ NULL, /* sw_breakpoint_from_kind */
+ NULL, /* thread_name */
+ NULL, /* breakpoint_kind_from_current_state */
+ NULL, /* supports_software_single_step */
+ NULL, /* supports_catch_syscall */
+ NULL, /* get_ipa_tdesc_idx */
+ NULL, /* thread_handle */
+ &the_lynx_target,
};
void
@@ -52,6 +52,14 @@ struct lynx_target_ops
extern struct lynx_target_ops the_low_target;
+/* Target ops definitions for a LynxOS target. */
+
+class lynx_process_target : public process_target
+{
+public:
+
+};
+
/* The inferior's target description. This is a global because the
LynxOS ports support neither bi-arch nor multi-process. */
extern const struct target_desc *lynx_tdesc;
@@ -930,6 +930,9 @@ nto_sw_breakpoint_from_kind (int kind, int *size)
return the_low_target.breakpoint;
}
+/* The QNX Neutrino target ops object. */
+
+static nto_process_target the_nto_target;
static process_stratum_target nto_target_ops = {
nto_create_inferior,
@@ -1003,6 +1006,13 @@ static process_stratum_target nto_target_ops = {
NULL, /* multifs_readlink */
NULL, /* breakpoint_kind_from_pc */
nto_sw_breakpoint_from_kind,
+ NULL, /* thread_name */
+ NULL, /* breakpoint_kind_from_current_state */
+ NULL, /* supports_software_single_step */
+ NULL, /* supports_catch_syscall */
+ NULL, /* get_ipa_tdesc_idx */
+ NULL, /* thread_handle */
+ &the_nto_target,
};
@@ -42,6 +42,14 @@ struct nto_target_ops
extern struct nto_target_ops the_low_target;
+/* Target ops definitions for a QNX Neutrino target. */
+
+class nto_process_target : public process_target
+{
+public:
+
+};
+
/* The inferior's target description. This is a global because the
LynxOS ports support neither bi-arch nor multi-process. */
extern const struct target_desc *nto_tdesc;
@@ -63,6 +63,8 @@ struct thread_resume
CORE_ADDR step_range_end; /* Exclusive */
};
+class process_target;
+
/* GDBserver doesn't have a concept of strata like GDB, but we call
its target vector "process_stratum" anyway for the benefit of
shared code. */
@@ -477,6 +479,16 @@ struct process_stratum_target
false for failure. Return pointer to thread handle via HANDLE
and the handle's length via HANDLE_LEN. */
bool (*thread_handle) (ptid_t ptid, gdb_byte **handle, int *handle_len);
+
+ /* The object that will gradually replace this struct. */
+ process_target *pt;
+};
+
+class process_target
+{
+public:
+
+ virtual ~process_target () = default;
};
extern process_stratum_target *the_target;
@@ -1834,6 +1834,10 @@ win32_sw_breakpoint_from_kind (int kind, int *size)
return the_low_target.breakpoint;
}
+/* The win32 target ops object. */
+
+static win32_process_target the_win32_target;
+
static process_stratum_target win32_target_ops = {
win32_create_inferior,
NULL, /* post_create_inferior */
@@ -1910,6 +1914,13 @@ static process_stratum_target win32_target_ops = {
NULL, /* multifs_readlink */
NULL, /* breakpoint_kind_from_pc */
win32_sw_breakpoint_from_kind,
+ NULL, /* thread_name */
+ NULL, /* breakpoint_kind_from_current_state */
+ NULL, /* supports_software_single_step */
+ NULL, /* supports_catch_syscall */
+ NULL, /* get_ipa_tdesc_idx */
+ NULL, /* thread_handle */
+ &the_win32_target,
};
/* Initialize the Win32 backend. */
@@ -101,6 +101,14 @@ struct win32_target_ops
extern struct win32_target_ops the_low_target;
+/* Target ops definitions for a Win32 target. */
+
+class win32_process_target : public process_target
+{
+public:
+
+};
+
/* Retrieve the context for this thread, if not already retrieved. */
extern void win32_require_context (win32_thread_info *th);