2005-01-19 Andrew Cagney <cagney@gnu.org>

	* infrun.c: (resume, proceed, wait_for_inferior)
	(handle_inferior_event, stop_stepping)
	(prepare_to_wait): Write debug output to gdb_stdlog.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 38b9549..e5b3585 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,9 @@
+2005-01-19  Andrew Cagney  <cagney@gnu.org>
+
+       * infrun.c: (resume, proceed, wait_for_inferior)
+       (handle_inferior_event, stop_stepping)
+       (prepare_to_wait): Write debug output to gdb_stdlog.
+
 2005-01-19  Mark Kettenis  <kettenis@gnu.org>
 
        * inf-ptrace.c (inf_ptrace_prepare_to_store)

diff --git a/gdb/infrun.c b/gdb/infrun.c
index e740e19..1f188df 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -503,7 +503,8 @@ resume (int step, enum target_signal sig)
   QUIT;
 
   if (debug_infrun)
-    printf_unfiltered ("infrun: resume (step=%d, signal=%d)\n", step, sig);
+    fprintf_unfiltered (gdb_stdlog, "infrun: resume (step=%d, signal=%d)\n",
+                       step, sig);
 
   /* FIXME: calling breakpoint_here_p (read_pc ()) three times! */
 
@@ -721,8 +722,9 @@ proceed (CORE_ADDR addr, enum target_signal siggnal, int step)
     }
 
   if (debug_infrun)
-    printf_unfiltered ("infrun: proceed (addr=0x%s, signal=%d, step=%d)\n",
-                      paddr_nz (addr), siggnal, step);
+    fprintf_unfiltered (gdb_stdlog,
+                       "infrun: proceed (addr=0x%s, signal=%d, step=%d)\n",
+                       paddr_nz (addr), siggnal, step);
 
   /* In a multi-threaded task we may select another thread
      and then continue or step.
@@ -938,7 +940,7 @@ wait_for_inferior (void)
   struct execution_control_state *ecs;
 
   if (debug_infrun)
-    printf_unfiltered ("infrun: wait_for_inferior\n");
+    fprintf_unfiltered (gdb_stdlog, "infrun: wait_for_inferior\n");
 
   old_cleanups = make_cleanup (delete_step_resume_breakpoint,
                               &step_resume_breakpoint);
@@ -1224,20 +1226,21 @@ handle_inferior_event (struct execution_control_state *ecs)
     {
     case infwait_thread_hop_state:
       if (debug_infrun)
-        printf_unfiltered ("infrun: infwait_thread_hop_state\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: infwait_thread_hop_state\n");
       /* Cancel the waiton_ptid. */
       ecs->waiton_ptid = pid_to_ptid (-1);
       break;
 
     case infwait_normal_state:
       if (debug_infrun)
-        printf_unfiltered ("infrun: infwait_normal_state\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: infwait_normal_state\n");
       stepped_after_stopped_by_watchpoint = 0;
       break;
 
     case infwait_nonstep_watch_state:
       if (debug_infrun)
-        printf_unfiltered ("infrun: infwait_nonstep_watch_state\n");
+        fprintf_unfiltered (gdb_stdlog,
+                           "infrun: infwait_nonstep_watch_state\n");
       insert_breakpoints ();
 
       /* FIXME-maybe: is this cleaner than setting a flag?  Does it
@@ -1273,7 +1276,7 @@ handle_inferior_event (struct execution_control_state *ecs)
     {
     case TARGET_WAITKIND_LOADED:
       if (debug_infrun)
-        printf_unfiltered ("infrun: TARGET_WAITKIND_LOADED\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
       /* Ignore gracefully during startup of the inferior, as it
          might be the shell which has just loaded some objects,
          otherwise add the symbols for the newly loaded objects.  */
@@ -1319,14 +1322,14 @@ handle_inferior_event (struct execution_control_state *ecs)
 
     case TARGET_WAITKIND_SPURIOUS:
       if (debug_infrun)
