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"
35 /* Flag which indicates whether internal debug messages should be printed. */
36 static int solib_frv_debug
;
38 /* FR-V pointers are four bytes wide. */
39 enum { FRV_PTR_SIZE
= 4 };
41 /* Representation of loadmap and related structs for the FR-V FDPIC ABI. */
43 /* External versions; the size and alignment of the fields should be
44 the same as those on the target. When loaded, the placement of
45 the bits in each field will be the same as on the target. */
46 typedef gdb_byte ext_Elf32_Half
[2];
47 typedef gdb_byte ext_Elf32_Addr
[4];
48 typedef gdb_byte ext_Elf32_Word
[4];
50 struct ext_elf32_fdpic_loadseg
52 /* Core address to which the segment is mapped. */
54 /* VMA recorded in the program header. */
55 ext_Elf32_Addr p_vaddr
;
56 /* Size of this segment in memory. */
57 ext_Elf32_Word p_memsz
;
60 struct ext_elf32_fdpic_loadmap
{
61 /* Protocol version number, must be zero. */
62 ext_Elf32_Half version
;
63 /* Number of segments in this map. */
65 /* The actual memory map. */
66 struct ext_elf32_fdpic_loadseg segs
[1 /* nsegs, actually */];
69 /* Internal versions; the types are GDB types and the data in each
70 of the fields is (or will be) decoded from the external struct
71 for ease of consumption. */
72 struct int_elf32_fdpic_loadseg
74 /* Core address to which the segment is mapped. */
76 /* VMA recorded in the program header. */
78 /* Size of this segment in memory. */
82 struct int_elf32_fdpic_loadmap
{
83 /* Protocol version number, must be zero. */
85 /* Number of segments in this map. */
87 /* The actual memory map. */
88 struct int_elf32_fdpic_loadseg segs
[1 /* nsegs, actually */];
91 /* Given address LDMADDR, fetch and decode the loadmap at that address.
92 Return NULL if there is a problem reading the target memory or if
93 there doesn't appear to be a loadmap at the given address. The
94 allocated space (representing the loadmap) returned by this
95 function may be freed via a single call to xfree(). */
97 static struct int_elf32_fdpic_loadmap
*
98 fetch_loadmap (CORE_ADDR ldmaddr
)
100 struct ext_elf32_fdpic_loadmap ext_ldmbuf_partial
;
101 struct ext_elf32_fdpic_loadmap
*ext_ldmbuf
;
102 struct int_elf32_fdpic_loadmap
*int_ldmbuf
;
103 int ext_ldmbuf_size
, int_ldmbuf_size
;
104 int version
, seg
, nsegs
;
106 /* Fetch initial portion of the loadmap. */
107 if (target_read_memory (ldmaddr
, (gdb_byte
*) &ext_ldmbuf_partial
,
108 sizeof ext_ldmbuf_partial
))
110 /* Problem reading the target's memory. */
114 /* Extract the version. */
115 version
= extract_unsigned_integer (ext_ldmbuf_partial
.version
,
116 sizeof ext_ldmbuf_partial
.version
);
119 /* We only handle version 0. */
123 /* Extract the number of segments. */
124 nsegs
= extract_unsigned_integer (ext_ldmbuf_partial
.nsegs
,
125 sizeof ext_ldmbuf_partial
.nsegs
);
127 /* Allocate space for the complete (external) loadmap. */
128 ext_ldmbuf_size
= sizeof (struct ext_elf32_fdpic_loadmap
)
129 + (nsegs
- 1) * sizeof (struct ext_elf32_fdpic_loadseg
);
130 ext_ldmbuf
= xmalloc (ext_ldmbuf_size
);
132 /* Copy over the portion of the loadmap that's already been read. */
133 memcpy (ext_ldmbuf
, &ext_ldmbuf_partial
, sizeof ext_ldmbuf_partial
);
135 /* Read the rest of the loadmap from the target. */
136 if (target_read_memory (ldmaddr
+ sizeof ext_ldmbuf_partial
,
137 (gdb_byte
*) ext_ldmbuf
+ sizeof ext_ldmbuf_partial
,
138 ext_ldmbuf_size
- sizeof ext_ldmbuf_partial
))
140 /* Couldn't read rest of the loadmap. */
145 /* Allocate space into which to put information extract from the
146 external loadsegs. I.e, allocate the internal loadsegs. */
147 int_ldmbuf_size
= sizeof (struct int_elf32_fdpic_loadmap
)
148 + (nsegs
- 1) * sizeof (struct int_elf32_fdpic_loadseg
);
149 int_ldmbuf
= xmalloc (int_ldmbuf_size
);
151 /* Place extracted information in internal structs. */
152 int_ldmbuf
->version
= version
;
153 int_ldmbuf
->nsegs
= nsegs
;
154 for (seg
= 0; seg
< nsegs
; seg
++)
156 int_ldmbuf
->segs
[seg
].addr
157 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].addr
,
158 sizeof (ext_ldmbuf
->segs
[seg
].addr
));
159 int_ldmbuf
->segs
[seg
].p_vaddr
160 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_vaddr
,
161 sizeof (ext_ldmbuf
->segs
[seg
].p_vaddr
));
162 int_ldmbuf
->segs
[seg
].p_memsz
163 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_memsz
,
164 sizeof (ext_ldmbuf
->segs
[seg
].p_memsz
));
171 /* External link_map and elf32_fdpic_loadaddr struct definitions. */
173 typedef gdb_byte ext_ptr
[4];
175 struct ext_elf32_fdpic_loadaddr
177 ext_ptr map
; /* struct elf32_fdpic_loadmap *map; */
178 ext_ptr got_value
; /* void *got_value; */
183 struct ext_elf32_fdpic_loadaddr l_addr
;
185 /* Absolute file name object was found in. */
186 ext_ptr l_name
; /* char *l_name; */
188 /* Dynamic section of the shared object. */
189 ext_ptr l_ld
; /* ElfW(Dyn) *l_ld; */
191 /* Chain of loaded objects. */
192 ext_ptr l_next
, l_prev
; /* struct link_map *l_next, *l_prev; */
195 /* Link map info to include in an allocated so_list entry */
199 /* The loadmap, digested into an easier to use form. */
200 struct int_elf32_fdpic_loadmap
*map
;
201 /* The GOT address for this link map entry. */
203 /* The link map address, needed for frv_fetch_objfile_link_map(). */
206 /* Cached dynamic symbol table and dynamic relocs initialized and
207 used only by find_canonical_descriptor_in_load_object().
209 Note: kevinb/2004-02-26: It appears that calls to
210 bfd_canonicalize_dynamic_reloc() will use the same symbols as
211 those supplied to the first call to this function. Therefore,
212 it's important to NOT free the asymbol ** data structure
213 supplied to the first call. Thus the caching of the dynamic
214 symbols (dyn_syms) is critical for correct operation. The
215 caching of the dynamic relocations could be dispensed with. */
217 arelent
**dyn_relocs
;
218 int dyn_reloc_count
; /* number of dynamic relocs. */
222 /* The load map, got value, etc. are not available from the chain
223 of loaded shared objects. ``main_executable_lm_info'' provides
224 a way to get at this information so that it doesn't need to be
225 frequently recomputed. Initialized by frv_relocate_main_executable(). */
226 static struct lm_info
*main_executable_lm_info
;
228 static void frv_relocate_main_executable (void);
229 static CORE_ADDR
main_got (void);
230 static int enable_break2 (void);
236 bfd_lookup_symbol -- lookup the value for a specific symbol
240 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
244 An expensive way to lookup the value of a single symbol for
245 bfd's that are only temporary anyway. This is used by the
246 shared library support to find the address of the debugger
247 interface structures in the shared library.
249 Note that 0 is specifically allowed as an error return (no
254 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
258 asymbol
**symbol_table
;
259 unsigned int number_of_symbols
;
261 struct cleanup
*back_to
;
262 CORE_ADDR symaddr
= 0;
264 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
266 if (storage_needed
> 0)
268 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
269 back_to
= make_cleanup (xfree
, symbol_table
);
270 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
272 for (i
= 0; i
< number_of_symbols
; i
++)
274 sym
= *symbol_table
++;
275 if (strcmp (sym
->name
, symname
) == 0)
277 /* Bfd symbols are section relative. */
278 symaddr
= sym
->value
+ sym
->section
->vma
;
282 do_cleanups (back_to
);
288 /* Look for the symbol in the dynamic string table too. */
290 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
292 if (storage_needed
> 0)
294 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
295 back_to
= make_cleanup (xfree
, symbol_table
);
296 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
298 for (i
= 0; i
< number_of_symbols
; i
++)
300 sym
= *symbol_table
++;
301 if (strcmp (sym
->name
, symname
) == 0)
303 /* Bfd symbols are section relative. */
304 symaddr
= sym
->value
+ sym
->section
->vma
;
308 do_cleanups (back_to
);
319 open_symbol_file_object
323 void open_symbol_file_object (void *from_tty)
327 If no open symbol file, attempt to locate and open the main symbol
330 If FROM_TTYP dereferences to a non-zero integer, allow messages to
331 be printed. This parameter is a pointer rather than an int because
332 open_symbol_file_object() is called via catch_errors() and
333 catch_errors() requires a pointer argument. */
336 open_symbol_file_object (void *from_ttyp
)
342 /* Cached value for lm_base(), below. */
343 static CORE_ADDR lm_base_cache
= 0;
345 /* Link map address for main module. */
346 static CORE_ADDR main_lm_addr
= 0;
348 /* Return the address from which the link map chain may be found. On
349 the FR-V, this may be found in a number of ways. Assuming that the
350 main executable has already been relocated, the easiest way to find
351 this value is to look up the address of _GLOBAL_OFFSET_TABLE_. A
352 pointer to the start of the link map will be located at the word found
353 at _GLOBAL_OFFSET_TABLE_ + 8. (This is part of the dynamic linker
354 reserve area mandated by the ABI.) */
359 struct minimal_symbol
*got_sym
;
361 gdb_byte buf
[FRV_PTR_SIZE
];
363 /* If we already have a cached value, return it. */
365 return lm_base_cache
;
367 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
,
372 fprintf_unfiltered (gdb_stdlog
,
373 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
377 addr
= SYMBOL_VALUE_ADDRESS (got_sym
) + 8;
380 fprintf_unfiltered (gdb_stdlog
,
381 "lm_base: _GLOBAL_OFFSET_TABLE_ + 8 = %s\n",
382 hex_string_custom (addr
, 8));
384 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
386 lm_base_cache
= extract_unsigned_integer (buf
, sizeof buf
);
389 fprintf_unfiltered (gdb_stdlog
,
390 "lm_base: lm_base_cache = %s\n",
391 hex_string_custom (lm_base_cache
, 8));
393 return lm_base_cache
;
399 frv_current_sos -- build a list of currently loaded shared objects
403 struct so_list *frv_current_sos ()
407 Build a list of `struct so_list' objects describing the shared
408 objects currently loaded in the inferior. This list does not
409 include an entry for the main executable file.
411 Note that we only gather information directly available from the
412 inferior --- we don't examine any of the shared library files
413 themselves. The declaration of `struct so_list' says which fields
414 we provide values for. */
416 static struct so_list
*
417 frv_current_sos (void)
419 CORE_ADDR lm_addr
, mgot
;
420 struct so_list
*sos_head
= NULL
;
421 struct so_list
**sos_next_ptr
= &sos_head
;
423 /* Make sure that the main executable has been relocated. This is
424 required in order to find the address of the global offset table,
425 which in turn is used to find the link map info. (See lm_base()
428 Note that the relocation of the main executable is also performed
429 by SOLIB_CREATE_INFERIOR_HOOK(), however, in the case of core
430 files, this hook is called too late in order to be of benefit to
431 SOLIB_ADD. SOLIB_ADD eventually calls this this function,
432 frv_current_sos, and also precedes the call to
433 SOLIB_CREATE_INFERIOR_HOOK(). (See post_create_inferior() in
435 if (main_executable_lm_info
== 0 && core_bfd
!= NULL
)
436 frv_relocate_main_executable ();
438 /* Fetch the GOT corresponding to the main executable. */
441 /* Locate the address of the first link map struct. */
442 lm_addr
= lm_base ();
444 /* We have at least one link map entry. Fetch the the lot of them,
445 building the solist chain. */
448 struct ext_link_map lm_buf
;
452 fprintf_unfiltered (gdb_stdlog
,
453 "current_sos: reading link_map entry at %s\n",
454 hex_string_custom (lm_addr
, 8));
456 if (target_read_memory (lm_addr
, (gdb_byte
*) &lm_buf
, sizeof (lm_buf
)) != 0)
458 warning (_("frv_current_sos: Unable to read link map entry. Shared object chain may be incomplete."));
463 = extract_unsigned_integer (lm_buf
.l_addr
.got_value
,
464 sizeof (lm_buf
.l_addr
.got_value
));
465 /* If the got_addr is the same as mgotr, then we're looking at the
466 entry for the main executable. By convention, we don't include
467 this in the list of shared objects. */
468 if (got_addr
!= mgot
)
472 struct int_elf32_fdpic_loadmap
*loadmap
;
476 /* Fetch the load map address. */
477 addr
= extract_unsigned_integer (lm_buf
.l_addr
.map
,
478 sizeof lm_buf
.l_addr
.map
);
479 loadmap
= fetch_loadmap (addr
);
482 warning (_("frv_current_sos: Unable to fetch load map. Shared object chain may be incomplete."));
486 sop
= xcalloc (1, sizeof (struct so_list
));
487 sop
->lm_info
= xcalloc (1, sizeof (struct lm_info
));
488 sop
->lm_info
->map
= loadmap
;
489 sop
->lm_info
->got_value
= got_addr
;
490 sop
->lm_info
->lm_addr
= lm_addr
;
491 /* Fetch the name. */
492 addr
= extract_unsigned_integer (lm_buf
.l_name
,
493 sizeof (lm_buf
.l_name
));
494 target_read_string (addr
, &name_buf
, SO_NAME_MAX_PATH_SIZE
- 1,
498 fprintf_unfiltered (gdb_stdlog
, "current_sos: name = %s\n",
502 warning (_("Can't read pathname for link map entry: %s."),
503 safe_strerror (errcode
));
506 strncpy (sop
->so_name
, name_buf
, SO_NAME_MAX_PATH_SIZE
- 1);
507 sop
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
509 strcpy (sop
->so_original_name
, sop
->so_name
);
513 sos_next_ptr
= &sop
->next
;
517 main_lm_addr
= lm_addr
;
520 lm_addr
= extract_unsigned_integer (lm_buf
.l_next
, sizeof (lm_buf
.l_next
));
529 /* Return 1 if PC lies in the dynamic symbol resolution code of the
532 static CORE_ADDR interp_text_sect_low
;
533 static CORE_ADDR interp_text_sect_high
;
534 static CORE_ADDR interp_plt_sect_low
;
535 static CORE_ADDR interp_plt_sect_high
;
538 frv_in_dynsym_resolve_code (CORE_ADDR pc
)
540 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
541 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
542 || in_plt_section (pc
, NULL
));
545 /* Given a loadmap and an address, return the displacement needed
546 to relocate the address. */
549 displacement_from_map (struct int_elf32_fdpic_loadmap
*map
,
554 for (seg
= 0; seg
< map
->nsegs
; seg
++)
556 if (map
->segs
[seg
].p_vaddr
<= addr
557 && addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
559 return map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
566 /* Print a warning about being unable to set the dynamic linker
570 enable_break_failure_warning (void)
572 warning (_("Unable to find dynamic linker breakpoint function.\n"
573 "GDB will be unable to debug shared library initializers\n"
574 "and track explicitly loaded dynamic code."));
581 enable_break -- arrange for dynamic linker to hit breakpoint
585 int enable_break (void)
589 The dynamic linkers has, as part of its debugger interface, support
590 for arranging for the inferior to hit a breakpoint after mapping in
591 the shared libraries. This function enables that breakpoint.
593 On the FR-V, using the shared library (FDPIC) ABI, the symbol
594 _dl_debug_addr points to the r_debug struct which contains
595 a field called r_brk. r_brk is the address of the function
596 descriptor upon which a breakpoint must be placed. Being a
597 function descriptor, we must extract the entry point in order
598 to set the breakpoint.
600 Our strategy will be to get the .interp section from the
601 executable. This section will provide us with the name of the
602 interpreter. We'll open the interpreter and then look up
603 the address of _dl_debug_addr. We then relocate this address
604 using the interpreter's loadmap. Once the relocated address
605 is known, we fetch the value (address) corresponding to r_brk
606 and then use that value to fetch the entry point of the function
611 static int enable_break1_done
= 0;
612 static int enable_break2_done
= 0;
619 asection
*interp_sect
;
621 if (!enable_break1_done
|| enable_break2_done
)
624 enable_break2_done
= 1;
626 /* First, remove all the solib event breakpoints. Their addresses
627 may have changed since the last time we ran the program. */
628 remove_solib_event_breakpoints ();
630 interp_text_sect_low
= interp_text_sect_high
= 0;
631 interp_plt_sect_low
= interp_plt_sect_high
= 0;
633 /* Find the .interp section; if not found, warn the user and drop
634 into the old breakpoint at symbol code. */
635 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
638 unsigned int interp_sect_size
;
642 char *tmp_pathname
= NULL
;
644 CORE_ADDR addr
, interp_loadmap_addr
;
645 gdb_byte addr_buf
[FRV_PTR_SIZE
];
646 struct int_elf32_fdpic_loadmap
*ldm
;
648 /* Read the contents of the .interp section into a local buffer;
649 the contents specify the dynamic linker this program uses. */
650 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
651 buf
= alloca (interp_sect_size
);
652 bfd_get_section_contents (exec_bfd
, interp_sect
,
653 buf
, 0, interp_sect_size
);
655 /* Now we need to figure out where the dynamic linker was
656 loaded so that we can load its symbols and place a breakpoint
657 in the dynamic linker itself.
659 This address is stored on the stack. However, I've been unable
660 to find any magic formula to find it for Solaris (appears to
661 be trivial on GNU/Linux). Therefore, we have to try an alternate
662 mechanism to find the dynamic linker's base address. */
664 tmp_fd
= solib_open (buf
, &tmp_pathname
);
666 tmp_bfd
= bfd_fopen (tmp_pathname
, gnutarget
, FOPEN_RB
, tmp_fd
);
670 enable_break_failure_warning ();
674 /* Make sure the dynamic linker is really a useful object. */
675 if (!bfd_check_format (tmp_bfd
, bfd_object
))
677 warning (_("Unable to grok dynamic linker %s as an object file"), buf
);
678 enable_break_failure_warning ();
683 status
= frv_fdpic_loadmap_addresses (current_gdbarch
,
684 &interp_loadmap_addr
, 0);
687 warning (_("Unable to determine dynamic linker loadmap address."));
688 enable_break_failure_warning ();
694 fprintf_unfiltered (gdb_stdlog
,
695 "enable_break: interp_loadmap_addr = %s\n",
696 hex_string_custom (interp_loadmap_addr
, 8));
698 ldm
= fetch_loadmap (interp_loadmap_addr
);
701 warning (_("Unable to load dynamic linker loadmap at address %s."),
702 hex_string_custom (interp_loadmap_addr
, 8));
703 enable_break_failure_warning ();
708 /* Record the relocated start and end address of the dynamic linker
709 text and plt section for svr4_in_dynsym_resolve_code. */
710 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
714 = bfd_section_vma (tmp_bfd
, interp_sect
);
716 += displacement_from_map (ldm
, interp_text_sect_low
);
717 interp_text_sect_high
718 = interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
720 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
723 interp_plt_sect_low
=
724 bfd_section_vma (tmp_bfd
, interp_sect
);
726 += displacement_from_map (ldm
, interp_plt_sect_low
);
727 interp_plt_sect_high
=
728 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
731 addr
= bfd_lookup_symbol (tmp_bfd
, "_dl_debug_addr");
734 warning (_("Could not find symbol _dl_debug_addr in dynamic linker"));
735 enable_break_failure_warning ();
741 fprintf_unfiltered (gdb_stdlog
,
742 "enable_break: _dl_debug_addr (prior to relocation) = %s\n",
743 hex_string_custom (addr
, 8));
745 addr
+= displacement_from_map (ldm
, addr
);
748 fprintf_unfiltered (gdb_stdlog
,
749 "enable_break: _dl_debug_addr (after relocation) = %s\n",
750 hex_string_custom (addr
, 8));
752 /* Fetch the address of the r_debug struct. */
753 if (target_read_memory (addr
, addr_buf
, sizeof addr_buf
) != 0)
755 warning (_("Unable to fetch contents of _dl_debug_addr (at address %s) from dynamic linker"),
756 hex_string_custom (addr
, 8));
758 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
);
760 /* Fetch the r_brk field. It's 8 bytes from the start of
762 if (target_read_memory (addr
+ 8, addr_buf
, sizeof addr_buf
) != 0)
764 warning (_("Unable to fetch _dl_debug_addr->r_brk (at address %s) from dynamic linker"),
765 hex_string_custom (addr
+ 8, 8));
766 enable_break_failure_warning ();
770 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
);
772 /* Now fetch the function entry point. */
773 if (target_read_memory (addr
, addr_buf
, sizeof addr_buf
) != 0)
775 warning (_("Unable to fetch _dl_debug_addr->.r_brk entry point (at address %s) from dynamic linker"),
776 hex_string_custom (addr
, 8));
777 enable_break_failure_warning ();
781 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
);
783 /* We're done with the temporary bfd. */
786 /* We're also done with the loadmap. */
789 /* Now (finally!) create the solib breakpoint. */
790 create_solib_event_breakpoint (addr
);
795 /* Tell the user we couldn't set a dynamic linker breakpoint. */
796 enable_break_failure_warning ();
798 /* Failure return. */
805 asection
*interp_sect
;
807 /* Remove all the solib event breakpoints. Their addresses
808 may have changed since the last time we ran the program. */
809 remove_solib_event_breakpoints ();
811 /* Check for the presence of a .interp section. If there is no
812 such section, the executable is statically linked. */
814 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
818 enable_break1_done
= 1;
819 create_solib_event_breakpoint (symfile_objfile
->ei
.entry_point
);
822 fprintf_unfiltered (gdb_stdlog
,
823 "enable_break: solib event breakpoint placed at entry point: %s\n",
825 (symfile_objfile
->ei
.entry_point
, 8));
830 fprintf_unfiltered (gdb_stdlog
,
831 "enable_break: No .interp section found.\n");
841 special_symbol_handling -- additional shared library symbol handling
845 void special_symbol_handling ()
849 Once the symbols from a shared object have been loaded in the usual
850 way, we are called to do any system specific symbol handling that
856 frv_special_symbol_handling (void)
858 /* Nothing needed (yet) for FRV. */
862 frv_relocate_main_executable (void)
866 struct int_elf32_fdpic_loadmap
*ldm
;
867 struct cleanup
*old_chain
;
868 struct section_offsets
*new_offsets
;
870 struct obj_section
*osect
;
872 status
= frv_fdpic_loadmap_addresses (current_gdbarch
, 0, &exec_addr
);
876 /* Not using FDPIC ABI, so do nothing. */
880 /* Fetch the loadmap located at ``exec_addr''. */
881 ldm
= fetch_loadmap (exec_addr
);
883 error (_("Unable to load the executable's loadmap."));
885 if (main_executable_lm_info
)
886 xfree (main_executable_lm_info
);
887 main_executable_lm_info
= xcalloc (1, sizeof (struct lm_info
));
888 main_executable_lm_info
->map
= ldm
;
890 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
891 sizeof (struct section_offsets
));
892 old_chain
= make_cleanup (xfree
, new_offsets
);
895 ALL_OBJFILE_OSECTIONS (symfile_objfile
, osect
)
897 CORE_ADDR orig_addr
, addr
, offset
;
901 osect_idx
= osect
->the_bfd_section
->index
;
903 /* Current address of section. */
905 /* Offset from where this section started. */
906 offset
= ANOFFSET (symfile_objfile
->section_offsets
, osect_idx
);
907 /* Original address prior to any past relocations. */
908 orig_addr
= addr
- offset
;
910 for (seg
= 0; seg
< ldm
->nsegs
; seg
++)
912 if (ldm
->segs
[seg
].p_vaddr
<= orig_addr
913 && orig_addr
< ldm
->segs
[seg
].p_vaddr
+ ldm
->segs
[seg
].p_memsz
)
915 new_offsets
->offsets
[osect_idx
]
916 = ldm
->segs
[seg
].addr
- ldm
->segs
[seg
].p_vaddr
;
918 if (new_offsets
->offsets
[osect_idx
] != offset
)
926 objfile_relocate (symfile_objfile
, new_offsets
);
928 do_cleanups (old_chain
);
930 /* Now that symfile_objfile has been relocated, we can compute the
931 GOT value and stash it away. */
932 main_executable_lm_info
->got_value
= main_got ();
939 frv_solib_create_inferior_hook -- shared library startup support
943 void frv_solib_create_inferior_hook ()
947 When gdb starts up the inferior, it nurses it along (through the
948 shell) until it is ready to execute it's first instruction. At this
949 point, this function gets called via expansion of the macro
950 SOLIB_CREATE_INFERIOR_HOOK.
952 For the FR-V shared library ABI (FDPIC), the main executable
953 needs to be relocated. The shared library breakpoints also need
958 frv_solib_create_inferior_hook (void)
960 /* Relocate main executable. */
961 frv_relocate_main_executable ();
963 /* Enable shared library breakpoints. */
964 if (!enable_break ())
966 warning (_("shared library handler failed to enable breakpoint"));
972 frv_clear_solib (void)
975 enable_break1_done
= 0;
976 enable_break2_done
= 0;
978 if (main_executable_lm_info
!= 0)
980 xfree (main_executable_lm_info
->map
);
981 xfree (main_executable_lm_info
->dyn_syms
);
982 xfree (main_executable_lm_info
->dyn_relocs
);
983 xfree (main_executable_lm_info
);
984 main_executable_lm_info
= 0;
989 frv_free_so (struct so_list
*so
)
991 xfree (so
->lm_info
->map
);
992 xfree (so
->lm_info
->dyn_syms
);
993 xfree (so
->lm_info
->dyn_relocs
);
998 frv_relocate_section_addresses (struct so_list
*so
,
999 struct section_table
*sec
)
1002 struct int_elf32_fdpic_loadmap
*map
;
1004 map
= so
->lm_info
->map
;
1006 for (seg
= 0; seg
< map
->nsegs
; seg
++)
1008 if (map
->segs
[seg
].p_vaddr
<= sec
->addr
1009 && sec
->addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
1011 CORE_ADDR displ
= map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
1013 sec
->endaddr
+= displ
;
1019 /* Return the GOT address associated with the main executable. Return
1020 0 if it can't be found. */
1025 struct minimal_symbol
*got_sym
;
1027 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
, symfile_objfile
);
1031 return SYMBOL_VALUE_ADDRESS (got_sym
);
1034 /* Find the global pointer for the given function address ADDR. */
1037 frv_fdpic_find_global_pointer (CORE_ADDR addr
)
1041 so
= master_so_list ();
1045 struct int_elf32_fdpic_loadmap
*map
;
1047 map
= so
->lm_info
->map
;
1049 for (seg
= 0; seg
< map
->nsegs
; seg
++)
1051 if (map
->segs
[seg
].addr
<= addr
1052 && addr
< map
->segs
[seg
].addr
+ map
->segs
[seg
].p_memsz
)
1053 return so
->lm_info
->got_value
;
1059 /* Didn't find it it any of the shared objects. So assume it's in the
1064 /* Forward declarations for frv_fdpic_find_canonical_descriptor(). */
1065 static CORE_ADDR find_canonical_descriptor_in_load_object
1066 (CORE_ADDR
, CORE_ADDR
, char *, bfd
*, struct lm_info
*);
1068 /* Given a function entry point, attempt to find the canonical descriptor
1069 associated with that entry point. Return 0 if no canonical descriptor
1073 frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point
)
1077 CORE_ADDR got_value
;
1078 struct int_elf32_fdpic_loadmap
*ldm
= 0;
1081 CORE_ADDR exec_loadmap_addr
;
1083 /* Fetch the corresponding global pointer for the entry point. */
1084 got_value
= frv_fdpic_find_global_pointer (entry_point
);
1086 /* Attempt to find the name of the function. If the name is available,
1087 it'll be used as an aid in finding matching functions in the dynamic
1089 sym
= find_pc_function (entry_point
);
1093 name
= SYMBOL_LINKAGE_NAME (sym
);
1095 /* Check the main executable. */
1096 addr
= find_canonical_descriptor_in_load_object
1097 (entry_point
, got_value
, name
, symfile_objfile
->obfd
,
1098 main_executable_lm_info
);
1100 /* If descriptor not found via main executable, check each load object
1101 in list of shared objects. */
1106 so
= master_so_list ();
1109 addr
= find_canonical_descriptor_in_load_object
1110 (entry_point
, got_value
, name
, so
->abfd
, so
->lm_info
);
1123 find_canonical_descriptor_in_load_object
1124 (CORE_ADDR entry_point
, CORE_ADDR got_value
, char *name
, bfd
*abfd
,
1131 /* Nothing to do if no bfd. */
1135 /* Nothing to do if no link map. */
1139 /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations.
1140 (More about this later.) But in order to fetch the relocs, we
1141 need to first fetch the dynamic symbols. These symbols need to
1142 be cached due to the way that bfd_canonicalize_dynamic_reloc()
1143 works. (See the comments in the declaration of struct lm_info
1144 for more information.) */
1145 if (lm
->dyn_syms
== NULL
)
1147 long storage_needed
;
1148 unsigned int number_of_symbols
;
1150 /* Determine amount of space needed to hold the dynamic symbol table. */
1151 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1153 /* If there are no dynamic symbols, there's nothing to do. */
1154 if (storage_needed
<= 0)
1157 /* Allocate space for the dynamic symbol table. */
1158 lm
->dyn_syms
= (asymbol
**) xmalloc (storage_needed
);
1160 /* Fetch the dynamic symbol table. */
1161 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, lm
->dyn_syms
);
1163 if (number_of_symbols
== 0)
1167 /* Fetch the dynamic relocations if not already cached. */
1168 if (lm
->dyn_relocs
== NULL
)
1170 long storage_needed
;
1172 /* Determine amount of space needed to hold the dynamic relocs. */
1173 storage_needed
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1175 /* Bail out if there are no dynamic relocs. */
1176 if (storage_needed
<= 0)
1179 /* Allocate space for the relocs. */
1180 lm
->dyn_relocs
= (arelent
**) xmalloc (storage_needed
);
1182 /* Fetch the dynamic relocs. */
1184 = bfd_canonicalize_dynamic_reloc (abfd
, lm
->dyn_relocs
, lm
->dyn_syms
);
1187 /* Search the dynamic relocs. */
1188 for (i
= 0; i
< lm
->dyn_reloc_count
; i
++)
1190 rel
= lm
->dyn_relocs
[i
];
1192 /* Relocs of interest are those which meet the following
1195 - the names match (assuming the caller could provide
1196 a name which matches ``entry_point'').
1197 - the relocation type must be R_FRV_FUNCDESC. Relocs
1198 of this type are used (by the dynamic linker) to
1199 look up the address of a canonical descriptor (allocating
1200 it if need be) and initializing the GOT entry referred
1201 to by the offset to the address of the descriptor.
1203 These relocs of interest may be used to obtain a
1204 candidate descriptor by first adjusting the reloc's
1205 address according to the link map and then dereferencing
1206 this address (which is a GOT entry) to obtain a descriptor
1208 if ((name
== 0 || strcmp (name
, (*rel
->sym_ptr_ptr
)->name
) == 0)
1209 && rel
->howto
->type
== R_FRV_FUNCDESC
)
1211 gdb_byte buf
[FRV_PTR_SIZE
];
1213 /* Compute address of address of candidate descriptor. */
1214 addr
= rel
->address
+ displacement_from_map (lm
->map
, rel
->address
);
1216 /* Fetch address of candidate descriptor. */
1217 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1219 addr
= extract_unsigned_integer (buf
, sizeof buf
);
1221 /* Check for matching entry point. */
1222 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1224 if (extract_unsigned_integer (buf
, sizeof buf
) != entry_point
)
1227 /* Check for matching got value. */
1228 if (target_read_memory (addr
+ 4, buf
, sizeof buf
) != 0)
1230 if (extract_unsigned_integer (buf
, sizeof buf
) != got_value
)
1233 /* Match was successful! Exit loop. */
1241 /* Given an objfile, return the address of its link map. This value is
1242 needed for TLS support. */
1244 frv_fetch_objfile_link_map (struct objfile
*objfile
)
1248 /* Cause frv_current_sos() to be run if it hasn't been already. */
1249 if (main_lm_addr
== 0)
1250 solib_add (0, 0, 0, 1);
1252 /* frv_current_sos() will set main_lm_addr for the main executable. */
1253 if (objfile
== symfile_objfile
)
1254 return main_lm_addr
;
1256 /* The other link map addresses may be found by examining the list
1257 of shared libraries. */
1258 for (so
= master_so_list (); so
; so
= so
->next
)
1260 if (so
->objfile
== objfile
)
1261 return so
->lm_info
->lm_addr
;
1268 static struct target_so_ops frv_so_ops
;
1271 _initialize_frv_solib (void)
1273 frv_so_ops
.relocate_section_addresses
= frv_relocate_section_addresses
;
1274 frv_so_ops
.free_so
= frv_free_so
;
1275 frv_so_ops
.clear_solib
= frv_clear_solib
;
1276 frv_so_ops
.solib_create_inferior_hook
= frv_solib_create_inferior_hook
;
1277 frv_so_ops
.special_symbol_handling
= frv_special_symbol_handling
;
1278 frv_so_ops
.current_sos
= frv_current_sos
;
1279 frv_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1280 frv_so_ops
.in_dynsym_resolve_code
= frv_in_dynsym_resolve_code
;
1282 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
1283 current_target_so_ops
= &frv_so_ops
;
1285 /* Debug this file's internals. */
1286 add_setshow_zinteger_cmd ("solib-frv", class_maintenance
,
1287 &solib_frv_debug
, _("\
1288 Set internal debugging of shared library code for FR-V."), _("\
1289 Show internal debugging of shared library code for FR-V."), _("\
1290 When non-zero, FR-V solib specific internal debugging is enabled."),
1292 NULL
, /* FIXME: i18n: */
1293 &setdebuglist
, &showdebuglist
);