1 /* Handle AIX5 shared libraries for GDB, the GNU Debugger.
2 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
3 2001, 2007 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include <sys/types.h>
26 #include "gdb_string.h"
27 #include <sys/param.h>
29 #include <sys/procfs.h>
31 #include "elf/external.h"
41 #include "gdb_regex.h"
49 /* Link map info to include in an allocated so_list entry */
53 int nmappings
; /* number of mappings */
56 CORE_ADDR addr
; /* base address */
57 CORE_ADDR size
; /* size of mapped object */
58 CORE_ADDR offset
; /* offset into mapped object */
59 long flags
; /* MA_ protection and attribute flags */
60 CORE_ADDR gp
; /* global pointer value */
62 char *mapname
; /* name in /proc/pid/object */
63 char *pathname
; /* full pathname to object */
64 char *membername
; /* member name in archive file */
67 /* List of symbols in the dynamic linker where GDB can try to place
68 a breakpoint to monitor shared library events. */
70 static char *solib_break_names
[] =
76 static void aix5_relocate_main_executable (void);
82 bfd_lookup_symbol -- lookup the value for a specific symbol
86 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
90 An expensive way to lookup the value of a single symbol for
91 bfd's that are only temporary anyway. This is used by the
92 shared library support to find the address of the debugger
93 interface structures in the shared library.
95 Note that 0 is specifically allowed as an error return (no
100 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
104 asymbol
**symbol_table
;
105 unsigned int number_of_symbols
;
107 struct cleanup
*back_to
;
108 CORE_ADDR symaddr
= 0;
110 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
112 if (storage_needed
> 0)
114 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
115 back_to
= make_cleanup (xfree
, symbol_table
);
116 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
118 for (i
= 0; i
< number_of_symbols
; i
++)
120 sym
= *symbol_table
++;
121 if (strcmp (sym
->name
, symname
) == 0)
123 /* Bfd symbols are section relative. */
124 symaddr
= sym
->value
+ sym
->section
->vma
;
128 do_cleanups (back_to
);
134 /* Look for the symbol in the dynamic string table too. */
136 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
138 if (storage_needed
> 0)
140 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
141 back_to
= make_cleanup (xfree
, symbol_table
);
142 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
144 for (i
= 0; i
< number_of_symbols
; i
++)
146 sym
= *symbol_table
++;
147 if (strcmp (sym
->name
, symname
) == 0)
149 /* Bfd symbols are section relative. */
150 symaddr
= sym
->value
+ sym
->section
->vma
;
154 do_cleanups (back_to
);
161 /* Read /proc/PID/map and build a list of shared objects such that
162 the pr_mflags value AND'd with MATCH_MASK is equal to MATCH_VAL.
163 This gives us a convenient way to find all of the mappings that
164 don't belong to the main executable or vice versa. Here are
165 some of the possibilities:
167 - Fetch all mappings:
170 - Fetch all mappings except for main executable:
171 MATCH_MASK: MA_MAINEXEC
173 - Fetch only main executable:
174 MATCH_MASK: MA_MAINEXEC
175 MATCH_VAL: MA_MAINEXEC
177 A cleanup chain for the list allocations done by this function should
178 be established prior to calling build_so_list_from_mapfile(). */
180 static struct so_list
*
181 build_so_list_from_mapfile (int pid
, long match_mask
, long match_val
)
186 struct so_list
*sos
= NULL
;
189 int mapbuf_allocation_size
= 8192;
193 /* Open the map file */
195 map_pathname
= xstrprintf ("/proc/%d/map", pid
);
196 map_fd
= open (map_pathname
, O_RDONLY
);
197 xfree (map_pathname
);
201 /* Read the entire map file in */
207 mapbuf_allocation_size
*= 2;
208 lseek (map_fd
, 0, SEEK_SET
);
210 mapbuf
= xmalloc (mapbuf_allocation_size
);
211 mapbuf_size
= read (map_fd
, mapbuf
, mapbuf_allocation_size
);
215 /* FIXME: This warrants an error or a warning of some sort */
218 } while (mapbuf_size
== mapbuf_allocation_size
);
223 for (prmap
= (struct prmap
*) mapbuf
;
224 (char *) prmap
< mapbuf
+ mapbuf_size
;
227 char *mapname
, *pathname
, *membername
;
231 if (prmap
->pr_size
== 0)
234 /* Skip to the next entry if there's no path associated with the
235 map, unless we're looking for the kernel text region, in which
236 case it's okay if there's no path. */
237 if ((prmap
->pr_pathoff
== 0 || prmap
->pr_pathoff
>= mapbuf_size
)
238 && ((match_mask
& MA_KERNTEXT
) == 0))
241 /* Skip to the next entry if our match conditions don't hold. */
242 if ((prmap
->pr_mflags
& match_mask
) != match_val
)
245 mapname
= prmap
->pr_mapname
;
246 if (prmap
->pr_pathoff
== 0)
253 pathname
= mapbuf
+ prmap
->pr_pathoff
;
254 membername
= pathname
+ strlen (pathname
) + 1;
257 for (sop
= sos
; sop
!= NULL
; sop
= sop
->next
)
258 if (strcmp (pathname
, sop
->lm_info
->pathname
) == 0
259 && strcmp (membername
, sop
->lm_info
->membername
) == 0)
264 sop
= xcalloc (1, sizeof (struct so_list
));
265 make_cleanup (xfree
, sop
);
266 sop
->lm_info
= xcalloc (1, sizeof (struct lm_info
));
267 make_cleanup (xfree
, sop
->lm_info
);
268 sop
->lm_info
->mapname
= xstrdup (mapname
);
269 make_cleanup (xfree
, sop
->lm_info
->mapname
);
270 /* FIXME: Eliminate the pathname field once length restriction
271 is lifted on so_name and so_original_name. */
272 sop
->lm_info
->pathname
= xstrdup (pathname
);
273 make_cleanup (xfree
, sop
->lm_info
->pathname
);
274 sop
->lm_info
->membername
= xstrdup (membername
);
275 make_cleanup (xfree
, sop
->lm_info
->membername
);
277 strncpy (sop
->so_name
, pathname
, SO_NAME_MAX_PATH_SIZE
- 1);
278 sop
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
279 strcpy (sop
->so_original_name
, sop
->so_name
);
285 mapidx
= sop
->lm_info
->nmappings
;
286 sop
->lm_info
->nmappings
+= 1;
287 sop
->lm_info
->mapping
288 = xrealloc (sop
->lm_info
->mapping
,
289 sop
->lm_info
->nmappings
* sizeof (struct lm_mapping
));
290 sop
->lm_info
->mapping
[mapidx
].addr
= (CORE_ADDR
) prmap
->pr_vaddr
;
291 sop
->lm_info
->mapping
[mapidx
].size
= prmap
->pr_size
;
292 sop
->lm_info
->mapping
[mapidx
].offset
= prmap
->pr_off
;
293 sop
->lm_info
->mapping
[mapidx
].flags
= prmap
->pr_mflags
;
294 sop
->lm_info
->mapping
[mapidx
].gp
= (CORE_ADDR
) prmap
->pr_gp
;
305 open_symbol_file_object
309 void open_symbol_file_object (void *from_tty)
313 If no open symbol file, attempt to locate and open the main symbol
316 If FROM_TTYP dereferences to a non-zero integer, allow messages to
317 be printed. This parameter is a pointer rather than an int because
318 open_symbol_file_object() is called via catch_errors() and
319 catch_errors() requires a pointer argument. */
322 open_symbol_file_object (void *from_ttyp
)
324 CORE_ADDR lm
, l_name
;
327 int from_tty
= *(int *)from_ttyp
;
328 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
331 sos
= build_so_list_from_mapfile (PIDGET (inferior_ptid
),
332 MA_MAINEXEC
, MA_MAINEXEC
);
337 warning (_("Could not find name of main executable in map file"));
341 symbol_file_command (sos
->lm_info
->pathname
, from_tty
);
343 do_cleanups (old_chain
);
345 aix5_relocate_main_executable ();
352 aix5_current_sos -- build a list of currently loaded shared objects
356 struct so_list *aix5_current_sos ()
360 Build a list of `struct so_list' objects describing the shared
361 objects currently loaded in the inferior. This list does not
362 include an entry for the main executable file.
364 Note that we only gather information directly available from the
365 inferior --- we don't examine any of the shared library files
366 themselves. The declaration of `struct so_list' says which fields
367 we provide values for. */
369 static struct so_list
*
370 aix5_current_sos (void)
372 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
375 /* Fetch the list of mappings, excluding the main executable. */
376 sos
= build_so_list_from_mapfile (PIDGET (inferior_ptid
), MA_MAINEXEC
, 0);
378 /* Reverse the list; it looks nicer when we print it if the mappings
379 are in the same order as in the map file. */
382 struct so_list
*next
= sos
->next
;
387 struct so_list
*prev
= sos
;
394 discard_cleanups (old_chain
);
399 /* Return 1 if PC lies in the dynamic symbol resolution code of the
402 static CORE_ADDR interp_text_sect_low
;
403 static CORE_ADDR interp_text_sect_high
;
404 static CORE_ADDR interp_plt_sect_low
;
405 static CORE_ADDR interp_plt_sect_high
;
408 aix5_in_dynsym_resolve_code (CORE_ADDR pc
)
410 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
411 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
412 || in_plt_section (pc
, NULL
));
419 enable_break -- arrange for dynamic linker to hit breakpoint
423 int enable_break (void)
427 The dynamic linkers has, as part of its debugger interface, support
428 for arranging for the inferior to hit a breakpoint after mapping in
429 the shared libraries. This function enables that breakpoint.
438 struct minimal_symbol
*msymbol
;
440 asection
*interp_sect
;
442 /* First, remove all the solib event breakpoints. Their addresses
443 may have changed since the last time we ran the program. */
444 remove_solib_event_breakpoints ();
446 interp_text_sect_low
= interp_text_sect_high
= 0;
447 interp_plt_sect_low
= interp_plt_sect_high
= 0;
449 /* Find the .interp section; if not found, warn the user and drop
450 into the old breakpoint at symbol code. */
451 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
454 unsigned int interp_sect_size
;
458 CORE_ADDR sym_addr
= 0;
460 /* Read the contents of the .interp section into a local buffer;
461 the contents specify the dynamic linker this program uses. */
462 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
463 buf
= alloca (interp_sect_size
);
464 bfd_get_section_contents (exec_bfd
, interp_sect
,
465 buf
, 0, interp_sect_size
);
467 /* Now we need to figure out where the dynamic linker was
468 loaded so that we can load its symbols and place a breakpoint
469 in the dynamic linker itself.
471 This address is stored on the stack. However, I've been unable
472 to find any magic formula to find it for Solaris (appears to
473 be trivial on GNU/Linux). Therefore, we have to try an alternate
474 mechanism to find the dynamic linker's base address. */
475 tmp_bfd
= bfd_openr (buf
, gnutarget
);
479 /* Make sure the dynamic linker's really a useful object. */
480 if (!bfd_check_format (tmp_bfd
, bfd_object
))
482 warning (_("Unable to grok dynamic linker %s as an object file"), buf
);
487 /* We find the dynamic linker's base address by examining the
488 current pc (which point at the entry point for the dynamic
489 linker) and subtracting the offset of the entry point. */
490 load_addr
= read_pc () - tmp_bfd
->start_address
;
492 /* Record the relocated start and end address of the dynamic linker
493 text and plt section for aix5_in_dynsym_resolve_code. */
494 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
497 interp_text_sect_low
=
498 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
499 interp_text_sect_high
=
500 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
502 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
505 interp_plt_sect_low
=
506 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
507 interp_plt_sect_high
=
508 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
511 /* Now try to set a breakpoint in the dynamic linker. */
512 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
514 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
519 /* We're done with the temporary bfd. */
524 create_solib_event_breakpoint (load_addr
+ sym_addr
);
528 /* For whatever reason we couldn't set a breakpoint in the dynamic
529 linker. Warn and drop into the old code. */
531 warning (_("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code."));
534 /* Nothing good happened. */
544 special_symbol_handling -- additional shared library symbol handling
548 void special_symbol_handling ()
552 Once the symbols from a shared object have been loaded in the usual
553 way, we are called to do any system specific symbol handling that
559 aix5_special_symbol_handling (void)
561 /* Nothing needed (yet) for AIX5. */
564 /* On AIX5, the /proc/PID/map information is used to determine
565 the relocation offsets needed for relocating the main executable.
566 There is no problem determining which map entries correspond
567 to the main executable, because these will have the MA_MAINEXEC
568 flag set. The tricky part is determining which sections correspond
569 to which map entries. To date, the following approaches have
572 - Use the MA_WRITE attribute of pr_mflags to distinguish the read-only
573 mapping from the read/write mapping. (This assumes that there are
574 only two mappings for the main executable.) All writable sections
575 are associated with the read/write mapping and all non-writable
576 sections are associated with the read-only mapping.
578 This approach worked quite well until we came across executables
579 which didn't have a read-only mapping. Both mappings had the
580 same attributes represented in pr_mflags and it was impossible
583 - Use the pr_off field (which represents the offset into the
584 executable) to determine the section-to-mapping relationship.
585 Unfortunately, this approach doesn't work either, because the
586 offset value contained in the mapping is rounded down by some
587 moderately large power-of-2 value (4096 is a typical value).
588 A small (e.g. "Hello World") program will appear to have all
589 of its sections belonging to both mappings.
591 Also, the following approach has been considered, but dismissed:
593 - The section vma values typically look (something) like
594 0x00000001xxxxxxxx or 0x00000002xxxxxxxx. Furthermore, the
595 0x00000001xxxxxxxx values always belong to one mapping and
596 the 0x00000002xxxxxxxx values always belong to the other.
597 Thus it seems conceivable that GDB could use the bit patterns
598 in the upper portion (for some definition of "upper") in a
599 section's vma to help determine the section-to-mapping
602 This approach was dismissed because there is nothing to prevent
603 the linker from lumping the section vmas together in one large
604 contiguous space and still expecting the dynamic linker to
605 separate them and relocate them independently. Also, different
606 linkers have been observed to use different patterns for the
607 upper portions of the vma addresses and it isn't clear what the
608 mask ought to be for distinguishing these patterns.
610 The current (admittedly inelegant) approach uses a lookup
611 table which associates section names with the map index that
612 they're permitted to be in. This is inelegant because we are
613 making the following assumptions:
615 1) There will only be two mappings.
616 2) The relevant (i.e. main executable) mappings will always appear
617 in the same order in the map file.
618 3) The sections named in the table will always belong to the
620 4) The table completely enumerates all possible section names.
622 IMO, any of these deficiencies alone will normally be sufficient
623 to disqualify this approach, but I haven't been able to think of
624 a better way to do it.
626 map_index_vs_section_name_okay() is a predicate which returns
627 true iff the section name NAME is associated with the map index
628 IDX in its builtin table. Of course, there's no guarantee that
629 this association is actually valid... */
632 map_index_vs_section_name_okay (int idx
, const char *name
)
645 { ".rela.rodata", 0 },
647 { ".rela.ctors", 0 },
648 { ".rela.dtors", 0 },
650 { ".rela.sdata", 0 },
651 { ".rela.IA_64.pltoff", 0 },
655 { ".rel.AIX.pfdesc", 0 },
656 { ".rel.IA_64.pltoff", 0 },
663 { ".IA_64.unwind_info", 0 },
664 { ".IA_64.unwind", 0 },
665 { ".AIX.mustrel", 0 },
673 { ".IA_64.pltoff", 1 },
680 for (i
= 0; i
< sizeof (okay
) / sizeof (okay
[0]); i
++)
682 if (strcmp (name
, okay
[i
].name
) == 0)
683 return idx
== okay
[i
].idx
;
686 warning (_("Ignoring section %s when relocating the executable."),
691 #define SECTMAPMASK (~ (CORE_ADDR) 0x03ffffff)
694 aix5_relocate_main_executable (void)
697 struct section_offsets
*new_offsets
;
700 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
702 /* Fetch the mappings for the main executable from the map file. */
703 so
= build_so_list_from_mapfile (PIDGET (inferior_ptid
),
704 MA_MAINEXEC
, MA_MAINEXEC
);
706 /* Make sure we actually have some mappings to work with. */
709 warning (_("Could not find main executable in map file"));
710 do_cleanups (old_chain
);
714 /* Allocate the data structure which'll contain the new offsets to
715 relocate by. Initialize it so it contains the current offsets. */
716 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
717 sizeof (struct section_offsets
));
718 make_cleanup (xfree
, new_offsets
);
719 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
720 new_offsets
->offsets
[i
] = ANOFFSET (symfile_objfile
->section_offsets
, i
);
722 /* Iterate over the mappings in the main executable and compute
723 the new offset value as appropriate. */
724 for (i
= 0; i
< so
->lm_info
->nmappings
; i
++)
726 CORE_ADDR increment
= 0;
727 struct obj_section
*sect
;
728 bfd
*obfd
= symfile_objfile
->obfd
;
729 struct lm_mapping
*mapping
= &so
->lm_info
->mapping
[i
];
731 ALL_OBJFILE_OSECTIONS (symfile_objfile
, sect
)
733 int flags
= bfd_get_section_flags (obfd
, sect
->the_bfd_section
);
734 if (flags
& SEC_ALLOC
)
736 file_ptr filepos
= sect
->the_bfd_section
->filepos
;
737 if (map_index_vs_section_name_okay (i
,
738 bfd_get_section_name (obfd
, sect
->the_bfd_section
)))
740 int idx
= sect
->the_bfd_section
->index
;
743 increment
= mapping
->addr
744 - (bfd_section_vma (obfd
, sect
->the_bfd_section
)
747 if (increment
!= ANOFFSET (new_offsets
, idx
))
749 new_offsets
->offsets
[idx
] = increment
;
757 /* If any of the offsets have changed, then relocate the objfile. */
759 objfile_relocate (symfile_objfile
, new_offsets
);
761 /* Free up all the space we've allocated. */
762 do_cleanups (old_chain
);
769 aix5_solib_create_inferior_hook -- shared library startup support
773 void aix5_solib_create_inferior_hook ()
777 When gdb starts up the inferior, it nurses it along (through the
778 shell) until it is ready to execute it's first instruction. At this
779 point, this function gets called via expansion of the macro
780 SOLIB_CREATE_INFERIOR_HOOK.
782 For AIX5 executables, this first instruction is the first
783 instruction in the dynamic linker (for dynamically linked
784 executables) or the instruction at "start" for statically linked
785 executables. For dynamically linked executables, the system
786 first exec's libc.so.N, which contains the dynamic linker,
787 and starts it running. The dynamic linker maps in any needed
788 shared libraries, maps in the actual user executable, and then
789 jumps to "start" in the user executable.
794 aix5_solib_create_inferior_hook (void)
796 aix5_relocate_main_executable ();
798 if (!enable_break ())
800 warning (_("shared library handler failed to enable breakpoint"));
806 aix5_clear_solib (void)
811 aix5_free_so (struct so_list
*so
)
813 xfree (so
->lm_info
->mapname
);
814 xfree (so
->lm_info
->pathname
);
815 xfree (so
->lm_info
->membername
);
820 aix5_relocate_section_addresses (struct so_list
*so
,
821 struct section_table
*sec
)
823 int flags
= bfd_get_section_flags (sec
->bfd
, sec
->the_bfd_section
);
824 file_ptr filepos
= sec
->the_bfd_section
->filepos
;
826 if (flags
& SEC_ALLOC
)
831 for (idx
= 0; idx
< so
->lm_info
->nmappings
; idx
++)
833 struct lm_mapping
*mapping
= &so
->lm_info
->mapping
[idx
];
834 if (mapping
->offset
<= filepos
835 && filepos
<= mapping
->offset
+ mapping
->size
)
839 if (idx
>= so
->lm_info
->nmappings
)
840 internal_error (__FILE__
, __LINE__
,
841 _("aix_relocate_section_addresses: Can't find mapping for section %s"),
842 bfd_get_section_name (sec
->bfd
, sec
->the_bfd_section
));
844 addr
= so
->lm_info
->mapping
[idx
].addr
;
847 sec
->endaddr
+= addr
;
851 /* Find the global pointer for the given function address ADDR. */
854 aix5_find_global_pointer (CORE_ADDR addr
)
856 struct so_list
*sos
, *so
;
857 CORE_ADDR global_pointer
= 0;
858 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
860 sos
= build_so_list_from_mapfile (PIDGET (inferior_ptid
), 0, 0);
862 for (so
= sos
; so
!= NULL
; so
= so
->next
)
865 for (idx
= 0; idx
< so
->lm_info
->nmappings
; idx
++)
866 if (so
->lm_info
->mapping
[idx
].addr
<= addr
867 && addr
<= so
->lm_info
->mapping
[idx
].addr
868 + so
->lm_info
->mapping
[idx
].size
)
873 if (idx
< so
->lm_info
->nmappings
)
875 /* Look for a non-zero global pointer in the current set of
877 for (idx
= 0; idx
< so
->lm_info
->nmappings
; idx
++)
878 if (so
->lm_info
->mapping
[idx
].gp
!= 0)
880 global_pointer
= so
->lm_info
->mapping
[idx
].gp
;
883 /* Get out regardless of whether we found one or not. Mappings
884 don't overlap, so it would be pointless to continue. */
889 do_cleanups (old_chain
);
891 return global_pointer
;
894 /* Find the execute-only kernel region known as the gate page. This
895 page is where the signal trampoline lives. It may be found by
896 querying the map file and looking for the MA_KERNTEXT flag. */
898 aix5_find_gate_addresses (CORE_ADDR
*start
, CORE_ADDR
*end
)
901 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
903 /* Fetch the mappings for the main executable from the map file. */
904 so
= build_so_list_from_mapfile (PIDGET (inferior_ptid
),
905 MA_KERNTEXT
, MA_KERNTEXT
);
907 /* Make sure we actually have some mappings to work with. */
910 warning (_("Could not find gate page in map file"));
913 do_cleanups (old_chain
);
917 /* There should only be on kernel mapping for the gate page and
918 it'll be in the read-only (even though it's execute-only)
919 mapping in the lm_info struct. */
921 *start
= so
->lm_info
->mapping
[0].addr
;
922 *end
= *start
+ so
->lm_info
->mapping
[0].size
;
924 /* Free up all the space we've allocated. */
925 do_cleanups (old_chain
);
928 /* From ia64-tdep.c. FIXME: If we end up using this for rs6000 too,
929 we'll need to make the names match. */
930 extern CORE_ADDR (*native_find_global_pointer
) (CORE_ADDR
);
932 /* From ia64-aix-tdep.c. Hook for finding the starting and
933 ending gate page addresses. The only reason that this hook
934 is in this file is because this is where the map file reading
936 extern void (*aix5_find_gate_addresses_hook
) (CORE_ADDR
*, CORE_ADDR
*);
938 static struct target_so_ops aix5_so_ops
;
941 _initialize_aix5_solib (void)
943 aix5_so_ops
.relocate_section_addresses
= aix5_relocate_section_addresses
;
944 aix5_so_ops
.free_so
= aix5_free_so
;
945 aix5_so_ops
.clear_solib
= aix5_clear_solib
;
946 aix5_so_ops
.solib_create_inferior_hook
= aix5_solib_create_inferior_hook
;
947 aix5_so_ops
.special_symbol_handling
= aix5_special_symbol_handling
;
948 aix5_so_ops
.current_sos
= aix5_current_sos
;
949 aix5_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
950 aix5_so_ops
.in_dynsym_resolve_code
= aix5_in_dynsym_resolve_code
;
952 native_find_global_pointer
= aix5_find_global_pointer
;
953 aix5_find_gate_addresses_hook
= aix5_find_gate_addresses
;
955 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
956 current_target_so_ops
= &aix5_so_ops
;