2007-06-25  Jan Kratochvil  <jan.kratochvil@redhat.com>

	* inferior.h (enum resume_step): New definition.

	(resume): Change STEP parameter type to ENUM RESUME_STEP.

	* infrun.c (resume): Likewise.  Extend debug printing of the STEP

	parameter.  Lock the scheduler only for intentional stepping.

	(proceed): Replace the variable ONESTEP with tristate RESUME_STEP.

	Set the third RESUME_STEP state according to BPSTAT_SHOULD_STEP.

	(currently_stepping): Change the return type to ENUM RESUME_STEP.

	Return RESUME_STEP_NEEDED if it is just due to BPSTAT_SHOULD_STEP.

	* linux-nat.c (select_singlestep_lwp_callback): Do not focus on

	the software watchpoint events.

	* linux-nat.h (struct lwp_info): Redeclare STEP as ENUM RESUME_STEP.

2007-10-19  Jan Kratochvil  <jan.kratochvil@redhat.com>

	* infrun.c (proceed): RESUME_STEP initialized for non-stepping.

	RESUME_STEP set according to STEP only at the end of the function.

2008-02-24  Jan Kratochvil  <jan.kratochvil@redhat.com>

	Port to GDB-6.8pre.

Index: gdb-7.5.50.20130215/gdb/inferior.h

===================================================================

--- gdb-7.5.50.20130215.orig/gdb/inferior.h	2013-01-16 18:31:38.000000000 +0100

+++ gdb-7.5.50.20130215/gdb/inferior.h	2013-02-15 22:31:42.993944957 +0100

@@ -160,7 +160,15 @@ extern void reopen_exec_file (void);

 /* The `resume' routine should only be called in special circumstances.

    Normally, use `proceed', which handles a lot of bookkeeping.  */

-extern void resume (int, enum gdb_signal);

+enum resume_step

+  {

+    /* currently_stepping () should return non-zero for non-continue.  */

+    RESUME_STEP_CONTINUE = 0,

+    RESUME_STEP_USER,		/* Stepping is intentional by the user.  */

+    RESUME_STEP_NEEDED		/* Stepping only for software watchpoints.  */

+  };

+

+extern void resume (enum resume_step, enum gdb_signal);

 extern ptid_t user_visible_resume_ptid (int step);

Index: gdb-7.5.50.20130215/gdb/infrun.c

===================================================================

--- gdb-7.5.50.20130215.orig/gdb/infrun.c	2013-01-31 20:18:58.000000000 +0100

+++ gdb-7.5.50.20130215/gdb/infrun.c	2013-02-15 22:34:07.132144519 +0100

@@ -81,7 +81,7 @@ static int follow_fork (void);

 static void set_schedlock_func (char *args, int from_tty,

 				struct cmd_list_element *c);

-static int currently_stepping (struct thread_info *tp);

+static enum resume_step currently_stepping (struct thread_info *tp);

 static int currently_stepping_or_nexting_callback (struct thread_info *tp,

 						   void *data);

@@ -1709,7 +1709,8 @@ user_visible_resume_ptid (int step)

     }

   else if ((scheduler_mode == schedlock_on)

 	   || (scheduler_mode == schedlock_step

-	       && (step || singlestep_breakpoints_inserted_p)))

+	       && (step == RESUME_STEP_USER

+		   || singlestep_breakpoints_inserted_p)))

     {

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

       resume_ptid = inferior_ptid;

@@ -1727,7 +1728,7 @@ user_visible_resume_ptid (int step)

    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 gdb_signal sig)

