Automatic date update in version.in
[external/binutils.git] / gdb / solib-frv.c
1 /* Handle FR-V (FDPIC) shared libraries for GDB, the GNU Debugger.
2    Copyright (C) 2004-2019 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           gdb::unique_xmalloc_ptr<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.get ());
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.get (),
420                        SO_NAME_MAX_PATH_SIZE - 1);
421               sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
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   int changed;
773   struct obj_section *osect;
774
775   status = frv_fdpic_loadmap_addresses (target_gdbarch (),
776                                         &interp_addr, &exec_addr);
777
778   if (status < 0 || (exec_addr == 0 && interp_addr == 0))
779     {
780       /* Not using FDPIC ABI, so do nothing.  */
781       return;
782     }
783
784   /* Fetch the loadmap located at ``exec_addr''.  */
785   ldm = fetch_loadmap (exec_addr);
786   if (ldm == NULL)
787     error (_("Unable to load the executable's loadmap."));
788
789   delete main_executable_lm_info;
790   main_executable_lm_info = new lm_info_frv;
791   main_executable_lm_info->map = ldm;
792
793   gdb::unique_xmalloc_ptr<struct section_offsets> new_offsets
794     (XCNEWVEC (struct section_offsets, symfile_objfile->num_sections));
795   changed = 0;
796
797   ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
798     {
799       CORE_ADDR orig_addr, addr, offset;
800       int osect_idx;
801       int seg;
802       
803       osect_idx = osect - symfile_objfile->sections;
804
805       /* Current address of section.  */
806       addr = obj_section_addr (osect);
807       /* Offset from where this section started.  */
808       offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx);
809       /* Original address prior to any past relocations.  */
810       orig_addr = addr - offset;
811
812       for (seg = 0; seg < ldm->nsegs; seg++)
813         {
814           if (ldm->segs[seg].p_vaddr <= orig_addr
815               && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
816             {
817               new_offsets->offsets[osect_idx]
818                 = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
819
820               if (new_offsets->offsets[osect_idx] != offset)
821                 changed = 1;
822               break;
823             }
824         }
825     }
826
827   if (changed)
828     objfile_relocate (symfile_objfile, new_offsets.get ());
829
830   /* Now that symfile_objfile has been relocated, we can compute the
831      GOT value and stash it away.  */
832   main_executable_lm_info->got_value = main_got ();
833 }
834
835 /* Implement the "create_inferior_hook" target_solib_ops method.
836
837    For the FR-V shared library ABI (FDPIC), the main executable needs
838    to be relocated.  The shared library breakpoints also need to be
839    enabled.  */
840
841 static void
842 frv_solib_create_inferior_hook (int from_tty)
843 {
844   /* Relocate main executable.  */
845   frv_relocate_main_executable ();
846
847   /* Enable shared library breakpoints.  */
848   if (!enable_break ())
849     {
850       warning (_("shared library handler failed to enable breakpoint"));
851       return;
852     }
853 }
854
855 static void
856 frv_clear_solib (void)
857 {
858   lm_base_cache = 0;
859   enable_break2_done = 0;
860   main_lm_addr = 0;
861
862   delete main_executable_lm_info;
863   main_executable_lm_info = NULL;
864 }
865
866 static void
867 frv_free_so (struct so_list *so)
868 {
869   lm_info_frv *li = (lm_info_frv *) so->lm_info;
870
871   delete li;
872 }
873
874 static void
875 frv_relocate_section_addresses (struct so_list *so,
876                                  struct target_section *sec)
877 {
878   int seg;
879   lm_info_frv *li = (lm_info_frv *) so->lm_info;
880   int_elf32_fdpic_loadmap *map = li->map;
881
882   for (seg = 0; seg < map->nsegs; seg++)
883     {
884       if (map->segs[seg].p_vaddr <= sec->addr
885           && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
886         {
887           CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
888
889           sec->addr += displ;
890           sec->endaddr += displ;
891           break;
892         }
893     }
894 }
895
896 /* Return the GOT address associated with the main executable.  Return
897    0 if it can't be found.  */
898
899 static CORE_ADDR
900 main_got (void)
901 {
902   struct bound_minimal_symbol got_sym;
903
904   got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_",
905                                    NULL, symfile_objfile);
906   if (got_sym.minsym == 0)
907     return 0;
908
909   return BMSYMBOL_VALUE_ADDRESS (got_sym);
910 }
911
912 /* Find the global pointer for the given function address ADDR.  */
913
914 CORE_ADDR
915 frv_fdpic_find_global_pointer (CORE_ADDR addr)
916 {
917   struct so_list *so;
918
919   so = master_so_list ();
920   while (so)
921     {
922       int seg;
923       lm_info_frv *li = (lm_info_frv *) so->lm_info;
924       int_elf32_fdpic_loadmap *map = li->map;
925
926       for (seg = 0; seg < map->nsegs; seg++)
927         {
928           if (map->segs[seg].addr <= addr
929               && addr < map->segs[seg].addr + map->segs[seg].p_memsz)
930             return li->got_value;
931         }
932
933       so = so->next;
934     }
935
936   /* Didn't find it in any of the shared objects.  So assume it's in the
937      main executable.  */
938   return main_got ();
939 }
940
941 /* Forward declarations for frv_fdpic_find_canonical_descriptor().  */
942 static CORE_ADDR find_canonical_descriptor_in_load_object
943   (CORE_ADDR, CORE_ADDR, const char *, bfd *, lm_info_frv *);
944
945 /* Given a function entry point, attempt to find the canonical descriptor
946    associated with that entry point.  Return 0 if no canonical descriptor
947    could be found.  */
948
949 CORE_ADDR
950 frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point)
951 {
952   const char *name;
953   CORE_ADDR addr;
954   CORE_ADDR got_value;
955   struct symbol *sym;
956
957   /* Fetch the corresponding global pointer for the entry point.  */
958   got_value = frv_fdpic_find_global_pointer (entry_point);
959
960   /* Attempt to find the name of the function.  If the name is available,
961      it'll be used as an aid in finding matching functions in the dynamic
962      symbol table.  */
963   sym = find_pc_function (entry_point);
964   if (sym == 0)
965     name = 0;
966   else
967     name = SYMBOL_LINKAGE_NAME (sym);
968
969   /* Check the main executable.  */
970   addr = find_canonical_descriptor_in_load_object
971            (entry_point, got_value, name, symfile_objfile->obfd,
972             main_executable_lm_info);
973
974   /* If descriptor not found via main executable, check each load object
975      in list of shared objects.  */
976   if (addr == 0)
977     {
978       struct so_list *so;
979
980       so = master_so_list ();
981       while (so)
982         {
983           lm_info_frv *li = (lm_info_frv *) so->lm_info;
984
985           addr = find_canonical_descriptor_in_load_object
986                    (entry_point, got_value, name, so->abfd, li);
987
988           if (addr != 0)
989             break;
990
991           so = so->next;
992         }
993     }
994
995   return addr;
996 }
997
998 static CORE_ADDR
999 find_canonical_descriptor_in_load_object
1000   (CORE_ADDR entry_point, CORE_ADDR got_value, const char *name, bfd *abfd,
1001    lm_info_frv *lm)
1002 {
1003   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1004   arelent *rel;
1005   unsigned int i;
1006   CORE_ADDR addr = 0;
1007
1008   /* Nothing to do if no bfd.  */
1009   if (abfd == 0)
1010     return 0;
1011
1012   /* Nothing to do if no link map.  */
1013   if (lm == 0)
1014     return 0;
1015
1016   /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations.
1017      (More about this later.)  But in order to fetch the relocs, we
1018      need to first fetch the dynamic symbols.  These symbols need to
1019      be cached due to the way that bfd_canonicalize_dynamic_reloc()
1020      works.  (See the comments in the declaration of struct lm_info
1021      for more information.)  */
1022   if (lm->dyn_syms == NULL)
1023     {
1024       long storage_needed;
1025       unsigned int number_of_symbols;
1026
1027       /* Determine amount of space needed to hold the dynamic symbol table.  */
1028       storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1029
1030       /* If there are no dynamic symbols, there's nothing to do.  */
1031       if (storage_needed <= 0)
1032         return 0;
1033
1034       /* Allocate space for the dynamic symbol table.  */
1035       lm->dyn_syms = (asymbol **) xmalloc (storage_needed);
1036
1037       /* Fetch the dynamic symbol table.  */
1038       number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, lm->dyn_syms);
1039
1040       if (number_of_symbols == 0)
1041         return 0;
1042     }
1043
1044   /* Fetch the dynamic relocations if not already cached.  */
1045   if (lm->dyn_relocs == NULL)
1046     {
1047       long storage_needed;
1048
1049       /* Determine amount of space needed to hold the dynamic relocs.  */
1050       storage_needed = bfd_get_dynamic_reloc_upper_bound (abfd);
1051
1052       /* Bail out if there are no dynamic relocs.  */
1053       if (storage_needed <= 0)
1054         return 0;
1055
1056       /* Allocate space for the relocs.  */
1057       lm->dyn_relocs = (arelent **) xmalloc (storage_needed);
1058
1059       /* Fetch the dynamic relocs.  */
1060       lm->dyn_reloc_count 
1061         = bfd_canonicalize_dynamic_reloc (abfd, lm->dyn_relocs, lm->dyn_syms);
1062     }
1063
1064   /* Search the dynamic relocs.  */
1065   for (i = 0; i < lm->dyn_reloc_count; i++)
1066     {
1067       rel = lm->dyn_relocs[i];
1068
1069       /* Relocs of interest are those which meet the following
1070          criteria:
1071
1072            - the names match (assuming the caller could provide
1073              a name which matches ``entry_point'').
1074            - the relocation type must be R_FRV_FUNCDESC.  Relocs
1075              of this type are used (by the dynamic linker) to
1076              look up the address of a canonical descriptor (allocating
1077              it if need be) and initializing the GOT entry referred
1078              to by the offset to the address of the descriptor.
1079
1080          These relocs of interest may be used to obtain a
1081          candidate descriptor by first adjusting the reloc's
1082          address according to the link map and then dereferencing
1083          this address (which is a GOT entry) to obtain a descriptor
1084          address.  */
1085       if ((name == 0 || strcmp (name, (*rel->sym_ptr_ptr)->name) == 0)
1086           && rel->howto->type == R_FRV_FUNCDESC)
1087         {
1088           gdb_byte buf [FRV_PTR_SIZE];
1089
1090           /* Compute address of address of candidate descriptor.  */
1091           addr = rel->address + displacement_from_map (lm->map, rel->address);
1092
1093           /* Fetch address of candidate descriptor.  */
1094           if (target_read_memory (addr, buf, sizeof buf) != 0)
1095             continue;
1096           addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
1097
1098           /* Check for matching entry point.  */
1099           if (target_read_memory (addr, buf, sizeof buf) != 0)
1100             continue;
1101           if (extract_unsigned_integer (buf, sizeof buf, byte_order)
1102               != entry_point)
1103             continue;
1104
1105           /* Check for matching got value.  */
1106           if (target_read_memory (addr + 4, buf, sizeof buf) != 0)
1107             continue;
1108           if (extract_unsigned_integer (buf, sizeof buf, byte_order)
1109               != got_value)
1110             continue;
1111
1112           /* Match was successful!  Exit loop.  */
1113           break;
1114         }
1115     }
1116
1117   return addr;
1118 }
1119
1120 /* Given an objfile, return the address of its link map.  This value is
1121    needed for TLS support.  */
1122 CORE_ADDR
1123 frv_fetch_objfile_link_map (struct objfile *objfile)
1124 {
1125   struct so_list *so;
1126
1127   /* Cause frv_current_sos() to be run if it hasn't been already.  */
1128   if (main_lm_addr == 0)
1129     solib_add (0, 0, 1);
1130
1131   /* frv_current_sos() will set main_lm_addr for the main executable.  */
1132   if (objfile == symfile_objfile)
1133     return main_lm_addr;
1134
1135   /* The other link map addresses may be found by examining the list
1136      of shared libraries.  */
1137   for (so = master_so_list (); so; so = so->next)
1138     {
1139       lm_info_frv *li = (lm_info_frv *) so->lm_info;
1140
1141       if (so->objfile == objfile)
1142         return li->lm_addr;
1143     }
1144
1145   /* Not found!  */
1146   return 0;
1147 }
1148
1149 struct target_so_ops frv_so_ops;
1150
1151 void
1152 _initialize_frv_solib (void)
1153 {
1154   frv_so_ops.relocate_section_addresses = frv_relocate_section_addresses;
1155   frv_so_ops.free_so = frv_free_so;
1156   frv_so_ops.clear_solib = frv_clear_solib;
1157   frv_so_ops.solib_create_inferior_hook = frv_solib_create_inferior_hook;
1158   frv_so_ops.current_sos = frv_current_sos;
1159   frv_so_ops.open_symbol_file_object = open_symbol_file_object;
1160   frv_so_ops.in_dynsym_resolve_code = frv_in_dynsym_resolve_code;
1161   frv_so_ops.bfd_open = solib_bfd_open;
1162
1163   /* Debug this file's internals.  */
1164   add_setshow_zuinteger_cmd ("solib-frv", class_maintenance,
1165                              &solib_frv_debug, _("\
1166 Set internal debugging of shared library code for FR-V."), _("\
1167 Show internal debugging of shared library code for FR-V."), _("\
1168 When non-zero, FR-V solib specific internal debugging is enabled."),
1169                              NULL,
1170                              NULL, /* FIXME: i18n: */
1171                              &setdebuglist, &showdebuglist);
1172 }