Phase 1 of the ptid_t changes.gdb-post-ptid_t-2001-05-03

1 files changed, 134 insertions, 133 deletions

diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c
index cc1e20cad95..97f3e2426a9 100644
--- a/gdb/sol-thread.c
+++ b/gdb/sol-thread.c
@@ -73,7 +73,7 @@ struct target_ops sol_core_ops;
 extern int procfs_suppress_run;
 extern struct target_ops procfs_ops;	/* target vector for procfs.c */
 extern struct target_ops core_ops;	/* target vector for corelow.c */
-extern char *procfs_pid_to_str (int pid);
+extern char *procfs_pid_to_str (ptid_t ptid);
 
 /* Prototypes for supply_gregset etc. */
 #include "gregset.h"
@@ -84,7 +84,7 @@ extern char *procfs_pid_to_str (int pid);
 
 struct ps_prochandle
   {
-    pid_t pid;
+    ptid_t ptid;
   };
 
 struct string_map
@@ -97,14 +97,14 @@ static struct ps_prochandle main_ph;
 static td_thragent_t *main_ta;
 static int sol_thread_active = 0;
 
-static struct cleanup *save_inferior_pid (void);
-static void restore_inferior_pid (void *pid);
+static struct cleanup *save_inferior_ptid (void);
+static void restore_inferior_ptid (void *pid);
 static char *td_err_string (td_err_e errcode);
 static char *td_state_string (td_thr_state_e statecode);
-static int thread_to_lwp (int thread_id, int default_lwp);
-static void sol_thread_resume (int pid, int step, enum target_signal signo);
-static int lwp_to_thread (int lwp);
-static int sol_thread_alive (int pid);
+static ptid_t thread_to_lwp (ptid_t thread_id, int default_lwp);
+static void sol_thread_resume (ptid_t ptid, int step, enum target_signal signo);
+static ptid_t lwp_to_thread (ptid_t lwp);
+static int sol_thread_alive (ptid_t ptid);
 static void sol_core_close (int quitting);
 
 static void init_sol_thread_ops (void);
@@ -288,7 +288,7 @@ td_state_string (td_thr_state_e statecode)
 
    SYNOPSIS
 
-   int thread_to_lwp (thread_id, default_lwp)
+   tpid_t thread_to_lwp (thread_id, default_lwp)
 
    DESCRIPTION
 
@@ -302,8 +302,8 @@ td_state_string (td_thr_state_e statecode)
 
  */
 
-static int
-thread_to_lwp (int thread_id, int default_lwp)
+static ptid_t
+thread_to_lwp (ptid_t thread_id, int default_lwp)
 {
   td_thrinfo_t ti;
   td_thrhandle_t th;
@@ -316,20 +316,20 @@ thread_to_lwp (int thread_id, int default_lwp)
 
   val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);
   if (val == TD_NOTHR)
-    return -1;			/* thread must have terminated */
+    return pid_to_ptid (-1);		/* thread must have terminated */
   else if (val != TD_OK)
     error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val));
 
   val = p_td_thr_get_info (&th, &ti);
   if (val == TD_NOTHR)
-    return -1;			/* thread must have terminated */
+    return pid_to_ptid (-1);		/* thread must have terminated */
   else if (val != TD_OK)
     error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val));
 
   if (ti.ti_state != TD_THR_ACTIVE)
     {
       if (default_lwp != -1)
-	return default_lwp;
+	return pid_to_ptid (default_lwp);
       error ("thread_to_lwp: thread state not active: %s",
 	     td_state_string (ti.ti_state));
     }
@@ -358,8 +358,8 @@ thread_to_lwp (int thread_id, int default_lwp)
 
  */
 
