From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 121828 invoked by alias); 17 Feb 2020 17:01:39 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 115387 invoked by uid 89); 17 Feb 2020 17:00:06 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.2 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3 autolearn=ham version=3.3.1 spammy= X-HELO: mga05.intel.com Received: from mga05.intel.com (HELO mga05.intel.com) (192.55.52.43) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 17 Feb 2020 16:59:32 +0000 Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga105.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 17 Feb 2020 08:59:25 -0800 Received: from irvmail001.ir.intel.com ([163.33.26.43]) by fmsmga002.fm.intel.com with ESMTP; 17 Feb 2020 08:59:18 -0800 Received: from ulvlx001.iul.intel.com (ulvlx001.iul.intel.com [172.28.207.17]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id 01HGxH8P028145; Mon, 17 Feb 2020 16:59:17 GMT Received: from ulvlx001.iul.intel.com (localhost [127.0.0.1]) by ulvlx001.iul.intel.com with ESMTP id 01HGxHKN026943; Mon, 17 Feb 2020 17:59:17 +0100 Received: (from taktemur@localhost) by ulvlx001.iul.intel.com with LOCAL id 01HGxHvT026939; Mon, 17 Feb 2020 17:59:17 +0100 From: Tankut Baris Aktemur To: gdb-patches@sourceware.org Cc: palves@redhat.com Subject: [PATCH v2 01/58] gdbserver: start turning the target ops vector into a class Date: Mon, 17 Feb 2020 17:01:00 -0000 Message-Id: In-Reply-To: References: In-Reply-To: References: X-IsSubscribed: yes X-SW-Source: 2020-02/txt/msg00652.txt.bz2 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 * target.h (class process_target): New class definition. (struct process_stratum_target) : 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(+) diff --git a/gdbserver/linux-low.cc b/gdbserver/linux-low.cc index 676dea26c63..17f360639a4 100644 --- a/gdbserver/linux-low.cc +++ b/gdbserver/linux-low.cc @@ -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 diff --git a/gdbserver/linux-low.h b/gdbserver/linux-low.h index e25ddd024dd..e6042735f38 100644 --- a/gdbserver/linux-low.h +++ b/gdbserver/linux-low.h @@ -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) diff --git a/gdbserver/lynx-low.cc b/gdbserver/lynx-low.cc index a5b019396fa..f1177920921 100644 --- a/gdbserver/lynx-low.cc +++ b/gdbserver/lynx-low.cc @@ -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 diff --git a/gdbserver/lynx-low.h b/gdbserver/lynx-low.h index b122298fb88..923725dd003 100644 --- a/gdbserver/lynx-low.h +++ b/gdbserver/lynx-low.h @@ -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; diff --git a/gdbserver/nto-low.cc b/gdbserver/nto-low.cc index b4dea479b9c..6f12a735c12 100644 --- a/gdbserver/nto-low.cc +++ b/gdbserver/nto-low.cc @@ -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, }; diff --git a/gdbserver/nto-low.h b/gdbserver/nto-low.h index 393b8a98695..2695db98737 100644 --- a/gdbserver/nto-low.h +++ b/gdbserver/nto-low.h @@ -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; diff --git a/gdbserver/target.h b/gdbserver/target.h index 1b0810ba049..af78d8caa90 100644 --- a/gdbserver/target.h +++ b/gdbserver/target.h @@ -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; diff --git a/gdbserver/win32-low.cc b/gdbserver/win32-low.cc index cdd70da8374..2a7b2964d92 100644 --- a/gdbserver/win32-low.cc +++ b/gdbserver/win32-low.cc @@ -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. */ diff --git a/gdbserver/win32-low.h b/gdbserver/win32-low.h index 7a3eeda6e24..ff96f804fbd 100644 --- a/gdbserver/win32-low.h +++ b/gdbserver/win32-low.h @@ -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); -- 2.17.1