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