 @@ -73,32 +73,26 @@ static int nbsd_thread_active = 0;
 static int nbsd_thread_core = 0;
 static ptid_t main_ptid;		/* Real process ID */
 static ptid_t cached_thread;
 struct target_ops nbsd_thread_ops;
 struct td_proc_callbacks_t nbsd_thread_callbacks;
 static ptid_t find_active_thread (void);
 static void nbsd_find_new_threads (struct target_ops *);
 #define GET_PID(ptid)		ptid_get_pid (ptid)
 #define GET_LWP(ptid)		ptid_get_lwp (ptid)
 #define IS_LWP(ptid)		(GET_LWP (ptid) != 0)
 #define BUILD_LWP(lwp, ptid)	ptid_build (GET_PID(ptid), (lwp), 0)
 static td_proc_t *main_ta;
 struct nbsd_thread_proc_arg {
   struct target_ops *ops;
   struct regcache *cache;
 } main_arg;
 static const char *syncnames[] = {
   "unknown", "mutex", "cond var", "spinlock", "thread"
 };
 struct string_map
 @@ -133,27 +127,28 @@ td_err_string (int errcode)
       return td_err_table[i].str;
   sprintf (buf, "Unknown thread_db error code: %d", errcode);
   return buf;
+}
 static void
 nbsd_thread_activate (void)
+{
   nbsd_thread_active = 1;
   main_ptid = inferior_ptid;
   cached_thread = minus_one_ptid;
-  thread_change_ptid(inferior_ptid, BUILD_LWP(1, inferior_ptid));
+  thread_change_ptid(inferior_ptid,
       ptid_build (ptid_get_pid (inferior_ptid), 1, 0));
   nbsd_find_new_threads (NULL);
   inferior_ptid = find_active_thread ();
+}
 static void
 nbsd_thread_deactivate (void)
+{
   td_close (main_ta);
   inferior_ptid = main_ptid;
   main_ptid = minus_one_ptid;
   cached_thread = main_ptid;
   nbsd_thread_active = 0;
 @@ -270,40 +265,41 @@ static ptid_t
 find_active_thread (void)
+{
   int val;
   td_thread_t *thread;
   td_thread_info_t ti;
   struct ptrace_lwpinfo pl;
   if (!ptid_equal (cached_thread, minus_one_ptid))
     return cached_thread;
   if (target_has_execution)
+    {
       pl.pl_lwpid = 0;
-      val = ptrace (PT_LWPINFO, GET_PID(inferior_ptid), (void *)&pl, sizeof(pl));
+      val = ptrace (PT_LWPINFO, ptid_get_pid(inferior_ptid), (void *)&pl, sizeof(pl));
       while ((val != -1) && (pl.pl_lwpid != 0) &&
-	     (pl.pl_event != PL_EVENT_SIGNAL))
+	     (pl.pl_event != PL_EVENT_SIGNAL)) {
-	val = ptrace (PT_LWPINFO, GET_PID(inferior_ptid), (void *)&pl, sizeof(pl));
+	val = ptrace (PT_LWPINFO, ptid_get_pid(inferior_ptid), (void *)&pl, sizeof(pl));
+    }
       if (pl.pl_lwpid == 0)
 	/* found no "active" thread, stay with current */
 	pl.pl_lwpid = inferior_ptid.lwp;
+    }
   else
+    {
       return inferior_ptid;
+    }
-  cached_thread = BUILD_LWP (pl.pl_lwpid, main_ptid);
+  cached_thread = ptid_build (ptid_get_pid (main_ptid), pl.pl_lwpid, 0);
   return cached_thread;
+}
 /* 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 ptid_t
 nbsd_thread_wait (struct target_ops *ops, ptid_t ptid,
   struct target_waitstatus *ourstatus, int options)
+{
   ptid_t rtnval;
   struct target_ops *beneath = find_target_beneath (ops);
 @@ -331,28 +327,28 @@ nbsd_thread_fetch_registers (struct targ
   struct target_ops *beneath = find_target_beneath (ops);
   td_thread_t *thread;
   gregset_t gregs;
 #ifdef HAVE_FPREGS
   fpregset_t fpregs;
 #endif
   int val;
   struct cleanup *old_chain;
   old_chain = save_inferior_ptid ();
   if (!target_has_execution)
+    {
-      inferior_ptid = pid_to_ptid ((GET_LWP (inferior_ptid) << 16) |
+      inferior_ptid = pid_to_ptid ((ptid_get_lwp (inferior_ptid) << 16) |
-				    GET_PID (inferior_ptid));
+				    ptid_get_pid (inferior_ptid));
+    }
     beneath->to_fetch_registers (beneath, cache, regno);
   do_cleanups (old_chain);
+}
 static void
 nbsd_thread_store_registers (struct target_ops *ops, struct regcache *cache,
     int regno)
+{
   struct target_ops *beneath = find_target_beneath (ops);
   td_thread_t *thread;
   gregset_t gregs;
 @@ -408,49 +404,49 @@ nbsd_core_files_info (struct target_ops
   struct target_ops *beneath = find_target_beneath (ignore);
   beneath->to_files_info (beneath);
+}
 /* Convert a ptid to printable form. */
 static char *
 nbsd_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
   static char buf[100];
   td_thread_t *th;
   char name[32];
