const char *linkage_name,
const struct block *block,
const domain_enum domain,
+ enum language language,
int *is_a_field_of_this,
struct symtab **symtab);
struct symtab **symtab);
#endif
-/* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c.
- Signals the presence of objects compiled by HP compilers. */
-int deprecated_hp_som_som_object_present = 0;
-
static void fixup_section (struct general_symbol_info *, struct objfile *);
static int file_matches (char *, char **, int);
code). */
struct symbol *
-lookup_symbol (const char *name, const struct block *block,
- const domain_enum domain, int *is_a_field_of_this,
- struct symtab **symtab)
+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)
{
char *demangled_name = NULL;
const char *modified_name = NULL;
/* If we are using C++ or Java, demangle the name before doing a lookup, so
we can always binary search. */
- if (current_language->la_language == language_cplus)
+ if (lang == language_cplus)
{
demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
if (demangled_name)
needtofreename = 1;
}
}
- else if (current_language->la_language == language_java)
+ else if (lang == language_java)
{
demangled_name = cplus_demangle (name,
DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
}
returnval = lookup_symbol_aux (modified_name, mangled_name, block,
- domain, is_a_field_of_this, symtab);
+ domain, lang,
+ is_a_field_of_this, symtab);
if (needtofreename)
xfree (demangled_name);
return returnval;
}
-/* Behave like lookup_symbol_aux except that NAME is the natural name
+/* Behave like lookup_symbol_in_language, but performed with the
+ current language. */
+
+struct symbol *
+lookup_symbol (const char *name, const struct block *block,
+ domain_enum domain, int *is_a_field_of_this,
+ struct symtab **symtab)
+{
+ return lookup_symbol_in_language (name, block, domain,
+ current_language->la_language,
+ is_a_field_of_this, symtab);
+}
+
+/* Behave like lookup_symbol except that NAME is the natural name
of the symbol that we're looking for and, if LINKAGE_NAME is
non-NULL, ensure that the symbol's linkage name matches as
well. */
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)
{
struct symbol *sym;
+ const struct language_defn *langdef;
/* Make sure we do something sensible with is_a_field_of_this, since
the callers that set this parameter to some non-null value will
if (sym != NULL)
return sym;
- /* If requested to do so by the caller and if appropriate for the
- current language, check to see if NAME is a field of `this'. */
+ /* If requested to do so by the caller and if appropriate for LANGUAGE,
+ check to see if NAME is a field of `this'. */
+
+ langdef = language_def (language);
- if (current_language->la_value_of_this != NULL
+ if (langdef->la_value_of_this != NULL
&& is_a_field_of_this != NULL)
{
- struct value *v = current_language->la_value_of_this (0);
+ struct value *v = langdef->la_value_of_this (0);
if (v && check_field (v, name))
{
}
}
- /* Now do whatever is appropriate for the current language to look
+ /* Now do whatever is appropriate for LANGUAGE to look
up static and global variables. */
- sym = current_language->la_lookup_symbol_nonlocal (name, linkage_name,
- block, domain,
- symtab);
+ sym = langdef->la_lookup_symbol_nonlocal (name, linkage_name,
+ block, domain, symtab);
if (sym != NULL)
return sym;
{ /* skip "first line" of function (which is actually its prologue) */
asection *section = SYMBOL_BFD_SECTION (sym);
/* If function is in an unmapped overlay, use its unmapped LMA
- address, so that SKIP_PROLOGUE has something unique to work on */
+ address, so that gdbarch_skip_prologue has something unique to work
+ on */
if (section_is_overlay (section) &&
!section_is_mapped (section))
pc = overlay_unmapped_address (pc, section);
pc += DEPRECATED_FUNCTION_START_OFFSET;
- pc = SKIP_PROLOGUE (pc);
+ pc = gdbarch_skip_prologue (current_gdbarch, pc);
/* For overlays, map pc back into its mapped VMA range */
pc = overlay_mapped_address (pc, section);
}
sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
- /* Check if SKIP_PROLOGUE left us in mid-line, and the next
+ /* Check if gdbarch_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
|| lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
(struct block *) NULL,
VAR_DOMAIN,
- 0, (struct symtab **) NULL) == NULL)
+ 0, (struct symtab **) NULL)
+ == NULL)
found_misc = 1;
}
}
{
char *tmp;
- if (TARGET_ADDR_BIT <= 32)
+ if (gdbarch_addr_bit (current_gdbarch) <= 32)
tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
& (CORE_ADDR) 0xffffffff,
8);
- 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 SKIP_PROLOGUE function to analyze 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
if (! func_start)
return 1; /* We *might* be in a prologue. */
- prologue_end = SKIP_PROLOGUE (func_start);
+ prologue_end = gdbarch_skip_prologue (current_gdbarch, func_start);
return func_start <= pc && pc < prologue_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 = SKIP_PROLOGUE (func_addr);
+ CORE_ADDR prologue_end = gdbarch_skip_prologue
+ (current_gdbarch, func_addr);
return func_addr <= pc && pc < prologue_end;
}
/* 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)
+ if (prologue_sal.end >= end_pc)
return 0;
while (prologue_sal.end < end_pc)
{