gdb/solib-som.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Handle SOM shared libraries.

  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. #include "defs.h"
  21. #include "symtab.h"
  22. #include "bfd.h"
  23. #include "symfile.h"
  24. #include "objfiles.h"
  25. #include "gdbcore.h"
  26. #include "target.h"
  27. #include "inferior.h"

  29. #include "hppa-tdep.h"
  30. #include "solist.h"
  31. #include "solib.h"
  32. #include "solib-som.h"

  34. ‌#undef SOLIB_SOM_DBG

  36. /* These ought to be defined in some public interface, but aren't.  They
  37.    define the meaning of the various bits in the distinguished __dld_flags
  38.    variable that is declared in every debuggable a.out on HP-UX, and that
  39.    is shared between the debugger and the dynamic linker.  */

  41. ‌#define DLD_FLAGS_MAPPRIVATE    0x1
  42. ‌#define DLD_FLAGS_HOOKVALID     0x2
  43. ‌#define DLD_FLAGS_LISTVALID     0x4
  44. ‌#define DLD_FLAGS_BOR_ENABLE    0x8

  46. ‌struct lm_info
  47.   {
  48.     /* Version of this structure (it is expected to change again in
  49.        hpux10).  */
  50.     unsigned char struct_version;

  52.     /* Binding mode for this library.  */
  53.     unsigned char bind_mode;

  55.     /* Version of this library.  */
  56.     short library_version;

  58.     /* Start of text address,
  59.        link-time text location (length of text area),
  60.        end of text address.  */
  61.     CORE_ADDR text_addr;
  62.     CORE_ADDR text_link_addr;
  63.     CORE_ADDR text_end;

  65.     /* Start of data, start of bss and end of data.  */
  66.     CORE_ADDR data_start;
  67.     CORE_ADDR bss_start;
  68.     CORE_ADDR data_end;

  70.     /* Value of linkage pointer (%r19).  */
  71.     CORE_ADDR got_value;

  73.     /* Address in target of offset from thread-local register of
  74.        start of this thread's data.  I.e., the first thread-local
  75.        variable in this shared library starts at *(tsd_start_addr)
  76.        from that area pointed to by cr27 (mpsfu_hi).

  78.        We do the indirection as soon as we read it, so from then
  79.        on it's the offset itself.  */
  80.     CORE_ADDR tsd_start_addr;

  82.     /* Address of the link map entry in the loader.  */
  83.     CORE_ADDR lm_addr;
  84.   };

  86. /* These addresses should be filled in by som_solib_create_inferior_hook.
  87.    They are also used elsewhere in this module.  */

  89. typedef struct
  90.   {
  91.     CORE_ADDR address;
  92.     struct unwind_table_entry *unwind;
  93.   }
  94. ‌addr_and_unwind_t;

  96. /* When adding fields, be sure to clear them in _initialize_som_solib.  */
  97. static struct
  98.   {
  99.     int is_valid;
  100.     addr_and_unwind_t hook;
  101.     addr_and_unwind_t hook_stub;
  102.     addr_and_unwind_t load;
  103.     addr_and_unwind_t load_stub;
  104.     addr_and_unwind_t unload;
  105.     addr_and_unwind_t unload2;
  106.     addr_and_unwind_t unload_stub;
  107.   }
  108. ‌dld_cache;

  110. static void
  111. ‌som_relocate_section_addresses (struct so_list *so,
  112.                                 struct target_section *sec)
  113. {
  114.   flagword aflag = bfd_get_section_flags(so->abfd, sec->the_bfd_section);

  116.   if (aflag & SEC_CODE)
  117.     {
  118.       sec->addr    += so->lm_info->text_addr - so->lm_info->text_link_addr;
  119.       sec->endaddr += so->lm_info->text_addr - so->lm_info->text_link_addr;
  120.     }
  121.   else if (aflag & SEC_DATA)
  122.     {
  123.       sec->addr    += so->lm_info->data_start;
  124.       sec->endaddr += so->lm_info->data_start;
  125.     }
  126.   else
  127.     {
  128.       /* Nothing.  */
  129.     }
  130. }


  133. /* Variable storing HP-UX major release number.

  135.    On non-native system, simply assume that the major release number
  136.    is 11.  On native systems, hppa-hpux-nat.c initialization code
  137.    sets this number to the real one on startup.

  139.    We cannot compute this value here, because we need to make a native
  140.    call to "uname".  We are are not allowed to do that from here, as
  141.    this file is used for both native and cross debugging.  */

  143. ‌#define DEFAULT_HPUX_MAJOR_RELEASE 11
  144. ‌int hpux_major_release = DEFAULT_HPUX_MAJOR_RELEASE;

  146. static int
  147. ‌get_hpux_major_release (void)
  148. {
  149.   return hpux_major_release;
  150. }

  152. /* DL header flag defines.  */
  153. ‌#define SHLIB_TEXT_PRIVATE_ENABLE 0x4000

  155. /* The DL header is documented in <shl.h>.  We are only interested
  156.    in the flags field to determine whether the executable wants shared
  157.    libraries mapped private.  */
  158. struct {
  159.     short junk[37];
  160.     short flags;
  161. ‌} dl_header;

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

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

  171.    __dld_flags is the location of the magic flags; as of this implementation
  172.    there are 3 flags of interest:

  174.    bit 0 when set indicates that private copies of the libraries are needed
  175.    bit 1 when set indicates that the callback hook routine is valid
  176.    bit 2 when set indicates that the dynamic linker should maintain the
  177.    __dld_list structure when loading/unloading libraries.

  179.    Note that shared libraries are not mapped in at this time, so we have
  180.    run the inferior until the libraries are mapped in.  Typically this
  181.    means running until the "_start" is called.  */

  183. static void
  184. ‌som_solib_create_inferior_hook (int from_tty)
  185. {
  186.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  187.   struct bound_minimal_symbol msymbol;
  188.   unsigned int dld_flags, status, have_endo;
  189.   asection *shlib_info;
  190.   gdb_byte buf[4];
  191.   CORE_ADDR anaddr;

  193.   if (symfile_objfile == NULL)
  194.     return;

  196.   /* First see if the objfile was dynamically linked.  */
  197.   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
  198.   if (!shlib_info)
  199.     return;

  201.   /* It's got a $SHLIB_INFO$ section, make sure it's not empty.  */
  202.   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
  203.     return;

  205.   /* Read the DL header.  */
  206.   bfd_get_section_contents (symfile_objfile->obfd, shlib_info,
  207.                             (char *) &dl_header, 0, sizeof (dl_header));

  209.   have_endo = 0;
  210.   /* Slam the pid of the process into __d_pid.

  212.      We used to warn when this failed, but that warning is only useful
  213.      on very old HP systems (hpux9 and older).  The warnings are an
  214.      annoyance to users of modern systems and foul up the testsuite as
  215.      well.  As a result, the warnings have been disabled.  */
  216.   msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
  217.   if (msymbol.minsym == NULL)
  218.     goto keep_going;

  220.   anaddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
  221.   store_unsigned_integer (buf, 4, byte_order, ptid_get_pid (inferior_ptid));
  222.   status = target_write_memory (anaddr, buf, 4);
  223.   if (status != 0)
  224.     {
  225.       warning (_("\
  226. Unable to write __d_pid.\n\
  227. Suggest linking with /opt/langtools/lib/end.o.\n\
  228. GDB will be unable to track shl_load/shl_unload calls"));
  229.       goto keep_going;
  230.     }

  232.   /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
  233.      This will force the dynamic linker to call __d_trap when significant
  234.      events occur.

  236.      Note that the above is the pre-HP-UX 9.0 behaviour.  At 9.0 and above,
  237.      the dld provides an export stub named "__d_trap" as well as the
  238.      function named "__d_trap" itself, but doesn't provide "_DLD_HOOK".
  239.      We'll look first for the old flavor and then the new.  */

  241.   msymbol = lookup_minimal_symbol ("_DLD_HOOK", NULL, symfile_objfile);
  242.   if (msymbol.minsym == NULL)
  243.     msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
  244.   if (msymbol.minsym == NULL)
  245.     {
  246.       warning (_("\
  247. Unable to find _DLD_HOOK symbol in object file.\n\
  248. Suggest linking with /opt/langtools/lib/end.o.\n\
  249. GDB will be unable to track shl_load/shl_unload calls"));
  250.       goto keep_going;
  251.     }
  252.   anaddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
  253.   dld_cache.hook.address = anaddr;

  255.   /* Grrr, this might not be an export symbol!  We have to find the
  256.      export stub.  */
  257.   msymbol
  258.     = hppa_lookup_stub_minimal_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
  259.                                        EXPORT);
  260.   if (msymbol.minsym != NULL)
  261.     {
  262.       anaddr = MSYMBOL_VALUE (msymbol.minsym);
  263.       dld_cache.hook_stub.address = anaddr;
  264.     }
  265.   store_unsigned_integer (buf, 4, byte_order, anaddr);

  267.   msymbol = lookup_minimal_symbol ("__dld_hook", NULL, symfile_objfile);
  268.   if (msymbol.minsym == NULL)
  269.     {
  270.       warning (_("\
  271. Unable to find __dld_hook symbol in object file.\n\
  272. Suggest linking with /opt/langtools/lib/end.o.\n\
  273. GDB will be unable to track shl_load/shl_unload calls"));
  274.       goto keep_going;
  275.     }
  276.   anaddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
  277.   status = target_write_memory (anaddr, buf, 4);

  279.   /* Now set a shlib_event breakpoint at __d_trap so we can track
  280.      significant shared library events.  */
  281.   msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
  282.   if (msymbol.minsym == NULL)
  283.     {
  284.       warning (_("\
  285. Unable to find __dld_d_trap symbol in object file.\n\
  286. Suggest linking with /opt/langtools/lib/end.o.\n\
  287. GDB will be unable to track shl_load/shl_unload calls"));
  288.       goto keep_going;
  289.     }
  290.   create_solib_event_breakpoint (target_gdbarch (),
  291.                                  BMSYMBOL_VALUE_ADDRESS (msymbol));

  293.   /* We have all the support usually found in end.o, so we can track
  294.      shl_load and shl_unload calls.  */
  295.   have_endo = 1;

  297. keep_going:

  299.   /* Get the address of __dld_flags, if no such symbol exists, then we can
  300.      not debug the shared code.  */
  301.   msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
  302.   if (msymbol.minsym == NULL)
  303.     {
  304.       error (_("Unable to find __dld_flags symbol in object file."));
  305.     }

  307.   anaddr = BMSYMBOL_VALUE_ADDRESS (msymbol);

  309.   /* Read the current contents.  */
  310.   status = target_read_memory (anaddr, buf, 4);
  311.   if (status != 0)
  312.     error (_("Unable to read __dld_flags."));
  313.   dld_flags = extract_unsigned_integer (buf, 4, byte_order);

  315.   /* If the libraries were not mapped private on HP-UX 11 and later, warn
  316.      the user.  On HP-UX 10 and earlier, there is no easy way to specify
  317.      that shared libraries should be privately mapped.  So, we just force
  318.      private mapping.  */
  319.   if (get_hpux_major_release () >= 11
  320.       && (dl_header.flags & SHLIB_TEXT_PRIVATE_ENABLE) == 0
  321.       && (dld_flags & DLD_FLAGS_MAPPRIVATE) == 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.   if (get_hpux_major_release () < 11)
  331.     dld_flags |= DLD_FLAGS_MAPPRIVATE;
  332.   if (have_endo)
  333.     dld_flags |= DLD_FLAGS_HOOKVALID;
  334.   store_unsigned_integer (buf, 4, byte_order, dld_flags);
  335.   status = target_write_memory (anaddr, buf, 4);
  336.   if (status != 0)
  337.     error (_("Unable to write __dld_flags."));

  339.   /* Now find the address of _start and set a breakpoint there.
  340.      We still need this code for two reasons:

  342.      * Not all sites have /opt/langtools/lib/end.o, so it's not always
  343.      possible to track the dynamic linker's events.

  345.      * At this time no events are triggered for shared libraries
  346.      loaded at startup time (what a crock).  */

  348.   msymbol = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
  349.   if (msymbol.minsym == NULL)
  350.     error (_("Unable to find _start symbol in object file."));

  352.   anaddr = BMSYMBOL_VALUE_ADDRESS (msymbol);

  354.   /* Make the breakpoint at "_start" a shared library event breakpoint.  */
  355.   create_solib_event_breakpoint (target_gdbarch (), anaddr);

  357.   clear_symtab_users (0);
  358. }

  360. static void
  361. ‌som_special_symbol_handling (void)
  362. {
  363. }

  365. static void
  366. ‌som_solib_desire_dynamic_linker_symbols (void)
  367. {
  368.   struct objfile *objfile;
  369.   struct unwind_table_entry *u;
  370.   struct bound_minimal_symbol dld_msymbol;

  372.   /* Do we already know the value of these symbols?  If so, then
  373.      we've no work to do.

  375.      (If you add clauses to this test, be sure to likewise update the
  376.      test within the loop.)  */

  378.   if (dld_cache.is_valid)
  379.     return;

  381.   ALL_OBJFILES (objfile)
  382.   {
  383.     dld_msymbol = lookup_minimal_symbol ("shl_load", NULL, objfile);
  384.     if (dld_msymbol.minsym != NULL)
  385.       {
  386.         dld_cache.load.address = MSYMBOL_VALUE (dld_msymbol.minsym);
  387.         dld_cache.load.unwind = find_unwind_entry (dld_cache.load.address);
  388.       }

  390.     dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_load",
  391.                                                           objfile);
  392.     if (dld_msymbol.minsym != NULL)
  393.       {
  394.         if (MSYMBOL_TYPE (dld_msymbol.minsym) == mst_solib_trampoline)
  395.           {
  396.             u = find_unwind_entry (MSYMBOL_VALUE (dld_msymbol.minsym));
  397.             if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
  398.               {
  399.                 dld_cache.load_stub.address
  400.                   = MSYMBOL_VALUE (dld_msymbol.minsym);
  401.                 dld_cache.load_stub.unwind = u;
  402.               }
  403.           }
  404.       }

  406.     dld_msymbol = lookup_minimal_symbol ("shl_unload", NULL, objfile);
  407.     if (dld_msymbol.minsym != NULL)
  408.       {
  409.         dld_cache.unload.address = MSYMBOL_VALUE (dld_msymbol.minsym);
  410.         dld_cache.unload.unwind = find_unwind_entry (dld_cache.unload.address);

  412.         /* ??rehrauer: I'm not sure exactly what this is, but it appears
  413.            that on some HPUX 10.x versions, there's two unwind regions to
  414.            cover the body of "shl_unload", the second being 4 bytes past
  415.            the end of the first.  This is a large hack to handle that
  416.            case, but since I don't seem to have any legitimate way to
  417.            look for this thing via the symbol table...  */

  419.         if (dld_cache.unload.unwind != NULL)
  420.           {
  421.             u = find_unwind_entry (dld_cache.unload.unwind->region_end + 4);
  422.             if (u != NULL)
  423.               {
  424.                 dld_cache.unload2.address = u->region_start;
  425.                 dld_cache.unload2.unwind = u;
  426.               }
  427.           }
  428.       }

  430.     dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_unload",
  431.                                                           objfile);
  432.     if (dld_msymbol.minsym != NULL)
  433.       {
  434.         if (MSYMBOL_TYPE (dld_msymbol.minsym) == mst_solib_trampoline)
  435.           {
  436.             u = find_unwind_entry (MSYMBOL_VALUE (dld_msymbol.minsym));
  437.             if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
  438.               {
  439.                 dld_cache.unload_stub.address
  440.                   = MSYMBOL_VALUE (dld_msymbol.minsym);
  441.                 dld_cache.unload_stub.unwind = u;
  442.               }
  443.           }
  444.       }

  446.     /* Did we find everything we were looking for?  If so, stop.  */
  447.     if ((dld_cache.load.address != 0)
  448.         && (dld_cache.load_stub.address != 0)
  449.         && (dld_cache.unload.address != 0)
  450.         && (dld_cache.unload_stub.address != 0))
  451.       {
  452.         dld_cache.is_valid = 1;
  453.         break;
  454.       }
  455.   }

  457.   dld_cache.hook.unwind = find_unwind_entry (dld_cache.hook.address);
  458.   dld_cache.hook_stub.unwind = find_unwind_entry (dld_cache.hook_stub.address);

  460.   /* We're prepared not to find some of these symbols, which is why
  461.      this function is a "desire" operation, and not a "require".  */
  462. }

  464. static int
  465. ‌som_in_dynsym_resolve_code (CORE_ADDR pc)
  466. {
  467.   struct unwind_table_entry *u_pc;

  469.   /* Are we in the dld itself?

  471.      ??rehrauer: Large hack -- We'll assume that any address in a
  472.      shared text region is the dld's text.  This would obviously
  473.      fall down if the user attached to a process, whose shlibs
  474.      weren't mapped to a (writeable) private region.  However, in
  475.      that case the debugger probably isn't able to set the fundamental
  476.      breakpoint in the dld callback anyways, so this hack should be
  477.      safe.  */

  479.   if ((pc & (CORE_ADDR) 0xc0000000) == (CORE_ADDR) 0xc0000000)
  480.     return 1;

  482.   /* Cache the address of some symbols that are part of the dynamic
  483.      linker, if not already known.  */

  485.   som_solib_desire_dynamic_linker_symbols ();

  487.   /* Are we in the dld callback?  Or its export stub?  */
  488.   u_pc = find_unwind_entry (pc);
  489.   if (u_pc == NULL)
  490.     return 0;

  492.   if ((u_pc == dld_cache.hook.unwind) || (u_pc == dld_cache.hook_stub.unwind))
  493.     return 1;

  495.   /* Or the interface of the dld (i.e., "shl_load" or friends)?  */
  496.   if ((u_pc == dld_cache.load.unwind)
  497.       || (u_pc == dld_cache.unload.unwind)
  498.       || (u_pc == dld_cache.unload2.unwind)
  499.       || (u_pc == dld_cache.load_stub.unwind)
  500.       || (u_pc == dld_cache.unload_stub.unwind))
  501.     return 1;

  503.   /* Apparently this address isn't part of the dld's text.  */
  504.   return 0;
  505. }

  507. static void
  508. ‌som_clear_solib (void)
  509. {
  510. }

  512. ‌struct dld_list {
  513.   char name[4];
  514.   char info[4];
  515.   char text_addr[4];
  516.   char text_link_addr[4];
  517.   char text_end[4];
  518.   char data_start[4];
  519.   char bss_start[4];
  520.   char data_end[4];
  521.   char got_value[4];
  522.   char next[4];
  523.   char tsd_start_addr_ptr[4];
  524. };

  526. static CORE_ADDR
  527. ‌link_map_start (void)
  528. {
  529.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  530.   struct bound_minimal_symbol sym;
  531.   CORE_ADDR addr;
  532.   gdb_byte buf[4];
  533.   unsigned int dld_flags;

  535.   sym = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
  536.   if (!sym.minsym)
  537.     error (_("Unable to find __dld_flags symbol in object file."));
  538.   addr = BMSYMBOL_VALUE_ADDRESS (sym);
  539.   read_memory (addr, buf, 4);
  540.   dld_flags = extract_unsigned_integer (buf, 4, byte_order);
  541.   if ((dld_flags & DLD_FLAGS_LISTVALID) == 0)
  542.     error (_("__dld_list is not valid according to __dld_flags."));

  544.   sym = lookup_minimal_symbol ("__dld_list", NULL, NULL);
  545.   if (!sym.minsym)
  546.     {
  547.       /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
  548.          but the data is still available if you know where to look.  */
  549.       sym = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
  550.       if (!sym.minsym)
  551.         {
  552.           error (_("Unable to find dynamic library list."));
  553.           return 0;
  554.         }
  555.       addr = BMSYMBOL_VALUE_ADDRESS (sym) - 8;
  556.     }
  557.   else
  558.     addr = BMSYMBOL_VALUE_ADDRESS (sym);

  560.   read_memory (addr, buf, 4);
  561.   addr = extract_unsigned_integer (buf, 4, byte_order);
  562.   if (addr == 0)
  563.     return 0;

  565.   read_memory (addr, buf, 4);
  566.   return extract_unsigned_integer (buf, 4, byte_order);
  567. }

  569. /* Does this so's name match the main binary?  */
  570. static int
  571. ‌match_main (const char *name)
  572. {
  573.   return strcmp (name, objfile_name (symfile_objfile)) == 0;
  574. }

  576. static struct so_list *
  577. ‌som_current_sos (void)
  578. {
  579.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  580.   CORE_ADDR lm;
  581.   struct so_list *head = 0;
  582.   struct so_list **link_ptr = &head;

  584.   for (lm = link_map_start (); lm; )
  585.     {
  586.       char *namebuf;
  587.       CORE_ADDR addr;
  588.       struct so_list *new;
  589.       struct cleanup *old_chain;
  590.       int errcode;
  591.       struct dld_list dbuf;
  592.       gdb_byte tsdbuf[4];

  594.       new = (struct so_list *) xmalloc (sizeof (struct so_list));
  595.       old_chain = make_cleanup (xfree, new);

  597.       memset (new, 0, sizeof (*new));
  598.       new->lm_info = xmalloc (sizeof (struct lm_info));
  599.       make_cleanup (xfree, new->lm_info);

  601.       read_memory (lm, (gdb_byte *)&dbuf, sizeof (struct dld_list));

  603.       addr = extract_unsigned_integer ((gdb_byte *)&dbuf.name,
  604.                                        sizeof (dbuf.name), byte_order);
  605.       target_read_string (addr, &namebuf, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
  606.       if (errcode != 0)
  607.         warning (_("Can't read pathname for load map: %s."),
  608.                  safe_strerror (errcode));
  609.       else
  610.         {
  611.           strncpy (new->so_name, namebuf, SO_NAME_MAX_PATH_SIZE - 1);
  612.           new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
  613.           xfree (namebuf);
  614.           strcpy (new->so_original_name, new->so_name);
  615.         }

  617.         if (new->so_name[0] && !match_main (new->so_name))
  618.           {
  619.             struct lm_info *lmi = new->lm_info;
  620.             unsigned int tmp;

  622.             lmi->lm_addr = lm;

  624. ‌#define EXTRACT(_fld) \
  625.   extract_unsigned_integer ((gdb_byte *)&dbuf._fld, \
  626.                             sizeof (dbuf._fld), byte_order);

  628.             lmi->text_addr = EXTRACT (text_addr);
  629.             tmp = EXTRACT (info);
  630.             lmi->library_version = (tmp >> 16) & 0xffff;
  631.             lmi->bind_mode = (tmp >> 8) & 0xff;
  632.             lmi->struct_version = tmp & 0xff;
  633.             lmi->text_link_addr = EXTRACT (text_link_addr);
  634.             lmi->text_end = EXTRACT (text_end);
  635.             lmi->data_start = EXTRACT (data_start);
  636.             lmi->bss_start = EXTRACT (bss_start);
  637.             lmi->data_end = EXTRACT (data_end);
  638.             lmi->got_value = EXTRACT (got_value);
  639.             tmp = EXTRACT (tsd_start_addr_ptr);
  640.             read_memory (tmp, tsdbuf, 4);
  641.             lmi->tsd_start_addr
  642.               = extract_unsigned_integer (tsdbuf, 4, byte_order);

  644. #ifdef SOLIB_SOM_DBG
  645.             printf ("\n+ library \"%s\" is described at %s\n", new->so_name,
  646.                         paddress (target_gdbarch (), lm));
  647.             printf ("  'version' is %d\n", new->lm_info->struct_version);
  648.             printf ("  'bind_mode' is %d\n", new->lm_info->bind_mode);
  649.             printf ("  'library_version' is %d\n",
  650.                         new->lm_info->library_version);
  651.             printf ("  'text_addr' is %s\n",
  652.                         paddress (target_gdbarch (), new->lm_info->text_addr));
  653.             printf ("  'text_link_addr' is %s\n",
  654.                         paddress (target_gdbarch (), new->lm_info->text_link_addr));
  655.             printf ("  'text_end' is %s\n",
  656.                         paddress (target_gdbarch (), new->lm_info->text_end));
  657.             printf ("  'data_start' is %s\n",
  658.                         paddress (target_gdbarch (), new->lm_info->data_start));
  659.             printf ("  'bss_start' is %s\n",
  660.                         paddress (target_gdbarch (), new->lm_info->bss_start));
  661.             printf ("  'data_end' is %s\n",
  662.                         paddress (target_gdbarch (), new->lm_info->data_end));
  663.             printf ("  'got_value' is %s\n",
  664.                         paddress (target_gdbarch (), new->lm_info->got_value));
  665.             printf ("  'tsd_start_addr' is %s\n",
  666.                         paddress (target_gdbarch (), new->lm_info->tsd_start_addr));
  667. #endif

  669.             new->addr_low = lmi->text_addr;
  670.             new->addr_high = lmi->text_end;

  672.             /* Link the new object onto the list.  */
  673.             new->next = NULL;
  674.             *link_ptr = new;
  675.             link_ptr = &new->next;
  676.           }
  677.          else
  678.           {
  679.             free_so (new);
  680.           }

  682.       lm = EXTRACT (next);
  683.       discard_cleanups (old_chain);
  684. ‌#undef EXTRACT
  685.     }

  687.   /* TODO: The original somsolib code has logic to detect and eliminate
  688.      duplicate entries.  Do we need that?  */

  690.   return head;
  691. }

  693. static int
  694. ‌som_open_symbol_file_object (void *from_ttyp)
  695. {
  696.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  697.   CORE_ADDR lm, l_name;
  698.   char *filename;
  699.   int errcode;
  700.   int from_tty = *(int *)from_ttyp;
  701.   gdb_byte buf[4];
  702.   struct cleanup *cleanup;

  704.   if (symfile_objfile)
  705.     if (!query (_("Attempt to reload symbols from process? ")))
  706.       return 0;

  708.   /* First link map member should be the executable.  */
  709.   if ((lm = link_map_start ()) == 0)
  710.     return 0;        /* failed somehow...  */

  712.   /* Read address of name from target memory to GDB.  */
  713.   read_memory (lm + offsetof (struct dld_list, name), buf, 4);

  715.   /* Convert the address to host format.  Assume that the address is
  716.      unsigned.  */
  717.   l_name = extract_unsigned_integer (buf, 4, byte_order);

  719.   if (l_name == 0)
  720.     return 0;                /* No filename.  */

  722.   /* Now fetch the filename from target memory.  */
  723.   target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);

  725.   if (errcode)
  726.     {
  727.       warning (_("failed to read exec filename from attached file: %s"),
  728.                safe_strerror (errcode));
  729.       return 0;
  730.     }

  732.   cleanup = make_cleanup (xfree, filename);
  733.   /* Have a pathname: read the symbol file.  */
  734.   symbol_file_add_main (filename, from_tty);

  736.   do_cleanups (cleanup);
  737.   return 1;
  738. }

  740. static void
  741. ‌som_free_so (struct so_list *so)
  742. {
  743.   xfree (so->lm_info);
  744. }

  746. static CORE_ADDR
  747. ‌som_solib_thread_start_addr (struct so_list *so)
  748. {
  749.   return so->lm_info->tsd_start_addr;
  750. }

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

  755. static CORE_ADDR
  756. ‌som_solib_get_got_by_pc (CORE_ADDR addr)
  757. {
  758.   struct so_list *so_list = master_so_list ();
  759.   CORE_ADDR got_value = 0;

  761.   while (so_list)
  762.     {
  763.       if (so_list->lm_info->text_addr <= addr
  764.           && so_list->lm_info->text_end > addr)
  765.         {
  766.           got_value = so_list->lm_info->got_value;
  767.           break;
  768.         }
  769.       so_list = so_list->next;
  770.     }
  771.   return got_value;
  772. }

  774. /* Return the address of the handle of the shared library in which
  775.    ADDR belongs.  If ADDR isn't in any known shared library, return
  776.    zero.  */
  777. /* This function is used in initialize_hp_cxx_exception_support in
  778.    hppa-hpux-tdep.c.  */

  780. static CORE_ADDR
  781. ‌som_solib_get_solib_by_pc (CORE_ADDR addr)
  782. {
  783.   struct so_list *so_list = master_so_list ();

  785.   while (so_list)
  786.     {
  787.       if (so_list->lm_info->text_addr <= addr
  788.           && so_list->lm_info->text_end > addr)
  789.         {
  790.           break;
  791.         }
  792.       so_list = so_list->next;
  793.     }
  794.   if (so_list)
  795.     return so_list->lm_info->lm_addr;
  796.   else
  797.     return 0;
  798. }


  801. ‌static struct target_so_ops som_so_ops;

  803. extern initialize_file_ftype _initialize_som_solib; /* -Wmissing-prototypes */

  805. void
  806. ‌_initialize_som_solib (void)
  807. {
  808.   som_so_ops.relocate_section_addresses = som_relocate_section_addresses;
  809.   som_so_ops.free_so = som_free_so;
  810.   som_so_ops.clear_solib = som_clear_solib;
  811.   som_so_ops.solib_create_inferior_hook = som_solib_create_inferior_hook;
  812.   som_so_ops.special_symbol_handling = som_special_symbol_handling;
  813.   som_so_ops.current_sos = som_current_sos;
  814.   som_so_ops.open_symbol_file_object = som_open_symbol_file_object;
  815.   som_so_ops.in_dynsym_resolve_code = som_in_dynsym_resolve_code;
  816.   som_so_ops.bfd_open = solib_bfd_open;
  817. }

  819. void
  820. ‌som_solib_select (struct gdbarch *gdbarch)
  821. {
  822.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  824.   set_solib_ops (gdbarch, &som_so_ops);
  825.   tdep->solib_thread_start_addr = som_solib_thread_start_addr;
  826.   tdep->solib_get_got_by_pc = som_solib_get_got_by_pc;
  827.   tdep->solib_get_solib_by_pc = som_solib_get_solib_by_pc;
  828. }

  830. /* The rest of these functions are not part of the solib interface; they
  831.    are used by somread.c or hppa-hpux-tdep.c.  */

  833. int
  834. ‌som_solib_section_offsets (struct objfile *objfile,
  835.                            struct section_offsets *offsets)
  836. {
  837.   struct so_list *so_list = master_so_list ();

  839.   while (so_list)
  840.     {
  841.       /* Oh what a pain!  We need the offsets before so_list->objfile
  842.          is valid.  The BFDs will never match.  Make a best guess.  */
  843.       if (strstr (objfile_name (objfile), so_list->so_name))
  844.         {
  845.           asection *private_section;
  846.           struct obj_section *sect;

  848.           /* The text offset is easy.  */
  849.           offsets->offsets[SECT_OFF_TEXT (objfile)]
  850.             = (so_list->lm_info->text_addr
  851.                - so_list->lm_info->text_link_addr);

  853.           /* We should look at presumed_dp in the SOM header, but
  854.              that's not easily available.  This should be OK though.  */
  855.           private_section = bfd_get_section_by_name (objfile->obfd,
  856.                                                      "$PRIVATE$");
  857.           if (!private_section)
  858.             {
  859.               warning (_("Unable to find $PRIVATE$ in shared library!"));
  860.               offsets->offsets[SECT_OFF_DATA (objfile)] = 0;
  861.               offsets->offsets[SECT_OFF_BSS (objfile)] = 0;
  862.               return 1;
  863.             }
  864.           if (objfile->sect_index_data != -1)
  865.             {
  866.               offsets->offsets[SECT_OFF_DATA (objfile)]
  867.                 = (so_list->lm_info->data_start - private_section->vma);
  868.               if (objfile->sect_index_bss != -1)
  869.                 offsets->offsets[SECT_OFF_BSS (objfile)]
  870.                   = ANOFFSET (offsets, SECT_OFF_DATA (objfile));
  871.             }

  873.           ALL_OBJFILE_OSECTIONS (objfile, sect)
  874.             {
  875.               flagword flags = bfd_get_section_flags (objfile->obfd,
  876.                                                       sect->the_bfd_section);

  878.               if ((flags & SEC_CODE) != 0)
  879.                 offsets->offsets[sect->the_bfd_section->index]
  880.                   = offsets->offsets[SECT_OFF_TEXT (objfile)];
  881.               else
  882.                 offsets->offsets[sect->the_bfd_section->index]
  883.                   = offsets->offsets[SECT_OFF_DATA (objfile)];
  884.             }

  886.           return 1;
  887.         }
  888.       so_list = so_list->next;
  889.     }
  890.   return 0;
  891. }