GDB (xrefs)

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