update copyright year range in GDB files
[external/binutils.git] / gdb / solib-frv.c
1 /* Handle FR-V (FDPIC) shared libraries for GDB, the GNU Debugger.
2    Copyright (C) 2004-2017 Free Software Foundation, Inc.
3
4    This file is part of GDB.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
18
19
20 #include "defs.h"
21 #include "inferior.h"
22 #include "gdbcore.h"
23 #include "solib.h"
24 #include "solist.h"
25 #include "frv-tdep.h"
26 #include "objfiles.h"
27 #include "symtab.h"
28 #include "language.h"
29 #include "command.h"
30 #include "gdbcmd.h"
31 #include "elf/frv.h"
32 #include "gdb_bfd.h"
33
34 /* Flag which indicates whether internal debug messages should be printed.  */
35 static unsigned int solib_frv_debug;
36
37 /* FR-V pointers are four bytes wide.  */
38 enum { FRV_PTR_SIZE = 4 };
39
40 /* Representation of loadmap and related structs for the FR-V FDPIC ABI.  */
41
42 /* External versions; the size and alignment of the fields should be
43    the same as those on the target.  When loaded, the placement of
44    the bits in each field will be the same as on the target.  */
45 typedef gdb_byte ext_Elf32_Half[2];
46 typedef gdb_byte ext_Elf32_Addr[4];
47 typedef gdb_byte ext_Elf32_Word[4];
48
49 struct ext_elf32_fdpic_loadseg
50 {
51   /* Core address to which the segment is mapped.  */
52   ext_Elf32_Addr addr;
53   /* VMA recorded in the program header.  */
54   ext_Elf32_Addr p_vaddr;
55   /* Size of this segment in memory.  */
56   ext_Elf32_Word p_memsz;
57 };
58
59 struct ext_elf32_fdpic_loadmap {
60   /* Protocol version number, must be zero.  */
61   ext_Elf32_Half version;
62   /* Number of segments in this map.  */
63   ext_Elf32_Half nsegs;
64   /* The actual memory map.  */
65   struct ext_elf32_fdpic_loadseg segs[1 /* nsegs, actually */];
66 };
67
68 /* Internal versions; the types are GDB types and the data in each
69    of the fields is (or will be) decoded from the external struct
70    for ease of consumption.  */
71 struct int_elf32_fdpic_loadseg
72 {
73   /* Core address to which the segment is mapped.  */
74   CORE_ADDR addr;
75   /* VMA recorded in the program header.  */
76   CORE_ADDR p_vaddr;
77   /* Size of this segment in memory.  */
78   long p_memsz;
79 };
80
81 struct int_elf32_fdpic_loadmap {
82   /* Protocol version number, must be zero.  */
83   int version;
84   /* Number of segments in this map.  */
85   int nsegs;
86   /* The actual memory map.  */
87   struct int_elf32_fdpic_loadseg segs[1 /* nsegs, actually */];
88 };
89
90 /* Given address LDMADDR, fetch and decode the loadmap at that address.
91    Return NULL if there is a problem reading the target memory or if
92    there doesn't appear to be a loadmap at the given address.  The
93    allocated space (representing the loadmap) returned by this
94    function may be freed via a single call to xfree().  */
95
96 static struct int_elf32_fdpic_loadmap *
97 fetch_loadmap (CORE_ADDR ldmaddr)
98 {
99   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
100   struct ext_elf32_fdpic_loadmap ext_ldmbuf_partial;
101   struct ext_elf32_fdpic_loadmap *ext_ldmbuf;
102   struct int_elf32_fdpic_loadmap *int_ldmbuf;
103   int ext_ldmbuf_size, int_ldmbuf_size;
104   int version, seg, nsegs;
105
106   /* Fetch initial portion of the loadmap.  */
107   if (target_read_memory (ldmaddr, (gdb_byte *) &ext_ldmbuf_partial,
108                           sizeof ext_ldmbuf_partial))
109     {
110       /* Problem reading the target's memory.  */
111       return NULL;
112     }
113
114   /* Extract the version.  */
115   version = extract_unsigned_integer (ext_ldmbuf_partial.version,
116                                       sizeof ext_ldmbuf_partial.version,
117                                       byte_order);
118   if (version != 0)
119     {
120       /* We only handle version 0.  */
121       return NULL;
122     }
123
124   /* Extract the number of segments.  */
125   nsegs = extract_unsigned_integer (ext_ldmbuf_partial.nsegs,
126                                     sizeof ext_ldmbuf_partial.nsegs,
127                                     byte_order);
128
129   if (nsegs <= 0)
130     return NULL;
131
132   /* Allocate space for the complete (external) loadmap.  */
133   ext_ldmbuf_size = sizeof (struct ext_elf32_fdpic_loadmap)
134                + (nsegs - 1) * sizeof (struct ext_elf32_fdpic_loadseg);
135   ext_ldmbuf = (struct ext_elf32_fdpic_loadmap *) xmalloc (ext_ldmbuf_size);
136
137   /* Copy over the portion of the loadmap that's already been read.  */
138   memcpy (ext_ldmbuf, &ext_ldmbuf_partial, sizeof ext_ldmbuf_partial);
139
140   /* Read the rest of the loadmap from the target.  */
141   if (target_read_memory (ldmaddr + sizeof ext_ldmbuf_partial,
142                           (gdb_byte *) ext_ldmbuf + sizeof ext_ldmbuf_partial,
143                           ext_ldmbuf_size - sizeof ext_ldmbuf_partial))
144     {
145       /* Couldn't read rest of the loadmap.  */
146       xfree (ext_ldmbuf);
147       return NULL;
148     }
149
150   /* Allocate space into which to put information extract from the
151      external loadsegs.  I.e, allocate the internal loadsegs.  */
152   int_ldmbuf_size = sizeof (struct int_elf32_fdpic_loadmap)
153                + (nsegs - 1) * sizeof (struct int_elf32_fdpic_loadseg);
154   int_ldmbuf = (struct int_elf32_fdpic_loadmap *) xmalloc (int_ldmbuf_size);
155
156   /* Place extracted information in internal structs.  */
157   int_ldmbuf->version = version;
158   int_ldmbuf->nsegs = nsegs;
159   for (seg = 0; seg < nsegs; seg++)
160     {
161       int_ldmbuf->segs[seg].addr
162         = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
163                                     sizeof (ext_ldmbuf->segs[seg].addr),
164                                     byte_order);
165       int_ldmbuf->segs[seg].p_vaddr
166         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr,
167                                     sizeof (ext_ldmbuf->segs[seg].p_vaddr),
168                                     byte_order);
169       int_ldmbuf->segs[seg].p_memsz
170         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz,
171                                     sizeof (ext_ldmbuf->segs[seg].p_memsz),
172                                     byte_order);
173     }
174
175   xfree (ext_ldmbuf);
176   return int_ldmbuf;
177 }
178
179 /* External link_map and elf32_fdpic_loadaddr struct definitions.  */
180
181 typedef gdb_byte ext_ptr[4];
182
183 struct ext_elf32_fdpic_loadaddr
184 {
185   ext_ptr map;                  /* struct elf32_fdpic_loadmap *map; */
186   ext_ptr got_value;            /* void *got_value; */
187 };
188
189 struct ext_link_map
190 {
191   struct ext_elf32_fdpic_loadaddr l_addr;
192
193   /* Absolute file name object was found in.  */
194   ext_ptr l_name;               /* char *l_name; */
195
196   /* Dynamic section of the shared object.  */
197   ext_ptr l_ld;                 /* ElfW(Dyn) *l_ld; */
198
199   /* Chain of loaded objects.  */
200   ext_ptr l_next, l_prev;       /* struct link_map *l_next, *l_prev; */
201 };
202
203 /* Link map info to include in an allocated so_list entry.  */
204
205 struct lm_info
206   {
207     /* The loadmap, digested into an easier to use form.  */
208     struct int_elf32_fdpic_loadmap *map;
209     /* The GOT address for this link map entry.  */
210     CORE_ADDR got_value;
211     /* The link map address, needed for frv_fetch_objfile_link_map().  */
212     CORE_ADDR lm_addr;
213
214     /* Cached dynamic symbol table and dynamic relocs initialized and
215        used only by find_canonical_descriptor_in_load_object().
216
217        Note: kevinb/2004-02-26: It appears that calls to
218        bfd_canonicalize_dynamic_reloc() will use the same symbols as
219        those supplied to the first call to this function.  Therefore,
220        it's important to NOT free the asymbol ** data structure
221        supplied to the first call.  Thus the caching of the dynamic
222        symbols (dyn_syms) is critical for correct operation.  The
223        caching of the dynamic relocations could be dispensed with.  */
224     asymbol **dyn_syms;
225     arelent **dyn_relocs;
226     int dyn_reloc_count;        /* Number of dynamic relocs.  */
227
228   };
229
230 /* The load map, got value, etc. are not available from the chain
231    of loaded shared objects.  ``main_executable_lm_info'' provides
232    a way to get at this information so that it doesn't need to be
233    frequently recomputed.  Initialized by frv_relocate_main_executable().  */
234 static struct lm_info *main_executable_lm_info;
235
236 static void frv_relocate_main_executable (void);
237 static CORE_ADDR main_got (void);
238 static int enable_break2 (void);
239
240 /* Implement the "open_symbol_file_object" target_so_ops method.  */
241
242 static int
243 open_symbol_file_object (void *from_ttyp)
244 {
245   /* Unimplemented.  */
246   return 0;
247 }
248
249 /* Cached value for lm_base(), below.  */
250 static CORE_ADDR lm_base_cache = 0;
251
252 /* Link map address for main module.  */
253 static CORE_ADDR main_lm_addr = 0;
254
255 /* Return the address from which the link map chain may be found.  On
256    the FR-V, this may be found in a number of ways.  Assuming that the
257    main executable has already been relocated, the easiest way to find
258    this value is to look up the address of _GLOBAL_OFFSET_TABLE_.  A
259    pointer to the start of the link map will be located at the word found
260    at _GLOBAL_OFFSET_TABLE_ + 8.  (This is part of the dynamic linker
261    reserve area mandated by the ABI.)  */
262
263 static CORE_ADDR
264 lm_base (void)
265 {
266   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
267   struct bound_minimal_symbol got_sym;
268   CORE_ADDR addr;
269   gdb_byte buf[FRV_PTR_SIZE];
270
271   /* One of our assumptions is that the main executable has been relocated.
272      Bail out if this has not happened.  (Note that post_create_inferior()
273      in infcmd.c will call solib_add prior to solib_create_inferior_hook().
274      If we allow this to happen, lm_base_cache will be initialized with
275      a bogus value.  */
276   if (main_executable_lm_info == 0)
277     return 0;
278
279   /* If we already have a cached value, return it.  */
280   if (lm_base_cache)
281     return lm_base_cache;
282
283   got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL,
284                                    symfile_objfile);
285   if (got_sym.minsym == 0)
286     {
287       if (solib_frv_debug)
288         fprintf_unfiltered (gdb_stdlog,
289                             "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
290       return 0;
291     }
292
293   addr = BMSYMBOL_VALUE_ADDRESS (got_sym) + 8;
294
295   if (solib_frv_debug)
296     fprintf_unfiltered (gdb_stdlog,
297                         "lm_base: _GLOBAL_OFFSET_TABLE_ + 8 = %s\n",
298                         hex_string_custom (addr, 8));
299
300   if (target_read_memory (addr, buf, sizeof buf) != 0)
301     return 0;
302   lm_base_cache = extract_unsigned_integer (buf, sizeof buf, byte_order);
303
304   if (solib_frv_debug)
305     fprintf_unfiltered (gdb_stdlog,
306                         "lm_base: lm_base_cache = %s\n",
307                         hex_string_custom (lm_base_cache, 8));
308
309   return lm_base_cache;
310 }
311
312
313 /* Implement the "current_sos" target_so_ops method.  */
314
315 static struct so_list *
316 frv_current_sos (void)
317 {
318   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
319   CORE_ADDR lm_addr, mgot;
320   struct so_list *sos_head = NULL;
321   struct so_list **sos_next_ptr = &sos_head;
322
323   /* Make sure that the main executable has been relocated.  This is
324      required in order to find the address of the global offset table,
325      which in turn is used to find the link map info.  (See lm_base()
326      for details.)
327
328      Note that the relocation of the main executable is also performed
329      by solib_create_inferior_hook(), however, in the case of core
330      files, this hook is called too late in order to be of benefit to
331      solib_add.  solib_add eventually calls this this function,
332      frv_current_sos, and also precedes the call to
333      solib_create_inferior_hook().   (See post_create_inferior() in
334      infcmd.c.)  */
335   if (main_executable_lm_info == 0 && core_bfd != NULL)
336     frv_relocate_main_executable ();
337
338   /* Fetch the GOT corresponding to the main executable.  */
339   mgot = main_got ();
340
341   /* Locate the address of the first link map struct.  */
342   lm_addr = lm_base ();
343
344   /* We have at least one link map entry.  Fetch the lot of them,
345      building the solist chain.  */
346   while (lm_addr)
347     {
348       struct ext_link_map lm_buf;
349       CORE_ADDR got_addr;
350
351       if (solib_frv_debug)
352         fprintf_unfiltered (gdb_stdlog,
353                             "current_sos: reading link_map entry at %s\n",
354                             hex_string_custom (lm_addr, 8));
355
356       if (target_read_memory (lm_addr, (gdb_byte *) &lm_buf,
357                               sizeof (lm_buf)) != 0)
358         {
359           warning (_("frv_current_sos: Unable to read link map entry.  "
360                      "Shared object chain may be incomplete."));
361           break;
362         }
363
364       got_addr
365         = extract_unsigned_integer (lm_buf.l_addr.got_value,
366                                     sizeof (lm_buf.l_addr.got_value),
367                                     byte_order);
368       /* If the got_addr is the same as mgotr, then we're looking at the
369          entry for the main executable.  By convention, we don't include
370          this in the list of shared objects.  */
371       if (got_addr != mgot)
372         {
373           int errcode;
374           char *name_buf;
375           struct int_elf32_fdpic_loadmap *loadmap;
376           struct so_list *sop;
377           CORE_ADDR addr;
378
379           /* Fetch the load map address.  */
380           addr = extract_unsigned_integer (lm_buf.l_addr.map,
381                                            sizeof lm_buf.l_addr.map,
382                                            byte_order);
383           loadmap = fetch_loadmap (addr);
384           if (loadmap == NULL)
385             {
386               warning (_("frv_current_sos: Unable to fetch load map.  "
387                          "Shared object chain may be incomplete."));
388               break;
389             }
390
391           sop = XCNEW (struct so_list);
392           sop->lm_info = XCNEW (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
439 static CORE_ADDR interp_text_sect_low;
440 static CORE_ADDR interp_text_sect_high;
441 static CORE_ADDR interp_plt_sect_low;
442 static CORE_ADDR interp_plt_sect_high;
443
444 static int
445 frv_in_dynsym_resolve_code (CORE_ADDR pc)
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
456 displacement_from_map (struct int_elf32_fdpic_loadmap *map,
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
477 enable_break_failure_warning (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 (const asymbol *sym, const 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
517 enable_break2 (void)
518 {
519   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
520   asection *interp_sect;
521
522   if (enable_break2_done)
523     return 1;
524
525   interp_text_sect_low = interp_text_sect_high = 0;
526   interp_plt_sect_low = interp_plt_sect_high = 0;
527
528   /* Find the .interp section; if not found, warn the user and drop
529      into the old breakpoint at symbol code.  */
530   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
531   if (interp_sect)
532     {
533       unsigned int interp_sect_size;
534       char *buf;
535       bfd *tmp_bfd = NULL;
536       int status;
537       CORE_ADDR addr, interp_loadmap_addr;
538       gdb_byte addr_buf[FRV_PTR_SIZE];
539       struct int_elf32_fdpic_loadmap *ldm;
540
541       /* Read the contents of the .interp section into a local buffer;
542          the contents specify the dynamic linker this program uses.  */
543       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
544       buf = (char *) alloca (interp_sect_size);
545       bfd_get_section_contents (exec_bfd, interp_sect,
546                                 buf, 0, interp_sect_size);
547
548       /* Now we need to figure out where the dynamic linker was
549          loaded so that we can load its symbols and place a breakpoint
550          in the dynamic linker itself.
551
552          This address is stored on the stack.  However, I've been unable
553          to find any magic formula to find it for Solaris (appears to
554          be trivial on GNU/Linux).  Therefore, we have to try an alternate
555          mechanism to find the dynamic linker's base address.  */
556
557       TRY
558         {
559           tmp_bfd = solib_bfd_open (buf);
560         }
561       CATCH (ex, RETURN_MASK_ALL)
562         {
563         }
564       END_CATCH
565
566       if (tmp_bfd == NULL)
567         {
568           enable_break_failure_warning ();
569           return 0;
570         }
571
572       status = frv_fdpic_loadmap_addresses (target_gdbarch (),
573                                             &interp_loadmap_addr, 0);
574       if (status < 0)
575         {
576           warning (_("Unable to determine dynamic linker loadmap address."));
577           enable_break_failure_warning ();
578           gdb_bfd_unref (tmp_bfd);
579           return 0;
580         }
581
582       if (solib_frv_debug)
583         fprintf_unfiltered (gdb_stdlog,
584                             "enable_break: interp_loadmap_addr = %s\n",
585                             hex_string_custom (interp_loadmap_addr, 8));
586
587       ldm = fetch_loadmap (interp_loadmap_addr);
588       if (ldm == NULL)
589         {
590           warning (_("Unable to load dynamic linker loadmap at address %s."),
591                    hex_string_custom (interp_loadmap_addr, 8));
592           enable_break_failure_warning ();
593           gdb_bfd_unref (tmp_bfd);
594           return 0;
595         }
596
597       /* Record the relocated start and end address of the dynamic linker
598          text and plt section for svr4_in_dynsym_resolve_code.  */
599       interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
600       if (interp_sect)
601         {
602           interp_text_sect_low
603             = bfd_section_vma (tmp_bfd, interp_sect);
604           interp_text_sect_low
605             += displacement_from_map (ldm, interp_text_sect_low);
606           interp_text_sect_high
607             = interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
608         }
609       interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
610       if (interp_sect)
611         {
612           interp_plt_sect_low =
613             bfd_section_vma (tmp_bfd, interp_sect);
614           interp_plt_sect_low
615             += displacement_from_map (ldm, interp_plt_sect_low);
616           interp_plt_sect_high =
617             interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
618         }
619
620       addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name, "_dl_debug_addr");
621
622       if (addr == 0)
623         {
624           warning (_("Could not find symbol _dl_debug_addr "
625                      "in dynamic linker"));
626           enable_break_failure_warning ();
627           gdb_bfd_unref (tmp_bfd);
628           return 0;
629         }
630
631       if (solib_frv_debug)
632         fprintf_unfiltered (gdb_stdlog,
633                             "enable_break: _dl_debug_addr "
634                             "(prior to relocation) = %s\n",
635                             hex_string_custom (addr, 8));
636
637       addr += displacement_from_map (ldm, addr);
638
639       if (solib_frv_debug)
640         fprintf_unfiltered (gdb_stdlog,
641                             "enable_break: _dl_debug_addr "
642                             "(after relocation) = %s\n",
643                             hex_string_custom (addr, 8));
644
645       /* Fetch the address of the r_debug struct.  */
646       if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0)
647         {
648           warning (_("Unable to fetch contents of _dl_debug_addr "
649                      "(at address %s) from dynamic linker"),
650                    hex_string_custom (addr, 8));
651         }
652       addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
653
654       if (solib_frv_debug)
655         fprintf_unfiltered (gdb_stdlog,
656                             "enable_break: _dl_debug_addr[0..3] = %s\n",
657                             hex_string_custom (addr, 8));
658
659       /* If it's zero, then the ldso hasn't initialized yet, and so
660          there are no shared libs yet loaded.  */
661       if (addr == 0)
662         {
663           if (solib_frv_debug)
664             fprintf_unfiltered (gdb_stdlog,
665                                 "enable_break: ldso not yet initialized\n");
666           /* Do not warn, but mark to run again.  */
667           return 0;
668         }
669
670       /* Fetch the r_brk field.  It's 8 bytes from the start of
671          _dl_debug_addr.  */
672       if (target_read_memory (addr + 8, addr_buf, sizeof addr_buf) != 0)
673         {
674           warning (_("Unable to fetch _dl_debug_addr->r_brk "
675                      "(at address %s) from dynamic linker"),
676                    hex_string_custom (addr + 8, 8));
677           enable_break_failure_warning ();
678           gdb_bfd_unref (tmp_bfd);
679           return 0;
680         }
681       addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
682
683       /* Now fetch the function entry point.  */
684       if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0)
685         {
686           warning (_("Unable to fetch _dl_debug_addr->.r_brk entry point "
687                      "(at address %s) from dynamic linker"),
688                    hex_string_custom (addr, 8));
689           enable_break_failure_warning ();
690           gdb_bfd_unref (tmp_bfd);
691           return 0;
692         }
693       addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
694
695       /* We're done with the temporary bfd.  */
696       gdb_bfd_unref (tmp_bfd);
697
698       /* We're also done with the loadmap.  */
699       xfree (ldm);
700
701       /* Remove all the solib event breakpoints.  Their addresses
702          may have changed since the last time we ran the program.  */
703       remove_solib_event_breakpoints ();
704
705       /* Now (finally!) create the solib breakpoint.  */
706       create_solib_event_breakpoint (target_gdbarch (), addr);
707
708       enable_break2_done = 1;
709
710       return 1;
711     }
712
713   /* Tell the user we couldn't set a dynamic linker breakpoint.  */
714   enable_break_failure_warning ();
715
716   /* Failure return.  */
717   return 0;
718 }
719
720 static int
721 enable_break (void)
722 {
723   asection *interp_sect;
724   CORE_ADDR entry_point;
725
726   if (symfile_objfile == NULL)
727     {
728       if (solib_frv_debug)
729         fprintf_unfiltered (gdb_stdlog,
730                             "enable_break: No symbol file found.\n");
731       return 0;
732     }
733
734   if (!entry_point_address_query (&entry_point))
735     {
736       if (solib_frv_debug)
737         fprintf_unfiltered (gdb_stdlog,
738                             "enable_break: Symbol file has no entry point.\n");
739       return 0;
740     }
741
742   /* Check for the presence of a .interp section.  If there is no
743      such section, the executable is statically linked.  */
744
745   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
746
747   if (interp_sect == NULL)
748     {
749       if (solib_frv_debug)
750         fprintf_unfiltered (gdb_stdlog,
751                             "enable_break: No .interp section found.\n");
752       return 0;
753     }
754
755   create_solib_event_breakpoint (target_gdbarch (), entry_point);
756
757   if (solib_frv_debug)
758     fprintf_unfiltered (gdb_stdlog,
759                         "enable_break: solib event breakpoint "
760                         "placed at entry point: %s\n",
761                         hex_string_custom (entry_point, 8));
762   return 1;
763 }
764
765 static void
766 frv_relocate_main_executable (void)
767 {
768   int status;
769   CORE_ADDR exec_addr, interp_addr;
770   struct int_elf32_fdpic_loadmap *ldm;
771   struct cleanup *old_chain;
772   struct section_offsets *new_offsets;
773   int changed;
774   struct obj_section *osect;
775
776   status = frv_fdpic_loadmap_addresses (target_gdbarch (),
777                                         &interp_addr, &exec_addr);
778
779   if (status < 0 || (exec_addr == 0 && interp_addr == 0))
780     {
781       /* Not using FDPIC ABI, so do nothing.  */
782       return;
783     }
784
785   /* Fetch the loadmap located at ``exec_addr''.  */
786   ldm = fetch_loadmap (exec_addr);
787   if (ldm == NULL)
788     error (_("Unable to load the executable's loadmap."));
789
790   if (main_executable_lm_info)
791     xfree (main_executable_lm_info);
792   main_executable_lm_info = XCNEW (struct lm_info);
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   if (main_executable_lm_info != 0)
867     {
868       xfree (main_executable_lm_info->map);
869       xfree (main_executable_lm_info->dyn_syms);
870       xfree (main_executable_lm_info->dyn_relocs);
871       xfree (main_executable_lm_info);
872       main_executable_lm_info = 0;
873     }
874 }
875
876 static void
877 frv_free_so (struct so_list *so)
878 {
879   xfree (so->lm_info->map);
880   xfree (so->lm_info->dyn_syms);
881   xfree (so->lm_info->dyn_relocs);
882   xfree (so->lm_info);
883 }
884
885 static void
886 frv_relocate_section_addresses (struct so_list *so,
887                                  struct target_section *sec)
888 {
889   int seg;
890   struct int_elf32_fdpic_loadmap *map;
891
892   map = so->lm_info->map;
893
894   for (seg = 0; seg < map->nsegs; seg++)
895     {
896       if (map->segs[seg].p_vaddr <= sec->addr
897           && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
898         {
899           CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
900
901           sec->addr += displ;
902           sec->endaddr += displ;
903           break;
904         }
905     }
906 }
907
908 /* Return the GOT address associated with the main executable.  Return
909    0 if it can't be found.  */
910
911 static CORE_ADDR
912 main_got (void)
913 {
914   struct bound_minimal_symbol got_sym;
915
916   got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_",
917                                    NULL, symfile_objfile);
918   if (got_sym.minsym == 0)
919     return 0;
920
921   return BMSYMBOL_VALUE_ADDRESS (got_sym);
922 }
923
924 /* Find the global pointer for the given function address ADDR.  */
925
926 CORE_ADDR
927 frv_fdpic_find_global_pointer (CORE_ADDR addr)
928 {
929   struct so_list *so;
930
931   so = master_so_list ();
932   while (so)
933     {
934       int seg;
935       struct int_elf32_fdpic_loadmap *map;
936
937       map = so->lm_info->map;
938
939       for (seg = 0; seg < map->nsegs; seg++)
940         {
941           if (map->segs[seg].addr <= addr
942               && addr < map->segs[seg].addr + map->segs[seg].p_memsz)
943             return so->lm_info->got_value;
944         }
945
946       so = so->next;
947     }
948
949   /* Didn't find it in any of the shared objects.  So assume it's in the
950      main executable.  */
951   return main_got ();
952 }
953
954 /* Forward declarations for frv_fdpic_find_canonical_descriptor().  */
955 static CORE_ADDR find_canonical_descriptor_in_load_object
956   (CORE_ADDR, CORE_ADDR, const char *, bfd *, struct lm_info *);
957
958 /* Given a function entry point, attempt to find the canonical descriptor
959    associated with that entry point.  Return 0 if no canonical descriptor
960    could be found.  */
961
962 CORE_ADDR
963 frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point)
964 {
965   const char *name;
966   CORE_ADDR addr;
967   CORE_ADDR got_value;
968   struct symbol *sym;
969
970   /* Fetch the corresponding global pointer for the entry point.  */
971   got_value = frv_fdpic_find_global_pointer (entry_point);
972
973   /* Attempt to find the name of the function.  If the name is available,
974      it'll be used as an aid in finding matching functions in the dynamic
975      symbol table.  */
976   sym = find_pc_function (entry_point);
977   if (sym == 0)
978     name = 0;
979   else
980     name = SYMBOL_LINKAGE_NAME (sym);
981
982   /* Check the main executable.  */
983   addr = find_canonical_descriptor_in_load_object
984            (entry_point, got_value, name, symfile_objfile->obfd,
985             main_executable_lm_info);
986
987   /* If descriptor not found via main executable, check each load object
988      in list of shared objects.  */
989   if (addr == 0)
990     {
991       struct so_list *so;
992
993       so = master_so_list ();
994       while (so)
995         {
996           addr = find_canonical_descriptor_in_load_object
997                    (entry_point, got_value, name, so->abfd, so->lm_info);
998
999           if (addr != 0)
1000             break;
1001
1002           so = so->next;
1003         }
1004     }
1005
1006   return addr;
1007 }
1008
1009 static CORE_ADDR
1010 find_canonical_descriptor_in_load_object
1011   (CORE_ADDR entry_point, CORE_ADDR got_value, const char *name, bfd *abfd,
1012    struct lm_info *lm)
1013 {
1014   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1015   arelent *rel;
1016   unsigned int i;
1017   CORE_ADDR addr = 0;
1018
1019   /* Nothing to do if no bfd.  */
1020   if (abfd == 0)
1021     return 0;
1022
1023   /* Nothing to do if no link map.  */
1024   if (lm == 0)
1025     return 0;
1026
1027   /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations.
1028      (More about this later.)  But in order to fetch the relocs, we
1029      need to first fetch the dynamic symbols.  These symbols need to
1030      be cached due to the way that bfd_canonicalize_dynamic_reloc()
1031      works.  (See the comments in the declaration of struct lm_info
1032      for more information.)  */
1033   if (lm->dyn_syms == NULL)
1034     {
1035       long storage_needed;
1036       unsigned int number_of_symbols;
1037
1038       /* Determine amount of space needed to hold the dynamic symbol table.  */
1039       storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1040
1041       /* If there are no dynamic symbols, there's nothing to do.  */
1042       if (storage_needed <= 0)
1043         return 0;
1044
1045       /* Allocate space for the dynamic symbol table.  */
1046       lm->dyn_syms = (asymbol **) xmalloc (storage_needed);
1047
1048       /* Fetch the dynamic symbol table.  */
1049       number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, lm->dyn_syms);
1050
1051       if (number_of_symbols == 0)
1052         return 0;
1053     }
1054
1055   /* Fetch the dynamic relocations if not already cached.  */
1056   if (lm->dyn_relocs == NULL)
1057     {
1058       long storage_needed;
1059
1060       /* Determine amount of space needed to hold the dynamic relocs.  */
1061       storage_needed = bfd_get_dynamic_reloc_upper_bound (abfd);
1062
1063       /* Bail out if there are no dynamic relocs.  */
1064       if (storage_needed <= 0)
1065         return 0;
1066
1067       /* Allocate space for the relocs.  */
1068       lm->dyn_relocs = (arelent **) xmalloc (storage_needed);
1069
1070       /* Fetch the dynamic relocs.  */
1071       lm->dyn_reloc_count 
1072         = bfd_canonicalize_dynamic_reloc (abfd, lm->dyn_relocs, lm->dyn_syms);
1073     }
1074
1075   /* Search the dynamic relocs.  */
1076   for (i = 0; i < lm->dyn_reloc_count; i++)
1077     {
1078       rel = lm->dyn_relocs[i];
1079
1080       /* Relocs of interest are those which meet the following
1081          criteria:
1082
1083            - the names match (assuming the caller could provide
1084              a name which matches ``entry_point'').
1085            - the relocation type must be R_FRV_FUNCDESC.  Relocs
1086              of this type are used (by the dynamic linker) to
1087              look up the address of a canonical descriptor (allocating
1088              it if need be) and initializing the GOT entry referred
1089              to by the offset to the address of the descriptor.
1090
1091          These relocs of interest may be used to obtain a
1092          candidate descriptor by first adjusting the reloc's
1093          address according to the link map and then dereferencing
1094          this address (which is a GOT entry) to obtain a descriptor
1095          address.  */
1096       if ((name == 0 || strcmp (name, (*rel->sym_ptr_ptr)->name) == 0)
1097           && rel->howto->type == R_FRV_FUNCDESC)
1098         {
1099           gdb_byte buf [FRV_PTR_SIZE];
1100
1101           /* Compute address of address of candidate descriptor.  */
1102           addr = rel->address + displacement_from_map (lm->map, rel->address);
1103
1104           /* Fetch address of candidate descriptor.  */
1105           if (target_read_memory (addr, buf, sizeof buf) != 0)
1106             continue;
1107           addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
1108
1109           /* Check for matching entry point.  */
1110           if (target_read_memory (addr, buf, sizeof buf) != 0)
1111             continue;
1112           if (extract_unsigned_integer (buf, sizeof buf, byte_order)
1113               != entry_point)
1114             continue;
1115
1116           /* Check for matching got value.  */
1117           if (target_read_memory (addr + 4, buf, sizeof buf) != 0)
1118             continue;
1119           if (extract_unsigned_integer (buf, sizeof buf, byte_order)
1120               != got_value)
1121             continue;
1122
1123           /* Match was successful!  Exit loop.  */
1124           break;
1125         }
1126     }
1127
1128   return addr;
1129 }
1130
1131 /* Given an objfile, return the address of its link map.  This value is
1132    needed for TLS support.  */
1133 CORE_ADDR
1134 frv_fetch_objfile_link_map (struct objfile *objfile)
1135 {
1136   struct so_list *so;
1137
1138   /* Cause frv_current_sos() to be run if it hasn't been already.  */
1139   if (main_lm_addr == 0)
1140     solib_add (0, 0, 0, 1);
1141
1142   /* frv_current_sos() will set main_lm_addr for the main executable.  */
1143   if (objfile == symfile_objfile)
1144     return main_lm_addr;
1145
1146   /* The other link map addresses may be found by examining the list
1147      of shared libraries.  */
1148   for (so = master_so_list (); so; so = so->next)
1149     {
1150       if (so->objfile == objfile)
1151         return so->lm_info->lm_addr;
1152     }
1153
1154   /* Not found!  */
1155   return 0;
1156 }
1157
1158 struct target_so_ops frv_so_ops;
1159
1160 /* Provide a prototype to silence -Wmissing-prototypes.  */
1161 extern initialize_file_ftype _initialize_frv_solib;
1162
1163 void
1164 _initialize_frv_solib (void)
1165 {
1166   frv_so_ops.relocate_section_addresses = frv_relocate_section_addresses;
1167   frv_so_ops.free_so = frv_free_so;
1168   frv_so_ops.clear_solib = frv_clear_solib;
1169   frv_so_ops.solib_create_inferior_hook = frv_solib_create_inferior_hook;
1170   frv_so_ops.current_sos = frv_current_sos;
1171   frv_so_ops.open_symbol_file_object = open_symbol_file_object;
1172   frv_so_ops.in_dynsym_resolve_code = frv_in_dynsym_resolve_code;
1173   frv_so_ops.bfd_open = solib_bfd_open;
1174
1175   /* Debug this file's internals.  */
1176   add_setshow_zuinteger_cmd ("solib-frv", class_maintenance,
1177                              &solib_frv_debug, _("\
1178 Set internal debugging of shared library code for FR-V."), _("\
1179 Show internal debugging of shared library code for FR-V."), _("\
1180 When non-zero, FR-V solib specific internal debugging is enabled."),
1181                              NULL,
1182                              NULL, /* FIXME: i18n: */
1183                              &setdebuglist, &showdebuglist);
1184 }