1 /* Handle FR-V (FDPIC) shared libraries for GDB, the GNU Debugger.
2 Copyright (C) 2004-2017 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 3 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, see <http://www.gnu.org/licenses/>. */
34 /* Flag which indicates whether internal debug messages should be printed. */
35 static unsigned int solib_frv_debug
;
37 /* FR-V pointers are four bytes wide. */
38 enum { FRV_PTR_SIZE
= 4 };
40 /* Representation of loadmap and related structs for the FR-V FDPIC ABI. */
42 /* External versions; the size and alignment of the fields should be
43 the same as those on the target. When loaded, the placement of
44 the bits in each field will be the same as on the target. */
45 typedef gdb_byte ext_Elf32_Half
[2];
46 typedef gdb_byte ext_Elf32_Addr
[4];
47 typedef gdb_byte ext_Elf32_Word
[4];
49 struct ext_elf32_fdpic_loadseg
51 /* Core address to which the segment is mapped. */
53 /* VMA recorded in the program header. */
54 ext_Elf32_Addr p_vaddr
;
55 /* Size of this segment in memory. */
56 ext_Elf32_Word p_memsz
;
59 struct ext_elf32_fdpic_loadmap
{
60 /* Protocol version number, must be zero. */
61 ext_Elf32_Half version
;
62 /* Number of segments in this map. */
64 /* The actual memory map. */
65 struct ext_elf32_fdpic_loadseg segs
[1 /* nsegs, actually */];
68 /* Internal versions; the types are GDB types and the data in each
69 of the fields is (or will be) decoded from the external struct
70 for ease of consumption. */
71 struct int_elf32_fdpic_loadseg
73 /* Core address to which the segment is mapped. */
75 /* VMA recorded in the program header. */
77 /* Size of this segment in memory. */
81 struct int_elf32_fdpic_loadmap
{
82 /* Protocol version number, must be zero. */
84 /* Number of segments in this map. */
86 /* The actual memory map. */
87 struct int_elf32_fdpic_loadseg segs
[1 /* nsegs, actually */];
90 /* Given address LDMADDR, fetch and decode the loadmap at that address.
91 Return NULL if there is a problem reading the target memory or if
92 there doesn't appear to be a loadmap at the given address. The
93 allocated space (representing the loadmap) returned by this
94 function may be freed via a single call to xfree(). */
96 static struct int_elf32_fdpic_loadmap
*
97 fetch_loadmap (CORE_ADDR ldmaddr
)
99 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
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
,
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
,
132 /* Allocate space for the complete (external) loadmap. */
133 ext_ldmbuf_size
= sizeof (struct ext_elf32_fdpic_loadmap
)
134 + (nsegs
- 1) * sizeof (struct ext_elf32_fdpic_loadseg
);
135 ext_ldmbuf
= (struct ext_elf32_fdpic_loadmap
*) xmalloc (ext_ldmbuf_size
);
137 /* Copy over the portion of the loadmap that's already been read. */
138 memcpy (ext_ldmbuf
, &ext_ldmbuf_partial
, sizeof ext_ldmbuf_partial
);
140 /* Read the rest of the loadmap from the target. */
141 if (target_read_memory (ldmaddr
+ sizeof ext_ldmbuf_partial
,
142 (gdb_byte
*) ext_ldmbuf
+ sizeof ext_ldmbuf_partial
,
143 ext_ldmbuf_size
- sizeof ext_ldmbuf_partial
))
145 /* Couldn't read rest of the loadmap. */
150 /* Allocate space into which to put information extract from the
151 external loadsegs. I.e, allocate the internal loadsegs. */
152 int_ldmbuf_size
= sizeof (struct int_elf32_fdpic_loadmap
)
153 + (nsegs
- 1) * sizeof (struct int_elf32_fdpic_loadseg
);
154 int_ldmbuf
= (struct int_elf32_fdpic_loadmap
*) xmalloc (int_ldmbuf_size
);
156 /* Place extracted information in internal structs. */
157 int_ldmbuf
->version
= version
;
158 int_ldmbuf
->nsegs
= nsegs
;
159 for (seg
= 0; seg
< nsegs
; seg
++)
161 int_ldmbuf
->segs
[seg
].addr
162 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].addr
,
163 sizeof (ext_ldmbuf
->segs
[seg
].addr
),
165 int_ldmbuf
->segs
[seg
].p_vaddr
166 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_vaddr
,
167 sizeof (ext_ldmbuf
->segs
[seg
].p_vaddr
),
169 int_ldmbuf
->segs
[seg
].p_memsz
170 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_memsz
,
171 sizeof (ext_ldmbuf
->segs
[seg
].p_memsz
),
179 /* External link_map and elf32_fdpic_loadaddr struct definitions. */
181 typedef gdb_byte ext_ptr
[4];
183 struct ext_elf32_fdpic_loadaddr
185 ext_ptr map
; /* struct elf32_fdpic_loadmap *map; */
186 ext_ptr got_value
; /* void *got_value; */
191 struct ext_elf32_fdpic_loadaddr l_addr
;
193 /* Absolute file name object was found in. */
194 ext_ptr l_name
; /* char *l_name; */
196 /* Dynamic section of the shared object. */
197 ext_ptr l_ld
; /* ElfW(Dyn) *l_ld; */
199 /* Chain of loaded objects. */
200 ext_ptr l_next
, l_prev
; /* struct link_map *l_next, *l_prev; */
203 /* Link map info to include in an allocated so_list entry. */
205 struct lm_info_frv
: public lm_info_base
208 /* The loadmap, digested into an easier to use form. */
209 struct int_elf32_fdpic_loadmap
*map
;
210 /* The GOT address for this link map entry. */
212 /* The link map address, needed for frv_fetch_objfile_link_map(). */
215 /* Cached dynamic symbol table and dynamic relocs initialized and
216 used only by find_canonical_descriptor_in_load_object().
218 Note: kevinb/2004-02-26: It appears that calls to
219 bfd_canonicalize_dynamic_reloc() will use the same symbols as
220 those supplied to the first call to this function. Therefore,
221 it's important to NOT free the asymbol ** data structure
222 supplied to the first call. Thus the caching of the dynamic
223 symbols (dyn_syms) is critical for correct operation. The
224 caching of the dynamic relocations could be dispensed with. */
226 arelent
**dyn_relocs
;
227 int dyn_reloc_count
; /* Number of dynamic relocs. */
231 /* The load map, got value, etc. are not available from the chain
232 of loaded shared objects. ``main_executable_lm_info'' provides
233 a way to get at this information so that it doesn't need to be
234 frequently recomputed. Initialized by frv_relocate_main_executable(). */
235 static lm_info_frv
*main_executable_lm_info
;
237 static void frv_relocate_main_executable (void);
238 static CORE_ADDR
main_got (void);
239 static int enable_break2 (void);
241 /* Implement the "open_symbol_file_object" target_so_ops method. */
244 open_symbol_file_object (void *from_ttyp
)
250 /* Cached value for lm_base(), below. */
251 static CORE_ADDR lm_base_cache
= 0;
253 /* Link map address for main module. */
254 static CORE_ADDR main_lm_addr
= 0;
256 /* Return the address from which the link map chain may be found. On
257 the FR-V, this may be found in a number of ways. Assuming that the
258 main executable has already been relocated, the easiest way to find
259 this value is to look up the address of _GLOBAL_OFFSET_TABLE_. A
260 pointer to the start of the link map will be located at the word found
261 at _GLOBAL_OFFSET_TABLE_ + 8. (This is part of the dynamic linker
262 reserve area mandated by the ABI.) */
267 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
268 struct bound_minimal_symbol got_sym
;
270 gdb_byte buf
[FRV_PTR_SIZE
];
272 /* One of our assumptions is that the main executable has been relocated.
273 Bail out if this has not happened. (Note that post_create_inferior()
274 in infcmd.c will call solib_add prior to solib_create_inferior_hook().
275 If we allow this to happen, lm_base_cache will be initialized with
277 if (main_executable_lm_info
== 0)
280 /* If we already have a cached value, return it. */
282 return lm_base_cache
;
284 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
,
286 if (got_sym
.minsym
== 0)
289 fprintf_unfiltered (gdb_stdlog
,
290 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
294 addr
= BMSYMBOL_VALUE_ADDRESS (got_sym
) + 8;
297 fprintf_unfiltered (gdb_stdlog
,
298 "lm_base: _GLOBAL_OFFSET_TABLE_ + 8 = %s\n",
299 hex_string_custom (addr
, 8));
301 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
303 lm_base_cache
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
306 fprintf_unfiltered (gdb_stdlog
,
307 "lm_base: lm_base_cache = %s\n",
308 hex_string_custom (lm_base_cache
, 8));
310 return lm_base_cache
;
314 /* Implement the "current_sos" target_so_ops method. */
316 static struct so_list
*
317 frv_current_sos (void)
319 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
320 CORE_ADDR lm_addr
, mgot
;
321 struct so_list
*sos_head
= NULL
;
322 struct so_list
**sos_next_ptr
= &sos_head
;
324 /* Make sure that the main executable has been relocated. This is
325 required in order to find the address of the global offset table,
326 which in turn is used to find the link map info. (See lm_base()
329 Note that the relocation of the main executable is also performed
330 by solib_create_inferior_hook(), however, in the case of core
331 files, this hook is called too late in order to be of benefit to
332 solib_add. solib_add eventually calls this this function,
333 frv_current_sos, and also precedes the call to
334 solib_create_inferior_hook(). (See post_create_inferior() in
336 if (main_executable_lm_info
== 0 && core_bfd
!= NULL
)
337 frv_relocate_main_executable ();
339 /* Fetch the GOT corresponding to the main executable. */
342 /* Locate the address of the first link map struct. */
343 lm_addr
= lm_base ();
345 /* We have at least one link map entry. Fetch the lot of them,
346 building the solist chain. */
349 struct ext_link_map lm_buf
;
353 fprintf_unfiltered (gdb_stdlog
,
354 "current_sos: reading link_map entry at %s\n",
355 hex_string_custom (lm_addr
, 8));
357 if (target_read_memory (lm_addr
, (gdb_byte
*) &lm_buf
,
358 sizeof (lm_buf
)) != 0)
360 warning (_("frv_current_sos: Unable to read link map entry. "
361 "Shared object chain may be incomplete."));
366 = extract_unsigned_integer (lm_buf
.l_addr
.got_value
,
367 sizeof (lm_buf
.l_addr
.got_value
),
369 /* If the got_addr is the same as mgotr, then we're looking at the
370 entry for the main executable. By convention, we don't include
371 this in the list of shared objects. */
372 if (got_addr
!= mgot
)
376 struct int_elf32_fdpic_loadmap
*loadmap
;
380 /* Fetch the load map address. */
381 addr
= extract_unsigned_integer (lm_buf
.l_addr
.map
,
382 sizeof lm_buf
.l_addr
.map
,
384 loadmap
= fetch_loadmap (addr
);
387 warning (_("frv_current_sos: Unable to fetch load map. "
388 "Shared object chain may be incomplete."));
392 sop
= XCNEW (struct so_list
);
393 lm_info_frv
*li
= XCNEW (lm_info_frv
);
396 li
->got_value
= got_addr
;
397 li
->lm_addr
= lm_addr
;
398 /* Fetch the name. */
399 addr
= extract_unsigned_integer (lm_buf
.l_name
,
400 sizeof (lm_buf
.l_name
),
402 target_read_string (addr
, &name_buf
, SO_NAME_MAX_PATH_SIZE
- 1,
406 fprintf_unfiltered (gdb_stdlog
, "current_sos: name = %s\n",
410 warning (_("Can't read pathname for link map entry: %s."),
411 safe_strerror (errcode
));
414 strncpy (sop
->so_name
, name_buf
, SO_NAME_MAX_PATH_SIZE
- 1);
415 sop
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
417 strcpy (sop
->so_original_name
, sop
->so_name
);
421 sos_next_ptr
= &sop
->next
;
425 main_lm_addr
= lm_addr
;
428 lm_addr
= extract_unsigned_integer (lm_buf
.l_next
,
429 sizeof (lm_buf
.l_next
), byte_order
);
438 /* Return 1 if PC lies in the dynamic symbol resolution code of the
441 static CORE_ADDR interp_text_sect_low
;
442 static CORE_ADDR interp_text_sect_high
;
443 static CORE_ADDR interp_plt_sect_low
;
444 static CORE_ADDR interp_plt_sect_high
;
447 frv_in_dynsym_resolve_code (CORE_ADDR pc
)
449 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
450 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
451 || in_plt_section (pc
));
454 /* Given a loadmap and an address, return the displacement needed
455 to relocate the address. */
458 displacement_from_map (struct int_elf32_fdpic_loadmap
*map
,
463 for (seg
= 0; seg
< map
->nsegs
; seg
++)
465 if (map
->segs
[seg
].p_vaddr
<= addr
466 && addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
468 return map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
475 /* Print a warning about being unable to set the dynamic linker
479 enable_break_failure_warning (void)
481 warning (_("Unable to find dynamic linker breakpoint function.\n"
482 "GDB will be unable to debug shared library initializers\n"
483 "and track explicitly loaded dynamic code."));
486 /* Helper function for gdb_bfd_lookup_symbol. */
489 cmp_name (const asymbol
*sym
, const void *data
)
491 return (strcmp (sym
->name
, (const char *) data
) == 0);
494 /* Arrange for dynamic linker to hit breakpoint.
496 The dynamic linkers has, as part of its debugger interface, support
497 for arranging for the inferior to hit a breakpoint after mapping in
498 the shared libraries. This function enables that breakpoint.
500 On the FR-V, using the shared library (FDPIC) ABI, the symbol
501 _dl_debug_addr points to the r_debug struct which contains
502 a field called r_brk. r_brk is the address of the function
503 descriptor upon which a breakpoint must be placed. Being a
504 function descriptor, we must extract the entry point in order
505 to set the breakpoint.
507 Our strategy will be to get the .interp section from the
508 executable. This section will provide us with the name of the
509 interpreter. We'll open the interpreter and then look up
510 the address of _dl_debug_addr. We then relocate this address
511 using the interpreter's loadmap. Once the relocated address
512 is known, we fetch the value (address) corresponding to r_brk
513 and then use that value to fetch the entry point of the function
514 we're interested in. */
516 static int enable_break2_done
= 0;
521 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
522 asection
*interp_sect
;
524 if (enable_break2_done
)
527 interp_text_sect_low
= interp_text_sect_high
= 0;
528 interp_plt_sect_low
= interp_plt_sect_high
= 0;
530 /* Find the .interp section; if not found, warn the user and drop
531 into the old breakpoint at symbol code. */
532 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
535 unsigned int interp_sect_size
;
538 CORE_ADDR addr
, interp_loadmap_addr
;
539 gdb_byte addr_buf
[FRV_PTR_SIZE
];
540 struct int_elf32_fdpic_loadmap
*ldm
;
542 /* Read the contents of the .interp section into a local buffer;
543 the contents specify the dynamic linker this program uses. */
544 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
545 buf
= (char *) alloca (interp_sect_size
);
546 bfd_get_section_contents (exec_bfd
, interp_sect
,
547 buf
, 0, interp_sect_size
);
549 /* Now we need to figure out where the dynamic linker was
550 loaded so that we can load its symbols and place a breakpoint
551 in the dynamic linker itself.
553 This address is stored on the stack. However, I've been unable
554 to find any magic formula to find it for Solaris (appears to
555 be trivial on GNU/Linux). Therefore, we have to try an alternate
556 mechanism to find the dynamic linker's base address. */
558 gdb_bfd_ref_ptr tmp_bfd
;
561 tmp_bfd
= solib_bfd_open (buf
);
563 CATCH (ex
, RETURN_MASK_ALL
)
570 enable_break_failure_warning ();
574 status
= frv_fdpic_loadmap_addresses (target_gdbarch (),
575 &interp_loadmap_addr
, 0);
578 warning (_("Unable to determine dynamic linker loadmap address."));
579 enable_break_failure_warning ();
584 fprintf_unfiltered (gdb_stdlog
,
585 "enable_break: interp_loadmap_addr = %s\n",
586 hex_string_custom (interp_loadmap_addr
, 8));
588 ldm
= fetch_loadmap (interp_loadmap_addr
);
591 warning (_("Unable to load dynamic linker loadmap at address %s."),
592 hex_string_custom (interp_loadmap_addr
, 8));
593 enable_break_failure_warning ();
597 /* Record the relocated start and end address of the dynamic linker
598 text and plt section for svr4_in_dynsym_resolve_code. */
599 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".text");
603 = bfd_section_vma (tmp_bfd
.get (), interp_sect
);
605 += displacement_from_map (ldm
, interp_text_sect_low
);
606 interp_text_sect_high
607 = interp_text_sect_low
+ bfd_section_size (tmp_bfd
.get (),
610 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".plt");
613 interp_plt_sect_low
=
614 bfd_section_vma (tmp_bfd
.get (), interp_sect
);
616 += displacement_from_map (ldm
, interp_plt_sect_low
);
617 interp_plt_sect_high
=
618 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
.get (),
622 addr
= gdb_bfd_lookup_symbol (tmp_bfd
.get (), cmp_name
, "_dl_debug_addr");
626 warning (_("Could not find symbol _dl_debug_addr "
627 "in dynamic linker"));
628 enable_break_failure_warning ();
633 fprintf_unfiltered (gdb_stdlog
,
634 "enable_break: _dl_debug_addr "
635 "(prior to relocation) = %s\n",
636 hex_string_custom (addr
, 8));
638 addr
+= displacement_from_map (ldm
, addr
);
641 fprintf_unfiltered (gdb_stdlog
,
642 "enable_break: _dl_debug_addr "
643 "(after relocation) = %s\n",
644 hex_string_custom (addr
, 8));
646 /* Fetch the address of the r_debug struct. */
647 if (target_read_memory (addr
, addr_buf
, sizeof addr_buf
) != 0)
649 warning (_("Unable to fetch contents of _dl_debug_addr "
650 "(at address %s) from dynamic linker"),
651 hex_string_custom (addr
, 8));
653 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
, byte_order
);
656 fprintf_unfiltered (gdb_stdlog
,
657 "enable_break: _dl_debug_addr[0..3] = %s\n",
658 hex_string_custom (addr
, 8));
660 /* If it's zero, then the ldso hasn't initialized yet, and so
661 there are no shared libs yet loaded. */
665 fprintf_unfiltered (gdb_stdlog
,
666 "enable_break: ldso not yet initialized\n");
667 /* Do not warn, but mark to run again. */
671 /* Fetch the r_brk field. It's 8 bytes from the start of
673 if (target_read_memory (addr
+ 8, addr_buf
, sizeof addr_buf
) != 0)
675 warning (_("Unable to fetch _dl_debug_addr->r_brk "
676 "(at address %s) from dynamic linker"),
677 hex_string_custom (addr
+ 8, 8));
678 enable_break_failure_warning ();
681 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
, byte_order
);
683 /* Now fetch the function entry point. */
684 if (target_read_memory (addr
, addr_buf
, sizeof addr_buf
) != 0)
686 warning (_("Unable to fetch _dl_debug_addr->.r_brk entry point "
687 "(at address %s) from dynamic linker"),
688 hex_string_custom (addr
, 8));
689 enable_break_failure_warning ();
692 addr
= extract_unsigned_integer (addr_buf
, sizeof addr_buf
, byte_order
);
694 /* We're done with the loadmap. */
697 /* Remove all the solib event breakpoints. Their addresses
698 may have changed since the last time we ran the program. */
699 remove_solib_event_breakpoints ();
701 /* Now (finally!) create the solib breakpoint. */
702 create_solib_event_breakpoint (target_gdbarch (), addr
);
704 enable_break2_done
= 1;
709 /* Tell the user we couldn't set a dynamic linker breakpoint. */
710 enable_break_failure_warning ();
712 /* Failure return. */
719 asection
*interp_sect
;
720 CORE_ADDR entry_point
;
722 if (symfile_objfile
== NULL
)
725 fprintf_unfiltered (gdb_stdlog
,
726 "enable_break: No symbol file found.\n");
730 if (!entry_point_address_query (&entry_point
))
733 fprintf_unfiltered (gdb_stdlog
,
734 "enable_break: Symbol file has no entry point.\n");
738 /* Check for the presence of a .interp section. If there is no
739 such section, the executable is statically linked. */
741 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
743 if (interp_sect
== NULL
)
746 fprintf_unfiltered (gdb_stdlog
,
747 "enable_break: No .interp section found.\n");
751 create_solib_event_breakpoint (target_gdbarch (), entry_point
);
754 fprintf_unfiltered (gdb_stdlog
,
755 "enable_break: solib event breakpoint "
756 "placed at entry point: %s\n",
757 hex_string_custom (entry_point
, 8));
762 frv_relocate_main_executable (void)
765 CORE_ADDR exec_addr
, interp_addr
;
766 struct int_elf32_fdpic_loadmap
*ldm
;
767 struct cleanup
*old_chain
;
768 struct section_offsets
*new_offsets
;
770 struct obj_section
*osect
;
772 status
= frv_fdpic_loadmap_addresses (target_gdbarch (),
773 &interp_addr
, &exec_addr
);
775 if (status
< 0 || (exec_addr
== 0 && interp_addr
== 0))
777 /* Not using FDPIC ABI, so do nothing. */
781 /* Fetch the loadmap located at ``exec_addr''. */
782 ldm
= fetch_loadmap (exec_addr
);
784 error (_("Unable to load the executable's loadmap."));
786 if (main_executable_lm_info
)
787 xfree (main_executable_lm_info
);
788 main_executable_lm_info
= XCNEW (lm_info_frv
);
789 main_executable_lm_info
->map
= ldm
;
791 new_offsets
= XCNEWVEC (struct section_offsets
,
792 symfile_objfile
->num_sections
);
793 old_chain
= make_cleanup (xfree
, new_offsets
);
796 ALL_OBJFILE_OSECTIONS (symfile_objfile
, osect
)
798 CORE_ADDR orig_addr
, addr
, offset
;
802 osect_idx
= osect
- symfile_objfile
->sections
;
804 /* Current address of section. */
805 addr
= obj_section_addr (osect
);
806 /* Offset from where this section started. */
807 offset
= ANOFFSET (symfile_objfile
->section_offsets
, osect_idx
);
808 /* Original address prior to any past relocations. */
809 orig_addr
= addr
- offset
;
811 for (seg
= 0; seg
< ldm
->nsegs
; seg
++)
813 if (ldm
->segs
[seg
].p_vaddr
<= orig_addr
814 && orig_addr
< ldm
->segs
[seg
].p_vaddr
+ ldm
->segs
[seg
].p_memsz
)
816 new_offsets
->offsets
[osect_idx
]
817 = ldm
->segs
[seg
].addr
- ldm
->segs
[seg
].p_vaddr
;
819 if (new_offsets
->offsets
[osect_idx
] != offset
)
827 objfile_relocate (symfile_objfile
, new_offsets
);
829 do_cleanups (old_chain
);
831 /* Now that symfile_objfile has been relocated, we can compute the
832 GOT value and stash it away. */
833 main_executable_lm_info
->got_value
= main_got ();
836 /* Implement the "create_inferior_hook" target_solib_ops method.
838 For the FR-V shared library ABI (FDPIC), the main executable needs
839 to be relocated. The shared library breakpoints also need to be
843 frv_solib_create_inferior_hook (int from_tty
)
845 /* Relocate main executable. */
846 frv_relocate_main_executable ();
848 /* Enable shared library breakpoints. */
849 if (!enable_break ())
851 warning (_("shared library handler failed to enable breakpoint"));
857 frv_clear_solib (void)
860 enable_break2_done
= 0;
862 if (main_executable_lm_info
!= 0)
864 xfree (main_executable_lm_info
->map
);
865 xfree (main_executable_lm_info
->dyn_syms
);
866 xfree (main_executable_lm_info
->dyn_relocs
);
867 xfree (main_executable_lm_info
);
868 main_executable_lm_info
= 0;
873 frv_free_so (struct so_list
*so
)
875 lm_info_frv
*li
= (lm_info_frv
*) so
->lm_info
;
878 xfree (li
->dyn_syms
);
879 xfree (li
->dyn_relocs
);
884 frv_relocate_section_addresses (struct so_list
*so
,
885 struct target_section
*sec
)
888 lm_info_frv
*li
= (lm_info_frv
*) so
->lm_info
;
889 int_elf32_fdpic_loadmap
*map
= li
->map
;
891 for (seg
= 0; seg
< map
->nsegs
; seg
++)
893 if (map
->segs
[seg
].p_vaddr
<= sec
->addr
894 && sec
->addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
896 CORE_ADDR displ
= map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
899 sec
->endaddr
+= displ
;
905 /* Return the GOT address associated with the main executable. Return
906 0 if it can't be found. */
911 struct bound_minimal_symbol got_sym
;
913 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_",
914 NULL
, symfile_objfile
);
915 if (got_sym
.minsym
== 0)
918 return BMSYMBOL_VALUE_ADDRESS (got_sym
);
921 /* Find the global pointer for the given function address ADDR. */
924 frv_fdpic_find_global_pointer (CORE_ADDR addr
)
928 so
= master_so_list ();
932 lm_info_frv
*li
= (lm_info_frv
*) so
->lm_info
;
933 int_elf32_fdpic_loadmap
*map
= li
->map
;
935 for (seg
= 0; seg
< map
->nsegs
; seg
++)
937 if (map
->segs
[seg
].addr
<= addr
938 && addr
< map
->segs
[seg
].addr
+ map
->segs
[seg
].p_memsz
)
939 return li
->got_value
;
945 /* Didn't find it in any of the shared objects. So assume it's in the
950 /* Forward declarations for frv_fdpic_find_canonical_descriptor(). */
951 static CORE_ADDR find_canonical_descriptor_in_load_object
952 (CORE_ADDR
, CORE_ADDR
, const char *, bfd
*, lm_info_frv
*);
954 /* Given a function entry point, attempt to find the canonical descriptor
955 associated with that entry point. Return 0 if no canonical descriptor
959 frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point
)
966 /* Fetch the corresponding global pointer for the entry point. */
967 got_value
= frv_fdpic_find_global_pointer (entry_point
);
969 /* Attempt to find the name of the function. If the name is available,
970 it'll be used as an aid in finding matching functions in the dynamic
972 sym
= find_pc_function (entry_point
);
976 name
= SYMBOL_LINKAGE_NAME (sym
);
978 /* Check the main executable. */
979 addr
= find_canonical_descriptor_in_load_object
980 (entry_point
, got_value
, name
, symfile_objfile
->obfd
,
981 main_executable_lm_info
);
983 /* If descriptor not found via main executable, check each load object
984 in list of shared objects. */
989 so
= master_so_list ();
992 lm_info_frv
*li
= (lm_info_frv
*) so
->lm_info
;
994 addr
= find_canonical_descriptor_in_load_object
995 (entry_point
, got_value
, name
, so
->abfd
, li
);
1008 find_canonical_descriptor_in_load_object
1009 (CORE_ADDR entry_point
, CORE_ADDR got_value
, const char *name
, bfd
*abfd
,
1012 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
1017 /* Nothing to do if no bfd. */
1021 /* Nothing to do if no link map. */
1025 /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations.
1026 (More about this later.) But in order to fetch the relocs, we
1027 need to first fetch the dynamic symbols. These symbols need to
1028 be cached due to the way that bfd_canonicalize_dynamic_reloc()
1029 works. (See the comments in the declaration of struct lm_info
1030 for more information.) */
1031 if (lm
->dyn_syms
== NULL
)
1033 long storage_needed
;
1034 unsigned int number_of_symbols
;
1036 /* Determine amount of space needed to hold the dynamic symbol table. */
1037 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1039 /* If there are no dynamic symbols, there's nothing to do. */
1040 if (storage_needed
<= 0)
1043 /* Allocate space for the dynamic symbol table. */
1044 lm
->dyn_syms
= (asymbol
**) xmalloc (storage_needed
);
1046 /* Fetch the dynamic symbol table. */
1047 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, lm
->dyn_syms
);
1049 if (number_of_symbols
== 0)
1053 /* Fetch the dynamic relocations if not already cached. */
1054 if (lm
->dyn_relocs
== NULL
)
1056 long storage_needed
;
1058 /* Determine amount of space needed to hold the dynamic relocs. */
1059 storage_needed
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1061 /* Bail out if there are no dynamic relocs. */
1062 if (storage_needed
<= 0)
1065 /* Allocate space for the relocs. */
1066 lm
->dyn_relocs
= (arelent
**) xmalloc (storage_needed
);
1068 /* Fetch the dynamic relocs. */
1070 = bfd_canonicalize_dynamic_reloc (abfd
, lm
->dyn_relocs
, lm
->dyn_syms
);
1073 /* Search the dynamic relocs. */
1074 for (i
= 0; i
< lm
->dyn_reloc_count
; i
++)
1076 rel
= lm
->dyn_relocs
[i
];
1078 /* Relocs of interest are those which meet the following
1081 - the names match (assuming the caller could provide
1082 a name which matches ``entry_point'').
1083 - the relocation type must be R_FRV_FUNCDESC. Relocs
1084 of this type are used (by the dynamic linker) to
1085 look up the address of a canonical descriptor (allocating
1086 it if need be) and initializing the GOT entry referred
1087 to by the offset to the address of the descriptor.
1089 These relocs of interest may be used to obtain a
1090 candidate descriptor by first adjusting the reloc's
1091 address according to the link map and then dereferencing
1092 this address (which is a GOT entry) to obtain a descriptor
1094 if ((name
== 0 || strcmp (name
, (*rel
->sym_ptr_ptr
)->name
) == 0)
1095 && rel
->howto
->type
== R_FRV_FUNCDESC
)
1097 gdb_byte buf
[FRV_PTR_SIZE
];
1099 /* Compute address of address of candidate descriptor. */
1100 addr
= rel
->address
+ displacement_from_map (lm
->map
, rel
->address
);
1102 /* Fetch address of candidate descriptor. */
1103 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1105 addr
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
1107 /* Check for matching entry point. */
1108 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1110 if (extract_unsigned_integer (buf
, sizeof buf
, byte_order
)
1114 /* Check for matching got value. */
1115 if (target_read_memory (addr
+ 4, buf
, sizeof buf
) != 0)
1117 if (extract_unsigned_integer (buf
, sizeof buf
, byte_order
)
1121 /* Match was successful! Exit loop. */
1129 /* Given an objfile, return the address of its link map. This value is
1130 needed for TLS support. */
1132 frv_fetch_objfile_link_map (struct objfile
*objfile
)
1136 /* Cause frv_current_sos() to be run if it hasn't been already. */
1137 if (main_lm_addr
== 0)
1138 solib_add (0, 0, 1);
1140 /* frv_current_sos() will set main_lm_addr for the main executable. */
1141 if (objfile
== symfile_objfile
)
1142 return main_lm_addr
;
1144 /* The other link map addresses may be found by examining the list
1145 of shared libraries. */
1146 for (so
= master_so_list (); so
; so
= so
->next
)
1148 lm_info_frv
*li
= (lm_info_frv
*) so
->lm_info
;
1150 if (so
->objfile
== objfile
)
1158 struct target_so_ops frv_so_ops
;
1160 /* Provide a prototype to silence -Wmissing-prototypes. */
1161 extern initialize_file_ftype _initialize_frv_solib
;
1164 _initialize_frv_solib (void)
1166 frv_so_ops
.relocate_section_addresses
= frv_relocate_section_addresses
;
1167 frv_so_ops
.free_so
= frv_free_so
;
1168 frv_so_ops
.clear_solib
= frv_clear_solib
;
1169 frv_so_ops
.solib_create_inferior_hook
= frv_solib_create_inferior_hook
;
1170 frv_so_ops
.current_sos
= frv_current_sos
;
1171 frv_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1172 frv_so_ops
.in_dynsym_resolve_code
= frv_in_dynsym_resolve_code
;
1173 frv_so_ops
.bfd_open
= solib_bfd_open
;
1175 /* Debug this file's internals. */
1176 add_setshow_zuinteger_cmd ("solib-frv", class_maintenance
,
1177 &solib_frv_debug
, _("\
1178 Set internal debugging of shared library code for FR-V."), _("\
1179 Show internal debugging of shared library code for FR-V."), _("\
1180 When non-zero, FR-V solib specific internal debugging is enabled."),
1182 NULL
, /* FIXME: i18n: */
1183 &setdebuglist
, &showdebuglist
);