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