GDB (xrefs)
/tmp/gdb-7.10/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-2015 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. */
48 
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 
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. */
72 {
73  /* Core address to which the segment is mapped. */
75  /* VMA recorded in the program header. */
77  /* Size of this segment in memory. */
78  long p_memsz;
79 };
80 
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 *
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 = 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 = 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 
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 {
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
206  {
207  /* The loadmap, digested into an easier to use form. */
209  /* The GOT address for this link map entry. */
211  /* The link map address, needed for frv_fetch_objfile_link_map(). */
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(). */
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. */
251 
252 /* Link map address for main module. */
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,
285  if (got_sym.minsym == 0)
286  {
287  if (solib_frv_debug)
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)
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)
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 *
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)
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)
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 = xcalloc (1, sizeof (struct so_list));
392  sop->lm_info = xcalloc (1, sizeof (struct lm_info));
393  sop->lm_info->map = loadmap;
394  sop->lm_info->got_value = got_addr;
395  sop->lm_info->lm_addr = lm_addr;
396  /* Fetch the name. */
397  addr = extract_unsigned_integer (lm_buf.l_name,
398  sizeof (lm_buf.l_name),
399  byte_order);
400  target_read_string (addr, &name_buf, SO_NAME_MAX_PATH_SIZE - 1,
401  &errcode);
402 
403  if (solib_frv_debug)
404  fprintf_unfiltered (gdb_stdlog, "current_sos: name = %s\n",
405  name_buf);
406 
407  if (errcode != 0)
408  warning (_("Can't read pathname for link map entry: %s."),
409  safe_strerror (errcode));
410  else
411  {
412  strncpy (sop->so_name, name_buf, SO_NAME_MAX_PATH_SIZE - 1);
413  sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
414  xfree (name_buf);
415  strcpy (sop->so_original_name, sop->so_name);
416  }
417 
418  *sos_next_ptr = sop;
419  sos_next_ptr = &sop->next;
420  }
421  else
422  {
423  main_lm_addr = lm_addr;
424  }
425 
426  lm_addr = extract_unsigned_integer (lm_buf.l_next,
427  sizeof (lm_buf.l_next), byte_order);
428  }
429 
430  enable_break2 ();
431 
432  return sos_head;
433 }
434 
435 
436 /* Return 1 if PC lies in the dynamic symbol resolution code of the
437  run time loader. */
438 
443 
444 static int
446 {
447  return ((pc >= interp_text_sect_low && pc < interp_text_sect_high)
448  || (pc >= interp_plt_sect_low && pc < interp_plt_sect_high)
449  || in_plt_section (pc));
450 }
451 
452 /* Given a loadmap and an address, return the displacement needed
453  to relocate the address. */
454 
455 static CORE_ADDR
457  CORE_ADDR addr)
458 {
459  int seg;
460 
461  for (seg = 0; seg < map->nsegs; seg++)
462  {
463  if (map->segs[seg].p_vaddr <= addr
464  && addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
465  {
466  return map->segs[seg].addr - map->segs[seg].p_vaddr;
467  }
468  }
469 
470  return 0;
471 }
472 
473 /* Print a warning about being unable to set the dynamic linker
474  breakpoint. */
475 
476 static void
478 {
479  warning (_("Unable to find dynamic linker breakpoint function.\n"
480  "GDB will be unable to debug shared library initializers\n"
481  "and track explicitly loaded dynamic code."));
482 }
483 
484 /* Helper function for gdb_bfd_lookup_symbol. */
485 
486 static int
487 cmp_name (asymbol *sym, void *data)
488 {
489  return (strcmp (sym->name, (const char *) data) == 0);
490 }
491 
492 /* Arrange for dynamic linker to hit breakpoint.
493 
494  The dynamic linkers has, as part of its debugger interface, support
495  for arranging for the inferior to hit a breakpoint after mapping in
496  the shared libraries. This function enables that breakpoint.
497 
498  On the FR-V, using the shared library (FDPIC) ABI, the symbol
499  _dl_debug_addr points to the r_debug struct which contains
500  a field called r_brk. r_brk is the address of the function
501  descriptor upon which a breakpoint must be placed. Being a
502  function descriptor, we must extract the entry point in order
503  to set the breakpoint.
504 
505  Our strategy will be to get the .interp section from the
506  executable. This section will provide us with the name of the
507  interpreter. We'll open the interpreter and then look up
508  the address of _dl_debug_addr. We then relocate this address
509  using the interpreter's loadmap. Once the relocated address
510  is known, we fetch the value (address) corresponding to r_brk
511  and then use that value to fetch the entry point of the function
512  we're interested in. */
513 
514 static int enable_break2_done = 0;
515 
516 static int
518 {
519  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
520  int success = 0;
521  char **bkpt_namep;
522  asection *interp_sect;
523 
524  if (enable_break2_done)
525  return 1;
526 
527  interp_text_sect_low = interp_text_sect_high = 0;
528  interp_plt_sect_low = interp_plt_sect_high = 0;
529 
530  /* Find the .interp section; if not found, warn the user and drop
531  into the old breakpoint at symbol code. */
532  interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
533  if (interp_sect)
534  {
535  unsigned int interp_sect_size;
536  char *buf;
537  bfd *tmp_bfd = NULL;
538  int status;
539  CORE_ADDR addr, interp_loadmap_addr;
540  gdb_byte addr_buf[FRV_PTR_SIZE];
541  struct int_elf32_fdpic_loadmap *ldm;
542 
543  /* Read the contents of the .interp section into a local buffer;
544  the contents specify the dynamic linker this program uses. */
545  interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
546  buf = alloca (interp_sect_size);
547  bfd_get_section_contents (exec_bfd, interp_sect,
548  buf, 0, interp_sect_size);
549 
550  /* Now we need to figure out where the dynamic linker was
551  loaded so that we can load its symbols and place a breakpoint
552  in the dynamic linker itself.
553 
554  This address is stored on the stack. However, I've been unable
555  to find any magic formula to find it for Solaris (appears to
556  be trivial on GNU/Linux). Therefore, we have to try an alternate
557  mechanism to find the dynamic linker's base address. */
558 
559  TRY
560  {
561  tmp_bfd = solib_bfd_open (buf);
562  }
563  CATCH (ex, RETURN_MASK_ALL)
564  {
565  }
566  END_CATCH
567 
568  if (tmp_bfd == NULL)
569  {
571  return 0;
572  }
573 
575  &interp_loadmap_addr, 0);
576  if (status < 0)
577  {
578  warning (_("Unable to determine dynamic linker loadmap address."));
580  gdb_bfd_unref (tmp_bfd);
581  return 0;
582  }
583 
584  if (solib_frv_debug)
586  "enable_break: interp_loadmap_addr = %s\n",
587  hex_string_custom (interp_loadmap_addr, 8));
588 
589  ldm = fetch_loadmap (interp_loadmap_addr);
590  if (ldm == NULL)
591  {
592  warning (_("Unable to load dynamic linker loadmap at address %s."),
593  hex_string_custom (interp_loadmap_addr, 8));
595  gdb_bfd_unref (tmp_bfd);
596  return 0;
597  }
598 
599  /* Record the relocated start and end address of the dynamic linker
600  text and plt section for svr4_in_dynsym_resolve_code. */
601  interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
602  if (interp_sect)
603  {
604  interp_text_sect_low
605  = bfd_section_vma (tmp_bfd, interp_sect);
606  interp_text_sect_low
607  += displacement_from_map (ldm, interp_text_sect_low);
608  interp_text_sect_high
609  = interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
610  }
611  interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
612  if (interp_sect)
613  {
614  interp_plt_sect_low =
615  bfd_section_vma (tmp_bfd, interp_sect);
616  interp_plt_sect_low
617  += displacement_from_map (ldm, interp_plt_sect_low);
618  interp_plt_sect_high =
619  interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
620  }
621 
622  addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name, "_dl_debug_addr");
623 
624  if (addr == 0)
625  {
626  warning (_("Could not find symbol _dl_debug_addr "
627  "in dynamic linker"));
629  gdb_bfd_unref (tmp_bfd);
630  return 0;
631  }
632 
633  if (solib_frv_debug)
635  "enable_break: _dl_debug_addr "
636  "(prior to relocation) = %s\n",
637  hex_string_custom (addr, 8));
638 
639  addr += displacement_from_map (ldm, addr);
640 
641  if (solib_frv_debug)
643  "enable_break: _dl_debug_addr "
644  "(after relocation) = %s\n",
645  hex_string_custom (addr, 8));
646 
647  /* Fetch the address of the r_debug struct. */
648  if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0)
649  {
650  warning (_("Unable to fetch contents of _dl_debug_addr "
651  "(at address %s) from dynamic linker"),
652  hex_string_custom (addr, 8));
653  }
654  addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
655 
656  if (solib_frv_debug)
658  "enable_break: _dl_debug_addr[0..3] = %s\n",
659  hex_string_custom (addr, 8));
660 
661  /* If it's zero, then the ldso hasn't initialized yet, and so
662  there are no shared libs yet loaded. */
663  if (addr == 0)
664  {
665  if (solib_frv_debug)
667  "enable_break: ldso not yet initialized\n");
668  /* Do not warn, but mark to run again. */
669  return 0;
670  }
671 
672  /* Fetch the r_brk field. It's 8 bytes from the start of
673  _dl_debug_addr. */
674  if (target_read_memory (addr + 8, addr_buf, sizeof addr_buf) != 0)
675  {
676  warning (_("Unable to fetch _dl_debug_addr->r_brk "
677  "(at address %s) from dynamic linker"),
678  hex_string_custom (addr + 8, 8));
680  gdb_bfd_unref (tmp_bfd);
681  return 0;
682  }
683  addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
684 
685  /* Now fetch the function entry point. */
686  if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0)
687  {
688  warning (_("Unable to fetch _dl_debug_addr->.r_brk entry point "
689  "(at address %s) from dynamic linker"),
690  hex_string_custom (addr, 8));
692  gdb_bfd_unref (tmp_bfd);
693  return 0;
694  }
695  addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
696 
697  /* We're done with the temporary bfd. */
698  gdb_bfd_unref (tmp_bfd);
699 
700  /* We're also done with the loadmap. */
701  xfree (ldm);
702 
703  /* Remove all the solib event breakpoints. Their addresses
704  may have changed since the last time we ran the program. */
706 
707  /* Now (finally!) create the solib breakpoint. */
709 
710  enable_break2_done = 1;
711 
712  return 1;
713  }
714 
715  /* Tell the user we couldn't set a dynamic linker breakpoint. */
717 
718  /* Failure return. */
719  return 0;
720 }
721 
722 static int
724 {
725  asection *interp_sect;
726  CORE_ADDR entry_point;
727 
728  if (symfile_objfile == NULL)
729  {
730  if (solib_frv_debug)
732  "enable_break: No symbol file found.\n");
733  return 0;
734  }
735 
736  if (!entry_point_address_query (&entry_point))
737  {
738  if (solib_frv_debug)
740  "enable_break: Symbol file has no entry point.\n");
741  return 0;
742  }
743 
744  /* Check for the presence of a .interp section. If there is no
745  such section, the executable is statically linked. */
746 
747  interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
748 
749  if (interp_sect == NULL)
750  {
751  if (solib_frv_debug)
753  "enable_break: No .interp section found.\n");
754  return 0;
755  }
756 
758 
759  if (solib_frv_debug)
761  "enable_break: solib event breakpoint "
762  "placed at entry point: %s\n",
763  hex_string_custom (entry_point, 8));
764  return 1;
765 }
766 
767 /* Implement the "special_symbol_handling" target_so_ops method. */
768 
769 static void
771 {
772  /* Nothing needed for FRV. */
773 }
774 
775 static void
777 {
778  int status;
779  CORE_ADDR exec_addr, interp_addr;
780  struct int_elf32_fdpic_loadmap *ldm;
781  struct cleanup *old_chain;
782  struct section_offsets *new_offsets;
783  int changed;
784  struct obj_section *osect;
785 
787  &interp_addr, &exec_addr);
788 
789  if (status < 0 || (exec_addr == 0 && interp_addr == 0))
790  {
791  /* Not using FDPIC ABI, so do nothing. */
792  return;
793  }
794 
795  /* Fetch the loadmap located at ``exec_addr''. */
796  ldm = fetch_loadmap (exec_addr);
797  if (ldm == NULL)
798  error (_("Unable to load the executable's loadmap."));
799 
800  if (main_executable_lm_info)
801  xfree (main_executable_lm_info);
802  main_executable_lm_info = xcalloc (1, sizeof (struct lm_info));
803  main_executable_lm_info->map = ldm;
804 
805  new_offsets = xcalloc (symfile_objfile->num_sections,
806  sizeof (struct section_offsets));
807  old_chain = make_cleanup (xfree, new_offsets);
808  changed = 0;
809 
811  {
812  CORE_ADDR orig_addr, addr, offset;
813  int osect_idx;
814  int seg;
815 
816  osect_idx = osect - symfile_objfile->sections;
817 
818  /* Current address of section. */
819  addr = obj_section_addr (osect);
820  /* Offset from where this section started. */
821  offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx);
822  /* Original address prior to any past relocations. */
823  orig_addr = addr - offset;
824 
825  for (seg = 0; seg < ldm->nsegs; seg++)
826  {
827  if (ldm->segs[seg].p_vaddr <= orig_addr
828  && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
829  {
830  new_offsets->offsets[osect_idx]
831  = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
832 
833  if (new_offsets->offsets[osect_idx] != offset)
834  changed = 1;
835  break;
836  }
837  }
838  }
839 
840  if (changed)
841  objfile_relocate (symfile_objfile, new_offsets);
842 
843  do_cleanups (old_chain);
844 
845  /* Now that symfile_objfile has been relocated, we can compute the
846  GOT value and stash it away. */
847  main_executable_lm_info->got_value = main_got ();
848 }
849 
850 /* Implement the "create_inferior_hook" target_solib_ops method.
851 
852  For the FR-V shared library ABI (FDPIC), the main executable needs
853  to be relocated. The shared library breakpoints also need to be
854  enabled. */
855 
856 static void
858 {
859  /* Relocate main executable. */
861 
862  /* Enable shared library breakpoints. */
863  if (!enable_break ())
864  {
865  warning (_("shared library handler failed to enable breakpoint"));
866  return;
867  }
868 }
869 
870 static void
872 {
873  lm_base_cache = 0;
874  enable_break2_done = 0;
875  main_lm_addr = 0;
876  if (main_executable_lm_info != 0)
877  {
878  xfree (main_executable_lm_info->map);
879  xfree (main_executable_lm_info->dyn_syms);
880  xfree (main_executable_lm_info->dyn_relocs);
881  xfree (main_executable_lm_info);
882  main_executable_lm_info = 0;
883  }
884 }
885 
886 static void
887 frv_free_so (struct so_list *so)
888 {
889  xfree (so->lm_info->map);
890  xfree (so->lm_info->dyn_syms);
891  xfree (so->lm_info->dyn_relocs);
892  xfree (so->lm_info);
893 }
894 
895 static void
897  struct target_section *sec)
898 {
899  int seg;
900  struct int_elf32_fdpic_loadmap *map;
901 
902  map = so->lm_info->map;
903 
904  for (seg = 0; seg < map->nsegs; seg++)
905  {
906  if (map->segs[seg].p_vaddr <= sec->addr
907  && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
908  {
909  CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
910 
911  sec->addr += displ;
912  sec->endaddr += displ;
913  break;
914  }
915  }
916 }
917 
918 /* Return the GOT address associated with the main executable. Return
919  0 if it can't be found. */
920 
921 static CORE_ADDR
922 main_got (void)
923 {
924  struct bound_minimal_symbol got_sym;
925 
926  got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_",
927  NULL, symfile_objfile);
928  if (got_sym.minsym == 0)
929  return 0;
930 
931  return BMSYMBOL_VALUE_ADDRESS (got_sym);
932 }
933 
934 /* Find the global pointer for the given function address ADDR. */
935 
936 CORE_ADDR
938 {
939  struct so_list *so;
940 
941  so = master_so_list ();
942  while (so)
943  {
944  int seg;
945  struct int_elf32_fdpic_loadmap *map;
946 
947  map = so->lm_info->map;
948 
949  for (seg = 0; seg < map->nsegs; seg++)
950  {
951  if (map->segs[seg].addr <= addr
952  && addr < map->segs[seg].addr + map->segs[seg].p_memsz)
953  return so->lm_info->got_value;
954  }
955 
956  so = so->next;
957  }
958 
959  /* Didn't find it in any of the shared objects. So assume it's in the
960  main executable. */
961  return main_got ();
962 }
963 
964 /* Forward declarations for frv_fdpic_find_canonical_descriptor(). */
966  (CORE_ADDR, CORE_ADDR, const char *, bfd *, struct lm_info *);
967 
968 /* Given a function entry point, attempt to find the canonical descriptor
969  associated with that entry point. Return 0 if no canonical descriptor
970  could be found. */
971 
972 CORE_ADDR
974 {
975  const char *name;
976  CORE_ADDR addr;
977  CORE_ADDR got_value;
978  struct int_elf32_fdpic_loadmap *ldm = 0;
979  struct symbol *sym;
980 
981  /* Fetch the corresponding global pointer for the entry point. */
982  got_value = frv_fdpic_find_global_pointer (entry_point);
983 
984  /* Attempt to find the name of the function. If the name is available,
985  it'll be used as an aid in finding matching functions in the dynamic
986  symbol table. */
987  sym = find_pc_function (entry_point);
988  if (sym == 0)
989  name = 0;
990  else
991  name = SYMBOL_LINKAGE_NAME (sym);
992 
993  /* Check the main executable. */
995  (entry_point, got_value, name, symfile_objfile->obfd,
996  main_executable_lm_info);
997 
998  /* If descriptor not found via main executable, check each load object
999  in list of shared objects. */
1000  if (addr == 0)
1001  {
1002  struct so_list *so;
1003 
1004  so = master_so_list ();
1005  while (so)
1006  {
1008  (entry_point, got_value, name, so->abfd, so->lm_info);
1009 
1010  if (addr != 0)
1011  break;
1012 
1013  so = so->next;
1014  }
1015  }
1016 
1017  return addr;
1018 }
1019 
1020 static CORE_ADDR
1022  (CORE_ADDR entry_point, CORE_ADDR got_value, const char *name, bfd *abfd,
1023  struct lm_info *lm)
1024 {
1025  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1026  arelent *rel;
1027  unsigned int i;
1028  CORE_ADDR addr = 0;
1029 
1030  /* Nothing to do if no bfd. */
1031  if (abfd == 0)
1032  return 0;
1033 
1034  /* Nothing to do if no link map. */
1035  if (lm == 0)
1036  return 0;
1037 
1038  /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations.
1039  (More about this later.) But in order to fetch the relocs, we
1040  need to first fetch the dynamic symbols. These symbols need to
1041  be cached due to the way that bfd_canonicalize_dynamic_reloc()
1042  works. (See the comments in the declaration of struct lm_info
1043  for more information.) */
1044  if (lm->dyn_syms == NULL)
1045  {
1046  long storage_needed;
1047  unsigned int number_of_symbols;
1048 
1049  /* Determine amount of space needed to hold the dynamic symbol table. */
1050  storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1051 
1052  /* If there are no dynamic symbols, there's nothing to do. */
1053  if (storage_needed <= 0)
1054  return 0;
1055 
1056  /* Allocate space for the dynamic symbol table. */
1057  lm->dyn_syms = (asymbol **) xmalloc (storage_needed);
1058 
1059  /* Fetch the dynamic symbol table. */
1060  number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, lm->dyn_syms);
1061 
1062  if (number_of_symbols == 0)
1063  return 0;
1064  }
1065 
1066  /* Fetch the dynamic relocations if not already cached. */
1067  if (lm->dyn_relocs == NULL)
1068  {
1069  long storage_needed;
1070 
1071  /* Determine amount of space needed to hold the dynamic relocs. */
1072  storage_needed = bfd_get_dynamic_reloc_upper_bound (abfd);
1073 
1074  /* Bail out if there are no dynamic relocs. */
1075  if (storage_needed <= 0)
1076  return 0;
1077 
1078  /* Allocate space for the relocs. */
1079  lm->dyn_relocs = (arelent **) xmalloc (storage_needed);
1080 
1081  /* Fetch the dynamic relocs. */
1082  lm->dyn_reloc_count
1083  = bfd_canonicalize_dynamic_reloc (abfd, lm->dyn_relocs, lm->dyn_syms);
1084  }
1085 
1086  /* Search the dynamic relocs. */
1087  for (i = 0; i < lm->dyn_reloc_count; i++)
1088  {
1089  rel = lm->dyn_relocs[i];
1090 
1091  /* Relocs of interest are those which meet the following
1092  criteria:
1093 
1094  - the names match (assuming the caller could provide
1095  a name which matches ``entry_point'').
1096  - the relocation type must be R_FRV_FUNCDESC. Relocs
1097  of this type are used (by the dynamic linker) to
1098  look up the address of a canonical descriptor (allocating
1099  it if need be) and initializing the GOT entry referred
1100  to by the offset to the address of the descriptor.
1101 
1102  These relocs of interest may be used to obtain a
1103  candidate descriptor by first adjusting the reloc's
1104  address according to the link map and then dereferencing
1105  this address (which is a GOT entry) to obtain a descriptor
1106  address. */
1107  if ((name == 0 || strcmp (name, (*rel->sym_ptr_ptr)->name) == 0)
1108  && rel->howto->type == R_FRV_FUNCDESC)
1109  {
1110  gdb_byte buf [FRV_PTR_SIZE];
1111 
1112  /* Compute address of address of candidate descriptor. */
1113  addr = rel->address + displacement_from_map (lm->map, rel->address);
1114 
1115  /* Fetch address of candidate descriptor. */
1116  if (target_read_memory (addr, buf, sizeof buf) != 0)
1117  continue;
1118  addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
1119 
1120  /* Check for matching entry point. */
1121  if (target_read_memory (addr, buf, sizeof buf) != 0)
1122  continue;
1123  if (extract_unsigned_integer (buf, sizeof buf, byte_order)
1124  != entry_point)
1125  continue;
1126 
1127  /* Check for matching got value. */
1128  if (target_read_memory (addr + 4, buf, sizeof buf) != 0)
1129  continue;
1130  if (extract_unsigned_integer (buf, sizeof buf, byte_order)
1131  != got_value)
1132  continue;
1133 
1134  /* Match was successful! Exit loop. */
1135  break;
1136  }
1137  }
1138 
1139  return addr;
1140 }
1141 
1142 /* Given an objfile, return the address of its link map. This value is
1143  needed for TLS support. */
1144 CORE_ADDR
1146 {
1147  struct so_list *so;
1148 
1149  /* Cause frv_current_sos() to be run if it hasn't been already. */
1150  if (main_lm_addr == 0)
1151  solib_add (0, 0, 0, 1);
1152 
1153  /* frv_current_sos() will set main_lm_addr for the main executable. */
1154  if (objfile == symfile_objfile)
1155  return main_lm_addr;
1156 
1157  /* The other link map addresses may be found by examining the list
1158  of shared libraries. */
1159  for (so = master_so_list (); so; so = so->next)
1160  {
1161  if (so->objfile == objfile)
1162  return so->lm_info->lm_addr;
1163  }
1164 
1165  /* Not found! */
1166  return 0;
1167 }
1168 
1170 
1171 /* Provide a prototype to silence -Wmissing-prototypes. */
1173 
1174 void
1176 {
1186 
1187  /* Debug this file's internals. */
1189  &solib_frv_debug, _("\
1190 Set internal debugging of shared library code for FR-V."), _("\
1191 Show internal debugging of shared library code for FR-V."), _("\
1192 When non-zero, FR-V solib specific internal debugging is enabled."),
1193  NULL,
1194  NULL, /* FIXME: i18n: */
1196 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
gdb_byte ext_Elf32_Half[2]
Definition: solib-frv.c:45
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
CORE_ADDR frv_fdpic_find_canonical_descriptor(CORE_ADDR entry_point)
Definition: solib-frv.c:973
static void frv_special_symbol_handling(void)
Definition: solib-frv.c:770
CORE_ADDR offsets[1]
Definition: symtab.h:907
int frv_fdpic_loadmap_addresses(struct gdbarch *gdbarch, CORE_ADDR *interp_addr, CORE_ADDR *exec_addr)
Definition: frv-tdep.c:104
void remove_solib_event_breakpoints(void)
Definition: breakpoint.c:7681
static CORE_ADDR lm_base_cache
Definition: solib-frv.c:250
int dyn_reloc_count
Definition: solib-frv.c:226
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_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:763
bfd_vma CORE_ADDR
Definition: common-types.h:41
gdb_byte ext_ptr[4]
Definition: solib-frv.c:181
void xfree(void *)
Definition: common-utils.c:97
struct so_list * next
Definition: solist.h:36
struct breakpoint * create_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7721
static CORE_ADDR main_got(void)
Definition: solib-frv.c:922
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
void warning(const char *fmt,...)
Definition: errors.c:26
struct ext_elf32_fdpic_loadseg segs[1]
Definition: solib-frv.c:65
static CORE_ADDR main_lm_addr
Definition: solib-frv.c:253
asymbol ** dyn_syms
Definition: solib-frv.c:224
static void frv_free_so(struct so_list *so)
Definition: solib-frv.c:887
void(* relocate_section_addresses)(struct so_list *so, struct target_section *)
Definition: solist.h:84
CORE_ADDR got_value
Definition: solib-frv.c:210
void(* solib_create_inferior_hook)(int from_tty)
Definition: solist.h:101
struct so_list *(* current_sos)(void)
Definition: solist.h:116
void objfile_relocate(struct objfile *objfile, const struct section_offsets *new_offsets)
Definition: objfiles.c:836
bfd *(* bfd_open)(char *pathname)
Definition: solist.h:130
ext_Elf32_Half version
Definition: solib-frv.c:61
static struct int_elf32_fdpic_loadmap * fetch_loadmap(CORE_ADDR ldmaddr)
Definition: solib-frv.c:97
Definition: solist.h:30
gdb_byte ext_Elf32_Word[4]
Definition: solib-frv.c:47
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:627
#define SO_NAME_MAX_PATH_SIZE
Definition: solist.h:22
static CORE_ADDR lm_base(void)
Definition: solib-frv.c:264
static CORE_ADDR lm_addr(struct so_list *so)
Definition: nto-tdep.c:262
#define _(String)
Definition: gdb_locale.h:40
#define END_CATCH
int(* open_symbol_file_object)(void *from_ttyp)
Definition: solist.h:123
static int enable_break2(void)
Definition: solib-frv.c:517
bfd * abfd
Definition: solist.h:63
static int frv_in_dynsym_resolve_code(CORE_ADDR pc)
Definition: solib-frv.c:445
#define obj_section_addr(s)
Definition: objfiles.h:135
ext_Elf32_Addr addr
Definition: solib-frv.c:52
struct lm_info * lm_info
Definition: solist.h:42
void(* clear_solib)(void)
Definition: solist.h:98
#define TRY
static void frv_clear_solib(void)
Definition: solib-frv.c:871
struct so_list * master_so_list(void)
Definition: solib.c:659
const char *const name
Definition: aarch64-tdep.c:68
int(* in_dynsym_resolve_code)(CORE_ADDR pc)
Definition: solist.h:127
#define CATCH(EXCEPTION, MASK)
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
void initialize_file_ftype(void)
Definition: defs.h:281
CORE_ADDR gdb_bfd_lookup_symbol(bfd *abfd, int(*match_sym)(asymbol *, void *), void *data)
Definition: solib.c:1629
#define exec_bfd
Definition: exec.h:32
arelent ** dyn_relocs
Definition: solib-frv.c:225
struct symbol * find_pc_function(CORE_ADDR pc)
Definition: blockframe.c:150
static int enable_break(void)
Definition: solib-frv.c:723
struct int_elf32_fdpic_loadmap * map
Definition: solib-frv.c:208
static void frv_relocate_main_executable(void)
Definition: solib-frv.c:776
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
CORE_ADDR frv_fetch_objfile_link_map(struct objfile *objfile)
Definition: solib-frv.c:1145
static unsigned int solib_frv_debug
Definition: solib-frv.c:35
char so_original_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:49
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
void solib_add(const char *pattern, int from_tty, struct target_ops *target, int readsyms)
Definition: solib.c:965
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:910
const char version[]
Definition: version.c:2
static struct lm_info * main_executable_lm_info
Definition: solib-frv.c:234
char so_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:52
gdb_byte ext_Elf32_Addr[4]
Definition: solib-frv.c:46
static CORE_ADDR find_canonical_descriptor_in_load_object(CORE_ADDR, CORE_ADDR, const char *, bfd *, struct lm_info *)
Definition: solib-frv.c:1022
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
#define symfile_objfile
Definition: progspace.h:216
CORE_ADDR endaddr
Definition: target.h:2260
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
void * xmalloc(YYSIZE_T)
struct ui_file * gdb_stdlog
Definition: main.c:73
ext_Elf32_Half nsegs
Definition: solib-frv.c:63
void(* special_symbol_handling)(void)
Definition: solist.h:107
CORE_ADDR addr
Definition: target.h:2259
ext_Elf32_Addr p_vaddr
Definition: solib-frv.c:54
static int open_symbol_file_object(void *from_ttyp)
Definition: solib-frv.c:243
ext_Elf32_Word p_memsz
Definition: solib-frv.c:56
static CORE_ADDR interp_text_sect_low
Definition: solib-frv.c:439
struct int_elf32_dsbt_loadmap * map
Definition: solib-dsbt.c:129
int entry_point_address_query(CORE_ADDR *entry_p)
Definition: objfiles.c:377
bfd_byte gdb_byte
Definition: common-types.h:38
static void enable_break_failure_warning(void)
Definition: solib-frv.c:477
struct int_elf32_fdpic_loadseg segs[1]
Definition: solib-frv.c:87
static CORE_ADDR interp_plt_sect_high
Definition: solib-frv.c:442
static int cmp_name(asymbol *sym, void *data)
Definition: solib-frv.c:487
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
static int in_plt_section(CORE_ADDR pc)
Definition: objfiles.h:539
struct minimal_symbol * minsym
Definition: minsyms.h:32
void(* free_so)(struct so_list *so)
Definition: solist.h:89
char * safe_strerror(int)
int offset
Definition: agent.c:65
CORE_ADDR lm_addr
Definition: nto-tdep.c:257
struct target_so_ops frv_so_ops
Definition: solib-frv.c:1169
initialize_file_ftype _initialize_frv_solib
CORE_ADDR frv_fdpic_find_global_pointer(CORE_ADDR addr)
Definition: solib-frv.c:937
static CORE_ADDR displacement_from_map(struct int_elf32_fdpic_loadmap *map, CORE_ADDR addr)
Definition: solib-frv.c:456
Definition: symtab.h:703
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
bfd * core_bfd
Definition: corefile.c:58
static CORE_ADDR interp_plt_sect_low
Definition: solib-frv.c:441
static struct so_list * frv_current_sos(void)
Definition: solib-frv.c:316
static CORE_ADDR interp_text_sect_high
Definition: solib-frv.c:440
struct objfile * objfile
Definition: solist.h:69
static int enable_break2_done
Definition: solib-frv.c:514
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:71
static void frv_relocate_section_addresses(struct so_list *so, struct target_section *sec)
Definition: solib-frv.c:896
int target_read_string(CORE_ADDR memaddr, char **string, int len, int *errnop)
Definition: target.c:915
void error(const char *fmt,...)
Definition: errors.c:38
static void frv_solib_create_inferior_hook(int from_tty)
Definition: solib-frv.c:857
bfd * solib_bfd_open(char *pathname)
Definition: solib.c:481
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175