Subversion Repositories openrisc_me

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

   process.

   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,

   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,

   2008 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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "gdb_string.h"

#include <ctype.h>

#include "symtab.h"

#include "frame.h"

#include "inferior.h"

#include "exceptions.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"

#include "observer.h"

#include "language.h"

#include "solib.h"

#include "main.h"

#include "gdb_assert.h"

#include "mi/mi-common.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 int restore_selected_frame (void *);

static void build_infrun (void);

static int follow_fork (void);

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);

static int prepare_to_proceed (int);

void _initialize_infrun (void);

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;

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. */

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;

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

   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.  */

/* 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

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

   flow is completely sorted out.  */

#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;

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

static struct symbol *step_start_function;

/* Nonzero if we are presently stepping over a breakpoint.

   If we hit a breakpoint or watchpoint, and then continue,

   we need to single step the current thread with breakpoints

   disabled, to avoid hitting the same breakpoint or

   watchpoint again.  And we should step just a single

   thread and keep other threads stopped, so that

   other threads don't miss breakpoints while they are removed.

   So, this variable simultaneously means that we need to single

   step the current thread, keep other threads stopped, and that

   breakpoints should be removed while we step.

   This variable is set either:

   - in proceed, when we resume inferior on user's explicit request

   - in keep_going, if handle_inferior_event decides we need to

   step over breakpoint.

   The variable is cleared in clear_proceed_status, called every

   time before we call proceed.  The proceed calls wait_for_inferior,

   which calls handle_inferior_event in a loop, and until

   wait_for_inferior exits, this variable is changed only by keep_going.  */

static int stepping_over_breakpoint;

/* 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;

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.  */

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?).  */

enum stop_kind stop_soon;

/* 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 after stop if current stack frame should be printed.  */

static int stop_print_frame;

static struct breakpoint *step_resume_breakpoint = NULL;

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

   returned by target_wait()/deprecated_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 child_pid;

  }

  fork_event;

  char *execd_pathname;

}

pending_follow;

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_child,

  follow_fork_mode_parent,

  NULL

};

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);

}

static int

follow_fork (void)

{

  int follow_child = (follow_fork_mode_string == follow_fork_mode_child);

  return target_follow_fork (follow_child);

}

void

follow_inferior_reset_breakpoints (void)

{

  /* 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)

    breakpoint_re_set_thread (step_resume_breakpoint);

  /* Reinsert all breakpoints in the child.  The user may have set

     breakpoints after catching the fork, in which case those

     were never set in the child, but only in the parent.  This makes

     sure the inserted breakpoints match the breakpoint list.  */

  breakpoint_re_set ();

  insert_breakpoints ();

}

/* 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;

  /* 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;

  /* 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. */

  gdb_flush (gdb_stdout);

  generic_mourn_inferior ();

  /* Because mourn_inferior resets inferior_ptid. */

  inferior_ptid = pid_to_ptid (saved_pid);

  if (gdb_sysroot && *gdb_sysroot)

    {

      char *name = alloca (strlen (gdb_sysroot)

                            + strlen (execd_pathname)

                            + 1);

      strcpy (name, gdb_sysroot);

      strcat (name, execd_pathname);

      execd_pathname = name;

    }

  /* 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. */

  no_shared_libraries (NULL, 0);

#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

     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;

/* The thread we inserted single-step breakpoints for.  */

static ptid_t singlestep_ptid;

/* PC when we started this single-step.  */

static CORE_ADDR singlestep_pc;

/* If another thread hit the singlestep breakpoint, we save the original

   thread here so that we can resume single-stepping it later.  */

static ptid_t saved_singlestep_ptid;

static int stepping_past_singlestep_breakpoint;

/* If not equal to null_ptid, this means that after stepping over breakpoint

   is finished, we need to switch to deferred_step_ptid, and step it.

   The use case is when one thread has hit a breakpoint, and then the user

   has switched to another thread and issued 'step'. We need to step over

   breakpoint in the thread which hit the breakpoint, but then continue

   stepping the thread user has selected.  */

