gdb/solib-frv.c

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