1 /* Handle FR-V (FDPIC) shared libraries for GDB, the GNU Debugger.
2 Copyright (C) 2004, 2007, 2008, 2009, 2010, 2011
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 3 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, see <http://www.gnu.org/licenses/>. */
22 #include "gdb_string.h"
34 #include "exceptions.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 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
102 struct ext_elf32_fdpic_loadmap ext_ldmbuf_partial
;
103 struct ext_elf32_fdpic_loadmap
*ext_ldmbuf
;
104 struct int_elf32_fdpic_loadmap
*int_ldmbuf
;
105 int ext_ldmbuf_size
, int_ldmbuf_size
;
106 int version
, seg
, nsegs
;
108 /* Fetch initial portion of the loadmap. */
109 if (target_read_memory (ldmaddr
, (gdb_byte
*) &ext_ldmbuf_partial
,
110 sizeof ext_ldmbuf_partial
))
112 /* Problem reading the target's memory. */
116 /* Extract the version. */
117 version
= extract_unsigned_integer (ext_ldmbuf_partial
.version
,
118 sizeof ext_ldmbuf_partial
.version
,
122 /* We only handle version 0. */
126 /* Extract the number of segments. */
127 nsegs
= extract_unsigned_integer (ext_ldmbuf_partial
.nsegs
,
128 sizeof ext_ldmbuf_partial
.nsegs
,
134 /* Allocate space for the complete (external) loadmap. */
135 ext_ldmbuf_size
= sizeof (struct ext_elf32_fdpic_loadmap
)
136 + (nsegs
- 1) * sizeof (struct ext_elf32_fdpic_loadseg
);
137 ext_ldmbuf
= xmalloc (ext_ldmbuf_size
);
139 /* Copy over the portion of the loadmap that's already been read. */
140 memcpy (ext_ldmbuf
, &ext_ldmbuf_partial
, sizeof ext_ldmbuf_partial
);
142 /* Read the rest of the loadmap from the target. */
143 if (target_read_memory (ldmaddr
+ sizeof ext_ldmbuf_partial
,
144 (gdb_byte
*) ext_ldmbuf
+ sizeof ext_ldmbuf_partial
,
145 ext_ldmbuf_size
- sizeof ext_ldmbuf_partial
))
147 /* Couldn't read rest of the loadmap. */
152 /* Allocate space into which to put information extract from the
153 external loadsegs. I.e, allocate the internal loadsegs. */
154 int_ldmbuf_size
= sizeof (struct int_elf32_fdpic_loadmap
)
155 + (nsegs
- 1) * sizeof (struct int_elf32_fdpic_loadseg
);
156 int_ldmbuf
= xmalloc (int_ldmbuf_size
);
158 /* Place extracted information in internal structs. */
159 int_ldmbuf
->version
= version
;
160 int_ldmbuf
->nsegs
= nsegs
;
161 for (seg
= 0; seg
< nsegs
; seg
++)
163 int_ldmbuf
->segs
[seg
].addr
164 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].addr
,
165 sizeof (ext_ldmbuf
->segs
[seg
].addr
),
167 int_ldmbuf
->segs
[seg
].p_vaddr
168 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_vaddr
,
169 sizeof (ext_ldmbuf
->segs
[seg
].p_vaddr
),
171 int_ldmbuf
->segs
[seg
].p_memsz
172 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_memsz
,
173 sizeof (ext_ldmbuf
->segs
[seg
].p_memsz
),
181 /* External link_map and elf32_fdpic_loadaddr struct definitions. */
183 typedef gdb_byte ext_ptr
[4];
185 struct ext_elf32_fdpic_loadaddr
187 ext_ptr map
; /* struct elf32_fdpic_loadmap *map; */
188 ext_ptr got_value
; /* void *got_value; */
193 struct ext_elf32_fdpic_loadaddr l_addr
;
195 /* Absolute file name object was found in. */
196 ext_ptr l_name
; /* char *l_name; */
198 /* Dynamic section of the shared object. */
199 ext_ptr l_ld
; /* ElfW(Dyn) *l_ld; */
201 /* Chain of loaded objects. */
202 ext_ptr l_next
, l_prev
; /* struct link_map *l_next, *l_prev; */
205 /* Link map info to include in an allocated so_list entry */
209 /* The loadmap, digested into an easier to use form. */
210 struct int_elf32_fdpic_loadmap
*map
;
211 /* The GOT address for this link map entry. */
213 /* The link map address, needed for frv_fetch_objfile_link_map(). */
216 /* Cached dynamic symbol table and dynamic relocs initialized and
217 used only by find_canonical_descriptor_in_load_object().
219 Note: kevinb/2004-02-26: It appears that calls to
220 bfd_canonicalize_dynamic_reloc() will use the same symbols as
221 those supplied to the first call to this function. Therefore,
222 it's important to NOT free the asymbol ** data structure
223 supplied to the first call. Thus the caching of the dynamic
224 symbols (dyn_syms) is critical for correct operation. The
225 caching of the dynamic relocations could be dispensed with. */
227 arelent
**dyn_relocs
;
228 int dyn_reloc_count
; /* number of dynamic relocs. */
232 /* The load map, got value, etc. are not available from the chain
233 of loaded shared objects. ``main_executable_lm_info'' provides
234 a way to get at this information so that it doesn't need to be
235 frequently recomputed. Initialized by frv_relocate_main_executable(). */
236 static struct lm_info
*main_executable_lm_info
;
238 static void frv_relocate_main_executable (void);
239 static CORE_ADDR
main_got (void);
240 static int enable_break2 (void);
246 bfd_lookup_symbol -- lookup the value for a specific symbol
250 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
254 An expensive way to lookup the value of a single symbol for
255 bfd's that are only temporary anyway. This is used by the
256 shared library support to find the address of the debugger
257 interface structures in the shared library.
259 Note that 0 is specifically allowed as an error return (no
264 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
268 asymbol
**symbol_table
;
269 unsigned int number_of_symbols
;
271 struct cleanup
*back_to
;
272 CORE_ADDR symaddr
= 0;
274 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
276 if (storage_needed
> 0)
278 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
279 back_to
= make_cleanup (xfree
, symbol_table
);
280 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
282 for (i
= 0; i
< number_of_symbols
; i
++)
284 sym
= *symbol_table
++;
285 if (strcmp (sym
->name
, symname
) == 0)
287 /* Bfd symbols are section relative. */
288 symaddr
= sym
->value
+ sym
->section
->vma
;
292 do_cleanups (back_to
);
298 /* Look for the symbol in the dynamic string table too. */
300 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
302 if (storage_needed
> 0)
304 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
305 back_to
= make_cleanup (xfree
, symbol_table
);
306 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
308 for (i
= 0; i
< number_of_symbols
; i
++)
310 sym
= *symbol_table
++;
311 if (strcmp (sym
->name
, symname
) == 0)
313 /* Bfd symbols are section relative. */
314 symaddr
= sym
->value
+ sym
->section
->vma
;
318 do_cleanups (back_to
);
329 open_symbol_file_object
333 void open_symbol_file_object (void *from_tty)
337 If no open symbol file, attempt to locate and open the main symbol
340 If FROM_TTYP dereferences to a non-zero integer, allow messages to
341 be printed. This parameter is a pointer rather than an int because
342 open_symbol_file_object() is called via catch_errors() and
343 catch_errors() requires a pointer argument. */
346 open_symbol_file_object (void *from_ttyp
)
352 /* Cached value for lm_base(), below. */
353 static CORE_ADDR lm_base_cache
= 0;
355 /* Link map address for main module. */
356 static CORE_ADDR main_lm_addr
= 0;
358 /* Return the address from which the link map chain may be found. On
359 the FR-V, this may be found in a number of ways. Assuming that the
360 main executable has already been relocated, the easiest way to find
361 this value is to look up the address of _GLOBAL_OFFSET_TABLE_. A
362 pointer to the start of the link map will be located at the word found
363 at _GLOBAL_OFFSET_TABLE_ + 8. (This is part of the dynamic linker
364 reserve area mandated by the ABI.) */
369 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
370 struct minimal_symbol
*got_sym
;
372 gdb_byte buf
[FRV_PTR_SIZE
];
374 /* One of our assumptions is that the main executable has been relocated.
375 Bail out if this has not happened. (Note that post_create_inferior()
376 in infcmd.c will call solib_add prior to solib_create_inferior_hook().
377 If we allow this to happen, lm_base_cache will be initialized with
379 if (main_executable_lm_info
== 0)
382 /* If we already have a cached value, return it. */
384 return lm_base_cache
;
386 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
,
391 fprintf_unfiltered (gdb_stdlog
,
392 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
396 addr
= SYMBOL_VALUE_ADDRESS (got_sym
) + 8;
399 fprintf_unfiltered (gdb_stdlog
,
400 "lm_base: _GLOBAL_OFFSET_TABLE_ + 8 = %s\n",
401 hex_string_custom (addr
, 8));
403 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
405 lm_base_cache
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
408 fprintf_unfiltered (gdb_stdlog
,
409 "lm_base: lm_base_cache = %s\n",
410 hex_string_custom (lm_base_cache
, 8));
412 return lm_base_cache
;
418 frv_current_sos -- build a list of currently loaded shared objects
422 struct so_list *frv_current_sos ()
426 Build a list of `struct so_list' objects describing the shared
427 objects currently loaded in the inferior. This list does not
428 include an entry for the main executable file.
430 Note that we only gather information directly available from the
431 inferior --- we don't examine any of the shared library files
432 themselves. The declaration of `struct so_list' says which fields
433 we provide values for. */
435 static struct so_list
*
436 frv_current_sos (void)
438 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
439 CORE_ADDR lm_addr
, mgot
;
440 struct so_list
*sos_head
= NULL
;
441 struct so_list
**sos_next_ptr
= &sos_head
;
443 /* Make sure that the main executable has been relocated. This is
444 required in order to find the address of the global offset table,
445 which in turn is used to find the link map info. (See lm_base()
448 Note that the relocation of the main executable is also performed
449 by SOLIB_CREATE_INFERIOR_HOOK(), however, in the case of core
450 files, this hook is called too late in order to be of benefit to
451 SOLIB_ADD. SOLIB_ADD eventually calls this this function,
452 frv_current_sos, and also precedes the call to
453 SOLIB_CREATE_INFERIOR_HOOK(). (See post_create_inferior() in
455 if (main_executable_lm_info
== 0 && core_bfd
!= NULL
)
456 frv_relocate_main_executable ();
458 /* Fetch the GOT corresponding to the main executable. */
461 /* Locate the address of the first link map struct. */
462 lm_addr
= lm_base ();
464 /* We have at least one link map entry. Fetch the the lot of them,
465 building the solist chain. */
468 struct ext_link_map lm_buf
;
472 fprintf_unfiltered (gdb_stdlog
,
473 "current_sos: reading link_map entry at %s\n",
474 hex_string_custom (lm_addr
, 8));
476 if (target_read_memory (lm_addr
, (gdb_byte
*) &lm_buf
, sizeof (lm_buf
)) != 0)
478 warning (_("frv_current_sos: Unable to read link map entry. Shared object chain may be incomplete."));
483 = extract_unsigned_integer (lm_buf
.l_addr
.got_value
,
484 sizeof (lm_buf
.l_addr
.got_value
),
486 /* If the got_addr is the same as mgotr, then we're looking at the
487 entry for the main executable. By convention, we don't include
488 this in the list of shared objects. */
489 if (got_addr
!= mgot
)
493 struct int_elf32_fdpic_loadmap
*loadmap
;
497 /* Fetch the load map address. */
498 addr
= extract_unsigned_integer (lm_buf
.l_addr
.map
,
499 sizeof lm_buf
.l_addr
.map
,
501 loadmap
= fetch_loadmap (addr
);
504 warning (_("frv_current_sos: Unable to fetch load map. Shared object chain may be incomplete."));
508 sop
= xcalloc (1, sizeof (struct so_list
));
509 sop
->lm_info
= xcalloc (1, sizeof (struct lm_info
));
510 sop
->lm_info
->map
= loadmap
;
511 sop
->lm_info
->got_value
= got_addr
;
512 sop
->lm_info
->lm_addr
= lm_addr
;
513 /* Fetch the name. */
514 addr
= extract_unsigned_integer (lm_buf
.l_name
,
515 sizeof (lm_buf
.l_name
),
517 target_read_string (addr
, &name_buf
, SO_NAME_MAX_PATH_SIZE
- 1,
521 fprintf_unfiltered (gdb_stdlog
, "current_sos: name = %s\n",
525 warning (_("Can't read pathname for link map entry: %s."),
526 safe_strerror (errcode
));
529 strncpy (sop
->so_name
, name_buf
, SO_NAME_MAX_PATH_SIZE
- 1);
530 sop
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
532 strcpy (sop
->so_original_name
, sop
->so_name
);
536 sos_next_ptr
= &sop
->next
;
540 main_lm_addr
= lm_addr
;
543 lm_addr
= extract_unsigned_integer (lm_buf
.l_next
,
544 sizeof (lm_buf
.l_next
), byte_order
);
553 /* Return 1 if PC lies in the dynamic symbol resolution code of the
556 static CORE_ADDR interp_text_sect_low
;
557 static CORE_ADDR interp_text_sect_high
;
558 static CORE_ADDR interp_plt_sect_low
;
559 static CORE_ADDR interp_plt_sect_high
;
562 frv_in_dynsym_resolve_code (CORE_ADDR pc
)
564 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
565 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
566 || in_plt_section (pc
, NULL
));
569 /* Given a loadmap and an address, return the displacement needed
570 to relocate the address. */
573 displacement_from_map (struct int_elf32_fdpic_loadmap
*map
,
578 for (seg
= 0; seg
< map
->nsegs
; seg
++)
580 if (map
->segs
[seg
].p_vaddr
<= addr
581 && addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
583 return map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
590 /* Print a warning about being unable to set the dynamic linker
594 enable_break_failure_warning (void)
596 warning (_("Unable to find dynamic linker breakpoint function.\n"
597 "GDB will be unable to debug shared library initializers\n"
598 "and track explicitly loaded dynamic code."));
605 enable_break -- arrange for dynamic linker to hit breakpoint
609 int enable_break (void)
613 The dynamic linkers has, as part of its debugger interface, support
614 for arranging for the inferior to hit a breakpoint after mapping in
615 the shared libraries. This function enables that breakpoint.
617 On the FR-V, using the shared library (FDPIC) ABI, the symbol
618 _dl_debug_addr points to the r_debug struct which contains
619 a field called r_brk. r_brk is the address of the function
620 descriptor upon which a breakpoint must be placed. Being a
621 function descriptor, we must extract the entry point in order
622 to set the breakpoint.
624 Our strategy will be to get the .interp section from the
625 executable. This section will provide us with the name of the
626 interpreter. We'll open the interpreter and then look up
627 the address of _dl_debug_addr. We then relocate this address
628 using the interpreter's loadmap. Once the relocated address
629 is known, we fetch the value (address) corresponding to r_brk
630 and then use that value to fetch the entry point of the function
635 static int enable_break2_done
= 0;
640 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
643 asection
*interp_sect
;
645 if (enable_break2_done
)
648 interp_text_sect_low
= interp_text_sect_high
= 0;
649 interp_plt_sect_low
= interp_plt_sect_high
= 0;
651 /* Find the .interp section; if not found, warn the user and drop
652 into the old breakpoint at symbol code. */
653 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
656 unsigned int interp_sect_size
;
660 CORE_ADDR addr
, interp_loadmap_addr
;
661 gdb_byte addr_buf
[FRV_PTR_SIZE
];
662 struct int_elf32_fdpic_loadmap
*ldm
;
663 volatile struct gdb_exception ex
;
665 /* Read the contents of the .interp section into a local buffer;
666 the contents specify the dynamic linker this program uses. */
667 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
668 buf
= alloca (interp_sect_size
);
669 bfd_get_section_contents (exec_bfd
, interp_sect
,
670 buf
, 0, interp_sect_size
);
672 /* Now we need to figure out where the dynamic linker was
673 loaded so that we can load its symbols and place a breakpoint
674 in the dynamic linker itself.
676 This address is stored on the stack. However, I've been unable
677 to find any magic formula to find it for Solaris (appears to
678 be trivial on GNU/Linux). Therefore, we have to try an alternate
679 mechanism to find the dynamic linker's base address. */
681 TRY_CATCH (ex
, RETURN_MASK_ALL
)
683 tmp_bfd
= solib_bfd_open (buf
);
687 enable_break_failure_warning ();
691 status
= frv_fdpic_loadmap_addresses (target_gdbarch
,
692 &interp_loadmap_addr
, 0);
695 warning (_("Unable to determine dynamic linker loadmap address."));
696 enable_break_failure_warning ();
702 fprintf_unfiltered (gdb_stdlog
,
703 "enable_break: interp_loadmap_addr = %s\n",
704 hex_string_custom (interp_loadmap_addr
, 8));
706 ldm
= fetch_loadmap (interp_loadmap_addr
);
709 warning (_("Unable to load dynamic linker loadmap at address %s."),
710 hex_string_custom (interp_loadmap_addr
, 8));
711 enable_break_failure_warning ();
716 /* Record the relocated start and end address of the dynamic linker
717 text and plt section for svr4_in_dynsym_resolve_code. */
718 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
722 = bfd_section_vma (tmp_bfd
, interp_sect
);
724 += displacement_from_map (ldm
, interp_text_sect_low
);
725 interp_text_sect_high
726 = interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
728 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
731 interp_plt_sect_low
=
732 bfd_section_vma (tmp_bfd
, interp_sect
);
734 += displacement_from_map (ldm
, interp_plt_sect_low
);
735 interp_plt_sect_high
=
736 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
739 addr
= bfd_lookup_symbol (tmp_bfd
, "_dl_debug_addr");
742 warning (_("Could not find symbol _dl_debug_addr in dynamic linker"));
743 enable_break_failure_warning ();
749 fprintf_unfiltered (gdb_stdlog
,
750 "enable_break: _dl_debug_addr (prior to relocation) = %s\n",
751 hex_string_custom (addr
, 8));
753 addr
+= displacement_from_map (ldm
, addr
);
756 fprintf_unfiltered (gdb_stdlog
,
757 "enable_break: _dl_debug_addr (after relocation) = %s\n",
758 hex_string_custom (addr
, 8));
760 /* Fetch the address of the r_debug struct. */
761 if (target_read_memory (addr
, addr_buf
, sizeof addr_buf
) != 0)
763 warning (_("Unable to fetch contents of _dl_debug_addr (at address %s) from dynamic linker"),
764 hex_string_custom (addr
, 8));
766 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
, byte_order
);
769 fprintf_unfiltered (gdb_stdlog
,
770 "enable_break: _dl_debug_addr[0..3] = %s\n",
771 hex_string_custom (addr
, 8));
773 /* If it's zero, then the ldso hasn't initialized yet, and so
774 there are no shared libs yet loaded. */
778 fprintf_unfiltered (gdb_stdlog
,
779 "enable_break: ldso not yet initialized\n");
780 /* Do not warn, but mark to run again. */
784 /* Fetch the r_brk field. It's 8 bytes from the start of
786 if (target_read_memory (addr
+ 8, addr_buf
, sizeof addr_buf
) != 0)
788 warning (_("Unable to fetch _dl_debug_addr->r_brk (at address %s) from dynamic linker"),
789 hex_string_custom (addr
+ 8, 8));
790 enable_break_failure_warning ();
794 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
, byte_order
);
796 /* Now fetch the function entry point. */
797 if (target_read_memory (addr
, addr_buf
, sizeof addr_buf
) != 0)
799 warning (_("Unable to fetch _dl_debug_addr->.r_brk entry point (at address %s) from dynamic linker"),
800 hex_string_custom (addr
, 8));
801 enable_break_failure_warning ();
805 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
, byte_order
);
807 /* We're done with the temporary bfd. */
810 /* We're also done with the loadmap. */
813 /* Remove all the solib event breakpoints. Their addresses
814 may have changed since the last time we ran the program. */
815 remove_solib_event_breakpoints ();
817 /* Now (finally!) create the solib breakpoint. */
818 create_solib_event_breakpoint (target_gdbarch
, addr
);
820 enable_break2_done
= 1;
825 /* Tell the user we couldn't set a dynamic linker breakpoint. */
826 enable_break_failure_warning ();
828 /* Failure return. */
835 asection
*interp_sect
;
837 if (symfile_objfile
== NULL
)
840 fprintf_unfiltered (gdb_stdlog
,
841 "enable_break: No symbol file found.\n");
845 if (!symfile_objfile
->ei
.entry_point_p
)
848 fprintf_unfiltered (gdb_stdlog
,
849 "enable_break: Symbol file has no entry point.\n");
853 /* Check for the presence of a .interp section. If there is no
854 such section, the executable is statically linked. */
856 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
858 if (interp_sect
== NULL
)
861 fprintf_unfiltered (gdb_stdlog
,
862 "enable_break: No .interp section found.\n");
866 create_solib_event_breakpoint (target_gdbarch
,
867 symfile_objfile
->ei
.entry_point
);
870 fprintf_unfiltered (gdb_stdlog
,
871 "enable_break: solib event breakpoint placed at entry point: %s\n",
872 hex_string_custom (symfile_objfile
->ei
.entry_point
, 8));
880 special_symbol_handling -- additional shared library symbol handling
884 void special_symbol_handling ()
888 Once the symbols from a shared object have been loaded in the usual
889 way, we are called to do any system specific symbol handling that
895 frv_special_symbol_handling (void)
897 /* Nothing needed (yet) for FRV. */
901 frv_relocate_main_executable (void)
904 CORE_ADDR exec_addr
, interp_addr
;
905 struct int_elf32_fdpic_loadmap
*ldm
;
906 struct cleanup
*old_chain
;
907 struct section_offsets
*new_offsets
;
909 struct obj_section
*osect
;
911 status
= frv_fdpic_loadmap_addresses (target_gdbarch
,
912 &interp_addr
, &exec_addr
);
914 if (status
< 0 || (exec_addr
== 0 && interp_addr
== 0))
916 /* Not using FDPIC ABI, so do nothing. */
920 /* Fetch the loadmap located at ``exec_addr''. */
921 ldm
= fetch_loadmap (exec_addr
);
923 error (_("Unable to load the executable's loadmap."));
925 if (main_executable_lm_info
)
926 xfree (main_executable_lm_info
);
927 main_executable_lm_info
= xcalloc (1, sizeof (struct lm_info
));
928 main_executable_lm_info
->map
= ldm
;
930 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
931 sizeof (struct section_offsets
));
932 old_chain
= make_cleanup (xfree
, new_offsets
);
935 ALL_OBJFILE_OSECTIONS (symfile_objfile
, osect
)
937 CORE_ADDR orig_addr
, addr
, offset
;
941 osect_idx
= osect
->the_bfd_section
->index
;
943 /* Current address of section. */
944 addr
= obj_section_addr (osect
);
945 /* Offset from where this section started. */
946 offset
= ANOFFSET (symfile_objfile
->section_offsets
, osect_idx
);
947 /* Original address prior to any past relocations. */
948 orig_addr
= addr
- offset
;
950 for (seg
= 0; seg
< ldm
->nsegs
; seg
++)
952 if (ldm
->segs
[seg
].p_vaddr
<= orig_addr
953 && orig_addr
< ldm
->segs
[seg
].p_vaddr
+ ldm
->segs
[seg
].p_memsz
)
955 new_offsets
->offsets
[osect_idx
]
956 = ldm
->segs
[seg
].addr
- ldm
->segs
[seg
].p_vaddr
;
958 if (new_offsets
->offsets
[osect_idx
] != offset
)
966 objfile_relocate (symfile_objfile
, new_offsets
);
968 do_cleanups (old_chain
);
970 /* Now that symfile_objfile has been relocated, we can compute the
971 GOT value and stash it away. */
972 main_executable_lm_info
->got_value
= main_got ();
979 frv_solib_create_inferior_hook -- shared library startup support
983 void frv_solib_create_inferior_hook ()
987 When gdb starts up the inferior, it nurses it along (through the
988 shell) until it is ready to execute it's first instruction. At this
989 point, this function gets called via expansion of the macro
990 SOLIB_CREATE_INFERIOR_HOOK.
992 For the FR-V shared library ABI (FDPIC), the main executable
993 needs to be relocated. The shared library breakpoints also need
998 frv_solib_create_inferior_hook (int from_tty
)
1000 /* Relocate main executable. */
1001 frv_relocate_main_executable ();
1003 /* Enable shared library breakpoints. */
1004 if (!enable_break ())
1006 warning (_("shared library handler failed to enable breakpoint"));
1012 frv_clear_solib (void)
1015 enable_break2_done
= 0;
1017 if (main_executable_lm_info
!= 0)
1019 xfree (main_executable_lm_info
->map
);
1020 xfree (main_executable_lm_info
->dyn_syms
);
1021 xfree (main_executable_lm_info
->dyn_relocs
);
1022 xfree (main_executable_lm_info
);
1023 main_executable_lm_info
= 0;
1028 frv_free_so (struct so_list
*so
)
1030 xfree (so
->lm_info
->map
);
1031 xfree (so
->lm_info
->dyn_syms
);
1032 xfree (so
->lm_info
->dyn_relocs
);
1033 xfree (so
->lm_info
);
1037 frv_relocate_section_addresses (struct so_list
*so
,
1038 struct target_section
*sec
)
1041 struct int_elf32_fdpic_loadmap
*map
;
1043 map
= so
->lm_info
->map
;
1045 for (seg
= 0; seg
< map
->nsegs
; seg
++)
1047 if (map
->segs
[seg
].p_vaddr
<= sec
->addr
1048 && sec
->addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
1050 CORE_ADDR displ
= map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
1053 sec
->endaddr
+= displ
;
1059 /* Return the GOT address associated with the main executable. Return
1060 0 if it can't be found. */
1065 struct minimal_symbol
*got_sym
;
1067 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
, symfile_objfile
);
1071 return SYMBOL_VALUE_ADDRESS (got_sym
);
1074 /* Find the global pointer for the given function address ADDR. */
1077 frv_fdpic_find_global_pointer (CORE_ADDR addr
)
1081 so
= master_so_list ();
1085 struct int_elf32_fdpic_loadmap
*map
;
1087 map
= so
->lm_info
->map
;
1089 for (seg
= 0; seg
< map
->nsegs
; seg
++)
1091 if (map
->segs
[seg
].addr
<= addr
1092 && addr
< map
->segs
[seg
].addr
+ map
->segs
[seg
].p_memsz
)
1093 return so
->lm_info
->got_value
;
1099 /* Didn't find it it any of the shared objects. So assume it's in the
1104 /* Forward declarations for frv_fdpic_find_canonical_descriptor(). */
1105 static CORE_ADDR find_canonical_descriptor_in_load_object
1106 (CORE_ADDR
, CORE_ADDR
, char *, bfd
*, struct lm_info
*);
1108 /* Given a function entry point, attempt to find the canonical descriptor
1109 associated with that entry point. Return 0 if no canonical descriptor
1113 frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point
)
1117 CORE_ADDR got_value
;
1118 struct int_elf32_fdpic_loadmap
*ldm
= 0;
1121 CORE_ADDR exec_loadmap_addr
;
1123 /* Fetch the corresponding global pointer for the entry point. */
1124 got_value
= frv_fdpic_find_global_pointer (entry_point
);
1126 /* Attempt to find the name of the function. If the name is available,
1127 it'll be used as an aid in finding matching functions in the dynamic
1129 sym
= find_pc_function (entry_point
);
1133 name
= SYMBOL_LINKAGE_NAME (sym
);
1135 /* Check the main executable. */
1136 addr
= find_canonical_descriptor_in_load_object
1137 (entry_point
, got_value
, name
, symfile_objfile
->obfd
,
1138 main_executable_lm_info
);
1140 /* If descriptor not found via main executable, check each load object
1141 in list of shared objects. */
1146 so
= master_so_list ();
1149 addr
= find_canonical_descriptor_in_load_object
1150 (entry_point
, got_value
, name
, so
->abfd
, so
->lm_info
);
1163 find_canonical_descriptor_in_load_object
1164 (CORE_ADDR entry_point
, CORE_ADDR got_value
, char *name
, bfd
*abfd
,
1167 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
1172 /* Nothing to do if no bfd. */
1176 /* Nothing to do if no link map. */
1180 /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations.
1181 (More about this later.) But in order to fetch the relocs, we
1182 need to first fetch the dynamic symbols. These symbols need to
1183 be cached due to the way that bfd_canonicalize_dynamic_reloc()
1184 works. (See the comments in the declaration of struct lm_info
1185 for more information.) */
1186 if (lm
->dyn_syms
== NULL
)
1188 long storage_needed
;
1189 unsigned int number_of_symbols
;
1191 /* Determine amount of space needed to hold the dynamic symbol table. */
1192 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1194 /* If there are no dynamic symbols, there's nothing to do. */
1195 if (storage_needed
<= 0)
1198 /* Allocate space for the dynamic symbol table. */
1199 lm
->dyn_syms
= (asymbol
**) xmalloc (storage_needed
);
1201 /* Fetch the dynamic symbol table. */
1202 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, lm
->dyn_syms
);
1204 if (number_of_symbols
== 0)
1208 /* Fetch the dynamic relocations if not already cached. */
1209 if (lm
->dyn_relocs
== NULL
)
1211 long storage_needed
;
1213 /* Determine amount of space needed to hold the dynamic relocs. */
1214 storage_needed
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1216 /* Bail out if there are no dynamic relocs. */
1217 if (storage_needed
<= 0)
1220 /* Allocate space for the relocs. */
1221 lm
->dyn_relocs
= (arelent
**) xmalloc (storage_needed
);
1223 /* Fetch the dynamic relocs. */
1225 = bfd_canonicalize_dynamic_reloc (abfd
, lm
->dyn_relocs
, lm
->dyn_syms
);
1228 /* Search the dynamic relocs. */
1229 for (i
= 0; i
< lm
->dyn_reloc_count
; i
++)
1231 rel
= lm
->dyn_relocs
[i
];
1233 /* Relocs of interest are those which meet the following
1236 - the names match (assuming the caller could provide
1237 a name which matches ``entry_point'').
1238 - the relocation type must be R_FRV_FUNCDESC. Relocs
1239 of this type are used (by the dynamic linker) to
1240 look up the address of a canonical descriptor (allocating
1241 it if need be) and initializing the GOT entry referred
1242 to by the offset to the address of the descriptor.
1244 These relocs of interest may be used to obtain a
1245 candidate descriptor by first adjusting the reloc's
1246 address according to the link map and then dereferencing
1247 this address (which is a GOT entry) to obtain a descriptor
1249 if ((name
== 0 || strcmp (name
, (*rel
->sym_ptr_ptr
)->name
) == 0)
1250 && rel
->howto
->type
== R_FRV_FUNCDESC
)
1252 gdb_byte buf
[FRV_PTR_SIZE
];
1254 /* Compute address of address of candidate descriptor. */
1255 addr
= rel
->address
+ displacement_from_map (lm
->map
, rel
->address
);
1257 /* Fetch address of candidate descriptor. */
1258 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1260 addr
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
1262 /* Check for matching entry point. */
1263 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1265 if (extract_unsigned_integer (buf
, sizeof buf
, byte_order
)
1269 /* Check for matching got value. */
1270 if (target_read_memory (addr
+ 4, buf
, sizeof buf
) != 0)
1272 if (extract_unsigned_integer (buf
, sizeof buf
, byte_order
)
1276 /* Match was successful! Exit loop. */
1284 /* Given an objfile, return the address of its link map. This value is
1285 needed for TLS support. */
1287 frv_fetch_objfile_link_map (struct objfile
*objfile
)
1291 /* Cause frv_current_sos() to be run if it hasn't been already. */
1292 if (main_lm_addr
== 0)
1293 solib_add (0, 0, 0, 1);
1295 /* frv_current_sos() will set main_lm_addr for the main executable. */
1296 if (objfile
== symfile_objfile
)
1297 return main_lm_addr
;
1299 /* The other link map addresses may be found by examining the list
1300 of shared libraries. */
1301 for (so
= master_so_list (); so
; so
= so
->next
)
1303 if (so
->objfile
== objfile
)
1304 return so
->lm_info
->lm_addr
;
1311 struct target_so_ops frv_so_ops
;
1313 /* Provide a prototype to silence -Wmissing-prototypes. */
1314 extern initialize_file_ftype _initialize_frv_solib
;
1317 _initialize_frv_solib (void)
1319 frv_so_ops
.relocate_section_addresses
= frv_relocate_section_addresses
;
1320 frv_so_ops
.free_so
= frv_free_so
;
1321 frv_so_ops
.clear_solib
= frv_clear_solib
;
1322 frv_so_ops
.solib_create_inferior_hook
= frv_solib_create_inferior_hook
;
1323 frv_so_ops
.special_symbol_handling
= frv_special_symbol_handling
;
1324 frv_so_ops
.current_sos
= frv_current_sos
;
1325 frv_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1326 frv_so_ops
.in_dynsym_resolve_code
= frv_in_dynsym_resolve_code
;
1327 frv_so_ops
.bfd_open
= solib_bfd_open
;
1329 /* Debug this file's internals. */
1330 add_setshow_zinteger_cmd ("solib-frv", class_maintenance
,
1331 &solib_frv_debug
, _("\
1332 Set internal debugging of shared library code for FR-V."), _("\
1333 Show internal debugging of shared library code for FR-V."), _("\
1334 When non-zero, FR-V solib specific internal debugging is enabled."),
1336 NULL
, /* FIXME: i18n: */
1337 &setdebuglist
, &showdebuglist
);