-static int
-lwp_to_thread (int lwp)
+static ptid_t
+lwp_to_thread (ptid_t lwp)
 {
   td_thrinfo_t ti;
   td_thrhandle_t th;
@@ -371,11 +371,11 @@ lwp_to_thread (int lwp)
   /* It's an lwp.  Convert it to a thread id.  */
 
   if (!sol_thread_alive (lwp))
-    return -1;			/* defunct lwp */
+    return pid_to_ptid (-1);	/* defunct lwp */
 
   val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
   if (val == TD_NOTHR)
-    return -1;			/* thread must have terminated */
+    return pid_to_ptid (-1);	/* thread must have terminated */
   else if (val != TD_OK)
     error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val));
 
@@ -388,7 +388,7 @@ lwp_to_thread (int lwp)
 
   val = p_td_thr_get_info (&th, &ti);
   if (val == TD_NOTHR)
-    return -1;			/* thread must have terminated */
+    return pid_to_ptid (-1);	/* thread must have terminated */
   else if (val != TD_OK)
     error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val));
 
@@ -399,44 +399,44 @@ lwp_to_thread (int lwp)
 
    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)
 {
-  int *saved_pid = xmalloc (sizeof (int));
-  *saved_pid = inferior_pid;
-  return make_cleanup (restore_inferior_pid, saved_pid);
+  ptid_t *saved_ptid = xmalloc (sizeof (ptid_t));
+  *saved_ptid = inferior_ptid;
+  return make_cleanup (restore_inferior_ptid, saved_ptid);
 }
 
 static void
-restore_inferior_pid (void *data)
+restore_inferior_ptid (void *data)
 {
-  int *saved_pid = data;
-  inferior_pid = *saved_pid;
-  xfree (saved_pid);
+  ptid_t *saved_ptid = data;
+  inferior_ptid = *saved_ptid;
+  xfree (saved_ptid);
 }
 
 
@@ -465,13 +465,13 @@ sol_thread_attach (char *args, int from_tty)
   if (sol_thread_active)
     {
       printf_filtered ("sol-thread active.\n");
-      main_ph.pid = inferior_pid;	/* Save for xfer_memory */
+      main_ph.ptid = inferior_ptid;		/* Save for xfer_memory */
       push_target (&sol_thread_ops);
-      inferior_pid = lwp_to_thread (inferior_pid);
-      if (inferior_pid == -1)
-	inferior_pid = main_ph.pid;
+      inferior_ptid = lwp_to_thread (inferior_ptid);
+      if (PIDGET (inferior_ptid) == -1)
+	inferior_ptid = main_ph.ptid;
       else
-	add_thread (inferior_pid);
+	add_thread (inferior_ptid);
     }
   /* XXX - might want to iterate over all the threads and register them. */
 }
@@ -487,7 +487,7 @@ sol_thread_attach (char *args, int from_tty)
 static void
 sol_thread_detach (char *args, int from_tty)
 {
-  inferior_pid = PIDGET (main_ph.pid);
+  inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid));
   unpush_target (&sol_thread_ops);
   procfs_ops.to_detach (args, from_tty);
 }
@@ -498,29 +498,29 @@ sol_thread_detach (char *args, int from_tty)
    for procfs.  */
 
 static void
-sol_thread_resume (int pid, int step, enum target_signal signo)
+sol_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 ();
 
-  inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
-  if (inferior_pid == -1)
-    inferior_pid = procfs_first_available ();
+  inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
+  if (PIDGET (inferior_ptid) == -1)
+    inferior_ptid = procfs_first_available ();
 
-  if (pid != -1)
+  if (PIDGET (ptid) != -1)
     {
-      int save_pid = pid;
+      ptid_t save_ptid = ptid;
 
-      pid = thread_to_lwp (pid, -2);
-      if (pid == -2)		/* Inactive thread */
+      ptid = thread_to_lwp (ptid, -2);
+      if (PIDGET (ptid) == -2)		/* Inactive thread */
 	error ("This version of Solaris can't start inactive threads.");
-      if (info_verbose && pid == -1)
-	warning ("Specified thread %d seems to have terminated",
-		 GET_THREAD (save_pid));
+      if (info_verbose && PIDGET (ptid) == -1)
+	warning ("Specified thread %ld seems to have terminated",
+		 GET_THREAD (save_ptid));
     }
 
