+2014-09-11 Tom Tromey <tromey@redhat.com>
+ Gary Benson <gbenson@redhat.com>
+
+ * target/target.h: New file.
+ * Makefile.in (HFILES_NO_SRCDIR): Add target/target.h.
+ * 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: Include target/target.h.
+ [!GDBSERVER]: Don't include target.h.
+ (helper_thread_id): Type changed to uint32_t.
+ (agent_get_helper_thread_id): Use target_read_uint32.
+ (agent_run_command): Always use target_read_memory and
+ target_write_memory.
+ (agent_capability): Type changed to uint32_t.
+ (agent_capability_check): Use target_read_uint32.
+
2014-09-11 Gary Benson <gbenson@redhat.com>
* common/common-debug.h (show_debug_regs): Declare.
common/print-utils.h common/rsp-low.h nat/x86-dregs.h x86-linux-nat.h \
i386-linux-nat.h common/common-defs.h common/errors.h common/common-types.h \
common/common-debug.h common/cleanups.h common/gdb_setjmp.h \
-common/common-exceptions.h
+common/common-exceptions.h target/target.h
# Header files that already have srcdir in them, or which are in objdir.
#include "server.h"
#else
#include "defs.h"
-#include "target.h"
#include "infrun.h"
#include "objfiles.h"
#endif
+#include "target/target.h"
#include <unistd.h>
#include "agent.h"
#include "filestuff.h"
/* Cache of the helper thread id. FIXME: this global should be made
per-process. */
-static unsigned int helper_thread_id = 0;
+static uint32_t helper_thread_id = 0;
static struct
{
{
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;
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)
{
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;
}
/* Each bit of it stands for a capability of agent. */
-static unsigned int agent_capability = 0;
+static uint32_t agent_capability = 0;
/* Return true if agent has capability AGENT_CAP, otherwise return false. */
{
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;
+2014-09-11 Tom Tromey <tromey@redhat.com>
+ Gary Benson <gbenson@redhat.com>
+
+ * target.h: Include target/target.h.
+ * target.c (target_read_memory, target_read_uint32)
+ (target_write_memory): New functions.
+
2014-09-11 Gary Benson <gbenson@redhat.com>
* server.h (debug_hw_points): Don't declare.
return res;
}
+/* See target/target.h. */
+
+int
+target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
+{
+ return read_inferior_memory (memaddr, myaddr, len);
+}
+
+/* See target/target.h. */
+
+int
+target_read_uint32 (CORE_ADDR memaddr, uint32_t *result)
+{
+ return read_inferior_memory (memaddr, (gdb_byte *) result, sizeof (*result));
+}
+
int
write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
int len)
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)
#ifndef TARGET_H
#define TARGET_H
+#include "target/target.h"
#include "target/resume.h"
#include "target/wait.h"
#include "target/waitstatus.h"
return TARGET_XFER_E_IO;
}
+/* See target/target.h. */
+
+int
+target_read_uint32 (CORE_ADDR memaddr, uint32_t *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. */
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"
extern int target_read_string (CORE_ADDR, char **, int, int *);
-extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
- ssize_t len);
+/* For target_read_memory see target/target.h. */
extern int target_read_raw_memory (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);
+/* For target_write_memory see target/target.h. */
extern int target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
ssize_t len);
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>. */
+
+#ifndef TARGET_COMMON_H
+#define TARGET_COMMON_H
+
+#include "target/waitstatus.h"
+#include <stdint.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. This function must be provided by
+ the client. 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. This function must be provided by the client.
+ 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, uint32_t *result);
+
+/* Write LEN bytes from MYADDR to target memory at address MEMADDR.
+ Return zero for success, nonzero if any error occurs. This
+ function must be provided by the client. 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 */
projects / thirdparty / binutils-gdb.git / commitdiff
