1/* Handle HP ELF shared libraries for GDB, the GNU Debugger. 2 3 Copyright 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, 4 Inc. 5 6 This file is part of GDB. 7 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 2 of the License, or 11 (at your option) any later version. 12 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. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. 22 23 HP in their infinite stupidity choose not to use standard ELF dynamic 24 linker interfaces. They also choose not to make their ELF dymamic 25 linker interfaces compatible with the SOM dynamic linker. The 26 net result is we can not use either of the existing somsolib.c or 27 solib.c. What a crock. 28 29 Even more disgusting. This file depends on functions provided only 30 in certain PA64 libraries. Thus this file is supposed to only be 31 used native. When will HP ever learn that they need to provide the 32 same functionality in all their libraries! */ 33 34#include <dlfcn.h> 35#include <elf.h> 36#include <elf_hp.h> 37 38#include "defs.h" 39 40#include "frame.h" 41#include "bfd.h" 42#include "libhppa.h" 43#include "gdbcore.h" 44#include "symtab.h" 45#include "breakpoint.h" 46#include "symfile.h" 47#include "objfiles.h" 48#include "inferior.h" 49#include "gdb-stabs.h" 50#include "gdb_stat.h" 51#include "gdbcmd.h" 52#include "language.h" 53#include "regcache.h" 54#include "exec.h" 55#include "hppa-tdep.h" 56 57#include <fcntl.h> 58 59#ifndef O_BINARY 60#define O_BINARY 0 61#endif 62 63static CORE_ADDR bfd_lookup_symbol (bfd *, char *); 64/* This lives in hppa-tdep.c. */ 65extern struct unwind_table_entry *find_unwind_entry (CORE_ADDR pc); 66 67/* These ought to be defined in some public interface, but aren't. They 68 identify dynamic linker events. */ 69#define DLD_CB_LOAD 1 70#define DLD_CB_UNLOAD 0 71 72/* A structure to keep track of all the known shared objects. */ 73struct so_list 74 { 75 bfd *abfd; 76 char *name; 77 struct so_list *next; 78 struct objfile *objfile; 79 CORE_ADDR pa64_solib_desc_addr; 80 struct load_module_desc pa64_solib_desc; 81 struct section_table *sections; 82 struct section_table *sections_end; 83 int loaded; 84 }; 85 86static struct so_list *so_list_head; 87 88/* This is the cumulative size in bytes of the symbol tables of all 89 shared objects on the so_list_head list. (When we say size, here 90 we mean of the information before it is brought into memory and 91 potentially expanded by GDB.) When adding a new shlib, this value 92 is compared against a threshold size, held by auto_solib_limit (in 93 megabytes). If adding symbols for the new shlib would cause the 94 total size to exceed the threshold, then the new shlib's symbols 95 are not loaded. */ 96static LONGEST pa64_solib_total_st_size; 97 98/* When the threshold is reached for any shlib, we refuse to add 99 symbols for subsequent shlibs, even if those shlibs' symbols would 100 be small enough to fit under the threshold. Although this may 101 result in one, early large shlib preventing the loading of later, 102 smaller shlibs' symbols, it allows us to issue one informational 103 message. The alternative, to issue a message for each shlib whose 104 symbols aren't loaded, could be a big annoyance where the threshold 105 is exceeded due to a very large number of shlibs. */ 106static int pa64_solib_st_size_threshold_exceeded; 107 108/* When adding fields, be sure to clear them in _initialize_pa64_solib. */ 109typedef struct 110 { 111 CORE_ADDR dld_flags_addr; 112 LONGEST dld_flags; 113 struct bfd_section *dyninfo_sect; 114 int have_read_dld_descriptor; 115 int is_valid; 116 CORE_ADDR load_map; 117 CORE_ADDR load_map_addr; 118 struct load_module_desc dld_desc; 119 } 120dld_cache_t; 121 122static dld_cache_t dld_cache; 123 124static void pa64_sharedlibrary_info_command (char *, int); 125 126static void pa64_solib_sharedlibrary_command (char *, int); 127 128static void *pa64_target_read_memory (void *, CORE_ADDR, size_t, int); 129 130static int read_dld_descriptor (struct target_ops *, int readsyms); 131 132static int read_dynamic_info (asection *, dld_cache_t *); 133 134static void add_to_solist (int, char *, int, struct load_module_desc *, 135 CORE_ADDR, struct target_ops *); 136 137/* When examining the shared library for debugging information we have to 138 look for HP debug symbols, stabs and dwarf2 debug symbols. */ 139static char *pa64_debug_section_names[] = { 140 ".debug_header", ".debug_gntt", ".debug_lntt", ".debug_slt", ".debug_vt", 141 ".stabs", ".stabstr", ".debug_info", ".debug_abbrev", ".debug_aranges", 142 ".debug_macinfo", ".debug_line", ".debug_loc", ".debug_pubnames", 143 ".debug_str", NULL 144}; 145 146/* Return a ballbark figure for the amount of memory GDB will need to 147 allocate to read in the debug symbols from FILENAME. */ 148static LONGEST 149pa64_solib_sizeof_symbol_table (char *filename) 150{ 151 bfd *abfd; 152 int i; 153 int desc; 154 char *absolute_name; 155 LONGEST st_size = (LONGEST) 0; 156 asection *sect; 157 158 /* We believe that filename was handed to us by the dynamic linker, and 159 is therefore always an absolute path. */ 160 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename, 161 O_RDONLY | O_BINARY, 0, &absolute_name); 162 if (desc < 0) 163 { 164 perror_with_name (filename); 165 } 166 filename = absolute_name; 167 168 abfd = bfd_fdopenr (filename, gnutarget, desc); 169 if (!abfd) 170 { 171 close (desc); 172 make_cleanup (xfree, filename); 173 error ("\"%s\": can't open to read symbols: %s.", filename, 174 bfd_errmsg (bfd_get_error ())); 175 } 176 177 if (!bfd_check_format (abfd, bfd_object)) 178 { 179 bfd_close (abfd); 180 make_cleanup (xfree, filename); 181 error ("\"%s\": can't read symbols: %s.", filename, 182 bfd_errmsg (bfd_get_error ())); 183 } 184 185 /* Sum the sizes of the various sections that compose debug info. */ 186 for (i = 0; pa64_debug_section_names[i] != NULL; i++) 187 { 188 asection *sect; 189 190 sect = bfd_get_section_by_name (abfd, pa64_debug_section_names[i]); 191 if (sect) 192 st_size += (LONGEST)bfd_section_size (abfd, sect); 193 } 194 195 bfd_close (abfd); 196 xfree (filename); 197 198 /* Unfortunately, just summing the sizes of various debug info 199 sections isn't a very accurate measurement of how much heap 200 space the debugger will need to hold them. It also doesn't 201 account for space needed by linker (aka "minimal") symbols. 202 203 Anecdotal evidence suggests that just summing the sizes of 204 debug-info-related sections understates the heap space needed 205 to represent it internally by about an order of magnitude. 206 207 Since it's not exactly brain surgery we're doing here, rather 208 than attempt to more accurately measure the size of a shlib's 209 symbol table in GDB's heap, we'll just apply a 10x fudge- 210 factor to the debug info sections' size-sum. No, this doesn't 211 account for minimal symbols in non-debuggable shlibs. But it 212 all roughly washes out in the end. */ 213 return st_size * (LONGEST) 10; 214} 215 216/* Add a shared library to the objfile list and load its symbols into 217 GDB's symbol table. */ 218static void 219pa64_solib_add_solib_objfile (struct so_list *so, char *name, int from_tty, 220 CORE_ADDR text_addr) 221{ 222 bfd *tmp_bfd; 223 asection *sec; 224 struct hppa_objfile_private *obj_private; 225 struct section_addr_info *section_addrs; 226 struct cleanup *my_cleanups; 227 228 /* We need the BFD so that we can look at its sections. We open up the 229 file temporarily, then close it when we are done. */ 230 tmp_bfd = bfd_openr (name, gnutarget); 231 if (tmp_bfd == NULL) 232 { 233 perror_with_name (name); 234 return; 235 } 236 237 if (!bfd_check_format (tmp_bfd, bfd_object)) 238 { 239 bfd_close (tmp_bfd); 240 error ("\"%s\" is not an object file: %s", name, 241 bfd_errmsg (bfd_get_error ())); 242 } 243 244 245 /* Undo some braindamage from symfile.c. 246 247 First, symfile.c will subtract the VMA of the first .text section 248 in the shared library that it finds. Undo that. */ 249 sec = bfd_get_section_by_name (tmp_bfd, ".text"); 250 text_addr += bfd_section_vma (tmp_bfd, sec); 251 252 /* Now find the true lowest section in the shared library. */ 253 sec = NULL; 254 bfd_map_over_sections (tmp_bfd, find_lowest_section, &sec); 255 256 if (sec) 257 { 258 /* Subtract out the VMA of the lowest section. */ 259 text_addr -= bfd_section_vma (tmp_bfd, sec); 260 261 /* ??? Add back in the filepos of that lowest section. */ 262 text_addr += sec->filepos; 263 } 264 265 section_addrs = alloc_section_addr_info (bfd_count_sections (tmp_bfd)); 266 my_cleanups = make_cleanup (xfree, section_addrs); 267 268 /* We are done with the temporary bfd. Get rid of it and make sure 269 nobody else can us it. */ 270 bfd_close (tmp_bfd); 271 tmp_bfd = NULL; 272 273 /* Now let the generic code load up symbols for this library. */ 274 section_addrs->other[0].addr = text_addr; 275 section_addrs->other[0].name = ".text"; 276 so->objfile = symbol_file_add (name, from_tty, section_addrs, 0, OBJF_SHARED); 277 so->abfd = so->objfile->obfd; 278 279 /* Mark this as a shared library and save private data. */ 280 so->objfile->flags |= OBJF_SHARED; 281 282 obj_private = (struct hppa_objfile_private *) 283 objfile_data (so->objfile, hppa_objfile_priv_data); 284 if (obj_private == NULL) 285 { 286 obj_private = (struct hppa_objfile_private *) 287 obstack_alloc (&so->objfile->objfile_obstack, 288 sizeof (struct hppa_objfile_private)); 289 set_objfile_data (so->objfile, hppa_objfile_priv_data, obj_private); 290 obj_private->unwind_info = NULL; 291 obj_private->so_info = NULL; 292 } 293 294 obj_private->so_info = so; 295 obj_private->dp = so->pa64_solib_desc.linkage_ptr; 296 do_cleanups (my_cleanups); 297} 298 299/* Load debugging information for a shared library. TARGET may be 300 NULL if we are not attaching to a process or reading a core file. */ 301 302static void 303pa64_solib_load_symbols (struct so_list *so, char *name, int from_tty, 304 CORE_ADDR text_addr, struct target_ops *target) 305{ 306 struct section_table *p; 307 asection *sec; 308 int status; 309 char buf[4]; 310 CORE_ADDR presumed_data_start; 311 312 if (text_addr == 0) 313 text_addr = so->pa64_solib_desc.text_base; 314 315 pa64_solib_add_solib_objfile (so, name, from_tty, text_addr); 316 317 /* Now we need to build a section table for this library since 318 we might be debugging a core file from a dynamically linked 319 executable in which the libraries were not privately mapped. */ 320 if (build_section_table (so->abfd, 321 &so->sections, 322 &so->sections_end)) 323 { 324 error ("Unable to build section table for shared library\n."); 325 return; 326 } 327 328 (so->objfile->section_offsets)->offsets[SECT_OFF_TEXT (so->objfile)] 329 = so->pa64_solib_desc.text_base; 330 (so->objfile->section_offsets)->offsets[SECT_OFF_DATA (so->objfile)] 331 = so->pa64_solib_desc.data_base; 332 333 /* Relocate all the sections based on where they got loaded. */ 334 for (p = so->sections; p < so->sections_end; p++) 335 { 336 if (p->the_bfd_section->flags & SEC_CODE) 337 { 338 p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT (so->objfile)); 339 p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT (so->objfile)); 340 } 341 else if (p->the_bfd_section->flags & SEC_DATA) 342 { 343 p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA (so->objfile)); 344 p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA (so->objfile)); 345 } 346 } 347 348 /* Now see if we need to map in the text and data for this shared 349 library (for example debugging a core file which does not use 350 private shared libraries.). 351 352 Carefully peek at the first text address in the library. If the 353 read succeeds, then the libraries were privately mapped and were 354 included in the core dump file. 355 356 If the peek failed, then the libraries were not privately mapped 357 and are not in the core file, we'll have to read them in ourselves. */ 358 status = target_read_memory (text_addr, buf, 4); 359 if (status != 0) 360 { 361 int new, old; 362 363 new = so->sections_end - so->sections; 364 365 old = target_resize_to_sections (target, new); 366 367 /* Copy over the old data before it gets clobbered. */ 368 memcpy ((char *) (target->to_sections + old), 369 so->sections, 370 ((sizeof (struct section_table)) * new)); 371 } 372} 373 374 375/* Add symbols from shared libraries into the symtab list, unless the 376 size threshold specified by auto_solib_limit (in megabytes) would 377 be exceeded. */ 378 379void 380pa64_solib_add (char *arg_string, int from_tty, struct target_ops *target, int readsyms) 381{ 382 struct minimal_symbol *msymbol; 383 CORE_ADDR addr; 384 asection *shlib_info; 385 int status; 386 unsigned int dld_flags; 387 char buf[4], *re_err; 388 int threshold_warning_given = 0; 389 int dll_index; 390 struct load_module_desc dll_desc; 391 char *dll_path; 392 393 /* First validate our arguments. */ 394 if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL) 395 { 396 error ("Invalid regexp: %s", re_err); 397 } 398 399 /* If we're debugging a core file, or have attached to a running 400 process, then pa64_solib_create_inferior_hook will not have been 401 called. 402 403 We need to first determine if we're dealing with a dynamically 404 linked executable. If not, then return without an error or warning. 405 406 We also need to examine __dld_flags to determine if the shared library 407 list is valid and to determine if the libraries have been privately 408 mapped. */ 409 if (symfile_objfile == NULL) 410 return; 411 412 /* First see if the objfile was dynamically linked. */ 413 shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, ".dynamic"); 414 if (!shlib_info) 415 return; 416 417 /* It's got a .dynamic section, make sure it's not empty. */ 418 if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0) 419 return; 420 421 /* Read in the load map pointer if we have not done so already. */ 422 if (! dld_cache.have_read_dld_descriptor) 423 if (! read_dld_descriptor (target, readsyms)) 424 return; 425 426 /* If the libraries were not mapped private, warn the user. */ 427 if ((dld_cache.dld_flags & DT_HP_DEBUG_PRIVATE) == 0) 428 warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n"); 429 430 /* For each shaerd library, add it to the shared library list. */ 431 for (dll_index = 1; ; dll_index++) 432 { 433 /* Read in the load module descriptor. */ 434 if (dlgetmodinfo (dll_index, &dll_desc, sizeof (dll_desc), 435 pa64_target_read_memory, 0, dld_cache.load_map) 436 == 0) 437 return; 438 439 /* Get the name of the shared library. */ 440 dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc), 441 pa64_target_read_memory, 442 0, dld_cache.load_map); 443 444 if (!dll_path) 445 error ("pa64_solib_add, unable to read shared library path."); 446 447 add_to_solist (from_tty, dll_path, readsyms, &dll_desc, 0, target); 448 } 449} 450 451 452/* This hook gets called just before the first instruction in the 453 inferior process is executed. 454 455 This is our opportunity to set magic flags in the inferior so 456 that GDB can be notified when a shared library is mapped in and 457 to tell the dynamic linker that a private copy of the library is 458 needed (so GDB can set breakpoints in the library). 459 460 We need to set two flag bits in this routine. 461 462 DT_HP_DEBUG_PRIVATE to indicate that shared libraries should be 463 mapped private. 464 465 DT_HP_DEBUG_CALLBACK to indicate that we want the dynamic linker to 466 call the breakpoint routine for significant events. */ 467 468void 469pa64_solib_create_inferior_hook (void) 470{ 471 struct minimal_symbol *msymbol; 472 unsigned int dld_flags, status; 473 asection *shlib_info, *interp_sect; 474 char buf[4]; 475 struct objfile *objfile; 476 CORE_ADDR anaddr; 477 478 /* First, remove all the solib event breakpoints. Their addresses 479 may have changed since the last time we ran the program. */ 480 remove_solib_event_breakpoints (); 481 482 if (symfile_objfile == NULL) 483 return; 484 485 /* First see if the objfile was dynamically linked. */ 486 shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, ".dynamic"); 487 if (!shlib_info) 488 return; 489 490 /* It's got a .dynamic section, make sure it's not empty. */ 491 if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0) 492 return; 493 494 /* Read in the .dynamic section. */ 495 if (! read_dynamic_info (shlib_info, &dld_cache)) 496 error ("Unable to read the .dynamic section."); 497 498 /* Turn on the flags we care about. */ 499 dld_cache.dld_flags |= DT_HP_DEBUG_PRIVATE; 500 dld_cache.dld_flags |= DT_HP_DEBUG_CALLBACK; 501 status = target_write_memory (dld_cache.dld_flags_addr, 502 (char *) &dld_cache.dld_flags, 503 sizeof (dld_cache.dld_flags)); 504 if (status != 0) 505 error ("Unable to modify dynamic linker flags."); 506 507 /* Now we have to create a shared library breakpoint in the dynamic 508 linker. This can be somewhat tricky since the symbol is inside 509 the dynamic linker (for which we do not have symbols or a base 510 load address! Luckily I wrote this code for solib.c years ago. */ 511 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp"); 512 if (interp_sect) 513 { 514 unsigned int interp_sect_size; 515 char *buf; 516 CORE_ADDR load_addr; 517 bfd *tmp_bfd; 518 CORE_ADDR sym_addr = 0; 519 520 /* Read the contents of the .interp section into a local buffer; 521 the contents specify the dynamic linker this program uses. */ 522 interp_sect_size = bfd_section_size (exec_bfd, interp_sect); 523 buf = alloca (interp_sect_size); 524 bfd_get_section_contents (exec_bfd, interp_sect, 525 buf, 0, interp_sect_size); 526 527 /* Now we need to figure out where the dynamic linker was 528 loaded so that we can load its symbols and place a breakpoint 529 in the dynamic linker itself. 530 531 This address is stored on the stack. However, I've been unable 532 to find any magic formula to find it for Solaris (appears to 533 be trivial on GNU/Linux). Therefore, we have to try an alternate 534 mechanism to find the dynamic linker's base address. */ 535 tmp_bfd = bfd_openr (buf, gnutarget); 536 if (tmp_bfd == NULL) 537 goto get_out; 538 539 /* Make sure the dynamic linker's really a useful object. */ 540 if (!bfd_check_format (tmp_bfd, bfd_object)) 541 { 542 warning ("Unable to grok dynamic linker %s as an object file", buf); 543 bfd_close (tmp_bfd); 544 goto get_out; 545 } 546 547 /* We find the dynamic linker's base address by examining the 548 current pc (which point at the entry point for the dynamic 549 linker) and subtracting the offset of the entry point. 550 551 Also note the breakpoint is the second instruction in the 552 routine. */ 553 load_addr = read_pc () - tmp_bfd->start_address; 554 sym_addr = bfd_lookup_symbol (tmp_bfd, "__dld_break"); 555 sym_addr = load_addr + sym_addr + 4; 556 557 /* Create the shared library breakpoint. */ 558 { 559 struct breakpoint *b 560 = create_solib_event_breakpoint (sym_addr); 561 562 /* The breakpoint is actually hard-coded into the dynamic linker, 563 so we don't need to actually insert a breakpoint instruction 564 there. In fact, the dynamic linker's code is immutable, even to 565 ttrace, so we shouldn't even try to do that. For cases like 566 this, we have "permanent" breakpoints. */ 567 make_breakpoint_permanent (b); 568 } 569 570 /* We're done with the temporary bfd. */ 571 bfd_close (tmp_bfd); 572 } 573 574get_out: 575 /* Wipe out all knowledge of old shared libraries since their 576 mapping can change from one exec to another! */ 577 while (so_list_head) 578 { 579 struct so_list *temp; 580 581 temp = so_list_head; 582 xfree (so_list_head); 583 so_list_head = temp->next; 584 } 585 clear_symtab_users (); 586} 587 588/* This operation removes the "hook" between GDB and the dynamic linker, 589 which causes the dld to notify GDB of shared library events. 590 591 After this operation completes, the dld will no longer notify GDB of 592 shared library events. To resume notifications, GDB must call 593 pa64_solib_create_inferior_hook. 594 595 This operation does not remove any knowledge of shared libraries which 596 GDB may already have been notified of. */ 597 598void 599pa64_solib_remove_inferior_hook (int pid) 600{ 601 /* Turn off the DT_HP_DEBUG_CALLBACK bit in the dynamic linker flags. */ 602 dld_cache.dld_flags &= ~DT_HP_DEBUG_CALLBACK; 603 target_write_memory (dld_cache.dld_flags_addr, 604 (char *)&dld_cache.dld_flags, 605 sizeof (dld_cache.dld_flags)); 606} 607 608/* This function creates a breakpoint on the dynamic linker hook, which 609 is called when e.g., a shl_load or shl_unload call is made. This 610 breakpoint will only trigger when a shl_load call is made. 611 612 If filename is NULL, then loads of any dll will be caught. Else, 613 only loads of the file whose pathname is the string contained by 614 filename will be caught. 615 616 Undefined behaviour is guaranteed if this function is called before 617 pa64_solib_create_inferior_hook. */ 618 619void 620pa64_solib_create_catch_load_hook (int pid, int tempflag, char *filename, 621 char *cond_string) 622{ 623 create_solib_load_event_breakpoint ("", tempflag, filename, cond_string); 624} 625 626/* This function creates a breakpoint on the dynamic linker hook, which 627 is called when e.g., a shl_load or shl_unload call is made. This 628 breakpoint will only trigger when a shl_unload call is made. 629 630 If filename is NULL, then unloads of any dll will be caught. Else, 631 only unloads of the file whose pathname is the string contained by 632 filename will be caught. 633 634 Undefined behaviour is guaranteed if this function is called before 635 pa64_solib_create_inferior_hook. */ 636 637void 638pa64_solib_create_catch_unload_hook (int pid, int tempflag, char *filename, 639 char *cond_string) 640{ 641 create_solib_unload_event_breakpoint ("", tempflag, filename, cond_string); 642} 643 644/* Return nonzero if the dynamic linker has reproted that a library 645 has been loaded. */ 646 647int 648pa64_solib_have_load_event (int pid) 649{ 650 CORE_ADDR event_kind; 651 652 event_kind = read_register (HPPA_ARG0_REGNUM); 653 return (event_kind == DLD_CB_LOAD); 654} 655 656/* Return nonzero if the dynamic linker has reproted that a library 657 has been unloaded. */ 658int 659pa64_solib_have_unload_event (int pid) 660{ 661 CORE_ADDR event_kind; 662 663 event_kind = read_register (HPPA_ARG0_REGNUM); 664 return (event_kind == DLD_CB_UNLOAD); 665} 666 667/* Return a pointer to a string indicating the pathname of the most 668 recently loaded library. 669 670 The caller is reposible for copying the string before the inferior is 671 restarted. */ 672 673char * 674pa64_solib_loaded_library_pathname (int pid) 675{ 676 static char dll_path[MAXPATHLEN]; 677 CORE_ADDR dll_path_addr = read_register (HPPA_ARG3_REGNUM); 678 read_memory_string (dll_path_addr, dll_path, MAXPATHLEN); 679 return dll_path; 680} 681 682/* Return a pointer to a string indicating the pathname of the most 683 recently unloaded library. 684 685 The caller is reposible for copying the string before the inferior is 686 restarted. */ 687 688char * 689pa64_solib_unloaded_library_pathname (int pid) 690{ 691 static char dll_path[MAXPATHLEN]; 692 CORE_ADDR dll_path_addr = read_register (HPPA_ARG3_REGNUM); 693 read_memory_string (dll_path_addr, dll_path, MAXPATHLEN); 694 return dll_path; 695} 696 697/* Return nonzero if PC is an address inside the dynamic linker. */ 698 699int 700pa64_solib_in_dynamic_linker (int pid, CORE_ADDR pc) 701{ 702 asection *shlib_info; 703 704 if (symfile_objfile == NULL) 705 return 0; 706 707 if (!dld_cache.have_read_dld_descriptor) 708 if (!read_dld_descriptor (¤t_target, auto_solib_add)) 709 return 0; 710 711 return (pc >= dld_cache.dld_desc.text_base 712 && pc < dld_cache.dld_desc.text_base + dld_cache.dld_desc.text_size); 713} 714 715 716/* Return the GOT value for the shared library in which ADDR belongs. If 717 ADDR isn't in any known shared library, return zero. */ 718 719CORE_ADDR 720pa64_solib_get_got_by_pc (CORE_ADDR addr) 721{ 722 struct so_list *so_list = so_list_head; 723 CORE_ADDR got_value = 0; 724 725 while (so_list) 726 { 727 if (so_list->pa64_solib_desc.text_base <= addr 728 && ((so_list->pa64_solib_desc.text_base 729 + so_list->pa64_solib_desc.text_size) 730 > addr)) 731 { 732 got_value = so_list->pa64_solib_desc.linkage_ptr; 733 break; 734 } 735 so_list = so_list->next; 736 } 737 return got_value; 738} 739 740/* Return the address of the handle of the shared library in which ADDR 741 belongs. If ADDR isn't in any known shared library, return zero. 742 743 This function is used in hppa_fix_call_dummy in hppa-tdep.c. */ 744 745CORE_ADDR 746pa64_solib_get_solib_by_pc (CORE_ADDR addr) 747{ 748 struct so_list *so_list = so_list_head; 749 CORE_ADDR retval = 0; 750 751 while (so_list) 752 { 753 if (so_list->pa64_solib_desc.text_base <= addr 754 && ((so_list->pa64_solib_desc.text_base 755 + so_list->pa64_solib_desc.text_size) 756 > addr)) 757 { 758 retval = so_list->pa64_solib_desc_addr; 759 break; 760 } 761 so_list = so_list->next; 762 } 763 return retval; 764} 765 766/* Dump information about all the currently loaded shared libraries. */ 767 768static void 769pa64_sharedlibrary_info_command (char *ignore, int from_tty) 770{ 771 struct so_list *so_list = so_list_head; 772 773 if (exec_bfd == NULL) 774 { 775 printf_unfiltered ("No executable file.\n"); 776 return; 777 } 778 779 if (so_list == NULL) 780 { 781 printf_unfiltered ("No shared libraries loaded at this time.\n"); 782 return; 783 } 784 785 printf_unfiltered ("Shared Object Libraries\n"); 786 printf_unfiltered (" %-19s%-19s%-19s%-19s\n", 787 " text start", " text end", 788 " data start", " data end"); 789 while (so_list) 790 { 791 unsigned int flags; 792 793 printf_unfiltered ("%s", so_list->name); 794 if (so_list->objfile == NULL) 795 printf_unfiltered (" (symbols not loaded)"); 796 if (so_list->loaded == 0) 797 printf_unfiltered (" (shared library unloaded)"); 798 printf_unfiltered (" %-18s", 799 hex_string_custom (so_list->pa64_solib_desc.linkage_ptr, 16)); 800 printf_unfiltered ("\n"); 801 printf_unfiltered ("%-18s", 802 hex_string_custom (so_list->pa64_solib_desc.text_base, 16)); 803 printf_unfiltered (" %-18s", 804 hex_string_custom ((so_list->pa64_solib_desc.text_base 805 + so_list->pa64_solib_desc.text_size), 16)); 806 printf_unfiltered (" %-18s", 807 hex_string_custom (so_list->pa64_solib_desc.data_base, 16)); 808 printf_unfiltered (" %-18s\n", 809 hex_string_custom ((so_list->pa64_solib_desc.data_base 810 + so_list->pa64_solib_desc.data_size), 16)); 811 so_list = so_list->next; 812 } 813} 814 815/* Load up one or more shared libraries as directed by the user. */ 816 817static void 818pa64_solib_sharedlibrary_command (char *args, int from_tty) 819{ 820 dont_repeat (); 821 pa64_solib_add (args, from_tty, (struct target_ops *) 0, 1); 822} 823 824/* Return the name of the shared library containing ADDR or NULL if ADDR 825 is not contained in any known shared library. */ 826 827char * 828pa64_solib_address (CORE_ADDR addr) 829{ 830 struct so_list *so = so_list_head; 831 832 while (so) 833 { 834 /* Is this address within this shlib's text range? If so, 835 return the shlib's name. */ 836 if (addr >= so->pa64_solib_desc.text_base 837 && addr < (so->pa64_solib_desc.text_base 838 | so->pa64_solib_desc.text_size)) 839 return so->name; 840 841 /* Nope, keep looking... */ 842 so = so->next; 843 } 844 845 /* No, we couldn't prove that the address is within a shlib. */ 846 return NULL; 847} 848 849/* We are killing the inferior and restarting the program. */ 850 851void 852pa64_solib_restart (void) 853{ 854 struct so_list *sl = so_list_head; 855 856 /* Before the shlib info vanishes, use it to disable any breakpoints 857 that may still be active in those shlibs. */ 858 disable_breakpoints_in_shlibs (0); 859 860 /* Discard all the shlib descriptors. */ 861 while (sl) 862 { 863 struct so_list *next_sl = sl->next; 864 xfree (sl); 865 sl = next_sl; 866 } 867 so_list_head = NULL; 868 869 pa64_solib_total_st_size = (LONGEST) 0; 870 pa64_solib_st_size_threshold_exceeded = 0; 871 872 dld_cache.is_valid = 0; 873 dld_cache.have_read_dld_descriptor = 0; 874 dld_cache.dld_flags_addr = 0; 875 dld_cache.load_map = 0; 876 dld_cache.load_map_addr = 0; 877 dld_cache.dld_desc.data_base = 0; 878 dld_cache.dld_flags = 0; 879 dld_cache.dyninfo_sect = 0; 880} 881 882void 883_initialize_pa64_solib (void) 884{ 885 add_com ("sharedlibrary", class_files, pa64_solib_sharedlibrary_command, 886 "Load shared object library symbols for files matching REGEXP."); 887 add_info ("sharedlibrary", pa64_sharedlibrary_info_command, 888 "Status of loaded shared object libraries."); 889 890 deprecated_add_show_from_set 891 (add_set_cmd ("auto-solib-add", class_support, var_boolean, 892 (char *) &auto_solib_add, 893 "Set autoloading of shared library symbols.\n\ 894If \"on\", symbols from all shared object libraries will be loaded\n\ 895automatically when the inferior begins execution, when the dynamic linker\n\ 896informs gdb that a new library has been loaded, or when attaching to the\n\ 897inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.", 898 &setlist), 899 &showlist); 900 901 deprecated_add_show_from_set 902 (add_set_cmd ("auto-solib-limit", class_support, var_zinteger, 903 (char *) &auto_solib_limit, 904 "Set threshold (in Mb) for autoloading shared library symbols.\n\ 905When shared library autoloading is enabled, new libraries will be loaded\n\ 906only until the total size of shared library symbols exceeds this\n\ 907threshold in megabytes. Is ignored when using `sharedlibrary'.", 908 &setlist), 909 &showlist); 910 911 /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how 912 much data space a process can use. We ought to be reading 913 MAXDSIZ and setting auto_solib_limit to some large fraction of 914 that value. If not that, we maybe ought to be setting it smaller 915 than the default for MAXDSIZ (that being 64Mb, I believe). 916 However, [1] this threshold is only crudely approximated rather 917 than actually measured, and [2] 50 Mbytes is too small for 918 debugging gdb itself. Thus, the arbitrary 100 figure. */ 919 auto_solib_limit = 100; /* Megabytes */ 920 921 pa64_solib_restart (); 922} 923 924/* Get some HPUX-specific data from a shared lib. */ 925CORE_ADDR 926so_lib_thread_start_addr (struct so_list *so) 927{ 928 return so->pa64_solib_desc.tls_start_addr; 929} 930 931/* Read the dynamic linker's internal shared library descriptor. 932 933 This must happen after dld starts running, so we can't do it in 934 read_dynamic_info. Record the fact that we have loaded the 935 descriptor. If the library is archive bound, then return zero, else 936 return nonzero. */ 937 938static int 939read_dld_descriptor (struct target_ops *target, int readsyms) 940{ 941 char *dll_path; 942 asection *dyninfo_sect; 943 944 /* If necessary call read_dynamic_info to extract the contents of the 945 .dynamic section from the shared library. */ 946 if (!dld_cache.is_valid) 947 { 948 if (symfile_objfile == NULL) 949 error ("No object file symbols."); 950 951 dyninfo_sect = bfd_get_section_by_name (symfile_objfile->obfd, 952 ".dynamic"); 953 if (!dyninfo_sect) 954 { 955 return 0; 956 } 957 958 if (!read_dynamic_info (dyninfo_sect, &dld_cache)) 959 error ("Unable to read in .dynamic section information."); 960 } 961 962 /* Read the load map pointer. */ 963 if (target_read_memory (dld_cache.load_map_addr, 964 (char*) &dld_cache.load_map, 965 sizeof(dld_cache.load_map)) 966 != 0) 967 { 968 error ("Error while reading in load map pointer."); 969 } 970 971 /* Read in the dld load module descriptor */ 972 if (dlgetmodinfo (-1, 973 &dld_cache.dld_desc, 974 sizeof(dld_cache.dld_desc), 975 pa64_target_read_memory, 976 0, 977 dld_cache.load_map) 978 == 0) 979 { 980 error ("Error trying to get information about dynamic linker."); 981 } 982 983 /* Indicate that we have loaded the dld descriptor. */ 984 dld_cache.have_read_dld_descriptor = 1; 985 986 /* Add dld.sl to the list of known shared libraries so that we can 987 do unwind, etc. 988 989 ?!? This may not be correct. Consider of dld.sl contains symbols 990 which are also referenced/defined by the user program or some user 991 shared library. We need to make absolutely sure that we do not 992 pollute the namespace from GDB's point of view. */ 993 dll_path = dlgetname (&dld_cache.dld_desc, 994 sizeof(dld_cache.dld_desc), 995 pa64_target_read_memory, 996 0, 997 dld_cache.load_map); 998 add_to_solist(0, dll_path, readsyms, &dld_cache.dld_desc, 0, target); 999 1000 return 1; 1001} 1002 1003/* Read the .dynamic section and extract the information of interest, 1004 which is stored in dld_cache. The routine elf_locate_base in solib.c 1005 was used as a model for this. */ 1006 1007static int 1008read_dynamic_info (asection *dyninfo_sect, dld_cache_t *dld_cache_p) 1009{ 1010 char *buf; 1011 char *bufend; 1012 CORE_ADDR dyninfo_addr; 1013 int dyninfo_sect_size; 1014 CORE_ADDR entry_addr; 1015 1016 /* Read in .dynamic section, silently ignore errors. */ 1017 dyninfo_addr = bfd_section_vma (symfile_objfile->obfd, dyninfo_sect); 1018 dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect); 1019 buf = alloca (dyninfo_sect_size); 1020 if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size)) 1021 return 0; 1022 1023 /* Scan the .dynamic section and record the items of interest. 1024 In particular, DT_HP_DLD_FLAGS */ 1025 for (bufend = buf + dyninfo_sect_size, entry_addr = dyninfo_addr; 1026 buf < bufend; 1027 buf += sizeof (Elf64_Dyn), entry_addr += sizeof (Elf64_Dyn)) 1028 { 1029 Elf64_Dyn *x_dynp = (Elf64_Dyn*)buf; 1030 Elf64_Sxword dyn_tag; 1031 CORE_ADDR dyn_ptr; 1032 char *pbuf; 1033 1034 pbuf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT); 1035 dyn_tag = bfd_h_get_64 (symfile_objfile->obfd, 1036 (bfd_byte*) &x_dynp->d_tag); 1037 1038 /* We can't use a switch here because dyn_tag is 64 bits and HP's 1039 lame comiler does not handle 64bit items in switch statements. */ 1040 if (dyn_tag == DT_NULL) 1041 break; 1042 else if (dyn_tag == DT_HP_DLD_FLAGS) 1043 { 1044 /* Set dld_flags_addr and dld_flags in *dld_cache_p */ 1045 dld_cache_p->dld_flags_addr = entry_addr + offsetof(Elf64_Dyn, d_un); 1046 if (target_read_memory (dld_cache_p->dld_flags_addr, 1047 (char*) &dld_cache_p->dld_flags, 1048 sizeof(dld_cache_p->dld_flags)) 1049 != 0) 1050 { 1051 error ("Error while reading in .dynamic section of the program."); 1052 } 1053 } 1054 else if (dyn_tag == DT_HP_LOAD_MAP) 1055 { 1056 /* Dld will place the address of the load map at load_map_addr 1057 after it starts running. */ 1058 if (target_read_memory (entry_addr + offsetof(Elf64_Dyn, 1059 d_un.d_ptr), 1060 (char*) &dld_cache_p->load_map_addr, 1061 sizeof(dld_cache_p->load_map_addr)) 1062 != 0) 1063 { 1064 error ("Error while reading in .dynamic section of the program."); 1065 } 1066 } 1067 else 1068 { 1069 /* tag is not of interest */ 1070 } 1071 } 1072 1073 /* Record other information and set is_valid to 1. */ 1074 dld_cache_p->dyninfo_sect = dyninfo_sect; 1075 1076 /* Verify that we read in required info. These fields are re-set to zero 1077 in pa64_solib_restart. */ 1078 1079 if (dld_cache_p->dld_flags_addr != 0 && dld_cache_p->load_map_addr != 0) 1080 dld_cache_p->is_valid = 1; 1081 else 1082 return 0; 1083 1084 return 1; 1085} 1086 1087/* Wrapper for target_read_memory to make dlgetmodinfo happy. */ 1088 1089static void * 1090pa64_target_read_memory (void *buffer, CORE_ADDR ptr, size_t bufsiz, int ident) 1091{ 1092 if (target_read_memory (ptr, buffer, bufsiz) != 0) 1093 return 0; 1094 return buffer; 1095} 1096 1097/* Called from handle_dynlink_load_event and pa64_solib_add to add 1098 a shared library to so_list_head list and possibly to read in the 1099 debug information for the library. 1100 1101 If load_module_desc_p is NULL, then the load module descriptor must 1102 be read from the inferior process at the address load_module_desc_addr. */ 1103 1104static void 1105add_to_solist (int from_tty, char *dll_path, int readsyms, 1106 struct load_module_desc *load_module_desc_p, 1107 CORE_ADDR load_module_desc_addr, struct target_ops *target) 1108{ 1109 struct so_list *new_so, *so_list_tail; 1110 int pa64_solib_st_size_threshhold_exceeded; 1111 LONGEST st_size; 1112 1113 if (symfile_objfile == NULL) 1114 return; 1115 1116 so_list_tail = so_list_head; 1117 /* Find the end of the list of shared objects. */ 1118 while (so_list_tail && so_list_tail->next) 1119 { 1120 if (strcmp (so_list_tail->name, dll_path) == 0) 1121 return; 1122 so_list_tail = so_list_tail->next; 1123 } 1124 1125 if (so_list_tail && strcmp (so_list_tail->name, dll_path) == 0) 1126 return; 1127 1128 /* Add the shared library to the so_list_head list */ 1129 new_so = (struct so_list *) xmalloc (sizeof (struct so_list)); 1130 memset ((char *)new_so, 0, sizeof (struct so_list)); 1131 if (so_list_head == NULL) 1132 { 1133 so_list_head = new_so; 1134 so_list_tail = new_so; 1135 } 1136 else 1137 { 1138 so_list_tail->next = new_so; 1139 so_list_tail = new_so; 1140 } 1141 1142 /* Initialize the new_so */ 1143 if (load_module_desc_p) 1144 { 1145 new_so->pa64_solib_desc = *load_module_desc_p; 1146 } 1147 else 1148 { 1149 if (target_read_memory (load_module_desc_addr, 1150 (char*) &new_so->pa64_solib_desc, 1151 sizeof(struct load_module_desc)) 1152 != 0) 1153 { 1154 error ("Error while reading in dynamic library %s", dll_path); 1155 } 1156 } 1157 1158 new_so->pa64_solib_desc_addr = load_module_desc_addr; 1159 new_so->loaded = 1; 1160 new_so->name = obsavestring (dll_path, strlen(dll_path), 1161 &symfile_objfile->objfile_obstack); 1162 1163 /* If we are not going to load the library, tell the user if we 1164 haven't already and return. */ 1165 1166 st_size = pa64_solib_sizeof_symbol_table (dll_path); 1167 pa64_solib_st_size_threshhold_exceeded = 1168 !from_tty 1169 && readsyms 1170 && ( (st_size + pa64_solib_total_st_size) 1171 > (auto_solib_limit * (LONGEST) (1024 * 1024))); 1172 if (pa64_solib_st_size_threshhold_exceeded) 1173 { 1174 pa64_solib_add_solib_objfile (new_so, dll_path, from_tty, 1); 1175 return; 1176 } 1177 1178 /* Now read in debug info. */ 1179 pa64_solib_total_st_size += st_size; 1180 1181 /* This fills in new_so->objfile, among others. */ 1182 pa64_solib_load_symbols (new_so, 1183 dll_path, 1184 from_tty, 1185 0, 1186 target); 1187 return; 1188} 1189 1190 1191/* 1192 LOCAL FUNCTION 1193 1194 bfd_lookup_symbol -- lookup the value for a specific symbol 1195 1196 SYNOPSIS 1197 1198 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname) 1199 1200 DESCRIPTION 1201 1202 An expensive way to lookup the value of a single symbol for 1203 bfd's that are only temporary anyway. This is used by the 1204 shared library support to find the address of the debugger 1205 interface structures in the shared library. 1206 1207 Note that 0 is specifically allowed as an error return (no 1208 such symbol). 1209 */ 1210 1211static CORE_ADDR 1212bfd_lookup_symbol (bfd *abfd, char *symname) 1213{ 1214 unsigned int storage_needed; 1215 asymbol *sym; 1216 asymbol **symbol_table; 1217 unsigned int number_of_symbols; 1218 unsigned int i; 1219 struct cleanup *back_to; 1220 CORE_ADDR symaddr = 0; 1221 1222 storage_needed = bfd_get_symtab_upper_bound (abfd); 1223 1224 if (storage_needed > 0) 1225 { 1226 symbol_table = (asymbol **) xmalloc (storage_needed); 1227 back_to = make_cleanup (xfree, symbol_table); 1228 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 1229 1230 for (i = 0; i < number_of_symbols; i++) 1231 { 1232 sym = *symbol_table++; 1233 if (strcmp (sym->name, symname) == 0) 1234 { 1235 /* Bfd symbols are section relative. */ 1236 symaddr = sym->value + sym->section->vma; 1237 break; 1238 } 1239 } 1240 do_cleanups (back_to); 1241 } 1242 return (symaddr); 1243} 1244 1245