1 /* Handle FR-V (FDPIC) shared libraries for GDB, the GNU Debugger.
2 Copyright (C) 2004, 2007 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
23 #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 gdb_byte ext_Elf32_Half
[2];
48 typedef gdb_byte ext_Elf32_Addr
[4];
49 typedef gdb_byte 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
, (gdb_byte
*) &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 (gdb_byte
*) 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 gdb_byte 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. */
204 /* The link map address, needed for frv_fetch_objfile_link_map(). */
207 /* Cached dynamic symbol table and dynamic relocs initialized and
208 used only by find_canonical_descriptor_in_load_object().
210 Note: kevinb/2004-02-26: It appears that calls to
211 bfd_canonicalize_dynamic_reloc() will use the same symbols as
212 those supplied to the first call to this function. Therefore,
213 it's important to NOT free the asymbol ** data structure
214 supplied to the first call. Thus the caching of the dynamic
215 symbols (dyn_syms) is critical for correct operation. The
216 caching of the dynamic relocations could be dispensed with. */
218 arelent
**dyn_relocs
;
219 int dyn_reloc_count
; /* number of dynamic relocs. */
223 /* The load map, got value, etc. are not available from the chain
224 of loaded shared objects. ``main_executable_lm_info'' provides
225 a way to get at this information so that it doesn't need to be
226 frequently recomputed. Initialized by frv_relocate_main_executable(). */
227 static struct lm_info
*main_executable_lm_info
;
229 static void frv_relocate_main_executable (void);
230 static CORE_ADDR
main_got (void);
231 static int enable_break2 (void);
237 bfd_lookup_symbol -- lookup the value for a specific symbol
241 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
245 An expensive way to lookup the value of a single symbol for
246 bfd's that are only temporary anyway. This is used by the
247 shared library support to find the address of the debugger
248 interface structures in the shared library.
250 Note that 0 is specifically allowed as an error return (no
255 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
259 asymbol
**symbol_table
;
260 unsigned int number_of_symbols
;
262 struct cleanup
*back_to
;
263 CORE_ADDR symaddr
= 0;
265 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
267 if (storage_needed
> 0)
269 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
270 back_to
= make_cleanup (xfree
, symbol_table
);
271 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
273 for (i
= 0; i
< number_of_symbols
; i
++)
275 sym
= *symbol_table
++;
276 if (strcmp (sym
->name
, symname
) == 0)
278 /* Bfd symbols are section relative. */
279 symaddr
= sym
->value
+ sym
->section
->vma
;
283 do_cleanups (back_to
);
289 /* Look for the symbol in the dynamic string table too. */
291 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
293 if (storage_needed
> 0)
295 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
296 back_to
= make_cleanup (xfree
, symbol_table
);
297 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
299 for (i
= 0; i
< number_of_symbols
; i
++)
301 sym
= *symbol_table
++;
302 if (strcmp (sym
->name
, symname
) == 0)
304 /* Bfd symbols are section relative. */
305 symaddr
= sym
->value
+ sym
->section
->vma
;
309 do_cleanups (back_to
);
320 open_symbol_file_object
324 void open_symbol_file_object (void *from_tty)
328 If no open symbol file, attempt to locate and open the main symbol
331 If FROM_TTYP dereferences to a non-zero integer, allow messages to
332 be printed. This parameter is a pointer rather than an int because
333 open_symbol_file_object() is called via catch_errors() and
334 catch_errors() requires a pointer argument. */
337 open_symbol_file_object (void *from_ttyp
)
343 /* Cached value for lm_base(), below. */
344 static CORE_ADDR lm_base_cache
= 0;
346 /* Link map address for main module. */
347 static CORE_ADDR main_lm_addr
= 0;
349 /* Return the address from which the link map chain may be found. On
350 the FR-V, this may be found in a number of ways. Assuming that the
351 main executable has already been relocated, the easiest way to find
352 this value is to look up the address of _GLOBAL_OFFSET_TABLE_. A
353 pointer to the start of the link map will be located at the word found
354 at _GLOBAL_OFFSET_TABLE_ + 8. (This is part of the dynamic linker
355 reserve area mandated by the ABI.) */
360 struct minimal_symbol
*got_sym
;
362 gdb_byte buf
[FRV_PTR_SIZE
];
364 /* One of our assumptions is that the main executable has been relocated.
365 Bail out if this has not happened. (Note that post_create_inferior()
366 in infcmd.c will call solib_add prior to solib_create_inferior_hook().
367 If we allow this to happen, lm_base_cache will be initialized with
369 if (main_executable_lm_info
== 0)
372 /* If we already have a cached value, return it. */
374 return lm_base_cache
;
376 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
,
381 fprintf_unfiltered (gdb_stdlog
,
382 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
386 addr
= SYMBOL_VALUE_ADDRESS (got_sym
) + 8;
389 fprintf_unfiltered (gdb_stdlog
,
390 "lm_base: _GLOBAL_OFFSET_TABLE_ + 8 = %s\n",
391 hex_string_custom (addr
, 8));
393 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
395 lm_base_cache
= extract_unsigned_integer (buf
, sizeof buf
);
398 fprintf_unfiltered (gdb_stdlog
,
399 "lm_base: lm_base_cache = %s\n",
400 hex_string_custom (lm_base_cache
, 8));
402 return lm_base_cache
;
408 frv_current_sos -- build a list of currently loaded shared objects
412 struct so_list *frv_current_sos ()
416 Build a list of `struct so_list' objects describing the shared
417 objects currently loaded in the inferior. This list does not
418 include an entry for the main executable file.
420 Note that we only gather information directly available from the
421 inferior --- we don't examine any of the shared library files
422 themselves. The declaration of `struct so_list' says which fields
423 we provide values for. */
425 static struct so_list
*
426 frv_current_sos (void)
428 CORE_ADDR lm_addr
, mgot
;
429 struct so_list
*sos_head
= NULL
;
430 struct so_list
**sos_next_ptr
= &sos_head
;
432 /* Make sure that the main executable has been relocated. This is
433 required in order to find the address of the global offset table,
434 which in turn is used to find the link map info. (See lm_base()
437 Note that the relocation of the main executable is also performed
438 by SOLIB_CREATE_INFERIOR_HOOK(), however, in the case of core
439 files, this hook is called too late in order to be of benefit to
440 SOLIB_ADD. SOLIB_ADD eventually calls this this function,
441 frv_current_sos, and also precedes the call to
442 SOLIB_CREATE_INFERIOR_HOOK(). (See post_create_inferior() in
444 if (main_executable_lm_info
== 0 && core_bfd
!= NULL
)
445 frv_relocate_main_executable ();
447 /* Fetch the GOT corresponding to the main executable. */
450 /* Locate the address of the first link map struct. */
451 lm_addr
= lm_base ();
453 /* We have at least one link map entry. Fetch the the lot of them,
454 building the solist chain. */
457 struct ext_link_map lm_buf
;
461 fprintf_unfiltered (gdb_stdlog
,
462 "current_sos: reading link_map entry at %s\n",
463 hex_string_custom (lm_addr
, 8));
465 if (target_read_memory (lm_addr
, (gdb_byte
*) &lm_buf
, sizeof (lm_buf
)) != 0)
467 warning (_("frv_current_sos: Unable to read link map entry. Shared object chain may be incomplete."));
472 = extract_unsigned_integer (lm_buf
.l_addr
.got_value
,
473 sizeof (lm_buf
.l_addr
.got_value
));
474 /* If the got_addr is the same as mgotr, then we're looking at the
475 entry for the main executable. By convention, we don't include
476 this in the list of shared objects. */
477 if (got_addr
!= mgot
)
481 struct int_elf32_fdpic_loadmap
*loadmap
;
485 /* Fetch the load map address. */
486 addr
= extract_unsigned_integer (lm_buf
.l_addr
.map
,
487 sizeof lm_buf
.l_addr
.map
);
488 loadmap
= fetch_loadmap (addr
);
491 warning (_("frv_current_sos: Unable to fetch load map. Shared object chain may be incomplete."));
495 sop
= xcalloc (1, sizeof (struct so_list
));
496 sop
->lm_info
= xcalloc (1, sizeof (struct lm_info
));
497 sop
->lm_info
->map
= loadmap
;
498 sop
->lm_info
->got_value
= got_addr
;
499 sop
->lm_info
->lm_addr
= lm_addr
;
500 /* Fetch the name. */
501 addr
= extract_unsigned_integer (lm_buf
.l_name
,
502 sizeof (lm_buf
.l_name
));
503 target_read_string (addr
, &name_buf
, SO_NAME_MAX_PATH_SIZE
- 1,
507 fprintf_unfiltered (gdb_stdlog
, "current_sos: name = %s\n",
511 warning (_("Can't read pathname for link map entry: %s."),
512 safe_strerror (errcode
));
515 strncpy (sop
->so_name
, name_buf
, SO_NAME_MAX_PATH_SIZE
- 1);
516 sop
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
518 strcpy (sop
->so_original_name
, sop
->so_name
);
522 sos_next_ptr
= &sop
->next
;
526 main_lm_addr
= lm_addr
;
529 lm_addr
= extract_unsigned_integer (lm_buf
.l_next
, sizeof (lm_buf
.l_next
));
538 /* Return 1 if PC lies in the dynamic symbol resolution code of the
541 static CORE_ADDR interp_text_sect_low
;
542 static CORE_ADDR interp_text_sect_high
;
543 static CORE_ADDR interp_plt_sect_low
;
544 static CORE_ADDR interp_plt_sect_high
;
547 frv_in_dynsym_resolve_code (CORE_ADDR pc
)
549 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
550 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
551 || in_plt_section (pc
, NULL
));
554 /* Given a loadmap and an address, return the displacement needed
555 to relocate the address. */
558 displacement_from_map (struct int_elf32_fdpic_loadmap
*map
,
563 for (seg
= 0; seg
< map
->nsegs
; seg
++)
565 if (map
->segs
[seg
].p_vaddr
<= addr
566 && addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
568 return map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
575 /* Print a warning about being unable to set the dynamic linker
579 enable_break_failure_warning (void)
581 warning (_("Unable to find dynamic linker breakpoint function.\n"
582 "GDB will be unable to debug shared library initializers\n"
583 "and track explicitly loaded dynamic code."));
590 enable_break -- arrange for dynamic linker to hit breakpoint
594 int enable_break (void)
598 The dynamic linkers has, as part of its debugger interface, support
599 for arranging for the inferior to hit a breakpoint after mapping in
600 the shared libraries. This function enables that breakpoint.
602 On the FR-V, using the shared library (FDPIC) ABI, the symbol
603 _dl_debug_addr points to the r_debug struct which contains
604 a field called r_brk. r_brk is the address of the function
605 descriptor upon which a breakpoint must be placed. Being a
606 function descriptor, we must extract the entry point in order
607 to set the breakpoint.
609 Our strategy will be to get the .interp section from the
610 executable. This section will provide us with the name of the
611 interpreter. We'll open the interpreter and then look up
612 the address of _dl_debug_addr. We then relocate this address
613 using the interpreter's loadmap. Once the relocated address
614 is known, we fetch the value (address) corresponding to r_brk
615 and then use that value to fetch the entry point of the function
620 static int enable_break1_done
= 0;
621 static int enable_break2_done
= 0;
628 asection
*interp_sect
;
630 if (!enable_break1_done
|| enable_break2_done
)
633 enable_break2_done
= 1;
635 /* First, remove all the solib event breakpoints. Their addresses
636 may have changed since the last time we ran the program. */
637 remove_solib_event_breakpoints ();
639 interp_text_sect_low
= interp_text_sect_high
= 0;
640 interp_plt_sect_low
= interp_plt_sect_high
= 0;
642 /* Find the .interp section; if not found, warn the user and drop
643 into the old breakpoint at symbol code. */
644 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
647 unsigned int interp_sect_size
;
651 char *tmp_pathname
= NULL
;
653 CORE_ADDR addr
, interp_loadmap_addr
;
654 gdb_byte addr_buf
[FRV_PTR_SIZE
];
655 struct int_elf32_fdpic_loadmap
*ldm
;
657 /* Read the contents of the .interp section into a local buffer;
658 the contents specify the dynamic linker this program uses. */
659 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
660 buf
= alloca (interp_sect_size
);
661 bfd_get_section_contents (exec_bfd
, interp_sect
,
662 buf
, 0, interp_sect_size
);
664 /* Now we need to figure out where the dynamic linker was
665 loaded so that we can load its symbols and place a breakpoint
666 in the dynamic linker itself.
668 This address is stored on the stack. However, I've been unable
669 to find any magic formula to find it for Solaris (appears to
670 be trivial on GNU/Linux). Therefore, we have to try an alternate
671 mechanism to find the dynamic linker's base address. */
673 tmp_fd
= solib_open (buf
, &tmp_pathname
);
675 tmp_bfd
= bfd_fopen (tmp_pathname
, gnutarget
, FOPEN_RB
, tmp_fd
);
679 enable_break_failure_warning ();
683 /* Make sure the dynamic linker is really a useful object. */
684 if (!bfd_check_format (tmp_bfd
, bfd_object
))
686 warning (_("Unable to grok dynamic linker %s as an object file"), buf
);
687 enable_break_failure_warning ();
692 status
= frv_fdpic_loadmap_addresses (current_gdbarch
,
693 &interp_loadmap_addr
, 0);
696 warning (_("Unable to determine dynamic linker loadmap address."));
697 enable_break_failure_warning ();
703 fprintf_unfiltered (gdb_stdlog
,
704 "enable_break: interp_loadmap_addr = %s\n",
705 hex_string_custom (interp_loadmap_addr
, 8));
707 ldm
= fetch_loadmap (interp_loadmap_addr
);
710 warning (_("Unable to load dynamic linker loadmap at address %s."),
711 hex_string_custom (interp_loadmap_addr
, 8));
712 enable_break_failure_warning ();
717 /* Record the relocated start and end address of the dynamic linker
718 text and plt section for svr4_in_dynsym_resolve_code. */
719 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
723 = bfd_section_vma (tmp_bfd
, interp_sect
);
725 += displacement_from_map (ldm
, interp_text_sect_low
);
726 interp_text_sect_high
727 = interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
729 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
732 interp_plt_sect_low
=
733 bfd_section_vma (tmp_bfd
, interp_sect
);
735 += displacement_from_map (ldm
, interp_plt_sect_low
);
736 interp_plt_sect_high
=
737 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
740 addr
= bfd_lookup_symbol (tmp_bfd
, "_dl_debug_addr");
743 warning (_("Could not find symbol _dl_debug_addr in dynamic linker"));
744 enable_break_failure_warning ();
750 fprintf_unfiltered (gdb_stdlog
,
751 "enable_break: _dl_debug_addr (prior to relocation) = %s\n",
752 hex_string_custom (addr
, 8));
754 addr
+= displacement_from_map (ldm
, addr
);
757 fprintf_unfiltered (gdb_stdlog
,
758 "enable_break: _dl_debug_addr (after relocation) = %s\n",
759 hex_string_custom (addr
, 8));
761 /* Fetch the address of the r_debug struct. */
762 if (target_read_memory (addr
, addr_buf
, sizeof addr_buf
) != 0)
764 warning (_("Unable to fetch contents of _dl_debug_addr (at address %s) from dynamic linker"),
765 hex_string_custom (addr
, 8));
767 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
);
769 /* Fetch the r_brk field. It's 8 bytes from the start of
771 if (target_read_memory (addr
+ 8, addr_buf
, sizeof addr_buf
) != 0)
773 warning (_("Unable to fetch _dl_debug_addr->r_brk (at address %s) from dynamic linker"),
774 hex_string_custom (addr
+ 8, 8));
775 enable_break_failure_warning ();
779 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
);
781 /* Now fetch the function entry point. */
782 if (target_read_memory (addr
, addr_buf
, sizeof addr_buf
) != 0)
784 warning (_("Unable to fetch _dl_debug_addr->.r_brk entry point (at address %s) from dynamic linker"),
785 hex_string_custom (addr
, 8));
786 enable_break_failure_warning ();
790 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
);
792 /* We're done with the temporary bfd. */
795 /* We're also done with the loadmap. */
798 /* Now (finally!) create the solib breakpoint. */
799 create_solib_event_breakpoint (addr
);
804 /* Tell the user we couldn't set a dynamic linker breakpoint. */
805 enable_break_failure_warning ();
807 /* Failure return. */
814 asection
*interp_sect
;
816 /* Remove all the solib event breakpoints. Their addresses
817 may have changed since the last time we ran the program. */
818 remove_solib_event_breakpoints ();
820 /* Check for the presence of a .interp section. If there is no
821 such section, the executable is statically linked. */
823 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
827 enable_break1_done
= 1;
828 create_solib_event_breakpoint (symfile_objfile
->ei
.entry_point
);
831 fprintf_unfiltered (gdb_stdlog
,
832 "enable_break: solib event breakpoint placed at entry point: %s\n",
834 (symfile_objfile
->ei
.entry_point
, 8));
839 fprintf_unfiltered (gdb_stdlog
,
840 "enable_break: No .interp section found.\n");
850 special_symbol_handling -- additional shared library symbol handling
854 void special_symbol_handling ()
858 Once the symbols from a shared object have been loaded in the usual
859 way, we are called to do any system specific symbol handling that
865 frv_special_symbol_handling (void)
867 /* Nothing needed (yet) for FRV. */
871 frv_relocate_main_executable (void)
875 struct int_elf32_fdpic_loadmap
*ldm
;
876 struct cleanup
*old_chain
;
877 struct section_offsets
*new_offsets
;
879 struct obj_section
*osect
;
881 status
= frv_fdpic_loadmap_addresses (current_gdbarch
, 0, &exec_addr
);
885 /* Not using FDPIC ABI, so do nothing. */
889 /* Fetch the loadmap located at ``exec_addr''. */
890 ldm
= fetch_loadmap (exec_addr
);
892 error (_("Unable to load the executable's loadmap."));
894 if (main_executable_lm_info
)
895 xfree (main_executable_lm_info
);
896 main_executable_lm_info
= xcalloc (1, sizeof (struct lm_info
));
897 main_executable_lm_info
->map
= ldm
;
899 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
900 sizeof (struct section_offsets
));
901 old_chain
= make_cleanup (xfree
, new_offsets
);
904 ALL_OBJFILE_OSECTIONS (symfile_objfile
, osect
)
906 CORE_ADDR orig_addr
, addr
, offset
;
910 osect_idx
= osect
->the_bfd_section
->index
;
912 /* Current address of section. */
914 /* Offset from where this section started. */
915 offset
= ANOFFSET (symfile_objfile
->section_offsets
, osect_idx
);
916 /* Original address prior to any past relocations. */
917 orig_addr
= addr
- offset
;
919 for (seg
= 0; seg
< ldm
->nsegs
; seg
++)
921 if (ldm
->segs
[seg
].p_vaddr
<= orig_addr
922 && orig_addr
< ldm
->segs
[seg
].p_vaddr
+ ldm
->segs
[seg
].p_memsz
)
924 new_offsets
->offsets
[osect_idx
]
925 = ldm
->segs
[seg
].addr
- ldm
->segs
[seg
].p_vaddr
;
927 if (new_offsets
->offsets
[osect_idx
] != offset
)
935 objfile_relocate (symfile_objfile
, new_offsets
);
937 do_cleanups (old_chain
);
939 /* Now that symfile_objfile has been relocated, we can compute the
940 GOT value and stash it away. */
941 main_executable_lm_info
->got_value
= main_got ();
948 frv_solib_create_inferior_hook -- shared library startup support
952 void frv_solib_create_inferior_hook ()
956 When gdb starts up the inferior, it nurses it along (through the
957 shell) until it is ready to execute it's first instruction. At this
958 point, this function gets called via expansion of the macro
959 SOLIB_CREATE_INFERIOR_HOOK.
961 For the FR-V shared library ABI (FDPIC), the main executable
962 needs to be relocated. The shared library breakpoints also need
967 frv_solib_create_inferior_hook (void)
969 /* Relocate main executable. */
970 frv_relocate_main_executable ();
972 /* Enable shared library breakpoints. */
973 if (!enable_break ())
975 warning (_("shared library handler failed to enable breakpoint"));
981 frv_clear_solib (void)
984 enable_break1_done
= 0;
985 enable_break2_done
= 0;
987 if (main_executable_lm_info
!= 0)
989 xfree (main_executable_lm_info
->map
);
990 xfree (main_executable_lm_info
->dyn_syms
);
991 xfree (main_executable_lm_info
->dyn_relocs
);
992 xfree (main_executable_lm_info
);
993 main_executable_lm_info
= 0;
998 frv_free_so (struct so_list
*so
)
1000 xfree (so
->lm_info
->map
);
1001 xfree (so
->lm_info
->dyn_syms
);
1002 xfree (so
->lm_info
->dyn_relocs
);
1003 xfree (so
->lm_info
);
1007 frv_relocate_section_addresses (struct so_list
*so
,
1008 struct section_table
*sec
)
1011 struct int_elf32_fdpic_loadmap
*map
;
1013 map
= so
->lm_info
->map
;
1015 for (seg
= 0; seg
< map
->nsegs
; seg
++)
1017 if (map
->segs
[seg
].p_vaddr
<= sec
->addr
1018 && sec
->addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
1020 CORE_ADDR displ
= map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
1022 sec
->endaddr
+= displ
;
1028 /* Return the GOT address associated with the main executable. Return
1029 0 if it can't be found. */
1034 struct minimal_symbol
*got_sym
;
1036 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
, symfile_objfile
);
1040 return SYMBOL_VALUE_ADDRESS (got_sym
);
1043 /* Find the global pointer for the given function address ADDR. */
1046 frv_fdpic_find_global_pointer (CORE_ADDR addr
)
1050 so
= master_so_list ();
1054 struct int_elf32_fdpic_loadmap
*map
;
1056 map
= so
->lm_info
->map
;
1058 for (seg
= 0; seg
< map
->nsegs
; seg
++)
1060 if (map
->segs
[seg
].addr
<= addr
1061 && addr
< map
->segs
[seg
].addr
+ map
->segs
[seg
].p_memsz
)
1062 return so
->lm_info
->got_value
;
1068 /* Didn't find it it any of the shared objects. So assume it's in the
1073 /* Forward declarations for frv_fdpic_find_canonical_descriptor(). */
1074 static CORE_ADDR find_canonical_descriptor_in_load_object
1075 (CORE_ADDR
, CORE_ADDR
, char *, bfd
*, struct lm_info
*);
1077 /* Given a function entry point, attempt to find the canonical descriptor
1078 associated with that entry point. Return 0 if no canonical descriptor
1082 frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point
)
1086 CORE_ADDR got_value
;
1087 struct int_elf32_fdpic_loadmap
*ldm
= 0;
1090 CORE_ADDR exec_loadmap_addr
;
1092 /* Fetch the corresponding global pointer for the entry point. */
1093 got_value
= frv_fdpic_find_global_pointer (entry_point
);
1095 /* Attempt to find the name of the function. If the name is available,
1096 it'll be used as an aid in finding matching functions in the dynamic
1098 sym
= find_pc_function (entry_point
);
1102 name
= SYMBOL_LINKAGE_NAME (sym
);
1104 /* Check the main executable. */
1105 addr
= find_canonical_descriptor_in_load_object
1106 (entry_point
, got_value
, name
, symfile_objfile
->obfd
,
1107 main_executable_lm_info
);
1109 /* If descriptor not found via main executable, check each load object
1110 in list of shared objects. */
1115 so
= master_so_list ();
1118 addr
= find_canonical_descriptor_in_load_object
1119 (entry_point
, got_value
, name
, so
->abfd
, so
->lm_info
);
1132 find_canonical_descriptor_in_load_object
1133 (CORE_ADDR entry_point
, CORE_ADDR got_value
, char *name
, bfd
*abfd
,
1140 /* Nothing to do if no bfd. */
1144 /* Nothing to do if no link map. */
1148 /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations.
1149 (More about this later.) But in order to fetch the relocs, we
1150 need to first fetch the dynamic symbols. These symbols need to
1151 be cached due to the way that bfd_canonicalize_dynamic_reloc()
1152 works. (See the comments in the declaration of struct lm_info
1153 for more information.) */
1154 if (lm
->dyn_syms
== NULL
)
1156 long storage_needed
;
1157 unsigned int number_of_symbols
;
1159 /* Determine amount of space needed to hold the dynamic symbol table. */
1160 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1162 /* If there are no dynamic symbols, there's nothing to do. */
1163 if (storage_needed
<= 0)
1166 /* Allocate space for the dynamic symbol table. */
1167 lm
->dyn_syms
= (asymbol
**) xmalloc (storage_needed
);
1169 /* Fetch the dynamic symbol table. */
1170 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, lm
->dyn_syms
);
1172 if (number_of_symbols
== 0)
1176 /* Fetch the dynamic relocations if not already cached. */
1177 if (lm
->dyn_relocs
== NULL
)
1179 long storage_needed
;
1181 /* Determine amount of space needed to hold the dynamic relocs. */
1182 storage_needed
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1184 /* Bail out if there are no dynamic relocs. */
1185 if (storage_needed
<= 0)
1188 /* Allocate space for the relocs. */
1189 lm
->dyn_relocs
= (arelent
**) xmalloc (storage_needed
);
1191 /* Fetch the dynamic relocs. */
1193 = bfd_canonicalize_dynamic_reloc (abfd
, lm
->dyn_relocs
, lm
->dyn_syms
);
1196 /* Search the dynamic relocs. */
1197 for (i
= 0; i
< lm
->dyn_reloc_count
; i
++)
1199 rel
= lm
->dyn_relocs
[i
];
1201 /* Relocs of interest are those which meet the following
1204 - the names match (assuming the caller could provide
1205 a name which matches ``entry_point'').
1206 - the relocation type must be R_FRV_FUNCDESC. Relocs
1207 of this type are used (by the dynamic linker) to
1208 look up the address of a canonical descriptor (allocating
1209 it if need be) and initializing the GOT entry referred
1210 to by the offset to the address of the descriptor.
1212 These relocs of interest may be used to obtain a
1213 candidate descriptor by first adjusting the reloc's
1214 address according to the link map and then dereferencing
1215 this address (which is a GOT entry) to obtain a descriptor
1217 if ((name
== 0 || strcmp (name
, (*rel
->sym_ptr_ptr
)->name
) == 0)
1218 && rel
->howto
->type
== R_FRV_FUNCDESC
)
1220 gdb_byte buf
[FRV_PTR_SIZE
];
1222 /* Compute address of address of candidate descriptor. */
1223 addr
= rel
->address
+ displacement_from_map (lm
->map
, rel
->address
);
1225 /* Fetch address of candidate descriptor. */
1226 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1228 addr
= extract_unsigned_integer (buf
, sizeof buf
);
1230 /* Check for matching entry point. */
1231 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1233 if (extract_unsigned_integer (buf
, sizeof buf
) != entry_point
)
1236 /* Check for matching got value. */
1237 if (target_read_memory (addr
+ 4, buf
, sizeof buf
) != 0)
1239 if (extract_unsigned_integer (buf
, sizeof buf
) != got_value
)
1242 /* Match was successful! Exit loop. */
1250 /* Given an objfile, return the address of its link map. This value is
1251 needed for TLS support. */
1253 frv_fetch_objfile_link_map (struct objfile
*objfile
)
1257 /* Cause frv_current_sos() to be run if it hasn't been already. */
1258 if (main_lm_addr
== 0)
1259 solib_add (0, 0, 0, 1);
1261 /* frv_current_sos() will set main_lm_addr for the main executable. */
1262 if (objfile
== symfile_objfile
)
1263 return main_lm_addr
;
1265 /* The other link map addresses may be found by examining the list
1266 of shared libraries. */
1267 for (so
= master_so_list (); so
; so
= so
->next
)
1269 if (so
->objfile
== objfile
)
1270 return so
->lm_info
->lm_addr
;
1277 static struct target_so_ops frv_so_ops
;
1280 _initialize_frv_solib (void)
1282 frv_so_ops
.relocate_section_addresses
= frv_relocate_section_addresses
;
1283 frv_so_ops
.free_so
= frv_free_so
;
1284 frv_so_ops
.clear_solib
= frv_clear_solib
;
1285 frv_so_ops
.solib_create_inferior_hook
= frv_solib_create_inferior_hook
;
1286 frv_so_ops
.special_symbol_handling
= frv_special_symbol_handling
;
1287 frv_so_ops
.current_sos
= frv_current_sos
;
1288 frv_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1289 frv_so_ops
.in_dynsym_resolve_code
= frv_in_dynsym_resolve_code
;
1291 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
1292 current_target_so_ops
= &frv_so_ops
;
1294 /* Debug this file's internals. */
1295 add_setshow_zinteger_cmd ("solib-frv", class_maintenance
,
1296 &solib_frv_debug
, _("\
1297 Set internal debugging of shared library code for FR-V."), _("\
1298 Show internal debugging of shared library code for FR-V."), _("\
1299 When non-zero, FR-V solib specific internal debugging is enabled."),
1301 NULL
, /* FIXME: i18n: */
1302 &setdebuglist
, &showdebuglist
);