* [PATCH 5/6] [PR 17684] add support for primitive types as symbols
@ 2014-12-18 12:29 Doug Evans
2015-08-27 13:53 ` Cell multi-arch type resolution broken (Re: [PATCH 5/6] [PR 17684] add support for primitive types as symbols) Ulrich Weigand
0 siblings, 1 reply; 5+ messages in thread
From: Doug Evans @ 2014-12-18 12:29 UTC (permalink / raw)
To: gdb-patches
Hi.
This patch is the main piece of the patch set.
It provides the infrastructure for looking up primitive types as symbols.
Regression tested on amd64-linux (as are the other patches
in this series).
2014-12-18 Doug Evans <xdje42@gmail.com>
* ada-lang.c (user_select_syms): Only fetch symtab if symbol is
objfile-owned.
(cache_symbol): Ignore symbols that are not objfile-owned.
* block.c (block_objfile): New function.
(block_gdbarch): New function.
* block.h (block_objfile): Declare.
(block_gdbarch): Declare.
* c-exp.y (classify_name): Remove call to
language_lookup_primitive_type. No longer necessary.
* gdbtypes.c (lookup_typename): Call lookup_symbol_in_language.
Remove call to language_lookup_primitive_type. No longer necessary.
* guile/scm-symbol.c (syscm_gdbarch_data_key): New static global.
(syscm_gdbarch_data): New struct.
(syscm_init_arch_symbols): New function.
(syscm_get_symbol_map): Renamed from syscm_objfile_symbol_map.
All callers updated. Handle symbols owned by arches.
(gdbscm_symbol_symtab): Handle symbols owned by arches.
(gdbscm_initialize_symbols): Initialize syscm_gdbarch_data_key.
* language.c (language_lookup_primitive_type_1): New function.
(language_lookup_primitive_type): Call it.
(language_alloc_type_symbol): New function.
(language_init_primitive_type_symbols): New function.
(language_lookup_primitive_type_as_symbol): New function.
* language.h (struct language_arch_info) <primitive_type_symbols>:
New member.
(language_lookup_primitive_type): Add function comment.
(language_lookup_primitive_type_as_symbol): Declare.
* printcmd.c (address_info): Handle arch-owned symbols.
* python/py-symbol.c (sympy_get_symtab): Ditto.
(set_symbol): Ditto.
(sympy_dealloc): Ditto.
* symmisc.c (print_symbol): Ditto.
* symtab.c (fixup_symbol_section): Ditto.
(lookup_symbol_aux): Initialize block_found.
(basic_lookup_symbol_nonlocal): Try looking up the symbol as a
primitive type.
(initialize_objfile_symbol_1): New function.
(initialize_objfile_symbol): Call it.
(allocate_symbol): Call it.
(allocate_template_symbol): Call it.
(symbol_objfile): Assert symbol is objfile-owned.
(symbol_arch, symbol_symtab, symbol_set_symtab): Ditto.
* symtab.h (struct symbol) <owner>: Replaces member "symtab".
(struct symbol) <is_objfile_owned>: New member.
(SYMBOL_OBJFILE_OWNED): New macro.
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 5d4ea2f..5d5d613 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -3716,7 +3716,10 @@ See set/show multiple-symbol."));
(SYMBOL_CLASS (syms[i].sym) == LOC_CONST
&& SYMBOL_TYPE (syms[i].sym) != NULL
&& TYPE_CODE (SYMBOL_TYPE (syms[i].sym)) == TYPE_CODE_ENUM);
- struct symtab *symtab = symbol_symtab (syms[i].sym);
+ struct symtab *symtab = NULL;
+
+ if (SYMBOL_OBJFILE_OWNED (syms[i].sym))
+ symtab = symbol_symtab (syms[i].sym);
if (SYMBOL_LINE (syms[i].sym) != 0 && symtab != NULL)
printf_unfiltered (_("[%d] %s at %s:%d\n"),
@@ -4466,6 +4469,11 @@ cache_symbol (const char *name, domain_enum namespace, struct symbol *sym,
char *copy;
struct cache_entry *e;
+ /* Symbols for builtin types don't have a block.
+ For now don't cache such symbols. */
+ if (sym != NULL && !SYMBOL_OBJFILE_OWNED (sym))
+ return;
+
/* If the symbol is a local symbol, then do not cache it, as a search
for that symbol depends on the context. To determine whether
the symbol is local or not, we check the block where we found it
diff --git a/gdb/block.c b/gdb/block.c
index e791c73..8d45b6e 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -25,6 +25,7 @@
#include "cp-support.h"
#include "addrmap.h"
#include "gdbtypes.h"
+#include "objfiles.h"
/* This is used by struct block to store namespace-related info for
C++ files, namely using declarations and the current namespace in
@@ -39,6 +40,31 @@ struct block_namespace_info
static void block_initialize_namespace (struct block *block,
struct obstack *obstack);
+/* See block.h. */
+
+struct objfile *
+block_objfile (const struct block *block)
+{
+ const struct global_block *global_block;
+
+ if (BLOCK_FUNCTION (block) != NULL)
+ return symbol_objfile (BLOCK_FUNCTION (block));
+
+ global_block = (struct global_block *) block_global_block (block);
+ return COMPUNIT_OBJFILE (global_block->compunit_symtab);
+}
+
+/* See block. */
+
+struct gdbarch *
+block_gdbarch (const struct block *block)
+{
+ if (BLOCK_FUNCTION (block) != NULL)
+ return symbol_arch (BLOCK_FUNCTION (block));
+
+ return get_objfile_arch (block_objfile (block));
+}
+
/* Return Nonzero if block a is lexically nested within block b,
or if a and b have the same pc range.
Return zero otherwise. */
diff --git a/gdb/block.h b/gdb/block.h
index 409a5c7..e6c5feb 100644
--- a/gdb/block.h
+++ b/gdb/block.h
@@ -136,6 +136,14 @@ struct blockvector
#define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
#define BLOCKVECTOR_MAP(blocklist) ((blocklist)->map)
+/* Return the objfile of BLOCK, which must be non-NULL. */
+
+extern struct objfile *block_objfile (const struct block *block);
+
+/* Return the architecture of BLOCK, which must be non-NULL. */
+
+extern struct gdbarch *block_gdbarch (const struct block *block);
+
extern struct symbol *block_linkage_function (const struct block *);
extern struct symbol *block_containing_function (const struct block *);
diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 707e504..91728ee 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -2941,13 +2941,6 @@ classify_name (struct parser_state *par_state, const struct block *block,
return TYPENAME;
}
- yylval.tsym.type
- = language_lookup_primitive_type (parse_language (par_state),
- parse_gdbarch (par_state),
- copy);
- if (yylval.tsym.type != NULL)
- return TYPENAME;
-
/* See if it's an ObjC classname. */
if (parse_language (par_state)->la_language == language_objc && !sym)
{
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 0048f6a..0297243 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -1306,14 +1306,11 @@ lookup_typename (const struct language_defn *language,
struct symbol *sym;
struct type *type;
- sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
+ sym = lookup_symbol_in_language (name, block, VAR_DOMAIN,
+ language->la_language, NULL);
if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
return SYMBOL_TYPE (sym);
- type = language_lookup_primitive_type (language, gdbarch, name);
- if (type)
- return type;
-
if (noerr)
return NULL;
error (_("No type named %s."), name);
diff --git a/gdb/guile/scm-symbol.c b/gdb/guile/scm-symbol.c
index 6a19648..a627f94 100644
--- a/gdb/guile/scm-symbol.c
+++ b/gdb/guile/scm-symbol.c
@@ -50,6 +50,13 @@ static SCM domain_keyword;
static SCM frame_keyword;
static const struct objfile_data *syscm_objfile_data_key;
+static struct gdbarch_data *syscm_gdbarch_data_key;
+
+struct syscm_gdbarch_data
+{
+ /* Hash table to implement eqable gdbarch symbols. */
+ htab_t htab;
+};
\f
/* Administrivia for symbol smobs. */
@@ -75,20 +82,44 @@ syscm_eq_symbol_smob (const void *ap, const void *bp)
&& a->symbol != NULL);
}
+static void *
+syscm_init_arch_symbols (struct gdbarch *gdbarch)
+{
+ struct syscm_gdbarch_data *data
+ = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct syscm_gdbarch_data);
+
+ data->htab = gdbscm_create_eqable_gsmob_ptr_map (syscm_hash_symbol_smob,
+ syscm_eq_symbol_smob);
+ return data;
+}
+
/* Return the struct symbol pointer -> SCM mapping table.
It is created if necessary. */
static htab_t
-syscm_objfile_symbol_map (struct symbol *symbol)
+syscm_get_symbol_map (struct symbol *symbol)
{
- struct objfile *objfile = symbol_objfile (symbol);
- htab_t htab = objfile_data (objfile, syscm_objfile_data_key);
+ htab_t htab;
- if (htab == NULL)
+ if (SYMBOL_OBJFILE_OWNED (symbol))
{
- htab = gdbscm_create_eqable_gsmob_ptr_map (syscm_hash_symbol_smob,
- syscm_eq_symbol_smob);
- set_objfile_data (objfile, syscm_objfile_data_key, htab);
+ struct objfile *objfile = symbol_objfile (symbol);
+
+ htab = objfile_data (objfile, syscm_objfile_data_key);
+ if (htab == NULL)
+ {
+ htab = gdbscm_create_eqable_gsmob_ptr_map (syscm_hash_symbol_smob,
+ syscm_eq_symbol_smob);
+ set_objfile_data (objfile, syscm_objfile_data_key, htab);
+ }
+ }
+ else
+ {
+ struct gdbarch *gdbarch = symbol_arch (symbol);
+ struct syscm_gdbarch_data *data = gdbarch_data (gdbarch,
+ syscm_gdbarch_data_key);
+
+ htab = data->htab;
}
return htab;
@@ -103,7 +134,7 @@ syscm_free_symbol_smob (SCM self)
if (s_smob->symbol != NULL)
{
- htab_t htab = syscm_objfile_symbol_map (s_smob->symbol);
+ htab_t htab = syscm_get_symbol_map (s_smob->symbol);
gdbscm_clear_eqable_gsmob_ptr_slot (htab, &s_smob->base);
}
@@ -181,7 +212,7 @@ syscm_scm_from_symbol (struct symbol *symbol)
/* If we've already created a gsmob for this symbol, return it.
This makes symbols eq?-able. */
- htab = syscm_objfile_symbol_map (symbol);
+ htab = syscm_get_symbol_map (symbol);
s_smob_for_lookup.symbol = symbol;
slot = gdbscm_find_eqable_gsmob_ptr_slot (htab, &s_smob_for_lookup.base);
if (*slot != NULL)
@@ -319,8 +350,9 @@ gdbscm_symbol_type (SCM self)
return tyscm_scm_from_type (SYMBOL_TYPE (symbol));
}
-/* (symbol-symtab <gdb:symbol>) -> <gdb:symtab>
- Return the symbol table of SELF. */
+/* (symbol-symtab <gdb:symbol>) -> <gdb:symtab> | #f
+ Return the symbol table of SELF.
+ If SELF does not have a symtab (it is arch-owned) return #f. */
static SCM
gdbscm_symbol_symtab (SCM self)
@@ -329,6 +361,8 @@ gdbscm_symbol_symtab (SCM self)
= syscm_get_valid_symbol_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
const struct symbol *symbol = s_smob->symbol;
+ if (!SYMBOL_OBJFILE_OWNED (symbol))
+ return SCM_BOOL_F;
return stscm_scm_from_symtab (symbol_symtab (symbol));
}
@@ -761,4 +795,8 @@ gdbscm_initialize_symbols (void)
invalidate symbols when an object file is about to be deleted. */
syscm_objfile_data_key
= register_objfile_data_with_cleanup (NULL, syscm_del_objfile_symbols);
+
+ /* Arch-specific symbol data. */
+ syscm_gdbarch_data_key
+ = gdbarch_data_register_post_init (syscm_init_arch_symbols);
}
diff --git a/gdb/language.c b/gdb/language.c
index df45ddd..fa43857 100644
--- a/gdb/language.c
+++ b/gdb/language.c
@@ -987,6 +987,24 @@ language_bool_type (const struct language_defn *la,
return ld->arch_info[la->la_language].bool_type_default;
}
+/* Helper function for primitive type lookup. */
+
+static struct type **
+language_lookup_primitive_type_1 (const struct language_arch_info *lai,
+ const char *name)
+{
+ struct type **p;
+
+ for (p = lai->primitive_type_vector; (*p) != NULL; p++)
+ {
+ if (strcmp (TYPE_NAME (*p), name) == 0)
+ return p;
+ }
+ return NULL;
+}
+
+/* See language.h. */
+
struct type *
language_lookup_primitive_type (const struct language_defn *la,
struct gdbarch *gdbarch,
@@ -994,33 +1012,113 @@ language_lookup_primitive_type (const struct language_defn *la,
{
struct language_gdbarch *ld = gdbarch_data (gdbarch,
language_gdbarch_data);
- struct type *const *p;
+ struct type **typep;
+
+ typep = language_lookup_primitive_type_1 (&ld->arch_info[la->la_language],
+ name);
+ if (typep == NULL)
+ return NULL;
+ return *typep;
+}
+
+/* Helper function for type lookup as a symbol.
+ Create the symbol corresponding to type TYPE in language LANG. */
+
+static struct symbol *
+language_alloc_type_symbol (enum language lang, struct type *type)
+{
+ struct symbol *symbol;
+ struct gdbarch *gdbarch;
+
+ gdb_assert (!TYPE_OBJFILE_OWNED (type));
+
+ gdbarch = TYPE_OWNER (type).gdbarch;
+ symbol = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct symbol);
+
+ symbol->ginfo.name = TYPE_NAME (type);
+ symbol->ginfo.language = lang;
+ symbol->owner.arch = gdbarch;
+ SYMBOL_OBJFILE_OWNED (symbol) = 0;
+ SYMBOL_TYPE (symbol) = type;
+ SYMBOL_DOMAIN (symbol) = VAR_DOMAIN;
+ SYMBOL_ACLASS_INDEX (symbol) = LOC_TYPEDEF;
+
+ return symbol;
+}
+
+/* Initialize the primitive type symbols of language LD.
+ The primitive type vector must have already been initialized. */
+
+static void
+language_init_primitive_type_symbols (struct language_arch_info *lai,
+ const struct language_defn *la,
+ struct gdbarch *gdbarch)
+{
+ int n;
+ struct compunit_symtab *cust;
+ struct symtab *symtab;
+ struct block *static_block, *global_block;
+
+ gdb_assert (lai->primitive_type_vector != NULL);
+
+ for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
+ continue;
+
+ lai->primitive_type_symbols
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, n + 1, struct symbol *);
+
+ for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
+ {
+ lai->primitive_type_symbols[n]
+ = language_alloc_type_symbol (la->la_language,
+ lai->primitive_type_vector[n]);
+ }
+
+ /* Note: The result of symbol lookup is normally a symbol *and* the block
+ it was found in (returned in global block_found). Builtin types don't
+ live in blocks. We *could* give them one, but there is no current need
+ so to keep things simple symbol lookup is extended to allow for
+ BLOCK_FOUND to be NULL. */
+}
+
+/* See language.h. */
+
+struct symbol *
+language_lookup_primitive_type_as_symbol (const struct language_defn *la,
+ struct gdbarch *gdbarch,
+ const char *name)
+{
+ struct language_gdbarch *ld = gdbarch_data (gdbarch,
+ language_gdbarch_data);
+ struct language_arch_info *lai = &ld->arch_info[la->la_language];
+ struct type **typep;
+ struct symbol *sym;
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog,
- "language_lookup_primitive_type (%s, %s, %s)",
+ "language_lookup_primitive_type_as_symbol"
+ " (%s, %s, %s)",
la->la_name, host_address_to_string (gdbarch), name);
}
- for (p = ld->arch_info[la->la_language].primitive_type_vector;
- (*p) != NULL;
- p++)
+ typep = language_lookup_primitive_type_1 (lai, name);
+ if (typep == NULL)
{
- if (strcmp (TYPE_NAME (*p), name) == 0)
- {
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog, " = %s\n",
- host_address_to_string (*p));
- }
- return (*p);
- }
+ if (symbol_lookup_debug)
+ fprintf_unfiltered (gdb_stdlog, " = NULL\n");
+ return NULL;
}
+ /* The set of symbols is lazily initialized. */
+ if (lai->primitive_type_symbols == NULL)
+ language_init_primitive_type_symbols (lai, la, gdbarch);
+
+ sym = lai->primitive_type_symbols[typep - lai->primitive_type_vector];
+
if (symbol_lookup_debug)
- fprintf_unfiltered (gdb_stdlog, " = NULL\n");
- return (NULL);
+ fprintf_unfiltered (gdb_stdlog, " = %s\n", host_address_to_string (sym));
+ return sym;
}
/* Initialize the language routines. */
diff --git a/gdb/language.h b/gdb/language.h
index 2a47e64..1103fe9 100644
--- a/gdb/language.h
+++ b/gdb/language.h
@@ -111,6 +111,11 @@ struct language_arch_info
expressions, regardless of whether the program being debugged
actually defines such a type. */
struct type **primitive_type_vector;
+
+ /* Symbol wrappers around primitive_type_vector, so that the symbol lookup
+ machinery can return them. */
+ struct symbol **primitive_type_symbols;
+
/* Type of elements of strings. */
struct type *string_char_type;
@@ -436,10 +441,21 @@ struct type *language_bool_type (const struct language_defn *l,
struct type *language_string_char_type (const struct language_defn *l,
struct gdbarch *gdbarch);
+/* Look up type NAME in language L, and return its definition for architecture
+ GDBARCH. Returns NULL if not found. */
+
struct type *language_lookup_primitive_type (const struct language_defn *l,
struct gdbarch *gdbarch,
const char *name);
+/* Wrapper around language_lookup_primitive_type to return the
+ corresponding symbol. */
+
+struct symbol *
+ language_lookup_primitive_type_as_symbol (const struct language_defn *l,
+ struct gdbarch *gdbarch,
+ const char *name);
+
\f
/* These macros define the behaviour of the expression
evaluator. */
diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index 58b7ac0..020a47c 100644
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -1251,7 +1251,10 @@ address_info (char *exp, int from_tty)
current_language->la_language, DMGL_ANSI);
printf_filtered ("\" is ");
val = SYMBOL_VALUE (sym);
- section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
+ if (SYMBOL_OBJFILE_OWNED (sym))
+ section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
+ else
+ section = NULL;
gdbarch = symbol_arch (sym);
if (SYMBOL_COMPUTED_OPS (sym) != NULL)
diff --git a/gdb/python/py-symbol.c b/gdb/python/py-symbol.c
index 62fde64..fdff53f 100644
--- a/gdb/python/py-symbol.c
+++ b/gdb/python/py-symbol.c
@@ -87,6 +87,9 @@ sympy_get_symtab (PyObject *self, void *closure)
SYMPY_REQUIRE_VALID (self, symbol);
+ if (!SYMBOL_OBJFILE_OWNED (symbol))
+ Py_RETURN_NONE;
+
return symtab_to_symtab_object (symbol_symtab (symbol));
}
@@ -290,7 +293,8 @@ set_symbol (symbol_object *obj, struct symbol *symbol)
{
obj->symbol = symbol;
obj->prev = NULL;
- if (symbol_symtab (symbol) != NULL)
+ if (SYMBOL_OBJFILE_OWNED (symbol)
+ && symbol_symtab (symbol) != NULL)
{
struct objfile *objfile = symbol_objfile (symbol);
@@ -334,6 +338,7 @@ sympy_dealloc (PyObject *obj)
if (sym_obj->prev)
sym_obj->prev->next = sym_obj->next;
else if (sym_obj->symbol != NULL
+ && SYMBOL_OBJFILE_OWNED (sym_obj->symbol)
&& symbol_symtab (sym_obj->symbol) != NULL)
{
set_objfile_data (symbol_objfile (sym_obj->symbol),
diff --git a/gdb/symmisc.c b/gdb/symmisc.c
index 3b6639d..9ae0847 100644
--- a/gdb/symmisc.c
+++ b/gdb/symmisc.c
@@ -466,8 +466,12 @@ print_symbol (void *args)
struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
int depth = ((struct print_symbol_args *) args)->depth;
struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
- struct obj_section *section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol),
- symbol);
+ struct obj_section *section;
+
+ if (SYMBOL_OBJFILE_OWNED (symbol))
+ section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol), symbol);
+ else
+ section = NULL;
print_spaces (depth, outfile);
if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
diff --git a/gdb/symtab.c b/gdb/symtab.c
index e7cd5af..0efd9d2 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1150,6 +1150,9 @@ fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
if (!sym)
return NULL;
+ if (!SYMBOL_OBJFILE_OWNED (sym))
+ return sym;
+
/* We either have an OBJFILE, or we can get at it from the sym's
symtab. Anything else is a bug. */
gdb_assert (objfile || symbol_symtab (sym));
@@ -1421,6 +1424,13 @@ lookup_symbol_aux (const char *name, const struct block *block,
domain_name (domain), language_str (language));
}
+ /* Initialize block_found so that the language la_lookup_symbol_nonlocal
+ routines don't have to set it (to NULL) if a primitive type is found.
+ We do this early so that block_found is also NULL if no symbol is
+ found (though this is not part of the API, and callers cannot assume
+ this). */
+ block_found = NULL;
+
/* 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
certainly use it later. If we don't set it, the contents of
@@ -1848,6 +1858,25 @@ basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
if (sym != NULL)
return sym;
+ /* If we didn't find a definition for a builtin type in the static block,
+ search for it now. This is actually the right thing to do and can be
+ a massive performance win. E.g., when debugging a program with lots of
+ shared libraries we could search all of them only to find out the
+ builtin type isn't defined in any of them. This is common for types
+ like "void". */
+ if (domain == VAR_DOMAIN)
+ {
+ struct gdbarch *gdbarch;
+
+ if (block == NULL)
+ gdbarch = target_gdbarch ();
+ else
+ gdbarch = block_gdbarch (block);
+ sym = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
+ if (sym != NULL)
+ return sym;
+ }
+
return lookup_global_symbol (name, block, domain);
}
@@ -5313,13 +5342,23 @@ initialize_ordinary_address_classes (void)
\f
-/* Initialize the symbol SYM. */
+/* Helper function to initialize the fields of an objfile-owned symbol.
+ It assumed that *SYM is already all zeroes. */
+
+static void
+initialize_objfile_symbol_1 (struct symbol *sym)
+{
+ SYMBOL_OBJFILE_OWNED (sym) = 1;
+ SYMBOL_SECTION (sym) = -1;
+}
+
+/* Initialize the symbol SYM, and mark it as being owned by an objfile. */
void
initialize_objfile_symbol (struct symbol *sym)
{
memset (sym, 0, sizeof (*sym));
- SYMBOL_SECTION (sym) = -1;
+ initialize_objfile_symbol_1 (sym);
}
/* Allocate and initialize a new 'struct symbol' on OBJFILE's
@@ -5331,7 +5370,7 @@ allocate_symbol (struct objfile *objfile)
struct symbol *result;
result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
- SYMBOL_SECTION (result) = -1;
+ initialize_objfile_symbol_1 (result);
return result;
}
@@ -5345,7 +5384,7 @@ allocate_template_symbol (struct objfile *objfile)
struct template_symbol *result;
result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct template_symbol);
- SYMBOL_SECTION (&result->base) = -1;
+ initialize_objfile_symbol_1 (&result->base);
return result;
}
@@ -5355,7 +5394,8 @@ allocate_template_symbol (struct objfile *objfile)
struct objfile *
symbol_objfile (const struct symbol *symbol)
{
- return SYMTAB_OBJFILE (symbol->symtab);
+ gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
+ return SYMTAB_OBJFILE (symbol->owner.symtab);
}
/* See symtab.h. */
@@ -5363,7 +5403,9 @@ symbol_objfile (const struct symbol *symbol)
struct gdbarch *
symbol_arch (const struct symbol *symbol)
{
- return get_objfile_arch (symbol_objfile (symbol));
+ if (!SYMBOL_OBJFILE_OWNED (symbol))
+ return symbol->owner.arch;
+ return get_objfile_arch (SYMTAB_OBJFILE (symbol->owner.symtab));
}
/* See symtab.h. */
@@ -5371,7 +5413,8 @@ symbol_arch (const struct symbol *symbol)
struct symtab *
symbol_symtab (const struct symbol *symbol)
{
- return symbol->symtab;
+ gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
+ return symbol->owner.symtab;
}
/* See symtab.h. */
@@ -5379,7 +5422,8 @@ symbol_symtab (const struct symbol *symbol)
void
symbol_set_symtab (struct symbol *symbol, struct symtab *symtab)
{
- symbol->symtab = symtab;
+ gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
+ symbol->owner.symtab = symtab;
}
\f
diff --git a/gdb/symtab.h b/gdb/symtab.h
index b3a9a6b..3f645b1 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -711,10 +711,19 @@ struct symbol
struct type *type;
- /* The symbol table containing this symbol. This is the file
- associated with LINE. It can be NULL during symbols read-in but it is
- never NULL during normal operation. */
- struct symtab *symtab;
+ /* The owner of this symbol.
+ Which one to use is defined by symbol.is_arch_owned. */
+
+ union
+ {
+ /* The symbol table containing this symbol. This is the file associated
+ with LINE. It can be NULL during symbols read-in but it is never NULL
+ during normal operation. */
+ struct symtab *symtab;
+
+ /* For types defined by the architecture. */
+ struct gdbarch *arch;
+ } owner;
/* Domain code. */
@@ -726,6 +735,11 @@ struct symbol
unsigned int aclass_index : SYMBOL_ACLASS_BITS;
+ /* If non-zero then symbol is objfile-owned, use owner.symtab.
+ Otherwise symbol is arch-owned, use owner.arch. */
+
+ unsigned int is_objfile_owned : 1;
+
/* Whether this is an argument. */
unsigned is_argument : 1;
@@ -742,6 +756,7 @@ struct symbol
SYMBOL_INLINED set) this is the line number of the function's call
site. Inlined function symbols are not definitions, and they are
never found by symbol table lookup.
+ If this symbol is arch-owned, LINE shall be zero.
FIXME: Should we really make the assumption that nobody will try
to debug files longer than 64K lines? What about machine
@@ -769,10 +784,14 @@ struct symbol
extern const struct symbol_impl *symbol_impls;
+/* Note: There is no accessor macro for symbol.owner because it is
+ "private". */
+
#define SYMBOL_DOMAIN(symbol) (symbol)->domain
#define SYMBOL_IMPL(symbol) (symbol_impls[(symbol)->aclass_index])
#define SYMBOL_ACLASS_INDEX(symbol) (symbol)->aclass_index
#define SYMBOL_CLASS(symbol) (SYMBOL_IMPL (symbol).aclass)
+#define SYMBOL_OBJFILE_OWNED(symbol) ((symbol)->is_objfile_owned)
#define SYMBOL_IS_ARGUMENT(symbol) (symbol)->is_argument
#define SYMBOL_INLINED(symbol) (symbol)->is_inlined
#define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
^ permalink raw reply [flat|nested] 5+ messages in thread
* Cell multi-arch type resolution broken (Re: [PATCH 5/6] [PR 17684] add support for primitive types as symbols)
2014-12-18 12:29 [PATCH 5/6] [PR 17684] add support for primitive types as symbols Doug Evans
@ 2015-08-27 13:53 ` Ulrich Weigand
2015-08-30 21:04 ` Doug Evans
0 siblings, 1 reply; 5+ messages in thread
From: Ulrich Weigand @ 2015-08-27 13:53 UTC (permalink / raw)
To: Doug Evans; +Cc: gdb-patches
Doug Evans wrote:
> 2014-12-18 Doug Evans <xdje42@gmail.com>
>
> * gdbtypes.c (lookup_typename): Call lookup_symbol_in_language.
> Remove call to language_lookup_primitive_type. No longer necessary.
> (basic_lookup_symbol_nonlocal): Try looking up the symbol as a
> primitive type.
This seems to have broken per-architecture primitive type resolution for
Cell multi-arch debugging. The problem here is that some primitive types
have different properties on SPU than on PowerPC, and so you want e.g.
print sizeof (long double)
to print 16 while in a PowerPC frame, but print 8 in a SPU frame.
This used to be triggered by the explicit gdbarch argument that was passed
to the language_typename routine (and related). But after your patch, that
routine is either no longer called at all, and even where it is, its
gdbarch argument to language_typename is now simply ignored.
Instead, we have this code in symtab.c:basic_lookup_symbol_nonlocal:
> + /* If we didn't find a definition for a builtin type in the static block,
> + search for it now. This is actually the right thing to do and can be
> + a massive performance win. E.g., when debugging a program with lots of
> + shared libraries we could search all of them only to find out the
> + builtin type isn't defined in any of them. This is common for types
> + like "void". */
> + if (domain == VAR_DOMAIN)
> + {
> + struct gdbarch *gdbarch;
> +
> + if (block == NULL)
> + gdbarch = target_gdbarch ();
> + else
> + gdbarch = block_gdbarch (block);
> + sym = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
> + if (sym != NULL)
> + return sym;
> + }
which just uses target_gdbarch. This is wrong just about always in symbol-
related code, and on Cell multi-arch debugging it in effect always uses the
PowerPC architecture even while in a SPU frame.
Note that while sometime the block architecture is used, this doesn't really
help here, since lookup_typename is nearly always called with a NULL block.
As a quick fix to get Cell going again, the appended patch works for me
(by using get_current_arch () instead of target_gdbarch ()). But this
isn't a real fix either. I guess we should either:
- Pass the intended target architecture alongside the intended language
throughout the symbol resolution stack, or ...
- Make sure we always have a current block when calling lookup_typename
(Note that latter still isn't quite the same: e.g. when debugging code
without debug info, or code outside any objfile, we can never have a
current block; but we can still have a proper architecture detected
at runtime for the current frame.)
Any thoughts on this?
Bye,
Ulrich
Index: binutils-gdb/gdb/ada-lang.c
===================================================================
--- binutils-gdb.orig/gdb/ada-lang.c
+++ binutils-gdb/gdb/ada-lang.c
@@ -5792,10 +5792,11 @@ ada_lookup_symbol_nonlocal (const struct
if (domain == VAR_DOMAIN)
{
+ /* FIXME: gdbarch should be passed by the caller. */
struct gdbarch *gdbarch;
if (block == NULL)
- gdbarch = target_gdbarch ();
+ gdbarch = get_current_arch ();
else
gdbarch = block_gdbarch (block);
sym.symbol = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
Index: binutils-gdb/gdb/symtab.c
===================================================================
--- binutils-gdb.orig/gdb/symtab.c
+++ binutils-gdb/gdb/symtab.c
@@ -41,6 +41,7 @@
#include "p-lang.h"
#include "addrmap.h"
#include "cli/cli-utils.h"
+#include "arch-utils.h"
#include "hashtab.h"
@@ -2531,10 +2532,11 @@ basic_lookup_symbol_nonlocal (const stru
like "void". */
if (domain == VAR_DOMAIN)
{
+ /* FIXME: gdbarch should be passed by the caller. */
struct gdbarch *gdbarch;
if (block == NULL)
- gdbarch = target_gdbarch ();
+ gdbarch = get_current_arch ();
else
gdbarch = block_gdbarch (block);
result.symbol = language_lookup_primitive_type_as_symbol (langdef,
--
Dr. Ulrich Weigand
GNU/Linux compilers and toolchain
Ulrich.Weigand@de.ibm.com
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: Cell multi-arch type resolution broken (Re: [PATCH 5/6] [PR 17684] add support for primitive types as symbols)
2015-08-27 13:53 ` Cell multi-arch type resolution broken (Re: [PATCH 5/6] [PR 17684] add support for primitive types as symbols) Ulrich Weigand
@ 2015-08-30 21:04 ` Doug Evans
2015-08-31 4:17 ` Doug Evans
0 siblings, 1 reply; 5+ messages in thread
From: Doug Evans @ 2015-08-30 21:04 UTC (permalink / raw)
To: Ulrich Weigand; +Cc: gdb-patches
"Ulrich Weigand" <uweigand@de.ibm.com> writes:
> Doug Evans wrote:
>
>> 2014-12-18 Doug Evans <xdje42@gmail.com>
>>
>> * gdbtypes.c (lookup_typename): Call lookup_symbol_in_language.
>> Remove call to language_lookup_primitive_type. No longer necessary.
>
>> (basic_lookup_symbol_nonlocal): Try looking up the symbol as a
>> primitive type.
>
> This seems to have broken per-architecture primitive type resolution for
> Cell multi-arch debugging. The problem here is that some primitive types
> have different properties on SPU than on PowerPC, and so you want e.g.
> print sizeof (long double)
> to print 16 while in a PowerPC frame, but print 8 in a SPU frame.
>
> This used to be triggered by the explicit gdbarch argument that was passed
> to the language_typename routine (and related). But after your patch, that
> routine is either no longer called at all, and even where it is, its
> gdbarch argument to language_typename is now simply ignored.
>
> Instead, we have this code in symtab.c:basic_lookup_symbol_nonlocal:
>
>> + /* If we didn't find a definition for a builtin type in the static block,
>> + search for it now. This is actually the right thing to do and can be
>> + a massive performance win. E.g., when debugging a program with lots of
>> + shared libraries we could search all of them only to find out the
>> + builtin type isn't defined in any of them. This is common for types
>> + like "void". */
>> + if (domain == VAR_DOMAIN)
>> + {
>> + struct gdbarch *gdbarch;
>> +
>> + if (block == NULL)
>> + gdbarch = target_gdbarch ();
>> + else
>> + gdbarch = block_gdbarch (block);
>> + sym = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
>> + if (sym != NULL)
>> + return sym;
>> + }
>
> which just uses target_gdbarch. This is wrong just about always in symbol-
> related code, and on Cell multi-arch debugging it in effect always uses the
> PowerPC architecture even while in a SPU frame.
>
> Note that while sometime the block architecture is used, this doesn't really
> help here, since lookup_typename is nearly always called with a NULL block.
>
> As a quick fix to get Cell going again, the appended patch works for me
> (by using get_current_arch () instead of target_gdbarch ()). But this
> isn't a real fix either. I guess we should either:
>
> - Pass the intended target architecture alongside the intended language
> throughout the symbol resolution stack, or ...
>
> - Make sure we always have a current block when calling lookup_typename
>
> (Note that latter still isn't quite the same: e.g. when debugging code
> without debug info, or code outside any objfile, we can never have a
> current block; but we can still have a proper architecture detected
> at runtime for the current frame.)
>
> Any thoughts on this?
I'd be ok with adding a gdbarch parameter to lookup_symbol,
and require at least one of block or gdbarch to be non-NULL.
The symbol lookup code is a lot simpler when block == NULL,
and handling all the different cases in one set of functions
makes things more complex than they could otherwise be.
One might then split things up into two paths underneath
(one for block, one for arch).
> Index: binutils-gdb/gdb/ada-lang.c
> ===================================================================
> --- binutils-gdb.orig/gdb/ada-lang.c
> +++ binutils-gdb/gdb/ada-lang.c
> @@ -5792,10 +5792,11 @@ ada_lookup_symbol_nonlocal (const struct
>
> if (domain == VAR_DOMAIN)
> {
> + /* FIXME: gdbarch should be passed by the caller. */
> struct gdbarch *gdbarch;
>
> if (block == NULL)
> - gdbarch = target_gdbarch ();
> + gdbarch = get_current_arch ();
> else
> gdbarch = block_gdbarch (block);
> sym.symbol = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
> Index: binutils-gdb/gdb/symtab.c
> ===================================================================
> --- binutils-gdb.orig/gdb/symtab.c
> +++ binutils-gdb/gdb/symtab.c
> @@ -41,6 +41,7 @@
> #include "p-lang.h"
> #include "addrmap.h"
> #include "cli/cli-utils.h"
> +#include "arch-utils.h"
>
> #include "hashtab.h"
>
> @@ -2531,10 +2532,11 @@ basic_lookup_symbol_nonlocal (const stru
> like "void". */
> if (domain == VAR_DOMAIN)
> {
> + /* FIXME: gdbarch should be passed by the caller. */
> struct gdbarch *gdbarch;
>
> if (block == NULL)
> - gdbarch = target_gdbarch ();
> + gdbarch = get_current_arch ();
> else
> gdbarch = block_gdbarch (block);
> result.symbol = language_lookup_primitive_type_as_symbol (langdef,
LGTM.
Thanks.
I ran the perf testsuite on this just as a sanity check,
and didn't find anything.
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: Cell multi-arch type resolution broken (Re: [PATCH 5/6] [PR 17684] add support for primitive types as symbols)
2015-08-30 21:04 ` Doug Evans
@ 2015-08-31 4:17 ` Doug Evans
2015-08-31 13:55 ` Ulrich Weigand
0 siblings, 1 reply; 5+ messages in thread
From: Doug Evans @ 2015-08-31 4:17 UTC (permalink / raw)
To: Ulrich Weigand; +Cc: gdb-patches
Doug Evans <xdje42@gmail.com> writes:
> "Ulrich Weigand" <uweigand@de.ibm.com> writes:
>> Doug Evans wrote:
>>
>>> 2014-12-18 Doug Evans <xdje42@gmail.com>
>>>
>>> * gdbtypes.c (lookup_typename): Call lookup_symbol_in_language.
>>> Remove call to language_lookup_primitive_type. No longer necessary.
>>
>>> (basic_lookup_symbol_nonlocal): Try looking up the symbol as a
>>> primitive type.
>>
>> This seems to have broken per-architecture primitive type resolution for
>> Cell multi-arch debugging. The problem here is that some primitive types
>> have different properties on SPU than on PowerPC, and so you want e.g.
>> print sizeof (long double)
>> to print 16 while in a PowerPC frame, but print 8 in a SPU frame.
>>
>> This used to be triggered by the explicit gdbarch argument that was passed
>> to the language_typename routine (and related). But after your patch, that
>> routine is either no longer called at all, and even where it is, its
>> gdbarch argument to language_typename is now simply ignored.
>>
>> Instead, we have this code in symtab.c:basic_lookup_symbol_nonlocal:
>>
>>> + /* If we didn't find a definition for a builtin type in the static block,
>>> + search for it now. This is actually the right thing to do and can be
>>> + a massive performance win. E.g., when debugging a program with lots of
>>> + shared libraries we could search all of them only to find out the
>>> + builtin type isn't defined in any of them. This is common for types
>>> + like "void". */
>>> + if (domain == VAR_DOMAIN)
>>> + {
>>> + struct gdbarch *gdbarch;
>>> +
>>> + if (block == NULL)
>>> + gdbarch = target_gdbarch ();
>>> + else
>>> + gdbarch = block_gdbarch (block);
>>> + sym = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
>>> + if (sym != NULL)
>>> + return sym;
>>> + }
>>
>> which just uses target_gdbarch. This is wrong just about always in symbol-
>> related code, and on Cell multi-arch debugging it in effect always uses the
>> PowerPC architecture even while in a SPU frame.
>>
>> Note that while sometime the block architecture is used, this doesn't really
>> help here, since lookup_typename is nearly always called with a NULL block.
>>
>> As a quick fix to get Cell going again, the appended patch works for me
>> (by using get_current_arch () instead of target_gdbarch ()). But this
>> isn't a real fix either. I guess we should either:
>>
>> - Pass the intended target architecture alongside the intended language
>> throughout the symbol resolution stack, or ...
>>
>> - Make sure we always have a current block when calling lookup_typename
>>
>> (Note that latter still isn't quite the same: e.g. when debugging code
>> without debug info, or code outside any objfile, we can never have a
>> current block; but we can still have a proper architecture detected
>> at runtime for the current frame.)
>>
>> Any thoughts on this?
>
> I'd be ok with adding a gdbarch parameter to lookup_symbol,
> and require at least one of block or gdbarch to be non-NULL.
>
> The symbol lookup code is a lot simpler when block == NULL,
> and handling all the different cases in one set of functions
> makes things more complex than they could otherwise be.
> One might then split things up into two paths underneath
> (one for block, one for arch).
I went through and played with adding gdbarch to the
symbol lookup routines. I pushed into some places that I didn't
I need to, just to see the effect.
I'll clean this up and resubmit in a bit.
This patch also allows block == NULL and gdbarch == NULL
in the call to lookup_symbol. Sometimes the caller doesn't have either
one and doesn't need either one. I'd prefer something else though:
It'd be cleaner to remove the choice and require the caller to use
routines that are more explicit.
Otherwise I suspect a subtle bug or two will creep in.
[IOW, if the lookup may be for an arch-specific symbol (e.g., primitive type)
then require the caller to use a routine that requires a non-NULL gdbarch.
Internal to symtab.c we can do whatever we want though.]
This patch also adds some const-correctness to gdbarch.*.
[It'll get split out of course.]
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 7e6b6dc..8629984 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -4609,10 +4609,12 @@ standard_lookup (const char *name, const struct block *block,
{
/* Initialize it just to avoid a GCC false warning. */
struct block_symbol sym = {NULL, NULL};
+ const struct gdbarch *gdbarch = get_current_arch ();
if (lookup_cached_symbol (name, domain, &sym.symbol, NULL))
return sym.symbol;
- sym = lookup_symbol_in_language (name, block, domain, language_c, 0);
+ sym = lookup_symbol_in_language (name, block, gdbarch, domain, language_c,
+ NULL);
cache_symbol (name, domain, sym.symbol, sym.block);
return sym.symbol;
}
@@ -5770,6 +5772,7 @@ static struct block_symbol
ada_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *name,
const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain)
{
struct block_symbol sym;
@@ -5790,15 +5793,17 @@ ada_lookup_symbol_nonlocal (const struct language_defn *langdef,
languages, we search the primitive types this late and only after
having searched the global symbols without success. */
- if (domain == VAR_DOMAIN)
+ if (domain == VAR_DOMAIN
+ && (block != NULL || gdbarch != NULL))
{
- struct gdbarch *gdbarch;
+ const struct gdbarch *gdbarch_for_lookup;
- if (block == NULL)
- gdbarch = target_gdbarch ();
+ if (block != NULL)
+ gdbarch_for_lookup = block_gdbarch (block);
else
- gdbarch = block_gdbarch (block);
- sym.symbol = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
+ gdbarch_for_lookup = gdbarch;
+ sym.symbol = language_lookup_primitive_type_as_symbol
+ (langdef, gdbarch_for_lookup, name);
if (sym.symbol != NULL)
return sym;
}
diff --git a/gdb/ada-tasks.c b/gdb/ada-tasks.c
index c97057e..e6f64bc 100644
--- a/gdb/ada-tasks.c
+++ b/gdb/ada-tasks.c
@@ -458,6 +458,7 @@ get_tcb_types_info (void)
struct type *call_type;
struct atcb_fieldnos fieldnos;
struct ada_tasks_pspace_data *pspace_data;
+ const struct gdbarch *gdbarch = target_gdbarch ();
const char *atcb_name = "system__tasking__ada_task_control_block___XVE";
const char *atcb_name_fixed = "system__tasking__ada_task_control_block";
@@ -470,23 +471,23 @@ get_tcb_types_info (void)
C-like) lookups to get the first match. */
struct symbol *atcb_sym =
- lookup_symbol_in_language (atcb_name, NULL, STRUCT_DOMAIN,
- language_c, NULL).symbol;
+ lookup_symbol_in_language (atcb_name, NULL, gdbarch,
+ STRUCT_DOMAIN, language_c, NULL).symbol;
const struct symbol *common_atcb_sym =
- lookup_symbol_in_language (common_atcb_name, NULL, STRUCT_DOMAIN,
- language_c, NULL).symbol;
+ lookup_symbol_in_language (common_atcb_name, NULL, gdbarch,
+ STRUCT_DOMAIN, language_c, NULL).symbol;
const struct symbol *private_data_sym =
- lookup_symbol_in_language (private_data_name, NULL, STRUCT_DOMAIN,
- language_c, NULL).symbol;
+ lookup_symbol_in_language (private_data_name, NULL, gdbarch,
+ STRUCT_DOMAIN, language_c, NULL).symbol;
const struct symbol *entry_call_record_sym =
- lookup_symbol_in_language (entry_call_record_name, NULL, STRUCT_DOMAIN,
- language_c, NULL).symbol;
+ lookup_symbol_in_language (entry_call_record_name, NULL, gdbarch,
+ STRUCT_DOMAIN, language_c, NULL).symbol;
if (atcb_sym == NULL || atcb_sym->type == NULL)
{
/* In Ravenscar run-time libs, the ATCB does not have a dynamic
size, so the symbol name differs. */
- atcb_sym = lookup_symbol_in_language (atcb_name_fixed, NULL,
+ atcb_sym = lookup_symbol_in_language (atcb_name_fixed, NULL, gdbarch,
STRUCT_DOMAIN, language_c,
NULL).symbol;
@@ -863,8 +864,9 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
data->known_tasks_addr = BMSYMBOL_VALUE_ADDRESS (msym);
/* Try to get pointer type and array length from the symtab. */
- sym = lookup_symbol_in_language (KNOWN_TASKS_NAME, NULL, VAR_DOMAIN,
- language_c, NULL).symbol;
+ sym = lookup_symbol_in_language (KNOWN_TASKS_NAME, NULL,
+ get_objfile_arch (msym.objfile),
+ VAR_DOMAIN, language_c, NULL).symbol;
if (sym != NULL)
{
/* Validate. */
@@ -908,8 +910,9 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
data->known_tasks_addr = BMSYMBOL_VALUE_ADDRESS (msym);
data->known_tasks_length = 1;
- sym = lookup_symbol_in_language (KNOWN_TASKS_LIST, NULL, VAR_DOMAIN,
- language_c, NULL).symbol;
+ sym = lookup_symbol_in_language (KNOWN_TASKS_LIST, NULL,
+ get_objfile_arch (msym.objfile),
+ VAR_DOMAIN, language_c, NULL).symbol;
if (sym != NULL && SYMBOL_VALUE_ADDRESS (sym) != 0)
{
/* Validate. */
diff --git a/gdb/alpha-mdebug-tdep.c b/gdb/alpha-mdebug-tdep.c
index a8a511b..4f82b12 100644
--- a/gdb/alpha-mdebug-tdep.c
+++ b/gdb/alpha-mdebug-tdep.c
@@ -107,7 +107,7 @@ find_proc_desc (CORE_ADDR pc)
symbol reading. */
sym = NULL;
else
- sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN,
+ sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, NULL, LABEL_DOMAIN,
0).symbol;
}
diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index 817fa53..c05d0c4 100644
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -1557,7 +1557,8 @@ gen_static_field (struct gdbarch *gdbarch,
else
{
const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
- struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0).symbol;
+ struct symbol *sym
+ = lookup_symbol_for_arch (phys_name, gdbarch, VAR_DOMAIN).symbol;
if (sym)
{
@@ -1651,7 +1652,7 @@ gen_maybe_namespace_elt (struct expression *exp,
struct block_symbol sym;
sym = cp_lookup_symbol_namespace (namespace_name, name,
- block_for_pc (ax->scope),
+ block_for_pc (ax->scope), exp->gdbarch,
VAR_DOMAIN);
if (sym.symbol == NULL)
diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 351505e..5e80803 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -937,8 +937,8 @@ block : BLOCKNAME
block : block COLONCOLON name
{ struct symbol *tem
- = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, NULL).symbol;
+ = lookup_symbol_from_block (copy_name ($3), $1,
+ VAR_DOMAIN).symbol;
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error (_("No function \"%s\" in specified context."),
@@ -963,8 +963,8 @@ variable: name_not_typename ENTRY
variable: block COLONCOLON name
{ struct block_symbol sym
- = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, NULL);
+ = lookup_symbol_from_block (copy_name ($3), $1,
+ VAR_DOMAIN);
if (sym.symbol == 0)
error (_("No symbol \"%s\" in specified context."),
@@ -1038,6 +1038,7 @@ variable: qualified_name
sym
= lookup_symbol (name, (const struct block *) NULL,
+ parse_gdbarch (pstate),
VAR_DOMAIN, NULL).symbol;
if (sym)
{
@@ -1334,7 +1335,8 @@ typebase /* Implements (approximately): (type-qualifier)* type-specifier */
0); }
| STRUCT name
{ $$ = lookup_struct (copy_name ($2),
- expression_context_block); }
+ expression_context_block,
+ parse_gdbarch (pstate)); }
| STRUCT COMPLETE
{
mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
@@ -1348,7 +1350,8 @@ typebase /* Implements (approximately): (type-qualifier)* type-specifier */
}
| CLASS name
{ $$ = lookup_struct (copy_name ($2),
- expression_context_block); }
+ expression_context_block,
+ parse_gdbarch (pstate)); }
| CLASS COMPLETE
{
mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
@@ -1362,7 +1365,8 @@ typebase /* Implements (approximately): (type-qualifier)* type-specifier */
}
| UNION name
{ $$ = lookup_union (copy_name ($2),
- expression_context_block); }
+ expression_context_block,
+ parse_gdbarch (pstate)); }
| UNION COMPLETE
{
mark_completion_tag (TYPE_CODE_UNION, "", 0);
@@ -1376,7 +1380,8 @@ typebase /* Implements (approximately): (type-qualifier)* type-specifier */
}
| ENUM name
{ $$ = lookup_enum (copy_name ($2),
- expression_context_block); }
+ expression_context_block,
+ parse_gdbarch (pstate)); }
| ENUM COMPLETE
{
mark_completion_tag (TYPE_CODE_ENUM, "", 0);
@@ -1408,8 +1413,9 @@ typebase /* Implements (approximately): (type-qualifier)* type-specifier */
reduced; template recognition happens by lookahead
in the token processing code in yylex. */
| TEMPLATE name '<' type '>'
- { $$ = lookup_template_type(copy_name($2), $4,
- expression_context_block);
+ { $$ = lookup_template_type (copy_name($2), $4,
+ expression_context_block,
+ parse_gdbarch (pstate));
}
| const_or_volatile_or_space_identifier_noopt typebase
{ $$ = follow_types ($2); }
@@ -1649,6 +1655,7 @@ name_not_typename : NAME
$$.stoken = $1;
$$.sym = lookup_symbol ($1.ptr,
expression_context_block,
+ parse_gdbarch (pstate),
VAR_DOMAIN,
&is_a_field_of_this);
$$.is_a_field_of_this
@@ -2812,7 +2819,7 @@ lex_one_token (struct parser_state *par_state, int *is_quoted_name)
struct field_of_this_result is_a_field_of_this;
if (lookup_symbol (copy, expression_context_block,
- VAR_DOMAIN,
+ parse_gdbarch (par_state), VAR_DOMAIN,
(parse_language (par_state)->la_language
== language_cplus ? &is_a_field_of_this
: NULL)).symbol
@@ -2882,7 +2889,7 @@ classify_name (struct parser_state *par_state, const struct block *block,
we can refer to it unconditionally below. */
memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
- bsym = lookup_symbol (copy, block, VAR_DOMAIN,
+ bsym = lookup_symbol (copy, block, parse_gdbarch (par_state), VAR_DOMAIN,
parse_language (par_state)->la_name_of_this
? &is_a_field_of_this : NULL);
@@ -2903,10 +2910,8 @@ classify_name (struct parser_state *par_state, const struct block *block,
&& TYPE_FN_FIELD_CONSTRUCTOR (is_a_field_of_this.fn_field->fn_fields,
0))
{
- struct field_of_this_result inner_is_a_field_of_this;
-
- bsym = lookup_symbol (copy, block, STRUCT_DOMAIN,
- &inner_is_a_field_of_this);
+ bsym = lookup_symbol (copy, block, parse_gdbarch (par_state),
+ STRUCT_DOMAIN, NULL);
if (bsym.symbol != NULL)
{
yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);
@@ -2948,7 +2953,8 @@ classify_name (struct parser_state *par_state, const struct block *block,
struct symbol *sym;
yylval.theclass.theclass = Class;
- sym = lookup_struct_typedef (copy, expression_context_block, 1);
+ sym = lookup_struct_typedef (copy, expression_context_block,
+ parse_gdbarch (par_state), 1);
if (sym)
yylval.theclass.type = SYMBOL_TYPE (sym);
return CLASSNAME;
diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index 80a75d7..feef955 100644
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -203,7 +203,7 @@ print_unpacked_pointer (struct type *type, struct type *elttype,
if (msymbol.minsym != NULL)
wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME(msymbol.minsym), block,
- VAR_DOMAIN, &is_this_fld).symbol;
+ gdbarch, VAR_DOMAIN, &is_this_fld).symbol;
if (wsym)
{
diff --git a/gdb/compile/compile-c-symbols.c b/gdb/compile/compile-c-symbols.c
index 355b063..9684f40 100644
--- a/gdb/compile/compile-c-symbols.c
+++ b/gdb/compile/compile-c-symbols.c
@@ -29,6 +29,7 @@
#include "exceptions.h"
#include "gdbtypes.h"
#include "dwarf2loc.h"
+#include "arch-utils.h"
\f
@@ -330,7 +331,8 @@ convert_symbol_sym (struct compile_c_instance *context, const char *identifier,
{
struct block_symbol global_sym;
- global_sym = lookup_symbol (identifier, NULL, domain, NULL);
+ global_sym = lookup_symbol (identifier, NULL,
+ block_gdbarch (static_block), domain, NULL);
/* If the outer symbol is in the static block, we ignore it, as
it cannot be referenced. */
if (global_sym.symbol != NULL
@@ -446,7 +448,8 @@ gcc_convert_symbol (void *datum,
{
struct block_symbol sym;
- sym = lookup_symbol (identifier, context->base.block, domain, NULL);
+ sym = lookup_symbol (identifier, context->base.block,
+ get_current_arch (), domain, NULL);
if (sym.symbol != NULL)
{
convert_symbol_sym (context, identifier, sym, domain);
@@ -495,7 +498,7 @@ gcc_symbol_address (void *datum, struct gcc_c_context *gcc_context,
struct symbol *sym;
/* We only need global functions here. */
- sym = lookup_symbol (identifier, NULL, VAR_DOMAIN, NULL).symbol;
+ sym = lookup_symbol (identifier, NULL, NULL, VAR_DOMAIN, NULL).symbol;
if (sym != NULL && SYMBOL_CLASS (sym) == LOC_BLOCK)
{
if (compile_debug)
diff --git a/gdb/cp-name-parser.y b/gdb/cp-name-parser.y
index 0657a52..9a3b3ac 100644
--- a/gdb/cp-name-parser.y
+++ b/gdb/cp-name-parser.y
@@ -2008,6 +2008,9 @@ cp_new_demangle_parse_info (void)
struct demangle_parse_info *info;
info = malloc (sizeof (struct demangle_parse_info));
+ /* For our purposes, target_gdbarch should suffice. We don't need
+ primitive type sizes, just names. */
+ info->gdbarch = target_gdbarch ();
info->info = NULL;
info->tree = NULL;
obstack_init (&info->obstack);
@@ -2205,7 +2208,7 @@ main (int argc, char **argv)
printf ("%s\n", buf);
continue;
}
- result = cp_demangled_name_to_comp (str2, &errmsg);
+ result = cp_demangled_name_to_comp (str2, NULL, &errmsg);
if (result == NULL)
{
fputs (errmsg, stderr);
@@ -2226,7 +2229,7 @@ main (int argc, char **argv)
}
else
{
- result = cp_demangled_name_to_comp (argv[arg], &errmsg);
+ result = cp_demangled_name_to_comp (argv[arg], NULL, &errmsg);
if (result == NULL)
{
fputs (errmsg, stderr);
diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index b8b19ed..3750947 100644
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -153,15 +153,16 @@ cp_basic_lookup_symbol (const char *name, const struct block *block,
NAME is guaranteed to not have any scope (no "::") in its name, though
if for example NAME is a template spec then "::" may appear in the
argument list.
- If LANGDEF is non-NULL then try to lookup NAME as a primitive type in
- that language. Normally we wouldn't need LANGDEF but fortran also uses
- this code.
+ If LANGDEF is non-NULL, and either BLOCK or GDBARCH is non-NULL,
+ then try to lookup NAME as a primitive type in that language.
+ Normally we wouldn't need LANGDEF but fortran also uses this code.
If SEARCH is non-zero then see if we can determine "this" from BLOCK, and
if so then also search for NAME in that class. */
static struct block_symbol
cp_lookup_bare_symbol (const struct language_defn *langdef,
const char *name, const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain, int search)
{
struct block_symbol sym;
@@ -177,21 +178,29 @@ cp_lookup_bare_symbol (const struct language_defn *langdef,
return sym;
/* If we didn't find a definition for a builtin type in the static block,
- search for it now. This is actually the right thing to do and can be
- a massive performance win. E.g., when debugging a program with lots of
- shared libraries we could search all of them only to find out the
- builtin type isn't defined in any of them. This is common for types
- like "void". */
- if (langdef != NULL && domain == VAR_DOMAIN)
+ and we're passed a gdbarch so we can look up its primitive types,
+ search for it now. This is actually the right thing to do.
+ E.g., imagine a program compiled with -fshort-double or whatever,
+ but this compilation unit wasn't. If we didn't find the primitive type
+ in the current static block we want to find it now, before searching any
+ other compilation units.
+ And it can be a massive performance win. E.g., when debugging a program
+ with lots of shared libraries we could search all of them only to find
+ out the builtin type isn't defined in any of them. This is common for
+ types like "void". */
+ if (langdef != NULL
+ && domain == VAR_DOMAIN
+ && (block != NULL || gdbarch != NULL))
{
- struct gdbarch *gdbarch;
+ const struct gdbarch *gdbarch_for_lookup;
- if (block == NULL)
- gdbarch = target_gdbarch ();
+ if (block != NULL)
+ gdbarch_for_lookup = block_gdbarch (block);
else
- gdbarch = block_gdbarch (block);
+ gdbarch_for_lookup = gdbarch;
sym.symbol
- = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
+ = language_lookup_primitive_type_as_symbol (langdef,
+ gdbarch_for_lookup, name);
sym.block = NULL;
if (sym.symbol != NULL)
return sym;
@@ -299,6 +308,7 @@ cp_search_static_and_baseclasses (const char *name,
static struct block_symbol
cp_lookup_symbol_in_namespace (const char *the_namespace, const char *name,
const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain, int search)
{
char *concatenated_name = NULL;
@@ -318,7 +328,7 @@ cp_lookup_symbol_in_namespace (const char *the_namespace, const char *name,
prefix_len = cp_entire_prefix_len (name);
if (prefix_len == 0)
- return cp_lookup_bare_symbol (NULL, name, block, domain, search);
+ return cp_lookup_bare_symbol (NULL, name, block, gdbarch, domain, search);
/* This would be simpler if we just called cp_lookup_nested_symbol
at this point. But that would require first looking up the containing
@@ -396,7 +406,7 @@ cp_lookup_symbol_via_imports (const char *scope,
/* First, try to find the symbol in the given namespace if requested. */
if (search_scope_first)
sym = cp_lookup_symbol_in_namespace (scope, name,
- block, domain, 1);
+ block, NULL, domain, 1);
if (sym.symbol != NULL)
return sym;
@@ -439,7 +449,7 @@ cp_lookup_symbol_via_imports (const char *scope,
? current->alias : current->declaration) == 0)
sym = cp_lookup_symbol_in_namespace (current->import_src,
current->declaration,
- block, domain, 1);
+ block, NULL, domain, 1);
/* If this is a DECLARATION_ONLY search or a symbol was found
or this import statement was an import declaration, the
@@ -473,7 +483,7 @@ cp_lookup_symbol_via_imports (const char *scope,
{
sym = cp_lookup_symbol_in_namespace (scope,
current->import_src,
- block, domain, 1);
+ block, NULL, domain, 1);
}
else if (current->alias == NULL)
{
@@ -645,6 +655,7 @@ cp_lookup_symbol_via_all_imports (const char *scope, const char *name,
/* Searches for NAME in the current namespace, and by applying
relevant import statements belonging to BLOCK and its parents.
+ GDBARCH is used when BLOCK is NULL and NAME is a primitive type.
SCOPE is the namespace scope of the context in which the search is
being evaluated. */
@@ -652,6 +663,7 @@ struct block_symbol
cp_lookup_symbol_namespace (const char *scope,
const char *name,
const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain)
{
struct block_symbol sym;
@@ -665,7 +677,7 @@ cp_lookup_symbol_namespace (const char *scope,
}
/* First, try to find the symbol in the given namespace. */
- sym = cp_lookup_symbol_in_namespace (scope, name, block, domain, 1);
+ sym = cp_lookup_symbol_in_namespace (scope, name, block, gdbarch, domain, 1);
/* Search for name in namespaces imported to this and parent blocks. */
if (sym.symbol == NULL)
@@ -700,6 +712,7 @@ static struct block_symbol
lookup_namespace_scope (const struct language_defn *langdef,
const char *name,
const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain,
const char *scope,
int scope_len)
@@ -720,7 +733,7 @@ lookup_namespace_scope (const struct language_defn *langdef,
new_scope_len += 2;
}
new_scope_len += cp_find_first_component (scope + new_scope_len);
- sym = lookup_namespace_scope (langdef, name, block, domain,
+ sym = lookup_namespace_scope (langdef, name, block, gdbarch, domain,
scope, new_scope_len);
if (sym.symbol != NULL)
return sym;
@@ -731,32 +744,37 @@ lookup_namespace_scope (const struct language_defn *langdef,
If we there is no scope and we know we have a bare symbol, then short
circuit everything and call cp_lookup_bare_symbol directly.
- This isn't an optimization, rather it allows us to pass LANGDEF which
- is needed for primitive type lookup. The test doesn't have to be
+ This isn't an optimization, rather it allows us to pass LANGDEF, GDBARCH
+ which is needed for primitive type lookup. The test doesn't have to be
perfect: if NAME is a bare symbol that our test doesn't catch (e.g., a
template symbol with "::" in the argument list) then
cp_lookup_symbol_in_namespace will catch it. */
if (scope_len == 0 && strchr (name, ':') == NULL)
- return cp_lookup_bare_symbol (langdef, name, block, domain, 1);
+ return cp_lookup_bare_symbol (langdef, name, block, gdbarch, domain, 1);
the_namespace = alloca (scope_len + 1);
strncpy (the_namespace, scope, scope_len);
the_namespace[scope_len] = '\0';
return cp_lookup_symbol_in_namespace (the_namespace, name,
- block, domain, 1);
+ block, gdbarch, domain, 1);
}
/* The C++-specific version of name lookup for static and global
names. This makes sure that names get looked for in all namespaces
- that are in scope. NAME is the natural name of the symbol that
- we're looking for, BLOCK is the block that we're searching within,
+ that are in scope.
+ NAME is the natural name of the symbol that we're looking for.
+ BLOCK is the block that we're searching within.
+ GDBARCH is for looking up primitive types and is used if BLOCK is NULL.
+ Both BLOCK and GDBARCH may be NULL, in which case lookup of primitive types
+ is skipped.
DOMAIN says what kind of symbols we're looking for. */
struct block_symbol
cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *name,
const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain)
{
struct block_symbol sym;
@@ -773,7 +791,8 @@ cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
/* First, try to find the symbol in the given namespace, and all
containing namespaces. */
- sym = lookup_namespace_scope (langdef, name, block, domain, scope, 0);
+ sym = lookup_namespace_scope (langdef, name, block, gdbarch, domain, scope,
+ 0);
/* Search for name in namespaces imported to this and parent blocks. */
if (sym.symbol == NULL)
diff --git a/gdb/cp-support.c b/gdb/cp-support.c
index d3e26ad..eb03425 100644
--- a/gdb/cp-support.c
+++ b/gdb/cp-support.c
@@ -176,7 +176,7 @@ inspect_type (struct demangle_parse_info *info,
TRY
{
- sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, 0, info->gdbarch, VAR_DOMAIN, 0).symbol;
}
CATCH (except, RETURN_MASK_ALL)
{
@@ -458,7 +458,8 @@ replace_typedefs (struct demangle_parse_info *info,
sym = NULL;
TRY
{
- sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0).symbol;
+ sym = lookup_symbol (local_name, 0, info->gdbarch,
+ VAR_DOMAIN, 0).symbol;
}
CATCH (except, RETURN_MASK_ALL)
{
@@ -1455,7 +1456,7 @@ cp_lookup_rtti_type (const char *name, struct block *block)
/* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
- rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;
+ rtti_sym = lookup_symbol (name, block, NULL, VAR_DOMAIN, NULL).symbol;
if (rtti_sym == NULL)
{
diff --git a/gdb/cp-support.h b/gdb/cp-support.h
index 12d8d80..ed72dd3 100644
--- a/gdb/cp-support.h
+++ b/gdb/cp-support.h
@@ -50,6 +50,9 @@ struct using_direct;
struct demangle_parse_info
{
+ /* The gdbarch, for primitive type lookup. */
+ const struct gdbarch *gdbarch;
+
/* The memory used during the parse. */
struct demangle_info *info;
@@ -106,12 +109,14 @@ extern struct block_symbol cp_lookup_symbol_nonlocal
(const struct language_defn *langdef,
const char *name,
const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain);
extern struct block_symbol
cp_lookup_symbol_namespace (const char *the_namespace,
const char *name,
const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain);
extern struct block_symbol cp_lookup_symbol_imports_or_template
diff --git a/gdb/d-exp.y b/gdb/d-exp.y
index dd87d8a..afeb17c 100644
--- a/gdb/d-exp.y
+++ b/gdb/d-exp.y
@@ -471,7 +471,8 @@ PrimaryExpression:
struct block_symbol sym;
/* Handle VAR, which could be local or global. */
- sym = lookup_symbol (copy, expression_context_block, VAR_DOMAIN,
+ sym = lookup_symbol (copy, expression_context_block,
+ parse_gdbarch (pstate), VAR_DOMAIN,
&is_a_field_of_this);
if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
{
@@ -534,8 +535,9 @@ PrimaryExpression:
make_cleanup (xfree, name);
sym =
- lookup_symbol (name, (const struct block *) NULL,
- VAR_DOMAIN, NULL);
+ lookup_symbol_for_arch (name,
+ parse_gdbarch (pstate),
+ VAR_DOMAIN);
if (sym.symbol)
{
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
@@ -1407,11 +1409,11 @@ classify_name (struct parser_state *par_state, const struct block *block)
{
struct block_symbol sym;
char *copy;
- struct field_of_this_result is_a_field_of_this;
copy = copy_name (yylval.sval);
- sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
+ sym = lookup_symbol (copy, block, parse_gdbarch (par_state), VAR_DOMAIN,
+ NULL);
if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)
{
yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
@@ -1420,9 +1422,11 @@ classify_name (struct parser_state *par_state, const struct block *block)
else if (sym.symbol == NULL)
{
/* Look-up first for a module name, then a type. */
- sym = lookup_symbol (copy, block, MODULE_DOMAIN, NULL);
+ sym = lookup_symbol (copy, block, parse_gdbarch (par_state),
+ MODULE_DOMAIN, NULL);
if (sym.symbol == NULL)
- sym = lookup_symbol (copy, block, STRUCT_DOMAIN, NULL);
+ sym = lookup_symbol (copy, block, parse_gdbarch (par_state),
+ STRUCT_DOMAIN, NULL);
if (sym.symbol != NULL)
{
diff --git a/gdb/d-lang.h b/gdb/d-lang.h
index 8b8b5dc..cbdb772 100644
--- a/gdb/d-lang.h
+++ b/gdb/d-lang.h
@@ -73,6 +73,7 @@ extern const struct builtin_d_type *builtin_d_type (struct gdbarch *);
extern struct block_symbol d_lookup_symbol_nonlocal (const struct language_defn *,
const char *,
const struct block *,
+ const struct gdbarch *,
const domain_enum);
extern struct block_symbol d_lookup_nested_symbol (struct type *, const char *,
diff --git a/gdb/d-namespace.c b/gdb/d-namespace.c
index bed8d5b..6097873 100644
--- a/gdb/d-namespace.c
+++ b/gdb/d-namespace.c
@@ -549,6 +549,7 @@ struct block_symbol
d_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *name,
const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain)
{
struct block_symbol sym;
diff --git a/gdb/eval.c b/gdb/eval.c
index a668e76..e60a2d2 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -1492,6 +1492,7 @@ evaluate_subexp_standard (struct type *expect_type,
function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
name,
get_selected_block (0),
+ exp->gdbarch,
VAR_DOMAIN).symbol;
if (function == NULL)
error (_("No symbol \"%s\" in namespace \"%s\"."),
diff --git a/gdb/f-exp.y b/gdb/f-exp.y
index 56629dc..eb32693 100644
--- a/gdb/f-exp.y
+++ b/gdb/f-exp.y
@@ -1213,6 +1213,7 @@ yylex (void)
memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
result = lookup_symbol (tmp, expression_context_block,
+ parse_gdbarch (pstate),
lookup_domains[i],
parse_language (pstate)->la_language
== language_cplus
diff --git a/gdb/ft32-tdep.c b/gdb/ft32-tdep.c
index 2e5deca..3e4ddb7 100644
--- a/gdb/ft32-tdep.c
+++ b/gdb/ft32-tdep.c
@@ -250,7 +250,8 @@ ft32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
plg_end = ft32_analyze_prologue (func_addr,
func_end, &cache, gdbarch);
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
+ sym = lookup_symbol (func_name, NULL, gdbarch, VAR_DOMAIN,
+ NULL).symbol;
/* Don't use line number debug info for assembly source files. */
if ((sym != NULL) && SYMBOL_LANGUAGE (sym) != language_asm)
{
diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 0d4142b..446184d 100644
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -1408,7 +1408,7 @@ gdbarch_tdep (struct gdbarch *gdbarch)
const struct bfd_arch_info *
-gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
+gdbarch_bfd_arch_info (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -1417,7 +1417,7 @@ gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
}
enum bfd_endian
-gdbarch_byte_order (struct gdbarch *gdbarch)
+gdbarch_byte_order (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -1426,7 +1426,7 @@ gdbarch_byte_order (struct gdbarch *gdbarch)
}
enum bfd_endian
-gdbarch_byte_order_for_code (struct gdbarch *gdbarch)
+gdbarch_byte_order_for_code (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -1435,7 +1435,7 @@ gdbarch_byte_order_for_code (struct gdbarch *gdbarch)
}
enum gdb_osabi
-gdbarch_osabi (struct gdbarch *gdbarch)
+gdbarch_osabi (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -1444,7 +1444,7 @@ gdbarch_osabi (struct gdbarch *gdbarch)
}
const struct target_desc *
-gdbarch_target_desc (struct gdbarch *gdbarch)
+gdbarch_target_desc (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -1453,7 +1453,7 @@ gdbarch_target_desc (struct gdbarch *gdbarch)
}
int
-gdbarch_bits_big_endian (struct gdbarch *gdbarch)
+gdbarch_bits_big_endian (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of bits_big_endian, invalid_p == 0 */
@@ -1470,7 +1470,7 @@ set_gdbarch_bits_big_endian (struct gdbarch *gdbarch,
}
int
-gdbarch_short_bit (struct gdbarch *gdbarch)
+gdbarch_short_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of short_bit, invalid_p == 0 */
@@ -1487,7 +1487,7 @@ set_gdbarch_short_bit (struct gdbarch *gdbarch,
}
int
-gdbarch_int_bit (struct gdbarch *gdbarch)
+gdbarch_int_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of int_bit, invalid_p == 0 */
@@ -1504,7 +1504,7 @@ set_gdbarch_int_bit (struct gdbarch *gdbarch,
}
int
-gdbarch_long_bit (struct gdbarch *gdbarch)
+gdbarch_long_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of long_bit, invalid_p == 0 */
@@ -1521,7 +1521,7 @@ set_gdbarch_long_bit (struct gdbarch *gdbarch,
}
int
-gdbarch_long_long_bit (struct gdbarch *gdbarch)
+gdbarch_long_long_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of long_long_bit, invalid_p == 0 */
@@ -1538,7 +1538,7 @@ set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
}
int
-gdbarch_long_long_align_bit (struct gdbarch *gdbarch)
+gdbarch_long_long_align_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of long_long_align_bit, invalid_p == 0 */
@@ -1555,7 +1555,7 @@ set_gdbarch_long_long_align_bit (struct gdbarch *gdbarch,
}
int
-gdbarch_half_bit (struct gdbarch *gdbarch)
+gdbarch_half_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of half_bit, invalid_p == 0 */
@@ -1572,7 +1572,7 @@ set_gdbarch_half_bit (struct gdbarch *gdbarch,
}
const struct floatformat **
-gdbarch_half_format (struct gdbarch *gdbarch)
+gdbarch_half_format (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -1588,7 +1588,7 @@ set_gdbarch_half_format (struct gdbarch *gdbarch,
}
int
-gdbarch_float_bit (struct gdbarch *gdbarch)
+gdbarch_float_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of float_bit, invalid_p == 0 */
@@ -1605,7 +1605,7 @@ set_gdbarch_float_bit (struct gdbarch *gdbarch,
}
const struct floatformat **
-gdbarch_float_format (struct gdbarch *gdbarch)
+gdbarch_float_format (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -1621,7 +1621,7 @@ set_gdbarch_float_format (struct gdbarch *gdbarch,
}
int
-gdbarch_double_bit (struct gdbarch *gdbarch)
+gdbarch_double_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of double_bit, invalid_p == 0 */
@@ -1638,7 +1638,7 @@ set_gdbarch_double_bit (struct gdbarch *gdbarch,
}
const struct floatformat **
-gdbarch_double_format (struct gdbarch *gdbarch)
+gdbarch_double_format (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -1654,7 +1654,7 @@ set_gdbarch_double_format (struct gdbarch *gdbarch,
}
int
-gdbarch_long_double_bit (struct gdbarch *gdbarch)
+gdbarch_long_double_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of long_double_bit, invalid_p == 0 */
@@ -1671,7 +1671,7 @@ set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
}
const struct floatformat **
-gdbarch_long_double_format (struct gdbarch *gdbarch)
+gdbarch_long_double_format (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -1687,7 +1687,7 @@ set_gdbarch_long_double_format (struct gdbarch *gdbarch,
}
int
-gdbarch_ptr_bit (struct gdbarch *gdbarch)
+gdbarch_ptr_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of ptr_bit, invalid_p == 0 */
@@ -1704,7 +1704,7 @@ set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
}
int
-gdbarch_addr_bit (struct gdbarch *gdbarch)
+gdbarch_addr_bit (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Check variable changed from pre-default. */
@@ -1722,7 +1722,7 @@ set_gdbarch_addr_bit (struct gdbarch *gdbarch,
}
int
-gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch)
+gdbarch_dwarf2_addr_size (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Check variable changed from pre-default. */
@@ -1740,7 +1740,7 @@ set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch,
}
int
-gdbarch_char_signed (struct gdbarch *gdbarch)
+gdbarch_char_signed (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Check variable changed from pre-default. */
@@ -1758,7 +1758,7 @@ set_gdbarch_char_signed (struct gdbarch *gdbarch,
}
int
-gdbarch_read_pc_p (struct gdbarch *gdbarch)
+gdbarch_read_pc_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->read_pc != NULL;
@@ -1782,7 +1782,7 @@ set_gdbarch_read_pc (struct gdbarch *gdbarch,
}
int
-gdbarch_write_pc_p (struct gdbarch *gdbarch)
+gdbarch_write_pc_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->write_pc != NULL;
@@ -1823,7 +1823,7 @@ set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
}
int
-gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
+gdbarch_pseudo_register_read_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->pseudo_register_read != NULL;
@@ -1847,7 +1847,7 @@ set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
}
int
-gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch)
+gdbarch_pseudo_register_read_value_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->pseudo_register_read_value != NULL;
@@ -1871,7 +1871,7 @@ set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch,
}
int
-gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
+gdbarch_pseudo_register_write_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->pseudo_register_write != NULL;
@@ -1895,7 +1895,7 @@ set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
}
int
-gdbarch_num_regs (struct gdbarch *gdbarch)
+gdbarch_num_regs (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Check variable changed from pre-default. */
@@ -1913,7 +1913,7 @@ set_gdbarch_num_regs (struct gdbarch *gdbarch,
}
int
-gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
+gdbarch_num_pseudo_regs (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of num_pseudo_regs, invalid_p == 0 */
@@ -1930,7 +1930,7 @@ set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
}
int
-gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch)
+gdbarch_ax_pseudo_register_collect_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->ax_pseudo_register_collect != NULL;
@@ -1954,7 +1954,7 @@ set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch,
}
int
-gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch)
+gdbarch_ax_pseudo_register_push_stack_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->ax_pseudo_register_push_stack != NULL;
@@ -1978,7 +1978,7 @@ set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
}
int
-gdbarch_sp_regnum (struct gdbarch *gdbarch)
+gdbarch_sp_regnum (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of sp_regnum, invalid_p == 0 */
@@ -1995,7 +1995,7 @@ set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
}
int
-gdbarch_pc_regnum (struct gdbarch *gdbarch)
+gdbarch_pc_regnum (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of pc_regnum, invalid_p == 0 */
@@ -2012,7 +2012,7 @@ set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
}
int
-gdbarch_ps_regnum (struct gdbarch *gdbarch)
+gdbarch_ps_regnum (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of ps_regnum, invalid_p == 0 */
@@ -2029,7 +2029,7 @@ set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
}
int
-gdbarch_fp0_regnum (struct gdbarch *gdbarch)
+gdbarch_fp0_regnum (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of fp0_regnum, invalid_p == 0 */
@@ -2131,7 +2131,7 @@ set_gdbarch_register_name (struct gdbarch *gdbarch,
}
int
-gdbarch_register_type_p (struct gdbarch *gdbarch)
+gdbarch_register_type_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->register_type != NULL;
@@ -2155,7 +2155,7 @@ set_gdbarch_register_type (struct gdbarch *gdbarch,
}
int
-gdbarch_dummy_id_p (struct gdbarch *gdbarch)
+gdbarch_dummy_id_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->dummy_id != NULL;
@@ -2179,7 +2179,7 @@ set_gdbarch_dummy_id (struct gdbarch *gdbarch,
}
int
-gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
+gdbarch_deprecated_fp_regnum (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
@@ -2196,7 +2196,7 @@ set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
}
int
-gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
+gdbarch_push_dummy_call_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->push_dummy_call != NULL;
@@ -2220,7 +2220,7 @@ set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
}
int
-gdbarch_call_dummy_location (struct gdbarch *gdbarch)
+gdbarch_call_dummy_location (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of call_dummy_location, invalid_p == 0 */
@@ -2237,7 +2237,7 @@ set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
}
int
-gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
+gdbarch_push_dummy_code_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->push_dummy_code != NULL;
@@ -2295,7 +2295,7 @@ set_gdbarch_print_float_info (struct gdbarch *gdbarch,
}
int
-gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
+gdbarch_print_vector_info_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->print_vector_info != NULL;
@@ -2370,7 +2370,7 @@ set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
}
int
-gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
+gdbarch_get_longjmp_target_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->get_longjmp_target != NULL;
@@ -2394,7 +2394,7 @@ set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
}
int
-gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
+gdbarch_believe_pcc_promotion (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -2512,7 +2512,7 @@ set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
}
int
-gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
+gdbarch_integer_to_address_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->integer_to_address != NULL;
@@ -2536,7 +2536,7 @@ set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
}
int
-gdbarch_return_value_p (struct gdbarch *gdbarch)
+gdbarch_return_value_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->return_value != NULL;
@@ -2594,7 +2594,7 @@ set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
}
int
-gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch)
+gdbarch_skip_main_prologue_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->skip_main_prologue != NULL;
@@ -2618,7 +2618,7 @@ set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch,
}
int
-gdbarch_skip_entrypoint_p (struct gdbarch *gdbarch)
+gdbarch_skip_entrypoint_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->skip_entrypoint != NULL;
@@ -2693,7 +2693,7 @@ set_gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch,
}
int
-gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
+gdbarch_adjust_breakpoint_address_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->adjust_breakpoint_address != NULL;
@@ -2751,7 +2751,7 @@ set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
}
CORE_ADDR
-gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
+gdbarch_decr_pc_after_break (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of decr_pc_after_break, invalid_p == 0 */
@@ -2768,7 +2768,7 @@ set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
}
CORE_ADDR
-gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
+gdbarch_deprecated_function_start_offset (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
@@ -2802,7 +2802,7 @@ set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
}
int
-gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
+gdbarch_fetch_tls_load_module_address_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->fetch_tls_load_module_address != NULL;
@@ -2826,7 +2826,7 @@ set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
}
CORE_ADDR
-gdbarch_frame_args_skip (struct gdbarch *gdbarch)
+gdbarch_frame_args_skip (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of frame_args_skip, invalid_p == 0 */
@@ -2843,7 +2843,7 @@ set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
}
int
-gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
+gdbarch_unwind_pc_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->unwind_pc != NULL;
@@ -2867,7 +2867,7 @@ set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
}
int
-gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
+gdbarch_unwind_sp_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->unwind_sp != NULL;
@@ -2891,7 +2891,7 @@ set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
}
int
-gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
+gdbarch_frame_num_args_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->frame_num_args != NULL;
@@ -2915,7 +2915,7 @@ set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
}
int
-gdbarch_frame_align_p (struct gdbarch *gdbarch)
+gdbarch_frame_align_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->frame_align != NULL;
@@ -2956,7 +2956,7 @@ set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
}
int
-gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
+gdbarch_frame_red_zone_size (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -3006,7 +3006,7 @@ set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
}
int
-gdbarch_software_single_step_p (struct gdbarch *gdbarch)
+gdbarch_software_single_step_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->software_single_step != NULL;
@@ -3030,7 +3030,7 @@ set_gdbarch_software_single_step (struct gdbarch *gdbarch,
}
int
-gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
+gdbarch_single_step_through_delay_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->single_step_through_delay != NULL;
@@ -3139,7 +3139,7 @@ set_gdbarch_stack_frame_destroyed_p (struct gdbarch *gdbarch,
}
int
-gdbarch_elf_make_msymbol_special_p (struct gdbarch *gdbarch)
+gdbarch_elf_make_msymbol_special_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->elf_make_msymbol_special != NULL;
@@ -3231,7 +3231,7 @@ set_gdbarch_adjust_dwarf2_line (struct gdbarch *gdbarch,
}
int
-gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
+gdbarch_cannot_step_breakpoint (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
@@ -3248,7 +3248,7 @@ set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
}
int
-gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
+gdbarch_have_nonsteppable_watchpoint (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
@@ -3265,7 +3265,7 @@ set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
}
int
-gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
+gdbarch_address_class_type_flags_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->address_class_type_flags != NULL;
@@ -3289,7 +3289,7 @@ set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
}
int
-gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
+gdbarch_address_class_type_flags_to_name_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->address_class_type_flags_to_name != NULL;
@@ -3313,7 +3313,7 @@ set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
}
int
-gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
+gdbarch_address_class_name_to_type_flags_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->address_class_name_to_type_flags != NULL;
@@ -3354,7 +3354,7 @@ set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
}
int
-gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
+gdbarch_fetch_pointer_argument_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->fetch_pointer_argument != NULL;
@@ -3378,7 +3378,7 @@ set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
}
int
-gdbarch_iterate_over_regset_sections_p (struct gdbarch *gdbarch)
+gdbarch_iterate_over_regset_sections_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->iterate_over_regset_sections != NULL;
@@ -3402,7 +3402,7 @@ set_gdbarch_iterate_over_regset_sections (struct gdbarch *gdbarch,
}
int
-gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch)
+gdbarch_make_corefile_notes_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->make_corefile_notes != NULL;
@@ -3426,7 +3426,7 @@ set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch,
}
int
-gdbarch_elfcore_write_linux_prpsinfo_p (struct gdbarch *gdbarch)
+gdbarch_elfcore_write_linux_prpsinfo_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->elfcore_write_linux_prpsinfo != NULL;
@@ -3450,7 +3450,7 @@ set_gdbarch_elfcore_write_linux_prpsinfo (struct gdbarch *gdbarch,
}
int
-gdbarch_find_memory_regions_p (struct gdbarch *gdbarch)
+gdbarch_find_memory_regions_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->find_memory_regions != NULL;
@@ -3474,7 +3474,7 @@ set_gdbarch_find_memory_regions (struct gdbarch *gdbarch,
}
int
-gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch)
+gdbarch_core_xfer_shared_libraries_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->core_xfer_shared_libraries != NULL;
@@ -3498,7 +3498,7 @@ set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch,
}
int
-gdbarch_core_xfer_shared_libraries_aix_p (struct gdbarch *gdbarch)
+gdbarch_core_xfer_shared_libraries_aix_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->core_xfer_shared_libraries_aix != NULL;
@@ -3522,7 +3522,7 @@ set_gdbarch_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch,
}
int
-gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch)
+gdbarch_core_pid_to_str_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->core_pid_to_str != NULL;
@@ -3546,14 +3546,14 @@ set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch,
}
int
-gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch)
+gdbarch_gcore_bfd_target_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->gcore_bfd_target != 0;
}
const char *
-gdbarch_gcore_bfd_target (struct gdbarch *gdbarch)
+gdbarch_gcore_bfd_target (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Check variable changed from pre-default. */
@@ -3571,7 +3571,7 @@ set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch,
}
int
-gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
+gdbarch_vtable_function_descriptors (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of vtable_function_descriptors, invalid_p == 0 */
@@ -3588,7 +3588,7 @@ set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
}
int
-gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
+gdbarch_vbit_in_delta (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of vbit_in_delta, invalid_p == 0 */
@@ -3622,14 +3622,14 @@ set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
}
int
-gdbarch_max_insn_length_p (struct gdbarch *gdbarch)
+gdbarch_max_insn_length_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->max_insn_length != 0;
}
ULONGEST
-gdbarch_max_insn_length (struct gdbarch *gdbarch)
+gdbarch_max_insn_length (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Check variable changed from pre-default. */
@@ -3647,7 +3647,7 @@ set_gdbarch_max_insn_length (struct gdbarch *gdbarch,
}
int
-gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch)
+gdbarch_displaced_step_copy_insn_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->displaced_step_copy_insn != NULL;
@@ -3688,7 +3688,7 @@ set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
}
int
-gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch)
+gdbarch_displaced_step_fixup_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->displaced_step_fixup != NULL;
@@ -3747,7 +3747,7 @@ set_gdbarch_displaced_step_location (struct gdbarch *gdbarch,
}
int
-gdbarch_relocate_instruction_p (struct gdbarch *gdbarch)
+gdbarch_relocate_instruction_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->relocate_instruction != NULL;
@@ -3772,7 +3772,7 @@ set_gdbarch_relocate_instruction (struct gdbarch *gdbarch,
}
int
-gdbarch_overlay_update_p (struct gdbarch *gdbarch)
+gdbarch_overlay_update_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->overlay_update != NULL;
@@ -3796,7 +3796,7 @@ set_gdbarch_overlay_update (struct gdbarch *gdbarch,
}
int
-gdbarch_core_read_description_p (struct gdbarch *gdbarch)
+gdbarch_core_read_description_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->core_read_description != NULL;
@@ -3820,7 +3820,7 @@ set_gdbarch_core_read_description (struct gdbarch *gdbarch,
}
int
-gdbarch_static_transform_name_p (struct gdbarch *gdbarch)
+gdbarch_static_transform_name_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->static_transform_name != NULL;
@@ -3844,7 +3844,7 @@ set_gdbarch_static_transform_name (struct gdbarch *gdbarch,
}
int
-gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch)
+gdbarch_sofun_address_maybe_missing (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
@@ -3861,7 +3861,7 @@ set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch,
}
int
-gdbarch_process_record_p (struct gdbarch *gdbarch)
+gdbarch_process_record_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->process_record != NULL;
@@ -3885,7 +3885,7 @@ set_gdbarch_process_record (struct gdbarch *gdbarch,
}
int
-gdbarch_process_record_signal_p (struct gdbarch *gdbarch)
+gdbarch_process_record_signal_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->process_record_signal != NULL;
@@ -3909,7 +3909,7 @@ set_gdbarch_process_record_signal (struct gdbarch *gdbarch,
}
int
-gdbarch_gdb_signal_from_target_p (struct gdbarch *gdbarch)
+gdbarch_gdb_signal_from_target_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->gdb_signal_from_target != NULL;
@@ -3933,7 +3933,7 @@ set_gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch,
}
int
-gdbarch_gdb_signal_to_target_p (struct gdbarch *gdbarch)
+gdbarch_gdb_signal_to_target_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->gdb_signal_to_target != NULL;
@@ -3957,7 +3957,7 @@ set_gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch,
}
int
-gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch)
+gdbarch_get_siginfo_type_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->get_siginfo_type != NULL;
@@ -3981,7 +3981,7 @@ set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch,
}
int
-gdbarch_record_special_symbol_p (struct gdbarch *gdbarch)
+gdbarch_record_special_symbol_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->record_special_symbol != NULL;
@@ -4005,7 +4005,7 @@ set_gdbarch_record_special_symbol (struct gdbarch *gdbarch,
}
int
-gdbarch_get_syscall_number_p (struct gdbarch *gdbarch)
+gdbarch_get_syscall_number_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->get_syscall_number != NULL;
@@ -4029,7 +4029,7 @@ set_gdbarch_get_syscall_number (struct gdbarch *gdbarch,
}
const char *
-gdbarch_xml_syscall_file (struct gdbarch *gdbarch)
+gdbarch_xml_syscall_file (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of xml_syscall_file, invalid_p == 0 */
@@ -4046,7 +4046,7 @@ set_gdbarch_xml_syscall_file (struct gdbarch *gdbarch,
}
struct syscalls_info *
-gdbarch_syscalls_info (struct gdbarch *gdbarch)
+gdbarch_syscalls_info (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of syscalls_info, invalid_p == 0 */
@@ -4063,7 +4063,7 @@ set_gdbarch_syscalls_info (struct gdbarch *gdbarch,
}
const char *const *
-gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch)
+gdbarch_stap_integer_prefixes (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of stap_integer_prefixes, invalid_p == 0 */
@@ -4080,7 +4080,7 @@ set_gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch,
}
const char *const *
-gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch)
+gdbarch_stap_integer_suffixes (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of stap_integer_suffixes, invalid_p == 0 */
@@ -4097,7 +4097,7 @@ set_gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch,
}
const char *const *
-gdbarch_stap_register_prefixes (struct gdbarch *gdbarch)
+gdbarch_stap_register_prefixes (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of stap_register_prefixes, invalid_p == 0 */
@@ -4114,7 +4114,7 @@ set_gdbarch_stap_register_prefixes (struct gdbarch *gdbarch,
}
const char *const *
-gdbarch_stap_register_suffixes (struct gdbarch *gdbarch)
+gdbarch_stap_register_suffixes (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of stap_register_suffixes, invalid_p == 0 */
@@ -4131,7 +4131,7 @@ set_gdbarch_stap_register_suffixes (struct gdbarch *gdbarch,
}
const char *const *
-gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdbarch)
+gdbarch_stap_register_indirection_prefixes (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of stap_register_indirection_prefixes, invalid_p == 0 */
@@ -4148,7 +4148,7 @@ set_gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdbarch,
}
const char *const *
-gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch)
+gdbarch_stap_register_indirection_suffixes (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of stap_register_indirection_suffixes, invalid_p == 0 */
@@ -4165,7 +4165,7 @@ set_gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch,
}
const char *
-gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch)
+gdbarch_stap_gdb_register_prefix (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of stap_gdb_register_prefix, invalid_p == 0 */
@@ -4182,7 +4182,7 @@ set_gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch,
}
const char *
-gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch)
+gdbarch_stap_gdb_register_suffix (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of stap_gdb_register_suffix, invalid_p == 0 */
@@ -4199,7 +4199,7 @@ set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch,
}
int
-gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch)
+gdbarch_stap_is_single_operand_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->stap_is_single_operand != NULL;
@@ -4223,7 +4223,7 @@ set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch,
}
int
-gdbarch_stap_parse_special_token_p (struct gdbarch *gdbarch)
+gdbarch_stap_parse_special_token_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->stap_parse_special_token != NULL;
@@ -4247,7 +4247,7 @@ set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch,
}
int
-gdbarch_dtrace_parse_probe_argument_p (struct gdbarch *gdbarch)
+gdbarch_dtrace_parse_probe_argument_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->dtrace_parse_probe_argument != NULL;
@@ -4271,7 +4271,7 @@ set_gdbarch_dtrace_parse_probe_argument (struct gdbarch *gdbarch,
}
int
-gdbarch_dtrace_probe_is_enabled_p (struct gdbarch *gdbarch)
+gdbarch_dtrace_probe_is_enabled_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->dtrace_probe_is_enabled != NULL;
@@ -4295,7 +4295,7 @@ set_gdbarch_dtrace_probe_is_enabled (struct gdbarch *gdbarch,
}
int
-gdbarch_dtrace_enable_probe_p (struct gdbarch *gdbarch)
+gdbarch_dtrace_enable_probe_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->dtrace_enable_probe != NULL;
@@ -4319,7 +4319,7 @@ set_gdbarch_dtrace_enable_probe (struct gdbarch *gdbarch,
}
int
-gdbarch_dtrace_disable_probe_p (struct gdbarch *gdbarch)
+gdbarch_dtrace_disable_probe_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->dtrace_disable_probe != NULL;
@@ -4343,7 +4343,7 @@ set_gdbarch_dtrace_disable_probe (struct gdbarch *gdbarch,
}
int
-gdbarch_has_global_solist (struct gdbarch *gdbarch)
+gdbarch_has_global_solist (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of has_global_solist, invalid_p == 0 */
@@ -4360,7 +4360,7 @@ set_gdbarch_has_global_solist (struct gdbarch *gdbarch,
}
int
-gdbarch_has_global_breakpoints (struct gdbarch *gdbarch)
+gdbarch_has_global_breakpoints (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of has_global_breakpoints, invalid_p == 0 */
@@ -4445,7 +4445,7 @@ set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch,
}
const char *
-gdbarch_solib_symbols_extension (struct gdbarch *gdbarch)
+gdbarch_solib_symbols_extension (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
@@ -4461,7 +4461,7 @@ set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch,
}
int
-gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch)
+gdbarch_has_dos_based_file_system (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of has_dos_based_file_system, invalid_p == 0 */
@@ -4495,7 +4495,7 @@ set_gdbarch_gen_return_address (struct gdbarch *gdbarch,
}
int
-gdbarch_info_proc_p (struct gdbarch *gdbarch)
+gdbarch_info_proc_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->info_proc != NULL;
@@ -4519,7 +4519,7 @@ set_gdbarch_info_proc (struct gdbarch *gdbarch,
}
int
-gdbarch_core_info_proc_p (struct gdbarch *gdbarch)
+gdbarch_core_info_proc_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->core_info_proc != NULL;
@@ -4560,7 +4560,7 @@ set_gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch,
}
struct ravenscar_arch_ops *
-gdbarch_ravenscar_ops (struct gdbarch *gdbarch)
+gdbarch_ravenscar_ops (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of ravenscar_ops, invalid_p == 0 */
@@ -4628,7 +4628,7 @@ set_gdbarch_insn_is_jump (struct gdbarch *gdbarch,
}
int
-gdbarch_auxv_parse_p (struct gdbarch *gdbarch)
+gdbarch_auxv_parse_p (const struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->auxv_parse != NULL;
diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
index 7df37c9..9464561 100644
--- a/gdb/gdbarch.h
+++ b/gdb/gdbarch.h
@@ -101,19 +101,19 @@ typedef void (iterate_over_regset_sections_cb)
/* The following are pre-initialized by GDBARCH. */
-extern const struct bfd_arch_info * gdbarch_bfd_arch_info (struct gdbarch *gdbarch);
+extern const struct bfd_arch_info * gdbarch_bfd_arch_info (const struct gdbarch *gdbarch);
/* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized. */
-extern enum bfd_endian gdbarch_byte_order (struct gdbarch *gdbarch);
+extern enum bfd_endian gdbarch_byte_order (const struct gdbarch *gdbarch);
/* set_gdbarch_byte_order() - not applicable - pre-initialized. */
-extern enum bfd_endian gdbarch_byte_order_for_code (struct gdbarch *gdbarch);
+extern enum bfd_endian gdbarch_byte_order_for_code (const struct gdbarch *gdbarch);
/* set_gdbarch_byte_order_for_code() - not applicable - pre-initialized. */
-extern enum gdb_osabi gdbarch_osabi (struct gdbarch *gdbarch);
+extern enum gdb_osabi gdbarch_osabi (const struct gdbarch *gdbarch);
/* set_gdbarch_osabi() - not applicable - pre-initialized. */
-extern const struct target_desc * gdbarch_target_desc (struct gdbarch *gdbarch);
+extern const struct target_desc * gdbarch_target_desc (const struct gdbarch *gdbarch);
/* set_gdbarch_target_desc() - not applicable - pre-initialized. */
@@ -122,7 +122,7 @@ extern const struct target_desc * gdbarch_target_desc (struct gdbarch *gdbarch);
/* The bit byte-order has to do just with numbering of bits in debugging symbols
and such. Conceptually, it's quite separate from byte/word byte order. */
-extern int gdbarch_bits_big_endian (struct gdbarch *gdbarch);
+extern int gdbarch_bits_big_endian (const struct gdbarch *gdbarch);
extern void set_gdbarch_bits_big_endian (struct gdbarch *gdbarch, int bits_big_endian);
/* Number of bits in a char or unsigned char for the target machine.
@@ -131,29 +131,29 @@ extern void set_gdbarch_bits_big_endian (struct gdbarch *gdbarch, int bits_big_e
Number of bits in a short or unsigned short for the target machine. */
-extern int gdbarch_short_bit (struct gdbarch *gdbarch);
+extern int gdbarch_short_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_short_bit (struct gdbarch *gdbarch, int short_bit);
/* Number of bits in an int or unsigned int for the target machine. */
-extern int gdbarch_int_bit (struct gdbarch *gdbarch);
+extern int gdbarch_int_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_int_bit (struct gdbarch *gdbarch, int int_bit);
/* Number of bits in a long or unsigned long for the target machine. */
-extern int gdbarch_long_bit (struct gdbarch *gdbarch);
+extern int gdbarch_long_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_long_bit (struct gdbarch *gdbarch, int long_bit);
/* Number of bits in a long long or unsigned long long for the target
machine. */
-extern int gdbarch_long_long_bit (struct gdbarch *gdbarch);
+extern int gdbarch_long_long_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_long_long_bit (struct gdbarch *gdbarch, int long_long_bit);
/* Alignment of a long long or unsigned long long for the target
machine. */
-extern int gdbarch_long_long_align_bit (struct gdbarch *gdbarch);
+extern int gdbarch_long_long_align_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_long_long_align_bit (struct gdbarch *gdbarch, int long_long_align_bit);
/* The ABI default bit-size and format for "half", "float", "double", and
@@ -162,28 +162,28 @@ extern void set_gdbarch_long_long_align_bit (struct gdbarch *gdbarch, int long_l
Each format describes both the big and little endian layouts (if
useful). */
-extern int gdbarch_half_bit (struct gdbarch *gdbarch);
+extern int gdbarch_half_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_half_bit (struct gdbarch *gdbarch, int half_bit);
-extern const struct floatformat ** gdbarch_half_format (struct gdbarch *gdbarch);
+extern const struct floatformat ** gdbarch_half_format (const struct gdbarch *gdbarch);
extern void set_gdbarch_half_format (struct gdbarch *gdbarch, const struct floatformat ** half_format);
-extern int gdbarch_float_bit (struct gdbarch *gdbarch);
+extern int gdbarch_float_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_float_bit (struct gdbarch *gdbarch, int float_bit);
-extern const struct floatformat ** gdbarch_float_format (struct gdbarch *gdbarch);
+extern const struct floatformat ** gdbarch_float_format (const struct gdbarch *gdbarch);
extern void set_gdbarch_float_format (struct gdbarch *gdbarch, const struct floatformat ** float_format);
-extern int gdbarch_double_bit (struct gdbarch *gdbarch);
+extern int gdbarch_double_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_double_bit (struct gdbarch *gdbarch, int double_bit);
-extern const struct floatformat ** gdbarch_double_format (struct gdbarch *gdbarch);
+extern const struct floatformat ** gdbarch_double_format (const struct gdbarch *gdbarch);
extern void set_gdbarch_double_format (struct gdbarch *gdbarch, const struct floatformat ** double_format);
-extern int gdbarch_long_double_bit (struct gdbarch *gdbarch);
+extern int gdbarch_long_double_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_long_double_bit (struct gdbarch *gdbarch, int long_double_bit);
-extern const struct floatformat ** gdbarch_long_double_format (struct gdbarch *gdbarch);
+extern const struct floatformat ** gdbarch_long_double_format (const struct gdbarch *gdbarch);
extern void set_gdbarch_long_double_format (struct gdbarch *gdbarch, const struct floatformat ** long_double_format);
/* For most targets, a pointer on the target and its representation as an
@@ -197,12 +197,12 @@ extern void set_gdbarch_long_double_format (struct gdbarch *gdbarch, const struc
ptr_bit is the size of a pointer on the target */
-extern int gdbarch_ptr_bit (struct gdbarch *gdbarch);
+extern int gdbarch_ptr_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_ptr_bit (struct gdbarch *gdbarch, int ptr_bit);
/* addr_bit is the size of a target address as represented in gdb */
-extern int gdbarch_addr_bit (struct gdbarch *gdbarch);
+extern int gdbarch_addr_bit (const struct gdbarch *gdbarch);
extern void set_gdbarch_addr_bit (struct gdbarch *gdbarch, int addr_bit);
/* dwarf2_addr_size is the target address size as used in the Dwarf debug
@@ -219,21 +219,21 @@ extern void set_gdbarch_addr_bit (struct gdbarch *gdbarch, int addr_bit);
GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size,
and if Dwarf versions < 4 need to be supported. */
-extern int gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch);
+extern int gdbarch_dwarf2_addr_size (const struct gdbarch *gdbarch);
extern void set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch, int dwarf2_addr_size);
/* One if `char' acts like `signed char', zero if `unsigned char'. */
-extern int gdbarch_char_signed (struct gdbarch *gdbarch);
+extern int gdbarch_char_signed (const struct gdbarch *gdbarch);
extern void set_gdbarch_char_signed (struct gdbarch *gdbarch, int char_signed);
-extern int gdbarch_read_pc_p (struct gdbarch *gdbarch);
+extern int gdbarch_read_pc_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_read_pc_ftype) (struct regcache *regcache);
extern CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache);
extern void set_gdbarch_read_pc (struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc);
-extern int gdbarch_write_pc_p (struct gdbarch *gdbarch);
+extern int gdbarch_write_pc_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_write_pc_ftype) (struct regcache *regcache, CORE_ADDR val);
extern void gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val);
@@ -247,7 +247,7 @@ typedef void (gdbarch_virtual_frame_pointer_ftype) (struct gdbarch *gdbarch, COR
extern void gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset);
extern void set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer);
-extern int gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch);
+extern int gdbarch_pseudo_register_read_p (const struct gdbarch *gdbarch);
typedef enum register_status (gdbarch_pseudo_register_read_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf);
extern enum register_status gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf);
@@ -258,19 +258,19 @@ extern void set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch, gdbarch_p
as appropriate. If this is defined, then pseudo_register_read will
never be called. */
-extern int gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch);
+extern int gdbarch_pseudo_register_read_value_p (const struct gdbarch *gdbarch);
typedef struct value * (gdbarch_pseudo_register_read_value_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum);
extern struct value * gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum);
extern void set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value);
-extern int gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch);
+extern int gdbarch_pseudo_register_write_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_pseudo_register_write_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf);
extern void gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf);
extern void set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write);
-extern int gdbarch_num_regs (struct gdbarch *gdbarch);
+extern int gdbarch_num_regs (const struct gdbarch *gdbarch);
extern void set_gdbarch_num_regs (struct gdbarch *gdbarch, int num_regs);
/* This macro gives the number of pseudo-registers that live in the
@@ -278,13 +278,13 @@ extern void set_gdbarch_num_regs (struct gdbarch *gdbarch, int num_regs);
These pseudo-registers may be aliases for other registers,
combinations of other registers, or they may be computed by GDB. */
-extern int gdbarch_num_pseudo_regs (struct gdbarch *gdbarch);
+extern int gdbarch_num_pseudo_regs (const struct gdbarch *gdbarch);
extern void set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch, int num_pseudo_regs);
/* Assemble agent expression bytecode to collect pseudo-register REG.
Return -1 if something goes wrong, 0 otherwise. */
-extern int gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch);
+extern int gdbarch_ax_pseudo_register_collect_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_ax_pseudo_register_collect_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
extern int gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
@@ -294,7 +294,7 @@ extern void set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, gdb
REG on the interpreter stack.
Return -1 if something goes wrong, 0 otherwise. */
-extern int gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch);
+extern int gdbarch_ax_pseudo_register_push_stack_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_ax_pseudo_register_push_stack_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
extern int gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
@@ -305,16 +305,16 @@ extern void set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
all (-1).
gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP. */
-extern int gdbarch_sp_regnum (struct gdbarch *gdbarch);
+extern int gdbarch_sp_regnum (const struct gdbarch *gdbarch);
extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum);
-extern int gdbarch_pc_regnum (struct gdbarch *gdbarch);
+extern int gdbarch_pc_regnum (const struct gdbarch *gdbarch);
extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum);
-extern int gdbarch_ps_regnum (struct gdbarch *gdbarch);
+extern int gdbarch_ps_regnum (const struct gdbarch *gdbarch);
extern void set_gdbarch_ps_regnum (struct gdbarch *gdbarch, int ps_regnum);
-extern int gdbarch_fp0_regnum (struct gdbarch *gdbarch);
+extern int gdbarch_fp0_regnum (const struct gdbarch *gdbarch);
extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum);
/* Convert stab register number (from `r' declaration) to a gdb REGNUM. */
@@ -349,13 +349,13 @@ extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register
the register cache should call this function directly; others should
use "register_type". */
-extern int gdbarch_register_type_p (struct gdbarch *gdbarch);
+extern int gdbarch_register_type_p (const struct gdbarch *gdbarch);
typedef struct type * (gdbarch_register_type_ftype) (struct gdbarch *gdbarch, int reg_nr);
extern struct type * gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr);
extern void set_gdbarch_register_type (struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type);
-extern int gdbarch_dummy_id_p (struct gdbarch *gdbarch);
+extern int gdbarch_dummy_id_p (const struct gdbarch *gdbarch);
typedef struct frame_id (gdbarch_dummy_id_ftype) (struct gdbarch *gdbarch, struct frame_info *this_frame);
extern struct frame_id gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame);
@@ -364,19 +364,19 @@ extern void set_gdbarch_dummy_id (struct gdbarch *gdbarch, gdbarch_dummy_id_ftyp
/* Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete
deprecated_fp_regnum. */
-extern int gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch);
+extern int gdbarch_deprecated_fp_regnum (const struct gdbarch *gdbarch);
extern void set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch, int deprecated_fp_regnum);
-extern int gdbarch_push_dummy_call_p (struct gdbarch *gdbarch);
+extern int gdbarch_push_dummy_call_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_push_dummy_call_ftype) (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr);
extern CORE_ADDR gdbarch_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr);
extern void set_gdbarch_push_dummy_call (struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call);
-extern int gdbarch_call_dummy_location (struct gdbarch *gdbarch);
+extern int gdbarch_call_dummy_location (const struct gdbarch *gdbarch);
extern void set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, int call_dummy_location);
-extern int gdbarch_push_dummy_code_p (struct gdbarch *gdbarch);
+extern int gdbarch_push_dummy_code_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_push_dummy_code_ftype) (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache);
extern CORE_ADDR gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache);
@@ -390,7 +390,7 @@ typedef void (gdbarch_print_float_info_ftype) (struct gdbarch *gdbarch, struct u
extern void gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
extern void set_gdbarch_print_float_info (struct gdbarch *gdbarch, gdbarch_print_float_info_ftype *print_float_info);
-extern int gdbarch_print_vector_info_p (struct gdbarch *gdbarch);
+extern int gdbarch_print_vector_info_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_print_vector_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
extern void gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
@@ -416,13 +416,13 @@ extern void set_gdbarch_cannot_store_register (struct gdbarch *gdbarch, gdbarch_
FRAME corresponds to the longjmp frame. */
-extern int gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch);
+extern int gdbarch_get_longjmp_target_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_get_longjmp_target_ftype) (struct frame_info *frame, CORE_ADDR *pc);
extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc);
extern void set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target);
-extern int gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch);
+extern int gdbarch_believe_pcc_promotion (const struct gdbarch *gdbarch);
extern void set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch, int believe_pcc_promotion);
typedef int (gdbarch_convert_register_p_ftype) (struct gdbarch *gdbarch, int regnum, struct type *type);
@@ -454,7 +454,7 @@ typedef void (gdbarch_address_to_pointer_ftype) (struct gdbarch *gdbarch, struct
extern void gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr);
extern void set_gdbarch_address_to_pointer (struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype *address_to_pointer);
-extern int gdbarch_integer_to_address_p (struct gdbarch *gdbarch);
+extern int gdbarch_integer_to_address_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_integer_to_address_ftype) (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
extern CORE_ADDR gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
@@ -471,7 +471,7 @@ extern void set_gdbarch_integer_to_address (struct gdbarch *gdbarch, gdbarch_int
to force the value returned by a function (see the "return" command
for instance). */
-extern int gdbarch_return_value_p (struct gdbarch *gdbarch);
+extern int gdbarch_return_value_p (const struct gdbarch *gdbarch);
typedef enum return_value_convention (gdbarch_return_value_ftype) (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf);
extern enum return_value_convention gdbarch_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf);
@@ -491,7 +491,7 @@ typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (struct gdbarch *gdbarch, CORE_A
extern CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
extern void set_gdbarch_skip_prologue (struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue);
-extern int gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch);
+extern int gdbarch_skip_main_prologue_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_skip_main_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip);
extern CORE_ADDR gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
@@ -509,7 +509,7 @@ extern void set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch, gdbarch_ski
by GDB common code even when debugging optimized code, where skip_prologue
is not used. */
-extern int gdbarch_skip_entrypoint_p (struct gdbarch *gdbarch);
+extern int gdbarch_skip_entrypoint_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_skip_entrypoint_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip);
extern CORE_ADDR gdbarch_skip_entrypoint (struct gdbarch *gdbarch, CORE_ADDR ip);
@@ -531,7 +531,7 @@ typedef void (gdbarch_remote_breakpoint_from_pc_ftype) (struct gdbarch *gdbarch,
extern void gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr);
extern void set_gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_remote_breakpoint_from_pc_ftype *remote_breakpoint_from_pc);
-extern int gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch);
+extern int gdbarch_adjust_breakpoint_address_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_adjust_breakpoint_address_ftype) (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
extern CORE_ADDR gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
@@ -545,7 +545,7 @@ typedef int (gdbarch_memory_remove_breakpoint_ftype) (struct gdbarch *gdbarch, s
extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint);
-extern CORE_ADDR gdbarch_decr_pc_after_break (struct gdbarch *gdbarch);
+extern CORE_ADDR gdbarch_decr_pc_after_break (const struct gdbarch *gdbarch);
extern void set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break);
/* A function can be addressed by either it's "pointer" (possibly a
@@ -556,7 +556,7 @@ extern void set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, CORE_ADDR
corresponds to the "function pointer" and the function's start
corresponds to the "function entry point" - and hence is redundant. */
-extern CORE_ADDR gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch);
+extern CORE_ADDR gdbarch_deprecated_function_start_offset (const struct gdbarch *gdbarch);
extern void set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch, CORE_ADDR deprecated_function_start_offset);
/* Return the remote protocol register number associated with this
@@ -568,22 +568,22 @@ extern void set_gdbarch_remote_register_number (struct gdbarch *gdbarch, gdbarch
/* Fetch the target specific address used to represent a load module. */
-extern int gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch);
+extern int gdbarch_fetch_tls_load_module_address_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_fetch_tls_load_module_address_ftype) (struct objfile *objfile);
extern CORE_ADDR gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile);
extern void set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address);
-extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
+extern CORE_ADDR gdbarch_frame_args_skip (const struct gdbarch *gdbarch);
extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
-extern int gdbarch_unwind_pc_p (struct gdbarch *gdbarch);
+extern int gdbarch_unwind_pc_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_unwind_pc_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame);
extern CORE_ADDR gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame);
extern void set_gdbarch_unwind_pc (struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype *unwind_pc);
-extern int gdbarch_unwind_sp_p (struct gdbarch *gdbarch);
+extern int gdbarch_unwind_sp_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_unwind_sp_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame);
extern CORE_ADDR gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame);
@@ -592,13 +592,13 @@ extern void set_gdbarch_unwind_sp (struct gdbarch *gdbarch, gdbarch_unwind_sp_ft
/* DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
frame-base. Enable frame-base before frame-unwind. */
-extern int gdbarch_frame_num_args_p (struct gdbarch *gdbarch);
+extern int gdbarch_frame_num_args_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_frame_num_args_ftype) (struct frame_info *frame);
extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame);
extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args);
-extern int gdbarch_frame_align_p (struct gdbarch *gdbarch);
+extern int gdbarch_frame_align_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_frame_align_ftype) (struct gdbarch *gdbarch, CORE_ADDR address);
extern CORE_ADDR gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address);
@@ -608,7 +608,7 @@ typedef int (gdbarch_stabs_argument_has_addr_ftype) (struct gdbarch *gdbarch, st
extern int gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type);
extern void set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr);
-extern int gdbarch_frame_red_zone_size (struct gdbarch *gdbarch);
+extern int gdbarch_frame_red_zone_size (const struct gdbarch *gdbarch);
extern void set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch, int frame_red_zone_size);
typedef CORE_ADDR (gdbarch_convert_from_func_ptr_addr_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ);
@@ -643,7 +643,7 @@ extern void set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch, gdbarch_addr_
A return value of 1 means that the software_single_step breakpoints
were inserted; 0 means they were not. */
-extern int gdbarch_software_single_step_p (struct gdbarch *gdbarch);
+extern int gdbarch_software_single_step_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_software_single_step_ftype) (struct frame_info *frame);
extern int gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame);
@@ -652,7 +652,7 @@ extern void set_gdbarch_software_single_step (struct gdbarch *gdbarch, gdbarch_s
/* Return non-zero if the processor is executing a delay slot and a
further single-step is needed before the instruction finishes. */
-extern int gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch);
+extern int gdbarch_single_step_through_delay_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_single_step_through_delay_ftype) (struct gdbarch *gdbarch, struct frame_info *frame);
extern int gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame);
@@ -705,7 +705,7 @@ extern void set_gdbarch_stack_frame_destroyed_p (struct gdbarch *gdbarch, gdbarc
that they can be treated in the appropriate manner in the processing of
the main symbol table and DWARF-2 records. */
-extern int gdbarch_elf_make_msymbol_special_p (struct gdbarch *gdbarch);
+extern int gdbarch_elf_make_msymbol_special_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_elf_make_msymbol_special_ftype) (asymbol *sym, struct minimal_symbol *msym);
extern void gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym);
@@ -754,19 +754,19 @@ typedef CORE_ADDR (gdbarch_adjust_dwarf2_line_ftype) (CORE_ADDR addr, int rel);
extern CORE_ADDR gdbarch_adjust_dwarf2_line (struct gdbarch *gdbarch, CORE_ADDR addr, int rel);
extern void set_gdbarch_adjust_dwarf2_line (struct gdbarch *gdbarch, gdbarch_adjust_dwarf2_line_ftype *adjust_dwarf2_line);
-extern int gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch);
+extern int gdbarch_cannot_step_breakpoint (const struct gdbarch *gdbarch);
extern void set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch, int cannot_step_breakpoint);
-extern int gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch);
+extern int gdbarch_have_nonsteppable_watchpoint (const struct gdbarch *gdbarch);
extern void set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch, int have_nonsteppable_watchpoint);
-extern int gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch);
+extern int gdbarch_address_class_type_flags_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_address_class_type_flags_ftype) (int byte_size, int dwarf2_addr_class);
extern int gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class);
extern void set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags);
-extern int gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch);
+extern int gdbarch_address_class_type_flags_to_name_p (const struct gdbarch *gdbarch);
typedef const char * (gdbarch_address_class_type_flags_to_name_ftype) (struct gdbarch *gdbarch, int type_flags);
extern const char * gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags);
@@ -776,7 +776,7 @@ extern void set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarc
This function should return 1 if the address class was recognized and
type_flags was set, zero otherwise. */
-extern int gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch);
+extern int gdbarch_address_class_name_to_type_flags_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_address_class_name_to_type_flags_ftype) (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
extern int gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
@@ -790,7 +790,7 @@ extern void set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch, gdbarch_re
/* Fetch the pointer to the ith function argument. */
-extern int gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch);
+extern int gdbarch_fetch_pointer_argument_p (const struct gdbarch *gdbarch);
typedef CORE_ADDR (gdbarch_fetch_pointer_argument_ftype) (struct frame_info *frame, int argi, struct type *type);
extern CORE_ADDR gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type);
@@ -803,7 +803,7 @@ extern void set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, gdbarch
values. Otherwise it should enumerate all supported register note
sections. */
-extern int gdbarch_iterate_over_regset_sections_p (struct gdbarch *gdbarch);
+extern int gdbarch_iterate_over_regset_sections_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_iterate_over_regset_sections_ftype) (struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache);
extern void gdbarch_iterate_over_regset_sections (struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache);
@@ -811,7 +811,7 @@ extern void set_gdbarch_iterate_over_regset_sections (struct gdbarch *gdbarch, g
/* Create core file notes */
-extern int gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch);
+extern int gdbarch_make_corefile_notes_p (const struct gdbarch *gdbarch);
typedef char * (gdbarch_make_corefile_notes_ftype) (struct gdbarch *gdbarch, bfd *obfd, int *note_size);
extern char * gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size);
@@ -823,7 +823,7 @@ extern void set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch, gdbarch_ma
call the Linux generic routines in bfd to write prpsinfo notes by
default. */
-extern int gdbarch_elfcore_write_linux_prpsinfo_p (struct gdbarch *gdbarch);
+extern int gdbarch_elfcore_write_linux_prpsinfo_p (const struct gdbarch *gdbarch);
typedef char * (gdbarch_elfcore_write_linux_prpsinfo_ftype) (bfd *obfd, char *note_data, int *note_size, const struct elf_internal_linux_prpsinfo *info);
extern char * gdbarch_elfcore_write_linux_prpsinfo (struct gdbarch *gdbarch, bfd *obfd, char *note_data, int *note_size, const struct elf_internal_linux_prpsinfo *info);
@@ -831,7 +831,7 @@ extern void set_gdbarch_elfcore_write_linux_prpsinfo (struct gdbarch *gdbarch, g
/* Find core file memory regions */
-extern int gdbarch_find_memory_regions_p (struct gdbarch *gdbarch);
+extern int gdbarch_find_memory_regions_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_find_memory_regions_ftype) (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data);
extern int gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data);
@@ -842,7 +842,7 @@ extern void set_gdbarch_find_memory_regions (struct gdbarch *gdbarch, gdbarch_fi
(zero indicates failure).
failed, otherwise, return the red length of READBUF. */
-extern int gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch);
+extern int gdbarch_core_xfer_shared_libraries_p (const struct gdbarch *gdbarch);
typedef ULONGEST (gdbarch_core_xfer_shared_libraries_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
extern ULONGEST gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
@@ -852,7 +852,7 @@ extern void set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb
libraries list from core file into buffer READBUF with length LEN.
Return the number of bytes read (zero indicates failure). */
-extern int gdbarch_core_xfer_shared_libraries_aix_p (struct gdbarch *gdbarch);
+extern int gdbarch_core_xfer_shared_libraries_aix_p (const struct gdbarch *gdbarch);
typedef ULONGEST (gdbarch_core_xfer_shared_libraries_aix_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
extern ULONGEST gdbarch_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
@@ -860,7 +860,7 @@ extern void set_gdbarch_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch,
/* How the core target converts a PTID from a core file to a string. */
-extern int gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch);
+extern int gdbarch_core_pid_to_str_p (const struct gdbarch *gdbarch);
typedef char * (gdbarch_core_pid_to_str_ftype) (struct gdbarch *gdbarch, ptid_t ptid);
extern char * gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid);
@@ -868,22 +868,22 @@ extern void set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch, gdbarch_core_p
/* BFD target to use when generating a core file. */
-extern int gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch);
+extern int gdbarch_gcore_bfd_target_p (const struct gdbarch *gdbarch);
-extern const char * gdbarch_gcore_bfd_target (struct gdbarch *gdbarch);
+extern const char * gdbarch_gcore_bfd_target (const struct gdbarch *gdbarch);
extern void set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch, const char * gcore_bfd_target);
/* If the elements of C++ vtables are in-place function descriptors rather
than normal function pointers (which may point to code or a descriptor),
set this to one. */
-extern int gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch);
+extern int gdbarch_vtable_function_descriptors (const struct gdbarch *gdbarch);
extern void set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch, int vtable_function_descriptors);
/* Set if the least significant bit of the delta is used instead of the least
significant bit of the pfn for pointers to virtual member functions. */
-extern int gdbarch_vbit_in_delta (struct gdbarch *gdbarch);
+extern int gdbarch_vbit_in_delta (const struct gdbarch *gdbarch);
extern void set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch, int vbit_in_delta);
/* Advance PC to next instruction in order to skip a permanent breakpoint. */
@@ -894,9 +894,9 @@ extern void set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, gdba
/* The maximum length of an instruction on this architecture in bytes. */
-extern int gdbarch_max_insn_length_p (struct gdbarch *gdbarch);
+extern int gdbarch_max_insn_length_p (const struct gdbarch *gdbarch);
-extern ULONGEST gdbarch_max_insn_length (struct gdbarch *gdbarch);
+extern ULONGEST gdbarch_max_insn_length (const struct gdbarch *gdbarch);
extern void set_gdbarch_max_insn_length (struct gdbarch *gdbarch, ULONGEST max_insn_length);
/* Copy the instruction at FROM to TO, and make any adjustments
@@ -929,7 +929,7 @@ extern void set_gdbarch_max_insn_length (struct gdbarch *gdbarch, ULONGEST max_i
core falls back to stepping past the instruction in-line instead in
that case. */
-extern int gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch);
+extern int gdbarch_displaced_step_copy_insn_p (const struct gdbarch *gdbarch);
typedef struct displaced_step_closure * (gdbarch_displaced_step_copy_insn_ftype) (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
extern struct displaced_step_closure * gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
@@ -966,7 +966,7 @@ extern void set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, g
For a general explanation of displaced stepping and how GDB uses it,
see the comments in infrun.c. */
-extern int gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch);
+extern int gdbarch_displaced_step_fixup_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_displaced_step_fixup_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
extern void gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
@@ -1011,7 +1011,7 @@ extern void set_gdbarch_displaced_step_location (struct gdbarch *gdbarch, gdbarc
relative branches, and other PC-relative instructions need the
offset adjusted; etc. */
-extern int gdbarch_relocate_instruction_p (struct gdbarch *gdbarch);
+extern int gdbarch_relocate_instruction_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_relocate_instruction_ftype) (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from);
extern void gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from);
@@ -1019,13 +1019,13 @@ extern void set_gdbarch_relocate_instruction (struct gdbarch *gdbarch, gdbarch_r
/* Refresh overlay mapped state for section OSECT. */
-extern int gdbarch_overlay_update_p (struct gdbarch *gdbarch);
+extern int gdbarch_overlay_update_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_overlay_update_ftype) (struct obj_section *osect);
extern void gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect);
extern void set_gdbarch_overlay_update (struct gdbarch *gdbarch, gdbarch_overlay_update_ftype *overlay_update);
-extern int gdbarch_core_read_description_p (struct gdbarch *gdbarch);
+extern int gdbarch_core_read_description_p (const struct gdbarch *gdbarch);
typedef const struct target_desc * (gdbarch_core_read_description_ftype) (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd);
extern const struct target_desc * gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd);
@@ -1033,7 +1033,7 @@ extern void set_gdbarch_core_read_description (struct gdbarch *gdbarch, gdbarch_
/* Handle special encoding of static variables in stabs debug info. */
-extern int gdbarch_static_transform_name_p (struct gdbarch *gdbarch);
+extern int gdbarch_static_transform_name_p (const struct gdbarch *gdbarch);
typedef const char * (gdbarch_static_transform_name_ftype) (const char *name);
extern const char * gdbarch_static_transform_name (struct gdbarch *gdbarch, const char *name);
@@ -1041,7 +1041,7 @@ extern void set_gdbarch_static_transform_name (struct gdbarch *gdbarch, gdbarch_
/* Set if the address in N_SO or N_FUN stabs may be zero. */
-extern int gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch);
+extern int gdbarch_sofun_address_maybe_missing (const struct gdbarch *gdbarch);
extern void set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch, int sofun_address_maybe_missing);
/* Parse the instruction at ADDR storing in the record execution log
@@ -1049,7 +1049,7 @@ extern void set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch, in
the instruction executes, along with their current values.
Return -1 if something goes wrong, 0 otherwise. */
-extern int gdbarch_process_record_p (struct gdbarch *gdbarch);
+extern int gdbarch_process_record_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_process_record_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
extern int gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
@@ -1058,7 +1058,7 @@ extern void set_gdbarch_process_record (struct gdbarch *gdbarch, gdbarch_process
/* Save process state after a signal.
Return -1 if something goes wrong, 0 otherwise. */
-extern int gdbarch_process_record_signal_p (struct gdbarch *gdbarch);
+extern int gdbarch_process_record_signal_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_process_record_signal_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal);
extern int gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal);
@@ -1072,7 +1072,7 @@ extern void set_gdbarch_process_record_signal (struct gdbarch *gdbarch, gdbarch_
"Live" targets hide the translation behind the target interface
(target_wait, target_resume, etc.). */
-extern int gdbarch_gdb_signal_from_target_p (struct gdbarch *gdbarch);
+extern int gdbarch_gdb_signal_from_target_p (const struct gdbarch *gdbarch);
typedef enum gdb_signal (gdbarch_gdb_signal_from_target_ftype) (struct gdbarch *gdbarch, int signo);
extern enum gdb_signal gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, int signo);
@@ -1086,7 +1086,7 @@ extern void set_gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, gdbarch
Return the target signal number if found, or -1 if the GDB internal
signal number is invalid. */
-extern int gdbarch_gdb_signal_to_target_p (struct gdbarch *gdbarch);
+extern int gdbarch_gdb_signal_to_target_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_gdb_signal_to_target_ftype) (struct gdbarch *gdbarch, enum gdb_signal signal);
extern int gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal);
@@ -1096,7 +1096,7 @@ extern void set_gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch, gdbarch_g
Return a type suitable to inspect extra signal information. */
-extern int gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch);
+extern int gdbarch_get_siginfo_type_p (const struct gdbarch *gdbarch);
typedef struct type * (gdbarch_get_siginfo_type_ftype) (struct gdbarch *gdbarch);
extern struct type * gdbarch_get_siginfo_type (struct gdbarch *gdbarch);
@@ -1104,7 +1104,7 @@ extern void set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch, gdbarch_get_s
/* Record architecture-specific information from the symbol table. */
-extern int gdbarch_record_special_symbol_p (struct gdbarch *gdbarch);
+extern int gdbarch_record_special_symbol_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_record_special_symbol_ftype) (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym);
extern void gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym);
@@ -1113,7 +1113,7 @@ extern void set_gdbarch_record_special_symbol (struct gdbarch *gdbarch, gdbarch_
/* Function for the 'catch syscall' feature.
Get architecture-specific system calls information from registers. */
-extern int gdbarch_get_syscall_number_p (struct gdbarch *gdbarch);
+extern int gdbarch_get_syscall_number_p (const struct gdbarch *gdbarch);
typedef LONGEST (gdbarch_get_syscall_number_ftype) (struct gdbarch *gdbarch, ptid_t ptid);
extern LONGEST gdbarch_get_syscall_number (struct gdbarch *gdbarch, ptid_t ptid);
@@ -1121,12 +1121,12 @@ extern void set_gdbarch_get_syscall_number (struct gdbarch *gdbarch, gdbarch_get
/* The filename of the XML syscall for this architecture. */
-extern const char * gdbarch_xml_syscall_file (struct gdbarch *gdbarch);
+extern const char * gdbarch_xml_syscall_file (const struct gdbarch *gdbarch);
extern void set_gdbarch_xml_syscall_file (struct gdbarch *gdbarch, const char * xml_syscall_file);
/* Information about system calls from this architecture */
-extern struct syscalls_info * gdbarch_syscalls_info (struct gdbarch *gdbarch);
+extern struct syscalls_info * gdbarch_syscalls_info (const struct gdbarch *gdbarch);
extern void set_gdbarch_syscalls_info (struct gdbarch *gdbarch, struct syscalls_info * syscalls_info);
/* SystemTap related fields and functions.
@@ -1138,13 +1138,13 @@ extern void set_gdbarch_syscalls_info (struct gdbarch *gdbarch, struct syscalls_
in this case, this prefix would be the character `$'. */
-extern const char *const * gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch);
+extern const char *const * gdbarch_stap_integer_prefixes (const struct gdbarch *gdbarch);
extern void set_gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch, const char *const * stap_integer_prefixes);
/* A NULL-terminated array of suffixes used to mark an integer constant
on the architecture's assembly. */
-extern const char *const * gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch);
+extern const char *const * gdbarch_stap_integer_suffixes (const struct gdbarch *gdbarch);
extern void set_gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch, const char *const * stap_integer_suffixes);
/* A NULL-terminated array of prefixes used to mark a register name on
@@ -1155,13 +1155,13 @@ extern void set_gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch, const ch
in this case, this prefix would be the character `%'. */
-extern const char *const * gdbarch_stap_register_prefixes (struct gdbarch *gdbarch);
+extern const char *const * gdbarch_stap_register_prefixes (const struct gdbarch *gdbarch);
extern void set_gdbarch_stap_register_prefixes (struct gdbarch *gdbarch, const char *const * stap_register_prefixes);
/* A NULL-terminated array of suffixes used to mark a register name on
the architecture's assembly. */
-extern const char *const * gdbarch_stap_register_suffixes (struct gdbarch *gdbarch);
+extern const char *const * gdbarch_stap_register_suffixes (const struct gdbarch *gdbarch);
extern void set_gdbarch_stap_register_suffixes (struct gdbarch *gdbarch, const char *const * stap_register_suffixes);
/* A NULL-terminated array of prefixes used to mark a register
@@ -1175,7 +1175,7 @@ extern void set_gdbarch_stap_register_suffixes (struct gdbarch *gdbarch, const c
Please note that we use the indirection prefix also for register
displacement, e.g., `4(%eax)' on x86. */
-extern const char *const * gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdbarch);
+extern const char *const * gdbarch_stap_register_indirection_prefixes (const struct gdbarch *gdbarch);
extern void set_gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdbarch, const char *const * stap_register_indirection_prefixes);
/* A NULL-terminated array of suffixes used to mark a register
@@ -1189,7 +1189,7 @@ extern void set_gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdba
Please note that we use the indirection suffix also for register
displacement, e.g., `4(%eax)' on x86. */
-extern const char *const * gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch);
+extern const char *const * gdbarch_stap_register_indirection_suffixes (const struct gdbarch *gdbarch);
extern void set_gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch, const char *const * stap_register_indirection_suffixes);
/* Prefix(es) used to name a register using GDB's nomenclature.
@@ -1199,12 +1199,12 @@ extern void set_gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdba
inside GDB this same register has an `r' appended to its name, so the 10th
register would be represented as `r10' internally. */
-extern const char * gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch);
+extern const char * gdbarch_stap_gdb_register_prefix (const struct gdbarch *gdbarch);
extern void set_gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch, const char * stap_gdb_register_prefix);
/* Suffix used to name a register using GDB's nomenclature. */
-extern const char * gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch);
+extern const char * gdbarch_stap_gdb_register_suffix (const struct gdbarch *gdbarch);
extern void set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch, const char * stap_gdb_register_suffix);
/* Check if S is a single operand.
@@ -1220,7 +1220,7 @@ extern void set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch, const
as much info as you can from the string, i.e., if you have to match
something like `(%', do not match just the `('. */
-extern int gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch);
+extern int gdbarch_stap_is_single_operand_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_stap_is_single_operand_ftype) (struct gdbarch *gdbarch, const char *s);
extern int gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s);
@@ -1248,7 +1248,7 @@ extern void set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, gdbarch
zero means that the special parser is deferring the parsing to the generic
parser), and should advance the buffer pointer (p->arg). */
-extern int gdbarch_stap_parse_special_token_p (struct gdbarch *gdbarch);
+extern int gdbarch_stap_parse_special_token_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_stap_parse_special_token_ftype) (struct gdbarch *gdbarch, struct stap_parse_info *p);
extern int gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p);
@@ -1258,7 +1258,7 @@ extern void set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, gdbar
The expression to compute the NARTGth+1 argument to a DTrace USDT probe.
NARG must be >= 0. */
-extern int gdbarch_dtrace_parse_probe_argument_p (struct gdbarch *gdbarch);
+extern int gdbarch_dtrace_parse_probe_argument_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_dtrace_parse_probe_argument_ftype) (struct gdbarch *gdbarch, struct parser_state *pstate, int narg);
extern void gdbarch_dtrace_parse_probe_argument (struct gdbarch *gdbarch, struct parser_state *pstate, int narg);
@@ -1267,7 +1267,7 @@ extern void set_gdbarch_dtrace_parse_probe_argument (struct gdbarch *gdbarch, gd
/* True if the given ADDR does not contain the instruction sequence
corresponding to a disabled DTrace is-enabled probe. */
-extern int gdbarch_dtrace_probe_is_enabled_p (struct gdbarch *gdbarch);
+extern int gdbarch_dtrace_probe_is_enabled_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_dtrace_probe_is_enabled_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
extern int gdbarch_dtrace_probe_is_enabled (struct gdbarch *gdbarch, CORE_ADDR addr);
@@ -1275,7 +1275,7 @@ extern void set_gdbarch_dtrace_probe_is_enabled (struct gdbarch *gdbarch, gdbarc
/* Enable a DTrace is-enabled probe at ADDR. */
-extern int gdbarch_dtrace_enable_probe_p (struct gdbarch *gdbarch);
+extern int gdbarch_dtrace_enable_probe_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_dtrace_enable_probe_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
extern void gdbarch_dtrace_enable_probe (struct gdbarch *gdbarch, CORE_ADDR addr);
@@ -1283,7 +1283,7 @@ extern void set_gdbarch_dtrace_enable_probe (struct gdbarch *gdbarch, gdbarch_dt
/* Disable a DTrace is-enabled probe at ADDR. */
-extern int gdbarch_dtrace_disable_probe_p (struct gdbarch *gdbarch);
+extern int gdbarch_dtrace_disable_probe_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_dtrace_disable_probe_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
extern void gdbarch_dtrace_disable_probe (struct gdbarch *gdbarch, CORE_ADDR addr);
@@ -1295,7 +1295,7 @@ extern void set_gdbarch_dtrace_disable_probe (struct gdbarch *gdbarch, gdbarch_d
an address space, will see the same set of symbols at the same
addresses. */
-extern int gdbarch_has_global_solist (struct gdbarch *gdbarch);
+extern int gdbarch_has_global_solist (const struct gdbarch *gdbarch);
extern void set_gdbarch_has_global_solist (struct gdbarch *gdbarch, int has_global_solist);
/* On some targets, even though each inferior has its own private
@@ -1303,7 +1303,7 @@ extern void set_gdbarch_has_global_solist (struct gdbarch *gdbarch, int has_glob
visible to all address spaces automatically. For such cases,
this property should be set to true. */
-extern int gdbarch_has_global_breakpoints (struct gdbarch *gdbarch);
+extern int gdbarch_has_global_breakpoints (const struct gdbarch *gdbarch);
extern void set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch, int has_global_breakpoints);
/* True if inferiors share an address space (e.g., uClinux). */
@@ -1337,14 +1337,14 @@ extern void set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch, gdbarch_auto
where the names of the files run on the target differ in extension
compared to the names of the files GDB should load for debug info. */
-extern const char * gdbarch_solib_symbols_extension (struct gdbarch *gdbarch);
+extern const char * gdbarch_solib_symbols_extension (const struct gdbarch *gdbarch);
extern void set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch, const char * solib_symbols_extension);
/* If true, the target OS has DOS-based file system semantics. That
is, absolute paths include a drive name, and the backslash is
considered a directory separator. */
-extern int gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch);
+extern int gdbarch_has_dos_based_file_system (const struct gdbarch *gdbarch);
extern void set_gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch, int has_dos_based_file_system);
/* Generate bytecodes to collect the return address in a frame.
@@ -1359,7 +1359,7 @@ extern void set_gdbarch_gen_return_address (struct gdbarch *gdbarch, gdbarch_gen
/* Implement the "info proc" command. */
-extern int gdbarch_info_proc_p (struct gdbarch *gdbarch);
+extern int gdbarch_info_proc_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_info_proc_ftype) (struct gdbarch *gdbarch, const char *args, enum info_proc_what what);
extern void gdbarch_info_proc (struct gdbarch *gdbarch, const char *args, enum info_proc_what what);
@@ -1369,7 +1369,7 @@ extern void set_gdbarch_info_proc (struct gdbarch *gdbarch, gdbarch_info_proc_ft
are two "info_proc"-like methods on gdbarch -- one for core files,
one for live targets. */
-extern int gdbarch_core_info_proc_p (struct gdbarch *gdbarch);
+extern int gdbarch_core_info_proc_p (const struct gdbarch *gdbarch);
typedef void (gdbarch_core_info_proc_ftype) (struct gdbarch *gdbarch, const char *args, enum info_proc_what what);
extern void gdbarch_core_info_proc (struct gdbarch *gdbarch, const char *args, enum info_proc_what what);
@@ -1395,7 +1395,7 @@ extern void set_gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *g
/* Ravenscar arch-dependent ops. */
-extern struct ravenscar_arch_ops * gdbarch_ravenscar_ops (struct gdbarch *gdbarch);
+extern struct ravenscar_arch_ops * gdbarch_ravenscar_ops (const struct gdbarch *gdbarch);
extern void set_gdbarch_ravenscar_ops (struct gdbarch *gdbarch, struct ravenscar_arch_ops * ravenscar_ops);
/* Return non-zero if the instruction at ADDR is a call; zero otherwise. */
@@ -1421,7 +1421,7 @@ extern void set_gdbarch_insn_is_jump (struct gdbarch *gdbarch, gdbarch_insn_is_j
Return -1 if there is insufficient buffer for a whole entry.
Return 1 if an entry was read into *TYPEP and *VALP. */
-extern int gdbarch_auxv_parse_p (struct gdbarch *gdbarch);
+extern int gdbarch_auxv_parse_p (const struct gdbarch *gdbarch);
typedef int (gdbarch_auxv_parse_ftype) (struct gdbarch *gdbarch, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp);
extern int gdbarch_auxv_parse (struct gdbarch *gdbarch, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp);
diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
index 34e6a74..9338c24 100755
--- a/gdb/gdbarch.sh
+++ b/gdb/gdbarch.sh
@@ -1291,7 +1291,7 @@ do
if class_is_info_p
then
printf "\n"
- printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
+ printf "extern ${returntype} gdbarch_${function} (const struct gdbarch *gdbarch);\n"
printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
fi
done
@@ -1313,12 +1313,12 @@ do
if class_is_predicate_p
then
printf "\n"
- printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
+ printf "extern int gdbarch_${function}_p (const struct gdbarch *gdbarch);\n"
fi
if class_is_variable_p
then
printf "\n"
- printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
+ printf "extern ${returntype} gdbarch_${function} (const struct gdbarch *gdbarch);\n"
printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
fi
if class_is_function_p
@@ -1957,7 +1957,7 @@ do
then
printf "\n"
printf "int\n"
- printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
+ printf "gdbarch_${function}_p (const struct gdbarch *gdbarch)\n"
printf "{\n"
printf " gdb_assert (gdbarch != NULL);\n"
printf " return ${predicate};\n"
@@ -2017,7 +2017,7 @@ do
then
printf "\n"
printf "${returntype}\n"
- printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
+ printf "gdbarch_${function} (const struct gdbarch *gdbarch)\n"
printf "{\n"
printf " gdb_assert (gdbarch != NULL);\n"
if [ "x${invalid_p}" = "x0" ]
@@ -2047,7 +2047,7 @@ do
then
printf "\n"
printf "${returntype}\n"
- printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
+ printf "gdbarch_${function} (const struct gdbarch *gdbarch)\n"
printf "{\n"
printf " gdb_assert (gdbarch != NULL);\n"
printf " if (gdbarch_debug >= 2)\n"
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 8204d39..404f38b 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -1413,13 +1413,13 @@ type_name_no_tag_or_error (struct type *type)
struct type *
lookup_typename (const struct language_defn *language,
- struct gdbarch *gdbarch, const char *name,
+ const struct gdbarch *gdbarch, const char *name,
const struct block *block, int noerr)
{
struct symbol *sym;
struct type *type;
- sym = lookup_symbol_in_language (name, block, VAR_DOMAIN,
+ sym = lookup_symbol_in_language (name, block, gdbarch, VAR_DOMAIN,
language->la_language, NULL).symbol;
if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
return SYMBOL_TYPE (sym);
@@ -1460,11 +1460,12 @@ lookup_signed_typename (const struct language_defn *language,
visible in lexical block BLOCK. */
struct type *
-lookup_struct (const char *name, const struct block *block)
+lookup_struct (const char *name, const struct block *block,
+ const struct gdbarch *gdbarch)
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, block, gdbarch, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
@@ -1482,12 +1483,13 @@ lookup_struct (const char *name, const struct block *block)
visible in lexical block BLOCK. */
struct type *
-lookup_union (const char *name, const struct block *block)
+lookup_union (const char *name, const struct block *block,
+ const struct gdbarch *gdbarch)
{
struct symbol *sym;
struct type *t;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, block, gdbarch, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
error (_("No union type named %s."), name);
@@ -1506,11 +1508,12 @@ lookup_union (const char *name, const struct block *block)
visible in lexical block BLOCK. */
struct type *
-lookup_enum (const char *name, const struct block *block)
+lookup_enum (const char *name, const struct block *block,
+ const struct gdbarch *gdbarch)
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, block, gdbarch, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
error (_("No enum type named %s."), name);
@@ -1528,7 +1531,8 @@ lookup_enum (const char *name, const struct block *block)
struct type *
lookup_template_type (char *name, struct type *type,
- const struct block *block)
+ const struct block *block,
+ const struct gdbarch *gdbarch)
{
struct symbol *sym;
char *nam = (char *)
@@ -1539,7 +1543,7 @@ lookup_template_type (char *name, struct type *type,
strcat (nam, TYPE_NAME (type));
strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
- sym = lookup_symbol (nam, block, VAR_DOMAIN, 0).symbol;
+ sym = lookup_symbol (nam, block, gdbarch, VAR_DOMAIN, 0).symbol;
if (sym == NULL)
{
@@ -2257,7 +2261,8 @@ check_typedef (struct type *type)
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, 0, get_type_arch (type), STRUCT_DOMAIN,
+ 0).symbol;
if (sym)
TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
else /* TYPE_CODE_UNDEF */
@@ -2348,7 +2353,8 @@ check_typedef (struct type *type)
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, 0, get_type_arch (type), STRUCT_DOMAIN,
+ 0).symbol;
if (sym)
{
/* Same as above for opaque types, we can replace the stub
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index f270855..f134083 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -1816,11 +1816,12 @@ extern void check_stub_method_group (struct type *, int);
extern char *gdb_mangle_name (struct type *, int, int);
extern struct type *lookup_typename (const struct language_defn *,
- struct gdbarch *, const char *,
+ const struct gdbarch *, const char *,
const struct block *, int);
extern struct type *lookup_template_type (char *, struct type *,
- const struct block *);
+ const struct block *,
+ const struct gdbarch *);
extern int get_vptr_fieldno (struct type *, struct type **);
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 3b6cc77..8f3c1fb 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -1061,8 +1061,8 @@ gnuv3_get_typeid_type (struct gdbarch *gdbarch)
struct symbol *typeinfo;
struct type *typeinfo_type;
- typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN,
- NULL).symbol;
+ typeinfo = lookup_symbol_for_arch ("std::type_info", gdbarch,
+ STRUCT_DOMAIN).symbol;
if (typeinfo == NULL)
typeinfo_type = gdbarch_data (gdbarch, std_type_info_gdbarch_data);
else
diff --git a/gdb/go-exp.y b/gdb/go-exp.y
index 4e017fe..1ede04f 100644
--- a/gdb/go-exp.y
+++ b/gdb/go-exp.y
@@ -1374,12 +1374,11 @@ build_packaged_name (const char *package, int package_len,
to mean the global scope. */
static int
-package_name_p (const char *name, const struct block *block)
+package_name_p (const char *name, const struct block *block,
+ const struct gdbarch *gdbarch)
{
- struct symbol *sym;
- struct field_of_this_result is_a_field_of_this;
-
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, &is_a_field_of_this).symbol;
+ struct symbol *sym = lookup_symbol (name, block, gdbarch, STRUCT_DOMAIN,
+ NULL).symbol;
if (sym
&& SYMBOL_CLASS (sym) == LOC_TYPEDEF
@@ -1414,7 +1413,8 @@ classify_unsafe_function (struct stoken function_name)
The result is one of NAME, NAME_OR_INT, or TYPENAME. */
static int
-classify_packaged_name (const struct block *block)
+classify_packaged_name (const struct block *block,
+ const struct gdbarch *gdbarch)
{
char *copy;
struct block_symbol sym;
@@ -1422,7 +1422,7 @@ classify_packaged_name (const struct block *block)
copy = copy_name (yylval.sval);
- sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
+ sym = lookup_symbol (copy, block, gdbarch, VAR_DOMAIN, &is_a_field_of_this);
if (sym.symbol)
{
@@ -1466,7 +1466,8 @@ classify_name (struct parser_state *par_state, const struct block *block)
/* TODO: What about other types? */
- sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
+ sym = lookup_symbol (copy, block, parse_gdbarch (par_state), VAR_DOMAIN,
+ &is_a_field_of_this);
if (sym.symbol)
{
@@ -1491,8 +1492,8 @@ classify_name (struct parser_state *par_state, const struct block *block)
copy, strlen (copy));
xfree (current_package_name);
- sym = lookup_symbol (sval.ptr, block, VAR_DOMAIN,
- &is_a_field_of_this);
+ sym = lookup_symbol (sval.ptr, block, parse_gdbarch (par_state),
+ VAR_DOMAIN, &is_a_field_of_this);
if (sym.symbol)
{
yylval.ssym.stoken = sval;
@@ -1580,14 +1581,16 @@ yylex (void)
return classify_unsafe_function (name2.value.sval);
}
- if (package_name_p (copy, expression_context_block))
+ if (package_name_p (copy, expression_context_block,
+ parse_gdbarch (pstate)))
{
popping = 1;
yylval.sval = build_packaged_name (current.value.sval.ptr,
current.value.sval.length,
name2.value.sval.ptr,
name2.value.sval.length);
- return classify_packaged_name (expression_context_block);
+ return classify_packaged_name (expression_context_block,
+ parse_gdbarch (pstate));
}
}
diff --git a/gdb/guile/scm-frame.c b/gdb/guile/scm-frame.c
index de77c21..f175f2d 100644
--- a/gdb/guile/scm-frame.c
+++ b/gdb/guile/scm-frame.c
@@ -911,10 +911,14 @@ gdbscm_frame_read_var (SCM self, SCM symbol_scm, SCM rest)
TRY
{
struct block_symbol lookup_sym;
+ const struct gdbarch *gdbarch = NULL;
if (block == NULL)
block = get_frame_block (frame, NULL);
- lookup_sym = lookup_symbol (var_name, block, VAR_DOMAIN, NULL);
+ if (block == NULL)
+ gdbarch = get_frame_arch (frame);
+ lookup_sym
+ = lookup_symbol (var_name, block, gdbarch, VAR_DOMAIN, NULL);
var = lookup_sym.symbol;
block = lookup_sym.block;
}
diff --git a/gdb/guile/scm-symbol.c b/gdb/guile/scm-symbol.c
index 0970a72..6fd732f 100644
--- a/gdb/guile/scm-symbol.c
+++ b/gdb/guile/scm-symbol.c
@@ -576,6 +576,7 @@ gdbscm_lookup_symbol (SCM name_scm, SCM rest)
char *name;
SCM keywords[] = { block_keyword, domain_keyword, SCM_BOOL_F };
const struct block *block = NULL;
+ const struct gdbarch *gdbarch = NULL;
SCM block_scm = SCM_BOOL_F;
int domain = VAR_DOMAIN;
int block_arg_pos = -1, domain_arg_pos = -1;
@@ -611,6 +612,8 @@ gdbscm_lookup_symbol (SCM name_scm, SCM rest)
{
selected_frame = get_selected_frame (_("no frame selected"));
block = get_frame_block (selected_frame, NULL);
+ if (block == NULL)
+ gdbarch = get_frame_arch (selected_frame);
}
CATCH (except, RETURN_MASK_ALL)
{
@@ -621,7 +624,8 @@ gdbscm_lookup_symbol (SCM name_scm, SCM rest)
TRY
{
- symbol = lookup_symbol (name, block, domain, &is_a_field_of_this).symbol;
+ symbol = lookup_symbol (name, block, gdbarch, domain,
+ &is_a_field_of_this).symbol;
}
CATCH (ex, RETURN_MASK_ALL)
{
diff --git a/gdb/guile/scm-type.c b/gdb/guile/scm-type.c
index fa0c213..18fc0b1 100644
--- a/gdb/guile/scm-type.c
+++ b/gdb/guile/scm-type.c
@@ -1243,17 +1243,18 @@ static struct type *
tyscm_lookup_typename (const char *type_name, const struct block *block)
{
struct type *type = NULL;
+ const struct gdbarch *gdbarch = get_current_arch ();
TRY
{
if (startswith (type_name, "struct "))
- type = lookup_struct (type_name + 7, NULL);
+ type = lookup_struct (type_name + 7, block, gdbarch);
else if (startswith (type_name, "union "))
- type = lookup_union (type_name + 6, NULL);
+ type = lookup_union (type_name + 6, block, gdbarch);
else if (startswith (type_name, "enum "))
- type = lookup_enum (type_name + 5, NULL);
+ type = lookup_enum (type_name + 5, block, gdbarch);
else
- type = lookup_typename (current_language, get_current_arch (),
+ type = lookup_typename (current_language, gdbarch,
type_name, block, 0);
}
CATCH (except, RETURN_MASK_ALL)
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 70dffca..d9c2cbc 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -7212,7 +7212,8 @@ insert_exception_resume_breakpoint (struct thread_info *tp,
CORE_ADDR handler;
struct breakpoint *bp;
- vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL);
+ vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b,
+ get_frame_arch (frame), VAR_DOMAIN, NULL);
value = read_var_value (vsym.symbol, vsym.block, frame);
/* If the value was optimized out, revert to the old behavior. */
if (! value_optimized_out (value))
diff --git a/gdb/jv-exp.y b/gdb/jv-exp.y
index 60b7d2e..ad490e4 100644
--- a/gdb/jv-exp.y
+++ b/gdb/jv-exp.y
@@ -122,7 +122,7 @@ static int yylex (void);
void yyerror (char *);
-static struct type *java_type_from_name (struct stoken);
+static struct type *java_type_from_name (struct parser_state *, struct stoken);
static void push_expression_name (struct parser_state *, struct stoken);
static void push_fieldnames (struct parser_state *, struct stoken);
@@ -316,7 +316,7 @@ ReferenceType:
ClassOrInterfaceType:
Name
- { $$ = java_type_from_name ($1); }
+ { $$ = java_type_from_name (pstate, $1); }
;
ClassType:
@@ -327,7 +327,7 @@ ArrayType:
PrimitiveType Dims
{ $$ = java_array_type ($1, $2); }
| Name Dims
- { $$ = java_array_type (java_type_from_name ($1), $2); }
+ { $$ = java_array_type (java_type_from_name (pstate, $1), $2); }
;
Name:
@@ -593,7 +593,7 @@ CastExpression:
{ write_exp_elt_opcode (pstate, UNOP_CAST);
write_exp_elt_type (pstate,
java_array_type (java_type_from_name
- ($2), $3));
+ (pstate, $2), $3));
write_exp_elt_opcode (pstate, UNOP_CAST); }
;
@@ -1253,10 +1253,11 @@ yyerror (char *msg)
}
static struct type *
-java_type_from_name (struct stoken name)
+java_type_from_name (struct parser_state *par_state, struct stoken name)
{
char *tmp = copy_name (name);
- struct type *typ = java_lookup_class (tmp);
+ struct type *typ = java_lookup_class (tmp, parse_gdbarch (par_state));
+
if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT)
error (_("No class named `%s'"), tmp);
return typ;
@@ -1272,7 +1273,8 @@ push_variable (struct parser_state *par_state, struct stoken name)
struct field_of_this_result is_a_field_of_this;
struct block_symbol sym;
- sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN,
+ sym = lookup_symbol (tmp, expression_context_block,
+ parse_gdbarch (par_state), VAR_DOMAIN,
&is_a_field_of_this);
if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
{
@@ -1359,7 +1361,7 @@ push_qualified_expression_name (struct parser_state *par_state,
{
token.length = dot_index;
tmp = copy_name (token);
- typ = java_lookup_class (tmp);
+ typ = java_lookup_class (tmp, parse_gdbarch (par_state));
if (typ != NULL)
{
if (dot_index == name.length)
@@ -1424,7 +1426,7 @@ push_expression_name (struct parser_state *par_state, struct stoken name)
if (push_variable (par_state, name))
return;
tmp = copy_name (name);
- typ = java_lookup_class (tmp);
+ typ = java_lookup_class (tmp, parse_gdbarch (par_state));
if (typ != NULL)
{
write_exp_elt_opcode (par_state, OP_TYPE);
diff --git a/gdb/jv-lang.c b/gdb/jv-lang.c
index 73df044..71f50aa 100644
--- a/gdb/jv-lang.c
+++ b/gdb/jv-lang.c
@@ -198,11 +198,11 @@ add_class_symbol (struct type *type, CORE_ADDR addr)
}
struct type *
-java_lookup_class (char *name)
+java_lookup_class (char *name, const struct gdbarch *gdbarch)
{
struct symbol *sym;
- sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN,
+ sym = lookup_symbol (name, expression_context_block, gdbarch, STRUCT_DOMAIN,
NULL).symbol;
if (sym != NULL)
return SYMBOL_TYPE (sym);
@@ -239,7 +239,7 @@ java_class_from_object (struct value *obj_val)
if (TYPE_CODE (value_type (obj_val)) == TYPE_CODE_PTR
&& TYPE_LENGTH (TYPE_TARGET_TYPE (value_type (obj_val))) == 0)
- obj_val = value_at (get_java_object_type (),
+ obj_val = value_at (get_java_object_type (get_value_arch (obj_val)),
value_as_address (obj_val));
vtable_val = value_struct_elt (&obj_val, NULL, "vtable", NULL, "structure");
@@ -300,7 +300,7 @@ type_from_class (struct gdbarch *gdbarch, struct value *clas)
*nptr = '.';
}
- type = java_lookup_class (name);
+ type = java_lookup_class (name, gdbarch);
if (type != NULL)
return type;
@@ -362,7 +362,7 @@ java_link_class_type (struct gdbarch *gdbarch,
temp = value_struct_elt (&temp, NULL, "superclass", NULL, "structure");
if (strcmp (name, "java.lang.Object") == 0)
{
- tsuper = get_java_object_type ();
+ tsuper = get_java_object_type (gdbarch);
if (tsuper && TYPE_CODE (tsuper) == TYPE_CODE_PTR)
tsuper = TYPE_TARGET_TYPE (tsuper);
type_is_object = 1;
@@ -481,7 +481,8 @@ java_link_class_type (struct gdbarch *gdbarch,
SET_FIELD_BITPOS (TYPE_FIELD (type, i), 8 * boffset);
if (accflags & 0x8000) /* FIELD_UNRESOLVED_FLAG */
{
- TYPE_FIELD_TYPE (type, i) = get_java_object_type (); /* FIXME */
+ TYPE_FIELD_TYPE (type, i)
+ = get_java_object_type (gdbarch); /* FIXME */
}
else
{
@@ -587,11 +588,12 @@ java_link_class_type (struct gdbarch *gdbarch,
}
struct type *
-get_java_object_type (void)
+get_java_object_type (const struct gdbarch *gdbarch)
{
struct symbol *sym;
- sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN, NULL).symbol;
+ sym = lookup_symbol ("java.lang.Object", NULL, gdbarch, STRUCT_DOMAIN,
+ NULL).symbol;
if (sym == NULL)
error (_("cannot find java.lang.Object"));
return SYMBOL_TYPE (sym);
@@ -600,7 +602,7 @@ get_java_object_type (void)
int
get_java_object_header_size (struct gdbarch *gdbarch)
{
- struct type *objtype = get_java_object_type ();
+ struct type *objtype = get_java_object_type (gdbarch);
if (objtype == NULL)
return (2 * gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
diff --git a/gdb/jv-lang.h b/gdb/jv-lang.h
index d34998a..bf3daef 100644
--- a/gdb/jv-lang.h
+++ b/gdb/jv-lang.h
@@ -62,10 +62,10 @@ extern struct type *java_primitive_type_from_name (struct gdbarch *,
extern struct type *java_array_type (struct type *, int);
-extern struct type *get_java_object_type (void);
+extern struct type *get_java_object_type (const struct gdbarch *);
extern int get_java_object_header_size (struct gdbarch *);
-extern struct type *java_lookup_class (char *);
+extern struct type *java_lookup_class (char *, const struct gdbarch *);
extern int is_object_type (struct type *);
diff --git a/gdb/language.c b/gdb/language.c
index 121e8ad..3dd7d0e 100644
--- a/gdb/language.c
+++ b/gdb/language.c
@@ -992,7 +992,7 @@ language_bool_type (const struct language_defn *la,
struct symbol *sym;
sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
- NULL, VAR_DOMAIN, NULL).symbol;
+ NULL, gdbarch, VAR_DOMAIN, NULL).symbol;
if (sym)
{
struct type *type = SYMBOL_TYPE (sym);
@@ -1102,9 +1102,11 @@ language_init_primitive_type_symbols (struct language_arch_info *lai,
struct symbol *
language_lookup_primitive_type_as_symbol (const struct language_defn *la,
- struct gdbarch *gdbarch,
+ const struct gdbarch *c_gdbarch,
const char *name)
{
+ /* Internally gdbarch is mutable. */
+ struct gdbarch *gdbarch = (struct gdbarch *) c_gdbarch;
struct language_gdbarch *ld = gdbarch_data (gdbarch,
language_gdbarch_data);
struct language_arch_info *lai = &ld->arch_info[la->la_language];
diff --git a/gdb/language.h b/gdb/language.h
index 8b579a2..2aabe47 100644
--- a/gdb/language.h
+++ b/gdb/language.h
@@ -277,6 +277,7 @@ struct language_defn
(const struct language_defn *,
const char *,
const struct block *,
+ const struct gdbarch *,
const domain_enum);
/* Find the definition of the type with the given name. */
@@ -460,7 +461,7 @@ struct type *language_lookup_primitive_type (const struct language_defn *l,
struct symbol *
language_lookup_primitive_type_as_symbol (const struct language_defn *l,
- struct gdbarch *gdbarch,
+ const struct gdbarch *gdbarch,
const char *name);
\f
diff --git a/gdb/linespec.c b/gdb/linespec.c
index 8f102fa..66b410e 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -2734,6 +2734,7 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char *arg)
const char *new_argptr;
struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
&symbol_names);
+ const struct gdbarch *gdbarch = target_gdbarch ();
info.state = self;
info.file_symtabs = NULL;
@@ -2744,7 +2745,7 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char *arg)
values.nelts = 0;
values.sals = NULL;
- new_argptr = find_imps (arg, &symbol_names);
+ new_argptr = find_imps (arg, gdbarch, &symbol_names);
if (VEC_empty (const_char_ptr, symbol_names))
{
do_cleanups (cleanup);
@@ -3176,6 +3177,7 @@ find_function_symbols (struct linespec_state *state,
VEC (const_char_ptr) *symbol_names = NULL;
struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
&symbol_names);
+ const struct gdbarch *gdbarch = target_gdbarch ();
info.state = state;
info.result.symbols = NULL;
@@ -3183,7 +3185,7 @@ find_function_symbols (struct linespec_state *state,
info.file_symtabs = file_symtabs;
/* Try NAME as an Objective-C selector. */
- find_imps (name, &symbol_names);
+ find_imps (name, gdbarch, &symbol_names);
if (!VEC_empty (const_char_ptr, symbol_names))
add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
else
@@ -3355,7 +3357,7 @@ find_label_symbols (struct linespec_state *self,
return NULL;
fn_sym = BLOCK_FUNCTION (block);
- sym = lookup_symbol (name, block, LABEL_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, block, NULL, LABEL_DOMAIN, 0).symbol;
if (sym != NULL)
{
@@ -3370,7 +3372,7 @@ find_label_symbols (struct linespec_state *self,
{
set_current_program_space (SYMTAB_PSPACE (symbol_symtab (fn_sym)));
block = SYMBOL_BLOCK_VALUE (fn_sym);
- sym = lookup_symbol (name, block, LABEL_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, block, NULL, LABEL_DOMAIN, 0).symbol;
if (sym != NULL)
{
diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y
index 360fdea..283b216 100644
--- a/gdb/m2-exp.y
+++ b/gdb/m2-exp.y
@@ -564,6 +564,7 @@ fblock : BLOCKNAME
{ struct symbol *sym
= lookup_symbol (copy_name ($1),
expression_context_block,
+ parse_gdbarch (pstate),
VAR_DOMAIN, 0).symbol;
$$ = sym;}
;
@@ -573,6 +574,7 @@ fblock : BLOCKNAME
fblock : block COLONCOLON BLOCKNAME
{ struct symbol *tem
= lookup_symbol (copy_name ($3), $1,
+ parse_gdbarch (pstate),
VAR_DOMAIN, 0).symbol;
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error (_("No function \"%s\" in specified context."),
@@ -597,6 +599,7 @@ variable: INTERNAL_VAR
variable: block COLONCOLON NAME
{ struct block_symbol sym
= lookup_symbol (copy_name ($3), $1,
+ parse_gdbarch (pstate),
VAR_DOMAIN, 0);
if (sym.symbol == 0)
@@ -623,6 +626,7 @@ variable: NAME
sym = lookup_symbol (copy_name ($1),
expression_context_block,
+ parse_gdbarch (pstate),
VAR_DOMAIN,
&is_a_field_of_this);
@@ -1026,7 +1030,8 @@ yylex (void)
if (lookup_symtab (tmp))
return BLOCKNAME;
- sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0).symbol;
+ sym = lookup_symbol (tmp, expression_context_block, parse_gdbarch (pstate),
+ VAR_DOMAIN, 0).symbol;
if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
return BLOCKNAME;
if (lookup_typename (parse_language (pstate), parse_gdbarch (pstate),
diff --git a/gdb/mi/mi-cmd-stack.c b/gdb/mi/mi-cmd-stack.c
index 520db2b..8717038 100644
--- a/gdb/mi/mi-cmd-stack.c
+++ b/gdb/mi/mi-cmd-stack.c
@@ -646,9 +646,8 @@ list_args_or_locals (enum what_to_list what, enum print_values values,
struct frame_arg arg, entryarg;
if (SYMBOL_IS_ARGUMENT (sym))
- sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
- block, VAR_DOMAIN,
- NULL).symbol;
+ sym2 = lookup_symbol_from_block (SYMBOL_LINKAGE_NAME (sym),
+ block, VAR_DOMAIN).symbol;
else
sym2 = sym;
gdb_assert (sym2 != NULL);
diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c
index 9496314..a915db3 100644
--- a/gdb/moxie-tdep.c
+++ b/gdb/moxie-tdep.c
@@ -241,7 +241,8 @@ moxie_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
plg_end = moxie_analyze_prologue (func_addr,
func_end, &cache, gdbarch);
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
+ sym = lookup_symbol (func_name, NULL, gdbarch, VAR_DOMAIN,
+ NULL).symbol;
/* Don't use line number debug info for assembly source
files. */
if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
diff --git a/gdb/mt-tdep.c b/gdb/mt-tdep.c
index ddc9522..9876067 100644
--- a/gdb/mt-tdep.c
+++ b/gdb/mt-tdep.c
@@ -415,7 +415,7 @@ mt_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
struct symbol *sym;
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
+ sym = lookup_symbol (func_name, NULL, gdbarch, VAR_DOMAIN, NULL).symbol;
if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
{
/* Don't use this trick for assembly source files. */
diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c
index 44dfed7..abfcbec 100644
--- a/gdb/objc-lang.c
+++ b/gdb/objc-lang.c
@@ -81,11 +81,12 @@ static const struct objfile_data *objc_objfile_data;
suitably defined. */
struct symbol *
-lookup_struct_typedef (char *name, const struct block *block, int noerr)
+lookup_struct_typedef (char *name, const struct block *block,
+ const struct gdbarch *gdbarch, int noerr)
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, block, gdbarch, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
@@ -203,9 +204,9 @@ value_nsstring (struct gdbarch *gdbarch, char *ptr, int len)
else
error (_("NSString: internal error -- no way to create new NSString"));
- sym = lookup_struct_typedef("NSString", 0, 1);
+ sym = lookup_struct_typedef ("NSString", 0, gdbarch, 1);
if (sym == NULL)
- sym = lookup_struct_typedef("NXString", 0, 1);
+ sym = lookup_struct_typedef ("NXString", 0, gdbarch, 1);
if (sym == NULL)
type = builtin_type (gdbarch)->builtin_data_ptr;
else
@@ -1107,7 +1108,8 @@ uniquify_strings (VEC (const_char_ptr) **strings)
*/
const char *
-find_imps (const char *method, VEC (const_char_ptr) **symbol_names)
+find_imps (const char *method, const struct gdbarch *gdbarch,
+ VEC (const_char_ptr) **symbol_names)
{
char type = '\0';
char *theclass = NULL;
@@ -1142,7 +1144,7 @@ find_imps (const char *method, VEC (const_char_ptr) **symbol_names)
add the selector itself as a symbol, if it exists. */
if (selector_case && !VEC_empty (const_char_ptr, *symbol_names))
{
- struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN,
+ struct symbol *sym = lookup_symbol (selector, NULL, gdbarch, VAR_DOMAIN,
0).symbol;
if (sym != NULL)
diff --git a/gdb/objc-lang.h b/gdb/objc-lang.h
index 464c49b..21e651a 100644
--- a/gdb/objc-lang.h
+++ b/gdb/objc-lang.h
@@ -37,8 +37,9 @@ extern char *objc_demangle (const char *mangled, int options);
extern int find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc);
-extern const char *
- find_imps (const char *method, VEC (const_char_ptr) **symbol_names);
+extern const char *find_imps (const char *method,
+ const struct gdbarch *gdbarch,
+ VEC (const_char_ptr) **symbol_names);
extern struct value *value_nsstring (struct gdbarch *gdbarch,
char *ptr, int len);
@@ -49,6 +50,6 @@ extern void add_msglist (struct stoken *str, int addcolon);
extern int end_msglist (struct parser_state *);
struct symbol *lookup_struct_typedef (char *name, const struct block *block,
- int noerr);
+ const struct gdbarch *, int noerr);
#endif
diff --git a/gdb/p-exp.y b/gdb/p-exp.y
index c255a57..ef11558 100644
--- a/gdb/p-exp.y
+++ b/gdb/p-exp.y
@@ -686,8 +686,8 @@ block : BLOCKNAME
block : block COLONCOLON name
{ struct symbol *tem
- = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, NULL).symbol;
+ = lookup_symbol_from_block (copy_name ($3), $1,
+ VAR_DOMAIN).symbol;
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error (_("No function \"%s\" in specified context."),
@@ -696,10 +696,10 @@ block : block COLONCOLON name
;
variable: block COLONCOLON name
- { struct block_symbol sym;
+ { struct block_symbol sym
+ = lookup_symbol_from_block (copy_name ($3), $1,
+ VAR_DOMAIN);
- sym = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, NULL);
if (sym.symbol == 0)
error (_("No symbol \"%s\" in specified context."),
copy_name ($3));
@@ -735,6 +735,7 @@ variable: qualified_name
sym =
lookup_symbol (name, (const struct block *) NULL,
+ parse_gdbarch (pstate),
VAR_DOMAIN, NULL).symbol;
if (sym)
{
@@ -848,10 +849,12 @@ typebase /* Implements (approximately): (type-qualifier)* type-specifier */
{ $$ = $1.type; }
| STRUCT name
{ $$ = lookup_struct (copy_name ($2),
- expression_context_block); }
+ expression_context_block,
+ parse_gdbarch (pstate)); }
| CLASS name
{ $$ = lookup_struct (copy_name ($2),
- expression_context_block); }
+ expression_context_block,
+ parse_gdbarch (pstate)); }
/* "const" and "volatile" are curently ignored. A type qualifier
after the type is handled in the ptype rule. I think these could
be too. */
@@ -1507,7 +1510,7 @@ yylex (void)
static const char this_name[] = "this";
if (lookup_symbol (this_name, expression_context_block,
- VAR_DOMAIN, NULL).symbol)
+ parse_gdbarch (pstate), VAR_DOMAIN, NULL).symbol)
{
free (uptokstart);
return THIS;
@@ -1557,7 +1560,8 @@ yylex (void)
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN, &is_a_field_of_this).symbol;
+ parse_gdbarch (pstate), VAR_DOMAIN,
+ &is_a_field_of_this).symbol;
/* second chance uppercased (as Free Pascal does). */
if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
{
@@ -1572,7 +1576,8 @@ yylex (void)
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN, &is_a_field_of_this).symbol;
+ parse_gdbarch (pstate), VAR_DOMAIN,
+ &is_a_field_of_this).symbol;
}
/* Third chance Capitalized (as GPC does). */
if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
@@ -1594,7 +1599,8 @@ yylex (void)
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN, &is_a_field_of_this).symbol;
+ parse_gdbarch (pstate), VAR_DOMAIN,
+ &is_a_field_of_this).symbol;
}
if (is_a_field || (is_a_field_of_this.type != NULL))
@@ -1687,6 +1693,7 @@ yylex (void)
memcpy (tmp1, namestart, p - namestart);
tmp1[p - namestart] = '\0';
cur_sym = lookup_symbol (ncopy, expression_context_block,
+ parse_gdbarch (pstate),
VAR_DOMAIN, NULL).symbol;
if (cur_sym)
{
diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
index a0b99f8..00eed0d 100644
--- a/gdb/p-valprint.c
+++ b/gdb/p-valprint.c
@@ -249,7 +249,7 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
if (msymbol.minsym != NULL)
wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
- block,
+ block, gdbarch,
VAR_DOMAIN, &is_this_fld).symbol;
if (wsym)
diff --git a/gdb/parse.c b/gdb/parse.c
index acd48a5..46edfaf 100644
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -671,7 +671,7 @@ write_dollar_variable (struct parser_state *ps, struct stoken str)
have names beginning with $ or $$. Check for those, first. */
sym = lookup_symbol (copy_name (str), (struct block *) NULL,
- VAR_DOMAIN, NULL);
+ parse_gdbarch (ps), VAR_DOMAIN, NULL);
if (sym.symbol)
{
write_exp_elt_opcode (ps, OP_VAR_VALUE);
diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index 5729b24..906dc7e 100644
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -1207,7 +1207,8 @@ address_info (char *exp, int from_tty)
if (exp == 0)
error (_("Argument required."));
- sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN,
+ sym = lookup_symbol (exp, get_selected_block (&context_pc),
+ get_current_arch (), VAR_DOMAIN,
&is_a_field_of_this).symbol;
if (sym == NULL)
{
diff --git a/gdb/python/py-frame.c b/gdb/python/py-frame.c
index b448686..dfe93cd 100644
--- a/gdb/python/py-frame.c
+++ b/gdb/python/py-frame.c
@@ -537,11 +537,16 @@ frapy_read_var (PyObject *self, PyObject *args)
TRY
{
struct block_symbol lookup_sym;
+ const struct gdbarch *gdbarch = NULL;
+
FRAPY_REQUIRE_VALID (self, frame);
- if (!block)
+ if (block == NULL)
block = get_frame_block (frame, NULL);
- lookup_sym = lookup_symbol (var_name, block, VAR_DOMAIN, NULL);
+ if (block == NULL)
+ gdbarch = get_frame_arch (frame);
+ lookup_sym
+ = lookup_symbol (var_name, block, gdbarch, VAR_DOMAIN, NULL);
var = lookup_sym.symbol;
block = lookup_sym.block;
}
diff --git a/gdb/python/py-symbol.c b/gdb/python/py-symbol.c
index 3d2fa91..a35d80b 100644
--- a/gdb/python/py-symbol.c
+++ b/gdb/python/py-symbol.c
@@ -375,6 +375,7 @@ gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw)
struct symbol *symbol = NULL;
PyObject *block_obj = NULL, *ret_tuple, *sym_obj, *bool_obj;
const struct block *block = NULL;
+ const struct gdbarch *gdbarch = NULL;
if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!i", keywords, &name,
&block_object_type, &block_obj, &domain))
@@ -390,6 +391,8 @@ gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw)
{
selected_frame = get_selected_frame (_("No frame selected."));
block = get_frame_block (selected_frame, NULL);
+ if (block == NULL)
+ gdbarch = get_frame_arch (selected_frame);
}
CATCH (except, RETURN_MASK_ALL)
{
@@ -400,7 +403,7 @@ gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw)
TRY
{
- symbol = lookup_symbol (name, block, (domain_enum) domain,
+ symbol = lookup_symbol (name, block, gdbarch, (domain_enum) domain,
&is_a_field_of_this).symbol;
}
CATCH (except, RETURN_MASK_ALL)
diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c
index e202c83..3b95e56 100644
--- a/gdb/python/py-type.c
+++ b/gdb/python/py-type.c
@@ -778,11 +778,11 @@ typy_lookup_typename (const char *type_name, const struct block *block)
TRY
{
if (startswith (type_name, "struct "))
- type = lookup_struct (type_name + 7, NULL);
+ type = lookup_struct (type_name + 7, block, python_gdbarch);
else if (startswith (type_name, "union "))
- type = lookup_union (type_name + 6, NULL);
+ type = lookup_union (type_name + 6, block, python_gdbarch);
else if (startswith (type_name, "enum "))
- type = lookup_enum (type_name + 5, NULL);
+ type = lookup_enum (type_name + 5, block, python_gdbarch);
else
type = lookup_typename (python_language, python_gdbarch,
type_name, block, 0);
diff --git a/gdb/skip.c b/gdb/skip.c
index a1cdd72..f6840c0 100644
--- a/gdb/skip.c
+++ b/gdb/skip.c
@@ -112,6 +112,7 @@ static void
skip_function_command (char *arg, int from_tty)
{
const char *name = NULL;
+ const struct gdbarch *gdbarch = get_current_arch ();
/* Default to the current function if no argument is given. */
if (arg == NULL)
@@ -125,13 +126,13 @@ skip_function_command (char *arg, int from_tty)
if (!find_pc_partial_function (pc, &name, NULL, NULL))
{
error (_("No function found containing current program point %s."),
- paddress (get_current_arch (), pc));
+ paddress (gdbarch, pc));
}
skip_function (name);
}
else
{
- if (lookup_symbol (arg, NULL, VAR_DOMAIN, NULL).symbol == NULL)
+ if (lookup_symbol (arg, NULL, gdbarch, VAR_DOMAIN, NULL).symbol == NULL)
{
fprintf_filtered (gdb_stderr,
_("No function found named %s.\n"), arg);
diff --git a/gdb/source.c b/gdb/source.c
index fab974c..5041cb9 100644
--- a/gdb/source.c
+++ b/gdb/source.c
@@ -274,7 +274,7 @@ select_source_symtab (struct symtab *s)
/* Make the default place to list be the function `main'
if one exists. */
- if (lookup_symbol (main_name (), 0, VAR_DOMAIN, 0).symbol)
+ if (lookup_symbol (main_name (), 0, target_gdbarch (), VAR_DOMAIN, 0).symbol)
{
sals = decode_line_with_current_source (main_name (),
DECODE_LINE_FUNFIRSTLINE);
diff --git a/gdb/stack.c b/gdb/stack.c
index 7d37dd1..9e3838d 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -621,7 +621,7 @@ print_frame_args (struct symbol *func, struct frame_info *frame,
struct symbol *nsym;
nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
- b, VAR_DOMAIN, NULL).symbol;
+ b, NULL, VAR_DOMAIN, NULL).symbol;
gdb_assert (nsym != NULL);
if (SYMBOL_CLASS (nsym) == LOC_REGISTER
&& !SYMBOL_IS_ARGUMENT (nsym))
@@ -2156,7 +2156,7 @@ iterate_over_block_arg_vars (const struct block *b,
are not combined in symbol-reading. */
sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
- b, VAR_DOMAIN, NULL).symbol;
+ b, NULL, VAR_DOMAIN, NULL).symbol;
(*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
}
}
diff --git a/gdb/symfile.c b/gdb/symfile.c
index cbb6d25..a27eeb4 100644
--- a/gdb/symfile.c
+++ b/gdb/symfile.c
@@ -1695,7 +1695,8 @@ set_initial_language (void)
if (lang == language_unknown)
{
char *name = main_name ();
- struct symbol *sym = lookup_symbol (name, NULL, VAR_DOMAIN, NULL).symbol;
+ struct symbol *sym = lookup_symbol (name, NULL, get_current_arch (),
+ VAR_DOMAIN, NULL).symbol;
if (sym != NULL)
lang = SYMBOL_LANGUAGE (sym);
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 1ba691e..b799512 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -71,6 +71,7 @@ static int find_line_common (struct linetable *, int, int *, int);
static struct block_symbol
lookup_symbol_aux (const char *name,
const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain,
enum language language,
struct field_of_this_result *);
@@ -1951,6 +1952,7 @@ demangle_for_lookup (const char *name, enum language lang,
struct block_symbol
lookup_symbol_in_language (const char *name, const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain, enum language lang,
struct field_of_this_result *is_a_field_of_this)
{
@@ -1958,7 +1960,7 @@ lookup_symbol_in_language (const char *name, const struct block *block,
struct block_symbol returnval;
struct cleanup *cleanup = demangle_for_lookup (name, lang, &modified_name);
- returnval = lookup_symbol_aux (modified_name, block, domain, lang,
+ returnval = lookup_symbol_aux (modified_name, block, gdbarch, domain, lang,
is_a_field_of_this);
do_cleanups (cleanup);
@@ -1969,10 +1971,10 @@ lookup_symbol_in_language (const char *name, const struct block *block,
struct block_symbol
lookup_symbol (const char *name, const struct block *block,
- domain_enum domain,
+ const struct gdbarch *gdbarch, domain_enum domain,
struct field_of_this_result *is_a_field_of_this)
{
- return lookup_symbol_in_language (name, block, domain,
+ return lookup_symbol_in_language (name, block, gdbarch, domain,
current_language->la_language,
is_a_field_of_this);
}
@@ -1980,6 +1982,34 @@ lookup_symbol (const char *name, const struct block *block,
/* See symtab.h. */
struct block_symbol
+lookup_symbol_from_block (const char *name, const struct block *block,
+ domain_enum domain)
+{
+ /* While lookup_symbol_in_language can handle both BLOCK,GDBARCH being NULL,
+ that is not the API we present. */
+ gdb_assert (block != NULL);
+
+ return lookup_symbol_in_language (name, block, NULL, domain,
+ current_language->la_language, NULL);
+}
+
+/* See symtab.h. */
+
+struct block_symbol
+lookup_symbol_for_arch (const char *name, const struct gdbarch *gdbarch,
+ domain_enum domain)
+{
+ /* While lookup_symbol_in_language can handle both BLOCK,GDBARCH being NULL,
+ that is not the API we present. */
+ gdb_assert (gdbarch != NULL);
+
+ return lookup_symbol_in_language (name, NULL, gdbarch, domain,
+ current_language->la_language, NULL);
+}
+
+/* See symtab.h. */
+
+struct block_symbol
lookup_language_this (const struct language_defn *lang,
const struct block *block)
{
@@ -2072,6 +2102,7 @@ check_field (struct type *type, const char *name,
static struct block_symbol
lookup_symbol_aux (const char *name, const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain, enum language language,
struct field_of_this_result *is_a_field_of_this)
{
@@ -2083,10 +2114,12 @@ lookup_symbol_aux (const char *name, const struct block *block,
struct objfile *objfile = lookup_objfile_from_block (block);
fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
+ "lookup_symbol_aux (%s, %s (objfile %s),"
+ " %s, %s, %s)\n",
name, host_address_to_string (block),
objfile != NULL
? objfile_debug_name (objfile) : "NULL",
+ gdbarch_bfd_arch_info (gdbarch)->printable_name,
domain_name (domain), language_str (language));
}
@@ -2154,7 +2187,8 @@ lookup_symbol_aux (const char *name, const struct block *block,
/* Now do whatever is appropriate for LANGUAGE to look
up static and global variables. */
- result = langdef->la_lookup_symbol_nonlocal (langdef, name, block, domain);
+ result = langdef->la_lookup_symbol_nonlocal (langdef, name, block, gdbarch,
+ domain);
if (result.symbol != NULL)
{
if (symbol_lookup_debug)
@@ -2483,6 +2517,7 @@ struct block_symbol
basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *name,
const struct block *block,
+ const struct gdbarch *gdbarch,
const domain_enum domain)
{
struct block_symbol result;
@@ -2524,21 +2559,28 @@ basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
return result;
/* If we didn't find a definition for a builtin type in the static block,
- search for it now. This is actually the right thing to do and can be
- a massive performance win. E.g., when debugging a program with lots of
- shared libraries we could search all of them only to find out the
- builtin type isn't defined in any of them. This is common for types
- like "void". */
- if (domain == VAR_DOMAIN)
- {
- struct gdbarch *gdbarch;
-
- if (block == NULL)
- gdbarch = target_gdbarch ();
+ and we're passed a gdbarch so we can look up its primitive types,
+ search for it now. This is actually the right thing to do.
+ E.g., imagine a program compiled with -fshort-double or whatever,
+ but this compilation unit wasn't. If we didn't find the primitive type
+ in the current static block we want to find it now, before searching any
+ other compilation units.
+ And it can be a massive performance win. E.g., when debugging a program
+ with lots of shared libraries we could search all of them only to find
+ out the builtin type isn't defined in any of them. This is common for
+ types like "void". */
+ if (domain == VAR_DOMAIN
+ && (block != NULL || gdbarch != NULL))
+ {
+ const struct gdbarch *gdbarch_for_lookup;
+
+ if (block != NULL)
+ gdbarch_for_lookup = block_gdbarch (block);
else
- gdbarch = block_gdbarch (block);
- result.symbol = language_lookup_primitive_type_as_symbol (langdef,
- gdbarch, name);
+ gdbarch_for_lookup = gdbarch;
+ result.symbol
+ = language_lookup_primitive_type_as_symbol (langdef,
+ gdbarch_for_lookup, name);
result.block = NULL;
if (result.symbol != NULL)
return result;
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 4ff8ae7..0162f91 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -1227,6 +1227,11 @@ struct field_of_this_result
/* Find the definition for a specified symbol name NAME
in domain DOMAIN in language LANGUAGE, visible from lexical block BLOCK
if non-NULL or from global/static blocks if BLOCK is NULL.
+ If BLOCK is NULL and GDBARCH is non-NULL then use GDBARCH for
+ architecture-dependent lookups. If GDBARCH is also NULL then skip all
+ arch-dependent lookups (primitive types).
+ If both BLOCK and GDBARCH are non-NULL, then the architecture of BLOCK
+ is used and GDBARCH is ignored.
Returns the struct symbol pointer, or NULL if no symbol is found.
C++: if IS_A_FIELD_OF_THIS is non-NULL on entry, check to see if
NAME is a field of the current implied argument `this'. If so fill in the
@@ -1236,6 +1241,7 @@ struct field_of_this_result
extern struct block_symbol
lookup_symbol_in_language (const char *,
const struct block *,
+ const struct gdbarch *,
const domain_enum,
enum language,
struct field_of_this_result *);
@@ -1244,9 +1250,27 @@ extern struct block_symbol
extern struct block_symbol lookup_symbol (const char *,
const struct block *,
+ const struct gdbarch *,
const domain_enum,
struct field_of_this_result *);
+/* Same as lookup_symbol_in_language, for when the block is known.
+ BLOCK must not be NULL.
+ The returned symbol doesn't necessarily live in BLOCK, it is only used
+ as a starting point for the search. LANGUAGE, FIELD_OF_THIS_RESULT are
+ elided for simplicity. */
+
+extern struct block_symbol lookup_symbol_from_block
+ (const char *, const struct block *, const domain_enum);
+
+/* Same as lookup_symbol_in_language, for when the architecture is known and
+ the block is not.
+ GDBARCH must not be NULL.
+ LANGUAGE, FIELD_OF_THIS_RESULT are elided for simplicity. */
+
+extern struct block_symbol lookup_symbol_for_arch
+ (const char *, const struct gdbarch *, const domain_enum);
+
/* A default version of lookup_symbol_nonlocal for use by languages
that can't think of anything better to do.
This implements the C lookup rules. */
@@ -1255,6 +1279,7 @@ extern struct block_symbol
basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *,
const struct block *,
+ const struct gdbarch *,
const domain_enum);
/* Some helper functions for languages that need to write their own
@@ -1308,11 +1333,14 @@ extern struct block_symbol
/* Lookup a [struct, union, enum] by name, within a specified block. */
-extern struct type *lookup_struct (const char *, const struct block *);
+extern struct type *lookup_struct (const char *, const struct block *,
+ const struct gdbarch *);
-extern struct type *lookup_union (const char *, const struct block *);
+extern struct type *lookup_union (const char *, const struct block *,
+ const struct gdbarch *);
-extern struct type *lookup_enum (const char *, const struct block *);
+extern struct type *lookup_enum (const char *, const struct block *,
+ const struct gdbarch *);
/* from blockframe.c: */
diff --git a/gdb/utils.c b/gdb/utils.c
index 3ce88b9..d9b9429 100644
--- a/gdb/utils.c
+++ b/gdb/utils.c
@@ -2739,7 +2739,7 @@ When set, debugging messages will be marked with seconds and microseconds."),
}
const char *
-paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
+paddress (const struct gdbarch *gdbarch, CORE_ADDR addr)
{
/* Truncate address to the size of a target address, avoiding shifts
larger or equal than the width of a CORE_ADDR. The local
diff --git a/gdb/utils.h b/gdb/utils.h
index 995a1cf..8a148c2 100644
--- a/gdb/utils.h
+++ b/gdb/utils.h
@@ -250,7 +250,7 @@ extern void gdb_print_host_address (const void *addr, struct ui_file *stream);
/* Convert CORE_ADDR to string in platform-specific manner.
This is usually formatted similar to 0x%lx. */
-extern const char *paddress (struct gdbarch *gdbarch, CORE_ADDR addr);
+extern const char *paddress (const struct gdbarch *gdbarch, CORE_ADDR addr);
/* Return a string representation in hexadecimal notation of ADDRESS,
which is suitable for printing. */
diff --git a/gdb/valops.c b/gdb/valops.c
index 173ef4e..b327331 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -39,6 +39,7 @@
#include "observer.h"
#include "objfiles.h"
#include "extension.h"
+#include "arch-utils.h"
extern unsigned int overload_debug;
/* Local functions. */
@@ -129,7 +130,7 @@ find_function_in_inferior (const char *name, struct objfile **objf_p)
{
struct block_symbol sym;
- sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
+ sym = lookup_symbol (name, 0, get_current_arch (), VAR_DOMAIN, 0);
if (sym.symbol != NULL)
{
if (SYMBOL_CLASS (sym.symbol) != LOC_BLOCK)
@@ -3441,7 +3442,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
{
struct symbol *s =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_DOMAIN, 0).symbol;
+ 0, get_type_arch (t), VAR_DOMAIN, 0).symbol;
if (s == NULL)
return NULL;
@@ -3472,7 +3473,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
{
struct symbol *s =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_DOMAIN, 0).symbol;
+ 0, get_type_arch (t), VAR_DOMAIN, 0).symbol;
if (s == NULL)
return NULL;
@@ -3552,7 +3553,8 @@ value_maybe_namespace_elt (const struct type *curtype,
struct value *result;
sym = cp_lookup_symbol_namespace (namespace_name, name,
- get_selected_block (0), VAR_DOMAIN);
+ get_selected_block (0),
+ get_type_arch (curtype), VAR_DOMAIN);
if (sym.symbol == NULL)
return NULL;
diff --git a/gdb/value.c b/gdb/value.c
index 91bf49e..74ecfa2 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -2949,7 +2949,9 @@ value_static_field (struct type *type, int fieldno)
{
const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
/* TYPE_FIELD_NAME (type, fieldno); */
- struct block_symbol sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
+ struct block_symbol sym = lookup_symbol (phys_name, NULL,
+ get_current_arch (), VAR_DOMAIN,
+ NULL);
if (sym.symbol == NULL)
{
@@ -3137,7 +3139,8 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
struct symbol *sym;
struct bound_minimal_symbol msym;
- sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0).symbol;
+ sym = lookup_symbol (physname, 0, get_type_arch (ftype), VAR_DOMAIN,
+ 0).symbol;
if (sym != NULL)
{
memset (&msym, 0, sizeof (msym));
diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c
index 05b3039..138ff4d 100644
--- a/gdb/xstormy16-tdep.c
+++ b/gdb/xstormy16-tdep.c
@@ -433,7 +433,7 @@ xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
return plg_end;
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
+ sym = lookup_symbol (func_name, NULL, gdbarch, VAR_DOMAIN, NULL).symbol;
/* Don't use line number debug info for assembly source files. */
if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
{
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: Cell multi-arch type resolution broken (Re: [PATCH 5/6] [PR 17684] add support for primitive types as symbols)
2015-08-31 4:17 ` Doug Evans
@ 2015-08-31 13:55 ` Ulrich Weigand
0 siblings, 0 replies; 5+ messages in thread
From: Ulrich Weigand @ 2015-08-31 13:55 UTC (permalink / raw)
To: Doug Evans; +Cc: gdb-patches
Doug Evans wrote:
> > I'd be ok with adding a gdbarch parameter to lookup_symbol,
> > and require at least one of block or gdbarch to be non-NULL.
> >
> > The symbol lookup code is a lot simpler when block == NULL,
> > and handling all the different cases in one set of functions
> > makes things more complex than they could otherwise be.
> > One might then split things up into two paths underneath
> > (one for block, one for arch).
>
> I went through and played with adding gdbarch to the
> symbol lookup routines. I pushed into some places that I didn't
> I need to, just to see the effect.
> I'll clean this up and resubmit in a bit.
Thanks!
> This patch also allows block == NULL and gdbarch == NULL
> in the call to lookup_symbol. Sometimes the caller doesn't have either
> one and doesn't need either one. I'd prefer something else though:
> It'd be cleaner to remove the choice and require the caller to use
> routines that are more explicit.
> Otherwise I suspect a subtle bug or two will creep in.
> [IOW, if the lookup may be for an arch-specific symbol (e.g., primitive type)
> then require the caller to use a routine that requires a non-NULL gdbarch.
> Internal to symtab.c we can do whatever we want though.]
Absolutely. I agree that it would be preferable to define the
interface so that if you want to enable looking up primitive types,
you need to pass in an gdbarch explicitly.
Conversely, many places know for sure they do not need primitive types
(e.g. because they are looking up a variable or function name, or they
are looking up some non-primitive type like a struct type), and those
should preferably pass in a NULL gdbarch. (Certainly preferable to
using some random arch from target_gdbarch or get_current_arch ...)
As an aside, I'm not really happy with the use of current_language
in lookup_symbol. Ideally, this is one more of those globals we'd
really better get rid of. (In particular, since many callers actually
do know which language they're operating on.)
I'd prefer an interface where lookup_symbol uses language_unknown,
i.e. does not perform any language-specific lookup (which should
actually be fine for many of the current users). If you do want
do perform language-specific lookup, you should pass in the language
explicitly.
(Just mentioning this now since you're already going through all
users :-))
> This patch also adds some const-correctness to gdbarch.*.
> [It'll get split out of course.]
This is just for the variable accessors and predicates, right?
I guess that makes sense. Not sure if it really makes much
of a difference since most callers will still need to call one
of the other routines ...
Bye,
Ulrich
--
Dr. Ulrich Weigand
GNU/Linux compilers and toolchain
Ulrich.Weigand@de.ibm.com
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2015-08-31 13:55 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-12-18 12:29 [PATCH 5/6] [PR 17684] add support for primitive types as symbols Doug Evans
2015-08-27 13:53 ` Cell multi-arch type resolution broken (Re: [PATCH 5/6] [PR 17684] add support for primitive types as symbols) Ulrich Weigand
2015-08-30 21:04 ` Doug Evans
2015-08-31 4:17 ` Doug Evans
2015-08-31 13:55 ` Ulrich Weigand
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).