diff options
| -rw-r--r-- | gdb/ChangeLog | 59 | ||||
| -rw-r--r-- | gdb/dwarfread.c | 16 | ||||
| -rw-r--r-- | gdb/elfread.c | 83 | ||||
| -rw-r--r-- | gdb/procfs.c | 87 | ||||
| -rw-r--r-- | gdb/solib.c | 1275 | ||||
| -rwxr-xr-x | gdb/tm-svr4.h | 18 |
6 files changed, 1203 insertions, 335 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index d57bf91..3d20936 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,47 @@ +Mon Dec 16 12:31:46 1991 Fred Fish (fnf at cygnus.com) + + * solib.c: Completely reorganized (rewritten) to support + SVR4 shared libraries in a manner very close to the original + SunOS implementation. This support is expected to change and + become more general at some future time. The SVR4 version + does not yet work for attached processes, for example. + + * dwarfread.c: Arrange in dwarf_build_psymtabs() for the + relocation address to be valid whether or not symbols are + being read from a shared library or an executable. Use the + relocation address recorded in the psymtab when reading + full symbol tables (in read_ofile_symtab). Ensure that the + relocated address ranges are recorded in partial symtabs. + + * elfread.c: Add new function elf_interpreter() to return the + string from the ELF ".interp" section. This is the interpreter + that the kernel tries to run and feed the executable to. + Expand arguments to record_misc_function to include a type arg. + Modify elf_symtab_read() to supply the type arg, and to do symbol + relocations for symbols read in from shared libraries. + + * procfs.c: Add new functions proc_base_address() and + proc_address_to_fd(), used by shared library support. + + * tm-svr4.h: Add macros to support SVR4 shared libraries. + Definitions for SOLIB_ADD, SOLIB_CREATE_INFERIOR_HOOK, + CLEAR_SOLIB, and DISABLE_UNSETTABLE_BREAK. + +Fri Dec 13 20:11:26 1991 John Gilmore (gnu at cygnus.com) + + * infrun.c, remote-eb.c, remote-nindy.c, remote-vx.c: Remove + unused START_INFERIOR_HOOK. + + * remote-eb.c: Change timeout to 24 seconds (*10 fits in byte) + to account for slow loading from floppies. + (eb_create_inferior): New fn, from eb_start and + nindy_create_inferior. + (eb_close): Only use log_file if nonzero. + (eb_xfer_memory): If not writing, then read! + (eb_read_inferior_memory, eb_write_inferior_memory): Return length. + (eb_kill): A new no-op. + (eb_mourn_inferior): Remove breakpoints, then generically weep. + Fri Dec 13 16:09:23 1991 Fred Fish (fnf at cygnus.com) * breakpoint.c, findvar.c, infrun.c, putenv.c, stack.c: Fix @@ -5,6 +49,21 @@ Fri Dec 13 16:09:23 1991 Fred Fish (fnf at cygnus.com) compiler warnings about comparison of integer with pointer, when NULL is ((void *) 0) rather than just a bare 0. +Wed Dec 11 13:02:58 1991 John Gilmore (gnu at cygnus.com) + + * breakpoint.c (breakpoint_re_set_one): Disable each breakpoint + while we reset it, in case of problems. Print breakpoint number + in error messages. + + * buildsym.c (read_struct_type): Avoid sun3 compiler bug with + foo[--n]. + + * source.c (find_source_lines): If getting file mod time fails, + don't warn. + + * target.c (target_xfer_memory): If errno is set, return it, + rather than EIO. + Tue Dec 10 04:07:22 1991 K. Richard Pixley (rich at rtl.cygnus.com) * Makefile.in: infodir belongs in datadir. diff --git a/gdb/dwarfread.c b/gdb/dwarfread.c index ab5b27f..65a4c3f 100644 --- a/gdb/dwarfread.c +++ b/gdb/dwarfread.c @@ -535,6 +535,14 @@ DEFUN(dwarf_build_psymtabs, init_psymbol_list (1024); } + /* From this point on, we don't need to pass mainline around, so zap + addr to zero if we don't need relocation. */ + + if (mainline) + { + addr = 0; + } + /* Follow the compilation unit sibling chain, building a partial symbol table entry for each one. Save enough information about each compilation unit to locate the full DWARF information later. */ @@ -2356,7 +2364,6 @@ SYNOPSIS DESCRIPTION - OFFSET is a relocation offset which gets added to each symbol (FIXME). */ static struct symtab * @@ -2375,6 +2382,7 @@ DEFUN(read_ofile_symtab, (pst), dbbase = xmalloc (DBLENGTH(pst)); dbroff = DBROFF(pst); foffset = DBFOFF(pst) + dbroff; + baseaddr = pst -> addr; if (bfd_seek (abfd, foffset, 0) || (bfd_read (dbbase, DBLENGTH(pst), 1, abfd) != DBLENGTH(pst))) { @@ -2407,7 +2415,7 @@ DEFUN(read_ofile_symtab, (pst), make_cleanup (free, lnbase); } - process_dies (dbbase, dbbase + DBLENGTH(pst), pst->objfile); + process_dies (dbbase, dbbase + DBLENGTH(pst), pst -> objfile); do_cleanups (back_to); return (symtab_list); } @@ -2467,7 +2475,6 @@ DEFUN(psymtab_to_symtab_1, if (DBLENGTH(pst)) /* Otherwise it's a dummy */ { - /* Init stuff necessary for reading in symbols */ pst -> symtab = read_ofile_symtab (pst); if (info_verbose) { @@ -2958,7 +2965,8 @@ DEFUN(scan_compilation_units, culength = nextdie - thisdie; curlnoffset = di.has_at_stmt_list ? lnoffset + di.at_stmt_list : 0; pst = start_psymtab (objfile, addr, di.at_name, - di.at_low_pc, di.at_high_pc, + di.at_low_pc + addr, + di.at_high_pc + addr, dbfoff, curoff, culength, curlnoffset, global_psymbols.next, static_psymbols.next); diff --git a/gdb/elfread.c b/gdb/elfread.c index 5de3cd7..c7783e1 100644 --- a/gdb/elfread.c +++ b/gdb/elfread.c @@ -93,6 +93,32 @@ DEFUN(elf_locate_sections, (abfd, sectp, ei), } } +char * +DEFUN(elf_interpreter, (abfd), + bfd *abfd) +{ + sec_ptr interp_sec; + unsigned size; + char *interp = NULL; + + interp_sec = bfd_get_section_by_name (abfd, ".interp"); + if (interp_sec) + { + size = bfd_section_size (abfd, interp_sec); + interp = alloca (size); + if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr)0, + size)) + { + interp = savestring (interp, size - 1); + } + else + { + interp = NULL; + } + } + return (interp); +} + /* LOCAL FUNCTION @@ -117,16 +143,37 @@ NOTES */ static void -DEFUN(record_misc_function, (name, address), char *name AND CORE_ADDR address) +DEFUN(record_misc_function, (name, address, mf_type), + char *name AND CORE_ADDR address AND enum misc_function_type mf_type) { prim_record_misc_function (obsavestring (name, strlen (name)), address, - mf_unknown); + mf_type); } +/* + +LOCAL FUNCTION + + elf_symtab_read -- read the symbol table of an ELF file + +SYNOPSIS + + void elf_symtab_read (bfd *abfd, CORE_ADDR addr, int mainline) + +DESCRIPTION + + Given an open bfd, a base address to relocate symbols to, and a + flag that specifies whether or not this bfd is for an executable + or not (may be shared library for example), add all the global + function and data symbols to the miscellaneous function vector. + +*/ + static void -DEFUN (elf_symtab_read, (abfd, addr), +DEFUN (elf_symtab_read, (abfd, addr, mainline), bfd *abfd AND - CORE_ADDR addr) + CORE_ADDR addr AND + int mainline) { unsigned int storage_needed; asymbol *sym; @@ -134,6 +181,8 @@ DEFUN (elf_symtab_read, (abfd, addr), unsigned int number_of_symbols; unsigned int i; struct cleanup *back_to; + CORE_ADDR symaddr; + enum misc_function_type mf_type; storage_needed = get_symtab_upper_bound (abfd); @@ -151,7 +200,28 @@ DEFUN (elf_symtab_read, (abfd, addr), if (sym -> flags & BSF_GLOBAL && ((sym -> section != NULL) || (sym -> flags & BSF_ABSOLUTE))) { - record_misc_function ((char *) sym -> name, sym -> value); + symaddr = sym -> value; + if (!mainline) + { + /* Relocate all symbols by base address */ + symaddr += addr; + } + /* For non-absolute symbols, use the type of the section + they are relative to, to intuit text/data. Bfd provides + no way of figuring this out for absolute symbols. */ + if (sym -> section && (sym -> section -> flags & SEC_CODE)) + { + mf_type = mf_text; + } + else if (sym -> section && (sym -> section -> flags & SEC_DATA)) + { + mf_type = mf_data; + } + else + { + mf_type = mf_unknown; + } + record_misc_function ((char *) sym -> name, symaddr, mf_type); } } do_cleanups (back_to); @@ -199,7 +269,7 @@ DEFUN(elf_symfile_read, (sf, addr, mainline), /* Process the normal ELF symbol table first. */ - elf_symtab_read (abfd, addr); + elf_symtab_read (abfd, addr, mainline); /* Now process the DWARF debugging information, which is contained in special ELF sections. We first have to find them... */ @@ -208,7 +278,6 @@ DEFUN(elf_symfile_read, (sf, addr, mainline), bfd_map_over_sections (abfd, elf_locate_sections, &ei); if (ei.dboffset && ei.lnoffset) { - addr = 0; /* FIXME: force address base to zero for now */ dwarf_build_psymtabs (fileno ((FILE *)(abfd -> iostream)), bfd_get_filename (abfd), addr, mainline, diff --git a/gdb/procfs.c b/gdb/procfs.c index 95947e8..7990b10 100644 --- a/gdb/procfs.c +++ b/gdb/procfs.c @@ -451,6 +451,93 @@ DEFUN_VOID(proc_set_exec_trap) } } +/* + +GLOBAL FUNCTION + + proc_base_address -- find base address for segment containing address + +SYNOPSIS + + CORE_ADDR proc_base_address (CORE_ADDR addr) + +DESCRIPTION + + Given an address of a location in the inferior, find and return + the base address of the mapped segment containing that address. + + This is used for example, by the shared library support code, + where we have the pc value for some location in the shared library + where we are stopped, and need to know the base address of the + segment containing that address. +*/ + + +CORE_ADDR +DEFUN(proc_base_address, (addr), + CORE_ADDR addr) +{ + int nmap; + struct prmap *prmaps; + struct prmap *prmap; + CORE_ADDR baseaddr = 0; + + if (ioctl (pi.fd, PIOCNMAP, &nmap) == 0) + { + prmaps = alloca ((nmap + 1) * sizeof (*prmaps)); + if (ioctl (pi.fd, PIOCMAP, prmaps) == 0) + { + for (prmap = prmaps; prmap -> pr_size; ++prmap) + { + if ((prmap -> pr_vaddr <= (caddr_t) addr) && + (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr)) + { + baseaddr = (CORE_ADDR) prmap -> pr_vaddr; + break; + } + } + } + } + return (baseaddr); +} + +/* + +GLOBAL_FUNCTION + + proc_address_to_fd -- return open fd for file mapped to address + +SYNOPSIS + + int proc_address_to_fd (CORE_ADDR addr) + +DESCRIPTION + + Given an address in the current inferior's address space, use the + /proc interface to find an open file descriptor for the file that + this address was mapped in from. Return -1 if there is no current + inferior. Print a warning message if there is an inferior but + the address corresponds to no file (IE a bogus address). + +*/ + +int +DEFUN(proc_address_to_fd, (addr), + CORE_ADDR addr) +{ + int fd = -1; + + if (pi.valid) + { + if ((fd = ioctl (pi.fd, PIOCOPENM, (caddr_t *) &addr)) < 0) + { + print_sys_errmsg (pi.pathname, errno); + warning ("can't find mapped file for address 0x%x", addr); + } + } + return (fd); +} + #ifdef ATTACH_DETACH diff --git a/gdb/solib.c b/gdb/solib.c index 6995e50..b1c78a4 100644 --- a/gdb/solib.c +++ b/gdb/solib.c @@ -1,5 +1,6 @@ -/* Copyright (C) 1990 Free Software Foundation, Inc. - +/* Handle SunOS and SVR4 shared libraries for GDB, the GNU Debugger. + Copyright 1990, 1991 Free Software Foundation, Inc. + This file is part of GDB. This program is free software; you can redistribute it and/or modify @@ -16,17 +17,16 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -/* -** symbol definitions -*/ + #include <sys/types.h> +#include <signal.h> #include <string.h> #include <link.h> #include <sys/param.h> #include <fcntl.h> #include <stdio.h> + #include "defs.h" -#include "param.h" #include "symtab.h" #include "gdbcore.h" #include "command.h" @@ -35,183 +35,510 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "regex.h" #include "inferior.h" -extern char *getenv(); +extern char *getenv (); +extern char *elf_interpreter (); /* Interpreter name from exec file */ +extern char *re_comp (); + +#define MAX_PATH_SIZE 256 /* FIXME: Should be dynamic */ + +/* On SVR4 systems, for the initial implementation, use main() as the + "startup mapping complete" breakpoint address. The models for SunOS + and SVR4 dynamic linking debugger support are different in that SunOS + hits one breakpoint when all mapping is complete while using the SVR4 + debugger support takes two breakpoint hits for each file mapped, and + there is no way to know when the "last" one is hit. Both these + mechanisms should be tied to a "breakpoint service routine" that + gets automatically executed whenever one of the breakpoints indicating + a change in mapping is hit. This is a future enhancement. (FIXME) */ + +#define BKPT_AT_MAIN 1 + +/* local data declarations */ + +#ifdef sun + +#define DEBUG_BASE "_DYNAMIC" +#define LM_ADDR(so) ((so) -> lm.lm_addr) +#define LM_NEXT(so) ((so) -> lm.lm_next) +#define LM_NAME(so) ((so) -> lm.lm_name) +static struct link_dynamic dynamic_copy; +static struct link_dynamic_2 ld_2_copy; +static struct ld_debug debug_copy; +static CORE_ADDR debug_addr; +static CORE_ADDR flag_addr; + +#else /* !sun */ + +#define DEBUG_BASE "_r_debug" +#define LM_ADDR(so) ((so) -> lm.l_addr) +#define LM_NEXT(so) ((so) -> lm.l_next) +#define LM_NAME(so) ((so) -> lm.l_name) +static struct r_debug debug_copy; +static CORE_ADDR shlib_base; /* Base address of shared library */ +char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */ +extern CORE_ADDR proc_base_address (); +extern int proc_address_to_fd (); + +#endif /* sun */ -/* -** local data declarations -*/ -#define MAX_PATH_SIZE 256 struct so_list { - struct link_map inferior_lm; /* inferior link map */ - struct link_map *inferior_lm_add; - long ld_text; - char inferior_so_name[MAX_PATH_SIZE]; /* Shared Object Library Name */ - struct so_list *next; /* Next Structure */ - char symbols_loaded; /* Flag: loaded? */ - char from_tty; /* Flag: print msgs? */ - bfd *so_bfd; - struct section_table *sections; - struct section_table *sections_end; + struct so_list *next; /* next structure in linked list */ + struct link_map lm; /* copy of link map from inferior */ + struct link_map *lmaddr; /* addr in inferior lm was read from */ + CORE_ADDR lmend; /* upper addr bound of mapped object */ + char so_name[MAX_PATH_SIZE]; /* shared object lib name (FIXME) */ + char symbols_loaded; /* flag: symbols read in yet? */ + char from_tty; /* flag: print msgs? */ + bfd *so_bfd; /* bfd for so_name */ + struct section_table *sections; + struct section_table *sections_end; }; -static struct so_list *so_list_head = 0; +static struct so_list *so_list_head; /* List of known shared objects */ +static CORE_ADDR debug_base; /* Base of dynamic linker structures */ +static CORE_ADDR breakpoint_addr; /* Address where end bkpt is set */ + /* -** Build a section map for a shared library, record its text size in -** the so_list structure and set up the text section of the shared lib. -*/ + +LOCAL FUNCTION + + solib_map_sections -- open bfd and build sections for shared lib + +SYNOPSIS + + static void solib_map_sections (struct so_list *so) + +DESCRIPTION + + Given a pointer to one of the shared objects in our list + of mapped objects, use the recorded name to open a bfd + descriptor for the object, build a section table, and then + relocate all the section addresses by the base address at + which the shared object was mapped. + +FIXMES + + In most (all?) cases the shared object file name recorded in the + dynamic linkage tables will be a fully qualified pathname. For + cases where it isn't, do we really mimic the systems search + mechanism correctly in the below code (particularly the tilde + expansion stuff?). + */ + static void -solib_map_sections(so) -struct so_list *so; +solib_map_sections (so) + struct so_list *so; { char *filename; char *scratch_pathname; int scratch_chan; struct section_table *p; - filename = tilde_expand (so->inferior_so_name); + filename = tilde_expand (so -> so_name); make_cleanup (free, filename); scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0, - &scratch_pathname); + &scratch_pathname); if (scratch_chan < 0) - scratch_chan = openp (getenv ("LD_LIBRARY_PATH"), 1, filename, O_RDONLY, 0, - &scratch_pathname); + { + scratch_chan = openp (getenv ("LD_LIBRARY_PATH"), 1, filename, + O_RDONLY, 0, &scratch_pathname); + } if (scratch_chan < 0) - perror_with_name (filename); - - so->so_bfd = bfd_fdopenr (scratch_pathname, NULL, scratch_chan); - if (!so->so_bfd) - error ("Could not open `%s' as an executable file: %s", - scratch_pathname, bfd_errmsg (bfd_error)); - if (!bfd_check_format (so->so_bfd, bfd_object)) - error ("\"%s\": not in executable format: %s.", - scratch_pathname, bfd_errmsg (bfd_error)); - if (build_section_table (so->so_bfd, &so->sections, &so->sections_end)) - error ("Can't find the file sections in `%s': %s", - exec_bfd->filename, bfd_errmsg (bfd_error)); - - for (p = so->sections; p < so->sections_end; p++) - { - if (strcmp (bfd_section_name (so->so_bfd, p->sec_ptr), ".text") == 0) + { + perror_with_name (filename); + } + + so -> so_bfd = bfd_fdopenr (scratch_pathname, NULL, scratch_chan); + if (!so -> so_bfd) + { + error ("Could not open `%s' as an executable file: %s", + scratch_pathname, bfd_errmsg (bfd_error)); + } + if (!bfd_check_format (so -> so_bfd, bfd_object)) + { + error ("\"%s\": not in executable format: %s.", + scratch_pathname, bfd_errmsg (bfd_error)); + } + if (build_section_table (so -> so_bfd, &so -> sections, &so -> sections_end)) + { + error ("Can't find the file sections in `%s': %s", + exec_bfd -> filename, bfd_errmsg (bfd_error)); + } + + for (p = so -> sections; p < so -> sections_end; p++) + { + /* Relocate the section binding addresses as recorded in the shared + object's file by the base address to which the object was actually + mapped. */ + p -> addr += (CORE_ADDR) LM_ADDR (so); + p -> endaddr += (CORE_ADDR) LM_ADDR (so); + so -> lmend = (CORE_ADDR) max (p -> endaddr, so -> lmend); + } +} + +/* + +LOCAL FUNCTION + + bfd_lookup_symbol -- lookup the value for a specific symbol + +SYNOPSIS + + CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname) + +DESCRIPTION + + An expensive way to lookup the value of a single symbol for + bfd's that are only temporary anyway. This is used by the + shared library support to find the address of the debugger + interface structures in the shared library. + + Note that 0 is specifically allowed as an error return (no + such symbol). + + FIXME: See if there is a less "expensive" way of doing this. + Also see if there is already another bfd or gdb function + that specifically does this, and if so, use it. +*/ + +static CORE_ADDR +DEFUN (bfd_lookup_symbol, (abfd, symname), + bfd *abfd AND + char *symname) +{ + unsigned int storage_needed; + asymbol *sym; + asymbol **symbol_table; + unsigned int number_of_symbols; + unsigned int i; + struct cleanup *back_to; + CORE_ADDR symaddr = 0; + enum misc_function_type mf_type; + + storage_needed = get_symtab_upper_bound (abfd); + + if (storage_needed > 0) + { + symbol_table = (asymbol **) bfd_xmalloc (storage_needed); + back_to = make_cleanup (free, symbol_table); + number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); + + for (i = 0; i < number_of_symbols; i++) { - /* Determine length of text section and relocate it. */ - so->ld_text = p->endaddr - p->addr; - p->addr += (CORE_ADDR)so->inferior_lm.lm_addr; - p->endaddr += (CORE_ADDR)so->inferior_lm.lm_addr; + sym = *symbol_table++; + if (strcmp (sym -> name, symname) == 0) + { + symaddr = sym -> value; + break; + } } - else - /* All other sections are ignored for now. */ - p->addr = p->endaddr = 0; + do_cleanups (back_to); } + return (symaddr); } -/*=======================================================================*/ - -/* find_solib -** -**Description: -** -** This module contains the routine which finds the names of any loaded -** "images" in the current process. The argument in must be NULL on the -** first call, and then the returned value must be passed in on -** subsequent calls. This provides the capability to "step" down the -** list of loaded objects. On the last object, a NULL value is returned. -** The arg and return value are "struct link_map" pointers, as defined -** in <link.h>. -** -** NOTE: This only works under SunOS4.0. -*/ +/* + +LOCAL FUNCTION + + locate_base -- locate the base address of dynamic linker structs + +SYNOPSIS + + CORE_ADDR locate_base (void) + +DESCRIPTION + + For both the SunOS and SVR4 shared library implementations, if the + inferior executable has been linked dynamically, there is a single + address somewhere in the inferior's data space which is the key to + locating all of the dynamic linker's runtime structures, and this + address is the value of the symbol defined by the macro DEBUG_BASE. + The job of this function is to find and return that address, or to + return 0 if there is no such address (the executable is statically + linked for example). + + For SunOS, the job is almost trivial, since the dynamic linker and + all of it's structures are statically linked to the executable at + link time. Thus the symbol for the address we are looking for has + already been added to the misc function vector at the time the symbol + file's symbols were read. + + The SVR4 version is much more complicated because the dynamic linker + and it's structures are located in the shared library itself, which + gets run as the executable's "interpreter" by the kernel. Because + of this complexity, we cache the value we find and return that value + on subsequent invocations, if it is non-zero. + + First we must decide if we are stopped at the entry point of the + shared C library, which is set to be the entry point of the dynamic + linker code (the function _rt_boot() to be precise), or at the entry + point given in the inferior's exec file (for statically linked + executables). + + If we are not stopped at the inferior's exec file entry point then + we are either stopped at the interpreter's entry point or somewhere + else (I.E. totally lost). Use the /proc interface to get an open + file descriptor on the file that is mapped at the current stop_pc + value and try to open a bfd for it. + +FIXME + + The SVR4 strategy does NOT work when gdb is attaching to an existing + process because the stop_pc is not in the library code, so we can't + use the /proc interface to get an open fd for the library. So we + need to rethink the method for finding the debugger interface struct. + + For SunOS we could look around in the executable code to find + DEBUG_BASE, if it isn't in the symbol table. It's not that hard to + find. Then we can debug stripped executables using shared library + symbols. + + */ + +static CORE_ADDR +locate_base () +{ + CORE_ADDR address; + +#ifdef sun + + int i; + + i = lookup_misc_func (DEBUG_BASE); + if (i >= 0 && misc_function_vector[i].address != 0) + { + address = misc_function_vector[i].address; + } + +#else /* !sun */ + + int stop_pc_fd; /* File descriptor for mapped file */ + int interp_fd; /* File descriptor for interpreter */ + char *interp_name; /* Name of interpreter */ + char *full_interp_name; /* Full pathname of interpreter */ + bfd *interp_bfd; + CORE_ADDR interp_base; + + if (debug_base > 0) + { + /* We have a currently valid address, so avoid doing all the work + again. */ + return (debug_base); + } + if (bfd_get_start_address (exec_bfd) == stop_pc) + { + /* We are stopped at the entry point to the exec file, so there + are no shared libs to deal with. */ + return (0); + } + if ((stop_pc_fd = proc_address_to_fd (stop_pc)) < 0) + { + /* We are stopped at an address for which we can't seem to get an open + file descriptor from the /proc interface. We should already have + printed a suitable warning message. */ + return (0); + } + if ((interp_name = elf_interpreter (exec_bfd)) == NULL) + { + /* There is no interpreter specified in the exec file, thus this is + not a normal dynamically linked file. */ + return (0); + } + if ((interp_fd = openp (getenv ("PATH"), 1, interp_name, O_RDONLY, 0, + &full_interp_name)) < 0) + { + /* We can't find and open the interpreter. This is a problem. */ + return (0); + } + if (!fdmatch (stop_pc_fd, interp_fd)) + { + /* The file for the mapped region is not the interpreter, something + is strange... */ + close (stop_pc_fd); + close (interp_fd); + free (full_interp_name); + return (0); + } + interp_bfd = bfd_fdopenr (full_interp_name, NULL, interp_fd); + if (!interp_bfd) + { + warning ("Could not open `%s' as an executable file: %s", + full_interp_name, bfd_errmsg (bfd_error)); + return (0); + } + if (!bfd_check_format (interp_bfd, bfd_object)) + { + warning ("\"%s\": not in executable format: %s.", + full_interp_name, bfd_errmsg (bfd_error)); + return (0); + } + + /* Lookup the unrelocated value of the symbol that defines the location + of the debugger interface structure for the dynamic linker in the shared + library. Then find the base address of the text segment in the + inferior's mapped in dynamic library, which gives the relocation to + apply to find the actual mapped address of the debugger interface + structure. */ + + if ((address = bfd_lookup_symbol (interp_bfd, DEBUG_BASE)) == 0) + { + warning ("can't find symbol %s in shared library", DEBUG_BASE); + return (0); + } + if ((interp_base = proc_base_address (stop_pc)) == 0) + { + warning ("can't find base address for shared library text segment"); + return (0); + } + shlib_base = interp_base; + address += interp_base; + + if ((interp_base + bfd_get_start_address (interp_bfd)) != stop_pc) + { + /* We are not stopped at the entry point to the dynamic linker, + so grumble and skip startup shared library processing. */ + warning ("not stopped at entry point of dynamic linker"); + warning ("shared library processing suppressed"); + return (0); + } + + bfd_close (interp_bfd); + +#endif /* sun */ + + return (address); + +} -struct so_list *find_solib(so_list_ptr) -struct so_list *so_list_ptr; /* so_list_head position ptr */ +static struct link_map * +first_link_map_member () { -struct so_list *so_list_next = 0; -struct link_map *inferior_lm = 0; -struct link_dynamic inferior_dynamic_cpy; -struct link_dynamic_2 inferior_ld_2_cpy; -struct so_list *new; -int i; - - if (!so_list_ptr) { - if (!(so_list_next = so_list_head)) { - i = lookup_misc_func ("_DYNAMIC"); - if (i >= 0) { - read_memory(misc_function_vector[i].address, - &inferior_dynamic_cpy, - sizeof(struct link_dynamic)); - if (inferior_dynamic_cpy.ld_version == 3) { - read_memory((CORE_ADDR)inferior_dynamic_cpy.ld_un.ld_2, - &inferior_ld_2_cpy, - sizeof(struct link_dynamic_2)); - inferior_lm = inferior_ld_2_cpy.ld_loaded; - } - } - } - } else { - /* - ** Advance to next local abbreviated load_map structure - */ - if (!(inferior_lm = so_list_ptr->inferior_lm.lm_next)) { - /* See if any were added, but be quiet if we can't read - from the target any more. */ - int status; - - status = target_read_memory ( - (CORE_ADDR)so_list_ptr->inferior_lm_add, - (char *)&so_list_ptr->inferior_lm, - sizeof(struct link_map)); - if (status == 0) - inferior_lm = so_list_ptr->inferior_lm.lm_next; - else - inferior_lm = 0; - } - so_list_next = so_list_ptr->next; - } - if ((!so_list_next) && inferior_lm) { - /* - ** Get Next LM Structure from inferior image and build - ** an local abbreviated load_map structure - */ - new = (struct so_list *) xmalloc(sizeof(struct so_list)); - new->inferior_lm_add = inferior_lm; - read_memory((CORE_ADDR)inferior_lm, - &new->inferior_lm, - sizeof(struct link_map)); - - read_memory((CORE_ADDR)new->inferior_lm.lm_name, - new->inferior_so_name, - MAX_PATH_SIZE - 1); - new->inferior_so_name[MAX_PATH_SIZE - 1] = 0; - /* Zero everything after the first terminating null */ - strncpy(new->inferior_so_name, new->inferior_so_name, MAX_PATH_SIZE); - -#if 0 - /* This doesn't work for core files, so instead get ld_text - using solib_map_sections (below). */ - read_memory((CORE_ADDR)new->inferior_lm.lm_ld, - &inferior_dynamic_cpy, - sizeof(struct link_dynamic)); - read_memory((CORE_ADDR)inferior_dynamic_cpy.ld_un.ld_2, - &inferior_ld_2_cpy, - sizeof(struct link_dynamic_2)); - new->ld_text = inferior_ld_2_cpy.ld_text; + struct link_map *lm = NULL; + +#ifdef sun + + read_memory (debug_base, &dynamic_copy, sizeof (dynamic_copy)); + if (dynamic_copy.ld_version >= 2) + { + /* It is a version that we can deal with, so read in the secondary + structure and find the address of the link map list from it. */ + read_memory ((CORE_ADDR) dynamic_copy.ld_un.ld_2, &ld_2_copy, + sizeof (struct link_dynamic_2)); + lm = ld_2_copy.ld_loaded; + } + +#else + + read_memory (debug_base, &debug_copy, sizeof (struct r_debug)); + lm = debug_copy.r_map; + #endif - new->next = 0; - new->symbols_loaded = 0; - new->so_bfd = NULL; - new->sections = NULL; - if (so_list_ptr) - so_list_ptr->next = new; - else - so_list_head = new; + return (lm); +} + +/* + +GLOBAL FUNCTION + + find_solib -- step through list of shared objects + +SYNOPSIS + + struct so_list *find_solib (struct so_list *so_list_ptr) + +DESCRIPTION + + This module contains the routine which finds the names of any + loaded "images" in the current process. The argument in must be + NULL on the first call, and then the returned value must be passed + in on subsequent calls. This provides the capability to "step" down + the list of loaded objects. On the last object, a NULL value is + returned. - solib_map_sections (new); + The arg and return value are "struct link_map" pointers, as defined + in <link.h>. + */ - so_list_next = new; - } - return(so_list_next); +struct so_list * +find_solib (so_list_ptr) + struct so_list *so_list_ptr; /* Last lm or NULL for first one */ +{ + struct so_list *so_list_next = NULL; + struct link_map *lm = NULL; + struct so_list *new; + + if (so_list_ptr == NULL) + { + /* We are setting up for a new scan through the loaded images. */ + if ((so_list_next = so_list_head) == NULL) + { + /* We have not already read in the dynamic linking structures + from the inferior, lookup the address of the base structure. */ + debug_base = locate_base (); + if (debug_base > 0) + { + /* Read the base structure in and find the address of the first + link map list member. */ + lm = first_link_map_member (); + } + } + } + else + { + /* We have been called before, and are in the process of walking + the shared library list. Advance to the next shared object. */ + if ((lm = LM_NEXT (so_list_ptr)) == NULL) + { + /* We have hit the end of the list, so check to see if any were + added, but be quiet if we can't read from the target any more. */ + int status = target_read_memory ((CORE_ADDR) so_list_ptr -> lmaddr, + (char *) &(so_list_ptr -> lm), + sizeof (struct link_map)); + if (status == 0) + { + lm = LM_NEXT (so_list_ptr); + } + else + { + lm = NULL; + } + } + so_list_next = so_list_ptr -> next; + } + if ((so_list_next == NULL) && (lm != NULL)) + { + /* Get next link map structure from inferior image and build a local + abbreviated load_map structure */ + new = (struct so_list *) xmalloc (sizeof (struct so_list)); + (void) memset ((char *) new, 0, sizeof (struct so_list)); + new -> lmaddr = lm; + /* Add the new node as the next node in the list, or as the root + node if this is the first one. */ + if (so_list_ptr != NULL) + { + so_list_ptr -> next = new; + } + else + { + so_list_head = new; + } + so_list_next = new; + read_memory ((CORE_ADDR) lm, &(new -> lm), sizeof (struct link_map)); + /* For the SVR4 version, there is one entry that has no name + (for the inferior executable) since it is not a shared object. */ + if (LM_NAME (new) != 0) + { + read_memory((CORE_ADDR) LM_NAME (new), new -> so_name, + MAX_PATH_SIZE - 1); + new -> so_name[MAX_PATH_SIZE - 1] = 0; + solib_map_sections (new); + } + } + return (so_list_next); } /* A small stub to get us past the arg-passing pinhole of catch_errors. */ @@ -220,15 +547,27 @@ static int symbol_add_stub (arg) char *arg; { - register struct so_list *so = (struct so_list *)arg; /* catch_errs bogon */ - - symbol_file_add (so->inferior_so_name, so->from_tty, - (unsigned int)so->inferior_lm.lm_addr, 0); - return 1; + register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */ + + symbol_file_add (so -> so_name, so -> from_tty, + (unsigned int) LM_ADDR (so), 0); + return (1); } -/* The real work of adding a shared library file to the symtab and - the section list. */ +/* + +GLOBAL FUNCTION + + solib_add -- add a shared library file to the symtab and section list + +SYNOPSIS + + void solib_add (char *arg_string, int from_tty, + struct target_ops *target) + +DESCRIPTION + +*/ void solib_add (arg_string, from_tty, target) @@ -236,226 +575,516 @@ solib_add (arg_string, from_tty, target) int from_tty; struct target_ops *target; { - register struct so_list *so = 0; /* link map state variable */ - char *val; - int count, old; - struct section_table *sec; - - if (arg_string == 0) - re_comp ("."); - else if (val = (char *) re_comp (arg_string)) { - error ("Invalid regexp: %s", val); - } - + register struct so_list *so = NULL; /* link map state variable */ + char *re_err; + int count; + int old; + + if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL) + { + error ("Invalid regexp: %s", re_err); + } + /* Getting new symbols may change our opinion about what is frameless. */ reinit_frame_cache (); - - if (from_tty) { - printf_filtered ("Shared libraries"); - if (arg_string) - printf_filtered (" matching regular expresion \"%s\"", arg_string); - printf_filtered (":\n"); - } - dont_repeat(); - - while (so = find_solib(so)) { - if (re_exec(so->inferior_so_name)) { - if (so->symbols_loaded) { + while ((so = find_solib (so)) != NULL) + { + if (so -> so_name[0] && re_exec (so -> so_name)) + { + if (so -> symbols_loaded) + { if (from_tty) - printf("Symbols already loaded for %s\n", so->inferior_so_name); - } else { - so->symbols_loaded = 1; - so->from_tty = from_tty; - catch_errors (symbol_add_stub, (char *)so, - "Error while reading shared library symbols:\n"); - } - } - } - + { + printf ("Symbols already loaded for %s\n", so -> so_name); + } + } + else + { + so -> symbols_loaded = 1; + so -> from_tty = from_tty; + catch_errors (symbol_add_stub, (char *) so, + "Error while reading shared library symbols:\n"); + } + } + } + /* Now add the shared library sections to the section table of the specified target, if any. */ - if (target) { - /* Count how many new section_table entries there are. */ - so = 0; - count = 0; - while (0 != (so = find_solib (so))) { - count += so->sections_end - so->sections; - } - - if (count) { - /* Reallocate the target's section table including the new size. */ - if (target->sections) { - old = target->sections_end - target->sections; - target->sections = (struct section_table *) - realloc ((char *)target->sections, - (sizeof (struct section_table)) * (count + old)); - } else { - old = 0; - target->sections = (struct section_table *) - malloc ((sizeof (struct section_table)) * count); - } - target->sections_end = target->sections + (count + old); - - /* Add these section table entries to the target's table. */ - while (0 != (so = find_solib (so))) { - count = so->sections_end - so->sections; - bcopy (so->sections, (char *)(target->sections + old), - (sizeof (struct section_table)) * count); - old += count; - } - } - } + if (target) + { + /* Count how many new section_table entries there are. */ + so = NULL; + count = 0; + while ((so = find_solib (so)) != NULL) + { + if (so -> so_name[0]) + { + count += so -> sections_end - so -> sections; + } + } + + if (count) + { + /* Reallocate the target's section table including the new size. */ + if (target -> sections) + { + old = target -> sections_end - target -> sections; + target -> sections = (struct section_table *) + realloc ((char *)target -> sections, + (sizeof (struct section_table)) * (count + old)); + } + else + { + old = 0; + target -> sections = (struct section_table *) + malloc ((sizeof (struct section_table)) * count); + } + target -> sections_end = target -> sections + (count + old); + + /* Add these section table entries to the target's table. */ + while ((so = find_solib (so)) != NULL) + { + if (so -> so_name[0]) + { + count = so -> sections_end - so -> sections; + bcopy (so -> sections, (char *)(target -> sections + old), + (sizeof (struct section_table)) * count); + old += count; + } + } + } + } } -/*=======================================================================*/ +/* -static void solib_info() -{ -register struct so_list *so = 0; /* link map state variable */ +LOCAL FUNCTION + + info_sharedlibrary_command -- code for "info sharedlibrary" + +SYNOPSIS + + static void info_sharedlibrary_command () + +DESCRIPTION - while (so = find_solib(so)) { - if (so == so_list_head) { - printf(" Address Range Syms Read Shared Object Library\n"); + Walk through the shared library list and print information + about each attached library. +*/ + +static void +info_sharedlibrary_command () +{ + register struct so_list *so = NULL; /* link map state variable */ + int header_done = 0; + + if (exec_bfd == NULL) + { + printf ("No exec file.\n"); + return; + } + while ((so = find_solib (so)) != NULL) + { + if (so -> so_name[0]) + { + if (!header_done) + { + printf("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read", + "Shared Object Library"); + header_done++; + } + printf ("%-12s", local_hex_string_custom (LM_ADDR (so), "08")); + printf ("%-12s", local_hex_string_custom (so -> lmend, "08")); + printf ("%-12s", so -> symbols_loaded ? "Yes" : "No"); + printf ("%s\n", so -> so_name); } - printf(" 0x%08x - 0x%08x %s %s\n", - so->inferior_lm.lm_addr, - so->inferior_lm.lm_addr + so->ld_text - 1, - (so->symbols_loaded ? "Yes" : "No "), - so->inferior_so_name); } - if (!so_list_head) { - printf("No shared libraries loaded at this time.\n"); + if (so_list_head == NULL) + { + printf ("No shared libraries loaded at this time.\n"); } } /* -** Called by Insert Breakpoint to see if Address is Shared Library Address -*/ + +GLOBAL FUNCTION + + solib_address -- check to see if an address is in a shared lib + +SYNOPSIS + + int solib_address (CORE_ADDR address) + +DESCRIPTION + + Provides a hook for other gdb routines to discover whether or + not a particular address is within the mapped address space of + a shared library. Any address between the base mapping address + and the first address beyond the end of the last mapping, is + considered to be within the shared library address space, for + our purposes. + + For example, this routine is called at one point to disable + breakpoints which are in shared libraries that are not currently + mapped in. + */ + int -solib_address(address) +solib_address (address) CORE_ADDR address; { -register struct so_list *so = 0; /* link map state variable */ + register struct so_list *so = 0; /* link map state variable */ + + while ((so = find_solib (so)) != NULL) + { + if (so -> so_name[0]) + { + if ((address >= (CORE_ADDR) LM_ADDR (so)) && + (address < (CORE_ADDR) so -> lmend)) + { + return (1); + } + } + } + return (0); +} + +/* Called by free_all_symtabs */ - while (so = find_solib(so)) { - if ((address >= (CORE_ADDR) so->inferior_lm.lm_addr) && - (address < (CORE_ADDR) so->inferior_lm.lm_addr + so->ld_text)) - return 1; +void +clear_solib() +{ + struct so_list *next; + + while (so_list_head) + { + if (so_list_head -> sections) + { + free (so_list_head -> sections); + } + if (so_list_head -> so_bfd) + { + bfd_close (so_list_head -> so_bfd); + } + next = so_list_head -> next; + free(so_list_head); + so_list_head = next; } - return 0; + debug_base = 0; } /* -** Called by free_all_symtabs + +LOCAL FUNCTION + + disable_break -- remove the "mapping changed" breakpoint + +SYNOPSIS + + static int disable_break () + +DESCRIPTION + + Removes the breakpoint that gets hit when the dynamic linker + completes a mapping change. + */ -void -clear_solib() + +static int +disable_break () { -struct so_list *next; - - while (so_list_head) { - if (so_list_head->sections) - free (so_list_head->sections); - if (so_list_head->so_bfd) - bfd_close (so_list_head->so_bfd); - next = so_list_head->next; - free(so_list_head); - so_list_head = next; - } + int status = 1; + +#ifdef sun + + /* FIXME: maybe we should add the common symbols from the ldd_cp chain + to the misc_function_vector ? */ + + int in_debugger = 0; + + /* Set `in_debugger' to zero now. */ + + write_memory (flag_addr, &in_debugger, sizeof (in_debugger)); + + /* Read the debugger structure from the inferior to retrieve the + address of the breakpoint and the original contents of the + breakpoint address. Remove the breakpoint by writing the original + contents back. */ + + read_memory (debug_addr, &debug_copy, sizeof (debug_copy)); + breakpoint_addr = (CORE_ADDR) debug_copy.ldd_bp_addr; + write_memory (breakpoint_addr, &debug_copy.ldd_bp_inst, + sizeof (debug_copy.ldd_bp_inst)); + +#else /* !sun */ + + /* Note that breakpoint address and original contents are in our address + space, so we just need to write the original contents back. */ + + if (memory_remove_breakpoint (breakpoint_addr, shadow_contents) != 0) + { + status = 0; + } + +#endif /* sun */ + + /* For the SVR4 version, we always know the breakpoint address. For the + SunOS version we don't know it until the above code is executed. + Grumble if we are stopped anywhere besides the breakpoint address. */ + + if (stop_pc != breakpoint_addr) + { + warning ("stopped at unknown breakpoint while handling shared libraries"); + } + + return (status); } -/* Called by child_create_inferior when the inferior is stopped at its - first instruction. */ +/* -void -solib_create_inferior_hook() +LOCAL FUNCTION + + enable_break -- arrange for dynamic linker to hit breakpoint + +SYNOPSIS + + int enable_break (void) + +DESCRIPTION + + Both the SunOS and the SVR4 dynamic linkers have, as part of their + debugger interface, support for arranging for the inferior to hit + a breakpoint after mapping in the shared libraries. This function + enables that breakpoint. + + For SunOS, there is a special flag location (in_debugger) which we + set to 1. When the dynamic linker sees this flag set, it will set + a breakpoint at a location known only to itself, after saving the + original contents of that place and the breakpoint address itself, + in it's own internal structures. When we resume the inferior, it + will eventually take a SIGTRAP when it runs into the breakpoint. + We handle this (in a different place) by restoring the contents of + the breakpointed location (which is only known after it stops), + chasing around to locate the shared libraries that have been + loaded, then resuming. + + For SVR4, the debugger interface structure contains a member (r_brk) + which is statically initialized at the time the shared library is + built, to the offset of a function (_r_debug_state) which is guaran- + teed to be called once before mapping in a library, and again when + the mapping is complete. At the time we are examining this member, + it contains only the unrelocated offset of the function, so we have + to do our own relocation. Later, when the dynamic linker actually + runs, it relocates r_brk to be the actual address of _r_debug_state(). + + The debugger interface structure also contains an enumeration which + is set to either RT_ADD or RT_DELETE prior to changing the mapping, + depending upon whether or not the library is being mapped or unmapped, + and then set to RT_CONSISTENT after the library is mapped/unmapped. +*/ + +static int +enable_break () { - struct link_dynamic inferior_dynamic_cpy; - CORE_ADDR inferior_debug_addr; - struct ld_debug inferior_debug_cpy; - int in_debugger; - CORE_ADDR in_debugger_addr; - CORE_ADDR breakpoint_addr; - int i, j; - /* FIXME: We should look around in the executable code to find _DYNAMIC, - if it isn't in the symbol table. It's not that hard to find... - Then we can debug stripped executables using shared library symbols. */ - i = lookup_misc_func ("_DYNAMIC"); - if (i < 0) /* Can't find shared lib ptr. */ - return; - if (misc_function_vector[i].address == 0) /* statically linked program */ - return; + int j; + +#ifdef sun + int in_debugger; + /* Get link_dynamic structure */ - j = target_read_memory(misc_function_vector[i].address, - &inferior_dynamic_cpy, - sizeof(struct link_dynamic)); - if (j) /* unreadable */ - return; + + j = target_read_memory (debug_base, (char *) &dynamic_copy, + sizeof (dynamic_copy)); + if (j) + { + /* unreadable */ + return (0); + } /* Calc address of debugger interface structure */ - inferior_debug_addr = (CORE_ADDR)inferior_dynamic_cpy.ldd; + + debug_addr = (CORE_ADDR) dynamic_copy.ldd; + /* Calc address of `in_debugger' member of debugger interface structure */ - in_debugger_addr = inferior_debug_addr + (CORE_ADDR)((char *)&inferior_debug_cpy.ldd_in_debugger - (char *)&inferior_debug_cpy); + + flag_addr = debug_addr + (CORE_ADDR) ((char *) &debug_copy.ldd_in_debugger - + (char *) &debug_copy); + /* Write a value of 1 to this member. */ + in_debugger = 1; - write_memory(in_debugger_addr, &in_debugger, sizeof(in_debugger)); - /* Now run the target. Seeing `in_debugger' set, it will set a - breakpoint at some convenient place, remember the original contents - of that place, and eventually take a SIGTRAP when it runs into the - breakpoint. We handle this by restoring the contents of the - breakpointed location (which is only known after it stops), - chasing around to locate the shared libraries that have been - loaded, then resuming. */ + write_memory (flag_addr, &in_debugger, sizeof (in_debugger)); + +#else /* !sun */ + +#ifdef BKPT_AT_MAIN + + int i; + + i = lookup_misc_func ("main"); + if (i >= 0 && misc_function_vector[i].address != 0) + { + breakpoint_addr = misc_function_vector[i].address; + } + else + { + return (0); + } + + if (target_insert_breakpoint (breakpoint_addr, shadow_contents) != 0) + { + return (0); + } + +#else /* !BKPT_AT_MAIN */ + + struct symtab_and_line sal; + + /* Read the debugger interface structure directly. */ + + read_memory (debug_base, (char *) &debug_copy, sizeof (debug_copy)); + + /* Set breakpoint at the debugger interface stub routine that will + be called just prior to each mapping change and again after the + mapping change is complete. Set up the (nonexistent) handler to + deal with hitting these breakpoints. (FIXME). */ + + warning ("'%s': line %d: missing SVR4 support code", __FILE__, __LINE__); + +#endif /* BKPT_AT_MAIN */ + +#endif /* sun */ + + return (1); +} + +/* + +GLOBAL FUNCTION + + solib_create_inferior_hook -- shared library startup support + +SYNOPSIS + + void solib_create_inferior_hook() + +DESCRIPTION + + When gdb starts up the inferior, it nurses it along (through the + shell) until it is ready to execute it's first instruction. At this + point, this function gets called via expansion of the macro + SOLIB_CREATE_INFERIOR_HOOK. + + For both SunOS shared libraries, and SVR4 shared libraries, we + can arrange to cooperate with the dynamic linker to discover the + names of shared libraries that are dynamically linked, and the + base addresses to which they are linked. + + This function is responsible for discovering those names and + addresses, and saving sufficient information about them to allow + their symbols to be read at a later time. + +FIXME + + Between enable_break() and disable_break(), this code does not + properly handle hitting breakpoints which the user might have + set in the startup code or in the dynamic linker itself. Proper + handling will probably have to wait until the implementation is + changed to use the "breakpoint handler function" method. + + Also, what if child has exit()ed? Must exit loop somehow. + */ + +void +solib_create_inferior_hook() +{ + CORE_ADDR debug_addr; + int in_debugger; + CORE_ADDR in_debugger_addr; + CORE_ADDR breakpoint_addr; + int i, j; + + if ((debug_base = locate_base ()) == 0) + { + /* Can't find the symbol or the executable is statically linked. */ + return; + } + + if (!enable_break ()) + { + warning ("shared library handler failed to enable breakpoint"); + return; + } + + /* Now run the target. It will eventually hit the breakpoint, at + which point all of the libraries will have been mapped in and we + can go groveling around in the dynamic linker structures to find + out what we need to know about them. */ clear_proceed_status (); stop_soon_quietly = 1; - target_resume (0, 0); - wait_for_inferior (); - while (stop_signal != SIGTRAP) + stop_signal = 0; + do { - /* FIXME, what if child has exit()ed? Must exit loop somehow */ target_resume (0, stop_signal); wait_for_inferior (); } + while (stop_signal != SIGTRAP); stop_soon_quietly = 0; + + /* We are now either at the "mapping complete" breakpoint (or somewhere + else, a condition we aren't prepared to deal with anyway), so adjust + the PC as necessary after a breakpoint, disable the breakpoint, and + add any shared libraries that were mapped in. */ - /* Set `in_debugger' to zero now. WHY, is this needed? */ - in_debugger = 0; - write_memory(in_debugger_addr, &in_debugger, sizeof(in_debugger)); - read_memory(inferior_debug_addr, &inferior_debug_cpy, sizeof(inferior_debug_cpy)); - /* FIXME: maybe we should add the common symbols from the ldd_cp chain - * to the misc_function_vector ? - */ - breakpoint_addr = (CORE_ADDR)inferior_debug_cpy.ldd_bp_addr; - if (stop_pc - DECR_PC_AFTER_BREAK == breakpoint_addr) - { - write_memory(breakpoint_addr, &inferior_debug_cpy.ldd_bp_inst, sizeof(inferior_debug_cpy.ldd_bp_inst)); - if (DECR_PC_AFTER_BREAK) - { - stop_pc -= DECR_PC_AFTER_BREAK; - write_register (PC_REGNUM, stop_pc); - } - } - solib_add ((char *)0, 0, (struct target_ops *)0); + if (DECR_PC_AFTER_BREAK) + { + stop_pc -= DECR_PC_AFTER_BREAK; + write_register (PC_REGNUM, stop_pc); + } + + if (!disable_break ()) + { + warning ("shared library handler failed to disable breakpoint"); + } + + solib_add ((char *) 0, 0, (struct target_ops *) 0); } +/* + +GLOBAL FUNCTION + + sharedlibrary_command -- handle command to explicitly add library + +SYNOPSIS + + void sharedlibrary_command (char *args, int from_tty) + +DESCRIPTION + +*/ + void sharedlibrary_command (args, from_tty) +char *args; +int from_tty; { - solib_add (args, from_tty, (struct target_ops *)0); + dont_repeat (); + solib_add (args, from_tty, (struct target_ops *) 0); } void _initialize_solib() { - - add_com("sharedlibrary", class_files, sharedlibrary_command, + + add_com ("sharedlibrary", class_files, sharedlibrary_command, "Load shared object library symbols for files matching REGEXP."); - add_info("sharedlibrary", solib_info, - "Status of loaded shared object libraries"); + add_info ("sharedlibrary", info_sharedlibrary_command, + "Status of loaded shared object libraries."); } diff --git a/gdb/tm-svr4.h b/gdb/tm-svr4.h index ed14214..f1eea20 100755 --- a/gdb/tm-svr4.h +++ b/gdb/tm-svr4.h @@ -18,4 +18,20 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -/* Currently empty */ +/* Support for SVR4 shared libraries. */ + +#define CLEAR_SOLIB clear_solib +extern void clear_solib (); /* solib.c */ + +#define SOLIB_ADD(filename, from_tty, targ) solib_add (filename, from_tty, targ) +extern void solib_add (); /* solib.c */ + +#define SOLIB_CREATE_INFERIOR_HOOK solib_create_inferior_hook +extern void solib_create_inferior_hook(); /* solib.c */ + +/* If we can't set a breakpoint, and it's in a shared library, just + disable it. */ + +#define DISABLE_UNSETTABLE_BREAK(addr) solib_address(addr) +extern int solib_address (); /* solib.c */ + |