1 /* Native support for the SGI Iris running IRIX version 5, for GDB.
2 Copyright 1988, 89, 90, 91, 92, 93, 94, 95, 96, 98, 1999
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,
24 Boston, MA 02111-1307, USA. */
31 #include "gdb_string.h"
33 #include <sys/procfs.h>
34 #include <setjmp.h> /* For JB_XXX. */
36 /* Prototypes for supply_gregset etc. */
39 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR
);
41 /* Size of elements in jmpbuf */
43 #define JB_ELEMENT_SIZE 4
46 * See the comment in m68k-tdep.c regarding the utility of these functions.
48 * These definitions are from the MIPS SVR4 ABI, so they may work for
49 * any MIPS SVR4 target.
53 supply_gregset (gregset_t
*gregsetp
)
56 register greg_t
*regp
= &(*gregsetp
)[0];
57 int gregoff
= sizeof (greg_t
) - MIPS_REGSIZE
;
58 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] =
61 for (regi
= 0; regi
<= CTX_RA
; regi
++)
62 supply_register (regi
, (char *) (regp
+ regi
) + gregoff
);
64 supply_register (PC_REGNUM
, (char *) (regp
+ CTX_EPC
) + gregoff
);
65 supply_register (HI_REGNUM
, (char *) (regp
+ CTX_MDHI
) + gregoff
);
66 supply_register (LO_REGNUM
, (char *) (regp
+ CTX_MDLO
) + gregoff
);
67 supply_register (CAUSE_REGNUM
, (char *) (regp
+ CTX_CAUSE
) + gregoff
);
69 /* Fill inaccessible registers with zero. */
70 supply_register (BADVADDR_REGNUM
, zerobuf
);
74 fill_gregset (gregset_t
*gregsetp
, int regno
)
77 register greg_t
*regp
= &(*gregsetp
)[0];
79 /* Under Irix6, if GDB is built with N32 ABI and is debugging an O32
80 executable, we have to sign extend the registers to 64 bits before
81 filling in the gregset structure. */
83 for (regi
= 0; regi
<= CTX_RA
; regi
++)
84 if ((regno
== -1) || (regno
== regi
))
86 extract_signed_integer (®isters
[REGISTER_BYTE (regi
)],
87 REGISTER_RAW_SIZE (regi
));
89 if ((regno
== -1) || (regno
== PC_REGNUM
))
91 extract_signed_integer (®isters
[REGISTER_BYTE (PC_REGNUM
)],
92 REGISTER_RAW_SIZE (PC_REGNUM
));
94 if ((regno
== -1) || (regno
== CAUSE_REGNUM
))
96 extract_signed_integer (®isters
[REGISTER_BYTE (CAUSE_REGNUM
)],
97 REGISTER_RAW_SIZE (CAUSE_REGNUM
));
99 if ((regno
== -1) || (regno
== HI_REGNUM
))
101 extract_signed_integer (®isters
[REGISTER_BYTE (HI_REGNUM
)],
102 REGISTER_RAW_SIZE (HI_REGNUM
));
104 if ((regno
== -1) || (regno
== LO_REGNUM
))
106 extract_signed_integer (®isters
[REGISTER_BYTE (LO_REGNUM
)],
107 REGISTER_RAW_SIZE (LO_REGNUM
));
111 * Now we do the same thing for floating-point registers.
112 * We don't bother to condition on FP0_REGNUM since any
113 * reasonable MIPS configuration has an R3010 in it.
115 * Again, see the comments in m68k-tdep.c.
119 supply_fpregset (fpregset_t
*fpregsetp
)
122 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] =
125 /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
127 for (regi
= 0; regi
< 32; regi
++)
128 supply_register (FP0_REGNUM
+ regi
,
129 (char *) &fpregsetp
->fp_r
.fp_regs
[regi
]);
131 supply_register (FCRCS_REGNUM
, (char *) &fpregsetp
->fp_csr
);
133 /* FIXME: how can we supply FCRIR_REGNUM? SGI doesn't tell us. */
134 supply_register (FCRIR_REGNUM
, zerobuf
);
138 fill_fpregset (fpregset_t
*fpregsetp
, int regno
)
143 /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
145 for (regi
= FP0_REGNUM
; regi
< FP0_REGNUM
+ 32; regi
++)
147 if ((regno
== -1) || (regno
== regi
))
149 from
= (char *) ®isters
[REGISTER_BYTE (regi
)];
150 to
= (char *) &(fpregsetp
->fp_r
.fp_regs
[regi
- FP0_REGNUM
]);
151 memcpy (to
, from
, REGISTER_RAW_SIZE (regi
));
155 if ((regno
== -1) || (regno
== FCRCS_REGNUM
))
156 fpregsetp
->fp_csr
= *(unsigned *) ®isters
[REGISTER_BYTE (FCRCS_REGNUM
)];
160 /* Figure out where the longjmp will land.
161 We expect the first arg to be a pointer to the jmp_buf structure from which
162 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
163 This routine returns true on success. */
166 get_longjmp_target (CORE_ADDR
*pc
)
171 buf
= alloca (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
172 jb_addr
= read_register (A0_REGNUM
);
174 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
175 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
178 *pc
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
183 /* Provide registers to GDB from a core file.
185 CORE_REG_SECT points to an array of bytes, which were obtained from
186 a core file which BFD thinks might contain register contents.
187 CORE_REG_SIZE is its size.
189 Normally, WHICH says which register set corelow suspects this is:
190 0 --- the general-purpose register set
191 2 --- the floating-point register set
192 However, for Irix 5, WHICH isn't used.
194 REG_ADDR is also unused. */
197 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
,
198 int which
, CORE_ADDR reg_addr
)
200 if (core_reg_size
== REGISTER_BYTES
)
202 memcpy ((char *) registers
, core_reg_sect
, core_reg_size
);
204 else if (MIPS_REGSIZE
== 4 &&
205 core_reg_size
== (2 * MIPS_REGSIZE
) * NUM_REGS
)
207 /* This is a core file from a N32 executable, 64 bits are saved
208 for all registers. */
209 char *srcp
= core_reg_sect
;
210 char *dstp
= registers
;
213 for (regno
= 0; regno
< NUM_REGS
; regno
++)
215 if (regno
>= FP0_REGNUM
&& regno
< (FP0_REGNUM
+ 32))
217 /* FIXME, this is wrong, N32 has 64 bit FP regs, but GDB
218 currently assumes that they are 32 bit. */
223 if (REGISTER_RAW_SIZE (regno
) == 4)
225 /* copying 4 bytes from eight bytes?
226 I don't see how this can be right... */
231 /* copy all 8 bytes (sizeof(double)) */
250 warning ("wrong size gregset struct in core file");
254 registers_fetched ();
257 /* Irix 5 uses what appears to be a unique form of shared library
258 support. This is a copy of solib.c modified for Irix 5. */
259 /* FIXME: Most of this code could be merged with osfsolib.c and solib.c
260 by using next_link_map_member and xfer_link_map_member in solib.c. */
262 #include <sys/types.h>
264 #include <sys/param.h>
267 /* <obj.h> includes <sym.h> and <symconst.h>, which causes conflicts
268 with our versions of those files included by tm-mips.h. Prevent
269 <obj.h> from including them with some appropriate defines. */
271 #define __SYMCONST_H__
273 #ifdef HAVE_OBJLIST_H
277 #ifdef NEW_OBJ_INFO_MAGIC
278 #define HANDLE_NEW_OBJ_LIST
284 #include "objfiles.h"
287 #include "gdb_regex.h"
288 #include "inferior.h"
289 #include "language.h"
292 /* The symbol which starts off the list of shared libraries. */
293 #define DEBUG_BASE "__rld_obj_head"
295 /* Irix 6.x introduces a new variant of object lists.
296 To be able to debug O32 executables under Irix 6, we have to handle both
301 OBJ_LIST_OLD
, /* Pre Irix 6.x object list. */
302 OBJ_LIST_32
, /* 32 Bit Elf32_Obj_Info. */
303 OBJ_LIST_64
/* 64 Bit Elf64_Obj_Info, FIXME not yet implemented. */
307 /* Define our own link_map structure.
308 This will help to share code with osfsolib.c and solib.c. */
312 obj_list_variant l_variant
; /* which variant of object list */
313 CORE_ADDR l_lladdr
; /* addr in inferior list was read from */
314 CORE_ADDR l_next
; /* address of next object list entry */
317 /* Irix 5 shared objects are pre-linked to particular addresses
318 although the dynamic linker may have to relocate them if the
319 address ranges of the libraries used by the main program clash.
320 The offset is the difference between the address where the object
321 is mapped and the binding address of the shared library. */
322 #define LM_OFFSET(so) ((so) -> offset)
323 /* Loaded address of shared library. */
324 #define LM_ADDR(so) ((so) -> lmstart)
326 char shadow_contents
[BREAKPOINT_MAX
]; /* Stash old bkpt addr contents */
330 struct so_list
*next
; /* next structure in linked list */
332 CORE_ADDR offset
; /* prelink to load address offset */
333 char *so_name
; /* shared object lib name */
334 CORE_ADDR lmstart
; /* lower addr bound of mapped object */
335 CORE_ADDR lmend
; /* upper addr bound of mapped object */
336 char symbols_loaded
; /* flag: symbols read in yet? */
337 char from_tty
; /* flag: print msgs? */
338 struct objfile
*objfile
; /* objfile for loaded lib */
339 struct section_table
*sections
;
340 struct section_table
*sections_end
;
341 struct section_table
*textsection
;
345 static struct so_list
*so_list_head
; /* List of known shared objects */
346 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
347 static CORE_ADDR breakpoint_addr
; /* Address where end bkpt is set */
349 /* Local function prototypes */
351 static void sharedlibrary_command (char *, int);
353 static int enable_break (void);
355 static int disable_break (void);
357 static void info_sharedlibrary_command (char *, int);
359 static int symbol_add_stub (void *);
361 static struct so_list
*find_solib (struct so_list
*);
363 static struct link_map
*first_link_map_member (void);
365 static struct link_map
*next_link_map_member (struct so_list
*);
367 static void xfer_link_map_member (struct so_list
*, struct link_map
*);
369 static CORE_ADDR
locate_base (void);
371 static int solib_map_sections (void *);
377 solib_map_sections -- open bfd and build sections for shared lib
381 static int solib_map_sections (struct so_list *so)
385 Given a pointer to one of the shared objects in our list
386 of mapped objects, use the recorded name to open a bfd
387 descriptor for the object, build a section table, and then
388 relocate all the section addresses by the base address at
389 which the shared object was mapped.
393 In most (all?) cases the shared object file name recorded in the
394 dynamic linkage tables will be a fully qualified pathname. For
395 cases where it isn't, do we really mimic the systems search
396 mechanism correctly in the below code (particularly the tilde
401 solib_map_sections (void *arg
)
403 struct so_list
*so
= (struct so_list
*) arg
; /* catch_errors bogon */
405 char *scratch_pathname
;
407 struct section_table
*p
;
408 struct cleanup
*old_chain
;
411 filename
= tilde_expand (so
->so_name
);
412 old_chain
= make_cleanup (xfree
, filename
);
414 scratch_chan
= openp (getenv ("PATH"), 1, filename
, O_RDONLY
, 0,
416 if (scratch_chan
< 0)
418 scratch_chan
= openp (getenv ("LD_LIBRARY_PATH"), 1, filename
,
419 O_RDONLY
, 0, &scratch_pathname
);
421 if (scratch_chan
< 0)
423 perror_with_name (filename
);
425 /* Leave scratch_pathname allocated. abfd->name will point to it. */
427 abfd
= bfd_fdopenr (scratch_pathname
, gnutarget
, scratch_chan
);
430 close (scratch_chan
);
431 error ("Could not open `%s' as an executable file: %s",
432 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
434 /* Leave bfd open, core_xfer_memory and "info files" need it. */
436 abfd
->cacheable
= true;
438 if (!bfd_check_format (abfd
, bfd_object
))
440 error ("\"%s\": not in executable format: %s.",
441 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
443 if (build_section_table (abfd
, &so
->sections
, &so
->sections_end
))
445 error ("Can't find the file sections in `%s': %s",
446 bfd_get_filename (exec_bfd
), bfd_errmsg (bfd_get_error ()));
449 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
451 /* Relocate the section binding addresses as recorded in the shared
452 object's file by the offset to get the address to which the
453 object was actually mapped. */
454 p
->addr
+= LM_OFFSET (so
);
455 p
->endaddr
+= LM_OFFSET (so
);
456 so
->lmend
= (CORE_ADDR
) max (p
->endaddr
, so
->lmend
);
457 if (STREQ (p
->the_bfd_section
->name
, ".text"))
463 /* Free the file names, close the file now. */
464 do_cleanups (old_chain
);
466 /* must be non-zero */
474 locate_base -- locate the base address of dynamic linker structs
478 CORE_ADDR locate_base (void)
482 For both the SunOS and SVR4 shared library implementations, if the
483 inferior executable has been linked dynamically, there is a single
484 address somewhere in the inferior's data space which is the key to
485 locating all of the dynamic linker's runtime structures. This
486 address is the value of the symbol defined by the macro DEBUG_BASE.
487 The job of this function is to find and return that address, or to
488 return 0 if there is no such address (the executable is statically
491 For SunOS, the job is almost trivial, since the dynamic linker and
492 all of it's structures are statically linked to the executable at
493 link time. Thus the symbol for the address we are looking for has
494 already been added to the minimal symbol table for the executable's
495 objfile at the time the symbol file's symbols were read, and all we
496 have to do is look it up there. Note that we explicitly do NOT want
497 to find the copies in the shared library.
499 The SVR4 version is much more complicated because the dynamic linker
500 and it's structures are located in the shared C library, which gets
501 run as the executable's "interpreter" by the kernel. We have to go
502 to a lot more work to discover the address of DEBUG_BASE. Because
503 of this complexity, we cache the value we find and return that value
504 on subsequent invocations. Note there is no copy in the executable
507 Irix 5 is basically like SunOS.
509 Note that we can assume nothing about the process state at the time
510 we need to find this address. We may be stopped on the first instruc-
511 tion of the interpreter (C shared library), the first instruction of
512 the executable itself, or somewhere else entirely (if we attached
513 to the process for example).
520 struct minimal_symbol
*msymbol
;
521 CORE_ADDR address
= 0;
523 msymbol
= lookup_minimal_symbol (DEBUG_BASE
, NULL
, symfile_objfile
);
524 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
526 address
= SYMBOL_VALUE_ADDRESS (msymbol
);
535 first_link_map_member -- locate first member in dynamic linker's map
539 static struct link_map *first_link_map_member (void)
543 Read in a copy of the first member in the inferior's dynamic
544 link map from the inferior's dynamic linker structures, and return
545 a pointer to the link map descriptor.
548 static struct link_map
*
549 first_link_map_member (void)
551 struct obj_list
*listp
;
552 struct obj_list list_old
;
554 static struct link_map first_lm
;
556 CORE_ADDR next_lladdr
;
558 /* We have not already read in the dynamic linking structures
559 from the inferior, lookup the address of the base structure. */
560 debug_base
= locate_base ();
564 /* Get address of first list entry. */
565 read_memory (debug_base
, (char *) &listp
, sizeof (struct obj_list
*));
570 /* Get first list entry. */
571 /* The MIPS Sign extends addresses. */
572 lladdr
= host_pointer_to_address (listp
);
573 read_memory (lladdr
, (char *) &list_old
, sizeof (struct obj_list
));
575 /* The first entry in the list is the object file we are debugging,
577 next_lladdr
= host_pointer_to_address (list_old
.next
);
579 #ifdef HANDLE_NEW_OBJ_LIST
580 if (list_old
.data
== NEW_OBJ_INFO_MAGIC
)
582 Elf32_Obj_Info list_32
;
584 read_memory (lladdr
, (char *) &list_32
, sizeof (Elf32_Obj_Info
));
585 if (list_32
.oi_size
!= sizeof (Elf32_Obj_Info
))
587 next_lladdr
= (CORE_ADDR
) list_32
.oi_next
;
591 if (next_lladdr
== 0)
594 first_lm
.l_lladdr
= next_lladdr
;
603 next_link_map_member -- locate next member in dynamic linker's map
607 static struct link_map *next_link_map_member (so_list_ptr)
611 Read in a copy of the next member in the inferior's dynamic
612 link map from the inferior's dynamic linker structures, and return
613 a pointer to the link map descriptor.
616 static struct link_map
*
617 next_link_map_member (struct so_list
*so_list_ptr
)
619 struct link_map
*lm
= &so_list_ptr
->lm
;
620 CORE_ADDR next_lladdr
= lm
->l_next
;
621 static struct link_map next_lm
;
623 if (next_lladdr
== 0)
625 /* We have hit the end of the list, so check to see if any were
626 added, but be quiet if we can't read from the target any more. */
629 if (lm
->l_variant
== OBJ_LIST_OLD
)
631 struct obj_list list_old
;
633 status
= target_read_memory (lm
->l_lladdr
,
635 sizeof (struct obj_list
));
636 next_lladdr
= host_pointer_to_address (list_old
.next
);
638 #ifdef HANDLE_NEW_OBJ_LIST
639 else if (lm
->l_variant
== OBJ_LIST_32
)
641 Elf32_Obj_Info list_32
;
642 status
= target_read_memory (lm
->l_lladdr
,
644 sizeof (Elf32_Obj_Info
));
645 next_lladdr
= (CORE_ADDR
) list_32
.oi_next
;
649 if (status
!= 0 || next_lladdr
== 0)
653 next_lm
.l_lladdr
= next_lladdr
;
662 xfer_link_map_member -- set local variables from dynamic linker's map
666 static void xfer_link_map_member (so_list_ptr, lm)
670 Read in a copy of the requested member in the inferior's dynamic
671 link map from the inferior's dynamic linker structures, and fill
672 in the necessary so_list_ptr elements.
676 xfer_link_map_member (struct so_list
*so_list_ptr
, struct link_map
*lm
)
678 struct obj_list list_old
;
679 CORE_ADDR lladdr
= lm
->l_lladdr
;
680 struct link_map
*new_lm
= &so_list_ptr
->lm
;
683 read_memory (lladdr
, (char *) &list_old
, sizeof (struct obj_list
));
685 new_lm
->l_variant
= OBJ_LIST_OLD
;
686 new_lm
->l_lladdr
= lladdr
;
687 new_lm
->l_next
= host_pointer_to_address (list_old
.next
);
689 #ifdef HANDLE_NEW_OBJ_LIST
690 if (list_old
.data
== NEW_OBJ_INFO_MAGIC
)
692 Elf32_Obj_Info list_32
;
694 read_memory (lladdr
, (char *) &list_32
, sizeof (Elf32_Obj_Info
));
695 if (list_32
.oi_size
!= sizeof (Elf32_Obj_Info
))
697 new_lm
->l_variant
= OBJ_LIST_32
;
698 new_lm
->l_next
= (CORE_ADDR
) list_32
.oi_next
;
700 target_read_string ((CORE_ADDR
) list_32
.oi_pathname
,
701 &so_list_ptr
->so_name
,
702 list_32
.oi_pathname_len
+ 1, &errcode
);
704 memory_error (errcode
, (CORE_ADDR
) list_32
.oi_pathname
);
706 LM_ADDR (so_list_ptr
) = (CORE_ADDR
) list_32
.oi_ehdr
;
707 LM_OFFSET (so_list_ptr
) =
708 (CORE_ADDR
) list_32
.oi_ehdr
- (CORE_ADDR
) list_32
.oi_orig_ehdr
;
713 #if defined (_MIPS_SIM_NABI32) && _MIPS_SIM == _MIPS_SIM_NABI32
714 /* If we are compiling GDB under N32 ABI, the alignments in
715 the obj struct are different from the O32 ABI and we will get
716 wrong values when accessing the struct.
717 As a workaround we use fixed values which are good for
721 read_memory ((CORE_ADDR
) list_old
.data
, buf
, sizeof (buf
));
723 target_read_string (extract_address (&buf
[236], 4),
724 &so_list_ptr
->so_name
,
727 memory_error (errcode
, extract_address (&buf
[236], 4));
729 LM_ADDR (so_list_ptr
) = extract_address (&buf
[196], 4);
730 LM_OFFSET (so_list_ptr
) =
731 extract_address (&buf
[196], 4) - extract_address (&buf
[248], 4);
735 read_memory ((CORE_ADDR
) list_old
.data
, (char *) &obj_old
,
736 sizeof (struct obj
));
738 target_read_string ((CORE_ADDR
) obj_old
.o_path
,
739 &so_list_ptr
->so_name
,
742 memory_error (errcode
, (CORE_ADDR
) obj_old
.o_path
);
744 LM_ADDR (so_list_ptr
) = (CORE_ADDR
) obj_old
.o_praw
;
745 LM_OFFSET (so_list_ptr
) =
746 (CORE_ADDR
) obj_old
.o_praw
- obj_old
.o_base_address
;
750 catch_errors (solib_map_sections
, (char *) so_list_ptr
,
751 "Error while mapping shared library sections:\n",
760 find_solib -- step through list of shared objects
764 struct so_list *find_solib (struct so_list *so_list_ptr)
768 This module contains the routine which finds the names of any
769 loaded "images" in the current process. The argument in must be
770 NULL on the first call, and then the returned value must be passed
771 in on subsequent calls. This provides the capability to "step" down
772 the list of loaded objects. On the last object, a NULL value is
776 static struct so_list
*
777 find_solib (struct so_list
*so_list_ptr
)
779 struct so_list
*so_list_next
= NULL
;
780 struct link_map
*lm
= NULL
;
783 if (so_list_ptr
== NULL
)
785 /* We are setting up for a new scan through the loaded images. */
786 if ((so_list_next
= so_list_head
) == NULL
)
788 /* Find the first link map list member. */
789 lm
= first_link_map_member ();
794 /* We have been called before, and are in the process of walking
795 the shared library list. Advance to the next shared object. */
796 lm
= next_link_map_member (so_list_ptr
);
797 so_list_next
= so_list_ptr
->next
;
799 if ((so_list_next
== NULL
) && (lm
!= NULL
))
801 new = (struct so_list
*) xmalloc (sizeof (struct so_list
));
802 memset ((char *) new, 0, sizeof (struct so_list
));
803 /* Add the new node as the next node in the list, or as the root
804 node if this is the first one. */
805 if (so_list_ptr
!= NULL
)
807 so_list_ptr
->next
= new;
814 xfer_link_map_member (new, lm
);
816 return (so_list_next
);
819 /* A small stub to get us past the arg-passing pinhole of catch_errors. */
822 symbol_add_stub (void *arg
)
824 register struct so_list
*so
= (struct so_list
*) arg
; /* catch_errs bogon */
825 CORE_ADDR text_addr
= 0;
826 struct section_addr_info section_addrs
;
828 memset (§ion_addrs
, 0, sizeof (section_addrs
));
830 text_addr
= so
->textsection
->addr
;
831 else if (so
->abfd
!= NULL
)
833 asection
*lowest_sect
;
835 /* If we didn't find a mapped non zero sized .text section, set up
836 text_addr so that the relocation in symbol_file_add does no harm. */
838 lowest_sect
= bfd_get_section_by_name (so
->abfd
, ".text");
839 if (lowest_sect
== NULL
)
840 bfd_map_over_sections (so
->abfd
, find_lowest_section
,
843 text_addr
= bfd_section_vma (so
->abfd
, lowest_sect
) + LM_OFFSET (so
);
847 section_addrs
.other
[0].name
= ".text";
848 section_addrs
.other
[0].addr
= text_addr
;
849 so
->objfile
= symbol_file_add (so
->so_name
, so
->from_tty
,
850 §ion_addrs
, 0, 0);
851 /* must be non-zero */
859 solib_add -- add a shared library file to the symtab and section list
863 void solib_add (char *arg_string, int from_tty,
864 struct target_ops *target)
871 solib_add (char *arg_string
, int from_tty
, struct target_ops
*target
)
873 register struct so_list
*so
= NULL
; /* link map state variable */
875 /* Last shared library that we read. */
876 struct so_list
*so_last
= NULL
;
882 if ((re_err
= re_comp (arg_string
? arg_string
: ".")) != NULL
)
884 error ("Invalid regexp: %s", re_err
);
887 /* Add the shared library sections to the section table of the
888 specified target, if any. */
891 /* Count how many new section_table entries there are. */
894 while ((so
= find_solib (so
)) != NULL
)
898 count
+= so
->sections_end
- so
->sections
;
904 old
= target_resize_to_sections (target
, count
);
906 /* Add these section table entries to the target's table. */
907 while ((so
= find_solib (so
)) != NULL
)
911 count
= so
->sections_end
- so
->sections
;
912 memcpy ((char *) (target
->to_sections
+ old
),
914 (sizeof (struct section_table
)) * count
);
921 /* Now add the symbol files. */
922 while ((so
= find_solib (so
)) != NULL
)
924 if (so
->so_name
[0] && re_exec (so
->so_name
))
926 so
->from_tty
= from_tty
;
927 if (so
->symbols_loaded
)
931 printf_unfiltered ("Symbols already loaded for %s\n", so
->so_name
);
934 else if (catch_errors
935 (symbol_add_stub
, (char *) so
,
936 "Error while reading shared library symbols:\n",
940 so
->symbols_loaded
= 1;
945 /* Getting new symbols may change our opinion about what is
948 reinit_frame_cache ();
955 info_sharedlibrary_command -- code for "info sharedlibrary"
959 static void info_sharedlibrary_command ()
963 Walk through the shared library list and print information
964 about each attached library.
968 info_sharedlibrary_command (char *ignore
, int from_tty
)
970 register struct so_list
*so
= NULL
; /* link map state variable */
973 if (exec_bfd
== NULL
)
975 printf_unfiltered ("No executable file.\n");
978 while ((so
= find_solib (so
)) != NULL
)
984 printf_unfiltered ("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read",
985 "Shared Object Library");
988 printf_unfiltered ("%-12s",
989 local_hex_string_custom ((unsigned long) LM_ADDR (so
),
991 printf_unfiltered ("%-12s",
992 local_hex_string_custom ((unsigned long) so
->lmend
,
994 printf_unfiltered ("%-12s", so
->symbols_loaded
? "Yes" : "No");
995 printf_unfiltered ("%s\n", so
->so_name
);
998 if (so_list_head
== NULL
)
1000 printf_unfiltered ("No shared libraries loaded at this time.\n");
1008 solib_address -- check to see if an address is in a shared lib
1012 char *solib_address (CORE_ADDR address)
1016 Provides a hook for other gdb routines to discover whether or
1017 not a particular address is within the mapped address space of
1018 a shared library. Any address between the base mapping address
1019 and the first address beyond the end of the last mapping, is
1020 considered to be within the shared library address space, for
1023 For example, this routine is called at one point to disable
1024 breakpoints which are in shared libraries that are not currently
1029 solib_address (CORE_ADDR address
)
1031 register struct so_list
*so
= 0; /* link map state variable */
1033 while ((so
= find_solib (so
)) != NULL
)
1037 if ((address
>= (CORE_ADDR
) LM_ADDR (so
)) &&
1038 (address
< (CORE_ADDR
) so
->lmend
))
1039 return (so
->so_name
);
1045 /* Called by free_all_symtabs */
1050 struct so_list
*next
;
1053 disable_breakpoints_in_shlibs (1);
1055 while (so_list_head
)
1057 if (so_list_head
->sections
)
1059 xfree (so_list_head
->sections
);
1061 if (so_list_head
->abfd
)
1063 bfd_filename
= bfd_get_filename (so_list_head
->abfd
);
1064 if (!bfd_close (so_list_head
->abfd
))
1065 warning ("cannot close \"%s\": %s",
1066 bfd_filename
, bfd_errmsg (bfd_get_error ()));
1069 /* This happens for the executable on SVR4. */
1070 bfd_filename
= NULL
;
1072 next
= so_list_head
->next
;
1074 xfree (bfd_filename
);
1075 xfree (so_list_head
->so_name
);
1076 xfree (so_list_head
);
1077 so_list_head
= next
;
1086 disable_break -- remove the "mapping changed" breakpoint
1090 static int disable_break ()
1094 Removes the breakpoint that gets hit when the dynamic linker
1095 completes a mapping change.
1100 disable_break (void)
1105 /* Note that breakpoint address and original contents are in our address
1106 space, so we just need to write the original contents back. */
1108 if (memory_remove_breakpoint (breakpoint_addr
, shadow_contents
) != 0)
1113 /* For the SVR4 version, we always know the breakpoint address. For the
1114 SunOS version we don't know it until the above code is executed.
1115 Grumble if we are stopped anywhere besides the breakpoint address. */
1117 if (stop_pc
!= breakpoint_addr
)
1119 warning ("stopped at unknown breakpoint while handling shared libraries");
1129 enable_break -- arrange for dynamic linker to hit breakpoint
1133 int enable_break (void)
1137 This functions inserts a breakpoint at the entry point of the
1138 main executable, where all shared libraries are mapped in.
1144 if (symfile_objfile
!= NULL
1145 && target_insert_breakpoint (symfile_objfile
->ei
.entry_point
,
1146 shadow_contents
) == 0)
1148 breakpoint_addr
= symfile_objfile
->ei
.entry_point
;
1159 solib_create_inferior_hook -- shared library startup support
1163 void solib_create_inferior_hook()
1167 When gdb starts up the inferior, it nurses it along (through the
1168 shell) until it is ready to execute it's first instruction. At this
1169 point, this function gets called via expansion of the macro
1170 SOLIB_CREATE_INFERIOR_HOOK.
1172 For SunOS executables, this first instruction is typically the
1173 one at "_start", or a similar text label, regardless of whether
1174 the executable is statically or dynamically linked. The runtime
1175 startup code takes care of dynamically linking in any shared
1176 libraries, once gdb allows the inferior to continue.
1178 For SVR4 executables, this first instruction is either the first
1179 instruction in the dynamic linker (for dynamically linked
1180 executables) or the instruction at "start" for statically linked
1181 executables. For dynamically linked executables, the system
1182 first exec's /lib/libc.so.N, which contains the dynamic linker,
1183 and starts it running. The dynamic linker maps in any needed
1184 shared libraries, maps in the actual user executable, and then
1185 jumps to "start" in the user executable.
1187 For both SunOS shared libraries, and SVR4 shared libraries, we
1188 can arrange to cooperate with the dynamic linker to discover the
1189 names of shared libraries that are dynamically linked, and the
1190 base addresses to which they are linked.
1192 This function is responsible for discovering those names and
1193 addresses, and saving sufficient information about them to allow
1194 their symbols to be read at a later time.
1198 Between enable_break() and disable_break(), this code does not
1199 properly handle hitting breakpoints which the user might have
1200 set in the startup code or in the dynamic linker itself. Proper
1201 handling will probably have to wait until the implementation is
1202 changed to use the "breakpoint handler function" method.
1204 Also, what if child has exit()ed? Must exit loop somehow.
1208 solib_create_inferior_hook (void)
1210 if (!enable_break ())
1212 warning ("shared library handler failed to enable breakpoint");
1216 /* Now run the target. It will eventually hit the breakpoint, at
1217 which point all of the libraries will have been mapped in and we
1218 can go groveling around in the dynamic linker structures to find
1219 out what we need to know about them. */
1221 clear_proceed_status ();
1222 stop_soon_quietly
= 1;
1223 stop_signal
= TARGET_SIGNAL_0
;
1226 target_resume (-1, 0, stop_signal
);
1227 wait_for_inferior ();
1229 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
1231 /* We are now either at the "mapping complete" breakpoint (or somewhere
1232 else, a condition we aren't prepared to deal with anyway), so adjust
1233 the PC as necessary after a breakpoint, disable the breakpoint, and
1234 add any shared libraries that were mapped in. */
1236 if (DECR_PC_AFTER_BREAK
)
1238 stop_pc
-= DECR_PC_AFTER_BREAK
;
1239 write_register (PC_REGNUM
, stop_pc
);
1242 if (!disable_break ())
1244 warning ("shared library handler failed to disable breakpoint");
1247 /* solib_add will call reinit_frame_cache.
1248 But we are stopped in the startup code and we might not have symbols
1249 for the startup code, so heuristic_proc_start could be called
1250 and will put out an annoying warning.
1251 Delaying the resetting of stop_soon_quietly until after symbol loading
1252 suppresses the warning. */
1254 solib_add ((char *) 0, 0, (struct target_ops
*) 0);
1255 stop_soon_quietly
= 0;
1262 sharedlibrary_command -- handle command to explicitly add library
1266 static void sharedlibrary_command (char *args, int from_tty)
1273 sharedlibrary_command (char *args
, int from_tty
)
1276 solib_add (args
, from_tty
, (struct target_ops
*) 0);
1280 _initialize_solib (void)
1282 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1283 "Load shared object library symbols for files matching REGEXP.");
1284 add_info ("sharedlibrary", info_sharedlibrary_command
,
1285 "Status of loaded shared object libraries.");
1288 (add_set_cmd ("auto-solib-add", class_support
, var_zinteger
,
1289 (char *) &auto_solib_add
,
1290 "Set autoloading of shared library symbols.\n\
1291 If nonzero, symbols from all shared object libraries will be loaded\n\
1292 automatically when the inferior begins execution or when the dynamic linker\n\
1293 informs gdb that a new library has been loaded. Otherwise, symbols\n\
1294 must be loaded manually, using `sharedlibrary'.",
1300 /* Register that we are able to handle irix5 core file formats.
1301 This really is bfd_target_unknown_flavour */
1303 static struct core_fns irix5_core_fns
=
1305 bfd_target_unknown_flavour
, /* core_flavour */
1306 default_check_format
, /* check_format */
1307 default_core_sniffer
, /* core_sniffer */
1308 fetch_core_registers
, /* core_read_registers */
1313 _initialize_core_irix5 (void)
1315 add_core_fns (&irix5_core_fns
);