* gdbint.texinfo (POP_FRAME): Document use by return_command.

[deliverable/binutils-gdb.git] / gdb / infrun.c

diff --git a/gdb/infrun.c b/gdb/infrun.c
index a753e5fcab47a5979a9147cfcdfd076163ea9029..e934c9ddca97cd47265a1ec5031727efe7387651 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -84,6 +84,11 @@ 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;
@@ -641,7 +646,7 @@ follow_vfork (int parent_pid, int child_pid)
       pending_follow.fork_event.saw_child_exec = 0;
       pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
       follow_exec (inferior_pid, pending_follow.execd_pathname);
-      free (pending_follow.execd_pathname);
+      xfree (pending_follow.execd_pathname);
     }
 }
 
@@ -940,7 +945,7 @@ clear_proceed_status (void)
   step_range_start = 0;
   step_range_end = 0;
   step_frame_address = 0;
-  step_over_calls = -1;
+  step_over_calls = STEP_OVER_UNDEBUGGABLE;
   stop_after_trap = 0;
   stop_soon_quietly = 0;
   proceed_to_finish = 0;
@@ -1108,7 +1113,7 @@ start_remote (void)
 
   /* Always go on waiting for the target, regardless of the mode. */
   /* FIXME: cagney/1999-09-23: At present it isn't possible to
-     indicate th wait_for_inferior that a target should timeout if
+     indicate to wait_for_inferior that a target should timeout if
      nothing is returned (instead of just blocking).  Because of this,
      targets expecting an immediate response need to, internally, set
      things up so that the target_wait() is forced to eventually
@@ -1710,7 +1715,7 @@ handle_inferior_event (struct execution_control_state *ecs)
        /* This causes the eventpoints and symbol table to be reset.  Must
           do this now, before trying to determine whether to stop. */
        follow_exec (inferior_pid, pending_follow.execd_pathname);
-       free (pending_follow.execd_pathname);
+       xfree (pending_follow.execd_pathname);
 
        stop_pc = read_pc_pid (ecs->pid);
        ecs->saved_inferior_pid = inferior_pid;
@@ -2612,7 +2617,7 @@ handle_inferior_event (struct execution_control_state *ecs)
        loader dynamic symbol resolution code, we keep on single stepping
        until we exit the run time loader code and reach the callee's
        address.  */
-    if (step_over_calls < 0 && IN_SOLIB_DYNSYM_RESOLVE_CODE (stop_pc))
+    if (step_over_calls == STEP_OVER_UNDEBUGGABLE && IN_SOLIB_DYNSYM_RESOLVE_CODE (stop_pc))
       {
        CORE_ADDR pc_after_resolver = SKIP_SOLIB_RESOLVER (stop_pc);
 
@@ -2733,7 +2738,7 @@ handle_inferior_event (struct execution_control_state *ecs)
       {
        /* It's a subroutine call.  */
 
-       if (step_over_calls == 0)
+       if (step_over_calls == STEP_OVER_NONE)
          {
            /* I presume that step_over_calls is only 0 when we're
               supposed to be stepping at the assembly language level
@@ -2744,7 +2749,7 @@ handle_inferior_event (struct execution_control_state *ecs)
            return;
          }
 
-       if (step_over_calls > 0 || IGNORE_HELPER_CALL (stop_pc))
+       if (step_over_calls == STEP_OVER_ALL || IGNORE_HELPER_CALL (stop_pc))
          {
            /* We're doing a "next".  */
 
@@ -2810,6 +2815,18 @@ handle_inferior_event (struct execution_control_state *ecs)
              return;
            }
        }
+
+       /* If we have no line number and the step-stop-if-no-debug
+          is set, we stop the step so that the user has a chance to
+          switch in assembly mode.  */
+       if (step_over_calls == STEP_OVER_UNDEBUGGABLE && step_stop_if_no_debug)
+         {
+           stop_step = 1;
+           print_stop_reason (END_STEPPING_RANGE, 0);
+           stop_stepping (ecs);
+           return;
+         }
+
        step_over_function (ecs);
        keep_going (ecs);
        return;
@@ -3446,9 +3463,9 @@ and/or watchpoints.\n");
 
   /* Look up the hook_stop and run it if it exists.  */
 
-  if (stop_command && stop_command->hook)
+  if (stop_command && stop_command->hook_pre)
     {
-      catch_errors (hook_stop_stub, stop_command->hook,
+      catch_errors (hook_stop_stub, stop_command->hook_pre,
                    "Error while running hook_stop:\n", RETURN_MASK_ALL);
     }
 
@@ -3874,7 +3891,7 @@ xdb_handle_command (char *args, int from_tty)
          else
            printf_filtered ("Invalid signal handling flag.\n");
          if (argBuf)
-           free (argBuf);
+           xfree (argBuf);
        }
     }
   do_cleanups (old_chain);
@@ -3899,7 +3916,7 @@ signals_info (char *signum_exp, int from_tty)
        {
          /* No, try numeric.  */
          oursig =
-           target_signal_from_command (parse_and_eval_address (signum_exp));
+           target_signal_from_command (parse_and_eval_long (signum_exp));
        }
       sig_print_info (oursig);
       return;
@@ -3934,7 +3951,7 @@ struct inferior_status
   CORE_ADDR step_range_start;
   CORE_ADDR step_range_end;
   CORE_ADDR step_frame_address;
-  int step_over_calls;
+  enum step_over_calls_kind step_over_calls;
   CORE_ADDR step_resume_break_address;
   int stop_after_trap;
   int stop_soon_quietly;
@@ -3965,9 +3982,9 @@ xmalloc_inferior_status (void)
 static void
 free_inferior_status (struct inferior_status *inf_status)
 {
-  free (inf_status->registers);
-  free (inf_status->stop_registers);
-  free (inf_status);
+  xfree (inf_status->registers);
+  xfree (inf_status->stop_registers);
+  xfree (inf_status);
 }
 
 void
@@ -4309,4 +4326,13 @@ step == scheduler locked during every single-step operation.\n\
 
   c->function.sfunc = set_schedlock_func;      /* traps on target vector */
   add_show_from_set (c, &showlist);
+
+  c = add_set_cmd ("step-mode", class_run,
+                  var_boolean, (char*) &step_stop_if_no_debug,
+"Set mode of the step operation. When set, doing a step over a\n\
+function without debug line information will stop at the first\n\
+instruction of that function. Otherwise, the function is skipped and\n\
+the step command stops at a different source line.",
+                       &setlist);
+  add_show_from_set (c, &showlist);
 }