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