gdb/solib-frv.c

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