1 /* Handle PA64 shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 2004, 2007-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* HP in their infinite stupidity choose not to use standard ELF dynamic
21 linker interfaces. They also choose not to make their ELF dymamic
22 linker interfaces compatible with the SOM dynamic linker. The
23 net result is we can not use either of the existing somsolib.c or
24 solib.c. What a crock.
26 Even more disgusting. This file depends on functions provided only
27 in certain PA64 libraries. Thus this file is supposed to only be
28 used native. When will HP ever learn that they need to provide the
29 same functionality in all their libraries! */
41 #include "hppa-tdep.h"
44 #include "solib-pa64.h"
48 /* We can build this file only when running natively on 64-bit HP/UX.
49 We check for that by checking for the elf_hp.h header file. */
50 #if defined(HAVE_ELF_HP_H) && defined(__LP64__)
52 /* FIXME: kettenis/20041213: These includes should be eliminated. */
58 struct load_module_desc desc
;
62 /* When adding fields, be sure to clear them in _initialize_pa64_solib. */
65 CORE_ADDR dld_flags_addr
;
67 struct bfd_section
*dyninfo_sect
;
68 int have_read_dld_descriptor
;
71 CORE_ADDR load_map_addr
;
72 struct load_module_desc dld_desc
;
76 static dld_cache_t dld_cache
;
78 static int read_dynamic_info (asection
*dyninfo_sect
,
79 dld_cache_t
*dld_cache_p
);
82 pa64_relocate_section_addresses (struct so_list
*so
,
83 struct target_section
*sec
)
85 asection
*asec
= sec
->the_bfd_section
;
86 CORE_ADDR load_offset
;
88 /* Relocate all the sections based on where they got loaded. */
90 load_offset
= bfd_section_vma (so
->abfd
, asec
) - asec
->filepos
;
92 if (asec
->flags
& SEC_CODE
)
94 sec
->addr
+= so
->lm_info
->desc
.text_base
- load_offset
;
95 sec
->endaddr
+= so
->lm_info
->desc
.text_base
- load_offset
;
97 else if (asec
->flags
& SEC_DATA
)
99 sec
->addr
+= so
->lm_info
->desc
.data_base
- load_offset
;
100 sec
->endaddr
+= so
->lm_info
->desc
.data_base
- load_offset
;
105 pa64_free_so (struct so_list
*so
)
111 pa64_clear_solib (void)
115 /* Wrapper for target_read_memory for dlgetmodinfo. */
118 pa64_target_read_memory (void *buffer
, CORE_ADDR ptr
, size_t bufsiz
, int ident
)
120 if (target_read_memory (ptr
, buffer
, bufsiz
) != 0)
125 /* Read the dynamic linker's internal shared library descriptor.
127 This must happen after dld starts running, so we can't do it in
128 read_dynamic_info. Record the fact that we have loaded the
129 descriptor. If the library is archive bound or the load map
130 hasn't been setup, then return zero; else return nonzero. */
133 read_dld_descriptor (void)
136 asection
*dyninfo_sect
;
138 /* If necessary call read_dynamic_info to extract the contents of the
139 .dynamic section from the shared library. */
140 if (!dld_cache
.is_valid
)
142 if (symfile_objfile
== NULL
)
143 error (_("No object file symbols."));
145 dyninfo_sect
= bfd_get_section_by_name (symfile_objfile
->obfd
,
152 if (!read_dynamic_info (dyninfo_sect
, &dld_cache
))
153 error (_("Unable to read in .dynamic section information."));
156 /* Read the load map pointer. */
157 if (target_read_memory (dld_cache
.load_map_addr
,
158 (char *) &dld_cache
.load_map
,
159 sizeof (dld_cache
.load_map
))
162 error (_("Error while reading in load map pointer."));
165 if (!dld_cache
.load_map
)
168 /* Read in the dld load module descriptor. */
169 if (dlgetmodinfo (-1,
171 sizeof (dld_cache
.dld_desc
),
172 pa64_target_read_memory
,
177 error (_("Error trying to get information about dynamic linker."));
180 /* Indicate that we have loaded the dld descriptor. */
181 dld_cache
.have_read_dld_descriptor
= 1;
187 /* Read the .dynamic section and extract the information of interest,
188 which is stored in dld_cache. The routine elf_locate_base in solib.c
189 was used as a model for this. */
192 read_dynamic_info (asection
*dyninfo_sect
, dld_cache_t
*dld_cache_p
)
196 CORE_ADDR dyninfo_addr
;
197 int dyninfo_sect_size
;
198 CORE_ADDR entry_addr
;
200 /* Read in .dynamic section, silently ignore errors. */
201 dyninfo_addr
= bfd_section_vma (symfile_objfile
->obfd
, dyninfo_sect
);
202 dyninfo_sect_size
= bfd_section_size (exec_bfd
, dyninfo_sect
);
203 buf
= alloca (dyninfo_sect_size
);
204 if (target_read_memory (dyninfo_addr
, buf
, dyninfo_sect_size
))
207 /* Scan the .dynamic section and record the items of interest.
208 In particular, DT_HP_DLD_FLAGS. */
209 for (bufend
= buf
+ dyninfo_sect_size
, entry_addr
= dyninfo_addr
;
211 buf
+= sizeof (Elf64_Dyn
), entry_addr
+= sizeof (Elf64_Dyn
))
213 Elf64_Dyn
*x_dynp
= (Elf64_Dyn
*)buf
;
214 Elf64_Sxword dyn_tag
;
217 dyn_tag
= bfd_h_get_64 (symfile_objfile
->obfd
,
218 (bfd_byte
*) &x_dynp
->d_tag
);
220 /* We can't use a switch here because dyn_tag is 64 bits and HP's
221 lame comiler does not handle 64bit items in switch statements. */
222 if (dyn_tag
== DT_NULL
)
224 else if (dyn_tag
== DT_HP_DLD_FLAGS
)
226 /* Set dld_flags_addr and dld_flags in *dld_cache_p. */
227 dld_cache_p
->dld_flags_addr
= entry_addr
+ offsetof(Elf64_Dyn
, d_un
);
228 if (target_read_memory (dld_cache_p
->dld_flags_addr
,
229 (char*) &dld_cache_p
->dld_flags
,
230 sizeof (dld_cache_p
->dld_flags
))
233 error (_("Error while reading in "
234 ".dynamic section of the program."));
237 else if (dyn_tag
== DT_HP_LOAD_MAP
)
239 /* Dld will place the address of the load map at load_map_addr
240 after it starts running. */
241 if (target_read_memory (entry_addr
+ offsetof(Elf64_Dyn
,
243 (char*) &dld_cache_p
->load_map_addr
,
244 sizeof (dld_cache_p
->load_map_addr
))
247 error (_("Error while reading in "
248 ".dynamic section of the program."));
253 /* Tag is not of interest. */
257 /* Record other information and set is_valid to 1. */
258 dld_cache_p
->dyninfo_sect
= dyninfo_sect
;
260 /* Verify that we read in required info. These fields are re-set to zero
261 in pa64_solib_restart. */
263 if (dld_cache_p
->dld_flags_addr
!= 0 && dld_cache_p
->load_map_addr
!= 0)
264 dld_cache_p
->is_valid
= 1;
271 /* Helper function for gdb_bfd_lookup_symbol_from_symtab. */
274 cmp_name (asymbol
*sym
, void *data
)
276 return (strcmp (sym
->name
, (const char *) data
) == 0);
279 /* This hook gets called just before the first instruction in the
280 inferior process is executed.
282 This is our opportunity to set magic flags in the inferior so
283 that GDB can be notified when a shared library is mapped in and
284 to tell the dynamic linker that a private copy of the library is
285 needed (so GDB can set breakpoints in the library).
287 We need to set DT_HP_DEBUG_CALLBACK to indicate that we want the
288 dynamic linker to call the breakpoint routine for significant events.
289 We used to set DT_HP_DEBUG_PRIVATE to indicate that shared libraries
290 should be mapped private. However, this flag can be set using
291 "chatr +dbg enable". Not setting DT_HP_DEBUG_PRIVATE allows debugging
292 with shared libraries mapped shareable. */
295 pa64_solib_create_inferior_hook (int from_tty
)
297 struct minimal_symbol
*msymbol
;
298 unsigned int dld_flags
, status
;
299 asection
*shlib_info
, *interp_sect
;
301 struct objfile
*objfile
;
304 if (symfile_objfile
== NULL
)
307 /* First see if the objfile was dynamically linked. */
308 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, ".dynamic");
312 /* It's got a .dynamic section, make sure it's not empty. */
313 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
316 /* Read in the .dynamic section. */
317 if (! read_dynamic_info (shlib_info
, &dld_cache
))
318 error (_("Unable to read the .dynamic section."));
320 /* If the libraries were not mapped private, warn the user. */
321 if ((dld_cache
.dld_flags
& DT_HP_DEBUG_PRIVATE
) == 0)
324 Private mapping of shared library text was not specified\n\
325 by the executable; setting a breakpoint in a shared library which\n\
326 is not privately mapped will not work. See the HP-UX 11i v3 chatr\n\
327 manpage for methods to privately map shared library text."));
329 /* Turn on the flags we care about. */
330 dld_cache
.dld_flags
|= DT_HP_DEBUG_CALLBACK
;
331 status
= target_write_memory (dld_cache
.dld_flags_addr
,
332 (char *) &dld_cache
.dld_flags
,
333 sizeof (dld_cache
.dld_flags
));
335 error (_("Unable to modify dynamic linker flags."));
337 /* Now we have to create a shared library breakpoint in the dynamic
338 linker. This can be somewhat tricky since the symbol is inside
339 the dynamic linker (for which we do not have symbols or a base
340 load address! Luckily I wrote this code for solib.c years ago. */
341 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
344 unsigned int interp_sect_size
;
348 CORE_ADDR sym_addr
= 0;
350 /* Read the contents of the .interp section into a local buffer;
351 the contents specify the dynamic linker this program uses. */
352 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
353 buf
= alloca (interp_sect_size
);
354 bfd_get_section_contents (exec_bfd
, interp_sect
,
355 buf
, 0, interp_sect_size
);
357 /* Now we need to figure out where the dynamic linker was
358 loaded so that we can load its symbols and place a breakpoint
359 in the dynamic linker itself.
361 This address is stored on the stack. However, I've been unable
362 to find any magic formula to find it for Solaris (appears to
363 be trivial on GNU/Linux). Therefore, we have to try an alternate
364 mechanism to find the dynamic linker's base address. */
365 tmp_bfd
= bfd_openr (buf
, gnutarget
);
369 /* Make sure the dynamic linker's really a useful object. */
370 if (!bfd_check_format (tmp_bfd
, bfd_object
))
372 warning (_("Unable to grok dynamic linker %s as an object file"),
378 /* We find the dynamic linker's base address by examining the
379 current pc (which point at the entry point for the dynamic
380 linker) and subtracting the offset of the entry point.
382 Also note the breakpoint is the second instruction in the
384 load_addr
= regcache_read_pc (get_current_regcache ())
385 - tmp_bfd
->start_address
;
386 sym_addr
= gdb_bfd_lookup_symbol_from_symtab (tmp_bfd
, cmp_name
,
388 sym_addr
= load_addr
+ sym_addr
+ 4;
390 /* Create the shared library breakpoint. */
393 = create_solib_event_breakpoint (target_gdbarch
, sym_addr
);
395 /* The breakpoint is actually hard-coded into the dynamic linker,
396 so we don't need to actually insert a breakpoint instruction
397 there. In fact, the dynamic linker's code is immutable, even to
398 ttrace, so we shouldn't even try to do that. For cases like
399 this, we have "permanent" breakpoints. */
400 make_breakpoint_permanent (b
);
403 /* We're done with the temporary bfd. */
409 pa64_special_symbol_handling (void)
413 static struct so_list
*
414 pa64_current_sos (void)
416 struct so_list
*head
= 0;
417 struct so_list
**link_ptr
= &head
;
420 /* Read in the load map pointer if we have not done so already. */
421 if (! dld_cache
.have_read_dld_descriptor
)
422 if (! read_dld_descriptor ())
425 for (dll_index
= -1; ; dll_index
++)
427 struct load_module_desc dll_desc
;
430 struct cleanup
*old_chain
;
435 /* Read in the load module descriptor. */
436 if (dlgetmodinfo (dll_index
, &dll_desc
, sizeof (dll_desc
),
437 pa64_target_read_memory
, 0, dld_cache
.load_map
)
441 /* Get the name of the shared library. */
442 dll_path
= (char *)dlgetname (&dll_desc
, sizeof (dll_desc
),
443 pa64_target_read_memory
,
444 0, dld_cache
.load_map
);
446 new = (struct so_list
*) xmalloc (sizeof (struct so_list
));
447 memset (new, 0, sizeof (struct so_list
));
448 new->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
449 memset (new->lm_info
, 0, sizeof (struct lm_info
));
451 strncpy (new->so_name
, dll_path
, SO_NAME_MAX_PATH_SIZE
- 1);
452 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
453 strcpy (new->so_original_name
, new->so_name
);
455 memcpy (&new->lm_info
->desc
, &dll_desc
, sizeof (dll_desc
));
457 #ifdef SOLIB_PA64_DBG
459 struct load_module_desc
*d
= &new->lm_info
->desc
;
461 printf ("\n+ library \"%s\" is described at index %d\n", new->so_name
,
463 printf (" text_base = %s\n", hex_string (d
->text_base
));
464 printf (" text_size = %s\n", hex_string (d
->text_size
));
465 printf (" data_base = %s\n", hex_string (d
->data_base
));
466 printf (" data_size = %s\n", hex_string (d
->data_size
));
467 printf (" unwind_base = %s\n", hex_string (d
->unwind_base
));
468 printf (" linkage_ptr = %s\n", hex_string (d
->linkage_ptr
));
469 printf (" phdr_base = %s\n", hex_string (d
->phdr_base
));
470 printf (" tls_size = %s\n", hex_string (d
->tls_size
));
471 printf (" tls_start_addr = %s\n", hex_string (d
->tls_start_addr
));
472 printf (" unwind_size = %s\n", hex_string (d
->unwind_size
));
473 printf (" tls_index = %s\n", hex_string (d
->tls_index
));
477 /* Link the new object onto the list. */
480 link_ptr
= &new->next
;
487 pa64_open_symbol_file_object (void *from_ttyp
)
489 int from_tty
= *(int *)from_ttyp
;
491 struct load_module_desc dll_desc
;
495 if (!query (_("Attempt to reload symbols from process? ")))
498 /* Read in the load map pointer if we have not done so already. */
499 if (! dld_cache
.have_read_dld_descriptor
)
500 if (! read_dld_descriptor ())
503 /* Read in the load module descriptor. */
504 if (dlgetmodinfo (0, &dll_desc
, sizeof (dll_desc
),
505 pa64_target_read_memory
, 0, dld_cache
.load_map
) == 0)
508 /* Get the name of the shared library. */
509 dll_path
= (char *)dlgetname (&dll_desc
, sizeof (dll_desc
),
510 pa64_target_read_memory
,
511 0, dld_cache
.load_map
);
513 /* Have a pathname: read the symbol file. */
514 symbol_file_add_main (dll_path
, from_tty
);
519 /* Return nonzero if PC is an address inside the dynamic linker. */
521 pa64_in_dynsym_resolve_code (CORE_ADDR pc
)
523 asection
*shlib_info
;
525 if (symfile_objfile
== NULL
)
528 if (!dld_cache
.have_read_dld_descriptor
)
529 if (!read_dld_descriptor ())
532 return (pc
>= dld_cache
.dld_desc
.text_base
533 && pc
< dld_cache
.dld_desc
.text_base
+ dld_cache
.dld_desc
.text_size
);
537 /* Return the GOT value for the shared library in which ADDR belongs. If
538 ADDR isn't in any known shared library, return zero. */
541 pa64_solib_get_got_by_pc (CORE_ADDR addr
)
543 struct so_list
*so_list
= master_so_list ();
544 CORE_ADDR got_value
= 0;
548 if (so_list
->lm_info
->desc
.text_base
<= addr
549 && ((so_list
->lm_info
->desc
.text_base
550 + so_list
->lm_info
->desc
.text_size
)
553 got_value
= so_list
->lm_info
->desc
.linkage_ptr
;
556 so_list
= so_list
->next
;
561 /* Get some HPUX-specific data from a shared lib. */
563 pa64_solib_thread_start_addr (struct so_list
*so
)
565 return so
->lm_info
->desc
.tls_start_addr
;
569 /* Return the address of the handle of the shared library in which ADDR
570 belongs. If ADDR isn't in any known shared library, return zero. */
573 pa64_solib_get_solib_by_pc (CORE_ADDR addr
)
575 struct so_list
*so_list
= master_so_list ();
576 CORE_ADDR retval
= 0;
580 if (so_list
->lm_info
->desc
.text_base
<= addr
581 && ((so_list
->lm_info
->desc
.text_base
582 + so_list
->lm_info
->desc
.text_size
)
585 retval
= so_list
->lm_info
->desc_addr
;
588 so_list
= so_list
->next
;
593 /* pa64 libraries do not seem to set the section offsets in a standard (i.e.
594 SVr4) way; the text section offset stored in the file doesn't correspond
595 to the place where the library is actually loaded into memory. Instead,
596 we rely on the dll descriptor to tell us where things were loaded. */
598 pa64_solib_get_text_base (struct objfile
*objfile
)
602 for (so
= master_so_list (); so
; so
= so
->next
)
603 if (so
->objfile
== objfile
)
604 return so
->lm_info
->desc
.text_base
;
609 static struct target_so_ops pa64_so_ops
;
611 extern initialize_file_ftype _initialize_pa64_solib
; /* -Wmissing-prototypes */
614 _initialize_pa64_solib (void)
616 pa64_so_ops
.relocate_section_addresses
= pa64_relocate_section_addresses
;
617 pa64_so_ops
.free_so
= pa64_free_so
;
618 pa64_so_ops
.clear_solib
= pa64_clear_solib
;
619 pa64_so_ops
.solib_create_inferior_hook
= pa64_solib_create_inferior_hook
;
620 pa64_so_ops
.special_symbol_handling
= pa64_special_symbol_handling
;
621 pa64_so_ops
.current_sos
= pa64_current_sos
;
622 pa64_so_ops
.open_symbol_file_object
= pa64_open_symbol_file_object
;
623 pa64_so_ops
.in_dynsym_resolve_code
= pa64_in_dynsym_resolve_code
;
624 pa64_so_ops
.bfd_open
= solib_bfd_open
;
626 memset (&dld_cache
, 0, sizeof (dld_cache
));
629 void pa64_solib_select (struct gdbarch
*gdbarch
)
631 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
633 set_solib_ops (gdbarch
, &pa64_so_ops
);
634 tdep
->solib_thread_start_addr
= pa64_solib_thread_start_addr
;
635 tdep
->solib_get_got_by_pc
= pa64_solib_get_got_by_pc
;
636 tdep
->solib_get_solib_by_pc
= pa64_solib_get_solib_by_pc
;
637 tdep
->solib_get_text_base
= pa64_solib_get_text_base
;
640 #else /* HAVE_ELF_HP_H */
642 extern initialize_file_ftype _initialize_pa64_solib
; /* -Wmissing-prototypes */
645 _initialize_pa64_solib (void)
649 void pa64_solib_select (struct gdbarch
*gdbarch
)
651 /* For a SOM-only target, there is no pa64 solib support. This is needed
652 for hppa-hpux-tdep.c to build. */
653 error (_("Cannot select pa64 solib support for this configuration."));