* hppah-nat.c (child_wait): Return TARGET_WAITKIND_IGNORE

	for the parent's fork event.
	* infrun.c (handle_inferior_event): Only expect one fork event.
	Call prepare_to_wait for TARGET_WAITKIND_IGNORE.  Update comment.
	* target.h: Update comment for TARGET_WAITKIND_IGNORE.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 0ab61827c77c406dc7bac0663d592ca54928fd4c..a83927b6897c5e57cda06ccf1e82866da9fe0126 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,11 @@
+2002-12-06  Daniel Jacobowitz  <drow@mvista.com>
+
+       * hppah-nat.c (child_wait): Return TARGET_WAITKIND_IGNORE
+       for the parent's fork event.
+       * infrun.c (handle_inferior_event): Only expect one fork event.
+       Call prepare_to_wait for TARGET_WAITKIND_IGNORE.  Update comment.
+       * target.h: Update comment for TARGET_WAITKIND_IGNORE.
+
 2002-12-10  Andrew Cagney  <ac131313@redhat.com>
 
        * PROBLEMS: Delete reference to PR gdb/725.

diff --git a/gdb/hppah-nat.c b/gdb/hppah-nat.c
index d5767a9c55f6126d14f529704893b6acc73de714..17614073e22f7c9fb76fb5f95e261c42b018a1ae 100644 (file)
--- a/gdb/hppah-nat.c
+++ b/gdb/hppah-nat.c
@@ -524,13 +524,23 @@ child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
          return pid_to_ptid (pid);
        }
 
-      if (hpux_has_forked (pid, &related_pid)
-         && ((pid == PIDGET (inferior_ptid)) 
-             || (related_pid == PIDGET (inferior_ptid))))
+      if (hpux_has_forked (pid, &related_pid))
        {
-         ourstatus->kind = TARGET_WAITKIND_FORKED;
-         ourstatus->value.related_pid = related_pid;
-         return pid_to_ptid (pid);
+         /* Ignore the parent's fork event.  */
+         if (pid == PIDGET (inferior_ptid))
+           {
+             ourstatus->kind = TARGET_WAITKIND_IGNORE;
+             return inferior_ptid;
+           }
+
+         /* If this is the child's fork event, report that the
+            process has forked.  */
+         if (related_pid == PIDGET (inferior_ptid))
+           {
+             ourstatus->kind = TARGET_WAITKIND_FORKED;
+             ourstatus->value.related_pid = pid;
+             return inferior_ptid;
+           }
        }
 
       if (hpux_has_vforked (pid, &related_pid)

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 76770cc5c100871ace1441f717151e39173087a2..7cb9f3338ea4c3697ed81eaa337d306f42dea34b 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1478,24 +1478,9 @@ handle_inferior_event (struct execution_control_state *ecs)
       stop_signal = TARGET_SIGNAL_TRAP;
       pending_follow.kind = ecs->ws.kind;
 
-      /* Ignore fork events reported for the parent; we're only
-         interested in reacting to forks of the child.  Note that
-         we expect the child's fork event to be available if we
-         waited for it now. */
-      if (ptid_equal (inferior_ptid, ecs->ptid))
-       {
-         pending_follow.fork_event.saw_parent_fork = 1;
-         pending_follow.fork_event.parent_pid = PIDGET (ecs->ptid);
-         pending_follow.fork_event.child_pid = ecs->ws.value.related_pid;
-         prepare_to_wait (ecs);
-         return;
-       }
-      else
-       {
-         pending_follow.fork_event.saw_child_fork = 1;
-         pending_follow.fork_event.child_pid = PIDGET (ecs->ptid);
-         pending_follow.fork_event.parent_pid = ecs->ws.value.related_pid;
-       }
+      pending_follow.fork_event.saw_child_fork = 1;
+      pending_follow.fork_event.parent_pid = PIDGET (ecs->ptid);
+      pending_follow.fork_event.child_pid = ecs->ws.value.related_pid;
 
       stop_pc = read_pc_pid (ecs->ptid);
       ecs->saved_inferior_ptid = inferior_ptid;
@@ -1703,13 +1688,15 @@ handle_inferior_event (struct execution_control_state *ecs)
 
       /* We had an event in the inferior, but we are not interested
          in handling it at this level. The lower layers have already
-         done what needs to be done, if anything. This case can
-         occur only when the target is async or extended-async. One
-         of the circumstamces for this to happen is when the
-         inferior produces output for the console. The inferior has
-         not stopped, and we are ignoring the event. */
+         done what needs to be done, if anything.
+        
+        One of the possible circumstances for this is when the
+        inferior produces output for the console. The inferior has
+        not stopped, and we are ignoring the event.  Another possible
+        circumstance is any event which the lower level knows will be
+        reported multiple times without an intervening resume.  */
     case TARGET_WAITKIND_IGNORE:
-      ecs->wait_some_more = 1;
+      prepare_to_wait (ecs);
       return;
     }
 

diff --git a/gdb/target.h b/gdb/target.h
index 337ea7c2ca3ecf372d327ae2aed9ee8b2a78bec8..79c2eaa1c02f9ad98ca9825654260f4e13c0799a 100644 (file)
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -112,8 +112,8 @@ enum target_waitkind
        inferior.  */
     TARGET_WAITKIND_SPURIOUS,
 
-    /* This is used for target async and extended-async
-       only. Remote_async_wait() returns this when there is an event
+    /* An event has occured, but we should wait again.
+       Remote_async_wait() returns this when there is an event
        on the inferior, but the rest of the world is not interested in
        it. The inferior has not stopped, but has just sent some output
        to the console, for instance. In this case, we want to go back