#include "frame.h"
#include "regex.h"
#include "inferior.h"
+#include "language.h"
#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
+
+#if defined (BKPT_AT_SYMBOL) && defined (SVR4_SHARED_LIBS)
+static char *bkpt_names[] = {
+#ifdef SOLIB_BKPT_NAME
+ SOLIB_BKPT_NAME, /* Prefer configured name if it exists. */
+#endif
+ "_start",
+ "main",
+ NULL
+};
+#endif
/* local data declarations */
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 *abfd;
};
static struct so_list *so_list_head; /* List of known shared objects */
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. abfd->name will point to it. */
- so -> so_bfd = bfd_fdopenr (scratch_pathname, NULL, scratch_chan);
- if (!so -> so_bfd)
+ abfd = bfd_fdopenr (scratch_pathname, gnutarget, 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 -> abfd = 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 (strcmp (p -> sec_ptr -> name, ".text") == 0)
+ 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
#ifndef SVR4_SHARED_LIBS
+/* In GDB 4.9 this routine was 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) was spent here, with 5/6 in
+ lookup_minimal_symbol and 1/6 in read_memory.
+
+ To fix this, we moved the call to special_symbol_handling out of the
+ loop in solib_add, so this only gets called once, rather than once
+ for every shared library, and also removed the call to lookup_minimal_symbol
+ in this routine. */
+
static void
solib_add_common_symbols (rtc_symp, objfile)
struct rtc_symb *rtc_symp;
/* Don't enter the symbol twice if the target is re-run. */
-#ifdef NAMES_HAVE_UNDERSCORE
- if (*name == '_')
+ if (name[0] == bfd_get_symbol_leading_char (objfile->obfd))
{
name++;
}
-#endif
+
+#if 0
+ /* I think this is unnecessary, GDB can probably deal with
+ duplicate minimal symbols, more or less. And the duplication
+ which used to happen because this was called for each shared
+ library is gone now that we are just called once. */
/* 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)
+#endif
{
name = obsavestring (name, strlen (name),
&objfile -> symbol_obstack);
prim_record_minimal_symbol (name, inferior_rtc_nlist.n_value,
- mst_bss);
+ mst_bss, objfile);
}
free (origname);
}
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;
}
}
mapped memory segment, so skip it. Also, if the fd corresponds
to the exec file, skip it as well. */
- if ((fd == -1) || fdmatch (fileno ((FILE *)(exec_bfd -> iostream)), fd))
+ if ((fd == -1) || fdmatch (fileno ((GDB_FILE *)(exec_bfd -> iostream)), fd))
{
return (0);
}
we have no way currently to find the filename. Don't gripe about
any problems we might have, just fail. */
- if ((interp_bfd = bfd_fdopenr ("unnamed", NULL, fd)) == NULL)
+ if ((interp_bfd = bfd_fdopenr ("unnamed", gnutarget, fd)) == NULL)
{
return (0);
}
library. We don't want the shared library versions. */
msymbol = lookup_minimal_symbol (DEBUG_BASE, symfile_objfile);
- if ((msymbol != NULL) && (msymbol -> address != 0))
+ if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
{
- address = msymbol -> 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 ()
{
#else /* SVR4_SHARED_LIBS */
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 */
/* 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. */
struct target_ops *target;
{
register struct so_list *so = NULL; /* link map state variable */
+
+ /* Last shared library that we read. */
+ struct so_list *so_last = NULL;
+
char *re_err;
int count;
int old;
{
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);
+ printf_unfiltered ("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))
{
- catch_errors (symbol_add_stub, (char *) so,
- "Error while reading shared library symbols:\n");
-
- special_symbol_handling (so);
+ so_last = so;
so -> symbols_loaded = 1;
- so -> from_tty = from_tty;
}
}
}
{
old = target -> to_sections_end - target -> to_sections;
target -> to_sections = (struct section_table *)
- realloc ((char *)target -> to_sections,
+ xrealloc ((char *)target -> to_sections,
(sizeof (struct section_table)) * (count + old));
}
else
{
old = 0;
target -> to_sections = (struct section_table *)
- malloc ((sizeof (struct section_table)) * count);
+ xmalloc ((sizeof (struct section_table)) * count);
}
target -> to_sections_end = target -> to_sections + (count + old);
if (so -> so_name[0])
{
count = so -> sections_end - so -> sections;
- (void) memcpy ((char *) (target -> to_sections + old),
- so -> sections,
- (sizeof (struct section_table)) * count);
+ memcpy ((char *) (target -> to_sections + old),
+ so -> sections,
+ (sizeof (struct section_table)) * count);
old += count;
}
}
}
}
+
+ /* Calling this once at the end means that we put all the minimal
+ symbols for commons into the objfile for the last shared library.
+ Since they are in common, this should not be a problem. If we
+ delete the objfile with the minimal symbols, we can put all the
+ symbols into a new objfile (and will on the next call to solib_add).
+
+ An alternate approach would be to create an objfile just for
+ common minsyms, thus not needing any objfile argument to
+ solib_add_common_symbols. */
+
+ if (so_last)
+ special_symbol_handling (so_last);
}
/*
if (exec_bfd == NULL)
{
- printf ("No exec file.\n");
+ printf_unfiltered ("No exec file.\n");
return;
}
while ((so = find_solib (so)) != NULL)
{
if (!header_done)
{
- printf("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read",
+ printf_unfiltered("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read",
"Shared Object Library");
header_done++;
}
- 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);
+ printf_unfiltered ("%-12s",
+ local_hex_string_custom ((unsigned long) LM_ADDR (so),
+ "08l"));
+ printf_unfiltered ("%-12s",
+ local_hex_string_custom ((unsigned long) so -> lmend,
+ "08l"));
+ printf_unfiltered ("%-12s", so -> symbols_loaded ? "Yes" : "No");
+ printf_unfiltered ("%s\n", so -> so_name);
}
}
if (so_list_head == NULL)
{
- printf ("No shared libraries loaded at this time.\n");
+ printf_unfiltered ("No shared libraries loaded at this time.\n");
}
}
clear_solib()
{
struct so_list *next;
+ char *bfd_filename;
while (so_list_head)
{
{
free ((PTR)so_list_head -> sections);
}
- if (so_list_head -> so_bfd)
+ if (so_list_head -> abfd)
{
- bfd_close (so_list_head -> so_bfd);
+ bfd_filename = bfd_get_filename (so_list_head -> abfd);
+ bfd_close (so_list_head -> abfd);
}
+ else
+ /* This happens for the executable on SVR4. */
+ bfd_filename = NULL;
+
next = so_list_head -> next;
- free((PTR)so_list_head);
+ if (bfd_filename)
+ free ((PTR)bfd_filename);
+ free ((PTR)so_list_head);
so_list_head = next;
}
debug_base = 0;
static int
enable_break ()
{
+ int success = 0;
#ifndef SVR4_SHARED_LIBS
/* Write a value of 1 to this member. */
in_debugger = 1;
-
write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
+ success = 1;
#else /* SVR4_SHARED_LIBS */
-#ifdef BKPT_AT_MAIN
+#ifdef BKPT_AT_SYMBOL
struct minimal_symbol *msymbol;
+ char **bkpt_namep;
+ CORE_ADDR bkpt_addr;
- msymbol = lookup_minimal_symbol ("main", symfile_objfile);
- if ((msymbol != NULL) && (msymbol -> address != 0))
- {
- breakpoint_addr = msymbol -> 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()
{
-
+ /* 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 ())
{
stop_signal = 0;
do
{
- target_resume (0, stop_signal);
+ target_resume (-1, 0, stop_signal);
wait_for_inferior ();
}
while (stop_signal != SIGTRAP);
projects / deliverable / binutils-gdb.git / blobdiff