static void check_for_thread_db (void) { td_err_e err; if (td_ta_new_p == NULL) return; /* Don't try to attach to a dead target if there is no core file. */ if (!target_has_execution && core_bfd == NULL) return; /* Nothing to do. The thread library was already detected and the target vector was already activated. */ if (fbsd_thread_active) return; /* Now, initialize libthread_db. This needs to be done after the shared libraries are located because it needs information from the user's thread library. */ err = td_init_p (); if (err != TD_OK) { warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err)); return; } /* Initialize the structure that identifies the child process. Note that at this point there is no guarantee that we actually have a child process. */ proc_handle.pid = GET_PID (inferior_ptid); /* Now attempt to open a connection to the thread library. */ err = td_ta_new_p (&proc_handle, &thread_agent); switch (err) { case TD_NOLIBTHREAD: /* No thread library was detected. */ break; case TD_OK: /* The thread library was detected. Activate the thread_db target. */ push_target(&fbsd_thread_ops); fbsd_thread_present = 1; fbsd_thread_activate(); break; default: warning ("Cannot initialize thread debugging library: %s", thread_db_err_str (err)); break; } }
static void fbsd_thread_post_attach (int pid) { child_ops.to_post_attach (pid); if (fbsd_thread_present && !fbsd_thread_active) { proc_handle.pid = GET_PID (inferior_ptid); fbsd_thread_activate (); } }
static void fbsd_thread_post_startup_inferior (ptid_t ptid) { if (fbsd_thread_present && !fbsd_thread_active) { /* The child process is now the actual multi-threaded program. Snatch its process ID... */ proc_handle.pid = GET_PID (ptid); td_ta_new_p (&proc_handle, &thread_agent); fbsd_thread_activate(); } }
static void fbsd_core_open (char *filename, int from_tty) { int err; fbsd_thread_core = 1; orig_core_ops.to_open (filename, from_tty); if (fbsd_thread_present) { err = td_ta_new_p (&proc_handle, &thread_agent); if (err == TD_OK) { proc_handle.pid = elf_tdata (core_bfd)->core_pid; fbsd_thread_activate (); } else error ("fbsd_core_open: td_ta_new: %s", thread_db_err_str (err)); } }
static void fbsd_thread_new_objfile (struct objfile *objfile) { td_err_e err; if (objfile == NULL) { /* All symbols have been discarded. If the thread_db target is active, deactivate it now. */ if (fbsd_thread_active) { gdb_assert (proc_handle.pid == 0); fbsd_thread_active = 0; } goto quit; } if (!child_suppress_run) goto quit; /* Nothing to do. The thread library was already detected and the target vector was already activated. */ if (fbsd_thread_active) goto quit; /* Initialize the structure that identifies the child process. Note that at this point there is no guarantee that we actually have a child process. */ proc_handle.pid = GET_PID (inferior_ptid); /* Now attempt to open a connection to the thread library. */ err = td_ta_new_p (&proc_handle, &thread_agent); switch (err) { case TD_NOLIBTHREAD: /* No thread library was detected. */ break; case TD_OK: /* The thread library was detected. Activate the thread_db target. */ fbsd_thread_present = 1; /* We can only poke around if there actually is a child process. If there is no child process alive, postpone the steps below until one has been created. */ if (fbsd_thread_core == 0 && proc_handle.pid != 0) { push_target(&fbsd_thread_ops); fbsd_thread_activate(); } else { td_ta_delete_p(thread_agent); thread_agent = NULL; } break; default: warning ("Cannot initialize thread debugging library: %s", thread_db_err_str (err)); break; } quit: if (target_new_objfile_chain) target_new_objfile_chain (objfile); }