Subversion Repositories or1k

/* Target-struct-independent code to start (run) and stop an inferior

   process.

   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,

   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software

   Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

#include "defs.h"

#include "gdb_string.h"

#include <ctype.h>

#include "symtab.h"

#include "frame.h"

#include "inferior.h"

#include "breakpoint.h"

#include "gdb_wait.h"

#include "gdbcore.h"

#include "gdbcmd.h"

#include "cli/cli-script.h"

#include "target.h"

#include "gdbthread.h"

#include "annotate.h"

#include "symfile.h"

#include "top.h"

#include <signal.h>

#include "inf-loop.h"

#include "regcache.h"

#include "value.h"

/* Prototypes for local functions */

static void signals_info (char *, int);

static void handle_command (char *, int);

static void sig_print_info (enum target_signal);

static void sig_print_header (void);

static void resume_cleanups (void *);

static int hook_stop_stub (void *);

static void delete_breakpoint_current_contents (void *);

static void set_follow_fork_mode_command (char *arg, int from_tty,

                                          struct cmd_list_element *c);

static int restore_selected_frame (void *);

static void build_infrun (void);

static void follow_inferior_fork (int parent_pid, int child_pid,

                                  int has_forked, int has_vforked);

static void follow_fork (int parent_pid, int child_pid);

static void follow_vfork (int parent_pid, int child_pid);

static void set_schedlock_func (char *args, int from_tty,

                                struct cmd_list_element *c);

struct execution_control_state;

static int currently_stepping (struct execution_control_state *ecs);

static void xdb_handle_command (char *args, int from_tty);

void _initialize_infrun (void);

int inferior_ignoring_startup_exec_events = 0;

int inferior_ignoring_leading_exec_events = 0;

/* When set, stop the 'step' command if we enter a function which has

   no line number information.  The normal behavior is that we step

   over such function.  */

int step_stop_if_no_debug = 0;

/* In asynchronous mode, but simulating synchronous execution. */

int sync_execution = 0;

/* wait_for_inferior and normal_stop use this to notify the user

   when the inferior stopped in a different thread than it had been

   running in.  */

static ptid_t previous_inferior_ptid;

/* This is true for configurations that may follow through execl() and

   similar functions.  At present this is only true for HP-UX native.  */

#ifndef MAY_FOLLOW_EXEC

#define MAY_FOLLOW_EXEC (0)

#endif

static int may_follow_exec = MAY_FOLLOW_EXEC;

/* Dynamic function trampolines are similar to solib trampolines in that they

   are between the caller and the callee.  The difference is that when you

   enter a dynamic trampoline, you can't determine the callee's address.  Some

   (usually complex) code needs to run in the dynamic trampoline to figure out

   the callee's address.  This macro is usually called twice.  First, when we

   enter the trampoline (looks like a normal function call at that point).  It

   should return the PC of a point within the trampoline where the callee's

   address is known.  Second, when we hit the breakpoint, this routine returns

   the callee's address.  At that point, things proceed as per a step resume

   breakpoint.  */

#ifndef DYNAMIC_TRAMPOLINE_NEXTPC

#define DYNAMIC_TRAMPOLINE_NEXTPC(pc) 0

#endif

