#include "value.h"
#include "observer.h"
#include "language.h"
+#include "solib.h"
+
#include "gdb_assert.h"
+#include "mi/mi-common.h"
/* Prototypes for local functions */
no line number information. The normal behavior is that we step
over such function. */
int step_stop_if_no_debug = 0;
+static void
+show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
+}
/* In asynchronous mode, but simulating synchronous execution. */
static int may_follow_exec = MAY_FOLLOW_EXEC;
static int debug_infrun = 0;
+static void
+show_debug_infrun (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
+}
/* If the program uses ELF-style shared libraries, then calls to
functions in shared libraries go through stubs, which live in a
signalling an error, which will obscure the change in the
inferior's state. */
-#ifndef IN_SOLIB_DYNSYM_RESOLVE_CODE
-#define IN_SOLIB_DYNSYM_RESOLVE_CODE(pc) 0
-#endif
-
/* This function returns TRUE if pc is the address of an instruction
that lies within the dynamic linker (such as the event hook, or the
dld itself).
static int trap_expected;
-#ifdef SOLIB_ADD
/* 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;
-#endif
+static void
+show_stop_on_solib_events (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Stopping for shared library events is %s.\n"),
+ value);
+}
/* Nonzero means expecting a trace trap
and should stop the inferior and return silently when it happens. */
};
static const char *follow_fork_mode_string = follow_fork_mode_parent;
+static void
+show_follow_fork_mode_string (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+Debugger response to a program call of fork or vfork is \"%s\".\n"),
+ value);
+}
\f
static int
#endif
#ifdef SOLIB_CREATE_INFERIOR_HOOK
SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
+#else
+ solib_create_inferior_hook ();
#endif
/* Reinsert all breakpoints. (Those which were symbolic have
static const char schedlock_off[] = "off";
static const char schedlock_on[] = "on";
static const char schedlock_step[] = "step";
-static const char *scheduler_mode = schedlock_off;
static const char *scheduler_enums[] = {
schedlock_off,
schedlock_on,
schedlock_step,
NULL
};
+static const char *scheduler_mode = schedlock_off;
+static void
+show_scheduler_mode (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+Mode for locking scheduler during execution is \"%s\".\n"),
+ value);
+}
static void
set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c)
{
- /* NOTE: cagney/2002-03-17: The deprecated_add_show_from_set()
- function clones the set command passed as a parameter. The clone
- operation will include (BUG?) any ``set'' command callback, if
- present. Commands like ``info set'' call all the ``show''
- command callbacks. Unfortunately, for ``show'' commands cloned
- from ``set'', this includes callbacks belonging to ``set''
- commands. Making this worse, this only occures if
- deprecated_add_show_from_set() is called after add_cmd_sfunc()
- (BUG?). */
- if (cmd_type (c) == set_cmd)
- if (!target_can_lock_scheduler)
- {
- scheduler_mode = schedlock_off;
- error (_("Target '%s' cannot support this command."), target_shortname);
- }
+ if (!target_can_lock_scheduler)
+ {
+ scheduler_mode = schedlock_off;
+ error (_("Target '%s' cannot support this command."), target_shortname);
+ }
}
void
handle_inferior_event (struct execution_control_state *ecs)
{
- /* NOTE: cagney/2003-03-28: If you're looking at this code and
- thinking that the variable stepped_after_stopped_by_watchpoint
- isn't used, then you're wrong! The macro STOPPED_BY_WATCHPOINT,
- defined in the file "config/pa/nm-hppah.h", accesses the variable
- indirectly. Mutter something rude about the HP merge. */
+ /* NOTE: bje/2005-05-02: If you're looking at this code and thinking
+ that the variable stepped_after_stopped_by_watchpoint isn't used,
+ then you're wrong! See remote.c:remote_stopped_data_address. */
+
int sw_single_step_trap_p = 0;
int stopped_by_watchpoint = -1; /* Mark as unknown. */
case BPSTAT_WHAT_CHECK_SHLIBS:
case BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK:
-#ifdef SOLIB_ADD
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: BPSTATE_WHAT_CHECK_SHLIBS\n");
exec/process stratum, instead relying on the target stack
to propagate relevant changes (stop, section table
changed, ...) up to other layers. */
+#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 ();
/* Try to reenable shared library breakpoints, additional
break;
}
}
-#endif
break;
case BPSTAT_WHAT_LAST:
until we exit the run time loader code and reach the callee's
address. */
if (step_over_calls == STEP_OVER_UNDEBUGGABLE
- && IN_SOLIB_DYNSYM_RESOLVE_CODE (stop_pc))
+#ifdef IN_SOLIB_DYNSYM_RESOLVE_CODE
+ && IN_SOLIB_DYNSYM_RESOLVE_CODE (stop_pc)
+#else
+ && in_solib_dynsym_resolve_code (stop_pc)
+#endif
+ )
{
CORE_ADDR pc_after_resolver =
gdbarch_skip_solib_resolver (current_gdbarch, stop_pc);
if (real_stop_pc != 0)
ecs->stop_func_start = real_stop_pc;
- if (IN_SOLIB_DYNSYM_RESOLVE_CODE (ecs->stop_func_start))
+ if (
+#ifdef IN_SOLIB_DYNSYM_RESOLVE_CODE
+ IN_SOLIB_DYNSYM_RESOLVE_CODE (ecs->stop_func_start)
+#else
+ in_solib_dynsym_resolve_code (ecs->stop_func_start)
+#endif
+)
{
struct symtab_and_line sr_sal;
init_sal (&sr_sal);
operation for n > 1 */
if (!step_multi || !stop_step)
if (ui_out_is_mi_like_p (uiout))
- ui_out_field_string (uiout, "reason", "end-stepping-range");
+ ui_out_field_string
+ (uiout, "reason",
+ async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
break;
case BREAKPOINT_HIT:
/* We found a breakpoint. */
/* The inferior was terminated by a signal. */
annotate_signalled ();
if (ui_out_is_mi_like_p (uiout))
- ui_out_field_string (uiout, "reason", "exited-signalled");
+ 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",
if (stop_info)
{
if (ui_out_is_mi_like_p (uiout))
- ui_out_field_string (uiout, "reason", "exited");
+ 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);
else
{
if (ui_out_is_mi_like_p (uiout))
- ui_out_field_string (uiout, "reason", "exited-normally");
+ ui_out_field_string
+ (uiout, "reason",
+ async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
ui_out_text (uiout, "\nProgram exited normally.\n");
}
break;
ui_out_text (uiout, "\nProgram received signal ");
annotate_signal_name ();
if (ui_out_is_mi_like_p (uiout))
- ui_out_field_string (uiout, "reason", "signal-received");
+ 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 ();
Show inferior debugging."), _("\
When non-zero, inferior specific debugging is enabled."),
NULL,
- NULL, /* FIXME: i18n: */
+ show_debug_infrun,
&setdebuglist, &showdebuglist);
numsigs = (int) TARGET_SIGNAL_LAST;
signal_stop[TARGET_SIGNAL_CANCEL] = 0;
signal_print[TARGET_SIGNAL_CANCEL] = 0;
-#ifdef SOLIB_ADD
add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
&stop_on_solib_events, _("\
Set stopping for shared library events."), _("\
notifies gdb of shared library events. The most common event of interest\n\
to the user would be loading/unloading of a new library."),
NULL,
- NULL, /* FIXME: i18n: */
+ show_stop_on_solib_events,
&setlist, &showlist);
-#endif
add_setshow_enum_cmd ("follow-fork-mode", class_run,
follow_fork_mode_kind_names,
The unfollowed process will continue to run.\n\
By default, the debugger will follow the parent process."),
NULL,
- NULL, /* FIXME: i18n: */
+ show_follow_fork_mode_string,
&setlist, &showlist);
add_setshow_enum_cmd ("scheduler-locking", class_run,
In this mode, no other thread may run during a step command.\n\
Other threads may run while stepping over a function call ('next')."),
set_schedlock_func, /* traps on target vector */
- NULL, /* FIXME: i18n: */
+ show_scheduler_mode,
&setlist, &showlist);
add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
will stop at the first instruction of that function. Otherwise, the\n\
function is skipped and the step command stops at a different source line."),
NULL,
- NULL, /* FIXME: i18n: */
+ show_step_stop_if_no_debug,
&setlist, &showlist);
/* ptid initializations */
projects / deliverable / binutils-gdb.git / blobdiff