#include "inferior.h"
#include "language.h"
-/* We need to set a breakpoint at a point when we know that the
- mapping of shared libraries is complete. dbx simply breaks at main
- (or, for FORTRAN, MAIN__), so we do the same. We can not break at
- the very beginning of main, because the startup code will jump into
- main after the GP initialization instructions. SOLIB_BKPT_OFFSET
- is used to skip those instructions. */
-
-#define SOLIB_BKPT_OFFSET 12
-
-static char *bkpt_names[] = {
- "main",
- "MAIN__",
- NULL
-};
-
/* The symbol which starts off the list of shared libraries. */
#define DEBUG_BASE "__rld_obj_head"
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.
-
- Irix 5, on the other hand, has no such features. Instead, we
- set a breakpoint at main.
+ This functions inserts a breakpoint at the entry point of the
+ main executable, where all shared libraries are mapped in.
*/
static int
enable_break ()
{
- int success = 0;
- struct minimal_symbol *msymbol;
- char **bkpt_namep;
- CORE_ADDR bkpt_addr;
-
- /* Scan through the list of symbols, trying to look up the symbol and
- set a breakpoint there. Terminate loop when we/if we succeed. */
-
- breakpoint_addr = 0;
- for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
+ if (symfile_objfile != NULL
+ && target_insert_breakpoint (symfile_objfile->ei.entry_point,
+ shadow_contents) == 0)
{
- msymbol = lookup_minimal_symbol (*bkpt_namep, symfile_objfile);
- if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
- {
- bkpt_addr = SYMBOL_VALUE_ADDRESS (msymbol);
-#ifdef SOLIB_BKPT_OFFSET
- /* We only want to skip if bkpt_addr is currently pointing
- at a GP setting instruction. */
- {
- char buf[4];
-
- if (target_read_memory (bkpt_addr, buf, 4) == 0)
- {
- unsigned long insn;
-
- insn = extract_unsigned_integer (buf, 4);
- if ((insn & 0xffff0000) == 0x3c1c0000) /* lui $gp,n */
- bkpt_addr += SOLIB_BKPT_OFFSET;
- }
- }
-#endif
- if (target_insert_breakpoint (bkpt_addr, shadow_contents) == 0)
- {
- breakpoint_addr = bkpt_addr;
- success = 1;
- break;
- }
- }
+ breakpoint_addr = symfile_objfile->ei.entry_point;
+ return 1;
}
- return (success);
+ return 0;
}
/*
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
warning ("shared library handler failed to disable breakpoint");
}
+ /* solib_add will call reinit_frame_cache.
+ But we are stopped in the startup code and we might not have symbols
+ for the startup code, so heuristic_proc_start could be called
+ and will put out an annoying warning.
+ Delaying the resetting of stop_soon_quietly until after symbol loading
+ suppresses the warning. */
solib_add ((char *) 0, 0, (struct target_ops *) 0);
+ stop_soon_quietly = 0;
}
/*
#include "demangle.h"
#include <obstack.h>
-#include <assert.h>
#include <sys/types.h>
#include <fcntl.h>
if (!is_destructor)
is_destructor = (strncmp(physname, "__dt", 4) == 0);
-#ifndef GCC_MANGLE_BUG
if (is_destructor || is_full_physname_constructor)
{
mangled_name = (char*) xmalloc(strlen(physname)+1);
if (strcmp(buf, "__") == 0)
buf[0] = '\0';
}
+ else if (newname != NULL && strchr (newname, '<') != NULL)
+ {
+ /* Template methods are fully mangled. */
+ sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
+ newname = NULL;
+ len = 0;
+ }
else
{
sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
if (newname != NULL)
strcat (mangled_name, newname);
-#else
-
- if (is_constructor)
- {
- buf[0] = '\0';
- }
- else
- {
- sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
- }
-
- mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
- + strlen (buf) + strlen (physname) + 1);
-
- /* Only needed for GNU-mangled names. ANSI-mangled names
- work with the normal mechanisms. */
- if (OPNAME_PREFIX_P (field_name))
- {
- char *opname;
- opname = cplus_mangle_opname (field_name + 3, 0);
- if (opname == NULL)
- {
- error ("No mangling for \"%s\"", field_name);
- }
- mangled_name_len += strlen (opname);
- mangled_name = (char *) xmalloc (mangled_name_len);
-
- strncpy (mangled_name, field_name, 3);
- strcpy (mangled_name + 3, opname);
- }
- else
- {
- mangled_name = (char *) xmalloc (mangled_name_len);
- if (is_constructor)
- {
- mangled_name[0] = '\0';
- }
- else
- {
- strcpy (mangled_name, field_name);
- }
- }
- strcat (mangled_name, buf);
-
-#endif
strcat (mangled_name, physname);
return (mangled_name);
}
ALL_PSYMTABS (objfile, pst)
{
if (pc >= pst->textlow && pc < pst->texthigh)
- return (pst);
+ {
+ struct minimal_symbol *msymbol;
+ struct partial_symtab *tpst;
+
+ /* An objfile that has its functions reordered might have
+ many partial symbol tables containing the PC, but
+ we want the partial symbol table that contains the
+ function containing the PC. */
+ if (!(objfile->flags & OBJF_REORDERED))
+ return (pst);
+
+ msymbol = lookup_minimal_symbol_by_pc (pc);
+ if (msymbol == NULL)
+ return (pst);
+
+ for (tpst = pst; tpst != NULL; tpst = tpst->next)
+ {
+ if (pc >= tpst->textlow && pc < tpst->texthigh)
+ {
+ struct partial_symbol *p;
+
+ p = find_pc_psymbol (tpst, pc);
+ if (p != NULL
+ && SYMBOL_VALUE_ADDRESS(p)
+ == SYMBOL_VALUE_ADDRESS (msymbol))
+ return (tpst);
+ }
+ }
+ return (pst);
+ }
}
return (NULL);
}
}
}
- /* Check for the possibility of the symbol being a global function
- that is stored in one of the minimal symbol tables. Eventually, all
- global symbols might be resolved in this way. */
+ /* Check for the possibility of the symbol being a function or
+ a mangled variable that is stored in one of the minimal symbol tables.
+ Eventually, all global symbols might be resolved in this way. */
if (namespace == VAR_NAMESPACE)
{
if (msymbol != NULL)
{
s = find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol));
- /* If S is NULL, there are no debug symbols for this file.
- Skip this stuff and check for matching static symbols below. */
if (s != NULL)
{
+ /* This is a function which has a symtab for its address. */
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
*symtab = s;
return sym;
}
+ else if (MSYMBOL_TYPE (msymbol) != mst_text
+ && MSYMBOL_TYPE (msymbol) != mst_file_text
+ && !STREQ (name, SYMBOL_NAME (msymbol)))
+ {
+ /* This is a mangled variable, look it up by its
+ mangled name. */
+ return lookup_symbol (SYMBOL_NAME (msymbol), block,
+ namespace, is_a_field_of_this, symtab);
+ }
+ /* There are no debug symbols for this file, or we are looking
+ for an unmangled variable.
+ Try to find a matching static symbol below. */
}
}
while (top > bottom)
{
center = bottom + (top - bottom) / 2;
- assert (center < top);
+ if (!(center < top))
+ abort ();
if (!do_linear_search && SYMBOL_LANGUAGE (center) == language_cplus)
{
do_linear_search = 1;
bottom = center + 1;
}
}
- assert (top == bottom);
+ if (!(top == bottom))
+ abort ();
while (STREQ (SYMBOL_NAME (top), name))
{
if (SYMBOL_NAMESPACE (top) == namespace)
to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
0x1000-0x4000, but for address 0x2345 we want to return symtab b.
- This is said to happen for the mips; it might be swifter to create
- several symtabs with the same name like xcoff does (I'm not sure). */
+
+ This happens for native ecoff format, where code from included files
+ gets its own symtab. The symtab for the included file should have
+ been read in already via the dependency mechanism.
+ It might be swifter to create several symtabs with the same name
+ like xcoff does (I'm not sure).
+
+ It also happens for objfiles that have their functions reordered.
+ For these, the symtab we are looking for is not necessarily read in. */
ALL_SYMTABS (objfile, s)
{
&& (distance == 0
|| BLOCK_END (b) - BLOCK_START (b) < distance))
{
+ /* For an objfile that has its functions reordered,
+ find_pc_psymtab will find the proper partial symbol table
+ and we simply return its corresponding symtab. */
+ if (objfile->flags & OBJF_REORDERED)
+ {
+ ps = find_pc_psymtab (pc);
+ if (ps)
+ s = PSYMTAB_TO_SYMTAB (ps);
+ else
+ s = NULL;
+ return (s);
+ }
distance = BLOCK_END (b) - BLOCK_START (b);
best_s = s;
}
*endptr = sal.end;
return sal.symtab != 0;
}
+
+/* Given a function symbol SYM, find the symtab and line for the start
+ of the function.
+ If the argument FUNFIRSTLINE is nonzero, we want the first line
+ of real code inside the function. */
+
+static struct symtab_and_line
+find_function_start_sal PARAMS ((struct symbol *sym, int));
+
+static struct symtab_and_line
+find_function_start_sal (sym, funfirstline)
+ struct symbol *sym;
+ int funfirstline;
+{
+ CORE_ADDR pc;
+ struct symtab_and_line sal;
+
+ pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ if (funfirstline)
+ {
+ pc += FUNCTION_START_OFFSET;
+ SKIP_PROLOGUE (pc);
+ }
+ sal = find_pc_line (pc, 0);
+
+#ifdef PROLOGUE_FIRSTLINE_OVERLAP
+ /* Convex: no need to suppress code on first line, if any */
+ sal.pc = pc;
+#else
+ /* Check if SKIP_PROLOGUE left us in mid-line, and the next
+ line is still part of the same function. */
+ if (sal.pc != pc
+ && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= sal.end
+ && sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
+ {
+ /* First pc of next line */
+ pc = sal.end;
+ /* Recalculate the line number (might not be N+1). */
+ sal = find_pc_line (pc, 0);
+ }
+ sal.pc = pc;
+#endif
+
+ return sal;
+}
\f
/* If P is of the form "operator[ \t]+..." where `...' is
some legitimate operator text, return a pointer to the
FUNCTION may be an undebuggable function found in minimal symbol table.
If the argument FUNFIRSTLINE is nonzero, we want the first line
- of real code inside a function when a function is specified.
+ of real code inside a function when a function is specified, and it is
+ not OK to specify a variable or type to get its line number.
DEFAULT_SYMTAB specifies the file to use if none is specified.
It defaults to current_source_symtab.
if (**argptr == '*')
{
- if (**argptr == '*')
- {
- (*argptr)++;
- }
+ (*argptr)++;
pc = parse_and_eval_address_1 (argptr);
values.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
values.nelts = 1;
values.sals[0] = find_pc_line (pc, 0);
values.sals[0].pc = pc;
- build_canonical_line_spec (values.sals, NULL, canonical);
return values;
}
{
if (p[0] == '<')
{
- while(!++p && *p != '>');
+ while(++p && *p != '>');
if (!p)
{
error ("non-matching '<' and '>' in command");
if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
{
- /* Arg is the name of a function */
- pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
- if (funfirstline)
- {
- pc += FUNCTION_START_OFFSET;
- SKIP_PROLOGUE (pc);
- }
values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
values.nelts = 1;
- values.sals[0] = find_pc_line (pc, 0);
- values.sals[0].pc = (values.sals[0].end && values.sals[0].pc != pc) ? values.sals[0].end : pc;
+ values.sals[0] = find_function_start_sal (sym,
+ funfirstline);
}
else
{
if (SYMBOL_CLASS (sym) == LOC_BLOCK)
{
/* Arg is the name of a function */
- pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
- if (funfirstline)
- {
- pc += FUNCTION_START_OFFSET;
- SKIP_PROLOGUE (pc);
- }
- val = find_pc_line (pc, 0);
-#ifdef PROLOGUE_FIRSTLINE_OVERLAP
- /* Convex: no need to suppress code on first line, if any */
- val.pc = pc;
-#else
- /* Check if SKIP_PROLOGUE left us in mid-line, and the next
- line is still part of the same function. */
- if (val.pc != pc
- && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= val.end
- && val.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
- {
- /* First pc of next line */
- pc = val.end;
- /* Recalculate the line number (might not be N+1). */
- val = find_pc_line (pc, 0);
- }
- val.pc = pc;
-#endif
values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
- values.sals[0] = val;
+ values.sals[0] = find_function_start_sal (sym, funfirstline);
values.nelts = 1;
/* Don't use the SYMBOL_LINE; if used at all it points to
}
return values;
}
- else if (SYMBOL_LINE (sym) != 0)
+ else
{
- /* We know its line number. */
- values.sals = (struct symtab_and_line *)
- xmalloc (sizeof (struct symtab_and_line));
- values.nelts = 1;
- memset (&values.sals[0], 0, sizeof (values.sals[0]));
- values.sals[0].symtab = sym_symtab;
- values.sals[0].line = SYMBOL_LINE (sym);
- return values;
+ if (funfirstline)
+ error ("\"%s\" is not a function", copy);
+ else if (SYMBOL_LINE (sym) != 0)
+ {
+ /* We know its line number. */
+ values.sals = (struct symtab_and_line *)
+ xmalloc (sizeof (struct symtab_and_line));
+ values.nelts = 1;
+ memset (&values.sals[0], 0, sizeof (values.sals[0]));
+ values.sals[0].symtab = sym_symtab;
+ values.sals[0].line = SYMBOL_LINE (sym);
+ return values;
+ }
+ else
+ /* This can happen if it is compiled with a compiler which doesn't
+ put out line numbers for variables. */
+ /* FIXME: Shouldn't we just set .line and .symtab to zero
+ and return? For example, "info line foo" could print
+ the address. */
+ error ("Line number not known for symbol \"%s\"", copy);
}
- else
- /* This can happen if it is compiled with a compiler which doesn't
- put out line numbers for variables. */
- /* FIXME: Shouldn't we just set .line and .symtab to zero and
- return? For example, "info line foo" could print the address. */
- error ("Line number not known for symbol \"%s\"", copy);
}
msymbol = lookup_minimal_symbol (copy, (struct objfile *) NULL);
char ***canonical;
{
struct symtabs_and_lines values, return_values;
- register CORE_ADDR pc;
char *args, *arg1;
int i;
char *prompt;
{
if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
{
- /* Arg is the name of a function */
- pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr[i]));
- if (funfirstline)
- {
- pc += FUNCTION_START_OFFSET;
- SKIP_PROLOGUE (pc);
- }
- values.sals[i] = find_pc_line (pc, 0);
- values.sals[i].pc = (values.sals[i].end && values.sals[i].pc != pc) ?
- values.sals[i].end : pc;
- printf_unfiltered("[%d] %s at %s:%d\n", (i+2), SYMBOL_SOURCE_NAME (sym_arr[i]),
- values.sals[i].symtab->filename, values.sals[i].line);
+ values.sals[i] = find_function_start_sal (sym_arr[i], funfirstline);
+ printf_unfiltered ("[%d] %s at %s:%d\n",
+ (i+2),
+ SYMBOL_SOURCE_NAME (sym_arr[i]),
+ values.sals[i].symtab->filename,
+ values.sals[i].line);
}
- else printf_unfiltered ("?HERE\n");
+ else
+ printf_unfiltered ("?HERE\n");
i++;
}
}
}
- /* Here, we search through the minimal symbol tables for functions that
- match, and call find_pc_symtab on them to force their symbols to
- be read. The symbol will then be found during the scan of symtabs
- below. If find_pc_symtab fails, set found_misc so that we will
- rescan to print any matching symbols without debug info. */
+ /* Here, we search through the minimal symbol tables for functions
+ and variables that match, and force their symbols to be read.
+ This is in particular necessary for demangled variable names,
+ which are no longer put into the partial symbol tables.
+ The symbol will then be found during the scan of symtabs below.
+
+ For functions, find_pc_symtab should succeed if we have debug info
+ for the function, for variables we have to call lookup_symbol
+ to determine if the variable has debug info.
+ If the lookup fails, set found_misc so that we will rescan to print
+ any matching symbols without debug info.
+ */
- if (class == 1)
+ if (class == 0 || class == 1)
{
ALL_MSYMBOLS (objfile, msymbol)
{
{
if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
{
- found_misc = 1;
+ if (class == 1
+ || lookup_symbol (SYMBOL_NAME (msymbol),
+ (struct block *) NULL,
+ VAR_NAMESPACE,
+ 0, (struct symtab **) NULL) == NULL)
+ found_misc = 1;
}
}
}
same name but in different files. In order to
set breakpoints on all of them, we must give
both the file name and the function name to
- break_command. */
+ break_command.
+ Quoting the symbol name gets rid of problems
+ with mangled symbol names that contain
+ CPLUS_MARKER characters. */
char *string =
(char *) alloca (strlen (s->filename)
+ strlen (SYMBOL_NAME(sym))
- + 2);
+ + 4);
strcpy (string, s->filename);
- strcat (string, ":");
+ strcat (string, ":'");
strcat (string, SYMBOL_NAME(sym));
+ strcat (string, "'");
break_command (string, from_tty);
}
}
projects / binutils-gdb.git / commitdiff