/* Memory-access and commands for "inferior" process, for GDB.
- Copyright (C) 1986-2017 Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 Free Software Foundation, Inc.
This file is part of GDB.
#include "block.h"
#include "solib.h"
#include <ctype.h>
-#include "observer.h"
+#include "observable.h"
#include "target-descriptions.h"
#include "user-regs.h"
#include "cli/cli-decode.h"
#include "top.h"
#include "interps.h"
#include "common/gdb_optional.h"
+#include "source.h"
/* Local functions: */
if the now pushed target supports hardware watchpoints. */
breakpoint_re_set ();
- observer_notify_inferior_created (target, from_tty);
+ gdb::observers::inferior_created.notify (target, from_tty);
}
/* Kill the inferior if already running. This function is designed
{
/* If we get a request for running in the bg but the target
doesn't support it, error out. */
- if (background && !target->to_can_async_p (target))
+ if (background && !target->can_async_p ())
error (_("Asynchronous execution not supported on this target."));
if (!background)
run_command_1 (const char *args, int from_tty, enum run_how run_how)
{
const char *exec_file;
- struct cleanup *old_chain;
- ptid_t ptid;
struct ui_out *uiout = current_uiout;
struct target_ops *run_target;
int async_exec;
prepare_execution_command (run_target, async_exec);
- if (non_stop && !run_target->to_supports_non_stop (run_target))
+ if (non_stop && !run_target->supports_non_stop ())
error (_("The target does not support running in non-stop mode."));
/* Done. Can now set breakpoints, change inferior args, etc. */
/* We call get_inferior_args() because we might need to compute
the value now. */
- run_target->to_create_inferior (run_target, exec_file,
- std::string (get_inferior_args ()),
- current_inferior ()->environment.envp (),
- from_tty);
+ run_target->create_inferior (exec_file,
+ std::string (get_inferior_args ()),
+ current_inferior ()->environment.envp (),
+ from_tty);
/* to_create_inferior should push the target, so after this point we
shouldn't refer to run_target again. */
run_target = NULL;
events --- the frontend shouldn't see them as stopped. In
all-stop, always finish the state of all threads, as we may be
resuming more than just the new process. */
- if (non_stop)
- ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
- else
- ptid = minus_one_ptid;
- old_chain = make_cleanup (finish_thread_state_cleanup, &ptid);
+ ptid_t finish_ptid = (non_stop
+ ? ptid_t (current_inferior ()->pid)
+ : minus_one_ptid);
+ scoped_finish_thread_state finish_state (finish_ptid);
/* Pass zero for FROM_TTY, because at this point the "run" command
has done its thing; now we are setting up the running program. */
- post_create_inferior (¤t_target, 0);
+ post_create_inferior (target_stack, 0);
/* Queue a pending event so that the program stops immediately. */
if (run_how == RUN_STOP_AT_FIRST_INSN)
/* Since there was no error, there's no need to finish the thread
states here. */
- discard_cleanups (old_chain);
+ finish_state.release ();
}
static void
ensure_not_running ();
}
- prepare_execution_command (¤t_target, async_exec);
+ prepare_execution_command (target_stack, async_exec);
if (from_tty)
printf_filtered (_("Continuing.\n"));
= strip_bg_char (count_string, &async_exec);
count_string = stripped.get ();
- prepare_execution_command (¤t_target, async_exec);
+ prepare_execution_command (target_stack, async_exec);
count = count_string ? parse_and_eval_long (count_string) : 1;
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (¤t_target, async_exec);
+ prepare_execution_command (target_stack, async_exec);
if (!arg)
error_no_arg (_("starting address"));
= strip_bg_char (signum_exp, &async_exec);
signum_exp = stripped.get ();
- prepare_execution_command (¤t_target, async_exec);
+ prepare_execution_command (target_stack, async_exec);
if (!signum_exp)
error_no_arg (_("signal number"));
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (¤t_target, async_exec);
+ prepare_execution_command (target_stack, async_exec);
if (arg)
until_break_command (arg, from_tty, 0);
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (¤t_target, async_exec);
+ prepare_execution_command (target_stack, async_exec);
until_break_command (arg, from_tty, 1);
}
struct value *
get_return_value (struct value *function, struct type *value_type)
{
- regcache stop_regs (regcache::readonly, *get_current_regcache ());
- struct gdbarch *gdbarch = stop_regs.arch ();
+ regcache *stop_regs = get_current_regcache ();
+ struct gdbarch *gdbarch = stop_regs->arch ();
struct value *value;
value_type = check_typedef (value_type);
case RETURN_VALUE_ABI_RETURNS_ADDRESS:
case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
value = allocate_value (value_type);
- gdbarch_return_value (gdbarch, function, value_type, &stop_regs,
+ gdbarch_return_value (gdbarch, function, value_type, stop_regs,
value_contents_raw (value), NULL);
break;
case RETURN_VALUE_STRUCT_CONVENTION:
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (¤t_target, async_exec);
+ prepare_execution_command (target_stack, async_exec);
if (arg)
error (_("The \"finish\" command does not take any arguments."));
}
\f
+static void
+pad_to_column (string_file &stream, int col)
+{
+ /* At least one space must be printed to separate columns. */
+ stream.putc (' ');
+ const int size = stream.size ();
+ if (size < col)
+ stream.puts (n_spaces (col - size));
+}
+
/* Print out the register NAME with value VAL, to FILE, in the default
fashion. */
{
struct type *regtype = value_type (val);
int print_raw_format;
+ string_file format_stream;
+ enum tab_stops
+ {
+ value_column_1 = 15,
+ /* Give enough room for "0x", 16 hex digits and two spaces in
+ preceding column. */
+ value_column_2 = value_column_1 + 2 + 16 + 2,
+ };
- fputs_filtered (name, file);
- print_spaces_filtered (15 - strlen (name), file);
+ format_stream.puts (name);
+ pad_to_column (format_stream, value_column_1);
print_raw_format = (value_entirely_available (val)
&& !value_optimized_out (val));
val_print (regtype,
value_embedded_offset (val), 0,
- file, 0, val, &opts, current_language);
+ &format_stream, 0, val, &opts, current_language);
if (print_raw_format)
{
- fprintf_filtered (file, "\t(raw ");
- print_hex_chars (file, valaddr, TYPE_LENGTH (regtype), byte_order,
- true);
- fprintf_filtered (file, ")");
+ pad_to_column (format_stream, value_column_2);
+ format_stream.puts ("(raw ");
+ print_hex_chars (&format_stream, valaddr, TYPE_LENGTH (regtype),
+ byte_order, true);
+ format_stream.putc (')');
}
}
else
opts.deref_ref = 1;
val_print (regtype,
value_embedded_offset (val), 0,
- file, 0, val, &opts, current_language);
+ &format_stream, 0, val, &opts, current_language);
/* If not a vector register, print it also according to its
natural format. */
if (print_raw_format && TYPE_VECTOR (regtype) == 0)
{
+ pad_to_column (format_stream, value_column_2);
get_user_print_options (&opts);
opts.deref_ref = 1;
- fprintf_filtered (file, "\t");
val_print (regtype,
value_embedded_offset (val), 0,
- file, 0, val, &opts, current_language);
+ &format_stream, 0, val, &opts, current_language);
}
}
+ fputs_filtered (format_stream.c_str (), file);
fprintf_filtered (file, "\n");
}
error (_("The program is not being run."));
if (!query (_("Kill the program being debugged? ")))
error (_("Not confirmed."));
+
+ int pid = current_inferior ()->pid;
+ /* Save the pid as a string before killing the inferior, since that
+ may unpush the current target, and we need the string after. */
+ std::string pid_str = target_pid_to_str (pid_to_ptid (pid));
+ int infnum = current_inferior ()->num;
+
target_kill ();
+ if (print_inferior_events)
+ printf_unfiltered (_("[Inferior %d (%s) killed]\n"),
+ infnum, pid_str.c_str ());
+
/* If we still have other inferiors to debug, then don't mess with
with their threads. */
if (!have_inferiors ())
/* Take any necessary post-attaching actions for this platform. */
target_post_attach (ptid_get_pid (inferior_ptid));
- post_create_inferior (¤t_target, from_tty);
+ post_create_inferior (target_stack, from_tty);
}
/* What to do after the first program stops after attaching. */
prepare_execution_command (attach_target, async_exec);
- if (non_stop && !attach_target->to_supports_non_stop (attach_target))
+ if (non_stop && !attach_target->supports_non_stop ())
error (_("Cannot attach to this target in non-stop mode"));
- attach_target->to_attach (attach_target, args, from_tty);
+ attach_target->attach (args, from_tty);
/* to_attach should push the target, so after this point we
shouldn't refer to attach_target again. */
attach_target = NULL;
/* Some system don't generate traps when attaching to inferior.
E.g. Mach 3 or GNU hurd. */
- if (!target_attach_no_wait)
+ if (!target_attach_no_wait ())
{
struct attach_command_continuation_args *a;
disconnect_tracing ();
- target_detach (args, from_tty);
+ target_detach (current_inferior (), from_tty);
/* The current inferior process was just detached successfully. Get
rid of breakpoints that no longer make sense. Note we don't do
if (non_stop)
target_stop (ptid);
else
- target_interrupt (ptid);
+ target_interrupt ();
/* Tag the thread as having been explicitly requested to stop, so
other parts of gdb know not to resume this thread automatically,
c = add_com ("jump", class_run, jump_command, _("\
Continue program being debugged at specified line or address.\n\
-Usage: jump <location>\n\
+Usage: jump LOCATION\n\
Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
for an address to start at."));
set_cmd_completer (c, location_completer);
projects / deliverable / binutils-gdb.git / blobdiff