diff options
Diffstat (limited to 'packages/gdb/gdb-6.8')
| -rw-r--r-- | packages/gdb/gdb-6.8/.mtn2git_empty | 0 | ||||
| -rw-r--r-- | packages/gdb/gdb-6.8/early_debug_in_nptl.patch | 306 |
2 files changed, 306 insertions, 0 deletions
diff --git a/packages/gdb/gdb-6.8/.mtn2git_empty b/packages/gdb/gdb-6.8/.mtn2git_empty new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/packages/gdb/gdb-6.8/.mtn2git_empty diff --git a/packages/gdb/gdb-6.8/early_debug_in_nptl.patch b/packages/gdb/gdb-6.8/early_debug_in_nptl.patch new file mode 100644 index 0000000000..c53f0d8ad5 --- /dev/null +++ b/packages/gdb/gdb-6.8/early_debug_in_nptl.patch @@ -0,0 +1,306 @@ +http://sourceware.org/ml/gdb-patches/2007-06/msg00479.html + +Index: gdb/linux-thread-db.c +=================================================================== +--- gdb/linux-thread-db.c.orig 2006-10-20 03:08:14.000000000 +0200 ++++ gdb/linux-thread-db.c 2008-03-01 14:45:52.000000000 +0100 +@@ -213,6 +213,21 @@ + } + } + ++/* Return 1 if any threads have been registered. There may be none if ++ the threading library is not fully initialized yet. */ ++ ++static int ++have_threads_callback (struct thread_info *thread, void *dummy) ++{ ++ return 1; ++} ++ ++static int ++have_threads (void) ++{ ++ return iterate_over_threads (have_threads_callback, NULL) != NULL; ++} ++ + /* A callback function for td_ta_thr_iter, which we use to map all + threads to LWPs. + +@@ -700,23 +715,6 @@ + } + + static void +-thread_db_attach (char *args, int from_tty) +-{ +- target_beneath->to_attach (args, from_tty); +- +- /* Destroy thread info; it's no longer valid. */ +- init_thread_list (); +- +- /* The child process is now the actual multi-threaded +- program. Snatch its process ID... */ +- proc_handle.pid = GET_PID (inferior_ptid); +- +- /* ...and perform the remaining initialization steps. */ +- enable_thread_event_reporting (); +- thread_db_find_new_threads (); +-} +- +-static void + detach_thread (ptid_t ptid, int verbose) + { + struct thread_info *thread_info; +@@ -742,14 +740,13 @@ + disable_thread_event_reporting (); + + /* There's no need to save & restore inferior_ptid here, since the +- inferior is supposed to be survive this function call. */ ++ inferior is not supposed to survive this function call. */ + inferior_ptid = lwp_from_thread (inferior_ptid); + +- /* Forget about the child's process ID. We shouldn't need it +- anymore. */ +- proc_handle.pid = 0; +- + target_beneath->to_detach (args, from_tty); ++ ++ /* Should this be done by detach_command? */ ++ target_mourn_inferior (); + } + + static int +@@ -870,12 +867,6 @@ + + ptid = target_beneath->to_wait (ptid, ourstatus); + +- if (proc_handle.pid == 0) +- /* The current child process isn't the actual multi-threaded +- program yet, so don't try to do any special thread-specific +- post-processing and bail out early. */ +- return ptid; +- + if (ourstatus->kind == TARGET_WAITKIND_EXITED + || ourstatus->kind == TARGET_WAITKIND_SIGNALLED) + return pid_to_ptid (-1); +@@ -889,23 +880,32 @@ + return pid_to_ptid (GET_PID (ptid)); + } + ++ /* If we do not know about the main thread yet, this would be a good time to ++ find it. */ ++ if (ourstatus->kind == TARGET_WAITKIND_STOPPED && !have_threads ()) ++ thread_db_find_new_threads (); ++ + if (ourstatus->kind == TARGET_WAITKIND_STOPPED + && ourstatus->value.sig == TARGET_SIGNAL_TRAP) + /* Check for a thread event. */ + check_event (ptid); + +- if (!ptid_equal (trap_ptid, null_ptid)) +- trap_ptid = thread_from_lwp (trap_ptid); ++ if (have_threads ()) ++ { ++ /* Change ptids back into the higher level PID + TID format. If ++ the thread is dead and no longer on the thread list, we will ++ get back a dead ptid. This can occur if the thread death ++ event gets postponed by other simultaneous events. In such a ++ case, we want to just ignore the event and continue on. */ ++ ++ if (!ptid_equal (trap_ptid, null_ptid)) ++ trap_ptid = thread_from_lwp (trap_ptid); ++ ++ ptid = thread_from_lwp (ptid); ++ if (GET_PID (ptid) == -1) ++ ourstatus->kind = TARGET_WAITKIND_SPURIOUS; ++ } + +- /* Change the ptid back into the higher level PID + TID format. +- If the thread is dead and no longer on the thread list, we will +- get back a dead ptid. This can occur if the thread death event +- gets postponed by other simultaneous events. In such a case, +- we want to just ignore the event and continue on. */ +- ptid = thread_from_lwp (ptid); +- if (GET_PID (ptid) == -1) +- ourstatus->kind = TARGET_WAITKIND_SPURIOUS; +- + return ptid; + } + +@@ -944,30 +944,6 @@ + } + + static void +-thread_db_create_inferior (char *exec_file, char *allargs, char **env, +- int from_tty) +-{ +- unpush_target (&thread_db_ops); +- using_thread_db = 0; +- target_beneath->to_create_inferior (exec_file, allargs, env, from_tty); +-} +- +-static void +-thread_db_post_startup_inferior (ptid_t ptid) +-{ +- if (proc_handle.pid == 0) +- { +- /* The child process is now the actual multi-threaded +- program. Snatch its process ID... */ +- proc_handle.pid = GET_PID (ptid); +- +- /* ...and perform the remaining initialization steps. */ +- enable_thread_event_reporting (); +- thread_db_find_new_threads (); +- } +-} +- +-static void + thread_db_mourn_inferior (void) + { + /* Forget about the child's process ID. We shouldn't need it +@@ -1002,6 +978,22 @@ + + ptid = ptid_build (GET_PID (inferior_ptid), ti.ti_lid, ti.ti_tid); + ++ if (ti.ti_tid == 0) ++ { ++ /* A thread ID of zero means that this is the main thread, but ++ glibc has not yet initialized thread-local storage and the ++ pthread library. We do not know what the thread's TID will ++ be yet. Just enable event reporting and otherwise ignore ++ it. */ ++ ++ err = td_thr_event_enable_p (th_p, 1); ++ if (err != TD_OK) ++ error (_("Cannot enable thread event reporting for %s: %s"), ++ target_pid_to_str (ptid), thread_db_err_str (err)); ++ ++ return 0; ++ } ++ + if (!in_thread_list (ptid)) + attach_thread (ptid, th_p, &ti, 1); + +@@ -1058,6 +1050,16 @@ + return NULL; + } + ++/* Return 1 if this thread has the same LWP as the passed PTID. */ ++ ++static int ++same_ptid_callback (struct thread_info *thread, void *arg) ++{ ++ ptid_t *ptid_p = arg; ++ ++ return GET_LWP (thread->ptid) == GET_LWP (*ptid_p); ++} ++ + /* Get the address of the thread local variable in load module LM which + is stored at OFFSET within the thread local storage for thread PTID. */ + +@@ -1066,6 +1068,21 @@ + CORE_ADDR lm, + CORE_ADDR offset) + { ++ /* If we have not discovered any threads yet, check now. */ ++ if (!is_thread (ptid) && !have_threads ()) ++ thread_db_find_new_threads (); ++ ++ /* Try to find a matching thread if we still have the LWP ID instead ++ of the thread ID. */ ++ if (!is_thread (ptid)) ++ { ++ struct thread_info *thread; ++ ++ thread = iterate_over_threads (same_ptid_callback, &ptid); ++ if (thread != NULL) ++ ptid = thread->ptid; ++ } ++ + if (is_thread (ptid)) + { + td_err_e err; +@@ -1125,14 +1142,11 @@ + thread_db_ops.to_shortname = "multi-thread"; + thread_db_ops.to_longname = "multi-threaded child process."; + thread_db_ops.to_doc = "Threads and pthreads support."; +- thread_db_ops.to_attach = thread_db_attach; + thread_db_ops.to_detach = thread_db_detach; + thread_db_ops.to_resume = thread_db_resume; + thread_db_ops.to_wait = thread_db_wait; + thread_db_ops.to_xfer_partial = thread_db_xfer_partial; + thread_db_ops.to_kill = thread_db_kill; +- thread_db_ops.to_create_inferior = thread_db_create_inferior; +- thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior; + thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior; + thread_db_ops.to_find_new_threads = thread_db_find_new_threads; + thread_db_ops.to_pid_to_str = thread_db_pid_to_str; +Index: gdb/gdbserver/thread-db.c +=================================================================== +--- gdb/gdbserver/thread-db.c.orig 2006-10-17 18:02:27.000000000 +0200 ++++ gdb/gdbserver/thread-db.c 2008-03-01 14:44:41.000000000 +0100 +@@ -40,6 +40,7 @@ + /* Connection to the libthread_db library. */ + static td_thragent_t *thread_agent; + ++static void thread_db_find_new_threads (void); + static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data); + + static char * +@@ -134,6 +135,8 @@ + td_event_msg_t msg; + td_err_e err; + struct inferior_linux_data *tdata; ++ struct thread_info *inferior; ++ struct process_info *process; + + if (debug_threads) + fprintf (stderr, "Thread creation event.\n"); +@@ -149,6 +152,14 @@ + fprintf (stderr, "thread getmsg err: %s\n", + thread_db_err_str (err)); + ++ /* If we do not know about the main thread yet, this would be a good time to ++ find it. We need to do this to pick up the main thread before any newly ++ created threads. */ ++ inferior = (struct thread_info *) all_threads.head; ++ process = get_thread_process (inferior); ++ if (process->thread_known == 0) ++ thread_db_find_new_threads (); ++ + /* msg.event == TD_EVENT_CREATE */ + + find_new_threads_callback (msg.th_p, NULL); +@@ -231,8 +242,24 @@ + { + inferior = (struct thread_info *) all_threads.head; + process = get_thread_process (inferior); ++ + if (process->thread_known == 0) + { ++ /* If the new thread ID is zero, a final thread ID will be ++ available later. Do not enable thread debugging yet. */ ++ if (ti_p->ti_tid == 0) ++ { ++ err = td_thr_event_enable (th_p, 1); ++ if (err != TD_OK) ++ error ("Cannot enable thread event reporting for %d: %s", ++ ti_p->ti_lid, thread_db_err_str (err)); ++ return; ++ } ++ ++ if (process->lwpid != ti_p->ti_lid) ++ fatal ("PID mismatch! Expected %ld, got %ld", ++ (long) process->lwpid, (long) ti_p->ti_lid); ++ + /* Switch to indexing the threads list by TID. */ + change_inferior_id (&all_threads, ti_p->ti_tid); + goto found; +@@ -331,6 +358,8 @@ + + process = get_thread_process (thread); + if (!process->thread_known) ++ thread_db_find_new_threads (); ++ if (!process->thread_known) + return TD_NOTHR; + + err = td_thr_tls_get_addr (&process->th, (psaddr_t) load_module, offset, |