-  procfs_ops.to_resume (pid, step, signo);
+  procfs_ops.to_resume (ptid, step, signo);
 
   do_cleanups (old_chain);
 }
@@ -528,44 +528,44 @@ sol_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
-sol_thread_wait (int pid, struct target_waitstatus *ourstatus)
+static ptid_t
+sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 {
-  int rtnval;
-  int save_pid;
+  ptid_t rtnval;
+  ptid_t save_ptid;
   struct cleanup *old_chain;
 
-  save_pid = inferior_pid;
-  old_chain = save_inferior_pid ();
+  save_ptid = inferior_ptid;
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
-  if (inferior_pid == -1)
-    inferior_pid = procfs_first_available ();
+  inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
+  if (PIDGET (inferior_ptid) == -1)
+    inferior_ptid = procfs_first_available ();
 
-  if (pid != -1)
+  if (PIDGET (ptid) != -1)
     {
-      int save_pid = pid;
+      ptid_t save_ptid = ptid;
 
-      pid = thread_to_lwp (pid, -2);
-      if (pid == -2)		/* Inactive thread */
+      ptid = thread_to_lwp (ptid, -2);
+      if (PIDGET (ptid) == -2)		/* Inactive thread */
 	error ("This version of Solaris can't start inactive threads.");
-      if (info_verbose && pid == -1)
-	warning ("Specified thread %d seems to have terminated",
-		 GET_THREAD (save_pid));
+      if (info_verbose && PIDGET (ptid) == -1)
+	warning ("Specified thread %ld seems to have terminated",
+		 GET_THREAD (save_ptid));
     }
 
-  rtnval = procfs_ops.to_wait (pid, ourstatus);
+  rtnval = procfs_ops.to_wait (ptid, ourstatus);
 
   if (ourstatus->kind != TARGET_WAITKIND_EXITED)
     {
       /* Map the LWP of interest back to the appropriate thread ID */
       rtnval = lwp_to_thread (rtnval);
-      if (rtnval == -1)
-	rtnval = save_pid;
+      if (PIDGET (rtnval) == -1)
+	rtnval = save_ptid;
 
       /* See if we have a new thread */
       if (is_thread (rtnval)
-	  && rtnval != save_pid
+	  && !ptid_equal (rtnval, save_ptid)
 	  && !in_thread_list (rtnval))
 	{
 	  printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));
@@ -595,7 +595,7 @@ sol_thread_fetch_registers (int regno)
   caddr_t xregset;
 #endif
 
-  if (!is_thread (inferior_pid))
+  if (!is_thread (inferior_ptid))
     {				/* LWP: pass the request on to procfs.c */
       if (target_has_execution)
 	procfs_ops.to_fetch_registers (regno);
@@ -604,9 +604,9 @@ sol_thread_fetch_registers (int regno)
       return;
     }
 
-  /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
+  /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
 
-  thread = GET_THREAD (inferior_pid);
+  thread = GET_THREAD (inferior_ptid);
 
   if (thread == 0)
     error ("sol_thread_fetch_registers:  thread == 0");
@@ -673,15 +673,15 @@ sol_thread_store_registers (int regno)
   caddr_t xregset;
 #endif
 
-  if (!is_thread (inferior_pid))
+  if (!is_thread (inferior_ptid))
     {				/* LWP: pass the request on to procfs.c */
       procfs_ops.to_store_registers (regno);
       return;
     }
 
-  /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
+  /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
 
-  thread = GET_THREAD (inferior_pid);
+  thread = GET_THREAD (inferior_ptid);
 
   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
   if (val != TD_OK)
@@ -774,11 +774,11 @@ sol_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite,
   int retval;
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  if (is_thread (inferior_pid) ||	/* A thread */
-      !target_thread_alive (inferior_pid))	/* An lwp, but not alive */
-    inferior_pid = procfs_first_available ();	/* Find any live lwp.  */
+  if (is_thread (inferior_ptid) ||	/* A thread */
+      !target_thread_alive (inferior_ptid))	/* An lwp, but not alive */
+    inferior_ptid = procfs_first_available ();	/* Find any live lwp.  */
   /* Note: don't need to call switch_to_thread; we're just reading memory.  */
 
   if (target_has_execution)
@@ -808,9 +808,9 @@ sol_thread_kill_inferior (void)
 }
 
 static void
