gdb/solib-sunos.c

   1 /* Handle SunOS shared libraries for GDB, the GNU Debugger.
   2
   3    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
   4    2001, 2004, 2007, 2008 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22
  23 #include <sys/types.h>
  24 #include <signal.h>
  25 #include "gdb_string.h"
  26 #include <sys/param.h>
  27 #include <fcntl.h>
  28
  29 /* SunOS shared libs need the nlist structure.  */
  30 #include <a.out.h>
  31 #include <link.h>
  32
  33 #include "symtab.h"
  34 #include "bfd.h"
  35 #include "symfile.h"
  36 #include "objfiles.h"
  37 #include "gdbcore.h"
  38 #include "inferior.h"
  39 #include "solist.h"
  40 #include "bcache.h"
  41 #include "regcache.h"
  42
  43 /* The shared library implementation found on BSD a.out systems is
  44    very similar to the SunOS implementation.  However, the data
  45    structures defined in <link.h> are named very differently.  Make up
  46    for those differences here.  */
  47
  48 #ifdef HAVE_STRUCT_SO_MAP_WITH_SOM_MEMBERS
  49
  50 /* FIXME: Temporary until the equivalent defines have been removed
  51    from all nm-*bsd*.h files.  */
  52 #ifndef link_dynamic
  53
  54 /* Map `struct link_map' and its members.  */
  55 #define link_map        so_map
  56 #define lm_addr         som_addr
  57 #define lm_name         som_path
  58 #define lm_next         som_next
  59
  60 /* Map `struct link_dynamic_2' and its members.  */
  61 #define link_dynamic_2  section_dispatch_table
  62 #define ld_loaded       sdt_loaded
  63
  64 /* Map `struct rtc_symb' and its members.  */
  65 #define rtc_symb        rt_symbol
  66 #define rtc_sp          rt_sp
  67 #define rtc_next        rt_next
  68
  69 /* Map `struct ld_debug' and its members.  */
  70 #define ld_debug        so_debug
  71 #define ldd_in_debugger dd_in_debugger
  72 #define ldd_bp_addr     dd_bpt_addr
  73 #define ldd_bp_inst     dd_bpt_shadow
  74 #define ldd_cp          dd_cc
  75
  76 /* Map `struct link_dynamic' and its members.  */
  77 #define link_dynamic    _dynamic
  78 #define ld_version      d_version
  79 #define ldd             d_debug
  80 #define ld_un           d_un
  81 #define ld_2            d_sdt
  82
  83 #endif
  84
  85 #endif
  86
  87 /* Link map info to include in an allocated so_list entry */
  88
  89 struct lm_info
  90   {
  91     /* Pointer to copy of link map from inferior.  The type is char *
  92        rather than void *, so that we may use byte offsets to find the
  93        various fields without the need for a cast.  */
  94     char *lm;
  95   };
  96
  97
  98 /* Symbols which are used to locate the base of the link map structures. */
  99
 100 static char *debug_base_symbols[] =
 101 {
 102   "_DYNAMIC",
 103   "_DYNAMIC__MGC",
 104   NULL
 105 };
 106
 107 static char *main_name_list[] =
 108 {
 109   "main_$main",
 110   NULL
 111 };
 112
 113 /* Macro to extract an address from a solib structure.  When GDB is
 114    configured for some 32-bit targets (e.g. Solaris 2.7 sparc), BFD is
 115    configured to handle 64-bit targets, so CORE_ADDR is 64 bits.  We
 116    have to extract only the significant bits of addresses to get the
 117    right address when accessing the core file BFD.
 118
 119    Assume that the address is unsigned.  */
 120
 121 #define SOLIB_EXTRACT_ADDRESS(MEMBER) \
 122         extract_unsigned_integer (&(MEMBER), sizeof (MEMBER))
 123
 124 /* local data declarations */
 125
 126 static struct link_dynamic dynamic_copy;
 127 static struct link_dynamic_2 ld_2_copy;
 128 static struct ld_debug debug_copy;
 129 static CORE_ADDR debug_addr;
 130 static CORE_ADDR flag_addr;
 131
 132 #ifndef offsetof
 133 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
 134 #endif
 135 #define fieldsize(TYPE, MEMBER) (sizeof (((TYPE *)0)->MEMBER))
 136
 137 /* link map access functions */
 138
 139 static CORE_ADDR
 140 LM_ADDR (struct so_list *so)
 141 {
 142   int lm_addr_offset = offsetof (struct link_map, lm_addr);
 143   int lm_addr_size = fieldsize (struct link_map, lm_addr);
 144
 145   return (CORE_ADDR) extract_signed_integer (so->lm_info->lm + lm_addr_offset,
 146                                              lm_addr_size);
 147 }
 148
 149 static CORE_ADDR
 150 LM_NEXT (struct so_list *so)
 151 {
 152   int lm_next_offset = offsetof (struct link_map, lm_next);
 153   int lm_next_size = fieldsize (struct link_map, lm_next);
 154
 155   /* Assume that the address is unsigned.  */
 156   return extract_unsigned_integer (so->lm_info->lm + lm_next_offset,
 157                                    lm_next_size);
 158 }
 159
 160 static CORE_ADDR
 161 LM_NAME (struct so_list *so)
 162 {
 163   int lm_name_offset = offsetof (struct link_map, lm_name);
 164   int lm_name_size = fieldsize (struct link_map, lm_name);
 165
 166   /* Assume that the address is unsigned.  */
 167   return extract_unsigned_integer (so->lm_info->lm + lm_name_offset,
 168                                    lm_name_size);
 169 }
 170
 171 static CORE_ADDR debug_base;    /* Base of dynamic linker structures */
 172
 173 /* Local function prototypes */
 174
 175 static int match_main (char *);
 176
 177 /* Allocate the runtime common object file.  */
 178
 179 static void
 180 allocate_rt_common_objfile (void)
 181 {
 182   struct objfile *objfile;
 183   struct objfile *last_one;
 184
 185   objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
 186   memset (objfile, 0, sizeof (struct objfile));
 187   objfile->md = NULL;
 188   objfile->psymbol_cache = bcache_xmalloc ();
 189   objfile->macro_cache = bcache_xmalloc ();
 190   obstack_init (&objfile->objfile_obstack);
 191   objfile->name = xstrdup ("rt_common");
 192
 193   /* Add this file onto the tail of the linked list of other such files. */
 194
 195   objfile->next = NULL;
 196   if (object_files == NULL)
 197     object_files = objfile;
 198   else
 199     {
 200       for (last_one = object_files;
 201            last_one->next;
 202            last_one = last_one->next);
 203       last_one->next = objfile;
 204     }
 205
 206   rt_common_objfile = objfile;
 207 }
 208
 209 /* Read all dynamically loaded common symbol definitions from the inferior
 210    and put them into the minimal symbol table for the runtime common
 211    objfile.  */
 212
 213 static void
 214 solib_add_common_symbols (CORE_ADDR rtc_symp)
 215 {
 216   struct rtc_symb inferior_rtc_symb;
 217   struct nlist inferior_rtc_nlist;
 218   int len;
 219   char *name;
 220
 221   /* Remove any runtime common symbols from previous runs.  */
 222
 223   if (rt_common_objfile != NULL && rt_common_objfile->minimal_symbol_count)
 224     {
 225       obstack_free (&rt_common_objfile->objfile_obstack, 0);
 226       obstack_init (&rt_common_objfile->objfile_obstack);
 227       rt_common_objfile->minimal_symbol_count = 0;
 228       rt_common_objfile->msymbols = NULL;
 229       terminate_minimal_symbol_table (rt_common_objfile);
 230     }
 231
 232   init_minimal_symbol_collection ();
 233   make_cleanup_discard_minimal_symbols ();
 234
 235   while (rtc_symp)
 236     {
 237       read_memory (rtc_symp,
 238                    (char *) &inferior_rtc_symb,
 239                    sizeof (inferior_rtc_symb));
 240       read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_sp),
 241                    (char *) &inferior_rtc_nlist,
 242                    sizeof (inferior_rtc_nlist));
 243       if (inferior_rtc_nlist.n_type == N_COMM)
 244         {
 245           /* FIXME: The length of the symbol name is not available, but in the
 246              current implementation the common symbol is allocated immediately
 247              behind the name of the symbol. */
 248           len = inferior_rtc_nlist.n_value - inferior_rtc_nlist.n_un.n_strx;
 249
 250           name = xmalloc (len);
 251           read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_nlist.n_un.n_name),
 252                        name, len);
 253
 254           /* Allocate the runtime common objfile if necessary. */
 255           if (rt_common_objfile == NULL)
 256             allocate_rt_common_objfile ();
 257
 258           prim_record_minimal_symbol (name, inferior_rtc_nlist.n_value,
 259                                       mst_bss, rt_common_objfile);
 260           xfree (name);
 261         }
 262       rtc_symp = SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_next);
 263     }
 264
 265   /* Install any minimal symbols that have been collected as the current
 266      minimal symbols for the runtime common objfile.  */
 267
 268   install_minimal_symbols (rt_common_objfile);
 269 }
 270
 271
 272 /*
 273
 274    LOCAL FUNCTION
 275
 276    locate_base -- locate the base address of dynamic linker structs
 277
 278    SYNOPSIS
 279
 280    CORE_ADDR locate_base (void)
 281
 282    DESCRIPTION
 283
 284    For both the SunOS and SVR4 shared library implementations, if the
 285    inferior executable has been linked dynamically, there is a single
 286    address somewhere in the inferior's data space which is the key to
 287    locating all of the dynamic linker's runtime structures.  This
 288    address is the value of the debug base symbol.  The job of this
 289    function is to find and return that address, or to return 0 if there
 290    is no such address (the executable is statically linked for example).
 291
 292    For SunOS, the job is almost trivial, since the dynamic linker and
 293    all of it's structures are statically linked to the executable at
 294    link time.  Thus the symbol for the address we are looking for has
 295    already been added to the minimal symbol table for the executable's
 296    objfile at the time the symbol file's symbols were read, and all we
 297    have to do is look it up there.  Note that we explicitly do NOT want
 298    to find the copies in the shared library.
 299
 300    The SVR4 version is a bit more complicated because the address
 301    is contained somewhere in the dynamic info section.  We have to go
 302    to a lot more work to discover the address of the debug base symbol.
 303    Because of this complexity, we cache the value we find and return that
 304    value on subsequent invocations.  Note there is no copy in the
 305    executable symbol tables.
 306
 307  */
 308
 309 static CORE_ADDR
 310 locate_base (void)
 311 {
 312   struct minimal_symbol *msymbol;
 313   CORE_ADDR address = 0;
 314   char **symbolp;
 315
 316   /* For SunOS, we want to limit the search for the debug base symbol to the
 317      executable being debugged, since there is a duplicate named symbol in the
 318      shared library.  We don't want the shared library versions. */
 319
 320   for (symbolp = debug_base_symbols; *symbolp != NULL; symbolp++)
 321     {
 322       msymbol = lookup_minimal_symbol (*symbolp, NULL, symfile_objfile);
 323       if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
 324         {
 325           address = SYMBOL_VALUE_ADDRESS (msymbol);
 326           return (address);
 327         }
 328     }
 329   return (0);
 330 }
 331
 332 /*
 333
 334    LOCAL FUNCTION
 335
 336    first_link_map_member -- locate first member in dynamic linker's map
 337
 338    SYNOPSIS
 339
 340    static CORE_ADDR first_link_map_member (void)
 341
 342    DESCRIPTION
 343
 344    Find the first element in the inferior's dynamic link map, and
 345    return its address in the inferior.  This function doesn't copy the
 346    link map entry itself into our address space; current_sos actually
 347    does the reading.  */
 348
 349 static CORE_ADDR
 350 first_link_map_member (void)
 351 {
 352   CORE_ADDR lm = 0;
 353
 354   read_memory (debug_base, (char *) &dynamic_copy, sizeof (dynamic_copy));
 355   if (dynamic_copy.ld_version >= 2)
 356     {
 357       /* It is a version that we can deal with, so read in the secondary
 358          structure and find the address of the link map list from it. */
 359       read_memory (SOLIB_EXTRACT_ADDRESS (dynamic_copy.ld_un.ld_2),
 360                    (char *) &ld_2_copy, sizeof (struct link_dynamic_2));
 361       lm = SOLIB_EXTRACT_ADDRESS (ld_2_copy.ld_loaded);
 362     }
 363   return (lm);
 364 }
 365
 366 static int
 367 open_symbol_file_object (void *from_ttyp)
 368 {
 369   return 1;
 370 }
 371
 372
 373 /* LOCAL FUNCTION
 374
 375    current_sos -- build a list of currently loaded shared objects
 376
 377    SYNOPSIS
 378
 379    struct so_list *current_sos ()
 380
 381    DESCRIPTION
 382
 383    Build a list of `struct so_list' objects describing the shared
 384    objects currently loaded in the inferior.  This list does not
 385    include an entry for the main executable file.
 386
 387    Note that we only gather information directly available from the
 388    inferior --- we don't examine any of the shared library files
 389    themselves.  The declaration of `struct so_list' says which fields
 390    we provide values for.  */
 391
 392 static struct so_list *
 393 sunos_current_sos (void)
 394 {
 395   CORE_ADDR lm;
 396   struct so_list *head = 0;
 397   struct so_list **link_ptr = &head;
 398   int errcode;
 399   char *buffer;
 400
 401   /* Make sure we've looked up the inferior's dynamic linker's base
 402      structure.  */
 403   if (! debug_base)
 404     {
 405       debug_base = locate_base ();
 406
 407       /* If we can't find the dynamic linker's base structure, this
 408          must not be a dynamically linked executable.  Hmm.  */
 409       if (! debug_base)
 410         return 0;
 411     }
 412
 413   /* Walk the inferior's link map list, and build our list of
 414      `struct so_list' nodes.  */
 415   lm = first_link_map_member ();
 416   while (lm)
 417     {
 418       struct so_list *new
 419         = (struct so_list *) xmalloc (sizeof (struct so_list));
 420       struct cleanup *old_chain = make_cleanup (xfree, new);
 421
 422       memset (new, 0, sizeof (*new));
 423
 424       new->lm_info = xmalloc (sizeof (struct lm_info));
 425       make_cleanup (xfree, new->lm_info);
 426
 427       new->lm_info->lm = xmalloc (sizeof (struct link_map));
 428       make_cleanup (xfree, new->lm_info->lm);
 429       memset (new->lm_info->lm, 0, sizeof (struct link_map));
 430
 431       read_memory (lm, new->lm_info->lm, sizeof (struct link_map));
 432
 433       lm = LM_NEXT (new);
 434
 435       /* Extract this shared object's name.  */
 436       target_read_string (LM_NAME (new), &buffer,
 437                           SO_NAME_MAX_PATH_SIZE - 1, &errcode);
 438       if (errcode != 0)
 439         warning (_("Can't read pathname for load map: %s."),
 440                  safe_strerror (errcode));
 441       else
 442         {
 443           strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
 444           new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
 445           xfree (buffer);
 446           strcpy (new->so_original_name, new->so_name);
 447         }
 448
 449       /* If this entry has no name, or its name matches the name
 450          for the main executable, don't include it in the list.  */
 451       if (! new->so_name[0]
 452           || match_main (new->so_name))
 453         free_so (new);
 454       else
 455         {
 456           new->next = 0;
 457           *link_ptr = new;
 458           link_ptr = &new->next;
 459         }
 460
 461       discard_cleanups (old_chain);
 462     }
 463
 464   return head;
 465 }
 466
 467
 468 /* On some systems, the only way to recognize the link map entry for
 469    the main executable file is by looking at its name.  Return
 470    non-zero iff SONAME matches one of the known main executable names.  */
 471
 472 static int
 473 match_main (char *soname)
 474 {
 475   char **mainp;
 476
 477   for (mainp = main_name_list; *mainp != NULL; mainp++)
 478     {
 479       if (strcmp (soname, *mainp) == 0)
 480         return (1);
 481     }
 482
 483   return (0);
 484 }
 485
 486
 487 static int
 488 sunos_in_dynsym_resolve_code (CORE_ADDR pc)
 489 {
 490   return 0;
 491 }
 492
 493 /*
 494
 495    LOCAL FUNCTION
 496
 497    disable_break -- remove the "mapping changed" breakpoint
 498
 499    SYNOPSIS
 500
 501    static int disable_break ()
 502
 503    DESCRIPTION
 504
 505    Removes the breakpoint that gets hit when the dynamic linker
 506    completes a mapping change.
 507
 508  */
 509
 510 static int
 511 disable_break (void)
 512 {
 513   CORE_ADDR breakpoint_addr;    /* Address where end bkpt is set */
 514
 515   int in_debugger = 0;
 516
 517   /* Read the debugger structure from the inferior to retrieve the
 518      address of the breakpoint and the original contents of the
 519      breakpoint address.  Remove the breakpoint by writing the original
 520      contents back. */
 521
 522   read_memory (debug_addr, (char *) &debug_copy, sizeof (debug_copy));
 523
 524   /* Set `in_debugger' to zero now. */
 525
 526   write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
 527
 528   breakpoint_addr = SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_bp_addr);
 529   write_memory (breakpoint_addr, (char *) &debug_copy.ldd_bp_inst,
 530                 sizeof (debug_copy.ldd_bp_inst));
 531
 532   /* For the SVR4 version, we always know the breakpoint address.  For the
 533      SunOS version we don't know it until the above code is executed.
 534      Grumble if we are stopped anywhere besides the breakpoint address. */
 535
 536   if (stop_pc != breakpoint_addr)
 537     {
 538       warning (_("stopped at unknown breakpoint while handling shared libraries"));
 539     }
 540
 541   return 1;
 542 }
 543
 544
 545 /*
 546
 547    LOCAL FUNCTION
 548
 549    enable_break -- arrange for dynamic linker to hit breakpoint
 550
 551    SYNOPSIS
 552
 553    int enable_break (void)
 554
 555    DESCRIPTION
 556
 557    Both the SunOS and the SVR4 dynamic linkers have, as part of their
 558    debugger interface, support for arranging for the inferior to hit
 559    a breakpoint after mapping in the shared libraries.  This function
 560    enables that breakpoint.
 561
 562    For SunOS, there is a special flag location (in_debugger) which we
 563    set to 1.  When the dynamic linker sees this flag set, it will set
 564    a breakpoint at a location known only to itself, after saving the
 565    original contents of that place and the breakpoint address itself,
 566    in it's own internal structures.  When we resume the inferior, it
 567    will eventually take a SIGTRAP when it runs into the breakpoint.
 568    We handle this (in a different place) by restoring the contents of
 569    the breakpointed location (which is only known after it stops),
 570    chasing around to locate the shared libraries that have been
 571    loaded, then resuming.
 572
 573    For SVR4, the debugger interface structure contains a member (r_brk)
 574    which is statically initialized at the time the shared library is
 575    built, to the offset of a function (_r_debug_state) which is guaran-
 576    teed to be called once before mapping in a library, and again when
 577    the mapping is complete.  At the time we are examining this member,
 578    it contains only the unrelocated offset of the function, so we have
 579    to do our own relocation.  Later, when the dynamic linker actually
 580    runs, it relocates r_brk to be the actual address of _r_debug_state().
 581
 582    The debugger interface structure also contains an enumeration which
 583    is set to either RT_ADD or RT_DELETE prior to changing the mapping,
 584    depending upon whether or not the library is being mapped or unmapped,
 585    and then set to RT_CONSISTENT after the library is mapped/unmapped.
 586  */
 587
 588 static int
 589 enable_break (void)
 590 {
 591   int success = 0;
 592   int j;
 593   int in_debugger;
 594
 595   /* Get link_dynamic structure */
 596
 597   j = target_read_memory (debug_base, (char *) &dynamic_copy,
 598                           sizeof (dynamic_copy));
 599   if (j)
 600     {
 601       /* unreadable */
 602       return (0);
 603     }
 604
 605   /* Calc address of debugger interface structure */
 606
 607   debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
 608
 609   /* Calc address of `in_debugger' member of debugger interface structure */
 610
 611   flag_addr = debug_addr + (CORE_ADDR) ((char *) &debug_copy.ldd_in_debugger -
 612                                         (char *) &debug_copy);
 613
 614   /* Write a value of 1 to this member.  */
 615
 616   in_debugger = 1;
 617   write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
 618   success = 1;
 619
 620   return (success);
 621 }
 622
 623 /*
 624
 625    LOCAL FUNCTION
 626
 627    special_symbol_handling -- additional shared library symbol handling
 628
 629    SYNOPSIS
 630
 631    void special_symbol_handling ()
 632
 633    DESCRIPTION
 634
 635    Once the symbols from a shared object have been loaded in the usual
 636    way, we are called to do any system specific symbol handling that
 637    is needed.
 638
 639    For SunOS4, this consists of grunging around in the dynamic
 640    linkers structures to find symbol definitions for "common" symbols
 641    and adding them to the minimal symbol table for the runtime common
 642    objfile.
 643
 644  */
 645
 646 static void
 647 sunos_special_symbol_handling (void)
 648 {
 649   int j;
 650
 651   if (debug_addr == 0)
 652     {
 653       /* Get link_dynamic structure */
 654
 655       j = target_read_memory (debug_base, (char *) &dynamic_copy,
 656                               sizeof (dynamic_copy));
 657       if (j)
 658         {
 659           /* unreadable */
 660           return;
 661         }
 662
 663       /* Calc address of debugger interface structure */
 664       /* FIXME, this needs work for cross-debugging of core files
 665          (byteorder, size, alignment, etc).  */
 666
 667       debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
 668     }
 669
 670   /* Read the debugger structure from the inferior, just to make sure
 671      we have a current copy. */
 672
 673   j = target_read_memory (debug_addr, (char *) &debug_copy,
 674                           sizeof (debug_copy));
 675   if (j)
 676     return;                     /* unreadable */
 677
 678   /* Get common symbol definitions for the loaded object. */
 679
 680   if (debug_copy.ldd_cp)
 681     {
 682       solib_add_common_symbols (SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_cp));
 683     }
 684 }
 685
 686 /*
 687
 688    GLOBAL FUNCTION
 689
 690    sunos_solib_create_inferior_hook -- shared library startup support
 691
 692    SYNOPSIS
 693
 694    void sunos_solib_create_inferior_hook ()
 695
 696    DESCRIPTION
 697
 698    When gdb starts up the inferior, it nurses it along (through the
 699    shell) until it is ready to execute it's first instruction.  At this
 700    point, this function gets called via expansion of the macro
 701    SOLIB_CREATE_INFERIOR_HOOK.
 702
 703    For SunOS executables, this first instruction is typically the
 704    one at "_start", or a similar text label, regardless of whether
 705    the executable is statically or dynamically linked.  The runtime
 706    startup code takes care of dynamically linking in any shared
 707    libraries, once gdb allows the inferior to continue.
 708
 709    For SVR4 executables, this first instruction is either the first
 710    instruction in the dynamic linker (for dynamically linked
 711    executables) or the instruction at "start" for statically linked
 712    executables.  For dynamically linked executables, the system
 713    first exec's /lib/libc.so.N, which contains the dynamic linker,
 714    and starts it running.  The dynamic linker maps in any needed
 715    shared libraries, maps in the actual user executable, and then
 716    jumps to "start" in the user executable.
 717
 718    For both SunOS shared libraries, and SVR4 shared libraries, we
 719    can arrange to cooperate with the dynamic linker to discover the
 720    names of shared libraries that are dynamically linked, and the
 721    base addresses to which they are linked.
 722
 723    This function is responsible for discovering those names and
 724    addresses, and saving sufficient information about them to allow
 725    their symbols to be read at a later time.
 726
 727    FIXME
 728
 729    Between enable_break() and disable_break(), this code does not
 730    properly handle hitting breakpoints which the user might have
 731    set in the startup code or in the dynamic linker itself.  Proper
 732    handling will probably have to wait until the implementation is
 733    changed to use the "breakpoint handler function" method.
 734
 735    Also, what if child has exit()ed?  Must exit loop somehow.
 736  */
 737
 738 static void
 739 sunos_solib_create_inferior_hook (void)
 740 {
 741   if ((debug_base = locate_base ()) == 0)
 742     {
 743       /* Can't find the symbol or the executable is statically linked. */
 744       return;
 745     }
 746
 747   if (!enable_break ())
 748     {
 749       warning (_("shared library handler failed to enable breakpoint"));
 750       return;
 751     }
 752
 753   /* SCO and SunOS need the loop below, other systems should be using the
 754      special shared library breakpoints and the shared library breakpoint
 755      service routine.
 756
 757      Now run the target.  It will eventually hit the breakpoint, at
 758      which point all of the libraries will have been mapped in and we
 759      can go groveling around in the dynamic linker structures to find
 760      out what we need to know about them. */
 761
 762   clear_proceed_status ();
 763   stop_soon = STOP_QUIETLY;
 764   stop_signal = TARGET_SIGNAL_0;
 765   do
 766     {
 767       target_resume (pid_to_ptid (-1), 0, stop_signal);
 768       wait_for_inferior (0);
 769     }
 770   while (stop_signal != TARGET_SIGNAL_TRAP);
 771   stop_soon = NO_STOP_QUIETLY;
 772
 773   /* We are now either at the "mapping complete" breakpoint (or somewhere
 774      else, a condition we aren't prepared to deal with anyway), so adjust
 775      the PC as necessary after a breakpoint, disable the breakpoint, and
 776      add any shared libraries that were mapped in.
 777
 778      Note that adjust_pc_after_break did not perform any PC adjustment,
 779      as the breakpoint the inferior just hit was not inserted by GDB,
 780      but by the dynamic loader itself, and is therefore not found on
 781      the GDB software break point list.  Thus we have to adjust the
 782      PC here.  */
 783
 784   if (gdbarch_decr_pc_after_break (current_gdbarch))
 785     {
 786       stop_pc -= gdbarch_decr_pc_after_break (current_gdbarch);
 787       write_pc (stop_pc);
 788     }
 789
 790   if (!disable_break ())
 791     {
 792       warning (_("shared library handler failed to disable breakpoint"));
 793     }
 794
 795   solib_add ((char *) 0, 0, (struct target_ops *) 0, auto_solib_add);
 796 }
 797
 798 static void
 799 sunos_clear_solib (void)
 800 {
 801   debug_base = 0;
 802 }
 803
 804 static void
 805 sunos_free_so (struct so_list *so)
 806 {
 807   xfree (so->lm_info->lm);
 808   xfree (so->lm_info);
 809 }
 810
 811 static void
 812 sunos_relocate_section_addresses (struct so_list *so,
 813                                  struct section_table *sec)
 814 {
 815   sec->addr += LM_ADDR (so);
 816   sec->endaddr += LM_ADDR (so);
 817 }
 818
 819 static struct target_so_ops sunos_so_ops;
 820
 821 void
 822 _initialize_sunos_solib (void)
 823 {
 824   sunos_so_ops.relocate_section_addresses = sunos_relocate_section_addresses;
 825   sunos_so_ops.free_so = sunos_free_so;
 826   sunos_so_ops.clear_solib = sunos_clear_solib;
 827   sunos_so_ops.solib_create_inferior_hook = sunos_solib_create_inferior_hook;
 828   sunos_so_ops.special_symbol_handling = sunos_special_symbol_handling;
 829   sunos_so_ops.current_sos = sunos_current_sos;
 830   sunos_so_ops.open_symbol_file_object = open_symbol_file_object;
 831   sunos_so_ops.in_dynsym_resolve_code = sunos_in_dynsym_resolve_code;
 832
 833   /* FIXME: Don't do this here.  *_gdbarch_init() should set so_ops. */
 834   current_target_so_ops = &sunos_so_ops;
 835 }