1 /* Handle FR-V (FDPIC) shared libraries for GDB, the GNU Debugger.
3 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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
36 /* Flag which indicates whether internal debug messages should be printed. */
37 static int solib_frv_debug
;
39 /* FR-V pointers are four bytes wide. */
40 enum { FRV_PTR_SIZE
= 4 };
42 /* Representation of loadmap and related structs for the FR-V FDPIC ABI. */
44 /* External versions; the size and alignment of the fields should be
45 the same as those on the target. When loaded, the placement of
46 the bits in each field will be the same as on the target. */
47 typedef unsigned char ext_Elf32_Half
[2];
48 typedef unsigned char ext_Elf32_Addr
[4];
49 typedef unsigned char ext_Elf32_Word
[4];
51 struct ext_elf32_fdpic_loadseg
53 /* Core address to which the segment is mapped. */
55 /* VMA recorded in the program header. */
56 ext_Elf32_Addr p_vaddr
;
57 /* Size of this segment in memory. */
58 ext_Elf32_Word p_memsz
;
61 struct ext_elf32_fdpic_loadmap
{
62 /* Protocol version number, must be zero. */
63 ext_Elf32_Half version
;
64 /* Number of segments in this map. */
66 /* The actual memory map. */
67 struct ext_elf32_fdpic_loadseg segs
[1 /* nsegs, actually */];
70 /* Internal versions; the types are GDB types and the data in each
71 of the fields is (or will be) decoded from the external struct
72 for ease of consumption. */
73 struct int_elf32_fdpic_loadseg
75 /* Core address to which the segment is mapped. */
77 /* VMA recorded in the program header. */
79 /* Size of this segment in memory. */
83 struct int_elf32_fdpic_loadmap
{
84 /* Protocol version number, must be zero. */
86 /* Number of segments in this map. */
88 /* The actual memory map. */
89 struct int_elf32_fdpic_loadseg segs
[1 /* nsegs, actually */];
92 /* Given address LDMADDR, fetch and decode the loadmap at that address.
93 Return NULL if there is a problem reading the target memory or if
94 there doesn't appear to be a loadmap at the given address. The
95 allocated space (representing the loadmap) returned by this
96 function may be freed via a single call to xfree(). */
98 static struct int_elf32_fdpic_loadmap
*
99 fetch_loadmap (CORE_ADDR ldmaddr
)
101 struct ext_elf32_fdpic_loadmap ext_ldmbuf_partial
;
102 struct ext_elf32_fdpic_loadmap
*ext_ldmbuf
;
103 struct int_elf32_fdpic_loadmap
*int_ldmbuf
;
104 int ext_ldmbuf_size
, int_ldmbuf_size
;
105 int version
, seg
, nsegs
;
107 /* Fetch initial portion of the loadmap. */
108 if (target_read_memory (ldmaddr
, (char *) &ext_ldmbuf_partial
,
109 sizeof ext_ldmbuf_partial
))
111 /* Problem reading the target's memory. */
115 /* Extract the version. */
116 version
= extract_unsigned_integer (&ext_ldmbuf_partial
.version
,
117 sizeof ext_ldmbuf_partial
.version
);
120 /* We only handle version 0. */
124 /* Extract the number of segments. */
125 nsegs
= extract_unsigned_integer (&ext_ldmbuf_partial
.nsegs
,
126 sizeof ext_ldmbuf_partial
.nsegs
);
128 /* Allocate space for the complete (external) loadmap. */
129 ext_ldmbuf_size
= sizeof (struct ext_elf32_fdpic_loadmap
)
130 + (nsegs
- 1) * sizeof (struct ext_elf32_fdpic_loadseg
);
131 ext_ldmbuf
= xmalloc (ext_ldmbuf_size
);
133 /* Copy over the portion of the loadmap that's already been read. */
134 memcpy (ext_ldmbuf
, &ext_ldmbuf_partial
, sizeof ext_ldmbuf_partial
);
136 /* Read the rest of the loadmap from the target. */
137 if (target_read_memory (ldmaddr
+ sizeof ext_ldmbuf_partial
,
138 (char *) ext_ldmbuf
+ sizeof ext_ldmbuf_partial
,
139 ext_ldmbuf_size
- sizeof ext_ldmbuf_partial
))
141 /* Couldn't read rest of the loadmap. */
146 /* Allocate space into which to put information extract from the
147 external loadsegs. I.e, allocate the internal loadsegs. */
148 int_ldmbuf_size
= sizeof (struct int_elf32_fdpic_loadmap
)
149 + (nsegs
- 1) * sizeof (struct int_elf32_fdpic_loadseg
);
150 int_ldmbuf
= xmalloc (int_ldmbuf_size
);
152 /* Place extracted information in internal structs. */
153 int_ldmbuf
->version
= version
;
154 int_ldmbuf
->nsegs
= nsegs
;
155 for (seg
= 0; seg
< nsegs
; seg
++)
157 int_ldmbuf
->segs
[seg
].addr
158 = extract_unsigned_integer (&ext_ldmbuf
->segs
[seg
].addr
,
159 sizeof (ext_ldmbuf
->segs
[seg
].addr
));
160 int_ldmbuf
->segs
[seg
].p_vaddr
161 = extract_unsigned_integer (&ext_ldmbuf
->segs
[seg
].p_vaddr
,
162 sizeof (ext_ldmbuf
->segs
[seg
].p_vaddr
));
163 int_ldmbuf
->segs
[seg
].p_memsz
164 = extract_unsigned_integer (&ext_ldmbuf
->segs
[seg
].p_memsz
,
165 sizeof (ext_ldmbuf
->segs
[seg
].p_memsz
));
172 /* External link_map and elf32_fdpic_loadaddr struct definitions. */
174 typedef unsigned char ext_ptr
[4];
176 struct ext_elf32_fdpic_loadaddr
178 ext_ptr map
; /* struct elf32_fdpic_loadmap *map; */
179 ext_ptr got_value
; /* void *got_value; */
184 struct ext_elf32_fdpic_loadaddr l_addr
;
186 /* Absolute file name object was found in. */
187 ext_ptr l_name
; /* char *l_name; */
189 /* Dynamic section of the shared object. */
190 ext_ptr l_ld
; /* ElfW(Dyn) *l_ld; */
192 /* Chain of loaded objects. */
193 ext_ptr l_next
, l_prev
; /* struct link_map *l_next, *l_prev; */
196 /* Link map info to include in an allocated so_list entry */
200 /* The loadmap, digested into an easier to use form. */
201 struct int_elf32_fdpic_loadmap
*map
;
202 /* The GOT address for this link map entry. */
205 /* Cached dynamic symbol table and dynamic relocs initialized and
206 used only by find_canonical_descriptor_in_load_object().
208 Note: kevinb/2004-02-26: It appears that calls to
209 bfd_canonicalize_dynamic_reloc() will use the same symbols as
210 those supplied to the first call to this function. Therefore,
211 it's important to NOT free the asymbol ** data structure
212 supplied to the first call. Thus the caching of the dynamic
213 symbols (dyn_syms) is critical for correct operation. The
214 caching of the dynamic relocations could be dispensed with. */
216 arelent
**dyn_relocs
;
217 int dyn_reloc_count
; /* number of dynamic relocs. */
221 /* The load map, got value, etc. are not available from the chain
222 of loaded shared objects. ``main_executable_lm_info'' provides
223 a way to get at this information so that it doesn't need to be
224 frequently recomputed. Initialized by frv_relocate_main_executable(). */
225 static struct lm_info
*main_executable_lm_info
;
227 static void frv_relocate_main_executable (void);
228 static CORE_ADDR
main_got (void);
229 static int enable_break2 (void);
235 bfd_lookup_symbol -- lookup the value for a specific symbol
239 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
243 An expensive way to lookup the value of a single symbol for
244 bfd's that are only temporary anyway. This is used by the
245 shared library support to find the address of the debugger
246 interface structures in the shared library.
248 Note that 0 is specifically allowed as an error return (no
253 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
257 asymbol
**symbol_table
;
258 unsigned int number_of_symbols
;
260 struct cleanup
*back_to
;
261 CORE_ADDR symaddr
= 0;
263 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
265 if (storage_needed
> 0)
267 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
268 back_to
= make_cleanup (xfree
, symbol_table
);
269 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
271 for (i
= 0; i
< number_of_symbols
; i
++)
273 sym
= *symbol_table
++;
274 if (strcmp (sym
->name
, symname
) == 0)
276 /* Bfd symbols are section relative. */
277 symaddr
= sym
->value
+ sym
->section
->vma
;
281 do_cleanups (back_to
);
287 /* Look for the symbol in the dynamic string table too. */
289 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
291 if (storage_needed
> 0)
293 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
294 back_to
= make_cleanup (xfree
, symbol_table
);
295 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
297 for (i
= 0; i
< number_of_symbols
; i
++)
299 sym
= *symbol_table
++;
300 if (strcmp (sym
->name
, symname
) == 0)
302 /* Bfd symbols are section relative. */
303 symaddr
= sym
->value
+ sym
->section
->vma
;
307 do_cleanups (back_to
);
318 open_symbol_file_object
322 void open_symbol_file_object (void *from_tty)
326 If no open symbol file, attempt to locate and open the main symbol
329 If FROM_TTYP dereferences to a non-zero integer, allow messages to
330 be printed. This parameter is a pointer rather than an int because
331 open_symbol_file_object() is called via catch_errors() and
332 catch_errors() requires a pointer argument. */
335 open_symbol_file_object (void *from_ttyp
)
341 /* Cached value for lm_base(), below. */
342 static CORE_ADDR lm_base_cache
= 0;
344 /* Return the address from which the link map chain may be found. On
345 the FR-V, this may be found in a number of ways. Assuming that the
346 main executable has already been relocated, the easiest way to find
347 this value is to look up the address of _GLOBAL_OFFSET_TABLE_. A
348 pointer to the start of the link map will be located at the word found
349 at _GLOBAL_OFFSET_TABLE_ + 8. (This is part of the dynamic linker
350 reserve area mandated by the ABI.) */
355 struct minimal_symbol
*got_sym
;
357 char buf
[FRV_PTR_SIZE
];
359 /* If we already have a cached value, return it. */
361 return lm_base_cache
;
363 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
,
368 fprintf_unfiltered (gdb_stdlog
,
369 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
373 addr
= SYMBOL_VALUE_ADDRESS (got_sym
) + 8;
376 fprintf_unfiltered (gdb_stdlog
,
377 "lm_base: _GLOBAL_OFFSET_TABLE_ + 8 = %s\n",
378 hex_string_custom (addr
, 8));
380 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
382 lm_base_cache
= extract_unsigned_integer (buf
, sizeof buf
);
385 fprintf_unfiltered (gdb_stdlog
,
386 "lm_base: lm_base_cache = %s\n",
387 hex_string_custom (lm_base_cache
, 8));
389 return lm_base_cache
;
395 frv_current_sos -- build a list of currently loaded shared objects
399 struct so_list *frv_current_sos ()
403 Build a list of `struct so_list' objects describing the shared
404 objects currently loaded in the inferior. This list does not
405 include an entry for the main executable file.
407 Note that we only gather information directly available from the
408 inferior --- we don't examine any of the shared library files
409 themselves. The declaration of `struct so_list' says which fields
410 we provide values for. */
412 static struct so_list
*
413 frv_current_sos (void)
415 CORE_ADDR lm_addr
, mgot
;
416 struct so_list
*sos_head
= NULL
;
417 struct so_list
**sos_next_ptr
= &sos_head
;
421 /* Locate the address of the first link map struct. */
422 lm_addr
= lm_base ();
424 /* We have at least one link map entry. Fetch the the lot of them,
425 building the solist chain. */
428 struct ext_link_map lm_buf
;
432 fprintf_unfiltered (gdb_stdlog
,
433 "current_sos: reading link_map entry at %s\n",
434 hex_string_custom (lm_addr
, 8));
436 if (target_read_memory (lm_addr
, (char *) &lm_buf
, sizeof (lm_buf
)) != 0)
438 warning ("frv_current_sos: Unable to read link map entry. Shared object chain may be incomplete.");
443 = extract_unsigned_integer (&lm_buf
.l_addr
.got_value
,
444 sizeof (lm_buf
.l_addr
.got_value
));
445 /* If the got_addr is the same as mgotr, then we're looking at the
446 entry for the main executable. By convention, we don't include
447 this in the list of shared objects. */
448 if (got_addr
!= mgot
)
452 struct int_elf32_fdpic_loadmap
*loadmap
;
456 /* Fetch the load map address. */
457 addr
= extract_unsigned_integer (&lm_buf
.l_addr
.map
,
458 sizeof lm_buf
.l_addr
.map
);
459 loadmap
= fetch_loadmap (addr
);
462 warning ("frv_current_sos: Unable to fetch load map. Shared object chain may be incomplete.");
466 sop
= xcalloc (1, sizeof (struct so_list
));
467 sop
->lm_info
= xcalloc (1, sizeof (struct lm_info
));
468 sop
->lm_info
->map
= loadmap
;
469 sop
->lm_info
->got_value
= got_addr
;
470 /* Fetch the name. */
471 addr
= extract_unsigned_integer (&lm_buf
.l_name
,
472 sizeof (lm_buf
.l_name
));
473 target_read_string (addr
, &name_buf
, SO_NAME_MAX_PATH_SIZE
- 1,
477 fprintf_unfiltered (gdb_stdlog
, "current_sos: name = %s\n",
482 warning ("frv_current_sos: Can't read pathname for link map entry: %s\n",
483 safe_strerror (errcode
));
487 strncpy (sop
->so_name
, name_buf
, SO_NAME_MAX_PATH_SIZE
- 1);
488 sop
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
490 strcpy (sop
->so_original_name
, sop
->so_name
);
494 sos_next_ptr
= &sop
->next
;
497 lm_addr
= extract_unsigned_integer (&lm_buf
.l_next
, sizeof (lm_buf
.l_next
));
506 /* Return 1 if PC lies in the dynamic symbol resolution code of the
509 static CORE_ADDR interp_text_sect_low
;
510 static CORE_ADDR interp_text_sect_high
;
511 static CORE_ADDR interp_plt_sect_low
;
512 static CORE_ADDR interp_plt_sect_high
;
515 frv_in_dynsym_resolve_code (CORE_ADDR pc
)
517 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
518 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
519 || in_plt_section (pc
, NULL
));
522 /* Given a loadmap and an address, return the displacement needed
523 to relocate the address. */
526 displacement_from_map (struct int_elf32_fdpic_loadmap
*map
,
531 for (seg
= 0; seg
< map
->nsegs
; seg
++)
533 if (map
->segs
[seg
].p_vaddr
<= addr
534 && addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
536 return map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
543 /* Print a warning about being unable to set the dynamic linker
547 enable_break_failure_warning (void)
549 warning ("Unable to find dynamic linker breakpoint function.\n"
550 "GDB will be unable to debug shared library initializers\n"
551 "and track explicitly loaded dynamic code.");
558 enable_break -- arrange for dynamic linker to hit breakpoint
562 int enable_break (void)
566 The dynamic linkers has, as part of its debugger interface, support
567 for arranging for the inferior to hit a breakpoint after mapping in
568 the shared libraries. This function enables that breakpoint.
570 On the FR-V, using the shared library (FDPIC) ABI, the symbol
571 _dl_debug_addr points to the r_debug struct which contains
572 a field called r_brk. r_brk is the address of the function
573 descriptor upon which a breakpoint must be placed. Being a
574 function descriptor, we must extract the entry point in order
575 to set the breakpoint.
577 Our strategy will be to get the .interp section from the
578 executable. This section will provide us with the name of the
579 interpreter. We'll open the interpreter and then look up
580 the address of _dl_debug_addr. We then relocate this address
581 using the interpreter's loadmap. Once the relocated address
582 is known, we fetch the value (address) corresponding to r_brk
583 and then use that value to fetch the entry point of the function
588 static int enable_break1_done
= 0;
589 static int enable_break2_done
= 0;
596 asection
*interp_sect
;
598 if (!enable_break1_done
|| enable_break2_done
)
601 enable_break2_done
= 1;
603 /* First, remove all the solib event breakpoints. Their addresses
604 may have changed since the last time we ran the program. */
605 remove_solib_event_breakpoints ();
607 interp_text_sect_low
= interp_text_sect_high
= 0;
608 interp_plt_sect_low
= interp_plt_sect_high
= 0;
610 /* Find the .interp section; if not found, warn the user and drop
611 into the old breakpoint at symbol code. */
612 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
615 unsigned int interp_sect_size
;
619 char *tmp_pathname
= NULL
;
621 CORE_ADDR addr
, interp_loadmap_addr
;
622 char addr_buf
[FRV_PTR_SIZE
];
623 struct int_elf32_fdpic_loadmap
*ldm
;
625 /* Read the contents of the .interp section into a local buffer;
626 the contents specify the dynamic linker this program uses. */
627 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
628 buf
= alloca (interp_sect_size
);
629 bfd_get_section_contents (exec_bfd
, interp_sect
,
630 buf
, 0, interp_sect_size
);
632 /* Now we need to figure out where the dynamic linker was
633 loaded so that we can load its symbols and place a breakpoint
634 in the dynamic linker itself.
636 This address is stored on the stack. However, I've been unable
637 to find any magic formula to find it for Solaris (appears to
638 be trivial on GNU/Linux). Therefore, we have to try an alternate
639 mechanism to find the dynamic linker's base address. */
641 tmp_fd
= solib_open (buf
, &tmp_pathname
);
643 tmp_bfd
= bfd_fdopenr (tmp_pathname
, gnutarget
, tmp_fd
);
647 enable_break_failure_warning ();
651 /* Make sure the dynamic linker is really a useful object. */
652 if (!bfd_check_format (tmp_bfd
, bfd_object
))
654 warning ("Unable to grok dynamic linker %s as an object file", buf
);
655 enable_break_failure_warning ();
660 status
= frv_fdpic_loadmap_addresses (current_gdbarch
,
661 &interp_loadmap_addr
, 0);
664 warning ("Unable to determine dynamic linker loadmap address\n");
665 enable_break_failure_warning ();
671 fprintf_unfiltered (gdb_stdlog
,
672 "enable_break: interp_loadmap_addr = %s\n",
673 hex_string_custom (interp_loadmap_addr
, 8));
675 ldm
= fetch_loadmap (interp_loadmap_addr
);
678 warning ("Unable to load dynamic linker loadmap at address %s\n",
679 hex_string_custom (interp_loadmap_addr
, 8));
680 enable_break_failure_warning ();
685 /* Record the relocated start and end address of the dynamic linker
686 text and plt section for svr4_in_dynsym_resolve_code. */
687 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
691 = bfd_section_vma (tmp_bfd
, interp_sect
);
693 += displacement_from_map (ldm
, interp_text_sect_low
);
694 interp_text_sect_high
695 = interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
697 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
700 interp_plt_sect_low
=
701 bfd_section_vma (tmp_bfd
, interp_sect
);
703 += displacement_from_map (ldm
, interp_plt_sect_low
);
704 interp_plt_sect_high
=
705 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
708 addr
= bfd_lookup_symbol (tmp_bfd
, "_dl_debug_addr");
711 warning ("Could not find symbol _dl_debug_addr in dynamic linker");
712 enable_break_failure_warning ();
718 fprintf_unfiltered (gdb_stdlog
,
719 "enable_break: _dl_debug_addr (prior to relocation) = %s\n",
720 hex_string_custom (addr
, 8));
722 addr
+= displacement_from_map (ldm
, addr
);
725 fprintf_unfiltered (gdb_stdlog
,
726 "enable_break: _dl_debug_addr (after relocation) = %s\n",
727 hex_string_custom (addr
, 8));
729 /* Fetch the address of the r_debug struct. */
730 if (target_read_memory (addr
, addr_buf
, sizeof addr_buf
) != 0)
732 warning ("Unable to fetch contents of _dl_debug_addr (at address %s) from dynamic linker",
733 hex_string_custom (addr
, 8));
735 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
);
737 /* Fetch the r_brk field. It's 8 bytes from the start of
739 if (target_read_memory (addr
+ 8, addr_buf
, sizeof addr_buf
) != 0)
741 warning ("Unable to fetch _dl_debug_addr->r_brk (at address %s) from dynamic linker",
742 hex_string_custom (addr
+ 8, 8));
743 enable_break_failure_warning ();
747 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
);
749 /* Now fetch the function entry point. */
750 if (target_read_memory (addr
, addr_buf
, sizeof addr_buf
) != 0)
752 warning ("Unable to fetch _dl_debug_addr->.r_brk entry point (at address %s) from dynamic linker",
753 hex_string_custom (addr
, 8));
754 enable_break_failure_warning ();
758 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
);
760 /* We're done with the temporary bfd. */
763 /* We're also done with the loadmap. */
766 /* Now (finally!) create the solib breakpoint. */
767 create_solib_event_breakpoint (addr
);
772 /* Tell the user we couldn't set a dynamic linker breakpoint. */
773 enable_break_failure_warning ();
775 /* Failure return. */
782 asection
*interp_sect
;
784 /* Remove all the solib event breakpoints. Their addresses
785 may have changed since the last time we ran the program. */
786 remove_solib_event_breakpoints ();
788 /* Check for the presence of a .interp section. If there is no
789 such section, the executable is statically linked. */
791 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
795 enable_break1_done
= 1;
796 create_solib_event_breakpoint (symfile_objfile
->ei
.entry_point
);
799 fprintf_unfiltered (gdb_stdlog
,
800 "enable_break: solib event breakpoint placed at entry point: %s\n",
802 (symfile_objfile
->ei
.entry_point
, 8));
807 fprintf_unfiltered (gdb_stdlog
,
808 "enable_break: No .interp section found.\n");
818 special_symbol_handling -- additional shared library symbol handling
822 void special_symbol_handling ()
826 Once the symbols from a shared object have been loaded in the usual
827 way, we are called to do any system specific symbol handling that
833 frv_special_symbol_handling (void)
835 /* Nothing needed (yet) for FRV. */
839 frv_relocate_main_executable (void)
843 struct int_elf32_fdpic_loadmap
*ldm
;
844 struct cleanup
*old_chain
;
845 struct section_offsets
*new_offsets
;
847 struct obj_section
*osect
;
849 status
= frv_fdpic_loadmap_addresses (current_gdbarch
, 0, &exec_addr
);
853 /* Not using FDPIC ABI, so do nothing. */
857 /* Fetch the loadmap located at ``exec_addr''. */
858 ldm
= fetch_loadmap (exec_addr
);
860 error ("Unable to load the executable's loadmap.");
862 if (main_executable_lm_info
)
863 xfree (main_executable_lm_info
);
864 main_executable_lm_info
= xcalloc (1, sizeof (struct lm_info
));
865 main_executable_lm_info
->map
= ldm
;
867 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
868 sizeof (struct section_offsets
));
869 old_chain
= make_cleanup (xfree
, new_offsets
);
872 ALL_OBJFILE_OSECTIONS (symfile_objfile
, osect
)
874 CORE_ADDR orig_addr
, addr
, offset
;
878 osect_idx
= osect
->the_bfd_section
->index
;
880 /* Current address of section. */
882 /* Offset from where this section started. */
883 offset
= ANOFFSET (symfile_objfile
->section_offsets
, osect_idx
);
884 /* Original address prior to any past relocations. */
885 orig_addr
= addr
- offset
;
887 for (seg
= 0; seg
< ldm
->nsegs
; seg
++)
889 if (ldm
->segs
[seg
].p_vaddr
<= orig_addr
890 && orig_addr
< ldm
->segs
[seg
].p_vaddr
+ ldm
->segs
[seg
].p_memsz
)
892 new_offsets
->offsets
[osect_idx
]
893 = ldm
->segs
[seg
].addr
- ldm
->segs
[seg
].p_vaddr
;
895 if (new_offsets
->offsets
[osect_idx
] != offset
)
903 objfile_relocate (symfile_objfile
, new_offsets
);
905 do_cleanups (old_chain
);
907 /* Now that symfile_objfile has been relocated, we can compute the
908 GOT value and stash it away. */
909 main_executable_lm_info
->got_value
= main_got ();
916 frv_solib_create_inferior_hook -- shared library startup support
920 void frv_solib_create_inferior_hook()
924 When gdb starts up the inferior, it nurses it along (through the
925 shell) until it is ready to execute it's first instruction. At this
926 point, this function gets called via expansion of the macro
927 SOLIB_CREATE_INFERIOR_HOOK.
929 For the FR-V shared library ABI (FDPIC), the main executable
930 needs to be relocated. The shared library breakpoints also need
935 frv_solib_create_inferior_hook (void)
937 /* Relocate main executable. */
938 frv_relocate_main_executable ();
940 /* Enable shared library breakpoints. */
941 if (!enable_break ())
943 warning ("shared library handler failed to enable breakpoint");
949 frv_clear_solib (void)
952 enable_break1_done
= 0;
953 enable_break2_done
= 0;
957 frv_free_so (struct so_list
*so
)
959 xfree (so
->lm_info
->map
);
960 xfree (so
->lm_info
->dyn_syms
);
961 xfree (so
->lm_info
->dyn_relocs
);
966 frv_relocate_section_addresses (struct so_list
*so
,
967 struct section_table
*sec
)
970 struct int_elf32_fdpic_loadmap
*map
;
972 map
= so
->lm_info
->map
;
974 for (seg
= 0; seg
< map
->nsegs
; seg
++)
976 if (map
->segs
[seg
].p_vaddr
<= sec
->addr
977 && sec
->addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
979 CORE_ADDR displ
= map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
981 sec
->endaddr
+= displ
;
987 /* Return the GOT address associated with the main executable. Return
988 0 if it can't be found. */
993 struct minimal_symbol
*got_sym
;
995 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
, symfile_objfile
);
999 return SYMBOL_VALUE_ADDRESS (got_sym
);
1002 /* Find the global pointer for the given function address ADDR. */
1005 frv_fdpic_find_global_pointer (CORE_ADDR addr
)
1009 so
= master_so_list ();
1013 struct int_elf32_fdpic_loadmap
*map
;
1015 map
= so
->lm_info
->map
;
1017 for (seg
= 0; seg
< map
->nsegs
; seg
++)
1019 if (map
->segs
[seg
].addr
<= addr
1020 && addr
< map
->segs
[seg
].addr
+ map
->segs
[seg
].p_memsz
)
1021 return so
->lm_info
->got_value
;
1027 /* Didn't find it it any of the shared objects. So assume it's in the
1032 /* Forward declarations for frv_fdpic_find_canonical_descriptor(). */
1033 static CORE_ADDR find_canonical_descriptor_in_load_object
1034 (CORE_ADDR
, CORE_ADDR
, char *, bfd
*, struct lm_info
*);
1036 /* Given a function entry point, attempt to find the canonical descriptor
1037 associated with that entry point. Return 0 if no canonical descriptor
1041 frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point
)
1045 CORE_ADDR got_value
;
1046 struct int_elf32_fdpic_loadmap
*ldm
= 0;
1049 CORE_ADDR exec_loadmap_addr
;
1051 /* Fetch the corresponding global pointer for the entry point. */
1052 got_value
= frv_fdpic_find_global_pointer (entry_point
);
1054 /* Attempt to find the name of the function. If the name is available,
1055 it'll be used as an aid in finding matching functions in the dynamic
1057 sym
= find_pc_function (entry_point
);
1061 name
= SYMBOL_LINKAGE_NAME (sym
);
1063 /* Check the main executable. */
1064 addr
= find_canonical_descriptor_in_load_object
1065 (entry_point
, got_value
, name
, symfile_objfile
->obfd
,
1066 main_executable_lm_info
);
1068 /* If descriptor not found via main executable, check each load object
1069 in list of shared objects. */
1074 so
= master_so_list ();
1077 addr
= find_canonical_descriptor_in_load_object
1078 (entry_point
, got_value
, name
, so
->abfd
, so
->lm_info
);
1091 find_canonical_descriptor_in_load_object
1092 (CORE_ADDR entry_point
, CORE_ADDR got_value
, char *name
, bfd
*abfd
,
1099 /* Nothing to do if no bfd. */
1103 /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations.
1104 (More about this later.) But in order to fetch the relocs, we
1105 need to first fetch the dynamic symbols. These symbols need to
1106 be cached due to the way that bfd_canonicalize_dynamic_reloc()
1107 works. (See the comments in the declaration of struct lm_info
1108 for more information.) */
1109 if (lm
->dyn_syms
== NULL
)
1111 long storage_needed
;
1112 unsigned int number_of_symbols
;
1114 /* Determine amount of space needed to hold the dynamic symbol table. */
1115 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1117 /* If there are no dynamic symbols, there's nothing to do. */
1118 if (storage_needed
<= 0)
1121 /* Allocate space for the dynamic symbol table. */
1122 lm
->dyn_syms
= (asymbol
**) xmalloc (storage_needed
);
1124 /* Fetch the dynamic symbol table. */
1125 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, lm
->dyn_syms
);
1127 if (number_of_symbols
== 0)
1131 /* Fetch the dynamic relocations if not already cached. */
1132 if (lm
->dyn_relocs
== NULL
)
1134 long storage_needed
;
1136 /* Determine amount of space needed to hold the dynamic relocs. */
1137 storage_needed
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1139 /* Bail out if there are no dynamic relocs. */
1140 if (storage_needed
<= 0)
1143 /* Allocate space for the relocs. */
1144 lm
->dyn_relocs
= (arelent
**) xmalloc (storage_needed
);
1146 /* Fetch the dynamic relocs. */
1148 = bfd_canonicalize_dynamic_reloc (abfd
, lm
->dyn_relocs
, lm
->dyn_syms
);
1151 /* Search the dynamic relocs. */
1152 for (i
= 0; i
< lm
->dyn_reloc_count
; i
++)
1154 rel
= lm
->dyn_relocs
[i
];
1156 /* Relocs of interest are those which meet the following
1159 - the names match (assuming the caller could provide
1160 a name which matches ``entry_point'').
1161 - the relocation type must be R_FRV_FUNCDESC. Relocs
1162 of this type are used (by the dynamic linker) to
1163 look up the address of a canonical descriptor (allocating
1164 it if need be) and initializing the GOT entry referred
1165 to by the offset to the address of the descriptor.
1167 These relocs of interest may be used to obtain a
1168 candidate descriptor by first adjusting the reloc's
1169 address according to the link map and then dereferencing
1170 this address (which is a GOT entry) to obtain a descriptor
1172 if ((name
== 0 || strcmp (name
, (*rel
->sym_ptr_ptr
)->name
) == 0)
1173 && rel
->howto
->type
== R_FRV_FUNCDESC
)
1175 char buf
[FRV_PTR_SIZE
];
1177 /* Compute address of address of candidate descriptor. */
1178 addr
= rel
->address
+ displacement_from_map (lm
->map
, rel
->address
);
1180 /* Fetch address of candidate descriptor. */
1181 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1183 addr
= extract_unsigned_integer (buf
, sizeof buf
);
1185 /* Check for matching entry point. */
1186 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1188 if (extract_unsigned_integer (buf
, sizeof buf
) != entry_point
)
1191 /* Check for matching got value. */
1192 if (target_read_memory (addr
+ 4, buf
, sizeof buf
) != 0)
1194 if (extract_unsigned_integer (buf
, sizeof buf
) != got_value
)
1197 /* Match was successful! Exit loop. */
1205 static struct target_so_ops frv_so_ops
;
1208 _initialize_frv_solib (void)
1210 frv_so_ops
.relocate_section_addresses
= frv_relocate_section_addresses
;
1211 frv_so_ops
.free_so
= frv_free_so
;
1212 frv_so_ops
.clear_solib
= frv_clear_solib
;
1213 frv_so_ops
.solib_create_inferior_hook
= frv_solib_create_inferior_hook
;
1214 frv_so_ops
.special_symbol_handling
= frv_special_symbol_handling
;
1215 frv_so_ops
.current_sos
= frv_current_sos
;
1216 frv_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1217 frv_so_ops
.in_dynsym_resolve_code
= frv_in_dynsym_resolve_code
;
1219 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
1220 current_target_so_ops
= &frv_so_ops
;
1222 /* Debug this file's internals. */
1223 deprecated_add_show_from_set
1224 (add_set_cmd ("solib-frv", class_maintenance
, var_zinteger
,
1226 "Set internal debugging of shared library code for FR-V.\n"
1227 "When non-zero, FR-V solib specific internal debugging is enabled.",