-sol_thread_notice_signals (int pid)
+sol_thread_notice_signals (ptid_t ptid)
 {
-  procfs_ops.to_notice_signals (PIDGET (pid));
+  procfs_ops.to_notice_signals (pid_to_ptid (PIDGET (ptid)));
 }
 
 /* Fork an inferior process, and start debugging it with /proc.  */
@@ -820,18 +820,18 @@ sol_thread_create_inferior (char *exec_file, char *allargs, char **env)
 {
   procfs_ops.to_create_inferior (exec_file, allargs, env);
 
-  if (sol_thread_active && inferior_pid != 0)
+  if (sol_thread_active && !ptid_equal (inferior_ptid, null_ptid))
     {
-      main_ph.pid = inferior_pid;	/* Save for xfer_memory */
+      main_ph.ptid = inferior_ptid;	/* Save for xfer_memory */
 
       push_target (&sol_thread_ops);
 
-      inferior_pid = lwp_to_thread (inferior_pid);
-      if (inferior_pid == -1)
-	inferior_pid = main_ph.pid;
+      inferior_ptid = lwp_to_thread (inferior_ptid);
+      if (PIDGET (inferior_ptid) == -1)
+	inferior_ptid = main_ph.ptid;
 
-      if (!in_thread_list (inferior_pid))
-	add_thread (inferior_pid);
+      if (!in_thread_list (inferior_ptid))
+	add_thread (inferior_ptid);
     }
 }
 
@@ -915,7 +915,7 @@ sol_thread_can_run (void)
 
    SYNOPSIS
 
-   static bool sol_thread_alive (int pid);
+   static bool sol_thread_alive (ptid_t ptid);
 
    DESCRIPTION
 
@@ -924,14 +924,15 @@ sol_thread_can_run (void)
  */
 
 static int
