Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+#include "defs.h"
+
#include <sys/types.h>
#include <signal.h>
#include <string.h>
#include <link.h>
#include <sys/param.h>
#include <fcntl.h>
-#include <stdio.h>
-#include <a.out.h>
-#include "defs.h"
+#ifndef SVR4_SHARED_LIBS
+ /* SunOS shared libs need the nlist structure. */
+#include <a.out.h>
+#endif
+
#include "symtab.h"
+#include "bfd.h"
+#include "symfile.h"
+#include "objfiles.h"
#include "gdbcore.h"
#include "command.h"
#include "target.h"
#include "regex.h"
#include "inferior.h"
-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
+/* On SVR4 systems, for the initial implementation, use some runtime startup
+ symbol 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
+#define BKPT_AT_SYMBOL 1
+
+static char *bkpt_names[] = {
+#ifdef SOLIB_BKPT_NAME
+ SOLIB_BKPT_NAME, /* Prefer configured name if it exists. */
+#endif
+ "_start",
+ "main",
+ NULL
+};
/* local data declarations */
#define LM_NAME(so) ((so) -> lm.l_name)
static struct r_debug debug_copy;
char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
-extern CORE_ADDR proc_base_address ();
-extern int proc_address_to_fd ();
#endif /* !SVR4_SHARED_LIBS */
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 objfile *objfile; /* objfile for loaded lib */
struct section_table *sections;
struct section_table *sections_end;
+ struct section_table *textsection;
+ bfd *bfd;
};
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 */
+extern int
+fdmatch PARAMS ((int, int)); /* In libiberty */
+
+/* Local function prototypes */
+
+static void
+special_symbol_handling PARAMS ((struct so_list *));
+
+static void
+sharedlibrary_command PARAMS ((char *, int));
+
+static int
+enable_break PARAMS ((void));
+
+static int
+disable_break PARAMS ((void));
+
+static void
+info_sharedlibrary_command PARAMS ((char *, int));
+
+static int
+symbol_add_stub PARAMS ((char *));
+
+static struct so_list *
+find_solib PARAMS ((struct so_list *));
+
+static struct link_map *
+first_link_map_member PARAMS ((void));
+
+static CORE_ADDR
+locate_base PARAMS ((void));
+
+static void
+solib_map_sections PARAMS ((struct so_list *));
+
+#ifdef SVR4_SHARED_LIBS
+
+static int
+look_for_base PARAMS ((int, CORE_ADDR));
+
+static CORE_ADDR
+bfd_lookup_symbol PARAMS ((bfd *, char *));
+
+#else
+
+static void
+solib_add_common_symbols PARAMS ((struct rtc_symb *, struct objfile *));
+
+#endif
/*
char *scratch_pathname;
int scratch_chan;
struct section_table *p;
+ struct cleanup *old_chain;
+ bfd *abfd;
filename = tilde_expand (so -> so_name);
- make_cleanup (free, filename);
+ old_chain = make_cleanup (free, filename);
scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
&scratch_pathname);
if (scratch_chan < 0)
{
perror_with_name (filename);
- }
+ }
+ /* Leave scratch_pathname allocated. bfd->name will point to it. */
- so -> so_bfd = bfd_fdopenr (scratch_pathname, NULL, scratch_chan);
- if (!so -> so_bfd)
+ abfd = bfd_fdopenr (scratch_pathname, NULL, scratch_chan);
+ if (!abfd)
{
+ close (scratch_chan);
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))
+ /* Leave bfd open, core_xfer_memory and "info files" need it. */
+ so -> bfd = abfd;
+ abfd -> cacheable = true;
+
+ if (!bfd_check_format (abfd, 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))
+ if (build_section_table (abfd, &so -> sections, &so -> sections_end))
{
error ("Can't find the file sections in `%s': %s",
- exec_bfd -> filename, bfd_errmsg (bfd_error));
+ bfd_get_filename (exec_bfd), bfd_errmsg (bfd_error));
}
for (p = so -> sections; p < so -> sections_end; p++)
p -> addr += (CORE_ADDR) LM_ADDR (so);
p -> endaddr += (CORE_ADDR) LM_ADDR (so);
so -> lmend = (CORE_ADDR) max (p -> endaddr, so -> lmend);
+ if (STREQ (p -> sec_ptr -> name, ".text"))
+ {
+ so -> textsection = p;
+ }
}
+
+ /* Free the file names, close the file now. */
+ do_cleanups (old_chain);
}
/* Read all dynamically loaded common symbol definitions from the inferior
- and add them to the misc_function_vector. */
+ and add them to the minimal symbol table for the shared library objfile. */
#ifndef SVR4_SHARED_LIBS
+/* This routine can be a real performance hog. According to some gprof data
+ which mtranle@paris.IntelliCorp.COM (Minh Tran-Le) sent, almost all the
+ time spend in solib_add (up to 20 minutes with 35 shared libraries) is
+ spent here, with 5/6 in lookup_minimal_symbol and 1/6 in read_memory.
+
+ Possible solutions:
+
+ * Hash the minimal symbols.
+
+ * Just record the name of the minimal symbol and lazily patch the
+ addresses.
+
+ * Tell everyone to switch to Solaris2.
+
+(1) Move the call to special_symbol_handling out of the find_solib
+loop in solib_add. This will call it once, rather than 35 times, when
+you have 35 shared libraries. It's in the loop to pass the current
+solib's objfile so the symbols are added to that objfile's minsym.
+But since the symbols are in common (BSS), it doesn't really matter
+which objfile's minsyms they are added to, I think.
+
+(2) Indeed, it might be best to create an objfile just for common minsyms,
+thus not needing any objfile argument to solib_add_common_symbols.
+
+(3) Remove the call to lookup_minimal_symbol from
+solib_add_common_symbols. If a symbol appears multiple times in the
+minsyms, we probably cope, more or less. Note that if we had an
+objfile for just minsyms, install_minimal_symbols would automatically
+remove duplicates caused by running solib_add_common_symbols several
+times.
+*/
+
static void
-solib_add_common_symbols (rtc_symp)
+solib_add_common_symbols (rtc_symp, objfile)
struct rtc_symb *rtc_symp;
+ struct objfile *objfile;
{
struct rtc_symb inferior_rtc_symb;
struct nlist inferior_rtc_nlist;
- extern void discard_misc_bunches();
+ int len;
+ char *name;
+ char *origname;
- init_misc_bunches ();
- make_cleanup (discard_misc_bunches, 0);
+ init_minimal_symbol_collection ();
+ make_cleanup (discard_minimal_symbols, 0);
while (rtc_symp)
{
- read_memory((CORE_ADDR)rtc_symp,
- &inferior_rtc_symb,
- sizeof(inferior_rtc_symb));
- read_memory((CORE_ADDR)inferior_rtc_symb.rtc_sp,
- &inferior_rtc_nlist,
- sizeof(inferior_rtc_nlist));
- if (inferior_rtc_nlist.n_type == N_COMM)
- {
- /* FIXME: The length of the symbol name is not available, but in the
- current implementation the common symbol is allocated immediately
- behind the name of the symbol. */
- int len = inferior_rtc_nlist.n_value - inferior_rtc_nlist.n_un.n_strx;
- char *name, *origname;
-
- origname = name = xmalloc (len);
- read_memory((CORE_ADDR)inferior_rtc_nlist.n_un.n_name, name, len);
-
- /* Don't enter the symbol twice if the target is re-run. */
-
-#ifdef NAMES_HAVE_UNDERSCORE
- if (*name == '_')
- name++;
-#endif
- if (lookup_misc_func (name) < 0)
- prim_record_misc_function (obsavestring (name, strlen (name)),
- inferior_rtc_nlist.n_value,
- mf_bss);
- free (origname);
- }
- rtc_symp = inferior_rtc_symb.rtc_next;
+ read_memory ((CORE_ADDR) rtc_symp,
+ (char *) &inferior_rtc_symb,
+ sizeof (inferior_rtc_symb));
+ read_memory ((CORE_ADDR) inferior_rtc_symb.rtc_sp,
+ (char *) &inferior_rtc_nlist,
+ sizeof(inferior_rtc_nlist));
+ if (inferior_rtc_nlist.n_type == N_COMM)
+ {
+ /* FIXME: The length of the symbol name is not available, but in the
+ current implementation the common symbol is allocated immediately
+ behind the name of the symbol. */
+ len = inferior_rtc_nlist.n_value - inferior_rtc_nlist.n_un.n_strx;
+
+ origname = name = xmalloc (len);
+ read_memory ((CORE_ADDR) inferior_rtc_nlist.n_un.n_name, name, len);
+
+ /* Don't enter the symbol twice if the target is re-run. */
+
+ if (name[0] == bfd_get_symbol_leading_char (objfile->obfd))
+ {
+ name++;
+ }
+
+ /* FIXME: Do we really want to exclude symbols which happen
+ to match symbols for other locations in the inferior's
+ address space, even when they are in different linkage units? */
+ if (lookup_minimal_symbol (name, (struct objfile *) NULL) == NULL)
+ {
+ name = obsavestring (name, strlen (name),
+ &objfile -> symbol_obstack);
+ prim_record_minimal_symbol (name, inferior_rtc_nlist.n_value,
+ mst_bss);
+ }
+ free (origname);
+ }
+ rtc_symp = inferior_rtc_symb.rtc_next;
}
- condense_misc_bunches (1);
+ /* Install any minimal symbols that have been collected as the current
+ minimal symbols for this objfile. */
+
+ install_minimal_symbols (objfile);
}
#endif /* SVR4_SHARED_LIBS */
+#ifdef SVR4_SHARED_LIBS
+
/*
LOCAL FUNCTION
*/
static CORE_ADDR
-DEFUN (bfd_lookup_symbol, (abfd, symname),
- bfd *abfd AND
- char *symname)
+bfd_lookup_symbol (abfd, symname)
+ bfd *abfd;
+ char *symname;
{
unsigned int storage_needed;
asymbol *sym;
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);
+ symbol_table = (asymbol **) xmalloc (storage_needed);
+ back_to = make_cleanup (free, (PTR)symbol_table);
number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
for (i = 0; i < number_of_symbols; i++)
{
sym = *symbol_table++;
- if (strcmp (sym -> name, symname) == 0)
+ if (STREQ (sym -> name, symname))
{
- symaddr = sym -> value;
+ /* Bfd symbols are section relative. */
+ symaddr = sym -> value + sym -> section -> vma;
break;
}
}
*/
static int
-DEFUN (look_for_base, (fd, baseaddr),
- int fd AND
- CORE_ADDR baseaddr)
+look_for_base (fd, baseaddr)
+ int fd;
+ CORE_ADDR baseaddr;
{
bfd *interp_bfd;
CORE_ADDR address;
return (1);
}
+#endif
+
/*
LOCAL FUNCTION
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, and all we have to do is look it up there.
+ already been added to the minimal symbol table for the executable's
+ objfile at the time the symbol file's symbols were read, and all we
+ have to do is look it up there. Note that we explicitly do NOT want
+ to find the copies in the shared library.
The SVR4 version is much more complicated because the dynamic linker
and it's structures are located in the shared C library, which gets
run as the executable's "interpreter" by the kernel. We have to go
to a lot more work to discover the address of DEBUG_BASE. Because
of this complexity, we cache the value we find and return that value
- on subsequent invocations.
+ on subsequent invocations. Note there is no copy in the executable
+ symbol tables.
Note that we can assume nothing about the process state at the time
we need to find this address. We may be stopped on the first instruc-
#ifndef SVR4_SHARED_LIBS
- int i;
+ struct minimal_symbol *msymbol;
CORE_ADDR address = 0;
- i = lookup_misc_func (DEBUG_BASE);
- if (i >= 0 && misc_function_vector[i].address != 0)
+ /* For SunOS, we want to limit the search for DEBUG_BASE to the executable
+ being debugged, since there is a duplicate named symbol in the shared
+ library. We don't want the shared library versions. */
+
+ msymbol = lookup_minimal_symbol (DEBUG_BASE, symfile_objfile);
+ if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
{
- address = misc_function_vector[i].address;
+ address = SYMBOL_VALUE_ADDRESS (msymbol);
}
return (address);
}
+/*
+
+LOCAL FUNCTION
+
+ first_link_map_member -- locate first member in dynamic linker's map
+
+SYNOPSIS
+
+ static struct link_map *first_link_map_member (void)
+
+DESCRIPTION
+
+ Read in a copy of the first member in the inferior's dynamic
+ link map from the inferior's dynamic linker structures, and return
+ a pointer to the copy in our address space.
+*/
+
static struct link_map *
first_link_map_member ()
{
#ifndef SVR4_SHARED_LIBS
- read_memory (debug_base, &dynamic_copy, sizeof (dynamic_copy));
+ read_memory (debug_base, (char *) &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,
+ read_memory ((CORE_ADDR) dynamic_copy.ld_un.ld_2, (char *) &ld_2_copy,
sizeof (struct link_dynamic_2));
lm = ld_2_copy.ld_loaded;
}
#else /* SVR4_SHARED_LIBS */
- read_memory (debug_base, &debug_copy, sizeof (struct r_debug));
+ read_memory (debug_base, (char *) &debug_copy, sizeof (struct r_debug));
+ /* FIXME: Perhaps we should validate the info somehow, perhaps by
+ checking r_version for a known version number, or r_state for
+ RT_CONSISTENT. */
lm = debug_copy.r_map;
#endif /* !SVR4_SHARED_LIBS */
/*
-GLOBAL FUNCTION
+LOCAL FUNCTION
find_solib -- step through list of shared objects
in <link.h>.
*/
-struct so_list *
+static struct so_list *
find_solib (so_list_ptr)
struct so_list *so_list_ptr; /* Last lm or NULL for first one */
{
/* 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)
+ if (debug_base != 0)
{
/* Read the base structure in and find the address of the first
link map list member. */
/* 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));
+ 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. */
so_list_head = new;
}
so_list_next = new;
- read_memory ((CORE_ADDR) lm, &(new -> lm), sizeof (struct link_map));
+ read_memory ((CORE_ADDR) lm, (char *) &(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)
{
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);
+ so -> objfile = symbol_file_add (so -> so_name, so -> from_tty,
+ (unsigned int) so -> textsection -> addr,
+ 0, 0, 0);
return (1);
}
{
if (so -> so_name[0] && re_exec (so -> so_name))
{
+ so -> from_tty = from_tty;
if (so -> symbols_loaded)
{
if (from_tty)
printf ("Symbols already loaded for %s\n", so -> so_name);
}
}
- else
+ else if (catch_errors
+ (symbol_add_stub, (char *) so,
+ "Error while reading shared library symbols:\n",
+ RETURN_MASK_ALL))
{
+ special_symbol_handling (so);
so -> symbols_loaded = 1;
- so -> from_tty = from_tty;
- catch_errors (symbol_add_stub, (char *) so,
- "Error while reading shared library symbols:\n");
}
}
}
if (so -> so_name[0])
{
count = so -> sections_end - so -> sections;
- bcopy (so -> sections, (char *)(target -> to_sections + old),
- (sizeof (struct section_table)) * count);
+ memcpy ((char *) (target -> to_sections + old),
+ so -> sections,
+ (sizeof (struct section_table)) * count);
old += count;
}
}
*/
static void
-info_sharedlibrary_command ()
+info_sharedlibrary_command (ignore, from_tty)
+ char *ignore;
+ int from_tty;
{
register struct so_list *so = NULL; /* link map state variable */
int header_done = 0;
"Shared Object Library");
header_done++;
}
- printf ("%-12s", local_hex_string_custom (LM_ADDR (so), "08"));
+ printf ("%-12s", local_hex_string_custom ((int) 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);
clear_solib()
{
struct so_list *next;
+ char *bfd_filename;
while (so_list_head)
{
if (so_list_head -> sections)
{
- free (so_list_head -> sections);
+ free ((PTR)so_list_head -> sections);
}
- if (so_list_head -> so_bfd)
+ if (so_list_head -> bfd)
{
- bfd_close (so_list_head -> so_bfd);
+ bfd_filename = bfd_get_filename (so_list_head -> bfd);
+ bfd_close (so_list_head -> bfd);
}
+ else
+ /* This happens for the executable on SVR4. */
+ bfd_filename = NULL;
+
next = so_list_head -> next;
- free(so_list_head);
+ if (bfd_filename)
+ free ((PTR)bfd_filename);
+ free ((PTR)so_list_head);
so_list_head = next;
}
debug_base = 0;
breakpoint address. Remove the breakpoint by writing the original
contents back. */
- read_memory (debug_addr, &debug_copy, sizeof (debug_copy));
-
- /* Get common symbol definitions for the loaded object. */
- if (debug_copy.ldd_cp)
- solib_add_common_symbols (debug_copy.ldd_cp);
+ read_memory (debug_addr, (char *) &debug_copy, sizeof (debug_copy));
/* Set `in_debugger' to zero now. */
- write_memory (flag_addr, &in_debugger, sizeof (in_debugger));
+ write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
breakpoint_addr = (CORE_ADDR) debug_copy.ldd_bp_addr;
- write_memory (breakpoint_addr, &debug_copy.ldd_bp_inst,
+ write_memory (breakpoint_addr, (char *) &debug_copy.ldd_bp_inst,
sizeof (debug_copy.ldd_bp_inst));
#else /* SVR4_SHARED_LIBS */
static int
enable_break ()
{
-
- int j;
+ int success = 0;
#ifndef SVR4_SHARED_LIBS
+ int j;
int in_debugger;
-
+
/* Get link_dynamic structure */
j = target_read_memory (debug_base, (char *) &dynamic_copy,
/* Write a value of 1 to this member. */
in_debugger = 1;
-
- write_memory (flag_addr, &in_debugger, sizeof (in_debugger));
+ write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
+ success = 1;
#else /* SVR4_SHARED_LIBS */
-#ifdef BKPT_AT_MAIN
+#ifdef BKPT_AT_SYMBOL
- int i;
+ struct minimal_symbol *msymbol;
+ char **bkpt_namep;
+ CORE_ADDR bkpt_addr;
- i = lookup_misc_func ("main");
- if (i >= 0 && misc_function_vector[i].address != 0)
- {
- breakpoint_addr = misc_function_vector[i].address;
- }
- else
- {
- return (0);
- }
+ /* Scan through the list of symbols, trying to look up the symbol and
+ set a breakpoint there. Terminate loop when we/if we succeed. */
- if (target_insert_breakpoint (breakpoint_addr, shadow_contents) != 0)
+ breakpoint_addr = 0;
+ for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
{
- return (0);
+ msymbol = lookup_minimal_symbol (*bkpt_namep, symfile_objfile);
+ if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
+ {
+ bkpt_addr = SYMBOL_VALUE_ADDRESS (msymbol);
+ if (target_insert_breakpoint (bkpt_addr, shadow_contents) == 0)
+ {
+ breakpoint_addr = bkpt_addr;
+ success = 1;
+ break;
+ }
+ }
}
-#else /* !BKPT_AT_MAIN */
+#else /* !BKPT_AT_SYMBOL */
struct symtab_and_line sal;
deal with hitting these breakpoints. (FIXME). */
warning ("'%s': line %d: missing SVR4 support code", __FILE__, __LINE__);
+ success = 1;
-#endif /* BKPT_AT_MAIN */
+#endif /* BKPT_AT_SYMBOL */
#endif /* !SVR4_SHARED_LIBS */
- return (1);
+ return (success);
}
/*
point, this function gets called via expansion of the macro
SOLIB_CREATE_INFERIOR_HOOK.
+ For SunOS executables, this first instruction is typically the
+ one at "_start", or a similar text label, regardless of whether
+ the executable is statically or dynamically linked. The runtime
+ startup code takes care of dynamically linking in any shared
+ libraries, once gdb allows the inferior to continue.
+
+ For SVR4 executables, this first instruction is either the first
+ instruction in the dynamic linker (for dynamically linked
+ executables) or the instruction at "start" for statically linked
+ executables. For dynamically linked executables, the system
+ first exec's /lib/libc.so.N, which contains the dynamic linker,
+ and starts it running. The dynamic linker maps in any needed
+ shared libraries, maps in the actual user executable, and then
+ jumps to "start" in the user executable.
+
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
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 we are using the BKPT_AT_SYMBOL code, then we don't need the base
+ yet. In fact, in the case of a SunOS4 executable being run on
+ Solaris, we can't get it yet. find_solib will get it when it needs
+ it. */
+#if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
if ((debug_base = locate_base ()) == 0)
{
/* Can't find the symbol or the executable is statically linked. */
return;
}
+#endif
if (!enable_break ())
{
/*
-GLOBAL FUNCTION
+LOCAL FUNCTION
+
+ special_symbol_handling -- additional shared library symbol handling
+
+SYNOPSIS
+
+ void special_symbol_handling (struct so_list *so)
+
+DESCRIPTION
+
+ Once the symbols from a shared object have been loaded in the usual
+ way, we are called to do any system specific symbol handling that
+ is needed.
+
+ For Suns, this consists of grunging around in the dynamic linkers
+ structures to find symbol definitions for "common" symbols and
+ adding them to the minimal symbol table for the corresponding
+ objfile.
+
+*/
+
+static void
+special_symbol_handling (so)
+struct so_list *so;
+{
+#ifndef SVR4_SHARED_LIBS
+ int j;
+
+ if (debug_addr == 0)
+ {
+ /* Get link_dynamic structure */
+
+ j = target_read_memory (debug_base, (char *) &dynamic_copy,
+ sizeof (dynamic_copy));
+ if (j)
+ {
+ /* unreadable */
+ return;
+ }
+
+ /* Calc address of debugger interface structure */
+ /* FIXME, this needs work for cross-debugging of core files
+ (byteorder, size, alignment, etc). */
+
+ debug_addr = (CORE_ADDR) dynamic_copy.ldd;
+ }
+
+ /* Read the debugger structure from the inferior, just to make sure
+ we have a current copy. */
+
+ j = target_read_memory (debug_addr, (char *) &debug_copy,
+ sizeof (debug_copy));
+ if (j)
+ return; /* unreadable */
+
+ /* Get common symbol definitions for the loaded object. */
+
+ if (debug_copy.ldd_cp)
+ {
+ solib_add_common_symbols (debug_copy.ldd_cp, so -> objfile);
+ }
+
+#endif /* !SVR4_SHARED_LIBS */
+}
+
+
+/*
+
+LOCAL FUNCTION
sharedlibrary_command -- handle command to explicitly add library
SYNOPSIS
- void sharedlibrary_command (char *args, int from_tty)
+ static void sharedlibrary_command (char *args, int from_tty)
DESCRIPTION
*/
-void
+static void
sharedlibrary_command (args, from_tty)
char *args;
int from_tty;
projects / deliverable / binutils-gdb.git / blobdiff