-  if ((GET_LWP(ptid) == 0) &&
+  if ((ptid_get_lwp(ptid) == 0) &&
       (nbsd_thread_active == 0))
-    sprintf (buf, "process %d", GET_PID (ptid));
+    sprintf (buf, "process %d", ptid_get_pid (ptid));
   else
-    sprintf (buf, "LWP %ld", GET_LWP (ptid));
+    sprintf (buf, "LWP %ld", ptid_get_lwp (ptid));
   return buf;
+}
 #ifdef notdef
 static void
 nbsd_add_to_thread_list (bfd *abfd, asection *asect, PTR reg_sect_arg)
+{
   int regval;
   td_thread_t *dummy;
   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
     return;
   regval = atoi (bfd_section_name (abfd, asect) + 5);
-  add_thread (BUILD_LWP(regval, main_ptid));
+  add_thread (ptid_build (ptid_get_pid (main_ptid), regval, 0));
+}
 #endif
 /* This routine is called whenever a new symbol table is read in, or when all
    symbol tables are removed.  libthread_db can only be initialized when it
    finds the right variables in libthread.so.  Since it's a shared library,
    those variables don't show up until the library gets mapped and the symbol
    table is read in.  */
 /* This new_objfile event is now managed by a chained function pointer.
  * It is the callee's responsability to call the next client on the chain.
  */
 @@ -495,31 +491,31 @@ quit:
   return;
+}
 static int
 nbsd_thread_alive (struct target_ops *ops, ptid_t ptid)
+{
   struct target_ops *beneath = find_target_beneath (ops);
   td_thread_t *th;
   td_thread_info_t ti;
   int val;
   if (nbsd_thread_active)
+    {
-      if (IS_LWP (ptid))
+      if (ptid_lwp_p (ptid))
+	{
 	  struct ptrace_lwpinfo pl;
-	  pl.pl_lwpid = GET_LWP (ptid);
+	  pl.pl_lwpid = ptid_get_lwp (ptid);
-	  val = ptrace (PT_LWPINFO, GET_PID (ptid), (void *)&pl, sizeof(pl));
+	  val = ptrace (PT_LWPINFO, ptid_get_pid (ptid), (void *)&pl, sizeof(pl));
 	  if (val == -1)
 	    val = 0;
 	  else
 	    val = 1;
+	}
       else
 	val = beneath->to_thread_alive (beneath, ptid);
+    }
   else
     val = beneath->to_thread_alive (beneath, ptid);
   return val;
+}
 @@ -543,33 +539,33 @@ nbsd_find_new_threads (struct target_ops
   if (nbsd_thread_active == 0)
 	  return;
   if (ptid_equal (inferior_ptid, minus_one_ptid))
+    {
       printf_filtered ("No process.\n");
       return;
+    }
   if (target_has_execution)
+    {
       struct ptrace_lwpinfo pl;
       pl.pl_lwpid = 0;
-      retval = ptrace (PT_LWPINFO, GET_PID(inferior_ptid), (void *)&pl, sizeof(pl));
+      retval = ptrace (PT_LWPINFO, ptid_get_pid(inferior_ptid), (void *)&pl, sizeof(pl));
       while ((retval != -1) && pl.pl_lwpid != 0)
+	{
-	  ptid = BUILD_LWP (pl.pl_lwpid, main_ptid);
+	  ptid = ptid_build (ptid_get_pid (main_ptid), pl.pl_lwpid, 0);
 	  if (!in_thread_list (ptid))
 	    add_thread (ptid);
-	  retval = ptrace (PT_LWPINFO, GET_PID(inferior_ptid), (void *)&pl, sizeof(pl));
+	  retval = ptrace (PT_LWPINFO, ptid_get_pid(inferior_ptid), (void *)&pl, sizeof(pl));
+	}
+    }
+}
 /* Fork an inferior process, and start debugging it.  */
 static void
 nbsd_thread_create_inferior (struct target_ops *ops, char *exec_file,
 			     char *allargs, char **env, int from_tty)
