From patchwork Wed Jul 16 14:17:18 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gary Benson X-Patchwork-Id: 2090 Received: (qmail 2813 invoked by alias); 16 Jul 2014 17:03:29 -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 2672 invoked by uid 89); 16 Jul 2014 17:03:28 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.0 required=5.0 tests=AWL, BAYES_00, RP_MATCHES_RCVD, SPF_HELO_PASS, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Wed, 16 Jul 2014 17:03:20 +0000 Received: from int-mx13.intmail.prod.int.phx2.redhat.com (int-mx13.intmail.prod.int.phx2.redhat.com [10.5.11.26]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id s6GGJbbJ012190 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Wed, 16 Jul 2014 12:19:37 -0400 Received: from blade.nx (ovpn-116-36.ams2.redhat.com [10.36.116.36]) by int-mx13.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id s6GGJZ8Y003251; Wed, 16 Jul 2014 12:19:36 -0400 Received: from blade.nx (localhost [127.0.0.1]) by blade.nx (Postfix) with ESMTP id 742772640D0; Wed, 16 Jul 2014 15:17:31 +0100 (BST) From: Gary Benson To: gdb-patches@sourceware.org Cc: Tom Tromey , Doug Evans Subject: [PATCH 10/15 v2] Add target/target.h Date: Wed, 16 Jul 2014 15:17:18 +0100 Message-Id: <1405520243-17282-11-git-send-email-gbenson@redhat.com> In-Reply-To: <1405520243-17282-1-git-send-email-gbenson@redhat.com> References: <1405520243-17282-1-git-send-email-gbenson@redhat.com> X-IsSubscribed: yes This adds target/target.h. This file declares some functions that the "common" code can use and that the clients must implement. It also changes code in common to use these functions. gdb/ 2014-07-16 Tom Tromey Gary Benson * target.h: Include target/target.h. (target_read_memory, target_write_memory): Don't declare. * target.c (target_read_uint32): New function. * common/agent.c: Don't include server.h or defs.h; update includes. (agent_get_helper_thread_id): Use target_read_uint32. (agent_run_command): Always use target_write_memory, target_read_memory. (agent_capability_check): Use target_read_uint32. * target/target.h: New file. gdb/gdbserver/ 2014-07-16 Tom Tromey * target.c (target_read_memory, target_read_uint32) (target_write_memory): New functions. --- gdb/ChangeLog | 14 +++++++++++ gdb/common/agent.c | 56 ++++++++++++--------------------------------- gdb/gdbserver/ChangeLog | 5 ++++ gdb/gdbserver/target.c | 24 +++++++++++++++++++ gdb/target.c | 16 +++++++++++++ gdb/target.h | 7 +----- gdb/target/target.h | 57 +++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 132 insertions(+), 47 deletions(-) create mode 100644 gdb/target/target.h diff --git a/gdb/common/agent.c b/gdb/common/agent.c index 549b784..52de3d4 100644 --- a/gdb/common/agent.c +++ b/gdb/common/agent.c @@ -26,6 +26,16 @@ #include "objfiles.h" #endif +#include +#include + +#include "common-types.h" +#include "target/target.h" +#include "errors.h" +#include "ptid.h" +#include "gdb_locale.h" +#include "common-utils.h" + #include #include #include "agent.h" @@ -128,23 +138,9 @@ agent_get_helper_thread_id (void) { if (helper_thread_id == 0) { -#ifdef GDBSERVER - if (read_inferior_memory (ipa_sym_addrs.addr_helper_thread_id, - (unsigned char *) &helper_thread_id, - sizeof helper_thread_id)) -#else - enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); - gdb_byte buf[4]; - - if (target_read_memory (ipa_sym_addrs.addr_helper_thread_id, - buf, sizeof buf) == 0) - helper_thread_id = extract_unsigned_integer (buf, sizeof buf, - byte_order); - else -#endif - { - warning (_("Error reading helper thread's id in lib")); - } + if (target_read_uint32 (ipa_sym_addrs.addr_helper_thread_id, + &helper_thread_id)) + warning (_("Error reading helper thread's id in lib")); } return helper_thread_id; @@ -222,13 +218,8 @@ agent_run_command (int pid, const char *cmd, int len) int tid = agent_get_helper_thread_id (); ptid_t ptid = ptid_build (pid, tid, 0); -#ifdef GDBSERVER - int ret = write_inferior_memory (ipa_sym_addrs.addr_cmd_buf, - (const unsigned char *) cmd, len); -#else int ret = target_write_memory (ipa_sym_addrs.addr_cmd_buf, (gdb_byte *) cmd, len); -#endif if (ret != 0) { @@ -310,13 +301,8 @@ agent_run_command (int pid, const char *cmd, int len) if (fd >= 0) { -#ifdef GDBSERVER - if (read_inferior_memory (ipa_sym_addrs.addr_cmd_buf, - (unsigned char *) cmd, IPA_CMD_BUF_SIZE)) -#else if (target_read_memory (ipa_sym_addrs.addr_cmd_buf, (gdb_byte *) cmd, IPA_CMD_BUF_SIZE)) -#endif { warning (_("Error reading command response")); return -1; @@ -336,20 +322,8 @@ agent_capability_check (enum agent_capa agent_capa) { if (agent_capability == 0) { -#ifdef GDBSERVER - if (read_inferior_memory (ipa_sym_addrs.addr_capability, - (unsigned char *) &agent_capability, - sizeof agent_capability)) -#else - enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); - gdb_byte buf[4]; - - if (target_read_memory (ipa_sym_addrs.addr_capability, - buf, sizeof buf) == 0) - agent_capability = extract_unsigned_integer (buf, sizeof buf, - byte_order); - else -#endif + if (target_read_uint32 (ipa_sym_addrs.addr_capability, + &agent_capability)) warning (_("Error reading capability of agent")); } return agent_capability & agent_capa; diff --git a/gdb/gdbserver/target.c b/gdb/gdbserver/target.c index dcad5c9..44e1e11 100644 --- a/gdb/gdbserver/target.c +++ b/gdb/gdbserver/target.c @@ -48,6 +48,22 @@ read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) return res; } +/* See target/target.h. */ + +int +target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len) +{ + return read_inferior_memory (memaddr, myaddr, len); +} + +/* See target/target.h. */ + +int +target_read_uint32 (CORE_ADDR memaddr, unsigned int *result) +{ + return read_inferior_memory (memaddr, (gdb_byte *) result, sizeof (*result)); +} + int write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len) @@ -71,6 +87,14 @@ write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr, return res; } +/* See target/target.h. */ + +int +target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len) +{ + return write_inferior_memory (memaddr, myaddr, len); +} + ptid_t mywait (ptid_t ptid, struct target_waitstatus *ourstatus, int options, int connected_wait) diff --git a/gdb/target.c b/gdb/target.c index 07d029a..d4907b6 100644 --- a/gdb/target.c +++ b/gdb/target.c @@ -1306,6 +1306,22 @@ target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len) return TARGET_XFER_E_IO; } +/* See target/target.h. */ + +int +target_read_uint32 (CORE_ADDR memaddr, unsigned int *result) +{ + gdb_byte buf[4]; + int r; + + r = target_read_memory (memaddr, buf, sizeof buf); + if (r != 0) + return r; + *result = extract_unsigned_integer (buf, sizeof buf, + gdbarch_byte_order (target_gdbarch ())); + return 0; +} + /* Like target_read_memory, but specify explicitly that this is a read from the target's raw memory. That is, this read bypasses the dcache, breakpoint shadowing, etc. */ diff --git a/gdb/target.h b/gdb/target.h index 8bf160c..8a2faca 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -58,6 +58,7 @@ struct dcache_struct; it goes into the file stratum, which is always below the process stratum. */ +#include "target/target.h" #include "target/resume.h" #include "target/wait.h" #include "target/waitstatus.h" @@ -1278,9 +1279,6 @@ int target_supports_disable_randomization (void); extern int target_read_string (CORE_ADDR, char **, int, int *); -extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, - ssize_t len); - extern int target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len); @@ -1288,9 +1286,6 @@ extern int target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len); extern int target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len); -extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, - ssize_t len); - extern int target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len); diff --git a/gdb/target/target.h b/gdb/target/target.h new file mode 100644 index 0000000..4ac3440 --- /dev/null +++ b/gdb/target/target.h @@ -0,0 +1,57 @@ +/* Declarations for common target functions. + + Copyright (C) 1986-2014 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 . */ + +#ifndef TARGET_COMMON_H +#define TARGET_COMMON_H + +/* This header is a stopgap until more code is shared. */ + +/* Read LEN bytes of target memory at address MEMADDR, placing the + results in GDB's memory at MYADDR. Return zero for success, + nonzero if any error occurs. Implementations of this function may + define and use their own error codes, but functions in the common, + nat and target directories must treat the return code as opaque. + No guarantee is made about the contents of the data at MYADDR if + any error occurs. */ + +extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, + ssize_t len); + +/* Read an unsigned 32-bit integer in the target's format from target + memory at address MEMADDR, storing the result in GDB's format in + GDB's memory at RESULT. Return zero for success, nonzero if any + error occurs. Implementations of this function may define and use + their own error codes, but functions in the common, nat and target + directories must treat the return code as opaque. No guarantee is + made about the contents of the data at RESULT if any error + occurs. */ + +extern int target_read_uint32 (CORE_ADDR memaddr, unsigned int *result); + +/* Write LEN bytes from MYADDR to target memory at address MEMADDR. + Return zero for success, nonzero if any error occurs. + Implementations of this function may define and use their own error + codes, but functions in the common, nat and target directories must + treat the return code as opaque. No guarantee is made about the + contents of the data at MEMADDR if any error occurs. */ + +extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, + ssize_t len); + +#endif /* TARGET_COMMON_H */