static void set_schedlock_func (char *args, int from_tty,
struct cmd_list_element *c);
-static int currently_stepping (struct thread_info *tp);
-
static int currently_stepping_or_nexting_callback (struct thread_info *tp,
void *data);
static int prepare_to_proceed (int);
+static void print_exited_reason (int exitstatus);
+
+static void print_signal_exited_reason (enum target_signal siggnal);
+
+static void print_no_history_reason (void);
+
+static void print_signal_received_reason (enum target_signal siggnal);
+
+static void print_end_stepping_range_reason (void);
+
void _initialize_infrun (void);
void nullify_last_target_wait_ptid (void);
fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
}
-static int debug_infrun = 0;
+int debug_infrun = 0;
static void
show_debug_infrun (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
/* Nonzero if we want to give control to the user when we're notified
of shared library events by the dynamic linker. */
-static int stop_on_solib_events;
+int stop_on_solib_events;
static void
show_stop_on_solib_events (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
/* That a.out is now the one to use. */
exec_file_attach (execd_pathname, 0);
- /* Load the main file's symbols. */
- symbol_file_add_main (execd_pathname, 0);
+ /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
+ (Position Independent Executable) main symbol file will get applied by
+ solib_create_inferior_hook below. breakpoint_re_set would fail to insert
+ the breakpoints with the zero displacement. */
+
+ symbol_file_add (execd_pathname, SYMFILE_MAINLINE | SYMFILE_DEFER_BP_RESET,
+ NULL, 0);
+
+ set_initial_language ();
#ifdef SOLIB_CREATE_INFERIOR_HOOK
SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
jit_inferior_created_hook ();
+ breakpoint_re_set ();
+
/* Reinsert all breakpoints. (Those which were symbolic have
been reset to the proper address in the new a.out, thanks
to symbol_file_command...) */
{
int hw_step = 1;
- if (gdbarch_software_single_step_p (gdbarch)
+ if (execution_direction == EXEC_FORWARD
+ && gdbarch_software_single_step_p (gdbarch)
&& gdbarch_software_single_step (gdbarch, get_current_frame ()))
{
hw_step = 0;
QUIT;
+ if (current_inferior ()->waiting_for_vfork_done)
+ {
+ /* Don't try to single-step a vfork parent that is waiting for
+ the child to get out of the shared memory region (by exec'ing
+ or exiting). This is particularly important on software
+ single-step archs, as the child process would trip on the
+ software single step breakpoint inserted for the parent
+ process. Since the parent will not actually execute any
+ instruction until the child is out of the shared region (such
+ are vfork's semantics), it is safe to simply continue it.
+ Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
+ the parent, and tell it to `keep_going', which automatically
+ re-sets it stepping. */
+ if (debug_infrun)
+ fprintf_unfiltered (gdb_stdlog,
+ "infrun: resume : clear step\n");
+ step = 0;
+ }
+
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog,
"infrun: resume (step=%d, signal=%d), "
We can't use displaced stepping when we have a signal to deliver;
the comments for displaced_step_prepare explain why. The
comments in the handle_inferior event for dealing with 'random
- signals' explain what we do instead. */
+ signals' explain what we do instead.
+
+ We can't use displaced stepping when we are waiting for vfork_done
+ event, displaced stepping breaks the vfork child similarly as single
+ step software breakpoint. */
if (use_displaced_stepping (gdbarch)
&& (tp->trap_expected
|| (step && gdbarch_software_single_step_p (gdbarch)))
- && sig == TARGET_SIGNAL_0)
+ && sig == TARGET_SIGNAL_0
+ && !current_inferior ()->waiting_for_vfork_done)
{
struct displaced_step_inferior_state *displaced;
infwait_nonstep_watch_state
};
-/* Why did the inferior stop? Used to print the appropriate messages
- to the interface from within handle_inferior_event(). */
-enum inferior_stop_reason
-{
- /* Step, next, nexti, stepi finished. */
- END_STEPPING_RANGE,
- /* Inferior terminated by signal. */
- SIGNAL_EXITED,
- /* Inferior exited. */
- EXITED,
- /* Inferior received signal, and user asked to be notified. */
- SIGNAL_RECEIVED,
- /* Reverse execution -- target ran out of history info. */
- NO_HISTORY
-};
-
/* The PTID we'll do a target_wait on.*/
ptid_t waiton_ptid;
static void stop_stepping (struct execution_control_state *ecs);
static void prepare_to_wait (struct execution_control_state *ecs);
static void keep_going (struct execution_control_state *ecs);
-static void print_stop_reason (enum inferior_stop_reason stop_reason,
- int stop_info);
/* Callback for iterate over threads. If the thread is stopped, but
the user/frontend doesn't know about that yet, go through
set_current_program_space (current_inferior ()->pspace);
handle_vfork_child_exec_or_exit (0);
target_terminal_ours (); /* Must do this before mourn anyway */
- print_stop_reason (EXITED, ecs->ws.value.integer);
+ print_exited_reason (ecs->ws.value.integer);
/* Record the exit code in the convenience variable $_exitcode, so
that the user can inspect this again later. */
gdb_flush (gdb_stdout);
target_mourn_inferior ();
singlestep_breakpoints_inserted_p = 0;
+ cancel_single_step_breakpoints ();
stop_print_frame = 0;
stop_stepping (ecs);
return;
may be needed. */
target_mourn_inferior ();
- print_stop_reason (SIGNAL_EXITED, ecs->ws.value.sig);
+ print_signal_exited_reason (ecs->ws.value.sig);
singlestep_breakpoints_inserted_p = 0;
+ cancel_single_step_breakpoints ();
stop_stepping (ecs);
return;
detach_breakpoints (child_pid);
}
+ if (singlestep_breakpoints_inserted_p)
+ {
+ /* Pull the single step breakpoints out of the target. */
+ remove_single_step_breakpoints ();
+ singlestep_breakpoints_inserted_p = 0;
+ }
+
/* In case the event is caught by a catchpoint, remember that
the event is to be followed at the next resume of the thread,
and not immediately. */
reinit_frame_cache ();
}
+ singlestep_breakpoints_inserted_p = 0;
+ cancel_single_step_breakpoints ();
+
stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
/* Do whatever is necessary to the parent branch of the vfork. */
case TARGET_WAITKIND_NO_HISTORY:
/* Reverse execution: target ran out of history info. */
stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
- print_stop_reason (NO_HISTORY, 0);
+ print_no_history_reason ();
stop_stepping (ecs);
return;
}
{
printed = 1;
target_terminal_ours_for_output ();
- print_stop_reason (SIGNAL_RECEIVED, ecs->event_thread->stop_signal);
+ print_signal_received_reason (ecs->event_thread->stop_signal);
}
/* Always stop on signals if we're either just gaining control
of the program, or the user explicitly requested this thread
stop_stack_dummy = what.call_dummy;
}
+ /* If we hit an internal event that triggers symbol changes, the
+ current frame will be invalidated within bpstat_what (e.g., if
+ we hit an internal solib event). Re-fetch it. */
+ frame = get_current_frame ();
+ gdbarch = get_frame_arch (frame);
+
switch (what.main_action)
{
case BPSTAT_WHAT_SET_LONGJMP_RESUME:
delete_step_resume_breakpoint (ecs->event_thread);
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
return;
}
break;
- case BPSTAT_WHAT_CHECK_SHLIBS:
- {
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_CHECK_SHLIBS\n");
-
- /* Check for any newly added shared libraries if we're
- supposed to be adding them automatically. Switch
- terminal for any messages produced by
- breakpoint_re_set. */
- target_terminal_ours_for_output ();
- /* NOTE: cagney/2003-11-25: Make certain that the target
- stack's section table is kept up-to-date. Architectures,
- (e.g., PPC64), use the section table to perform
- operations such as address => section name and hence
- require the table to contain all sections (including
- those found in shared libraries). */
-#ifdef SOLIB_ADD
- SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add);
-#else
- solib_add (NULL, 0, ¤t_target, auto_solib_add);
-#endif
- target_terminal_inferior ();
-
- /* If requested, stop when the dynamic linker notifies
- gdb of events. This allows the user to get control
- and place breakpoints in initializer routines for
- dynamically loaded objects (among other things). */
- if (stop_on_solib_events || stop_stack_dummy)
- {
- stop_stepping (ecs);
- return;
- }
- else
- {
- /* We want to step over this breakpoint, then keep going. */
- ecs->event_thread->stepping_over_breakpoint = 1;
- break;
- }
- }
- break;
-
- case BPSTAT_WHAT_CHECK_JIT:
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_CHECK_JIT\n");
-
- /* Switch terminal for any messages produced by breakpoint_re_set. */
- target_terminal_ours_for_output ();
-
- jit_event_handler (gdbarch);
-
- target_terminal_inferior ();
-
- /* We want to step over this breakpoint, then keep going. */
- ecs->event_thread->stepping_over_breakpoint = 1;
-
- break;
-
- case BPSTAT_WHAT_LAST:
- /* Not a real code, but listed here to shut up gcc -Wall. */
-
case BPSTAT_WHAT_KEEP_CHECKING:
break;
}
the frame cache to be re-initialized, making our FRAME variable
a dangling pointer. */
frame = get_current_frame ();
+ gdbarch = get_frame_arch (frame);
/* If stepping through a line, keep going if still within it.
&& execution_direction == EXEC_REVERSE)
{
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
}
else
well. FENN */
/* And this works the same backward as frontward. MVS */
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
return;
}
&& step_stop_if_no_debug)
{
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
return;
}
is set, we stop the step so that the user has a chance to
switch in assembly mode. */
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
return;
}
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
return;
}
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
return;
}
step_into_inline_frame (ecs->ptid);
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
return;
}
else
{
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
}
return;
else
{
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
}
return;
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepped to a different line\n");
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
return;
}
/* Is thread TP in the middle of single-stepping? */
-static int
+int
currently_stepping (struct thread_info *tp)
{
return ((tp->step_range_end && tp->step_resume_breakpoint == NULL)
{
/* We are already there: stop now. */
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
return;
}
{
/* We're there already. Just stop stepping now. */
ecs->event_thread->stop_step = 1;
- print_stop_reason (END_STEPPING_RANGE, 0);
+ print_end_stepping_range_reason ();
stop_stepping (ecs);
}
else
ecs->wait_some_more = 1;
}
-/* Print why the inferior has stopped. We always print something when
- the inferior exits, or receives a signal. The rest of the cases are
- dealt with later on in normal_stop() and print_it_typical(). Ideally
- there should be a call to this function from handle_inferior_event()
- each time stop_stepping() is called.*/
+/* Several print_*_reason functions to print why the inferior has stopped.
+ We always print something when the inferior exits, or receives a signal.
+ The rest of the cases are dealt with later on in normal_stop and
+ print_it_typical. Ideally there should be a call to one of these
+ print_*_reason functions functions from handle_inferior_event each time
+ stop_stepping is called. */
+
+/* Print why the inferior has stopped.
+ We are done with a step/next/si/ni command, print why the inferior has
+ stopped. For now print nothing. Print a message only if not in the middle
+ of doing a "step n" operation for n > 1. */
+
+static void
+print_end_stepping_range_reason (void)
+{
+ if ((!inferior_thread ()->step_multi || !inferior_thread ()->stop_step)
+ && ui_out_is_mi_like_p (uiout))
+ ui_out_field_string (uiout, "reason",
+ async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
+}
+
+/* The inferior was terminated by a signal, print why it stopped. */
+
+static void
+print_signal_exited_reason (enum target_signal siggnal)
+{
+ annotate_signalled ();
+ if (ui_out_is_mi_like_p (uiout))
+ ui_out_field_string
+ (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
+ ui_out_text (uiout, "\nProgram terminated with signal ");
+ annotate_signal_name ();
+ ui_out_field_string (uiout, "signal-name",
+ target_signal_to_name (siggnal));
+ annotate_signal_name_end ();
+ ui_out_text (uiout, ", ");
+ annotate_signal_string ();
+ ui_out_field_string (uiout, "signal-meaning",
+ target_signal_to_string (siggnal));
+ annotate_signal_string_end ();
+ ui_out_text (uiout, ".\n");
+ ui_out_text (uiout, "The program no longer exists.\n");
+}
+
+/* The inferior program is finished, print why it stopped. */
+
static void
-print_stop_reason (enum inferior_stop_reason stop_reason, int stop_info)
+print_exited_reason (int exitstatus)
{
- switch (stop_reason)
+ annotate_exited (exitstatus);
+ if (exitstatus)
+ {
+ if (ui_out_is_mi_like_p (uiout))
+ ui_out_field_string (uiout, "reason",
+ async_reason_lookup (EXEC_ASYNC_EXITED));
+ ui_out_text (uiout, "\nProgram exited with code ");
+ ui_out_field_fmt (uiout, "exit-code", "0%o", (unsigned int) exitstatus);
+ ui_out_text (uiout, ".\n");
+ }
+ else
{
- case END_STEPPING_RANGE:
- /* We are done with a step/next/si/ni command. */
- /* For now print nothing. */
- /* Print a message only if not in the middle of doing a "step n"
- operation for n > 1 */
- if (!inferior_thread ()->step_multi
- || !inferior_thread ()->stop_step)
- if (ui_out_is_mi_like_p (uiout))
- ui_out_field_string
- (uiout, "reason",
- async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
- break;
- case SIGNAL_EXITED:
- /* The inferior was terminated by a signal. */
- annotate_signalled ();
if (ui_out_is_mi_like_p (uiout))
ui_out_field_string
- (uiout, "reason",
- async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
- ui_out_text (uiout, "\nProgram terminated with signal ");
+ (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
+ ui_out_text (uiout, "\nProgram exited normally.\n");
+ }
+ /* Support the --return-child-result option. */
+ return_child_result_value = exitstatus;
+}
+
+/* Signal received, print why the inferior has stopped. The signal table
+ tells us to print about it. */
+
+static void
+print_signal_received_reason (enum target_signal siggnal)
+{
+ annotate_signal ();
+
+ if (siggnal == TARGET_SIGNAL_0 && !ui_out_is_mi_like_p (uiout))
+ {
+ struct thread_info *t = inferior_thread ();
+
+ ui_out_text (uiout, "\n[");
+ ui_out_field_string (uiout, "thread-name",
+ target_pid_to_str (t->ptid));
+ ui_out_field_fmt (uiout, "thread-id", "] #%d", t->num);
+ ui_out_text (uiout, " stopped");
+ }
+ else
+ {
+ ui_out_text (uiout, "\nProgram received signal ");
annotate_signal_name ();
+ if (ui_out_is_mi_like_p (uiout))
+ ui_out_field_string
+ (uiout, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
ui_out_field_string (uiout, "signal-name",
- target_signal_to_name (stop_info));
+ target_signal_to_name (siggnal));
annotate_signal_name_end ();
ui_out_text (uiout, ", ");
annotate_signal_string ();
ui_out_field_string (uiout, "signal-meaning",
- target_signal_to_string (stop_info));
+ target_signal_to_string (siggnal));
annotate_signal_string_end ();
- ui_out_text (uiout, ".\n");
- ui_out_text (uiout, "The program no longer exists.\n");
- break;
- case EXITED:
- /* The inferior program is finished. */
- annotate_exited (stop_info);
- if (stop_info)
- {
- if (ui_out_is_mi_like_p (uiout))
- ui_out_field_string (uiout, "reason",
- async_reason_lookup (EXEC_ASYNC_EXITED));
- ui_out_text (uiout, "\nProgram exited with code ");
- ui_out_field_fmt (uiout, "exit-code", "0%o",
- (unsigned int) stop_info);
- ui_out_text (uiout, ".\n");
- }
- else
- {
- if (ui_out_is_mi_like_p (uiout))
- ui_out_field_string
- (uiout, "reason",
- async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
- ui_out_text (uiout, "\nProgram exited normally.\n");
- }
- /* Support the --return-child-result option. */
- return_child_result_value = stop_info;
- break;
- case SIGNAL_RECEIVED:
- /* Signal received. The signal table tells us to print about
- it. */
- annotate_signal ();
+ }
+ ui_out_text (uiout, ".\n");
+}
- if (stop_info == TARGET_SIGNAL_0 && !ui_out_is_mi_like_p (uiout))
- {
- struct thread_info *t = inferior_thread ();
+/* Reverse execution: target ran out of history info, print why the inferior
+ has stopped. */
- ui_out_text (uiout, "\n[");
- ui_out_field_string (uiout, "thread-name",
- target_pid_to_str (t->ptid));
- ui_out_field_fmt (uiout, "thread-id", "] #%d", t->num);
- ui_out_text (uiout, " stopped");
- }
- else
- {
- ui_out_text (uiout, "\nProgram received signal ");
- annotate_signal_name ();
- if (ui_out_is_mi_like_p (uiout))
- ui_out_field_string
- (uiout, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
- ui_out_field_string (uiout, "signal-name",
- target_signal_to_name (stop_info));
- annotate_signal_name_end ();
- ui_out_text (uiout, ", ");
- annotate_signal_string ();
- ui_out_field_string (uiout, "signal-meaning",
- target_signal_to_string (stop_info));
- annotate_signal_string_end ();
- }
- ui_out_text (uiout, ".\n");
- break;
- case NO_HISTORY:
- /* Reverse execution: target ran out of history info. */
- ui_out_text (uiout, "\nNo more reverse-execution history.\n");
- break;
- default:
- internal_error (__FILE__, __LINE__,
- _("print_stop_reason: unrecognized enum value"));
- break;
- }
+static void
+print_no_history_reason (void)
+{
+ ui_out_text (uiout, "\nNo more reverse-execution history.\n");
}
-\f
/* Here to return control to GDB when the inferior stops for real.
Print appropriate messages, remove breakpoints, give terminal our modes.
enum target_signal stop_signal;
CORE_ADDR stop_pc;
struct regcache *registers;
+
+ /* Format of SIGINFO or NULL if it is not present. */
+ struct gdbarch *siginfo_gdbarch;
+
+ /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
+ TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
+ content would be invalid. */
+ gdb_byte *siginfo_data;
};
struct inferior_thread_state *
save_inferior_thread_state (void)
{
- struct inferior_thread_state *inf_state = XMALLOC (struct inferior_thread_state);
+ struct inferior_thread_state *inf_state;
struct thread_info *tp = inferior_thread ();
+ struct regcache *regcache = get_current_regcache ();
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ gdb_byte *siginfo_data = NULL;
+
+ if (gdbarch_get_siginfo_type_p (gdbarch))
+ {
+ struct type *type = gdbarch_get_siginfo_type (gdbarch);
+ size_t len = TYPE_LENGTH (type);
+ struct cleanup *back_to;
+
+ siginfo_data = xmalloc (len);
+ back_to = make_cleanup (xfree, siginfo_data);
+
+ if (target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
+ siginfo_data, 0, len) == len)
+ discard_cleanups (back_to);
+ else
+ {
+ /* Errors ignored. */
+ do_cleanups (back_to);
+ siginfo_data = NULL;
+ }
+ }
+
+ inf_state = XZALLOC (struct inferior_thread_state);
+
+ if (siginfo_data)
+ {
+ inf_state->siginfo_gdbarch = gdbarch;
+ inf_state->siginfo_data = siginfo_data;
+ }
inf_state->stop_signal = tp->stop_signal;
inf_state->stop_pc = stop_pc;
- inf_state->registers = regcache_dup (get_current_regcache ());
+ inf_state->registers = regcache_dup (regcache);
return inf_state;
}
restore_inferior_thread_state (struct inferior_thread_state *inf_state)
{
struct thread_info *tp = inferior_thread ();
+ struct regcache *regcache = get_current_regcache ();
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
tp->stop_signal = inf_state->stop_signal;
stop_pc = inf_state->stop_pc;
+ if (inf_state->siginfo_gdbarch == gdbarch)
+ {
+ struct type *type = gdbarch_get_siginfo_type (gdbarch);
+ size_t len = TYPE_LENGTH (type);
+
+ /* Errors ignored. */
+ target_write (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
+ inf_state->siginfo_data, 0, len);
+ }
+
/* The inferior can be gone if the user types "print exit(0)"
(and perhaps other times). */
if (target_has_execution)
/* NB: The register write goes through to the target. */
- regcache_cpy (get_current_regcache (), inf_state->registers);
+ regcache_cpy (regcache, inf_state->registers);
regcache_xfree (inf_state->registers);
+ xfree (inf_state->siginfo_data);
xfree (inf_state);
}
else if (!strcmp (exec_direction, exec_reverse))
execution_direction = EXEC_REVERSE;
}
+ else
+ {
+ exec_direction = exec_forward;
+ error (_("Target does not support this operation."));
+ }
}
static void
Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
The special arg \"all\" is recognized to mean all signals except those\n\
used by the debugger, typically SIGTRAP and SIGINT.\n\
-Recognized actions include \"s\" (toggles between stop and nostop), \n\
+Recognized actions include \"s\" (toggles between stop and nostop),\n\
\"r\" (toggles between print and noprint), \"i\" (toggles between pass and \
nopass), \"Q\" (noprint)\n\
Stop means reenter debugger if this signal happens (implies print).\n\
\n\
follow-exec-mode can be:\n\
\n\
- new - the debugger creates a new inferior and rebinds the process \n\
+ new - the debugger creates a new inferior and rebinds the process\n\
to this new inferior. The program the process was running before\n\
the exec call can be restarted afterwards by restarting the original\n\
inferior.\n\
projects / deliverable / binutils-gdb.git / blobdiff