-sol_thread_alive (int pid)
+sol_thread_alive (ptid_t ptid)
 {
-  if (is_thread (pid))		/* non-kernel thread */
+  if (is_thread (ptid))		/* non-kernel thread */
     {
       td_err_e val;
       td_thrhandle_t th;
+      int pid;
 
-      pid = GET_THREAD (pid);
+      pid = GET_THREAD (ptid);
       if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
 	return 0;		/* thread not found */
       if ((val = p_td_thr_validate (&th)) != TD_OK)
@@ -942,9 +943,9 @@ sol_thread_alive (int pid)
     /* kernel thread (LWP): let procfs test it */
     {
       if (target_has_execution)
-	return procfs_ops.to_thread_alive (pid);
+	return procfs_ops.to_thread_alive (ptid);
       else
-	return orig_core_ops.to_thread_alive (pid);
+	return orig_core_ops.to_thread_alive (ptid);
     }
 }
 
@@ -1050,11 +1051,11 @@ rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
 {
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  if (is_thread (inferior_pid) ||	/* A thread */
-      !target_thread_alive (inferior_pid))	/* An lwp, but not alive */
-    inferior_pid = procfs_first_available ();	/* Find any live lwp.  */
+  if (is_thread (inferior_ptid) ||	/* A thread */
+      !target_thread_alive (inferior_ptid))	/* An lwp, but not alive */
+    inferior_ptid = procfs_first_available ();	/* Find any live lwp.  */
   /* Note: don't need to call switch_to_thread; we're just reading memory.  */
 
 #if defined (__sparcv9)
@@ -1154,9 +1155,9 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 {
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
 
   if (target_has_execution)
     procfs_ops.to_fetch_registers (-1);
@@ -1177,9 +1178,9 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 {
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
 
   supply_gregset ((gdb_gregset_t *) gregset);
   if (target_has_execution)
@@ -1286,9 +1287,9 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 {
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
 
   if (target_has_execution)
     procfs_ops.to_fetch_registers (-1);
@@ -1309,9 +1310,9 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 {
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
 
   supply_fpregset ((gdb_fpregset_t *) fpregset);
   if (target_has_execution)
@@ -1353,16 +1354,16 @@ ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 	    struct ssd *pldt)
 {
   /* NOTE: only used on Solaris, therefore OK to refer to procfs.c */
-  extern struct ssd *procfs_find_LDT_entry (int);
+  extern struct ssd *procfs_find_LDT_entry (ptid_t);
   struct ssd *ret;
 
   /* FIXME: can't I get the process ID from the prochandle or something?
    */
 
-  if (inferior_pid <= 0 || lwpid <= 0)
+  if (PIDGET (inferior_ptid) <= 0 || lwpid <= 0)
     return PS_BADLID;
 
-  ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_pid)));
+  ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_ptid)));
   if (ret)
     {
       memcpy (pldt, ret, sizeof (struct ssd));
@@ -1376,31 +1377,31 @@ ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 /* Convert a pid to printable form. */
 
 char *
-solaris_pid_to_str (int pid)
+solaris_pid_to_str (ptid_t ptid)
 {
   static char buf[100];
 
   /* in case init failed to resolve the libthread_db library */
   if (!procfs_suppress_run)
-    return procfs_pid_to_str (pid);
+    return procfs_pid_to_str (ptid);
 
-  if (is_thread (pid))
+  if (is_thread (ptid))
     {
-      int lwp;
+      ptid_t lwp;
 
-      lwp = thread_to_lwp (pid, -2);
+      lwp = thread_to_lwp (ptid, -2);
 
-      if (lwp == -1)
-	sprintf (buf, "Thread %d (defunct)", GET_THREAD (pid));
-      else if (lwp != -2)
-	sprintf (buf, "Thread %d (LWP %d)", GET_THREAD (pid), GET_LWP (lwp));
+      if (PIDGET (lwp) == -1)
+	sprintf (buf, "Thread %ld (defunct)", GET_THREAD (ptid));
+      else if (PIDGET (lwp) != -2)
+	sprintf (buf, "Thread %ld (LWP %ld)", GET_THREAD (ptid), GET_LWP (lwp));
       else
-	sprintf (buf, "Thread %d        ", GET_THREAD (pid));
+	sprintf (buf, "Thread %ld        ", GET_THREAD (ptid));
     }
-  else if (GET_LWP (pid) != 0)
-    sprintf (buf, "LWP    %d        ", GET_LWP (pid));
+  else if (GET_LWP (ptid) != 0)
+    sprintf (buf, "LWP    %ld        ", GET_LWP (ptid));
   else
-    sprintf (buf, "process %d    ", PIDGET (pid));
+    sprintf (buf, "process %d    ", PIDGET (ptid));
 
   return buf;
 }
@@ -1415,15 +1416,15 @@ sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
 {
   td_err_e retval;
   td_thrinfo_t ti;
-  int pid;
+  ptid_t ptid;
 
   if ((retval = p_td_thr_get_info (th, &ti)) != TD_OK)
     {
       return -1;
     }
-  pid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_pid));
-  if (!in_thread_list (pid))
-    add_thread (pid);
+  ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid));
+  if (!in_thread_list (ptid))
+    add_thread (ptid);
 
   return 0;
 }
@@ -1435,12 +1436,12 @@ sol_find_new_threads (void)
   if (!procfs_suppress_run)
     return;
 
-  if (inferior_pid == -1)
+  if (PIDGET (inferior_ptid) == -1)
     {
       printf_filtered ("No process.\n");
       return;
     }
-  procfs_find_new_threads ();	/* first find new kernel threads. */
+  procfs_ops.to_find_new_threads ();	/* first find new kernel threads */
   p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0,
 		    TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
 		    TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);