OSDN Git Service

Copyright updates for 2007.
[pf3gnuchains/pf3gnuchains3x.git] / gdb / solib-svr4.c
1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger.
2
3    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
4    2001, 2003, 2004, 2005, 2006, 2007 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., 51 Franklin Street, Fifth Floor,
21    Boston, MA 02110-1301, USA.  */
22
23 #include "defs.h"
24
25 #include "elf/external.h"
26 #include "elf/common.h"
27 #include "elf/mips.h"
28
29 #include "symtab.h"
30 #include "bfd.h"
31 #include "symfile.h"
32 #include "objfiles.h"
33 #include "gdbcore.h"
34 #include "target.h"
35 #include "inferior.h"
36
37 #include "gdb_assert.h"
38
39 #include "solist.h"
40 #include "solib.h"
41 #include "solib-svr4.h"
42
43 #include "bfd-target.h"
44 #include "elf-bfd.h"
45 #include "exec.h"
46
47 static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
48 static int svr4_have_link_map_offsets (void);
49
50 /* This hook is set to a function that provides native link map
51    offsets if the code in solib-legacy.c is linked in.  */
52 struct link_map_offsets *(*legacy_svr4_fetch_link_map_offsets_hook) (void);
53
54 /* Link map info to include in an allocated so_list entry */
55
56 struct lm_info
57   {
58     /* Pointer to copy of link map from inferior.  The type is char *
59        rather than void *, so that we may use byte offsets to find the
60        various fields without the need for a cast.  */
61     gdb_byte *lm;
62
63     /* Amount by which addresses in the binary should be relocated to
64        match the inferior.  This could most often be taken directly
65        from lm, but when prelinking is involved and the prelink base
66        address changes, we may need a different offset, we want to
67        warn about the difference and compute it only once.  */
68     CORE_ADDR l_addr;
69   };
70
71 /* On SVR4 systems, a list of symbols in the dynamic linker where
72    GDB can try to place a breakpoint to monitor shared library
73    events.
74
75    If none of these symbols are found, or other errors occur, then
76    SVR4 systems will fall back to using a symbol as the "startup
77    mapping complete" breakpoint address.  */
78
79 static char *solib_break_names[] =
80 {
81   "r_debug_state",
82   "_r_debug_state",
83   "_dl_debug_state",
84   "rtld_db_dlactivity",
85   "_rtld_debug_state",
86
87   /* On the 64-bit PowerPC, the linker symbol with the same name as
88      the C function points to a function descriptor, not to the entry
89      point.  The linker symbol whose name is the C function name
90      prefixed with a '.' points to the function's entry point.  So
91      when we look through this table, we ignore symbols that point
92      into the data section (thus skipping the descriptor's symbol),
93      and eventually try this one, giving us the real entry point
94      address.  */
95   "._dl_debug_state",
96
97   NULL
98 };
99
100 #define BKPT_AT_SYMBOL 1
101
102 #if defined (BKPT_AT_SYMBOL)
103 static char *bkpt_names[] =
104 {
105 #ifdef SOLIB_BKPT_NAME
106   SOLIB_BKPT_NAME,              /* Prefer configured name if it exists. */
107 #endif
108   "_start",
109   "__start",
110   "main",
111   NULL
112 };
113 #endif
114
115 static char *main_name_list[] =
116 {
117   "main_$main",
118   NULL
119 };
120
121 /* Macro to extract an address from a solib structure.  When GDB is
122    configured for some 32-bit targets (e.g. Solaris 2.7 sparc), BFD is
123    configured to handle 64-bit targets, so CORE_ADDR is 64 bits.  We
124    have to extract only the significant bits of addresses to get the
125    right address when accessing the core file BFD.
126
127    Assume that the address is unsigned.  */
128
129 #define SOLIB_EXTRACT_ADDRESS(MEMBER) \
130         extract_unsigned_integer (&(MEMBER), sizeof (MEMBER))
131
132 /* local data declarations */
133
134 /* link map access functions */
135
136 static CORE_ADDR
137 LM_ADDR_FROM_LINK_MAP (struct so_list *so)
138 {
139   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
140
141   return (CORE_ADDR) extract_signed_integer (so->lm_info->lm
142                                              + lmo->l_addr_offset,
143                                              lmo->l_addr_size);
144 }
145
146 static int
147 HAS_LM_DYNAMIC_FROM_LINK_MAP ()
148 {
149   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
150
151   return (lmo->l_ld_size != 0);
152 }
153
154 static CORE_ADDR
155 LM_DYNAMIC_FROM_LINK_MAP (struct so_list *so)
156 {
157   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
158
159   gdb_assert (lmo->l_ld_size != 0);
160
161   return (CORE_ADDR) extract_signed_integer (so->lm_info->lm
162                                              + lmo->l_ld_offset,
163                                              lmo->l_ld_size);
164 }
165
166 static CORE_ADDR
167 LM_ADDR_CHECK (struct so_list *so, bfd *abfd)
168 {
169   if (so->lm_info->l_addr == (CORE_ADDR)-1)
170     {
171       struct bfd_section *dyninfo_sect;
172       CORE_ADDR l_addr, l_dynaddr, dynaddr, align = 0x1000;
173
174       l_addr = LM_ADDR_FROM_LINK_MAP (so);
175
176       if (! abfd || ! HAS_LM_DYNAMIC_FROM_LINK_MAP ())
177         goto set_addr;
178
179       l_dynaddr = LM_DYNAMIC_FROM_LINK_MAP (so);
180
181       dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic");
182       if (dyninfo_sect == NULL)
183         goto set_addr;
184
185       dynaddr = bfd_section_vma (abfd, dyninfo_sect);
186
187       if (dynaddr + l_addr != l_dynaddr)
188         {
189           if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
190             {
191               Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
192               Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
193               int i;
194
195               align = 1;
196
197               for (i = 0; i < ehdr->e_phnum; i++)
198                 if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)
199                   align = phdr[i].p_align;
200             }
201
202           /* Turn it into a mask.  */
203           align--;
204
205           /* If the changes match the alignment requirements, we
206              assume we're using a core file that was generated by the
207              same binary, just prelinked with a different base offset.
208              If it doesn't match, we may have a different binary, the
209              same binary with the dynamic table loaded at an unrelated
210              location, or anything, really.  To avoid regressions,
211              don't adjust the base offset in the latter case, although
212              odds are that, if things really changed, debugging won't
213              quite work.  */
214           if ((l_addr & align) == 0 && ((dynaddr - l_dynaddr) & align) == 0)
215             {
216               l_addr = l_dynaddr - dynaddr;
217
218               warning (_(".dynamic section for \"%s\" "
219                      "is not at the expected address"), so->so_name);
220               warning (_("difference appears to be caused by prelink, "
221                          "adjusting expectations"));
222             }
223           else
224             warning (_(".dynamic section for \"%s\" "
225                        "is not at the expected address "
226                        "(wrong library or version mismatch?)"), so->so_name);
227         }
228
229     set_addr:
230       so->lm_info->l_addr = l_addr;
231     }
232
233   return so->lm_info->l_addr;
234 }
235
236 static CORE_ADDR
237 LM_NEXT (struct so_list *so)
238 {
239   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
240
241   /* Assume that the address is unsigned.  */
242   return extract_unsigned_integer (so->lm_info->lm + lmo->l_next_offset,
243                                    lmo->l_next_size);
244 }
245
246 static CORE_ADDR
247 LM_NAME (struct so_list *so)
248 {
249   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
250
251   /* Assume that the address is unsigned.  */
252   return extract_unsigned_integer (so->lm_info->lm + lmo->l_name_offset,
253                                    lmo->l_name_size);
254 }
255
256 static int
257 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list *so)
258 {
259   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
260
261   /* Assume that the address is unsigned.  */
262   return extract_unsigned_integer (so->lm_info->lm + lmo->l_prev_offset,
263                                    lmo->l_prev_size) == 0;
264 }
265
266 static CORE_ADDR debug_base;    /* Base of dynamic linker structures */
267 static CORE_ADDR breakpoint_addr;       /* Address where end bkpt is set */
268
269 /* Validity flag for debug_loader_offset.  */
270 static int debug_loader_offset_p;
271
272 /* Load address for the dynamic linker, inferred.  */
273 static CORE_ADDR debug_loader_offset;
274
275 /* Name of the dynamic linker, valid if debug_loader_offset_p.  */
276 static char *debug_loader_name;
277
278 /* Local function prototypes */
279
280 static int match_main (char *);
281
282 static CORE_ADDR bfd_lookup_symbol (bfd *, char *, flagword);
283
284 /*
285
286    LOCAL FUNCTION
287
288    bfd_lookup_symbol -- lookup the value for a specific symbol
289
290    SYNOPSIS
291
292    CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
293
294    DESCRIPTION
295
296    An expensive way to lookup the value of a single symbol for
297    bfd's that are only temporary anyway.  This is used by the
298    shared library support to find the address of the debugger
299    interface structures in the shared library.
300
301    If SECT_FLAGS is non-zero, only match symbols in sections whose
302    flags include all those in SECT_FLAGS.
303
304    Note that 0 is specifically allowed as an error return (no
305    such symbol).
306  */
307
308 static CORE_ADDR
309 bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
310 {
311   long storage_needed;
312   asymbol *sym;
313   asymbol **symbol_table;
314   unsigned int number_of_symbols;
315   unsigned int i;
316   struct cleanup *back_to;
317   CORE_ADDR symaddr = 0;
318
319   storage_needed = bfd_get_symtab_upper_bound (abfd);
320
321   if (storage_needed > 0)
322     {
323       symbol_table = (asymbol **) xmalloc (storage_needed);
324       back_to = make_cleanup (xfree, symbol_table);
325       number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
326
327       for (i = 0; i < number_of_symbols; i++)
328         {
329           sym = *symbol_table++;
330           if (strcmp (sym->name, symname) == 0
331               && (sym->section->flags & sect_flags) == sect_flags)
332             {
333               /* Bfd symbols are section relative. */
334               symaddr = sym->value + sym->section->vma;
335               break;
336             }
337         }
338       do_cleanups (back_to);
339     }
340
341   if (symaddr)
342     return symaddr;
343
344   /* On FreeBSD, the dynamic linker is stripped by default.  So we'll
345      have to check the dynamic string table too.  */
346
347   storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
348
349   if (storage_needed > 0)
350     {
351       symbol_table = (asymbol **) xmalloc (storage_needed);
352       back_to = make_cleanup (xfree, symbol_table);
353       number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
354
355       for (i = 0; i < number_of_symbols; i++)
356         {
357           sym = *symbol_table++;
358
359           if (strcmp (sym->name, symname) == 0
360               && (sym->section->flags & sect_flags) == sect_flags)
361             {
362               /* Bfd symbols are section relative. */
363               symaddr = sym->value + sym->section->vma;
364               break;
365             }
366         }
367       do_cleanups (back_to);
368     }
369
370   return symaddr;
371 }
372
373 /*
374
375    LOCAL FUNCTION
376
377    elf_locate_base -- locate the base address of dynamic linker structs
378    for SVR4 elf targets.
379
380    SYNOPSIS
381
382    CORE_ADDR elf_locate_base (void)
383
384    DESCRIPTION
385
386    For SVR4 elf targets the address of the dynamic linker's runtime
387    structure is contained within the dynamic info section in the
388    executable file.  The dynamic section is also mapped into the
389    inferior address space.  Because the runtime loader fills in the
390    real address before starting the inferior, we have to read in the
391    dynamic info section from the inferior address space.
392    If there are any errors while trying to find the address, we
393    silently return 0, otherwise the found address is returned.
394
395  */
396
397 static CORE_ADDR
398 elf_locate_base (void)
399 {
400   struct bfd_section *dyninfo_sect;
401   int dyninfo_sect_size;
402   CORE_ADDR dyninfo_addr;
403   gdb_byte *buf;
404   gdb_byte *bufend;
405   int arch_size;
406
407   /* Find the start address of the .dynamic section.  */
408   dyninfo_sect = bfd_get_section_by_name (exec_bfd, ".dynamic");
409   if (dyninfo_sect == NULL)
410     return 0;
411   dyninfo_addr = bfd_section_vma (exec_bfd, dyninfo_sect);
412
413   /* Read in .dynamic section, silently ignore errors.  */
414   dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);
415   buf = alloca (dyninfo_sect_size);
416   if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))
417     return 0;
418
419   /* Find the DT_DEBUG entry in the the .dynamic section.
420      For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
421      no DT_DEBUG entries.  */
422
423   arch_size = bfd_get_arch_size (exec_bfd);
424   if (arch_size == -1)  /* failure */
425     return 0;
426
427   if (arch_size == 32)
428     { /* 32-bit elf */
429       for (bufend = buf + dyninfo_sect_size;
430            buf < bufend;
431            buf += sizeof (Elf32_External_Dyn))
432         {
433           Elf32_External_Dyn *x_dynp = (Elf32_External_Dyn *) buf;
434           long dyn_tag;
435           CORE_ADDR dyn_ptr;
436
437           dyn_tag = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
438           if (dyn_tag == DT_NULL)
439             break;
440           else if (dyn_tag == DT_DEBUG)
441             {
442               dyn_ptr = bfd_h_get_32 (exec_bfd, 
443                                       (bfd_byte *) x_dynp->d_un.d_ptr);
444               return dyn_ptr;
445             }
446           else if (dyn_tag == DT_MIPS_RLD_MAP)
447             {
448               gdb_byte *pbuf;
449               int pbuf_size = TARGET_PTR_BIT / HOST_CHAR_BIT;
450
451               pbuf = alloca (pbuf_size);
452               /* DT_MIPS_RLD_MAP contains a pointer to the address
453                  of the dynamic link structure.  */
454               dyn_ptr = bfd_h_get_32 (exec_bfd, 
455                                       (bfd_byte *) x_dynp->d_un.d_ptr);
456               if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
457                 return 0;
458               return extract_unsigned_integer (pbuf, pbuf_size);
459             }
460         }
461     }
462   else /* 64-bit elf */
463     {
464       for (bufend = buf + dyninfo_sect_size;
465            buf < bufend;
466            buf += sizeof (Elf64_External_Dyn))
467         {
468           Elf64_External_Dyn *x_dynp = (Elf64_External_Dyn *) buf;
469           long dyn_tag;
470           CORE_ADDR dyn_ptr;
471
472           dyn_tag = bfd_h_get_64 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
473           if (dyn_tag == DT_NULL)
474             break;
475           else if (dyn_tag == DT_DEBUG)
476             {
477               dyn_ptr = bfd_h_get_64 (exec_bfd, 
478                                       (bfd_byte *) x_dynp->d_un.d_ptr);
479               return dyn_ptr;
480             }
481           else if (dyn_tag == DT_MIPS_RLD_MAP)
482             {
483               gdb_byte *pbuf;
484               int pbuf_size = TARGET_PTR_BIT / HOST_CHAR_BIT;
485
486               pbuf = alloca (pbuf_size);
487               /* DT_MIPS_RLD_MAP contains a pointer to the address
488                  of the dynamic link structure.  */
489               dyn_ptr = bfd_h_get_64 (exec_bfd, 
490                                       (bfd_byte *) x_dynp->d_un.d_ptr);
491               if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
492                 return 0;
493               return extract_unsigned_integer (pbuf, pbuf_size);
494             }
495         }
496     }
497
498   /* DT_DEBUG entry not found.  */
499   return 0;
500 }
501
502 /*
503
504    LOCAL FUNCTION
505
506    locate_base -- locate the base address of dynamic linker structs
507
508    SYNOPSIS
509
510    CORE_ADDR locate_base (void)
511
512    DESCRIPTION
513
514    For both the SunOS and SVR4 shared library implementations, if the
515    inferior executable has been linked dynamically, there is a single
516    address somewhere in the inferior's data space which is the key to
517    locating all of the dynamic linker's runtime structures.  This
518    address is the value of the debug base symbol.  The job of this
519    function is to find and return that address, or to return 0 if there
520    is no such address (the executable is statically linked for example).
521
522    For SunOS, the job is almost trivial, since the dynamic linker and
523    all of it's structures are statically linked to the executable at
524    link time.  Thus the symbol for the address we are looking for has
525    already been added to the minimal symbol table for the executable's
526    objfile at the time the symbol file's symbols were read, and all we
527    have to do is look it up there.  Note that we explicitly do NOT want
528    to find the copies in the shared library.
529
530    The SVR4 version is a bit more complicated because the address
531    is contained somewhere in the dynamic info section.  We have to go
532    to a lot more work to discover the address of the debug base symbol.
533    Because of this complexity, we cache the value we find and return that
534    value on subsequent invocations.  Note there is no copy in the
535    executable symbol tables.
536
537  */
538
539 static CORE_ADDR
540 locate_base (void)
541 {
542   /* Check to see if we have a currently valid address, and if so, avoid
543      doing all this work again and just return the cached address.  If
544      we have no cached address, try to locate it in the dynamic info
545      section for ELF executables.  There's no point in doing any of this
546      though if we don't have some link map offsets to work with.  */
547
548   if (debug_base == 0 && svr4_have_link_map_offsets ())
549     {
550       if (exec_bfd != NULL
551           && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
552         debug_base = elf_locate_base ();
553     }
554   return (debug_base);
555 }
556
557 /* Find the first element in the inferior's dynamic link map, and
558    return its address in the inferior.
559
560    FIXME: Perhaps we should validate the info somehow, perhaps by
561    checking r_version for a known version number, or r_state for
562    RT_CONSISTENT.  */
563
564 static CORE_ADDR
565 solib_svr4_r_map (void)
566 {
567   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
568
569   return read_memory_typed_address (debug_base + lmo->r_map_offset,
570                                     builtin_type_void_data_ptr);
571 }
572
573 /* Find the link map for the dynamic linker (if it is not in the
574    normal list of loaded shared objects).  */
575
576 static CORE_ADDR
577 solib_svr4_r_ldsomap (void)
578 {
579   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
580   ULONGEST version;
581
582   /* Check version, and return zero if `struct r_debug' doesn't have
583      the r_ldsomap member.  */
584   version = read_memory_unsigned_integer (debug_base + lmo->r_version_offset,
585                                           lmo->r_version_size);
586   if (version < 2 || lmo->r_ldsomap_offset == -1)
587     return 0;
588
589   return read_memory_typed_address (debug_base + lmo->r_ldsomap_offset,
590                                     builtin_type_void_data_ptr);
591 }
592
593 /*
594
595   LOCAL FUNCTION
596
597   open_symbol_file_object
598
599   SYNOPSIS
600
601   void open_symbol_file_object (void *from_tty)
602
603   DESCRIPTION
604
605   If no open symbol file, attempt to locate and open the main symbol
606   file.  On SVR4 systems, this is the first link map entry.  If its
607   name is here, we can open it.  Useful when attaching to a process
608   without first loading its symbol file.
609
610   If FROM_TTYP dereferences to a non-zero integer, allow messages to
611   be printed.  This parameter is a pointer rather than an int because
612   open_symbol_file_object() is called via catch_errors() and
613   catch_errors() requires a pointer argument. */
614
615 static int
616 open_symbol_file_object (void *from_ttyp)
617 {
618   CORE_ADDR lm, l_name;
619   char *filename;
620   int errcode;
621   int from_tty = *(int *)from_ttyp;
622   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
623   gdb_byte *l_name_buf = xmalloc (lmo->l_name_size);
624   struct cleanup *cleanups = make_cleanup (xfree, l_name_buf);
625
626   if (symfile_objfile)
627     if (!query ("Attempt to reload symbols from process? "))
628       return 0;
629
630   if ((debug_base = locate_base ()) == 0)
631     return 0;   /* failed somehow... */
632
633   /* First link map member should be the executable.  */
634   lm = solib_svr4_r_map ();
635   if (lm == 0)
636     return 0;   /* failed somehow... */
637
638   /* Read address of name from target memory to GDB.  */
639   read_memory (lm + lmo->l_name_offset, l_name_buf, lmo->l_name_size);
640
641   /* Convert the address to host format.  Assume that the address is
642      unsigned.  */
643   l_name = extract_unsigned_integer (l_name_buf, lmo->l_name_size);
644
645   /* Free l_name_buf.  */
646   do_cleanups (cleanups);
647
648   if (l_name == 0)
649     return 0;           /* No filename.  */
650
651   /* Now fetch the filename from target memory.  */
652   target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
653
654   if (errcode)
655     {
656       warning (_("failed to read exec filename from attached file: %s"),
657                safe_strerror (errcode));
658       return 0;
659     }
660
661   make_cleanup (xfree, filename);
662   /* Have a pathname: read the symbol file.  */
663   symbol_file_add_main (filename, from_tty);
664
665   return 1;
666 }
667
668 /* If no shared library information is available from the dynamic
669    linker, build a fallback list from other sources.  */
670
671 static struct so_list *
672 svr4_default_sos (void)
673 {
674   struct so_list *head = NULL;
675   struct so_list **link_ptr = &head;
676
677   if (debug_loader_offset_p)
678     {
679       struct so_list *new = XZALLOC (struct so_list);
680
681       new->lm_info = xmalloc (sizeof (struct lm_info));
682
683       /* Nothing will ever check the cached copy of the link
684          map if we set l_addr.  */
685       new->lm_info->l_addr = debug_loader_offset;
686       new->lm_info->lm = NULL;
687
688       strncpy (new->so_name, debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1);
689       new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
690       strcpy (new->so_original_name, new->so_name);
691
692       *link_ptr = new;
693       link_ptr = &new->next;
694     }
695
696   return head;
697 }
698
699 /* LOCAL FUNCTION
700
701    current_sos -- build a list of currently loaded shared objects
702
703    SYNOPSIS
704
705    struct so_list *current_sos ()
706
707    DESCRIPTION
708
709    Build a list of `struct so_list' objects describing the shared
710    objects currently loaded in the inferior.  This list does not
711    include an entry for the main executable file.
712
713    Note that we only gather information directly available from the
714    inferior --- we don't examine any of the shared library files
715    themselves.  The declaration of `struct so_list' says which fields
716    we provide values for.  */
717
718 static struct so_list *
719 svr4_current_sos (void)
720 {
721   CORE_ADDR lm;
722   struct so_list *head = 0;
723   struct so_list **link_ptr = &head;
724   CORE_ADDR ldsomap = 0;
725
726   /* Make sure we've looked up the inferior's dynamic linker's base
727      structure.  */
728   if (! debug_base)
729     {
730       debug_base = locate_base ();
731
732       /* If we can't find the dynamic linker's base structure, this
733          must not be a dynamically linked executable.  Hmm.  */
734       if (! debug_base)
735         return svr4_default_sos ();
736     }
737
738   /* Walk the inferior's link map list, and build our list of
739      `struct so_list' nodes.  */
740   lm = solib_svr4_r_map ();
741
742   while (lm)
743     {
744       struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
745       struct so_list *new = XZALLOC (struct so_list);
746       struct cleanup *old_chain = make_cleanup (xfree, new);
747
748       new->lm_info = xmalloc (sizeof (struct lm_info));
749       make_cleanup (xfree, new->lm_info);
750
751       new->lm_info->l_addr = (CORE_ADDR)-1;
752       new->lm_info->lm = xzalloc (lmo->link_map_size);
753       make_cleanup (xfree, new->lm_info->lm);
754
755       read_memory (lm, new->lm_info->lm, lmo->link_map_size);
756
757       lm = LM_NEXT (new);
758
759       /* For SVR4 versions, the first entry in the link map is for the
760          inferior executable, so we must ignore it.  For some versions of
761          SVR4, it has no name.  For others (Solaris 2.3 for example), it
762          does have a name, so we can no longer use a missing name to
763          decide when to ignore it. */
764       if (IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap == 0)
765         free_so (new);
766       else
767         {
768           int errcode;
769           char *buffer;
770
771           /* Extract this shared object's name.  */
772           target_read_string (LM_NAME (new), &buffer,
773                               SO_NAME_MAX_PATH_SIZE - 1, &errcode);
774           if (errcode != 0)
775             warning (_("Can't read pathname for load map: %s."),
776                      safe_strerror (errcode));
777           else
778             {
779               strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
780               new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
781               xfree (buffer);
782               strcpy (new->so_original_name, new->so_name);
783             }
784
785           /* If this entry has no name, or its name matches the name
786              for the main executable, don't include it in the list.  */
787           if (! new->so_name[0]
788               || match_main (new->so_name))
789             free_so (new);
790           else
791             {
792               new->next = 0;
793               *link_ptr = new;
794               link_ptr = &new->next;
795             }
796         }
797
798       /* On Solaris, the dynamic linker is not in the normal list of
799          shared objects, so make sure we pick it up too.  Having
800          symbol information for the dynamic linker is quite crucial
801          for skipping dynamic linker resolver code.  */
802       if (lm == 0 && ldsomap == 0)
803         lm = ldsomap = solib_svr4_r_ldsomap ();
804
805       discard_cleanups (old_chain);
806     }
807
808   if (head == NULL)
809     return svr4_default_sos ();
810
811   return head;
812 }
813
814 /* Get the address of the link_map for a given OBJFILE.  Loop through
815    the link maps, and return the address of the one corresponding to
816    the given objfile.  Note that this function takes into account that
817    objfile can be the main executable, not just a shared library.  The
818    main executable has always an empty name field in the linkmap.  */
819
820 CORE_ADDR
821 svr4_fetch_objfile_link_map (struct objfile *objfile)
822 {
823   CORE_ADDR lm;
824
825   if ((debug_base = locate_base ()) == 0)
826     return 0;   /* failed somehow... */
827
828   /* Position ourselves on the first link map.  */
829   lm = solib_svr4_r_map ();  
830   while (lm)
831     {
832       /* Get info on the layout of the r_debug and link_map structures. */
833       struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
834       int errcode;
835       char *buffer;
836       struct lm_info objfile_lm_info;
837       struct cleanup *old_chain;
838       CORE_ADDR name_address;
839       gdb_byte *l_name_buf = xmalloc (lmo->l_name_size);
840       old_chain = make_cleanup (xfree, l_name_buf);
841
842       /* Set up the buffer to contain the portion of the link_map
843          structure that gdb cares about.  Note that this is not the
844          whole link_map structure.  */
845       objfile_lm_info.lm = xzalloc (lmo->link_map_size);
846       make_cleanup (xfree, objfile_lm_info.lm);
847
848       /* Read the link map into our internal structure.  */
849       read_memory (lm, objfile_lm_info.lm, lmo->link_map_size);
850
851       /* Read address of name from target memory to GDB.  */
852       read_memory (lm + lmo->l_name_offset, l_name_buf, lmo->l_name_size);
853
854       /* Extract this object's name.  Assume that the address is
855          unsigned.  */
856       name_address = extract_unsigned_integer (l_name_buf, lmo->l_name_size);
857       target_read_string (name_address, &buffer,
858                           SO_NAME_MAX_PATH_SIZE - 1, &errcode);
859       make_cleanup (xfree, buffer);
860       if (errcode != 0)
861         warning (_("Can't read pathname for load map: %s."),
862                  safe_strerror (errcode));
863       else
864         {
865           /* Is this the linkmap for the file we want?  */
866           /* If the file is not a shared library and has no name,
867              we are sure it is the main executable, so we return that.  */
868           if ((buffer && strcmp (buffer, objfile->name) == 0)
869               || (!(objfile->flags & OBJF_SHARED) && (strcmp (buffer, "") == 0)))
870             {
871               do_cleanups (old_chain);
872               return lm;
873             }
874         }
875       /* Not the file we wanted, continue checking.  Assume that the
876          address is unsigned.  */
877       lm = extract_unsigned_integer (objfile_lm_info.lm + lmo->l_next_offset,
878                                      lmo->l_next_size);
879       do_cleanups (old_chain);
880     }
881   return 0;
882 }
883
884 /* On some systems, the only way to recognize the link map entry for
885    the main executable file is by looking at its name.  Return
886    non-zero iff SONAME matches one of the known main executable names.  */
887
888 static int
889 match_main (char *soname)
890 {
891   char **mainp;
892
893   for (mainp = main_name_list; *mainp != NULL; mainp++)
894     {
895       if (strcmp (soname, *mainp) == 0)
896         return (1);
897     }
898
899   return (0);
900 }
901
902 /* Return 1 if PC lies in the dynamic symbol resolution code of the
903    SVR4 run time loader.  */
904 static CORE_ADDR interp_text_sect_low;
905 static CORE_ADDR interp_text_sect_high;
906 static CORE_ADDR interp_plt_sect_low;
907 static CORE_ADDR interp_plt_sect_high;
908
909 static int
910 svr4_in_dynsym_resolve_code (CORE_ADDR pc)
911 {
912   return ((pc >= interp_text_sect_low && pc < interp_text_sect_high)
913           || (pc >= interp_plt_sect_low && pc < interp_plt_sect_high)
914           || in_plt_section (pc, NULL));
915 }
916
917 /* Given an executable's ABFD and target, compute the entry-point
918    address.  */
919
920 static CORE_ADDR
921 exec_entry_point (struct bfd *abfd, struct target_ops *targ)
922 {
923   /* KevinB wrote ... for most targets, the address returned by
924      bfd_get_start_address() is the entry point for the start
925      function.  But, for some targets, bfd_get_start_address() returns
926      the address of a function descriptor from which the entry point
927      address may be extracted.  This address is extracted by
928      gdbarch_convert_from_func_ptr_addr().  The method
929      gdbarch_convert_from_func_ptr_addr() is the merely the identify
930      function for targets which don't use function descriptors.  */
931   return gdbarch_convert_from_func_ptr_addr (current_gdbarch,
932                                              bfd_get_start_address (abfd),
933                                              targ);
934 }
935
936 /*
937
938    LOCAL FUNCTION
939
940    enable_break -- arrange for dynamic linker to hit breakpoint
941
942    SYNOPSIS
943
944    int enable_break (void)
945
946    DESCRIPTION
947
948    Both the SunOS and the SVR4 dynamic linkers have, as part of their
949    debugger interface, support for arranging for the inferior to hit
950    a breakpoint after mapping in the shared libraries.  This function
951    enables that breakpoint.
952
953    For SunOS, there is a special flag location (in_debugger) which we
954    set to 1.  When the dynamic linker sees this flag set, it will set
955    a breakpoint at a location known only to itself, after saving the
956    original contents of that place and the breakpoint address itself,
957    in it's own internal structures.  When we resume the inferior, it
958    will eventually take a SIGTRAP when it runs into the breakpoint.
959    We handle this (in a different place) by restoring the contents of
960    the breakpointed location (which is only known after it stops),
961    chasing around to locate the shared libraries that have been
962    loaded, then resuming.
963
964    For SVR4, the debugger interface structure contains a member (r_brk)
965    which is statically initialized at the time the shared library is
966    built, to the offset of a function (_r_debug_state) which is guaran-
967    teed to be called once before mapping in a library, and again when
968    the mapping is complete.  At the time we are examining this member,
969    it contains only the unrelocated offset of the function, so we have
970    to do our own relocation.  Later, when the dynamic linker actually
971    runs, it relocates r_brk to be the actual address of _r_debug_state().
972
973    The debugger interface structure also contains an enumeration which
974    is set to either RT_ADD or RT_DELETE prior to changing the mapping,
975    depending upon whether or not the library is being mapped or unmapped,
976    and then set to RT_CONSISTENT after the library is mapped/unmapped.
977  */
978
979 static int
980 enable_break (void)
981 {
982   int success = 0;
983
984 #ifdef BKPT_AT_SYMBOL
985
986   struct minimal_symbol *msymbol;
987   char **bkpt_namep;
988   asection *interp_sect;
989
990   /* First, remove all the solib event breakpoints.  Their addresses
991      may have changed since the last time we ran the program.  */
992   remove_solib_event_breakpoints ();
993
994   interp_text_sect_low = interp_text_sect_high = 0;
995   interp_plt_sect_low = interp_plt_sect_high = 0;
996
997   /* Find the .interp section; if not found, warn the user and drop
998      into the old breakpoint at symbol code.  */
999   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
1000   if (interp_sect)
1001     {
1002       unsigned int interp_sect_size;
1003       char *buf;
1004       CORE_ADDR load_addr = 0;
1005       int load_addr_found = 0;
1006       struct so_list *so;
1007       bfd *tmp_bfd = NULL;
1008       struct target_ops *tmp_bfd_target;
1009       int tmp_fd = -1;
1010       char *tmp_pathname = NULL;
1011       CORE_ADDR sym_addr = 0;
1012
1013       /* Read the contents of the .interp section into a local buffer;
1014          the contents specify the dynamic linker this program uses.  */
1015       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
1016       buf = alloca (interp_sect_size);
1017       bfd_get_section_contents (exec_bfd, interp_sect,
1018                                 buf, 0, interp_sect_size);
1019
1020       /* Now we need to figure out where the dynamic linker was
1021          loaded so that we can load its symbols and place a breakpoint
1022          in the dynamic linker itself.
1023
1024          This address is stored on the stack.  However, I've been unable
1025          to find any magic formula to find it for Solaris (appears to
1026          be trivial on GNU/Linux).  Therefore, we have to try an alternate
1027          mechanism to find the dynamic linker's base address.  */
1028
1029       /* TODO drow/2006-09-12: This is somewhat fragile, because it
1030          relies on read_pc.  On both Solaris and GNU/Linux we can use
1031          the AT_BASE auxilliary entry, which GDB now knows how to
1032          access, to find the base address.  */
1033
1034       tmp_fd = solib_open (buf, &tmp_pathname);
1035       if (tmp_fd >= 0)
1036         tmp_bfd = bfd_fopen (tmp_pathname, gnutarget, FOPEN_RB, tmp_fd);
1037
1038       if (tmp_bfd == NULL)
1039         goto bkpt_at_symbol;
1040
1041       /* Make sure the dynamic linker's really a useful object.  */
1042       if (!bfd_check_format (tmp_bfd, bfd_object))
1043         {
1044           warning (_("Unable to grok dynamic linker %s as an object file"), buf);
1045           bfd_close (tmp_bfd);
1046           goto bkpt_at_symbol;
1047         }
1048
1049       /* Now convert the TMP_BFD into a target.  That way target, as
1050          well as BFD operations can be used.  Note that closing the
1051          target will also close the underlying bfd.  */
1052       tmp_bfd_target = target_bfd_reopen (tmp_bfd);
1053
1054       /* On a running target, we can get the dynamic linker's base
1055          address from the shared library table.  */
1056       solib_add (NULL, 0, NULL, auto_solib_add);
1057       so = master_so_list ();
1058       while (so)
1059         {
1060           if (strcmp (buf, so->so_original_name) == 0)
1061             {
1062               load_addr_found = 1;
1063               load_addr = LM_ADDR_CHECK (so, tmp_bfd);
1064               break;
1065             }
1066           so = so->next;
1067         }
1068
1069       /* Otherwise we find the dynamic linker's base address by examining
1070          the current pc (which should point at the entry point for the
1071          dynamic linker) and subtracting the offset of the entry point.  */
1072       if (!load_addr_found)
1073         {
1074           load_addr = (read_pc ()
1075                        - exec_entry_point (tmp_bfd, tmp_bfd_target));
1076           debug_loader_name = xstrdup (buf);
1077           debug_loader_offset_p = 1;
1078           debug_loader_offset = load_addr;
1079           solib_add (NULL, 0, NULL, auto_solib_add);
1080         }
1081
1082       /* Record the relocated start and end address of the dynamic linker
1083          text and plt section for svr4_in_dynsym_resolve_code.  */
1084       interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
1085       if (interp_sect)
1086         {
1087           interp_text_sect_low =
1088             bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1089           interp_text_sect_high =
1090             interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
1091         }
1092       interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
1093       if (interp_sect)
1094         {
1095           interp_plt_sect_low =
1096             bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1097           interp_plt_sect_high =
1098             interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
1099         }
1100
1101       /* Now try to set a breakpoint in the dynamic linker.  */
1102       for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
1103         {
1104           /* On ABI's that use function descriptors, there are usually
1105              two linker symbols associated with each C function: one
1106              pointing at the actual entry point of the machine code,
1107              and one pointing at the function's descriptor.  The
1108              latter symbol has the same name as the C function.
1109
1110              What we're looking for here is the machine code entry
1111              point, so we are only interested in symbols in code
1112              sections.  */
1113           sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep, SEC_CODE);
1114           if (sym_addr != 0)
1115             break;
1116         }
1117
1118       /* We're done with both the temporary bfd and target.  Remember,
1119          closing the target closes the underlying bfd.  */
1120       target_close (tmp_bfd_target, 0);
1121
1122       if (sym_addr != 0)
1123         {
1124           create_solib_event_breakpoint (load_addr + sym_addr);
1125           return 1;
1126         }
1127
1128       /* For whatever reason we couldn't set a breakpoint in the dynamic
1129          linker.  Warn and drop into the old code.  */
1130     bkpt_at_symbol:
1131       warning (_("Unable to find dynamic linker breakpoint function.\n"
1132                "GDB will be unable to debug shared library initializers\n"
1133                "and track explicitly loaded dynamic code."));
1134     }
1135
1136   /* Scan through the list of symbols, trying to look up the symbol and
1137      set a breakpoint there.  Terminate loop when we/if we succeed. */
1138
1139   breakpoint_addr = 0;
1140   for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
1141     {
1142       msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
1143       if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
1144         {
1145           create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
1146           return 1;
1147         }
1148     }
1149
1150   /* Nothing good happened.  */
1151   success = 0;
1152
1153 #endif /* BKPT_AT_SYMBOL */
1154
1155   return (success);
1156 }
1157
1158 /*
1159
1160    LOCAL FUNCTION
1161
1162    special_symbol_handling -- additional shared library symbol handling
1163
1164    SYNOPSIS
1165
1166    void special_symbol_handling ()
1167
1168    DESCRIPTION
1169
1170    Once the symbols from a shared object have been loaded in the usual
1171    way, we are called to do any system specific symbol handling that 
1172    is needed.
1173
1174    For SunOS4, this consisted of grunging around in the dynamic
1175    linkers structures to find symbol definitions for "common" symbols
1176    and adding them to the minimal symbol table for the runtime common
1177    objfile.
1178
1179    However, for SVR4, there's nothing to do.
1180
1181  */
1182
1183 static void
1184 svr4_special_symbol_handling (void)
1185 {
1186 }
1187
1188 /* Relocate the main executable.  This function should be called upon
1189    stopping the inferior process at the entry point to the program. 
1190    The entry point from BFD is compared to the PC and if they are
1191    different, the main executable is relocated by the proper amount. 
1192    
1193    As written it will only attempt to relocate executables which
1194    lack interpreter sections.  It seems likely that only dynamic
1195    linker executables will get relocated, though it should work
1196    properly for a position-independent static executable as well.  */
1197
1198 static void
1199 svr4_relocate_main_executable (void)
1200 {
1201   asection *interp_sect;
1202   CORE_ADDR pc = read_pc ();
1203
1204   /* Decide if the objfile needs to be relocated.  As indicated above,
1205      we will only be here when execution is stopped at the beginning
1206      of the program.  Relocation is necessary if the address at which
1207      we are presently stopped differs from the start address stored in
1208      the executable AND there's no interpreter section.  The condition
1209      regarding the interpreter section is very important because if
1210      there *is* an interpreter section, execution will begin there
1211      instead.  When there is an interpreter section, the start address
1212      is (presumably) used by the interpreter at some point to start
1213      execution of the program.
1214
1215      If there is an interpreter, it is normal for it to be set to an
1216      arbitrary address at the outset.  The job of finding it is
1217      handled in enable_break().
1218
1219      So, to summarize, relocations are necessary when there is no
1220      interpreter section and the start address obtained from the
1221      executable is different from the address at which GDB is
1222      currently stopped.
1223      
1224      [ The astute reader will note that we also test to make sure that
1225        the executable in question has the DYNAMIC flag set.  It is my
1226        opinion that this test is unnecessary (undesirable even).  It
1227        was added to avoid inadvertent relocation of an executable
1228        whose e_type member in the ELF header is not ET_DYN.  There may
1229        be a time in the future when it is desirable to do relocations
1230        on other types of files as well in which case this condition
1231        should either be removed or modified to accomodate the new file
1232        type.  (E.g, an ET_EXEC executable which has been built to be
1233        position-independent could safely be relocated by the OS if
1234        desired.  It is true that this violates the ABI, but the ABI
1235        has been known to be bent from time to time.)  - Kevin, Nov 2000. ]
1236      */
1237
1238   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
1239   if (interp_sect == NULL 
1240       && (bfd_get_file_flags (exec_bfd) & DYNAMIC) != 0
1241       && (exec_entry_point (exec_bfd, &exec_ops) != pc))
1242     {
1243       struct cleanup *old_chain;
1244       struct section_offsets *new_offsets;
1245       int i, changed;
1246       CORE_ADDR displacement;
1247       
1248       /* It is necessary to relocate the objfile.  The amount to
1249          relocate by is simply the address at which we are stopped
1250          minus the starting address from the executable.
1251
1252          We relocate all of the sections by the same amount.  This
1253          behavior is mandated by recent editions of the System V ABI. 
1254          According to the System V Application Binary Interface,
1255          Edition 4.1, page 5-5:
1256
1257            ...  Though the system chooses virtual addresses for
1258            individual processes, it maintains the segments' relative
1259            positions.  Because position-independent code uses relative
1260            addressesing between segments, the difference between
1261            virtual addresses in memory must match the difference
1262            between virtual addresses in the file.  The difference
1263            between the virtual address of any segment in memory and
1264            the corresponding virtual address in the file is thus a
1265            single constant value for any one executable or shared
1266            object in a given process.  This difference is the base
1267            address.  One use of the base address is to relocate the
1268            memory image of the program during dynamic linking.
1269
1270          The same language also appears in Edition 4.0 of the System V
1271          ABI and is left unspecified in some of the earlier editions.  */
1272
1273       displacement = pc - exec_entry_point (exec_bfd, &exec_ops);
1274       changed = 0;
1275
1276       new_offsets = xcalloc (symfile_objfile->num_sections,
1277                              sizeof (struct section_offsets));
1278       old_chain = make_cleanup (xfree, new_offsets);
1279
1280       for (i = 0; i < symfile_objfile->num_sections; i++)
1281         {
1282           if (displacement != ANOFFSET (symfile_objfile->section_offsets, i))
1283             changed = 1;
1284           new_offsets->offsets[i] = displacement;
1285         }
1286
1287       if (changed)
1288         objfile_relocate (symfile_objfile, new_offsets);
1289
1290       do_cleanups (old_chain);
1291     }
1292 }
1293
1294 /*
1295
1296    GLOBAL FUNCTION
1297
1298    svr4_solib_create_inferior_hook -- shared library startup support
1299
1300    SYNOPSIS
1301
1302    void svr4_solib_create_inferior_hook ()
1303
1304    DESCRIPTION
1305
1306    When gdb starts up the inferior, it nurses it along (through the
1307    shell) until it is ready to execute it's first instruction.  At this
1308    point, this function gets called via expansion of the macro
1309    SOLIB_CREATE_INFERIOR_HOOK.
1310
1311    For SunOS executables, this first instruction is typically the
1312    one at "_start", or a similar text label, regardless of whether
1313    the executable is statically or dynamically linked.  The runtime
1314    startup code takes care of dynamically linking in any shared
1315    libraries, once gdb allows the inferior to continue.
1316
1317    For SVR4 executables, this first instruction is either the first
1318    instruction in the dynamic linker (for dynamically linked
1319    executables) or the instruction at "start" for statically linked
1320    executables.  For dynamically linked executables, the system
1321    first exec's /lib/libc.so.N, which contains the dynamic linker,
1322    and starts it running.  The dynamic linker maps in any needed
1323    shared libraries, maps in the actual user executable, and then
1324    jumps to "start" in the user executable.
1325
1326    For both SunOS shared libraries, and SVR4 shared libraries, we
1327    can arrange to cooperate with the dynamic linker to discover the
1328    names of shared libraries that are dynamically linked, and the
1329    base addresses to which they are linked.
1330
1331    This function is responsible for discovering those names and
1332    addresses, and saving sufficient information about them to allow
1333    their symbols to be read at a later time.
1334
1335    FIXME
1336
1337    Between enable_break() and disable_break(), this code does not
1338    properly handle hitting breakpoints which the user might have
1339    set in the startup code or in the dynamic linker itself.  Proper
1340    handling will probably have to wait until the implementation is
1341    changed to use the "breakpoint handler function" method.
1342
1343    Also, what if child has exit()ed?  Must exit loop somehow.
1344  */
1345
1346 static void
1347 svr4_solib_create_inferior_hook (void)
1348 {
1349   /* Relocate the main executable if necessary.  */
1350   svr4_relocate_main_executable ();
1351
1352   if (!svr4_have_link_map_offsets ())
1353     {
1354       warning (_("no shared library support for this OS / ABI"));
1355       return;
1356
1357     }
1358
1359   if (!enable_break ())
1360     {
1361       warning (_("shared library handler failed to enable breakpoint"));
1362       return;
1363     }
1364
1365 #if defined(_SCO_DS)
1366   /* SCO needs the loop below, other systems should be using the
1367      special shared library breakpoints and the shared library breakpoint
1368      service routine.
1369
1370      Now run the target.  It will eventually hit the breakpoint, at
1371      which point all of the libraries will have been mapped in and we
1372      can go groveling around in the dynamic linker structures to find
1373      out what we need to know about them. */
1374
1375   clear_proceed_status ();
1376   stop_soon = STOP_QUIETLY;
1377   stop_signal = TARGET_SIGNAL_0;
1378   do
1379     {
1380       target_resume (pid_to_ptid (-1), 0, stop_signal);
1381       wait_for_inferior ();
1382     }
1383   while (stop_signal != TARGET_SIGNAL_TRAP);
1384   stop_soon = NO_STOP_QUIETLY;
1385 #endif /* defined(_SCO_DS) */
1386 }
1387
1388 static void
1389 svr4_clear_solib (void)
1390 {
1391   debug_base = 0;
1392   debug_loader_offset_p = 0;
1393   debug_loader_offset = 0;
1394   xfree (debug_loader_name);
1395   debug_loader_name = NULL;
1396 }
1397
1398 static void
1399 svr4_free_so (struct so_list *so)
1400 {
1401   xfree (so->lm_info->lm);
1402   xfree (so->lm_info);
1403 }
1404
1405
1406 /* Clear any bits of ADDR that wouldn't fit in a target-format
1407    data pointer.  "Data pointer" here refers to whatever sort of
1408    address the dynamic linker uses to manage its sections.  At the
1409    moment, we don't support shared libraries on any processors where
1410    code and data pointers are different sizes.
1411
1412    This isn't really the right solution.  What we really need here is
1413    a way to do arithmetic on CORE_ADDR values that respects the
1414    natural pointer/address correspondence.  (For example, on the MIPS,
1415    converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
1416    sign-extend the value.  There, simply truncating the bits above
1417    TARGET_PTR_BIT, as we do below, is no good.)  This should probably
1418    be a new gdbarch method or something.  */
1419 static CORE_ADDR
1420 svr4_truncate_ptr (CORE_ADDR addr)
1421 {
1422   if (TARGET_PTR_BIT == sizeof (CORE_ADDR) * 8)
1423     /* We don't need to truncate anything, and the bit twiddling below
1424        will fail due to overflow problems.  */
1425     return addr;
1426   else
1427     return addr & (((CORE_ADDR) 1 << TARGET_PTR_BIT) - 1);
1428 }
1429
1430
1431 static void
1432 svr4_relocate_section_addresses (struct so_list *so,
1433                                  struct section_table *sec)
1434 {
1435   sec->addr    = svr4_truncate_ptr (sec->addr    + LM_ADDR_CHECK (so,
1436                                                                   sec->bfd));
1437   sec->endaddr = svr4_truncate_ptr (sec->endaddr + LM_ADDR_CHECK (so,
1438                                                                   sec->bfd));
1439 }
1440 \f
1441
1442 /* Architecture-specific operations.  */
1443
1444 /* Per-architecture data key.  */
1445 static struct gdbarch_data *solib_svr4_data;
1446
1447 struct solib_svr4_ops
1448 {
1449   /* Return a description of the layout of `struct link_map'.  */
1450   struct link_map_offsets *(*fetch_link_map_offsets)(void);
1451 };
1452
1453 /* Return a default for the architecture-specific operations.  */
1454
1455 static void *
1456 solib_svr4_init (struct obstack *obstack)
1457 {
1458   struct solib_svr4_ops *ops;
1459
1460   ops = OBSTACK_ZALLOC (obstack, struct solib_svr4_ops);
1461   ops->fetch_link_map_offsets = legacy_svr4_fetch_link_map_offsets_hook;
1462   return ops;
1463 }
1464
1465 /* Set the architecture-specific `struct link_map_offsets' fetcher for
1466    GDBARCH to FLMO.  */
1467
1468 void
1469 set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch,
1470                                        struct link_map_offsets *(*flmo) (void))
1471 {
1472   struct solib_svr4_ops *ops = gdbarch_data (gdbarch, solib_svr4_data);
1473
1474   ops->fetch_link_map_offsets = flmo;
1475 }
1476
1477 /* Fetch a link_map_offsets structure using the architecture-specific
1478    `struct link_map_offsets' fetcher.  */
1479
1480 static struct link_map_offsets *
1481 svr4_fetch_link_map_offsets (void)
1482 {
1483   struct solib_svr4_ops *ops = gdbarch_data (current_gdbarch, solib_svr4_data);
1484
1485   gdb_assert (ops->fetch_link_map_offsets);
1486   return ops->fetch_link_map_offsets ();
1487 }
1488
1489 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise.  */
1490
1491 static int
1492 svr4_have_link_map_offsets (void)
1493 {
1494   struct solib_svr4_ops *ops = gdbarch_data (current_gdbarch, solib_svr4_data);
1495   return (ops->fetch_link_map_offsets != NULL);
1496 }
1497 \f
1498
1499 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
1500    `struct r_debug' and a `struct link_map' that are binary compatible
1501    with the origional SVR4 implementation.  */
1502
1503 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1504    for an ILP32 SVR4 system.  */
1505   
1506 struct link_map_offsets *
1507 svr4_ilp32_fetch_link_map_offsets (void)
1508 {
1509   static struct link_map_offsets lmo;
1510   static struct link_map_offsets *lmp = NULL;
1511
1512   if (lmp == NULL)
1513     {
1514       lmp = &lmo;
1515
1516       lmo.r_version_offset = 0;
1517       lmo.r_version_size = 4;
1518       lmo.r_map_offset = 4;
1519       lmo.r_ldsomap_offset = 20;
1520
1521       /* Everything we need is in the first 20 bytes.  */
1522       lmo.link_map_size = 20;
1523       lmo.l_addr_offset = 0;
1524       lmo.l_addr_size = 4;
1525       lmo.l_name_offset = 4;
1526       lmo.l_name_size = 4;
1527       lmo.l_ld_offset = 8;
1528       lmo.l_ld_size = 4;
1529       lmo.l_next_offset = 12;
1530       lmo.l_next_size = 4;
1531       lmo.l_prev_offset = 16;
1532       lmo.l_prev_size = 4;
1533     }
1534
1535   return lmp;
1536 }
1537
1538 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1539    for an LP64 SVR4 system.  */
1540   
1541 struct link_map_offsets *
1542 svr4_lp64_fetch_link_map_offsets (void)
1543 {
1544   static struct link_map_offsets lmo;
1545   static struct link_map_offsets *lmp = NULL;
1546
1547   if (lmp == NULL)
1548     {
1549       lmp = &lmo;
1550
1551       lmo.r_version_offset = 0;
1552       lmo.r_version_size = 4;
1553       lmo.r_map_offset = 8;
1554       lmo.r_ldsomap_offset = 40;
1555
1556       /* Everything we need is in the first 40 bytes.  */
1557       lmo.link_map_size = 40;
1558       lmo.l_addr_offset = 0;
1559       lmo.l_addr_size = 8;
1560       lmo.l_name_offset = 8;
1561       lmo.l_name_size = 8;
1562       lmo.l_ld_offset = 16;
1563       lmo.l_ld_size = 8;
1564       lmo.l_next_offset = 24;
1565       lmo.l_next_size = 8;
1566       lmo.l_prev_offset = 32;
1567       lmo.l_prev_size = 8;
1568     }
1569
1570   return lmp;
1571 }
1572 \f
1573
1574 static struct target_so_ops svr4_so_ops;
1575
1576 extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */
1577
1578 void
1579 _initialize_svr4_solib (void)
1580 {
1581   solib_svr4_data = gdbarch_data_register_pre_init (solib_svr4_init);
1582
1583   svr4_so_ops.relocate_section_addresses = svr4_relocate_section_addresses;
1584   svr4_so_ops.free_so = svr4_free_so;
1585   svr4_so_ops.clear_solib = svr4_clear_solib;
1586   svr4_so_ops.solib_create_inferior_hook = svr4_solib_create_inferior_hook;
1587   svr4_so_ops.special_symbol_handling = svr4_special_symbol_handling;
1588   svr4_so_ops.current_sos = svr4_current_sos;
1589   svr4_so_ops.open_symbol_file_object = open_symbol_file_object;
1590   svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code;
1591
1592   /* FIXME: Don't do this here.  *_gdbarch_init() should set so_ops. */
1593   current_target_so_ops = &svr4_so_ops;
1594 }