-        printf_unfiltered ("infrun: TARGET_WAITKIND_SPURIOUS\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
       resume (0, TARGET_SIGNAL_0);
       prepare_to_wait (ecs);
       return;
 
     case TARGET_WAITKIND_EXITED:
       if (debug_infrun)
-        printf_unfiltered ("infrun: TARGET_WAITKIND_EXITED\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXITED\n");
       target_terminal_ours (); /* Must do this before mourn anyway */
       print_stop_reason (EXITED, ecs->ws.value.integer);
 
@@ -1344,7 +1347,7 @@ handle_inferior_event (struct execution_control_state *ecs)
 
     case TARGET_WAITKIND_SIGNALLED:
       if (debug_infrun)
-        printf_unfiltered ("infrun: TARGET_WAITKIND_SIGNALLED\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SIGNALLED\n");
       stop_print_frame = 0;
       stop_signal = ecs->ws.value.sig;
       target_terminal_ours (); /* Must do this before mourn anyway */
@@ -1366,7 +1369,7 @@ handle_inferior_event (struct execution_control_state *ecs)
     case TARGET_WAITKIND_FORKED:
     case TARGET_WAITKIND_VFORKED:
       if (debug_infrun)
-        printf_unfiltered ("infrun: TARGET_WAITKIND_FORKED\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
       stop_signal = TARGET_SIGNAL_TRAP;
       pending_follow.kind = ecs->ws.kind;
 
@@ -1390,7 +1393,7 @@ handle_inferior_event (struct execution_control_state *ecs)
 
     case TARGET_WAITKIND_EXECD:
       if (debug_infrun)
-        printf_unfiltered ("infrun: TARGET_WAITKIND_EXECED\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECED\n");
       stop_signal = TARGET_SIGNAL_TRAP;
 
       /* NOTE drow/2002-12-05: This code should be pushed down into the
@@ -1444,7 +1447,7 @@ handle_inferior_event (struct execution_control_state *ecs)
          that's in a syscall.  It's frequently a losing proposition.  */
     case TARGET_WAITKIND_SYSCALL_ENTRY:
       if (debug_infrun)
-        printf_unfiltered ("infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
       resume (0, TARGET_SIGNAL_0);
       prepare_to_wait (ecs);
       return;
@@ -1456,14 +1459,14 @@ handle_inferior_event (struct execution_control_state *ecs)
          into user code.)  */
     case TARGET_WAITKIND_SYSCALL_RETURN:
       if (debug_infrun)
-        printf_unfiltered ("infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
       target_resume (ecs->ptid, 1, TARGET_SIGNAL_0);
       prepare_to_wait (ecs);
       return;
 
     case TARGET_WAITKIND_STOPPED:
       if (debug_infrun)
-        printf_unfiltered ("infrun: TARGET_WAITKIND_STOPPED\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
       stop_signal = ecs->ws.value.sig;
       break;
 
@@ -1478,7 +1481,7 @@ handle_inferior_event (struct execution_control_state *ecs)
          reported multiple times without an intervening resume.  */
     case TARGET_WAITKIND_IGNORE:
       if (debug_infrun)
-        printf_unfiltered ("infrun: TARGET_WAITKIND_IGNORE\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
       prepare_to_wait (ecs);
       return;
     }
@@ -1500,7 +1503,7 @@ handle_inferior_event (struct execution_control_state *ecs)
   stop_pc = read_pc_pid (ecs->ptid);
 
   if (debug_infrun)
-    printf_unfiltered ("infrun: stop_pc = 0x%s\n", paddr_nz (stop_pc));
+    fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = 0x%s\n", paddr_nz (stop_pc));
 
   if (stepping_past_singlestep_breakpoint)
     {
@@ -1517,7 +1520,7 @@ handle_inferior_event (struct execution_control_state *ecs)
       if (stop_signal == TARGET_SIGNAL_TRAP)
        {
          if (debug_infrun)
-           printf_unfiltered ("infrun: stepping_past_singlestep_breakpoint\n");
+           fprintf_unfiltered (gdb_stdlog, "infrun: stepping_past_singlestep_breakpoint\n");
          /* Pull the single step breakpoints out of the target.  */
          SOFTWARE_SINGLE_STEP (0, 0);
          singlestep_breakpoints_inserted_p = 0;
@@ -1575,7 +1578,7 @@ handle_inferior_event (struct execution_control_state *ecs)
          int remove_status;
 
          if (debug_infrun)
-           printf_unfiltered ("infrun: thread_hop_needed\n");
+           fprintf_unfiltered (gdb_stdlog, "infrun: thread_hop_needed\n");
 
          /* Saw a breakpoint, but it was hit by the wrong thread.
             Just continue. */
@@ -1643,7 +1646,7 @@ handle_inferior_event (struct execution_control_state *ecs)
   if (!ptid_equal (ecs->ptid, inferior_ptid))
     {
       if (debug_infrun)
-       printf_unfiltered ("infrun: context switch\n");
+       fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
 
       context_switch (ecs);
 
@@ -1666,7 +1669,7 @@ handle_inferior_event (struct execution_control_state *ecs)
   if (HAVE_STEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (ecs->ws))
     {
       if (debug_infrun)
-       printf_unfiltered ("infrun: STOPPED_BY_WATCHPOINT\n");
+       fprintf_unfiltered (gdb_stdlog, "infrun: STOPPED_BY_WATCHPOINT\n");
       resume (1, 0);
       prepare_to_wait (ecs);
       return;
@@ -1695,7 +1698,7 @@ handle_inferior_event (struct execution_control_state *ecs)
          stop in the correct manner.  */
 
       if (debug_infrun)
-       printf_unfiltered ("infrun: STOPPED_BY_WATCHPOINT\n");
+       fprintf_unfiltered (gdb_stdlog, "infrun: STOPPED_BY_WATCHPOINT\n");
       remove_breakpoints ();
       registers_changed ();
       target_resume (ecs->ptid, 1, TARGET_SIGNAL_0);   /* Single step */
@@ -1742,7 +1745,7 @@ handle_inferior_event (struct execution_control_state *ecs)
        = gdbarch_single_step_through_delay (current_gdbarch,
                                             get_current_frame ());
       if (debug_infrun && step_through_delay)
-       printf_unfiltered ("infrun: step through delay\n");
+       fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
       if (step_range_end == 0 && step_through_delay)
        {
          /* The user issued a continue when stopped at a breakpoint.
@@ -1792,7 +1795,7 @@ handle_inferior_event (struct execution_control_state *ecs)
       if (stop_signal == TARGET_SIGNAL_TRAP && stop_after_trap)
        {
           if (debug_infrun)
-           printf_unfiltered ("infrun: stopped\n");
+           fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
          stop_print_frame = 0;
          stop_stepping (ecs);
          return;
@@ -1803,7 +1806,7 @@ handle_inferior_event (struct execution_control_state *ecs)
       if (stop_soon == STOP_QUIETLY)
        {
           if (debug_infrun)
-           printf_unfiltered ("infrun: quietly stopped\n");
+           fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
          stop_stepping (ecs);
          return;
        }
@@ -1825,7 +1828,7 @@ handle_inferior_event (struct execution_control_state *ecs)
       if (stop_signal == TARGET_SIGNAL_TRAP && trap_expected)
        {
           if (debug_infrun)
-           printf_unfiltered ("infrun: trap expected\n");
+           fprintf_unfiltered (gdb_stdlog, "infrun: trap expected\n");
          bpstat_clear (&stop_bpstat);
        }
       else
@@ -1889,7 +1892,7 @@ process_event_stop_test:
       int printed = 0;
 
       if (debug_infrun)
-        printf_unfiltered ("infrun: random signal %d\n", stop_signal);
+        fprintf_unfiltered (gdb_stdlog, "infrun: random signal %d\n", stop_signal);
 
       stopped_by_random_signal = 1;
 
@@ -1971,7 +1974,7 @@ process_event_stop_test:
           duration of this command.  Then, install a temporary
           breakpoint at the target of the jmp_buf. */
         if (debug_infrun)
-         printf_unfiltered ("infrun: BPSTATE_WHAT_SET_LONGJMP_RESUME\n");
+         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTATE_WHAT_SET_LONGJMP_RESUME\n");
        disable_longjmp_breakpoint ();
        remove_breakpoints ();
        breakpoints_inserted = 0;
@@ -1996,7 +1999,7 @@ process_event_stop_test:
       case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
       case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE:
         if (debug_infrun)
-         printf_unfiltered ("infrun: BPSTATE_WHAT_CLEAR_LONGJMP_RESUME\n");
+         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTATE_WHAT_CLEAR_LONGJMP_RESUME\n");
        remove_breakpoints ();
        breakpoints_inserted = 0;
        disable_longjmp_breakpoint ();
@@ -2007,7 +2010,7 @@ process_event_stop_test:
 
       case BPSTAT_WHAT_SINGLE:
         if (debug_infrun)
-         printf_unfiltered ("infrun: BPSTATE_WHAT_SINGLE\n");
+         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTATE_WHAT_SINGLE\n");
        if (breakpoints_inserted)
          {
            remove_breakpoints ();
@@ -2020,7 +2023,7 @@ process_event_stop_test:
 
       case BPSTAT_WHAT_STOP_NOISY:
         if (debug_infrun)
-         printf_unfiltered ("infrun: BPSTATE_WHAT_STOP_NOISY\n");
+         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTATE_WHAT_STOP_NOISY\n");
        stop_print_frame = 1;
 
        /* We are about to nuke the step_resume_breakpointt via the
@@ -2031,7 +2034,7 @@ process_event_stop_test:
 
       case BPSTAT_WHAT_STOP_SILENT:
         if (debug_infrun)
-         printf_unfiltered ("infrun: BPSTATE_WHAT_STOP_SILENT\n");
+         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTATE_WHAT_STOP_SILENT\n");
        stop_print_frame = 0;
 
        /* We are about to nuke the step_resume_breakpoin via the
@@ -2059,7 +2062,7 @@ process_event_stop_test:
           the one deleted is the one currently stopped at.  MVS  */
 
         if (debug_infrun)
-         printf_unfiltered ("infrun: BPSTATE_WHAT_STEP_RESUME\n");
+         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTATE_WHAT_STEP_RESUME\n");
 
        if (step_resume_breakpoint == NULL)
          {
@@ -2083,7 +2086,7 @@ process_event_stop_test:
 
       case BPSTAT_WHAT_THROUGH_SIGTRAMP:
         if (debug_infrun)
-         printf_unfiltered ("infrun: BPSTATE_WHAT_THROUGH_SIGTRAMP\n");
+         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTATE_WHAT_THROUGH_SIGTRAMP\n");
        /* If were waiting for a trap, hitting the step_resume_break
           doesn't count as getting it.  */
        if (trap_expected)
@@ -2095,7 +2098,7 @@ process_event_stop_test:
 #ifdef SOLIB_ADD
        {
           if (debug_infrun)
-           printf_unfiltered ("infrun: BPSTATE_WHAT_CHECK_SHLIBS\n");
+           fprintf_unfiltered (gdb_stdlog, "infrun: BPSTATE_WHAT_CHECK_SHLIBS\n");
          /* Remove breakpoints, we eventually want to step over the
             shlib event breakpoint, and SOLIB_ADD might adjust
             breakpoint addresses via breakpoint_re_set.  */
@@ -2209,14 +2212,14 @@ process_event_stop_test:
       if (SOLIB_IN_DYNAMIC_LINKER (PIDGET (ecs->ptid), stop_pc))
        {
           if (debug_infrun)
-           printf_unfiltered ("infrun: stepping in dynamic linker\n");
+           fprintf_unfiltered (gdb_stdlog, "infrun: stepping in dynamic linker\n");
          ecs->another_trap = 1;
          keep_going (ecs);
          return;
        }
 #endif
       if (debug_infrun)
-        printf_unfiltered ("infrun: step past dynamic linker\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: step past dynamic linker\n");
       /* Else, stop and report the catchpoint(s) whose triggering
          caused us to begin stepping. */
       ecs->stepping_through_solib_after_catch = 0;
@@ -2231,7 +2234,7 @@ process_event_stop_test:
   if (step_resume_breakpoint)
     {
       if (debug_infrun)
-        printf_unfiltered ("infrun: step-resume breakpoint\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: step-resume breakpoint\n");
 
       /* Having a step-resume breakpoint overrides anything
          else having to do with stepping commands until
@@ -2243,7 +2246,7 @@ process_event_stop_test:
   if (step_range_end == 0)
     {
       if (debug_infrun)
-        printf_unfiltered ("infrun: no stepping, continue\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
       /* Likewise if we aren't even stepping.  */
       keep_going (ecs);
       return;
@@ -2257,7 +2260,7 @@ process_event_stop_test:
   if (stop_pc >= step_range_start && stop_pc < step_range_end)
     {
       if (debug_infrun)
-        printf_unfiltered ("infrun: stepping inside range [0x%s-0x%s]\n",
+        fprintf_unfiltered (gdb_stdlog, "infrun: stepping inside range [0x%s-0x%s]\n",
                            paddr_nz (step_range_start),
                            paddr_nz (step_range_end));
       keep_going (ecs);
@@ -2277,7 +2280,7 @@ process_event_stop_test:
        gdbarch_skip_solib_resolver (current_gdbarch, stop_pc);
 
       if (debug_infrun)
-        printf_unfiltered ("infrun: stepped into dynsym resolve code\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: stepped into dynsym resolve code\n");
 
       if (pc_after_resolver)
        {
@@ -2300,7 +2303,7 @@ process_event_stop_test:
       && get_frame_type (get_current_frame ()) == SIGTRAMP_FRAME)
     {
       if (debug_infrun)
-        printf_unfiltered ("infrun: stepped into signal trampoline\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: stepped into signal trampoline\n");
       /* The inferior, while doing a "step" or "next", has ended up in
          a signal trampoline (either by a signal being delivered or by
          the signal handler returning).  Just single-step until the
@@ -2316,7 +2319,7 @@ process_event_stop_test:
       CORE_ADDR real_stop_pc;
 
       if (debug_infrun)
-        printf_unfiltered ("infrun: stepped into subroutine\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
 
       if ((step_over_calls == STEP_OVER_NONE)
          || ((step_range_end == 1)
@@ -2409,7 +2412,7 @@ process_event_stop_test:
       CORE_ADDR real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc);
 
       if (debug_infrun)
-        printf_unfiltered ("infrun: stepped into solib return tramp\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: stepped into solib return tramp\n");
 
       /* Only proceed through if we know where it's going.  */
       if (real_stop_pc)
@@ -2440,7 +2443,7 @@ process_event_stop_test:
       && ecs->stop_func_name == NULL)
     {
       if (debug_infrun)
-        printf_unfiltered ("infrun: stepped into undebuggable function\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: stepped into undebuggable function\n");
 
       /* The inferior just stepped into, or returned to, an
          undebuggable function (where there is no symbol, not even a
@@ -2473,7 +2476,7 @@ process_event_stop_test:
       /* It is stepi or nexti.  We always want to stop stepping after
          one instruction.  */
       if (debug_infrun)
-        printf_unfiltered ("infrun: stepi/nexti\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
       stop_step = 1;
       print_stop_reason (END_STEPPING_RANGE, 0);
       stop_stepping (ecs);
@@ -2489,7 +2492,7 @@ process_event_stop_test:
          when we do "s" in a function with no line numbers,
          or can this happen as a result of a return or longjmp?).  */
       if (debug_infrun)
-        printf_unfiltered ("infrun: no line number info\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
       stop_step = 1;
       print_stop_reason (END_STEPPING_RANGE, 0);
       stop_stepping (ecs);
@@ -2505,7 +2508,7 @@ process_event_stop_test:
          That is said to make things like for (;;) statements work
          better.  */
       if (debug_infrun)
-        printf_unfiltered ("infrun: stepped to a different line\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: stepped to a different line\n");
       stop_step = 1;
       print_stop_reason (END_STEPPING_RANGE, 0);
       stop_stepping (ecs);
@@ -2527,7 +2530,7 @@ process_event_stop_test:
          in which after skipping the prologue we better stop even though
          we will be in mid-line.  */
       if (debug_infrun)
-        printf_unfiltered ("infrun: stepped to a different function\n");
+        fprintf_unfiltered (gdb_stdlog, "infrun: stepped to a different function\n");
       stop_step = 1;
       print_stop_reason (END_STEPPING_RANGE, 0);
       stop_stepping (ecs);
@@ -2565,7 +2568,7 @@ process_event_stop_test:
   }
 
   if (debug_infrun)
-     printf_unfiltered ("infrun: keep going\n");
+     fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
   keep_going (ecs);
 }
 
@@ -2703,7 +2706,7 @@ static void
 stop_stepping (struct execution_control_state *ecs)
 {
   if (debug_infrun)
-    printf_unfiltered ("infrun: stop_stepping\n");
+    fprintf_unfiltered (gdb_stdlog, "infrun: stop_stepping\n");
 
   /* Let callers know we don't want to wait for the inferior anymore.  */
   ecs->wait_some_more = 0;
@@ -2783,7 +2786,7 @@ static void
 prepare_to_wait (struct execution_control_state *ecs)
 {
   if (debug_infrun)
-    printf_unfiltered ("infrun: prepare_to_wait\n");
+    fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
   if (ecs->infwait_state == infwait_normal_state)
     {
       overlay_cache_invalid = 1;