From patchwork Sat Apr 14 19:09:20 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 26713 Received: (qmail 123288 invoked by alias); 14 Apr 2018 19:10:05 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 123172 invoked by uid 89); 14 Apr 2018 19:10:05 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.4 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3 autolearn=ham version=3.3.2 spammy=observers, Find, 3288 X-HELO: mx1.redhat.com Received: from mx3-rdu2.redhat.com (HELO mx1.redhat.com) (66.187.233.73) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 14 Apr 2018 19:10:01 +0000 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.rdu2.redhat.com [10.11.54.6]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 4B5D34072458 for ; Sat, 14 Apr 2018 19:10:00 +0000 (UTC) Received: from localhost.localdomain (ovpn04.gateway.prod.ext.ams2.redhat.com [10.39.146.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id EF0DC215CDC8 for ; Sat, 14 Apr 2018 19:09:59 +0000 (UTC) From: Pedro Alves To: gdb-patches@sourceware.org Subject: [PATCH 07/40] target_ops/C++: ravenscar-thread Date: Sat, 14 Apr 2018 20:09:20 +0100 Message-Id: <20180414190953.24481-8-palves@redhat.com> In-Reply-To: <20180414190953.24481-1-palves@redhat.com> References: <20180414190953.24481-1-palves@redhat.com> Straighforward conversion. --- gdb/ravenscar-thread.c | 230 ++++++++++++++++++++++++------------------------- 1 file changed, 115 insertions(+), 115 deletions(-) diff --git a/gdb/ravenscar-thread.c b/gdb/ravenscar-thread.c index 46e454a6a8..e850ef7507 100644 --- a/gdb/ravenscar-thread.c +++ b/gdb/ravenscar-thread.c @@ -60,9 +60,6 @@ /* If non-null, ravenscar task support is enabled. */ static int ravenscar_task_support = 1; -/* This module's target-specific operations. */ -static struct target_ops ravenscar_ops; - /* PTID of the last thread that received an event. This can be useful to determine the associated task that received the event, to make it the current task. */ @@ -76,20 +73,62 @@ static const char first_task_name[] = "system__tasking__debug__first_task"; static const char ravenscar_runtime_initializer[] = "system__bb__threads__initialize"; -static void ravenscar_update_thread_list (struct target_ops *ops); +struct ravenscar_thread_target final : public target_ops +{ + ravenscar_thread_target () + { to_stratum = thread_stratum; } + + const char *shortname () override + { return "ravenscar"; } + + const char *longname () override + { return _("Ravenscar tasks."); } + + const char *doc () override + { return _("Ravenscar tasks support."); } + + ptid_t wait (ptid_t, struct target_waitstatus *, int) override; + void resume (ptid_t, int, enum gdb_signal) override; + + void fetch_registers (struct regcache *, int) override; + void store_registers (struct regcache *, int) override; + + void prepare_to_store (struct regcache *) override; + + int stopped_by_sw_breakpoint () override; + + int stopped_by_hw_breakpoint () override; + + int stopped_by_watchpoint () override; + + int stopped_data_address (CORE_ADDR *) override; + + int thread_alive (ptid_t ptid) override; + + int core_of_thread (ptid_t ptid) override; + + void update_thread_list () override; + + const char *extra_thread_info (struct thread_info *) override; + + const char *pid_to_str (ptid_t) override; + + ptid_t get_ada_task_ptid (long lwp, long thread) override; + + void mourn_inferior () override; + + int has_all_memory () override { return default_child_has_all_memory (); } + int has_memory () override { return default_child_has_memory (); } + int has_stack () override { return default_child_has_stack (); } + int has_registers () override { return default_child_has_registers (); } + int has_execution (ptid_t ptid) override + { return default_child_has_execution (ptid); } +}; + +/* This module's target-specific operations. */ +static ravenscar_thread_target ravenscar_ops; + static ptid_t ravenscar_active_task (int cpu); -static const char *ravenscar_extra_thread_info (struct target_ops *self, - struct thread_info *tp); -static int ravenscar_thread_alive (struct target_ops *ops, ptid_t ptid); -static void ravenscar_fetch_registers (struct target_ops *ops, - struct regcache *regcache, int regnum); -static void ravenscar_store_registers (struct target_ops *ops, - struct regcache *regcache, int regnum); -static void ravenscar_prepare_to_store (struct target_ops *self, - struct regcache *regcache); -static void ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step, - enum gdb_signal siggnal); -static void ravenscar_mourn_inferior (struct target_ops *ops); static void ravenscar_update_inferior_ptid (void); static int has_ravenscar_runtime (void); static int ravenscar_runtime_initialized (void); @@ -281,26 +320,25 @@ get_running_thread_id (int cpu) return extract_typed_address (buf, builtin_type_void_data_ptr); } -static void -ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step, - enum gdb_signal siggnal) +void +ravenscar_thread_target::resume (ptid_t ptid, int step, enum gdb_signal siggnal) { - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); inferior_ptid = base_ptid; - beneath->to_resume (beneath, base_ptid, step, siggnal); + beneath->resume (base_ptid, step, siggnal); } -static ptid_t -ravenscar_wait (struct target_ops *ops, ptid_t ptid, - struct target_waitstatus *status, - int options) +ptid_t +ravenscar_thread_target::wait (ptid_t ptid, + struct target_waitstatus *status, + int options) { - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); ptid_t event_ptid; inferior_ptid = base_ptid; - event_ptid = beneath->to_wait (beneath, base_ptid, status, 0); + event_ptid = beneath->wait (base_ptid, status, 0); /* Find any new threads that might have been created, and update inferior_ptid to the active thread. @@ -312,7 +350,7 @@ ravenscar_wait (struct target_ops *ops, ptid_t ptid, && status->kind != TARGET_WAITKIND_SIGNALLED) { inferior_ptid = event_ptid; - ravenscar_update_thread_list (ops); + this->update_thread_list (); ravenscar_update_inferior_ptid (); } return inferior_ptid; @@ -328,8 +366,8 @@ ravenscar_add_thread (struct ada_task_info *task) add_thread (task->ptid); } -static void -ravenscar_update_thread_list (struct target_ops *ops) +void +ravenscar_thread_target::update_thread_list () { ada_build_task_list (); @@ -352,21 +390,21 @@ ravenscar_active_task (int cpu) return ptid_build (ptid_get_pid (base_ptid), 0, tid); } -static const char * -ravenscar_extra_thread_info (struct target_ops *self, struct thread_info *tp) +const char * +ravenscar_thread_target::extra_thread_info (thread_info *tp) { return "Ravenscar task"; } -static int -ravenscar_thread_alive (struct target_ops *ops, ptid_t ptid) +int +ravenscar_thread_target::thread_alive (ptid_t ptid) { /* Ravenscar tasks are non-terminating. */ return 1; } -static const char * -ravenscar_pid_to_str (struct target_ops *ops, ptid_t ptid) +const char * +ravenscar_thread_target::pid_to_str (ptid_t ptid) { static char buf[30]; @@ -374,11 +412,10 @@ ravenscar_pid_to_str (struct target_ops *ops, ptid_t ptid) return buf; } -static void -ravenscar_fetch_registers (struct target_ops *ops, - struct regcache *regcache, int regnum) +void +ravenscar_thread_target::fetch_registers (struct regcache *regcache, int regnum) { - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); ptid_t ptid = regcache_get_ptid (regcache); if (ravenscar_runtime_initialized () @@ -392,14 +429,14 @@ ravenscar_fetch_registers (struct target_ops *ops, arch_ops->to_fetch_registers (regcache, regnum); } else - beneath->to_fetch_registers (beneath, regcache, regnum); + beneath->fetch_registers (regcache, regnum); } -static void -ravenscar_store_registers (struct target_ops *ops, - struct regcache *regcache, int regnum) +void +ravenscar_thread_target::store_registers (struct regcache *regcache, + int regnum) { - struct target_ops *beneath = find_target_beneath (ops); + target_ops *beneath = find_target_beneath (this); ptid_t ptid = regcache_get_ptid (regcache); if (ravenscar_runtime_initialized () @@ -410,17 +447,16 @@ ravenscar_store_registers (struct target_ops *ops, struct ravenscar_arch_ops *arch_ops = gdbarch_ravenscar_ops (gdbarch); - arch_ops->to_store_registers (regcache, regnum); + beneath->store_registers (regcache, regnum); } else - beneath->to_store_registers (beneath, regcache, regnum); + beneath->store_registers (regcache, regnum); } -static void -ravenscar_prepare_to_store (struct target_ops *self, - struct regcache *regcache) +void +ravenscar_thread_target::prepare_to_store (struct regcache *regcache) { - struct target_ops *beneath = find_target_beneath (self); + target_ops *beneath = find_target_beneath (this); ptid_t ptid = regcache_get_ptid (regcache); if (ravenscar_runtime_initialized () @@ -431,93 +467,93 @@ ravenscar_prepare_to_store (struct target_ops *self, struct ravenscar_arch_ops *arch_ops = gdbarch_ravenscar_ops (gdbarch); - arch_ops->to_prepare_to_store (regcache); + beneath->prepare_to_store (regcache); } else - beneath->to_prepare_to_store (beneath, regcache); + beneath->prepare_to_store (regcache); } /* Implement the to_stopped_by_sw_breakpoint target_ops "method". */ -static int -ravenscar_stopped_by_sw_breakpoint (struct target_ops *ops) +int +ravenscar_thread_target::stopped_by_sw_breakpoint () { ptid_t saved_ptid = inferior_ptid; - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); int result; inferior_ptid = get_base_thread_from_ravenscar_task (saved_ptid); - result = beneath->to_stopped_by_sw_breakpoint (beneath); + result = beneath->stopped_by_sw_breakpoint (); inferior_ptid = saved_ptid; return result; } /* Implement the to_stopped_by_hw_breakpoint target_ops "method". */ -static int -ravenscar_stopped_by_hw_breakpoint (struct target_ops *ops) +int +ravenscar_thread_target::stopped_by_hw_breakpoint () { ptid_t saved_ptid = inferior_ptid; - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); int result; inferior_ptid = get_base_thread_from_ravenscar_task (saved_ptid); - result = beneath->to_stopped_by_hw_breakpoint (beneath); + result = beneath->stopped_by_hw_breakpoint (); inferior_ptid = saved_ptid; return result; } /* Implement the to_stopped_by_watchpoint target_ops "method". */ -static int -ravenscar_stopped_by_watchpoint (struct target_ops *ops) +int +ravenscar_thread_target::stopped_by_watchpoint () { ptid_t saved_ptid = inferior_ptid; - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); int result; inferior_ptid = get_base_thread_from_ravenscar_task (saved_ptid); - result = beneath->to_stopped_by_watchpoint (beneath); + result = beneath->stopped_by_watchpoint (); inferior_ptid = saved_ptid; return result; } /* Implement the to_stopped_data_address target_ops "method". */ -static int -ravenscar_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p) +int +ravenscar_thread_target::stopped_data_address (CORE_ADDR *addr_p) { ptid_t saved_ptid = inferior_ptid; - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); int result; inferior_ptid = get_base_thread_from_ravenscar_task (saved_ptid); - result = beneath->to_stopped_data_address (beneath, addr_p); + result = beneath->stopped_data_address (addr_p); inferior_ptid = saved_ptid; return result; } -static void -ravenscar_mourn_inferior (struct target_ops *ops) +void +ravenscar_thread_target::mourn_inferior () { - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); base_ptid = null_ptid; - beneath->to_mourn_inferior (beneath); + beneath->mourn_inferior (); unpush_target (&ravenscar_ops); } /* Implement the to_core_of_thread target_ops "method". */ -static int -ravenscar_core_of_thread (struct target_ops *ops, ptid_t ptid) +int +ravenscar_thread_target::core_of_thread (ptid_t ptid) { ptid_t saved_ptid = inferior_ptid; - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); int result; inferior_ptid = get_base_thread_from_ravenscar_task (saved_ptid); - result = beneath->to_core_of_thread (beneath, inferior_ptid); + result = beneath->core_of_thread (inferior_ptid); inferior_ptid = saved_ptid; return result; } @@ -545,45 +581,12 @@ ravenscar_inferior_created (struct target_ops *target, int from_tty) push_target (&ravenscar_ops); } -static ptid_t -ravenscar_get_ada_task_ptid (struct target_ops *self, long lwp, long thread) +ptid_t +ravenscar_thread_target::get_ada_task_ptid (long lwp, long thread) { return ptid_build (ptid_get_pid (base_ptid), 0, thread); } -static void -init_ravenscar_thread_ops (void) -{ - ravenscar_ops.to_shortname = "ravenscar"; - ravenscar_ops.to_longname = "Ravenscar tasks."; - ravenscar_ops.to_doc = "Ravenscar tasks support."; - ravenscar_ops.to_resume = ravenscar_resume; - ravenscar_ops.to_wait = ravenscar_wait; - ravenscar_ops.to_fetch_registers = ravenscar_fetch_registers; - ravenscar_ops.to_store_registers = ravenscar_store_registers; - ravenscar_ops.to_prepare_to_store = ravenscar_prepare_to_store; - ravenscar_ops.to_stopped_by_sw_breakpoint - = ravenscar_stopped_by_sw_breakpoint; - ravenscar_ops.to_stopped_by_hw_breakpoint - = ravenscar_stopped_by_hw_breakpoint; - ravenscar_ops.to_stopped_by_watchpoint = ravenscar_stopped_by_watchpoint; - ravenscar_ops.to_stopped_data_address = ravenscar_stopped_data_address; - ravenscar_ops.to_thread_alive = ravenscar_thread_alive; - ravenscar_ops.to_update_thread_list = ravenscar_update_thread_list; - ravenscar_ops.to_pid_to_str = ravenscar_pid_to_str; - ravenscar_ops.to_extra_thread_info = ravenscar_extra_thread_info; - ravenscar_ops.to_get_ada_task_ptid = ravenscar_get_ada_task_ptid; - ravenscar_ops.to_mourn_inferior = ravenscar_mourn_inferior; - ravenscar_ops.to_has_all_memory = default_child_has_all_memory; - ravenscar_ops.to_has_memory = default_child_has_memory; - ravenscar_ops.to_has_stack = default_child_has_stack; - ravenscar_ops.to_has_registers = default_child_has_registers; - ravenscar_ops.to_has_execution = default_child_has_execution; - ravenscar_ops.to_stratum = thread_stratum; - ravenscar_ops.to_core_of_thread = ravenscar_core_of_thread; - ravenscar_ops.to_magic = OPS_MAGIC; -} - /* Command-list for the "set/show ravenscar" prefix command. */ static struct cmd_list_element *set_ravenscar_list; static struct cmd_list_element *show_ravenscar_list; @@ -627,15 +630,12 @@ Support for Ravenscar task/thread switching is disabled\n")); void _initialize_ravenscar (void) { - init_ravenscar_thread_ops (); base_ptid = null_ptid; /* Notice when the inferior is created in order to push the ravenscar ops if needed. */ gdb::observers::inferior_created.attach (ravenscar_inferior_created); - complete_target_initialization (&ravenscar_ops); - add_prefix_cmd ("ravenscar", no_class, set_ravenscar_command, _("Prefix command for changing Ravenscar-specific settings"), &set_ravenscar_list, "set ravenscar ", 0, &setlist);