+{
   struct target_ops *beneath = find_target_beneath (ops);
   nbsd_thread_core = 0;
 @@ -658,35 +654,35 @@ nbsd_thread_proc_getregs (void *arg, int
   struct nbsd_thread_proc_arg *a = arg;
   struct regcache *cache = a->cache;
   struct target_ops *ops = a->ops;
   struct cleanup *old_chain;
   struct target_ops *beneath = find_target_beneath (ops);
   int ret;
   old_chain = save_inferior_ptid ();
   if (target_has_execution)
+    {
       /* Fetching registers from a live process requires that
 	 inferior_ptid is a LWP value rather than a thread value. */
-      inferior_ptid = BUILD_LWP (lwp, main_ptid);
+      inferior_ptid = ptid_build (ptid_get_pid (main_ptid), lwp, 0);
       beneath->to_fetch_registers (beneath, cache, -1);
+    }
   else
+    {
       /* Fetching registers from a core process requires that
 	 the PID value of inferior_ptid have the funky value that
 	 the kernel drops rather than the real PID. Gross. */
-      inferior_ptid = pid_to_ptid ((lwp << 16) | GET_PID (main_ptid));
+      inferior_ptid = pid_to_ptid ((lwp << 16) | ptid_get_pid (main_ptid));
       beneath->to_fetch_registers (ops, cache, -1);
+    }
   ret = 0;
   switch (regset)
+    {
     case 0:
       fill_gregset (cache, (gregset_t *)buf, -1);
       break;
     case 1:
 #ifdef HAVE_FPREGS
       fill_fpregset (cache, (fpregset_t *)buf, -1);
 #endif
 @@ -719,27 +715,27 @@ nbsd_thread_proc_setregs (void *arg, int
       supply_gregset(cache, (gregset_t *)buf);
       break;
     case 1:
 #ifdef HAVE_FPREGS
       supply_fpregset(cache, (fpregset_t *)buf);
 #endif
       break;
     default: /* XXX need to handle other reg sets: SSE, AltiVec, etc. */
       ret = TD_ERR_INVAL;
+    }
   /* Storing registers requires that inferior_ptid is a LWP value
      rather than a thread value. */
-  inferior_ptid = BUILD_LWP (lwp, main_ptid);
+  inferior_ptid = ptid_build (ptid_get_pid (main_ptid), lwp, 0);
   beneath->to_store_registers (beneath, cache, -1);
   do_cleanups (old_chain);
   return ret;
+}
 static void
 init_nbsd_proc_callbacks (void)
+{
   nbsd_thread_callbacks.proc_read = nbsd_thread_proc_read;
   nbsd_thread_callbacks.proc_write = nbsd_thread_proc_write;
   nbsd_thread_callbacks.proc_lookup = nbsd_thread_proc_lookup;
   nbsd_thread_callbacks.proc_regsize = nbsd_thread_proc_regsize;