gdb/solib-frv.c

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