gdb/solib-pa64.c

   1 /* Handle PA64 shared libraries for GDB, the GNU Debugger.
   2
   3    Copyright (C) 2004, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21    HP in their infinite stupidity choose not to use standard ELF dynamic
  22    linker interfaces.  They also choose not to make their ELF dymamic
  23    linker interfaces compatible with the SOM dynamic linker.  The
  24    net result is we can not use either of the existing somsolib.c or
  25    solib.c.  What a crock.
  26
  27    Even more disgusting.  This file depends on functions provided only
  28    in certain PA64 libraries.  Thus this file is supposed to only be
  29    used native.  When will HP ever learn that they need to provide the
  30    same functionality in all their libraries!  */
  31
  32 #include "defs.h"
  33 #include "symtab.h"
  34 #include "bfd.h"
  35 #include "symfile.h"
  36 #include "objfiles.h"
  37 #include "gdbcore.h"
  38 #include "target.h"
  39 #include "inferior.h"
  40 #include "regcache.h"
  41
  42 #include "hppa-tdep.h"
  43 #include "solist.h"
  44 #include "solib.h"
  45 #include "solib-pa64.h"
  46
  47 #undef SOLIB_PA64_DBG
  48
  49 /* We can build this file only when running natively on 64-bit HP/UX.
  50    We check for that by checking for the elf_hp.h header file.  */
  51 #if defined(HAVE_ELF_HP_H) && defined(__LP64__)
  52
  53 /* FIXME: kettenis/20041213: These includes should be eliminated.  */
  54 #include <dlfcn.h>
  55 #include <elf.h>
  56 #include <elf_hp.h>
  57
  58 struct lm_info {
  59   struct load_module_desc desc;
  60   CORE_ADDR desc_addr;
  61 };
  62
  63 /* When adding fields, be sure to clear them in _initialize_pa64_solib. */
  64 typedef struct
  65   {
  66     CORE_ADDR dld_flags_addr;
  67     LONGEST dld_flags;
  68     struct bfd_section *dyninfo_sect;
  69     int have_read_dld_descriptor;
  70     int is_valid;
  71     CORE_ADDR load_map;
  72     CORE_ADDR load_map_addr;
  73     struct load_module_desc dld_desc;
  74   }
  75 dld_cache_t;
  76
  77 static dld_cache_t dld_cache;
  78
  79 static int
  80 read_dynamic_info (asection *dyninfo_sect, dld_cache_t *dld_cache_p);
  81
  82 static void
  83 pa64_relocate_section_addresses (struct so_list *so,
  84                                  struct target_section *sec)
  85 {
  86   asection *asec = sec->the_bfd_section;
  87   CORE_ADDR load_offset;
  88
  89   /* Relocate all the sections based on where they got loaded.  */
  90
  91   load_offset = bfd_section_vma (so->abfd, asec) - asec->filepos;
  92
  93   if (asec->flags & SEC_CODE)
  94     {
  95       sec->addr += so->lm_info->desc.text_base - load_offset;
  96       sec->endaddr += so->lm_info->desc.text_base - load_offset;
  97     }
  98   else if (asec->flags & SEC_DATA)
  99     {
 100       sec->addr += so->lm_info->desc.data_base - load_offset;
 101       sec->endaddr += so->lm_info->desc.data_base - load_offset;
 102     }
 103 }
 104
 105 static void
 106 pa64_free_so (struct so_list *so)
 107 {
 108   xfree (so->lm_info);
 109 }
 110
 111 static void
 112 pa64_clear_solib (void)
 113 {
 114 }
 115
 116 /* Wrapper for target_read_memory for dlgetmodinfo.  */
 117
 118 static void *
 119 pa64_target_read_memory (void *buffer, CORE_ADDR ptr, size_t bufsiz, int ident)
 120 {
 121   if (target_read_memory (ptr, buffer, bufsiz) != 0)
 122     return 0;
 123   return buffer;
 124 }
 125
 126 /* Read the dynamic linker's internal shared library descriptor.
 127
 128    This must happen after dld starts running, so we can't do it in
 129    read_dynamic_info.  Record the fact that we have loaded the
 130    descriptor.  If the library is archive bound or the load map
 131    hasn't been setup, then return zero; else return nonzero.  */
 132
 133 static int
 134 read_dld_descriptor (void)
 135 {
 136   char *dll_path;
 137   asection *dyninfo_sect;
 138
 139   /* If necessary call read_dynamic_info to extract the contents of the
 140      .dynamic section from the shared library.  */
 141   if (!dld_cache.is_valid)
 142     {
 143       if (symfile_objfile == NULL)
 144         error (_("No object file symbols."));
 145
 146       dyninfo_sect = bfd_get_section_by_name (symfile_objfile->obfd,
 147                                               ".dynamic");
 148       if (!dyninfo_sect)
 149         {
 150           return 0;
 151         }
 152
 153       if (!read_dynamic_info (dyninfo_sect, &dld_cache))
 154         error (_("Unable to read in .dynamic section information."));
 155     }
 156
 157   /* Read the load map pointer.  */
 158   if (target_read_memory (dld_cache.load_map_addr,
 159                           (char *) &dld_cache.load_map,
 160                           sizeof (dld_cache.load_map))
 161       != 0)
 162     {
 163       error (_("Error while reading in load map pointer."));
 164     }
 165
 166   if (!dld_cache.load_map)
 167     return 0;
 168
 169   /* Read in the dld load module descriptor */
 170   if (dlgetmodinfo (-1,
 171                     &dld_cache.dld_desc,
 172                     sizeof (dld_cache.dld_desc),
 173                     pa64_target_read_memory,
 174                     0,
 175                     dld_cache.load_map)
 176       == 0)
 177     {
 178       error (_("Error trying to get information about dynamic linker."));
 179     }
 180
 181   /* Indicate that we have loaded the dld descriptor.  */
 182   dld_cache.have_read_dld_descriptor = 1;
 183
 184   return 1;
 185 }
 186
 187
 188 /* Read the .dynamic section and extract the information of interest,
 189    which is stored in dld_cache.  The routine elf_locate_base in solib.c
 190    was used as a model for this.  */
 191
 192 static int
 193 read_dynamic_info (asection *dyninfo_sect, dld_cache_t *dld_cache_p)
 194 {
 195   char *buf;
 196   char *bufend;
 197   CORE_ADDR dyninfo_addr;
 198   int dyninfo_sect_size;
 199   CORE_ADDR entry_addr;
 200
 201   /* Read in .dynamic section, silently ignore errors.  */
 202   dyninfo_addr = bfd_section_vma (symfile_objfile->obfd, dyninfo_sect);
 203   dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);
 204   buf = alloca (dyninfo_sect_size);
 205   if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))
 206     return 0;
 207
 208   /* Scan the .dynamic section and record the items of interest.
 209      In particular, DT_HP_DLD_FLAGS */
 210   for (bufend = buf + dyninfo_sect_size, entry_addr = dyninfo_addr;
 211        buf < bufend;
 212        buf += sizeof (Elf64_Dyn), entry_addr += sizeof (Elf64_Dyn))
 213     {
 214       Elf64_Dyn *x_dynp = (Elf64_Dyn*)buf;
 215       Elf64_Sxword dyn_tag;
 216       CORE_ADDR dyn_ptr;
 217
 218       dyn_tag = bfd_h_get_64 (symfile_objfile->obfd,
 219                               (bfd_byte*) &x_dynp->d_tag);
 220
 221       /* We can't use a switch here because dyn_tag is 64 bits and HP's
 222          lame comiler does not handle 64bit items in switch statements.  */
 223       if (dyn_tag == DT_NULL)
 224         break;
 225       else if (dyn_tag == DT_HP_DLD_FLAGS)
 226         {
 227           /* Set dld_flags_addr and dld_flags in *dld_cache_p */
 228           dld_cache_p->dld_flags_addr = entry_addr + offsetof(Elf64_Dyn, d_un);
 229           if (target_read_memory (dld_cache_p->dld_flags_addr,
 230                                   (char*) &dld_cache_p->dld_flags,
 231                                   sizeof (dld_cache_p->dld_flags))
 232               != 0)
 233             {
 234               error (_("Error while reading in "
 235                        ".dynamic section of the program."));
 236             }
 237         }
 238       else if (dyn_tag == DT_HP_LOAD_MAP)
 239         {
 240           /* Dld will place the address of the load map at load_map_addr
 241              after it starts running.  */
 242           if (target_read_memory (entry_addr + offsetof(Elf64_Dyn,
 243                                                         d_un.d_ptr),
 244                                   (char*) &dld_cache_p->load_map_addr,
 245                                   sizeof (dld_cache_p->load_map_addr))
 246               != 0)
 247             {
 248               error (_("Error while reading in "
 249                        ".dynamic section of the program."));
 250             }
 251         }
 252       else
 253         {
 254           /* tag is not of interest */
 255         }
 256     }
 257
 258   /* Record other information and set is_valid to 1. */
 259   dld_cache_p->dyninfo_sect = dyninfo_sect;
 260
 261   /* Verify that we read in required info.  These fields are re-set to zero
 262      in pa64_solib_restart.  */
 263
 264   if (dld_cache_p->dld_flags_addr != 0 && dld_cache_p->load_map_addr != 0)
 265     dld_cache_p->is_valid = 1;
 266   else
 267     return 0;
 268
 269   return 1;
 270 }
 271
 272 /*
 273    bfd_lookup_symbol -- lookup the value for a specific symbol
 274
 275    An expensive way to lookup the value of a single symbol for
 276    bfd's that are only temporary anyway.  This is used by the
 277    shared library support to find the address of the debugger
 278    interface structures in the shared library.
 279
 280    Note that 0 is specifically allowed as an error return (no
 281    such symbol).
 282  */
 283
 284 static CORE_ADDR
 285 bfd_lookup_symbol (bfd *abfd, char *symname)
 286 {
 287   unsigned int storage_needed;
 288   asymbol *sym;
 289   asymbol **symbol_table;
 290   unsigned int number_of_symbols;
 291   unsigned int i;
 292   struct cleanup *back_to;
 293   CORE_ADDR symaddr = 0;
 294
 295   storage_needed = bfd_get_symtab_upper_bound (abfd);
 296
 297   if (storage_needed > 0)
 298     {
 299       symbol_table = (asymbol **) xmalloc (storage_needed);
 300       back_to = make_cleanup (xfree, symbol_table);
 301       number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 302
 303       for (i = 0; i < number_of_symbols; i++)
 304         {
 305           sym = *symbol_table++;
 306           if (strcmp (sym->name, symname) == 0)
 307             {
 308               /* Bfd symbols are section relative. */
 309               symaddr = sym->value + sym->section->vma;
 310               break;
 311             }
 312         }
 313       do_cleanups (back_to);
 314     }
 315   return (symaddr);
 316 }
 317
 318
 319 /* This hook gets called just before the first instruction in the
 320    inferior process is executed.
 321
 322    This is our opportunity to set magic flags in the inferior so
 323    that GDB can be notified when a shared library is mapped in and
 324    to tell the dynamic linker that a private copy of the library is
 325    needed (so GDB can set breakpoints in the library).
 326
 327    We need to set DT_HP_DEBUG_CALLBACK to indicate that we want the
 328    dynamic linker to call the breakpoint routine for significant events.
 329    We used to set DT_HP_DEBUG_PRIVATE to indicate that shared libraries
 330    should be mapped private.  However, this flag can be set using
 331    "chatr +dbg enable".  Not setting DT_HP_DEBUG_PRIVATE allows debugging
 332    with shared libraries mapped shareable.  */
 333
 334 static void
 335 pa64_solib_create_inferior_hook (int from_tty)
 336 {
 337   struct minimal_symbol *msymbol;
 338   unsigned int dld_flags, status;
 339   asection *shlib_info, *interp_sect;
 340   char buf[4];
 341   struct objfile *objfile;
 342   CORE_ADDR anaddr;
 343
 344   if (symfile_objfile == NULL)
 345     return;
 346
 347   /* First see if the objfile was dynamically linked.  */
 348   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, ".dynamic");
 349   if (!shlib_info)
 350     return;
 351
 352   /* It's got a .dynamic section, make sure it's not empty.  */
 353   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
 354     return;
 355
 356   /* Read in the .dynamic section.  */
 357   if (! read_dynamic_info (shlib_info, &dld_cache))
 358     error (_("Unable to read the .dynamic section."));
 359
 360   /* If the libraries were not mapped private, warn the user.  */
 361   if ((dld_cache.dld_flags & DT_HP_DEBUG_PRIVATE) == 0)
 362     warning
 363       (_("Private mapping of shared library text was not specified\n"
 364          "by the executable; setting a breakpoint in a shared library which\n"
 365          "is not privately mapped will not work.  See the HP-UX 11i v3 chatr\n"
 366          "manpage for methods to privately map shared library text."));
 367
 368   /* Turn on the flags we care about.  */
 369   dld_cache.dld_flags |= DT_HP_DEBUG_CALLBACK;
 370   status = target_write_memory (dld_cache.dld_flags_addr,
 371                                 (char *) &dld_cache.dld_flags,
 372                                 sizeof (dld_cache.dld_flags));
 373   if (status != 0)
 374     error (_("Unable to modify dynamic linker flags."));
 375
 376   /* Now we have to create a shared library breakpoint in the dynamic
 377      linker.  This can be somewhat tricky since the symbol is inside
 378      the dynamic linker (for which we do not have symbols or a base
 379      load address!   Luckily I wrote this code for solib.c years ago.  */
 380   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
 381   if (interp_sect)
 382     {
 383       unsigned int interp_sect_size;
 384       char *buf;
 385       CORE_ADDR load_addr;
 386       bfd *tmp_bfd;
 387       CORE_ADDR sym_addr = 0;
 388
 389       /* Read the contents of the .interp section into a local buffer;
 390          the contents specify the dynamic linker this program uses.  */
 391       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
 392       buf = alloca (interp_sect_size);
 393       bfd_get_section_contents (exec_bfd, interp_sect,
 394                                 buf, 0, interp_sect_size);
 395
 396       /* Now we need to figure out where the dynamic linker was
 397          loaded so that we can load its symbols and place a breakpoint
 398          in the dynamic linker itself.
 399
 400          This address is stored on the stack.  However, I've been unable
 401          to find any magic formula to find it for Solaris (appears to
 402          be trivial on GNU/Linux).  Therefore, we have to try an alternate
 403          mechanism to find the dynamic linker's base address.  */
 404       tmp_bfd = bfd_openr (buf, gnutarget);
 405       if (tmp_bfd == NULL)
 406         return;
 407
 408       /* Make sure the dynamic linker's really a useful object.  */
 409       if (!bfd_check_format (tmp_bfd, bfd_object))
 410         {
 411           warning (_("Unable to grok dynamic linker %s as an object file"),
 412                    buf);
 413           bfd_close (tmp_bfd);
 414           return;
 415         }
 416
 417       /* We find the dynamic linker's base address by examining the
 418          current pc (which point at the entry point for the dynamic
 419          linker) and subtracting the offset of the entry point.
 420
 421          Also note the breakpoint is the second instruction in the
 422          routine.  */
 423       load_addr = regcache_read_pc (get_current_regcache ())
 424                   - tmp_bfd->start_address;
 425       sym_addr = bfd_lookup_symbol (tmp_bfd, "__dld_break");
 426       sym_addr = load_addr + sym_addr + 4;
 427
 428       /* Create the shared library breakpoint.  */
 429       {
 430         struct breakpoint *b
 431           = create_solib_event_breakpoint (target_gdbarch, sym_addr);
 432
 433         /* The breakpoint is actually hard-coded into the dynamic linker,
 434            so we don't need to actually insert a breakpoint instruction
 435            there.  In fact, the dynamic linker's code is immutable, even to
 436            ttrace, so we shouldn't even try to do that.  For cases like
 437            this, we have "permanent" breakpoints.  */
 438         make_breakpoint_permanent (b);
 439       }
 440
 441       /* We're done with the temporary bfd.  */
 442       bfd_close (tmp_bfd);
 443     }
 444 }
 445
 446 static void
 447 pa64_special_symbol_handling (void)
 448 {
 449 }
 450
 451 static struct so_list *
 452 pa64_current_sos (void)
 453 {
 454   struct so_list *head = 0;
 455   struct so_list **link_ptr = &head;
 456   int dll_index;
 457
 458   /* Read in the load map pointer if we have not done so already.  */
 459   if (! dld_cache.have_read_dld_descriptor)
 460     if (! read_dld_descriptor ())
 461       return NULL;
 462
 463   for (dll_index = -1; ; dll_index++)
 464     {
 465       struct load_module_desc dll_desc;
 466       char *dll_path;
 467       struct so_list *new;
 468       struct cleanup *old_chain;
 469
 470       if (dll_index == 0)
 471         continue;
 472
 473       /* Read in the load module descriptor.  */
 474       if (dlgetmodinfo (dll_index, &dll_desc, sizeof (dll_desc),
 475                         pa64_target_read_memory, 0, dld_cache.load_map)
 476           == 0)
 477         break;
 478
 479       /* Get the name of the shared library.  */
 480       dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc),
 481                             pa64_target_read_memory,
 482                             0, dld_cache.load_map);
 483
 484       new = (struct so_list *) xmalloc (sizeof (struct so_list));
 485       memset (new, 0, sizeof (struct so_list));
 486       new->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
 487       memset (new->lm_info, 0, sizeof (struct lm_info));
 488
 489       strncpy (new->so_name, dll_path, SO_NAME_MAX_PATH_SIZE - 1);
 490       new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
 491       strcpy (new->so_original_name, new->so_name);
 492
 493       memcpy (&new->lm_info->desc, &dll_desc, sizeof (dll_desc));
 494
 495 #ifdef SOLIB_PA64_DBG
 496       {
 497         struct load_module_desc *d = &new->lm_info->desc;
 498
 499         printf ("\n+ library \"%s\" is described at index %d\n", new->so_name,
 500                 dll_index);
 501         printf ("    text_base = %s\n", hex_string (d->text_base));
 502         printf ("    text_size = %s\n", hex_string (d->text_size));
 503         printf ("    data_base = %s\n", hex_string (d->data_base));
 504         printf ("    data_size = %s\n", hex_string (d->data_size));
 505         printf ("    unwind_base = %s\n", hex_string (d->unwind_base));
 506         printf ("    linkage_ptr = %s\n", hex_string (d->linkage_ptr));
 507         printf ("    phdr_base = %s\n", hex_string (d->phdr_base));
 508         printf ("    tls_size = %s\n", hex_string (d->tls_size));
 509         printf ("    tls_start_addr = %s\n", hex_string (d->tls_start_addr));
 510         printf ("    unwind_size = %s\n", hex_string (d->unwind_size));
 511         printf ("    tls_index = %s\n", hex_string (d->tls_index));
 512       }
 513 #endif
 514
 515       /* Link the new object onto the list.  */
 516       new->next = NULL;
 517       *link_ptr = new;
 518       link_ptr = &new->next;
 519     }
 520
 521   return head;
 522 }
 523
 524 static int
 525 pa64_open_symbol_file_object (void *from_ttyp)
 526 {
 527   int from_tty = *(int *)from_ttyp;
 528   char buf[4];
 529   struct load_module_desc dll_desc;
 530   char *dll_path;
 531
 532   if (symfile_objfile)
 533     if (!query (_("Attempt to reload symbols from process? ")))
 534       return 0;
 535
 536   /* Read in the load map pointer if we have not done so already.  */
 537   if (! dld_cache.have_read_dld_descriptor)
 538     if (! read_dld_descriptor ())
 539       return 0;
 540
 541   /* Read in the load module descriptor.  */
 542   if (dlgetmodinfo (0, &dll_desc, sizeof (dll_desc),
 543                     pa64_target_read_memory, 0, dld_cache.load_map) == 0)
 544     return 0;
 545
 546   /* Get the name of the shared library.  */
 547   dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc),
 548                                 pa64_target_read_memory,
 549                                 0, dld_cache.load_map);
 550
 551   /* Have a pathname: read the symbol file.  */
 552   symbol_file_add_main (dll_path, from_tty);
 553
 554   return 1;
 555 }
 556
 557 /* Return nonzero if PC is an address inside the dynamic linker.  */
 558 static int
 559 pa64_in_dynsym_resolve_code (CORE_ADDR pc)
 560 {
 561   asection *shlib_info;
 562
 563   if (symfile_objfile == NULL)
 564     return 0;
 565
 566   if (!dld_cache.have_read_dld_descriptor)
 567     if (!read_dld_descriptor ())
 568       return 0;
 569
 570   return (pc >= dld_cache.dld_desc.text_base
 571           && pc < dld_cache.dld_desc.text_base + dld_cache.dld_desc.text_size);
 572 }
 573
 574
 575 /* Return the GOT value for the shared library in which ADDR belongs.  If
 576    ADDR isn't in any known shared library, return zero.  */
 577
 578 static CORE_ADDR
 579 pa64_solib_get_got_by_pc (CORE_ADDR addr)
 580 {
 581   struct so_list *so_list = master_so_list ();
 582   CORE_ADDR got_value = 0;
 583
 584   while (so_list)
 585     {
 586       if (so_list->lm_info->desc.text_base <= addr
 587           && ((so_list->lm_info->desc.text_base
 588                + so_list->lm_info->desc.text_size)
 589               > addr))
 590         {
 591           got_value = so_list->lm_info->desc.linkage_ptr;
 592           break;
 593         }
 594       so_list = so_list->next;
 595     }
 596   return got_value;
 597 }
 598
 599 /* Get some HPUX-specific data from a shared lib.  */
 600 static CORE_ADDR
 601 pa64_solib_thread_start_addr (struct so_list *so)
 602 {
 603   return so->lm_info->desc.tls_start_addr;
 604 }
 605
 606
 607 /* Return the address of the handle of the shared library in which ADDR
 608    belongs.  If ADDR isn't in any known shared library, return zero.  */
 609
 610 static CORE_ADDR
 611 pa64_solib_get_solib_by_pc (CORE_ADDR addr)
 612 {
 613   struct so_list *so_list = master_so_list ();
 614   CORE_ADDR retval = 0;
 615
 616   while (so_list)
 617     {
 618       if (so_list->lm_info->desc.text_base <= addr
 619           && ((so_list->lm_info->desc.text_base
 620                + so_list->lm_info->desc.text_size)
 621               > addr))
 622         {
 623           retval = so_list->lm_info->desc_addr;
 624           break;
 625         }
 626       so_list = so_list->next;
 627     }
 628   return retval;
 629 }
 630
 631 /* pa64 libraries do not seem to set the section offsets in a standard (i.e.
 632    SVr4) way; the text section offset stored in the file doesn't correspond
 633    to the place where the library is actually loaded into memory.  Instead,
 634    we rely on the dll descriptor to tell us where things were loaded.  */
 635 static CORE_ADDR
 636 pa64_solib_get_text_base (struct objfile *objfile)
 637 {
 638   struct so_list *so;
 639
 640   for (so = master_so_list (); so; so = so->next)
 641     if (so->objfile == objfile)
 642       return so->lm_info->desc.text_base;
 643
 644   return 0;
 645 }
 646
 647 static struct target_so_ops pa64_so_ops;
 648
 649 extern initialize_file_ftype _initialize_pa64_solib; /* -Wmissing-prototypes */
 650
 651 void
 652 _initialize_pa64_solib (void)
 653 {
 654   pa64_so_ops.relocate_section_addresses = pa64_relocate_section_addresses;
 655   pa64_so_ops.free_so = pa64_free_so;
 656   pa64_so_ops.clear_solib = pa64_clear_solib;
 657   pa64_so_ops.solib_create_inferior_hook = pa64_solib_create_inferior_hook;
 658   pa64_so_ops.special_symbol_handling = pa64_special_symbol_handling;
 659   pa64_so_ops.current_sos = pa64_current_sos;
 660   pa64_so_ops.open_symbol_file_object = pa64_open_symbol_file_object;
 661   pa64_so_ops.in_dynsym_resolve_code = pa64_in_dynsym_resolve_code;
 662   pa64_so_ops.bfd_open = solib_bfd_open;
 663
 664   memset (&dld_cache, 0, sizeof (dld_cache));
 665 }
 666
 667 void pa64_solib_select (struct gdbarch *gdbarch)
 668 {
 669   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 670
 671   set_solib_ops (gdbarch, &pa64_so_ops);
 672   tdep->solib_thread_start_addr = pa64_solib_thread_start_addr;
 673   tdep->solib_get_got_by_pc = pa64_solib_get_got_by_pc;
 674   tdep->solib_get_solib_by_pc = pa64_solib_get_solib_by_pc;
 675   tdep->solib_get_text_base = pa64_solib_get_text_base;
 676 }
 677
 678 #else /* HAVE_ELF_HP_H */
 679
 680 extern initialize_file_ftype _initialize_pa64_solib; /* -Wmissing-prototypes */
 681
 682 void
 683 _initialize_pa64_solib (void)
 684 {
 685 }
 686
 687 void pa64_solib_select (struct gdbarch *gdbarch)
 688 {
 689   /* For a SOM-only target, there is no pa64 solib support.  This is needed
 690      for hppa-hpux-tdep.c to build.  */
 691   error (_("Cannot select pa64 solib support for this configuration."));
 692 }
 693 #endif