1 /* Solaris threads debugging interface.
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* This module implements a sort of half target that sits between the
24 machine-independent parts of GDB and the /proc interface (procfs.c)
25 to provide access to the Solaris user-mode thread implementation.
27 Solaris threads are true user-mode threads, which are invoked via
28 the thr_* and pthread_* (native and POSIX respectivly) interfaces.
29 These are mostly implemented in user-space, with all thread context
30 kept in various structures that live in the user's heap. These
31 should not be confused with lightweight processes (LWPs), which are
32 implemented by the kernel, and scheduled without explicit
33 intervention by the process.
35 Just to confuse things a little, Solaris threads (both native and
36 POSIX) are actually implemented using LWPs. In general, there are
37 going to be more threads than LWPs. There is no fixed
38 correspondence between a thread and an LWP. When a thread wants to
39 run, it gets scheduled onto the first available LWP and can
40 therefore migrate from one LWP to another as time goes on. A
41 sleeping thread may not be associated with an LWP at all!
43 To make it possible to mess with threads, Sun provides a library
44 called libthread_db.so.1 (not to be confused with
45 libthread_db.so.0, which doesn't have a published interface). This
46 interface has an upper part, which it provides, and a lower part
47 which we provide. The upper part consists of the td_* routines,
48 which allow us to find all the threads, query their state, etc...
49 The lower part consists of all of the ps_*, which are used by the
50 td_* routines to read/write memory, manipulate LWPs, lookup
51 symbols, etc... The ps_* routines actually do most of their work
52 by calling functions in procfs.c. */
56 #include <proc_service.h>
57 #include <thread_db.h>
58 #include "gdbthread.h"
70 #include "gdb_string.h"
72 extern struct target_ops sol_thread_ops; /* Forward declaration */
73 extern struct target_ops sol_core_ops; /* Forward declaration */
75 /* place to store core_ops before we overwrite it */
76 static struct target_ops orig_core_ops;
78 struct target_ops sol_thread_ops;
79 struct target_ops sol_core_ops;
81 extern int procfs_suppress_run;
82 extern struct target_ops procfs_ops; /* target vector for procfs.c */
83 extern struct target_ops core_ops; /* target vector for corelow.c */
84 extern char *procfs_pid_to_str (ptid_t ptid);
86 /* Prototypes for supply_gregset etc. */
89 /* This struct is defined by us, but mainly used for the proc_service
90 interface. We don't have much use for it, except as a handy place
91 to get a real PID for memory accesses. */
104 static struct ps_prochandle main_ph;
105 static td_thragent_t *main_ta;
106 static int sol_thread_active = 0;
108 static void sol_thread_resume (ptid_t ptid, int step, enum target_signal signo);
109 static int sol_thread_alive (ptid_t ptid);
110 static void sol_core_close (int quitting);
112 static void init_sol_thread_ops (void);
113 static void init_sol_core_ops (void);
115 /* Default definitions: These must be defined in tm.h if they are to
116 be shared with a process module such as procfs. */
118 #define GET_PID(ptid) ptid_get_pid (ptid)
119 #define GET_LWP(ptid) ptid_get_lwp (ptid)
120 #define GET_THREAD(ptid) ptid_get_tid (ptid)
122 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
123 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
125 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
126 #define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
128 /* Pointers to routines from libthread_db resolved by dlopen(). */
130 static void (*p_td_log)(const int on_off);
131 static td_err_e (*p_td_ta_new)(const struct ps_prochandle *ph_p,
132 td_thragent_t **ta_pp);
133 static td_err_e (*p_td_ta_delete)(td_thragent_t *ta_p);
134 static td_err_e (*p_td_init)(void);
135 static td_err_e (*p_td_ta_get_ph)(const td_thragent_t *ta_p,
136 struct ps_prochandle **ph_pp);
137 static td_err_e (*p_td_ta_get_nthreads)(const td_thragent_t *ta_p,
139 static td_err_e (*p_td_ta_tsd_iter)(const td_thragent_t *ta_p,
140 td_key_iter_f *cb, void *cbdata_p);
141 static td_err_e (*p_td_ta_thr_iter)(const td_thragent_t *ta_p,
142 td_thr_iter_f *cb, void *cbdata_p,
143 td_thr_state_e state, int ti_pri,
144 sigset_t *ti_sigmask_p,
145 unsigned ti_user_flags);
146 static td_err_e (*p_td_thr_validate)(const td_thrhandle_t *th_p);
147 static td_err_e (*p_td_thr_tsd)(const td_thrhandle_t * th_p,
148 const thread_key_t key, void **data_pp);
149 static td_err_e (*p_td_thr_get_info)(const td_thrhandle_t *th_p,
151 static td_err_e (*p_td_thr_getfpregs)(const td_thrhandle_t *th_p,
152 prfpregset_t *fpregset);
153 static td_err_e (*p_td_thr_getxregsize)(const td_thrhandle_t *th_p,
155 static td_err_e (*p_td_thr_getxregs)(const td_thrhandle_t *th_p,
156 const caddr_t xregset);
157 static td_err_e (*p_td_thr_sigsetmask)(const td_thrhandle_t *th_p,
158 const sigset_t ti_sigmask);
159 static td_err_e (*p_td_thr_setprio)(const td_thrhandle_t *th_p,
161 static td_err_e (*p_td_thr_setsigpending)(const td_thrhandle_t *th_p,
162 const uchar_t ti_pending_flag,
163 const sigset_t ti_pending);
164 static td_err_e (*p_td_thr_setfpregs)(const td_thrhandle_t *th_p,
165 const prfpregset_t *fpregset);
166 static td_err_e (*p_td_thr_setxregs)(const td_thrhandle_t *th_p,
167 const caddr_t xregset);
168 static td_err_e (*p_td_ta_map_id2thr)(const td_thragent_t *ta_p,
170 td_thrhandle_t *th_p);
171 static td_err_e (*p_td_ta_map_lwp2thr)(const td_thragent_t *ta_p,
173 td_thrhandle_t *th_p);
174 static td_err_e (*p_td_thr_getgregs)(const td_thrhandle_t *th_p,
176 static td_err_e (*p_td_thr_setgregs)(const td_thrhandle_t *th_p,
177 const prgregset_t regset);
180 /* Return the libthread_db error string associated with ERRCODE. If
181 ERRCODE is unknown, return an appropriate message. */
184 td_err_string (td_err_e errcode)
186 static struct string_map td_err_table[] =
188 { TD_OK, "generic \"call succeeded\"" },
189 { TD_ERR, "generic error." },
190 { TD_NOTHR, "no thread can be found to satisfy query" },
191 { TD_NOSV, "no synch. variable can be found to satisfy query" },
192 { TD_NOLWP, "no lwp can be found to satisfy query" },
193 { TD_BADPH, "invalid process handle" },
194 { TD_BADTH, "invalid thread handle" },
195 { TD_BADSH, "invalid synchronization handle" },
196 { TD_BADTA, "invalid thread agent" },
197 { TD_BADKEY, "invalid key" },
198 { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
199 { TD_NOFPREGS, "FPU register set not available for given thread" },
200 { TD_NOLIBTHREAD, "application not linked with libthread" },
201 { TD_NOEVENT, "requested event is not supported" },
202 { TD_NOCAPAB, "capability not available" },
203 { TD_DBERR, "Debugger service failed" },
204 { TD_NOAPLIC, "Operation not applicable to" },
205 { TD_NOTSD, "No thread specific data for this thread" },
206 { TD_MALLOC, "Malloc failed" },
207 { TD_PARTIALREG, "Only part of register set was written/read" },
208 { TD_NOXREGS, "X register set not available for given thread" }
210 const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
214 for (i = 0; i < td_err_size; i++)
215 if (td_err_table[i].num == errcode)
216 return td_err_table[i].str;
218 sprintf (buf, "Unknown libthread_db error code: %d", errcode);
223 /* Return the the libthread_db state string assicoated with STATECODE.
224 If STATECODE is unknown, return an appropriate message. */
227 td_state_string (td_thr_state_e statecode)
229 static struct string_map td_thr_state_table[] =
231 { TD_THR_ANY_STATE, "any state" },
232 { TD_THR_UNKNOWN, "unknown" },
233 { TD_THR_STOPPED, "stopped" },
234 { TD_THR_RUN, "run" },
235 { TD_THR_ACTIVE, "active" },
236 { TD_THR_ZOMBIE, "zombie" },
237 { TD_THR_SLEEP, "sleep" },
238 { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
240 const int td_thr_state_table_size =
241 sizeof td_thr_state_table / sizeof (struct string_map);
245 for (i = 0; i < td_thr_state_table_size; i++)
246 if (td_thr_state_table[i].num == statecode)
247 return td_thr_state_table[i].str;
249 sprintf (buf, "Unknown libthread_db state code: %d", statecode);
255 /* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID
256 doesn't exist, that's an error. If it's an inactive thread, return
259 NOTE: This function probably shouldn't call error(). */
262 thread_to_lwp (ptid_t thread_id, int default_lwp)
268 if (is_lwp (thread_id))
269 return thread_id; /* It's already an LWP ID. */
271 /* It's a thread. Convert to LWP. */
273 val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);
275 return pid_to_ptid (-1); /* Thread must have terminated. */
276 else if (val != TD_OK)
277 error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
279 val = p_td_thr_get_info (&th, &ti);
281 return pid_to_ptid (-1); /* Thread must have terminated. */
282 else if (val != TD_OK)
283 error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
285 if (ti.ti_state != TD_THR_ACTIVE)
287 if (default_lwp != -1)
288 return pid_to_ptid (default_lwp);
289 error (_("thread_to_lwp: thread state not active: %s"),
290 td_state_string (ti.ti_state));
293 return BUILD_LWP (ti.ti_lid, PIDGET (thread_id));
296 /* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
297 doesn't exists, that's an error.
299 NOTE: This function probably shouldn't call error(). */
302 lwp_to_thread (ptid_t lwp)
309 return lwp; /* It's already a thread ID. */
311 /* It's an LWP. Convert it to a thread ID. */
313 if (!sol_thread_alive (lwp))
314 return pid_to_ptid (-1); /* Must be a defunct LPW. */
316 val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
318 return pid_to_ptid (-1); /* Thread must have terminated. */
319 else if (val != TD_OK)
320 error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
322 val = p_td_thr_validate (&th);
324 return lwp; /* Unknown to libthread; just return LPW, */
325 else if (val != TD_OK)
326 error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
328 val = p_td_thr_get_info (&th, &ti);
330 return pid_to_ptid (-1); /* Thread must have terminated. */
331 else if (val != TD_OK)
332 error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
334 return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));
338 /* Most target vector functions from here on actually just pass
339 through to procfs.c, as they don't need to do anything specific for
343 sol_thread_open (char *arg, int from_tty)
345 procfs_ops.to_open (arg, from_tty);
348 /* Attach to process PID, then initialize for debugging it and wait
349 for the trace-trap that results from attaching. */
352 sol_thread_attach (char *args, int from_tty)
354 procfs_ops.to_attach (args, from_tty);
356 /* Must get symbols from shared libraries before libthread_db can run! */
357 solib_add (NULL, from_tty, (struct target_ops *) 0, auto_solib_add);
359 if (sol_thread_active)
361 printf_filtered ("sol-thread active.\n");
362 main_ph.ptid = inferior_ptid; /* Save for xfer_memory. */
363 push_target (&sol_thread_ops);
364 inferior_ptid = lwp_to_thread (inferior_ptid);
365 if (PIDGET (inferior_ptid) == -1)
366 inferior_ptid = main_ph.ptid;
368 add_thread (inferior_ptid);
371 /* FIXME: Might want to iterate over all the threads and register
375 /* Take a program previously attached to and detaches it. The program
376 resumes execution and will no longer stop on signals, etc. We'd
377 better not have left any breakpoints in the program or it'll die
378 when it hits one. For this to work, it may be necessary for the
379 process to have been previously attached. It *might* work if the
380 program was started via the normal ptrace (PTRACE_TRACEME). */
383 sol_thread_detach (char *args, int from_tty)
385 inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid));
386 unpush_target (&sol_thread_ops);
387 procfs_ops.to_detach (args, from_tty);
390 /* Resume execution of process PTID. If STEP is nozero, then just
391 single step it. If SIGNAL is nonzero, restart it with that signal
392 activated. We may have to convert PTID from a thread ID to an LWP
396 sol_thread_resume (ptid_t ptid, int step, enum target_signal signo)
398 struct cleanup *old_chain;
400 old_chain = save_inferior_ptid ();
402 inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
403 if (PIDGET (inferior_ptid) == -1)
404 inferior_ptid = procfs_first_available ();
406 if (PIDGET (ptid) != -1)
408 ptid_t save_ptid = ptid;
410 ptid = thread_to_lwp (ptid, -2);
411 if (PIDGET (ptid) == -2) /* Inactive thread. */
412 error (_("This version of Solaris can't start inactive threads."));
413 if (info_verbose && PIDGET (ptid) == -1)
414 warning (_("Specified thread %ld seems to have terminated"),
415 GET_THREAD (save_ptid));
418 procfs_ops.to_resume (ptid, step, signo);
420 do_cleanups (old_chain);
423 /* Wait for any threads to stop. We may have to convert PIID from a
424 thread ID to an LWP ID, and vice versa on the way out. */
427 sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
431 struct cleanup *old_chain;
433 save_ptid = inferior_ptid;
434 old_chain = save_inferior_ptid ();
436 inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
437 if (PIDGET (inferior_ptid) == -1)
438 inferior_ptid = procfs_first_available ();
440 if (PIDGET (ptid) != -1)
442 ptid_t save_ptid = ptid;
444 ptid = thread_to_lwp (ptid, -2);
445 if (PIDGET (ptid) == -2) /* Inactive thread. */
446 error (_("This version of Solaris can't start inactive threads."));
447 if (info_verbose && PIDGET (ptid) == -1)
448 warning (_("Specified thread %ld seems to have terminated"),
449 GET_THREAD (save_ptid));
452 rtnval = procfs_ops.to_wait (ptid, ourstatus);
454 if (ourstatus->kind != TARGET_WAITKIND_EXITED)
456 /* Map the LWP of interest back to the appropriate thread ID. */
457 rtnval = lwp_to_thread (rtnval);
458 if (PIDGET (rtnval) == -1)
461 /* See if we have a new thread. */
462 if (is_thread (rtnval)
463 && !ptid_equal (rtnval, save_ptid)
464 && !in_thread_list (rtnval))
466 printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));
471 /* During process initialization, we may get here without the thread
472 package being initialized, since that can only happen after we've
473 found the shared libs. */
475 do_cleanups (old_chain);
481 sol_thread_fetch_registers (int regnum)
484 td_thrhandle_t thandle;
487 prfpregset_t fpregset;
493 if (!is_thread (inferior_ptid))
495 /* It's an LWP; pass the request on to procfs. */
496 if (target_has_execution)
497 procfs_ops.to_fetch_registers (regnum);
499 orig_core_ops.to_fetch_registers (regnum);
503 /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t. */
504 thread = GET_THREAD (inferior_ptid);
506 error (_("sol_thread_fetch_registers: thread == 0"));
508 val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
510 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
511 td_err_string (val));
513 /* Get the general-purpose registers. */
515 val = p_td_thr_getgregs (&thandle, gregset);
516 if (val != TD_OK && val != TD_PARTIALREG)
517 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
518 td_err_string (val));
520 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
521 and %sp are saved (by a thread context switch). */
523 /* And, now the floating-point registers. */
525 val = p_td_thr_getfpregs (&thandle, &fpregset);
526 if (val != TD_OK && val != TD_NOFPREGS)
527 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
528 td_err_string (val));
530 /* Note that we must call supply_gregset and supply_fpregset *after*
531 calling the td routines because the td routines call ps_lget*
532 which affect the values stored in the registers array. */
534 supply_gregset ((gdb_gregset_t *) &gregset);
535 supply_fpregset ((gdb_fpregset_t *) &fpregset);
538 /* FIXME: libthread_db doesn't seem to handle this right. */
539 val = td_thr_getxregsize (&thandle, &xregsize);
540 if (val != TD_OK && val != TD_NOXREGS)
541 error (_("sol_thread_fetch_registers: td_thr_getxregsize %s"),
542 td_err_string (val));
546 xregset = alloca (xregsize);
547 val = td_thr_getxregs (&thandle, xregset);
549 error (_("sol_thread_fetch_registers: td_thr_getxregs %s"),
550 td_err_string (val));
556 sol_thread_store_registers (int regnum)
559 td_thrhandle_t thandle;
562 prfpregset_t fpregset;
568 if (!is_thread (inferior_ptid))
570 /* It's an LWP; pass the request on to procfs.c. */
571 procfs_ops.to_store_registers (regnum);
575 /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t. */
576 thread = GET_THREAD (inferior_ptid);
578 val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
580 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
581 td_err_string (val));
585 /* Not writing all the registers. */
586 char old_value[MAX_REGISTER_SIZE];
588 /* Save new register value. */
589 regcache_raw_collect (current_regcache, regnum, old_value);
591 val = p_td_thr_getgregs (&thandle, gregset);
593 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
594 td_err_string (val));
595 val = p_td_thr_getfpregs (&thandle, &fpregset);
597 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
598 td_err_string (val));
600 /* Restore new register value. */
601 regcache_raw_supply (current_regcache, regnum, old_value);
604 /* FIXME: libthread_db doesn't seem to handle this right. */
605 val = td_thr_getxregsize (&thandle, &xregsize);
606 if (val != TD_OK && val != TD_NOXREGS)
607 error (_("sol_thread_store_registers: td_thr_getxregsize %s"),
608 td_err_string (val));
612 xregset = alloca (xregsize);
613 val = td_thr_getxregs (&thandle, xregset);
615 error (_("sol_thread_store_registers: td_thr_getxregs %s"),
616 td_err_string (val));
621 fill_gregset ((gdb_gregset_t *) &gregset, regnum);
622 fill_fpregset ((gdb_fpregset_t *) &fpregset, regnum);
624 val = p_td_thr_setgregs (&thandle, gregset);
626 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
627 td_err_string (val));
628 val = p_td_thr_setfpregs (&thandle, &fpregset);
630 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
631 td_err_string (val));
634 /* FIXME: libthread_db doesn't seem to handle this right. */
635 val = td_thr_getxregsize (&thandle, &xregsize);
636 if (val != TD_OK && val != TD_NOXREGS)
637 error (_("sol_thread_store_registers: td_thr_getxregsize %s"),
638 td_err_string (val));
640 /* ??? Should probably do something about writing the xregs here,
641 but what are they? */
645 /* Get ready to modify the registers array. On machines which store
646 individual registers, this doesn't need to do anything. On
647 machines which store all the registers in one fell swoop, this
648 makes sure that registers contains all the registers from the
649 program being debugged. */
652 sol_thread_prepare_to_store (void)
654 procfs_ops.to_prepare_to_store ();
657 /* Transfer LEN bytes between GDB address MYADDR and target address
658 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
659 otherwise transfer them from the target. TARGET is unused.
661 Returns the number of bytes transferred. */
664 sol_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite,
665 struct mem_attrib *attrib,
666 struct target_ops *target)
669 struct cleanup *old_chain;
671 old_chain = save_inferior_ptid ();
673 if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
675 /* It's either a thread or an LWP that isn't alive. Any live
676 LWP will do so use the first available.
678 NOTE: We don't need to call switch_to_thread; we're just
680 inferior_ptid = procfs_first_available ();
683 if (target_has_execution)
684 retval = procfs_ops.deprecated_xfer_memory (memaddr, myaddr, len,
685 dowrite, attrib, target);
687 retval = orig_core_ops.deprecated_xfer_memory (memaddr, myaddr, len,
688 dowrite, attrib, target);
690 do_cleanups (old_chain);
695 /* Perform partial transfers on OBJECT. See target_read_partial and
696 target_write_partial for details of each variant. One, and only
697 one, of readbuf or writebuf must be non-NULL. */
700 sol_thread_xfer_partial (struct target_ops *ops, enum target_object object,
701 const char *annex, void *readbuf,
702 const void *writebuf, ULONGEST offset, LONGEST len)
705 struct cleanup *old_chain;
707 old_chain = save_inferior_ptid ();
709 if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
711 /* It's either a thread or an LWP that isn't alive. Any live
712 LWP will do so use the first available.
714 NOTE: We don't need to call switch_to_thread; we're just
716 inferior_ptid = procfs_first_available ();
719 if (target_has_execution)
720 retval = procfs_ops.to_xfer_partial (ops, object, annex,
721 readbuf, writebuf, offset, len);
723 retval = orig_core_ops.to_xfer_partial (ops, object, annex,
724 readbuf, writebuf, offset, len);
726 do_cleanups (old_chain);
731 /* Print status information about what we're accessing. */
734 sol_thread_files_info (struct target_ops *ignore)
736 procfs_ops.to_files_info (ignore);
740 sol_thread_kill_inferior (void)
742 procfs_ops.to_kill ();
746 sol_thread_notice_signals (ptid_t ptid)
748 procfs_ops.to_notice_signals (pid_to_ptid (PIDGET (ptid)));
751 /* Fork an inferior process, and start debugging it with /proc. */
754 sol_thread_create_inferior (char *exec_file, char *allargs, char **env,
757 procfs_ops.to_create_inferior (exec_file, allargs, env, from_tty);
759 if (sol_thread_active && !ptid_equal (inferior_ptid, null_ptid))
761 /* Save for xfer_memory. */
762 main_ph.ptid = inferior_ptid;
764 push_target (&sol_thread_ops);
766 inferior_ptid = lwp_to_thread (inferior_ptid);
767 if (PIDGET (inferior_ptid) == -1)
768 inferior_ptid = main_ph.ptid;
770 if (!in_thread_list (inferior_ptid))
771 add_thread (inferior_ptid);
775 /* This routine is called whenever a new symbol table is read in, or
776 when all symbol tables are removed. libthread_db can only be
777 initialized when it finds the right variables in libthread.so.
778 Since it's a shared library, those variables don't show up until
779 the library gets mapped and the symbol table is read in.
781 This new_objfile event is managed by a chained function pointer.
782 It is the callee's responsability to call the next client on the
785 /* Saved pointer to previous owner of the new_objfile event. */
786 static void (*target_new_objfile_chain) (struct objfile *);
789 sol_thread_new_objfile (struct objfile *objfile)
795 sol_thread_active = 0;
799 /* Don't do anything if init failed to resolve the libthread_db
801 if (!procfs_suppress_run)
804 /* Now, initialize libthread_db. This needs to be done after the
805 shared libraries are located because it needs information from
806 the user's thread library. */
811 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (val));
815 val = p_td_ta_new (&main_ph, &main_ta);
816 if (val == TD_NOLIBTHREAD)
818 else if (val != TD_OK)
820 warning (_("sol_thread_new_objfile: td_ta_new: %s"), td_err_string (val));
824 sol_thread_active = 1;
827 /* Call predecessor on chain, if any. */
828 if (target_new_objfile_chain)
829 target_new_objfile_chain (objfile);
832 /* Clean up after the inferior dies. */
835 sol_thread_mourn_inferior (void)
837 unpush_target (&sol_thread_ops);
838 procfs_ops.to_mourn_inferior ();
841 /* Mark our target-struct as eligible for stray "run" and "attach"
845 sol_thread_can_run (void)
847 return procfs_suppress_run;
854 sol_thread_alive - test thread for "aliveness"
858 static bool sol_thread_alive (ptid_t ptid);
862 returns true if thread still active in inferior.
866 /* Return true if PTID is still active in the inferior. */
869 sol_thread_alive (ptid_t ptid)
871 if (is_thread (ptid))
873 /* It's a (user-level) thread. */
878 pid = GET_THREAD (ptid);
879 if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
880 return 0; /* Thread not found. */
881 if ((val = p_td_thr_validate (&th)) != TD_OK)
882 return 0; /* Thread not valid. */
883 return 1; /* Known thread. */
887 /* It's an LPW; pass the request on to procfs. */
888 if (target_has_execution)
889 return procfs_ops.to_thread_alive (ptid);
891 return orig_core_ops.to_thread_alive (ptid);
896 sol_thread_stop (void)
898 procfs_ops.to_stop ();
901 /* These routines implement the lower half of the thread_db interface,
902 i.e. the ps_* routines. */
904 /* Various versions of <proc_service.h> have slightly different
905 function prototypes. In particular, we have
908 struct ps_prochandle * const struct ps_prochandle *
913 Which one you have depends on the Solaris version and what patches
914 you've applied. On the theory that there are only two major
915 variants, we have configure check the prototype of ps_pdwrite (),
916 and use that info to make appropriate typedefs here. */
918 #ifdef PROC_SERVICE_IS_OLD
919 typedef const struct ps_prochandle *gdb_ps_prochandle_t;
920 typedef char *gdb_ps_read_buf_t;
921 typedef char *gdb_ps_write_buf_t;
922 typedef int gdb_ps_size_t;
923 typedef paddr_t gdb_ps_addr_t;
925 typedef struct ps_prochandle *gdb_ps_prochandle_t;
926 typedef void *gdb_ps_read_buf_t;
927 typedef const void *gdb_ps_write_buf_t;
928 typedef size_t gdb_ps_size_t;
929 typedef psaddr_t gdb_ps_addr_t;
932 /* The next four routines are called by libthread_db to tell us to
933 stop and stop a particular process or lwp. Since GDB ensures that
934 these are all stopped by the time we call anything in thread_db,
935 these routines need to do nothing. */
940 ps_pstop (gdb_ps_prochandle_t ph)
945 /* Process continue. */
948 ps_pcontinue (gdb_ps_prochandle_t ph)
956 ps_lstop (gdb_ps_prochandle_t ph, lwpid_t lwpid)
964 ps_lcontinue (gdb_ps_prochandle_t ph, lwpid_t lwpid)
969 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
972 ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *ld_object_name,
973 const char *ld_symbol_name, gdb_ps_addr_t *ld_symbol_addr)
975 struct minimal_symbol *ms;
977 ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
981 *ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
985 /* Common routine for reading and writing memory. */
988 rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
991 struct cleanup *old_chain;
993 old_chain = save_inferior_ptid ();
995 if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
997 /* It's either a thread or an LWP that isn't alive. Any live
998 LWP will do so use the first available.
1000 NOTE: We don't need to call switch_to_thread; we're just
1002 inferior_ptid = procfs_first_available ();
1005 #if defined (__sparcv9)
1006 /* For Sparc64 cross Sparc32, make sure the address has not been
1007 accidentally sign-extended (or whatever) to beyond 32 bits. */
1008 if (bfd_get_arch_size (exec_bfd) == 32)
1016 /* FIXME: passing 0 as attrib argument. */
1017 if (target_has_execution)
1018 cc = procfs_ops.deprecated_xfer_memory (addr, buf, size,
1019 dowrite, 0, &procfs_ops);
1021 cc = orig_core_ops.deprecated_xfer_memory (addr, buf, size,
1022 dowrite, 0, &core_ops);
1027 print_sys_errmsg ("rw_common (): read", errno);
1029 print_sys_errmsg ("rw_common (): write", errno);
1031 do_cleanups (old_chain);
1038 warning (_("rw_common (): unable to read at addr 0x%lx"),
1041 warning (_("rw_common (): unable to write at addr 0x%lx"),
1044 do_cleanups (old_chain);
1053 do_cleanups (old_chain);
1058 /* Copies SIZE bytes from target process .data segment to debugger memory. */
1061 ps_pdread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1062 gdb_ps_read_buf_t buf, gdb_ps_size_t size)
1064 return rw_common (0, ph, addr, buf, size);
1067 /* Copies SIZE bytes from debugger memory .data segment to target process. */
1070 ps_pdwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1071 gdb_ps_write_buf_t buf, gdb_ps_size_t size)
1073 return rw_common (1, ph, addr, (char *) buf, size);
1076 /* Copies SIZE bytes from target process .text segment to debugger memory. */
1079 ps_ptread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1080 gdb_ps_read_buf_t buf, gdb_ps_size_t size)
1082 return rw_common (0, ph, addr, buf, size);
1085 /* Copies SIZE bytes from debugger memory .text segment to target process. */
1088 ps_ptwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
1089 gdb_ps_write_buf_t buf, gdb_ps_size_t size)
1091 return rw_common (1, ph, addr, (char *) buf, size);
1094 /* Get general-purpose registers for LWP. */
1097 ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
1099 struct cleanup *old_chain;
1101 old_chain = save_inferior_ptid ();
1103 inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1105 if (target_has_execution)
1106 procfs_ops.to_fetch_registers (-1);
1108 orig_core_ops.to_fetch_registers (-1);
1109 fill_gregset ((gdb_gregset_t *) gregset, -1);
1111 do_cleanups (old_chain);
1116 /* Set general-purpose registers for LWP. */
1119 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1120 const prgregset_t gregset)
1122 struct cleanup *old_chain;
1124 old_chain = save_inferior_ptid ();
1126 inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1128 supply_gregset ((gdb_gregset_t *) gregset);
1129 if (target_has_execution)
1130 procfs_ops.to_store_registers (-1);
1132 orig_core_ops.to_store_registers (-1);
1134 do_cleanups (old_chain);
1139 /* Log a message (sends to gdb_stderr). */
1142 ps_plog (const char *fmt, ...)
1146 va_start (args, fmt);
1148 vfprintf_filtered (gdb_stderr, fmt, args);
1151 /* Get size of extra register set. Currently a noop. */
1154 ps_lgetxregsize (gdb_ps_prochandle_t ph, lwpid_t lwpid, int *xregsize)
1161 val = get_lwp_fd (ph, lwpid, &lwp_fd);
1165 if (ioctl (lwp_fd, PIOCGXREGSIZE, ®size))
1167 if (errno == EINVAL)
1168 return PS_NOFREGS; /* XXX Wrong code, but this is the closest
1169 thing in proc_service.h */
1171 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno);
1179 /* Get extra register set. Currently a noop. */
1182 ps_lgetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
1188 val = get_lwp_fd (ph, lwpid, &lwp_fd);
1192 if (ioctl (lwp_fd, PIOCGXREG, xregset))
1194 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno);
1202 /* Set extra register set. Currently a noop. */
1205 ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
1211 val = get_lwp_fd (ph, lwpid, &lwp_fd);
1215 if (ioctl (lwp_fd, PIOCSXREG, xregset))
1217 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno);
1225 /* Get floating-point registers for LWP. */
1228 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1229 prfpregset_t *fpregset)
1231 struct cleanup *old_chain;
1233 old_chain = save_inferior_ptid ();
1235 inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1237 if (target_has_execution)
1238 procfs_ops.to_fetch_registers (-1);
1240 orig_core_ops.to_fetch_registers (-1);
1241 fill_fpregset ((gdb_fpregset_t *) fpregset, -1);
1243 do_cleanups (old_chain);
1248 /* Set floating-point regs for LWP */
1251 ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1252 const prfpregset_t * fpregset)
1254 struct cleanup *old_chain;
1256 old_chain = save_inferior_ptid ();
1258 inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1260 supply_fpregset ((gdb_fpregset_t *) fpregset);
1261 if (target_has_execution)
1262 procfs_ops.to_store_registers (-1);
1264 orig_core_ops.to_store_registers (-1);
1266 do_cleanups (old_chain);
1271 #ifdef PR_MODEL_LP64
1272 /* Identify process as 32-bit or 64-bit. At the moment we're using
1273 BFD to do this. There might be a more Solaris-specific
1274 (e.g. procfs) method, but this ought to work. */
1277 ps_pdmodel (gdb_ps_prochandle_t ph, int *data_model)
1280 *data_model = PR_MODEL_UNKNOWN;
1281 else if (bfd_get_arch_size (exec_bfd) == 32)
1282 *data_model = PR_MODEL_ILP32;
1284 *data_model = PR_MODEL_LP64;
1288 #endif /* PR_MODEL_LP64 */
1290 #ifdef TM_I386SOL2_H
1292 /* Reads the local descriptor table of a LWP. */
1295 ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
1298 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
1299 extern struct ssd *procfs_find_LDT_entry (ptid_t);
1302 /* FIXME: can't I get the process ID from the prochandle or
1305 if (PIDGET (inferior_ptid) <= 0 || lwpid <= 0)
1308 ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_ptid)));
1311 memcpy (pldt, ret, sizeof (struct ssd));
1315 /* LDT not found. */
1318 #endif /* TM_I386SOL2_H */
1321 /* Convert PTID to printable form. */
1324 solaris_pid_to_str (ptid_t ptid)
1326 static char buf[100];
1328 /* In case init failed to resolve the libthread_db library. */
1329 if (!procfs_suppress_run)
1330 return procfs_pid_to_str (ptid);
1332 if (is_thread (ptid))
1336 lwp = thread_to_lwp (ptid, -2);
1338 if (PIDGET (lwp) == -1)
1339 sprintf (buf, "Thread %ld (defunct)", GET_THREAD (ptid));
1340 else if (PIDGET (lwp) != -2)
1341 sprintf (buf, "Thread %ld (LWP %ld)",
1342 GET_THREAD (ptid), GET_LWP (lwp));
1344 sprintf (buf, "Thread %ld ", GET_THREAD (ptid));
1346 else if (GET_LWP (ptid) != 0)
1347 sprintf (buf, "LWP %ld ", GET_LWP (ptid));
1349 sprintf (buf, "process %d ", PIDGET (ptid));
1355 /* Worker bee for find_new_threads. Callback function that gets
1356 called once per user-level thread (i.e. not for LWP's). */
1359 sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
1365 retval = p_td_thr_get_info (th, &ti);
1366 if (retval != TD_OK)
1369 ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid));
1370 if (!in_thread_list (ptid))
1377 sol_find_new_threads (void)
1379 /* Don't do anything if init failed to resolve the libthread_db
1381 if (!procfs_suppress_run)
1384 if (PIDGET (inferior_ptid) == -1)
1386 printf_filtered ("No process.\n");
1390 /* First Find any new LWP's. */
1391 procfs_ops.to_find_new_threads ();
1393 /* Then find any new user-level threads. */
1394 p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0,
1395 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1396 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1400 sol_core_open (char *filename, int from_tty)
1402 orig_core_ops.to_open (filename, from_tty);
1406 sol_core_close (int quitting)
1408 orig_core_ops.to_close (quitting);
1412 sol_core_detach (char *args, int from_tty)
1414 unpush_target (&core_ops);
1415 orig_core_ops.to_detach (args, from_tty);
1419 sol_core_files_info (struct target_ops *t)
1421 orig_core_ops.to_files_info (t);
1424 /* Worker bee for the "info sol-thread" command. This is a callback
1425 function that gets called once for each Solaris user-level thread
1426 (i.e. not for LWPs) in the inferior. Print anything interesting
1427 that we can think of. */
1430 info_cb (const td_thrhandle_t *th, void *s)
1435 ret = p_td_thr_get_info (th, &ti);
1438 printf_filtered ("%s thread #%d, lwp %d, ",
1439 ti.ti_type == TD_THR_SYSTEM ? "system" : "user ",
1440 ti.ti_tid, ti.ti_lid);
1441 switch (ti.ti_state)
1444 case TD_THR_UNKNOWN:
1445 printf_filtered ("<unknown state>");
1447 case TD_THR_STOPPED:
1448 printf_filtered ("(stopped)");
1451 printf_filtered ("(run) ");
1454 printf_filtered ("(active) ");
1457 printf_filtered ("(zombie) ");
1460 printf_filtered ("(asleep) ");
1462 case TD_THR_STOPPED_ASLEEP:
1463 printf_filtered ("(stopped asleep)");
1466 /* Print thr_create start function. */
1467 if (ti.ti_startfunc != 0)
1469 struct minimal_symbol *msym;
1470 msym = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
1472 printf_filtered (" startfunc: %s\n",
1473 DEPRECATED_SYMBOL_NAME (msym));
1475 printf_filtered (" startfunc: 0x%s\n", paddr (ti.ti_startfunc));
1478 /* If thread is asleep, print function that went to sleep. */
1479 if (ti.ti_state == TD_THR_SLEEP)
1481 struct minimal_symbol *msym;
1482 msym = lookup_minimal_symbol_by_pc (ti.ti_pc);
1484 printf_filtered (" - Sleep func: %s\n",
1485 DEPRECATED_SYMBOL_NAME (msym));
1487 printf_filtered (" - Sleep func: 0x%s\n", paddr (ti.ti_startfunc));
1490 /* Wrap up line, if necessary. */
1491 if (ti.ti_state != TD_THR_SLEEP && ti.ti_startfunc == 0)
1492 printf_filtered ("\n"); /* don't you hate counting newlines? */
1495 warning (_("info sol-thread: failed to get info for thread."));
1500 /* List some state about each Solaris user-level thread in the
1504 info_solthreads (char *args, int from_tty)
1506 p_td_ta_thr_iter (main_ta, info_cb, args,
1507 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1508 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1512 sol_find_memory_regions (int (*func) (CORE_ADDR, unsigned long,
1513 int, int, int, void *),
1516 return procfs_ops.to_find_memory_regions (func, data);
1520 sol_make_note_section (bfd *obfd, int *note_size)
1522 return procfs_ops.to_make_corefile_notes (obfd, note_size);
1526 ignore (CORE_ADDR addr, gdb_byte *contents)
1532 init_sol_thread_ops (void)
1534 sol_thread_ops.to_shortname = "solaris-threads";
1535 sol_thread_ops.to_longname = "Solaris threads and pthread.";
1536 sol_thread_ops.to_doc = "Solaris threads and pthread support.";
1537 sol_thread_ops.to_open = sol_thread_open;
1538 sol_thread_ops.to_attach = sol_thread_attach;
1539 sol_thread_ops.to_detach = sol_thread_detach;
1540 sol_thread_ops.to_resume = sol_thread_resume;
1541 sol_thread_ops.to_wait = sol_thread_wait;
1542 sol_thread_ops.to_fetch_registers = sol_thread_fetch_registers;
1543 sol_thread_ops.to_store_registers = sol_thread_store_registers;
1544 sol_thread_ops.to_prepare_to_store = sol_thread_prepare_to_store;
1545 sol_thread_ops.deprecated_xfer_memory = sol_thread_xfer_memory;
1546 sol_thread_ops.to_xfer_partial = sol_thread_xfer_partial;
1547 sol_thread_ops.to_files_info = sol_thread_files_info;
1548 sol_thread_ops.to_insert_breakpoint = memory_insert_breakpoint;
1549 sol_thread_ops.to_remove_breakpoint = memory_remove_breakpoint;
1550 sol_thread_ops.to_terminal_init = terminal_init_inferior;
1551 sol_thread_ops.to_terminal_inferior = terminal_inferior;
1552 sol_thread_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1553 sol_thread_ops.to_terminal_ours = terminal_ours;
1554 sol_thread_ops.to_terminal_save_ours = terminal_save_ours;
1555 sol_thread_ops.to_terminal_info = child_terminal_info;
1556 sol_thread_ops.to_kill = sol_thread_kill_inferior;
1557 sol_thread_ops.to_create_inferior = sol_thread_create_inferior;
1558 sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior;
1559 sol_thread_ops.to_can_run = sol_thread_can_run;
1560 sol_thread_ops.to_notice_signals = sol_thread_notice_signals;
1561 sol_thread_ops.to_thread_alive = sol_thread_alive;
1562 sol_thread_ops.to_pid_to_str = solaris_pid_to_str;
1563 sol_thread_ops.to_find_new_threads = sol_find_new_threads;
1564 sol_thread_ops.to_stop = sol_thread_stop;
1565 sol_thread_ops.to_stratum = process_stratum;
1566 sol_thread_ops.to_has_all_memory = 1;
1567 sol_thread_ops.to_has_memory = 1;
1568 sol_thread_ops.to_has_stack = 1;
1569 sol_thread_ops.to_has_registers = 1;
1570 sol_thread_ops.to_has_execution = 1;
1571 sol_thread_ops.to_has_thread_control = tc_none;
1572 sol_thread_ops.to_find_memory_regions = sol_find_memory_regions;
1573 sol_thread_ops.to_make_corefile_notes = sol_make_note_section;
1574 sol_thread_ops.to_magic = OPS_MAGIC;
1578 init_sol_core_ops (void)
1580 sol_core_ops.to_shortname = "solaris-core";
1581 sol_core_ops.to_longname = "Solaris core threads and pthread.";
1582 sol_core_ops.to_doc = "Solaris threads and pthread support for core files.";
1583 sol_core_ops.to_open = sol_core_open;
1584 sol_core_ops.to_close = sol_core_close;
1585 sol_core_ops.to_attach = sol_thread_attach;
1586 sol_core_ops.to_detach = sol_core_detach;
1587 sol_core_ops.to_fetch_registers = sol_thread_fetch_registers;
1588 sol_core_ops.deprecated_xfer_memory = sol_thread_xfer_memory;
1589 sol_core_ops.to_xfer_partial = sol_thread_xfer_partial;
1590 sol_core_ops.to_files_info = sol_core_files_info;
1591 sol_core_ops.to_insert_breakpoint = ignore;
1592 sol_core_ops.to_remove_breakpoint = ignore;
1593 sol_core_ops.to_create_inferior = sol_thread_create_inferior;
1594 sol_core_ops.to_stratum = core_stratum;
1595 sol_core_ops.to_has_memory = 1;
1596 sol_core_ops.to_has_stack = 1;
1597 sol_core_ops.to_has_registers = 1;
1598 sol_core_ops.to_has_thread_control = tc_none;
1599 sol_core_ops.to_thread_alive = sol_thread_alive;
1600 sol_core_ops.to_pid_to_str = solaris_pid_to_str;
1601 /* On Solaris/x86, when debugging a threaded core file from process
1602 <n>, the following causes "info threads" to produce "procfs:
1603 couldn't find pid <n> in procinfo list" where <n> is the pid of
1604 the process that produced the core file. Disable it for now. */
1606 sol_core_ops.to_find_new_threads = sol_find_new_threads;
1608 sol_core_ops.to_magic = OPS_MAGIC;
1611 /* We suppress the call to add_target of core_ops in corelow because
1612 if there are two targets in the stratum core_stratum,
1613 find_core_target won't know which one to return. See corelow.c for
1614 an additonal comment on coreops_suppress_target. */
1615 int coreops_suppress_target = 1;
1618 _initialize_sol_thread (void)
1622 init_sol_thread_ops ();
1623 init_sol_core_ops ();
1625 dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1629 #define resolve(X) \
1630 if (!(p_##X = dlsym (dlhandle, #X))) \
1634 resolve (td_ta_new);
1635 resolve (td_ta_delete);
1637 resolve (td_ta_get_ph);
1638 resolve (td_ta_get_nthreads);
1639 resolve (td_ta_tsd_iter);
1640 resolve (td_ta_thr_iter);
1641 resolve (td_thr_validate);
1642 resolve (td_thr_tsd);
1643 resolve (td_thr_get_info);
1644 resolve (td_thr_getfpregs);
1645 resolve (td_thr_getxregsize);
1646 resolve (td_thr_getxregs);
1647 resolve (td_thr_sigsetmask);
1648 resolve (td_thr_setprio);
1649 resolve (td_thr_setsigpending);
1650 resolve (td_thr_setfpregs);
1651 resolve (td_thr_setxregs);
1652 resolve (td_ta_map_id2thr);
1653 resolve (td_ta_map_lwp2thr);
1654 resolve (td_thr_getgregs);
1655 resolve (td_thr_setgregs);
1657 add_target (&sol_thread_ops);
1659 procfs_suppress_run = 1;
1661 add_cmd ("sol-threads", class_maintenance, info_solthreads,
1662 _("Show info on Solaris user threads."), &maintenanceinfolist);
1664 memcpy (&orig_core_ops, &core_ops, sizeof (struct target_ops));
1665 memcpy (&core_ops, &sol_core_ops, sizeof (struct target_ops));
1666 add_target (&core_ops);
1668 /* Hook into new_objfile notification. */
1669 target_new_objfile_chain = deprecated_target_new_objfile_hook;
1670 deprecated_target_new_objfile_hook = sol_thread_new_objfile;
1674 fprintf_unfiltered (gdb_stderr, "\
1675 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1680 /* Allow the user to debug non-threaded core files. */
1681 add_target (&core_ops);