static void
open_target (char *args, int from_tty, struct cmd_list_element *command)
{
- struct target_ops *ops = get_cmd_context (command);
+ struct target_ops *ops = (struct target_ops *) get_cmd_context (command);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "-> %s->to_open (...)\n",
terminal_is_ours = 2
};
-static enum terminal_state terminal_state;
+static enum terminal_state terminal_state = terminal_is_ours;
/* See target.h. */
static void
cleanup_restore_target_terminal (void *arg)
{
- enum terminal_state *previous_state = arg;
+ enum terminal_state *previous_state = (enum terminal_state *) arg;
switch (*previous_state)
{
struct cleanup *
make_cleanup_restore_target_terminal (void)
{
- enum terminal_state *ts = xmalloc (sizeof (*ts));
+ enum terminal_state *ts = XNEW (enum terminal_state);
*ts = terminal_state;
/* Small for testing. */
buffer_allocated = 4;
- buffer = xmalloc (buffer_allocated);
+ buffer = (char *) xmalloc (buffer_allocated);
bufptr = buffer;
while (len > 0)
bytes = bufptr - buffer;
buffer_allocated *= 2;
- buffer = xrealloc (buffer, buffer_allocated);
+ buffer = (char *) xrealloc (buffer, buffer_allocated);
bufptr = buffer + bytes;
}
instance, could have some of memory but delegate other bits to
the target below it. So, we must manually try all targets. */
-static enum target_xfer_status
+enum target_xfer_status
raw_memory_xfer_partial (struct target_ops *ops, gdb_byte *readbuf,
const gdb_byte *writebuf, ULONGEST memaddr, LONGEST len,
ULONGEST *xfered_len)
int unit_size,
VEC(memory_read_result_s) **result)
{
- gdb_byte *buf = xmalloc (end - begin);
+ gdb_byte *buf = (gdb_byte *) xmalloc (end - begin);
ULONGEST current_begin = begin;
ULONGEST current_end = end;
int forward;
/* The [current_end, end) range has been read. */
LONGEST region_len = end - current_end;
- r.data = xmalloc (region_len * unit_size);
+ r.data = (gdb_byte *) xmalloc (region_len * unit_size);
memcpy (r.data, buf + (current_end - begin) * unit_size,
region_len * unit_size);
r.begin = current_end;
void
free_memory_read_result_vector (void *x)
{
- VEC(memory_read_result_s) *v = x;
+ VEC(memory_read_result_s) *v = (VEC(memory_read_result_s) *) x;
memory_read_result_s *current;
int ix;
/* Start by reading up to 4K at a time. The target will throttle
this number down if necessary. */
buf_alloc = 4096;
- buf = xmalloc (buf_alloc);
+ buf = (gdb_byte *) xmalloc (buf_alloc);
buf_pos = 0;
while (1)
{
if (buf_alloc < buf_pos * 2)
{
buf_alloc *= 2;
- buf = xrealloc (buf, buf_alloc);
+ buf = (gdb_byte *) xrealloc (buf, buf_alloc);
}
QUIT;
target_clear_description ();
}
+ /* attach_flag may be set if the previous process associated with
+ the inferior was attached to. */
+ current_inferior ()->attach_flag = 0;
+
agent_capability_invalidate ();
}
return (current_target.to_wait) (¤t_target, ptid, status, options);
}
+/* See target.h. */
+
+ptid_t
+default_target_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status,
+ int options)
+{
+ status->kind = TARGET_WAITKIND_IGNORE;
+ return minus_one_ptid;
+}
+
char *
target_pid_to_str (ptid_t ptid)
{
follow_child, detach_fork);
}
+/* Target wrapper for follow exec hook. */
+
+void
+target_follow_exec (struct inferior *inf, char *execd_pathname)
+{
+ current_target.to_follow_exec (¤t_target, inf, execd_pathname);
+}
+
static void
default_mourn_inferior (struct target_ops *self)
{
if (search_space_len < search_buf_size)
search_buf_size = search_space_len;
- search_buf = malloc (search_buf_size);
+ search_buf = (gdb_byte *) malloc (search_buf_size);
if (search_buf == NULL)
error (_("Unable to allocate memory to perform the search."));
old_cleanups = make_cleanup (free_current_contents, &search_buf);
#define fileio_fd_to_fh(fd) \
VEC_index (fileio_fh_t, fileio_fhandles, (fd))
-/* See target.h. */
+/* Helper for target_fileio_open and
+ target_fileio_open_warn_if_slow. */
-int
-target_fileio_open (struct inferior *inf, const char *filename,
- int flags, int mode, int *target_errno)
+static int
+target_fileio_open_1 (struct inferior *inf, const char *filename,
+ int flags, int mode, int warn_if_slow,
+ int *target_errno)
{
struct target_ops *t;
if (t->to_fileio_open != NULL)
{
int fd = t->to_fileio_open (t, inf, filename, flags, mode,
- target_errno);
+ warn_if_slow, target_errno);
if (fd < 0)
fd = -1;
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
- "target_fileio_open (%d,%s,0x%x,0%o)"
+ "target_fileio_open (%d,%s,0x%x,0%o,%d)"
" = %d (%d)\n",
inf == NULL ? 0 : inf->num,
filename, flags, mode,
- fd, fd != -1 ? 0 : *target_errno);
+ warn_if_slow, fd,
+ fd != -1 ? 0 : *target_errno);
return fd;
}
}
/* See target.h. */
+int
+target_fileio_open (struct inferior *inf, const char *filename,
+ int flags, int mode, int *target_errno)
+{
+ return target_fileio_open_1 (inf, filename, flags, mode, 0,
+ target_errno);
+}
+
+/* See target.h. */
+
+int
+target_fileio_open_warn_if_slow (struct inferior *inf,
+ const char *filename,
+ int flags, int mode, int *target_errno)
+{
+ return target_fileio_open_1 (inf, filename, flags, mode, 1,
+ target_errno);
+}
+
+/* See target.h. */
+
int
target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
ULONGEST offset, int *target_errno)
target_fileio_close (fd, &target_errno);
}
-typedef int (read_alloc_pread_ftype) (int handle, gdb_byte *read_buf, int len,
- ULONGEST offset, int *target_errno);
-
-/* Helper for target_fileio_read_alloc_1 to make it interruptible. */
-
-static int
-target_fileio_read_alloc_1_pread (int handle, gdb_byte *read_buf, int len,
- ULONGEST offset, int *target_errno)
-{
- QUIT;
-
- return target_fileio_pread (handle, read_buf, len, offset, target_errno);
-}
-
/* Read target file FILENAME, in the filesystem as seen by INF. If
INF is NULL, use the filesystem seen by the debugger (GDB or, for
remote targets, the remote stub). Store the result in *BUF_P and
more information. */
static LONGEST
-read_alloc (gdb_byte **buf_p, int handle, read_alloc_pread_ftype *pread_func,
- int padding)
+target_fileio_read_alloc_1 (struct inferior *inf, const char *filename,
+ gdb_byte **buf_p, int padding)
{
+ struct cleanup *close_cleanup;
size_t buf_alloc, buf_pos;
gdb_byte *buf;
LONGEST n;
+ int fd;
int target_errno;
+ fd = target_fileio_open (inf, filename, FILEIO_O_RDONLY, 0700,
+ &target_errno);
+ if (fd == -1)
+ return -1;
+
+ close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
+
/* Start by reading up to 4K at a time. The target will throttle
this number down if necessary. */
buf_alloc = 4096;
- buf = xmalloc (buf_alloc);
+ buf = (gdb_byte *) xmalloc (buf_alloc);
buf_pos = 0;
while (1)
{
- n = pread_func (handle, &buf[buf_pos], buf_alloc - buf_pos - padding,
- buf_pos, &target_errno);
- if (n <= 0)
+ n = target_fileio_pread (fd, &buf[buf_pos],
+ buf_alloc - buf_pos - padding, buf_pos,
+ &target_errno);
+ if (n < 0)
+ {
+ /* An error occurred. */
+ do_cleanups (close_cleanup);
+ xfree (buf);
+ return -1;
+ }
+ else if (n == 0)
{
- if (n < 0 || (n == 0 && buf_pos == 0))
+ /* Read all there was. */
+ do_cleanups (close_cleanup);
+ if (buf_pos == 0)
xfree (buf);
else
*buf_p = buf;
- if (n < 0)
- {
- /* An error occurred. */
- return -1;
- }
- else
- {
- /* Read all there was. */
- return buf_pos;
- }
+ return buf_pos;
}
buf_pos += n;
if (buf_alloc < buf_pos * 2)
{
buf_alloc *= 2;
- buf = xrealloc (buf, buf_alloc);
+ buf = (gdb_byte *) xrealloc (buf, buf_alloc);
}
- }
-}
-
-typedef LONGEST (read_stralloc_func_ftype) (struct inferior *inf,
- const char *filename,
- gdb_byte **buf_p, int padding);
-static LONGEST
-target_fileio_read_alloc_1 (struct inferior *inf, const char *filename,
- gdb_byte **buf_p, int padding)
-{
- struct cleanup *close_cleanup;
- int fd, target_errno;
- LONGEST retval;
-
- fd = target_fileio_open (inf, filename, FILEIO_O_RDONLY, 0700, &target_errno);
- if (fd == -1)
- return -1;
-
- close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
- retval = read_alloc (buf_p, fd, target_fileio_read_alloc_1_pread, padding);
- do_cleanups (close_cleanup);
- return retval;
+ QUIT;
+ }
}
/* See target.h. */
return target_fileio_read_alloc_1 (inf, filename, buf_p, 0);
}
-/* Helper for target_fileio_read_stralloc. */
+/* See target.h. */
-static char *
-read_stralloc (struct inferior *inf, const char *filename,
- read_stralloc_func_ftype *func)
+char *
+target_fileio_read_stralloc (struct inferior *inf, const char *filename)
{
gdb_byte *buffer;
char *bufstr;
LONGEST i, transferred;
- transferred = func (inf, filename, &buffer, 1);
+ transferred = target_fileio_read_alloc_1 (inf, filename, &buffer, 1);
bufstr = (char *) buffer;
if (transferred < 0)
return bufstr;
}
-/* See target.h. */
-
-char *
-target_fileio_read_stralloc (struct inferior *inf, const char *filename)
-{
- return read_stralloc (inf, filename, target_fileio_read_alloc_1);
-}
static int
default_region_ok_for_hw_watchpoint (struct target_ops *self,
(*current_target.to_stop) (¤t_target, ptid);
}
+void
+target_interrupt (ptid_t ptid)
+{
+ if (!may_stop)
+ {
+ warning (_("May not interrupt or stop the target, ignoring attempt"));
+ return;
+ }
+
+ (*current_target.to_interrupt) (¤t_target, ptid);
+}
+
+/* See target.h. */
+
+void
+target_check_pending_interrupt (void)
+{
+ (*current_target.to_check_pending_interrupt) (¤t_target);
+}
+
/* See target/target.h. */
void
/* See target.h. */
int
-target_record_is_replaying (void)
+target_record_is_replaying (ptid_t ptid)
+{
+ return current_target.to_record_is_replaying (¤t_target, ptid);
+}
+
+/* See target.h. */
+
+int
+target_record_will_replay (ptid_t ptid, int dir)
+{
+ return current_target.to_record_will_replay (¤t_target, ptid, dir);
+}
+
+/* See target.h. */
+
+void
+target_record_stop_replaying (void)
{
- return current_target.to_record_is_replaying (¤t_target);
+ current_target.to_record_stop_replaying (¤t_target);
}
/* See target.h. */
}
}
+/* See target.h. */
+
+void
+target_async (int enable)
+{
+ infrun_async (enable);
+ current_target.to_async (¤t_target, enable);
+}
+
/* Controls if targets can report that they can/are async. This is
just for maintainers to use when debugging gdb. */
int target_async_permitted = 1;
"asynchronous mode is %s.\n"), value);
}
+/* Return true if the target operates in non-stop mode even with "set
+ non-stop off". */
+
+static int
+target_always_non_stop_p (void)
+{
+ return current_target.to_always_non_stop_p (¤t_target);
+}
+
+/* See target.h. */
+
+int
+target_is_non_stop_p (void)
+{
+ return (non_stop
+ || target_non_stop_enabled == AUTO_BOOLEAN_TRUE
+ || (target_non_stop_enabled == AUTO_BOOLEAN_AUTO
+ && target_always_non_stop_p ()));
+}
+
+/* Controls if targets can report that they always run in non-stop
+ mode. This is just for maintainers to use when debugging gdb. */
+enum auto_boolean target_non_stop_enabled = AUTO_BOOLEAN_AUTO;
+
+/* The set command writes to this variable. If the inferior is
+ executing, target_non_stop_enabled is *not* updated. */
+static enum auto_boolean target_non_stop_enabled_1 = AUTO_BOOLEAN_AUTO;
+
+/* Implementation of "maint set target-non-stop". */
+
+static void
+maint_set_target_non_stop_command (char *args, int from_tty,
+ struct cmd_list_element *c)
+{
+ if (have_live_inferiors ())
+ {
+ target_non_stop_enabled_1 = target_non_stop_enabled;
+ error (_("Cannot change this setting while the inferior is running."));
+ }
+
+ target_non_stop_enabled = target_non_stop_enabled_1;
+}
+
+/* Implementation of "maint show target-non-stop". */
+
+static void
+maint_show_target_non_stop_command (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ if (target_non_stop_enabled == AUTO_BOOLEAN_AUTO)
+ fprintf_filtered (file,
+ _("Whether the target is always in non-stop mode "
+ "is %s (currently %s).\n"), value,
+ target_always_non_stop_p () ? "on" : "off");
+ else
+ fprintf_filtered (file,
+ _("Whether the target is always in non-stop mode "
+ "is %s.\n"), value);
+}
+
/* Temporary copies of permission settings. */
static int may_write_registers_1 = 1;
&maintenance_set_cmdlist,
&maintenance_show_cmdlist);
+ add_setshow_auto_boolean_cmd ("target-non-stop", no_class,
+ &target_non_stop_enabled_1, _("\
+Set whether gdb always controls the inferior in non-stop mode."), _("\
+Show whether gdb always controls the inferior in non-stop mode."), _("\
+Tells gdb whether to control the inferior in non-stop mode."),
+ maint_set_target_non_stop_command,
+ maint_show_target_non_stop_command,
+ &maintenance_set_cmdlist,
+ &maintenance_show_cmdlist);
+
add_setshow_boolean_cmd ("may-write-registers", class_support,
&may_write_registers_1, _("\
Set permission to write into registers."), _("\
projects / deliverable / binutils-gdb.git / blobdiff