/* If the program uses ELF-style shared libraries, then calls to

   functions in shared libraries go through stubs, which live in a

   table called the PLT (Procedure Linkage Table).  The first time the

   function is called, the stub sends control to the dynamic linker,

   which looks up the function's real address, patches the stub so

   that future calls will go directly to the function, and then passes

   control to the function.

   If we are stepping at the source level, we don't want to see any of

   this --- we just want to skip over the stub and the dynamic linker.

   The simple approach is to single-step until control leaves the

   dynamic linker.

   However, on some systems (e.g., Red Hat's 5.2 distribution) the

   dynamic linker calls functions in the shared C library, so you

   can't tell from the PC alone whether the dynamic linker is still

   running.  In this case, we use a step-resume breakpoint to get us

   past the dynamic linker, as if we were using "next" to step over a

   function call.

   IN_SOLIB_DYNSYM_RESOLVE_CODE says whether we're in the dynamic

   linker code or not.  Normally, this means we single-step.  However,

   if SKIP_SOLIB_RESOLVER then returns non-zero, then its value is an

   address where we can place a step-resume breakpoint to get past the

   linker's symbol resolution function.

   IN_SOLIB_DYNSYM_RESOLVE_CODE can generally be implemented in a

   pretty portable way, by comparing the PC against the address ranges

   of the dynamic linker's sections.

   SKIP_SOLIB_RESOLVER is generally going to be system-specific, since

   it depends on internal details of the dynamic linker.  It's usually

   not too hard to figure out where to put a breakpoint, but it

   certainly isn't portable.  SKIP_SOLIB_RESOLVER should do plenty of

   sanity checking.  If it can't figure things out, returning zero and

   getting the (possibly confusing) stepping behavior is better than

   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

#ifndef SKIP_SOLIB_RESOLVER

#define SKIP_SOLIB_RESOLVER(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).

   This function must be used only when a dynamic linker event has

   been caught, and the inferior is being stepped out of the hook, or

   undefined results are guaranteed.  */

#ifndef SOLIB_IN_DYNAMIC_LINKER

#define SOLIB_IN_DYNAMIC_LINKER(pid,pc) 0

#endif

/* On MIPS16, a function that returns a floating point value may call

   a library helper function to copy the return value to a floating point

   register.  The IGNORE_HELPER_CALL macro returns non-zero if we

   should ignore (i.e. step over) this function call.  */

#ifndef IGNORE_HELPER_CALL

#define IGNORE_HELPER_CALL(pc)  0

#endif

/* On some systems, the PC may be left pointing at an instruction that  won't

   actually be executed.  This is usually indicated by a bit in the PSW.  If

   we find ourselves in such a state, then we step the target beyond the

   nullified instruction before returning control to the user so as to avoid

   confusion. */

#ifndef INSTRUCTION_NULLIFIED

#define INSTRUCTION_NULLIFIED 0

#endif

/* We can't step off a permanent breakpoint in the ordinary way, because we

   can't remove it.  Instead, we have to advance the PC to the next

   instruction.  This macro should expand to a pointer to a function that

   does that, or zero if we have no such function.  If we don't have a

   definition for it, we have to report an error.  */

#ifndef SKIP_PERMANENT_BREAKPOINT

#define SKIP_PERMANENT_BREAKPOINT (default_skip_permanent_breakpoint)

static void

default_skip_permanent_breakpoint (void)

