From patchwork Sat Apr 14 19:09:32 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 26715 Received: (qmail 124436 invoked by alias); 14 Apr 2018 19:10:13 -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 124288 invoked by uid 89); 14 Apr 2018 19:10:12 -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=farm, to_detach 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:09 +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 DCD7942F9293 for ; Sat, 14 Apr 2018 19:10:07 +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 8CF5B215CDC8 for ; Sat, 14 Apr 2018 19:10:07 +0000 (UTC) From: Pedro Alves To: gdb-patches@sourceware.org Subject: [PATCH 19/40] target_ops/C++: AIX target Date: Sat, 14 Apr 2018 20:09:32 +0100 Message-Id: <20180414190953.24481-20-palves@redhat.com> In-Reply-To: <20180414190953.24481-1-palves@redhat.com> References: <20180414190953.24481-1-palves@redhat.com> Straighforward conversion. Tested on AIX 7.2 on the compile farm. --- gdb/aix-thread.c | 161 +++++++++++++++++++++++++++++-------------------------- gdb/rs6000-nat.c | 95 +++++++++++++++++--------------- 2 files changed, 138 insertions(+), 118 deletions(-) diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c index d2b951d94d..3727336fcb 100644 --- a/gdb/aix-thread.c +++ b/gdb/aix-thread.c @@ -108,7 +108,45 @@ struct pd_thread { /* This module's target-specific operations, active while pd_able is true. */ -static struct target_ops aix_thread_ops; +class aix_thread_target final : public target_ops +{ +public: + aix_thread_target () + { to_stratum = thread_stratum; } + + const char *shortname () override + { return "aix-threads"; } + const char *longname () override + { return _("AIX pthread support"); } + const char *doc () override + { return _("AIX pthread support"); } + + void detach (inferior *, int) override; + void resume (ptid_t, int, enum gdb_signal) override; + ptid_t wait (ptid_t, struct target_waitstatus *, int) override; + + void fetch_registers (struct regcache *, int) override; + void store_registers (struct regcache *, int) override; + + enum target_xfer_status xfer_partial (enum target_object object, + const char *annex, + gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, + ULONGEST *xfered_len) override; + + void mourn_inferior () override; + + int thread_alive (ptid_t ptid) override; + + const char *pid_to_str (ptid_t) override; + + const char *extra_thread_info (struct thread_info *) override; + + ptid_t get_ada_task_ptid (long lwp, long thread) override; +}; + +static aix_thread_target aix_thread_ops; /* Address of the function that libpthread will call when libpthdebug is ready to be initialized. */ @@ -980,21 +1018,20 @@ aix_thread_inferior_created (struct target_ops *ops, int from_tty) /* Detach from the process attached to by aix_thread_attach(). */ -static void -aix_thread_detach (struct target_ops *ops, inferior *inf, int from_tty) +void +aix_thread_target::detach (inferior *inf, int from_tty) { - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); pd_disable (); - beneath->to_detach (beneath, inf, from_tty); + beneath->detach (inf, from_tty); } /* Tell the inferior process to continue running thread PID if != -1 and all threads otherwise. */ -static void -aix_thread_resume (struct target_ops *ops, - ptid_t ptid, int step, enum gdb_signal sig) +void +aix_thread_target::resume (ptid_t ptid, int step, enum gdb_signal sig) { struct thread_info *thread; pthdb_tid_t tid[2]; @@ -1002,10 +1039,10 @@ aix_thread_resume (struct target_ops *ops, if (!PD_TID (ptid)) { scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); - beneath->to_resume (beneath, ptid, step, sig); + beneath->resume (ptid, step, sig); } else { @@ -1035,11 +1072,11 @@ aix_thread_resume (struct target_ops *ops, If an error occurs, return -1, else return the pid of the stopped thread. */ -static ptid_t -aix_thread_wait (struct target_ops *ops, - ptid_t ptid, struct target_waitstatus *status, int options) +ptid_t +aix_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); { scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); @@ -1047,7 +1084,7 @@ aix_thread_wait (struct target_ops *ops, pid_to_prc (&ptid); inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); - ptid = beneath->to_wait (beneath, ptid, status, options); + ptid = beneath->wait (ptid, status, options); } if (ptid_get_pid (ptid) == -1) @@ -1319,16 +1356,15 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno, /* Fetch register REGNO if != -1 or all registers otherwise from the thread/process connected to REGCACHE. */ -static void -aix_thread_fetch_registers (struct target_ops *ops, - struct regcache *regcache, int regno) +void +aix_thread_target::fetch_registers (struct regcache *regcache, int regno) { struct thread_info *thread; pthdb_tid_t tid; - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); if (!PD_TID (regcache_get_ptid (regcache))) - beneath->to_fetch_registers (beneath, regcache, regno); + beneath->fetch_registers (regcache, regno); else { thread = find_thread_ptid (regcache_get_ptid (regcache)); @@ -1674,16 +1710,15 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno, /* Store gdb's current view of the register set into the thread/process connected to REGCACHE. */ -static void -aix_thread_store_registers (struct target_ops *ops, - struct regcache *regcache, int regno) +void +aix_thread_target::store_registers (struct regcache *regcache, int regno) { struct thread_info *thread; pthdb_tid_t tid; - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); if (!PD_TID (regcache_get_ptid (regcache))) - beneath->to_store_registers (beneath, regcache, regno); + beneath->store_registers (regcache, regno); else { thread = find_thread_ptid (regcache_get_ptid (regcache)); @@ -1699,40 +1734,41 @@ aix_thread_store_registers (struct target_ops *ops, /* Implement the to_xfer_partial target_ops method. */ -static enum target_xfer_status -aix_thread_xfer_partial (struct target_ops *ops, enum target_object object, - const char *annex, gdb_byte *readbuf, - const gdb_byte *writebuf, - ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) +enum target_xfer_status +aix_thread_target::xfer_partial (enum target_object object, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, + ULONGEST *xfered_len) { scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); - return beneath->to_xfer_partial (beneath, object, annex, readbuf, - writebuf, offset, len, xfered_len); + return beneath->xfer_partial (object, annex, readbuf, + writebuf, offset, len, xfered_len); } /* Clean up after the inferior exits. */ -static void -aix_thread_mourn_inferior (struct target_ops *ops) +void +aix_thread_target::mourn_inferior () { - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); pd_deactivate (); - beneath->to_mourn_inferior (beneath); + beneath->mourn_inferior (); } /* Return whether thread PID is still valid. */ -static int -aix_thread_thread_alive (struct target_ops *ops, ptid_t ptid) +int +aix_thread_target::thread_alive (ptid_t ptid) { - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); if (!PD_TID (ptid)) - return beneath->to_thread_alive (beneath, ptid); + return beneath->thread_alive (ptid); /* We update the thread list every time the child stops, so all valid threads should be in the thread list. */ @@ -1742,14 +1778,14 @@ aix_thread_thread_alive (struct target_ops *ops, ptid_t ptid) /* Return a printable representation of composite PID for use in "info threads" output. */ -static const char * -aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid) +const char * +aix_thread_target::pid_to_str (ptid_t ptid) { static char *ret = NULL; - struct target_ops *beneath = find_target_beneath (ops); + struct target_ops *beneath = find_target_beneath (this); if (!PD_TID (ptid)) - return beneath->to_pid_to_str (beneath, ptid); + return beneath->pid_to_str (ptid); /* Free previous return value; a new one will be allocated by xstrprintf(). */ @@ -1762,9 +1798,8 @@ aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid) /* Return a printable representation of extra information about THREAD, for use in "info threads" output. */ -static const char * -aix_thread_extra_thread_info (struct target_ops *self, - struct thread_info *thread) +const char * +aix_thread_target::extra_thread_info (struct thread_info *thread) { int status; pthdb_pthread_t pdtid; @@ -1819,35 +1854,12 @@ aix_thread_extra_thread_info (struct target_ops *self, return ret; } -static ptid_t -aix_thread_get_ada_task_ptid (struct target_ops *self, long lwp, long thread) +ptid_t +aix_thread_target::get_ada_task_ptid (long lwp, long thread) { return ptid_build (ptid_get_pid (inferior_ptid), 0, thread); } -/* Initialize target aix_thread_ops. */ - -static void -init_aix_thread_ops (void) -{ - aix_thread_ops.to_shortname = "aix-threads"; - aix_thread_ops.to_longname = _("AIX pthread support"); - aix_thread_ops.to_doc = _("AIX pthread support"); - - aix_thread_ops.to_detach = aix_thread_detach; - aix_thread_ops.to_resume = aix_thread_resume; - aix_thread_ops.to_wait = aix_thread_wait; - aix_thread_ops.to_fetch_registers = aix_thread_fetch_registers; - aix_thread_ops.to_store_registers = aix_thread_store_registers; - aix_thread_ops.to_xfer_partial = aix_thread_xfer_partial; - aix_thread_ops.to_mourn_inferior = aix_thread_mourn_inferior; - aix_thread_ops.to_thread_alive = aix_thread_thread_alive; - aix_thread_ops.to_pid_to_str = aix_thread_pid_to_str; - aix_thread_ops.to_extra_thread_info = aix_thread_extra_thread_info; - aix_thread_ops.to_get_ada_task_ptid = aix_thread_get_ada_task_ptid; - aix_thread_ops.to_stratum = thread_stratum; - aix_thread_ops.to_magic = OPS_MAGIC; -} /* Module startup initialization function, automagically called by init.c. */ @@ -1855,9 +1867,6 @@ init_aix_thread_ops (void) void _initialize_aix_thread (void) { - init_aix_thread_ops (); - complete_target_initialization (&aix_thread_ops); - /* Notice when object files get loaded and unloaded. */ gdb::observers::new_objfile.attach (new_objfile); diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c index d8c15f00ea..0880d3748e 100644 --- a/gdb/rs6000-nat.c +++ b/gdb/rs6000-nat.c @@ -74,7 +74,34 @@ # define ARCH64() (register_size (target_gdbarch (), 0) == 8) #endif -static target_xfer_partial_ftype rs6000_xfer_shared_libraries; +class rs6000_nat_target final : public inf_ptrace_target +{ +public: + void fetch_registers (struct regcache *, int) override; + void store_registers (struct regcache *, int) override; + + enum target_xfer_status xfer_partial (enum target_object object, + const char *annex, + gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, + ULONGEST *xfered_len) override; + + void create_inferior (const char *, const std::string &, + char **, int) override; + + ptid_t wait (ptid_t, struct target_waitstatus *, int) override; + +private: + enum target_xfer_status + xfer_shared_libraries (enum target_object object, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, + ULONGEST *xfered_len); +}; + +static rs6000_nat_target the_rs6000_nat_target; /* Given REGNO, a gdb register number, return the corresponding number suitable for use as a ptrace() parameter. Return -1 if @@ -277,9 +304,8 @@ store_register (struct regcache *regcache, int regno) /* Read from the inferior all registers if REGNO == -1 and just register REGNO otherwise. */ -static void -rs6000_fetch_inferior_registers (struct target_ops *ops, - struct regcache *regcache, int regno) +void +rs6000_nat_target::fetch_registers (struct regcache *regcache, int regno) { struct gdbarch *gdbarch = regcache->arch (); if (regno != -1) @@ -320,9 +346,8 @@ rs6000_fetch_inferior_registers (struct target_ops *ops, If REGNO is -1, do this for all registers. Otherwise, REGNO specifies which register (so we can save time). */ -static void -rs6000_store_inferior_registers (struct target_ops *ops, - struct regcache *regcache, int regno) +void +rs6000_nat_target::store_registers (struct regcache *regcache, int regno) { struct gdbarch *gdbarch = regcache->arch (); if (regno != -1) @@ -361,11 +386,12 @@ rs6000_store_inferior_registers (struct target_ops *ops, /* Implement the to_xfer_partial target_ops method. */ -static enum target_xfer_status -rs6000_xfer_partial (struct target_ops *ops, enum target_object object, - const char *annex, gdb_byte *readbuf, - const gdb_byte *writebuf, - ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) +enum target_xfer_status +rs6000_nat_target::xfer_partial (enum target_object object, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, + ULONGEST *xfered_len) { pid_t pid = ptid_get_pid (inferior_ptid); int arch64 = ARCH64 (); @@ -373,9 +399,9 @@ rs6000_xfer_partial (struct target_ops *ops, enum target_object object, switch (object) { case TARGET_OBJECT_LIBRARIES_AIX: - return rs6000_xfer_shared_libraries (ops, object, annex, - readbuf, writebuf, - offset, len, xfered_len); + return xfer_shared_libraries (object, annex, + readbuf, writebuf, + offset, len, xfered_len); case TARGET_OBJECT_MEMORY: { union @@ -467,9 +493,9 @@ rs6000_xfer_partial (struct target_ops *ops, enum target_object object, process ID of the child, or MINUS_ONE_PTID in case of error; store the status in *OURSTATUS. */ -static ptid_t -rs6000_wait (struct target_ops *ops, - ptid_t ptid, struct target_waitstatus *ourstatus, int options) +ptid_t +rs6000_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, + int options) { pid_t pid; int status, save_errno; @@ -524,20 +550,17 @@ rs6000_wait (struct target_ops *ops, /* Set the current architecture from the host running GDB. Called when starting a child process. */ -static void (*super_create_inferior) (struct target_ops *, - const char *exec_file, - const std::string &allargs, - char **env, int from_tty); -static void -rs6000_create_inferior (struct target_ops * ops, const char *exec_file, - const std::string &allargs, char **env, int from_tty) +void +rs6000_nat_target::create_inferior (const char *exec_file, + const std::string &allargs, + char **env, int from_tty) { enum bfd_architecture arch; unsigned long mach; bfd abfd; struct gdbarch_info info; - super_create_inferior (ops, exec_file, allargs, env, from_tty); + inf_ptrace_target::create_inferior (exec_file, allargs, env, from_tty); if (__power_rs ()) { @@ -617,9 +640,9 @@ rs6000_ptrace_ldinfo (ptid_t ptid) /* Implement the to_xfer_partial target_ops method for TARGET_OBJECT_LIBRARIES_AIX objects. */ -static enum target_xfer_status -rs6000_xfer_shared_libraries - (struct target_ops *ops, enum target_object object, +enum target_xfer_status +rs6000_nat_target::xfer_shared_libraries + (enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) { @@ -648,17 +671,5 @@ rs6000_xfer_shared_libraries void _initialize_rs6000_nat (void) { - struct target_ops *t; - - t = inf_ptrace_target (); - t->to_fetch_registers = rs6000_fetch_inferior_registers; - t->to_store_registers = rs6000_store_inferior_registers; - t->to_xfer_partial = rs6000_xfer_partial; - - super_create_inferior = t->to_create_inferior; - t->to_create_inferior = rs6000_create_inferior; - - t->to_wait = rs6000_wait; - - add_target (t); + add_target (&the_rs6000_nat_target); }