1 /* Native support for the SGI Iris running IRIX version 5, for GDB.
2 Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
3 Free Software Foundation, Inc.
4 Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
5 and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
6 Implemented for Irix 4.x by Garrett A. Wollman.
7 Modified for Irix 5.x by Ian Lance Taylor.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
30 #include "gdb_string.h"
32 #include <sys/procfs.h>
33 #include <setjmp.h> /* For JB_XXX. */
36 fetch_core_registers
PARAMS ((char *, unsigned int, int, CORE_ADDR
));
38 /* Size of elements in jmpbuf */
40 #define JB_ELEMENT_SIZE 4
43 * See the comment in m68k-tdep.c regarding the utility of these functions.
45 * These definitions are from the MIPS SVR4 ABI, so they may work for
46 * any MIPS SVR4 target.
50 supply_gregset (gregsetp
)
54 register greg_t
*regp
= &(*gregsetp
)[0];
55 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
57 for(regi
= 0; regi
<= CTX_RA
; regi
++)
58 supply_register (regi
, (char *)(regp
+ regi
));
60 supply_register (PC_REGNUM
, (char *)(regp
+ CTX_EPC
));
61 supply_register (HI_REGNUM
, (char *)(regp
+ CTX_MDHI
));
62 supply_register (LO_REGNUM
, (char *)(regp
+ CTX_MDLO
));
63 supply_register (CAUSE_REGNUM
, (char *)(regp
+ CTX_CAUSE
));
65 /* Fill inaccessible registers with zero. */
66 supply_register (BADVADDR_REGNUM
, zerobuf
);
70 fill_gregset (gregsetp
, regno
)
75 register greg_t
*regp
= &(*gregsetp
)[0];
77 for (regi
= 0; regi
<= CTX_RA
; regi
++)
78 if ((regno
== -1) || (regno
== regi
))
79 *(regp
+ regi
) = *(greg_t
*) ®isters
[REGISTER_BYTE (regi
)];
81 if ((regno
== -1) || (regno
== PC_REGNUM
))
82 *(regp
+ CTX_EPC
) = *(greg_t
*) ®isters
[REGISTER_BYTE (PC_REGNUM
)];
84 if ((regno
== -1) || (regno
== CAUSE_REGNUM
))
85 *(regp
+ CTX_CAUSE
) = *(greg_t
*) ®isters
[REGISTER_BYTE (CAUSE_REGNUM
)];
87 if ((regno
== -1) || (regno
== HI_REGNUM
))
88 *(regp
+ CTX_MDHI
) = *(greg_t
*) ®isters
[REGISTER_BYTE (HI_REGNUM
)];
90 if ((regno
== -1) || (regno
== LO_REGNUM
))
91 *(regp
+ CTX_MDLO
) = *(greg_t
*) ®isters
[REGISTER_BYTE (LO_REGNUM
)];
95 * Now we do the same thing for floating-point registers.
96 * We don't bother to condition on FP0_REGNUM since any
97 * reasonable MIPS configuration has an R3010 in it.
99 * Again, see the comments in m68k-tdep.c.
103 supply_fpregset (fpregsetp
)
104 fpregset_t
*fpregsetp
;
107 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
109 for (regi
= 0; regi
< 32; regi
++)
110 supply_register (FP0_REGNUM
+ regi
,
111 (char *)&fpregsetp
->fp_r
.fp_regs
[regi
]);
113 supply_register (FCRCS_REGNUM
, (char *)&fpregsetp
->fp_csr
);
115 /* FIXME: how can we supply FCRIR_REGNUM? SGI doesn't tell us. */
116 supply_register (FCRIR_REGNUM
, zerobuf
);
120 fill_fpregset (fpregsetp
, regno
)
121 fpregset_t
*fpregsetp
;
127 for (regi
= FP0_REGNUM
; regi
< FP0_REGNUM
+ 32; regi
++)
129 if ((regno
== -1) || (regno
== regi
))
131 from
= (char *) ®isters
[REGISTER_BYTE (regi
)];
132 to
= (char *) &(fpregsetp
->fp_r
.fp_regs
[regi
- FP0_REGNUM
]);
133 memcpy(to
, from
, REGISTER_RAW_SIZE (regi
));
137 if ((regno
== -1) || (regno
== FCRCS_REGNUM
))
138 fpregsetp
->fp_csr
= *(unsigned *) ®isters
[REGISTER_BYTE(FCRCS_REGNUM
)];
142 /* Figure out where the longjmp will land.
143 We expect the first arg to be a pointer to the jmp_buf structure from which
144 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
145 This routine returns true on success. */
148 get_longjmp_target (pc
)
151 char buf
[TARGET_PTR_BIT
/ TARGET_CHAR_BIT
];
154 jb_addr
= read_register (A0_REGNUM
);
156 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
157 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
160 *pc
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
166 fetch_core_registers (core_reg_sect
, core_reg_size
, which
, reg_addr
)
168 unsigned core_reg_size
;
169 int which
; /* Unused */
170 CORE_ADDR reg_addr
; /* Unused */
172 if (core_reg_size
!= REGISTER_BYTES
)
174 warning ("wrong size gregset struct in core file");
178 memcpy ((char *)registers
, core_reg_sect
, core_reg_size
);
181 /* Irix 5 uses what appears to be a unique form of shared library
182 support. This is a copy of solib.c modified for Irix 5. */
184 #include <sys/types.h>
186 #include <sys/param.h>
189 /* <obj.h> includes <sym.h> and <symconst.h>, which causes conflicts
190 with our versions of those files included by tm-mips.h. Prevent
191 <obj.h> from including them with some appropriate defines. */
193 #define __SYMCONST_H__
199 #include "objfiles.h"
202 #include "gnu-regex.h"
203 #include "inferior.h"
204 #include "language.h"
207 /* The symbol which starts off the list of shared libraries. */
208 #define DEBUG_BASE "__rld_obj_head"
210 /* How to get the loaded address of a shared library. */
211 #define LM_ADDR(so) ((so)->lm.o_praw)
213 char shadow_contents
[BREAKPOINT_MAX
]; /* Stash old bkpt addr contents */
216 struct so_list
*next
; /* next structure in linked list */
218 struct obj lm
; /* copy of link map from inferior */
219 struct obj_list
*lladdr
; /* addr in inferior lm was read from */
220 CORE_ADDR lmend
; /* upper addr bound of mapped object */
221 char symbols_loaded
; /* flag: symbols read in yet? */
222 char from_tty
; /* flag: print msgs? */
223 struct objfile
*objfile
; /* objfile for loaded lib */
224 struct section_table
*sections
;
225 struct section_table
*sections_end
;
226 struct section_table
*textsection
;
230 static struct so_list
*so_list_head
; /* List of known shared objects */
231 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
232 static CORE_ADDR breakpoint_addr
; /* Address where end bkpt is set */
234 /* Local function prototypes */
237 sharedlibrary_command
PARAMS ((char *, int));
240 enable_break
PARAMS ((void));
243 disable_break
PARAMS ((void));
246 info_sharedlibrary_command
PARAMS ((char *, int));
249 symbol_add_stub
PARAMS ((char *));
251 static struct so_list
*
252 find_solib
PARAMS ((struct so_list
*));
254 static struct obj_list
*
255 first_link_map_member
PARAMS ((void));
258 locate_base
PARAMS ((void));
261 solib_map_sections
PARAMS ((struct so_list
*));
267 solib_map_sections -- open bfd and build sections for shared lib
271 static void solib_map_sections (struct so_list *so)
275 Given a pointer to one of the shared objects in our list
276 of mapped objects, use the recorded name to open a bfd
277 descriptor for the object, build a section table, and then
278 relocate all the section addresses by the base address at
279 which the shared object was mapped.
283 In most (all?) cases the shared object file name recorded in the
284 dynamic linkage tables will be a fully qualified pathname. For
285 cases where it isn't, do we really mimic the systems search
286 mechanism correctly in the below code (particularly the tilde
291 solib_map_sections (so
)
295 char *scratch_pathname
;
297 struct section_table
*p
;
298 struct cleanup
*old_chain
;
302 filename
= tilde_expand (so
-> lm
.o_path
);
303 old_chain
= make_cleanup (free
, filename
);
305 scratch_chan
= openp (getenv ("PATH"), 1, filename
, O_RDONLY
, 0,
307 if (scratch_chan
< 0)
309 scratch_chan
= openp (getenv ("LD_LIBRARY_PATH"), 1, filename
,
310 O_RDONLY
, 0, &scratch_pathname
);
312 if (scratch_chan
< 0)
314 perror_with_name (filename
);
316 /* Leave scratch_pathname allocated. abfd->name will point to it. */
318 abfd
= bfd_fdopenr (scratch_pathname
, gnutarget
, scratch_chan
);
321 close (scratch_chan
);
322 error ("Could not open `%s' as an executable file: %s",
323 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
325 /* Leave bfd open, core_xfer_memory and "info files" need it. */
327 abfd
-> cacheable
= true;
329 if (!bfd_check_format (abfd
, bfd_object
))
331 error ("\"%s\": not in executable format: %s.",
332 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
334 if (build_section_table (abfd
, &so
-> sections
, &so
-> sections_end
))
336 error ("Can't find the file sections in `%s': %s",
337 bfd_get_filename (exec_bfd
), bfd_errmsg (bfd_get_error ()));
340 /* Irix 5 shared objects are pre-linked to particular addresses
341 although the dynamic linker may have to relocate them if the
342 address ranges of the libraries used by the main program clash.
343 The offset is the difference between the address where the object
344 is mapped and the binding address of the shared library. */
345 offset
= (CORE_ADDR
) LM_ADDR (so
) - so
-> lm
.o_base_address
;
347 for (p
= so
-> sections
; p
< so
-> sections_end
; p
++)
349 /* Relocate the section binding addresses as recorded in the shared
350 object's file by the offset to get the address to which the
351 object was actually mapped. */
353 p
-> endaddr
+= offset
;
354 so
-> lmend
= (CORE_ADDR
) max (p
-> endaddr
, so
-> lmend
);
355 if (STREQ (p
-> the_bfd_section
-> name
, ".text"))
357 so
-> textsection
= p
;
361 /* Free the file names, close the file now. */
362 do_cleanups (old_chain
);
369 locate_base -- locate the base address of dynamic linker structs
373 CORE_ADDR locate_base (void)
377 For both the SunOS and SVR4 shared library implementations, if the
378 inferior executable has been linked dynamically, there is a single
379 address somewhere in the inferior's data space which is the key to
380 locating all of the dynamic linker's runtime structures. This
381 address is the value of the symbol defined by the macro DEBUG_BASE.
382 The job of this function is to find and return that address, or to
383 return 0 if there is no such address (the executable is statically
386 For SunOS, the job is almost trivial, since the dynamic linker and
387 all of it's structures are statically linked to the executable at
388 link time. Thus the symbol for the address we are looking for has
389 already been added to the minimal symbol table for the executable's
390 objfile at the time the symbol file's symbols were read, and all we
391 have to do is look it up there. Note that we explicitly do NOT want
392 to find the copies in the shared library.
394 The SVR4 version is much more complicated because the dynamic linker
395 and it's structures are located in the shared C library, which gets
396 run as the executable's "interpreter" by the kernel. We have to go
397 to a lot more work to discover the address of DEBUG_BASE. Because
398 of this complexity, we cache the value we find and return that value
399 on subsequent invocations. Note there is no copy in the executable
402 Irix 5 is basically like SunOS.
404 Note that we can assume nothing about the process state at the time
405 we need to find this address. We may be stopped on the first instruc-
406 tion of the interpreter (C shared library), the first instruction of
407 the executable itself, or somewhere else entirely (if we attached
408 to the process for example).
415 struct minimal_symbol
*msymbol
;
416 CORE_ADDR address
= 0;
418 msymbol
= lookup_minimal_symbol (DEBUG_BASE
, NULL
, symfile_objfile
);
419 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
421 address
= SYMBOL_VALUE_ADDRESS (msymbol
);
430 first_link_map_member -- locate first member in dynamic linker's map
434 static struct link_map *first_link_map_member (void)
438 Read in a copy of the first member in the inferior's dynamic
439 link map from the inferior's dynamic linker structures, and return
440 a pointer to the copy in our address space.
443 static struct obj_list
*
444 first_link_map_member ()
449 read_memory (debug_base
, (char *) &lm
, sizeof (struct obj_list
*));
454 /* The first entry in the list is the object file we are debugging,
456 read_memory ((CORE_ADDR
) lm
, (char *) &s
, sizeof (struct obj_list
));
465 find_solib -- step through list of shared objects
469 struct so_list *find_solib (struct so_list *so_list_ptr)
473 This module contains the routine which finds the names of any
474 loaded "images" in the current process. The argument in must be
475 NULL on the first call, and then the returned value must be passed
476 in on subsequent calls. This provides the capability to "step" down
477 the list of loaded objects. On the last object, a NULL value is
481 static struct so_list
*
482 find_solib (so_list_ptr
)
483 struct so_list
*so_list_ptr
; /* Last lm or NULL for first one */
485 struct so_list
*so_list_next
= NULL
;
486 struct obj_list
*lm
= NULL
;
489 if (so_list_ptr
== NULL
)
491 /* We are setting up for a new scan through the loaded images. */
492 if ((so_list_next
= so_list_head
) == NULL
)
494 /* We have not already read in the dynamic linking structures
495 from the inferior, lookup the address of the base structure. */
496 debug_base
= locate_base ();
499 /* Read the base structure in and find the address of the first
500 link map list member. */
501 lm
= first_link_map_member ();
507 /* We have been called before, and are in the process of walking
508 the shared library list. Advance to the next shared object. */
509 if ((lm
= so_list_ptr
->ll
.next
) == NULL
)
511 /* We have hit the end of the list, so check to see if any were
512 added, but be quiet if we can't read from the target any more. */
513 int status
= target_read_memory ((CORE_ADDR
) so_list_ptr
-> lladdr
,
514 (char *) &(so_list_ptr
-> ll
),
515 sizeof (struct obj_list
));
518 lm
= so_list_ptr
->ll
.next
;
525 so_list_next
= so_list_ptr
-> next
;
527 if ((so_list_next
== NULL
) && (lm
!= NULL
))
532 /* Get next link map structure from inferior image and build a local
533 abbreviated load_map structure */
534 new = (struct so_list
*) xmalloc (sizeof (struct so_list
));
535 memset ((char *) new, 0, sizeof (struct so_list
));
537 /* Add the new node as the next node in the list, or as the root
538 node if this is the first one. */
539 if (so_list_ptr
!= NULL
)
541 so_list_ptr
-> next
= new;
548 read_memory ((CORE_ADDR
) lm
, (char *) &(new -> ll
),
549 sizeof (struct obj_list
));
550 read_memory ((CORE_ADDR
) new->ll
.data
, (char *) &(new -> lm
),
551 sizeof (struct obj
));
552 target_read_string ((CORE_ADDR
)new->lm
.o_path
, &buffer
,
555 memory_error (errcode
, (CORE_ADDR
)new->lm
.o_path
);
556 new->lm
.o_path
= buffer
;
557 solib_map_sections (new);
559 return (so_list_next
);
562 /* A small stub to get us past the arg-passing pinhole of catch_errors. */
565 symbol_add_stub (arg
)
568 register struct so_list
*so
= (struct so_list
*) arg
; /* catch_errs bogon */
569 CORE_ADDR text_addr
= 0;
571 if (so
-> textsection
)
572 text_addr
= so
-> textsection
-> addr
;
575 asection
*lowest_sect
;
577 /* If we didn't find a mapped non zero sized .text section, set up
578 text_addr so that the relocation in symbol_file_add does no harm. */
580 lowest_sect
= bfd_get_section_by_name (so
-> abfd
, ".text");
581 if (lowest_sect
== NULL
)
582 bfd_map_over_sections (so
-> abfd
, find_lowest_section
,
585 text_addr
= bfd_section_vma (so
-> abfd
, lowest_sect
)
586 + (CORE_ADDR
) LM_ADDR (so
) - so
-> lm
.o_base_address
;
589 so
-> objfile
= symbol_file_add (so
-> lm
.o_path
, so
-> from_tty
,
599 solib_add -- add a shared library file to the symtab and section list
603 void solib_add (char *arg_string, int from_tty,
604 struct target_ops *target)
611 solib_add (arg_string
, from_tty
, target
)
614 struct target_ops
*target
;
616 register struct so_list
*so
= NULL
; /* link map state variable */
618 /* Last shared library that we read. */
619 struct so_list
*so_last
= NULL
;
625 if ((re_err
= re_comp (arg_string
? arg_string
: ".")) != NULL
)
627 error ("Invalid regexp: %s", re_err
);
630 /* Add the shared library sections to the section table of the
631 specified target, if any. */
634 /* Count how many new section_table entries there are. */
637 while ((so
= find_solib (so
)) != NULL
)
639 if (so
-> lm
.o_path
[0])
641 count
+= so
-> sections_end
- so
-> sections
;
649 /* We must update the to_sections field in the core_ops structure
650 here, otherwise we dereference a potential dangling pointer
651 for each call to target_read/write_memory within this routine. */
652 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
654 /* Reallocate the target's section table including the new size. */
655 if (target
-> to_sections
)
657 old
= target
-> to_sections_end
- target
-> to_sections
;
658 target
-> to_sections
= (struct section_table
*)
659 xrealloc ((char *)target
-> to_sections
,
660 (sizeof (struct section_table
)) * (count
+ old
));
665 target
-> to_sections
= (struct section_table
*)
666 xmalloc ((sizeof (struct section_table
)) * count
);
668 target
-> to_sections_end
= target
-> to_sections
+ (count
+ old
);
670 /* Update the to_sections field in the core_ops structure
674 core_ops
.to_sections
= target
->to_sections
;
675 core_ops
.to_sections_end
= target
->to_sections_end
;
678 /* Add these section table entries to the target's table. */
679 while ((so
= find_solib (so
)) != NULL
)
681 if (so
-> lm
.o_path
[0])
683 count
= so
-> sections_end
- so
-> sections
;
684 memcpy ((char *) (target
-> to_sections
+ old
),
686 (sizeof (struct section_table
)) * count
);
693 /* Now add the symbol files. */
694 while ((so
= find_solib (so
)) != NULL
)
696 if (so
-> lm
.o_path
[0] && re_exec (so
-> lm
.o_path
))
698 so
-> from_tty
= from_tty
;
699 if (so
-> symbols_loaded
)
703 printf_unfiltered ("Symbols already loaded for %s\n", so
-> lm
.o_path
);
706 else if (catch_errors
707 (symbol_add_stub
, (char *) so
,
708 "Error while reading shared library symbols:\n",
712 so
-> symbols_loaded
= 1;
717 /* Getting new symbols may change our opinion about what is
720 reinit_frame_cache ();
727 info_sharedlibrary_command -- code for "info sharedlibrary"
731 static void info_sharedlibrary_command ()
735 Walk through the shared library list and print information
736 about each attached library.
740 info_sharedlibrary_command (ignore
, from_tty
)
744 register struct so_list
*so
= NULL
; /* link map state variable */
747 if (exec_bfd
== NULL
)
749 printf_unfiltered ("No exec file.\n");
752 while ((so
= find_solib (so
)) != NULL
)
754 if (so
-> lm
.o_path
[0])
758 printf_unfiltered("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read",
759 "Shared Object Library");
762 printf_unfiltered ("%-12s",
763 local_hex_string_custom ((unsigned long) LM_ADDR (so
),
765 printf_unfiltered ("%-12s",
766 local_hex_string_custom ((unsigned long) so
-> lmend
,
768 printf_unfiltered ("%-12s", so
-> symbols_loaded
? "Yes" : "No");
769 printf_unfiltered ("%s\n", so
-> lm
.o_path
);
772 if (so_list_head
== NULL
)
774 printf_unfiltered ("No shared libraries loaded at this time.\n");
782 solib_address -- check to see if an address is in a shared lib
786 char *solib_address (CORE_ADDR address)
790 Provides a hook for other gdb routines to discover whether or
791 not a particular address is within the mapped address space of
792 a shared library. Any address between the base mapping address
793 and the first address beyond the end of the last mapping, is
794 considered to be within the shared library address space, for
797 For example, this routine is called at one point to disable
798 breakpoints which are in shared libraries that are not currently
803 solib_address (address
)
806 register struct so_list
*so
= 0; /* link map state variable */
808 while ((so
= find_solib (so
)) != NULL
)
810 if (so
-> lm
.o_path
[0])
812 if ((address
>= (CORE_ADDR
) LM_ADDR (so
)) &&
813 (address
< (CORE_ADDR
) so
-> lmend
))
814 return (so
->lm
.o_path
);
820 /* Called by free_all_symtabs */
825 struct so_list
*next
;
830 if (so_list_head
-> sections
)
832 free ((PTR
)so_list_head
-> sections
);
834 if (so_list_head
-> abfd
)
836 bfd_filename
= bfd_get_filename (so_list_head
-> abfd
);
837 if (!bfd_close (so_list_head
-> abfd
))
838 warning ("cannot close \"%s\": %s",
839 bfd_filename
, bfd_errmsg (bfd_get_error ()));
842 /* This happens for the executable on SVR4. */
845 next
= so_list_head
-> next
;
847 free ((PTR
)bfd_filename
);
848 free (so_list_head
->lm
.o_path
);
849 free ((PTR
)so_list_head
);
859 disable_break -- remove the "mapping changed" breakpoint
863 static int disable_break ()
867 Removes the breakpoint that gets hit when the dynamic linker
868 completes a mapping change.
878 /* Note that breakpoint address and original contents are in our address
879 space, so we just need to write the original contents back. */
881 if (memory_remove_breakpoint (breakpoint_addr
, shadow_contents
) != 0)
886 /* For the SVR4 version, we always know the breakpoint address. For the
887 SunOS version we don't know it until the above code is executed.
888 Grumble if we are stopped anywhere besides the breakpoint address. */
890 if (stop_pc
!= breakpoint_addr
)
892 warning ("stopped at unknown breakpoint while handling shared libraries");
902 enable_break -- arrange for dynamic linker to hit breakpoint
906 int enable_break (void)
910 This functions inserts a breakpoint at the entry point of the
911 main executable, where all shared libraries are mapped in.
917 if (symfile_objfile
!= NULL
918 && target_insert_breakpoint (symfile_objfile
->ei
.entry_point
,
919 shadow_contents
) == 0)
921 breakpoint_addr
= symfile_objfile
->ei
.entry_point
;
932 solib_create_inferior_hook -- shared library startup support
936 void solib_create_inferior_hook()
940 When gdb starts up the inferior, it nurses it along (through the
941 shell) until it is ready to execute it's first instruction. At this
942 point, this function gets called via expansion of the macro
943 SOLIB_CREATE_INFERIOR_HOOK.
945 For SunOS executables, this first instruction is typically the
946 one at "_start", or a similar text label, regardless of whether
947 the executable is statically or dynamically linked. The runtime
948 startup code takes care of dynamically linking in any shared
949 libraries, once gdb allows the inferior to continue.
951 For SVR4 executables, this first instruction is either the first
952 instruction in the dynamic linker (for dynamically linked
953 executables) or the instruction at "start" for statically linked
954 executables. For dynamically linked executables, the system
955 first exec's /lib/libc.so.N, which contains the dynamic linker,
956 and starts it running. The dynamic linker maps in any needed
957 shared libraries, maps in the actual user executable, and then
958 jumps to "start" in the user executable.
960 For both SunOS shared libraries, and SVR4 shared libraries, we
961 can arrange to cooperate with the dynamic linker to discover the
962 names of shared libraries that are dynamically linked, and the
963 base addresses to which they are linked.
965 This function is responsible for discovering those names and
966 addresses, and saving sufficient information about them to allow
967 their symbols to be read at a later time.
971 Between enable_break() and disable_break(), this code does not
972 properly handle hitting breakpoints which the user might have
973 set in the startup code or in the dynamic linker itself. Proper
974 handling will probably have to wait until the implementation is
975 changed to use the "breakpoint handler function" method.
977 Also, what if child has exit()ed? Must exit loop somehow.
981 solib_create_inferior_hook()
983 if (!enable_break ())
985 warning ("shared library handler failed to enable breakpoint");
989 /* Now run the target. It will eventually hit the breakpoint, at
990 which point all of the libraries will have been mapped in and we
991 can go groveling around in the dynamic linker structures to find
992 out what we need to know about them. */
994 clear_proceed_status ();
995 stop_soon_quietly
= 1;
999 target_resume (-1, 0, stop_signal
);
1000 wait_for_inferior ();
1002 while (stop_signal
!= SIGTRAP
);
1004 /* We are now either at the "mapping complete" breakpoint (or somewhere
1005 else, a condition we aren't prepared to deal with anyway), so adjust
1006 the PC as necessary after a breakpoint, disable the breakpoint, and
1007 add any shared libraries that were mapped in. */
1009 if (DECR_PC_AFTER_BREAK
)
1011 stop_pc
-= DECR_PC_AFTER_BREAK
;
1012 write_register (PC_REGNUM
, stop_pc
);
1015 if (!disable_break ())
1017 warning ("shared library handler failed to disable breakpoint");
1020 /* solib_add will call reinit_frame_cache.
1021 But we are stopped in the startup code and we might not have symbols
1022 for the startup code, so heuristic_proc_start could be called
1023 and will put out an annoying warning.
1024 Delaying the resetting of stop_soon_quietly until after symbol loading
1025 suppresses the warning. */
1027 solib_add ((char *) 0, 0, (struct target_ops
*) 0);
1028 stop_soon_quietly
= 0;
1035 sharedlibrary_command -- handle command to explicitly add library
1039 static void sharedlibrary_command (char *args, int from_tty)
1046 sharedlibrary_command (args
, from_tty
)
1051 solib_add (args
, from_tty
, (struct target_ops
*) 0);
1057 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1058 "Load shared object library symbols for files matching REGEXP.");
1059 add_info ("sharedlibrary", info_sharedlibrary_command
,
1060 "Status of loaded shared object libraries.");
1063 (add_set_cmd ("auto-solib-add", class_support
, var_zinteger
,
1064 (char *) &auto_solib_add
,
1065 "Set autoloading of shared library symbols.\n\
1066 If nonzero, symbols from all shared object libraries will be loaded\n\
1067 automatically when the inferior begins execution or when the dynamic linker\n\
1068 informs gdb that a new library has been loaded. Otherwise, symbols\n\
1069 must be loaded manually, using `sharedlibrary'.",
1075 /* Register that we are able to handle irix5 core file formats.
1076 This really is bfd_target_unknown_flavour */
1078 static struct core_fns irix5_core_fns
=
1080 bfd_target_unknown_flavour
,
1081 fetch_core_registers
,
1086 _initialize_core_irix5 ()
1088 add_core_fns (&irix5_core_fns
);