{

  error ("\

The program is stopped at a permanent breakpoint, but GDB does not know\n\

how to step past a permanent breakpoint on this architecture.  Try using\n\

a command like `return' or `jump' to continue execution.");

}

#endif

/* Convert the #defines into values.  This is temporary until wfi control

   flow is completely sorted out.  */

#ifndef HAVE_STEPPABLE_WATCHPOINT

#define HAVE_STEPPABLE_WATCHPOINT 0

#else

#undef  HAVE_STEPPABLE_WATCHPOINT

#define HAVE_STEPPABLE_WATCHPOINT 1

#endif

#ifndef HAVE_NONSTEPPABLE_WATCHPOINT

#define HAVE_NONSTEPPABLE_WATCHPOINT 0

#else

#undef  HAVE_NONSTEPPABLE_WATCHPOINT

#define HAVE_NONSTEPPABLE_WATCHPOINT 1

#endif

#ifndef HAVE_CONTINUABLE_WATCHPOINT

#define HAVE_CONTINUABLE_WATCHPOINT 0

#else

#undef  HAVE_CONTINUABLE_WATCHPOINT

#define HAVE_CONTINUABLE_WATCHPOINT 1

#endif

#ifndef CANNOT_STEP_HW_WATCHPOINTS

#define CANNOT_STEP_HW_WATCHPOINTS 0

#else

#undef  CANNOT_STEP_HW_WATCHPOINTS

#define CANNOT_STEP_HW_WATCHPOINTS 1

#endif

/* Tables of how to react to signals; the user sets them.  */

static unsigned char *signal_stop;

static unsigned char *signal_print;

static unsigned char *signal_program;

#define SET_SIGS(nsigs,sigs,flags) \

  do { \

    int signum = (nsigs); \

    while (signum-- > 0) \

      if ((sigs)[signum]) \

        (flags)[signum] = 1; \

  } while (0)

#define UNSET_SIGS(nsigs,sigs,flags) \

  do { \

    int signum = (nsigs); \

    while (signum-- > 0) \

      if ((sigs)[signum]) \

        (flags)[signum] = 0; \

  } while (0)

/* Value to pass to target_resume() to cause all threads to resume */

#define RESUME_ALL (pid_to_ptid (-1))

/* Command list pointer for the "stop" placeholder.  */

static struct cmd_list_element *stop_command;

/* Nonzero if breakpoints are now inserted in the inferior.  */

static int breakpoints_inserted;

/* Function inferior was in as of last step command.  */

static struct symbol *step_start_function;

/* Nonzero if we are expecting a trace trap and should proceed from it.  */

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

#ifdef HP_OS_BUG

/* Nonzero if the next time we try to continue the inferior, it will

   step one instruction and generate a spurious trace trap.

   This is used to compensate for a bug in HP-UX.  */

static int trap_expected_after_continue;

#endif

/* Nonzero means expecting a trace trap

   and should stop the inferior and return silently when it happens.  */

int stop_after_trap;

/* Nonzero means expecting a trap and caller will handle it themselves.

   It is used after attach, due to attaching to a process;

   when running in the shell before the child program has been exec'd;

   and when running some kinds of remote stuff (FIXME?).  */

int stop_soon_quietly;

/* Nonzero if proceed is being used for a "finish" command or a similar

   situation when stop_registers should be saved.  */

int proceed_to_finish;

/* Save register contents here when about to pop a stack dummy frame,

   if-and-only-if proceed_to_finish is set.

   Thus this contains the return value from the called function (assuming

   values are returned in a register).  */

struct regcache *stop_registers;

/* Nonzero if program stopped due to error trying to insert breakpoints.  */

static int breakpoints_failed;

/* Nonzero after stop if current stack frame should be printed.  */

static int stop_print_frame;

static struct breakpoint *step_resume_breakpoint = NULL;

static struct breakpoint *through_sigtramp_breakpoint = NULL;

/* On some platforms (e.g., HP-UX), hardware watchpoints have bad

   interactions with an inferior that is running a kernel function

   (aka, a system call or "syscall").  wait_for_inferior therefore

   may have a need to know when the inferior is in a syscall.  This

   is a count of the number of inferior threads which are known to

   currently be running in a syscall. */

static int number_of_threads_in_syscalls;

/* This is a cached copy of the pid/waitstatus of the last event

   returned by target_wait()/target_wait_hook().  This information is

   returned by get_last_target_status(). */

static ptid_t target_last_wait_ptid;

static struct target_waitstatus target_last_waitstatus;

/* This is used to remember when a fork, vfork or exec event

   was caught by a catchpoint, and thus the event is to be

   followed at the next resume of the inferior, and not

   immediately. */

static struct

{

  enum target_waitkind kind;

  struct

  {

    int parent_pid;

    int saw_parent_fork;

    int child_pid;

    int saw_child_fork;

    int saw_child_exec;

  }

  fork_event;

  char *execd_pathname;

}

pending_follow;

/* Some platforms don't allow us to do anything meaningful with a

   vforked child until it has exec'd.  Vforked processes on such

   platforms can only be followed after they've exec'd.

   When this is set to 0, a vfork can be immediately followed,

   and an exec can be followed merely as an exec.  When this is

   set to 1, a vfork event has been seen, but cannot be followed

   until the exec is seen.

   (In the latter case, inferior_ptid is still the parent of the

   vfork, and pending_follow.fork_event.child_pid is the child.  The

   appropriate process is followed, according to the setting of

   follow-fork-mode.) */

static int follow_vfork_when_exec;

static const char follow_fork_mode_ask[] = "ask";

static const char follow_fork_mode_both[] = "both";

static const char follow_fork_mode_child[] = "child";

static const char follow_fork_mode_parent[] = "parent";

static const char *follow_fork_mode_kind_names[] = {

  follow_fork_mode_ask,

  /* ??rehrauer: The "both" option is broken, by what may be a 10.20

     kernel problem.  It's also not terribly useful without a GUI to

     help the user drive two debuggers.  So for now, I'm disabling the

     "both" option. */

  /* follow_fork_mode_both, */

  follow_fork_mode_child,

  follow_fork_mode_parent,

  NULL

};

static const char *follow_fork_mode_string = follow_fork_mode_parent;

static void

follow_inferior_fork (int parent_pid, int child_pid, int has_forked,

                      int has_vforked)

{

  int followed_parent = 0;

  int followed_child = 0;

  /* Which process did the user want us to follow? */

  const char *follow_mode = follow_fork_mode_string;

  /* Or, did the user not know, and want us to ask? */

  if (follow_fork_mode_string == follow_fork_mode_ask)

    {

      internal_error (__FILE__, __LINE__,

                      "follow_inferior_fork: \"ask\" mode not implemented");

      /* follow_mode = follow_fork_mode_...; */

    }

  /* If we're to be following the parent, then detach from child_pid.

     We're already following the parent, so need do nothing explicit

     for it. */

  if (follow_mode == follow_fork_mode_parent)

    {

      followed_parent = 1;

      /* We're already attached to the parent, by default. */

      /* Before detaching from the child, remove all breakpoints from

         it.  (This won't actually modify the breakpoint list, but will

         physically remove the breakpoints from the child.) */

      if (!has_vforked || !follow_vfork_when_exec)

        {

          detach_breakpoints (child_pid);

#ifdef SOLIB_REMOVE_INFERIOR_HOOK

          SOLIB_REMOVE_INFERIOR_HOOK (child_pid);

#endif

        }

      /* Detach from the child. */

      dont_repeat ();

      target_require_detach (child_pid, "", 1);

    }

  /* If we're to be following the child, then attach to it, detach

     from inferior_ptid, and set inferior_ptid to child_pid. */

  else if (follow_mode == follow_fork_mode_child)

    {

      char child_pid_spelling[100];     /* Arbitrary length. */

      followed_child = 1;

      /* Before detaching from the parent, detach all breakpoints from

         the child.  But only if we're forking, or if we follow vforks

         as soon as they happen.  (If we're following vforks only when

         the child has exec'd, then it's very wrong to try to write

         back the "shadow contents" of inserted breakpoints now -- they

         belong to the child's pre-exec'd a.out.) */

      if (!has_vforked || !follow_vfork_when_exec)

        {

          detach_breakpoints (child_pid);

        }

      /* Before detaching from the parent, remove all breakpoints from it. */

      remove_breakpoints ();

      /* Also reset the solib inferior hook from the parent. */

#ifdef SOLIB_REMOVE_INFERIOR_HOOK

      SOLIB_REMOVE_INFERIOR_HOOK (PIDGET (inferior_ptid));

#endif

      /* Detach from the parent. */

      dont_repeat ();

      target_detach (NULL, 1);

      /* Attach to the child. */

      inferior_ptid = pid_to_ptid (child_pid);

      sprintf (child_pid_spelling, "%d", child_pid);

      dont_repeat ();

      target_require_attach (child_pid_spelling, 1);

      /* Was there a step_resume breakpoint?  (There was if the user

         did a "next" at the fork() call.)  If so, explicitly reset its

         thread number.

         step_resumes are a form of bp that are made to be per-thread.

         Since we created the step_resume bp when the parent process

         was being debugged, and now are switching to the child process,

         from the breakpoint package's viewpoint, that's a switch of

         "threads".  We must update the bp's notion of which thread

         it is for, or it'll be ignored when it triggers... */

      if (step_resume_breakpoint && (!has_vforked || !follow_vfork_when_exec))

        breakpoint_re_set_thread (step_resume_breakpoint);

      /* Reinsert all breakpoints in the child.  (The user may've set

         breakpoints after catching the fork, in which case those

         actually didn't get set in the child, but only in the parent.) */

      if (!has_vforked || !follow_vfork_when_exec)

        {

          breakpoint_re_set ();

          insert_breakpoints ();

        }

    }

  /* If we're to be following both parent and child, then fork ourselves,

     and attach the debugger clone to the child. */

  else if (follow_mode == follow_fork_mode_both)

    {

      char pid_suffix[100];     /* Arbitrary length. */

      /* Clone ourselves to follow the child.  This is the end of our

         involvement with child_pid; our clone will take it from here... */

      dont_repeat ();

      target_clone_and_follow_inferior (child_pid, &followed_child);

      followed_parent = !followed_child;

      /* We continue to follow the parent.  To help distinguish the two

         debuggers, though, both we and our clone will reset our prompts. */

      sprintf (pid_suffix, "[%d] ", PIDGET (inferior_ptid));

      set_prompt (strcat (get_prompt (), pid_suffix));

    }

  /* The parent and child of a vfork share the same address space.

     Also, on some targets the order in which vfork and exec events

     are received for parent in child requires some delicate handling

     of the events.

     For instance, on ptrace-based HPUX we receive the child's vfork

     event first, at which time the parent has been suspended by the

     OS and is essentially untouchable until the child's exit or second

     exec event arrives.  At that time, the parent's vfork event is

     delivered to us, and that's when we see and decide how to follow

     the vfork.  But to get to that point, we must continue the child

     until it execs or exits.  To do that smoothly, all breakpoints

     must be removed from the child, in case there are any set between

     the vfork() and exec() calls.  But removing them from the child

     also removes them from the parent, due to the shared-address-space

     nature of a vfork'd parent and child.  On HPUX, therefore, we must

     take care to restore the bp's to the parent before we continue it.

     Else, it's likely that we may not stop in the expected place.  (The

     worst scenario is when the user tries to step over a vfork() call;

     the step-resume bp must be restored for the step to properly stop

     in the parent after the call completes!)

     Sequence of events, as reported to gdb from HPUX:

     Parent        Child           Action for gdb to take

     -------------------------------------------------------

     1                VFORK               Continue child

     2                EXEC

     3                EXEC or EXIT

     4  VFORK */

  if (has_vforked)

    {

      target_post_follow_vfork (parent_pid,

                                followed_parent, child_pid, followed_child);

    }

  pending_follow.fork_event.saw_parent_fork = 0;

  pending_follow.fork_event.saw_child_fork = 0;

}

static void

follow_fork (int parent_pid, int child_pid)

{

  follow_inferior_fork (parent_pid, child_pid, 1, 0);

}

/* Forward declaration. */

static void follow_exec (int, char *);

static void

follow_vfork (int parent_pid, int child_pid)

{

  follow_inferior_fork (parent_pid, child_pid, 0, 1);

  /* Did we follow the child?  Had it exec'd before we saw the parent vfork? */

  if (pending_follow.fork_event.saw_child_exec

      && (PIDGET (inferior_ptid) == child_pid))

    {

      pending_follow.fork_event.saw_child_exec = 0;

      pending_follow.kind = TARGET_WAITKIND_SPURIOUS;

      follow_exec (PIDGET (inferior_ptid), pending_follow.execd_pathname);

      xfree (pending_follow.execd_pathname);

    }

}

/* EXECD_PATHNAME is assumed to be non-NULL. */

static void

follow_exec (int pid, char *execd_pathname)

{

  int saved_pid = pid;

  struct target_ops *tgt;

  if (!may_follow_exec)

    return;

  /* Did this exec() follow a vfork()?  If so, we must follow the

     vfork now too.  Do it before following the exec. */

  if (follow_vfork_when_exec &&

      (pending_follow.kind == TARGET_WAITKIND_VFORKED))

    {

      pending_follow.kind = TARGET_WAITKIND_SPURIOUS;

      follow_vfork (PIDGET (inferior_ptid),

                    pending_follow.fork_event.child_pid);

      follow_vfork_when_exec = 0;

      saved_pid = PIDGET (inferior_ptid);

      /* Did we follow the parent?  If so, we're done.  If we followed

         the child then we must also follow its exec(). */

      if (PIDGET (inferior_ptid) == pending_follow.fork_event.parent_pid)

        return;

    }

  /* This is an exec event that we actually wish to pay attention to.

     Refresh our symbol table to the newly exec'd program, remove any

     momentary bp's, etc.

     If there are breakpoints, they aren't really inserted now,

     since the exec() transformed our inferior into a fresh set

     of instructions.

     We want to preserve symbolic breakpoints on the list, since

     we have hopes that they can be reset after the new a.out's

     symbol table is read.

     However, any "raw" breakpoints must be removed from the list

     (e.g., the solib bp's), since their address is probably invalid

     now.

     And, we DON'T want to call delete_breakpoints() here, since

     that may write the bp's "shadow contents" (the instruction

     value that was overwritten witha TRAP instruction).  Since

     we now have a new a.out, those shadow contents aren't valid. */

  update_breakpoints_after_exec ();

  /* If there was one, it's gone now.  We cannot truly step-to-next

     statement through an exec(). */

  step_resume_breakpoint = NULL;

  step_range_start = 0;

  step_range_end = 0;

  /* If there was one, it's gone now. */

  through_sigtramp_breakpoint = NULL;

  /* What is this a.out's name? */

  printf_unfiltered ("Executing new program: %s\n", execd_pathname);

  /* We've followed the inferior through an exec.  Therefore, the

     inferior has essentially been killed & reborn. */

  /* First collect the run target in effect.  */

  tgt = find_run_target ();

  /* If we can't find one, things are in a very strange state...  */

  if (tgt == NULL)

    error ("Could find run target to save before following exec");

  gdb_flush (gdb_stdout);

  target_mourn_inferior ();

  inferior_ptid = pid_to_ptid (saved_pid);

  /* Because mourn_inferior resets inferior_ptid. */

  push_target (tgt);

  /* That a.out is now the one to use. */

  exec_file_attach (execd_pathname, 0);

  /* And also is where symbols can be found. */

  symbol_file_add_main (execd_pathname, 0);

  /* Reset the shared library package.  This ensures that we get

     a shlib event when the child reaches "_start", at which point

     the dld will have had a chance to initialize the child. */

#if defined(SOLIB_RESTART)

  SOLIB_RESTART ();

#endif

#ifdef SOLIB_CREATE_INFERIOR_HOOK

  SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));

