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, Boston, MA 02111-1307, USA. */
20 /* This module implements a sort of half target that sits between the
21 machine-independent parts of GDB and the /proc interface (procfs.c) to
22 provide access to the Solaris user-mode thread implementation.
24 Solaris threads are true user-mode threads, which are invoked via the thr_*
25 and pthread_* (native and Posix respectivly) interfaces. These are mostly
26 implemented in user-space, with all thread context kept in various
27 structures that live in the user's heap. These should not be confused with
28 lightweight processes (LWPs), which are implemented by the kernel, and
29 scheduled without explicit intervention by the process.
31 Just to confuse things a little, Solaris threads (both native and Posix) are
32 actually implemented using LWPs. In general, there are going to be more
33 threads than LWPs. There is no fixed correspondence between a thread and an
34 LWP. When a thread wants to run, it gets scheduled onto the first available
35 LWP and can therefore migrate from one LWP to another as time goes on. A
36 sleeping thread may not be associated with an LWP at all!
38 To make it possible to mess with threads, Sun provides a library called
39 libthread_db.so.1 (not to be confused with libthread_db.so.0, which doesn't
40 have a published interface). This interface has an upper part, which it
41 provides, and a lower part which I provide. The upper part consists of the
42 td_* routines, which allow me to find all the threads, query their state,
43 etc... The lower part consists of all of the ps_*, which are used by the
44 td_* routines to read/write memory, manipulate LWPs, lookup symbols, etc...
45 The ps_* routines actually do most of their work by calling functions in
50 #include <proc_service.h>
51 #include <thread_db.h>
52 #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 #define THREAD_FLAG 0x80000000
123 #define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
124 #define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
125 #define GET_LWP(LWP_ID) (TIDGET(LWP_ID))
126 #define GET_THREAD(THREAD_ID) (((THREAD_ID) >> 16) & 0x7fff)
127 #define BUILD_LWP(LWP_ID, PID) ((LWP_ID) << 16 | (PID))
128 #define BUILD_THREAD(THREAD_ID, PID) (THREAD_FLAG | BUILD_LWP (THREAD_ID, PID))
130 /* Pointers to routines from lithread_db resolved by dlopen() */
133 (*p_td_log
) (const int on_off
);
135 (*p_td_ta_new
) (const struct ps_prochandle
*ph_p
, td_thragent_t
**ta_pp
);
137 (*p_td_ta_delete
) (td_thragent_t
*ta_p
);
141 (*p_td_ta_get_ph
) (const td_thragent_t
*ta_p
, struct ps_prochandle
**ph_pp
);
143 (*p_td_ta_get_nthreads
) (const td_thragent_t
*ta_p
, int *nthread_p
);
145 (*p_td_ta_tsd_iter
) (const td_thragent_t
*ta_p
, td_key_iter_f
*cb
, void *cbdata_p
);
147 (*p_td_ta_thr_iter
) (const td_thragent_t
*ta_p
, td_thr_iter_f
*cb
, void *cbdata_p
, td_thr_state_e state
,
148 int ti_pri
, sigset_t
*ti_sigmask_p
, unsigned ti_user_flags
);
150 (*p_td_thr_validate
) (const td_thrhandle_t
*th_p
);
152 (*p_td_thr_tsd
) (const td_thrhandle_t
*th_p
, const thread_key_t key
, void **data_pp
);
154 (*p_td_thr_get_info
) (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
);
156 (*p_td_thr_getfpregs
) (const td_thrhandle_t
*th_p
, prfpregset_t
*fpregset
);
158 (*p_td_thr_getxregsize
) (const td_thrhandle_t
*th_p
, int *xregsize
);
160 (*p_td_thr_getxregs
) (const td_thrhandle_t
*th_p
, const caddr_t xregset
);
162 (*p_td_thr_sigsetmask
) (const td_thrhandle_t
*th_p
, const sigset_t ti_sigmask
);
164 (*p_td_thr_setprio
) (const td_thrhandle_t
*th_p
, const int ti_pri
);
166 (*p_td_thr_setsigpending
) (const td_thrhandle_t
*th_p
, const uchar_t ti_pending_flag
, const sigset_t ti_pending
);
168 (*p_td_thr_setfpregs
) (const td_thrhandle_t
*th_p
, const prfpregset_t
*fpregset
);
170 (*p_td_thr_setxregs
) (const td_thrhandle_t
*th_p
, const caddr_t xregset
);
172 (*p_td_ta_map_id2thr
) (const td_thragent_t
*ta_p
, thread_t tid
, td_thrhandle_t
*th_p
);
174 (*p_td_ta_map_lwp2thr
) (const td_thragent_t
*ta_p
, lwpid_t lwpid
, td_thrhandle_t
*th_p
);
176 (*p_td_thr_getgregs
) (const td_thrhandle_t
*th_p
, prgregset_t regset
);
178 (*p_td_thr_setgregs
) (const td_thrhandle_t
*th_p
, const prgregset_t regset
);
184 td_err_string - Convert a thread_db error code to a string
188 char * td_err_string (errcode)
192 Return the thread_db error string associated with errcode. If errcode
193 is unknown, then return a message.
198 td_err_string (errcode
)
201 static struct string_map
203 {TD_OK
, "generic \"call succeeded\""},
204 {TD_ERR
, "generic error."},
205 {TD_NOTHR
, "no thread can be found to satisfy query"},
206 {TD_NOSV
, "no synch. variable can be found to satisfy query"},
207 {TD_NOLWP
, "no lwp can be found to satisfy query"},
208 {TD_BADPH
, "invalid process handle"},
209 {TD_BADTH
, "invalid thread handle"},
210 {TD_BADSH
, "invalid synchronization handle"},
211 {TD_BADTA
, "invalid thread agent"},
212 {TD_BADKEY
, "invalid key"},
213 {TD_NOMSG
, "td_thr_event_getmsg() called when there was no message"},
214 {TD_NOFPREGS
, "FPU register set not available for given thread"},
215 {TD_NOLIBTHREAD
, "application not linked with libthread"},
216 {TD_NOEVENT
, "requested event is not supported"},
217 {TD_NOCAPAB
, "capability not available"},
218 {TD_DBERR
, "Debugger service failed"},
219 {TD_NOAPLIC
, "Operation not applicable to"},
220 {TD_NOTSD
, "No thread specific data for this thread"},
221 {TD_MALLOC
, "Malloc failed"},
222 {TD_PARTIALREG
, "Only part of register set was writen/read"},
223 {TD_NOXREGS
, "X register set not available for given thread"}
225 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
229 for (i
= 0; i
< td_err_size
; i
++)
230 if (td_err_table
[i
].num
== errcode
)
231 return td_err_table
[i
].str
;
233 sprintf (buf
, "Unknown thread_db error code: %d", errcode
);
242 td_state_string - Convert a thread_db state code to a string
246 char * td_state_string (statecode)
250 Return the thread_db state string associated with statecode. If
251 statecode is unknown, then return a message.
256 td_state_string (statecode
)
257 td_thr_state_e statecode
;
259 static struct string_map
260 td_thr_state_table
[] = {
261 {TD_THR_ANY_STATE
, "any state"},
262 {TD_THR_UNKNOWN
, "unknown"},
263 {TD_THR_STOPPED
, "stopped"},
265 {TD_THR_ACTIVE
, "active"},
266 {TD_THR_ZOMBIE
, "zombie"},
267 {TD_THR_SLEEP
, "sleep"},
268 {TD_THR_STOPPED_ASLEEP
, "stopped asleep"}
270 const int td_thr_state_table_size
= sizeof td_thr_state_table
/ sizeof (struct string_map
);
274 for (i
= 0; i
< td_thr_state_table_size
; i
++)
275 if (td_thr_state_table
[i
].num
== statecode
)
276 return td_thr_state_table
[i
].str
;
278 sprintf (buf
, "Unknown thread_db state code: %d", statecode
);
287 thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
291 int thread_to_lwp (thread_id, default_lwp)
295 This function converts a Posix or Solaris thread id to a lightweight
296 process id. If thread_id is non-existent, that's an error. If it's
297 an inactive thread, then we return default_lwp.
301 This function probably shouldn't call error()...
306 thread_to_lwp (thread_id
, default_lwp
)
314 if (is_lwp (thread_id
))
315 return thread_id
; /* It's already an LWP id */
317 /* It's a thread. Convert to lwp */
319 val
= p_td_ta_map_id2thr (main_ta
, GET_THREAD (thread_id
), &th
);
321 return -1; /* thread must have terminated */
322 else if (val
!= TD_OK
)
323 error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val
));
325 val
= p_td_thr_get_info (&th
, &ti
);
327 return -1; /* thread must have terminated */
328 else if (val
!= TD_OK
)
329 error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val
));
331 if (ti
.ti_state
!= TD_THR_ACTIVE
)
333 if (default_lwp
!= -1)
335 error ("thread_to_lwp: thread state not active: %s",
336 td_state_string (ti
.ti_state
));
339 return BUILD_LWP (ti
.ti_lid
, PIDGET (thread_id
));
346 lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
350 int lwp_to_thread (lwp_id)
354 This function converts a lightweight process id to a Posix or Solaris
355 thread id. If thread_id is non-existent, that's an error.
359 This function probably shouldn't call error()...
372 return lwp
; /* It's already a thread id */
374 /* It's an lwp. Convert it to a thread id. */
376 if (!sol_thread_alive (lwp
))
377 return -1; /* defunct lwp */
379 val
= p_td_ta_map_lwp2thr (main_ta
, GET_LWP (lwp
), &th
);
381 return -1; /* thread must have terminated */
382 else if (val
!= TD_OK
)
383 error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val
));
385 val
= p_td_thr_validate (&th
);
387 return lwp
; /* libthread doesn't know about it, just return lwp */
388 else if (val
!= TD_OK
)
389 error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val
));
391 val
= p_td_thr_get_info (&th
, &ti
);
393 return -1; /* thread must have terminated */
394 else if (val
!= TD_OK
)
395 error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val
));
397 return BUILD_THREAD (ti
.ti_tid
, PIDGET (lwp
));
404 save_inferior_pid - Save inferior_pid on the cleanup list
405 restore_inferior_pid - Restore inferior_pid from the cleanup list
409 struct cleanup *save_inferior_pid ()
410 void restore_inferior_pid (int pid)
414 These two functions act in unison to restore inferior_pid in
419 inferior_pid is a global variable that needs to be changed by many of
420 these routines before calling functions in procfs.c. In order to
421 guarantee that inferior_pid gets restored (in case of errors), you
422 need to call save_inferior_pid before changing it. At the end of the
423 function, you should invoke do_cleanups to restore it.
428 static struct cleanup
*
431 return make_cleanup (restore_inferior_pid
, (void*) inferior_pid
);
435 restore_inferior_pid (pid
)
438 inferior_pid
= (int) pid
;
442 /* Most target vector functions from here on actually just pass through to
443 procfs.c, as they don't need to do anything specific for threads. */
448 sol_thread_open (arg
, from_tty
)
452 procfs_ops
.to_open (arg
, from_tty
);
455 /* Attach to process PID, then initialize for debugging it
456 and wait for the trace-trap that results from attaching. */
459 sol_thread_attach (args
, from_tty
)
463 procfs_ops
.to_attach (args
, from_tty
);
464 /* Must get symbols from solibs before libthread_db can run! */
465 SOLIB_ADD ((char *)0, from_tty
, (struct target_ops
*)0);
466 if (sol_thread_active
)
468 printf_filtered ("sol-thread active.\n");
469 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
470 push_target (&sol_thread_ops
);
471 inferior_pid
= lwp_to_thread (inferior_pid
);
472 if (inferior_pid
== -1)
473 inferior_pid
= main_ph
.pid
;
475 add_thread (inferior_pid
);
477 /* XXX - might want to iterate over all the threads and register them. */
480 /* Take a program previously attached to and detaches it.
481 The program resumes execution and will no longer stop
482 on signals, etc. We'd better not have left any breakpoints
483 in the program or it'll die when it hits one. For this
484 to work, it may be necessary for the process to have been
485 previously attached. It *might* work if the program was
486 started via the normal ptrace (PTRACE_TRACEME). */
489 sol_thread_detach (args
, from_tty
)
493 unpush_target (&sol_thread_ops
);
494 procfs_ops
.to_detach (args
, from_tty
);
497 /* Resume execution of process PID. If STEP is nozero, then
498 just single step it. If SIGNAL is nonzero, restart it with that
499 signal activated. We may have to convert pid from a thread-id to an LWP id
503 sol_thread_resume (pid
, step
, signo
)
506 enum target_signal signo
;
508 struct cleanup
*old_chain
;
510 old_chain
= save_inferior_pid ();
512 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
513 if (inferior_pid
== -1)
514 inferior_pid
= procfs_first_available ();
520 pid
= thread_to_lwp (pid
, -2);
521 if (pid
== -2) /* Inactive thread */
522 error ("This version of Solaris can't start inactive threads.");
523 if (info_verbose
&& pid
== -1)
524 warning ("Specified thread %d seems to have terminated",
525 GET_THREAD (save_pid
));
528 procfs_ops
.to_resume (pid
, step
, signo
);
530 do_cleanups (old_chain
);
533 /* Wait for any threads to stop. We may have to convert PID from a thread id
534 to a LWP id, and vice versa on the way out. */
537 sol_thread_wait (pid
, ourstatus
)
539 struct target_waitstatus
*ourstatus
;
543 struct cleanup
*old_chain
;
545 save_pid
= inferior_pid
;
546 old_chain
= save_inferior_pid ();
548 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
549 if (inferior_pid
== -1)
550 inferior_pid
= procfs_first_available ();
556 pid
= thread_to_lwp (pid
, -2);
557 if (pid
== -2) /* Inactive thread */
558 error ("This version of Solaris can't start inactive threads.");
559 if (info_verbose
&& pid
== -1)
560 warning ("Specified thread %d seems to have terminated",
561 GET_THREAD (save_pid
));
564 rtnval
= procfs_ops
.to_wait (pid
, ourstatus
);
566 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
568 /* Map the LWP of interest back to the appropriate thread ID */
569 rtnval
= lwp_to_thread (rtnval
);
573 /* See if we have a new thread */
574 if (is_thread (rtnval
)
575 && rtnval
!= save_pid
576 && !in_thread_list (rtnval
))
578 printf_filtered ("[New %s]\n", target_pid_to_str (rtnval
));
583 /* During process initialization, we may get here without the thread package
584 being initialized, since that can only happen after we've found the shared
587 do_cleanups (old_chain
);
593 sol_thread_fetch_registers (regno
)
597 td_thrhandle_t thandle
;
600 prfpregset_t fpregset
;
606 if (!is_thread (inferior_pid
))
607 { /* LWP: pass the request on to procfs.c */
608 if (target_has_execution
)
609 procfs_ops
.to_fetch_registers (regno
);
611 orig_core_ops
.to_fetch_registers (regno
);
615 /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
617 thread
= GET_THREAD (inferior_pid
);
620 error ("sol_thread_fetch_registers: thread == 0");
622 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
624 error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
625 td_err_string (val
));
627 /* Get the integer regs */
629 val
= p_td_thr_getgregs (&thandle
, gregset
);
631 && val
!= TD_PARTIALREG
)
632 error ("sol_thread_fetch_registers: td_thr_getgregs %s",
633 td_err_string (val
));
635 /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
636 are saved (by a thread context switch). */
638 /* And, now the fp regs */
640 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
642 && val
!= TD_NOFPREGS
)
643 error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
644 td_err_string (val
));
646 /* Note that we must call supply_{g fp}regset *after* calling the td routines
647 because the td routines call ps_lget* which affect the values stored in the
650 supply_gregset (gregset
);
651 supply_fpregset (&fpregset
);
654 /* thread_db doesn't seem to handle this right */
655 val
= td_thr_getxregsize (&thandle
, &xregsize
);
656 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
657 error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
658 td_err_string (val
));
662 xregset
= alloca (xregsize
);
663 val
= td_thr_getxregs (&thandle
, xregset
);
665 error ("sol_thread_fetch_registers: td_thr_getxregs %s",
666 td_err_string (val
));
672 sol_thread_store_registers (regno
)
676 td_thrhandle_t thandle
;
679 prfpregset_t fpregset
;
685 if (!is_thread (inferior_pid
))
686 { /* LWP: pass the request on to procfs.c */
687 procfs_ops
.to_store_registers (regno
);
691 /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
693 thread
= GET_THREAD (inferior_pid
);
695 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
697 error ("sol_thread_store_registers: td_ta_map_id2thr %s",
698 td_err_string (val
));
701 { /* Not writing all the regs */
702 /* save new register value */
703 char old_value
[REGISTER_SIZE
];
704 memcpy(old_value
, & registers
[REGISTER_BYTE(regno
)], REGISTER_SIZE
);
706 val
= p_td_thr_getgregs (&thandle
, regset
);
708 error ("sol_thread_store_registers: td_thr_getgregs %s",
709 td_err_string (val
));
710 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
712 error ("sol_thread_store_registers: td_thr_getfpregs %s",
713 td_err_string (val
));
715 /* restore new register value */
716 memcpy(& registers
[REGISTER_BYTE(regno
)], old_value
, REGISTER_SIZE
);
719 /* thread_db doesn't seem to handle this right */
720 val
= td_thr_getxregsize (&thandle
, &xregsize
);
721 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
722 error ("sol_thread_store_registers: td_thr_getxregsize %s",
723 td_err_string (val
));
727 xregset
= alloca (xregsize
);
728 val
= td_thr_getxregs (&thandle
, xregset
);
730 error ("sol_thread_store_registers: td_thr_getxregs %s",
731 td_err_string (val
));
736 fill_gregset (regset
, regno
);
737 fill_fpregset (&fpregset
, regno
);
739 val
= p_td_thr_setgregs (&thandle
, regset
);
741 error ("sol_thread_store_registers: td_thr_setgregs %s",
742 td_err_string (val
));
743 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
745 error ("sol_thread_store_registers: td_thr_setfpregs %s",
746 td_err_string (val
));
749 /* thread_db doesn't seem to handle this right */
750 val
= td_thr_getxregsize (&thandle
, &xregsize
);
751 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
752 error ("sol_thread_store_registers: td_thr_getxregsize %s",
753 td_err_string (val
));
755 /* Should probably do something about writing the xregs here, but what are
760 /* Get ready to modify the registers array. On machines which store
761 individual registers, this doesn't need to do anything. On machines
762 which store all the registers in one fell swoop, this makes sure
763 that registers contains all the registers from the program being
767 sol_thread_prepare_to_store ()
769 procfs_ops
.to_prepare_to_store ();
773 sol_thread_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
778 struct target_ops
*target
; /* ignored */
781 struct cleanup
*old_chain
;
783 old_chain
= save_inferior_pid ();
785 if (is_thread (inferior_pid
) || /* A thread */
786 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
787 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
788 /* Note: don't need to call switch_to_thread; we're just reading memory. */
790 if (target_has_execution
)
791 retval
= procfs_ops
.to_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
);
793 retval
= orig_core_ops
.to_xfer_memory (memaddr
, myaddr
, len
,
796 do_cleanups (old_chain
);
801 /* Print status information about what we're accessing. */
804 sol_thread_files_info (ignore
)
805 struct target_ops
*ignore
;
807 procfs_ops
.to_files_info (ignore
);
811 sol_thread_kill_inferior ()
813 procfs_ops
.to_kill ();
817 sol_thread_notice_signals (pid
)
820 procfs_ops
.to_notice_signals (PIDGET (pid
));
823 /* Fork an inferior process, and start debugging it with /proc. */
826 sol_thread_create_inferior (exec_file
, allargs
, env
)
831 procfs_ops
.to_create_inferior (exec_file
, allargs
, env
);
833 if (sol_thread_active
&& inferior_pid
!= 0)
835 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
837 push_target (&sol_thread_ops
);
839 inferior_pid
= lwp_to_thread (inferior_pid
);
840 if (inferior_pid
== -1)
841 inferior_pid
= main_ph
.pid
;
843 add_thread (inferior_pid
);
847 /* This routine is called whenever a new symbol table is read in, or when all
848 symbol tables are removed. libthread_db can only be initialized when it
849 finds the right variables in libthread.so. Since it's a shared library,
850 those variables don't show up until the library gets mapped and the symbol
854 sol_thread_new_objfile (objfile
)
855 struct objfile
*objfile
;
861 sol_thread_active
= 0;
866 /* don't do anything if init failed to resolve the libthread_db library */
867 if (!procfs_suppress_run
)
870 /* Now, initialize the thread debugging library. This needs to be done after
871 the shared libraries are located because it needs information from the
872 user's thread library. */
876 error ("target_new_objfile: td_init: %s", td_err_string (val
));
878 val
= p_td_ta_new (&main_ph
, &main_ta
);
879 if (val
== TD_NOLIBTHREAD
)
881 else if (val
!= TD_OK
)
882 error ("target_new_objfile: td_ta_new: %s", td_err_string (val
));
884 sol_thread_active
= 1;
887 /* Clean up after the inferior dies. */
890 sol_thread_mourn_inferior ()
892 unpush_target (&sol_thread_ops
);
893 procfs_ops
.to_mourn_inferior ();
896 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
899 sol_thread_can_run ()
901 return procfs_suppress_run
;
908 sol_thread_alive - test thread for "aliveness"
912 static bool sol_thread_alive (int pid);
916 returns true if thread still active in inferior.
921 sol_thread_alive (pid
)
924 if (is_thread (pid
)) /* non-kernel thread */
929 pid
= GET_THREAD (pid
);
930 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
931 return 0; /* thread not found */
932 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
933 return 0; /* thread not valid */
934 return 1; /* known thread: return true */
936 else /* kernel thread (LWP): let procfs test it */
938 if (target_has_execution
)
939 return procfs_ops
.to_thread_alive (pid
);
941 return orig_core_ops
.to_thread_alive (pid
);
948 procfs_ops
.to_stop ();
951 /* These routines implement the lower half of the thread_db interface. Ie: the
954 /* Various versions of <proc_service.h> have slightly
955 different function prototypes. In particular, we have
958 struct ps_prochandle * const struct ps_prochandle *
963 Which one you have depends on solaris version and what
964 patches you've applied. On the theory that there are
965 only two major variants, we have configure check the
966 prototype of ps_pdwrite (), and use that info to make
967 appropriate typedefs here. */
969 #ifdef PROC_SERVICE_IS_OLD
970 typedef const struct ps_prochandle
* gdb_ps_prochandle_t
;
971 typedef char * gdb_ps_read_buf_t
;
972 typedef char * gdb_ps_write_buf_t
;
973 typedef int gdb_ps_size_t
;
975 typedef struct ps_prochandle
* gdb_ps_prochandle_t
;
976 typedef void * gdb_ps_read_buf_t
;
977 typedef const void * gdb_ps_write_buf_t
;
978 typedef size_t gdb_ps_size_t
;
982 /* The next four routines are called by thread_db to tell us to stop and stop
983 a particular process or lwp. Since GDB ensures that these are all stopped
984 by the time we call anything in thread_db, these routines need to do
988 ps_pstop (gdb_ps_prochandle_t ph
)
994 ps_pcontinue (gdb_ps_prochandle_t ph
)
1000 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1006 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1012 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
1013 const char *ld_symbol_name
, paddr_t
*ld_symbol_addr
)
1015 struct minimal_symbol
*ms
;
1017 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
1022 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
1027 /* Common routine for reading and writing memory. */
1030 rw_common (int dowrite
, const struct ps_prochandle
*ph
, paddr_t addr
,
1031 char *buf
, int size
)
1033 struct cleanup
*old_chain
;
1035 old_chain
= save_inferior_pid ();
1037 if (is_thread (inferior_pid
) || /* A thread */
1038 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
1039 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
1040 /* Note: don't need to call switch_to_thread; we're just reading memory. */
1046 if (target_has_execution
)
1047 cc
= procfs_ops
.to_xfer_memory (addr
, buf
, size
, dowrite
, &procfs_ops
);
1049 cc
= orig_core_ops
.to_xfer_memory (addr
, buf
, size
, dowrite
, &core_ops
);
1054 print_sys_errmsg ("rw_common (): read", errno
);
1056 print_sys_errmsg ("rw_common (): write", errno
);
1058 do_cleanups (old_chain
);
1066 do_cleanups (old_chain
);
1072 ps_pdread (gdb_ps_prochandle_t ph
, paddr_t addr
,
1073 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1075 return rw_common (0, ph
, addr
, buf
, size
);
1079 ps_pdwrite (gdb_ps_prochandle_t ph
, paddr_t addr
,
1080 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1082 return rw_common (1, ph
, addr
, (char*) buf
, size
);
1086 ps_ptread (gdb_ps_prochandle_t ph
, paddr_t addr
,
1087 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1089 return rw_common (0, ph
, addr
, buf
, size
);
1093 ps_ptwrite (gdb_ps_prochandle_t ph
, paddr_t addr
,
1094 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1096 return rw_common (1, ph
, addr
, (char*) buf
, size
);
1099 /* Get integer regs */
1102 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1103 prgregset_t gregset
)
1105 struct cleanup
*old_chain
;
1107 old_chain
= save_inferior_pid ();
1109 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1111 if (target_has_execution
)
1112 procfs_ops
.to_fetch_registers (-1);
1114 orig_core_ops
.to_fetch_registers (-1);
1115 fill_gregset (gregset
, -1);
1117 do_cleanups (old_chain
);
1122 /* Set integer regs */
1125 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1126 const prgregset_t gregset
)
1128 struct cleanup
*old_chain
;
1130 old_chain
= save_inferior_pid ();
1132 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1134 supply_gregset (gregset
);
1135 if (target_has_execution
)
1136 procfs_ops
.to_store_registers (-1);
1138 orig_core_ops
.to_store_registers (-1);
1140 do_cleanups (old_chain
);
1146 ps_plog (const char *fmt
, ...)
1150 va_start (args
, fmt
);
1152 vfprintf_filtered (gdb_stderr
, fmt
, args
);
1155 /* Get size of extra register set. Currently a noop. */
1158 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
1165 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1169 if (ioctl (lwp_fd
, PIOCGXREGSIZE
, ®size
))
1171 if (errno
== EINVAL
)
1172 return PS_NOFREGS
; /* XXX Wrong code, but this is the closest
1173 thing in proc_service.h */
1175 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno
);
1183 /* Get extra register set. Currently a noop. */
1186 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1192 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1196 if (ioctl (lwp_fd
, PIOCGXREG
, xregset
))
1198 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno
);
1206 /* Set extra register set. Currently a noop. */
1209 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1215 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1219 if (ioctl (lwp_fd
, PIOCSXREG
, xregset
))
1221 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno
);
1229 /* Get floating-point regs. */
1232 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1233 prfpregset_t
*fpregset
)
1235 struct cleanup
*old_chain
;
1237 old_chain
= save_inferior_pid ();
1239 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1241 if (target_has_execution
)
1242 procfs_ops
.to_fetch_registers (-1);
1244 orig_core_ops
.to_fetch_registers (-1);
1245 fill_fpregset (fpregset
, -1);
1247 do_cleanups (old_chain
);
1252 /* Set floating-point regs. */
1255 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1256 const prfpregset_t
*fpregset
)
1258 struct cleanup
*old_chain
;
1260 old_chain
= save_inferior_pid ();
1262 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1264 supply_fpregset (fpregset
);
1265 if (target_has_execution
)
1266 procfs_ops
.to_store_registers (-1);
1268 orig_core_ops
.to_store_registers (-1);
1270 do_cleanups (old_chain
);
1275 #ifdef TM_I386SOL2_H
1277 /* Get local descriptor table. */
1279 #include <sys/procfs.h>
1280 #include <sys/reg.h>
1281 #include <sys/sysi86.h>
1283 static int nldt_allocated
= 0;
1284 static struct ssd
*ldt_bufp
= NULL
;
1287 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1296 /* Get procfs file descriptor for the LWP. */
1297 lwp_fd
= procfs_get_pid_fd (BUILD_LWP (lwpid
, PIDGET (inferior_pid
)));
1301 /* Fetch registers und LDT descriptors. */
1302 if (ioctl (lwp_fd
, PIOCGREG
, &gregset
) == -1)
1305 if (ioctl (lwp_fd
, PIOCNLDT
, &nldt
) == -1)
1308 if (nldt_allocated
< nldt
)
1311 = (struct ssd
*) xrealloc (ldt_bufp
, (nldt
+ 1) * sizeof (struct ssd
));
1312 nldt_allocated
= nldt
;
1315 if (ioctl (lwp_fd
, PIOCLDT
, ldt_bufp
) == -1)
1318 /* Search LDT for the LWP via register GS. */
1319 for (i
= 0; i
< nldt
; i
++)
1321 if (ldt_bufp
[i
].sel
== (gregset
[GS
] & 0xffff))
1323 *pldt
= ldt_bufp
[i
];
1328 /* LDT not found. */
1331 #endif /* TM_I386SOL2_H */
1333 /* Convert a pid to printable form. */
1336 solaris_pid_to_str (pid
)
1339 static char buf
[100];
1341 /* in case init failed to resolve the libthread_db library */
1342 if (!procfs_suppress_run
)
1343 return procfs_pid_to_str (pid
);
1345 if (is_thread (pid
))
1349 lwp
= thread_to_lwp (pid
, -2);
1352 sprintf (buf
, "Thread %d (defunct)", GET_THREAD (pid
));
1354 sprintf (buf
, "Thread %d (LWP %d)", GET_THREAD (pid
), GET_LWP (lwp
));
1356 sprintf (buf
, "Thread %d ", GET_THREAD (pid
));
1358 else if (GET_LWP (pid
) != 0)
1359 sprintf (buf
, "LWP %d ", GET_LWP (pid
));
1361 sprintf (buf
, "process %d ", PIDGET (pid
));
1367 /* Worker bee for find_new_threads
1368 Callback function that gets called once per USER thread (i.e., not
1372 sol_find_new_threads_callback(th
, ignored
)
1373 const td_thrhandle_t
*th
;
1380 if ((retval
= p_td_thr_get_info(th
, &ti
)) != TD_OK
)
1384 pid
= BUILD_THREAD(ti
.ti_tid
, PIDGET(inferior_pid
));
1385 if (!in_thread_list(pid
))
1392 sol_find_new_threads()
1394 /* don't do anything if init failed to resolve the libthread_db library */
1395 if (!procfs_suppress_run
)
1398 if (inferior_pid
== -1)
1400 printf_filtered("No process.\n");
1403 p_td_ta_thr_iter (main_ta
, sol_find_new_threads_callback
, (void *)0,
1404 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1405 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1409 sol_core_open (filename
, from_tty
)
1413 orig_core_ops
.to_open (filename
, from_tty
);
1417 sol_core_close (quitting
)
1420 orig_core_ops
.to_close (quitting
);
1424 sol_core_detach (args
, from_tty
)
1428 unpush_target (&core_ops
);
1429 orig_core_ops
.to_detach (args
, from_tty
);
1433 sol_core_files_info (t
)
1434 struct target_ops
*t
;
1436 orig_core_ops
.to_files_info (t
);
1439 /* Worker bee for info sol-thread command. This is a callback function that
1440 gets called once for each Solaris thread (ie. not kernel thread) in the
1441 inferior. Print anything interesting that we can think of. */
1445 const td_thrhandle_t
*th
;
1450 struct minimal_symbol
*msym
;
1452 if ((ret
= p_td_thr_get_info (th
, &ti
)) == TD_OK
)
1454 printf_filtered ("%s thread #%d, lwp %d, ",
1455 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1456 ti
.ti_tid
, ti
.ti_lid
);
1457 switch (ti
.ti_state
) {
1459 case TD_THR_UNKNOWN
: printf_filtered ("<unknown state>"); break;
1460 case TD_THR_STOPPED
: printf_filtered ("(stopped)"); break;
1461 case TD_THR_RUN
: printf_filtered ("(run) "); break;
1462 case TD_THR_ACTIVE
: printf_filtered ("(active) "); break;
1463 case TD_THR_ZOMBIE
: printf_filtered ("(zombie) "); break;
1464 case TD_THR_SLEEP
: printf_filtered ("(asleep) "); break;
1465 case TD_THR_STOPPED_ASLEEP
:
1466 printf_filtered ("(stopped asleep)"); break;
1468 /* Print thr_create start function: */
1469 if (ti
.ti_startfunc
!= 0)
1470 if (msym
= lookup_minimal_symbol_by_pc (ti
.ti_startfunc
))
1471 printf_filtered (" startfunc: %s\n", SYMBOL_NAME (msym
));
1473 printf_filtered (" startfunc: 0x%08x\n", ti
.ti_startfunc
);
1475 /* If thread is asleep, print function that went to sleep: */
1476 if (ti
.ti_state
== TD_THR_SLEEP
)
1477 if (msym
= lookup_minimal_symbol_by_pc (ti
.ti_pc
))
1478 printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym
));
1480 printf_filtered (" - Sleep func: 0x%08x\n", ti
.ti_startfunc
);
1482 /* Wrap up line, if necessary */
1483 if (ti
.ti_state
!= TD_THR_SLEEP
&& ti
.ti_startfunc
== 0)
1484 printf_filtered ("\n"); /* don't you hate counting newlines? */
1487 warning ("info sol-thread: failed to get info for thread.");
1492 /* List some state about each Solaris user thread in the inferior. */
1495 info_solthreads (args
, from_tty
)
1499 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1500 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1501 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1505 ignore (addr
, contents
)
1514 init_sol_thread_ops ()
1516 sol_thread_ops
.to_shortname
= "solaris-threads";
1517 sol_thread_ops
.to_longname
= "Solaris threads and pthread.";
1518 sol_thread_ops
.to_doc
= "Solaris threads and pthread support.";
1519 sol_thread_ops
.to_open
= sol_thread_open
;
1520 sol_thread_ops
.to_close
= 0;
1521 sol_thread_ops
.to_attach
= sol_thread_attach
;
1522 sol_thread_ops
.to_detach
= sol_thread_detach
;
1523 sol_thread_ops
.to_resume
= sol_thread_resume
;
1524 sol_thread_ops
.to_wait
= sol_thread_wait
;
1525 sol_thread_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1526 sol_thread_ops
.to_store_registers
= sol_thread_store_registers
;
1527 sol_thread_ops
.to_prepare_to_store
= sol_thread_prepare_to_store
;
1528 sol_thread_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1529 sol_thread_ops
.to_files_info
= sol_thread_files_info
;
1530 sol_thread_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1531 sol_thread_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1532 sol_thread_ops
.to_terminal_init
= terminal_init_inferior
;
1533 sol_thread_ops
.to_terminal_inferior
= terminal_inferior
;
1534 sol_thread_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1535 sol_thread_ops
.to_terminal_ours
= terminal_ours
;
1536 sol_thread_ops
.to_terminal_info
= child_terminal_info
;
1537 sol_thread_ops
.to_kill
= sol_thread_kill_inferior
;
1538 sol_thread_ops
.to_load
= 0;
1539 sol_thread_ops
.to_lookup_symbol
= 0;
1540 sol_thread_ops
.to_create_inferior
= sol_thread_create_inferior
;
1541 sol_thread_ops
.to_mourn_inferior
= sol_thread_mourn_inferior
;
1542 sol_thread_ops
.to_can_run
= sol_thread_can_run
;
1543 sol_thread_ops
.to_notice_signals
= sol_thread_notice_signals
;
1544 sol_thread_ops
.to_thread_alive
= sol_thread_alive
;
1545 sol_thread_ops
.to_stop
= sol_thread_stop
;
1546 sol_thread_ops
.to_stratum
= process_stratum
;
1547 sol_thread_ops
.to_has_all_memory
= 1;
1548 sol_thread_ops
.to_has_memory
= 1;
1549 sol_thread_ops
.to_has_stack
= 1;
1550 sol_thread_ops
.to_has_registers
= 1;
1551 sol_thread_ops
.to_has_execution
= 1;
1552 sol_thread_ops
.to_has_thread_control
= tc_none
;
1553 sol_thread_ops
.to_sections
= 0;
1554 sol_thread_ops
.to_sections_end
= 0;
1555 sol_thread_ops
.to_magic
= OPS_MAGIC
;
1560 init_sol_core_ops ()
1562 sol_core_ops
.to_shortname
= "solaris-core";
1563 sol_core_ops
.to_longname
= "Solaris core threads and pthread.";
1564 sol_core_ops
.to_doc
= "Solaris threads and pthread support for core files.";
1565 sol_core_ops
.to_open
= sol_core_open
;
1566 sol_core_ops
.to_close
= sol_core_close
;
1567 sol_core_ops
.to_attach
= sol_thread_attach
;
1568 sol_core_ops
.to_detach
= sol_core_detach
;
1569 /* sol_core_ops.to_resume = 0; */
1570 /* sol_core_ops.to_wait = 0; */
1571 sol_core_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1572 /* sol_core_ops.to_store_registers = 0; */
1573 /* sol_core_ops.to_prepare_to_store = 0; */
1574 sol_core_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1575 sol_core_ops
.to_files_info
= sol_core_files_info
;
1576 sol_core_ops
.to_insert_breakpoint
= ignore
;
1577 sol_core_ops
.to_remove_breakpoint
= ignore
;
1578 /* sol_core_ops.to_terminal_init = 0; */
1579 /* sol_core_ops.to_terminal_inferior = 0; */
1580 /* sol_core_ops.to_terminal_ours_for_output = 0; */
1581 /* sol_core_ops.to_terminal_ours = 0; */
1582 /* sol_core_ops.to_terminal_info = 0; */
1583 /* sol_core_ops.to_kill = 0; */
1584 /* sol_core_ops.to_load = 0; */
1585 /* sol_core_ops.to_lookup_symbol = 0; */
1586 sol_core_ops
.to_create_inferior
= sol_thread_create_inferior
;
1587 sol_core_ops
.to_stratum
= core_stratum
;
1588 sol_core_ops
.to_has_all_memory
= 0;
1589 sol_core_ops
.to_has_memory
= 1;
1590 sol_core_ops
.to_has_stack
= 1;
1591 sol_core_ops
.to_has_registers
= 1;
1592 sol_core_ops
.to_has_execution
= 0;
1593 sol_core_ops
.to_has_thread_control
= tc_none
;
1594 sol_core_ops
.to_sections
= 0;
1595 sol_core_ops
.to_sections_end
= 0;
1596 sol_core_ops
.to_magic
= OPS_MAGIC
;
1599 /* we suppress the call to add_target of core_ops in corelow because
1600 if there are two targets in the stratum core_stratum, find_core_target
1601 won't know which one to return. see corelow.c for an additonal
1602 comment on coreops_suppress_target. */
1603 int coreops_suppress_target
= 1;
1606 _initialize_sol_thread ()
1610 init_sol_thread_ops ();
1611 init_sol_core_ops ();
1613 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1617 #define resolve(X) \
1618 if (!(p_##X = dlsym (dlhandle, #X))) \
1622 resolve (td_ta_new
);
1623 resolve (td_ta_delete
);
1625 resolve (td_ta_get_ph
);
1626 resolve (td_ta_get_nthreads
);
1627 resolve (td_ta_tsd_iter
);
1628 resolve (td_ta_thr_iter
);
1629 resolve (td_thr_validate
);
1630 resolve (td_thr_tsd
);
1631 resolve (td_thr_get_info
);
1632 resolve (td_thr_getfpregs
);
1633 resolve (td_thr_getxregsize
);
1634 resolve (td_thr_getxregs
);
1635 resolve (td_thr_sigsetmask
);
1636 resolve (td_thr_setprio
);
1637 resolve (td_thr_setsigpending
);
1638 resolve (td_thr_setfpregs
);
1639 resolve (td_thr_setxregs
);
1640 resolve (td_ta_map_id2thr
);
1641 resolve (td_ta_map_lwp2thr
);
1642 resolve (td_thr_getgregs
);
1643 resolve (td_thr_setgregs
);
1645 add_target (&sol_thread_ops
);
1647 procfs_suppress_run
= 1;
1649 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1650 "Show info on Solaris user threads.\n", &maintenanceinfolist
);
1652 memcpy(&orig_core_ops
, &core_ops
, sizeof (struct target_ops
));
1653 memcpy(&core_ops
, &sol_core_ops
, sizeof (struct target_ops
));
1654 add_target (&core_ops
);
1660 fprintf_unfiltered (gdb_stderr
, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1665 /* allow the user to debug non-threaded core files */
1666 add_target(&core_ops
);