gdb/
[deliverable/binutils-gdb.git] / gdb / solib-frv.c
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.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20
21 #include "defs.h"
22 #include "gdb_string.h"
23 #include "inferior.h"
24 #include "gdbcore.h"
25 #include "solib.h"
26 #include "solist.h"
27 #include "frv-tdep.h"
28 #include "objfiles.h"
29 #include "symtab.h"
30 #include "language.h"
31 #include "command.h"
32 #include "gdbcmd.h"
33 #include "elf/frv.h"
34 #include "exceptions.h"
35
36 /* Flag which indicates whether internal debug messages should be printed. */
37 static int solib_frv_debug;
38
39 /* FR-V pointers are four bytes wide. */
40 enum { FRV_PTR_SIZE = 4 };
41
42 /* Representation of loadmap and related structs for the FR-V FDPIC ABI. */
43
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];
50
51 struct ext_elf32_fdpic_loadseg
52 {
53 /* Core address to which the segment is mapped. */
54 ext_Elf32_Addr addr;
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;
59 };
60
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. */
65 ext_Elf32_Half nsegs;
66 /* The actual memory map. */
67 struct ext_elf32_fdpic_loadseg segs[1 /* nsegs, actually */];
68 };
69
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
74 {
75 /* Core address to which the segment is mapped. */
76 CORE_ADDR addr;
77 /* VMA recorded in the program header. */
78 CORE_ADDR p_vaddr;
79 /* Size of this segment in memory. */
80 long p_memsz;
81 };
82
83 struct int_elf32_fdpic_loadmap {
84 /* Protocol version number, must be zero. */
85 int version;
86 /* Number of segments in this map. */
87 int nsegs;
88 /* The actual memory map. */
89 struct int_elf32_fdpic_loadseg segs[1 /* nsegs, actually */];
90 };
91
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(). */
97
98 static struct int_elf32_fdpic_loadmap *
99 fetch_loadmap (CORE_ADDR ldmaddr)
100 {
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;
107
108 /* Fetch initial portion of the loadmap. */
109 if (target_read_memory (ldmaddr, (gdb_byte *) &ext_ldmbuf_partial,
110 sizeof ext_ldmbuf_partial))
111 {
112 /* Problem reading the target's memory. */
113 return NULL;
114 }
115
116 /* Extract the version. */
117 version = extract_unsigned_integer (ext_ldmbuf_partial.version,
118 sizeof ext_ldmbuf_partial.version,
119 byte_order);
120 if (version != 0)
121 {
122 /* We only handle version 0. */
123 return NULL;
124 }
125
126 /* Extract the number of segments. */
127 nsegs = extract_unsigned_integer (ext_ldmbuf_partial.nsegs,
128 sizeof ext_ldmbuf_partial.nsegs,
129 byte_order);
130
131 if (nsegs <= 0)
132 return NULL;
133
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);
138
139 /* Copy over the portion of the loadmap that's already been read. */
140 memcpy (ext_ldmbuf, &ext_ldmbuf_partial, sizeof ext_ldmbuf_partial);
141
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))
146 {
147 /* Couldn't read rest of the loadmap. */
148 xfree (ext_ldmbuf);
149 return NULL;
150 }
151
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);
157
158 /* Place extracted information in internal structs. */
159 int_ldmbuf->version = version;
160 int_ldmbuf->nsegs = nsegs;
161 for (seg = 0; seg < nsegs; seg++)
162 {
163 int_ldmbuf->segs[seg].addr
164 = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
165 sizeof (ext_ldmbuf->segs[seg].addr),
166 byte_order);
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),
170 byte_order);
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),
174 byte_order);
175 }
176
177 xfree (ext_ldmbuf);
178 return int_ldmbuf;
179 }
180
181 /* External link_map and elf32_fdpic_loadaddr struct definitions. */
182
183 typedef gdb_byte ext_ptr[4];
184
185 struct ext_elf32_fdpic_loadaddr
186 {
187 ext_ptr map; /* struct elf32_fdpic_loadmap *map; */
188 ext_ptr got_value; /* void *got_value; */
189 };
190
191 struct ext_link_map
192 {
193 struct ext_elf32_fdpic_loadaddr l_addr;
194
195 /* Absolute file name object was found in. */
196 ext_ptr l_name; /* char *l_name; */
197
198 /* Dynamic section of the shared object. */
199 ext_ptr l_ld; /* ElfW(Dyn) *l_ld; */
200
201 /* Chain of loaded objects. */
202 ext_ptr l_next, l_prev; /* struct link_map *l_next, *l_prev; */
203 };
204
205 /* Link map info to include in an allocated so_list entry. */
206
207 struct lm_info
208 {
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. */
212 CORE_ADDR got_value;
213 /* The link map address, needed for frv_fetch_objfile_link_map(). */
214 CORE_ADDR lm_addr;
215
216 /* Cached dynamic symbol table and dynamic relocs initialized and
217 used only by find_canonical_descriptor_in_load_object().
218
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. */
226 asymbol **dyn_syms;
227 arelent **dyn_relocs;
228 int dyn_reloc_count; /* Number of dynamic relocs. */
229
230 };
231
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;
237
238 static void frv_relocate_main_executable (void);
239 static CORE_ADDR main_got (void);
240 static int enable_break2 (void);
241
242 /* Implement the "open_symbol_file_object" target_so_ops method. */
243
244 static int
245 open_symbol_file_object (void *from_ttyp)
246 {
247 /* Unimplemented. */
248 return 0;
249 }
250
251 /* Cached value for lm_base(), below. */
252 static CORE_ADDR lm_base_cache = 0;
253
254 /* Link map address for main module. */
255 static CORE_ADDR main_lm_addr = 0;
256
257 /* Return the address from which the link map chain may be found. On
258 the FR-V, this may be found in a number of ways. Assuming that the
259 main executable has already been relocated, the easiest way to find
260 this value is to look up the address of _GLOBAL_OFFSET_TABLE_. A
261 pointer to the start of the link map will be located at the word found
262 at _GLOBAL_OFFSET_TABLE_ + 8. (This is part of the dynamic linker
263 reserve area mandated by the ABI.) */
264
265 static CORE_ADDR
266 lm_base (void)
267 {
268 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
269 struct minimal_symbol *got_sym;
270 CORE_ADDR addr;
271 gdb_byte buf[FRV_PTR_SIZE];
272
273 /* One of our assumptions is that the main executable has been relocated.
274 Bail out if this has not happened. (Note that post_create_inferior()
275 in infcmd.c will call solib_add prior to solib_create_inferior_hook().
276 If we allow this to happen, lm_base_cache will be initialized with
277 a bogus value. */
278 if (main_executable_lm_info == 0)
279 return 0;
280
281 /* If we already have a cached value, return it. */
282 if (lm_base_cache)
283 return lm_base_cache;
284
285 got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL,
286 symfile_objfile);
287 if (got_sym == 0)
288 {
289 if (solib_frv_debug)
290 fprintf_unfiltered (gdb_stdlog,
291 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
292 return 0;
293 }
294
295 addr = SYMBOL_VALUE_ADDRESS (got_sym) + 8;
296
297 if (solib_frv_debug)
298 fprintf_unfiltered (gdb_stdlog,
299 "lm_base: _GLOBAL_OFFSET_TABLE_ + 8 = %s\n",
300 hex_string_custom (addr, 8));
301
302 if (target_read_memory (addr, buf, sizeof buf) != 0)
303 return 0;
304 lm_base_cache = extract_unsigned_integer (buf, sizeof buf, byte_order);
305
306 if (solib_frv_debug)
307 fprintf_unfiltered (gdb_stdlog,
308 "lm_base: lm_base_cache = %s\n",
309 hex_string_custom (lm_base_cache, 8));
310
311 return lm_base_cache;
312 }
313
314
315 /* Implement the "current_sos" target_so_ops method. */
316
317 static struct so_list *
318 frv_current_sos (void)
319 {
320 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
321 CORE_ADDR lm_addr, mgot;
322 struct so_list *sos_head = NULL;
323 struct so_list **sos_next_ptr = &sos_head;
324
325 /* Make sure that the main executable has been relocated. This is
326 required in order to find the address of the global offset table,
327 which in turn is used to find the link map info. (See lm_base()
328 for details.)
329
330 Note that the relocation of the main executable is also performed
331 by SOLIB_CREATE_INFERIOR_HOOK(), however, in the case of core
332 files, this hook is called too late in order to be of benefit to
333 SOLIB_ADD. SOLIB_ADD eventually calls this this function,
334 frv_current_sos, and also precedes the call to
335 SOLIB_CREATE_INFERIOR_HOOK(). (See post_create_inferior() in
336 infcmd.c.) */
337 if (main_executable_lm_info == 0 && core_bfd != NULL)
338 frv_relocate_main_executable ();
339
340 /* Fetch the GOT corresponding to the main executable. */
341 mgot = main_got ();
342
343 /* Locate the address of the first link map struct. */
344 lm_addr = lm_base ();
345
346 /* We have at least one link map entry. Fetch the lot of them,
347 building the solist chain. */
348 while (lm_addr)
349 {
350 struct ext_link_map lm_buf;
351 CORE_ADDR got_addr;
352
353 if (solib_frv_debug)
354 fprintf_unfiltered (gdb_stdlog,
355 "current_sos: reading link_map entry at %s\n",
356 hex_string_custom (lm_addr, 8));
357
358 if (target_read_memory (lm_addr, (gdb_byte *) &lm_buf,
359 sizeof (lm_buf)) != 0)
360 {
361 warning (_("frv_current_sos: Unable to read link map entry. "
362 "Shared object chain may be incomplete."));
363 break;
364 }
365
366 got_addr
367 = extract_unsigned_integer (lm_buf.l_addr.got_value,
368 sizeof (lm_buf.l_addr.got_value),
369 byte_order);
370 /* If the got_addr is the same as mgotr, then we're looking at the
371 entry for the main executable. By convention, we don't include
372 this in the list of shared objects. */
373 if (got_addr != mgot)
374 {
375 int errcode;
376 char *name_buf;
377 struct int_elf32_fdpic_loadmap *loadmap;
378 struct so_list *sop;
379 CORE_ADDR addr;
380
381 /* Fetch the load map address. */
382 addr = extract_unsigned_integer (lm_buf.l_addr.map,
383 sizeof lm_buf.l_addr.map,
384 byte_order);
385 loadmap = fetch_loadmap (addr);
386 if (loadmap == NULL)
387 {
388 warning (_("frv_current_sos: Unable to fetch load map. "
389 "Shared object chain may be incomplete."));
390 break;
391 }
392
393 sop = xcalloc (1, sizeof (struct so_list));
394 sop->lm_info = xcalloc (1, sizeof (struct lm_info));
395 sop->lm_info->map = loadmap;
396 sop->lm_info->got_value = got_addr;
397 sop->lm_info->lm_addr = lm_addr;
398 /* Fetch the name. */
399 addr = extract_unsigned_integer (lm_buf.l_name,
400 sizeof (lm_buf.l_name),
401 byte_order);
402 target_read_string (addr, &name_buf, SO_NAME_MAX_PATH_SIZE - 1,
403 &errcode);
404
405 if (solib_frv_debug)
406 fprintf_unfiltered (gdb_stdlog, "current_sos: name = %s\n",
407 name_buf);
408
409 if (errcode != 0)
410 warning (_("Can't read pathname for link map entry: %s."),
411 safe_strerror (errcode));
412 else
413 {
414 strncpy (sop->so_name, name_buf, SO_NAME_MAX_PATH_SIZE - 1);
415 sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
416 xfree (name_buf);
417 strcpy (sop->so_original_name, sop->so_name);
418 }
419
420 *sos_next_ptr = sop;
421 sos_next_ptr = &sop->next;
422 }
423 else
424 {
425 main_lm_addr = lm_addr;
426 }
427
428 lm_addr = extract_unsigned_integer (lm_buf.l_next,
429 sizeof (lm_buf.l_next), byte_order);
430 }
431
432 enable_break2 ();
433
434 return sos_head;
435 }
436
437
438 /* Return 1 if PC lies in the dynamic symbol resolution code of the
439 run time loader. */
440
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;
445
446 static int
447 frv_in_dynsym_resolve_code (CORE_ADDR pc)
448 {
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, NULL));
452 }
453
454 /* Given a loadmap and an address, return the displacement needed
455 to relocate the address. */
456
457 static CORE_ADDR
458 displacement_from_map (struct int_elf32_fdpic_loadmap *map,
459 CORE_ADDR addr)
460 {
461 int seg;
462
463 for (seg = 0; seg < map->nsegs; seg++)
464 {
465 if (map->segs[seg].p_vaddr <= addr
466 && addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
467 {
468 return map->segs[seg].addr - map->segs[seg].p_vaddr;
469 }
470 }
471
472 return 0;
473 }
474
475 /* Print a warning about being unable to set the dynamic linker
476 breakpoint. */
477
478 static void
479 enable_break_failure_warning (void)
480 {
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."));
484 }
485
486 /* Helper function for gdb_bfd_lookup_symbol. */
487
488 static int
489 cmp_name (asymbol *sym, void *data)
490 {
491 return (strcmp (sym->name, (const char *) data) == 0);
492 }
493
494 /* Arrange for dynamic linker to hit breakpoint.
495
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.
499
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.
506
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. */
515
516 static int enable_break2_done = 0;
517
518 static int
519 enable_break2 (void)
520 {
521 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
522 int success = 0;
523 char **bkpt_namep;
524 asection *interp_sect;
525
526 if (enable_break2_done)
527 return 1;
528
529 interp_text_sect_low = interp_text_sect_high = 0;
530 interp_plt_sect_low = interp_plt_sect_high = 0;
531
532 /* Find the .interp section; if not found, warn the user and drop
533 into the old breakpoint at symbol code. */
534 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
535 if (interp_sect)
536 {
537 unsigned int interp_sect_size;
538 gdb_byte *buf;
539 bfd *tmp_bfd = NULL;
540 int status;
541 CORE_ADDR addr, interp_loadmap_addr;
542 gdb_byte addr_buf[FRV_PTR_SIZE];
543 struct int_elf32_fdpic_loadmap *ldm;
544 volatile struct gdb_exception ex;
545
546 /* Read the contents of the .interp section into a local buffer;
547 the contents specify the dynamic linker this program uses. */
548 interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
549 buf = alloca (interp_sect_size);
550 bfd_get_section_contents (exec_bfd, interp_sect,
551 buf, 0, interp_sect_size);
552
553 /* Now we need to figure out where the dynamic linker was
554 loaded so that we can load its symbols and place a breakpoint
555 in the dynamic linker itself.
556
557 This address is stored on the stack. However, I've been unable
558 to find any magic formula to find it for Solaris (appears to
559 be trivial on GNU/Linux). Therefore, we have to try an alternate
560 mechanism to find the dynamic linker's base address. */
561
562 TRY_CATCH (ex, RETURN_MASK_ALL)
563 {
564 tmp_bfd = solib_bfd_open (buf);
565 }
566 if (tmp_bfd == NULL)
567 {
568 enable_break_failure_warning ();
569 return 0;
570 }
571
572 status = frv_fdpic_loadmap_addresses (target_gdbarch,
573 &interp_loadmap_addr, 0);
574 if (status < 0)
575 {
576 warning (_("Unable to determine dynamic linker loadmap address."));
577 enable_break_failure_warning ();
578 bfd_close (tmp_bfd);
579 return 0;
580 }
581
582 if (solib_frv_debug)
583 fprintf_unfiltered (gdb_stdlog,
584 "enable_break: interp_loadmap_addr = %s\n",
585 hex_string_custom (interp_loadmap_addr, 8));
586
587 ldm = fetch_loadmap (interp_loadmap_addr);
588 if (ldm == NULL)
589 {
590 warning (_("Unable to load dynamic linker loadmap at address %s."),
591 hex_string_custom (interp_loadmap_addr, 8));
592 enable_break_failure_warning ();
593 bfd_close (tmp_bfd);
594 return 0;
595 }
596
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, ".text");
600 if (interp_sect)
601 {
602 interp_text_sect_low
603 = bfd_section_vma (tmp_bfd, interp_sect);
604 interp_text_sect_low
605 += displacement_from_map (ldm, interp_text_sect_low);
606 interp_text_sect_high
607 = interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
608 }
609 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
610 if (interp_sect)
611 {
612 interp_plt_sect_low =
613 bfd_section_vma (tmp_bfd, interp_sect);
614 interp_plt_sect_low
615 += displacement_from_map (ldm, interp_plt_sect_low);
616 interp_plt_sect_high =
617 interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
618 }
619
620 addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name, "_dl_debug_addr");
621
622 if (addr == 0)
623 {
624 warning (_("Could not find symbol _dl_debug_addr "
625 "in dynamic linker"));
626 enable_break_failure_warning ();
627 bfd_close (tmp_bfd);
628 return 0;
629 }
630
631 if (solib_frv_debug)
632 fprintf_unfiltered (gdb_stdlog,
633 "enable_break: _dl_debug_addr "
634 "(prior to relocation) = %s\n",
635 hex_string_custom (addr, 8));
636
637 addr += displacement_from_map (ldm, addr);
638
639 if (solib_frv_debug)
640 fprintf_unfiltered (gdb_stdlog,
641 "enable_break: _dl_debug_addr "
642 "(after relocation) = %s\n",
643 hex_string_custom (addr, 8));
644
645 /* Fetch the address of the r_debug struct. */
646 if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0)
647 {
648 warning (_("Unable to fetch contents of _dl_debug_addr "
649 "(at address %s) from dynamic linker"),
650 hex_string_custom (addr, 8));
651 }
652 addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
653
654 if (solib_frv_debug)
655 fprintf_unfiltered (gdb_stdlog,
656 "enable_break: _dl_debug_addr[0..3] = %s\n",
657 hex_string_custom (addr, 8));
658
659 /* If it's zero, then the ldso hasn't initialized yet, and so
660 there are no shared libs yet loaded. */
661 if (addr == 0)
662 {
663 if (solib_frv_debug)
664 fprintf_unfiltered (gdb_stdlog,
665 "enable_break: ldso not yet initialized\n");
666 /* Do not warn, but mark to run again. */
667 return 0;
668 }
669
670 /* Fetch the r_brk field. It's 8 bytes from the start of
671 _dl_debug_addr. */
672 if (target_read_memory (addr + 8, addr_buf, sizeof addr_buf) != 0)
673 {
674 warning (_("Unable to fetch _dl_debug_addr->r_brk "
675 "(at address %s) from dynamic linker"),
676 hex_string_custom (addr + 8, 8));
677 enable_break_failure_warning ();
678 bfd_close (tmp_bfd);
679 return 0;
680 }
681 addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
682
683 /* Now fetch the function entry point. */
684 if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0)
685 {
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 ();
690 bfd_close (tmp_bfd);
691 return 0;
692 }
693 addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
694
695 /* We're done with the temporary bfd. */
696 bfd_close (tmp_bfd);
697
698 /* We're also done with the loadmap. */
699 xfree (ldm);
700
701 /* Remove all the solib event breakpoints. Their addresses
702 may have changed since the last time we ran the program. */
703 remove_solib_event_breakpoints ();
704
705 /* Now (finally!) create the solib breakpoint. */
706 create_solib_event_breakpoint (target_gdbarch, addr);
707
708 enable_break2_done = 1;
709
710 return 1;
711 }
712
713 /* Tell the user we couldn't set a dynamic linker breakpoint. */
714 enable_break_failure_warning ();
715
716 /* Failure return. */
717 return 0;
718 }
719
720 static int
721 enable_break (void)
722 {
723 asection *interp_sect;
724
725 if (symfile_objfile == NULL)
726 {
727 if (solib_frv_debug)
728 fprintf_unfiltered (gdb_stdlog,
729 "enable_break: No symbol file found.\n");
730 return 0;
731 }
732
733 if (!symfile_objfile->ei.entry_point_p)
734 {
735 if (solib_frv_debug)
736 fprintf_unfiltered (gdb_stdlog,
737 "enable_break: Symbol file has no entry point.\n");
738 return 0;
739 }
740
741 /* Check for the presence of a .interp section. If there is no
742 such section, the executable is statically linked. */
743
744 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
745
746 if (interp_sect == NULL)
747 {
748 if (solib_frv_debug)
749 fprintf_unfiltered (gdb_stdlog,
750 "enable_break: No .interp section found.\n");
751 return 0;
752 }
753
754 create_solib_event_breakpoint (target_gdbarch,
755 symfile_objfile->ei.entry_point);
756
757 if (solib_frv_debug)
758 fprintf_unfiltered (gdb_stdlog,
759 "enable_break: solib event breakpoint "
760 "placed at entry point: %s\n",
761 hex_string_custom (symfile_objfile->ei.entry_point,
762 8));
763 return 1;
764 }
765
766 /* Implement the "special_symbol_handling" target_so_ops method. */
767
768 static void
769 frv_special_symbol_handling (void)
770 {
771 /* Nothing needed for FRV. */
772 }
773
774 static void
775 frv_relocate_main_executable (void)
776 {
777 int status;
778 CORE_ADDR exec_addr, interp_addr;
779 struct int_elf32_fdpic_loadmap *ldm;
780 struct cleanup *old_chain;
781 struct section_offsets *new_offsets;
782 int changed;
783 struct obj_section *osect;
784
785 status = frv_fdpic_loadmap_addresses (target_gdbarch,
786 &interp_addr, &exec_addr);
787
788 if (status < 0 || (exec_addr == 0 && interp_addr == 0))
789 {
790 /* Not using FDPIC ABI, so do nothing. */
791 return;
792 }
793
794 /* Fetch the loadmap located at ``exec_addr''. */
795 ldm = fetch_loadmap (exec_addr);
796 if (ldm == NULL)
797 error (_("Unable to load the executable's loadmap."));
798
799 if (main_executable_lm_info)
800 xfree (main_executable_lm_info);
801 main_executable_lm_info = xcalloc (1, sizeof (struct lm_info));
802 main_executable_lm_info->map = ldm;
803
804 new_offsets = xcalloc (symfile_objfile->num_sections,
805 sizeof (struct section_offsets));
806 old_chain = make_cleanup (xfree, new_offsets);
807 changed = 0;
808
809 ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
810 {
811 CORE_ADDR orig_addr, addr, offset;
812 int osect_idx;
813 int seg;
814
815 osect_idx = osect->the_bfd_section->index;
816
817 /* Current address of section. */
818 addr = obj_section_addr (osect);
819 /* Offset from where this section started. */
820 offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx);
821 /* Original address prior to any past relocations. */
822 orig_addr = addr - offset;
823
824 for (seg = 0; seg < ldm->nsegs; seg++)
825 {
826 if (ldm->segs[seg].p_vaddr <= orig_addr
827 && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
828 {
829 new_offsets->offsets[osect_idx]
830 = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
831
832 if (new_offsets->offsets[osect_idx] != offset)
833 changed = 1;
834 break;
835 }
836 }
837 }
838
839 if (changed)
840 objfile_relocate (symfile_objfile, new_offsets);
841
842 do_cleanups (old_chain);
843
844 /* Now that symfile_objfile has been relocated, we can compute the
845 GOT value and stash it away. */
846 main_executable_lm_info->got_value = main_got ();
847 }
848
849 /* Implement the "create_inferior_hook" target_solib_ops method.
850
851 For the FR-V shared library ABI (FDPIC), the main executable needs
852 to be relocated. The shared library breakpoints also need to be
853 enabled. */
854
855 static void
856 frv_solib_create_inferior_hook (int from_tty)
857 {
858 /* Relocate main executable. */
859 frv_relocate_main_executable ();
860
861 /* Enable shared library breakpoints. */
862 if (!enable_break ())
863 {
864 warning (_("shared library handler failed to enable breakpoint"));
865 return;
866 }
867 }
868
869 static void
870 frv_clear_solib (void)
871 {
872 lm_base_cache = 0;
873 enable_break2_done = 0;
874 main_lm_addr = 0;
875 if (main_executable_lm_info != 0)
876 {
877 xfree (main_executable_lm_info->map);
878 xfree (main_executable_lm_info->dyn_syms);
879 xfree (main_executable_lm_info->dyn_relocs);
880 xfree (main_executable_lm_info);
881 main_executable_lm_info = 0;
882 }
883 }
884
885 static void
886 frv_free_so (struct so_list *so)
887 {
888 xfree (so->lm_info->map);
889 xfree (so->lm_info->dyn_syms);
890 xfree (so->lm_info->dyn_relocs);
891 xfree (so->lm_info);
892 }
893
894 static void
895 frv_relocate_section_addresses (struct so_list *so,
896 struct target_section *sec)
897 {
898 int seg;
899 struct int_elf32_fdpic_loadmap *map;
900
901 map = so->lm_info->map;
902
903 for (seg = 0; seg < map->nsegs; seg++)
904 {
905 if (map->segs[seg].p_vaddr <= sec->addr
906 && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
907 {
908 CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
909
910 sec->addr += displ;
911 sec->endaddr += displ;
912 break;
913 }
914 }
915 }
916
917 /* Return the GOT address associated with the main executable. Return
918 0 if it can't be found. */
919
920 static CORE_ADDR
921 main_got (void)
922 {
923 struct minimal_symbol *got_sym;
924
925 got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_",
926 NULL, symfile_objfile);
927 if (got_sym == 0)
928 return 0;
929
930 return SYMBOL_VALUE_ADDRESS (got_sym);
931 }
932
933 /* Find the global pointer for the given function address ADDR. */
934
935 CORE_ADDR
936 frv_fdpic_find_global_pointer (CORE_ADDR addr)
937 {
938 struct so_list *so;
939
940 so = master_so_list ();
941 while (so)
942 {
943 int seg;
944 struct int_elf32_fdpic_loadmap *map;
945
946 map = so->lm_info->map;
947
948 for (seg = 0; seg < map->nsegs; seg++)
949 {
950 if (map->segs[seg].addr <= addr
951 && addr < map->segs[seg].addr + map->segs[seg].p_memsz)
952 return so->lm_info->got_value;
953 }
954
955 so = so->next;
956 }
957
958 /* Didn't find it in any of the shared objects. So assume it's in the
959 main executable. */
960 return main_got ();
961 }
962
963 /* Forward declarations for frv_fdpic_find_canonical_descriptor(). */
964 static CORE_ADDR find_canonical_descriptor_in_load_object
965 (CORE_ADDR, CORE_ADDR, char *, bfd *, struct lm_info *);
966
967 /* Given a function entry point, attempt to find the canonical descriptor
968 associated with that entry point. Return 0 if no canonical descriptor
969 could be found. */
970
971 CORE_ADDR
972 frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point)
973 {
974 char *name;
975 CORE_ADDR addr;
976 CORE_ADDR got_value;
977 struct int_elf32_fdpic_loadmap *ldm = 0;
978 struct symbol *sym;
979 int status;
980 CORE_ADDR exec_loadmap_addr;
981
982 /* Fetch the corresponding global pointer for the entry point. */
983 got_value = frv_fdpic_find_global_pointer (entry_point);
984
985 /* Attempt to find the name of the function. If the name is available,
986 it'll be used as an aid in finding matching functions in the dynamic
987 symbol table. */
988 sym = find_pc_function (entry_point);
989 if (sym == 0)
990 name = 0;
991 else
992 name = SYMBOL_LINKAGE_NAME (sym);
993
994 /* Check the main executable. */
995 addr = find_canonical_descriptor_in_load_object
996 (entry_point, got_value, name, symfile_objfile->obfd,
997 main_executable_lm_info);
998
999 /* If descriptor not found via main executable, check each load object
1000 in list of shared objects. */
1001 if (addr == 0)
1002 {
1003 struct so_list *so;
1004
1005 so = master_so_list ();
1006 while (so)
1007 {
1008 addr = find_canonical_descriptor_in_load_object
1009 (entry_point, got_value, name, so->abfd, so->lm_info);
1010
1011 if (addr != 0)
1012 break;
1013
1014 so = so->next;
1015 }
1016 }
1017
1018 return addr;
1019 }
1020
1021 static CORE_ADDR
1022 find_canonical_descriptor_in_load_object
1023 (CORE_ADDR entry_point, CORE_ADDR got_value, char *name, bfd *abfd,
1024 struct lm_info *lm)
1025 {
1026 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
1027 arelent *rel;
1028 unsigned int i;
1029 CORE_ADDR addr = 0;
1030
1031 /* Nothing to do if no bfd. */
1032 if (abfd == 0)
1033 return 0;
1034
1035 /* Nothing to do if no link map. */
1036 if (lm == 0)
1037 return 0;
1038
1039 /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations.
1040 (More about this later.) But in order to fetch the relocs, we
1041 need to first fetch the dynamic symbols. These symbols need to
1042 be cached due to the way that bfd_canonicalize_dynamic_reloc()
1043 works. (See the comments in the declaration of struct lm_info
1044 for more information.) */
1045 if (lm->dyn_syms == NULL)
1046 {
1047 long storage_needed;
1048 unsigned int number_of_symbols;
1049
1050 /* Determine amount of space needed to hold the dynamic symbol table. */
1051 storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1052
1053 /* If there are no dynamic symbols, there's nothing to do. */
1054 if (storage_needed <= 0)
1055 return 0;
1056
1057 /* Allocate space for the dynamic symbol table. */
1058 lm->dyn_syms = (asymbol **) xmalloc (storage_needed);
1059
1060 /* Fetch the dynamic symbol table. */
1061 number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, lm->dyn_syms);
1062
1063 if (number_of_symbols == 0)
1064 return 0;
1065 }
1066
1067 /* Fetch the dynamic relocations if not already cached. */
1068 if (lm->dyn_relocs == NULL)
1069 {
1070 long storage_needed;
1071
1072 /* Determine amount of space needed to hold the dynamic relocs. */
1073 storage_needed = bfd_get_dynamic_reloc_upper_bound (abfd);
1074
1075 /* Bail out if there are no dynamic relocs. */
1076 if (storage_needed <= 0)
1077 return 0;
1078
1079 /* Allocate space for the relocs. */
1080 lm->dyn_relocs = (arelent **) xmalloc (storage_needed);
1081
1082 /* Fetch the dynamic relocs. */
1083 lm->dyn_reloc_count
1084 = bfd_canonicalize_dynamic_reloc (abfd, lm->dyn_relocs, lm->dyn_syms);
1085 }
1086
1087 /* Search the dynamic relocs. */
1088 for (i = 0; i < lm->dyn_reloc_count; i++)
1089 {
1090 rel = lm->dyn_relocs[i];
1091
1092 /* Relocs of interest are those which meet the following
1093 criteria:
1094
1095 - the names match (assuming the caller could provide
1096 a name which matches ``entry_point'').
1097 - the relocation type must be R_FRV_FUNCDESC. Relocs
1098 of this type are used (by the dynamic linker) to
1099 look up the address of a canonical descriptor (allocating
1100 it if need be) and initializing the GOT entry referred
1101 to by the offset to the address of the descriptor.
1102
1103 These relocs of interest may be used to obtain a
1104 candidate descriptor by first adjusting the reloc's
1105 address according to the link map and then dereferencing
1106 this address (which is a GOT entry) to obtain a descriptor
1107 address. */
1108 if ((name == 0 || strcmp (name, (*rel->sym_ptr_ptr)->name) == 0)
1109 && rel->howto->type == R_FRV_FUNCDESC)
1110 {
1111 gdb_byte buf [FRV_PTR_SIZE];
1112
1113 /* Compute address of address of candidate descriptor. */
1114 addr = rel->address + displacement_from_map (lm->map, rel->address);
1115
1116 /* Fetch address of candidate descriptor. */
1117 if (target_read_memory (addr, buf, sizeof buf) != 0)
1118 continue;
1119 addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
1120
1121 /* Check for matching entry point. */
1122 if (target_read_memory (addr, buf, sizeof buf) != 0)
1123 continue;
1124 if (extract_unsigned_integer (buf, sizeof buf, byte_order)
1125 != entry_point)
1126 continue;
1127
1128 /* Check for matching got value. */
1129 if (target_read_memory (addr + 4, buf, sizeof buf) != 0)
1130 continue;
1131 if (extract_unsigned_integer (buf, sizeof buf, byte_order)
1132 != got_value)
1133 continue;
1134
1135 /* Match was successful! Exit loop. */
1136 break;
1137 }
1138 }
1139
1140 return addr;
1141 }
1142
1143 /* Given an objfile, return the address of its link map. This value is
1144 needed for TLS support. */
1145 CORE_ADDR
1146 frv_fetch_objfile_link_map (struct objfile *objfile)
1147 {
1148 struct so_list *so;
1149
1150 /* Cause frv_current_sos() to be run if it hasn't been already. */
1151 if (main_lm_addr == 0)
1152 solib_add (0, 0, 0, 1);
1153
1154 /* frv_current_sos() will set main_lm_addr for the main executable. */
1155 if (objfile == symfile_objfile)
1156 return main_lm_addr;
1157
1158 /* The other link map addresses may be found by examining the list
1159 of shared libraries. */
1160 for (so = master_so_list (); so; so = so->next)
1161 {
1162 if (so->objfile == objfile)
1163 return so->lm_info->lm_addr;
1164 }
1165
1166 /* Not found! */
1167 return 0;
1168 }
1169
1170 struct target_so_ops frv_so_ops;
1171
1172 /* Provide a prototype to silence -Wmissing-prototypes. */
1173 extern initialize_file_ftype _initialize_frv_solib;
1174
1175 void
1176 _initialize_frv_solib (void)
1177 {
1178 frv_so_ops.relocate_section_addresses = frv_relocate_section_addresses;
1179 frv_so_ops.free_so = frv_free_so;
1180 frv_so_ops.clear_solib = frv_clear_solib;
1181 frv_so_ops.solib_create_inferior_hook = frv_solib_create_inferior_hook;
1182 frv_so_ops.special_symbol_handling = frv_special_symbol_handling;
1183 frv_so_ops.current_sos = frv_current_sos;
1184 frv_so_ops.open_symbol_file_object = open_symbol_file_object;
1185 frv_so_ops.in_dynsym_resolve_code = frv_in_dynsym_resolve_code;
1186 frv_so_ops.bfd_open = solib_bfd_open;
1187
1188 /* Debug this file's internals. */
1189 add_setshow_zinteger_cmd ("solib-frv", class_maintenance,
1190 &solib_frv_debug, _("\
1191 Set internal debugging of shared library code for FR-V."), _("\
1192 Show internal debugging of shared library code for FR-V."), _("\
1193 When non-zero, FR-V solib specific internal debugging is enabled."),
1194 NULL,
1195 NULL, /* FIXME: i18n: */
1196 &setdebuglist, &showdebuglist);
1197 }
This page took 0.053561 seconds and 4 git commands to generate.