1 /* Handle OSF/1, Digital UNIX, and Tru64 shared libraries
2 for GDB, the GNU Debugger.
3 Copyright (C) 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2007, 2008
4 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 3 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, see <http://www.gnu.org/licenses/>. */
21 /* When handling shared libraries, GDB has to find out the pathnames
22 of all shared libraries that are currently loaded (to read in their
23 symbols) and where the shared libraries are loaded in memory
24 (to relocate them properly from their prelinked addresses to the
25 current load address).
27 Under OSF/1 there are two possibilities to get at this information:
29 1) Peek around in the runtime loader structures.
30 These are not documented, and they are not defined in the system
31 header files. The definitions below were obtained by experimentation,
32 but they seem stable enough.
34 2) Use the libxproc.a library, which contains the equivalent ldr_*
35 routines. The library is documented in Tru64 5.x, but as of 5.1, it
36 only allows a process to examine itself. On earlier versions, it
37 may require that the GDB executable be dynamically linked and that
38 NAT_CLIBS include -lxproc -Wl,-expect_unresolved,ldr_process_context
39 for GDB and all applications that are using libgdb.
41 We will use the peeking approach until libxproc.a works for other
46 #include <sys/types.h>
48 #include "gdb_string.h"
58 #ifdef USE_LDR_ROUTINES
62 #ifndef USE_LDR_ROUTINES
63 /* Definition of runtime loader structures, found by experimentation. */
64 #define RLD_CONTEXT_ADDRESS 0x3ffc0000000
66 /* Per-module information structure referenced by ldr_context_t.head. */
73 CORE_ADDR module_name
;
74 CORE_ADDR modinfo_addr
; /* used by next_link_map_member() to detect
75 the end of the shared module list */
80 CORE_ADDR regioninfo_addr
;
84 /* Per-region structure referenced by ldr_module_info_t.regioninfo_addr. */
89 CORE_ADDR regionname_addr
;
98 /* Structure at RLD_CONTEXT_ADDRESS specifying the start and finish addresses
99 of the shared module list. */
109 #endif /* !USE_LDR_ROUTINES */
111 /* Per-section information, stored in struct lm_info.secs. */
115 CORE_ADDR offset
; /* difference between default and actual
116 virtual addresses of section .name */
117 CORE_ADDR nameaddr
; /* address in inferior of section name */
118 const char *name
; /* name of section, null if not fetched */
121 /* Per-module information, stored in struct so_list.lm_info. */
125 int isloader
; /* whether the module is /sbin/loader */
126 int nsecs
; /* length of .secs */
127 struct lm_sec secs
[1]; /* variable-length array of sections, sorted
131 /* Context for iterating through the inferior's shared module list. */
135 #ifdef USE_LDR_ROUTINES
139 CORE_ADDR next
; /* next element in module list */
140 CORE_ADDR tail
; /* last element in module list */
144 /* Forward declaration for this module's autoinit function. */
146 extern void _initialize_osf_solib (void);
148 #ifdef USE_LDR_ROUTINES
150 /* This routine is intended to be called by ldr_* routines to read memory from
151 the current target. Usage:
153 ldr_process = ldr_core_process ();
154 ldr_set_core_reader (ldr_read_memory);
155 ldr_xdetach (ldr_process);
156 ldr_xattach (ldr_process);
158 ldr_core_process() and ldr_read_memory() are neither documented nor
159 declared in system header files. They work with OSF/1 2.x, and they might
160 work with later versions as well. */
163 ldr_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int readstring
)
170 target_read_string (memaddr
, &buffer
, len
, &result
);
172 strcpy (myaddr
, buffer
);
176 result
= target_read_memory (memaddr
, myaddr
, len
);
183 #endif /* USE_LDR_ROUTINES */
185 /* Comparison for qsort() and bsearch(): return -1, 0, or 1 according to
186 whether lm_sec *P1's name is lexically less than, equal to, or greater
190 lm_sec_cmp (const void *p1
, const void *p2
)
192 const struct lm_sec
*lms1
= p1
, *lms2
= p2
;
193 return strcmp (lms1
->name
, lms2
->name
);
196 /* Sort LMI->secs so that osf_relocate_section_addresses() can binary-search
200 lm_secs_sort (struct lm_info
*lmi
)
202 qsort (lmi
->secs
, lmi
->nsecs
, sizeof *lmi
->secs
, lm_sec_cmp
);
205 /* Populate name fields of LMI->secs. */
208 fetch_sec_names (struct lm_info
*lmi
)
210 #ifndef USE_LDR_ROUTINES
215 for (i
= 0; i
< lmi
->nsecs
; i
++)
218 target_read_string (lms
->nameaddr
, &name
, PATH_MAX
, &errcode
);
221 warning (_("unable to read shared sec name at 0x%lx"), lms
->nameaddr
);
230 /* target_so_ops callback. Adjust SEC's addresses after it's been mapped into
234 osf_relocate_section_addresses (struct so_list
*so
,
235 struct section_table
*sec
)
238 struct lm_sec lms_key
, *lms
;
240 /* Fetch SO's section names if we haven't done so already. */
242 if (lmi
->nsecs
&& !lmi
->secs
[0].name
)
243 fetch_sec_names (lmi
);
245 /* Binary-search for offset information corresponding to SEC. */
246 lms_key
.name
= sec
->the_bfd_section
->name
;
247 lms
= bsearch (&lms_key
, lmi
->secs
, lmi
->nsecs
, sizeof *lms
, lm_sec_cmp
);
250 sec
->addr
+= lms
->offset
;
251 sec
->endaddr
+= lms
->offset
;
255 /* target_so_ops callback. Free parts of SO allocated by this file. */
258 osf_free_so (struct so_list
*so
)
263 for (i
= 0; i
< so
->lm_info
->nsecs
; i
++)
265 name
= so
->lm_info
->secs
[i
].name
;
267 xfree ((void *) name
);
272 /* target_so_ops callback. Discard information accumulated by this file and
273 not freed by osf_free_so(). */
276 osf_clear_solib (void)
281 /* target_so_ops callback. Prepare to handle shared libraries after the
282 inferior process has been created but before it's executed any
285 For a statically bound executable, the inferior's first instruction is the
286 one at "_start", or a similar text label. No further processing is needed
289 For a dynamically bound executable, this first instruction is somewhere
290 in the rld, and the actual user executable is not yet mapped in.
291 We continue the inferior again, rld then maps in the actual user
292 executable and any needed shared libraries and then sends
295 At that point we discover the names of all shared libraries and
296 read their symbols in.
300 This code does not properly handle hitting breakpoints which the
301 user might have set in the rld itself. Proper handling would have
302 to check if the SIGTRAP happened due to a kill call.
304 Also, what if child has exit()ed? Must exit loop somehow. */
307 osf_solib_create_inferior_hook (void)
309 /* If we are attaching to the inferior, the shared libraries
310 have already been mapped, so nothing more to do. */
314 /* Nothing to do for statically bound executables. */
316 if (symfile_objfile
== NULL
317 || symfile_objfile
->obfd
== NULL
318 || ((bfd_get_file_flags (symfile_objfile
->obfd
) & DYNAMIC
) == 0))
321 /* Now run the target. It will eventually get a SIGTRAP, at
322 which point all of the libraries will have been mapped in and we
323 can go groveling around in the rld structures to find
324 out what we need to know about them.
326 If debugging from a core file, we cannot resume the execution
327 of the inferior. But this is actually not an issue, because
328 shared libraries have already been mapped anyways, which means
329 we have nothing more to do. */
330 if (!target_can_run (¤t_target
))
333 clear_proceed_status ();
334 stop_soon
= STOP_QUIETLY
;
335 stop_signal
= TARGET_SIGNAL_0
;
338 target_resume (minus_one_ptid
, 0, stop_signal
);
339 wait_for_inferior (0);
341 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
343 /* solib_add will call reinit_frame_cache.
344 But we are stopped in the runtime loader and we do not have symbols
345 for the runtime loader. So heuristic_proc_start will be called
346 and will put out an annoying warning.
347 Delaying the resetting of stop_soon until after symbol loading
348 suppresses the warning. */
349 solib_add ((char *) 0, 0, (struct target_ops
*) 0, auto_solib_add
);
350 stop_soon
= NO_STOP_QUIETLY
;
353 /* target_so_ops callback. Do additional symbol handling, lookup, etc. after
354 symbols for a shared object have been loaded. */
357 osf_special_symbol_handling (void)
362 /* Initialize CTXT in preparation for iterating through the inferior's module
363 list using read_map(). Return success. */
366 open_map (struct read_map_ctxt
*ctxt
)
368 #ifdef USE_LDR_ROUTINES
369 /* Note: As originally written, ldr_my_process() was used to obtain
370 the value for ctxt->proc. This is incorrect, however, since
371 ldr_my_process() retrieves the "unique identifier" associated
372 with the current process (i.e. GDB) and not the one being
373 debugged. Presumably, the pid of the process being debugged is
374 compatible with the "unique identifier" used by the ldr_
375 routines, so we use that. */
376 ctxt
->proc
= ptid_get_pid (inferior_ptid
);
377 if (ldr_xattach (ctxt
->proc
) != 0)
379 ctxt
->next
= LDR_NULL_MODULE
;
381 CORE_ADDR ldr_context_addr
, prev
, next
;
382 ldr_context_t ldr_context
;
384 if (target_read_memory ((CORE_ADDR
) RLD_CONTEXT_ADDRESS
,
385 (char *) &ldr_context_addr
,
386 sizeof (CORE_ADDR
)) != 0)
388 if (target_read_memory (ldr_context_addr
,
389 (char *) &ldr_context
,
390 sizeof (ldr_context_t
)) != 0)
392 ctxt
->next
= ldr_context
.head
;
393 ctxt
->tail
= ldr_context
.tail
;
398 /* Initialize SO to have module NAME, /sbin/loader indicator ISLOADR, and
399 space for NSECS sections. */
402 init_so (struct so_list
*so
, char *name
, int isloader
, int nsecs
)
406 /* solib.c requires various fields to be initialized to 0. */
407 memset (so
, 0, sizeof *so
);
410 namelen
= strlen (name
);
411 if (namelen
>= SO_NAME_MAX_PATH_SIZE
)
412 namelen
= SO_NAME_MAX_PATH_SIZE
- 1;
414 memcpy (so
->so_original_name
, name
, namelen
);
415 so
->so_original_name
[namelen
] = '\0';
416 memcpy (so
->so_name
, so
->so_original_name
, namelen
+ 1);
418 /* Allocate section space. */
419 so
->lm_info
= xmalloc ((unsigned) &(((struct lm_info
*)0)->secs
) +
420 nsecs
* sizeof *so
->lm_info
);
421 so
->lm_info
->isloader
= isloader
;
422 so
->lm_info
->nsecs
= nsecs
;
423 for (i
= 0; i
< nsecs
; i
++)
424 so
->lm_info
->secs
[i
].name
= NULL
;
427 /* Initialize SO's section SECIDX with name address NAMEADDR, name string
428 NAME, default virtual address VADDR, and actual virtual address
432 init_sec (struct so_list
*so
, int secidx
, CORE_ADDR nameaddr
,
433 const char *name
, CORE_ADDR vaddr
, CORE_ADDR mapaddr
)
437 lms
= so
->lm_info
->secs
+ secidx
;
438 lms
->nameaddr
= nameaddr
;
440 lms
->offset
= mapaddr
- vaddr
;
443 /* If there are more elements starting at CTXT in inferior's module list,
444 store the next element in SO, advance CTXT to the next element, and return
448 read_map (struct read_map_ctxt
*ctxt
, struct so_list
*so
)
450 ldr_module_info_t minf
;
451 ldr_region_info_t rinf
;
453 #ifdef USE_LDR_ROUTINES
457 /* Retrieve the next element. */
458 if (ldr_next_module (ctxt
->proc
, &ctxt
->next
) != 0)
460 if (ctxt
->next
== LDR_NULL_MODULE
)
462 if (ldr_inq_module (ctxt
->proc
, ctxt
->next
, &minf
, sizeof minf
, &size
) != 0)
465 /* Initialize the module name and section count. */
466 init_so (so
, minf
.lmi_name
, 0, minf
.lmi_nregion
);
468 /* Retrieve section names and offsets. */
469 for (i
= 0; i
< minf
.lmi_nregion
; i
++)
471 if (ldr_inq_region (ctxt
->proc
, ctxt
->next
, i
, &rinf
,
472 sizeof rinf
, &size
) != 0)
474 init_sec (so
, (int) i
, 0, xstrdup (rinf
.lri_name
),
475 (CORE_ADDR
) rinf
.lri_vaddr
, (CORE_ADDR
) rinf
.lri_mapaddr
);
477 lm_secs_sort (so
->lm_info
);
482 /* Retrieve the next element. */
485 if (target_read_memory (ctxt
->next
, (char *) &minf
, sizeof minf
) != 0)
487 if (ctxt
->next
== ctxt
->tail
)
490 ctxt
->next
= minf
.next
;
492 /* Initialize the module name and section count. */
493 target_read_string (minf
.module_name
, &name
, PATH_MAX
, &errcode
);
496 init_so (so
, name
, !minf
.modinfo_addr
, minf
.region_count
);
499 /* Retrieve section names and offsets. */
500 for (i
= 0; i
< minf
.region_count
; i
++)
502 if (target_read_memory (minf
.regioninfo_addr
+ i
* sizeof rinf
,
503 (char *) &rinf
, sizeof rinf
) != 0)
505 init_sec (so
, i
, rinf
.regionname_addr
, NULL
, rinf
.vaddr
, rinf
.mapaddr
);
507 #endif /* !USE_LDR_ROUTINES */
515 /* Free resources allocated by open_map (CTXT). */
518 close_map (struct read_map_ctxt
*ctxt
)
520 #ifdef USE_LDR_ROUTINES
521 ldr_xdetach (ctxt
->proc
);
525 /* target_so_ops callback. Return a list of shared objects currently loaded
528 static struct so_list
*
529 osf_current_sos (void)
531 struct so_list
*head
= NULL
, *tail
, *newtail
, so
;
532 struct read_map_ctxt ctxt
;
535 if (!open_map (&ctxt
))
538 /* Read subsequent elements. */
539 for (skipped_main
= 0;;)
541 if (!read_map (&ctxt
, &so
))
544 /* Skip the main program module, which is first in the list after
546 if (!so
.lm_info
->isloader
&& !skipped_main
)
553 newtail
= xmalloc (sizeof *newtail
);
557 tail
->next
= newtail
;
560 memcpy (tail
, &so
, sizeof so
);
568 /* target_so_ops callback. Attempt to locate and open the main symbol
572 osf_open_symbol_file_object (void *from_ttyp
)
574 struct read_map_ctxt ctxt
;
579 if (!query ("Attempt to reload symbols from process? "))
582 /* The first module after /sbin/loader is the main program. */
583 if (!open_map (&ctxt
))
585 for (found
= 0; !found
;)
587 if (!read_map (&ctxt
, &so
))
589 found
= !so
.lm_info
->isloader
;
595 symbol_file_add_main (so
.so_name
, *(int *) from_ttyp
);
599 /* target_so_ops callback. Return whether PC is in the dynamic linker. */
602 osf_in_dynsym_resolve_code (CORE_ADDR pc
)
604 /* This function currently always return False. This is a temporary
605 solution which only consequence is to introduce a minor incovenience
606 for the user: When stepping inside a subprogram located in a shared
607 library, gdb might stop inside the dynamic loader code instead of
608 inside the subprogram itself. See the explanations in infrun.c about
609 the IN_SOLIB_DYNSYM_RESOLVE_CODE macro for more details. */
613 static struct target_so_ops osf_so_ops
;
616 _initialize_osf_solib (void)
618 osf_so_ops
.relocate_section_addresses
= osf_relocate_section_addresses
;
619 osf_so_ops
.free_so
= osf_free_so
;
620 osf_so_ops
.clear_solib
= osf_clear_solib
;
621 osf_so_ops
.solib_create_inferior_hook
= osf_solib_create_inferior_hook
;
622 osf_so_ops
.special_symbol_handling
= osf_special_symbol_handling
;
623 osf_so_ops
.current_sos
= osf_current_sos
;
624 osf_so_ops
.open_symbol_file_object
= osf_open_symbol_file_object
;
625 osf_so_ops
.in_dynsym_resolve_code
= osf_in_dynsym_resolve_code
;
627 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
628 current_target_so_ops
= &osf_so_ops
;