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
63 static CORE_ADDR bfd_lookup_symbol (bfd *, char *);
64 /* This lives in hppa-tdep.c. */
65 extern 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. */
73 struct 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
86 static 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. */
96 static 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. */
106 static int pa64_solib_st_size_threshold_exceeded;
107
108 /* When adding fields, be sure to clear them in _initialize_pa64_solib. */
109 typedef 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 }
120 dld_cache_t;
121
122 static dld_cache_t dld_cache;
123
124 static void pa64_sharedlibrary_info_command (char *, int);
125
126 static void pa64_solib_sharedlibrary_command (char *, int);
127
128 static void *pa64_target_read_memory (void *, CORE_ADDR, size_t, int);
129
130 static int read_dld_descriptor (struct target_ops *, int readsyms);
131
132 static int read_dynamic_info (asection *, dld_cache_t *);
133
134 static 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. */
139 static 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. */
148 static LONGEST
pa64_solib_sizeof_symbol_table(char * filename)149 pa64_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. */
218 static void
pa64_solib_add_solib_objfile(struct so_list * so,char * name,int from_tty,CORE_ADDR text_addr)219 pa64_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
302 static void
pa64_solib_load_symbols(struct so_list * so,char * name,int from_tty,CORE_ADDR text_addr,struct target_ops * target)303 pa64_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
379 void
pa64_solib_add(char * arg_string,int from_tty,struct target_ops * target,int readsyms)380 pa64_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
468 void
pa64_solib_create_inferior_hook(void)469 pa64_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
574 get_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
598 void
pa64_solib_remove_inferior_hook(int pid)599 pa64_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
619 void
pa64_solib_create_catch_load_hook(int pid,int tempflag,char * filename,char * cond_string)620 pa64_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
637 void
pa64_solib_create_catch_unload_hook(int pid,int tempflag,char * filename,char * cond_string)638 pa64_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
647 int
pa64_solib_have_load_event(int pid)648 pa64_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. */
658 int
pa64_solib_have_unload_event(int pid)659 pa64_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
673 char *
pa64_solib_loaded_library_pathname(int pid)674 pa64_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
688 char *
pa64_solib_unloaded_library_pathname(int pid)689 pa64_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
699 int
pa64_solib_in_dynamic_linker(int pid,CORE_ADDR pc)700 pa64_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
719 CORE_ADDR
pa64_solib_get_got_by_pc(CORE_ADDR addr)720 pa64_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
745 CORE_ADDR
pa64_solib_get_solib_by_pc(CORE_ADDR addr)746 pa64_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
768 static void
pa64_sharedlibrary_info_command(char * ignore,int from_tty)769 pa64_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
817 static void
pa64_solib_sharedlibrary_command(char * args,int from_tty)818 pa64_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
827 char *
pa64_solib_address(CORE_ADDR addr)828 pa64_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
851 void
pa64_solib_restart(void)852 pa64_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
882 void
_initialize_pa64_solib(void)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\
894 If \"on\", symbols from all shared object libraries will be loaded\n\
895 automatically when the inferior begins execution, when the dynamic linker\n\
896 informs gdb that a new library has been loaded, or when attaching to the\n\
897 inferior. 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\
905 When shared library autoloading is enabled, new libraries will be loaded\n\
906 only until the total size of shared library symbols exceeds this\n\
907 threshold 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. */
925 CORE_ADDR
so_lib_thread_start_addr(struct so_list * so)926 so_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
938 static int
read_dld_descriptor(struct target_ops * target,int readsyms)939 read_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
1007 static int
read_dynamic_info(asection * dyninfo_sect,dld_cache_t * dld_cache_p)1008 read_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
1089 static void *
pa64_target_read_memory(void * buffer,CORE_ADDR ptr,size_t bufsiz,int ident)1090 pa64_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
1104 static void
add_to_solist(int from_tty,char * dll_path,int readsyms,struct load_module_desc * load_module_desc_p,CORE_ADDR load_module_desc_addr,struct target_ops * target)1105 add_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
1211 static CORE_ADDR
bfd_lookup_symbol(bfd * abfd,char * symname)1212 bfd_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