gdb/solib-frv.c

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