#include <sys/types.h>
#include <fcntl.h>
-#include <string.h>
#include <sys/stat.h>
#include <ctype.h>
#include "cp-abi.h"
#include "cp-support.h"
#include "observer.h"
-#include "gdb_assert.h"
#include "solist.h"
#include "macrotab.h"
#include "macroscope.h"
NAME is a field of the current implied argument `this'. If so set
*IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
BLOCK_FOUND is set to the block in which NAME is found (in the case of
- a field of `this', value_of_this sets BLOCK_FOUND to the proper value.)
-
- If DOMAIN is VAR_DOMAIN and the language permits using tag names for
- elaborated types, such as classes in C++, this function will search
- STRUCT_DOMAIN if no matching is found. */
+ a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
/* This function (or rather its subordinates) have a bunch of loops and
it would seem to be attractive to put in some QUIT's (though I'm not really
returnval = lookup_symbol_aux (modified_name, block, domain, lang,
is_a_field_of_this);
- if (returnval == NULL)
- {
- if (is_a_field_of_this != NULL
- && is_a_field_of_this->type != NULL)
- return NULL;
-
- /* Some languages define typedefs of a type equal to its tag name,
- e.g., in C++, "struct foo { ... }" also defines a typedef for
- "foo". */
- if (domain == VAR_DOMAIN
- && (lang == language_cplus || lang == language_java
- || lang == language_ada || lang == language_d))
- {
- returnval = lookup_symbol_aux (modified_name, block, STRUCT_DOMAIN,
- lang, is_a_field_of_this);
- }
- }
do_cleanups (cleanup);
return returnval;
{
const struct objfile *objfile;
struct symbol *sym;
- struct blockvector *bv;
+ const struct blockvector *bv;
const struct block *block;
struct symtab *s;
const char *name, const domain_enum domain)
{
struct symbol *sym = NULL;
- struct blockvector *bv;
+ const struct blockvector *bv;
const struct block *block;
struct symtab *s;
const char *name, const domain_enum domain)
{
struct symtab *symtab;
- struct blockvector *bv;
+ const struct blockvector *bv;
const struct block *block;
struct symbol *sym;
return lookup_data.result;
}
+int
+symbol_matches_domain (enum language symbol_language,
+ domain_enum symbol_domain,
+ domain_enum domain)
+{
+ /* For C++ "struct foo { ... }" also defines a typedef for "foo".
+ A Java class declaration also defines a typedef for the class.
+ Similarly, any Ada type declaration implicitly defines a typedef. */
+ if (symbol_language == language_cplus
+ || symbol_language == language_d
+ || symbol_language == language_java
+ || symbol_language == language_ada)
+ {
+ if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
+ && symbol_domain == STRUCT_DOMAIN)
+ return 1;
+ }
+ /* For all other languages, strict match is required. */
+ return (symbol_domain == domain);
+}
+
/* Look up a type named NAME in the struct_domain. The type returned
must not be opaque -- i.e., must have at least one field
defined. */
const char *name)
{
struct symtab *symtab;
- struct blockvector *bv;
+ const struct blockvector *bv;
struct block *block;
struct symbol *sym;
{
struct symbol *sym;
struct symtab *s = NULL;
- struct blockvector *bv;
+ const struct blockvector *bv;
struct objfile *objfile;
struct block *block;
struct type *t;
binary search terminates, we drop through and do a straight linear
search on the symbols. Each symbol which is marked as being a ObjC/C++
symbol (language_cplus or language_objc set) has both the encoded and
- non-encoded names tested for a match.
-
- This function specifically disallows domain mismatches. If a language
- defines a typedef for an elaborated type, such as classes in C++,
- then this function will need to be called twice, once to search
- VAR_DOMAIN and once to search STRUCT_DOMAIN. */
+ non-encoded names tested for a match. */
struct symbol *
lookup_block_symbol (const struct block *block, const char *name,
sym != NULL;
sym = block_iter_name_next (name, &iter))
{
- if (SYMBOL_DOMAIN (sym) == domain)
+ if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+ SYMBOL_DOMAIN (sym), domain))
return sym;
}
return NULL;
sym != NULL;
sym = block_iter_name_next (name, &iter))
{
- if (SYMBOL_DOMAIN (sym) == domain)
+ if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+ SYMBOL_DOMAIN (sym), domain))
{
sym_found = sym;
if (!SYMBOL_IS_ARGUMENT (sym))
sym != NULL;
sym = block_iter_name_next (name, &iter))
{
- if (SYMBOL_DOMAIN (sym) == domain)
+ if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+ SYMBOL_DOMAIN (sym), domain))
{
if (!callback (sym, data))
return;
find_pc_sect_symtab (CORE_ADDR pc, struct obj_section *section)
{
struct block *b;
- struct blockvector *bv;
+ const struct blockvector *bv;
struct symtab *s = NULL;
struct symtab *best_s = NULL;
struct objfile *objfile;
int i;
struct linetable_entry *item;
struct symtab_and_line val;
- struct blockvector *bv;
+ const struct blockvector *bv;
struct bound_minimal_symbol msymbol;
struct objfile *objfile;
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. */
+
+struct symtab_and_line
+find_function_start_sal (struct symbol *sym, int funfirstline)
+{
+ struct symtab_and_line sal;
+
+ fixup_symbol_section (sym, NULL);
+ sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
+ SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym), 0);
+
+ /* We always should have a line for the function start address.
+ If we don't, something is odd. Create a plain SAL refering
+ just the PC and hope that skip_prologue_sal (if requested)
+ can find a line number for after the prologue. */
+ if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
+ {
+ init_sal (&sal);
+ sal.pspace = current_program_space;
+ sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ sal.section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym);
+ }
+
+ if (funfirstline)
+ skip_prologue_sal (&sal);
+
+ return sal;
+}
+
/* Given a function start address FUNC_ADDR and SYMTAB, find the first
address for that function that has an entry in SYMTAB's line info
table. If such an entry cannot be found, return FUNC_ADDR
return func_addr;
}
-/* 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. */
-
-struct symtab_and_line
-find_function_start_sal (struct symbol *sym, int funfirstline)
-{
- struct symtab_and_line sal;
-
- fixup_symbol_section (sym, NULL);
- sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
- SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym), 0);
-
- /* We always should have a line for the function start address.
- If we don't, something is odd. Create a plain SAL refering
- just the PC and hope that skip_prologue_sal (if requested)
- can find a line number for after the prologue. */
- if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
- {
- init_sal (&sal);
- sal.pspace = current_program_space;
- sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
- sal.section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym);
- }
-
- if (funfirstline)
- skip_prologue_sal (&sal);
-
- return sal;
-}
-
/* Adjust SAL to the first instruction past the function prologue.
If the PC was explicitly specified, the SAL is not changed.
If the line number was explicitly specified, at most the SAL's PC
const char *name;
struct objfile *objfile;
struct gdbarch *gdbarch;
- struct block *b, *function_block;
+ const struct block *b, *function_block;
int force_skip, skip;
/* Do not change the SAL if PC was specified explicitly. */
}
}
+/* Determine if PC is in the prologue of a function. The prologue is the area
+ between the first instruction of a function, and the first executable line.
+ Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
+
+ If non-zero, func_start is where we think the prologue starts, possibly
+ by previous examination of symbol table information. */
+
+int
+in_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR func_start)
+{
+ struct symtab_and_line sal;
+ CORE_ADDR func_addr, func_end;
+
+ /* We have several sources of information we can consult to figure
+ this out.
+ - Compilers usually emit line number info that marks the prologue
+ as its own "source line". So the ending address of that "line"
+ is the end of the prologue. If available, this is the most
+ reliable method.
+ - The minimal symbols and partial symbols, which can usually tell
+ us the starting and ending addresses of a function.
+ - If we know the function's start address, we can call the
+ architecture-defined gdbarch_skip_prologue function to analyze the
+ instruction stream and guess where the prologue ends.
+ - Our `func_start' argument; if non-zero, this is the caller's
+ best guess as to the function's entry point. At the time of
+ this writing, handle_inferior_event doesn't get this right, so
+ it should be our last resort. */
+
+ /* Consult the partial symbol table, to find which function
+ the PC is in. */
+ if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end))
+ {
+ CORE_ADDR prologue_end;
+
+ /* We don't even have minsym information, so fall back to using
+ func_start, if given. */
+ if (! func_start)
+ return 1; /* We *might* be in a prologue. */
+
+ prologue_end = gdbarch_skip_prologue (gdbarch, func_start);
+
+ return func_start <= pc && pc < prologue_end;
+ }
+
+ /* If we have line number information for the function, that's
+ usually pretty reliable. */
+ sal = find_pc_line (func_addr, 0);
+
+ /* Now sal describes the source line at the function's entry point,
+ which (by convention) is the prologue. The end of that "line",
+ sal.end, is the end of the prologue.
+
+ Note that, for functions whose source code is all on a single
+ line, the line number information doesn't always end up this way.
+ So we must verify that our purported end-of-prologue address is
+ *within* the function, not at its start or end. */
+ if (sal.line == 0
+ || sal.end <= func_addr
+ || func_end <= sal.end)
+ {
+ /* We don't have any good line number info, so use the minsym
+ information, together with the architecture-specific prologue
+ scanning code. */
+ CORE_ADDR prologue_end = gdbarch_skip_prologue (gdbarch, func_addr);
+
+ return func_addr <= pc && pc < prologue_end;
+ }
+
+ /* We have line number info, and it looks good. */
+ return func_addr <= pc && pc < sal.end;
+}
+
+/* Given PC at the function's start address, attempt to find the
+ prologue end using SAL information. Return zero if the skip fails.
+
+ A non-optimized prologue traditionally has one SAL for the function
+ and a second for the function body. A single line function has
+ them both pointing at the same line.
+
+ An optimized prologue is similar but the prologue may contain
+ instructions (SALs) from the instruction body. Need to skip those
+ while not getting into the function body.
+
+ The functions end point and an increasing SAL line are used as
+ indicators of the prologue's endpoint.
+
+ This code is based on the function refine_prologue_limit
+ (found in ia64). */
+
+CORE_ADDR
+skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
+{
+ struct symtab_and_line prologue_sal;
+ CORE_ADDR start_pc;
+ CORE_ADDR end_pc;
+ const struct block *bl;
+
+ /* Get an initial range for the function. */
+ find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
+ start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
+
+ prologue_sal = find_pc_line (start_pc, 0);
+ if (prologue_sal.line != 0)
+ {
+ /* For languages other than assembly, treat two consecutive line
+ entries at the same address as a zero-instruction prologue.
+ The GNU assembler emits separate line notes for each instruction
+ in a multi-instruction macro, but compilers generally will not
+ do this. */
+ if (prologue_sal.symtab->language != language_asm)
+ {
+ struct linetable *linetable = LINETABLE (prologue_sal.symtab);
+ int idx = 0;
+
+ /* Skip any earlier lines, and any end-of-sequence marker
+ from a previous function. */
+ while (linetable->item[idx].pc != prologue_sal.pc
+ || linetable->item[idx].line == 0)
+ idx++;
+
+ if (idx+1 < linetable->nitems
+ && linetable->item[idx+1].line != 0
+ && linetable->item[idx+1].pc == start_pc)
+ return start_pc;
+ }
+
+ /* If there is only one sal that covers the entire function,
+ then it is probably a single line function, like
+ "foo(){}". */
+ if (prologue_sal.end >= end_pc)
+ return 0;
+
+ while (prologue_sal.end < end_pc)
+ {
+ struct symtab_and_line sal;
+
+ sal = find_pc_line (prologue_sal.end, 0);
+ if (sal.line == 0)
+ break;
+ /* Assume that a consecutive SAL for the same (or larger)
+ line mark the prologue -> body transition. */
+ if (sal.line >= prologue_sal.line)
+ break;
+ /* Likewise if we are in a different symtab altogether
+ (e.g. within a file included via #include). */
+ if (sal.symtab != prologue_sal.symtab)
+ break;
+
+ /* The line number is smaller. Check that it's from the
+ same function, not something inlined. If it's inlined,
+ then there is no point comparing the line numbers. */
+ bl = block_for_pc (prologue_sal.end);
+ while (bl)
+ {
+ if (block_inlined_p (bl))
+ break;
+ if (BLOCK_FUNCTION (bl))
+ {
+ bl = NULL;
+ break;
+ }
+ bl = BLOCK_SUPERBLOCK (bl);
+ }
+ if (bl != NULL)
+ break;
+
+ /* The case in which compiler's optimizer/scheduler has
+ moved instructions into the prologue. We look ahead in
+ the function looking for address ranges whose
+ corresponding line number is less the first one that we
+ found for the function. This is more conservative then
+ refine_prologue_limit which scans a large number of SALs
+ looking for any in the prologue. */
+ prologue_sal = sal;
+ }
+ }
+
+ if (prologue_sal.end < end_pc)
+ /* Return the end of this line, or zero if we could not find a
+ line. */
+ return prologue_sal.end;
+ else
+ /* Don't return END_PC, which is past the end of the function. */
+ return prologue_sal.pc;
+}
+\f
/* If P is of the form "operator[ \t]+..." where `...' is
some legitimate operator text, return a pointer to the
beginning of the substring of the operator text.
Otherwise, return "". */
-static char *
-operator_chars (char *p, char **end)
+static const char *
+operator_chars (const char *p, const char **end)
{
*end = "";
if (strncmp (p, "operator", 8))
if (isalpha (*p) || *p == '_' || *p == '$')
{
- char *q = p + 1;
+ const char *q = p + 1;
while (isalnum (*q) || *q == '_' || *q == '$')
q++;
non-zero compare only lbasename of FILES. */
static int
-file_matches (const char *file, char *files[], int nfiles, int basenames)
+file_matches (const char *file, const char *files[], int nfiles, int basenames)
{
int i;
struct search_symbols_data
{
int nfiles;
- char **files;
+ const char **files;
/* It is true if PREG contains valid data, false otherwise. */
unsigned preg_p : 1;
Duplicate entries are removed. */
void
-search_symbols (char *regexp, enum search_domain kind,
- int nfiles, char *files[],
+search_symbols (const char *regexp, enum search_domain kind,
+ int nfiles, const char *files[],
struct symbol_search **matches)
{
struct symtab *s;
- struct blockvector *bv;
+ const struct blockvector *bv;
struct block *b;
int i = 0;
struct block_iterator iter;
This is just a courtesy to make the matching less sensitive
to how many spaces the user leaves between 'operator'
and <TYPENAME> or <OPERATOR>. */
- char *opend;
- char *opname = operator_chars (regexp, &opend);
+ const char *opend;
+ const char *opname = operator_chars (regexp, &opend);
int errcode;
if (*opname)
gdb_assert (kind <= TYPES_DOMAIN);
/* Must make sure that if we're interrupted, symbols gets freed. */
- search_symbols (regexp, kind, 0, (char **) NULL, &symbols);
+ search_symbols (regexp, kind, 0, NULL, &symbols);
old_chain = make_cleanup_free_search_symbols (&symbols);
if (regexp != NULL)
struct cleanup *old_chain;
char *string = NULL;
int len = 0;
- char **files = NULL, *file_name;
+ const char **files = NULL;
+ const char *file_name;
int nfiles = 0;
if (regexp)
if (colon && *(colon + 1) != ':')
{
int colon_index;
+ char *local_name;
colon_index = colon - regexp;
- file_name = alloca (colon_index + 1);
- memcpy (file_name, regexp, colon_index);
- file_name[colon_index--] = 0;
- while (isspace (file_name[colon_index]))
- file_name[colon_index--] = 0;
+ local_name = alloca (colon_index + 1);
+ memcpy (local_name, regexp, colon_index);
+ local_name[colon_index--] = 0;
+ while (isspace (local_name[colon_index]))
+ local_name[colon_index--] = 0;
+ file_name = local_name;
files = &file_name;
nfiles = 1;
regexp = skip_spaces (colon + 1);
{
struct add_name_data *datum = (struct add_name_data *) user_data;
- completion_list_add_name ((char *) name,
+ completion_list_add_name (name,
datum->sym_text, datum->sym_text_len,
datum->text, datum->word);
}
struct symtab *s;
struct minimal_symbol *msymbol;
struct objfile *objfile;
- struct block *b;
+ const struct block *b;
const struct block *surrounding_static_block, *surrounding_global_block;
struct block_iterator iter;
/* The symbol we are completing on. Points in same buffer as text. */
return list;
}
-
-/* Determine if PC is in the prologue of a function. The prologue is the area
- between the first instruction of a function, and the first executable line.
- Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
-
- If non-zero, func_start is where we think the prologue starts, possibly
- by previous examination of symbol table information. */
-
-int
-in_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR func_start)
-{
- struct symtab_and_line sal;
- CORE_ADDR func_addr, func_end;
-
- /* We have several sources of information we can consult to figure
- this out.
- - Compilers usually emit line number info that marks the prologue
- as its own "source line". So the ending address of that "line"
- is the end of the prologue. If available, this is the most
- reliable method.
- - The minimal symbols and partial symbols, which can usually tell
- us the starting and ending addresses of a function.
- - If we know the function's start address, we can call the
- architecture-defined gdbarch_skip_prologue function to analyze the
- instruction stream and guess where the prologue ends.
- - Our `func_start' argument; if non-zero, this is the caller's
- best guess as to the function's entry point. At the time of
- this writing, handle_inferior_event doesn't get this right, so
- it should be our last resort. */
-
- /* Consult the partial symbol table, to find which function
- the PC is in. */
- if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end))
- {
- CORE_ADDR prologue_end;
-
- /* We don't even have minsym information, so fall back to using
- func_start, if given. */
- if (! func_start)
- return 1; /* We *might* be in a prologue. */
-
- prologue_end = gdbarch_skip_prologue (gdbarch, func_start);
-
- return func_start <= pc && pc < prologue_end;
- }
-
- /* If we have line number information for the function, that's
- usually pretty reliable. */
- sal = find_pc_line (func_addr, 0);
-
- /* Now sal describes the source line at the function's entry point,
- which (by convention) is the prologue. The end of that "line",
- sal.end, is the end of the prologue.
-
- Note that, for functions whose source code is all on a single
- line, the line number information doesn't always end up this way.
- So we must verify that our purported end-of-prologue address is
- *within* the function, not at its start or end. */
- if (sal.line == 0
- || sal.end <= func_addr
- || func_end <= sal.end)
- {
- /* We don't have any good line number info, so use the minsym
- information, together with the architecture-specific prologue
- scanning code. */
- CORE_ADDR prologue_end = gdbarch_skip_prologue (gdbarch, func_addr);
-
- return func_addr <= pc && pc < prologue_end;
- }
-
- /* We have line number info, and it looks good. */
- return func_addr <= pc && pc < sal.end;
-}
-
-/* Given PC at the function's start address, attempt to find the
- prologue end using SAL information. Return zero if the skip fails.
-
- A non-optimized prologue traditionally has one SAL for the function
- and a second for the function body. A single line function has
- them both pointing at the same line.
-
- An optimized prologue is similar but the prologue may contain
- instructions (SALs) from the instruction body. Need to skip those
- while not getting into the function body.
-
- The functions end point and an increasing SAL line are used as
- indicators of the prologue's endpoint.
-
- This code is based on the function refine_prologue_limit
- (found in ia64). */
-
-CORE_ADDR
-skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
-{
- struct symtab_and_line prologue_sal;
- CORE_ADDR start_pc;
- CORE_ADDR end_pc;
- struct block *bl;
-
- /* Get an initial range for the function. */
- find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
- start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
-
- prologue_sal = find_pc_line (start_pc, 0);
- if (prologue_sal.line != 0)
- {
- /* For languages other than assembly, treat two consecutive line
- entries at the same address as a zero-instruction prologue.
- The GNU assembler emits separate line notes for each instruction
- in a multi-instruction macro, but compilers generally will not
- do this. */
- if (prologue_sal.symtab->language != language_asm)
- {
- struct linetable *linetable = LINETABLE (prologue_sal.symtab);
- int idx = 0;
-
- /* Skip any earlier lines, and any end-of-sequence marker
- from a previous function. */
- while (linetable->item[idx].pc != prologue_sal.pc
- || linetable->item[idx].line == 0)
- idx++;
-
- if (idx+1 < linetable->nitems
- && linetable->item[idx+1].line != 0
- && linetable->item[idx+1].pc == start_pc)
- return start_pc;
- }
-
- /* If there is only one sal that covers the entire function,
- then it is probably a single line function, like
- "foo(){}". */
- if (prologue_sal.end >= end_pc)
- return 0;
-
- while (prologue_sal.end < end_pc)
- {
- struct symtab_and_line sal;
-
- sal = find_pc_line (prologue_sal.end, 0);
- if (sal.line == 0)
- break;
- /* Assume that a consecutive SAL for the same (or larger)
- line mark the prologue -> body transition. */
- if (sal.line >= prologue_sal.line)
- break;
- /* Likewise if we are in a different symtab altogether
- (e.g. within a file included via #include). */
- if (sal.symtab != prologue_sal.symtab)
- break;
-
- /* The line number is smaller. Check that it's from the
- same function, not something inlined. If it's inlined,
- then there is no point comparing the line numbers. */
- bl = block_for_pc (prologue_sal.end);
- while (bl)
- {
- if (block_inlined_p (bl))
- break;
- if (BLOCK_FUNCTION (bl))
- {
- bl = NULL;
- break;
- }
- bl = BLOCK_SUPERBLOCK (bl);
- }
- if (bl != NULL)
- break;
-
- /* The case in which compiler's optimizer/scheduler has
- moved instructions into the prologue. We look ahead in
- the function looking for address ranges whose
- corresponding line number is less the first one that we
- found for the function. This is more conservative then
- refine_prologue_limit which scans a large number of SALs
- looking for any in the prologue. */
- prologue_sal = sal;
- }
- }
-
- if (prologue_sal.end < end_pc)
- /* Return the end of this line, or zero if we could not find a
- line. */
- return prologue_sal.end;
- else
- /* Don't return END_PC, which is past the end of the function. */
- return prologue_sal.pc;
-}
\f
/* Track MAIN */
projects / platform / upstream / binutils.git / blobdiff