/* Select target systems and architectures at runtime for GDB.
- Copyright (C) 1990-2016 Free Software Foundation, Inc.
+ Copyright (C) 1990-2017 Free Software Foundation, Inc.
Contributed by Cygnus Support.
#include "target-debug.h"
#include "top.h"
#include "event-top.h"
+#include <algorithm>
static void target_info (char *, int);
struct ui *ui = current_ui;
/* A background resume (``run&'') should leave GDB in control of the
- terminal. Use target_can_async_p, not target_is_async_p, since at
- this point the target is not async yet. However, if sync_execution
- is not set, we know it will become async prior to resume. */
- if (target_can_async_p () && !sync_execution)
+ terminal. */
+ if (ui->prompt_state != PROMPT_BLOCKED)
return;
- /* Always delete the current UI's input file handler, regardless of
- terminal_state, because terminal_state is only valid for the main
- UI. */
- delete_file_handler (ui->input_fd);
+ /* Since we always run the inferior in the main console (unless "set
+ inferior-tty" is in effect), when some UI other than the main one
+ calls target_terminal_inferior/target_terminal_inferior, then we
+ leave the main UI's terminal settings as is. */
+ if (ui != main_ui)
+ return;
if (terminal_state == terminal_is_inferior)
return;
{
struct ui *ui = current_ui;
- /* Always add the current UI's input file handler, regardless of
- terminal_state, because terminal_state is only valid for the main
- UI. */
- add_file_handler (ui->input_fd, stdin_event_handler, ui);
+ /* See target_terminal_inferior. */
+ if (ui != main_ui)
+ return;
if (terminal_state == terminal_is_ours)
return;
void
target_terminal_ours_for_output (void)
{
+ struct ui *ui = current_ui;
+
+ /* See target_terminal_inferior. */
+ if (ui != main_ui)
+ return;
+
if (terminal_state != terminal_is_inferior)
return;
(*current_target.to_terminal_ours_for_output) (¤t_target);
by memory_xfer_partial_1. We will continually malloc
and free a copy of the entire write request for breakpoint
shadow handling even though we only end up writing a small
- subset of it. Cap writes to 4KB to mitigate this. */
- len = min (4096, len);
+ subset of it. Cap writes to a limit specified by the target
+ to mitigate this. */
+ len = std::min (ops->to_get_memory_xfer_limit (ops), len);
buf = (gdb_byte *) xmalloc (len);
old_chain = make_cleanup (xfree, buf);
void
free_memory_read_result_vector (void *x)
{
- VEC(memory_read_result_s) *v = (VEC(memory_read_result_s) *) x;
+ VEC(memory_read_result_s) **v = (VEC(memory_read_result_s) **) x;
memory_read_result_s *current;
int ix;
- for (ix = 0; VEC_iterate (memory_read_result_s, v, ix, current); ++ix)
+ for (ix = 0; VEC_iterate (memory_read_result_s, *v, ix, current); ++ix)
{
xfree (current->data);
}
- VEC_free (memory_read_result_s, v);
+ VEC_free (memory_read_result_s, *v);
}
VEC(memory_read_result_s) *
{
VEC(memory_read_result_s) *result = 0;
int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
+ struct cleanup *cleanup = make_cleanup (free_memory_read_result_vector,
+ &result);
LONGEST xfered_total = 0;
while (xfered_total < len)
}
else
{
- LONGEST to_read = min (len - xfered_total, region_len);
+ LONGEST to_read = std::min (len - xfered_total, region_len);
gdb_byte *buffer = (gdb_byte *) xmalloc (to_read * unit_size);
+ struct cleanup *inner_cleanup = make_cleanup (xfree, buffer);
LONGEST xfered_partial =
target_read (ops, TARGET_OBJECT_MEMORY, NULL,
{
/* Got an error reading full chunk. See if maybe we can read
some subrange. */
- xfree (buffer);
+ do_cleanups (inner_cleanup);
read_whatever_is_readable (ops, offset + xfered_total,
offset + xfered_total + to_read,
unit_size, &result);
else
{
struct memory_read_result r;
+
+ discard_cleanups (inner_cleanup);
r.data = buffer;
r.begin = offset + xfered_total;
r.end = r.begin + xfered_partial;
QUIT;
}
}
+
+ discard_cleanups (cleanup);
return result;
}
int
target_remove_breakpoint (struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
+ struct bp_target_info *bp_tgt,
+ enum remove_bp_reason reason)
{
/* This is kind of a weird case to handle, but the permission might
have been changed after breakpoints were inserted - in which case
}
return current_target.to_remove_breakpoint (¤t_target,
- gdbarch, bp_tgt);
+ gdbarch, bp_tgt, reason);
}
static void
current_target.to_disconnect (¤t_target, args, from_tty);
}
+/* See target/target.h. */
+
ptid_t
target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
{
clear_inline_frame_state (ptid);
}
+/* If true, target_commit_resume is a nop. */
+static int defer_target_commit_resume;
+
+/* See target.h. */
+
+void
+target_commit_resume (void)
+{
+ struct target_ops *t;
+
+ if (defer_target_commit_resume)
+ return;
+
+ current_target.to_commit_resume (¤t_target);
+}
+
+/* See target.h. */
+
+struct cleanup *
+make_cleanup_defer_target_commit_resume (void)
+{
+ struct cleanup *old_chain;
+
+ old_chain = make_cleanup_restore_integer (&defer_target_commit_resume);
+ defer_target_commit_resume = 1;
+ return old_chain;
+}
+
void
target_pass_signals (int numsigs, unsigned char *pass_signals)
{
}
void
-target_mourn_inferior (void)
+target_mourn_inferior (ptid_t ptid)
{
+ gdb_assert (ptid_equal (ptid, inferior_ptid));
current_target.to_mourn_inferior (¤t_target);
/* We no longer need to keep handles on any of the object files.
while (search_space_len >= pattern_len)
{
gdb_byte *found_ptr;
- unsigned nr_search_bytes = min (search_space_len, search_buf_size);
+ unsigned nr_search_bytes
+ = std::min (search_space_len, (ULONGEST) search_buf_size);
found_ptr = (gdb_byte *) memmem (search_buf, nr_search_bytes,
pattern, pattern_len);
gdb_assert (keep_len == pattern_len - 1);
memcpy (search_buf, search_buf + chunk_size, keep_len);
- nr_to_read = min (search_space_len - keep_len, chunk_size);
+ nr_to_read = std::min (search_space_len - keep_len,
+ (ULONGEST) chunk_size);
if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
search_buf + keep_len, read_addr,
return 0;
}
+/* See target/target.h. */
+
+int
+target_supports_multi_process (void)
+{
+ return (*current_target.to_supports_multi_process) (¤t_target);
+}
+
char *
target_get_osdata (const char *type)
{
release_fileio_fd (int fd, fileio_fh_t *fh)
{
fh->fd = -1;
- lowest_closed_fd = min (lowest_closed_fd, fd);
+ lowest_closed_fd = std::min (lowest_closed_fd, fd);
}
/* Return a pointer to the fileio_fhandle_t corresponding to FD. */
}
\f
+
+/* See target.h */
+
+void
+target_announce_detach (int from_tty)
+{
+ pid_t pid;
+ char *exec_file;
+
+ if (!from_tty)
+ return;
+
+ exec_file = get_exec_file (0);
+ if (exec_file == NULL)
+ exec_file = "";
+
+ pid = ptid_get_pid (inferior_ptid);
+ printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
+ target_pid_to_str (pid_to_ptid (pid)));
+ gdb_flush (gdb_stdout);
+}
+
/* The inferior process has died. Long live the inferior! */
void
target_resume (ptid, 0, GDB_SIGNAL_0);
}
+/* See target/target.h. */
+
+void
+target_continue (ptid_t ptid, enum gdb_signal signal)
+{
+ target_resume (ptid, 0, signal);
+}
+
/* Concatenate ELEM to LIST, a comma separate list, and return the
result. The LIST incoming argument is released. */
ULONGEST xfered_len;
enum target_xfer_status status;
gdb_byte buf[1024];
- ULONGEST howmuch = min (sizeof (buf), size - total_xfered);
+ ULONGEST howmuch = std::min<ULONGEST> (sizeof (buf), size - total_xfered);
status = target_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
buf, NULL, lma + total_xfered, howmuch,
projects / binutils-gdb.git / blobdiff