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