gdb/solib-pa64.c

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