static ptid_t deferred_step_ptid;

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

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_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)

{

  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;

  if (debug_infrun)

    fprintf_unfiltered (gdb_stdlog, "infrun: resume (step=%d, signal=%d)\n",

                        step, sig);

  /* 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)

    remove_hw_watchpoints ();

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

     removed or inserted, as appropriate.  The exception is if we're sitting

     at a permanent breakpoint; we need to step over it, but permanent

     breakpoints can't be removed.  So we have to test for it here.  */

  if (breakpoint_here_p (read_pc ()) == permanent_breakpoint_here)

    {

      if (gdbarch_skip_permanent_breakpoint_p (current_gdbarch))

        gdbarch_skip_permanent_breakpoint (current_gdbarch,

                                           get_current_regcache ());

      else

        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."));

    }

  if (step && gdbarch_software_single_step_p (current_gdbarch))

    {

      /* Do it the hard way, w/temp breakpoints */

      if (gdbarch_software_single_step (current_gdbarch, get_current_frame ()))

        {

          /* ...and don't ask hardware to do it.  */

          step = 0;

          /* and do not pull these breakpoints until after a `wait' in

          `wait_for_inferior' */

          singlestep_breakpoints_inserted_p = 1;

          singlestep_ptid = inferior_ptid;

          singlestep_pc = read_pc ();

        }

    }

  /* If there were any forks/vforks/execs that were caught and are

     now to be followed, then do so.  */

  switch (pending_follow.kind)

    {

    case TARGET_WAITKIND_FORKED:

    case TARGET_WAITKIND_VFORKED:

      pending_follow.kind = TARGET_WAITKIND_SPURIOUS;

      if (follow_fork ())

        should_resume = 0;

      break;

    case TARGET_WAITKIND_EXECD:

      /* follow_exec is called as soon as the exec event is seen. */

      pending_follow.kind = TARGET_WAITKIND_SPURIOUS;

      break;

    default:

      break;

    }

  /* Install inferior's terminal modes.  */

  target_terminal_inferior ();

  if (should_resume)

    {

      ptid_t resume_ptid;

      resume_ptid = RESUME_ALL; /* Default */

      /* If STEP is set, it's a request to use hardware stepping

         facilities.  But in that case, we should never

         use singlestep breakpoint.  */

      gdb_assert (!(singlestep_breakpoints_inserted_p && step));

      if (singlestep_breakpoints_inserted_p

          && stepping_past_singlestep_breakpoint)

        {

          /* The situation here is as follows.  In thread T1 we wanted to

             single-step.  Lacking hardware single-stepping we've

             set breakpoint at the PC of the next instruction -- call it

             P.  After resuming, we've hit that breakpoint in thread T2.

             Now we've removed original breakpoint, inserted breakpoint

             at P+1, and try to step to advance T2 past breakpoint.

             We need to step only T2, as if T1 is allowed to freely run,

             it can run past P, and if other threads are allowed to run,

             they can hit breakpoint at P+1, and nested hits of single-step

             breakpoints is not something we'd want -- that's complicated

             to support, and has no value.  */

          resume_ptid = inferior_ptid;

        }

      if ((step || singlestep_breakpoints_inserted_p)

          && breakpoint_here_p (read_pc ())

          && !breakpoint_inserted_here_p (read_pc ()))

        {

          /* We're stepping, have breakpoint at PC, and it's

             not inserted.  Most likely, proceed has noticed that

             we have breakpoint and tries to single-step over it,

             so that it's not hit.  In which case, we need to

             single-step only this thread, and keep others stopped,

             as they can miss this breakpoint if allowed to run.

             The current code either has all breakpoints inserted,

             or all removed, so if we let other threads run,

             we can actually miss any breakpoint, not the one at PC.  */

          resume_ptid = inferior_ptid;

        }

      if ((scheduler_mode == schedlock_on)

          || (scheduler_mode == schedlock_step

              && (step || singlestep_breakpoints_inserted_p)))

        {

          /* User-settable 'scheduler' mode requires solo thread resume. */

          resume_ptid = inferior_ptid;

        }

      if (gdbarch_cannot_step_breakpoint (current_gdbarch))

        {

          /* Most targets can step a breakpoint instruction, thus

             executing it normally.  But if this one cannot, just

             continue and we will hit it anyway.  */

          if (step && breakpoint_inserted_here_p (read_pc ()))

            step = 0;

        }

      target_resume (resume_ptid, step, sig);

    }

  discard_cleanups (old_cleanups);

}

