gdb/solib-frv.c

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