gdb/solib-frv.c

   1 /* Handle FR-V (FDPIC) shared libraries for GDB, the GNU Debugger.
   2    Copyright (C) 2004, 2007-2012 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 "gdb_string.h"
  22 #include "inferior.h"
  23 #include "gdbcore.h"
  24 #include "solib.h"
  25 #include "solist.h"
  26 #include "frv-tdep.h"
  27 #include "objfiles.h"
  28 #include "symtab.h"
  29 #include "language.h"
  30 #include "command.h"
  31 #include "gdbcmd.h"
  32 #include "elf/frv.h"
  33 #include "exceptions.h"
  34
  35 /* Flag which indicates whether internal debug messages should be printed.  */
  36 static int solib_frv_debug;
  37
  38 /* FR-V pointers are four bytes wide.  */
  39 enum { FRV_PTR_SIZE = 4 };
  40
  41 /* Representation of loadmap and related structs for the FR-V FDPIC ABI.  */
  42
  43 /* External versions; the size and alignment of the fields should be
  44    the same as those on the target.  When loaded, the placement of
  45    the bits in each field will be the same as on the target.  */
  46 typedef gdb_byte ext_Elf32_Half[2];
  47 typedef gdb_byte ext_Elf32_Addr[4];
  48 typedef gdb_byte ext_Elf32_Word[4];
  49
  50 struct ext_elf32_fdpic_loadseg
  51 {
  52   /* Core address to which the segment is mapped.  */
  53   ext_Elf32_Addr addr;
  54   /* VMA recorded in the program header.  */
  55   ext_Elf32_Addr p_vaddr;
  56   /* Size of this segment in memory.  */
  57   ext_Elf32_Word p_memsz;
  58 };
  59
  60 struct ext_elf32_fdpic_loadmap {
  61   /* Protocol version number, must be zero.  */
  62   ext_Elf32_Half version;
  63   /* Number of segments in this map.  */
  64   ext_Elf32_Half nsegs;
  65   /* The actual memory map.  */
  66   struct ext_elf32_fdpic_loadseg segs[1 /* nsegs, actually */];
  67 };
  68
  69 /* Internal versions; the types are GDB types and the data in each
  70    of the fields is (or will be) decoded from the external struct
  71    for ease of consumption.  */
  72 struct int_elf32_fdpic_loadseg
  73 {
  74   /* Core address to which the segment is mapped.  */
  75   CORE_ADDR addr;
  76   /* VMA recorded in the program header.  */
  77   CORE_ADDR p_vaddr;
  78   /* Size of this segment in memory.  */
  79   long p_memsz;
  80 };
  81
  82 struct int_elf32_fdpic_loadmap {
  83   /* Protocol version number, must be zero.  */
  84   int version;
  85   /* Number of segments in this map.  */
  86   int nsegs;
  87   /* The actual memory map.  */
  88   struct int_elf32_fdpic_loadseg segs[1 /* nsegs, actually */];
  89 };
  90
  91 /* Given address LDMADDR, fetch and decode the loadmap at that address.
  92    Return NULL if there is a problem reading the target memory or if
  93    there doesn't appear to be a loadmap at the given address.  The
  94    allocated space (representing the loadmap) returned by this
  95    function may be freed via a single call to xfree().  */
  96
  97 static struct int_elf32_fdpic_loadmap *
  98 fetch_loadmap (CORE_ADDR ldmaddr)
  99 {
 100   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 101   struct ext_elf32_fdpic_loadmap ext_ldmbuf_partial;
 102   struct ext_elf32_fdpic_loadmap *ext_ldmbuf;
 103   struct int_elf32_fdpic_loadmap *int_ldmbuf;
 104   int ext_ldmbuf_size, int_ldmbuf_size;
 105   int version, seg, nsegs;
 106
 107   /* Fetch initial portion of the loadmap.  */
 108   if (target_read_memory (ldmaddr, (gdb_byte *) &ext_ldmbuf_partial,
 109                           sizeof ext_ldmbuf_partial))
 110     {
 111       /* Problem reading the target's memory.  */
 112       return NULL;
 113     }
 114
 115   /* Extract the version.  */
 116   version = extract_unsigned_integer (ext_ldmbuf_partial.version,
 117                                       sizeof ext_ldmbuf_partial.version,
 118                                       byte_order);
 119   if (version != 0)
 120     {
 121       /* We only handle version 0.  */
 122       return NULL;
 123     }
 124
 125   /* Extract the number of segments.  */
 126   nsegs = extract_unsigned_integer (ext_ldmbuf_partial.nsegs,
 127                                     sizeof ext_ldmbuf_partial.nsegs,
 128                                     byte_order);
 129
 130   if (nsegs <= 0)
 131     return NULL;
 132
 133   /* Allocate space for the complete (external) loadmap.  */
 134   ext_ldmbuf_size = sizeof (struct ext_elf32_fdpic_loadmap)
 135                + (nsegs - 1) * sizeof (struct ext_elf32_fdpic_loadseg);
 136   ext_ldmbuf = xmalloc (ext_ldmbuf_size);
 137
 138   /* Copy over the portion of the loadmap that's already been read.  */
 139   memcpy (ext_ldmbuf, &ext_ldmbuf_partial, sizeof ext_ldmbuf_partial);
 140
 141   /* Read the rest of the loadmap from the target.  */
 142   if (target_read_memory (ldmaddr + sizeof ext_ldmbuf_partial,
 143                           (gdb_byte *) ext_ldmbuf + sizeof ext_ldmbuf_partial,
 144                           ext_ldmbuf_size - sizeof ext_ldmbuf_partial))
 145     {
 146       /* Couldn't read rest of the loadmap.  */
 147       xfree (ext_ldmbuf);
 148       return NULL;
 149     }
 150
 151   /* Allocate space into which to put information extract from the
 152      external loadsegs.  I.e, allocate the internal loadsegs.  */
 153   int_ldmbuf_size = sizeof (struct int_elf32_fdpic_loadmap)
 154                + (nsegs - 1) * sizeof (struct int_elf32_fdpic_loadseg);
 155   int_ldmbuf = xmalloc (int_ldmbuf_size);
 156
 157   /* Place extracted information in internal structs.  */
 158   int_ldmbuf->version = version;
 159   int_ldmbuf->nsegs = nsegs;
 160   for (seg = 0; seg < nsegs; seg++)
 161     {
 162       int_ldmbuf->segs[seg].addr
 163         = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
 164                                     sizeof (ext_ldmbuf->segs[seg].addr),
 165                                     byte_order);
 166       int_ldmbuf->segs[seg].p_vaddr
 167         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr,
 168                                     sizeof (ext_ldmbuf->segs[seg].p_vaddr),
 169                                     byte_order);
 170       int_ldmbuf->segs[seg].p_memsz
 171         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz,
 172                                     sizeof (ext_ldmbuf->segs[seg].p_memsz),
 173                                     byte_order);
 174     }
 175
 176   xfree (ext_ldmbuf);
 177   return int_ldmbuf;
 178 }
 179
 180 /* External link_map and elf32_fdpic_loadaddr struct definitions.  */
 181
 182 typedef gdb_byte ext_ptr[4];
 183
 184 struct ext_elf32_fdpic_loadaddr
 185 {
 186   ext_ptr map;                  /* struct elf32_fdpic_loadmap *map; */
 187   ext_ptr got_value;            /* void *got_value; */
 188 };
 189
 190 struct ext_link_map
 191 {
 192   struct ext_elf32_fdpic_loadaddr l_addr;
 193
 194   /* Absolute file name object was found in.  */
 195   ext_ptr l_name;               /* char *l_name; */
 196
 197   /* Dynamic section of the shared object.  */
 198   ext_ptr l_ld;                 /* ElfW(Dyn) *l_ld; */
 199
 200   /* Chain of loaded objects.  */
 201   ext_ptr l_next, l_prev;       /* struct link_map *l_next, *l_prev; */
 202 };
 203
 204 /* Link map info to include in an allocated so_list entry.  */
 205
 206 struct lm_info
 207   {
 208     /* The loadmap, digested into an easier to use form.  */
 209     struct int_elf32_fdpic_loadmap *map;
 210     /* The GOT address for this link map entry.  */
 211     CORE_ADDR got_value;
 212     /* The link map address, needed for frv_fetch_objfile_link_map().  */
 213     CORE_ADDR lm_addr;
 214
 215     /* Cached dynamic symbol table and dynamic relocs initialized and
 216        used only by find_canonical_descriptor_in_load_object().
 217
 218        Note: kevinb/2004-02-26: It appears that calls to
 219        bfd_canonicalize_dynamic_reloc() will use the same symbols as
 220        those supplied to the first call to this function.  Therefore,
 221        it's important to NOT free the asymbol ** data structure
 222        supplied to the first call.  Thus the caching of the dynamic
 223        symbols (dyn_syms) is critical for correct operation.  The
 224        caching of the dynamic relocations could be dispensed with.  */
 225     asymbol **dyn_syms;
 226     arelent **dyn_relocs;
 227     int dyn_reloc_count;        /* Number of dynamic relocs.  */
 228
 229   };
 230
 231 /* The load map, got value, etc. are not available from the chain
 232    of loaded shared objects.  ``main_executable_lm_info'' provides
 233    a way to get at this information so that it doesn't need to be
 234    frequently recomputed.  Initialized by frv_relocate_main_executable().  */
 235 static struct lm_info *main_executable_lm_info;
 236
 237 static void frv_relocate_main_executable (void);
 238 static CORE_ADDR main_got (void);
 239 static int enable_break2 (void);
 240
 241 /* Implement the "open_symbol_file_object" target_so_ops method.  */
 242
 243 static int
 244 open_symbol_file_object (void *from_ttyp)
 245 {
 246   /* Unimplemented.  */
 247   return 0;
 248 }
 249
 250 /* Cached value for lm_base(), below.  */
 251 static CORE_ADDR lm_base_cache = 0;
 252
 253 /* Link map address for main module.  */
 254 static CORE_ADDR main_lm_addr = 0;
 255
 256 /* Return the address from which the link map chain may be found.  On
 257    the FR-V, this may be found in a number of ways.  Assuming that the
 258    main executable has already been relocated, the easiest way to find
 259    this value is to look up the address of _GLOBAL_OFFSET_TABLE_.  A
 260    pointer to the start of the link map will be located at the word found
 261    at _GLOBAL_OFFSET_TABLE_ + 8.  (This is part of the dynamic linker
 262    reserve area mandated by the ABI.)  */
 263
 264 static CORE_ADDR
 265 lm_base (void)
 266 {
 267   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 268   struct minimal_symbol *got_sym;
 269   CORE_ADDR addr;
 270   gdb_byte buf[FRV_PTR_SIZE];
 271
 272   /* One of our assumptions is that the main executable has been relocated.
 273      Bail out if this has not happened.  (Note that post_create_inferior()
 274      in infcmd.c will call solib_add prior to solib_create_inferior_hook().
 275      If we allow this to happen, lm_base_cache will be initialized with
 276      a bogus value.  */
 277   if (main_executable_lm_info == 0)
 278     return 0;
 279
 280   /* If we already have a cached value, return it.  */
 281   if (lm_base_cache)
 282     return lm_base_cache;
 283
 284   got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL,
 285                                    symfile_objfile);
 286   if (got_sym == 0)
 287     {
 288       if (solib_frv_debug)
 289         fprintf_unfiltered (gdb_stdlog,
 290                             "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
 291       return 0;
 292     }
 293
 294   addr = SYMBOL_VALUE_ADDRESS (got_sym) + 8;
 295
 296   if (solib_frv_debug)
 297     fprintf_unfiltered (gdb_stdlog,
 298                         "lm_base: _GLOBAL_OFFSET_TABLE_ + 8 = %s\n",
 299                         hex_string_custom (addr, 8));
 300
 301   if (target_read_memory (addr, buf, sizeof buf) != 0)
 302     return 0;
 303   lm_base_cache = extract_unsigned_integer (buf, sizeof buf, byte_order);
 304
 305   if (solib_frv_debug)
 306     fprintf_unfiltered (gdb_stdlog,
 307                         "lm_base: lm_base_cache = %s\n",
 308                         hex_string_custom (lm_base_cache, 8));
 309
 310   return lm_base_cache;
 311 }
 312
 313
 314 /* Implement the "current_sos" target_so_ops method.  */
 315
 316 static struct so_list *
 317 frv_current_sos (void)
 318 {
 319   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 320   CORE_ADDR lm_addr, mgot;
 321   struct so_list *sos_head = NULL;
 322   struct so_list **sos_next_ptr = &sos_head;
 323
 324   /* Make sure that the main executable has been relocated.  This is
 325      required in order to find the address of the global offset table,
 326      which in turn is used to find the link map info.  (See lm_base()
 327      for details.)
 328
 329      Note that the relocation of the main executable is also performed
 330      by SOLIB_CREATE_INFERIOR_HOOK(), however, in the case of core
 331      files, this hook is called too late in order to be of benefit to
 332      SOLIB_ADD.  SOLIB_ADD eventually calls this this function,
 333      frv_current_sos, and also precedes the call to
 334      SOLIB_CREATE_INFERIOR_HOOK().   (See post_create_inferior() in
 335      infcmd.c.)  */
 336   if (main_executable_lm_info == 0 && core_bfd != NULL)
 337     frv_relocate_main_executable ();
 338
 339   /* Fetch the GOT corresponding to the main executable.  */
 340   mgot = main_got ();
 341
 342   /* Locate the address of the first link map struct.  */
 343   lm_addr = lm_base ();
 344
 345   /* We have at least one link map entry.  Fetch the lot of them,
 346      building the solist chain.  */
 347   while (lm_addr)
 348     {
 349       struct ext_link_map lm_buf;
 350       CORE_ADDR got_addr;
 351
 352       if (solib_frv_debug)
 353         fprintf_unfiltered (gdb_stdlog,
 354                             "current_sos: reading link_map entry at %s\n",
 355                             hex_string_custom (lm_addr, 8));
 356
 357       if (target_read_memory (lm_addr, (gdb_byte *) &lm_buf,
 358                               sizeof (lm_buf)) != 0)
 359         {
 360           warning (_("frv_current_sos: Unable to read link map entry.  "
 361                      "Shared object chain may be incomplete."));
 362           break;
 363         }
 364
 365       got_addr
 366         = extract_unsigned_integer (lm_buf.l_addr.got_value,
 367                                     sizeof (lm_buf.l_addr.got_value),
 368                                     byte_order);
 369       /* If the got_addr is the same as mgotr, then we're looking at the
 370          entry for the main executable.  By convention, we don't include
 371          this in the list of shared objects.  */
 372       if (got_addr != mgot)
 373         {
 374           int errcode;
 375           char *name_buf;
 376           struct int_elf32_fdpic_loadmap *loadmap;
 377           struct so_list *sop;
 378           CORE_ADDR addr;
 379
 380           /* Fetch the load map address.  */
 381           addr = extract_unsigned_integer (lm_buf.l_addr.map,
 382                                            sizeof lm_buf.l_addr.map,
 383                                            byte_order);
 384           loadmap = fetch_loadmap (addr);
 385           if (loadmap == NULL)
 386             {
 387               warning (_("frv_current_sos: Unable to fetch load map.  "
 388                          "Shared object chain may be incomplete."));
 389               break;
 390             }
 391
 392           sop = xcalloc (1, sizeof (struct so_list));
 393           sop->lm_info = xcalloc (1, sizeof (struct lm_info));
 394           sop->lm_info->map = loadmap;
 395           sop->lm_info->got_value = got_addr;
 396           sop->lm_info->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, NULL));
 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 (asymbol *sym, 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   int success = 0;
 522   char **bkpt_namep;
 523   asection *interp_sect;
 524
 525   if (enable_break2_done)
 526     return 1;
 527
 528   interp_text_sect_low = interp_text_sect_high = 0;
 529   interp_plt_sect_low = interp_plt_sect_high = 0;
 530
 531   /* Find the .interp section; if not found, warn the user and drop
 532      into the old breakpoint at symbol code.  */
 533   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
 534   if (interp_sect)
 535     {
 536       unsigned int interp_sect_size;
 537       gdb_byte *buf;
 538       bfd *tmp_bfd = NULL;
 539       int status;
 540       CORE_ADDR addr, interp_loadmap_addr;
 541       gdb_byte addr_buf[FRV_PTR_SIZE];
 542       struct int_elf32_fdpic_loadmap *ldm;
 543       volatile struct gdb_exception ex;
 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 (exec_bfd, interp_sect);
 548       buf = alloca (interp_sect_size);
 549       bfd_get_section_contents (exec_bfd, interp_sect,
 550                                 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       TRY_CATCH (ex, RETURN_MASK_ALL)
 562         {
 563           tmp_bfd = solib_bfd_open (buf);
 564         }
 565       if (tmp_bfd == NULL)
 566         {
 567           enable_break_failure_warning ();
 568           return 0;
 569         }
 570
 571       status = frv_fdpic_loadmap_addresses (target_gdbarch,
 572                                             &interp_loadmap_addr, 0);
 573       if (status < 0)
 574         {
 575           warning (_("Unable to determine dynamic linker loadmap address."));
 576           enable_break_failure_warning ();
 577           bfd_close (tmp_bfd);
 578           return 0;
 579         }
 580
 581       if (solib_frv_debug)
 582         fprintf_unfiltered (gdb_stdlog,
 583                             "enable_break: interp_loadmap_addr = %s\n",
 584                             hex_string_custom (interp_loadmap_addr, 8));
 585
 586       ldm = fetch_loadmap (interp_loadmap_addr);
 587       if (ldm == NULL)
 588         {
 589           warning (_("Unable to load dynamic linker loadmap at address %s."),
 590                    hex_string_custom (interp_loadmap_addr, 8));
 591           enable_break_failure_warning ();
 592           bfd_close (tmp_bfd);
 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, ".text");
 599       if (interp_sect)
 600         {
 601           interp_text_sect_low
 602             = bfd_section_vma (tmp_bfd, 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, interp_sect);
 607         }
 608       interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
 609       if (interp_sect)
 610         {
 611           interp_plt_sect_low =
 612             bfd_section_vma (tmp_bfd, interp_sect);
 613           interp_plt_sect_low
 614             += displacement_from_map (ldm, interp_plt_sect_low);
 615           interp_plt_sect_high =
 616             interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
 617         }
 618
 619       addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name, "_dl_debug_addr");
 620
 621       if (addr == 0)
 622         {
 623           warning (_("Could not find symbol _dl_debug_addr "
 624                      "in dynamic linker"));
 625           enable_break_failure_warning ();
 626           bfd_close (tmp_bfd);
 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           bfd_close (tmp_bfd);
 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           bfd_close (tmp_bfd);
 690           return 0;
 691         }
 692       addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
 693
 694       /* We're done with the temporary bfd.  */
 695       bfd_close (tmp_bfd);
 696
 697       /* We're also done with the loadmap.  */
 698       xfree (ldm);
 699
 700       /* Remove all the solib event breakpoints.  Their addresses
 701          may have changed since the last time we ran the program.  */
 702       remove_solib_event_breakpoints ();
 703
 704       /* Now (finally!) create the solib breakpoint.  */
 705       create_solib_event_breakpoint (target_gdbarch, addr);
 706
 707       enable_break2_done = 1;
 708
 709       return 1;
 710     }
 711
 712   /* Tell the user we couldn't set a dynamic linker breakpoint.  */
 713   enable_break_failure_warning ();
 714
 715   /* Failure return.  */
 716   return 0;
 717 }
 718
 719 static int
 720 enable_break (void)
 721 {
 722   asection *interp_sect;
 723
 724   if (symfile_objfile == NULL)
 725     {
 726       if (solib_frv_debug)
 727         fprintf_unfiltered (gdb_stdlog,
 728                             "enable_break: No symbol file found.\n");
 729       return 0;
 730     }
 731
 732   if (!symfile_objfile->ei.entry_point_p)
 733     {
 734       if (solib_frv_debug)
 735         fprintf_unfiltered (gdb_stdlog,
 736                             "enable_break: Symbol file has no entry point.\n");
 737       return 0;
 738     }
 739
 740   /* Check for the presence of a .interp section.  If there is no
 741      such section, the executable is statically linked.  */
 742
 743   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
 744
 745   if (interp_sect == NULL)
 746     {
 747       if (solib_frv_debug)
 748         fprintf_unfiltered (gdb_stdlog,
 749                             "enable_break: No .interp section found.\n");
 750       return 0;
 751     }
 752
 753   create_solib_event_breakpoint (target_gdbarch,
 754                                  symfile_objfile->ei.entry_point);
 755
 756   if (solib_frv_debug)
 757     fprintf_unfiltered (gdb_stdlog,
 758                         "enable_break: solib event breakpoint "
 759                         "placed at entry point: %s\n",
 760                         hex_string_custom (symfile_objfile->ei.entry_point,
 761                                            8));
 762   return 1;
 763 }
 764
 765 /* Implement the "special_symbol_handling" target_so_ops method.  */
 766
 767 static void
 768 frv_special_symbol_handling (void)
 769 {
 770   /* Nothing needed for FRV.  */
 771 }
 772
 773 static void
 774 frv_relocate_main_executable (void)
 775 {
 776   int status;
 777   CORE_ADDR exec_addr, interp_addr;
 778   struct int_elf32_fdpic_loadmap *ldm;
 779   struct cleanup *old_chain;
 780   struct section_offsets *new_offsets;
 781   int changed;
 782   struct obj_section *osect;
 783
 784   status = frv_fdpic_loadmap_addresses (target_gdbarch,
 785                                         &interp_addr, &exec_addr);
 786
 787   if (status < 0 || (exec_addr == 0 && interp_addr == 0))
 788     {
 789       /* Not using FDPIC ABI, so do nothing.  */
 790       return;
 791     }
 792
 793   /* Fetch the loadmap located at ``exec_addr''.  */
 794   ldm = fetch_loadmap (exec_addr);
 795   if (ldm == NULL)
 796     error (_("Unable to load the executable's loadmap."));
 797
 798   if (main_executable_lm_info)
 799     xfree (main_executable_lm_info);
 800   main_executable_lm_info = xcalloc (1, sizeof (struct lm_info));
 801   main_executable_lm_info->map = ldm;
 802
 803   new_offsets = xcalloc (symfile_objfile->num_sections,
 804                          sizeof (struct section_offsets));
 805   old_chain = make_cleanup (xfree, new_offsets);
 806   changed = 0;
 807
 808   ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
 809     {
 810       CORE_ADDR orig_addr, addr, offset;
 811       int osect_idx;
 812       int seg;
 813
 814       osect_idx = osect->the_bfd_section->index;
 815
 816       /* Current address of section.  */
 817       addr = obj_section_addr (osect);
 818       /* Offset from where this section started.  */
 819       offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx);
 820       /* Original address prior to any past relocations.  */
 821       orig_addr = addr - offset;
 822
 823       for (seg = 0; seg < ldm->nsegs; seg++)
 824         {
 825           if (ldm->segs[seg].p_vaddr <= orig_addr
 826               && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
 827             {
 828               new_offsets->offsets[osect_idx]
 829                 = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
 830
 831               if (new_offsets->offsets[osect_idx] != offset)
 832                 changed = 1;
 833               break;
 834             }
 835         }
 836     }
 837
 838   if (changed)
 839     objfile_relocate (symfile_objfile, new_offsets);
 840
 841   do_cleanups (old_chain);
 842
 843   /* Now that symfile_objfile has been relocated, we can compute the
 844      GOT value and stash it away.  */
 845   main_executable_lm_info->got_value = main_got ();
 846 }
 847
 848 /* Implement the "create_inferior_hook" target_solib_ops method.
 849
 850    For the FR-V shared library ABI (FDPIC), the main executable needs
 851    to be relocated.  The shared library breakpoints also need to be
 852    enabled.  */
 853
 854 static void
 855 frv_solib_create_inferior_hook (int from_tty)
 856 {
 857   /* Relocate main executable.  */
 858   frv_relocate_main_executable ();
 859
 860   /* Enable shared library breakpoints.  */
 861   if (!enable_break ())
 862     {
 863       warning (_("shared library handler failed to enable breakpoint"));
 864       return;
 865     }
 866 }
 867
 868 static void
 869 frv_clear_solib (void)
 870 {
 871   lm_base_cache = 0;
 872   enable_break2_done = 0;
 873   main_lm_addr = 0;
 874   if (main_executable_lm_info != 0)
 875     {
 876       xfree (main_executable_lm_info->map);
 877       xfree (main_executable_lm_info->dyn_syms);
 878       xfree (main_executable_lm_info->dyn_relocs);
 879       xfree (main_executable_lm_info);
 880       main_executable_lm_info = 0;
 881     }
 882 }
 883
 884 static void
 885 frv_free_so (struct so_list *so)
 886 {
 887   xfree (so->lm_info->map);
 888   xfree (so->lm_info->dyn_syms);
 889   xfree (so->lm_info->dyn_relocs);
 890   xfree (so->lm_info);
 891 }
 892
 893 static void
 894 frv_relocate_section_addresses (struct so_list *so,
 895                                  struct target_section *sec)
 896 {
 897   int seg;
 898   struct int_elf32_fdpic_loadmap *map;
 899
 900   map = so->lm_info->map;
 901
 902   for (seg = 0; seg < map->nsegs; seg++)
 903     {
 904       if (map->segs[seg].p_vaddr <= sec->addr
 905           && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
 906         {
 907           CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
 908
 909           sec->addr += displ;
 910           sec->endaddr += displ;
 911           break;
 912         }
 913     }
 914 }
 915
 916 /* Return the GOT address associated with the main executable.  Return
 917    0 if it can't be found.  */
 918
 919 static CORE_ADDR
 920 main_got (void)
 921 {
 922   struct minimal_symbol *got_sym;
 923
 924   got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_",
 925                                    NULL, symfile_objfile);
 926   if (got_sym == 0)
 927     return 0;
 928
 929   return SYMBOL_VALUE_ADDRESS (got_sym);
 930 }
 931
 932 /* Find the global pointer for the given function address ADDR.  */
 933
 934 CORE_ADDR
 935 frv_fdpic_find_global_pointer (CORE_ADDR addr)
 936 {
 937   struct so_list *so;
 938
 939   so = master_so_list ();
 940   while (so)
 941     {
 942       int seg;
 943       struct int_elf32_fdpic_loadmap *map;
 944
 945       map = so->lm_info->map;
 946
 947       for (seg = 0; seg < map->nsegs; seg++)
 948         {
 949           if (map->segs[seg].addr <= addr
 950               && addr < map->segs[seg].addr + map->segs[seg].p_memsz)
 951             return so->lm_info->got_value;
 952         }
 953
 954       so = so->next;
 955     }
 956
 957   /* Didn't find it in any of the shared objects.  So assume it's in the
 958      main executable.  */
 959   return main_got ();
 960 }
 961
 962 /* Forward declarations for frv_fdpic_find_canonical_descriptor().  */
 963 static CORE_ADDR find_canonical_descriptor_in_load_object
 964   (CORE_ADDR, CORE_ADDR, const char *, bfd *, struct lm_info *);
 965
 966 /* Given a function entry point, attempt to find the canonical descriptor
 967    associated with that entry point.  Return 0 if no canonical descriptor
 968    could be found.  */
 969
 970 CORE_ADDR
 971 frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point)
 972 {
 973   const char *name;
 974   CORE_ADDR addr;
 975   CORE_ADDR got_value;
 976   struct int_elf32_fdpic_loadmap *ldm = 0;
 977   struct symbol *sym;
 978   int status;
 979   CORE_ADDR exec_loadmap_addr;
 980
 981   /* Fetch the corresponding global pointer for the entry point.  */
 982   got_value = frv_fdpic_find_global_pointer (entry_point);
 983
 984   /* Attempt to find the name of the function.  If the name is available,
 985      it'll be used as an aid in finding matching functions in the dynamic
 986      symbol table.  */
 987   sym = find_pc_function (entry_point);
 988   if (sym == 0)
 989     name = 0;
 990   else
 991     name = SYMBOL_LINKAGE_NAME (sym);
 992
 993   /* Check the main executable.  */
 994   addr = find_canonical_descriptor_in_load_object
 995            (entry_point, got_value, name, symfile_objfile->obfd,
 996             main_executable_lm_info);
 997
 998   /* If descriptor not found via main executable, check each load object
 999      in list of shared objects.  */
1000   if (addr == 0)
1001     {
1002       struct so_list *so;
1003
1004       so = master_so_list ();
1005       while (so)
1006         {
1007           addr = find_canonical_descriptor_in_load_object
1008                    (entry_point, got_value, name, so->abfd, so->lm_info);
1009
1010           if (addr != 0)
1011             break;
1012
1013           so = so->next;
1014         }
1015     }
1016
1017   return addr;
1018 }
1019
1020 static CORE_ADDR
1021 find_canonical_descriptor_in_load_object
1022   (CORE_ADDR entry_point, CORE_ADDR got_value, const char *name, bfd *abfd,
1023    struct lm_info *lm)
1024 {
1025   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
1026   arelent *rel;
1027   unsigned int i;
1028   CORE_ADDR addr = 0;
1029
1030   /* Nothing to do if no bfd.  */
1031   if (abfd == 0)
1032     return 0;
1033
1034   /* Nothing to do if no link map.  */
1035   if (lm == 0)
1036     return 0;
1037
1038   /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations.
1039      (More about this later.)  But in order to fetch the relocs, we
1040      need to first fetch the dynamic symbols.  These symbols need to
1041      be cached due to the way that bfd_canonicalize_dynamic_reloc()
1042      works.  (See the comments in the declaration of struct lm_info
1043      for more information.)  */
1044   if (lm->dyn_syms == NULL)
1045     {
1046       long storage_needed;
1047       unsigned int number_of_symbols;
1048
1049       /* Determine amount of space needed to hold the dynamic symbol table.  */
1050       storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1051
1052       /* If there are no dynamic symbols, there's nothing to do.  */
1053       if (storage_needed <= 0)
1054         return 0;
1055
1056       /* Allocate space for the dynamic symbol table.  */
1057       lm->dyn_syms = (asymbol **) xmalloc (storage_needed);
1058
1059       /* Fetch the dynamic symbol table.  */
1060       number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, lm->dyn_syms);
1061
1062       if (number_of_symbols == 0)
1063         return 0;
1064     }
1065
1066   /* Fetch the dynamic relocations if not already cached.  */
1067   if (lm->dyn_relocs == NULL)
1068     {
1069       long storage_needed;
1070
1071       /* Determine amount of space needed to hold the dynamic relocs.  */
1072       storage_needed = bfd_get_dynamic_reloc_upper_bound (abfd);
1073
1074       /* Bail out if there are no dynamic relocs.  */
1075       if (storage_needed <= 0)
1076         return 0;
1077
1078       /* Allocate space for the relocs.  */
1079       lm->dyn_relocs = (arelent **) xmalloc (storage_needed);
1080
1081       /* Fetch the dynamic relocs.  */
1082       lm->dyn_reloc_count
1083         = bfd_canonicalize_dynamic_reloc (abfd, lm->dyn_relocs, lm->dyn_syms);
1084     }
1085
1086   /* Search the dynamic relocs.  */
1087   for (i = 0; i < lm->dyn_reloc_count; i++)
1088     {
1089       rel = lm->dyn_relocs[i];
1090
1091       /* Relocs of interest are those which meet the following
1092          criteria:
1093
1094            - the names match (assuming the caller could provide
1095              a name which matches ``entry_point'').
1096            - the relocation type must be R_FRV_FUNCDESC.  Relocs
1097              of this type are used (by the dynamic linker) to
1098              look up the address of a canonical descriptor (allocating
1099              it if need be) and initializing the GOT entry referred
1100              to by the offset to the address of the descriptor.
1101
1102          These relocs of interest may be used to obtain a
1103          candidate descriptor by first adjusting the reloc's
1104          address according to the link map and then dereferencing
1105          this address (which is a GOT entry) to obtain a descriptor
1106          address.  */
1107       if ((name == 0 || strcmp (name, (*rel->sym_ptr_ptr)->name) == 0)
1108           && rel->howto->type == R_FRV_FUNCDESC)
1109         {
1110           gdb_byte buf [FRV_PTR_SIZE];
1111
1112           /* Compute address of address of candidate descriptor.  */
1113           addr = rel->address + displacement_from_map (lm->map, rel->address);
1114
1115           /* Fetch address of candidate descriptor.  */
1116           if (target_read_memory (addr, buf, sizeof buf) != 0)
1117             continue;
1118           addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
1119
1120           /* Check for matching entry point.  */
1121           if (target_read_memory (addr, buf, sizeof buf) != 0)
1122             continue;
1123           if (extract_unsigned_integer (buf, sizeof buf, byte_order)
1124               != entry_point)
1125             continue;
1126
1127           /* Check for matching got value.  */
1128           if (target_read_memory (addr + 4, buf, sizeof buf) != 0)
1129             continue;
1130           if (extract_unsigned_integer (buf, sizeof buf, byte_order)
1131               != got_value)
1132             continue;
1133
1134           /* Match was successful!  Exit loop.  */
1135           break;
1136         }
1137     }
1138
1139   return addr;
1140 }
1141
1142 /* Given an objfile, return the address of its link map.  This value is
1143    needed for TLS support.  */
1144 CORE_ADDR
1145 frv_fetch_objfile_link_map (struct objfile *objfile)
1146 {
1147   struct so_list *so;
1148
1149   /* Cause frv_current_sos() to be run if it hasn't been already.  */
1150   if (main_lm_addr == 0)
1151     solib_add (0, 0, 0, 1);
1152
1153   /* frv_current_sos() will set main_lm_addr for the main executable.  */
1154   if (objfile == symfile_objfile)
1155     return main_lm_addr;
1156
1157   /* The other link map addresses may be found by examining the list
1158      of shared libraries.  */
1159   for (so = master_so_list (); so; so = so->next)
1160     {
1161       if (so->objfile == objfile)
1162         return so->lm_info->lm_addr;
1163     }
1164
1165   /* Not found!  */
1166   return 0;
1167 }
1168
1169 struct target_so_ops frv_so_ops;
1170
1171 /* Provide a prototype to silence -Wmissing-prototypes.  */
1172 extern initialize_file_ftype _initialize_frv_solib;
1173
1174 void
1175 _initialize_frv_solib (void)
1176 {
1177   frv_so_ops.relocate_section_addresses = frv_relocate_section_addresses;
1178   frv_so_ops.free_so = frv_free_so;
1179   frv_so_ops.clear_solib = frv_clear_solib;
1180   frv_so_ops.solib_create_inferior_hook = frv_solib_create_inferior_hook;
1181   frv_so_ops.special_symbol_handling = frv_special_symbol_handling;
1182   frv_so_ops.current_sos = frv_current_sos;
1183   frv_so_ops.open_symbol_file_object = open_symbol_file_object;
1184   frv_so_ops.in_dynsym_resolve_code = frv_in_dynsym_resolve_code;
1185   frv_so_ops.bfd_open = solib_bfd_open;
1186
1187   /* Debug this file's internals.  */
1188   add_setshow_zinteger_cmd ("solib-frv", class_maintenance,
1189                             &solib_frv_debug, _("\
1190 Set internal debugging of shared library code for FR-V."), _("\
1191 Show internal debugging of shared library code for FR-V."), _("\
1192 When non-zero, FR-V solib specific internal debugging is enabled."),
1193                             NULL,
1194                             NULL, /* FIXME: i18n: */
1195                             &setdebuglist, &showdebuglist);
1196 }