/* Clear out all variables saying what to do when inferior is continued.

   First do this, then set the ones you want, then call `proceed'.  */

void

clear_proceed_status (void)

{

  stepping_over_breakpoint = 0;

  step_range_start = 0;

  step_range_end = 0;

  step_frame_id = null_frame_id;

  step_over_calls = STEP_OVER_UNDEBUGGABLE;

  stop_after_trap = 0;

  stop_soon = NO_STOP_QUIETLY;

  proceed_to_finish = 0;

  breakpoint_proceeded = 1;     /* We're about to proceed... */

  if (stop_registers)

    {

      regcache_xfree (stop_registers);

      stop_registers = NULL;

    }

  /* Discard any remaining commands or status from previous stop.  */

  bpstat_clear (&stop_bpstat);

}

/* This should be suitable for any targets that support threads. */

static int

prepare_to_proceed (int step)

{

  ptid_t wait_ptid;

  struct target_waitstatus wait_status;

  /* Get the last target status returned by target_wait().  */

  get_last_target_status (&wait_ptid, &wait_status);

  /* Make sure we were stopped at a breakpoint.  */

  if (wait_status.kind != TARGET_WAITKIND_STOPPED

      || wait_status.value.sig != TARGET_SIGNAL_TRAP)

    {

      return 0;

    }

  /* Switched over from WAIT_PID.  */

  if (!ptid_equal (wait_ptid, minus_one_ptid)

      && !ptid_equal (inferior_ptid, wait_ptid)

      && breakpoint_here_p (read_pc_pid (wait_ptid)))

    {

      /* If stepping, remember current thread to switch back to.  */

      if (step)

        {

          deferred_step_ptid = inferior_ptid;

        }

      /* Switch back to WAIT_PID thread.  */

      switch_to_thread (wait_ptid);

      /* We return 1 to indicate that there is a breakpoint here,

         so we need to step over it before continuing to avoid

         hitting it straight away. */

      return 1;

    }

  return 0;

}

/* Record the pc of the program the last time it stopped.  This is

   just used internally by wait_for_inferior, but need to be preserved

   over calls to it and cleared when the inferior is started.  */

static CORE_ADDR prev_pc;

/* Basic routine for continuing the program in various fashions.

   ADDR is the address to resume at, or -1 for resume where stopped.

   SIGGNAL is the signal to give it, or 0 for none,

   or -1 for act according to how it stopped.

   STEP is nonzero if should trap after one instruction.

   -1 means return after that and print nothing.

   You should probably set various step_... variables

   before calling here, if you are stepping.

   You should call clear_proceed_status before calling proceed.  */

void

proceed (CORE_ADDR addr, enum target_signal siggnal, int step)

{

  int oneproc = 0;

  if (step > 0)

    step_start_function = find_pc_function (read_pc ());

  if (step < 0)

    stop_after_trap = 1;

  if (addr == (CORE_ADDR) -1)

    {

      if (read_pc () == stop_pc && breakpoint_here_p (read_pc ()))

        /* There is a breakpoint at the address we will resume at,

           step one instruction before inserting breakpoints so that

           we do not stop right away (and report a second hit at this

           breakpoint).  */

        oneproc = 1;

      else if (gdbarch_single_step_through_delay_p (current_gdbarch)

              && gdbarch_single_step_through_delay (current_gdbarch,

                                                    get_current_frame ()))

        /* We stepped onto an instruction that needs to be stepped

           again before re-inserting the breakpoint, do so.  */

        oneproc = 1;

    }

  else

    {

      write_pc (addr);