1 /* Handle PA64 shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 2004, 2007 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! */
40 #include "hppa-tdep.h"
42 #include "solib-pa64.h"
46 /* If we are building for a SOM-only target, then we don't need this. */
49 /* FIXME: kettenis/20041213: These includes should be eliminated. */
55 struct load_module_desc desc
;
59 /* When adding fields, be sure to clear them in _initialize_pa64_solib. */
62 CORE_ADDR dld_flags_addr
;
64 struct bfd_section
*dyninfo_sect
;
65 int have_read_dld_descriptor
;
68 CORE_ADDR load_map_addr
;
69 struct load_module_desc dld_desc
;
73 static dld_cache_t dld_cache
;
76 read_dynamic_info (asection
*dyninfo_sect
, dld_cache_t
*dld_cache_p
);
79 pa64_relocate_section_addresses (struct so_list
*so
,
80 struct section_table
*sec
)
82 asection
*asec
= sec
->the_bfd_section
;
83 CORE_ADDR load_offset
;
85 /* Relocate all the sections based on where they got loaded. */
87 load_offset
= bfd_section_vma (so
->abfd
, asec
) - asec
->filepos
;
89 if (asec
->flags
& SEC_CODE
)
91 sec
->addr
+= so
->lm_info
->desc
.text_base
- load_offset
;
92 sec
->endaddr
+= so
->lm_info
->desc
.text_base
- load_offset
;
94 else if (asec
->flags
& SEC_DATA
)
96 sec
->addr
+= so
->lm_info
->desc
.data_base
- load_offset
;
97 sec
->endaddr
+= so
->lm_info
->desc
.data_base
- load_offset
;
102 pa64_free_so (struct so_list
*so
)
108 pa64_clear_solib (void)
112 /* Wrapper for target_read_memory for dlgetmodinfo. */
115 pa64_target_read_memory (void *buffer
, CORE_ADDR ptr
, size_t bufsiz
, int ident
)
117 if (target_read_memory (ptr
, buffer
, bufsiz
) != 0)
122 /* Read the dynamic linker's internal shared library descriptor.
124 This must happen after dld starts running, so we can't do it in
125 read_dynamic_info. Record the fact that we have loaded the
126 descriptor. If the library is archive bound, then return zero, else
130 read_dld_descriptor (void)
133 asection
*dyninfo_sect
;
135 /* If necessary call read_dynamic_info to extract the contents of the
136 .dynamic section from the shared library. */
137 if (!dld_cache
.is_valid
)
139 if (symfile_objfile
== NULL
)
140 error (_("No object file symbols."));
142 dyninfo_sect
= bfd_get_section_by_name (symfile_objfile
->obfd
,
149 if (!read_dynamic_info (dyninfo_sect
, &dld_cache
))
150 error (_("Unable to read in .dynamic section information."));
153 /* Read the load map pointer. */
154 if (target_read_memory (dld_cache
.load_map_addr
,
155 (char *) &dld_cache
.load_map
,
156 sizeof (dld_cache
.load_map
))
159 error (_("Error while reading in load map pointer."));
162 /* Read in the dld load module descriptor */
163 if (dlgetmodinfo (-1,
165 sizeof (dld_cache
.dld_desc
),
166 pa64_target_read_memory
,
171 error (_("Error trying to get information about dynamic linker."));
174 /* Indicate that we have loaded the dld descriptor. */
175 dld_cache
.have_read_dld_descriptor
= 1;
181 /* Read the .dynamic section and extract the information of interest,
182 which is stored in dld_cache. The routine elf_locate_base in solib.c
183 was used as a model for this. */
186 read_dynamic_info (asection
*dyninfo_sect
, dld_cache_t
*dld_cache_p
)
190 CORE_ADDR dyninfo_addr
;
191 int dyninfo_sect_size
;
192 CORE_ADDR entry_addr
;
194 /* Read in .dynamic section, silently ignore errors. */
195 dyninfo_addr
= bfd_section_vma (symfile_objfile
->obfd
, dyninfo_sect
);
196 dyninfo_sect_size
= bfd_section_size (exec_bfd
, dyninfo_sect
);
197 buf
= alloca (dyninfo_sect_size
);
198 if (target_read_memory (dyninfo_addr
, buf
, dyninfo_sect_size
))
201 /* Scan the .dynamic section and record the items of interest.
202 In particular, DT_HP_DLD_FLAGS */
203 for (bufend
= buf
+ dyninfo_sect_size
, entry_addr
= dyninfo_addr
;
205 buf
+= sizeof (Elf64_Dyn
), entry_addr
+= sizeof (Elf64_Dyn
))
207 Elf64_Dyn
*x_dynp
= (Elf64_Dyn
*)buf
;
208 Elf64_Sxword dyn_tag
;
212 pbuf
= alloca (gdbarch_ptr_bit (current_gdbarch
) / HOST_CHAR_BIT
);
213 dyn_tag
= bfd_h_get_64 (symfile_objfile
->obfd
,
214 (bfd_byte
*) &x_dynp
->d_tag
);
216 /* We can't use a switch here because dyn_tag is 64 bits and HP's
217 lame comiler does not handle 64bit items in switch statements. */
218 if (dyn_tag
== DT_NULL
)
220 else if (dyn_tag
== DT_HP_DLD_FLAGS
)
222 /* Set dld_flags_addr and dld_flags in *dld_cache_p */
223 dld_cache_p
->dld_flags_addr
= entry_addr
+ offsetof(Elf64_Dyn
, d_un
);
224 if (target_read_memory (dld_cache_p
->dld_flags_addr
,
225 (char*) &dld_cache_p
->dld_flags
,
226 sizeof (dld_cache_p
->dld_flags
))
229 error (_("Error while reading in .dynamic section of the program."));
232 else if (dyn_tag
== DT_HP_LOAD_MAP
)
234 /* Dld will place the address of the load map at load_map_addr
235 after it starts running. */
236 if (target_read_memory (entry_addr
+ offsetof(Elf64_Dyn
,
238 (char*) &dld_cache_p
->load_map_addr
,
239 sizeof (dld_cache_p
->load_map_addr
))
242 error (_("Error while reading in .dynamic section of the program."));
247 /* tag is not of interest */
251 /* Record other information and set is_valid to 1. */
252 dld_cache_p
->dyninfo_sect
= dyninfo_sect
;
254 /* Verify that we read in required info. These fields are re-set to zero
255 in pa64_solib_restart. */
257 if (dld_cache_p
->dld_flags_addr
!= 0 && dld_cache_p
->load_map_addr
!= 0)
258 dld_cache_p
->is_valid
= 1;
266 bfd_lookup_symbol -- lookup the value for a specific symbol
268 An expensive way to lookup the value of a single symbol for
269 bfd's that are only temporary anyway. This is used by the
270 shared library support to find the address of the debugger
271 interface structures in the shared library.
273 Note that 0 is specifically allowed as an error return (no
278 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
280 unsigned int storage_needed
;
282 asymbol
**symbol_table
;
283 unsigned int number_of_symbols
;
285 struct cleanup
*back_to
;
286 CORE_ADDR symaddr
= 0;
288 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
290 if (storage_needed
> 0)
292 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
293 back_to
= make_cleanup (xfree
, symbol_table
);
294 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
296 for (i
= 0; i
< number_of_symbols
; i
++)
298 sym
= *symbol_table
++;
299 if (strcmp (sym
->name
, symname
) == 0)
301 /* Bfd symbols are section relative. */
302 symaddr
= sym
->value
+ sym
->section
->vma
;
306 do_cleanups (back_to
);
312 /* This hook gets called just before the first instruction in the
313 inferior process is executed.
315 This is our opportunity to set magic flags in the inferior so
316 that GDB can be notified when a shared library is mapped in and
317 to tell the dynamic linker that a private copy of the library is
318 needed (so GDB can set breakpoints in the library).
320 We need to set two flag bits in this routine.
322 DT_HP_DEBUG_PRIVATE to indicate that shared libraries should be
325 DT_HP_DEBUG_CALLBACK to indicate that we want the dynamic linker to
326 call the breakpoint routine for significant events. */
329 pa64_solib_create_inferior_hook (void)
331 struct minimal_symbol
*msymbol
;
332 unsigned int dld_flags
, status
;
333 asection
*shlib_info
, *interp_sect
;
335 struct objfile
*objfile
;
338 /* First, remove all the solib event breakpoints. Their addresses
339 may have changed since the last time we ran the program. */
340 remove_solib_event_breakpoints ();
342 if (symfile_objfile
== NULL
)
345 /* First see if the objfile was dynamically linked. */
346 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, ".dynamic");
350 /* It's got a .dynamic section, make sure it's not empty. */
351 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
354 /* Read in the .dynamic section. */
355 if (! read_dynamic_info (shlib_info
, &dld_cache
))
356 error (_("Unable to read the .dynamic section."));
358 /* Turn on the flags we care about. */
359 dld_cache
.dld_flags
|= DT_HP_DEBUG_PRIVATE
;
360 dld_cache
.dld_flags
|= DT_HP_DEBUG_CALLBACK
;
361 status
= target_write_memory (dld_cache
.dld_flags_addr
,
362 (char *) &dld_cache
.dld_flags
,
363 sizeof (dld_cache
.dld_flags
));
365 error (_("Unable to modify dynamic linker flags."));
367 /* Now we have to create a shared library breakpoint in the dynamic
368 linker. This can be somewhat tricky since the symbol is inside
369 the dynamic linker (for which we do not have symbols or a base
370 load address! Luckily I wrote this code for solib.c years ago. */
371 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
374 unsigned int interp_sect_size
;
378 CORE_ADDR sym_addr
= 0;
380 /* Read the contents of the .interp section into a local buffer;
381 the contents specify the dynamic linker this program uses. */
382 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
383 buf
= alloca (interp_sect_size
);
384 bfd_get_section_contents (exec_bfd
, interp_sect
,
385 buf
, 0, interp_sect_size
);
387 /* Now we need to figure out where the dynamic linker was
388 loaded so that we can load its symbols and place a breakpoint
389 in the dynamic linker itself.
391 This address is stored on the stack. However, I've been unable
392 to find any magic formula to find it for Solaris (appears to
393 be trivial on GNU/Linux). Therefore, we have to try an alternate
394 mechanism to find the dynamic linker's base address. */
395 tmp_bfd
= bfd_openr (buf
, gnutarget
);
399 /* Make sure the dynamic linker's really a useful object. */
400 if (!bfd_check_format (tmp_bfd
, bfd_object
))
402 warning (_("Unable to grok dynamic linker %s as an object file"), buf
);
407 /* We find the dynamic linker's base address by examining the
408 current pc (which point at the entry point for the dynamic
409 linker) and subtracting the offset of the entry point.
411 Also note the breakpoint is the second instruction in the
413 load_addr
= read_pc () - tmp_bfd
->start_address
;
414 sym_addr
= bfd_lookup_symbol (tmp_bfd
, "__dld_break");
415 sym_addr
= load_addr
+ sym_addr
+ 4;
417 /* Create the shared library breakpoint. */
420 = create_solib_event_breakpoint (sym_addr
);
422 /* The breakpoint is actually hard-coded into the dynamic linker,
423 so we don't need to actually insert a breakpoint instruction
424 there. In fact, the dynamic linker's code is immutable, even to
425 ttrace, so we shouldn't even try to do that. For cases like
426 this, we have "permanent" breakpoints. */
427 make_breakpoint_permanent (b
);
430 /* We're done with the temporary bfd. */
436 pa64_special_symbol_handling (void)
440 static struct so_list
*
441 pa64_current_sos (void)
443 struct so_list
*head
= 0;
444 struct so_list
**link_ptr
= &head
;
447 /* Read in the load map pointer if we have not done so already. */
448 if (! dld_cache
.have_read_dld_descriptor
)
449 if (! read_dld_descriptor ())
452 /* If the libraries were not mapped private, warn the user. */
453 if ((dld_cache
.dld_flags
& DT_HP_DEBUG_PRIVATE
) == 0)
454 warning (_("The shared libraries were not privately mapped; setting a\n"
455 "breakpoint in a shared library will not work until you rerun "
458 for (dll_index
= -1; ; dll_index
++)
460 struct load_module_desc dll_desc
;
463 struct cleanup
*old_chain
;
468 /* Read in the load module descriptor. */
469 if (dlgetmodinfo (dll_index
, &dll_desc
, sizeof (dll_desc
),
470 pa64_target_read_memory
, 0, dld_cache
.load_map
)
474 /* Get the name of the shared library. */
475 dll_path
= (char *)dlgetname (&dll_desc
, sizeof (dll_desc
),
476 pa64_target_read_memory
,
477 0, dld_cache
.load_map
);
479 new = (struct so_list
*) xmalloc (sizeof (struct so_list
));
480 memset (new, 0, sizeof (struct so_list
));
481 new->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
482 memset (new->lm_info
, 0, sizeof (struct lm_info
));
484 strncpy (new->so_name
, dll_path
, SO_NAME_MAX_PATH_SIZE
- 1);
485 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
486 strcpy (new->so_original_name
, new->so_name
);
488 memcpy (&new->lm_info
->desc
, &dll_desc
, sizeof (dll_desc
));
490 #ifdef SOLIB_PA64_DBG
492 struct load_module_desc
*d
= &new->lm_info
->desc
;
493 printf ("\n+ library \"%s\" is described at index %d\n", new->so_name
,
495 printf (" text_base = 0x%llx\n", d
->text_base
);
496 printf (" text_size = 0x%llx\n", d
->text_size
);
497 printf (" data_base = 0x%llx\n", d
->data_base
);
498 printf (" data_size = 0x%llx\n", d
->data_size
);
499 printf (" unwind_base = 0x%llx\n", d
->unwind_base
);
500 printf (" linkage_ptr = 0x%llx\n", d
->linkage_ptr
);
501 printf (" phdr_base = 0x%llx\n", d
->phdr_base
);
502 printf (" tls_size = 0x%llx\n", d
->tls_size
);
503 printf (" tls_start_addr = 0x%llx\n", d
->tls_start_addr
);
504 printf (" unwind_size = 0x%llx\n", d
->unwind_size
);
505 printf (" tls_index = 0x%llx\n", d
->tls_index
);
509 /* Link the new object onto the list. */
512 link_ptr
= &new->next
;
519 pa64_open_symbol_file_object (void *from_ttyp
)
521 int from_tty
= *(int *)from_ttyp
;
523 struct load_module_desc dll_desc
;
527 if (!query ("Attempt to reload symbols from process? "))
530 /* Read in the load map pointer if we have not done so already. */
531 if (! dld_cache
.have_read_dld_descriptor
)
532 if (! read_dld_descriptor ())
535 /* Read in the load module descriptor. */
536 if (dlgetmodinfo (0, &dll_desc
, sizeof (dll_desc
),
537 pa64_target_read_memory
, 0, dld_cache
.load_map
) == 0)
540 /* Get the name of the shared library. */
541 dll_path
= (char *)dlgetname (&dll_desc
, sizeof (dll_desc
),
542 pa64_target_read_memory
,
543 0, dld_cache
.load_map
);
545 /* Have a pathname: read the symbol file. */
546 symbol_file_add_main (dll_path
, from_tty
);
551 /* Return nonzero if PC is an address inside the dynamic linker. */
553 pa64_in_dynsym_resolve_code (CORE_ADDR pc
)
555 asection
*shlib_info
;
557 if (symfile_objfile
== NULL
)
560 if (!dld_cache
.have_read_dld_descriptor
)
561 if (!read_dld_descriptor ())
564 return (pc
>= dld_cache
.dld_desc
.text_base
565 && pc
< dld_cache
.dld_desc
.text_base
+ dld_cache
.dld_desc
.text_size
);
569 /* Return the GOT value for the shared library in which ADDR belongs. If
570 ADDR isn't in any known shared library, return zero. */
573 pa64_solib_get_got_by_pc (CORE_ADDR addr
)
575 struct so_list
*so_list
= master_so_list ();
576 CORE_ADDR got_value
= 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 got_value
= so_list
->lm_info
->desc
.linkage_ptr
;
588 so_list
= so_list
->next
;
593 /* Get some HPUX-specific data from a shared lib. */
595 pa64_solib_thread_start_addr (struct so_list
*so
)
597 return so
->lm_info
->desc
.tls_start_addr
;
601 /* Return the address of the handle of the shared library in which ADDR
602 belongs. If ADDR isn't in any known shared library, return zero. */
605 pa64_solib_get_solib_by_pc (CORE_ADDR addr
)
607 struct so_list
*so_list
= master_so_list ();
608 CORE_ADDR retval
= 0;
612 if (so_list
->lm_info
->desc
.text_base
<= addr
613 && ((so_list
->lm_info
->desc
.text_base
614 + so_list
->lm_info
->desc
.text_size
)
617 retval
= so_list
->lm_info
->desc_addr
;
620 so_list
= so_list
->next
;
625 /* pa64 libraries do not seem to set the section offsets in a standard (i.e.
626 SVr4) way; the text section offset stored in the file doesn't correspond
627 to the place where the library is actually loaded into memory. Instead,
628 we rely on the dll descriptor to tell us where things were loaded. */
630 pa64_solib_get_text_base (struct objfile
*objfile
)
634 for (so
= master_so_list (); so
; so
= so
->next
)
635 if (so
->objfile
== objfile
)
636 return so
->lm_info
->desc
.text_base
;
641 static struct target_so_ops pa64_so_ops
;
643 extern initialize_file_ftype _initialize_pa64_solib
; /* -Wmissing-prototypes */
646 _initialize_pa64_solib (void)
648 pa64_so_ops
.relocate_section_addresses
= pa64_relocate_section_addresses
;
649 pa64_so_ops
.free_so
= pa64_free_so
;
650 pa64_so_ops
.clear_solib
= pa64_clear_solib
;
651 pa64_so_ops
.solib_create_inferior_hook
= pa64_solib_create_inferior_hook
;
652 pa64_so_ops
.special_symbol_handling
= pa64_special_symbol_handling
;
653 pa64_so_ops
.current_sos
= pa64_current_sos
;
654 pa64_so_ops
.open_symbol_file_object
= pa64_open_symbol_file_object
;
655 pa64_so_ops
.in_dynsym_resolve_code
= pa64_in_dynsym_resolve_code
;
657 memset (&dld_cache
, 0, sizeof (dld_cache
));
660 void pa64_solib_select (struct gdbarch_tdep
*tdep
)
662 current_target_so_ops
= &pa64_so_ops
;
664 tdep
->solib_thread_start_addr
= pa64_solib_thread_start_addr
;
665 tdep
->solib_get_got_by_pc
= pa64_solib_get_got_by_pc
;
666 tdep
->solib_get_solib_by_pc
= pa64_solib_get_solib_by_pc
;
667 tdep
->solib_get_text_base
= pa64_solib_get_text_base
;
670 #else /* PA_SOM_ONLY */
672 extern initialize_file_ftype _initialize_pa64_solib
; /* -Wmissing-prototypes */
675 _initialize_pa64_solib (void)
679 void pa64_solib_select (struct gdbarch_tdep
*tdep
)
681 /* For a SOM-only target, there is no pa64 solib support. This is needed
682 for hppa-hpux-tdep.c to build. */
683 error (_("Cannot select pa64 solib support for this configuration."));