1 /* Handle AIX5 shared libraries for GDB, the GNU Debugger.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include <sys/types.h>
27 #include "gdb_string.h"
28 #include <sys/param.h>
30 #include <sys/procfs.h>
32 #include "elf/external.h"
42 #include "gdb_regex.h"
50 /* Link map info to include in an allocated so_list entry */
62 CORE_ADDR addr
; /* base address */
63 CORE_ADDR size
; /* size of mapped object */
64 CORE_ADDR offset
; /* offset into mapped object */
65 long flags
; /* MA_ protection and attribute flags */
66 CORE_ADDR gp
; /* global pointer value */
68 char *mapname
; /* name in /proc/pid/object */
69 char *pathname
; /* full pathname to object */
70 char *membername
; /* member name in archive file */
73 /* List of symbols in the dynamic linker where GDB can try to place
74 a breakpoint to monitor shared library events. */
76 static char *solib_break_names
[] =
82 static void aix5_relocate_main_executable (void);
88 bfd_lookup_symbol -- lookup the value for a specific symbol
92 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
96 An expensive way to lookup the value of a single symbol for
97 bfd's that are only temporary anyway. This is used by the
98 shared library support to find the address of the debugger
99 interface structures in the shared library.
101 Note that 0 is specifically allowed as an error return (no
106 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
108 unsigned int storage_needed
;
110 asymbol
**symbol_table
;
111 unsigned int number_of_symbols
;
113 struct cleanup
*back_to
;
114 CORE_ADDR symaddr
= 0;
116 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
118 if (storage_needed
> 0)
120 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
121 back_to
= make_cleanup (xfree
, symbol_table
);
122 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
124 for (i
= 0; i
< number_of_symbols
; i
++)
126 sym
= *symbol_table
++;
127 if (strcmp (sym
->name
, symname
) == 0)
129 /* Bfd symbols are section relative. */
130 symaddr
= sym
->value
+ sym
->section
->vma
;
134 do_cleanups (back_to
);
140 /* Look for the symbol in the dynamic string table too. */
142 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
143 /* FIXME: This problem should be addressed in BFD. */
144 #define REASONABLE_LIMIT 0x400000
145 if (storage_needed
> REASONABLE_LIMIT
)
146 storage_needed
= REASONABLE_LIMIT
;
148 if (storage_needed
> 0)
150 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
151 back_to
= make_cleanup (xfree
, symbol_table
);
152 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
154 for (i
= 0; i
< number_of_symbols
; i
++)
156 sym
= *symbol_table
++;
157 if (strcmp (sym
->name
, symname
) == 0)
159 /* Bfd symbols are section relative. */
160 symaddr
= sym
->value
+ sym
->section
->vma
;
164 do_cleanups (back_to
);
171 /* Read /proc/PID/map and build a list of shared objects such that
172 the pr_mflags value AND'd with MATCH_MASK is equal to MATCH_VAL.
173 This gives us a convenient way to find all of the mappings that
174 don't belong to the main executable or vice versa. Here are
175 some of the possibilities:
177 - Fetch all mappings:
180 - Fetch all mappings except for main executable:
181 MATCH_MASK: MA_MAINEXEC
183 - Fetch only main executable:
184 MATCH_MASK: MA_MAINEXEC
185 MATCH_VAL: MA_MAINEXEC
187 A cleanup chain for the list allocations done by this function should
188 be established prior to calling build_so_list_from_mapfile(). */
190 static struct so_list
*
191 build_so_list_from_mapfile (int pid
, long match_mask
, long match_val
)
196 struct so_list
*sos
= NULL
;
199 int mapbuf_allocation_size
= 8192;
200 char map_pathname
[64];
203 /* Open the map file */
205 xasprintf (map_pathname
, "/proc/%d/map", pid
);
206 map_fd
= open (map_pathname
, O_RDONLY
);
210 /* Read the entire map file in */
216 mapbuf_allocation_size
*= 2;
217 lseek (map_fd
, 0, SEEK_SET
);
219 mapbuf
= xmalloc (mapbuf_allocation_size
);
220 mapbuf_size
= read (map_fd
, mapbuf
, mapbuf_allocation_size
);
224 /* FIXME: This warrants an error or a warning of some sort */
227 } while (mapbuf_size
== mapbuf_allocation_size
);
232 for (prmap
= (struct prmap
*) mapbuf
;
233 (char *) prmap
< mapbuf
+ mapbuf_size
;
236 char *mapname
, *pathname
, *membername
;
238 enum maptype maptype
;
240 if (prmap
->pr_size
== 0)
243 /* Skip to the next entry if there's no path associated with the
244 map, unless we're looking for the kernel text region, in which
245 case it's okay if there's no path. */
246 if ((prmap
->pr_pathoff
== 0 || prmap
->pr_pathoff
>= mapbuf_size
)
247 && ((match_mask
& MA_KERNTEXT
) == 0))
250 /* Skip to the next entry if our match conditions don't hold. */
251 if ((prmap
->pr_mflags
& match_mask
) != match_val
)
254 mapname
= prmap
->pr_mapname
;
255 if (prmap
->pr_pathoff
== 0)
262 pathname
= mapbuf
+ prmap
->pr_pathoff
;
263 membername
= pathname
+ strlen (pathname
) + 1;
266 for (sop
= sos
; sop
!= NULL
; sop
= sop
->next
)
267 if (strcmp (pathname
, sop
->lm_info
->pathname
) == 0
268 && strcmp (membername
, sop
->lm_info
->membername
) == 0)
273 sop
= xcalloc (sizeof (struct so_list
), 1);
274 make_cleanup (xfree
, sop
);
275 sop
->lm_info
= xcalloc (sizeof (struct lm_info
), 1);
276 make_cleanup (xfree
, sop
->lm_info
);
277 sop
->lm_info
->mapname
= xstrdup (mapname
);
278 make_cleanup (xfree
, sop
->lm_info
->mapname
);
279 /* FIXME: Eliminate the pathname field once length restriction
280 is lifted on so_name and so_original_name. */
281 sop
->lm_info
->pathname
= xstrdup (pathname
);
282 make_cleanup (xfree
, sop
->lm_info
->pathname
);
283 sop
->lm_info
->membername
= xstrdup (membername
);
284 make_cleanup (xfree
, sop
->lm_info
->membername
);
286 strncpy (sop
->so_name
, pathname
, SO_NAME_MAX_PATH_SIZE
- 1);
287 sop
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
288 strcpy (sop
->so_original_name
, sop
->so_name
);
294 maptype
= (prmap
->pr_mflags
& MA_WRITE
) ? MT_READWRITE
: MT_READONLY
;
295 sop
->lm_info
->mapping
[maptype
].addr
= (CORE_ADDR
) prmap
->pr_vaddr
;
296 sop
->lm_info
->mapping
[maptype
].size
= prmap
->pr_size
;
297 sop
->lm_info
->mapping
[maptype
].offset
= prmap
->pr_off
;
298 sop
->lm_info
->mapping
[maptype
].flags
= prmap
->pr_mflags
;
299 sop
->lm_info
->mapping
[maptype
].gp
= (CORE_ADDR
) prmap
->pr_gp
;
310 open_symbol_file_object
314 void open_symbol_file_object (void *from_tty)
318 If no open symbol file, attempt to locate and open the main symbol
321 If FROM_TTYP dereferences to a non-zero integer, allow messages to
322 be printed. This parameter is a pointer rather than an int because
323 open_symbol_file_object() is called via catch_errors() and
324 catch_errors() requires a pointer argument. */
327 open_symbol_file_object (void *from_ttyp
)
329 CORE_ADDR lm
, l_name
;
332 int from_tty
= *(int *)from_ttyp
;
333 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
336 sos
= build_so_list_from_mapfile (PIDGET (inferior_pid
),
337 MA_MAINEXEC
, MA_MAINEXEC
);
342 warning ("Could not find name of main executable in map file");
346 symbol_file_command (sos
->lm_info
->pathname
, from_tty
);
348 do_cleanups (old_chain
);
350 aix5_relocate_main_executable ();
357 aix5_current_sos -- build a list of currently loaded shared objects
361 struct so_list *aix5_current_sos ()
365 Build a list of `struct so_list' objects describing the shared
366 objects currently loaded in the inferior. This list does not
367 include an entry for the main executable file.
369 Note that we only gather information directly available from the
370 inferior --- we don't examine any of the shared library files
371 themselves. The declaration of `struct so_list' says which fields
372 we provide values for. */
374 static struct so_list
*
375 aix5_current_sos (void)
377 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
380 /* Fetch the list of mappings, excluding the main executable. */
381 sos
= build_so_list_from_mapfile (PIDGET (inferior_pid
), MA_MAINEXEC
, 0);
383 /* Reverse the list; it looks nicer when we print it if the mappings
384 are in the same order as in the map file. */
387 struct so_list
*next
= sos
->next
;
392 struct so_list
*prev
= sos
;
399 discard_cleanups (old_chain
);
404 /* Return 1 if PC lies in the dynamic symbol resolution code of the
407 static CORE_ADDR interp_text_sect_low
;
408 static CORE_ADDR interp_text_sect_high
;
409 static CORE_ADDR interp_plt_sect_low
;
410 static CORE_ADDR interp_plt_sect_high
;
413 aix5_in_dynsym_resolve_code (CORE_ADDR pc
)
415 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
416 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
417 || in_plt_section (pc
, NULL
));
424 enable_break -- arrange for dynamic linker to hit breakpoint
428 int enable_break (void)
432 The dynamic linkers has, as part of its debugger interface, support
433 for arranging for the inferior to hit a breakpoint after mapping in
434 the shared libraries. This function enables that breakpoint.
443 struct minimal_symbol
*msymbol
;
445 asection
*interp_sect
;
447 /* First, remove all the solib event breakpoints. Their addresses
448 may have changed since the last time we ran the program. */
449 remove_solib_event_breakpoints ();
451 interp_text_sect_low
= interp_text_sect_high
= 0;
452 interp_plt_sect_low
= interp_plt_sect_high
= 0;
454 /* Find the .interp section; if not found, warn the user and drop
455 into the old breakpoint at symbol code. */
456 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
459 unsigned int interp_sect_size
;
463 CORE_ADDR sym_addr
= 0;
465 /* Read the contents of the .interp section into a local buffer;
466 the contents specify the dynamic linker this program uses. */
467 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
468 buf
= alloca (interp_sect_size
);
469 bfd_get_section_contents (exec_bfd
, interp_sect
,
470 buf
, 0, interp_sect_size
);
472 /* Now we need to figure out where the dynamic linker was
473 loaded so that we can load its symbols and place a breakpoint
474 in the dynamic linker itself.
476 This address is stored on the stack. However, I've been unable
477 to find any magic formula to find it for Solaris (appears to
478 be trivial on GNU/Linux). Therefore, we have to try an alternate
479 mechanism to find the dynamic linker's base address. */
480 tmp_bfd
= bfd_openr (buf
, gnutarget
);
484 /* Make sure the dynamic linker's really a useful object. */
485 if (!bfd_check_format (tmp_bfd
, bfd_object
))
487 warning ("Unable to grok dynamic linker %s as an object file", buf
);
492 /* We find the dynamic linker's base address by examining the
493 current pc (which point at the entry point for the dynamic
494 linker) and subtracting the offset of the entry point. */
495 load_addr
= read_pc () - tmp_bfd
->start_address
;
497 /* Record the relocated start and end address of the dynamic linker
498 text and plt section for aix5_in_dynsym_resolve_code. */
499 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
502 interp_text_sect_low
=
503 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
504 interp_text_sect_high
=
505 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
507 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
510 interp_plt_sect_low
=
511 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
512 interp_plt_sect_high
=
513 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
516 /* Now try to set a breakpoint in the dynamic linker. */
517 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
519 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
524 /* We're done with the temporary bfd. */
529 create_solib_event_breakpoint (load_addr
+ sym_addr
);
533 /* For whatever reason we couldn't set a breakpoint in the dynamic
534 linker. Warn and drop into the old code. */
536 warning ("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code.");
539 /* Nothing good happened. */
549 special_symbol_handling -- additional shared library symbol handling
553 void special_symbol_handling ()
557 Once the symbols from a shared object have been loaded in the usual
558 way, we are called to do any system specific symbol handling that
564 aix5_special_symbol_handling (void)
566 /* Nothing needed (yet) for AIX5. */
569 #define SECTMAPMASK (~ (CORE_ADDR) 0x03ffffff)
572 aix5_relocate_main_executable (void)
575 struct section_offsets
*new_offsets
;
578 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
580 /* Fetch the mappings for the main executable from the map file. */
581 so
= build_so_list_from_mapfile (PIDGET (inferior_pid
),
582 MA_MAINEXEC
, MA_MAINEXEC
);
584 /* Make sure we actually have some mappings to work with. */
587 warning ("Could not find main executable in map file");
588 do_cleanups (old_chain
);
592 /* Allocate the data structure which'll contain the new offsets to
593 relocate by. Initialize it so it contains the current offsets. */
594 new_offsets
= xcalloc (sizeof (struct section_offsets
),
595 symfile_objfile
->num_sections
);
596 make_cleanup (xfree
, new_offsets
);
597 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
598 new_offsets
->offsets
[i
] = ANOFFSET (symfile_objfile
->section_offsets
, i
);
600 /* Iterate over the mappings in the main executable and compute
601 the new offset value as appropriate. */
602 for (i
= 0; i
< MT_LAST
; i
++)
604 CORE_ADDR increment
= 0;
605 struct obj_section
*sect
;
606 bfd
*obfd
= symfile_objfile
->obfd
;
608 ALL_OBJFILE_OSECTIONS (symfile_objfile
, sect
)
610 int flags
= bfd_get_section_flags (obfd
, sect
->the_bfd_section
);
611 if (flags
& SEC_ALLOC
)
613 if (((so
->lm_info
->mapping
[i
].flags
& MA_WRITE
) == 0)
614 == ((flags
& SEC_READONLY
) != 0))
616 int idx
= sect
->the_bfd_section
->index
;
619 increment
= so
->lm_info
->mapping
[i
].addr
620 - (bfd_section_vma (obfd
, sect
->the_bfd_section
)
623 if (increment
!= ANOFFSET (new_offsets
, idx
))
625 new_offsets
->offsets
[idx
] = increment
;
633 /* If any of the offsets have changed, then relocate the objfile. */
635 objfile_relocate (symfile_objfile
, new_offsets
);
637 /* Free up all the space we've allocated. */
638 do_cleanups (old_chain
);
645 aix5_solib_create_inferior_hook -- shared library startup support
649 void aix5_solib_create_inferior_hook()
653 When gdb starts up the inferior, it nurses it along (through the
654 shell) until it is ready to execute it's first instruction. At this
655 point, this function gets called via expansion of the macro
656 SOLIB_CREATE_INFERIOR_HOOK.
658 For AIX5 executables, this first instruction is the first
659 instruction in the dynamic linker (for dynamically linked
660 executables) or the instruction at "start" for statically linked
661 executables. For dynamically linked executables, the system
662 first exec's libc.so.N, which contains the dynamic linker,
663 and starts it running. The dynamic linker maps in any needed
664 shared libraries, maps in the actual user executable, and then
665 jumps to "start" in the user executable.
670 aix5_solib_create_inferior_hook (void)
672 aix5_relocate_main_executable ();
674 if (!enable_break ())
676 warning ("shared library handler failed to enable breakpoint");
682 aix5_clear_solib (void)
687 aix5_free_so (struct so_list
*so
)
689 xfree (so
->lm_info
->mapname
);
690 xfree (so
->lm_info
->pathname
);
691 xfree (so
->lm_info
->membername
);
696 aix5_relocate_section_addresses (struct so_list
*so
,
697 struct section_table
*sec
)
699 int flags
= bfd_get_section_flags (sec
->bfd
, sec
->the_bfd_section
);
701 if (flags
& SEC_ALLOC
)
703 int idx
= (flags
& SEC_READONLY
) ? MT_READONLY
: MT_READWRITE
;
704 CORE_ADDR addr
= so
->lm_info
->mapping
[idx
].addr
;
707 sec
->endaddr
+= addr
;
711 /* Find the global pointer for the given function address ADDR. */
714 aix5_find_global_pointer (CORE_ADDR addr
)
716 struct so_list
*sos
, *so
;
717 CORE_ADDR global_pointer
= 0;
718 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
720 sos
= build_so_list_from_mapfile (PIDGET (inferior_pid
), 0, 0);
722 for (so
= sos
; so
!= NULL
; so
= so
->next
)
724 if (so
->lm_info
->mapping
[MT_READONLY
].addr
<= addr
725 && addr
<= so
->lm_info
->mapping
[MT_READONLY
].addr
726 + so
->lm_info
->mapping
[MT_READONLY
].size
)
728 global_pointer
= so
->lm_info
->mapping
[MT_READWRITE
].gp
;
733 do_cleanups (old_chain
);
735 return global_pointer
;
738 /* Find the execute-only kernel region known as the gate page. This
739 page is where the signal trampoline lives. It may be found by
740 querying the map file and looking for the MA_KERNTEXT flag. */
742 aix5_find_gate_addresses (CORE_ADDR
*start
, CORE_ADDR
*end
)
745 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
747 /* Fetch the mappings for the main executable from the map file. */
748 so
= build_so_list_from_mapfile (PIDGET (inferior_pid
),
749 MA_KERNTEXT
, MA_KERNTEXT
);
751 /* Make sure we actually have some mappings to work with. */
754 warning ("Could not find gate page in map file");
757 do_cleanups (old_chain
);
761 /* There should only be on kernel mapping for the gate page and
762 it'll be in the read-only (even though it's execute-only)
763 mapping in the lm_info struct. */
765 *start
= so
->lm_info
->mapping
[MT_READONLY
].addr
;
766 *end
= *start
+ so
->lm_info
->mapping
[MT_READONLY
].size
;
768 /* Free up all the space we've allocated. */
769 do_cleanups (old_chain
);
772 /* From ia64-tdep.c. FIXME: If we end up using this for rs6000 too,
773 we'll need to make the names match. */
774 extern CORE_ADDR (*native_find_global_pointer
) (CORE_ADDR
);
776 /* From ia64-aix-tdep.c. Hook for finding the starting and
777 ending gate page addresses. The only reason that this hook
778 is in this file is because this is where the map file reading
780 extern void (*aix5_find_gate_addresses_hook
) (CORE_ADDR
*, CORE_ADDR
*);
782 static struct target_so_ops aix5_so_ops
;
785 _initialize_aix5_solib (void)
787 aix5_so_ops
.relocate_section_addresses
= aix5_relocate_section_addresses
;
788 aix5_so_ops
.free_so
= aix5_free_so
;
789 aix5_so_ops
.clear_solib
= aix5_clear_solib
;
790 aix5_so_ops
.solib_create_inferior_hook
= aix5_solib_create_inferior_hook
;
791 aix5_so_ops
.special_symbol_handling
= aix5_special_symbol_handling
;
792 aix5_so_ops
.current_sos
= aix5_current_sos
;
793 aix5_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
794 aix5_so_ops
.in_dynsym_resolve_code
= aix5_in_dynsym_resolve_code
;
796 native_find_global_pointer
= aix5_find_global_pointer
;
797 aix5_find_gate_addresses_hook
= aix5_find_gate_addresses
;
799 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
800 current_target_so_ops
= &aix5_so_ops
;