const struct block *block,
const domain_enum domain,
enum language language,
- int *is_a_field_of_this,
- struct symtab **symtab);
+ int *is_a_field_of_this);
static
struct symbol *lookup_symbol_aux_local (const char *name,
const char *linkage_name,
const struct block *block,
- const domain_enum domain,
- struct symtab **symtab);
+ const domain_enum domain);
static
struct symbol *lookup_symbol_aux_symtabs (int block_index,
const char *name,
const char *linkage_name,
- const domain_enum domain,
- struct symtab **symtab);
+ const domain_enum domain);
static
struct symbol *lookup_symbol_aux_psymtabs (int block_index,
const char *name,
const char *linkage_name,
- const domain_enum domain,
- struct symtab **symtab);
+ const domain_enum domain);
static int file_matches (char *, char **, int);
{
case LOC_STATIC:
case LOC_LABEL:
- case LOC_INDIRECT:
addr = SYMBOL_VALUE_ADDRESS (sym);
break;
case LOC_BLOCK:
{
case LOC_STATIC:
case LOC_LABEL:
- case LOC_INDIRECT:
case LOC_BLOCK:
addr = SYMBOL_VALUE_ADDRESS (psym);
break;
/* Find the definition for a specified symbol name NAME
in domain DOMAIN, visible from lexical block BLOCK.
Returns the struct symbol pointer, or zero if no symbol is found.
- If SYMTAB is non-NULL, store the symbol table in which the
- symbol was found there, or NULL if not found.
C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
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.
struct symbol *
lookup_symbol_in_language (const char *name, const struct block *block,
const domain_enum domain, enum language lang,
- int *is_a_field_of_this,
- struct symtab **symtab)
+ int *is_a_field_of_this)
{
char *demangled_name = NULL;
const char *modified_name = NULL;
}
returnval = lookup_symbol_aux (modified_name, mangled_name, block,
- domain, lang,
- is_a_field_of_this, symtab);
+ domain, lang, is_a_field_of_this);
if (needtofreename)
xfree (demangled_name);
- /* Override the returned symtab with the symbol's specific one. */
- if (returnval != NULL && symtab != NULL)
- *symtab = SYMBOL_SYMTAB (returnval);
-
return returnval;
}
struct symbol *
lookup_symbol (const char *name, const struct block *block,
- domain_enum domain, int *is_a_field_of_this,
- struct symtab **symtab)
+ domain_enum domain, int *is_a_field_of_this)
{
return lookup_symbol_in_language (name, block, domain,
current_language->la_language,
- is_a_field_of_this, symtab);
+ is_a_field_of_this);
}
/* Behave like lookup_symbol except that NAME is the natural name
static struct symbol *
lookup_symbol_aux (const char *name, const char *linkage_name,
const struct block *block, const domain_enum domain,
- enum language language,
- int *is_a_field_of_this, struct symtab **symtab)
+ enum language language, int *is_a_field_of_this)
{
struct symbol *sym;
const struct language_defn *langdef;
/* Search specified block and its superiors. Don't search
STATIC_BLOCK or GLOBAL_BLOCK. */
- sym = lookup_symbol_aux_local (name, linkage_name, block, domain,
- symtab);
+ sym = lookup_symbol_aux_local (name, linkage_name, block, domain);
if (sym != NULL)
return sym;
if (check_field (t, name))
{
*is_a_field_of_this = 1;
- if (symtab != NULL)
- *symtab = NULL;
return NULL;
}
}
/* Now do whatever is appropriate for LANGUAGE to look
up static and global variables. */
- sym = langdef->la_lookup_symbol_nonlocal (name, linkage_name,
- block, domain, symtab);
+ sym = langdef->la_lookup_symbol_nonlocal (name, linkage_name, block, domain);
if (sym != NULL)
return sym;
desired name as a file-level static, then do psymtab-to-symtab
conversion on the fly and return the found symbol. */
- sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, linkage_name,
- domain, symtab);
+ sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, linkage_name, domain);
if (sym != NULL)
return sym;
- sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, linkage_name,
- domain, symtab);
+ sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, linkage_name, domain);
if (sym != NULL)
return sym;
- if (symtab != NULL)
- *symtab = NULL;
return NULL;
}
static struct symbol *
lookup_symbol_aux_local (const char *name, const char *linkage_name,
const struct block *block,
- const domain_enum domain,
- struct symtab **symtab)
+ const domain_enum domain)
{
struct symbol *sym;
const struct block *static_block = block_static_block (block);
while (block != static_block)
{
- sym = lookup_symbol_aux_block (name, linkage_name, block, domain,
- symtab);
+ sym = lookup_symbol_aux_block (name, linkage_name, block, domain);
if (sym != NULL)
return sym;
block = BLOCK_SUPERBLOCK (block);
return NULL;
}
-/* Look up a symbol in a block; if found, locate its symtab, fixup the
- symbol, and set block_found appropriately. */
+/* Look up a symbol in a block; if found, fixup the symbol, and set
+ block_found appropriately. */
struct symbol *
lookup_symbol_aux_block (const char *name, const char *linkage_name,
const struct block *block,
- const domain_enum domain,
- struct symtab **symtab)
+ const domain_enum domain)
{
struct symbol *sym;
- struct objfile *objfile = NULL;
- struct blockvector *bv;
- struct block *b;
- struct symtab *s = NULL;
sym = lookup_block_symbol (block, name, linkage_name, domain);
if (sym)
{
block_found = block;
- if (symtab != NULL)
- {
- /* Search the list of symtabs for one which contains the
- address of the start of this block. */
- ALL_PRIMARY_SYMTABS (objfile, s)
- {
- bv = BLOCKVECTOR (s);
- b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- if (BLOCK_START (b) <= BLOCK_START (block)
- && BLOCK_END (b) > BLOCK_START (block))
- goto found;
- }
- found:
- *symtab = s;
- }
-
- return fixup_symbol_section (sym, objfile);
+ return fixup_symbol_section (sym, NULL);
}
return NULL;
lookup_global_symbol_from_objfile (const struct objfile *objfile,
const char *name,
const char *linkage_name,
- const domain_enum domain,
- struct symtab **symtab)
+ const domain_enum domain)
{
struct symbol *sym;
struct blockvector *bv;
if (sym)
{
block_found = block;
- if (symtab != NULL)
- *symtab = s;
return fixup_symbol_section (sym, (struct objfile *)objfile);
}
}
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
sym = lookup_block_symbol (block, name, linkage_name, domain);
- if (symtab != NULL)
- *symtab = s;
return fixup_symbol_section (sym, (struct objfile *)objfile);
}
}
if (objfile->separate_debug_objfile)
return lookup_global_symbol_from_objfile (objfile->separate_debug_objfile,
- name, linkage_name, domain,
- symtab);
+ name, linkage_name, domain);
return NULL;
}
static struct symbol *
lookup_symbol_aux_symtabs (int block_index,
const char *name, const char *linkage_name,
- const domain_enum domain,
- struct symtab **symtab)
+ const domain_enum domain)
{
struct symbol *sym;
struct objfile *objfile;
if (sym)
{
block_found = block;
- if (symtab != NULL)
- *symtab = s;
return fixup_symbol_section (sym, objfile);
}
}
static struct symbol *
lookup_symbol_aux_psymtabs (int block_index, const char *name,
const char *linkage_name,
- const domain_enum domain,
- struct symtab **symtab)
+ const domain_enum domain)
{
struct symbol *sym;
struct objfile *objfile;
block_index == GLOBAL_BLOCK ? "global" : "static",
name, ps->filename, name, name);
}
- if (symtab != NULL)
- *symtab = s;
return fixup_symbol_section (sym, objfile);
}
}
basic_lookup_symbol_nonlocal (const char *name,
const char *linkage_name,
const struct block *block,
- const domain_enum domain,
- struct symtab **symtab)
+ const domain_enum domain)
{
struct symbol *sym;
than that one, so I don't think we should worry about that for
now. */
- sym = lookup_symbol_static (name, linkage_name, block, domain, symtab);
+ sym = lookup_symbol_static (name, linkage_name, block, domain);
if (sym != NULL)
return sym;
- return lookup_symbol_global (name, linkage_name, block, domain, symtab);
+ return lookup_symbol_global (name, linkage_name, block, domain);
}
/* Lookup a symbol in the static block associated to BLOCK, if there
lookup_symbol_static (const char *name,
const char *linkage_name,
const struct block *block,
- const domain_enum domain,
- struct symtab **symtab)
+ const domain_enum domain)
{
const struct block *static_block = block_static_block (block);
if (static_block != NULL)
- return lookup_symbol_aux_block (name, linkage_name, static_block,
- domain, symtab);
+ return lookup_symbol_aux_block (name, linkage_name, static_block, domain);
else
return NULL;
}
lookup_symbol_global (const char *name,
const char *linkage_name,
const struct block *block,
- const domain_enum domain,
- struct symtab **symtab)
+ const domain_enum domain)
{
struct symbol *sym = NULL;
struct objfile *objfile = NULL;
/* Call library-specific lookup procedure. */
objfile = lookup_objfile_from_block (block);
if (objfile != NULL)
- sym = solib_global_lookup (objfile, name, linkage_name, domain, symtab);
+ sym = solib_global_lookup (objfile, name, linkage_name, domain);
if (sym != NULL)
return sym;
- sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, linkage_name,
- domain, symtab);
+ sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, linkage_name, domain);
if (sym != NULL)
return sym;
- return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, linkage_name,
- domain, symtab);
+ return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, linkage_name, domain);
}
int
? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1))
{
sym_found = sym;
- if (SYMBOL_CLASS (sym) != LOC_ARG &&
- SYMBOL_CLASS (sym) != LOC_LOCAL_ARG &&
- SYMBOL_CLASS (sym) != LOC_REF_ARG &&
- SYMBOL_CLASS (sym) != LOC_REGPARM &&
- SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR &&
- SYMBOL_CLASS (sym) != LOC_BASEREG_ARG &&
- SYMBOL_CLASS (sym) != LOC_COMPUTED_ARG)
+ if (!SYMBOL_IS_ARGUMENT (sym))
{
break;
}
/* Recalculate the line number (might not be N+1). */
sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
}
+
+ /* On targets with executable formats that don't have a concept of
+ constructors (ELF with .init has, PE doesn't), gcc emits a call
+ to `__main' in `main' between the prologue and before user
+ code. */
+ if (funfirstline
+ && gdbarch_skip_main_prologue_p (current_gdbarch)
+ && SYMBOL_LINKAGE_NAME (sym)
+ && strcmp (SYMBOL_LINKAGE_NAME (sym), "main") == 0)
+ {
+ pc = gdbarch_skip_main_prologue (current_gdbarch, pc);
+ /* Recalculate the line number (might not be N+1). */
+ sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
+ }
+
sal.pc = pc;
return sal;
if (kind == FUNCTIONS_DOMAIN
|| lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
(struct block *) NULL,
- VAR_DOMAIN,
- 0, (struct symtab **) NULL)
+ VAR_DOMAIN, 0)
== NULL)
found_misc = 1;
}
{
/* Variables/Absolutes: Look up by name */
if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
- (struct block *) NULL, VAR_DOMAIN,
- 0, (struct symtab **) NULL) == NULL)
+ (struct block *) NULL, VAR_DOMAIN, 0)
+ == NULL)
{
/* match */
psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
projects / deliverable / binutils-gdb.git / blobdiff