+resume (enum resume_step step, enum gdb_signal sig)

 {

   int should_resume = 1;

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

@@ -1760,9 +1761,13 @@ resume (int step, enum gdb_signal sig)

   if (debug_infrun)

     fprintf_unfiltered (gdb_stdlog,

-                        "infrun: resume (step=%d, signal=%d), "

+                        "infrun: resume (step=%s, signal=%d), "

 			"trap_expected=%d, current thread [%s] at %s\n",

- 			step, sig, tp->control.trap_expected,

+			(step == RESUME_STEP_CONTINUE

+			 ? "RESUME_STEP_CONTINUE"

+			 : (step == RESUME_STEP_USER ? "RESUME_STEP_USER"

+						     : "RESUME_STEP_NEEDED")),

+ 			sig, tp->control.trap_expected,

 			target_pid_to_str (inferior_ptid),

 			paddress (gdbarch, pc));

@@ -2140,7 +2145,7 @@ proceed (CORE_ADDR addr, enum gdb_signal

   CORE_ADDR pc;

   struct address_space *aspace;

   /* GDB may force the inferior to step due to various reasons.  */

-  int force_step = 0;

+  enum resume_step resume_step = RESUME_STEP_CONTINUE;

   /* If we're stopped at a fork/vfork, follow the branch set by the

      "set follow-fork-mode" command; otherwise, we'll just proceed

@@ -2180,13 +2185,13 @@ proceed (CORE_ADDR addr, enum gdb_signal

 	   actually be executing the breakpoint insn anyway.

 	   We'll be (un-)executing the previous instruction.  */

-	force_step = 1;

+	resume_step = RESUME_STEP_USER;

       else if (gdbarch_single_step_through_delay_p (gdbarch)

 	       && gdbarch_single_step_through_delay (gdbarch,

 						     get_current_frame ()))

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

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

-	force_step = 1;

+	resume_step = RESUME_STEP_USER;

     }

   else

     {

@@ -2217,13 +2222,13 @@ proceed (CORE_ADDR addr, enum gdb_signal

 	 is required it returns TRUE and sets the current thread to

 	 the old thread.  */

       if (prepare_to_proceed (step))

-	force_step = 1;

+	resume_step = RESUME_STEP_USER;

     }

   /* prepare_to_proceed may change the current thread.  */

   tp = inferior_thread ();

-  if (force_step)

+  if (resume_step == RESUME_STEP_USER)

     {

       tp->control.trap_expected = 1;

       /* If displaced stepping is enabled, we can step over the

@@ -2310,9 +2315,13 @@ proceed (CORE_ADDR addr, enum gdb_signal

   /* Reset to normal state.  */

   init_infwait_state ();

+  if (step)

+    resume_step = RESUME_STEP_USER;

+  if (resume_step == RESUME_STEP_CONTINUE && bpstat_should_step ())

+    resume_step = RESUME_STEP_NEEDED;

+

   /* Resume inferior.  */

-  resume (force_step || step || bpstat_should_step (),

-	  tp->suspend.stop_signal);

+  resume (resume_step, tp->suspend.stop_signal);

   /* Wait for it to stop (if not standalone)

      and in any case decode why it stopped, and act accordingly.  */

@@ -5247,13 +5256,18 @@ process_event_stop_test:

 /* Is thread TP in the middle of single-stepping?  */

-static int

+static enum resume_step

 currently_stepping (struct thread_info *tp)

 {

-  return ((tp->control.step_range_end

-	   && tp->control.step_resume_breakpoint == NULL)

-	  || tp->control.trap_expected

-	  || bpstat_should_step ());

+  if ((tp->control.step_range_end

+       && tp->control.step_resume_breakpoint == NULL)

+      || tp->control.trap_expected)

+    return RESUME_STEP_USER;

+

+  if (bpstat_should_step ())

+    return RESUME_STEP_NEEDED;

+

+  return RESUME_STEP_CONTINUE;

 }

 /* Returns true if any thread *but* the one passed in "data" is in the

Index: gdb-7.5.50.20130215/gdb/linux-nat.c

===================================================================

--- gdb-7.5.50.20130215.orig/gdb/linux-nat.c	2013-02-13 15:59:49.000000000 +0100

+++ gdb-7.5.50.20130215/gdb/linux-nat.c	2013-02-15 22:31:42.997944967 +0100

@@ -2971,7 +2971,11 @@ static int

 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)

 {

   if (lp->last_resume_kind == resume_step

-      && lp->status != 0)

+      && lp->status != 0

+      /* We do not focus on software watchpoints as we would not catch

+	 STEPPING_PAST_SINGLESTEP_BREAKPOINT breakpoints in some other thread

+	 as they would remain pending due to `Push back breakpoint for %s'.  */

+      && lp->step == RESUME_STEP_USER)

     return 1;

   else

     return 0;

Index: gdb-7.5.50.20130215/gdb/linux-nat.h

===================================================================

--- gdb-7.5.50.20130215.orig/gdb/linux-nat.h	2013-02-13 15:59:49.000000000 +0100

+++ gdb-7.5.50.20130215/gdb/linux-nat.h	2013-02-15 22:31:42.998944969 +0100

@@ -73,8 +73,8 @@ struct lwp_info

   /* If non-zero, a pending wait status.  */

   int status;

-  /* Non-zero if we were stepping this LWP.  */

-  int step;

+  /* The kind of stepping of this LWP.  */

+  enum resume_step step;

   /* STOPPED_BY_WATCHPOINT is non-zero if this LWP stopped with a data

      watchpoint trap.  */