OSDN Git Service

2000-03-23 Michael Snyder <msnyder@cleaver.cygnus.com>
[pf3gnuchains/pf3gnuchains3x.git] / gdb / solib.c
1 /* Handle SunOS and SVR4 shared libraries for GDB, the GNU Debugger.
2    Copyright 1990, 91, 92, 93, 94, 95, 96, 98, 1999
3    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 2 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, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
21
22
23 #include "defs.h"
24
25 /* This file is only compilable if link.h is available. */
26
27 #ifdef HAVE_LINK_H
28
29 #include <sys/types.h>
30 #include <signal.h>
31 #include "gdb_string.h"
32 #include <sys/param.h>
33 #include <fcntl.h>
34
35 #ifndef SVR4_SHARED_LIBS
36  /* SunOS shared libs need the nlist structure.  */
37 #include <a.out.h>
38 #else
39 #include "elf/external.h"
40 #endif
41
42 #include <link.h>
43
44 #include "symtab.h"
45 #include "bfd.h"
46 #include "symfile.h"
47 #include "objfiles.h"
48 #include "gdbcore.h"
49 #include "command.h"
50 #include "target.h"
51 #include "frame.h"
52 #include "gnu-regex.h"
53 #include "inferior.h"
54 #include "environ.h"
55 #include "language.h"
56 #include "gdbcmd.h"
57
58 #define MAX_PATH_SIZE 512       /* FIXME: Should be dynamic */
59
60 /* On SVR4 systems, a list of symbols in the dynamic linker where
61    GDB can try to place a breakpoint to monitor shared library
62    events.
63
64    If none of these symbols are found, or other errors occur, then
65    SVR4 systems will fall back to using a symbol as the "startup
66    mapping complete" breakpoint address.  */
67
68 #ifdef SVR4_SHARED_LIBS
69 static char *solib_break_names[] =
70 {
71   "r_debug_state",
72   "_r_debug_state",
73   "_dl_debug_state",
74   "rtld_db_dlactivity",
75   NULL
76 };
77 #endif
78
79 #define BKPT_AT_SYMBOL 1
80
81 #if defined (BKPT_AT_SYMBOL) && defined (SVR4_SHARED_LIBS)
82 static char *bkpt_names[] =
83 {
84 #ifdef SOLIB_BKPT_NAME
85   SOLIB_BKPT_NAME,              /* Prefer configured name if it exists. */
86 #endif
87   "_start",
88   "main",
89   NULL
90 };
91 #endif
92
93 /* Symbols which are used to locate the base of the link map structures. */
94
95 #ifndef SVR4_SHARED_LIBS
96 static char *debug_base_symbols[] =
97 {
98   "_DYNAMIC",
99   "_DYNAMIC__MGC",
100   NULL
101 };
102 #endif
103
104 static char *main_name_list[] =
105 {
106   "main_$main",
107   NULL
108 };
109
110 /* local data declarations */
111
112 /* Macro to extract an address from a solib structure.
113    When GDB is configured for some 32-bit targets (e.g. Solaris 2.7
114    sparc), BFD is configured to handle 64-bit targets, so CORE_ADDR is
115    64 bits.  We have to extract only the significant bits of addresses
116    to get the right address when accessing the core file BFD.  */
117
118 #define SOLIB_EXTRACT_ADDRESS(member) \
119   extract_address (&member, sizeof (member))
120
121 #ifndef SVR4_SHARED_LIBS
122
123 #define LM_ADDR(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.lm_addr))
124 #define LM_NEXT(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.lm_next))
125 #define LM_NAME(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.lm_name))
126 /* Test for first link map entry; first entry is a shared library. */
127 #define IGNORE_FIRST_LINK_MAP_ENTRY(so) (0)
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 #else /* SVR4_SHARED_LIBS */
135
136 #define LM_ADDR(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.l_addr))
137 #define LM_NEXT(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.l_next))
138 #define LM_NAME(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.l_name))
139 /* Test for first link map entry; first entry is the exec-file. */
140 #define IGNORE_FIRST_LINK_MAP_ENTRY(so) \
141   (SOLIB_EXTRACT_ADDRESS ((so) -> lm.l_prev) == 0)
142 static struct r_debug debug_copy;
143 char shadow_contents[BREAKPOINT_MAX];   /* Stash old bkpt addr contents */
144
145 #endif /* !SVR4_SHARED_LIBS */
146
147 struct so_list
148   {
149     /* The following fields of the structure come directly from the
150        dynamic linker's tables in the inferior, and are initialized by
151        current_sos.  */
152
153     struct so_list *next;       /* next structure in linked list */
154     struct link_map lm;         /* copy of link map from inferior */
155     CORE_ADDR lmaddr;           /* addr in inferior lm was read from */
156
157     /* Shared object file name, exactly as it appears in the
158        inferior's link map.  This may be a relative path, or something
159        which needs to be looked up in LD_LIBRARY_PATH, etc.  We use it
160        to tell which entries in the inferior's dynamic linker's link
161        map we've already loaded.  */
162     char so_original_name[MAX_PATH_SIZE];
163
164     /* shared object file name, expanded to something GDB can open */
165     char so_name[MAX_PATH_SIZE];
166
167     /* The following fields of the structure are built from
168        information gathered from the shared object file itself, and
169        are initialized when we actually add it to our symbol tables.  */
170
171     bfd *abfd;
172     CORE_ADDR lmend;            /* upper addr bound of mapped object */
173     char symbols_loaded;        /* flag: symbols read in yet? */
174     char from_tty;              /* flag: print msgs? */
175     struct objfile *objfile;    /* objfile for loaded lib */
176     struct section_table *sections;
177     struct section_table *sections_end;
178     struct section_table *textsection;
179   };
180
181 static struct so_list *so_list_head;    /* List of known shared objects */
182 static CORE_ADDR debug_base;    /* Base of dynamic linker structures */
183 static CORE_ADDR breakpoint_addr;       /* Address where end bkpt is set */
184
185 static int solib_cleanup_queued = 0;    /* make_run_cleanup called */
186
187 extern int
188 fdmatch PARAMS ((int, int));    /* In libiberty */
189
190 /* Local function prototypes */
191
192 static void
193 do_clear_solib PARAMS ((PTR));
194
195 static int
196 match_main PARAMS ((char *));
197
198 static void
199 special_symbol_handling PARAMS ((void));
200
201 static void
202 sharedlibrary_command PARAMS ((char *, int));
203
204 static int
205 enable_break PARAMS ((void));
206
207 static void
208 info_sharedlibrary_command PARAMS ((char *, int));
209
210 static int symbol_add_stub PARAMS ((PTR));
211
212 static CORE_ADDR
213   first_link_map_member PARAMS ((void));
214
215 static CORE_ADDR
216   locate_base PARAMS ((void));
217
218 static int solib_map_sections PARAMS ((PTR));
219
220 #ifdef SVR4_SHARED_LIBS
221
222 static CORE_ADDR
223   elf_locate_base PARAMS ((void));
224
225 #else
226
227 static struct so_list *current_sos (void);
228 static void free_so (struct so_list *node);
229
230 static int
231 disable_break PARAMS ((void));
232
233 static void
234 allocate_rt_common_objfile PARAMS ((void));
235
236 static void
237 solib_add_common_symbols (CORE_ADDR);
238
239 #endif
240
241 void _initialize_solib PARAMS ((void));
242
243 /* If non-zero, this is a prefix that will be added to the front of the name
244    shared libraries with an absolute filename for loading.  */
245 static char *solib_absolute_prefix = NULL;
246
247 /* If non-empty, this is a search path for loading non-absolute shared library
248    symbol files.  This takes precedence over the environment variables PATH
249    and LD_LIBRARY_PATH.  */
250 static char *solib_search_path = NULL;
251
252 /*
253
254    LOCAL FUNCTION
255
256    solib_map_sections -- open bfd and build sections for shared lib
257
258    SYNOPSIS
259
260    static int solib_map_sections (struct so_list *so)
261
262    DESCRIPTION
263
264    Given a pointer to one of the shared objects in our list
265    of mapped objects, use the recorded name to open a bfd
266    descriptor for the object, build a section table, and then
267    relocate all the section addresses by the base address at
268    which the shared object was mapped.
269
270    FIXMES
271
272    In most (all?) cases the shared object file name recorded in the
273    dynamic linkage tables will be a fully qualified pathname.  For
274    cases where it isn't, do we really mimic the systems search
275    mechanism correctly in the below code (particularly the tilde
276    expansion stuff?).
277  */
278
279 static int
280 solib_map_sections (arg)
281      PTR arg;
282 {
283   struct so_list *so = (struct so_list *) arg;  /* catch_errors bogon */
284   char *filename;
285   char *scratch_pathname;
286   int scratch_chan;
287   struct section_table *p;
288   struct cleanup *old_chain;
289   bfd *abfd;
290
291   filename = tilde_expand (so->so_name);
292
293   if (solib_absolute_prefix && ROOTED_P (filename))
294     /* Prefix shared libraries with absolute filenames with
295        SOLIB_ABSOLUTE_PREFIX.  */
296     {
297       char *pfxed_fn;
298       int pfx_len;
299
300       pfx_len = strlen (solib_absolute_prefix);
301
302       /* Remove trailing slashes.  */
303       while (pfx_len > 0 && SLASH_P (solib_absolute_prefix[pfx_len - 1]))
304         pfx_len--;
305
306       pfxed_fn = xmalloc (pfx_len + strlen (filename) + 1);
307       strcpy (pfxed_fn, solib_absolute_prefix);
308       strcat (pfxed_fn, filename);
309       free (filename);
310
311       filename = pfxed_fn;
312     }
313
314   old_chain = make_cleanup (free, filename);
315
316   scratch_chan = -1;
317
318   if (solib_search_path)
319     scratch_chan = openp (solib_search_path,
320                           1, filename, O_RDONLY, 0, &scratch_pathname);
321   if (scratch_chan < 0)
322     scratch_chan = openp (get_in_environ (inferior_environ, "PATH"),
323                           1, filename, O_RDONLY, 0, &scratch_pathname);
324   if (scratch_chan < 0)
325     {
326       scratch_chan = openp (get_in_environ
327                             (inferior_environ, "LD_LIBRARY_PATH"),
328                             1, filename, O_RDONLY, 0, &scratch_pathname);
329     }
330   if (scratch_chan < 0)
331     {
332       perror_with_name (filename);
333     }
334   /* Leave scratch_pathname allocated.  abfd->name will point to it.  */
335
336   abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
337   if (!abfd)
338     {
339       close (scratch_chan);
340       error ("Could not open `%s' as an executable file: %s",
341              scratch_pathname, bfd_errmsg (bfd_get_error ()));
342     }
343   /* Leave bfd open, core_xfer_memory and "info files" need it.  */
344   so->abfd = abfd;
345   abfd->cacheable = true;
346
347   /* copy full path name into so_name, so that later symbol_file_add can find
348      it */
349   if (strlen (scratch_pathname) >= MAX_PATH_SIZE)
350     error ("Full path name length of shared library exceeds MAX_PATH_SIZE in so_list structure.");
351   strcpy (so->so_name, scratch_pathname);
352
353   if (!bfd_check_format (abfd, bfd_object))
354     {
355       error ("\"%s\": not in executable format: %s.",
356              scratch_pathname, bfd_errmsg (bfd_get_error ()));
357     }
358   if (build_section_table (abfd, &so->sections, &so->sections_end))
359     {
360       error ("Can't find the file sections in `%s': %s",
361              bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
362     }
363
364   for (p = so->sections; p < so->sections_end; p++)
365     {
366       /* Relocate the section binding addresses as recorded in the shared
367          object's file by the base address to which the object was actually
368          mapped. */
369       p->addr += LM_ADDR (so);
370       p->endaddr += LM_ADDR (so);
371       so->lmend = max (p->endaddr, so->lmend);
372       if (STREQ (p->the_bfd_section->name, ".text"))
373         {
374           so->textsection = p;
375         }
376     }
377
378   /* Free the file names, close the file now.  */
379   do_cleanups (old_chain);
380
381   return (1);
382 }
383
384 #ifndef SVR4_SHARED_LIBS
385
386 /* Allocate the runtime common object file.  */
387
388 static void
389 allocate_rt_common_objfile ()
390 {
391   struct objfile *objfile;
392   struct objfile *last_one;
393
394   objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
395   memset (objfile, 0, sizeof (struct objfile));
396   objfile->md = NULL;
397   obstack_specify_allocation (&objfile->psymbol_cache.cache, 0, 0,
398                               xmalloc, free);
399   obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0, xmalloc,
400                               free);
401   obstack_specify_allocation (&objfile->symbol_obstack, 0, 0, xmalloc,
402                               free);
403   obstack_specify_allocation (&objfile->type_obstack, 0, 0, xmalloc,
404                               free);
405   objfile->name = mstrsave (objfile->md, "rt_common");
406
407   /* Add this file onto the tail of the linked list of other such files. */
408
409   objfile->next = NULL;
410   if (object_files == NULL)
411     object_files = objfile;
412   else
413     {
414       for (last_one = object_files;
415            last_one->next;
416            last_one = last_one->next);
417       last_one->next = objfile;
418     }
419
420   rt_common_objfile = objfile;
421 }
422
423 /* Read all dynamically loaded common symbol definitions from the inferior
424    and put them into the minimal symbol table for the runtime common
425    objfile.  */
426
427 static void
428 solib_add_common_symbols (rtc_symp)
429      CORE_ADDR rtc_symp;
430 {
431   struct rtc_symb inferior_rtc_symb;
432   struct nlist inferior_rtc_nlist;
433   int len;
434   char *name;
435
436   /* Remove any runtime common symbols from previous runs.  */
437
438   if (rt_common_objfile != NULL && rt_common_objfile->minimal_symbol_count)
439     {
440       obstack_free (&rt_common_objfile->symbol_obstack, 0);
441       obstack_specify_allocation (&rt_common_objfile->symbol_obstack, 0, 0,
442                                   xmalloc, free);
443       rt_common_objfile->minimal_symbol_count = 0;
444       rt_common_objfile->msymbols = NULL;
445     }
446
447   init_minimal_symbol_collection ();
448   make_cleanup ((make_cleanup_func) discard_minimal_symbols, 0);
449
450   while (rtc_symp)
451     {
452       read_memory (rtc_symp,
453                    (char *) &inferior_rtc_symb,
454                    sizeof (inferior_rtc_symb));
455       read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_sp),
456                    (char *) &inferior_rtc_nlist,
457                    sizeof (inferior_rtc_nlist));
458       if (inferior_rtc_nlist.n_type == N_COMM)
459         {
460           /* FIXME: The length of the symbol name is not available, but in the
461              current implementation the common symbol is allocated immediately
462              behind the name of the symbol. */
463           len = inferior_rtc_nlist.n_value - inferior_rtc_nlist.n_un.n_strx;
464
465           name = xmalloc (len);
466           read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_nlist.n_un.n_name),
467                        name, len);
468
469           /* Allocate the runtime common objfile if necessary. */
470           if (rt_common_objfile == NULL)
471             allocate_rt_common_objfile ();
472
473           prim_record_minimal_symbol (name, inferior_rtc_nlist.n_value,
474                                       mst_bss, rt_common_objfile);
475           free (name);
476         }
477       rtc_symp = SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_next);
478     }
479
480   /* Install any minimal symbols that have been collected as the current
481      minimal symbols for the runtime common objfile.  */
482
483   install_minimal_symbols (rt_common_objfile);
484 }
485
486 #endif /* SVR4_SHARED_LIBS */
487
488
489 #ifdef SVR4_SHARED_LIBS
490
491 static CORE_ADDR
492   bfd_lookup_symbol PARAMS ((bfd *, char *));
493
494 /*
495
496    LOCAL FUNCTION
497
498    bfd_lookup_symbol -- lookup the value for a specific symbol
499
500    SYNOPSIS
501
502    CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
503
504    DESCRIPTION
505
506    An expensive way to lookup the value of a single symbol for
507    bfd's that are only temporary anyway.  This is used by the
508    shared library support to find the address of the debugger
509    interface structures in the shared library.
510
511    Note that 0 is specifically allowed as an error return (no
512    such symbol).
513  */
514
515 static CORE_ADDR
516 bfd_lookup_symbol (abfd, symname)
517      bfd *abfd;
518      char *symname;
519 {
520   unsigned int storage_needed;
521   asymbol *sym;
522   asymbol **symbol_table;
523   unsigned int number_of_symbols;
524   unsigned int i;
525   struct cleanup *back_to;
526   CORE_ADDR symaddr = 0;
527
528   storage_needed = bfd_get_symtab_upper_bound (abfd);
529
530   if (storage_needed > 0)
531     {
532       symbol_table = (asymbol **) xmalloc (storage_needed);
533       back_to = make_cleanup (free, (PTR) symbol_table);
534       number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
535
536       for (i = 0; i < number_of_symbols; i++)
537         {
538           sym = *symbol_table++;
539           if (STREQ (sym->name, symname))
540             {
541               /* Bfd symbols are section relative. */
542               symaddr = sym->value + sym->section->vma;
543               break;
544             }
545         }
546       do_cleanups (back_to);
547     }
548   return (symaddr);
549 }
550
551 #ifdef HANDLE_SVR4_EXEC_EMULATORS
552
553 /*
554    Solaris BCP (the part of Solaris which allows it to run SunOS4
555    a.out files) throws in another wrinkle. Solaris does not fill
556    in the usual a.out link map structures when running BCP programs,
557    the only way to get at them is via groping around in the dynamic
558    linker.
559    The dynamic linker and it's structures are located in the shared
560    C library, which gets run as the executable's "interpreter" by
561    the kernel.
562
563    Note that we can assume nothing about the process state at the time
564    we need to find these structures.  We may be stopped on the first
565    instruction of the interpreter (C shared library), the first
566    instruction of the executable itself, or somewhere else entirely
567    (if we attached to the process for example).
568  */
569
570 static char *debug_base_symbols[] =
571 {
572   "r_debug",                    /* Solaris 2.3 */
573   "_r_debug",                   /* Solaris 2.1, 2.2 */
574   NULL
575 };
576
577 static int
578 look_for_base PARAMS ((int, CORE_ADDR));
579
580 /*
581
582    LOCAL FUNCTION
583
584    look_for_base -- examine file for each mapped address segment
585
586    SYNOPSYS
587
588    static int look_for_base (int fd, CORE_ADDR baseaddr)
589
590    DESCRIPTION
591
592    This function is passed to proc_iterate_over_mappings, which
593    causes it to get called once for each mapped address space, with
594    an open file descriptor for the file mapped to that space, and the
595    base address of that mapped space.
596
597    Our job is to find the debug base symbol in the file that this
598    fd is open on, if it exists, and if so, initialize the dynamic
599    linker structure base address debug_base.
600
601    Note that this is a computationally expensive proposition, since
602    we basically have to open a bfd on every call, so we specifically
603    avoid opening the exec file.
604  */
605
606 static int
607 look_for_base (fd, baseaddr)
608      int fd;
609      CORE_ADDR baseaddr;
610 {
611   bfd *interp_bfd;
612   CORE_ADDR address = 0;
613   char **symbolp;
614
615   /* If the fd is -1, then there is no file that corresponds to this
616      mapped memory segment, so skip it.  Also, if the fd corresponds
617      to the exec file, skip it as well. */
618
619   if (fd == -1
620       || (exec_bfd != NULL
621           && fdmatch (fileno ((FILE *) (exec_bfd->iostream)), fd)))
622     {
623       return (0);
624     }
625
626   /* Try to open whatever random file this fd corresponds to.  Note that
627      we have no way currently to find the filename.  Don't gripe about
628      any problems we might have, just fail. */
629
630   if ((interp_bfd = bfd_fdopenr ("unnamed", gnutarget, fd)) == NULL)
631     {
632       return (0);
633     }
634   if (!bfd_check_format (interp_bfd, bfd_object))
635     {
636       /* FIXME-leak: on failure, might not free all memory associated with
637          interp_bfd.  */
638       bfd_close (interp_bfd);
639       return (0);
640     }
641
642   /* Now try to find our debug base symbol in this file, which we at
643      least know to be a valid ELF executable or shared library. */
644
645   for (symbolp = debug_base_symbols; *symbolp != NULL; symbolp++)
646     {
647       address = bfd_lookup_symbol (interp_bfd, *symbolp);
648       if (address != 0)
649         {
650           break;
651         }
652     }
653   if (address == 0)
654     {
655       /* FIXME-leak: on failure, might not free all memory associated with
656          interp_bfd.  */
657       bfd_close (interp_bfd);
658       return (0);
659     }
660
661   /* Eureka!  We found the symbol.  But now we may need to relocate it
662      by the base address.  If the symbol's value is less than the base
663      address of the shared library, then it hasn't yet been relocated
664      by the dynamic linker, and we have to do it ourself.  FIXME: Note
665      that we make the assumption that the first segment that corresponds
666      to the shared library has the base address to which the library
667      was relocated. */
668
669   if (address < baseaddr)
670     {
671       address += baseaddr;
672     }
673   debug_base = address;
674   /* FIXME-leak: on failure, might not free all memory associated with
675      interp_bfd.  */
676   bfd_close (interp_bfd);
677   return (1);
678 }
679 #endif /* HANDLE_SVR4_EXEC_EMULATORS */
680
681 /*
682
683    LOCAL FUNCTION
684
685    elf_locate_base -- locate the base address of dynamic linker structs
686    for SVR4 elf targets.
687
688    SYNOPSIS
689
690    CORE_ADDR elf_locate_base (void)
691
692    DESCRIPTION
693
694    For SVR4 elf targets the address of the dynamic linker's runtime
695    structure is contained within the dynamic info section in the
696    executable file.  The dynamic section is also mapped into the
697    inferior address space.  Because the runtime loader fills in the
698    real address before starting the inferior, we have to read in the
699    dynamic info section from the inferior address space.
700    If there are any errors while trying to find the address, we
701    silently return 0, otherwise the found address is returned.
702
703  */
704
705 static CORE_ADDR
706 elf_locate_base ()
707 {
708   sec_ptr dyninfo_sect;
709   int dyninfo_sect_size;
710   CORE_ADDR dyninfo_addr;
711   char *buf;
712   char *bufend;
713
714   /* Find the start address of the .dynamic section.  */
715   dyninfo_sect = bfd_get_section_by_name (exec_bfd, ".dynamic");
716   if (dyninfo_sect == NULL)
717     return 0;
718   dyninfo_addr = bfd_section_vma (exec_bfd, dyninfo_sect);
719
720   /* Read in .dynamic section, silently ignore errors.  */
721   dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);
722   buf = alloca (dyninfo_sect_size);
723   if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))
724     return 0;
725
726   /* Find the DT_DEBUG entry in the the .dynamic section.
727      For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
728      no DT_DEBUG entries.  */
729 #ifndef TARGET_ELF64
730   for (bufend = buf + dyninfo_sect_size;
731        buf < bufend;
732        buf += sizeof (Elf32_External_Dyn))
733     {
734       Elf32_External_Dyn *x_dynp = (Elf32_External_Dyn *) buf;
735       long dyn_tag;
736       CORE_ADDR dyn_ptr;
737
738       dyn_tag = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
739       if (dyn_tag == DT_NULL)
740         break;
741       else if (dyn_tag == DT_DEBUG)
742         {
743           dyn_ptr = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_un.d_ptr);
744           return dyn_ptr;
745         }
746 #ifdef DT_MIPS_RLD_MAP
747       else if (dyn_tag == DT_MIPS_RLD_MAP)
748         {
749           char pbuf[TARGET_PTR_BIT / HOST_CHAR_BIT];
750
751           /* DT_MIPS_RLD_MAP contains a pointer to the address
752              of the dynamic link structure.  */
753           dyn_ptr = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_un.d_ptr);
754           if (target_read_memory (dyn_ptr, pbuf, sizeof (pbuf)))
755             return 0;
756           return extract_unsigned_integer (pbuf, sizeof (pbuf));
757         }
758 #endif
759     }
760 #else /* ELF64 */
761   for (bufend = buf + dyninfo_sect_size;
762        buf < bufend;
763        buf += sizeof (Elf64_External_Dyn))
764     {
765       Elf64_External_Dyn *x_dynp = (Elf64_External_Dyn *) buf;
766       long dyn_tag;
767       CORE_ADDR dyn_ptr;
768
769       dyn_tag = bfd_h_get_64 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
770       if (dyn_tag == DT_NULL)
771         break;
772       else if (dyn_tag == DT_DEBUG)
773         {
774           dyn_ptr = bfd_h_get_64 (exec_bfd, (bfd_byte *) x_dynp->d_un.d_ptr);
775           return dyn_ptr;
776         }
777     }
778 #endif
779
780   /* DT_DEBUG entry not found.  */
781   return 0;
782 }
783
784 #endif /* SVR4_SHARED_LIBS */
785
786 /*
787
788    LOCAL FUNCTION
789
790    locate_base -- locate the base address of dynamic linker structs
791
792    SYNOPSIS
793
794    CORE_ADDR locate_base (void)
795
796    DESCRIPTION
797
798    For both the SunOS and SVR4 shared library implementations, if the
799    inferior executable has been linked dynamically, there is a single
800    address somewhere in the inferior's data space which is the key to
801    locating all of the dynamic linker's runtime structures.  This
802    address is the value of the debug base symbol.  The job of this
803    function is to find and return that address, or to return 0 if there
804    is no such address (the executable is statically linked for example).
805
806    For SunOS, the job is almost trivial, since the dynamic linker and
807    all of it's structures are statically linked to the executable at
808    link time.  Thus the symbol for the address we are looking for has
809    already been added to the minimal symbol table for the executable's
810    objfile at the time the symbol file's symbols were read, and all we
811    have to do is look it up there.  Note that we explicitly do NOT want
812    to find the copies in the shared library.
813
814    The SVR4 version is a bit more complicated because the address
815    is contained somewhere in the dynamic info section.  We have to go
816    to a lot more work to discover the address of the debug base symbol.
817    Because of this complexity, we cache the value we find and return that
818    value on subsequent invocations.  Note there is no copy in the
819    executable symbol tables.
820
821  */
822
823 static CORE_ADDR
824 locate_base ()
825 {
826
827 #ifndef SVR4_SHARED_LIBS
828
829   struct minimal_symbol *msymbol;
830   CORE_ADDR address = 0;
831   char **symbolp;
832
833   /* For SunOS, we want to limit the search for the debug base symbol to the
834      executable being debugged, since there is a duplicate named symbol in the
835      shared library.  We don't want the shared library versions. */
836
837   for (symbolp = debug_base_symbols; *symbolp != NULL; symbolp++)
838     {
839       msymbol = lookup_minimal_symbol (*symbolp, NULL, symfile_objfile);
840       if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
841         {
842           address = SYMBOL_VALUE_ADDRESS (msymbol);
843           return (address);
844         }
845     }
846   return (0);
847
848 #else /* SVR4_SHARED_LIBS */
849
850   /* Check to see if we have a currently valid address, and if so, avoid
851      doing all this work again and just return the cached address.  If
852      we have no cached address, try to locate it in the dynamic info
853      section for ELF executables.  */
854
855   if (debug_base == 0)
856     {
857       if (exec_bfd != NULL
858           && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
859         debug_base = elf_locate_base ();
860 #ifdef HANDLE_SVR4_EXEC_EMULATORS
861       /* Try it the hard way for emulated executables.  */
862       else if (inferior_pid != 0 && target_has_execution)
863         proc_iterate_over_mappings (look_for_base);
864 #endif
865     }
866   return (debug_base);
867
868 #endif /* !SVR4_SHARED_LIBS */
869
870 }
871
872 /*
873
874    LOCAL FUNCTION
875
876    first_link_map_member -- locate first member in dynamic linker's map
877
878    SYNOPSIS
879
880    static CORE_ADDR first_link_map_member (void)
881
882    DESCRIPTION
883
884    Find the first element in the inferior's dynamic link map, and
885    return its address in the inferior.  This function doesn't copy the
886    link map entry itself into our address space; current_sos actually
887    does the reading.  */
888
889 static CORE_ADDR
890 first_link_map_member ()
891 {
892   CORE_ADDR lm = 0;
893
894 #ifndef SVR4_SHARED_LIBS
895
896   read_memory (debug_base, (char *) &dynamic_copy, sizeof (dynamic_copy));
897   if (dynamic_copy.ld_version >= 2)
898     {
899       /* It is a version that we can deal with, so read in the secondary
900          structure and find the address of the link map list from it. */
901       read_memory (SOLIB_EXTRACT_ADDRESS (dynamic_copy.ld_un.ld_2),
902                    (char *) &ld_2_copy, sizeof (struct link_dynamic_2));
903       lm = SOLIB_EXTRACT_ADDRESS (ld_2_copy.ld_loaded);
904     }
905
906 #else /* SVR4_SHARED_LIBS */
907
908   read_memory (debug_base, (char *) &debug_copy, sizeof (struct r_debug));
909   /* FIXME:  Perhaps we should validate the info somehow, perhaps by
910      checking r_version for a known version number, or r_state for
911      RT_CONSISTENT. */
912   lm = SOLIB_EXTRACT_ADDRESS (debug_copy.r_map);
913
914 #endif /* !SVR4_SHARED_LIBS */
915
916   return (lm);
917 }
918
919 #ifdef SVR4_SHARED_LIBS
920 /*
921
922   LOCAL FUNCTION
923
924   open_symbol_file_object
925
926   SYNOPSIS
927
928   void open_symbol_file_object (int from_tty)
929
930   DESCRIPTION
931
932   If no open symbol file, attempt to locate and open the main symbol
933   file.  On SVR4 systems, this is the first link map entry.  If its
934   name is here, we can open it.  Useful when attaching to a process
935   without first loading its symbol file.
936
937  */
938
939 static int
940 open_symbol_file_object (from_ttyp)
941      int *from_ttyp;    /* sneak past catch_errors */
942 {
943   CORE_ADDR lm;
944   struct link_map lmcopy;
945   char *filename;
946   int errcode;
947
948   if (symfile_objfile)
949     if (!query ("Attempt to reload symbols from process? "))
950       return 0;
951
952   if ((debug_base = locate_base ()) == 0)
953     return 0;   /* failed somehow... */
954
955   /* First link map member should be the executable.  */
956   if ((lm = first_link_map_member ()) == 0)
957     return 0;   /* failed somehow... */
958
959   /* Read from target memory to GDB.  */
960   read_memory (lm, (void *) &lmcopy, sizeof (lmcopy));
961
962   if (lmcopy.l_name == 0)
963     return 0;   /* no filename.  */
964
965   /* Now fetch the filename from target memory.  */
966   target_read_string (SOLIB_EXTRACT_ADDRESS (lmcopy.l_name), &filename, 
967                       MAX_PATH_SIZE - 1, &errcode);
968   if (errcode)
969     {
970       warning ("failed to read exec filename from attached file: %s",
971                safe_strerror (errcode));
972       return 0;
973     }
974
975   make_cleanup ((make_cleanup_func) free, (void *) filename);
976   /* Have a pathname: read the symbol file.  */
977   symbol_file_command (filename, *from_ttyp);
978
979   return 1;
980 }
981 #endif /* SVR4_SHARED_LIBS */
982
983
984 /* LOCAL FUNCTION
985
986    free_so --- free a `struct so_list' object
987
988    SYNOPSIS
989
990    void free_so (struct so_list *so)
991
992    DESCRIPTION
993
994    Free the storage associated with the `struct so_list' object SO.
995    If we have opened a BFD for SO, close it.  
996
997    The caller is responsible for removing SO from whatever list it is
998    a member of.  If we have placed SO's sections in some target's
999    section table, the caller is responsible for removing them.
1000
1001    This function doesn't mess with objfiles at all.  If there is an
1002    objfile associated with SO that needs to be removed, the caller is
1003    responsible for taking care of that.  */
1004
1005 static void
1006 free_so (struct so_list *so)
1007 {
1008   char *bfd_filename = 0;
1009
1010   if (so->sections)
1011     free (so->sections);
1012       
1013   if (so->abfd)
1014     {
1015       bfd_filename = bfd_get_filename (so->abfd);
1016       if (! bfd_close (so->abfd))
1017         warning ("cannot close \"%s\": %s",
1018                  bfd_filename, bfd_errmsg (bfd_get_error ()));
1019     }
1020
1021   if (bfd_filename)
1022     free (bfd_filename);
1023
1024   free (so);
1025 }
1026
1027
1028 /* On some systems, the only way to recognize the link map entry for
1029    the main executable file is by looking at its name.  Return
1030    non-zero iff SONAME matches one of the known main executable names.  */
1031
1032 static int
1033 match_main (soname)
1034      char *soname;
1035 {
1036   char **mainp;
1037
1038   for (mainp = main_name_list; *mainp != NULL; mainp++)
1039     {
1040       if (strcmp (soname, *mainp) == 0)
1041         return (1);
1042     }
1043
1044   return (0);
1045 }
1046
1047
1048 /* LOCAL FUNCTION
1049
1050    current_sos -- build a list of currently loaded shared objects
1051
1052    SYNOPSIS
1053
1054    struct so_list *current_sos ()
1055
1056    DESCRIPTION
1057
1058    Build a list of `struct so_list' objects describing the shared
1059    objects currently loaded in the inferior.  This list does not
1060    include an entry for the main executable file.
1061
1062    Note that we only gather information directly available from the
1063    inferior --- we don't examine any of the shared library files
1064    themselves.  The declaration of `struct so_list' says which fields
1065    we provide values for.  */
1066
1067 static struct so_list *
1068 current_sos ()
1069 {
1070   CORE_ADDR lm;
1071   struct so_list *head = 0;
1072   struct so_list **link_ptr = &head;
1073
1074   /* Make sure we've looked up the inferior's dynamic linker's base
1075      structure.  */
1076   if (! debug_base)
1077     {
1078       debug_base = locate_base ();
1079
1080       /* If we can't find the dynamic linker's base structure, this
1081          must not be a dynamically linked executable.  Hmm.  */
1082       if (! debug_base)
1083         return 0;
1084     }
1085
1086   /* Walk the inferior's link map list, and build our list of
1087      `struct so_list' nodes.  */
1088   lm = first_link_map_member ();  
1089   while (lm)
1090     {
1091       struct so_list *new
1092         = (struct so_list *) xmalloc (sizeof (struct so_list));
1093       struct cleanup *old_chain = make_cleanup (free, new);
1094       memset (new, 0, sizeof (*new));
1095
1096       new->lmaddr = lm;
1097       read_memory (lm, (char *) &(new->lm), sizeof (struct link_map));
1098
1099       lm = LM_NEXT (new);
1100
1101       /* For SVR4 versions, the first entry in the link map is for the
1102          inferior executable, so we must ignore it.  For some versions of
1103          SVR4, it has no name.  For others (Solaris 2.3 for example), it
1104          does have a name, so we can no longer use a missing name to
1105          decide when to ignore it. */
1106       if (IGNORE_FIRST_LINK_MAP_ENTRY (new))
1107         free_so (new);
1108       else
1109         {
1110           int errcode;
1111           char *buffer;
1112
1113           /* Extract this shared object's name.  */
1114           target_read_string (LM_NAME (new), &buffer,
1115                               MAX_PATH_SIZE - 1, &errcode);
1116           if (errcode != 0)
1117             {
1118               warning ("current_sos: Can't read pathname for load map: %s\n",
1119                        safe_strerror (errcode));
1120             }
1121           else
1122             {
1123               strncpy (new->so_name, buffer, MAX_PATH_SIZE - 1);
1124               new->so_name[MAX_PATH_SIZE - 1] = '\0';
1125               free (buffer);
1126               strcpy (new->so_original_name, new->so_name);
1127             }
1128
1129           /* If this entry has no name, or its name matches the name
1130              for the main executable, don't include it in the list.  */
1131           if (! new->so_name[0]
1132               || match_main (new->so_name))
1133             free_so (new);
1134           else
1135             {
1136               new->next = 0;
1137               *link_ptr = new;
1138               link_ptr = &new->next;
1139             }
1140         }
1141
1142       discard_cleanups (old_chain);
1143     }
1144
1145   return head;
1146 }
1147
1148
1149 /* A small stub to get us past the arg-passing pinhole of catch_errors.  */
1150
1151 static int
1152 symbol_add_stub (arg)
1153      PTR arg;
1154 {
1155   register struct so_list *so = (struct so_list *) arg;  /* catch_errs bogon */
1156   CORE_ADDR text_addr = 0;
1157   struct section_addr_info *sap;
1158
1159   /* Have we already loaded this shared object?  */
1160   ALL_OBJFILES (so->objfile)
1161     {
1162       if (strcmp (so->objfile->name, so->so_name) == 0)
1163         return 1;
1164     }
1165
1166   /* Find the shared object's text segment.  */
1167   if (so->textsection)
1168     text_addr = so->textsection->addr;
1169   else if (so->abfd != NULL)
1170     {
1171       asection *lowest_sect;
1172
1173       /* If we didn't find a mapped non zero sized .text section, set up
1174          text_addr so that the relocation in symbol_file_add does no harm.  */
1175       lowest_sect = bfd_get_section_by_name (so->abfd, ".text");
1176       if (lowest_sect == NULL)
1177         bfd_map_over_sections (so->abfd, find_lowest_section,
1178                                (PTR) &lowest_sect);
1179       if (lowest_sect)
1180         text_addr = bfd_section_vma (so->abfd, lowest_sect)
1181           + LM_ADDR (so);
1182     }
1183
1184   sap = build_section_addr_info_from_section_table (so->sections,
1185                                                     so->sections_end);
1186   sap->text_addr = text_addr;
1187   so->objfile = symbol_file_add (so->so_name, so->from_tty,
1188                                  sap, 0, OBJF_SHARED);
1189   free_section_addr_info (sap);
1190
1191   return (1);
1192 }
1193
1194
1195 /* LOCAL FUNCTION
1196
1197    solib_add -- synchronize GDB's shared object list with the inferior's
1198
1199    SYNOPSIS
1200
1201    void solib_add (char *pattern, int from_tty, struct target_ops *TARGET)
1202
1203    DESCRIPTION
1204
1205    Extract the list of currently loaded shared objects from the
1206    inferior, and compare it with the list of shared objects for which
1207    GDB has currently loaded symbolic information.  If new shared
1208    objects have been loaded, or old shared objects have disappeared,
1209    make the appropriate changes to GDB's tables.
1210
1211    If PATTERN is non-null, read symbols only for shared objects
1212    whose names match PATTERN.
1213
1214    If FROM_TTY is non-null, feel free to print messages about what
1215    we're doing.
1216
1217    If TARGET is non-null, add the sections of all new shared objects
1218    to TARGET's section table.  Note that this doesn't remove any
1219    sections for shared objects that have been unloaded, and it
1220    doesn't check to see if the new shared objects are already present in
1221    the section table.  But we only use this for core files and
1222    processes we've just attached to, so that's okay.  */
1223
1224 void
1225 solib_add (char *pattern, int from_tty, struct target_ops *target)
1226 {
1227   struct so_list *inferior = current_sos ();
1228   struct so_list *gdb, **gdb_link;
1229
1230 #ifdef SVR4_SHARED_LIBS
1231   /* If we are attaching to a running process for which we 
1232      have not opened a symbol file, we may be able to get its 
1233      symbols now!  */
1234   if (attach_flag &&
1235       symfile_objfile == NULL)
1236     catch_errors (open_symbol_file_object, (PTR) &from_tty, 
1237                   "Error reading attached process's symbol file.\n",
1238                   RETURN_MASK_ALL);
1239
1240 #endif SVR4_SHARED_LIBS
1241
1242   if (pattern)
1243     {
1244       char *re_err = re_comp (pattern);
1245
1246       if (re_err)
1247         error ("Invalid regexp: %s", re_err);
1248     }
1249
1250   /* Since this function might actually add some elements to the
1251      so_list_head list, arrange for it to be cleaned up when
1252      appropriate.  */
1253   if (!solib_cleanup_queued)
1254     {
1255       make_run_cleanup (do_clear_solib, NULL);
1256       solib_cleanup_queued = 1;
1257     }
1258
1259   /* GDB and the inferior's dynamic linker each maintain their own
1260      list of currently loaded shared objects; we want to bring the
1261      former in sync with the latter.  Scan both lists, seeing which
1262      shared objects appear where.  There are three cases:
1263
1264      - A shared object appears on both lists.  This means that GDB
1265        knows about it already, and it's still loaded in the inferior.
1266        Nothing needs to happen.
1267
1268      - A shared object appears only on GDB's list.  This means that
1269        the inferior has unloaded it.  We should remove the shared
1270        object from GDB's tables.
1271
1272      - A shared object appears only on the inferior's list.  This
1273        means that it's just been loaded.  We should add it to GDB's
1274        tables.
1275
1276      So we walk GDB's list, checking each entry to see if it appears
1277      in the inferior's list too.  If it does, no action is needed, and
1278      we remove it from the inferior's list.  If it doesn't, the
1279      inferior has unloaded it, and we remove it from GDB's list.  By
1280      the time we're done walking GDB's list, the inferior's list
1281      contains only the new shared objects, which we then add.  */
1282
1283   gdb = so_list_head;
1284   gdb_link = &so_list_head;
1285   while (gdb)
1286     {
1287       struct so_list *i = inferior;
1288       struct so_list **i_link = &inferior;
1289
1290       /* Check to see whether the shared object *gdb also appears in
1291          the inferior's current list.  */
1292       while (i)
1293         {
1294           if (! strcmp (gdb->so_original_name, i->so_original_name))
1295             break;
1296
1297           i_link = &i->next;
1298           i = *i_link;
1299         }
1300
1301       /* If the shared object appears on the inferior's list too, then
1302          it's still loaded, so we don't need to do anything.  Delete
1303          it from the inferior's list, and leave it on GDB's list.  */
1304       if (i)
1305         {
1306           *i_link = i->next;
1307           free_so (i);
1308           gdb_link = &gdb->next;
1309           gdb = *gdb_link;
1310         }
1311
1312       /* If it's not on the inferior's list, remove it from GDB's tables.  */
1313       else
1314         {
1315           *gdb_link = gdb->next;
1316
1317           /* Unless the user loaded it explicitly, free SO's objfile.  */
1318           if (! (gdb->objfile->flags & OBJF_USERLOADED))
1319             free_objfile (gdb->objfile);
1320
1321           /* Some targets' section tables might be referring to
1322              sections from so->abfd; remove them.  */
1323           remove_target_sections (gdb->abfd);
1324
1325           free_so (gdb);
1326           gdb = *gdb_link;
1327         }
1328     }
1329
1330   /* Now the inferior's list contains only shared objects that don't
1331      appear in GDB's list --- those that are newly loaded.  Add them
1332      to GDB's shared object list, and read in their symbols, if
1333      appropriate.  */
1334   if (inferior)
1335     {
1336       struct so_list *i;
1337
1338       /* Add the new shared objects to GDB's list.  */
1339       *gdb_link = inferior;
1340
1341       /* Fill in the rest of each of the `struct so_list' nodes, and
1342          read symbols for those files whose names match PATTERN.  */
1343       for (i = inferior; i; i = i->next)
1344         {
1345           i->from_tty = from_tty;
1346
1347           /* Fill in the rest of the `struct so_list' node.  */
1348           catch_errors (solib_map_sections, i,
1349                         "Error while mapping shared library sections:\n",
1350                         RETURN_MASK_ALL);
1351
1352           if (! pattern || re_exec (i->so_name))
1353             {
1354               if (i->symbols_loaded)
1355                 {
1356                   if (from_tty)
1357                     printf_unfiltered ("Symbols already loaded for %s\n",
1358                                        i->so_name);
1359                 }
1360               else
1361                 {
1362                   if (catch_errors
1363                       (symbol_add_stub, i,
1364                        "Error while reading shared library symbols:\n",
1365                        RETURN_MASK_ALL))
1366                     {
1367                       if (from_tty)
1368                         printf_unfiltered ("Loaded symbols for %s\n",
1369                                            i->so_name);
1370                       i->symbols_loaded = 1;
1371                     }
1372                 }
1373             }
1374         }
1375
1376       /* If requested, add the shared objects' sections to the the
1377          TARGET's section table.  */
1378       if (target)
1379         {
1380           int new_sections;
1381
1382           /* Figure out how many sections we'll need to add in total.  */
1383           new_sections = 0;
1384           for (i = inferior; i; i = i->next)
1385             new_sections += (i->sections_end - i->sections);
1386
1387           if (new_sections > 0)
1388             {
1389               int space = target_resize_to_sections (target, new_sections);
1390
1391               for (i = inferior; i; i = i->next)
1392                 {
1393                   int count = (i->sections_end - i->sections);
1394                   memcpy (target->to_sections + space,
1395                           i->sections,
1396                           count * sizeof (i->sections[0]));
1397                   space += count;
1398                 }
1399             }
1400         }
1401
1402       /* Getting new symbols may change our opinion about what is
1403          frameless.  */
1404       reinit_frame_cache ();
1405
1406       special_symbol_handling ();
1407     }
1408 }
1409
1410
1411 /*
1412
1413    LOCAL FUNCTION
1414
1415    info_sharedlibrary_command -- code for "info sharedlibrary"
1416
1417    SYNOPSIS
1418
1419    static void info_sharedlibrary_command ()
1420
1421    DESCRIPTION
1422
1423    Walk through the shared library list and print information
1424    about each attached library.
1425  */
1426
1427 static void
1428 info_sharedlibrary_command (ignore, from_tty)
1429      char *ignore;
1430      int from_tty;
1431 {
1432   register struct so_list *so = NULL;   /* link map state variable */
1433   int header_done = 0;
1434   int addr_width;
1435   char *addr_fmt;
1436
1437   if (exec_bfd == NULL)
1438     {
1439       printf_unfiltered ("No executable file.\n");
1440       return;
1441     }
1442
1443 #ifndef TARGET_ELF64
1444   addr_width = 8 + 4;
1445   addr_fmt = "08l";
1446 #else
1447   addr_width = 16 + 4;
1448   addr_fmt = "016l";
1449 #endif
1450
1451   solib_add (0, 0, 0);
1452
1453   for (so = so_list_head; so; so = so->next)
1454     {
1455       if (so->so_name[0])
1456         {
1457           if (!header_done)
1458             {
1459               printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width, "From",
1460                                  addr_width, "To", "Syms Read",
1461                                  "Shared Object Library");
1462               header_done++;
1463             }
1464
1465           printf_unfiltered ("%-*s", addr_width,
1466                       local_hex_string_custom ((unsigned long) LM_ADDR (so),
1467                                                addr_fmt));
1468           printf_unfiltered ("%-*s", addr_width,
1469                          local_hex_string_custom ((unsigned long) so->lmend,
1470                                                   addr_fmt));
1471           printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
1472           printf_unfiltered ("%s\n", so->so_name);
1473         }
1474     }
1475   if (so_list_head == NULL)
1476     {
1477       printf_unfiltered ("No shared libraries loaded at this time.\n");
1478     }
1479 }
1480
1481 /*
1482
1483    GLOBAL FUNCTION
1484
1485    solib_address -- check to see if an address is in a shared lib
1486
1487    SYNOPSIS
1488
1489    char * solib_address (CORE_ADDR address)
1490
1491    DESCRIPTION
1492
1493    Provides a hook for other gdb routines to discover whether or
1494    not a particular address is within the mapped address space of
1495    a shared library.  Any address between the base mapping address
1496    and the first address beyond the end of the last mapping, is
1497    considered to be within the shared library address space, for
1498    our purposes.
1499
1500    For example, this routine is called at one point to disable
1501    breakpoints which are in shared libraries that are not currently
1502    mapped in.
1503  */
1504
1505 char *
1506 solib_address (address)
1507      CORE_ADDR address;
1508 {
1509   register struct so_list *so = 0;      /* link map state variable */
1510
1511   for (so = so_list_head; so; so = so->next)
1512     {
1513       if (LM_ADDR (so) <= address && address < so->lmend)
1514         return (so->so_name);
1515     }
1516
1517   return (0);
1518 }
1519
1520 /* Called by free_all_symtabs */
1521
1522 void
1523 clear_solib ()
1524 {
1525   /* This function is expected to handle ELF shared libraries.  It is
1526      also used on Solaris, which can run either ELF or a.out binaries
1527      (for compatibility with SunOS 4), both of which can use shared
1528      libraries.  So we don't know whether we have an ELF executable or
1529      an a.out executable until the user chooses an executable file.
1530
1531      ELF shared libraries don't get mapped into the address space
1532      until after the program starts, so we'd better not try to insert
1533      breakpoints in them immediately.  We have to wait until the
1534      dynamic linker has loaded them; we'll hit a bp_shlib_event
1535      breakpoint (look for calls to create_solib_event_breakpoint) when
1536      it's ready.
1537
1538      SunOS shared libraries seem to be different --- they're present
1539      as soon as the process begins execution, so there's no need to
1540      put off inserting breakpoints.  There's also nowhere to put a
1541      bp_shlib_event breakpoint, so if we put it off, we'll never get
1542      around to it.
1543
1544      So: disable breakpoints only if we're using ELF shared libs.  */
1545   if (exec_bfd != NULL
1546       && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
1547     disable_breakpoints_in_shlibs (1);
1548
1549   while (so_list_head)
1550     {
1551       struct so_list *so = so_list_head;
1552       so_list_head = so->next;
1553       free_so (so);
1554     }
1555
1556   debug_base = 0;
1557 }
1558
1559 static void
1560 do_clear_solib (dummy)
1561      PTR dummy;
1562 {
1563   solib_cleanup_queued = 0;
1564   clear_solib ();
1565 }
1566
1567 #ifdef SVR4_SHARED_LIBS
1568
1569 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1570    SVR4 run time loader.  */
1571
1572 static CORE_ADDR interp_text_sect_low;
1573 static CORE_ADDR interp_text_sect_high;
1574 static CORE_ADDR interp_plt_sect_low;
1575 static CORE_ADDR interp_plt_sect_high;
1576
1577 int
1578 in_svr4_dynsym_resolve_code (pc)
1579      CORE_ADDR pc;
1580 {
1581   return ((pc >= interp_text_sect_low && pc < interp_text_sect_high)
1582           || (pc >= interp_plt_sect_low && pc < interp_plt_sect_high)
1583           || in_plt_section (pc, NULL));
1584 }
1585 #endif
1586
1587 /*
1588
1589    LOCAL FUNCTION
1590
1591    disable_break -- remove the "mapping changed" breakpoint
1592
1593    SYNOPSIS
1594
1595    static int disable_break ()
1596
1597    DESCRIPTION
1598
1599    Removes the breakpoint that gets hit when the dynamic linker
1600    completes a mapping change.
1601
1602  */
1603
1604 #ifndef SVR4_SHARED_LIBS
1605
1606 static int
1607 disable_break ()
1608 {
1609   int status = 1;
1610
1611 #ifndef SVR4_SHARED_LIBS
1612
1613   int in_debugger = 0;
1614
1615   /* Read the debugger structure from the inferior to retrieve the
1616      address of the breakpoint and the original contents of the
1617      breakpoint address.  Remove the breakpoint by writing the original
1618      contents back. */
1619
1620   read_memory (debug_addr, (char *) &debug_copy, sizeof (debug_copy));
1621
1622   /* Set `in_debugger' to zero now. */
1623
1624   write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
1625
1626   breakpoint_addr = SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_bp_addr);
1627   write_memory (breakpoint_addr, (char *) &debug_copy.ldd_bp_inst,
1628                 sizeof (debug_copy.ldd_bp_inst));
1629
1630 #else /* SVR4_SHARED_LIBS */
1631
1632   /* Note that breakpoint address and original contents are in our address
1633      space, so we just need to write the original contents back. */
1634
1635   if (memory_remove_breakpoint (breakpoint_addr, shadow_contents) != 0)
1636     {
1637       status = 0;
1638     }
1639
1640 #endif /* !SVR4_SHARED_LIBS */
1641
1642   /* For the SVR4 version, we always know the breakpoint address.  For the
1643      SunOS version we don't know it until the above code is executed.
1644      Grumble if we are stopped anywhere besides the breakpoint address. */
1645
1646   if (stop_pc != breakpoint_addr)
1647     {
1648       warning ("stopped at unknown breakpoint while handling shared libraries");
1649     }
1650
1651   return (status);
1652 }
1653
1654 #endif /* #ifdef SVR4_SHARED_LIBS */
1655
1656 /*
1657
1658    LOCAL FUNCTION
1659
1660    enable_break -- arrange for dynamic linker to hit breakpoint
1661
1662    SYNOPSIS
1663
1664    int enable_break (void)
1665
1666    DESCRIPTION
1667
1668    Both the SunOS and the SVR4 dynamic linkers have, as part of their
1669    debugger interface, support for arranging for the inferior to hit
1670    a breakpoint after mapping in the shared libraries.  This function
1671    enables that breakpoint.
1672
1673    For SunOS, there is a special flag location (in_debugger) which we
1674    set to 1.  When the dynamic linker sees this flag set, it will set
1675    a breakpoint at a location known only to itself, after saving the
1676    original contents of that place and the breakpoint address itself,
1677    in it's own internal structures.  When we resume the inferior, it
1678    will eventually take a SIGTRAP when it runs into the breakpoint.
1679    We handle this (in a different place) by restoring the contents of
1680    the breakpointed location (which is only known after it stops),
1681    chasing around to locate the shared libraries that have been
1682    loaded, then resuming.
1683
1684    For SVR4, the debugger interface structure contains a member (r_brk)
1685    which is statically initialized at the time the shared library is
1686    built, to the offset of a function (_r_debug_state) which is guaran-
1687    teed to be called once before mapping in a library, and again when
1688    the mapping is complete.  At the time we are examining this member,
1689    it contains only the unrelocated offset of the function, so we have
1690    to do our own relocation.  Later, when the dynamic linker actually
1691    runs, it relocates r_brk to be the actual address of _r_debug_state().
1692
1693    The debugger interface structure also contains an enumeration which
1694    is set to either RT_ADD or RT_DELETE prior to changing the mapping,
1695    depending upon whether or not the library is being mapped or unmapped,
1696    and then set to RT_CONSISTENT after the library is mapped/unmapped.
1697  */
1698
1699 static int
1700 enable_break ()
1701 {
1702   int success = 0;
1703
1704 #ifndef SVR4_SHARED_LIBS
1705
1706   int j;
1707   int in_debugger;
1708
1709   /* Get link_dynamic structure */
1710
1711   j = target_read_memory (debug_base, (char *) &dynamic_copy,
1712                           sizeof (dynamic_copy));
1713   if (j)
1714     {
1715       /* unreadable */
1716       return (0);
1717     }
1718
1719   /* Calc address of debugger interface structure */
1720
1721   debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
1722
1723   /* Calc address of `in_debugger' member of debugger interface structure */
1724
1725   flag_addr = debug_addr + (CORE_ADDR) ((char *) &debug_copy.ldd_in_debugger -
1726                                         (char *) &debug_copy);
1727
1728   /* Write a value of 1 to this member.  */
1729
1730   in_debugger = 1;
1731   write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
1732   success = 1;
1733
1734 #else /* SVR4_SHARED_LIBS */
1735
1736 #ifdef BKPT_AT_SYMBOL
1737
1738   struct minimal_symbol *msymbol;
1739   char **bkpt_namep;
1740   asection *interp_sect;
1741
1742   /* First, remove all the solib event breakpoints.  Their addresses
1743      may have changed since the last time we ran the program.  */
1744   remove_solib_event_breakpoints ();
1745
1746 #ifdef SVR4_SHARED_LIBS
1747   interp_text_sect_low = interp_text_sect_high = 0;
1748   interp_plt_sect_low = interp_plt_sect_high = 0;
1749
1750   /* Find the .interp section; if not found, warn the user and drop
1751      into the old breakpoint at symbol code.  */
1752   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
1753   if (interp_sect)
1754     {
1755       unsigned int interp_sect_size;
1756       char *buf;
1757       CORE_ADDR load_addr;
1758       bfd *tmp_bfd;
1759       CORE_ADDR sym_addr = 0;
1760
1761       /* Read the contents of the .interp section into a local buffer;
1762          the contents specify the dynamic linker this program uses.  */
1763       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
1764       buf = alloca (interp_sect_size);
1765       bfd_get_section_contents (exec_bfd, interp_sect,
1766                                 buf, 0, interp_sect_size);
1767
1768       /* Now we need to figure out where the dynamic linker was
1769          loaded so that we can load its symbols and place a breakpoint
1770          in the dynamic linker itself.
1771
1772          This address is stored on the stack.  However, I've been unable
1773          to find any magic formula to find it for Solaris (appears to
1774          be trivial on GNU/Linux).  Therefore, we have to try an alternate
1775          mechanism to find the dynamic linker's base address.  */
1776       tmp_bfd = bfd_openr (buf, gnutarget);
1777       if (tmp_bfd == NULL)
1778         goto bkpt_at_symbol;
1779
1780       /* Make sure the dynamic linker's really a useful object.  */
1781       if (!bfd_check_format (tmp_bfd, bfd_object))
1782         {
1783           warning ("Unable to grok dynamic linker %s as an object file", buf);
1784           bfd_close (tmp_bfd);
1785           goto bkpt_at_symbol;
1786         }
1787
1788       /* We find the dynamic linker's base address by examining the
1789          current pc (which point at the entry point for the dynamic
1790          linker) and subtracting the offset of the entry point.  */
1791       load_addr = read_pc () - tmp_bfd->start_address;
1792
1793       /* Record the relocated start and end address of the dynamic linker
1794          text and plt section for in_svr4_dynsym_resolve_code.  */
1795       interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
1796       if (interp_sect)
1797         {
1798           interp_text_sect_low =
1799             bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1800           interp_text_sect_high =
1801             interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
1802         }
1803       interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
1804       if (interp_sect)
1805         {
1806           interp_plt_sect_low =
1807             bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1808           interp_plt_sect_high =
1809             interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
1810         }
1811
1812       /* Now try to set a breakpoint in the dynamic linker.  */
1813       for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
1814         {
1815           sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep);
1816           if (sym_addr != 0)
1817             break;
1818         }
1819
1820       /* We're done with the temporary bfd.  */
1821       bfd_close (tmp_bfd);
1822
1823       if (sym_addr != 0)
1824         {
1825           create_solib_event_breakpoint (load_addr + sym_addr);
1826           return 1;
1827         }
1828
1829       /* For whatever reason we couldn't set a breakpoint in the dynamic
1830          linker.  Warn and drop into the old code.  */
1831     bkpt_at_symbol:
1832       warning ("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code.");
1833     }
1834 #endif
1835
1836   /* Scan through the list of symbols, trying to look up the symbol and
1837      set a breakpoint there.  Terminate loop when we/if we succeed. */
1838
1839   breakpoint_addr = 0;
1840   for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
1841     {
1842       msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
1843       if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
1844         {
1845           create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
1846           return 1;
1847         }
1848     }
1849
1850   /* Nothing good happened.  */
1851   success = 0;
1852
1853 #endif /* BKPT_AT_SYMBOL */
1854
1855 #endif /* !SVR4_SHARED_LIBS */
1856
1857   return (success);
1858 }
1859
1860 /*
1861
1862    GLOBAL FUNCTION
1863
1864    solib_create_inferior_hook -- shared library startup support
1865
1866    SYNOPSIS
1867
1868    void solib_create_inferior_hook()
1869
1870    DESCRIPTION
1871
1872    When gdb starts up the inferior, it nurses it along (through the
1873    shell) until it is ready to execute it's first instruction.  At this
1874    point, this function gets called via expansion of the macro
1875    SOLIB_CREATE_INFERIOR_HOOK.
1876
1877    For SunOS executables, this first instruction is typically the
1878    one at "_start", or a similar text label, regardless of whether
1879    the executable is statically or dynamically linked.  The runtime
1880    startup code takes care of dynamically linking in any shared
1881    libraries, once gdb allows the inferior to continue.
1882
1883    For SVR4 executables, this first instruction is either the first
1884    instruction in the dynamic linker (for dynamically linked
1885    executables) or the instruction at "start" for statically linked
1886    executables.  For dynamically linked executables, the system
1887    first exec's /lib/libc.so.N, which contains the dynamic linker,
1888    and starts it running.  The dynamic linker maps in any needed
1889    shared libraries, maps in the actual user executable, and then
1890    jumps to "start" in the user executable.
1891
1892    For both SunOS shared libraries, and SVR4 shared libraries, we
1893    can arrange to cooperate with the dynamic linker to discover the
1894    names of shared libraries that are dynamically linked, and the
1895    base addresses to which they are linked.
1896
1897    This function is responsible for discovering those names and
1898    addresses, and saving sufficient information about them to allow
1899    their symbols to be read at a later time.
1900
1901    FIXME
1902
1903    Between enable_break() and disable_break(), this code does not
1904    properly handle hitting breakpoints which the user might have
1905    set in the startup code or in the dynamic linker itself.  Proper
1906    handling will probably have to wait until the implementation is
1907    changed to use the "breakpoint handler function" method.
1908
1909    Also, what if child has exit()ed?  Must exit loop somehow.
1910  */
1911
1912 void
1913 solib_create_inferior_hook ()
1914 {
1915   /* If we are using the BKPT_AT_SYMBOL code, then we don't need the base
1916      yet.  In fact, in the case of a SunOS4 executable being run on
1917      Solaris, we can't get it yet.  current_sos will get it when it needs
1918      it.  */
1919 #if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
1920   if ((debug_base = locate_base ()) == 0)
1921     {
1922       /* Can't find the symbol or the executable is statically linked. */
1923       return;
1924     }
1925 #endif
1926
1927   if (!enable_break ())
1928     {
1929       warning ("shared library handler failed to enable breakpoint");
1930       return;
1931     }
1932
1933 #if !defined(SVR4_SHARED_LIBS) || defined(_SCO_DS)
1934   /* SCO and SunOS need the loop below, other systems should be using the
1935      special shared library breakpoints and the shared library breakpoint
1936      service routine.
1937
1938      Now run the target.  It will eventually hit the breakpoint, at
1939      which point all of the libraries will have been mapped in and we
1940      can go groveling around in the dynamic linker structures to find
1941      out what we need to know about them. */
1942
1943   clear_proceed_status ();
1944   stop_soon_quietly = 1;
1945   stop_signal = TARGET_SIGNAL_0;
1946   do
1947     {
1948       target_resume (-1, 0, stop_signal);
1949       wait_for_inferior ();
1950     }
1951   while (stop_signal != TARGET_SIGNAL_TRAP);
1952   stop_soon_quietly = 0;
1953
1954 #if !defined(_SCO_DS)
1955   /* We are now either at the "mapping complete" breakpoint (or somewhere
1956      else, a condition we aren't prepared to deal with anyway), so adjust
1957      the PC as necessary after a breakpoint, disable the breakpoint, and
1958      add any shared libraries that were mapped in. */
1959
1960   if (DECR_PC_AFTER_BREAK)
1961     {
1962       stop_pc -= DECR_PC_AFTER_BREAK;
1963       write_register (PC_REGNUM, stop_pc);
1964     }
1965
1966   if (!disable_break ())
1967     {
1968       warning ("shared library handler failed to disable breakpoint");
1969     }
1970
1971   if (auto_solib_add)
1972     solib_add ((char *) 0, 0, (struct target_ops *) 0);
1973 #endif /* ! _SCO_DS */
1974 #endif
1975 }
1976
1977 /*
1978
1979    LOCAL FUNCTION
1980
1981    special_symbol_handling -- additional shared library symbol handling
1982
1983    SYNOPSIS
1984
1985    void special_symbol_handling ()
1986
1987    DESCRIPTION
1988
1989    Once the symbols from a shared object have been loaded in the usual
1990    way, we are called to do any system specific symbol handling that 
1991    is needed.
1992
1993    For SunOS4, this consists of grunging around in the dynamic
1994    linkers structures to find symbol definitions for "common" symbols
1995    and adding them to the minimal symbol table for the runtime common
1996    objfile.
1997
1998  */
1999
2000 static void
2001 special_symbol_handling ()
2002 {
2003 #ifndef SVR4_SHARED_LIBS
2004   int j;
2005
2006   if (debug_addr == 0)
2007     {
2008       /* Get link_dynamic structure */
2009
2010       j = target_read_memory (debug_base, (char *) &dynamic_copy,
2011                               sizeof (dynamic_copy));
2012       if (j)
2013         {
2014           /* unreadable */
2015           return;
2016         }
2017
2018       /* Calc address of debugger interface structure */
2019       /* FIXME, this needs work for cross-debugging of core files
2020          (byteorder, size, alignment, etc).  */
2021
2022       debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
2023     }
2024
2025   /* Read the debugger structure from the inferior, just to make sure
2026      we have a current copy. */
2027
2028   j = target_read_memory (debug_addr, (char *) &debug_copy,
2029                           sizeof (debug_copy));
2030   if (j)
2031     return;                     /* unreadable */
2032
2033   /* Get common symbol definitions for the loaded object. */
2034
2035   if (debug_copy.ldd_cp)
2036     {
2037       solib_add_common_symbols (SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_cp));
2038     }
2039
2040 #endif /* !SVR4_SHARED_LIBS */
2041 }
2042
2043
2044 /*
2045
2046    LOCAL FUNCTION
2047
2048    sharedlibrary_command -- handle command to explicitly add library
2049
2050    SYNOPSIS
2051
2052    static void sharedlibrary_command (char *args, int from_tty)
2053
2054    DESCRIPTION
2055
2056  */
2057
2058 static void
2059 sharedlibrary_command (args, from_tty)
2060      char *args;
2061      int from_tty;
2062 {
2063   dont_repeat ();
2064   solib_add (args, from_tty, (struct target_ops *) 0);
2065 }
2066
2067 #endif /* HAVE_LINK_H */
2068
2069 void
2070 _initialize_solib ()
2071 {
2072 #ifdef HAVE_LINK_H
2073
2074   add_com ("sharedlibrary", class_files, sharedlibrary_command,
2075            "Load shared object library symbols for files matching REGEXP.");
2076   add_info ("sharedlibrary", info_sharedlibrary_command,
2077             "Status of loaded shared object libraries.");
2078
2079   add_show_from_set
2080     (add_set_cmd ("auto-solib-add", class_support, var_zinteger,
2081                   (char *) &auto_solib_add,
2082                   "Set autoloading of shared library symbols.\n\
2083 If nonzero, symbols from all shared object libraries will be loaded\n\
2084 automatically when the inferior begins execution or when the dynamic linker\n\
2085 informs gdb that a new library has been loaded.  Otherwise, symbols\n\
2086 must be loaded manually, using `sharedlibrary'.",
2087                   &setlist),
2088      &showlist);
2089
2090   add_show_from_set
2091     (add_set_cmd ("solib-absolute-prefix", class_support, var_filename,
2092                   (char *) &solib_absolute_prefix,
2093                   "Set prefix for loading absolute shared library symbol files.\n\
2094 For other (relative) files, you can add values using `set solib-search-path'.",
2095                   &setlist),
2096      &showlist);
2097   add_show_from_set
2098     (add_set_cmd ("solib-search-path", class_support, var_string,
2099                   (char *) &solib_search_path,
2100                   "Set the search path for loading non-absolute shared library symbol files.\n\
2101 This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.",
2102                   &setlist),
2103      &showlist);
2104
2105 #endif /* HAVE_LINK_H */
2106 }