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