#endif

  /* Reinsert all breakpoints.  (Those which were symbolic have

     been reset to the proper address in the new a.out, thanks

     to symbol_file_command...) */

  insert_breakpoints ();

  /* The next resume of this inferior should bring it to the shlib

     startup breakpoints.  (If the user had also set bp's on

     "main" from the old (parent) process, then they'll auto-

     matically get reset there in the new process.) */

}

/* Non-zero if we just simulating a single-step.  This is needed

   because we cannot remove the breakpoints in the inferior process

   until after the `wait' in `wait_for_inferior'.  */

static int singlestep_breakpoints_inserted_p = 0;

/* Things to clean up if we QUIT out of resume ().  */

/* ARGSUSED */

static void

resume_cleanups (void *ignore)

{

  normal_stop ();

}

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 void

set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c)

{

  /* NOTE: cagney/2002-03-17: The 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.  Unfortunatly, for ``show'' commands cloned from

     ``set'', this includes callbacks belonging to ``set'' commands.

     Making this worse, this only occures if 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);

      }

}

/* Resume the inferior, but allow a QUIT.  This is useful if the user

   wants to interrupt some lengthy single-stepping operation

   (for child processes, the SIGINT goes to the inferior, and so

   we get a SIGINT random_signal, but for remote debugging and perhaps

   other targets, that's not true).

   STEP nonzero if we should step (zero to continue instead).

   SIG is the signal to give the inferior (zero for none).  */

void

resume (int step, enum target_signal sig)

{

  int should_resume = 1;

  struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);

  QUIT;

  /* FIXME: calling breakpoint_here_p (read_pc ()) three times! */

  /* Some targets (e.g. Solaris x86) have a kernel bug when stepping

     over an instruction that causes a page fault without triggering

     a hardware watchpoint. The kernel properly notices that it shouldn't

     stop, because the hardware watchpoint is not triggered, but it forgets

     the step request and continues the program normally.

     Work around the problem by removing hardware watchpoints if a step is

     requested, GDB will check for a hardware watchpoint trigger after the

     step anyway.  */

  if (CANNOT_STEP_HW_WATCHPOINTS && step && breakpoints_inserted)

    remove_hw_watchpoints ();

  /* Normally, by the time we reach `resume', the breakpoints are either