gdb/solib-pa64.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Handle PA64 shared libraries for GDB, the GNU Debugger.

  3.    Copyright (C) 2004-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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.

  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!  */

  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. #include "gdb_bfd.h"

  42. #include "hppa-tdep.h"
  43. #include "solist.h"
  44. #include "solib.h"
  45. #include "solib-pa64.h"

  47. ‌#undef SOLIB_PA64_DBG

  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__)

  53. /* FIXME: kettenis/20041213: These includes should be eliminated.  */
  54. #include <dlfcn.h>
  55. #include <elf.h>
  56. #include <elf_hp.h>

  58. ‌struct lm_info {
  59.   struct load_module_desc desc;
  60.   CORE_ADDR desc_addr;
  61. };

  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;

  77. ‌static dld_cache_t dld_cache;

  79. static int read_dynamic_info (asection *dyninfo_sect,
  80.                               dld_cache_t *dld_cache_p);

  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;

  89.   /* Relocate all the sections based on where they got loaded.  */

  91.   load_offset = bfd_section_vma (so->abfd, asec) - asec->filepos;

  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. }

  105. static void
  106. ‌pa64_free_so (struct so_list *so)
  107. {
  108.   xfree (so->lm_info);
  109. }

  111. static void
  112. ‌pa64_clear_solib (void)
  113. {
  114. }

  116. /* Wrapper for target_read_memory for dlgetmodinfo.  */

  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. }

  126. /* Read the dynamic linker's internal shared library descriptor.

  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.  */

  133. static int
  134. ‌read_dld_descriptor (void)
  135. {
  136.   char *dll_path;
  137.   asection *dyninfo_sect;

  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."));

  146.       dyninfo_sect = bfd_get_section_by_name (symfile_objfile->obfd,
  147.                                               ".dynamic");
  148.       if (!dyninfo_sect)
  149.         {
  150.           return 0;
  151.         }

  153.       if (!read_dynamic_info (dyninfo_sect, &dld_cache))
  154.         error (_("Unable to read in .dynamic section information."));
  155.     }

  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.     }

  166.   if (!dld_cache.load_map)
  167.     return 0;

  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.     }

  181.   /* Indicate that we have loaded the dld descriptor.  */
  182.   dld_cache.have_read_dld_descriptor = 1;

  184.   return 1;
  185. }


  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.  */

  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;

  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;

  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;

  218.       dyn_tag = bfd_h_get_64 (symfile_objfile->obfd,
  219.                               (bfd_byte*) &x_dynp->d_tag);

  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.     }

  258.   /* Record other information and set is_valid to 1.  */
  259.   dld_cache_p->dyninfo_sect = dyninfo_sect;

  261.   /* Verify that we read in required info.  These fields are re-set to zero
  262.      in pa64_solib_restart.  */

  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;

  269.   return 1;
  270. }

  272. /* Helper function for gdb_bfd_lookup_symbol_from_symtab.  */

  274. static int
  275. ‌cmp_name (asymbol *sym, void *data)
  276. {
  277.   return (strcmp (sym->name, (const char *) data) == 0);
  278. }

  280. /* This hook gets called just before the first instruction in the
  281.    inferior process is executed.

  283.    This is our opportunity to set magic flags in the inferior so
  284.    that GDB can be notified when a shared library is mapped in and
  285.    to tell the dynamic linker that a private copy of the library is
  286.    needed (so GDB can set breakpoints in the library).

  288.    We need to set DT_HP_DEBUG_CALLBACK to indicate that we want the
  289.    dynamic linker to call the breakpoint routine for significant events.
  290.    We used to set DT_HP_DEBUG_PRIVATE to indicate that shared libraries
  291.    should be mapped private.  However, this flag can be set using
  292.    "chatr +dbg enable".  Not setting DT_HP_DEBUG_PRIVATE allows debugging
  293.    with shared libraries mapped shareable.  */

  295. static void
  296. ‌pa64_solib_create_inferior_hook (int from_tty)
  297. {
  298.   struct minimal_symbol *msymbol;
  299.   unsigned int dld_flags, status;
  300.   asection *shlib_info, *interp_sect;
  301.   struct objfile *objfile;
  302.   CORE_ADDR anaddr;

  304.   if (symfile_objfile == NULL)
  305.     return;

  307.   /* First see if the objfile was dynamically linked.  */
  308.   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, ".dynamic");
  309.   if (!shlib_info)
  310.     return;

  312.   /* It's got a .dynamic section, make sure it's not empty.  */
  313.   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
  314.     return;

  316.   /* Read in the .dynamic section.  */
  317.   if (! read_dynamic_info (shlib_info, &dld_cache))
  318.     error (_("Unable to read the .dynamic section."));

  320.   /* If the libraries were not mapped private, warn the user.  */
  321.   if ((dld_cache.dld_flags & DT_HP_DEBUG_PRIVATE) == 0)
  322.     warning
  323.       (_("\
  324. Private mapping of shared library text was not specified\n\
  325. by the executable; setting a breakpoint in a shared library which\n\
  326. is not privately mapped will not work.  See the HP-UX 11i v3 chatr\n\
  327. manpage for methods to privately map shared library text."));

  329.   /* Turn on the flags we care about.  */
  330.   dld_cache.dld_flags |= DT_HP_DEBUG_CALLBACK;
  331.   status = target_write_memory (dld_cache.dld_flags_addr,
  332.                                 (char *) &dld_cache.dld_flags,
  333.                                 sizeof (dld_cache.dld_flags));
  334.   if (status != 0)
  335.     error (_("Unable to modify dynamic linker flags."));

  337.   /* Now we have to create a shared library breakpoint in the dynamic
  338.      linker.  This can be somewhat tricky since the symbol is inside
  339.      the dynamic linker (for which we do not have symbols or a base
  340.      load address!   Luckily I wrote this code for solib.c years ago.  */
  341.   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
  342.   if (interp_sect)
  343.     {
  344.       unsigned int interp_sect_size;
  345.       char *buf;
  346.       CORE_ADDR load_addr;
  347.       bfd *tmp_bfd;
  348.       CORE_ADDR sym_addr = 0;

  350.       /* Read the contents of the .interp section into a local buffer;
  351.          the contents specify the dynamic linker this program uses.  */
  352.       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
  353.       buf = alloca (interp_sect_size);
  354.       bfd_get_section_contents (exec_bfd, interp_sect,
  355.                                 buf, 0, interp_sect_size);

  357.       /* Now we need to figure out where the dynamic linker was
  358.          loaded so that we can load its symbols and place a breakpoint
  359.          in the dynamic linker itself.

  361.          This address is stored on the stack.  However, I've been unable
  362.          to find any magic formula to find it for Solaris (appears to
  363.          be trivial on GNU/Linux).  Therefore, we have to try an alternate
  364.          mechanism to find the dynamic linker's base address.  */
  365.       tmp_bfd = gdb_bfd_open (buf, gnutarget, -1);
  366.       if (tmp_bfd == NULL)
  367.         return;

  369.       /* Make sure the dynamic linker's really a useful object.  */
  370.       if (!bfd_check_format (tmp_bfd, bfd_object))
  371.         {
  372.           warning (_("Unable to grok dynamic linker %s as an object file"),
  373.                    buf);
  374.           gdb_bfd_unref (tmp_bfd);
  375.           return;
  376.         }

  378.       /* We find the dynamic linker's base address by examining the
  379.          current pc (which point at the entry point for the dynamic
  380.          linker) and subtracting the offset of the entry point.

  382.          Also note the breakpoint is the second instruction in the
  383.          routine.  */
  384.       load_addr = regcache_read_pc (get_current_regcache ())
  385.                   - tmp_bfd->start_address;
  386.       sym_addr = gdb_bfd_lookup_symbol_from_symtab (tmp_bfd, cmp_name,
  387.                                                     "__dld_break");
  388.       sym_addr = load_addr + sym_addr + 4;

  390.       /* Create the shared library breakpoint.  */
  391.       {
  392.         struct breakpoint *b
  393.           = create_solib_event_breakpoint (target_gdbarch (), sym_addr);

  395.         /* The breakpoint is actually hard-coded into the dynamic linker,
  396.            so we don't need to actually insert a breakpoint instruction
  397.            there.  In fact, the dynamic linker's code is immutable, even to
  398.            ttrace, so we shouldn't even try to do that.  For cases like
  399.            this, we have "permanent" breakpoints.  */
  400.         make_breakpoint_permanent (b);
  401.       }

  403.       /* We're done with the temporary bfd.  */
  404.       gdb_bfd_unref (tmp_bfd);
  405.     }
  406. }

  408. static void
  409. ‌pa64_special_symbol_handling (void)
  410. {
  411. }

  413. static struct so_list *
  414. ‌pa64_current_sos (void)
  415. {
  416.   struct so_list *head = 0;
  417.   struct so_list **link_ptr = &head;
  418.   int dll_index;

  420.   /* Read in the load map pointer if we have not done so already.  */
  421.   if (! dld_cache.have_read_dld_descriptor)
  422.     if (! read_dld_descriptor ())
  423.       return NULL;

  425.   for (dll_index = -1; ; dll_index++)
  426.     {
  427.       struct load_module_desc dll_desc;
  428.       char *dll_path;
  429.       struct so_list *new;
  430.       struct cleanup *old_chain;

  432.       if (dll_index == 0)
  433.         continue;

  435.       /* Read in the load module descriptor.  */
  436.       if (dlgetmodinfo (dll_index, &dll_desc, sizeof (dll_desc),
  437.                         pa64_target_read_memory, 0, dld_cache.load_map)
  438.           == 0)
  439.         break;

  441.       /* Get the name of the shared library.  */
  442.       dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc),
  443.                             pa64_target_read_memory,
  444.                             0, dld_cache.load_map);

  446.       new = (struct so_list *) xmalloc (sizeof (struct so_list));
  447.       memset (new, 0, sizeof (struct so_list));
  448.       new->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
  449.       memset (new->lm_info, 0, sizeof (struct lm_info));

  451.       strncpy (new->so_name, dll_path, SO_NAME_MAX_PATH_SIZE - 1);
  452.       new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
  453.       strcpy (new->so_original_name, new->so_name);

  455.       memcpy (&new->lm_info->desc, &dll_desc, sizeof (dll_desc));

  457. #ifdef SOLIB_PA64_DBG
  458.       {
  459.         struct load_module_desc *d = &new->lm_info->desc;

  461.         printf ("\n+ library \"%s\" is described at index %d\n", new->so_name,
  462.                 dll_index);
  463.         printf ("    text_base = %s\n", hex_string (d->text_base));
  464.         printf ("    text_size = %s\n", hex_string (d->text_size));
  465.         printf ("    data_base = %s\n", hex_string (d->data_base));
  466.         printf ("    data_size = %s\n", hex_string (d->data_size));
  467.         printf ("    unwind_base = %s\n", hex_string (d->unwind_base));
  468.         printf ("    linkage_ptr = %s\n", hex_string (d->linkage_ptr));
  469.         printf ("    phdr_base = %s\n", hex_string (d->phdr_base));
  470.         printf ("    tls_size = %s\n", hex_string (d->tls_size));
  471.         printf ("    tls_start_addr = %s\n", hex_string (d->tls_start_addr));
  472.         printf ("    unwind_size = %s\n", hex_string (d->unwind_size));
  473.         printf ("    tls_index = %s\n", hex_string (d->tls_index));
  474.       }
  475. #endif

  477.       /* Link the new object onto the list.  */
  478.       new->next = NULL;
  479.       *link_ptr = new;
  480.       link_ptr = &new->next;
  481.     }

  483.   return head;
  484. }

  486. static int
  487. ‌pa64_open_symbol_file_object (void *from_ttyp)
  488. {
  489.   int from_tty = *(int *)from_ttyp;
  490.   struct load_module_desc dll_desc;
  491.   char *dll_path;

  493.   if (symfile_objfile)
  494.     if (!query (_("Attempt to reload symbols from process? ")))
  495.       return 0;

  497.   /* Read in the load map pointer if we have not done so already.  */
  498.   if (! dld_cache.have_read_dld_descriptor)
  499.     if (! read_dld_descriptor ())
  500.       return 0;

  502.   /* Read in the load module descriptor.  */
  503.   if (dlgetmodinfo (0, &dll_desc, sizeof (dll_desc),
  504.                     pa64_target_read_memory, 0, dld_cache.load_map) == 0)
  505.     return 0;

  507.   /* Get the name of the shared library.  */
  508.   dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc),
  509.                                 pa64_target_read_memory,
  510.                                 0, dld_cache.load_map);

  512.   /* Have a pathname: read the symbol file.  */
  513.   symbol_file_add_main (dll_path, from_tty);

  515.   return 1;
  516. }

  518. /* Return nonzero if PC is an address inside the dynamic linker.  */
  519. static int
  520. ‌pa64_in_dynsym_resolve_code (CORE_ADDR pc)
  521. {
  522.   asection *shlib_info;

  524.   if (symfile_objfile == NULL)
  525.     return 0;

  527.   if (!dld_cache.have_read_dld_descriptor)
  528.     if (!read_dld_descriptor ())
  529.       return 0;

  531.   return (pc >= dld_cache.dld_desc.text_base
  532.           && pc < dld_cache.dld_desc.text_base + dld_cache.dld_desc.text_size);
  533. }


  536. /* Return the GOT value for the shared library in which ADDR belongs.  If
  537.    ADDR isn't in any known shared library, return zero.  */

  539. static CORE_ADDR
  540. ‌pa64_solib_get_got_by_pc (CORE_ADDR addr)
  541. {
  542.   struct so_list *so_list = master_so_list ();
  543.   CORE_ADDR got_value = 0;

  545.   while (so_list)
  546.     {
  547.       if (so_list->lm_info->desc.text_base <= addr
  548.           && ((so_list->lm_info->desc.text_base
  549.                + so_list->lm_info->desc.text_size)
  550.               > addr))
  551.         {
  552.           got_value = so_list->lm_info->desc.linkage_ptr;
  553.            break;
  554.         }
  555.       so_list = so_list->next;
  556.     }
  557.   return got_value;
  558. }

  560. /* Get some HPUX-specific data from a shared lib.  */
  561. static CORE_ADDR
  562. ‌pa64_solib_thread_start_addr (struct so_list *so)
  563. {
  564.   return so->lm_info->desc.tls_start_addr;
  565. }


  568. /* Return the address of the handle of the shared library in which ADDR
  569.    belongs.  If ADDR isn't in any known shared library, return zero.  */

  571. static CORE_ADDR
  572. ‌pa64_solib_get_solib_by_pc (CORE_ADDR addr)
  573. {
  574.   struct so_list *so_list = master_so_list ();
  575.   CORE_ADDR retval = 0;

  577.   while (so_list)
  578.     {
  579.       if (so_list->lm_info->desc.text_base <= addr
  580.           && ((so_list->lm_info->desc.text_base
  581.                + so_list->lm_info->desc.text_size)
  582.               > addr))
  583.         {
  584.           retval = so_list->lm_info->desc_addr;
  585.           break;
  586.         }
  587.       so_list = so_list->next;
  588.     }
  589.   return retval;
  590. }

  592. /* pa64 libraries do not seem to set the section offsets in a standard (i.e.
  593.    SVr4) way; the text section offset stored in the file doesn't correspond
  594.    to the place where the library is actually loaded into memory.  Instead,
  595.    we rely on the dll descriptor to tell us where things were loaded.  */
  596. static CORE_ADDR
  597. ‌pa64_solib_get_text_base (struct objfile *objfile)
  598. {
  599.   struct so_list *so;

  601.   for (so = master_so_list (); so; so = so->next)
  602.     if (so->objfile == objfile)
  603.       return so->lm_info->desc.text_base;

  605.   return 0;
  606. }

  608. ‌static struct target_so_ops pa64_so_ops;

  610. extern initialize_file_ftype _initialize_pa64_solib; /* -Wmissing-prototypes */

  612. void
  613. ‌_initialize_pa64_solib (void)
  614. {
  615.   pa64_so_ops.relocate_section_addresses = pa64_relocate_section_addresses;
  616.   pa64_so_ops.free_so = pa64_free_so;
  617.   pa64_so_ops.clear_solib = pa64_clear_solib;
  618.   pa64_so_ops.solib_create_inferior_hook = pa64_solib_create_inferior_hook;
  619.   pa64_so_ops.special_symbol_handling = pa64_special_symbol_handling;
  620.   pa64_so_ops.current_sos = pa64_current_sos;
  621.   pa64_so_ops.open_symbol_file_object = pa64_open_symbol_file_object;
  622.   pa64_so_ops.in_dynsym_resolve_code = pa64_in_dynsym_resolve_code;
  623.   pa64_so_ops.bfd_open = solib_bfd_open;

  625.   memset (&dld_cache, 0, sizeof (dld_cache));
  626. }

  628. ‌void pa64_solib_select (struct gdbarch *gdbarch)
  629. {
  630.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  632.   set_solib_ops (gdbarch, &pa64_so_ops);
  633.   tdep->solib_thread_start_addr = pa64_solib_thread_start_addr;
  634.   tdep->solib_get_got_by_pc = pa64_solib_get_got_by_pc;
  635.   tdep->solib_get_solib_by_pc = pa64_solib_get_solib_by_pc;
  636.   tdep->solib_get_text_base = pa64_solib_get_text_base;
  637. }

  639. #else /* HAVE_ELF_HP_H */

  641. extern initialize_file_ftype _initialize_pa64_solib; /* -Wmissing-prototypes */

  643. void
  644. ‌_initialize_pa64_solib (void)
  645. {
  646. }

  648. ‌void pa64_solib_select (struct gdbarch *gdbarch)
  649. {
  650.   /* For a SOM-only target, there is no pa64 solib support.  This is needed
  651.      for hppa-hpux-tdep.c to build.  */
  652.   error (_("Cannot select pa64 solib support for this configuration."));
  653. }
  654. #endif