gdb/solib-frv.c

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