gdb/solib-frv.c

   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.  */
  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 = 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
 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 = 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
 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 (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
 517 enable_break2 (void)
 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         {
 570           enable_break_failure_warning ();
 571           return 0;
 572         }
 573
 574       status = frv_fdpic_loadmap_addresses (target_gdbarch (),
 575                                             &interp_loadmap_addr, 0);
 576       if (status < 0)
 577         {
 578           warning (_("Unable to determine dynamic linker loadmap address."));
 579           enable_break_failure_warning ();
 580           gdb_bfd_unref (tmp_bfd);
 581           return 0;
 582         }
 583
 584       if (solib_frv_debug)
 585         fprintf_unfiltered (gdb_stdlog,
 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));
 594           enable_break_failure_warning ();
 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"));
 628           enable_break_failure_warning ();
 629           gdb_bfd_unref (tmp_bfd);
 630           return 0;
 631         }
 632
 633       if (solib_frv_debug)
 634         fprintf_unfiltered (gdb_stdlog,
 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)
 642         fprintf_unfiltered (gdb_stdlog,
 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)
 657         fprintf_unfiltered (gdb_stdlog,
 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)
 666             fprintf_unfiltered (gdb_stdlog,
 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));
 679           enable_break_failure_warning ();
 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));
 691           enable_break_failure_warning ();
 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.  */
 705       remove_solib_event_breakpoints ();
 706
 707       /* Now (finally!) create the solib breakpoint.  */
 708       create_solib_event_breakpoint (target_gdbarch (), addr);
 709
 710       enable_break2_done = 1;
 711
 712       return 1;
 713     }
 714
 715   /* Tell the user we couldn't set a dynamic linker breakpoint.  */
 716   enable_break_failure_warning ();
 717
 718   /* Failure return.  */
 719   return 0;
 720 }
 721
 722 static int
 723 enable_break (void)
 724 {
 725   asection *interp_sect;
 726   CORE_ADDR entry_point;
 727
 728   if (symfile_objfile == NULL)
 729     {
 730       if (solib_frv_debug)
 731         fprintf_unfiltered (gdb_stdlog,
 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)
 739         fprintf_unfiltered (gdb_stdlog,
 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)
 752         fprintf_unfiltered (gdb_stdlog,
 753                             "enable_break: No .interp section found.\n");
 754       return 0;
 755     }
 756
 757   create_solib_event_breakpoint (target_gdbarch (), entry_point);
 758
 759   if (solib_frv_debug)
 760     fprintf_unfiltered (gdb_stdlog,
 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
 770 frv_special_symbol_handling (void)
 771 {
 772   /* Nothing needed for FRV.  */
 773 }
 774
 775 static void
 776 frv_relocate_main_executable (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
 786   status = frv_fdpic_loadmap_addresses (target_gdbarch (),
 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
 810   ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
 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
 857 frv_solib_create_inferior_hook (int from_tty)
 858 {
 859   /* Relocate main executable.  */
 860   frv_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
 871 frv_clear_solib (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
 896 frv_relocate_section_addresses (struct so_list *so,
 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
 937 frv_fdpic_find_global_pointer (CORE_ADDR 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().  */
 965 static CORE_ADDR find_canonical_descriptor_in_load_object
 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
 973 frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point)
 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.  */
 994   addr = find_canonical_descriptor_in_load_object
 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         {
1007           addr = find_canonical_descriptor_in_load_object
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
1021 find_canonical_descriptor_in_load_object
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
1145 frv_fetch_objfile_link_map (struct objfile *objfile)
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
1169 struct target_so_ops frv_so_ops;
1170
1171 /* Provide a prototype to silence -Wmissing-prototypes.  */
1172 extern initialize_file_ftype _initialize_frv_solib;
1173
1174 void
1175 _initialize_frv_solib (void)
1176 {
1177   frv_so_ops.relocate_section_addresses = frv_relocate_section_addresses;
1178   frv_so_ops.free_so = frv_free_so;
1179   frv_so_ops.clear_solib = frv_clear_solib;
1180   frv_so_ops.solib_create_inferior_hook = frv_solib_create_inferior_hook;
1181   frv_so_ops.special_symbol_handling = frv_special_symbol_handling;
1182   frv_so_ops.current_sos = frv_current_sos;
1183   frv_so_ops.open_symbol_file_object = open_symbol_file_object;
1184   frv_so_ops.in_dynsym_resolve_code = frv_in_dynsym_resolve_code;
1185   frv_so_ops.bfd_open = solib_bfd_open;
1186
1187   /* Debug this file's internals.  */
1188   add_setshow_zuinteger_cmd ("solib-frv", class_maintenance,
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: */
1195                              &setdebuglist, &showdebuglist);
1196 }