From 39f770628a4eaf018fec8d55684bf2ec16ada9cc Mon Sep 17 00:00:00 2001 From: Kevin Buettner Date: Fri, 4 May 2001 04:15:33 +0000 Subject: Phase 1 of the ptid_t changes. --- gdb/uw-thread.c | 161 ++++++++++++++++++++++++++++++-------------------------- 1 file changed, 85 insertions(+), 76 deletions(-) (limited to 'gdb/uw-thread.c') diff --git a/gdb/uw-thread.c b/gdb/uw-thread.c index 8f1d1c6..617cfbd 100644 --- a/gdb/uw-thread.c +++ b/gdb/uw-thread.c @@ -135,7 +135,7 @@ #endif /* Back end to CALL_BASE() and TRY_BASE(): evaluate CALL, then convert - inferior_pid to a composite thread/process id. */ + inferior_ptid to a composite thread/process id. */ #define CALL_BASE_1(call) \ do { \ @@ -144,8 +144,8 @@ do { \ do_cleanups (infpid_cleanup); \ } while (0) -/* If inferior_pid can be converted to a composite lwp/process id, do so, - evaluate base_ops function CALL, and then convert inferior_pid back to a +/* If inferior_ptid can be converted to a composite lwp/process id, do so, + evaluate base_ops function CALL, and then convert inferior_ptid back to a composite thread/process id. Otherwise, issue an error message and return nonlocally. */ @@ -158,7 +158,7 @@ do { \ } while (0) /* Like CALL_BASE(), but instead of returning nonlocally on error, set - *CALLED to whether the inferior_pid conversion was successful. */ + *CALLED to whether the inferior_ptid conversion was successful. */ #define TRY_BASE(call, called) \ do { \ @@ -220,7 +220,7 @@ static CORE_ADDR thr_map_main; libthread.so passes null map when calling stub with tc_*_complete. */ static struct thread_info *switchto_thread; -/* Cleanup chain for safely restoring inferior_pid after CALL_BASE. */ +/* Cleanup chain for safely restoring inferior_ptid after CALL_BASE. */ static struct cleanup *infpid_cleanup; @@ -261,7 +261,7 @@ dbg (char *fmt, ...) /* Return a string representing composite PID's components. */ static char * -dbgpid (int pid) +dbgpid (ptid_t ptid) { static char *buf, buf1[80], buf2[80]; if (!buf || buf == buf2) @@ -269,10 +269,10 @@ dbgpid (int pid) else buf = buf2; - if (pid <= 0) - sprintf (buf, "%d", pid); + if (PIDGET (ptid) <= 0) + sprintf (buf, "%d", PIDGET (ptid)); else - sprintf (buf, "%s %d/%d", ISTID (pid) ? "thr" : "lwp", + sprintf (buf, "%s %ld/%d", ISTID (pid) ? "thr" : "lwp", TIDGET (pid), PIDGET (pid)); return buf; @@ -404,20 +404,20 @@ deactivate_uw_thread (void) /* Return the composite lwp/process id corresponding to composite id PID. If PID is a thread with no lwp, return 0. */ -static int -thr_to_lwp (int pid) +static ptid_t +thr_to_lwp (ptid_t ptid) { struct thread_info *info; - int lid; + ptid_t lid; - if (!ISTID (pid)) - lid = pid; - else if (!(info = find_thread_pid (pid))) - lid = 0; + if (!ISTID (ptid)) + lid = ptid; + else if (!(info = find_thread_pid (ptid))) + lid = null_ptid; else if (!info->private->lwpid) - lid = 0; + lid = null_ptid; else - lid = MKLID (pid, info->private->lwpid); + lid = MKLID (PIDGET (ptid), info->private->lwpid); DBG2((" thr_to_lwp(%s) = %s", dbgpid (pid), dbgpid (lid))); return lid; @@ -431,7 +431,7 @@ find_thread_lwp_callback (struct thread_info *tp, void *data) { int lwpid = (int)data; - if (!ISTID (tp->pid)) + if (!ISTID (tp->ptid)) return 0; if (!tp->private->stable) return 0; @@ -454,51 +454,52 @@ find_thread_lwp (int lwpid) /* Return the composite thread/process id corresponding to composite id PID. If PID is an lwp with no thread, return PID. */ -static int -lwp_to_thr (int pid) +static ptid_t +lwp_to_thr (ptid_t ptid) { struct thread_info *info; - int tid = pid, lwpid; + int lwpid; + ptid_t tid = ptid; - if (ISTID (pid)) + if (ISTID (ptid)) goto done; - if (!(lwpid = LIDGET (pid))) + if (!(lwpid = LIDGET (ptid))) goto done; if (!(info = find_thread_lwp (lwpid))) goto done; - tid = MKTID (pid, info->private->thrid); + tid = MKTID (PIDGET (ptid), info->private->thrid); done: - DBG2((ISTID (tid) ? NULL : "lwp_to_thr: no thr for %s", dbgpid (pid))); + DBG2((ISTID (tid) ? NULL : "lwp_to_thr: no thr for %s", dbgpid (ptid))); return tid; } -/* do_cleanups() callback: convert inferior_pid to a composite +/* do_cleanups() callback: convert inferior_ptid to a composite thread/process id after having made a procfs call. */ static void thr_infpid (void *unused) { - int pid = lwp_to_thr (inferior_pid); - DBG2((" inferior_pid from procfs: %s => %s", - dbgpid (inferior_pid), dbgpid (pid))); - inferior_pid = pid; + ptid_t ptid = lwp_to_thr (inferior_ptid); + DBG2((" inferior_ptid from procfs: %s => %s", + dbgpid (inferior_ptid), dbgpid (ptid))); + inferior_ptid = ptid; } -/* If possible, convert inferior_pid to a composite lwp/process id in +/* If possible, convert inferior_ptid to a composite lwp/process id in preparation for making a procfs call. Return success. */ static int lwp_infpid (void) { - int pid = thr_to_lwp (inferior_pid); - DBG2((" inferior_pid to procfs: %s => %s", - dbgpid (inferior_pid), dbgpid (pid))); + ptid_t ptid = thr_to_lwp (inferior_ptid); + DBG2((" inferior_ptid to procfs: %s => %s", + dbgpid (inferior_ptid), dbgpid (ptid))); - if (!pid) + if (ptid_equal (ptid, null_ptid)) return 0; - inferior_pid = pid; + inferior_ptid = ptid; infpid_cleanup = make_cleanup (thr_infpid, NULL); return 1; } @@ -507,11 +508,11 @@ lwp_infpid (void) lwp id LWPID, map address MAPP, and composite thread/process PID. */ static void -add_thread_uw (int thrid, int lwpid, CORE_ADDR mapp, int pid) +add_thread_uw (int thrid, int lwpid, CORE_ADDR mapp, ptid_t ptid) { struct thread_info *newthread; - if ((newthread = add_thread (pid)) == NULL) + if ((newthread = add_thread (ptid)) == NULL) error ("failed to create new thread structure"); newthread->private = xmalloc (sizeof (struct private_thread_info)); @@ -521,7 +522,7 @@ add_thread_uw (int thrid, int lwpid, CORE_ADDR mapp, int pid) newthread->private->mapp = mapp; if (target_has_execution) - printf_unfiltered ("[New %s]\n", target_pid_to_str (pid)); + printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid)); } /* notice_threads() and find_main() callback: if the thread list doesn't @@ -533,10 +534,10 @@ notice_thread (iter_t *iter, void *data) { int thrid = iter->map.thr_tid; int lwpid = !iter->map.thr_lwpp ? 0 : iter->lwp.lwp_id; - int pid = MKTID (inferior_pid, thrid); + ptid_t ptid = MKTID (PIDGET (inferior_ptid), thrid); - if (!find_thread_pid (pid) && (!data || thrid == 1)) - add_thread_uw (thrid, lwpid, iter->mapp, pid); + if (!find_thread_pid (ptid) && (!data || thrid == 1)) + add_thread_uw (thrid, lwpid, iter->mapp, ptid); return 0; } @@ -558,7 +559,7 @@ find_main (void) { struct thread_info *info; thread_iter (notice_thread, (void *)1); - if ((info = find_thread_pid (MKTID (inferior_pid, 1)))) + if ((info = find_thread_pid (MKTID (PIDGET (inferior_ptid), 1)))) thr_map_main = info->private->mapp; } return thr_map_main; @@ -590,12 +591,16 @@ uw_thread_detach (char *args, int from_tty) and all threads otherwise. */ static void -uw_thread_resume (int pid, int step, enum target_signal signo) +uw_thread_resume (ptid_t ptid, int step, enum target_signal signo) { - if (pid > 0 && !(pid = thr_to_lwp (pid))) - pid = -1; + if (PIDGET (ptid) > 0) + { + ptid = thr_to_lwp (ptid); + if (ptid_equal (ptid, null_ptid)) + ptid = pid_to_ptid (-1); + } - CALL_BASE (base_ops.to_resume (pid, step, signo)); + CALL_BASE (base_ops.to_resume (ptid, step, signo)); } /* If the trap we just received from lwp PID was due to a breakpoint @@ -603,21 +608,22 @@ uw_thread_resume (int pid, int step, enum target_signal signo) accordingly. */ static void -libthread_stub (int pid) +libthread_stub (ptid_t ptid) { CORE_ADDR sp, mapp, mapp_main; enum thread_change change; struct thread_map map; __lwp_desc_t lwp; - int tid = 0, lwpid; + int lwpid; + ptid_t tid = null_ptid; struct thread_info *info; /* Check for stub breakpoint. */ - if (read_pc_pid (pid) - DECR_PC_AFTER_BREAK != thr_brk_addr) + if (read_pc_pid (ptid) - DECR_PC_AFTER_BREAK != thr_brk_addr) return; /* Retrieve stub args. */ - sp = read_register_pid (SP_REGNUM, pid); + sp = read_register_pid (SP_REGNUM, ptid); if (!base_ops.to_xfer_memory (sp + SP_ARG0, (char *)&mapp, sizeof (mapp), 0, NULL, &base_ops)) goto err; @@ -642,7 +648,7 @@ libthread_stub (int pid) break; if (!read_map (mapp, &map)) goto err; - tid = MKTID (pid, map.thr_tid); + tid = MKTID (PIDGET (ptid), map.thr_tid); switch (change) { case tc_thread_create: /* new thread */ @@ -658,8 +664,8 @@ libthread_stub (int pid) case tc_thread_exit: /* thread has exited */ printf_unfiltered ("[Exited %s]\n", target_pid_to_str (tid)); delete_thread (tid); - if (tid == inferior_pid) - inferior_pid = pid; + if (ptid_equal (tid, inferior_ptid)) + inferior_ptid = ptid; break; case tc_switch_begin: /* lwp is switching threads */ @@ -720,22 +726,25 @@ libthread_stub (int pid) /* Wait for thread/lwp/process ID if >= 0 or for any thread otherwise. */ -static int -uw_thread_wait (int pid, struct target_waitstatus *status) +static ptid_t +uw_thread_wait (ptid_t ptid, struct target_waitstatus *status) { - if (pid > 0) - pid = thr_to_lwp (pid); - CALL_BASE (pid = base_ops.to_wait (pid > 0 ? pid : -1, status)); + if (PIDGET (ptid) > 0) + ptid = thr_to_lwp (ptid); + if (PIDGET (ptid) <= 0) + ptid = pid_to_ptid (-1); + + CALL_BASE (ptid = base_ops.to_wait (ptid, status)); if (status->kind == TARGET_WAITKIND_STOPPED && status->value.sig == TARGET_SIGNAL_TRAP) - libthread_stub (pid); + libthread_stub (ptid); - return lwp_to_thr (pid); + return lwp_to_thr (ptid); } /* Tell gdb about the registers in the thread/lwp/process specified by - inferior_pid. */ + inferior_ptid. */ static void uw_thread_fetch_registers (int regno) @@ -748,7 +757,7 @@ uw_thread_fetch_registers (int regno) if (called) return; - if (!(info = find_thread_pid (inferior_pid))) + if (!(info = find_thread_pid (inferior_ptid))) return; if (!read_map (info->private->mapp, &map)) return; @@ -758,7 +767,7 @@ uw_thread_fetch_registers (int regno) } /* Store gdb's current view of the register set into the thread/lwp/process - specified by inferior_pid. */ + specified by inferior_ptid. */ static void uw_thread_store_registers (int regno) @@ -822,14 +831,14 @@ uw_thread_can_run (void) /* Return whether thread PID is still valid. */ static int -uw_thread_alive (int pid) +uw_thread_alive (ptid_t ptid) { - if (!ISTID (pid)) - return base_ops.to_thread_alive (pid); + if (!ISTID (ptid)) + return base_ops.to_thread_alive (ptid); /* If it's in the thread list, it's valid, because otherwise libthread_stub() would have deleted it. */ - return in_thread_list (pid); + return in_thread_list (ptid); } /* Add to the thread list any threads and lwps it doesn't already contain. */ @@ -846,16 +855,16 @@ uw_thread_find_new_threads (void) This may be called by either procfs.c or by generic gdb. */ static char * -uw_thread_pid_to_str (int pid) +uw_thread_pid_to_str (ptid_t ptid) { -#define FMT "Thread %d" - static char buf[sizeof (FMT) + 3 * sizeof (pid)]; +#define FMT "Thread %ld" + static char buf[sizeof (FMT) + 3 * sizeof (long)]; - if (!ISTID (pid)) + if (!ISTID (ptid)) /* core_ops says "process foo", so call procfs_ops explicitly. */ - return procfs_ops.to_pid_to_str (pid); + return procfs_ops.to_pid_to_str (ptid); - sprintf (buf, FMT, TIDGET (pid)); + sprintf (buf, FMT, TIDGET (ptid)); #undef FMT return buf; } @@ -872,7 +881,7 @@ uw_extra_thread_info (struct thread_info *info) int lwpid; char *name; - if (!ISTID (info->pid)) + if (!ISTID (info->ptid)) return NULL; if (!info->private->stable) -- cgit v1.1