gdb/solib-som.c

   1 /* Handle SOM shared libraries.
   2
   3    Copyright (C) 2004, 2005, 2007, 2008, 2009 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 #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"
  28
  29 #include "hppa-tdep.h"
  30 #include "solist.h"
  31 #include "solib.h"
  32 #include "solib-som.h"
  33
  34 #include <sys/utsname.h>
  35 #include <string.h>
  36
  37 #undef SOLIB_SOM_DBG
  38
  39 /* These ought to be defined in some public interface, but aren't.  They
  40    define the meaning of the various bits in the distinguished __dld_flags
  41    variable that is declared in every debuggable a.out on HP-UX, and that
  42    is shared between the debugger and the dynamic linker.
  43  */
  44 #define DLD_FLAGS_MAPPRIVATE    0x1
  45 #define DLD_FLAGS_HOOKVALID     0x2
  46 #define DLD_FLAGS_LISTVALID     0x4
  47 #define DLD_FLAGS_BOR_ENABLE    0x8
  48
  49 struct lm_info
  50   {
  51     /* Version of this structure (it is expected to change again in hpux10).  */
  52     unsigned char struct_version;
  53
  54     /* Binding mode for this library.  */
  55     unsigned char bind_mode;
  56
  57     /* Version of this library.  */
  58     short library_version;
  59
  60     /* Start of text address,
  61        link-time text location (length of text area),
  62        end of text address.  */
  63     CORE_ADDR text_addr;
  64     CORE_ADDR text_link_addr;
  65     CORE_ADDR text_end;
  66
  67     /* Start of data, start of bss and end of data.  */
  68     CORE_ADDR data_start;
  69     CORE_ADDR bss_start;
  70     CORE_ADDR data_end;
  71
  72     /* Value of linkage pointer (%r19).  */
  73     CORE_ADDR got_value;
  74
  75     /* Address in target of offset from thread-local register of
  76        start of this thread's data.  I.e., the first thread-local
  77        variable in this shared library starts at *(tsd_start_addr)
  78        from that area pointed to by cr27 (mpsfu_hi).
  79
  80        We do the indirection as soon as we read it, so from then
  81        on it's the offset itself.  */
  82     CORE_ADDR tsd_start_addr;
  83
  84     /* Address of the link map entry in the loader.  */
  85     CORE_ADDR lm_addr;
  86   };
  87
  88 /* These addresses should be filled in by som_solib_create_inferior_hook.
  89    They are also used elsewhere in this module.
  90  */
  91 typedef struct
  92   {
  93     CORE_ADDR address;
  94     struct unwind_table_entry *unwind;
  95   }
  96 addr_and_unwind_t;
  97
  98 /* When adding fields, be sure to clear them in _initialize_som_solib. */
  99 static struct
 100   {
 101     int is_valid;
 102     addr_and_unwind_t hook;
 103     addr_and_unwind_t hook_stub;
 104     addr_and_unwind_t load;
 105     addr_and_unwind_t load_stub;
 106     addr_and_unwind_t unload;
 107     addr_and_unwind_t unload2;
 108     addr_and_unwind_t unload_stub;
 109   }
 110 dld_cache;
 111
 112 static void
 113 som_relocate_section_addresses (struct so_list *so,
 114                                 struct target_section *sec)
 115 {
 116   flagword aflag = bfd_get_section_flags(so->abfd, sec->the_bfd_section);
 117
 118   if (aflag & SEC_CODE)
 119     {
 120       sec->addr    += so->lm_info->text_addr - so->lm_info->text_link_addr;
 121       sec->endaddr += so->lm_info->text_addr - so->lm_info->text_link_addr;
 122     }
 123   else if (aflag & SEC_DATA)
 124     {
 125       sec->addr    += so->lm_info->data_start;
 126       sec->endaddr += so->lm_info->data_start;
 127     }
 128   else
 129     ;
 130 }
 131
 132 /* Get HP-UX major release number.  Returns zero if the
 133    release is not known.  */
 134
 135 static int
 136 get_hpux_major_release (void)
 137 {
 138   static int hpux_major_release = -1;
 139
 140   if (hpux_major_release == -1)
 141     {
 142       struct utsname x;
 143       char *p;
 144
 145       uname (&x);
 146       p = strchr (x.release, '.');
 147       hpux_major_release = p ? atoi (p + 1) : 0;
 148     }
 149
 150   return hpux_major_release;
 151 }
 152
 153 /* DL header flag defines.  */
 154 #define SHLIB_TEXT_PRIVATE_ENABLE 0x4000
 155
 156 /* The DL header is documented in <shl.h>.  We are only interested
 157    in the flags field to determine whether the executable wants shared
 158    libraries mapped private.  */
 159 struct {
 160     short junk[37];
 161     short flags;
 162 } dl_header;
 163
 164 /* This hook gets called just before the first instruction in the
 165    inferior process is executed.
 166
 167    This is our opportunity to set magic flags in the inferior so
 168    that GDB can be notified when a shared library is mapped in and
 169    to tell the dynamic linker that a private copy of the library is
 170    needed (so GDB can set breakpoints in the library).
 171
 172    __dld_flags is the location of the magic flags; as of this implementation
 173    there are 3 flags of interest:
 174
 175    bit 0 when set indicates that private copies of the libraries are needed
 176    bit 1 when set indicates that the callback hook routine is valid
 177    bit 2 when set indicates that the dynamic linker should maintain the
 178    __dld_list structure when loading/unloading libraries.
 179
 180    Note that shared libraries are not mapped in at this time, so we have
 181    run the inferior until the libraries are mapped in.  Typically this
 182    means running until the "_start" is called.  */
 183
 184 static void
 185 som_solib_create_inferior_hook (void)
 186 {
 187   struct minimal_symbol *msymbol;
 188   unsigned int dld_flags, status, have_endo;
 189   asection *shlib_info;
 190   char buf[4];
 191   CORE_ADDR anaddr;
 192
 193   /* First, remove all the solib event breakpoints.  Their addresses
 194      may have changed since the last time we ran the program.  */
 195   remove_solib_event_breakpoints ();
 196
 197   if (symfile_objfile == NULL)
 198     return;
 199
 200   /* First see if the objfile was dynamically linked.  */
 201   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
 202   if (!shlib_info)
 203     return;
 204
 205   /* It's got a $SHLIB_INFO$ section, make sure it's not empty.  */
 206   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
 207     return;
 208
 209   /* Read the DL header.  */
 210   bfd_get_section_contents (symfile_objfile->obfd, shlib_info,
 211                             (char *) &dl_header, 0, sizeof (dl_header));
 212
 213   have_endo = 0;
 214   /* Slam the pid of the process into __d_pid.
 215
 216      We used to warn when this failed, but that warning is only useful
 217      on very old HP systems (hpux9 and older).  The warnings are an
 218      annoyance to users of modern systems and foul up the testsuite as
 219      well.  As a result, the warnings have been disabled.  */
 220   msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
 221   if (msymbol == NULL)
 222     goto keep_going;
 223
 224   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
 225   store_unsigned_integer (buf, 4, PIDGET (inferior_ptid));
 226   status = target_write_memory (anaddr, buf, 4);
 227   if (status != 0)
 228     {
 229       warning (_("\
 230 Unable to write __d_pid.\n\
 231 Suggest linking with /opt/langtools/lib/end.o.\n\
 232 GDB will be unable to track shl_load/shl_unload calls"));
 233       goto keep_going;
 234     }
 235
 236   /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
 237      This will force the dynamic linker to call __d_trap when significant
 238      events occur.
 239
 240      Note that the above is the pre-HP-UX 9.0 behaviour.  At 9.0 and above,
 241      the dld provides an export stub named "__d_trap" as well as the
 242      function named "__d_trap" itself, but doesn't provide "_DLD_HOOK".
 243      We'll look first for the old flavor and then the new.
 244    */
 245   msymbol = lookup_minimal_symbol ("_DLD_HOOK", NULL, symfile_objfile);
 246   if (msymbol == NULL)
 247     msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
 248   if (msymbol == NULL)
 249     {
 250       warning (_("\
 251 Unable to find _DLD_HOOK symbol in object file.\n\
 252 Suggest linking with /opt/langtools/lib/end.o.\n\
 253 GDB will be unable to track shl_load/shl_unload calls"));
 254       goto keep_going;
 255     }
 256   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
 257   dld_cache.hook.address = anaddr;
 258
 259   /* Grrr, this might not be an export symbol!  We have to find the
 260      export stub.  */
 261   msymbol = hppa_lookup_stub_minimal_symbol (SYMBOL_LINKAGE_NAME (msymbol),
 262                                              EXPORT);
 263   if (msymbol != NULL)
 264     {
 265       anaddr = SYMBOL_VALUE (msymbol);
 266       dld_cache.hook_stub.address = anaddr;
 267     }
 268   store_unsigned_integer (buf, 4, anaddr);
 269
 270   msymbol = lookup_minimal_symbol ("__dld_hook", NULL, symfile_objfile);
 271   if (msymbol == NULL)
 272     {
 273       warning (_("\
 274 Unable to find __dld_hook symbol in object file.\n\
 275 Suggest linking with /opt/langtools/lib/end.o.\n\
 276 GDB will be unable to track shl_load/shl_unload calls"));
 277       goto keep_going;
 278     }
 279   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
 280   status = target_write_memory (anaddr, buf, 4);
 281
 282   /* Now set a shlib_event breakpoint at __d_trap so we can track
 283      significant shared library events.  */
 284   msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
 285   if (msymbol == NULL)
 286     {
 287       warning (_("\
 288 Unable to find __dld_d_trap symbol in object file.\n\
 289 Suggest linking with /opt/langtools/lib/end.o.\n\
 290 GDB will be unable to track shl_load/shl_unload calls"));
 291       goto keep_going;
 292     }
 293   create_solib_event_breakpoint (target_gdbarch,
 294                                  SYMBOL_VALUE_ADDRESS (msymbol));
 295
 296   /* We have all the support usually found in end.o, so we can track
 297      shl_load and shl_unload calls.  */
 298   have_endo = 1;
 299
 300 keep_going:
 301
 302   /* Get the address of __dld_flags, if no such symbol exists, then we can
 303      not debug the shared code.  */
 304   msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
 305   if (msymbol == NULL)
 306     {
 307       error (_("Unable to find __dld_flags symbol in object file."));
 308     }
 309
 310   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
 311
 312   /* Read the current contents.  */
 313   status = target_read_memory (anaddr, buf, 4);
 314   if (status != 0)
 315     error (_("Unable to read __dld_flags."));
 316   dld_flags = extract_unsigned_integer (buf, 4);
 317
 318   /* If the libraries were not mapped private on HP-UX 11 and later, warn
 319      the user.  On HP-UX 10 and earlier, there is no easy way to specify
 320      that shared libraries should be privately mapped.  So, we just force
 321      private mapping.  */
 322   if (get_hpux_major_release () >= 11
 323       && (dl_header.flags & SHLIB_TEXT_PRIVATE_ENABLE) == 0
 324       && (dld_flags & DLD_FLAGS_MAPPRIVATE) == 0)
 325     warning
 326       (_("Private mapping of shared library text was not specified\n"
 327          "by the executable; setting a breakpoint in a shared library which\n"
 328          "is not privately mapped will not work.  See the HP-UX 11i v3 chatr\n"
 329          "manpage for methods to privately map shared library text."));
 330
 331   /* Turn on the flags we care about.  */
 332   if (get_hpux_major_release () < 11)
 333     dld_flags |= DLD_FLAGS_MAPPRIVATE;
 334   if (have_endo)
 335     dld_flags |= DLD_FLAGS_HOOKVALID;
 336   store_unsigned_integer (buf, 4, dld_flags);
 337   status = target_write_memory (anaddr, buf, 4);
 338   if (status != 0)
 339     error (_("Unable to write __dld_flags."));
 340
 341   /* Now find the address of _start and set a breakpoint there.
 342      We still need this code for two reasons:
 343
 344      * Not all sites have /opt/langtools/lib/end.o, so it's not always
 345      possible to track the dynamic linker's events.
 346
 347      * At this time no events are triggered for shared libraries
 348      loaded at startup time (what a crock).  */
 349
 350   msymbol = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
 351   if (msymbol == NULL)
 352     error (_("Unable to find _start symbol in object file."));
 353
 354   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
 355
 356   /* Make the breakpoint at "_start" a shared library event breakpoint.  */
 357   create_solib_event_breakpoint (target_gdbarch, anaddr);
 358
 359   clear_symtab_users ();
 360 }
 361
 362 static void
 363 som_special_symbol_handling (void)
 364 {
 365 }
 366
 367 static void
 368 som_solib_desire_dynamic_linker_symbols (void)
 369 {
 370   struct objfile *objfile;
 371   struct unwind_table_entry *u;
 372   struct minimal_symbol *dld_msymbol;
 373
 374   /* Do we already know the value of these symbols?  If so, then
 375      we've no work to do.
 376
 377      (If you add clauses to this test, be sure to likewise update the
 378      test within the loop.)
 379    */
 380   if (dld_cache.is_valid)
 381     return;
 382
 383   ALL_OBJFILES (objfile)
 384   {
 385     dld_msymbol = lookup_minimal_symbol ("shl_load", NULL, objfile);
 386     if (dld_msymbol != NULL)
 387       {
 388         dld_cache.load.address = SYMBOL_VALUE (dld_msymbol);
 389         dld_cache.load.unwind = find_unwind_entry (dld_cache.load.address);
 390       }
 391
 392     dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_load",
 393                                                           objfile);
 394     if (dld_msymbol != NULL)
 395       {
 396         if (MSYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
 397           {
 398             u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
 399             if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
 400               {
 401                 dld_cache.load_stub.address = SYMBOL_VALUE (dld_msymbol);
 402                 dld_cache.load_stub.unwind = u;
 403               }
 404           }
 405       }
 406
 407     dld_msymbol = lookup_minimal_symbol ("shl_unload", NULL, objfile);
 408     if (dld_msymbol != NULL)
 409       {
 410         dld_cache.unload.address = SYMBOL_VALUE (dld_msymbol);
 411         dld_cache.unload.unwind = find_unwind_entry (dld_cache.unload.address);
 412
 413         /* ??rehrauer: I'm not sure exactly what this is, but it appears
 414            that on some HPUX 10.x versions, there's two unwind regions to
 415            cover the body of "shl_unload", the second being 4 bytes past
 416            the end of the first.  This is a large hack to handle that
 417            case, but since I don't seem to have any legitimate way to
 418            look for this thing via the symbol table...
 419          */
 420         if (dld_cache.unload.unwind != NULL)
 421           {
 422             u = find_unwind_entry (dld_cache.unload.unwind->region_end + 4);
 423             if (u != NULL)
 424               {
 425                 dld_cache.unload2.address = u->region_start;
 426                 dld_cache.unload2.unwind = u;
 427               }
 428           }
 429       }
 430
 431     dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_unload",
 432                                                           objfile);
 433     if (dld_msymbol != NULL)
 434       {
 435         if (MSYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
 436           {
 437             u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
 438             if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
 439               {
 440                 dld_cache.unload_stub.address = SYMBOL_VALUE (dld_msymbol);
 441                 dld_cache.unload_stub.unwind = u;
 442               }
 443           }
 444       }
 445
 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   }
 456
 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);
 459
 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    */
 463 }
 464
 465 static int
 466 som_in_dynsym_resolve_code (CORE_ADDR pc)
 467 {
 468   struct unwind_table_entry *u_pc;
 469
 470   /* Are we in the dld itself?
 471
 472      ??rehrauer: Large hack -- We'll assume that any address in a
 473      shared text region is the dld's text.  This would obviously
 474      fall down if the user attached to a process, whose shlibs
 475      weren't mapped to a (writeable) private region.  However, in
 476      that case the debugger probably isn't able to set the fundamental
 477      breakpoint in the dld callback anyways, so this hack should be
 478      safe.
 479    */
 480   if ((pc & (CORE_ADDR) 0xc0000000) == (CORE_ADDR) 0xc0000000)
 481     return 1;
 482
 483   /* Cache the address of some symbols that are part of the dynamic
 484      linker, if not already known.
 485    */
 486   som_solib_desire_dynamic_linker_symbols ();
 487
 488   /* Are we in the dld callback?  Or its export stub? */
 489   u_pc = find_unwind_entry (pc);
 490   if (u_pc == NULL)
 491     return 0;
 492
 493   if ((u_pc == dld_cache.hook.unwind) || (u_pc == dld_cache.hook_stub.unwind))
 494     return 1;
 495
 496   /* Or the interface of the dld (i.e., "shl_load" or friends)? */
 497   if ((u_pc == dld_cache.load.unwind)
 498       || (u_pc == dld_cache.unload.unwind)
 499       || (u_pc == dld_cache.unload2.unwind)
 500       || (u_pc == dld_cache.load_stub.unwind)
 501       || (u_pc == dld_cache.unload_stub.unwind))
 502     return 1;
 503
 504   /* Apparently this address isn't part of the dld's text. */
 505   return 0;
 506 }
 507
 508 static void
 509 som_clear_solib (void)
 510 {
 511 }
 512
 513 struct dld_list {
 514   char name[4];
 515   char info[4];
 516   char text_addr[4];
 517   char text_link_addr[4];
 518   char text_end[4];
 519   char data_start[4];
 520   char bss_start[4];
 521   char data_end[4];
 522   char got_value[4];
 523   char next[4];
 524   char tsd_start_addr_ptr[4];
 525 };
 526
 527 static CORE_ADDR
 528 link_map_start (void)
 529 {
 530   struct minimal_symbol *sym;
 531   CORE_ADDR addr;
 532   char buf[4];
 533   unsigned int dld_flags;
 534
 535   sym = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
 536   if (!sym)
 537     error (_("Unable to find __dld_flags symbol in object file."));
 538   addr = SYMBOL_VALUE_ADDRESS (sym);
 539   read_memory (addr, buf, 4);
 540   dld_flags = extract_unsigned_integer (buf, 4);
 541   if ((dld_flags & DLD_FLAGS_LISTVALID) == 0)
 542     error (_("__dld_list is not valid according to __dld_flags."));
 543
 544   sym = lookup_minimal_symbol ("__dld_list", NULL, NULL);
 545   if (!sym)
 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)
 551         {
 552           error (_("Unable to find dynamic library list."));
 553           return 0;
 554         }
 555       addr = SYMBOL_VALUE_ADDRESS (sym) - 8;
 556     }
 557   else
 558     addr = SYMBOL_VALUE_ADDRESS (sym);
 559
 560   read_memory (addr, buf, 4);
 561   addr = extract_unsigned_integer (buf, 4);
 562   if (addr == 0)
 563     return 0;
 564
 565   read_memory (addr, buf, 4);
 566   return extract_unsigned_integer (buf, 4);
 567 }
 568
 569 /* Does this so's name match the main binary? */
 570 static int
 571 match_main (const char *name)
 572 {
 573   return strcmp (name, symfile_objfile->name) == 0;
 574 }
 575
 576 static struct so_list *
 577 som_current_sos (void)
 578 {
 579   CORE_ADDR lm;
 580   struct so_list *head = 0;
 581   struct so_list **link_ptr = &head;
 582
 583   for (lm = link_map_start (); lm; )
 584     {
 585       char *namebuf;
 586       CORE_ADDR addr;
 587       struct so_list *new;
 588       struct cleanup *old_chain;
 589       int errcode;
 590       struct dld_list dbuf;
 591       char tsdbuf[4];
 592
 593       new = (struct so_list *) xmalloc (sizeof (struct so_list));
 594       old_chain = make_cleanup (xfree, new);
 595
 596       memset (new, 0, sizeof (*new));
 597       new->lm_info = xmalloc (sizeof (struct lm_info));
 598       make_cleanup (xfree, new->lm_info);
 599
 600       read_memory (lm, (gdb_byte *)&dbuf, sizeof (struct dld_list));
 601
 602       addr = extract_unsigned_integer ((gdb_byte *)&dbuf.name,
 603                                        sizeof (dbuf.name));
 604       target_read_string (addr, &namebuf, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
 605       if (errcode != 0)
 606         warning (_("Can't read pathname for load map: %s."),
 607                  safe_strerror (errcode));
 608       else
 609         {
 610           strncpy (new->so_name, namebuf, SO_NAME_MAX_PATH_SIZE - 1);
 611           new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
 612           xfree (namebuf);
 613           strcpy (new->so_original_name, new->so_name);
 614         }
 615
 616         if (new->so_name[0] && !match_main (new->so_name))
 617           {
 618             struct lm_info *lmi = new->lm_info;
 619             unsigned int tmp;
 620
 621             lmi->lm_addr = lm;
 622
 623 #define EXTRACT(_fld) \
 624   extract_unsigned_integer ((gdb_byte *)&dbuf._fld, sizeof (dbuf._fld));
 625
 626             lmi->text_addr = EXTRACT (text_addr);
 627             tmp = EXTRACT (info);
 628             lmi->library_version = (tmp >> 16) & 0xffff;
 629             lmi->bind_mode = (tmp >> 8) & 0xff;
 630             lmi->struct_version = tmp & 0xff;
 631             lmi->text_link_addr = EXTRACT (text_link_addr);
 632             lmi->text_end = EXTRACT (text_end);
 633             lmi->data_start = EXTRACT (data_start);
 634             lmi->bss_start = EXTRACT (bss_start);
 635             lmi->data_end = EXTRACT (data_end);
 636             lmi->got_value = EXTRACT (got_value);
 637             tmp = EXTRACT (tsd_start_addr_ptr);
 638             read_memory (tmp, tsdbuf, 4);
 639             lmi->tsd_start_addr = extract_unsigned_integer (tsdbuf, 4);
 640
 641 #ifdef SOLIB_SOM_DBG
 642             printf ("\n+ library \"%s\" is described at %s\n", new->so_name,
 643                     paddress (target_gdbarch, lm));
 644             printf ("  'version' is %d\n", new->lm_info->struct_version);
 645             printf ("  'bind_mode' is %d\n", new->lm_info->bind_mode);
 646             printf ("  'library_version' is %d\n",
 647                     new->lm_info->library_version);
 648             printf ("  'text_addr' is %s\n",
 649                     paddress (target_gdbarch, new->lm_info->text_addr));
 650             printf ("  'text_link_addr' is %s\n",
 651                     paddress (target_gdbarch, new->lm_info->text_link_addr));
 652             printf ("  'text_end' is %s\n",
 653                     paddress (target_gdbarch, new->lm_info->text_end));
 654             printf ("  'data_start' is %s\n",
 655                     paddress (target_gdbarch, new->lm_info->data_start));
 656             printf ("  'bss_start' is %s\n",
 657                     paddress (target_gdbarch, new->lm_info->bss_start));
 658             printf ("  'data_end' is %s\n",
 659                     paddress (target_gdbarch, new->lm_info->data_end));
 660             printf ("  'got_value' is %s\n",
 661                     paddress (target_gdbarch, new->lm_info->got_value));
 662             printf ("  'tsd_start_addr' is %s\n",
 663                     paddress (target_gdbarch, new->lm_info->tsd_start_addr));
 664 #endif
 665
 666             new->addr_low = lmi->text_addr;
 667             new->addr_high = lmi->text_end;
 668
 669             /* Link the new object onto the list.  */
 670             new->next = NULL;
 671             *link_ptr = new;
 672             link_ptr = &new->next;
 673           }
 674         else
 675           {
 676             free_so (new);
 677           }
 678
 679       lm = EXTRACT (next);
 680       discard_cleanups (old_chain);
 681 #undef EXTRACT
 682     }
 683
 684   /* TODO: The original somsolib code has logic to detect and eliminate
 685      duplicate entries.  Do we need that?  */
 686
 687   return head;
 688 }
 689
 690 static int
 691 som_open_symbol_file_object (void *from_ttyp)
 692 {
 693   CORE_ADDR lm, l_name;
 694   char *filename;
 695   int errcode;
 696   int from_tty = *(int *)from_ttyp;
 697   char buf[4];
 698
 699   if (symfile_objfile)
 700     if (!query (_("Attempt to reload symbols from process? ")))
 701       return 0;
 702
 703   /* First link map member should be the executable.  */
 704   if ((lm = link_map_start ()) == 0)
 705     return 0;   /* failed somehow... */
 706
 707   /* Read address of name from target memory to GDB.  */
 708   read_memory (lm + offsetof (struct dld_list, name), buf, 4);
 709
 710   /* Convert the address to host format.  Assume that the address is
 711      unsigned.  */
 712   l_name = extract_unsigned_integer (buf, 4);
 713
 714   if (l_name == 0)
 715     return 0;           /* No filename.  */
 716
 717   /* Now fetch the filename from target memory.  */
 718   target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
 719
 720   if (errcode)
 721     {
 722       warning (_("failed to read exec filename from attached file: %s"),
 723                safe_strerror (errcode));
 724       return 0;
 725     }
 726
 727   make_cleanup (xfree, filename);
 728   /* Have a pathname: read the symbol file.  */
 729   symbol_file_add_main (filename, from_tty);
 730
 731   return 1;
 732 }
 733
 734 static void
 735 som_free_so (struct so_list *so)
 736 {
 737   xfree (so->lm_info);
 738 }
 739
 740 static CORE_ADDR
 741 som_solib_thread_start_addr (struct so_list *so)
 742 {
 743   return so->lm_info->tsd_start_addr;
 744 }
 745
 746 /* Return the GOT value for the shared library in which ADDR belongs.  If
 747    ADDR isn't in any known shared library, return zero.  */
 748
 749 static CORE_ADDR
 750 som_solib_get_got_by_pc (CORE_ADDR addr)
 751 {
 752   struct so_list *so_list = master_so_list ();
 753   CORE_ADDR got_value = 0;
 754
 755   while (so_list)
 756     {
 757       if (so_list->lm_info->text_addr <= addr
 758           && so_list->lm_info->text_end > addr)
 759         {
 760           got_value = so_list->lm_info->got_value;
 761           break;
 762         }
 763       so_list = so_list->next;
 764     }
 765   return got_value;
 766 }
 767
 768 /* Return the address of the handle of the shared library in which ADDR belongs.
 769    If ADDR isn't in any known shared library, return zero.  */
 770 /* this function is used in initialize_hp_cxx_exception_support in
 771    hppa-hpux-tdep.c  */
 772
 773 static CORE_ADDR
 774 som_solib_get_solib_by_pc (CORE_ADDR addr)
 775 {
 776   struct so_list *so_list = master_so_list ();
 777
 778   while (so_list)
 779     {
 780       if (so_list->lm_info->text_addr <= addr
 781           && so_list->lm_info->text_end > addr)
 782         {
 783           break;
 784         }
 785       so_list = so_list->next;
 786     }
 787   if (so_list)
 788     return so_list->lm_info->lm_addr;
 789   else
 790     return 0;
 791 }
 792
 793
 794 static struct target_so_ops som_so_ops;
 795
 796 extern initialize_file_ftype _initialize_som_solib; /* -Wmissing-prototypes */
 797
 798 void
 799 _initialize_som_solib (void)
 800 {
 801   som_so_ops.relocate_section_addresses = som_relocate_section_addresses;
 802   som_so_ops.free_so = som_free_so;
 803   som_so_ops.clear_solib = som_clear_solib;
 804   som_so_ops.solib_create_inferior_hook = som_solib_create_inferior_hook;
 805   som_so_ops.special_symbol_handling = som_special_symbol_handling;
 806   som_so_ops.current_sos = som_current_sos;
 807   som_so_ops.open_symbol_file_object = som_open_symbol_file_object;
 808   som_so_ops.in_dynsym_resolve_code = som_in_dynsym_resolve_code;
 809 }
 810
 811 void
 812 som_solib_select (struct gdbarch *gdbarch)
 813 {
 814   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 815   set_solib_ops (gdbarch, &som_so_ops);
 816
 817   tdep->solib_thread_start_addr = som_solib_thread_start_addr;
 818   tdep->solib_get_got_by_pc = som_solib_get_got_by_pc;
 819   tdep->solib_get_solib_by_pc = som_solib_get_solib_by_pc;
 820 }
 821
 822 /* The rest of these functions are not part of the solib interface; they
 823    are used by somread.c or hppa-hpux-tdep.c */
 824
 825 int
 826 som_solib_section_offsets (struct objfile *objfile,
 827                            struct section_offsets *offsets)
 828 {
 829   struct so_list *so_list = master_so_list ();
 830
 831   while (so_list)
 832     {
 833       /* Oh what a pain!  We need the offsets before so_list->objfile
 834          is valid.  The BFDs will never match.  Make a best guess.  */
 835       if (strstr (objfile->name, so_list->so_name))
 836         {
 837           asection *private_section;
 838
 839           /* The text offset is easy.  */
 840           offsets->offsets[SECT_OFF_TEXT (objfile)]
 841             = (so_list->lm_info->text_addr
 842                - so_list->lm_info->text_link_addr);
 843           offsets->offsets[SECT_OFF_RODATA (objfile)]
 844             = ANOFFSET (offsets, SECT_OFF_TEXT (objfile));
 845
 846           /* We should look at presumed_dp in the SOM header, but
 847              that's not easily available.  This should be OK though.  */
 848           private_section = bfd_get_section_by_name (objfile->obfd,
 849                                                      "$PRIVATE$");
 850           if (!private_section)
 851             {
 852               warning (_("Unable to find $PRIVATE$ in shared library!"));
 853               offsets->offsets[SECT_OFF_DATA (objfile)] = 0;
 854               offsets->offsets[SECT_OFF_BSS (objfile)] = 0;
 855               return 1;
 856             }
 857           offsets->offsets[SECT_OFF_DATA (objfile)]
 858             = (so_list->lm_info->data_start - private_section->vma);
 859           offsets->offsets[SECT_OFF_BSS (objfile)]
 860             = ANOFFSET (offsets, SECT_OFF_DATA (objfile));
 861           return 1;
 862         }
 863       so_list = so_list->next;
 864     }
 865   return 0;
 866 }