1 /* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
2 Copyright 1996, 1997, 1998 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* This module implements a sort of half target that sits between the
22 machine-independent parts of GDB and the /proc interface (procfs.c) to
23 provide access to the Solaris user-mode thread implementation.
25 Solaris threads are true user-mode threads, which are invoked via the thr_*
26 and pthread_* (native and Posix respectivly) interfaces. These are mostly
27 implemented in user-space, with all thread context kept in various
28 structures that live in the user's heap. These should not be confused with
29 lightweight processes (LWPs), which are implemented by the kernel, and
30 scheduled without explicit intervention by the process.
32 Just to confuse things a little, Solaris threads (both native and Posix) are
33 actually implemented using LWPs. In general, there are going to be more
34 threads than LWPs. There is no fixed correspondence between a thread and an
35 LWP. When a thread wants to run, it gets scheduled onto the first available
36 LWP and can therefore migrate from one LWP to another as time goes on. A
37 sleeping thread may not be associated with an LWP at all!
39 To make it possible to mess with threads, Sun provides a library called
40 libthread_db.so.1 (not to be confused with libthread_db.so.0, which doesn't
41 have a published interface). This interface has an upper part, which it
42 provides, and a lower part which I provide. The upper part consists of the
43 td_* routines, which allow me to find all the threads, query their state,
44 etc... The lower part consists of all of the ps_*, which are used by the
45 td_* routines to read/write memory, manipulate LWPs, lookup symbols, etc...
46 The ps_* routines actually do most of their work by calling functions in
51 #include <proc_service.h>
52 #include <thread_db.h>
53 #include "gdbthread.h"
61 extern struct target_ops sol_thread_ops
; /* Forward declaration */
62 extern struct target_ops sol_core_ops
; /* Forward declaration */
64 /* place to store core_ops before we overwrite it */
65 static struct target_ops orig_core_ops
;
67 struct target_ops sol_thread_ops
;
68 struct target_ops sol_core_ops
;
70 extern int procfs_suppress_run
;
71 extern struct target_ops procfs_ops
; /* target vector for procfs.c */
72 extern struct target_ops core_ops
; /* target vector for corelow.c */
73 extern char *procfs_pid_to_str
PARAMS ((int pid
));
75 /* Note that these prototypes differ slightly from those used in procfs.c
76 for of two reasons. One, we can't use gregset_t, as that's got a whole
77 different meaning under Solaris (also, see above). Two, we can't use the
78 pointer form here as these are actually arrays of ints (for Sparc's at
79 least), and are automatically coerced into pointers to ints when used as
80 parameters. That makes it impossible to avoid a compiler warning when
81 passing pr{g fp}regset_t's from a parameter to an argument of one of
84 extern void supply_gregset
PARAMS ((const prgregset_t
));
85 extern void fill_gregset
PARAMS ((prgregset_t
, int));
86 extern void supply_fpregset
PARAMS ((const prfpregset_t
*));
87 extern void fill_fpregset
PARAMS ((prfpregset_t
*, int));
89 /* This struct is defined by us, but mainly used for the proc_service interface.
90 We don't have much use for it, except as a handy place to get a real pid
91 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 struct cleanup
*save_inferior_pid
PARAMS ((void));
109 static void restore_inferior_pid
PARAMS ((void *pid
));
110 static char *td_err_string
PARAMS ((td_err_e errcode
));
111 static char *td_state_string
PARAMS ((td_thr_state_e statecode
));
112 static int thread_to_lwp
PARAMS ((int thread_id
, int default_lwp
));
113 static void sol_thread_resume
PARAMS ((int pid
, int step
,
114 enum target_signal signo
));
115 static int lwp_to_thread
PARAMS ((int lwp
));
116 static int sol_thread_alive
PARAMS ((int pid
));
117 static void sol_core_close
PARAMS ((int quitting
));
119 static void init_sol_thread_ops
PARAMS ((void));
120 static void init_sol_core_ops
PARAMS ((void));
122 /* Default definitions: These must be defined in tm.h
123 if they are to be shared with a process module such as procfs. */
125 #define THREAD_FLAG 0x80000000
126 #define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
127 #define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
128 #define GET_LWP(PID) TIDGET (PID)
129 #define GET_THREAD(PID) (((PID) >> 16) & 0x7fff)
130 #define BUILD_LWP(TID, PID) ((TID) << 16 | (PID))
132 #define BUILD_THREAD(THREAD_ID, PID) (THREAD_FLAG | BUILD_LWP (THREAD_ID, PID))
134 /* Pointers to routines from lithread_db resolved by dlopen() */
137 (*p_td_log
) (const int on_off
);
139 (*p_td_ta_new
) (const struct ps_prochandle
* ph_p
, td_thragent_t
** ta_pp
);
141 (*p_td_ta_delete
) (td_thragent_t
* ta_p
);
145 (*p_td_ta_get_ph
) (const td_thragent_t
* ta_p
, struct ps_prochandle
** ph_pp
);
147 (*p_td_ta_get_nthreads
) (const td_thragent_t
* ta_p
, int *nthread_p
);
149 (*p_td_ta_tsd_iter
) (const td_thragent_t
* ta_p
, td_key_iter_f
* cb
, void *cbdata_p
);
151 (*p_td_ta_thr_iter
) (const td_thragent_t
* ta_p
, td_thr_iter_f
* cb
, void *cbdata_p
, td_thr_state_e state
,
152 int ti_pri
, sigset_t
* ti_sigmask_p
, unsigned ti_user_flags
);
154 (*p_td_thr_validate
) (const td_thrhandle_t
* th_p
);
156 (*p_td_thr_tsd
) (const td_thrhandle_t
* th_p
, const thread_key_t key
, void **data_pp
);
158 (*p_td_thr_get_info
) (const td_thrhandle_t
* th_p
, td_thrinfo_t
* ti_p
);
160 (*p_td_thr_getfpregs
) (const td_thrhandle_t
* th_p
, prfpregset_t
* fpregset
);
162 (*p_td_thr_getxregsize
) (const td_thrhandle_t
* th_p
, int *xregsize
);
164 (*p_td_thr_getxregs
) (const td_thrhandle_t
* th_p
, const caddr_t xregset
);
166 (*p_td_thr_sigsetmask
) (const td_thrhandle_t
* th_p
, const sigset_t ti_sigmask
);
168 (*p_td_thr_setprio
) (const td_thrhandle_t
* th_p
, const int ti_pri
);
170 (*p_td_thr_setsigpending
) (const td_thrhandle_t
* th_p
, const uchar_t ti_pending_flag
, const sigset_t ti_pending
);
172 (*p_td_thr_setfpregs
) (const td_thrhandle_t
* th_p
, const prfpregset_t
* fpregset
);
174 (*p_td_thr_setxregs
) (const td_thrhandle_t
* th_p
, const caddr_t xregset
);
176 (*p_td_ta_map_id2thr
) (const td_thragent_t
* ta_p
, thread_t tid
, td_thrhandle_t
* th_p
);
178 (*p_td_ta_map_lwp2thr
) (const td_thragent_t
* ta_p
, lwpid_t lwpid
, td_thrhandle_t
* th_p
);
180 (*p_td_thr_getgregs
) (const td_thrhandle_t
* th_p
, prgregset_t regset
);
182 (*p_td_thr_setgregs
) (const td_thrhandle_t
* th_p
, const prgregset_t regset
);
188 td_err_string - Convert a thread_db error code to a string
192 char * td_err_string (errcode)
196 Return the thread_db error string associated with errcode. If errcode
197 is unknown, then return a message.
202 td_err_string (errcode
)
205 static struct string_map
208 {TD_OK
, "generic \"call succeeded\""},
209 {TD_ERR
, "generic error."},
210 {TD_NOTHR
, "no thread can be found to satisfy query"},
211 {TD_NOSV
, "no synch. variable can be found to satisfy query"},
212 {TD_NOLWP
, "no lwp can be found to satisfy query"},
213 {TD_BADPH
, "invalid process handle"},
214 {TD_BADTH
, "invalid thread handle"},
215 {TD_BADSH
, "invalid synchronization handle"},
216 {TD_BADTA
, "invalid thread agent"},
217 {TD_BADKEY
, "invalid key"},
218 {TD_NOMSG
, "td_thr_event_getmsg() called when there was no message"},
219 {TD_NOFPREGS
, "FPU register set not available for given thread"},
220 {TD_NOLIBTHREAD
, "application not linked with libthread"},
221 {TD_NOEVENT
, "requested event is not supported"},
222 {TD_NOCAPAB
, "capability not available"},
223 {TD_DBERR
, "Debugger service failed"},
224 {TD_NOAPLIC
, "Operation not applicable to"},
225 {TD_NOTSD
, "No thread specific data for this thread"},
226 {TD_MALLOC
, "Malloc failed"},
227 {TD_PARTIALREG
, "Only part of register set was writen/read"},
228 {TD_NOXREGS
, "X register set not available for given thread"}
230 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
234 for (i
= 0; i
< td_err_size
; i
++)
235 if (td_err_table
[i
].num
== errcode
)
236 return td_err_table
[i
].str
;
238 sprintf (buf
, "Unknown thread_db error code: %d", errcode
);
247 td_state_string - Convert a thread_db state code to a string
251 char * td_state_string (statecode)
255 Return the thread_db state string associated with statecode. If
256 statecode is unknown, then return a message.
261 td_state_string (statecode
)
262 td_thr_state_e statecode
;
264 static struct string_map
265 td_thr_state_table
[] =
267 {TD_THR_ANY_STATE
, "any state"},
268 {TD_THR_UNKNOWN
, "unknown"},
269 {TD_THR_STOPPED
, "stopped"},
271 {TD_THR_ACTIVE
, "active"},
272 {TD_THR_ZOMBIE
, "zombie"},
273 {TD_THR_SLEEP
, "sleep"},
274 {TD_THR_STOPPED_ASLEEP
, "stopped asleep"}
276 const int td_thr_state_table_size
= sizeof td_thr_state_table
/ sizeof (struct string_map
);
280 for (i
= 0; i
< td_thr_state_table_size
; i
++)
281 if (td_thr_state_table
[i
].num
== statecode
)
282 return td_thr_state_table
[i
].str
;
284 sprintf (buf
, "Unknown thread_db state code: %d", statecode
);
293 thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
297 int thread_to_lwp (thread_id, default_lwp)
301 This function converts a Posix or Solaris thread id to a lightweight
302 process id. If thread_id is non-existent, that's an error. If it's
303 an inactive thread, then we return default_lwp.
307 This function probably shouldn't call error()...
312 thread_to_lwp (thread_id
, default_lwp
)
320 if (is_lwp (thread_id
))
321 return thread_id
; /* It's already an LWP id */
323 /* It's a thread. Convert to lwp */
325 val
= p_td_ta_map_id2thr (main_ta
, GET_THREAD (thread_id
), &th
);
327 return -1; /* thread must have terminated */
328 else if (val
!= TD_OK
)
329 error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val
));
331 val
= p_td_thr_get_info (&th
, &ti
);
333 return -1; /* thread must have terminated */
334 else if (val
!= TD_OK
)
335 error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val
));
337 if (ti
.ti_state
!= TD_THR_ACTIVE
)
339 if (default_lwp
!= -1)
341 error ("thread_to_lwp: thread state not active: %s",
342 td_state_string (ti
.ti_state
));
345 return BUILD_LWP (ti
.ti_lid
, PIDGET (thread_id
));
352 lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
356 int lwp_to_thread (lwp_id)
360 This function converts a lightweight process id to a Posix or Solaris
361 thread id. If thread_id is non-existent, that's an error.
365 This function probably shouldn't call error()...
378 return lwp
; /* It's already a thread id */
380 /* It's an lwp. Convert it to a thread id. */
382 if (!sol_thread_alive (lwp
))
383 return -1; /* defunct lwp */
385 val
= p_td_ta_map_lwp2thr (main_ta
, GET_LWP (lwp
), &th
);
387 return -1; /* thread must have terminated */
388 else if (val
!= TD_OK
)
389 error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val
));
391 val
= p_td_thr_validate (&th
);
393 return lwp
; /* libthread doesn't know about it, just return lwp */
394 else if (val
!= TD_OK
)
395 error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val
));
397 val
= p_td_thr_get_info (&th
, &ti
);
399 return -1; /* thread must have terminated */
400 else if (val
!= TD_OK
)
401 error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val
));
403 return BUILD_THREAD (ti
.ti_tid
, PIDGET (lwp
));
410 save_inferior_pid - Save inferior_pid on the cleanup list
411 restore_inferior_pid - Restore inferior_pid from the cleanup list
415 struct cleanup *save_inferior_pid ()
416 void restore_inferior_pid (int pid)
420 These two functions act in unison to restore inferior_pid in
425 inferior_pid is a global variable that needs to be changed by many of
426 these routines before calling functions in procfs.c. In order to
427 guarantee that inferior_pid gets restored (in case of errors), you
428 need to call save_inferior_pid before changing it. At the end of the
429 function, you should invoke do_cleanups to restore it.
434 static struct cleanup
*
437 return make_cleanup (restore_inferior_pid
, (void *) inferior_pid
);
441 restore_inferior_pid (pid
)
444 inferior_pid
= (int) pid
;
448 /* Most target vector functions from here on actually just pass through to
449 procfs.c, as they don't need to do anything specific for threads. */
454 sol_thread_open (arg
, from_tty
)
458 procfs_ops
.to_open (arg
, from_tty
);
461 /* Attach to process PID, then initialize for debugging it
462 and wait for the trace-trap that results from attaching. */
465 sol_thread_attach (args
, from_tty
)
469 procfs_ops
.to_attach (args
, from_tty
);
470 /* Must get symbols from solibs before libthread_db can run! */
471 SOLIB_ADD ((char *) 0, from_tty
, (struct target_ops
*) 0);
472 if (sol_thread_active
)
474 printf_filtered ("sol-thread active.\n");
475 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
476 push_target (&sol_thread_ops
);
477 inferior_pid
= lwp_to_thread (inferior_pid
);
478 if (inferior_pid
== -1)
479 inferior_pid
= main_ph
.pid
;
481 add_thread (inferior_pid
);
483 /* XXX - might want to iterate over all the threads and register them. */
486 /* Take a program previously attached to and detaches it.
487 The program resumes execution and will no longer stop
488 on signals, etc. We'd better not have left any breakpoints
489 in the program or it'll die when it hits one. For this
490 to work, it may be necessary for the process to have been
491 previously attached. It *might* work if the program was
492 started via the normal ptrace (PTRACE_TRACEME). */
495 sol_thread_detach (args
, from_tty
)
499 inferior_pid
= PIDGET (main_ph
.pid
);
500 unpush_target (&sol_thread_ops
);
501 procfs_ops
.to_detach (args
, from_tty
);
504 /* Resume execution of process PID. If STEP is nozero, then
505 just single step it. If SIGNAL is nonzero, restart it with that
506 signal activated. We may have to convert pid from a thread-id to an LWP id
510 sol_thread_resume (pid
, step
, signo
)
513 enum target_signal signo
;
515 struct cleanup
*old_chain
;
517 old_chain
= save_inferior_pid ();
519 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
520 if (inferior_pid
== -1)
521 inferior_pid
= procfs_first_available ();
527 pid
= thread_to_lwp (pid
, -2);
528 if (pid
== -2) /* Inactive thread */
529 error ("This version of Solaris can't start inactive threads.");
530 if (info_verbose
&& pid
== -1)
531 warning ("Specified thread %d seems to have terminated",
532 GET_THREAD (save_pid
));
535 procfs_ops
.to_resume (pid
, step
, signo
);
537 do_cleanups (old_chain
);
540 /* Wait for any threads to stop. We may have to convert PID from a thread id
541 to a LWP id, and vice versa on the way out. */
544 sol_thread_wait (pid
, ourstatus
)
546 struct target_waitstatus
*ourstatus
;
550 struct cleanup
*old_chain
;
552 save_pid
= inferior_pid
;
553 old_chain
= save_inferior_pid ();
555 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
556 if (inferior_pid
== -1)
557 inferior_pid
= procfs_first_available ();
563 pid
= thread_to_lwp (pid
, -2);
564 if (pid
== -2) /* Inactive thread */
565 error ("This version of Solaris can't start inactive threads.");
566 if (info_verbose
&& pid
== -1)
567 warning ("Specified thread %d seems to have terminated",
568 GET_THREAD (save_pid
));
571 rtnval
= procfs_ops
.to_wait (pid
, ourstatus
);
573 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
575 /* Map the LWP of interest back to the appropriate thread ID */
576 rtnval
= lwp_to_thread (rtnval
);
580 /* See if we have a new thread */
581 if (is_thread (rtnval
)
582 && rtnval
!= save_pid
583 && !in_thread_list (rtnval
))
585 printf_filtered ("[New %s]\n", target_pid_to_str (rtnval
));
590 /* During process initialization, we may get here without the thread package
591 being initialized, since that can only happen after we've found the shared
594 do_cleanups (old_chain
);
600 sol_thread_fetch_registers (regno
)
604 td_thrhandle_t thandle
;
607 prfpregset_t fpregset
;
613 if (!is_thread (inferior_pid
))
614 { /* LWP: pass the request on to procfs.c */
615 if (target_has_execution
)
616 procfs_ops
.to_fetch_registers (regno
);
618 orig_core_ops
.to_fetch_registers (regno
);
622 /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
624 thread
= GET_THREAD (inferior_pid
);
627 error ("sol_thread_fetch_registers: thread == 0");
629 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
631 error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
632 td_err_string (val
));
634 /* Get the integer regs */
636 val
= p_td_thr_getgregs (&thandle
, gregset
);
638 && val
!= TD_PARTIALREG
)
639 error ("sol_thread_fetch_registers: td_thr_getgregs %s",
640 td_err_string (val
));
642 /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
643 are saved (by a thread context switch). */
645 /* And, now the fp regs */
647 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
649 && val
!= TD_NOFPREGS
)
650 error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
651 td_err_string (val
));
653 /* Note that we must call supply_{g fp}regset *after* calling the td routines
654 because the td routines call ps_lget* which affect the values stored in the
657 supply_gregset (gregset
);
658 supply_fpregset (&fpregset
);
661 /* thread_db doesn't seem to handle this right */
662 val
= td_thr_getxregsize (&thandle
, &xregsize
);
663 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
664 error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
665 td_err_string (val
));
669 xregset
= alloca (xregsize
);
670 val
= td_thr_getxregs (&thandle
, xregset
);
672 error ("sol_thread_fetch_registers: td_thr_getxregs %s",
673 td_err_string (val
));
679 sol_thread_store_registers (regno
)
683 td_thrhandle_t thandle
;
686 prfpregset_t fpregset
;
692 if (!is_thread (inferior_pid
))
693 { /* LWP: pass the request on to procfs.c */
694 procfs_ops
.to_store_registers (regno
);
698 /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
700 thread
= GET_THREAD (inferior_pid
);
702 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
704 error ("sol_thread_store_registers: td_ta_map_id2thr %s",
705 td_err_string (val
));
708 { /* Not writing all the regs */
709 /* save new register value */
710 char old_value
[REGISTER_SIZE
];
711 memcpy (old_value
, ®isters
[REGISTER_BYTE (regno
)], REGISTER_SIZE
);
713 val
= p_td_thr_getgregs (&thandle
, regset
);
715 error ("sol_thread_store_registers: td_thr_getgregs %s",
716 td_err_string (val
));
717 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
719 error ("sol_thread_store_registers: td_thr_getfpregs %s",
720 td_err_string (val
));
722 /* restore new register value */
723 memcpy (®isters
[REGISTER_BYTE (regno
)], old_value
, REGISTER_SIZE
);
726 /* thread_db doesn't seem to handle this right */
727 val
= td_thr_getxregsize (&thandle
, &xregsize
);
728 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
729 error ("sol_thread_store_registers: td_thr_getxregsize %s",
730 td_err_string (val
));
734 xregset
= alloca (xregsize
);
735 val
= td_thr_getxregs (&thandle
, xregset
);
737 error ("sol_thread_store_registers: td_thr_getxregs %s",
738 td_err_string (val
));
743 fill_gregset (regset
, regno
);
744 fill_fpregset (&fpregset
, regno
);
746 val
= p_td_thr_setgregs (&thandle
, regset
);
748 error ("sol_thread_store_registers: td_thr_setgregs %s",
749 td_err_string (val
));
750 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
752 error ("sol_thread_store_registers: td_thr_setfpregs %s",
753 td_err_string (val
));
756 /* thread_db doesn't seem to handle this right */
757 val
= td_thr_getxregsize (&thandle
, &xregsize
);
758 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
759 error ("sol_thread_store_registers: td_thr_getxregsize %s",
760 td_err_string (val
));
762 /* Should probably do something about writing the xregs here, but what are
767 /* Get ready to modify the registers array. On machines which store
768 individual registers, this doesn't need to do anything. On machines
769 which store all the registers in one fell swoop, this makes sure
770 that registers contains all the registers from the program being
774 sol_thread_prepare_to_store ()
776 procfs_ops
.to_prepare_to_store ();
780 sol_thread_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
785 struct target_ops
*target
; /* ignored */
788 struct cleanup
*old_chain
;
790 old_chain
= save_inferior_pid ();
792 if (is_thread (inferior_pid
) || /* A thread */
793 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
794 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
795 /* Note: don't need to call switch_to_thread; we're just reading memory. */
797 if (target_has_execution
)
798 retval
= procfs_ops
.to_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
);
800 retval
= orig_core_ops
.to_xfer_memory (memaddr
, myaddr
, len
,
803 do_cleanups (old_chain
);
808 /* Print status information about what we're accessing. */
811 sol_thread_files_info (ignore
)
812 struct target_ops
*ignore
;
814 procfs_ops
.to_files_info (ignore
);
818 sol_thread_kill_inferior ()
820 procfs_ops
.to_kill ();
824 sol_thread_notice_signals (pid
)
827 procfs_ops
.to_notice_signals (PIDGET (pid
));
830 /* Fork an inferior process, and start debugging it with /proc. */
833 sol_thread_create_inferior (exec_file
, allargs
, env
)
838 procfs_ops
.to_create_inferior (exec_file
, allargs
, env
);
840 if (sol_thread_active
&& inferior_pid
!= 0)
842 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
844 push_target (&sol_thread_ops
);
846 inferior_pid
= lwp_to_thread (inferior_pid
);
847 if (inferior_pid
== -1)
848 inferior_pid
= main_ph
.pid
;
850 add_thread (inferior_pid
);
854 /* This routine is called whenever a new symbol table is read in, or when all
855 symbol tables are removed. libthread_db can only be initialized when it
856 finds the right variables in libthread.so. Since it's a shared library,
857 those variables don't show up until the library gets mapped and the symbol
861 sol_thread_new_objfile (objfile
)
862 struct objfile
*objfile
;
868 sol_thread_active
= 0;
873 /* don't do anything if init failed to resolve the libthread_db library */
874 if (!procfs_suppress_run
)
877 /* Now, initialize the thread debugging library. This needs to be done after
878 the shared libraries are located because it needs information from the
879 user's thread library. */
883 error ("target_new_objfile: td_init: %s", td_err_string (val
));
885 val
= p_td_ta_new (&main_ph
, &main_ta
);
886 if (val
== TD_NOLIBTHREAD
)
888 else if (val
!= TD_OK
)
889 error ("target_new_objfile: td_ta_new: %s", td_err_string (val
));
891 sol_thread_active
= 1;
894 /* Clean up after the inferior dies. */
897 sol_thread_mourn_inferior ()
899 unpush_target (&sol_thread_ops
);
900 procfs_ops
.to_mourn_inferior ();
903 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
906 sol_thread_can_run ()
908 return procfs_suppress_run
;
915 sol_thread_alive - test thread for "aliveness"
919 static bool sol_thread_alive (int pid);
923 returns true if thread still active in inferior.
928 sol_thread_alive (pid
)
931 if (is_thread (pid
)) /* non-kernel thread */
936 pid
= GET_THREAD (pid
);
937 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
938 return 0; /* thread not found */
939 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
940 return 0; /* thread not valid */
941 return 1; /* known thread: return true */
944 /* kernel thread (LWP): let procfs test it */
946 if (target_has_execution
)
947 return procfs_ops
.to_thread_alive (pid
);
949 return orig_core_ops
.to_thread_alive (pid
);
956 procfs_ops
.to_stop ();
959 /* These routines implement the lower half of the thread_db interface. Ie: the
962 /* Various versions of <proc_service.h> have slightly
963 different function prototypes. In particular, we have
966 struct ps_prochandle * const struct ps_prochandle *
971 Which one you have depends on solaris version and what
972 patches you've applied. On the theory that there are
973 only two major variants, we have configure check the
974 prototype of ps_pdwrite (), and use that info to make
975 appropriate typedefs here. */
977 #ifdef PROC_SERVICE_IS_OLD
978 typedef const struct ps_prochandle
*gdb_ps_prochandle_t
;
979 typedef char *gdb_ps_read_buf_t
;
980 typedef char *gdb_ps_write_buf_t
;
981 typedef int gdb_ps_size_t
;
983 typedef struct ps_prochandle
*gdb_ps_prochandle_t
;
984 typedef void *gdb_ps_read_buf_t
;
985 typedef const void *gdb_ps_write_buf_t
;
986 typedef size_t gdb_ps_size_t
;
990 /* The next four routines are called by thread_db to tell us to stop and stop
991 a particular process or lwp. Since GDB ensures that these are all stopped
992 by the time we call anything in thread_db, these routines need to do
998 ps_pstop (gdb_ps_prochandle_t ph
)
1003 /* Process continue */
1006 ps_pcontinue (gdb_ps_prochandle_t ph
)
1014 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1022 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1027 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
1030 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
1031 const char *ld_symbol_name
, paddr_t
* ld_symbol_addr
)
1033 struct minimal_symbol
*ms
;
1035 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
1040 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
1045 /* Common routine for reading and writing memory. */
1048 rw_common (int dowrite
, const struct ps_prochandle
*ph
, paddr_t addr
,
1049 char *buf
, int size
)
1051 struct cleanup
*old_chain
;
1053 old_chain
= save_inferior_pid ();
1055 if (is_thread (inferior_pid
) || /* A thread */
1056 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
1057 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
1058 /* Note: don't need to call switch_to_thread; we're just reading memory. */
1064 if (target_has_execution
)
1065 cc
= procfs_ops
.to_xfer_memory (addr
, buf
, size
, dowrite
, &procfs_ops
);
1067 cc
= orig_core_ops
.to_xfer_memory (addr
, buf
, size
, dowrite
, &core_ops
);
1072 print_sys_errmsg ("rw_common (): read", errno
);
1074 print_sys_errmsg ("rw_common (): write", errno
);
1076 do_cleanups (old_chain
);
1084 do_cleanups (old_chain
);
1089 /* Copies SIZE bytes from target process .data segment to debugger memory. */
1092 ps_pdread (gdb_ps_prochandle_t ph
, paddr_t addr
,
1093 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1095 return rw_common (0, ph
, addr
, buf
, size
);
1098 /* Copies SIZE bytes from debugger memory .data segment to target process. */
1101 ps_pdwrite (gdb_ps_prochandle_t ph
, paddr_t addr
,
1102 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1104 return rw_common (1, ph
, addr
, (char *) buf
, size
);
1107 /* Copies SIZE bytes from target process .text segment to debugger memory. */
1110 ps_ptread (gdb_ps_prochandle_t ph
, paddr_t addr
,
1111 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1113 return rw_common (0, ph
, addr
, buf
, size
);
1116 /* Copies SIZE bytes from debugger memory .text segment to target process. */
1119 ps_ptwrite (gdb_ps_prochandle_t ph
, paddr_t addr
,
1120 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1122 return rw_common (1, ph
, addr
, (char *) buf
, size
);
1125 /* Get integer regs for LWP */
1128 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1129 prgregset_t gregset
)
1131 struct cleanup
*old_chain
;
1133 old_chain
= save_inferior_pid ();
1135 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1137 if (target_has_execution
)
1138 procfs_ops
.to_fetch_registers (-1);
1140 orig_core_ops
.to_fetch_registers (-1);
1141 fill_gregset (gregset
, -1);
1143 do_cleanups (old_chain
);
1148 /* Set integer regs for LWP */
1151 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1152 const prgregset_t gregset
)
1154 struct cleanup
*old_chain
;
1156 old_chain
= save_inferior_pid ();
1158 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1160 supply_gregset (gregset
);
1161 if (target_has_execution
)
1162 procfs_ops
.to_store_registers (-1);
1164 orig_core_ops
.to_store_registers (-1);
1166 do_cleanups (old_chain
);
1171 /* Log a message (sends to gdb_stderr). */
1174 ps_plog (const char *fmt
,...)
1178 va_start (args
, fmt
);
1180 vfprintf_filtered (gdb_stderr
, fmt
, args
);
1183 /* Get size of extra register set. Currently a noop. */
1186 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
1193 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1197 if (ioctl (lwp_fd
, PIOCGXREGSIZE
, ®size
))
1199 if (errno
== EINVAL
)
1200 return PS_NOFREGS
; /* XXX Wrong code, but this is the closest
1201 thing in proc_service.h */
1203 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno
);
1211 /* Get extra register set. Currently a noop. */
1214 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1220 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1224 if (ioctl (lwp_fd
, PIOCGXREG
, xregset
))
1226 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno
);
1234 /* Set extra register set. Currently a noop. */
1237 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1243 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1247 if (ioctl (lwp_fd
, PIOCSXREG
, xregset
))
1249 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno
);
1257 /* Get floating-point regs for LWP */
1260 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1261 prfpregset_t
* fpregset
)
1263 struct cleanup
*old_chain
;
1265 old_chain
= save_inferior_pid ();
1267 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1269 if (target_has_execution
)
1270 procfs_ops
.to_fetch_registers (-1);
1272 orig_core_ops
.to_fetch_registers (-1);
1273 fill_fpregset (fpregset
, -1);
1275 do_cleanups (old_chain
);
1280 /* Set floating-point regs for LWP */
1283 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1284 const prfpregset_t
* fpregset
)
1286 struct cleanup
*old_chain
;
1288 old_chain
= save_inferior_pid ();
1290 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1292 supply_fpregset (fpregset
);
1293 if (target_has_execution
)
1294 procfs_ops
.to_store_registers (-1);
1296 orig_core_ops
.to_store_registers (-1);
1298 do_cleanups (old_chain
);
1303 #ifdef TM_I386SOL2_H
1305 /* Get local descriptor table. */
1307 #include <sys/procfs.h>
1308 #include <sys/reg.h>
1309 #include <sys/sysi86.h>
1311 static int nldt_allocated
= 0;
1312 static struct ssd
*ldt_bufp
= NULL
;
1314 /* Reads the local descriptor table of a LWP. */
1317 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1326 /* Get procfs file descriptor for the LWP. */
1327 lwp_fd
= procfs_get_pid_fd (BUILD_LWP (lwpid
, PIDGET (inferior_pid
)));
1331 /* Fetch registers und LDT descriptors. */
1332 if (ioctl (lwp_fd
, PIOCGREG
, &gregset
) == -1)
1335 if (ioctl (lwp_fd
, PIOCNLDT
, &nldt
) == -1)
1338 if (nldt_allocated
< nldt
)
1341 = (struct ssd
*) xrealloc (ldt_bufp
, (nldt
+ 1) * sizeof (struct ssd
));
1342 nldt_allocated
= nldt
;
1345 if (ioctl (lwp_fd
, PIOCLDT
, ldt_bufp
) == -1)
1348 /* Search LDT for the LWP via register GS. */
1349 for (i
= 0; i
< nldt
; i
++)
1351 if (ldt_bufp
[i
].sel
== (gregset
[GS
] & 0xffff))
1353 *pldt
= ldt_bufp
[i
];
1358 /* LDT not found. */
1361 #endif /* TM_I386SOL2_H */
1363 /* Convert a pid to printable form. */
1366 solaris_pid_to_str (pid
)
1369 static char buf
[100];
1371 /* in case init failed to resolve the libthread_db library */
1372 if (!procfs_suppress_run
)
1373 return procfs_pid_to_str (pid
);
1375 if (is_thread (pid
))
1379 lwp
= thread_to_lwp (pid
, -2);
1382 sprintf (buf
, "Thread %d (defunct)", GET_THREAD (pid
));
1384 sprintf (buf
, "Thread %d (LWP %d)", GET_THREAD (pid
), GET_LWP (lwp
));
1386 sprintf (buf
, "Thread %d ", GET_THREAD (pid
));
1388 else if (GET_LWP (pid
) != 0)
1389 sprintf (buf
, "LWP %d ", GET_LWP (pid
));
1391 sprintf (buf
, "process %d ", PIDGET (pid
));
1397 /* Worker bee for find_new_threads
1398 Callback function that gets called once per USER thread (i.e., not
1402 sol_find_new_threads_callback (th
, ignored
)
1403 const td_thrhandle_t
*th
;
1410 if ((retval
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1414 pid
= BUILD_THREAD (ti
.ti_tid
, PIDGET (inferior_pid
));
1415 if (!in_thread_list (pid
))
1422 sol_find_new_threads ()
1424 /* don't do anything if init failed to resolve the libthread_db library */
1425 if (!procfs_suppress_run
)
1428 if (inferior_pid
== -1)
1430 printf_filtered ("No process.\n");
1433 p_td_ta_thr_iter (main_ta
, sol_find_new_threads_callback
, (void *) 0,
1434 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1435 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1439 sol_core_open (filename
, from_tty
)
1443 orig_core_ops
.to_open (filename
, from_tty
);
1447 sol_core_close (quitting
)
1450 orig_core_ops
.to_close (quitting
);
1454 sol_core_detach (args
, from_tty
)
1458 unpush_target (&core_ops
);
1459 orig_core_ops
.to_detach (args
, from_tty
);
1463 sol_core_files_info (t
)
1464 struct target_ops
*t
;
1466 orig_core_ops
.to_files_info (t
);
1469 /* Worker bee for info sol-thread command. This is a callback function that
1470 gets called once for each Solaris thread (ie. not kernel thread) in the
1471 inferior. Print anything interesting that we can think of. */
1475 const td_thrhandle_t
*th
;
1480 struct minimal_symbol
*msym
;
1482 if ((ret
= p_td_thr_get_info (th
, &ti
)) == TD_OK
)
1484 printf_filtered ("%s thread #%d, lwp %d, ",
1485 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1486 ti
.ti_tid
, ti
.ti_lid
);
1487 switch (ti
.ti_state
)
1490 case TD_THR_UNKNOWN
:
1491 printf_filtered ("<unknown state>");
1493 case TD_THR_STOPPED
:
1494 printf_filtered ("(stopped)");
1497 printf_filtered ("(run) ");
1500 printf_filtered ("(active) ");
1503 printf_filtered ("(zombie) ");
1506 printf_filtered ("(asleep) ");
1508 case TD_THR_STOPPED_ASLEEP
:
1509 printf_filtered ("(stopped asleep)");
1512 /* Print thr_create start function: */
1513 if (ti
.ti_startfunc
!= 0)
1514 if (msym
= lookup_minimal_symbol_by_pc (ti
.ti_startfunc
))
1515 printf_filtered (" startfunc: %s\n", SYMBOL_NAME (msym
));
1517 printf_filtered (" startfunc: 0x%08x\n", ti
.ti_startfunc
);
1519 /* If thread is asleep, print function that went to sleep: */
1520 if (ti
.ti_state
== TD_THR_SLEEP
)
1521 if (msym
= lookup_minimal_symbol_by_pc (ti
.ti_pc
))
1522 printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym
));
1524 printf_filtered (" - Sleep func: 0x%08x\n", ti
.ti_startfunc
);
1526 /* Wrap up line, if necessary */
1527 if (ti
.ti_state
!= TD_THR_SLEEP
&& ti
.ti_startfunc
== 0)
1528 printf_filtered ("\n"); /* don't you hate counting newlines? */
1531 warning ("info sol-thread: failed to get info for thread.");
1536 /* List some state about each Solaris user thread in the inferior. */
1539 info_solthreads (args
, from_tty
)
1543 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1544 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1545 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1549 ignore (addr
, contents
)
1558 init_sol_thread_ops ()
1560 sol_thread_ops
.to_shortname
= "solaris-threads";
1561 sol_thread_ops
.to_longname
= "Solaris threads and pthread.";
1562 sol_thread_ops
.to_doc
= "Solaris threads and pthread support.";
1563 sol_thread_ops
.to_open
= sol_thread_open
;
1564 sol_thread_ops
.to_close
= 0;
1565 sol_thread_ops
.to_attach
= sol_thread_attach
;
1566 sol_thread_ops
.to_detach
= sol_thread_detach
;
1567 sol_thread_ops
.to_resume
= sol_thread_resume
;
1568 sol_thread_ops
.to_wait
= sol_thread_wait
;
1569 sol_thread_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1570 sol_thread_ops
.to_store_registers
= sol_thread_store_registers
;
1571 sol_thread_ops
.to_prepare_to_store
= sol_thread_prepare_to_store
;
1572 sol_thread_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1573 sol_thread_ops
.to_files_info
= sol_thread_files_info
;
1574 sol_thread_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1575 sol_thread_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1576 sol_thread_ops
.to_terminal_init
= terminal_init_inferior
;
1577 sol_thread_ops
.to_terminal_inferior
= terminal_inferior
;
1578 sol_thread_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1579 sol_thread_ops
.to_terminal_ours
= terminal_ours
;
1580 sol_thread_ops
.to_terminal_info
= child_terminal_info
;
1581 sol_thread_ops
.to_kill
= sol_thread_kill_inferior
;
1582 sol_thread_ops
.to_load
= 0;
1583 sol_thread_ops
.to_lookup_symbol
= 0;
1584 sol_thread_ops
.to_create_inferior
= sol_thread_create_inferior
;
1585 sol_thread_ops
.to_mourn_inferior
= sol_thread_mourn_inferior
;
1586 sol_thread_ops
.to_can_run
= sol_thread_can_run
;
1587 sol_thread_ops
.to_notice_signals
= sol_thread_notice_signals
;
1588 sol_thread_ops
.to_thread_alive
= sol_thread_alive
;
1589 sol_thread_ops
.to_find_new_threads
= sol_find_new_threads
;
1590 sol_thread_ops
.to_stop
= sol_thread_stop
;
1591 sol_thread_ops
.to_stratum
= process_stratum
;
1592 sol_thread_ops
.to_has_all_memory
= 1;
1593 sol_thread_ops
.to_has_memory
= 1;
1594 sol_thread_ops
.to_has_stack
= 1;
1595 sol_thread_ops
.to_has_registers
= 1;
1596 sol_thread_ops
.to_has_execution
= 1;
1597 sol_thread_ops
.to_has_thread_control
= tc_none
;
1598 sol_thread_ops
.to_sections
= 0;
1599 sol_thread_ops
.to_sections_end
= 0;
1600 sol_thread_ops
.to_magic
= OPS_MAGIC
;
1605 init_sol_core_ops ()
1607 sol_core_ops
.to_shortname
= "solaris-core";
1608 sol_core_ops
.to_longname
= "Solaris core threads and pthread.";
1609 sol_core_ops
.to_doc
= "Solaris threads and pthread support for core files.";
1610 sol_core_ops
.to_open
= sol_core_open
;
1611 sol_core_ops
.to_close
= sol_core_close
;
1612 sol_core_ops
.to_attach
= sol_thread_attach
;
1613 sol_core_ops
.to_detach
= sol_core_detach
;
1614 /* sol_core_ops.to_resume = 0; */
1615 /* sol_core_ops.to_wait = 0; */
1616 sol_core_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1617 /* sol_core_ops.to_store_registers = 0; */
1618 /* sol_core_ops.to_prepare_to_store = 0; */
1619 sol_core_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1620 sol_core_ops
.to_files_info
= sol_core_files_info
;
1621 sol_core_ops
.to_insert_breakpoint
= ignore
;
1622 sol_core_ops
.to_remove_breakpoint
= ignore
;
1623 /* sol_core_ops.to_terminal_init = 0; */
1624 /* sol_core_ops.to_terminal_inferior = 0; */
1625 /* sol_core_ops.to_terminal_ours_for_output = 0; */
1626 /* sol_core_ops.to_terminal_ours = 0; */
1627 /* sol_core_ops.to_terminal_info = 0; */
1628 /* sol_core_ops.to_kill = 0; */
1629 /* sol_core_ops.to_load = 0; */
1630 /* sol_core_ops.to_lookup_symbol = 0; */
1631 sol_core_ops
.to_create_inferior
= sol_thread_create_inferior
;
1632 sol_core_ops
.to_stratum
= core_stratum
;
1633 sol_core_ops
.to_has_all_memory
= 0;
1634 sol_core_ops
.to_has_memory
= 1;
1635 sol_core_ops
.to_has_stack
= 1;
1636 sol_core_ops
.to_has_registers
= 1;
1637 sol_core_ops
.to_has_execution
= 0;
1638 sol_core_ops
.to_has_thread_control
= tc_none
;
1639 sol_core_ops
.to_sections
= 0;
1640 sol_core_ops
.to_sections_end
= 0;
1641 sol_core_ops
.to_magic
= OPS_MAGIC
;
1644 /* we suppress the call to add_target of core_ops in corelow because
1645 if there are two targets in the stratum core_stratum, find_core_target
1646 won't know which one to return. see corelow.c for an additonal
1647 comment on coreops_suppress_target. */
1648 int coreops_suppress_target
= 1;
1651 _initialize_sol_thread ()
1655 init_sol_thread_ops ();
1656 init_sol_core_ops ();
1658 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1662 #define resolve(X) \
1663 if (!(p_##X = dlsym (dlhandle, #X))) \
1667 resolve (td_ta_new
);
1668 resolve (td_ta_delete
);
1670 resolve (td_ta_get_ph
);
1671 resolve (td_ta_get_nthreads
);
1672 resolve (td_ta_tsd_iter
);
1673 resolve (td_ta_thr_iter
);
1674 resolve (td_thr_validate
);
1675 resolve (td_thr_tsd
);
1676 resolve (td_thr_get_info
);
1677 resolve (td_thr_getfpregs
);
1678 resolve (td_thr_getxregsize
);
1679 resolve (td_thr_getxregs
);
1680 resolve (td_thr_sigsetmask
);
1681 resolve (td_thr_setprio
);
1682 resolve (td_thr_setsigpending
);
1683 resolve (td_thr_setfpregs
);
1684 resolve (td_thr_setxregs
);
1685 resolve (td_ta_map_id2thr
);
1686 resolve (td_ta_map_lwp2thr
);
1687 resolve (td_thr_getgregs
);
1688 resolve (td_thr_setgregs
);
1690 add_target (&sol_thread_ops
);
1692 procfs_suppress_run
= 1;
1694 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1695 "Show info on Solaris user threads.\n", &maintenanceinfolist
);
1697 memcpy (&orig_core_ops
, &core_ops
, sizeof (struct target_ops
));
1698 memcpy (&core_ops
, &sol_core_ops
, sizeof (struct target_ops
));
1699 add_target (&core_ops
);
1705 fprintf_unfiltered (gdb_stderr
, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1710 /* allow the user to debug non-threaded core files */
1711 add_target (&core_ops
);