1 /* Native support for the SGI Iris running IRIX version 5, for GDB.
2 Copyright 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
3 Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
4 and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
5 Implemented for Irix 4.x by Garrett A. Wollman.
6 Modified for Irix 5.x by Ian Lance Taylor.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
30 #include <sys/procfs.h>
31 #include <setjmp.h> /* For JB_XXX. */
33 /* Size of elements in jmpbuf */
35 #define JB_ELEMENT_SIZE 4
38 * See the comment in m68k-tdep.c regarding the utility of these functions.
40 * These definitions are from the MIPS SVR4 ABI, so they may work for
41 * any MIPS SVR4 target.
45 supply_gregset (gregsetp
)
49 register greg_t
*regp
= &(*gregsetp
)[0];
51 for(regi
= 0; regi
<= CTX_RA
; regi
++)
52 supply_register (regi
, (char *)(regp
+ regi
));
54 supply_register (PC_REGNUM
, (char *)(regp
+ CTX_EPC
));
55 supply_register (HI_REGNUM
, (char *)(regp
+ CTX_MDHI
));
56 supply_register (LO_REGNUM
, (char *)(regp
+ CTX_MDLO
));
57 supply_register (CAUSE_REGNUM
, (char *)(regp
+ CTX_CAUSE
));
61 fill_gregset (gregsetp
, regno
)
66 register greg_t
*regp
= &(*gregsetp
)[0];
68 for (regi
= 0; regi
<= CTX_RA
; regi
++)
69 if ((regno
== -1) || (regno
== regi
))
70 *(regp
+ regi
) = *(greg_t
*) ®isters
[REGISTER_BYTE (regi
)];
72 if ((regno
== -1) || (regno
== PC_REGNUM
))
73 *(regp
+ CTX_EPC
) = *(greg_t
*) ®isters
[REGISTER_BYTE (PC_REGNUM
)];
75 if ((regno
== -1) || (regno
== CAUSE_REGNUM
))
76 *(regp
+ CTX_CAUSE
) = *(greg_t
*) ®isters
[REGISTER_BYTE (PS_REGNUM
)];
78 if ((regno
== -1) || (regno
== HI_REGNUM
))
79 *(regp
+ CTX_MDHI
) = *(greg_t
*) ®isters
[REGISTER_BYTE (HI_REGNUM
)];
81 if ((regno
== -1) || (regno
== LO_REGNUM
))
82 *(regp
+ CTX_MDLO
) = *(greg_t
*) ®isters
[REGISTER_BYTE (LO_REGNUM
)];
86 * Now we do the same thing for floating-point registers.
87 * We don't bother to condition on FP0_REGNUM since any
88 * reasonable MIPS configuration has an R3010 in it.
90 * Again, see the comments in m68k-tdep.c.
94 supply_fpregset (fpregsetp
)
95 fpregset_t
*fpregsetp
;
99 for (regi
= 0; regi
< 32; regi
++)
100 supply_register (FP0_REGNUM
+ regi
,
101 (char *)&fpregsetp
->fp_r
.fp_regs
[regi
]);
103 supply_register (FCRCS_REGNUM
, (char *)&fpregsetp
->fp_csr
);
105 /* FIXME: how can we supply FCRIR_REGNUM? SGI doesn't tell us. */
109 fill_fpregset (fpregsetp
, regno
)
110 fpregset_t
*fpregsetp
;
116 for (regi
= FP0_REGNUM
; regi
< FP0_REGNUM
+ 32; regi
++)
118 if ((regno
== -1) || (regno
== regi
))
120 from
= (char *) ®isters
[REGISTER_BYTE (regi
)];
121 to
= (char *) &(fpregsetp
->fp_r
.fp_regs
[regi
- FP0_REGNUM
]);
122 memcpy(to
, from
, REGISTER_RAW_SIZE (regi
));
126 if ((regno
== -1) || (regno
== FCRCS_REGNUM
))
127 fpregsetp
->fp_csr
= *(unsigned *) ®isters
[REGISTER_BYTE(FCRCS_REGNUM
)];
131 /* Figure out where the longjmp will land.
132 We expect the first arg to be a pointer to the jmp_buf structure from which
133 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
134 This routine returns true on success. */
137 get_longjmp_target (pc
)
140 char buf
[TARGET_PTR_BIT
/ TARGET_CHAR_BIT
];
143 jb_addr
= read_register (A0_REGNUM
);
145 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
146 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
149 *pc
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
155 fetch_core_registers (core_reg_sect
, core_reg_size
, which
, reg_addr
)
157 unsigned core_reg_size
;
158 int which
; /* Unused */
159 unsigned int reg_addr
; /* Unused */
161 if (core_reg_size
!= REGISTER_BYTES
)
163 warning ("wrong size gregset struct in core file");
167 memcpy ((char *)registers
, core_reg_sect
, core_reg_size
);
170 /* Irix 5 uses what appears to be a unique form of shared library
171 support. This is a copy of solib.c modified for Irix 5. */
173 #include <sys/types.h>
176 #include <sys/param.h>
179 /* <obj.h> includes <sym.h> and <symconst.h>, which causes conflicts
180 with our versions of those files included by tm-mips.h. Prevent
181 <obj.h> from including them with some appropriate defines. */
183 #define __SYMCONST_H__
189 #include "objfiles.h"
193 #include "inferior.h"
194 #include "language.h"
196 /* We need to set a breakpoint at a point when we know that the
197 mapping of shared libraries is complete. dbx simply breaks at main
198 (or, for FORTRAN, MAIN__), so we do the same. We can not break at
199 the very beginning of main, because the startup code will jump into
200 main after the GP initialization instructions. SOLIB_BKPT_OFFSET
201 is used to skip those instructions. */
203 #define SOLIB_BKPT_OFFSET 12
205 static char *bkpt_names
[] = {
211 /* The symbol which starts off the list of shared libraries. */
212 #define DEBUG_BASE "__rld_obj_head"
214 /* How to get the loaded address of a shared library. */
215 #define LM_ADDR(so) ((so)->lm.o_base_address)
217 char shadow_contents
[BREAKPOINT_MAX
]; /* Stash old bkpt addr contents */
219 extern CORE_ADDR sigtramp_address
, sigtramp_end
;
222 struct so_list
*next
; /* next structure in linked list */
224 struct obj lm
; /* copy of link map from inferior */
225 struct obj_list
*lladdr
; /* addr in inferior lm was read from */
226 CORE_ADDR lmend
; /* upper addr bound of mapped object */
227 char symbols_loaded
; /* flag: symbols read in yet? */
228 char from_tty
; /* flag: print msgs? */
229 struct objfile
*objfile
; /* objfile for loaded lib */
230 struct section_table
*sections
;
231 struct section_table
*sections_end
;
232 struct section_table
*textsection
;
236 static struct so_list
*so_list_head
; /* List of known shared objects */
237 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
238 static CORE_ADDR breakpoint_addr
; /* Address where end bkpt is set */
240 /* Local function prototypes */
243 sharedlibrary_command
PARAMS ((char *, int));
246 enable_break
PARAMS ((void));
249 disable_break
PARAMS ((void));
252 info_sharedlibrary_command
PARAMS ((char *, int));
255 symbol_add_stub
PARAMS ((char *));
257 static struct so_list
*
258 find_solib
PARAMS ((struct so_list
*));
260 static struct obj_list
*
261 first_link_map_member
PARAMS ((void));
264 locate_base
PARAMS ((void));
267 solib_map_sections
PARAMS ((struct so_list
*));
273 solib_map_sections -- open bfd and build sections for shared lib
277 static void solib_map_sections (struct so_list *so)
281 Given a pointer to one of the shared objects in our list
282 of mapped objects, use the recorded name to open a bfd
283 descriptor for the object, build a section table, and then
284 relocate all the section addresses by the base address at
285 which the shared object was mapped.
289 In most (all?) cases the shared object file name recorded in the
290 dynamic linkage tables will be a fully qualified pathname. For
291 cases where it isn't, do we really mimic the systems search
292 mechanism correctly in the below code (particularly the tilde
297 solib_map_sections (so
)
301 char *scratch_pathname
;
303 struct section_table
*p
;
304 struct cleanup
*old_chain
;
307 filename
= tilde_expand (so
-> lm
.o_path
);
308 old_chain
= make_cleanup (free
, filename
);
310 scratch_chan
= openp (getenv ("PATH"), 1, filename
, O_RDONLY
, 0,
312 if (scratch_chan
< 0)
314 scratch_chan
= openp (getenv ("LD_LIBRARY_PATH"), 1, filename
,
315 O_RDONLY
, 0, &scratch_pathname
);
317 if (scratch_chan
< 0)
319 perror_with_name (filename
);
321 /* Leave scratch_pathname allocated. abfd->name will point to it. */
323 abfd
= bfd_fdopenr (scratch_pathname
, gnutarget
, scratch_chan
);
326 close (scratch_chan
);
327 error ("Could not open `%s' as an executable file: %s",
328 scratch_pathname
, bfd_errmsg (bfd_error
));
330 /* Leave bfd open, core_xfer_memory and "info files" need it. */
332 abfd
-> cacheable
= true;
334 if (!bfd_check_format (abfd
, bfd_object
))
336 error ("\"%s\": not in executable format: %s.",
337 scratch_pathname
, bfd_errmsg (bfd_error
));
339 if (build_section_table (abfd
, &so
-> sections
, &so
-> sections_end
))
341 error ("Can't find the file sections in `%s': %s",
342 bfd_get_filename (exec_bfd
), bfd_errmsg (bfd_error
));
345 for (p
= so
-> sections
; p
< so
-> sections_end
; p
++)
347 /* Relocate the section binding addresses as recorded in the shared
348 object's file by the base address to which the object was actually
350 p
-> addr
+= (CORE_ADDR
) LM_ADDR (so
);
351 p
-> endaddr
+= (CORE_ADDR
) LM_ADDR (so
);
352 so
-> lmend
= (CORE_ADDR
) max (p
-> endaddr
, so
-> lmend
);
353 if (STREQ (p
-> sec_ptr
-> name
, ".text"))
355 so
-> textsection
= p
;
359 /* Free the file names, close the file now. */
360 do_cleanups (old_chain
);
367 locate_base -- locate the base address of dynamic linker structs
371 CORE_ADDR locate_base (void)
375 For both the SunOS and SVR4 shared library implementations, if the
376 inferior executable has been linked dynamically, there is a single
377 address somewhere in the inferior's data space which is the key to
378 locating all of the dynamic linker's runtime structures. This
379 address is the value of the symbol defined by the macro DEBUG_BASE.
380 The job of this function is to find and return that address, or to
381 return 0 if there is no such address (the executable is statically
384 For SunOS, the job is almost trivial, since the dynamic linker and
385 all of it's structures are statically linked to the executable at
386 link time. Thus the symbol for the address we are looking for has
387 already been added to the minimal symbol table for the executable's
388 objfile at the time the symbol file's symbols were read, and all we
389 have to do is look it up there. Note that we explicitly do NOT want
390 to find the copies in the shared library.
392 The SVR4 version is much more complicated because the dynamic linker
393 and it's structures are located in the shared C library, which gets
394 run as the executable's "interpreter" by the kernel. We have to go
395 to a lot more work to discover the address of DEBUG_BASE. Because
396 of this complexity, we cache the value we find and return that value
397 on subsequent invocations. Note there is no copy in the executable
400 Irix 5 is basically like SunOS.
402 Note that we can assume nothing about the process state at the time
403 we need to find this address. We may be stopped on the first instruc-
404 tion of the interpreter (C shared library), the first instruction of
405 the executable itself, or somewhere else entirely (if we attached
406 to the process for example).
413 struct minimal_symbol
*msymbol
;
414 CORE_ADDR address
= 0;
416 msymbol
= lookup_minimal_symbol (DEBUG_BASE
, symfile_objfile
);
417 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
419 address
= SYMBOL_VALUE_ADDRESS (msymbol
);
428 first_link_map_member -- locate first member in dynamic linker's map
432 static struct link_map *first_link_map_member (void)
436 Read in a copy of the first member in the inferior's dynamic
437 link map from the inferior's dynamic linker structures, and return
438 a pointer to the copy in our address space.
441 static struct obj_list
*
442 first_link_map_member ()
447 read_memory (debug_base
, (char *) &lm
, sizeof (struct obj_list
*));
452 /* The first entry in the list is the object file we are debugging,
454 read_memory ((CORE_ADDR
) lm
, (char *) &s
, sizeof (struct obj_list
));
463 find_solib -- step through list of shared objects
467 struct so_list *find_solib (struct so_list *so_list_ptr)
471 This module contains the routine which finds the names of any
472 loaded "images" in the current process. The argument in must be
473 NULL on the first call, and then the returned value must be passed
474 in on subsequent calls. This provides the capability to "step" down
475 the list of loaded objects. On the last object, a NULL value is
479 static struct so_list
*
480 find_solib (so_list_ptr
)
481 struct so_list
*so_list_ptr
; /* Last lm or NULL for first one */
483 struct so_list
*so_list_next
= NULL
;
484 struct obj_list
*lm
= NULL
;
487 if (so_list_ptr
== NULL
)
489 /* We are setting up for a new scan through the loaded images. */
490 if ((so_list_next
= so_list_head
) == NULL
)
492 /* We have not already read in the dynamic linking structures
493 from the inferior, lookup the address of the base structure. */
494 debug_base
= locate_base ();
497 /* Read the base structure in and find the address of the first
498 link map list member. */
499 lm
= first_link_map_member ();
505 /* We have been called before, and are in the process of walking
506 the shared library list. Advance to the next shared object. */
507 if ((lm
= so_list_ptr
->ll
.next
) == NULL
)
509 /* We have hit the end of the list, so check to see if any were
510 added, but be quiet if we can't read from the target any more. */
511 int status
= target_read_memory ((CORE_ADDR
) so_list_ptr
-> lladdr
,
512 (char *) &(so_list_ptr
-> ll
),
513 sizeof (struct obj_list
));
516 lm
= so_list_ptr
->ll
.next
;
523 so_list_next
= so_list_ptr
-> next
;
525 if ((so_list_next
== NULL
) && (lm
!= NULL
))
527 /* Get next link map structure from inferior image and build a local
528 abbreviated load_map structure */
529 new = (struct so_list
*) xmalloc (sizeof (struct so_list
));
530 memset ((char *) new, 0, sizeof (struct so_list
));
532 /* Add the new node as the next node in the list, or as the root
533 node if this is the first one. */
534 if (so_list_ptr
!= NULL
)
536 so_list_ptr
-> next
= new;
543 read_memory ((CORE_ADDR
) lm
, (char *) &(new -> ll
),
544 sizeof (struct obj_list
));
545 read_memory ((CORE_ADDR
) new->ll
.data
, (char *) &(new -> lm
),
546 sizeof (struct obj
));
547 solib_map_sections (new);
549 return (so_list_next
);
552 /* A small stub to get us past the arg-passing pinhole of catch_errors. */
555 symbol_add_stub (arg
)
558 register struct so_list
*so
= (struct so_list
*) arg
; /* catch_errs bogon */
560 so
-> objfile
= symbol_file_add (so
-> lm
.o_path
, so
-> from_tty
,
561 (unsigned int) so
-> textsection
-> addr
,
570 solib_add -- add a shared library file to the symtab and section list
574 void solib_add (char *arg_string, int from_tty,
575 struct target_ops *target)
582 solib_add (arg_string
, from_tty
, target
)
585 struct target_ops
*target
;
587 register struct so_list
*so
= NULL
; /* link map state variable */
589 /* Last shared library that we read. */
590 struct so_list
*so_last
= NULL
;
596 if ((re_err
= re_comp (arg_string
? arg_string
: ".")) != NULL
)
598 error ("Invalid regexp: %s", re_err
);
601 /* Getting new symbols may change our opinion about what is
603 reinit_frame_cache ();
604 /* Not to mention where _sigtramp is. */
605 sigtramp_address
= 0;
607 while ((so
= find_solib (so
)) != NULL
)
609 if (so
-> lm
.o_path
[0] && re_exec (so
-> lm
.o_path
))
611 so
-> from_tty
= from_tty
;
612 if (so
-> symbols_loaded
)
616 printf_unfiltered ("Symbols already loaded for %s\n", so
-> lm
.o_path
);
619 else if (catch_errors
620 (symbol_add_stub
, (char *) so
,
621 "Error while reading shared library symbols:\n",
625 so
-> symbols_loaded
= 1;
630 /* Now 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
;
647 /* Reallocate the target's section table including the new size. */
648 if (target
-> to_sections
)
650 old
= target
-> to_sections_end
- target
-> to_sections
;
651 target
-> to_sections
= (struct section_table
*)
652 xrealloc ((char *)target
-> to_sections
,
653 (sizeof (struct section_table
)) * (count
+ old
));
658 target
-> to_sections
= (struct section_table
*)
659 xmalloc ((sizeof (struct section_table
)) * count
);
661 target
-> to_sections_end
= target
-> to_sections
+ (count
+ old
);
663 /* Add these section table entries to the target's table. */
664 while ((so
= find_solib (so
)) != NULL
)
666 if (so
-> lm
.o_path
[0])
668 count
= so
-> sections_end
- so
-> sections
;
669 memcpy ((char *) (target
-> to_sections
+ old
),
671 (sizeof (struct section_table
)) * count
);
683 info_sharedlibrary_command -- code for "info sharedlibrary"
687 static void info_sharedlibrary_command ()
691 Walk through the shared library list and print information
692 about each attached library.
696 info_sharedlibrary_command (ignore
, from_tty
)
700 register struct so_list
*so
= NULL
; /* link map state variable */
703 if (exec_bfd
== NULL
)
705 printf_unfiltered ("No exec file.\n");
708 while ((so
= find_solib (so
)) != NULL
)
710 if (so
-> lm
.o_path
[0])
714 printf_unfiltered("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read",
715 "Shared Object Library");
718 printf_unfiltered ("%-12s",
719 local_hex_string_custom ((unsigned long) LM_ADDR (so
),
721 printf_unfiltered ("%-12s",
722 local_hex_string_custom ((unsigned long) so
-> lmend
,
724 printf_unfiltered ("%-12s", so
-> symbols_loaded
? "Yes" : "No");
725 printf_unfiltered ("%s\n", so
-> lm
.o_path
);
728 if (so_list_head
== NULL
)
730 printf_unfiltered ("No shared libraries loaded at this time.\n");
738 solib_address -- check to see if an address is in a shared lib
742 int solib_address (CORE_ADDR address)
746 Provides a hook for other gdb routines to discover whether or
747 not a particular address is within the mapped address space of
748 a shared library. Any address between the base mapping address
749 and the first address beyond the end of the last mapping, is
750 considered to be within the shared library address space, for
753 For example, this routine is called at one point to disable
754 breakpoints which are in shared libraries that are not currently
759 solib_address (address
)
762 register struct so_list
*so
= 0; /* link map state variable */
764 while ((so
= find_solib (so
)) != NULL
)
766 if (so
-> lm
.o_path
[0])
768 if ((address
>= (CORE_ADDR
) so
->lm
.o_base_address
) &&
769 (address
< (CORE_ADDR
) so
-> lmend
))
778 /* Called by free_all_symtabs */
783 struct so_list
*next
;
788 if (so_list_head
-> sections
)
790 free ((PTR
)so_list_head
-> sections
);
792 if (so_list_head
-> abfd
)
794 bfd_filename
= bfd_get_filename (so_list_head
-> abfd
);
795 bfd_close (so_list_head
-> abfd
);
798 /* This happens for the executable on SVR4. */
801 next
= so_list_head
-> next
;
803 free ((PTR
)bfd_filename
);
804 free ((PTR
)so_list_head
);
814 disable_break -- remove the "mapping changed" breakpoint
818 static int disable_break ()
822 Removes the breakpoint that gets hit when the dynamic linker
823 completes a mapping change.
833 /* Note that breakpoint address and original contents are in our address
834 space, so we just need to write the original contents back. */
836 if (memory_remove_breakpoint (breakpoint_addr
, shadow_contents
) != 0)
841 /* For the SVR4 version, we always know the breakpoint address. For the
842 SunOS version we don't know it until the above code is executed.
843 Grumble if we are stopped anywhere besides the breakpoint address. */
845 if (stop_pc
!= breakpoint_addr
)
847 warning ("stopped at unknown breakpoint while handling shared libraries");
857 enable_break -- arrange for dynamic linker to hit breakpoint
861 int enable_break (void)
865 Both the SunOS and the SVR4 dynamic linkers have, as part of their
866 debugger interface, support for arranging for the inferior to hit
867 a breakpoint after mapping in the shared libraries. This function
868 enables that breakpoint.
870 For SunOS, there is a special flag location (in_debugger) which we
871 set to 1. When the dynamic linker sees this flag set, it will set
872 a breakpoint at a location known only to itself, after saving the
873 original contents of that place and the breakpoint address itself,
874 in it's own internal structures. When we resume the inferior, it
875 will eventually take a SIGTRAP when it runs into the breakpoint.
876 We handle this (in a different place) by restoring the contents of
877 the breakpointed location (which is only known after it stops),
878 chasing around to locate the shared libraries that have been
879 loaded, then resuming.
881 For SVR4, the debugger interface structure contains a member (r_brk)
882 which is statically initialized at the time the shared library is
883 built, to the offset of a function (_r_debug_state) which is guaran-
884 teed to be called once before mapping in a library, and again when
885 the mapping is complete. At the time we are examining this member,
886 it contains only the unrelocated offset of the function, so we have
887 to do our own relocation. Later, when the dynamic linker actually
888 runs, it relocates r_brk to be the actual address of _r_debug_state().
890 The debugger interface structure also contains an enumeration which
891 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
892 depending upon whether or not the library is being mapped or unmapped,
893 and then set to RT_CONSISTENT after the library is mapped/unmapped.
895 Irix 5, on the other hand, has no such features. Instead, we
896 set a breakpoint at main.
903 struct minimal_symbol
*msymbol
;
907 /* Scan through the list of symbols, trying to look up the symbol and
908 set a breakpoint there. Terminate loop when we/if we succeed. */
911 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
913 msymbol
= lookup_minimal_symbol (*bkpt_namep
, symfile_objfile
);
914 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
916 bkpt_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
917 #ifdef SOLIB_BKPT_OFFSET
918 /* We only want to skip if bkpt_addr is currently pointing
919 at a GP setting instruction. */
923 if (target_read_memory (bkpt_addr
, buf
, 4) == 0)
927 insn
= extract_unsigned_integer (buf
, 4);
928 if ((insn
& 0xffff0000) == 0x3c1c0000) /* lui $gp,n */
929 bkpt_addr
+= SOLIB_BKPT_OFFSET
;
933 if (target_insert_breakpoint (bkpt_addr
, shadow_contents
) == 0)
935 breakpoint_addr
= bkpt_addr
;
949 solib_create_inferior_hook -- shared library startup support
953 void solib_create_inferior_hook()
957 When gdb starts up the inferior, it nurses it along (through the
958 shell) until it is ready to execute it's first instruction. At this
959 point, this function gets called via expansion of the macro
960 SOLIB_CREATE_INFERIOR_HOOK.
962 For SunOS executables, this first instruction is typically the
963 one at "_start", or a similar text label, regardless of whether
964 the executable is statically or dynamically linked. The runtime
965 startup code takes care of dynamically linking in any shared
966 libraries, once gdb allows the inferior to continue.
968 For SVR4 executables, this first instruction is either the first
969 instruction in the dynamic linker (for dynamically linked
970 executables) or the instruction at "start" for statically linked
971 executables. For dynamically linked executables, the system
972 first exec's /lib/libc.so.N, which contains the dynamic linker,
973 and starts it running. The dynamic linker maps in any needed
974 shared libraries, maps in the actual user executable, and then
975 jumps to "start" in the user executable.
977 For both SunOS shared libraries, and SVR4 shared libraries, we
978 can arrange to cooperate with the dynamic linker to discover the
979 names of shared libraries that are dynamically linked, and the
980 base addresses to which they are linked.
982 This function is responsible for discovering those names and
983 addresses, and saving sufficient information about them to allow
984 their symbols to be read at a later time.
988 Between enable_break() and disable_break(), this code does not
989 properly handle hitting breakpoints which the user might have
990 set in the startup code or in the dynamic linker itself. Proper
991 handling will probably have to wait until the implementation is
992 changed to use the "breakpoint handler function" method.
994 Also, what if child has exit()ed? Must exit loop somehow.
998 solib_create_inferior_hook()
1000 if (!enable_break ())
1002 warning ("shared library handler failed to enable breakpoint");
1006 /* Now run the target. It will eventually hit the breakpoint, at
1007 which point all of the libraries will have been mapped in and we
1008 can go groveling around in the dynamic linker structures to find
1009 out what we need to know about them. */
1011 clear_proceed_status ();
1012 stop_soon_quietly
= 1;
1016 target_resume (-1, 0, stop_signal
);
1017 wait_for_inferior ();
1019 while (stop_signal
!= SIGTRAP
);
1020 stop_soon_quietly
= 0;
1022 /* We are now either at the "mapping complete" breakpoint (or somewhere
1023 else, a condition we aren't prepared to deal with anyway), so adjust
1024 the PC as necessary after a breakpoint, disable the breakpoint, and
1025 add any shared libraries that were mapped in. */
1027 if (DECR_PC_AFTER_BREAK
)
1029 stop_pc
-= DECR_PC_AFTER_BREAK
;
1030 write_register (PC_REGNUM
, stop_pc
);
1033 if (!disable_break ())
1035 warning ("shared library handler failed to disable breakpoint");
1038 solib_add ((char *) 0, 0, (struct target_ops
*) 0);
1045 sharedlibrary_command -- handle command to explicitly add library
1049 static void sharedlibrary_command (char *args, int from_tty)
1056 sharedlibrary_command (args
, from_tty
)
1061 solib_add (args
, from_tty
, (struct target_ops
*) 0);
1068 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1069 "Load shared object library symbols for files matching REGEXP.");
1070 add_info ("sharedlibrary", info_sharedlibrary_command
,
1071 "Status of loaded shared object libraries.");