Phase 1 of the ptid_t changes.

[deliverable/binutils-gdb.git] / gdb / hpux-thread.c

diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c
index d7172eb85b762868c2eee2019d20d283acbb0c78..4efeb4a5725aaf9486f3e76cf1fbc5b4b3edd0a5 100644 (file)
--- a/gdb/hpux-thread.c
+++ b/gdb/hpux-thread.c
@@ -57,16 +57,17 @@ struct string_map
 
 static int hpux_thread_active = 0;
 
-static int main_pid;           /* Real process ID */
+static ptid_t main_ptid;               /* Real process ID */
 
 static CORE_ADDR P_cma__g_known_threads;
 static CORE_ADDR P_cma__g_current_thread;
 
-static struct cleanup *save_inferior_pid (void);
+static struct cleanup *save_inferior_ptid (void);
 
-static void restore_inferior_pid (int pid);
+static void restore_inferior_ptid (ptid_t pid);
 
-static void hpux_thread_resume (int pid, int step, enum target_signal signo);
+static void hpux_thread_resume (ptid_t ptid, int step,
+                                enum target_signal signo);
 
 static void init_hpux_thread_ops (void);
 
@@ -76,40 +77,40 @@ static struct target_ops hpux_thread_ops;
 
    LOCAL FUNCTION
 
-   save_inferior_pid - Save inferior_pid on the cleanup list
-   restore_inferior_pid - Restore inferior_pid from the cleanup list
+   save_inferior_ptid - Save inferior_ptid on the cleanup list
+   restore_inferior_ptid - Restore inferior_ptid from the cleanup list
 
    SYNOPSIS
 
-   struct cleanup *save_inferior_pid ()
-   void restore_inferior_pid (int pid)
+   struct cleanup *save_inferior_ptid ()
+   void restore_inferior_ptid (int pid)
 
    DESCRIPTION
 
-   These two functions act in unison to restore inferior_pid in
+   These two functions act in unison to restore inferior_ptid in
    case of an error.
 
    NOTES
 
-   inferior_pid is a global variable that needs to be changed by many of
+   inferior_ptid is a global variable that needs to be changed by many of
    these routines before calling functions in procfs.c.  In order to
-   guarantee that inferior_pid gets restored (in case of errors), you
-   need to call save_inferior_pid before changing it.  At the end of the
+   guarantee that inferior_ptid gets restored (in case of errors), you
+   need to call save_inferior_ptid before changing it.  At the end of the
    function, you should invoke do_cleanups to restore it.
 
  */
 
 
 static struct cleanup *
-save_inferior_pid (void)
+save_inferior_ptid (void)
 {
-  return make_cleanup (restore_inferior_pid, inferior_pid);
+  return make_cleanup (restore_inferior_ptid, inferior_ptid);
 }
 
 static void
-restore_inferior_pid (int pid)
+restore_inferior_ptid (ptid_t ptid)
 {
-  inferior_pid = pid;
+  inferior_ptid = ptid;
 }
 \f
 static int find_active_thread (void);
@@ -133,7 +134,8 @@ find_active_thread (void)
 
   read_memory (tcb_ptr, (char *) &tcb, sizeof tcb);
 
-  return (cma_thread_get_unique (&tcb.prolog.client_thread) << 16) | main_pid;
+  return (cma_thread_get_unique (&tcb.prolog.client_thread) << 16) 
+         | PIDGET (main_ptid);
 }
 
 static cma__t_int_tcb *find_tcb (int thread);
@@ -214,13 +216,14 @@ hpux_thread_detach (char *args, int from_tty)
    for procfs.  */
 
 static void
-hpux_thread_resume (int pid, int step, enum target_signal signo)
+hpux_thread_resume (ptid_t ptid, int step, enum target_signal signo)
 {
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  pid = inferior_pid = main_pid;
+  ptid = main_ptid;
+  inferior_ptid = main_ptid;
 
 #if 0
   if (pid != -1)
@@ -231,7 +234,7 @@ hpux_thread_resume (int pid, int step, enum target_signal signo)
     }
 #endif
 
-  child_ops.to_resume (pid, step, signo);
+  child_ops.to_resume (ptid, step, signo);
 
   cached_thread = 0;
   cached_active_thread = 0;
@@ -242,20 +245,20 @@ hpux_thread_resume (int pid, int step, enum target_signal signo)
 /* Wait for any threads to stop.  We may have to convert PID from a thread id
    to a LWP id, and vice versa on the way out.  */
 
-static int
-hpux_thread_wait (int pid, struct target_waitstatus *ourstatus)
+static ptid_t
+hpux_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 {
-  int rtnval;
+  ptid_t rtnval;
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = main_pid;
+  inferior_ptid = main_ptid;
 
-  if (pid != -1)
-    pid = main_pid;
+  if (!ptid_equal (ptid, minus_one_ptid))
+    ptid = main_ptid;
 
-  rtnval = child_ops.to_wait (pid, ourstatus);
+  rtnval = child_ops.to_wait (ptid, ourstatus);
 
   rtnval = find_active_thread ();
 
@@ -298,11 +301,11 @@ hpux_thread_fetch_registers (int regno)
   int i;
   int first_regno, last_regno;
 
-  tcb_ptr = find_tcb (inferior_pid);
+  tcb_ptr = find_tcb (PIDGET (inferior_ptid));
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = main_pid;
+  inferior_ptid = main_ptid;
 
   if (tcb_ptr->state == cma__c_state_running)
     {
@@ -360,11 +363,11 @@ hpux_thread_store_registers (int regno)
   int i;
   int first_regno, last_regno;
 
-  tcb_ptr = find_tcb (inferior_pid);
+  tcb_ptr = find_tcb (PIDGET (inferior_ptid));
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = main_pid;
+  inferior_ptid = main_ptid;
 
   if (tcb_ptr->state == cma__c_state_running)
     {
@@ -441,9 +444,9 @@ hpux_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
   int retval;
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = main_pid;
+  inferior_ptid = main_ptid;
 
   retval = 
     child_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, attribs, target);
@@ -468,9 +471,9 @@ hpux_thread_kill_inferior (void)
 }
 
 static void
-hpux_thread_notice_signals (int pid)
+hpux_thread_notice_signals (ptid_t ptid)
 {
-  child_ops.to_notice_signals (pid);
+  child_ops.to_notice_signals (ptid);
 }
 
 /* Fork an inferior process, and start debugging it with /proc.  */
@@ -482,13 +485,13 @@ hpux_thread_create_inferior (char *exec_file, char *allargs, char **env)
 
   if (hpux_thread_active)
     {
-      main_pid = inferior_pid;
+      main_ptid = inferior_ptid;
 
       push_target (&hpux_thread_ops);
 
-      inferior_pid = find_active_thread ();
+      inferior_ptid = find_active_thread ();
 
-      add_thread (inferior_pid);
+      add_thread (inferior_ptid);
     }
 }
 
@@ -554,7 +557,7 @@ hpux_thread_can_run (void)
 }
 
 static int
-hpux_thread_alive (int pid)
+hpux_thread_alive (ptid_t ptid)
 {
   return 1;
 }
@@ -568,9 +571,10 @@ hpux_thread_stop (void)
 /* Convert a pid to printable form. */
 
 char *
-hpux_pid_to_str (int pid)
+hpux_pid_to_str (ptid_t ptid)
 {
   static char buf[100];
+  int pid = PIDGET (ptid);
 
   sprintf (buf, "Thread %d", pid >> 16);