/* Ada language support routines for GDB, the GNU debugger.
- Copyright (C) 1992-2019 Free Software Foundation, Inc.
+ Copyright (C) 1992-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include <ctype.h>
-#include "demangle.h"
#include "gdb_regex.h"
#include "frame.h"
#include "symtab.h"
#include "parser-defs.h"
#include "language.h"
#include "varobj.h"
-#include "c-lang.h"
#include "inferior.h"
#include "symfile.h"
#include "objfiles.h"
#include "gdb_obstack.h"
#include "ada-lang.h"
#include "completer.h"
-#include <sys/stat.h>
#include "ui-out.h"
#include "block.h"
#include "infcall.h"
-#include "dictionary.h"
#include "annotate.h"
#include "valprint.h"
#include "source.h"
#include "observable.h"
-#include "common/vec.h"
#include "stack.h"
-#include "common/gdb_vecs.h"
#include "typeprint.h"
#include "namespace.h"
+#include "cli/cli-style.h"
-#include "psymtab.h"
#include "value.h"
#include "mi/mi-common.h"
#include "arch-utils.h"
#include "cli/cli-utils.h"
-#include "common/function-view.h"
-#include "common/byte-vector.h"
+#include "gdbsupport/function-view.h"
+#include "gdbsupport/byte-vector.h"
#include <algorithm>
/* Define whether or not the C operator '/' truncates towards zero for
static struct block_symbol *defns_collected (struct obstack *, int);
static struct value *resolve_subexp (expression_up *, int *, int,
- struct type *, int);
+ struct type *, int,
+ innermost_block_tracker *);
static void replace_operator_with_call (expression_up *, int, int, int,
struct symbol *, const struct block *);
static int discrete_type_p (struct type *);
-static enum ada_renaming_category parse_old_style_renaming (struct type *,
- const char **,
- int *,
- const char **);
-
-static struct symbol *find_old_style_renaming_symbol (const char *,
- const struct block *);
-
static struct type *ada_lookup_struct_elt_type (struct type *, const char *,
int, int);
static struct value *value_pos_atr (struct type *, struct value *);
+static struct value *val_atr (struct type *, LONGEST);
+
static struct value *value_val_atr (struct type *, struct value *);
static struct symbol *standard_lookup (const char *, const struct block *,
static struct value *ada_search_struct_field (const char *, struct value *, int,
struct type *);
-static struct value *ada_value_primitive_field (struct value *, int, int,
- struct type *);
-
static int find_struct_field (const char *, struct type *, int,
struct type **, int *, int *, int *, int *);
static int ada_is_direct_array_type (struct type *);
-static void ada_language_arch_info (struct gdbarch *,
- struct language_arch_info *);
-
static struct value *ada_index_struct_field (int, struct value *, int,
struct type *);
static struct cmd_list_element *maint_set_ada_cmdlist;
static struct cmd_list_element *maint_show_ada_cmdlist;
-/* Implement the "maintenance set ada" (prefix) command. */
-
-static void
-maint_set_ada_cmd (const char *args, int from_tty)
-{
- help_list (maint_set_ada_cmdlist, "maintenance set ada ", all_commands,
- gdb_stdout);
-}
-
-/* Implement the "maintenance show ada" (prefix) command. */
-
-static void
-maint_show_ada_cmd (const char *args, int from_tty)
-{
- cmd_show_list (maint_show_ada_cmdlist, from_tty, "");
-}
-
/* The "maintenance ada set/show ignore-descriptive-type" value. */
-static int ada_ignore_descriptive_types_p = 0;
+static bool ada_ignore_descriptive_types_p = false;
/* Inferior-specific data. */
tagged types. With older versions of GNAT, this type was directly
accessible through a component ("tsd") in the object tag. But this
is no longer the case, so we cache it for each inferior. */
- struct type *tsd_type;
+ struct type *tsd_type = nullptr;
/* The exception_support_info data. This data is used to determine
how to implement support for Ada exception catchpoints in a given
inferior. */
- const struct exception_support_info *exception_info;
+ const struct exception_support_info *exception_info = nullptr;
};
/* Our key to this module's inferior data. */
-static const struct inferior_data *ada_inferior_data;
-
-/* A cleanup routine for our inferior data. */
-static void
-ada_inferior_data_cleanup (struct inferior *inf, void *arg)
-{
- struct ada_inferior_data *data;
-
- data = (struct ada_inferior_data *) inferior_data (inf, ada_inferior_data);
- if (data != NULL)
- xfree (data);
-}
+static const struct inferior_key<ada_inferior_data> ada_inferior_data;
/* Return our inferior data for the given inferior (INF).
{
struct ada_inferior_data *data;
- data = (struct ada_inferior_data *) inferior_data (inf, ada_inferior_data);
+ data = ada_inferior_data.get (inf);
if (data == NULL)
- {
- data = XCNEW (struct ada_inferior_data);
- set_inferior_data (inf, ada_inferior_data, data);
- }
+ data = ada_inferior_data.emplace (inf);
return data;
}
static void
ada_inferior_exit (struct inferior *inf)
{
- ada_inferior_data_cleanup (inf, NULL);
- set_inferior_data (inf, ada_inferior_data, NULL);
+ ada_inferior_data.clear (inf);
}
/* This module's per-program-space data. */
struct ada_pspace_data
{
+ ~ada_pspace_data ()
+ {
+ if (sym_cache != NULL)
+ ada_free_symbol_cache (sym_cache);
+ }
+
/* The Ada symbol cache. */
- struct ada_symbol_cache *sym_cache;
+ struct ada_symbol_cache *sym_cache = nullptr;
};
/* Key to our per-program-space data. */
-static const struct program_space_data *ada_pspace_data_handle;
+static const struct program_space_key<ada_pspace_data> ada_pspace_data_handle;
/* Return this module's data for the given program space (PSPACE).
If not is found, add a zero'ed one now.
{
struct ada_pspace_data *data;
- data = ((struct ada_pspace_data *)
- program_space_data (pspace, ada_pspace_data_handle));
+ data = ada_pspace_data_handle.get (pspace);
if (data == NULL)
- {
- data = XCNEW (struct ada_pspace_data);
- set_program_space_data (pspace, ada_pspace_data_handle, data);
- }
+ data = ada_pspace_data_handle.emplace (pspace);
return data;
}
-/* The cleanup callback for this module's per-program-space data. */
-
-static void
-ada_pspace_data_cleanup (struct program_space *pspace, void *data)
-{
- struct ada_pspace_data *pspace_data = (struct ada_pspace_data *) data;
-
- if (pspace_data->sym_cache != NULL)
- ada_free_symbol_cache (pspace_data->sym_cache);
- xfree (pspace_data);
-}
-
/* Utilities */
/* If TYPE is a TYPE_CODE_TYPEDEF type, return the target type after
static struct type *
ada_typedef_target_type (struct type *type)
{
- while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ while (type->code () == TYPE_CODE_TYPEDEF)
type = TYPE_TARGET_TYPE (type);
return type;
}
return ada_completer_word_break_characters;
}
-/* Print an array element index using the Ada syntax. */
-
-static void
-ada_print_array_index (struct value *index_value, struct ui_file *stream,
- const struct value_print_options *options)
-{
- LA_VALUE_PRINT (index_value, stream, options);
- fprintf_filtered (stream, " => ");
-}
-
/* la_watch_location_expression for Ada. */
-gdb::unique_xmalloc_ptr<char>
+static gdb::unique_xmalloc_ptr<char>
ada_watch_location_expression (struct type *type, CORE_ADDR addr)
{
type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
(xstrprintf ("{%s} %s", name.c_str (), core_addr_to_string (addr)));
}
+/* Assuming V points to an array of S objects, make sure that it contains at
+ least M objects, updating V and S as necessary. */
+
+#define GROW_VECT(v, s, m) \
+ if ((s) < (m)) (v) = (char *) grow_vect (v, &(s), m, sizeof *(v));
+
/* Assuming VECT points to an array of *SIZE objects of size
ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
updating *SIZE as necessary and returning the (new) array. */
-void *
+static void *
grow_vect (void *vect, size_t *size, size_t min_size, int element_size)
{
if (*size < min_size)
int fieldno;
struct type *struct_type = check_typedef ((struct type *) type);
- for (fieldno = 0; fieldno < TYPE_NFIELDS (struct_type); fieldno++)
+ for (fieldno = 0; fieldno < struct_type->num_fields (); fieldno++)
if (field_name_match (TYPE_FIELD_NAME (struct_type, fieldno), field_name))
return fieldno;
if (!maybe_missing)
error (_("Unable to find field %s in struct %s. Aborting"),
- field_name, TYPE_NAME (struct_type));
+ field_name, struct_type->name ());
return -1;
}
set_value_component_location (result, val);
set_value_bitsize (result, value_bitsize (val));
set_value_bitpos (result, value_bitpos (val));
- set_value_address (result, value_address (val));
+ if (VALUE_LVAL (result) == lval_memory)
+ set_value_address (result, value_address (val));
return result;
}
}
LONGEST
ada_discrete_type_high_bound (struct type *type)
{
- type = resolve_dynamic_type (type, NULL, 0);
- switch (TYPE_CODE (type))
+ type = resolve_dynamic_type (type, {}, 0);
+ switch (type->code ())
{
case TYPE_CODE_RANGE:
return TYPE_HIGH_BOUND (type);
case TYPE_CODE_ENUM:
- return TYPE_FIELD_ENUMVAL (type, TYPE_NFIELDS (type) - 1);
+ return TYPE_FIELD_ENUMVAL (type, type->num_fields () - 1);
case TYPE_CODE_BOOL:
return 1;
case TYPE_CODE_CHAR:
LONGEST
ada_discrete_type_low_bound (struct type *type)
{
- type = resolve_dynamic_type (type, NULL, 0);
- switch (TYPE_CODE (type))
+ type = resolve_dynamic_type (type, {}, 0);
+ switch (type->code ())
{
case TYPE_CODE_RANGE:
return TYPE_LOW_BOUND (type);
static struct type *
get_base_type (struct type *type)
{
- while (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE)
+ while (type != NULL && type->code () == TYPE_CODE_RANGE)
{
if (type == TYPE_TARGET_TYPE (type) || TYPE_TARGET_TYPE (type) == NULL)
return type;
/* Return a decoded version of the given VALUE. This means returning
a value whose type is obtained by applying all the GNAT-specific
- encondings, making the resulting type a static but standard description
+ encodings, making the resulting type a static but standard description
of the initial type. */
struct value *
if (ada_is_array_descriptor_type (type)
|| (ada_is_constrained_packed_array_type (type)
- && TYPE_CODE (type) != TYPE_CODE_PTR))
+ && type->code () != TYPE_CODE_PTR))
{
- if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) /* array access type. */
+ if (type->code () == TYPE_CODE_TYPEDEF) /* array access type. */
value = ada_coerce_to_simple_array_ptr (value);
else
value = ada_coerce_to_simple_array (value);
/* If the main program is in Ada, return language_ada, otherwise return LANG
(the main program is in Ada iif the adainit symbol is found). */
-enum language
+static enum language
ada_update_initial_language (enum language lang)
{
- if (lookup_minimal_symbol ("adainit", (const char *) NULL,
- (struct objfile *) NULL).minsym != NULL)
+ if (lookup_minimal_symbol ("adainit", NULL, NULL).minsym != NULL)
return language_ada;
return lang;
quotes, unfolded, but with the quotes stripped away. Result good
to next call. */
-char *
-ada_fold_name (const char *name)
+static char *
+ada_fold_name (gdb::string_view name)
{
static char *fold_buffer = NULL;
static size_t fold_buffer_size = 0;
- int len = strlen (name);
+ int len = name.size ();
GROW_VECT (fold_buffer, fold_buffer_size, len + 1);
if (name[0] == '\'')
{
- strncpy (fold_buffer, name + 1, len - 2);
+ strncpy (fold_buffer, name.data () + 1, len - 2);
fold_buffer[len - 2] = '\000';
}
else
*len = *len - 1;
}
-/* Remove trailing X[bn]* suffixes (indicating names in package bodies). */
-
-static void
-ada_remove_Xbn_suffix (const char *encoded, int *len)
-{
- int i = *len - 1;
-
- while (i > 0 && (encoded[i] == 'b' || encoded[i] == 'n'))
- i--;
-
- if (encoded[i] != 'X')
- return;
-
- if (i == 0)
- return;
-
- if (isalnum (encoded[i-1]))
- *len = i;
-}
-
/* If ENCODED follows the GNAT entity encoding conventions, then return
the decoded form of ENCODED. Otherwise, return "<%s>" where "%s" is
- replaced by ENCODED.
+ replaced by ENCODED. */
- The resulting string is valid until the next call of ada_decode.
- If the string is unchanged by decoding, the original string pointer
- is returned. */
-
-const char *
+std::string
ada_decode (const char *encoded)
{
int i, j;
int len0;
const char *p;
- char *decoded;
int at_start_name;
- static char *decoding_buffer = NULL;
- static size_t decoding_buffer_size = 0;
+ std::string decoded;
/* With function descriptors on PPC64, the value of a symbol named
".FN", if it exists, is the entry point of the function "FN". */
/* Make decoded big enough for possible expansion by operator name. */
- GROW_VECT (decoding_buffer, decoding_buffer_size, 2 * len0 + 1);
- decoded = decoding_buffer;
+ decoded.resize (2 * len0 + 1, 'X');
/* Remove trailing __{digit}+ or trailing ${digit}+. */
op_len - 1) == 0)
&& !isalnum (encoded[i + op_len]))
{
- strcpy (decoded + j, ada_opname_table[k].decoded);
+ strcpy (&decoded.front() + j, ada_opname_table[k].decoded);
at_start_name = 0;
i += op_len;
j += strlen (ada_opname_table[k].decoded);
j += 1;
}
}
- decoded[j] = '\000';
+ decoded.resize (j);
/* Decoded names should never contain any uppercase character.
Double-check this, and abort the decoding if we find one. */
- for (i = 0; decoded[i] != '\0'; i += 1)
+ for (i = 0; i < decoded.length(); ++i)
if (isupper (decoded[i]) || decoded[i] == ' ')
goto Suppress;
- if (strcmp (decoded, encoded) == 0)
- return encoded;
- else
- return decoded;
+ return decoded;
Suppress:
- GROW_VECT (decoding_buffer, decoding_buffer_size, strlen (encoded) + 3);
- decoded = decoding_buffer;
if (encoded[0] == '<')
- strcpy (decoded, encoded);
+ decoded = encoded;
else
- xsnprintf (decoded, decoding_buffer_size, "<%s>", encoded);
+ decoded = '<' + std::string(encoded) + '>';
return decoded;
}
if (!gsymbol->ada_mangled)
{
- const char *decoded = ada_decode (gsymbol->name);
+ std::string decoded = ada_decode (gsymbol->linkage_name ());
struct obstack *obstack = gsymbol->language_specific.obstack;
gsymbol->ada_mangled = 1;
if (obstack != NULL)
- *resultp
- = (const char *) obstack_copy0 (obstack, decoded, strlen (decoded));
+ *resultp = obstack_strdup (obstack, decoded.c_str ());
else
{
/* Sometimes, we can't find a corresponding objfile, in
significant memory leak (FIXME). */
char **slot = (char **) htab_find_slot (decoded_names_store,
- decoded, INSERT);
+ decoded.c_str (), INSERT);
if (*slot == NULL)
- *slot = xstrdup (decoded);
+ *slot = xstrdup (decoded.c_str ());
*resultp = *slot;
}
}
static char *
ada_la_decode (const char *encoded, int options)
{
- return xstrdup (ada_decode (encoded));
-}
-
-/* Implement la_sniff_from_mangled_name for Ada. */
-
-static int
-ada_sniff_from_mangled_name (const char *mangled, char **out)
-{
- const char *demangled = ada_decode (mangled);
-
- *out = NULL;
-
- if (demangled != mangled && demangled != NULL && demangled[0] != '<')
- {
- /* Set the gsymbol language to Ada, but still return 0.
- Two reasons for that:
-
- 1. For Ada, we prefer computing the symbol's decoded name
- on the fly rather than pre-compute it, in order to save
- memory (Ada projects are typically very large).
-
- 2. There are some areas in the definition of the GNAT
- encoding where, with a bit of bad luck, we might be able
- to decode a non-Ada symbol, generating an incorrect
- demangled name (Eg: names ending with "TB" for instance
- are identified as task bodies and so stripped from
- the decoded name returned).
-
- Returning 1, here, but not setting *DEMANGLED, helps us get a
- little bit of the best of both worlds. Because we're last,
- we should not affect any of the other languages that were
- able to demangle the symbol before us; we get to correctly
- tag Ada symbols as such; and even if we incorrectly tagged a
- non-Ada symbol, which should be rare, any routing through the
- Ada language should be transparent (Ada tries to behave much
- like C/C++ with non-Ada symbols). */
- return 1;
- }
-
- return 0;
+ return xstrdup (ada_decode (encoded).c_str ());
}
\f
Otherwise, do nothing. This function also does nothing if
INDEX_DESC_TYPE is NULL.
- The GNAT encoding used to describle the array index type evolved a bit.
+ The GNAT encoding used to describe the array index type evolved a bit.
Initially, the information would be provided through the name of each
field of the structure type only, while the type of these fields was
described as unspecified and irrelevant. The debugger was then expected
if (index_desc_type == NULL)
return;
- gdb_assert (TYPE_NFIELDS (index_desc_type) > 0);
+ gdb_assert (index_desc_type->num_fields () > 0);
/* Check if INDEX_DESC_TYPE follows the older encoding (it is sufficient
to check one field only, no need to check them all). If not, return
If our INDEX_DESC_TYPE was generated using the older encoding,
the field type should be a meaningless integer type whose name
is not equal to the field name. */
- if (TYPE_NAME (TYPE_FIELD_TYPE (index_desc_type, 0)) != NULL
- && strcmp (TYPE_NAME (TYPE_FIELD_TYPE (index_desc_type, 0)),
+ if (TYPE_FIELD_TYPE (index_desc_type, 0)->name () != NULL
+ && strcmp (TYPE_FIELD_TYPE (index_desc_type, 0)->name (),
TYPE_FIELD_NAME (index_desc_type, 0)) == 0)
return;
/* Fixup each field of INDEX_DESC_TYPE. */
- for (i = 0; i < TYPE_NFIELDS (index_desc_type); i++)
+ for (i = 0; i < index_desc_type->num_fields (); i++)
{
const char *name = TYPE_FIELD_NAME (index_desc_type, i);
struct type *raw_type = ada_check_typedef (ada_find_any_type (name));
}
}
-/* Names of MAX_ADA_DIMENS bounds in P_BOUNDS fields of array descriptors. */
-
-static const char *bound_name[] = {
- "LB0", "UB0", "LB1", "UB1", "LB2", "UB2", "LB3", "UB3",
- "LB4", "UB4", "LB5", "UB5", "LB6", "UB6", "LB7", "UB7"
-};
-
-/* Maximum number of array dimensions we are prepared to handle. */
-
-#define MAX_ADA_DIMENS (sizeof(bound_name) / (2*sizeof(char *)))
-
-
/* The desc_* routines return primitive portions of array descriptors
(fat pointers). */
if (type == NULL)
return NULL;
type = ada_check_typedef (type);
- if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ if (type->code () == TYPE_CODE_TYPEDEF)
type = ada_typedef_target_type (type);
if (type != NULL
- && (TYPE_CODE (type) == TYPE_CODE_PTR
- || TYPE_CODE (type) == TYPE_CODE_REF))
+ && (type->code () == TYPE_CODE_PTR
+ || type->code () == TYPE_CODE_REF))
return ada_check_typedef (TYPE_TARGET_TYPE (type));
else
return type;
data_type = lookup_pointer_type (data_type);
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ if (type->code () == TYPE_CODE_PTR)
return value_cast (data_type, value_copy (val));
else
return value_from_longest (data_type, value_address (val));
is_thick_pntr (struct type *type)
{
type = desc_base_type (type);
- return (type != NULL && TYPE_CODE (type) == TYPE_CODE_STRUCT
+ return (type != NULL && type->code () == TYPE_CODE_STRUCT
&& lookup_struct_elt_type (type, "P_BOUNDS", 1) != NULL);
}
if (r != NULL)
return ada_check_typedef (r);
}
- else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ else if (type->code () == TYPE_CODE_STRUCT)
{
r = lookup_struct_elt_type (type, "P_BOUNDS", 1);
if (r != NULL)
/* NOTE: The following calculation is not really kosher, but
since desc_type is an XVE-encoded type (and shouldn't be),
the correct calculation is a real pain. FIXME (and fix GCC). */
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ if (type->code () == TYPE_CODE_PTR)
addr = value_as_long (arr);
else
addr = value_address (arr);
struct type *p_bounds_type = value_type (p_bounds);
if (p_bounds_type
- && TYPE_CODE (p_bounds_type) == TYPE_CODE_PTR)
+ && p_bounds_type->code () == TYPE_CODE_PTR)
{
struct type *target_type = TYPE_TARGET_TYPE (p_bounds_type);
struct type *data_type = lookup_struct_elt_type (type, "P_ARRAY", 1);
if (data_type
- && TYPE_CODE (ada_check_typedef (data_type)) == TYPE_CODE_PTR)
+ && ada_check_typedef (data_type)->code () == TYPE_CODE_PTR)
return ada_check_typedef (TYPE_TARGET_TYPE (data_type));
}
static struct value *
desc_one_bound (struct value *bounds, int i, int which)
{
- return value_struct_elt (&bounds, NULL, bound_name[2 * i + which - 2], NULL,
+ char bound_name[20];
+ xsnprintf (bound_name, sizeof (bound_name), "%cB%d",
+ which ? 'U' : 'L', i - 1);
+ return value_struct_elt (&bounds, NULL, bound_name, NULL,
_("Bad GNAT array descriptor bounds"));
}
{
type = desc_base_type (type);
- if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
- return lookup_struct_elt_type (type, bound_name[2 * i - 2], 1);
+ if (type->code () == TYPE_CODE_STRUCT)
+ {
+ char bound_name[20];
+ xsnprintf (bound_name, sizeof (bound_name), "LB%d", i - 1);
+ return lookup_struct_elt_type (type, bound_name, 1);
+ }
else
return NULL;
}
type = desc_base_type (type);
if (type != NULL)
- return TYPE_NFIELDS (type) / 2;
+ return type->num_fields () / 2;
return 0;
}
if (type == NULL)
return 0;
type = ada_check_typedef (type);
- return (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ return (type->code () == TYPE_CODE_ARRAY
|| ada_is_array_descriptor_type (type));
}
static int
ada_is_array_type (struct type *type)
{
- while (type != NULL
- && (TYPE_CODE (type) == TYPE_CODE_PTR
- || TYPE_CODE (type) == TYPE_CODE_REF))
+ while (type != NULL
+ && (type->code () == TYPE_CODE_PTR
+ || type->code () == TYPE_CODE_REF))
type = TYPE_TARGET_TYPE (type);
return ada_is_direct_array_type (type);
}
if (type == NULL)
return 0;
type = ada_check_typedef (type);
- return (TYPE_CODE (type) == TYPE_CODE_ARRAY
- || (TYPE_CODE (type) == TYPE_CODE_PTR
- && TYPE_CODE (ada_check_typedef (TYPE_TARGET_TYPE (type)))
- == TYPE_CODE_ARRAY));
+ return (type->code () == TYPE_CODE_ARRAY
+ || (type->code () == TYPE_CODE_PTR
+ && (ada_check_typedef (TYPE_TARGET_TYPE (type))->code ()
+ == TYPE_CODE_ARRAY)));
}
/* Non-zero iff TYPE belongs to a GNAT array descriptor. */
return 0;
type = ada_check_typedef (type);
return (data_type != NULL
- && TYPE_CODE (data_type) == TYPE_CODE_ARRAY
+ && data_type->code () == TYPE_CODE_ARRAY
&& desc_arity (desc_bounds_type (type)) > 0);
}
{
return
type != NULL
- && TYPE_CODE (type) == TYPE_CODE_STRUCT
+ && type->code () == TYPE_CODE_STRUCT
&& (lookup_struct_elt_type (type, "P_BOUNDS", 1) != NULL
|| lookup_struct_elt_type (type, "P_ARRAY", 1) != NULL)
&& !ada_is_array_descriptor_type (type);
the ARR denotes a null array descriptor and BOUNDS is non-zero,
returns NULL. The result is simply the type of ARR if ARR is not
a descriptor. */
-struct type *
+
+static struct type *
ada_type_of_array (struct value *arr, int bounds)
{
if (ada_is_constrained_packed_array_type (value_type (arr)))
/* Access to arrays implemented as fat pointers are encoded as a typedef
of the fat pointer type. We need the name of the fat pointer type
to do the decoding, so strip the typedef layer. */
- if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ if (type->code () == TYPE_CODE_TYPEDEF)
type = ada_typedef_target_type (type);
raw_name = ada_type_name (ada_check_typedef (type));
LONGEST low_bound, high_bound;
type = ada_check_typedef (type);
- if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
+ if (type->code () != TYPE_CODE_ARRAY)
return type;
index_type_desc = ada_find_parallel_type (type, "___XA");
elt_bits);
create_array_type (new_type, new_elt_type, index_type);
TYPE_FIELD_BITSIZE (new_type, 0) = *elt_bits;
- TYPE_NAME (new_type) = ada_type_name (type);
+ new_type->set_name (ada_type_name (type));
- if ((TYPE_CODE (check_typedef (index_type)) == TYPE_CODE_RANGE
+ if ((check_typedef (index_type)->code () == TYPE_CODE_RANGE
&& is_dynamic_type (check_typedef (index_type)))
|| get_discrete_bounds (index_type, &low_bound, &high_bound) < 0)
low_bound = high_bound = 0;
}
shadow_type = check_typedef (shadow_type);
- if (TYPE_CODE (shadow_type) != TYPE_CODE_ARRAY)
+ if (shadow_type->code () != TYPE_CODE_ARRAY)
{
lim_warning (_("could not understand bounds "
"information on packed array"));
and "value_ind" routines to perform the dereferencing, as opposed
to using "ada_coerce_ref" or "ada_value_ind". */
arr = coerce_ref (arr);
- if (TYPE_CODE (ada_check_typedef (value_type (arr))) == TYPE_CODE_PTR)
+ if (ada_check_typedef (value_type (arr))->code () == TYPE_CODE_PTR)
arr = value_ind (arr);
type = decode_constrained_packed_array_type (value_type (arr));
return NULL;
}
- if (gdbarch_bits_big_endian (get_type_arch (value_type (arr)))
+ if (type_byte_order (value_type (arr)) == BFD_ENDIAN_BIG
&& ada_is_modular_type (value_type (arr)))
{
/* This is a (right-justified) modular type representing a packed
elt_type = ada_check_typedef (value_type (arr));
for (i = 0; i < arity; i += 1)
{
- if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY
+ if (elt_type->code () != TYPE_CODE_ARRAY
|| TYPE_FIELD_BITSIZE (elt_type, 0) == 0)
error
(_("attempt to do packed indexing of "
static int
has_negatives (struct type *type)
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
default:
return 0;
case TYPE_CODE_INT:
return !TYPE_UNSIGNED (type);
case TYPE_CODE_RANGE:
- return TYPE_LOW_BOUND (type) < 0;
+ return TYPE_LOW_BOUND (type) - TYPE_RANGE_DATA (type)->bias < 0;
}
}
const gdb_byte *src; /* First byte containing data to unpack */
gdb_byte *unpacked;
const int is_scalar = is_scalar_type (type);
- const int is_big_endian = gdbarch_bits_big_endian (get_type_arch (type));
+ const int is_big_endian = type_byte_order (type) == BFD_ENDIAN_BIG;
gdb::byte_vector staging;
type = ada_check_typedef (type);
staging.data (), staging.size (),
is_big_endian, has_negatives (type),
is_scalar);
- type = resolve_dynamic_type (type, staging.data (), 0);
+ type = resolve_dynamic_type (type, staging, 0);
if (TYPE_LENGTH (type) < (bit_size + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT)
{
/* This happens when the length of the object is dynamic,
if (VALUE_LVAL (toval) == lval_memory
&& bits > 0
- && (TYPE_CODE (type) == TYPE_CODE_FLT
- || TYPE_CODE (type) == TYPE_CODE_STRUCT))
+ && (type->code () == TYPE_CODE_FLT
+ || type->code () == TYPE_CODE_STRUCT))
{
int len = (value_bitpos (toval)
+ bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
struct value *val;
CORE_ADDR to_addr = value_address (toval);
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (type->code () == TYPE_CODE_FLT)
fromval = value_cast (type, fromval);
read_memory (to_addr, buffer, len);
from_size = value_bitsize (fromval);
if (from_size == 0)
from_size = TYPE_LENGTH (value_type (fromval)) * TARGET_CHAR_BIT;
- if (gdbarch_bits_big_endian (get_type_arch (type)))
- copy_bitwise (buffer, value_bitpos (toval),
- value_contents (fromval), from_size - bits, bits, 1);
- else
- copy_bitwise (buffer, value_bitpos (toval),
- value_contents (fromval), 0, bits, 0);
+
+ const int is_big_endian = type_byte_order (type) == BFD_ENDIAN_BIG;
+ ULONGEST from_offset = 0;
+ if (is_big_endian && is_scalar_type (value_type (fromval)))
+ from_offset = from_size - bits;
+ copy_bitwise (buffer, value_bitpos (toval),
+ value_contents (fromval), from_offset,
+ bits, is_big_endian);
write_memory_with_notification (to_addr, buffer, len);
val = value_copy (toval);
else
bits = value_bitsize (component);
- if (gdbarch_bits_big_endian (get_type_arch (value_type (container))))
+ if (type_byte_order (value_type (container)) == BFD_ENDIAN_BIG)
{
int src_offset;
bool
ada_is_access_to_unconstrained_array (struct type *type)
{
- return (TYPE_CODE (type) == TYPE_CODE_TYPEDEF
+ return (type->code () == TYPE_CODE_TYPEDEF
&& is_thick_pntr (ada_typedef_target_type (type)));
}
elt = ada_coerce_to_simple_array (arr);
elt_type = ada_check_typedef (value_type (elt));
- if (TYPE_CODE (elt_type) == TYPE_CODE_ARRAY
+ if (elt_type->code () == TYPE_CODE_ARRAY
&& TYPE_FIELD_BITSIZE (elt_type, 0) > 0)
return value_subscript_packed (elt, arity, ind);
{
struct type *saved_elt_type = TYPE_TARGET_TYPE (elt_type);
- if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY)
+ if (elt_type->code () != TYPE_CODE_ARRAY)
error (_("too many subscripts (%d expected)"), k);
elt = value_subscript (elt, pos_atr (ind[k]));
if (ada_is_access_to_unconstrained_array (saved_elt_type)
- && TYPE_CODE (value_type (elt)) != TYPE_CODE_TYPEDEF)
+ && value_type (elt)->code () != TYPE_CODE_TYPEDEF)
{
/* The element is a typedef to an unconstrained array,
except that the value_subscript call stripped the
struct type *type
= check_typedef (value_enclosing_type (array_ind));
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ if (type->code () == TYPE_CODE_ARRAY
&& TYPE_FIELD_BITSIZE (type, 0) > 0)
return value_subscript_packed (array_ind, arity, ind);
for (k = 0; k < arity; k += 1)
{
LONGEST lwb, upb;
- struct value *lwb_value;
- if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
+ if (type->code () != TYPE_CODE_ARRAY)
error (_("too many subscripts (%d expected)"), k);
arr = value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
value_copy (arr));
get_discrete_bounds (TYPE_INDEX_TYPE (type), &lwb, &upb);
- lwb_value = value_from_longest (value_type(ind[k]), lwb);
- arr = value_ptradd (arr, pos_atr (ind[k]) - pos_atr (lwb_value));
+ arr = value_ptradd (arr, pos_atr (ind[k]) - lwb);
type = TYPE_TARGET_TYPE (type);
}
= create_static_range_type (NULL, base_index_type, low, high);
struct type *slice_type = create_array_type_with_stride
(NULL, TYPE_TARGET_TYPE (type0), index_type,
- get_dyn_prop (DYN_PROP_BYTE_STRIDE, type0),
+ type0->dyn_prop (DYN_PROP_BYTE_STRIDE),
TYPE_FIELD_BITSIZE (type0, 0));
int base_low = ada_discrete_type_low_bound (TYPE_INDEX_TYPE (type0));
LONGEST base_low_pos, low_pos;
= create_static_range_type (NULL, TYPE_INDEX_TYPE (type), low, high);
struct type *slice_type = create_array_type_with_stride
(NULL, TYPE_TARGET_TYPE (type), index_type,
- get_dyn_prop (DYN_PROP_BYTE_STRIDE, type),
+ type->dyn_prop (DYN_PROP_BYTE_STRIDE),
TYPE_FIELD_BITSIZE (type, 0));
LONGEST low_pos, high_pos;
type = desc_base_type (type);
arity = 0;
- if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ if (type->code () == TYPE_CODE_STRUCT)
return desc_arity (desc_bounds_type (type));
else
- while (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ while (type->code () == TYPE_CODE_ARRAY)
{
arity += 1;
type = ada_check_typedef (TYPE_TARGET_TYPE (type));
{
type = desc_base_type (type);
- if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ if (type->code () == TYPE_CODE_STRUCT)
{
int k;
struct type *p_array_type;
}
return p_array_type;
}
- else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ else if (type->code () == TYPE_CODE_ARRAY)
{
- while (nindices != 0 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ while (nindices != 0 && type->code () == TYPE_CODE_ARRAY)
{
type = TYPE_TARGET_TYPE (type);
nindices -= 1;
/* FIXME: The stabs type r(0,0);bound;bound in an array type
has a target type of TYPE_CODE_UNDEF. We compensate here, but
perhaps stabsread.c would make more sense. */
- if (result_type && TYPE_CODE (result_type) == TYPE_CODE_UNDEF)
+ if (result_type && result_type->code () == TYPE_CODE_UNDEF)
result_type = NULL;
}
else
if (arr_type == NULL || !ada_is_simple_array_type (arr_type))
return (LONGEST) - which;
- if (TYPE_CODE (arr_type) == TYPE_CODE_PTR)
+ if (arr_type->code () == TYPE_CODE_PTR)
type = TYPE_TARGET_TYPE (arr_type);
else
type = arr_type;
{
struct type *arr_type;
- if (TYPE_CODE (check_typedef (value_type (arr))) == TYPE_CODE_PTR)
+ if (check_typedef (value_type (arr))->code () == TYPE_CODE_PTR)
arr = value_ind (arr);
arr_type = value_enclosing_type (arr);
struct type *arr_type, *index_type;
int low, high;
- if (TYPE_CODE (check_typedef (value_type (arr))) == TYPE_CODE_PTR)
+ if (check_typedef (value_type (arr))->code () == TYPE_CODE_PTR)
arr = value_ind (arr);
arr_type = value_enclosing_type (arr);
if (index_type != NULL)
{
struct type *base_type;
- if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
+ if (index_type->code () == TYPE_CODE_RANGE)
base_type = TYPE_TARGET_TYPE (index_type);
else
base_type = index_type;
error (_("Could not find operator name for opcode"));
}
+/* Returns true (non-zero) iff decoded name N0 should appear before N1
+ in a listing of choices during disambiguation (see sort_choices, below).
+ The idea is that overloadings of a subprogram name from the
+ same package should sort in their source order. We settle for ordering
+ such symbols by their trailing number (__N or $N). */
-/* Same as evaluate_type (*EXP), but resolves ambiguous symbol
- references (marked by OP_VAR_VALUE nodes in which the symbol has an
- undefined namespace) and converts operators that are
- user-defined into appropriate function calls. If CONTEXT_TYPE is
- non-null, it provides a preferred result type [at the moment, only
- type void has any effect---causing procedures to be preferred over
- functions in calls]. A null CONTEXT_TYPE indicates that a non-void
- return type is preferred. May change (expand) *EXP. */
-
-static void
-resolve (expression_up *expp, int void_context_p, int parse_completion)
+static int
+encoded_ordered_before (const char *N0, const char *N1)
{
- struct type *context_type = NULL;
- int pc = 0;
+ if (N1 == NULL)
+ return 0;
+ else if (N0 == NULL)
+ return 1;
+ else
+ {
+ int k0, k1;
- if (void_context_p)
- context_type = builtin_type ((*expp)->gdbarch)->builtin_void;
+ for (k0 = strlen (N0) - 1; k0 > 0 && isdigit (N0[k0]); k0 -= 1)
+ ;
+ for (k1 = strlen (N1) - 1; k1 > 0 && isdigit (N1[k1]); k1 -= 1)
+ ;
+ if ((N0[k0] == '_' || N0[k0] == '$') && N0[k0 + 1] != '\000'
+ && (N1[k1] == '_' || N1[k1] == '$') && N1[k1 + 1] != '\000')
+ {
+ int n0, n1;
- resolve_subexp (expp, &pc, 1, context_type, parse_completion);
+ n0 = k0;
+ while (N0[n0] == '_' && n0 > 0 && N0[n0 - 1] == '_')
+ n0 -= 1;
+ n1 = k1;
+ while (N1[n1] == '_' && n1 > 0 && N1[n1 - 1] == '_')
+ n1 -= 1;
+ if (n0 == n1 && strncmp (N0, N1, n0) == 0)
+ return (atoi (N0 + k0 + 1) < atoi (N1 + k1 + 1));
+ }
+ return (strcmp (N0, N1) < 0);
+ }
}
-/* Resolve the operator of the subexpression beginning at
- position *POS of *EXPP. "Resolving" consists of replacing
- the symbols that have undefined namespaces in OP_VAR_VALUE nodes
- with their resolutions, replacing built-in operators with
- function calls to user-defined operators, where appropriate, and,
- when DEPROCEDURE_P is non-zero, converting function-valued variables
- into parameterless calls. May expand *EXPP. The CONTEXT_TYPE functions
- are as in ada_resolve, above. */
+/* Sort SYMS[0..NSYMS-1] to put the choices in a canonical order by the
+ encoded names. */
-static struct value *
-resolve_subexp (expression_up *expp, int *pos, int deprocedure_p,
- struct type *context_type, int parse_completion)
+static void
+sort_choices (struct block_symbol syms[], int nsyms)
{
- int pc = *pos;
int i;
- struct expression *exp; /* Convenience: == *expp. */
- enum exp_opcode op = (*expp)->elts[pc].opcode;
- struct value **argvec; /* Vector of operand types (alloca'ed). */
- int nargs; /* Number of operands. */
- int oplen;
-
- argvec = NULL;
- nargs = 0;
- exp = expp->get ();
- /* Pass one: resolve operands, saving their types and updating *pos,
- if needed. */
- switch (op)
+ for (i = 1; i < nsyms; i += 1)
{
- case OP_FUNCALL:
- if (exp->elts[pc + 3].opcode == OP_VAR_VALUE
- && SYMBOL_DOMAIN (exp->elts[pc + 5].symbol) == UNDEF_DOMAIN)
- *pos += 7;
- else
+ struct block_symbol sym = syms[i];
+ int j;
+
+ for (j = i - 1; j >= 0; j -= 1)
{
- *pos += 3;
- resolve_subexp (expp, pos, 0, NULL, parse_completion);
+ if (encoded_ordered_before (syms[j].symbol->linkage_name (),
+ sym.symbol->linkage_name ()))
+ break;
+ syms[j + 1] = syms[j];
}
- nargs = longest_to_int (exp->elts[pc + 1].longconst);
- break;
+ syms[j + 1] = sym;
+ }
+}
- case UNOP_ADDR:
- *pos += 1;
- resolve_subexp (expp, pos, 0, NULL, parse_completion);
- break;
+/* Whether GDB should display formals and return types for functions in the
+ overloads selection menu. */
+static bool print_signatures = true;
- case UNOP_QUAL:
- *pos += 3;
- resolve_subexp (expp, pos, 1, check_typedef (exp->elts[pc + 1].type),
- parse_completion);
- break;
+/* Print the signature for SYM on STREAM according to the FLAGS options. For
+ all but functions, the signature is just the name of the symbol. For
+ functions, this is the name of the function, the list of types for formals
+ and the return type (if any). */
- case OP_ATR_MODULUS:
- case OP_ATR_SIZE:
- case OP_ATR_TAG:
- case OP_ATR_FIRST:
- case OP_ATR_LAST:
- case OP_ATR_LENGTH:
- case OP_ATR_POS:
- case OP_ATR_VAL:
- case OP_ATR_MIN:
- case OP_ATR_MAX:
- case TERNOP_IN_RANGE:
- case BINOP_IN_BOUNDS:
- case UNOP_IN_RANGE:
- case OP_AGGREGATE:
- case OP_OTHERS:
- case OP_CHOICES:
- case OP_POSITIONAL:
- case OP_DISCRETE_RANGE:
- case OP_NAME:
- ada_forward_operator_length (exp, pc, &oplen, &nargs);
- *pos += oplen;
- break;
+static void
+ada_print_symbol_signature (struct ui_file *stream, struct symbol *sym,
+ const struct type_print_options *flags)
+{
+ struct type *type = SYMBOL_TYPE (sym);
- case BINOP_ASSIGN:
- {
- struct value *arg1;
+ fprintf_filtered (stream, "%s", sym->print_name ());
+ if (!print_signatures
+ || type == NULL
+ || type->code () != TYPE_CODE_FUNC)
+ return;
- *pos += 1;
- arg1 = resolve_subexp (expp, pos, 0, NULL, parse_completion);
- if (arg1 == NULL)
- resolve_subexp (expp, pos, 1, NULL, parse_completion);
- else
- resolve_subexp (expp, pos, 1, value_type (arg1), parse_completion);
- break;
- }
+ if (type->num_fields () > 0)
+ {
+ int i;
- case UNOP_CAST:
- *pos += 3;
- nargs = 1;
- break;
+ fprintf_filtered (stream, " (");
+ for (i = 0; i < type->num_fields (); ++i)
+ {
+ if (i > 0)
+ fprintf_filtered (stream, "; ");
+ ada_print_type (TYPE_FIELD_TYPE (type, i), NULL, stream, -1, 0,
+ flags);
+ }
+ fprintf_filtered (stream, ")");
+ }
+ if (TYPE_TARGET_TYPE (type) != NULL
+ && TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
+ {
+ fprintf_filtered (stream, " return ");
+ ada_print_type (TYPE_TARGET_TYPE (type), NULL, stream, -1, 0, flags);
+ }
+}
- case BINOP_ADD:
- case BINOP_SUB:
- case BINOP_MUL:
- case BINOP_DIV:
+/* Read and validate a set of numeric choices from the user in the
+ range 0 .. N_CHOICES-1. Place the results in increasing
+ order in CHOICES[0 .. N-1], and return N.
+
+ The user types choices as a sequence of numbers on one line
+ separated by blanks, encoding them as follows:
+
+ + A choice of 0 means to cancel the selection, throwing an error.
+ + If IS_ALL_CHOICE, a choice of 1 selects the entire set 0 .. N_CHOICES-1.
+ + The user chooses k by typing k+IS_ALL_CHOICE+1.
+
+ The user is not allowed to choose more than MAX_RESULTS values.
+
+ ANNOTATION_SUFFIX, if present, is used to annotate the input
+ prompts (for use with the -f switch). */
+
+static int
+get_selections (int *choices, int n_choices, int max_results,
+ int is_all_choice, const char *annotation_suffix)
+{
+ const char *args;
+ const char *prompt;
+ int n_chosen;
+ int first_choice = is_all_choice ? 2 : 1;
+
+ prompt = getenv ("PS2");
+ if (prompt == NULL)
+ prompt = "> ";
+
+ args = command_line_input (prompt, annotation_suffix);
+
+ if (args == NULL)
+ error_no_arg (_("one or more choice numbers"));
+
+ n_chosen = 0;
+
+ /* Set choices[0 .. n_chosen-1] to the users' choices in ascending
+ order, as given in args. Choices are validated. */
+ while (1)
+ {
+ char *args2;
+ int choice, j;
+
+ args = skip_spaces (args);
+ if (*args == '\0' && n_chosen == 0)
+ error_no_arg (_("one or more choice numbers"));
+ else if (*args == '\0')
+ break;
+
+ choice = strtol (args, &args2, 10);
+ if (args == args2 || choice < 0
+ || choice > n_choices + first_choice - 1)
+ error (_("Argument must be choice number"));
+ args = args2;
+
+ if (choice == 0)
+ error (_("cancelled"));
+
+ if (choice < first_choice)
+ {
+ n_chosen = n_choices;
+ for (j = 0; j < n_choices; j += 1)
+ choices[j] = j;
+ break;
+ }
+ choice -= first_choice;
+
+ for (j = n_chosen - 1; j >= 0 && choice < choices[j]; j -= 1)
+ {
+ }
+
+ if (j < 0 || choice != choices[j])
+ {
+ int k;
+
+ for (k = n_chosen - 1; k > j; k -= 1)
+ choices[k + 1] = choices[k];
+ choices[j + 1] = choice;
+ n_chosen += 1;
+ }
+ }
+
+ if (n_chosen > max_results)
+ error (_("Select no more than %d of the above"), max_results);
+
+ return n_chosen;
+}
+
+/* Given a list of NSYMS symbols in SYMS, select up to MAX_RESULTS>0
+ by asking the user (if necessary), returning the number selected,
+ and setting the first elements of SYMS items. Error if no symbols
+ selected. */
+
+/* NOTE: Adapted from decode_line_2 in symtab.c, with which it ought
+ to be re-integrated one of these days. */
+
+static int
+user_select_syms (struct block_symbol *syms, int nsyms, int max_results)
+{
+ int i;
+ int *chosen = XALLOCAVEC (int , nsyms);
+ int n_chosen;
+ int first_choice = (max_results == 1) ? 1 : 2;
+ const char *select_mode = multiple_symbols_select_mode ();
+
+ if (max_results < 1)
+ error (_("Request to select 0 symbols!"));
+ if (nsyms <= 1)
+ return nsyms;
+
+ if (select_mode == multiple_symbols_cancel)
+ error (_("\
+canceled because the command is ambiguous\n\
+See set/show multiple-symbol."));
+
+ /* If select_mode is "all", then return all possible symbols.
+ Only do that if more than one symbol can be selected, of course.
+ Otherwise, display the menu as usual. */
+ if (select_mode == multiple_symbols_all && max_results > 1)
+ return nsyms;
+
+ printf_filtered (_("[0] cancel\n"));
+ if (max_results > 1)
+ printf_filtered (_("[1] all\n"));
+
+ sort_choices (syms, nsyms);
+
+ for (i = 0; i < nsyms; i += 1)
+ {
+ if (syms[i].symbol == NULL)
+ continue;
+
+ if (SYMBOL_CLASS (syms[i].symbol) == LOC_BLOCK)
+ {
+ struct symtab_and_line sal =
+ find_function_start_sal (syms[i].symbol, 1);
+
+ printf_filtered ("[%d] ", i + first_choice);
+ ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
+ &type_print_raw_options);
+ if (sal.symtab == NULL)
+ printf_filtered (_(" at %p[<no source file available>%p]:%d\n"),
+ metadata_style.style ().ptr (), nullptr, sal.line);
+ else
+ printf_filtered
+ (_(" at %ps:%d\n"),
+ styled_string (file_name_style.style (),
+ symtab_to_filename_for_display (sal.symtab)),
+ sal.line);
+ continue;
+ }
+ else
+ {
+ int is_enumeral =
+ (SYMBOL_CLASS (syms[i].symbol) == LOC_CONST
+ && SYMBOL_TYPE (syms[i].symbol) != NULL
+ && SYMBOL_TYPE (syms[i].symbol)->code () == TYPE_CODE_ENUM);
+ struct symtab *symtab = NULL;
+
+ if (SYMBOL_OBJFILE_OWNED (syms[i].symbol))
+ symtab = symbol_symtab (syms[i].symbol);
+
+ if (SYMBOL_LINE (syms[i].symbol) != 0 && symtab != NULL)
+ {
+ printf_filtered ("[%d] ", i + first_choice);
+ ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
+ &type_print_raw_options);
+ printf_filtered (_(" at %s:%d\n"),
+ symtab_to_filename_for_display (symtab),
+ SYMBOL_LINE (syms[i].symbol));
+ }
+ else if (is_enumeral
+ && SYMBOL_TYPE (syms[i].symbol)->name () != NULL)
+ {
+ printf_filtered (("[%d] "), i + first_choice);
+ ada_print_type (SYMBOL_TYPE (syms[i].symbol), NULL,
+ gdb_stdout, -1, 0, &type_print_raw_options);
+ printf_filtered (_("'(%s) (enumeral)\n"),
+ syms[i].symbol->print_name ());
+ }
+ else
+ {
+ printf_filtered ("[%d] ", i + first_choice);
+ ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
+ &type_print_raw_options);
+
+ if (symtab != NULL)
+ printf_filtered (is_enumeral
+ ? _(" in %s (enumeral)\n")
+ : _(" at %s:?\n"),
+ symtab_to_filename_for_display (symtab));
+ else
+ printf_filtered (is_enumeral
+ ? _(" (enumeral)\n")
+ : _(" at ?\n"));
+ }
+ }
+ }
+
+ n_chosen = get_selections (chosen, nsyms, max_results, max_results > 1,
+ "overload-choice");
+
+ for (i = 0; i < n_chosen; i += 1)
+ syms[i] = syms[chosen[i]];
+
+ return n_chosen;
+}
+
+/* Same as evaluate_type (*EXP), but resolves ambiguous symbol
+ references (marked by OP_VAR_VALUE nodes in which the symbol has an
+ undefined namespace) and converts operators that are
+ user-defined into appropriate function calls. If CONTEXT_TYPE is
+ non-null, it provides a preferred result type [at the moment, only
+ type void has any effect---causing procedures to be preferred over
+ functions in calls]. A null CONTEXT_TYPE indicates that a non-void
+ return type is preferred. May change (expand) *EXP. */
+
+static void
+resolve (expression_up *expp, int void_context_p, int parse_completion,
+ innermost_block_tracker *tracker)
+{
+ struct type *context_type = NULL;
+ int pc = 0;
+
+ if (void_context_p)
+ context_type = builtin_type ((*expp)->gdbarch)->builtin_void;
+
+ resolve_subexp (expp, &pc, 1, context_type, parse_completion, tracker);
+}
+
+/* Resolve the operator of the subexpression beginning at
+ position *POS of *EXPP. "Resolving" consists of replacing
+ the symbols that have undefined namespaces in OP_VAR_VALUE nodes
+ with their resolutions, replacing built-in operators with
+ function calls to user-defined operators, where appropriate, and,
+ when DEPROCEDURE_P is non-zero, converting function-valued variables
+ into parameterless calls. May expand *EXPP. The CONTEXT_TYPE functions
+ are as in ada_resolve, above. */
+
+static struct value *
+resolve_subexp (expression_up *expp, int *pos, int deprocedure_p,
+ struct type *context_type, int parse_completion,
+ innermost_block_tracker *tracker)
+{
+ int pc = *pos;
+ int i;
+ struct expression *exp; /* Convenience: == *expp. */
+ enum exp_opcode op = (*expp)->elts[pc].opcode;
+ struct value **argvec; /* Vector of operand types (alloca'ed). */
+ int nargs; /* Number of operands. */
+ int oplen;
+
+ argvec = NULL;
+ nargs = 0;
+ exp = expp->get ();
+
+ /* Pass one: resolve operands, saving their types and updating *pos,
+ if needed. */
+ switch (op)
+ {
+ case OP_FUNCALL:
+ if (exp->elts[pc + 3].opcode == OP_VAR_VALUE
+ && SYMBOL_DOMAIN (exp->elts[pc + 5].symbol) == UNDEF_DOMAIN)
+ *pos += 7;
+ else
+ {
+ *pos += 3;
+ resolve_subexp (expp, pos, 0, NULL, parse_completion, tracker);
+ }
+ nargs = longest_to_int (exp->elts[pc + 1].longconst);
+ break;
+
+ case UNOP_ADDR:
+ *pos += 1;
+ resolve_subexp (expp, pos, 0, NULL, parse_completion, tracker);
+ break;
+
+ case UNOP_QUAL:
+ *pos += 3;
+ resolve_subexp (expp, pos, 1, check_typedef (exp->elts[pc + 1].type),
+ parse_completion, tracker);
+ break;
+
+ case OP_ATR_MODULUS:
+ case OP_ATR_SIZE:
+ case OP_ATR_TAG:
+ case OP_ATR_FIRST:
+ case OP_ATR_LAST:
+ case OP_ATR_LENGTH:
+ case OP_ATR_POS:
+ case OP_ATR_VAL:
+ case OP_ATR_MIN:
+ case OP_ATR_MAX:
+ case TERNOP_IN_RANGE:
+ case BINOP_IN_BOUNDS:
+ case UNOP_IN_RANGE:
+ case OP_AGGREGATE:
+ case OP_OTHERS:
+ case OP_CHOICES:
+ case OP_POSITIONAL:
+ case OP_DISCRETE_RANGE:
+ case OP_NAME:
+ ada_forward_operator_length (exp, pc, &oplen, &nargs);
+ *pos += oplen;
+ break;
+
+ case BINOP_ASSIGN:
+ {
+ struct value *arg1;
+
+ *pos += 1;
+ arg1 = resolve_subexp (expp, pos, 0, NULL, parse_completion, tracker);
+ if (arg1 == NULL)
+ resolve_subexp (expp, pos, 1, NULL, parse_completion, tracker);
+ else
+ resolve_subexp (expp, pos, 1, value_type (arg1), parse_completion,
+ tracker);
+ break;
+ }
+
+ case UNOP_CAST:
+ *pos += 3;
+ nargs = 1;
+ break;
+
+ case BINOP_ADD:
+ case BINOP_SUB:
+ case BINOP_MUL:
+ case BINOP_DIV:
case BINOP_REM:
case BINOP_MOD:
case BINOP_EXP:
argvec = XALLOCAVEC (struct value *, nargs + 1);
for (i = 0; i < nargs; i += 1)
- argvec[i] = resolve_subexp (expp, pos, 1, NULL, parse_completion);
+ argvec[i] = resolve_subexp (expp, pos, 1, NULL, parse_completion,
+ tracker);
argvec[i] = NULL;
exp = expp->get ();
int n_candidates;
n_candidates =
- ada_lookup_symbol_list (SYMBOL_LINKAGE_NAME
- (exp->elts[pc + 2].symbol),
+ ada_lookup_symbol_list (exp->elts[pc + 2].symbol->linkage_name (),
exp->elts[pc + 1].block, VAR_DOMAIN,
&candidates);
if (n_candidates == 0)
error (_("No definition found for %s"),
- SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
+ exp->elts[pc + 2].symbol->print_name ());
else if (n_candidates == 1)
i = 0;
else if (deprocedure_p
{
i = ada_resolve_function
(candidates.data (), n_candidates, NULL, 0,
- SYMBOL_LINKAGE_NAME (exp->elts[pc + 2].symbol),
+ exp->elts[pc + 2].symbol->linkage_name (),
context_type, parse_completion);
if (i < 0)
error (_("Could not find a match for %s"),
- SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
+ exp->elts[pc + 2].symbol->print_name ());
}
else
{
printf_filtered (_("Multiple matches for %s\n"),
- SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
+ exp->elts[pc + 2].symbol->print_name ());
user_select_syms (candidates.data (), n_candidates, 1);
i = 0;
}
exp->elts[pc + 1].block = candidates[i].block;
exp->elts[pc + 2].symbol = candidates[i].symbol;
- innermost_block.update (candidates[i]);
+ tracker->update (candidates[i]);
}
if (deprocedure_p
- && (TYPE_CODE (SYMBOL_TYPE (exp->elts[pc + 2].symbol))
+ && (SYMBOL_TYPE (exp->elts[pc + 2].symbol)->code ()
== TYPE_CODE_FUNC))
{
replace_operator_with_call (expp, pc, 0, 4,
int n_candidates;
n_candidates =
- ada_lookup_symbol_list (SYMBOL_LINKAGE_NAME
- (exp->elts[pc + 5].symbol),
+ ada_lookup_symbol_list (exp->elts[pc + 5].symbol->linkage_name (),
exp->elts[pc + 4].block, VAR_DOMAIN,
&candidates);
i = ada_resolve_function
(candidates.data (), n_candidates,
argvec, nargs,
- SYMBOL_LINKAGE_NAME (exp->elts[pc + 5].symbol),
+ exp->elts[pc + 5].symbol->linkage_name (),
context_type, parse_completion);
if (i < 0)
error (_("Could not find a match for %s"),
- SYMBOL_PRINT_NAME (exp->elts[pc + 5].symbol));
+ exp->elts[pc + 5].symbol->print_name ());
}
exp->elts[pc + 4].block = candidates[i].block;
exp->elts[pc + 5].symbol = candidates[i].symbol;
- innermost_block.update (candidates[i]);
+ tracker->update (candidates[i]);
}
}
break;
n_candidates =
ada_lookup_symbol_list (ada_decoded_op_name (op),
NULL, VAR_DOMAIN,
- &candidates);
-
- i = ada_resolve_function (candidates.data (), n_candidates, argvec,
- nargs, ada_decoded_op_name (op), NULL,
- parse_completion);
- if (i < 0)
- break;
-
- replace_operator_with_call (expp, pc, nargs, 1,
- candidates[i].symbol,
- candidates[i].block);
- exp = expp->get ();
- }
- break;
-
- case OP_TYPE:
- case OP_REGISTER:
- return NULL;
- }
-
- *pos = pc;
- if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE)
- return evaluate_var_msym_value (EVAL_AVOID_SIDE_EFFECTS,
- exp->elts[pc + 1].objfile,
- exp->elts[pc + 2].msymbol);
- else
- return evaluate_subexp_type (exp, pos);
-}
-
-/* Return non-zero if formal type FTYPE matches actual type ATYPE. If
- MAY_DEREF is non-zero, the formal may be a pointer and the actual
- a non-pointer. */
-/* The term "match" here is rather loose. The match is heuristic and
- liberal. */
-
-static int
-ada_type_match (struct type *ftype, struct type *atype, int may_deref)
-{
- ftype = ada_check_typedef (ftype);
- atype = ada_check_typedef (atype);
-
- if (TYPE_CODE (ftype) == TYPE_CODE_REF)
- ftype = TYPE_TARGET_TYPE (ftype);
- if (TYPE_CODE (atype) == TYPE_CODE_REF)
- atype = TYPE_TARGET_TYPE (atype);
-
- switch (TYPE_CODE (ftype))
- {
- default:
- return TYPE_CODE (ftype) == TYPE_CODE (atype);
- case TYPE_CODE_PTR:
- if (TYPE_CODE (atype) == TYPE_CODE_PTR)
- return ada_type_match (TYPE_TARGET_TYPE (ftype),
- TYPE_TARGET_TYPE (atype), 0);
- else
- return (may_deref
- && ada_type_match (TYPE_TARGET_TYPE (ftype), atype, 0));
- case TYPE_CODE_INT:
- case TYPE_CODE_ENUM:
- case TYPE_CODE_RANGE:
- switch (TYPE_CODE (atype))
- {
- case TYPE_CODE_INT:
- case TYPE_CODE_ENUM:
- case TYPE_CODE_RANGE:
- return 1;
- default:
- return 0;
- }
-
- case TYPE_CODE_ARRAY:
- return (TYPE_CODE (atype) == TYPE_CODE_ARRAY
- || ada_is_array_descriptor_type (atype));
-
- case TYPE_CODE_STRUCT:
- if (ada_is_array_descriptor_type (ftype))
- return (TYPE_CODE (atype) == TYPE_CODE_ARRAY
- || ada_is_array_descriptor_type (atype));
- else
- return (TYPE_CODE (atype) == TYPE_CODE_STRUCT
- && !ada_is_array_descriptor_type (atype));
-
- case TYPE_CODE_UNION:
- case TYPE_CODE_FLT:
- return (TYPE_CODE (atype) == TYPE_CODE (ftype));
- }
-}
-
-/* Return non-zero if the formals of FUNC "sufficiently match" the
- vector of actual argument types ACTUALS of size N_ACTUALS. FUNC
- may also be an enumeral, in which case it is treated as a 0-
- argument function. */
-
-static int
-ada_args_match (struct symbol *func, struct value **actuals, int n_actuals)
-{
- int i;
- struct type *func_type = SYMBOL_TYPE (func);
-
- if (SYMBOL_CLASS (func) == LOC_CONST
- && TYPE_CODE (func_type) == TYPE_CODE_ENUM)
- return (n_actuals == 0);
- else if (func_type == NULL || TYPE_CODE (func_type) != TYPE_CODE_FUNC)
- return 0;
-
- if (TYPE_NFIELDS (func_type) != n_actuals)
- return 0;
-
- for (i = 0; i < n_actuals; i += 1)
- {
- if (actuals[i] == NULL)
- return 0;
- else
- {
- struct type *ftype = ada_check_typedef (TYPE_FIELD_TYPE (func_type,
- i));
- struct type *atype = ada_check_typedef (value_type (actuals[i]));
-
- if (!ada_type_match (ftype, atype, 1))
- return 0;
- }
- }
- return 1;
-}
-
-/* False iff function type FUNC_TYPE definitely does not produce a value
- compatible with type CONTEXT_TYPE. Conservatively returns 1 if
- FUNC_TYPE is not a valid function type with a non-null return type
- or an enumerated type. A null CONTEXT_TYPE indicates any non-void type. */
-
-static int
-return_match (struct type *func_type, struct type *context_type)
-{
- struct type *return_type;
-
- if (func_type == NULL)
- return 1;
-
- if (TYPE_CODE (func_type) == TYPE_CODE_FUNC)
- return_type = get_base_type (TYPE_TARGET_TYPE (func_type));
- else
- return_type = get_base_type (func_type);
- if (return_type == NULL)
- return 1;
-
- context_type = get_base_type (context_type);
-
- if (TYPE_CODE (return_type) == TYPE_CODE_ENUM)
- return context_type == NULL || return_type == context_type;
- else if (context_type == NULL)
- return TYPE_CODE (return_type) != TYPE_CODE_VOID;
- else
- return TYPE_CODE (return_type) == TYPE_CODE (context_type);
-}
-
-
-/* Returns the index in SYMS[0..NSYMS-1] that contains the symbol for the
- function (if any) that matches the types of the NARGS arguments in
- ARGS. If CONTEXT_TYPE is non-null and there is at least one match
- that returns that type, then eliminate matches that don't. If
- CONTEXT_TYPE is void and there is at least one match that does not
- return void, eliminate all matches that do.
-
- Asks the user if there is more than one match remaining. Returns -1
- if there is no such symbol or none is selected. NAME is used
- solely for messages. May re-arrange and modify SYMS in
- the process; the index returned is for the modified vector. */
-
-static int
-ada_resolve_function (struct block_symbol syms[],
- int nsyms, struct value **args, int nargs,
- const char *name, struct type *context_type,
- int parse_completion)
-{
- int fallback;
- int k;
- int m; /* Number of hits */
-
- m = 0;
- /* In the first pass of the loop, we only accept functions matching
- context_type. If none are found, we add a second pass of the loop
- where every function is accepted. */
- for (fallback = 0; m == 0 && fallback < 2; fallback++)
- {
- for (k = 0; k < nsyms; k += 1)
- {
- struct type *type = ada_check_typedef (SYMBOL_TYPE (syms[k].symbol));
-
- if (ada_args_match (syms[k].symbol, args, nargs)
- && (fallback || return_match (type, context_type)))
- {
- syms[m] = syms[k];
- m += 1;
- }
- }
- }
-
- /* If we got multiple matches, ask the user which one to use. Don't do this
- interactive thing during completion, though, as the purpose of the
- completion is providing a list of all possible matches. Prompting the
- user to filter it down would be completely unexpected in this case. */
- if (m == 0)
- return -1;
- else if (m > 1 && !parse_completion)
- {
- printf_filtered (_("Multiple matches for %s\n"), name);
- user_select_syms (syms, m, 1);
- return 0;
- }
- return 0;
-}
-
-/* Returns true (non-zero) iff decoded name N0 should appear before N1
- in a listing of choices during disambiguation (see sort_choices, below).
- The idea is that overloadings of a subprogram name from the
- same package should sort in their source order. We settle for ordering
- such symbols by their trailing number (__N or $N). */
-
-static int
-encoded_ordered_before (const char *N0, const char *N1)
-{
- if (N1 == NULL)
- return 0;
- else if (N0 == NULL)
- return 1;
- else
- {
- int k0, k1;
-
- for (k0 = strlen (N0) - 1; k0 > 0 && isdigit (N0[k0]); k0 -= 1)
- ;
- for (k1 = strlen (N1) - 1; k1 > 0 && isdigit (N1[k1]); k1 -= 1)
- ;
- if ((N0[k0] == '_' || N0[k0] == '$') && N0[k0 + 1] != '\000'
- && (N1[k1] == '_' || N1[k1] == '$') && N1[k1 + 1] != '\000')
- {
- int n0, n1;
+ &candidates);
- n0 = k0;
- while (N0[n0] == '_' && n0 > 0 && N0[n0 - 1] == '_')
- n0 -= 1;
- n1 = k1;
- while (N1[n1] == '_' && n1 > 0 && N1[n1 - 1] == '_')
- n1 -= 1;
- if (n0 == n1 && strncmp (N0, N1, n0) == 0)
- return (atoi (N0 + k0 + 1) < atoi (N1 + k1 + 1));
+ i = ada_resolve_function (candidates.data (), n_candidates, argvec,
+ nargs, ada_decoded_op_name (op), NULL,
+ parse_completion);
+ if (i < 0)
+ break;
+
+ replace_operator_with_call (expp, pc, nargs, 1,
+ candidates[i].symbol,
+ candidates[i].block);
+ exp = expp->get ();
}
- return (strcmp (N0, N1) < 0);
+ break;
+
+ case OP_TYPE:
+ case OP_REGISTER:
+ return NULL;
}
+
+ *pos = pc;
+ if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE)
+ return evaluate_var_msym_value (EVAL_AVOID_SIDE_EFFECTS,
+ exp->elts[pc + 1].objfile,
+ exp->elts[pc + 2].msymbol);
+ else
+ return evaluate_subexp_type (exp, pos);
}
-/* Sort SYMS[0..NSYMS-1] to put the choices in a canonical order by the
- encoded names. */
+/* Return non-zero if formal type FTYPE matches actual type ATYPE. If
+ MAY_DEREF is non-zero, the formal may be a pointer and the actual
+ a non-pointer. */
+/* The term "match" here is rather loose. The match is heuristic and
+ liberal. */
-static void
-sort_choices (struct block_symbol syms[], int nsyms)
+static int
+ada_type_match (struct type *ftype, struct type *atype, int may_deref)
{
- int i;
+ ftype = ada_check_typedef (ftype);
+ atype = ada_check_typedef (atype);
- for (i = 1; i < nsyms; i += 1)
- {
- struct block_symbol sym = syms[i];
- int j;
+ if (ftype->code () == TYPE_CODE_REF)
+ ftype = TYPE_TARGET_TYPE (ftype);
+ if (atype->code () == TYPE_CODE_REF)
+ atype = TYPE_TARGET_TYPE (atype);
- for (j = i - 1; j >= 0; j -= 1)
+ switch (ftype->code ())
+ {
+ default:
+ return ftype->code () == atype->code ();
+ case TYPE_CODE_PTR:
+ if (atype->code () == TYPE_CODE_PTR)
+ return ada_type_match (TYPE_TARGET_TYPE (ftype),
+ TYPE_TARGET_TYPE (atype), 0);
+ else
+ return (may_deref
+ && ada_type_match (TYPE_TARGET_TYPE (ftype), atype, 0));
+ case TYPE_CODE_INT:
+ case TYPE_CODE_ENUM:
+ case TYPE_CODE_RANGE:
+ switch (atype->code ())
{
- if (encoded_ordered_before (SYMBOL_LINKAGE_NAME (syms[j].symbol),
- SYMBOL_LINKAGE_NAME (sym.symbol)))
- break;
- syms[j + 1] = syms[j];
+ case TYPE_CODE_INT:
+ case TYPE_CODE_ENUM:
+ case TYPE_CODE_RANGE:
+ return 1;
+ default:
+ return 0;
}
- syms[j + 1] = sym;
- }
-}
-
-/* Whether GDB should display formals and return types for functions in the
- overloads selection menu. */
-static int print_signatures = 1;
-
-/* Print the signature for SYM on STREAM according to the FLAGS options. For
- all but functions, the signature is just the name of the symbol. For
- functions, this is the name of the function, the list of types for formals
- and the return type (if any). */
-
-static void
-ada_print_symbol_signature (struct ui_file *stream, struct symbol *sym,
- const struct type_print_options *flags)
-{
- struct type *type = SYMBOL_TYPE (sym);
- fprintf_filtered (stream, "%s", SYMBOL_PRINT_NAME (sym));
- if (!print_signatures
- || type == NULL
- || TYPE_CODE (type) != TYPE_CODE_FUNC)
- return;
+ case TYPE_CODE_ARRAY:
+ return (atype->code () == TYPE_CODE_ARRAY
+ || ada_is_array_descriptor_type (atype));
- if (TYPE_NFIELDS (type) > 0)
- {
- int i;
+ case TYPE_CODE_STRUCT:
+ if (ada_is_array_descriptor_type (ftype))
+ return (atype->code () == TYPE_CODE_ARRAY
+ || ada_is_array_descriptor_type (atype));
+ else
+ return (atype->code () == TYPE_CODE_STRUCT
+ && !ada_is_array_descriptor_type (atype));
- fprintf_filtered (stream, " (");
- for (i = 0; i < TYPE_NFIELDS (type); ++i)
- {
- if (i > 0)
- fprintf_filtered (stream, "; ");
- ada_print_type (TYPE_FIELD_TYPE (type, i), NULL, stream, -1, 0,
- flags);
- }
- fprintf_filtered (stream, ")");
- }
- if (TYPE_TARGET_TYPE (type) != NULL
- && TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
- {
- fprintf_filtered (stream, " return ");
- ada_print_type (TYPE_TARGET_TYPE (type), NULL, stream, -1, 0, flags);
+ case TYPE_CODE_UNION:
+ case TYPE_CODE_FLT:
+ return (atype->code () == ftype->code ());
}
}
-/* Given a list of NSYMS symbols in SYMS, select up to MAX_RESULTS>0
- by asking the user (if necessary), returning the number selected,
- and setting the first elements of SYMS items. Error if no symbols
- selected. */
-
-/* NOTE: Adapted from decode_line_2 in symtab.c, with which it ought
- to be re-integrated one of these days. */
+/* Return non-zero if the formals of FUNC "sufficiently match" the
+ vector of actual argument types ACTUALS of size N_ACTUALS. FUNC
+ may also be an enumeral, in which case it is treated as a 0-
+ argument function. */
-int
-user_select_syms (struct block_symbol *syms, int nsyms, int max_results)
+static int
+ada_args_match (struct symbol *func, struct value **actuals, int n_actuals)
{
int i;
- int *chosen = XALLOCAVEC (int , nsyms);
- int n_chosen;
- int first_choice = (max_results == 1) ? 1 : 2;
- const char *select_mode = multiple_symbols_select_mode ();
-
- if (max_results < 1)
- error (_("Request to select 0 symbols!"));
- if (nsyms <= 1)
- return nsyms;
-
- if (select_mode == multiple_symbols_cancel)
- error (_("\
-canceled because the command is ambiguous\n\
-See set/show multiple-symbol."));
-
- /* If select_mode is "all", then return all possible symbols.
- Only do that if more than one symbol can be selected, of course.
- Otherwise, display the menu as usual. */
- if (select_mode == multiple_symbols_all && max_results > 1)
- return nsyms;
+ struct type *func_type = SYMBOL_TYPE (func);
- printf_filtered (_("[0] cancel\n"));
- if (max_results > 1)
- printf_filtered (_("[1] all\n"));
+ if (SYMBOL_CLASS (func) == LOC_CONST
+ && func_type->code () == TYPE_CODE_ENUM)
+ return (n_actuals == 0);
+ else if (func_type == NULL || func_type->code () != TYPE_CODE_FUNC)
+ return 0;
- sort_choices (syms, nsyms);
+ if (func_type->num_fields () != n_actuals)
+ return 0;
- for (i = 0; i < nsyms; i += 1)
+ for (i = 0; i < n_actuals; i += 1)
{
- if (syms[i].symbol == NULL)
- continue;
-
- if (SYMBOL_CLASS (syms[i].symbol) == LOC_BLOCK)
- {
- struct symtab_and_line sal =
- find_function_start_sal (syms[i].symbol, 1);
-
- printf_filtered ("[%d] ", i + first_choice);
- ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
- &type_print_raw_options);
- if (sal.symtab == NULL)
- printf_filtered (_(" at <no source file available>:%d\n"),
- sal.line);
- else
- printf_filtered (_(" at %s:%d\n"),
- symtab_to_filename_for_display (sal.symtab),
- sal.line);
- continue;
- }
+ if (actuals[i] == NULL)
+ return 0;
else
{
- int is_enumeral =
- (SYMBOL_CLASS (syms[i].symbol) == LOC_CONST
- && SYMBOL_TYPE (syms[i].symbol) != NULL
- && TYPE_CODE (SYMBOL_TYPE (syms[i].symbol)) == TYPE_CODE_ENUM);
- struct symtab *symtab = NULL;
-
- if (SYMBOL_OBJFILE_OWNED (syms[i].symbol))
- symtab = symbol_symtab (syms[i].symbol);
-
- if (SYMBOL_LINE (syms[i].symbol) != 0 && symtab != NULL)
- {
- printf_filtered ("[%d] ", i + first_choice);
- ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
- &type_print_raw_options);
- printf_filtered (_(" at %s:%d\n"),
- symtab_to_filename_for_display (symtab),
- SYMBOL_LINE (syms[i].symbol));
- }
- else if (is_enumeral
- && TYPE_NAME (SYMBOL_TYPE (syms[i].symbol)) != NULL)
- {
- printf_filtered (("[%d] "), i + first_choice);
- ada_print_type (SYMBOL_TYPE (syms[i].symbol), NULL,
- gdb_stdout, -1, 0, &type_print_raw_options);
- printf_filtered (_("'(%s) (enumeral)\n"),
- SYMBOL_PRINT_NAME (syms[i].symbol));
- }
- else
- {
- printf_filtered ("[%d] ", i + first_choice);
- ada_print_symbol_signature (gdb_stdout, syms[i].symbol,
- &type_print_raw_options);
-
- if (symtab != NULL)
- printf_filtered (is_enumeral
- ? _(" in %s (enumeral)\n")
- : _(" at %s:?\n"),
- symtab_to_filename_for_display (symtab));
- else
- printf_filtered (is_enumeral
- ? _(" (enumeral)\n")
- : _(" at ?\n"));
- }
- }
- }
-
- n_chosen = get_selections (chosen, nsyms, max_results, max_results > 1,
- "overload-choice");
-
- for (i = 0; i < n_chosen; i += 1)
- syms[i] = syms[chosen[i]];
-
- return n_chosen;
-}
-
-/* Read and validate a set of numeric choices from the user in the
- range 0 .. N_CHOICES-1. Place the results in increasing
- order in CHOICES[0 .. N-1], and return N.
-
- The user types choices as a sequence of numbers on one line
- separated by blanks, encoding them as follows:
-
- + A choice of 0 means to cancel the selection, throwing an error.
- + If IS_ALL_CHOICE, a choice of 1 selects the entire set 0 .. N_CHOICES-1.
- + The user chooses k by typing k+IS_ALL_CHOICE+1.
-
- The user is not allowed to choose more than MAX_RESULTS values.
-
- ANNOTATION_SUFFIX, if present, is used to annotate the input
- prompts (for use with the -f switch). */
-
-int
-get_selections (int *choices, int n_choices, int max_results,
- int is_all_choice, const char *annotation_suffix)
-{
- char *args;
- const char *prompt;
- int n_chosen;
- int first_choice = is_all_choice ? 2 : 1;
+ struct type *ftype = ada_check_typedef (TYPE_FIELD_TYPE (func_type,
+ i));
+ struct type *atype = ada_check_typedef (value_type (actuals[i]));
- prompt = getenv ("PS2");
- if (prompt == NULL)
- prompt = "> ";
+ if (!ada_type_match (ftype, atype, 1))
+ return 0;
+ }
+ }
+ return 1;
+}
- args = command_line_input (prompt, annotation_suffix);
+/* False iff function type FUNC_TYPE definitely does not produce a value
+ compatible with type CONTEXT_TYPE. Conservatively returns 1 if
+ FUNC_TYPE is not a valid function type with a non-null return type
+ or an enumerated type. A null CONTEXT_TYPE indicates any non-void type. */
- if (args == NULL)
- error_no_arg (_("one or more choice numbers"));
+static int
+return_match (struct type *func_type, struct type *context_type)
+{
+ struct type *return_type;
- n_chosen = 0;
+ if (func_type == NULL)
+ return 1;
- /* Set choices[0 .. n_chosen-1] to the users' choices in ascending
- order, as given in args. Choices are validated. */
- while (1)
- {
- char *args2;
- int choice, j;
+ if (func_type->code () == TYPE_CODE_FUNC)
+ return_type = get_base_type (TYPE_TARGET_TYPE (func_type));
+ else
+ return_type = get_base_type (func_type);
+ if (return_type == NULL)
+ return 1;
- args = skip_spaces (args);
- if (*args == '\0' && n_chosen == 0)
- error_no_arg (_("one or more choice numbers"));
- else if (*args == '\0')
- break;
+ context_type = get_base_type (context_type);
- choice = strtol (args, &args2, 10);
- if (args == args2 || choice < 0
- || choice > n_choices + first_choice - 1)
- error (_("Argument must be choice number"));
- args = args2;
+ if (return_type->code () == TYPE_CODE_ENUM)
+ return context_type == NULL || return_type == context_type;
+ else if (context_type == NULL)
+ return return_type->code () != TYPE_CODE_VOID;
+ else
+ return return_type->code () == context_type->code ();
+}
- if (choice == 0)
- error (_("cancelled"));
- if (choice < first_choice)
- {
- n_chosen = n_choices;
- for (j = 0; j < n_choices; j += 1)
- choices[j] = j;
- break;
- }
- choice -= first_choice;
+/* Returns the index in SYMS[0..NSYMS-1] that contains the symbol for the
+ function (if any) that matches the types of the NARGS arguments in
+ ARGS. If CONTEXT_TYPE is non-null and there is at least one match
+ that returns that type, then eliminate matches that don't. If
+ CONTEXT_TYPE is void and there is at least one match that does not
+ return void, eliminate all matches that do.
- for (j = n_chosen - 1; j >= 0 && choice < choices[j]; j -= 1)
- {
- }
+ Asks the user if there is more than one match remaining. Returns -1
+ if there is no such symbol or none is selected. NAME is used
+ solely for messages. May re-arrange and modify SYMS in
+ the process; the index returned is for the modified vector. */
- if (j < 0 || choice != choices[j])
+static int
+ada_resolve_function (struct block_symbol syms[],
+ int nsyms, struct value **args, int nargs,
+ const char *name, struct type *context_type,
+ int parse_completion)
+{
+ int fallback;
+ int k;
+ int m; /* Number of hits */
+
+ m = 0;
+ /* In the first pass of the loop, we only accept functions matching
+ context_type. If none are found, we add a second pass of the loop
+ where every function is accepted. */
+ for (fallback = 0; m == 0 && fallback < 2; fallback++)
+ {
+ for (k = 0; k < nsyms; k += 1)
{
- int k;
+ struct type *type = ada_check_typedef (SYMBOL_TYPE (syms[k].symbol));
- for (k = n_chosen - 1; k > j; k -= 1)
- choices[k + 1] = choices[k];
- choices[j + 1] = choice;
- n_chosen += 1;
+ if (ada_args_match (syms[k].symbol, args, nargs)
+ && (fallback || return_match (type, context_type)))
+ {
+ syms[m] = syms[k];
+ m += 1;
+ }
}
}
- if (n_chosen > max_results)
- error (_("Select no more than %d of the above"), max_results);
-
- return n_chosen;
+ /* If we got multiple matches, ask the user which one to use. Don't do this
+ interactive thing during completion, though, as the purpose of the
+ completion is providing a list of all possible matches. Prompting the
+ user to filter it down would be completely unexpected in this case. */
+ if (m == 0)
+ return -1;
+ else if (m > 1 && !parse_completion)
+ {
+ printf_filtered (_("Multiple matches for %s\n"), name);
+ user_select_syms (syms, m, 1);
+ return 0;
+ }
+ return 0;
}
/* Replace the operator of length OPLEN at position PC in *EXPP with a call
return 0;
else
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_INT:
case TYPE_CODE_FLT:
return 0;
else
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_INT:
return 1;
return 0;
else
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_INT:
case TYPE_CODE_RANGE:
return 0;
else
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_INT:
case TYPE_CODE_RANGE:
{
default:
return ADA_NOT_RENAMING;
- case LOC_TYPEDEF:
- return parse_old_style_renaming (SYMBOL_TYPE (sym),
- renamed_entity, len, renaming_expr);
case LOC_LOCAL:
case LOC_STATIC:
case LOC_COMPUTED:
case LOC_OPTIMIZED_OUT:
- info = strstr (SYMBOL_LINKAGE_NAME (sym), "___XR");
+ info = strstr (sym->linkage_name (), "___XR");
if (info == NULL)
return ADA_NOT_RENAMING;
switch (info[5])
return kind;
}
-/* Assuming TYPE encodes a renaming according to the old encoding in
- exp_dbug.ads, returns details of that renaming in *RENAMED_ENTITY,
- *LEN, and *RENAMING_EXPR, as for ada_parse_renaming, above. Returns
- ADA_NOT_RENAMING otherwise. */
-static enum ada_renaming_category
-parse_old_style_renaming (struct type *type,
- const char **renamed_entity, int *len,
- const char **renaming_expr)
-{
- enum ada_renaming_category kind;
- const char *name;
- const char *info;
- const char *suffix;
-
- if (type == NULL || TYPE_CODE (type) != TYPE_CODE_ENUM
- || TYPE_NFIELDS (type) != 1)
- return ADA_NOT_RENAMING;
-
- name = TYPE_NAME (type);
- if (name == NULL)
- return ADA_NOT_RENAMING;
-
- name = strstr (name, "___XR");
- if (name == NULL)
- return ADA_NOT_RENAMING;
- switch (name[5])
- {
- case '\0':
- case '_':
- kind = ADA_OBJECT_RENAMING;
- break;
- case 'E':
- kind = ADA_EXCEPTION_RENAMING;
- break;
- case 'P':
- kind = ADA_PACKAGE_RENAMING;
- break;
- case 'S':
- kind = ADA_SUBPROGRAM_RENAMING;
- break;
- default:
- return ADA_NOT_RENAMING;
- }
-
- info = TYPE_FIELD_NAME (type, 0);
- if (info == NULL)
- return ADA_NOT_RENAMING;
- if (renamed_entity != NULL)
- *renamed_entity = info;
- suffix = strstr (info, "___XE");
- if (renaming_expr != NULL)
- *renaming_expr = suffix + 5;
- if (suffix == NULL || suffix == info)
- return ADA_NOT_RENAMING;
- if (len != NULL)
- *len = suffix - info;
- return kind;
-}
-
/* Compute the value of the given RENAMING_SYM, which is expected to
be a symbol encoding a renaming expression. BLOCK is the block
used to evaluate the renaming. */
{
const char *sym_name;
- sym_name = SYMBOL_LINKAGE_NAME (renaming_sym);
+ sym_name = renaming_sym->linkage_name ();
expression_up expr = parse_exp_1 (&sym_name, 0, block, 0);
return evaluate_expression (expr.get ());
}
write_memory (addr, value_contents (val), len);
}
- return val;
+ return val;
+}
+
+/* Given ARG, a value of type (pointer or reference to a)*
+ structure/union, extract the component named NAME from the ultimate
+ target structure/union and return it as a value with its
+ appropriate type.
+
+ The routine searches for NAME among all members of the structure itself
+ and (recursively) among all members of any wrapper members
+ (e.g., '_parent').
+
+ If NO_ERR, then simply return NULL in case of error, rather than
+ calling error. */
+
+static struct value *
+ada_value_struct_elt (struct value *arg, const char *name, int no_err)
+{
+ struct type *t, *t1;
+ struct value *v;
+ int check_tag;
+
+ v = NULL;
+ t1 = t = ada_check_typedef (value_type (arg));
+ if (t->code () == TYPE_CODE_REF)
+ {
+ t1 = TYPE_TARGET_TYPE (t);
+ if (t1 == NULL)
+ goto BadValue;
+ t1 = ada_check_typedef (t1);
+ if (t1->code () == TYPE_CODE_PTR)
+ {
+ arg = coerce_ref (arg);
+ t = t1;
+ }
+ }
+
+ while (t->code () == TYPE_CODE_PTR)
+ {
+ t1 = TYPE_TARGET_TYPE (t);
+ if (t1 == NULL)
+ goto BadValue;
+ t1 = ada_check_typedef (t1);
+ if (t1->code () == TYPE_CODE_PTR)
+ {
+ arg = value_ind (arg);
+ t = t1;
+ }
+ else
+ break;
+ }
+
+ if (t1->code () != TYPE_CODE_STRUCT && t1->code () != TYPE_CODE_UNION)
+ goto BadValue;
+
+ if (t1 == t)
+ v = ada_search_struct_field (name, arg, 0, t);
+ else
+ {
+ int bit_offset, bit_size, byte_offset;
+ struct type *field_type;
+ CORE_ADDR address;
+
+ if (t->code () == TYPE_CODE_PTR)
+ address = value_address (ada_value_ind (arg));
+ else
+ address = value_address (ada_coerce_ref (arg));
+
+ /* Check to see if this is a tagged type. We also need to handle
+ the case where the type is a reference to a tagged type, but
+ we have to be careful to exclude pointers to tagged types.
+ The latter should be shown as usual (as a pointer), whereas
+ a reference should mostly be transparent to the user. */
+
+ if (ada_is_tagged_type (t1, 0)
+ || (t1->code () == TYPE_CODE_REF
+ && ada_is_tagged_type (TYPE_TARGET_TYPE (t1), 0)))
+ {
+ /* We first try to find the searched field in the current type.
+ If not found then let's look in the fixed type. */
+
+ if (!find_struct_field (name, t1, 0,
+ &field_type, &byte_offset, &bit_offset,
+ &bit_size, NULL))
+ check_tag = 1;
+ else
+ check_tag = 0;
+ }
+ else
+ check_tag = 0;
+
+ /* Convert to fixed type in all cases, so that we have proper
+ offsets to each field in unconstrained record types. */
+ t1 = ada_to_fixed_type (ada_get_base_type (t1), NULL,
+ address, NULL, check_tag);
+
+ if (find_struct_field (name, t1, 0,
+ &field_type, &byte_offset, &bit_offset,
+ &bit_size, NULL))
+ {
+ if (bit_size != 0)
+ {
+ if (t->code () == TYPE_CODE_REF)
+ arg = ada_coerce_ref (arg);
+ else
+ arg = ada_value_ind (arg);
+ v = ada_value_primitive_packed_val (arg, NULL, byte_offset,
+ bit_offset, bit_size,
+ field_type);
+ }
+ else
+ v = value_at_lazy (field_type, address + byte_offset);
+ }
+ }
+
+ if (v != NULL || no_err)
+ return v;
+ else
+ error (_("There is no member named %s."), name);
+
+ BadValue:
+ if (no_err)
+ return NULL;
+ else
+ error (_("Attempt to extract a component of "
+ "a value that is not a record."));
}
/* Return the value ACTUAL, converted to be an appropriate value for a
struct type *actual_type = ada_check_typedef (value_type (actual));
struct type *formal_type = ada_check_typedef (formal_type0);
struct type *formal_target =
- TYPE_CODE (formal_type) == TYPE_CODE_PTR
+ formal_type->code () == TYPE_CODE_PTR
? ada_check_typedef (TYPE_TARGET_TYPE (formal_type)) : formal_type;
struct type *actual_target =
- TYPE_CODE (actual_type) == TYPE_CODE_PTR
+ actual_type->code () == TYPE_CODE_PTR
? ada_check_typedef (TYPE_TARGET_TYPE (actual_type)) : actual_type;
if (ada_is_array_descriptor_type (formal_target)
- && TYPE_CODE (actual_target) == TYPE_CODE_ARRAY)
+ && actual_target->code () == TYPE_CODE_ARRAY)
return make_array_descriptor (formal_type, actual);
- else if (TYPE_CODE (formal_type) == TYPE_CODE_PTR
- || TYPE_CODE (formal_type) == TYPE_CODE_REF)
+ else if (formal_type->code () == TYPE_CODE_PTR
+ || formal_type->code () == TYPE_CODE_REF)
{
struct value *result;
- if (TYPE_CODE (formal_target) == TYPE_CODE_ARRAY
+ if (formal_target->code () == TYPE_CODE_ARRAY
&& ada_is_array_descriptor_type (actual_target))
result = desc_data (actual);
- else if (TYPE_CODE (formal_type) != TYPE_CODE_PTR)
+ else if (formal_type->code () != TYPE_CODE_PTR)
{
if (VALUE_LVAL (actual) != lval_memory)
{
return actual;
return value_cast_pointers (formal_type, result, 0);
}
- else if (TYPE_CODE (actual_type) == TYPE_CODE_PTR)
+ else if (actual_type->code () == TYPE_CODE_PTR)
return ada_value_ind (actual);
else if (ada_is_aligner_type (formal_type))
{
addr = value_address (value);
gdbarch_address_to_pointer (gdbarch, type, buf, addr);
- addr = extract_unsigned_integer (buf, len, gdbarch_byte_order (gdbarch));
+ addr = extract_unsigned_integer (buf, len, type_byte_order (type));
return addr;
}
descriptor = ensure_lval (descriptor);
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ if (type->code () == TYPE_CODE_PTR)
return value_addr (descriptor);
else
return descriptor;
struct ada_symbol_cache *sym_cache
= ada_get_symbol_cache (current_program_space);
int h;
- char *copy;
struct cache_entry *e;
/* Symbols for builtin types don't have a block.
e = XOBNEW (&sym_cache->cache_space, cache_entry);
e->next = sym_cache->root[h];
sym_cache->root[h] = e;
- e->name = copy
- = (char *) obstack_alloc (&sym_cache->cache_space, strlen (name) + 1);
- strcpy (copy, name);
+ e->name = obstack_strdup (&sym_cache->cache_space, name);
e->sym = sym;
e->domain = domain;
e->block = block;
int i;
for (i = 0; i < n; i += 1)
- if (TYPE_CODE (SYMBOL_TYPE (syms[i].symbol)) != TYPE_CODE_FUNC
- && (TYPE_CODE (SYMBOL_TYPE (syms[i].symbol)) != TYPE_CODE_ENUM
+ if (SYMBOL_TYPE (syms[i].symbol)->code () != TYPE_CODE_FUNC
+ && (SYMBOL_TYPE (syms[i].symbol)->code () != TYPE_CODE_ENUM
|| SYMBOL_CLASS (syms[i].symbol) != LOC_CONST))
return 1;
if (type0 == type1)
return 1;
if (type0 == NULL || type1 == NULL
- || TYPE_CODE (type0) != TYPE_CODE (type1))
+ || type0->code () != type1->code ())
return 0;
- if ((TYPE_CODE (type0) == TYPE_CODE_STRUCT
- || TYPE_CODE (type0) == TYPE_CODE_ENUM)
+ if ((type0->code () == TYPE_CODE_STRUCT
+ || type0->code () == TYPE_CODE_ENUM)
&& ada_type_name (type0) != NULL && ada_type_name (type1) != NULL
&& strcmp (ada_type_name (type0), ada_type_name (type1)) == 0)
return 1;
{
struct type *type0 = SYMBOL_TYPE (sym0);
struct type *type1 = SYMBOL_TYPE (sym1);
- const char *name0 = SYMBOL_LINKAGE_NAME (sym0);
- const char *name1 = SYMBOL_LINKAGE_NAME (sym1);
+ const char *name0 = sym0->linkage_name ();
+ const char *name1 = sym1->linkage_name ();
int len0 = strlen (name0);
return
- TYPE_CODE (type0) == TYPE_CODE (type1)
+ type0->code () == type1->code ()
&& (equiv_types (type0, type1)
|| (len0 < strlen (name1) && strncmp (name0, name1, len0) == 0
&& startswith (name1 + len0, "___XV")));
case LOC_CONST:
return SYMBOL_VALUE (sym0) == SYMBOL_VALUE (sym1)
&& equiv_types (SYMBOL_TYPE (sym0), SYMBOL_TYPE (sym1));
+
+ case LOC_STATIC:
+ {
+ const char *name0 = sym0->linkage_name ();
+ const char *name1 = sym1->linkage_name ();
+ return (strcmp (name0, name1) == 0
+ && SYMBOL_VALUE_ADDRESS (sym0) == SYMBOL_VALUE_ADDRESS (sym1));
+ }
+
default:
return 0;
}
{
for (minimal_symbol *msymbol : objfile->msymbols ())
{
- if (match_name (MSYMBOL_LINKAGE_NAME (msymbol), lookup_name, NULL)
+ if (match_name (msymbol->linkage_name (), lookup_name, NULL)
&& MSYMBOL_TYPE (msymbol) != mst_solib_trampoline)
{
result.minsym = msymbol;
This function assumes that TYPE1 and TYPE2 are both TYPE_CODE_ENUM
types and that their number of enumerals is identical (in other
- words, TYPE_NFIELDS (type1) == TYPE_NFIELDS (type2)). */
+ words, type1->num_fields () == type2->num_fields ()). */
static int
ada_identical_enum_types_p (struct type *type1, struct type *type2)
underlying value and name. */
/* All enums in the type should have an identical underlying value. */
- for (i = 0; i < TYPE_NFIELDS (type1); i++)
+ for (i = 0; i < type1->num_fields (); i++)
if (TYPE_FIELD_ENUMVAL (type1, i) != TYPE_FIELD_ENUMVAL (type2, i))
return 0;
/* All enumerals should also have the same name (modulo any numerical
suffix). */
- for (i = 0; i < TYPE_NFIELDS (type1); i++)
+ for (i = 0; i < type1->num_fields (); i++)
{
const char *name_1 = TYPE_FIELD_NAME (type1, i);
const char *name_2 = TYPE_FIELD_NAME (type2, i);
/* Quick check: All symbols should have an enum type. */
for (i = 0; i < syms.size (); i++)
- if (TYPE_CODE (SYMBOL_TYPE (syms[i].symbol)) != TYPE_CODE_ENUM)
+ if (SYMBOL_TYPE (syms[i].symbol)->code () != TYPE_CODE_ENUM)
return 0;
/* Quick check: They should all have the same value. */
/* Quick check: They should all have the same number of enumerals. */
for (i = 1; i < syms.size (); i++)
- if (TYPE_NFIELDS (SYMBOL_TYPE (syms[i].symbol))
- != TYPE_NFIELDS (SYMBOL_TYPE (syms[0].symbol)))
+ if (SYMBOL_TYPE (syms[i].symbol)->num_fields ()
+ != SYMBOL_TYPE (syms[0].symbol)->num_fields ())
return 0;
/* All the sanity checks passed, so we might have a set of
the get rid of the stub. */
if (TYPE_STUB (SYMBOL_TYPE ((*syms)[i].symbol))
- && SYMBOL_LINKAGE_NAME ((*syms)[i].symbol) != NULL)
+ && (*syms)[i].symbol->linkage_name () != NULL)
{
for (j = 0; j < syms->size (); j++)
{
if (j != i
&& !TYPE_STUB (SYMBOL_TYPE ((*syms)[j].symbol))
- && SYMBOL_LINKAGE_NAME ((*syms)[j].symbol) != NULL
- && strcmp (SYMBOL_LINKAGE_NAME ((*syms)[i].symbol),
- SYMBOL_LINKAGE_NAME ((*syms)[j].symbol)) == 0)
+ && (*syms)[j].symbol->linkage_name () != NULL
+ && strcmp ((*syms)[i].symbol->linkage_name (),
+ (*syms)[j].symbol->linkage_name ()) == 0)
remove_p = 1;
}
}
/* Two symbols with the same name, same class and same address
should be identical. */
- else if (SYMBOL_LINKAGE_NAME ((*syms)[i].symbol) != NULL
+ else if ((*syms)[i].symbol->linkage_name () != NULL
&& SYMBOL_CLASS ((*syms)[i].symbol) == LOC_STATIC
&& is_nondebugging_type (SYMBOL_TYPE ((*syms)[i].symbol)))
{
for (j = 0; j < syms->size (); j += 1)
{
if (i != j
- && SYMBOL_LINKAGE_NAME ((*syms)[j].symbol) != NULL
- && strcmp (SYMBOL_LINKAGE_NAME ((*syms)[i].symbol),
- SYMBOL_LINKAGE_NAME ((*syms)[j].symbol)) == 0
+ && (*syms)[j].symbol->linkage_name () != NULL
+ && strcmp ((*syms)[i].symbol->linkage_name (),
+ (*syms)[j].symbol->linkage_name ()) == 0
&& SYMBOL_CLASS ((*syms)[i].symbol)
== SYMBOL_CLASS ((*syms)[j].symbol)
&& SYMBOL_VALUE_ADDRESS ((*syms)[i].symbol)
So, to extract the scope, we search for the "___XR" extension,
and then backtrack until we find the first "__". */
- const char *name = TYPE_NAME (renaming_type);
+ const char *name = renaming_type->name ();
const char *suffix = strstr (name, "___XR");
const char *last;
if (sym == NULL || SYMBOL_CLASS (sym) == LOC_TYPEDEF)
continue;
- name = SYMBOL_LINKAGE_NAME (sym);
+ name = sym->linkage_name ();
suffix = strstr (name, "___XR");
if (suffix != NULL)
is_new_style_renaming = 1;
for (j = 0; j < syms->size (); j += 1)
if (i != j && (*syms)[j].symbol != NULL
- && strncmp (name, SYMBOL_LINKAGE_NAME ((*syms)[j].symbol),
+ && strncmp (name, (*syms)[j].symbol->linkage_name (),
name_len) == 0
&& block == (*syms)[j].block)
(*syms)[j].symbol = NULL;
if (current_function == NULL)
return syms->size ();
- current_function_name = SYMBOL_LINKAGE_NAME (current_function);
+ current_function_name = current_function->linkage_name ();
if (current_function_name == NULL)
return syms->size ();
int found_sym;
};
-/* A callback for add_nonlocal_symbols that adds SYM, found in BLOCK,
- to a list of symbols. DATA0 is a pointer to a struct match_data *
+/* A callback for add_nonlocal_symbols that adds symbol, found in BSYM,
+ to a list of symbols. DATA is a pointer to a struct match_data *
containing the obstack that collects the symbol list, the file that SYM
must come from, a flag indicating whether a non-argument symbol has
been found in the current block, and the last argument symbol
marking the end of a block, the argument symbol is added if no
other has been found. */
-static int
-aux_add_nonlocal_symbols (const struct block *block, struct symbol *sym,
- void *data0)
+static bool
+aux_add_nonlocal_symbols (struct block_symbol *bsym,
+ struct match_data *data)
{
- struct match_data *data = (struct match_data *) data0;
-
+ const struct block *block = bsym->block;
+ struct symbol *sym = bsym->symbol;
+
if (sym == NULL)
{
if (!data->found_sym && data->arg_sym != NULL)
else
{
if (SYMBOL_CLASS (sym) == LOC_UNRESOLVED)
- return 0;
+ return true;
else if (SYMBOL_IS_ARGUMENT (sym))
data->arg_sym = sym;
else
block);
}
}
- return 0;
+ return true;
}
/* Helper for add_nonlocal_symbols. Find symbols in DOMAIN which are
bool is_wild_match = lookup_name.ada ().wild_match_p ();
+ auto callback = [&] (struct block_symbol *bsym)
+ {
+ return aux_add_nonlocal_symbols (bsym, &data);
+ };
+
for (objfile *objfile : current_program_space->objfiles ())
{
data.objfile = objfile;
- if (is_wild_match)
- objfile->sf->qf->map_matching_symbols (objfile, lookup_name.name ().c_str (),
- domain, global,
- aux_add_nonlocal_symbols, &data,
- symbol_name_match_type::WILD,
- NULL);
- else
- objfile->sf->qf->map_matching_symbols (objfile, lookup_name.name ().c_str (),
- domain, global,
- aux_add_nonlocal_symbols, &data,
- symbol_name_match_type::FULL,
- compare_names);
+ objfile->sf->qf->map_matching_symbols (objfile, lookup_name,
+ domain, global, callback,
+ (is_wild_match
+ ? NULL : compare_names));
for (compunit_symtab *cu : objfile->compunits ())
{
if (num_defns_collected (obstackp) == 0 && global && !is_wild_match)
{
const char *name = ada_lookup_name (lookup_name);
- std::string name1 = std::string ("<_ada_") + name + '>';
+ std::string bracket_name = std::string ("<_ada_") + name + '>';
+ lookup_name_info name1 (bracket_name, symbol_name_match_type::FULL);
for (objfile *objfile : current_program_space->objfiles ())
{
data.objfile = objfile;
- objfile->sf->qf->map_matching_symbols (objfile, name1.c_str (),
- domain, global,
- aux_add_nonlocal_symbols,
- &data,
- symbol_name_match_type::FULL,
+ objfile->sf->qf->map_matching_symbols (objfile, name1,
+ domain, global, callback,
compare_names);
}
}
else
{
/* In the !full_search case we're are being called by
- ada_iterate_over_symbols, and we don't want to search
+ iterate_over_symbols, and we don't want to search
superblocks. */
ada_add_block_symbols (obstackp, block, lookup_name, domain, NULL);
}
return ada_lookup_symbol_list_worker (lookup_name, block, domain, results, 1);
}
-/* Implementation of the la_iterate_over_symbols method. */
-
-static void
-ada_iterate_over_symbols
- (const struct block *block, const lookup_name_info &name,
- domain_enum domain,
- gdb::function_view<symbol_found_callback_ftype> callback)
-{
- int ndefs, i;
- std::vector<struct block_symbol> results;
-
- ndefs = ada_lookup_symbol_list_worker (name, block, domain, &results, 0);
-
- for (i = 0; i < ndefs; ++i)
- {
- if (!callback (&results[i]))
- break;
- }
-}
-
/* The result is as for ada_lookup_symbol_list with FULL_SEARCH set
to 1, but choosing the first symbol found if there are multiple
choices.
std::string verbatim = std::string ("<") + name + '>';
gdb_assert (info != NULL);
- *info = ada_lookup_symbol (verbatim.c_str (), block, domain, NULL);
+ *info = ada_lookup_symbol (verbatim.c_str (), block, domain);
}
/* Return a symbol in DOMAIN matching NAME, in BLOCK0 and enclosing
scope and in global scopes, or NULL if none. NAME is folded and
encoded first. Otherwise, the result is as for ada_lookup_symbol_list,
- choosing the first symbol if there are multiple choices.
- If IS_A_FIELD_OF_THIS is not NULL, it is set to zero. */
+ choosing the first symbol if there are multiple choices. */
struct block_symbol
ada_lookup_symbol (const char *name, const struct block *block0,
- domain_enum domain, int *is_a_field_of_this)
+ domain_enum domain)
{
- if (is_a_field_of_this != NULL)
- *is_a_field_of_this = 0;
-
std::vector<struct block_symbol> candidates;
int n_candidates;
{
struct block_symbol sym;
- sym = ada_lookup_symbol (name, block_static_block (block), domain, NULL);
+ sym = ada_lookup_symbol (name, block_static_block (block), domain);
if (sym.symbol != NULL)
return sym;
static int
is_valid_name_for_wild_match (const char *name0)
{
- const char *decoded_name = ada_decode (name0);
+ std::string decoded_name = ada_decode (name0);
int i;
/* If the decoded name starts with an angle bracket, it means that
sym != NULL;
sym = block_iter_match_next (lookup_name, &iter))
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
- SYMBOL_DOMAIN (sym), domain))
+ if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain))
{
if (SYMBOL_CLASS (sym) != LOC_UNRESOLVED)
{
ALL_BLOCK_SYMBOLS (block, iter, sym)
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+ if (symbol_matches_domain (sym->language (),
SYMBOL_DOMAIN (sym), domain))
{
int cmp;
- cmp = (int) '_' - (int) SYMBOL_LINKAGE_NAME (sym)[0];
+ cmp = (int) '_' - (int) sym->linkage_name ()[0];
if (cmp == 0)
{
- cmp = !startswith (SYMBOL_LINKAGE_NAME (sym), "_ada_");
+ cmp = !startswith (sym->linkage_name (), "_ada_");
if (cmp == 0)
- cmp = strncmp (name, SYMBOL_LINKAGE_NAME (sym) + 5,
+ cmp = strncmp (name, sym->linkage_name () + 5,
name_len);
}
if (cmp == 0
- && is_name_suffix (SYMBOL_LINKAGE_NAME (sym) + name_len + 5))
+ && is_name_suffix (sym->linkage_name () + name_len + 5))
{
if (SYMBOL_CLASS (sym) != LOC_UNRESOLVED)
{
if (strncmp (sym_name, text, text_len) == 0)
match = true;
+ std::string decoded_name = ada_decode (sym_name);
if (match && !m_encoded_p)
{
/* One needed check before declaring a positive match is to verify
that iff we are doing a verbatim match, the decoded version
of the symbol name starts with '<'. Otherwise, this symbol name
is not a suitable completion. */
- const char *sym_name_copy = sym_name;
- bool has_angle_bracket;
- sym_name = ada_decode (sym_name);
- has_angle_bracket = (sym_name[0] == '<');
+ bool has_angle_bracket = (decoded_name[0] == '<');
match = (has_angle_bracket == m_verbatim_p);
- sym_name = sym_name_copy;
}
if (match && !m_verbatim_p)
/* Since we are doing wild matching, this means that TEXT
may represent an unqualified symbol name. We therefore must
also compare TEXT against the unqualified name of the symbol. */
- sym_name = ada_unqualified_name (ada_decode (sym_name));
+ sym_name = ada_unqualified_name (decoded_name.c_str ());
if (strncmp (sym_name, text, text_len) == 0)
match = true;
if (completion_skip_symbol (mode, msymbol))
continue;
- language symbol_language = MSYMBOL_LANGUAGE (msymbol);
+ language symbol_language = msymbol->language ();
/* Ada minimal symbols won't have their language set to Ada. If
we let completion_list_add_name compare using the
completion_list_add_name (tracker,
symbol_language,
- MSYMBOL_LINKAGE_NAME (msymbol),
+ msymbol->linkage_name (),
lookup_name, text, word);
}
}
continue;
completion_list_add_name (tracker,
- SYMBOL_LANGUAGE (sym),
- SYMBOL_LINKAGE_NAME (sym),
+ sym->language (),
+ sym->linkage_name (),
lookup_name, text, word);
}
}
continue;
completion_list_add_name (tracker,
- SYMBOL_LANGUAGE (sym),
- SYMBOL_LINKAGE_NAME (sym),
+ sym->language (),
+ sym->linkage_name (),
lookup_name, text, word);
}
}
continue;
completion_list_add_name (tracker,
- SYMBOL_LANGUAGE (sym),
- SYMBOL_LINKAGE_NAME (sym),
+ sym->language (),
+ sym->linkage_name (),
lookup_name, text, word);
}
}
{
const char *name;
- if (TYPE_CODE (type) != TYPE_CODE_PTR)
+ if (type->code () != TYPE_CODE_PTR)
return 0;
- name = TYPE_NAME (TYPE_TARGET_TYPE (type));
+ name = TYPE_TARGET_TYPE (type)->name ();
if (name == NULL)
return 0;
static int
ada_is_interface_tag (struct type *type)
{
- const char *name = TYPE_NAME (type);
+ const char *name = type->name ();
if (name == NULL)
return 0;
int
ada_is_ignored_field (struct type *type, int field_num)
{
- if (field_num < 0 || field_num > TYPE_NFIELDS (type))
+ if (field_num < 0 || field_num > type->num_fields ())
return 1;
/* Check the name of that field. */
/* Anonymous field names should not be printed.
brobecker/2007-02-20: I don't think this can actually happen
- but we don't want to print the value of annonymous fields anyway. */
+ but we don't want to print the value of anonymous fields anyway. */
if (name == NULL)
return 1;
{
type = ada_check_typedef (type);
- if (type == NULL || TYPE_CODE (type) != TYPE_CODE_PTR)
+ if (type == NULL || type->code () != TYPE_CODE_PTR)
return 0;
else
{
/* The type of the tag on VAL. */
-struct type *
+static struct type *
ada_tag_type (struct value *val)
{
return ada_lookup_struct_elt_type (value_type (val), "_tag", 1, 0);
/* The value of the tag on VAL. */
-struct value *
+static struct value *
ada_value_tag (struct value *val)
{
return ada_value_struct_elt (val, "_tag", 0);
/* It is the responsability of the caller to deref pointers. */
- if (TYPE_CODE (obj_type) == TYPE_CODE_PTR
- || TYPE_CODE (obj_type) == TYPE_CODE_REF)
+ if (obj_type->code () == TYPE_CODE_PTR || obj_type->code () == TYPE_CODE_REF)
return obj;
tag = ada_value_tag (obj);
see ada_tag_name for more details. We do not print the error
message for the same reason. */
- TRY
+ try
{
offset_to_top = value_as_long (value_ind (value_ptradd (val, -2)));
}
- CATCH (e, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &e)
{
return obj;
}
- END_CATCH
/* If offset is null, nothing to do. */
We also do not print the error message either (which often is very
low-level (Eg: "Cannot read memory at 0x[...]"), but instead let
the caller print a more meaningful message if necessary. */
- TRY
+ try
{
struct value *tsd = ada_get_tsd_from_tag (tag);
if (tsd != NULL)
name = ada_tag_name_from_tsd (tsd);
}
- CATCH (e, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &e)
{
}
- END_CATCH
return name;
}
type = ada_check_typedef (type);
- if (type == NULL || TYPE_CODE (type) != TYPE_CODE_STRUCT)
+ if (type == NULL || type->code () != TYPE_CODE_STRUCT)
return NULL;
- for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+ for (i = 0; i < type->num_fields (); i += 1)
if (ada_is_parent_field (type, i))
{
struct type *parent_type = TYPE_FIELD_TYPE (type, i);
/* If the _parent field is a pointer, then dereference it. */
- if (TYPE_CODE (parent_type) == TYPE_CODE_PTR)
+ if (parent_type->code () == TYPE_CODE_PTR)
parent_type = TYPE_TARGET_TYPE (parent_type);
/* If there is a parallel XVS type, get the actual base type. */
parent_type = ada_get_base_type (parent_type);
int
ada_is_variant_part (struct type *type, int field_num)
{
+ /* Only Ada types are eligible. */
+ if (!ADA_TYPE_P (type))
+ return 0;
+
struct type *field_type = TYPE_FIELD_TYPE (type, field_num);
- return (TYPE_CODE (field_type) == TYPE_CODE_UNION
- || (is_dynamic_field (type, field_num)
- && (TYPE_CODE (TYPE_TARGET_TYPE (field_type))
+ return (field_type->code () == TYPE_CODE_UNION
+ || (is_dynamic_field (type, field_num)
+ && (TYPE_TARGET_TYPE (field_type)->code ()
== TYPE_CODE_UNION)));
}
valid field number within it, returns 1 iff field FIELD_NUM of TYPE
represents a 'when others' clause; otherwise 0. */
-int
+static int
ada_is_others_clause (struct type *type, int field_num)
{
const char *name = TYPE_FIELD_NAME (type, field_num);
const char *discrim_end;
const char *discrim_start;
- if (TYPE_CODE (type0) == TYPE_CODE_PTR)
+ if (type0->code () == TYPE_CODE_PTR)
type = TYPE_TARGET_TYPE (type0);
else
type = type0;
and FIELD_NUM is a valid field number within it, returns 1 iff VAL is
in the range encoded by field FIELD_NUM of TYPE; otherwise 0. */
-int
+static int
ada_in_variant (LONGEST val, struct type *type, int field_num)
{
const char *name = TYPE_FIELD_NAME (type, field_num);
fields. FIELDNO says which field. Differs from value_primitive_field
only in that it can handle packed values of arbitrary type. */
-static struct value *
+struct value *
ada_value_primitive_field (struct value *arg1, int offset, int fieldno,
struct type *arg_type)
{
arg_type = ada_check_typedef (arg_type);
type = TYPE_FIELD_TYPE (arg_type, fieldno);
- /* Handle packed fields. */
-
- if (TYPE_FIELD_BITSIZE (arg_type, fieldno) != 0)
+ /* Handle packed fields. It might be that the field is not packed
+ relative to its containing structure, but the structure itself is
+ packed; in this case we must take the bit-field path. */
+ if (TYPE_FIELD_BITSIZE (arg_type, fieldno) != 0 || value_bitpos (arg1) != 0)
{
int bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
int bit_size = TYPE_FIELD_BITSIZE (arg_type, fieldno);
if (bit_size_p != NULL)
*bit_size_p = 0;
- for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+ for (i = 0; i < type->num_fields (); i += 1)
{
int bit_pos = TYPE_FIELD_BITPOS (type, i);
int fld_offset = offset + bit_pos / 8;
struct type *field_type
= ada_check_typedef (TYPE_FIELD_TYPE (type, i));
- for (j = 0; j < TYPE_NFIELDS (field_type); j += 1)
+ for (j = 0; j < field_type->num_fields (); j += 1)
{
if (find_struct_field (name, TYPE_FIELD_TYPE (field_type, j),
fld_offset
int parent_offset = -1;
type = ada_check_typedef (type);
- for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+ for (i = 0; i < type->num_fields (); i += 1)
{
const char *t_field_name = TYPE_FIELD_NAME (type, i);
i));
int var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
- for (j = 0; j < TYPE_NFIELDS (field_type); j += 1)
+ for (j = 0; j < field_type->num_fields (); j += 1)
{
struct value *v = ada_search_struct_field /* Force line
break. */
int i;
type = ada_check_typedef (type);
- for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+ for (i = 0; i < type->num_fields (); i += 1)
{
if (TYPE_FIELD_NAME (type, i) == NULL)
continue;
return NULL;
}
-/* Given ARG, a value of type (pointer or reference to a)*
- structure/union, extract the component named NAME from the ultimate
- target structure/union and return it as a value with its
- appropriate type.
-
- The routine searches for NAME among all members of the structure itself
- and (recursively) among all members of any wrapper members
- (e.g., '_parent').
-
- If NO_ERR, then simply return NULL in case of error, rather than
- calling error. */
-
-struct value *
-ada_value_struct_elt (struct value *arg, const char *name, int no_err)
-{
- struct type *t, *t1;
- struct value *v;
- int check_tag;
-
- v = NULL;
- t1 = t = ada_check_typedef (value_type (arg));
- if (TYPE_CODE (t) == TYPE_CODE_REF)
- {
- t1 = TYPE_TARGET_TYPE (t);
- if (t1 == NULL)
- goto BadValue;
- t1 = ada_check_typedef (t1);
- if (TYPE_CODE (t1) == TYPE_CODE_PTR)
- {
- arg = coerce_ref (arg);
- t = t1;
- }
- }
-
- while (TYPE_CODE (t) == TYPE_CODE_PTR)
- {
- t1 = TYPE_TARGET_TYPE (t);
- if (t1 == NULL)
- goto BadValue;
- t1 = ada_check_typedef (t1);
- if (TYPE_CODE (t1) == TYPE_CODE_PTR)
- {
- arg = value_ind (arg);
- t = t1;
- }
- else
- break;
- }
-
- if (TYPE_CODE (t1) != TYPE_CODE_STRUCT && TYPE_CODE (t1) != TYPE_CODE_UNION)
- goto BadValue;
-
- if (t1 == t)
- v = ada_search_struct_field (name, arg, 0, t);
- else
- {
- int bit_offset, bit_size, byte_offset;
- struct type *field_type;
- CORE_ADDR address;
-
- if (TYPE_CODE (t) == TYPE_CODE_PTR)
- address = value_address (ada_value_ind (arg));
- else
- address = value_address (ada_coerce_ref (arg));
-
- /* Check to see if this is a tagged type. We also need to handle
- the case where the type is a reference to a tagged type, but
- we have to be careful to exclude pointers to tagged types.
- The latter should be shown as usual (as a pointer), whereas
- a reference should mostly be transparent to the user. */
-
- if (ada_is_tagged_type (t1, 0)
- || (TYPE_CODE (t1) == TYPE_CODE_REF
- && ada_is_tagged_type (TYPE_TARGET_TYPE (t1), 0)))
- {
- /* We first try to find the searched field in the current type.
- If not found then let's look in the fixed type. */
-
- if (!find_struct_field (name, t1, 0,
- &field_type, &byte_offset, &bit_offset,
- &bit_size, NULL))
- check_tag = 1;
- else
- check_tag = 0;
- }
- else
- check_tag = 0;
-
- /* Convert to fixed type in all cases, so that we have proper
- offsets to each field in unconstrained record types. */
- t1 = ada_to_fixed_type (ada_get_base_type (t1), NULL,
- address, NULL, check_tag);
-
- if (find_struct_field (name, t1, 0,
- &field_type, &byte_offset, &bit_offset,
- &bit_size, NULL))
- {
- if (bit_size != 0)
- {
- if (TYPE_CODE (t) == TYPE_CODE_REF)
- arg = ada_coerce_ref (arg);
- else
- arg = ada_value_ind (arg);
- v = ada_value_primitive_packed_val (arg, NULL, byte_offset,
- bit_offset, bit_size,
- field_type);
- }
- else
- v = value_at_lazy (field_type, address + byte_offset);
- }
- }
-
- if (v != NULL || no_err)
- return v;
- else
- error (_("There is no member named %s."), name);
-
- BadValue:
- if (no_err)
- return NULL;
- else
- error (_("Attempt to extract a component of "
- "a value that is not a record."));
-}
-
/* Return a string representation of type TYPE. */
static std::string
while (1)
{
type = ada_check_typedef (type);
- if (TYPE_CODE (type) != TYPE_CODE_PTR
- && TYPE_CODE (type) != TYPE_CODE_REF)
+ if (type->code () != TYPE_CODE_PTR && type->code () != TYPE_CODE_REF)
break;
type = TYPE_TARGET_TYPE (type);
}
if (type == NULL
- || (TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_UNION))
+ || (type->code () != TYPE_CODE_STRUCT
+ && type->code () != TYPE_CODE_UNION))
{
if (noerr)
return NULL;
type = to_static_fixed_type (type);
- for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+ for (i = 0; i < type->num_fields (); i += 1)
{
const char *t_field_name = TYPE_FIELD_NAME (type, i);
struct type *t;
struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type,
i));
- for (j = TYPE_NFIELDS (field_type) - 1; j >= 0; j -= 1)
+ for (j = field_type->num_fields () - 1; j >= 0; j -= 1)
{
/* FIXME pnh 2008/01/26: We check for a field that is
NOT wrapped in a struct, since the compiler sometimes
/* Assuming that VAR_TYPE is the type of a variant part of a record (a union),
- within a value of type OUTER_TYPE that is stored in GDB at
- OUTER_VALADDR, determine which variant clause (field number in VAR_TYPE,
+ within OUTER, determine which variant clause (field number in VAR_TYPE,
numbering from 0) is applicable. Returns -1 if none are. */
int
-ada_which_variant_applies (struct type *var_type, struct type *outer_type,
- const gdb_byte *outer_valaddr)
+ada_which_variant_applies (struct type *var_type, struct value *outer)
{
int others_clause;
int i;
const char *discrim_name = ada_variant_discrim_name (var_type);
- struct value *outer;
struct value *discrim;
LONGEST discrim_val;
/* Using plain value_from_contents_and_address here causes problems
because we will end up trying to resolve a type that is currently
being constructed. */
- outer = value_from_contents_and_address_unresolved (outer_type,
- outer_valaddr, 0);
discrim = ada_value_struct_elt (outer, discrim_name, 1);
if (discrim == NULL)
return -1;
discrim_val = value_as_long (discrim);
others_clause = -1;
- for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
+ for (i = 0; i < var_type->num_fields (); i += 1)
{
if (ada_is_others_clause (var_type, i))
others_clause = i;
static struct value *
ada_coerce_ref (struct value *val0)
{
- if (TYPE_CODE (value_type (val0)) == TYPE_CODE_REF)
+ if (value_type (val0)->code () == TYPE_CODE_REF)
{
struct value *val = val0;
return val0;
}
-/* Return OFF rounded upward if necessary to a multiple of
- ALIGNMENT (a power of 2). */
-
-static unsigned int
-align_value (unsigned int off, unsigned int alignment)
-{
- return (off + alignment - 1) & ~(alignment - 1);
-}
-
/* Return the bit alignment required for field #F of template type TYPE. */
static unsigned int
symbols whose name is that of NAME_SYM suffixed with "___XR".
Return symbol if found, and NULL otherwise. */
-struct symbol *
-ada_find_renaming_symbol (struct symbol *name_sym, const struct block *block)
+static bool
+ada_is_renaming_symbol (struct symbol *name_sym)
{
- const char *name = SYMBOL_LINKAGE_NAME (name_sym);
- struct symbol *sym;
-
- if (strstr (name, "___XR") != NULL)
- return name_sym;
-
- sym = find_old_style_renaming_symbol (name, block);
-
- if (sym != NULL)
- return sym;
-
- /* Not right yet. FIXME pnh 7/20/2007. */
- sym = ada_find_any_type_symbol (name);
- if (sym != NULL && strstr (SYMBOL_LINKAGE_NAME (sym), "___XR") != NULL)
- return sym;
- else
- return NULL;
-}
-
-static struct symbol *
-find_old_style_renaming_symbol (const char *name, const struct block *block)
-{
- const struct symbol *function_sym = block_linkage_function (block);
- char *rename;
-
- if (function_sym != NULL)
- {
- /* If the symbol is defined inside a function, NAME is not fully
- qualified. This means we need to prepend the function name
- as well as adding the ``___XR'' suffix to build the name of
- the associated renaming symbol. */
- const char *function_name = SYMBOL_LINKAGE_NAME (function_sym);
- /* Function names sometimes contain suffixes used
- for instance to qualify nested subprograms. When building
- the XR type name, we need to make sure that this suffix is
- not included. So do not include any suffix in the function
- name length below. */
- int function_name_len = ada_name_prefix_len (function_name);
- const int rename_len = function_name_len + 2 /* "__" */
- + strlen (name) + 6 /* "___XR\0" */ ;
-
- /* Strip the suffix if necessary. */
- ada_remove_trailing_digits (function_name, &function_name_len);
- ada_remove_po_subprogram_suffix (function_name, &function_name_len);
- ada_remove_Xbn_suffix (function_name, &function_name_len);
-
- /* Library-level functions are a special case, as GNAT adds
- a ``_ada_'' prefix to the function name to avoid namespace
- pollution. However, the renaming symbols themselves do not
- have this prefix, so we need to skip this prefix if present. */
- if (function_name_len > 5 /* "_ada_" */
- && strstr (function_name, "_ada_") == function_name)
- {
- function_name += 5;
- function_name_len -= 5;
- }
-
- rename = (char *) alloca (rename_len * sizeof (char));
- strncpy (rename, function_name, function_name_len);
- xsnprintf (rename + function_name_len, rename_len - function_name_len,
- "__%s___XR", name);
- }
- else
- {
- const int rename_len = strlen (name) + 6;
-
- rename = (char *) alloca (rename_len * sizeof (char));
- xsnprintf (rename, rename_len * sizeof (char), "%s___XR", name);
- }
-
- return ada_find_any_type_symbol (rename);
+ const char *name = name_sym->linkage_name ();
+ return strstr (name, "___XR") != NULL;
}
/* Because of GNAT encoding conventions, several GDB symbols may match a
return 1;
else if (type0 == NULL)
return 0;
- else if (TYPE_CODE (type1) == TYPE_CODE_VOID)
+ else if (type1->code () == TYPE_CODE_VOID)
return 1;
- else if (TYPE_CODE (type0) == TYPE_CODE_VOID)
+ else if (type0->code () == TYPE_CODE_VOID)
return 0;
- else if (TYPE_NAME (type1) == NULL && TYPE_NAME (type0) != NULL)
+ else if (type1->name () == NULL && type0->name () != NULL)
return 1;
else if (ada_is_constrained_packed_array_type (type0))
return 1;
return 1;
else
{
- const char *type0_name = TYPE_NAME (type0);
- const char *type1_name = TYPE_NAME (type1);
+ const char *type0_name = type0->name ();
+ const char *type1_name = type1->name ();
if (type0_name != NULL && strstr (type0_name, "___XR") != NULL
&& (type1_name == NULL || strstr (type1_name, "___XR") == NULL))
{
if (type == NULL)
return NULL;
- return TYPE_NAME (type);
+ return type->name ();
}
/* Search the list of "descriptive" types associated to TYPE for a type
{
type = ada_check_typedef (type);
- if (type == NULL || TYPE_CODE (type) != TYPE_CODE_STRUCT
+ if (type == NULL || type->code () != TYPE_CODE_STRUCT
|| ada_type_name (type) == NULL)
return NULL;
else
const char *name = TYPE_FIELD_NAME (templ_type, field_num);
return name != NULL
- && TYPE_CODE (TYPE_FIELD_TYPE (templ_type, field_num)) == TYPE_CODE_PTR
+ && TYPE_FIELD_TYPE (templ_type, field_num)->code () == TYPE_CODE_PTR
&& strstr (name, "___XVL") != NULL;
}
{
int f;
- if (type == NULL || TYPE_CODE (type) != TYPE_CODE_STRUCT)
+ if (type == NULL || type->code () != TYPE_CODE_STRUCT)
return -1;
- for (f = 0; f < TYPE_NFIELDS (type); f += 1)
+ for (f = 0; f < type->num_fields (); f += 1)
{
if (ada_is_variant_part (type, f))
return f;
{
struct type *type = alloc_type_copy (templ);
- TYPE_CODE (type) = TYPE_CODE_STRUCT;
- TYPE_NFIELDS (type) = 0;
- TYPE_FIELDS (type) = NULL;
- INIT_CPLUS_SPECIFIC (type);
- TYPE_NAME (type) = "<empty>";
+ type->set_code (TYPE_CODE_STRUCT);
+ INIT_NONE_SPECIFIC (type);
+ type->set_name ("<empty>");
TYPE_LENGTH (type) = 0;
return type;
}
to be processed: unless keep_dynamic_fields, this includes only
fields whose position and length are static will be processed. */
if (keep_dynamic_fields)
- nfields = TYPE_NFIELDS (type);
+ nfields = type->num_fields ();
else
{
nfields = 0;
- while (nfields < TYPE_NFIELDS (type)
+ while (nfields < type->num_fields ()
&& !ada_is_variant_part (type, nfields)
&& !is_dynamic_field (type, nfields))
nfields++;
}
rtype = alloc_type_copy (type);
- TYPE_CODE (rtype) = TYPE_CODE_STRUCT;
- INIT_CPLUS_SPECIFIC (rtype);
- TYPE_NFIELDS (rtype) = nfields;
- TYPE_FIELDS (rtype) = (struct field *)
- TYPE_ALLOC (rtype, nfields * sizeof (struct field));
- memset (TYPE_FIELDS (rtype), 0, sizeof (struct field) * nfields);
- TYPE_NAME (rtype) = ada_type_name (type);
+ rtype->set_code (TYPE_CODE_STRUCT);
+ INIT_NONE_SPECIFIC (rtype);
+ rtype->set_num_fields (nfields);
+ rtype->set_fields
+ ((struct field *) TYPE_ZALLOC (rtype, nfields * sizeof (struct field)));
+ rtype->set_name (ada_type_name (type));
TYPE_FIXED_INSTANCE (rtype) = 1;
off = 0;
for (f = 0; f < nfields; f += 1)
{
- off = align_value (off, field_alignment (type, f))
+ off = align_up (off, field_alignment (type, f))
+ TYPE_FIELD_BITPOS (type, f);
- SET_FIELD_BITPOS (TYPE_FIELD (rtype, f), off);
+ SET_FIELD_BITPOS (rtype->field (f), off);
TYPE_FIELD_BITSIZE (rtype, f) = 0;
if (ada_is_variant_part (type, f))
the length of our field. If this is a typedef,
get the length of the target type, not the length
of the typedef. */
- if (TYPE_CODE (field_type) == TYPE_CODE_TYPEDEF)
+ if (field_type->code () == TYPE_CODE_TYPEDEF)
field_type = ada_typedef_target_type (field_type);
fld_bit_len =
bit_len = off + fld_bit_len;
off += fld_bit_len;
TYPE_LENGTH (rtype) =
- align_value (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT;
+ align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT;
}
/* We handle the variant part, if any, at the end because of certain
cond_offset_target (address, off / TARGET_CHAR_BIT), dval);
if (branch_type == NULL)
{
- for (f = variant_field + 1; f < TYPE_NFIELDS (rtype); f += 1)
- TYPE_FIELDS (rtype)[f - 1] = TYPE_FIELDS (rtype)[f];
- TYPE_NFIELDS (rtype) -= 1;
+ for (f = variant_field + 1; f < rtype->num_fields (); f += 1)
+ rtype->field (f - 1) = rtype->field (f);
+ rtype->set_num_fields (rtype->num_fields () - 1);
}
else
{
if (off + fld_bit_len > bit_len)
bit_len = off + fld_bit_len;
TYPE_LENGTH (rtype) =
- align_value (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT;
+ align_up (bit_len, TARGET_CHAR_BIT) / TARGET_CHAR_BIT;
}
}
the current RTYPE length might be good enough for our purposes. */
if (TYPE_LENGTH (type) <= 0)
{
- if (TYPE_NAME (rtype))
+ if (rtype->name ())
warning (_("Invalid type size for `%s' detected: %s."),
- TYPE_NAME (rtype), pulongest (TYPE_LENGTH (type)));
+ rtype->name (), pulongest (TYPE_LENGTH (type)));
else
warning (_("Invalid type size for <unnamed> detected: %s."),
pulongest (TYPE_LENGTH (type)));
}
else
{
- TYPE_LENGTH (rtype) = align_value (TYPE_LENGTH (rtype),
- TYPE_LENGTH (type));
+ TYPE_LENGTH (rtype) = align_up (TYPE_LENGTH (rtype),
+ TYPE_LENGTH (type));
}
value_free_to_mark (mark);
/* Don't clone TYPE0 until we are sure we are going to need a copy. */
type = type0;
- nfields = TYPE_NFIELDS (type0);
+ nfields = type0->num_fields ();
/* Whether or not we cloned TYPE0, cache the result so that we don't do
recompute all over next time. */
if (type == type0)
{
TYPE_TARGET_TYPE (type0) = type = alloc_type_copy (type0);
- TYPE_CODE (type) = TYPE_CODE (type0);
- INIT_CPLUS_SPECIFIC (type);
- TYPE_NFIELDS (type) = nfields;
- TYPE_FIELDS (type) = (struct field *)
- TYPE_ALLOC (type, nfields * sizeof (struct field));
- memcpy (TYPE_FIELDS (type), TYPE_FIELDS (type0),
+ type->set_code (type0->code ());
+ INIT_NONE_SPECIFIC (type);
+ type->set_num_fields (nfields);
+
+ field *fields =
+ ((struct field *)
+ TYPE_ALLOC (type, nfields * sizeof (struct field)));
+ memcpy (fields, type0->fields (),
sizeof (struct field) * nfields);
- TYPE_NAME (type) = ada_type_name (type0);
+ type->set_fields (fields);
+
+ type->set_name (ada_type_name (type0));
TYPE_FIXED_INSTANCE (type) = 1;
TYPE_LENGTH (type) = 0;
}
struct value *dval;
struct type *rtype;
struct type *branch_type;
- int nfields = TYPE_NFIELDS (type);
+ int nfields = type->num_fields ();
int variant_field = variant_field_index (type);
if (variant_field == -1)
dval = dval0;
rtype = alloc_type_copy (type);
- TYPE_CODE (rtype) = TYPE_CODE_STRUCT;
- INIT_CPLUS_SPECIFIC (rtype);
- TYPE_NFIELDS (rtype) = nfields;
- TYPE_FIELDS (rtype) =
+ rtype->set_code (TYPE_CODE_STRUCT);
+ INIT_NONE_SPECIFIC (rtype);
+ rtype->set_num_fields (nfields);
+
+ field *fields =
(struct field *) TYPE_ALLOC (rtype, nfields * sizeof (struct field));
- memcpy (TYPE_FIELDS (rtype), TYPE_FIELDS (type),
- sizeof (struct field) * nfields);
- TYPE_NAME (rtype) = ada_type_name (type);
+ memcpy (fields, type->fields (), sizeof (struct field) * nfields);
+ rtype->set_fields (fields);
+
+ rtype->set_name (ada_type_name (type));
TYPE_FIXED_INSTANCE (rtype) = 1;
TYPE_LENGTH (rtype) = TYPE_LENGTH (type);
int f;
for (f = variant_field + 1; f < nfields; f += 1)
- TYPE_FIELDS (rtype)[f - 1] = TYPE_FIELDS (rtype)[f];
- TYPE_NFIELDS (rtype) -= 1;
+ rtype->field (f - 1) = rtype->field (f);
+ rtype->set_num_fields (rtype->num_fields () - 1);
}
else
{
struct type *templ_type;
struct type *var_type;
- if (TYPE_CODE (var_type0) == TYPE_CODE_PTR)
+ if (var_type0->code () == TYPE_CODE_PTR)
var_type = TYPE_TARGET_TYPE (var_type0);
else
var_type = var_type0;
if (is_unchecked_variant (var_type, value_type (dval)))
return var_type0;
- which =
- ada_which_variant_applies (var_type,
- value_type (dval), value_contents (dval));
+ which = ada_which_variant_applies (var_type, dval);
if (which < 0)
return empty_record (var_type);
int n;
LONGEST lo, hi;
- gdb_assert (TYPE_CODE (range_type) == TYPE_CODE_RANGE);
+ gdb_assert (range_type->code () == TYPE_CODE_RANGE);
- if (TYPE_CODE (get_base_type (range_type))
- != TYPE_CODE (get_base_type (encoding_type)))
+ if (get_base_type (range_type)->code ()
+ != get_base_type (encoding_type)->code ())
{
/* The compiler probably used a simple base type to describe
the range type instead of the range's actual base type,
if (is_dynamic_type (range_type))
return 0;
- if (TYPE_NAME (encoding_type) == NULL)
+ if (encoding_type->name () == NULL)
return 0;
- bounds_str = strstr (TYPE_NAME (encoding_type), "___XDLU_");
+ bounds_str = strstr (encoding_type->name (), "___XDLU_");
if (bounds_str == NULL)
return 0;
struct type *this_layer = check_typedef (array_type);
int i;
- for (i = 0; i < TYPE_NFIELDS (desc_type); i++)
+ for (i = 0; i < desc_type->num_fields (); i++)
{
if (!ada_is_redundant_range_encoding (TYPE_INDEX_TYPE (this_layer),
TYPE_FIELD_TYPE (desc_type, i)))
struct type *elt_type0;
elt_type0 = type0;
- for (i = TYPE_NFIELDS (index_type_desc); i > 0; i -= 1)
+ for (i = index_type_desc->num_fields (); i > 0; i -= 1)
elt_type0 = TYPE_TARGET_TYPE (elt_type0);
/* NOTE: result---the fixed version of elt_type0---should never
ada_to_fixed_type (ada_check_typedef (elt_type0), 0, 0, dval, 1);
elt_type0 = type0;
- for (i = TYPE_NFIELDS (index_type_desc) - 1; i >= 0; i -= 1)
+ for (i = index_type_desc->num_fields () - 1; i >= 0; i -= 1)
{
struct type *range_type =
to_fixed_range_type (TYPE_FIELD_TYPE (index_type_desc, i), dval);
/* We want to preserve the type name. This can be useful when
trying to get the type name of a value that has already been
printed (for instance, if the user did "print VAR; whatis $". */
- TYPE_NAME (result) = TYPE_NAME (type0);
+ result->set_name (type0->name ());
if (constrained_packed_array_p)
{
CORE_ADDR address, struct value *dval, int check_tag)
{
type = ada_check_typedef (type);
- switch (TYPE_CODE (type))
+
+ /* Only un-fixed types need to be handled here. */
+ if (!HAVE_GNAT_AUX_INFO (type))
+ return type;
+
+ switch (type->code ())
{
default:
return type;
LONGEST size;
xsnprintf (xvz_name, strlen (name) + 7, "%s___XVZ", name);
- TRY
+ try
{
xvz_found = get_int_var_value (xvz_name, size);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
/* We found the variable, but somehow failed to read
its value. Rethrow the same error, but with a little
optimized out). */
throw_error (except.error,
_("unable to read value of %s (%s)"),
- xvz_name, except.message);
+ xvz_name, except.what ());
}
- END_CATCH
if (xvz_found && TYPE_LENGTH (fixed_record_type) != size)
{
brobecker/2010-11-19: It seems to me that the only case where it is
useful to preserve the typedef layer is when dealing with fat pointers.
Perhaps, we could add a check for that and preserve the typedef layer
- only in that situation. But this seems unecessary so far, probably
+ only in that situation. But this seems unnecessary so far, probably
because we call check_typedef/ada_check_typedef pretty much everywhere.
*/
- if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF
+ if (type->code () == TYPE_CODE_TYPEDEF
&& (TYPE_MAIN_TYPE (ada_typedef_target_type (type))
== TYPE_MAIN_TYPE (fixed_type)))
return type;
type0 = ada_check_typedef (type0);
- switch (TYPE_CODE (type0))
+ switch (type0->code ())
{
default:
return type0;
{
struct type *type1 = TYPE_FIELD_TYPE (ada_check_typedef (type), 0);
if (ada_type_name (type1) == NULL)
- TYPE_NAME (type1) = ada_type_name (type);
+ type1->set_name (ada_type_name (type));
return static_unwrap_type (type1);
}
return type;
type = check_typedef (type);
- if (type == NULL || TYPE_CODE (type) != TYPE_CODE_ENUM
+ if (type == NULL || type->code () != TYPE_CODE_ENUM
|| !TYPE_STUB (type)
- || TYPE_NAME (type) == NULL)
+ || type->name () == NULL)
return type;
else
{
- const char *name = TYPE_NAME (type);
+ const char *name = type->name ();
struct type *type1 = ada_find_any_type (name);
if (type1 == NULL)
stubs pointing to arrays, as we don't create symbols for array
types, only for the typedef-to-array types). If that's the case,
strip the typedef layer. */
- if (TYPE_CODE (type1) == TYPE_CODE_TYPEDEF)
+ if (type1->code () == TYPE_CODE_TYPEDEF)
type1 = ada_check_typedef (type1);
return type1;
0
};
-const char *
+static const char *
ada_attribute_name (enum exp_opcode n)
{
if (n >= OP_ATR_FIRST && n <= (int) OP_ATR_VAL)
/* Evaluate the TYPE'VAL attribute applied to ARG. */
+static struct value *
+val_atr (struct type *type, LONGEST val)
+{
+ gdb_assert (discrete_type_p (type));
+ if (type->code () == TYPE_CODE_RANGE)
+ type = TYPE_TARGET_TYPE (type);
+ if (type->code () == TYPE_CODE_ENUM)
+ {
+ if (val < 0 || val >= type->num_fields ())
+ error (_("argument to 'VAL out of range"));
+ val = TYPE_FIELD_ENUMVAL (type, val);
+ }
+ return value_from_longest (type, val);
+}
+
static struct value *
value_val_atr (struct type *type, struct value *arg)
{
if (!integer_type_p (value_type (arg)))
error (_("'VAL requires integral argument"));
- if (TYPE_CODE (type) == TYPE_CODE_ENUM)
- {
- long pos = value_as_long (arg);
-
- if (pos < 0 || pos >= TYPE_NFIELDS (type))
- error (_("argument to 'VAL out of range"));
- return value_from_longest (type, TYPE_FIELD_ENUMVAL (type, pos));
- }
- else
- return value_from_longest (type, value_as_long (arg));
+ return val_atr (type, value_as_long (arg));
}
\f
[At the moment, this is true only for Character and Wide_Character;
It is a heuristic test that could stand improvement]. */
-int
+bool
ada_is_character_type (struct type *type)
{
const char *name;
/* If the type code says it's a character, then assume it really is,
and don't check any further. */
- if (TYPE_CODE (type) == TYPE_CODE_CHAR)
- return 1;
+ if (type->code () == TYPE_CODE_CHAR)
+ return true;
/* Otherwise, assume it's a character type iff it is a discrete type
with a known character type name. */
name = ada_type_name (type);
return (name != NULL
- && (TYPE_CODE (type) == TYPE_CODE_INT
- || TYPE_CODE (type) == TYPE_CODE_RANGE)
+ && (type->code () == TYPE_CODE_INT
+ || type->code () == TYPE_CODE_RANGE)
&& (strcmp (name, "character") == 0
|| strcmp (name, "wide_character") == 0
|| strcmp (name, "wide_wide_character") == 0
/* True if TYPE appears to be an Ada string type. */
-int
+bool
ada_is_string_type (struct type *type)
{
type = ada_check_typedef (type);
if (type != NULL
- && TYPE_CODE (type) != TYPE_CODE_PTR
+ && type->code () != TYPE_CODE_PTR
&& (ada_is_simple_array_type (type)
|| ada_is_array_descriptor_type (type))
&& ada_array_arity (type) == 1)
return ada_is_character_type (elttype);
}
else
- return 0;
+ return false;
}
/* The compiler sometimes provides a parallel XVS type for a given
Set to True if the debugger should trust the contents of PAD types.
Otherwise, ignore the PAD type if there is a parallel XVS type. */
-static int trust_pad_over_xvs = 1;
+static bool trust_pad_over_xvs = true;
/* True if TYPE is a struct type introduced by the compiler to force the
alignment of a value. Such types have a single field with a
if (!trust_pad_over_xvs && ada_find_parallel_type (type, "___XVS") != NULL)
return 0;
- return (TYPE_CODE (type) == TYPE_CODE_STRUCT
- && TYPE_NFIELDS (type) == 1
+ return (type->code () == TYPE_CODE_STRUCT
+ && type->num_fields () == 1
&& strcmp (TYPE_FIELD_NAME (type, 0), "F") == 0);
}
struct type *real_type_namer;
struct type *raw_real_type;
- if (raw_type == NULL || TYPE_CODE (raw_type) != TYPE_CODE_STRUCT)
+ if (raw_type == NULL || raw_type->code () != TYPE_CODE_STRUCT)
return raw_type;
if (ada_is_aligner_type (raw_type))
real_type_namer = ada_find_parallel_type (raw_type, "___XVS");
if (real_type_namer == NULL
- || TYPE_CODE (real_type_namer) != TYPE_CODE_STRUCT
- || TYPE_NFIELDS (real_type_namer) != 1)
+ || real_type_namer->code () != TYPE_CODE_STRUCT
+ || real_type_namer->num_fields () != 1)
return raw_type;
- if (TYPE_CODE (TYPE_FIELD_TYPE (real_type_namer, 0)) != TYPE_CODE_REF)
+ if (TYPE_FIELD_TYPE (real_type_namer, 0)->code () != TYPE_CODE_REF)
{
/* This is an older encoding form where the base type needs to be
- looked up by name. We prefer the newer enconding because it is
+ looked up by name. We prefer the newer encoding because it is
more efficient. */
raw_real_type = ada_find_any_type (TYPE_FIELD_NAME (real_type_namer, 0));
if (raw_real_type == NULL)
if (sscanf (name + 2, "%x", &v) != 1)
return name;
}
+ else if (((name[1] >= '0' && name[1] <= '9')
+ || (name[1] >= 'a' && name[1] <= 'z'))
+ && name[2] == '\0')
+ {
+ GROW_VECT (result, result_len, 4);
+ xsnprintf (result, result_len, "'%c'", name[1]);
+ return result;
+ }
else
return name;
struct type *val_type = ada_check_typedef (value_type (v));
if (ada_type_name (val_type) == NULL)
- TYPE_NAME (val_type) = ada_type_name (type);
+ val_type->set_name (ada_type_name (type));
return unwrap_value (v);
}
return arg;
struct value *scale = ada_scaling_factor (type);
- if (ada_is_fixed_point_type (value_type (arg)))
+ if (ada_is_gnat_encoded_fixed_point_type (value_type (arg)))
arg = cast_from_fixed (value_type (scale), arg);
else
arg = value_cast (value_type (scale), arg);
/* Verify that both val and type are arrays of scalars, and
that the size of val's elements is smaller than the size
of type's element. */
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY);
+ gdb_assert (type->code () == TYPE_CODE_ARRAY);
gdb_assert (is_integral_type (TYPE_TARGET_TYPE (type)));
- gdb_assert (TYPE_CODE (value_type (val)) == TYPE_CODE_ARRAY);
+ gdb_assert (value_type (val)->code () == TYPE_CODE_ARRAY);
gdb_assert (is_integral_type (TYPE_TARGET_TYPE (value_type (val))));
gdb_assert (TYPE_LENGTH (TYPE_TARGET_TYPE (type))
> TYPE_LENGTH (TYPE_TARGET_TYPE (value_type (val))));
type2 = ada_check_typedef (type2);
type = ada_check_typedef (type);
- if (TYPE_CODE (type2) == TYPE_CODE_PTR
- && TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ if (type2->code () == TYPE_CODE_PTR
+ && type->code () == TYPE_CODE_ARRAY)
{
val = ada_value_ind (val);
type2 = value_type (val);
}
- if (TYPE_CODE (type2) == TYPE_CODE_ARRAY
- && TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ if (type2->code () == TYPE_CODE_ARRAY
+ && type->code () == TYPE_CODE_ARRAY)
{
if (!ada_same_array_size_p (type, type2))
error (_("cannot assign arrays of different length"));
type1 = get_base_type (ada_check_typedef (value_type (arg1)));
type2 = get_base_type (ada_check_typedef (value_type (arg2)));
- if (TYPE_CODE (type1) != TYPE_CODE_INT
- || TYPE_CODE (type2) != TYPE_CODE_INT)
+ if (type1->code () != TYPE_CODE_INT
+ || type2->code () != TYPE_CODE_INT)
return value_binop (arg1, arg2, op);
switch (op)
val = allocate_value (type1);
store_unsigned_integer (value_contents_raw (val),
TYPE_LENGTH (value_type (val)),
- gdbarch_byte_order (get_type_arch (type1)), v);
+ type_byte_order (type1), v);
return val;
}
arg1_type = ada_check_typedef (value_type (arg1));
arg2_type = ada_check_typedef (value_type (arg2));
- if (TYPE_CODE (arg1_type) != TYPE_CODE_ARRAY
- || TYPE_CODE (arg2_type) != TYPE_CODE_ARRAY)
+ if (arg1_type->code () != TYPE_CODE_ARRAY
+ || arg2_type->code () != TYPE_CODE_ARRAY)
error (_("Attempt to compare array with non-array"));
/* FIXME: The following works only for types whose
representations use all bits (no padding or undefined bits)
struct value *elt;
struct type *lhs_type = check_typedef (value_type (lhs));
- if (TYPE_CODE (lhs_type) == TYPE_CODE_ARRAY)
+ if (lhs_type->code () == TYPE_CODE_ARRAY)
{
struct type *index_type = builtin_type (exp->gdbarch)->builtin_int;
struct value *index_val = value_from_longest (index_type, index);
low_index = TYPE_ARRAY_LOWER_BOUND_VALUE (lhs_type);
high_index = TYPE_ARRAY_UPPER_BOUND_VALUE (lhs_type);
}
- else if (TYPE_CODE (lhs_type) == TYPE_CODE_STRUCT)
+ else if (lhs_type->code () == TYPE_CODE_STRUCT)
{
low_index = 0;
high_index = num_visible_fields (lhs_type) - 1;
name = &exp->elts[choice_pos + 2].string;
break;
case OP_VAR_VALUE:
- name = SYMBOL_NATURAL_NAME (exp->elts[choice_pos + 2].symbol);
+ name = exp->elts[choice_pos + 2].symbol->natural_name ();
break;
default:
error (_("Invalid record component association."));
if (type == ada_check_typedef (value_type (arg2)))
return arg2;
- if (ada_is_fixed_point_type (type))
+ if (ada_is_gnat_encoded_fixed_point_type (type))
return cast_to_fixed (type, arg2);
- if (ada_is_fixed_point_type (value_type (arg2)))
+ if (ada_is_gnat_encoded_fixed_point_type (value_type (arg2)))
return cast_from_fixed (type, arg2);
return value_cast (type, arg2);
information nor the associated type structure in GDB are able to
express such dynamic types. So what the debugger does is to create
"fixed" versions of the type that applies to the specific object.
- We also informally refer to this opperation as "fixing" an object,
+ We also informally refer to this operation as "fixing" an object,
which means creating its associated fixed type.
Example: when printing the value of variable "Yes" above, its fixed
result = evaluate_subexp_standard (expect_type, exp, pos, noside);
/* The result type will have code OP_STRING, bashed there from
OP_ARRAY. Bash it back. */
- if (TYPE_CODE (value_type (result)) == TYPE_CODE_STRING)
- TYPE_CODE (value_type (result)) = TYPE_CODE_ARRAY;
+ if (value_type (result)->code () == TYPE_CODE_STRING)
+ value_type (result)->set_code (TYPE_CODE_ARRAY);
return result;
}
arg2 = evaluate_subexp (type, exp, pos, noside);
if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
return arg1;
- if (ada_is_fixed_point_type (value_type (arg1)))
+ if (VALUE_LVAL (arg1) == lval_internalvar)
+ {
+ /* Nothing. */
+ }
+ else if (ada_is_gnat_encoded_fixed_point_type (value_type (arg1)))
arg2 = cast_to_fixed (value_type (arg1), arg2);
- else if (ada_is_fixed_point_type (value_type (arg2)))
+ else if (ada_is_gnat_encoded_fixed_point_type (value_type (arg2)))
error
(_("Fixed-point values must be assigned to fixed-point variables"));
else
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- if (TYPE_CODE (value_type (arg1)) == TYPE_CODE_PTR)
+ if (value_type (arg1)->code () == TYPE_CODE_PTR)
return (value_from_longest
(value_type (arg1),
value_as_long (arg1) + value_as_long (arg2)));
- if (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR)
+ if (value_type (arg2)->code () == TYPE_CODE_PTR)
return (value_from_longest
(value_type (arg2),
value_as_long (arg1) + value_as_long (arg2)));
- if ((ada_is_fixed_point_type (value_type (arg1))
- || ada_is_fixed_point_type (value_type (arg2)))
+ if ((ada_is_gnat_encoded_fixed_point_type (value_type (arg1))
+ || ada_is_gnat_encoded_fixed_point_type (value_type (arg2)))
&& value_type (arg1) != value_type (arg2))
error (_("Operands of fixed-point addition must have the same type"));
/* Do the addition, and cast the result to the type of the first
argument. We cannot cast the result to a reference type, so if
ARG1 is a reference type, find its underlying type. */
type = value_type (arg1);
- while (TYPE_CODE (type) == TYPE_CODE_REF)
+ while (type->code () == TYPE_CODE_REF)
type = TYPE_TARGET_TYPE (type);
binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
return value_cast (type, value_binop (arg1, arg2, BINOP_ADD));
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- if (TYPE_CODE (value_type (arg1)) == TYPE_CODE_PTR)
+ if (value_type (arg1)->code () == TYPE_CODE_PTR)
return (value_from_longest
(value_type (arg1),
value_as_long (arg1) - value_as_long (arg2)));
- if (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR)
+ if (value_type (arg2)->code () == TYPE_CODE_PTR)
return (value_from_longest
(value_type (arg2),
value_as_long (arg1) - value_as_long (arg2)));
- if ((ada_is_fixed_point_type (value_type (arg1))
- || ada_is_fixed_point_type (value_type (arg2)))
+ if ((ada_is_gnat_encoded_fixed_point_type (value_type (arg1))
+ || ada_is_gnat_encoded_fixed_point_type (value_type (arg2)))
&& value_type (arg1) != value_type (arg2))
error (_("Operands of fixed-point subtraction "
"must have the same type"));
argument. We cannot cast the result to a reference type, so if
ARG1 is a reference type, find its underlying type. */
type = value_type (arg1);
- while (TYPE_CODE (type) == TYPE_CODE_REF)
+ while (type->code () == TYPE_CODE_REF)
type = TYPE_TARGET_TYPE (type);
binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
return value_cast (type, value_binop (arg1, arg2, BINOP_SUB));
else
{
type = builtin_type (exp->gdbarch)->builtin_double;
- if (ada_is_fixed_point_type (value_type (arg1)))
+ if (ada_is_gnat_encoded_fixed_point_type (value_type (arg1)))
arg1 = cast_from_fixed (type, arg1);
- if (ada_is_fixed_point_type (value_type (arg2)))
+ if (ada_is_gnat_encoded_fixed_point_type (value_type (arg2)))
arg2 = cast_from_fixed (type, arg2);
binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
return ada_value_binop (arg1, arg2, op);
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- else if (ada_is_fixed_point_type (value_type (arg1)))
+ else if (ada_is_gnat_encoded_fixed_point_type (value_type (arg1)))
return value_cast (value_type (arg1), value_neg (arg1));
else
{
context other than a function call, in which case, it is
invalid. */
error (_("Unexpected unresolved symbol, %s, during evaluation"),
- SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
+ exp->elts[pc + 2].symbol->print_name ());
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
The latter should be shown as usual (as a pointer), whereas
a reference should mostly be transparent to the user. */
if (ada_is_tagged_type (type, 0)
- || (TYPE_CODE (type) == TYPE_CODE_REF
+ || (type->code () == TYPE_CODE_REF
&& ada_is_tagged_type (TYPE_TARGET_TYPE (type), 0)))
{
/* Tagged types are a little special in the fact that the real
type in the type description. */
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
- if (TYPE_CODE (type) != TYPE_CODE_REF)
+ if (type->code () != TYPE_CODE_REF)
{
struct type *actual_type;
For instance, a case statement in a variant record would be
replaced by the relevant components based on the actual
value of the discriminants. */
- if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
+ if ((type->code () == TYPE_CODE_STRUCT
&& dynamic_template_type (type) != NULL)
- || (TYPE_CODE (type) == TYPE_CODE_UNION
+ || (type->code () == TYPE_CODE_UNION
&& ada_find_parallel_type (type, "___XVU") != NULL))
{
*pos += 4;
if (exp->elts[*pos].opcode == OP_VAR_VALUE
&& SYMBOL_DOMAIN (exp->elts[pc + 5].symbol) == UNDEF_DOMAIN)
error (_("Unexpected unresolved symbol, %s, during evaluation"),
- SYMBOL_PRINT_NAME (exp->elts[pc + 5].symbol));
+ exp->elts[pc + 5].symbol->print_name ());
else
{
for (tem = 0; tem <= nargs; tem += 1)
if (ada_is_constrained_packed_array_type
(desc_base_type (value_type (argvec[0]))))
argvec[0] = ada_coerce_to_simple_array (argvec[0]);
- else if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_ARRAY
+ else if (value_type (argvec[0])->code () == TYPE_CODE_ARRAY
&& TYPE_FIELD_BITSIZE (value_type (argvec[0]), 0) != 0)
/* This is a packed array that has already been fixed, and
therefore already coerced to a simple array. Nothing further
to do. */
;
- else if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_REF)
+ else if (value_type (argvec[0])->code () == TYPE_CODE_REF)
{
/* Make sure we dereference references so that all the code below
feels like it's really handling the referenced value. Wrapping
well. */
argvec[0] = ada_to_fixed_value (coerce_ref (argvec[0]));
}
- else if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_ARRAY
+ else if (value_type (argvec[0])->code () == TYPE_CODE_ARRAY
&& VALUE_LVAL (argvec[0]) == lval_memory)
argvec[0] = value_addr (argvec[0]);
/* Ada allows us to implicitly dereference arrays when subscripting
them. So, if this is an array typedef (encoding use for array
access types encoded as fat pointers), strip it now. */
- if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ if (type->code () == TYPE_CODE_TYPEDEF)
type = ada_typedef_target_type (type);
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ if (type->code () == TYPE_CODE_PTR)
{
- switch (TYPE_CODE (ada_check_typedef (TYPE_TARGET_TYPE (type))))
+ switch (ada_check_typedef (TYPE_TARGET_TYPE (type))->code ())
{
case TYPE_CODE_FUNC:
type = ada_check_typedef (TYPE_TARGET_TYPE (type));
}
}
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_FUNC:
if (noside == EVAL_AVOID_SIDE_EFFECTS)
/* If this is a reference to an aligner type, then remove all
the aligners. */
- if (TYPE_CODE (value_type (array)) == TYPE_CODE_REF
+ if (value_type (array)->code () == TYPE_CODE_REF
&& ada_is_aligner_type (TYPE_TARGET_TYPE (value_type (array))))
TYPE_TARGET_TYPE (value_type (array)) =
ada_aligned_type (TYPE_TARGET_TYPE (value_type (array)));
/* If this is a reference to an array or an array lvalue,
convert to a pointer. */
- if (TYPE_CODE (value_type (array)) == TYPE_CODE_REF
- || (TYPE_CODE (value_type (array)) == TYPE_CODE_ARRAY
+ if (value_type (array)->code () == TYPE_CODE_REF
+ || (value_type (array)->code () == TYPE_CODE_ARRAY
&& VALUE_LVAL (array) == lval_memory))
array = value_addr (array);
/* If we have more than one level of pointer indirection,
dereference the value until we get only one level. */
- while (TYPE_CODE (value_type (array)) == TYPE_CODE_PTR
- && (TYPE_CODE (TYPE_TARGET_TYPE (value_type (array)))
+ while (value_type (array)->code () == TYPE_CODE_PTR
+ && (TYPE_TARGET_TYPE (value_type (array))->code ()
== TYPE_CODE_PTR))
array = value_ind (array);
if (!ada_is_simple_array_type (value_type (array)))
error (_("cannot take slice of non-array"));
- if (TYPE_CODE (ada_check_typedef (value_type (array)))
+ if (ada_check_typedef (value_type (array))->code ()
== TYPE_CODE_PTR)
{
struct type *type0 = ada_check_typedef (value_type (array));
if (noside == EVAL_SKIP)
goto nosideret;
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
default:
lim_warning (_("Membership test incompletely implemented; "
if (noside == EVAL_SKIP)
goto nosideret;
+ else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ if (type_arg == NULL)
+ type_arg = value_type (arg1);
+
+ if (ada_is_constrained_packed_array_type (type_arg))
+ type_arg = decode_constrained_packed_array_type (type_arg);
+
+ if (!discrete_type_p (type_arg))
+ {
+ switch (op)
+ {
+ default: /* Should never happen. */
+ error (_("unexpected attribute encountered"));
+ case OP_ATR_FIRST:
+ case OP_ATR_LAST:
+ type_arg = ada_index_type (type_arg, tem,
+ ada_attribute_name (op));
+ break;
+ case OP_ATR_LENGTH:
+ type_arg = builtin_type (exp->gdbarch)->builtin_int;
+ break;
+ }
+ }
- if (type_arg == NULL)
+ return value_zero (type_arg, not_lval);
+ }
+ else if (type_arg == NULL)
{
arg1 = ada_coerce_ref (arg1);
type = builtin_type (exp->gdbarch)->builtin_int;
}
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return allocate_value (type);
-
switch (op)
{
default: /* Should never happen. */
const char *name = ada_type_name (type_arg);
range_type = NULL;
- if (name != NULL && TYPE_CODE (type_arg) != TYPE_CODE_ENUM)
+ if (name != NULL && type_arg->code () != TYPE_CODE_ENUM)
range_type = to_fixed_range_type (type_arg, NULL);
if (range_type == NULL)
range_type = type_arg;
error (_("the 'length attribute applies only to array types"));
}
}
- else if (TYPE_CODE (type_arg) == TYPE_CODE_FLT)
+ else if (type_arg->code () == TYPE_CODE_FLT)
error (_("unimplemented type attribute"));
else
{
type = builtin_type (exp->gdbarch)->builtin_int;
}
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return allocate_value (type);
-
switch (op)
{
default:
/* If the argument is a reference, then dereference its type, since
the user is really asking for the size of the actual object,
not the size of the pointer. */
- if (TYPE_CODE (type) == TYPE_CODE_REF)
+ if (type->code () == TYPE_CODE_REF)
type = TYPE_TARGET_TYPE (type);
if (noside == EVAL_SKIP)
error (_("Attempt to dereference null array pointer."));
return value_at_lazy (arrType, 0);
}
- else if (TYPE_CODE (type) == TYPE_CODE_PTR
- || TYPE_CODE (type) == TYPE_CODE_REF
+ else if (type->code () == TYPE_CODE_PTR
+ || type->code () == TYPE_CODE_REF
/* In C you can dereference an array to get the 1st elt. */
- || TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ || type->code () == TYPE_CODE_ARRAY)
{
/* As mentioned in the OP_VAR_VALUE case, tagged types can
only be determined by inspecting the object's tag.
This means that we need to evaluate completely the
expression in order to get its type. */
- if ((TYPE_CODE (type) == TYPE_CODE_REF
- || TYPE_CODE (type) == TYPE_CODE_PTR)
+ if ((type->code () == TYPE_CODE_REF
+ || type->code () == TYPE_CODE_PTR)
&& ada_is_tagged_type (TYPE_TARGET_TYPE (type), 0))
{
arg1 = evaluate_subexp (NULL_TYPE, exp, &preeval_pos,
ada_ensure_varsize_limit (type);
return value_zero (type, lval_memory);
}
- else if (TYPE_CODE (type) == TYPE_CODE_INT)
+ else if (type->code () == TYPE_CODE_INT)
{
/* GDB allows dereferencing an int. */
if (expect_type == NULL)
arg1 = ada_coerce_ref (arg1); /* FIXME: What is this for?? */
type = ada_check_typedef (value_type (arg1));
- if (TYPE_CODE (type) == TYPE_CODE_INT)
+ if (type->code () == TYPE_CODE_INT)
/* GDB allows dereferencing an int. If we were given
the expect_type, then use that as the target type.
Otherwise, assume that the target type is an int. */
Otherwise, return NULL. */
static const char *
-fixed_type_info (struct type *type)
+gnat_encoded_fixed_type_info (struct type *type)
{
const char *name = ada_type_name (type);
- enum type_code code = (type == NULL) ? TYPE_CODE_UNDEF : TYPE_CODE (type);
+ enum type_code code = (type == NULL) ? TYPE_CODE_UNDEF : type->code ();
if ((code == TYPE_CODE_INT || code == TYPE_CODE_RANGE) && name != NULL)
{
return tail + 5;
}
else if (code == TYPE_CODE_RANGE && TYPE_TARGET_TYPE (type) != type)
- return fixed_type_info (TYPE_TARGET_TYPE (type));
+ return gnat_encoded_fixed_type_info (TYPE_TARGET_TYPE (type));
else
return NULL;
}
/* Returns non-zero iff TYPE represents an Ada fixed-point type. */
int
-ada_is_fixed_point_type (struct type *type)
+ada_is_gnat_encoded_fixed_point_type (struct type *type)
{
- return fixed_type_info (type) != NULL;
+ return gnat_encoded_fixed_type_info (type) != NULL;
}
/* Return non-zero iff TYPE represents a System.Address type. */
int
ada_is_system_address_type (struct type *type)
{
- return (TYPE_NAME (type)
- && strcmp (TYPE_NAME (type), "system__address") == 0);
+ return (type->name () && strcmp (type->name (), "system__address") == 0);
}
/* Assuming that TYPE is the representation of an Ada fixed-point
delta cannot be determined. */
struct value *
-ada_delta (struct type *type)
+gnat_encoded_fixed_point_delta (struct type *type)
{
- const char *encoding = fixed_type_info (type);
+ const char *encoding = gnat_encoded_fixed_type_info (type);
struct type *scale_type = ada_scaling_type (type);
long long num, den;
value_from_longest (scale_type, den), BINOP_DIV);
}
-/* Assuming that ada_is_fixed_point_type (TYPE), return the scaling
- factor ('SMALL value) associated with the type. */
+/* Assuming that ada_is_gnat_encoded_fixed_point_type (TYPE), return
+ the scaling factor ('SMALL value) associated with the type. */
struct value *
ada_scaling_factor (struct type *type)
{
- const char *encoding = fixed_type_info (type);
+ const char *encoding = gnat_encoded_fixed_type_info (type);
struct type *scale_type = ada_scaling_type (type);
long long num0, den0, num1, den1;
const char *subtype_info;
gdb_assert (raw_type != NULL);
- gdb_assert (TYPE_NAME (raw_type) != NULL);
+ gdb_assert (raw_type->name () != NULL);
- if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
+ if (raw_type->code () == TYPE_CODE_RANGE)
base_type = TYPE_TARGET_TYPE (raw_type);
else
base_type = raw_type;
- name = TYPE_NAME (raw_type);
+ name = raw_type->name ();
subtype_info = strstr (name, "___XD");
if (subtype_info == NULL)
{
to match the size of the base_type, which is not what we want.
Set it back to the original range type's length. */
TYPE_LENGTH (type) = TYPE_LENGTH (raw_type);
- TYPE_NAME (type) = name;
+ type->set_name (name);
return type;
}
}
{
struct type *subranged_type = get_base_type (type);
- return (subranged_type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
- && TYPE_CODE (subranged_type) == TYPE_CODE_INT
+ return (subranged_type != NULL && type->code () == TYPE_CODE_RANGE
+ && subranged_type->code () == TYPE_CODE_INT
&& TYPE_UNSIGNED (subranged_type));
}
static CORE_ADDR ada_unhandled_exception_name_addr_from_raise (void);
/* The following exception support info structure describes how to
- implement exception catchpoints with the latest version of the
- Ada runtime (as of 2007-03-06). */
+ implement exception catchpoints with the latest version of the
+ Ada runtime (as of 2019-08-??). */
+
+static const struct exception_support_info default_exception_support_info =
+{
+ "__gnat_debug_raise_exception", /* catch_exception_sym */
+ "__gnat_unhandled_exception", /* catch_exception_unhandled_sym */
+ "__gnat_debug_raise_assert_failure", /* catch_assert_sym */
+ "__gnat_begin_handler_v1", /* catch_handlers_sym */
+ ada_unhandled_exception_name_addr
+};
+
+/* The following exception support info structure describes how to
+ implement exception catchpoints with an earlier version of the
+ Ada runtime (as of 2007-03-06) using v0 of the EH ABI. */
-static const struct exception_support_info default_exception_support_info =
+static const struct exception_support_info exception_support_info_v0 =
{
"__gnat_debug_raise_exception", /* catch_exception_sym */
"__gnat_unhandled_exception", /* catch_exception_unhandled_sym */
/* Make sure that the symbol we found corresponds to a function. */
if (SYMBOL_CLASS (sym) != LOC_BLOCK)
- error (_("Symbol \"%s\" is not a function (class = %d)"),
- SYMBOL_LINKAGE_NAME (sym), SYMBOL_CLASS (sym));
+ {
+ error (_("Symbol \"%s\" is not a function (class = %d)"),
+ sym->linkage_name (), SYMBOL_CLASS (sym));
+ return 0;
+ }
+
+ sym = standard_lookup (einfo->catch_handlers_sym, NULL, VAR_DOMAIN);
+ if (sym == NULL)
+ {
+ struct bound_minimal_symbol msym
+ = lookup_minimal_symbol (einfo->catch_handlers_sym, NULL, NULL);
+
+ if (msym.minsym && MSYMBOL_TYPE (msym.minsym) != mst_solib_trampoline)
+ error (_("Your Ada runtime appears to be missing some debugging "
+ "information.\nCannot insert Ada exception catchpoint "
+ "in this configuration."));
+
+ return 0;
+ }
+
+ /* Make sure that the symbol we found corresponds to a function. */
+
+ if (SYMBOL_CLASS (sym) != LOC_BLOCK)
+ {
+ error (_("Symbol \"%s\" is not a function (class = %d)"),
+ sym->linkage_name (), SYMBOL_CLASS (sym));
+ return 0;
+ }
return 1;
}
return;
}
+ /* Try the v0 exception suport info. */
+ if (ada_has_this_exception_support (&exception_support_info_v0))
+ {
+ data->exception_info = &exception_support_info_v0;
+ return;
+ }
+
/* Try our fallback exception suport info. */
if (ada_has_this_exception_support (&exception_support_info_fallback))
{
if (access (fullname, R_OK) != 0)
return 1;
- /* Check the unit filename againt the Ada runtime file naming.
+ /* Check the unit filename against the Ada runtime file naming.
We also check the name of the objfile against the name of some
known system libraries that sometimes come with debugging info
too. */
{
gdb::unique_xmalloc_ptr<char> e_msg;
- TRY
+ try
{
e_msg = ada_exception_message_1 ();
}
- CATCH (e, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &e)
{
e_msg.reset (nullptr);
}
- END_CATCH
return e_msg;
}
{
CORE_ADDR result = 0;
- TRY
+ try
{
result = ada_exception_name_addr_1 (ex, b);
}
- CATCH (e, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &e)
{
- warning (_("failed to get exception name: %s"), e.message);
+ warning (_("failed to get exception name: %s"), e.what ());
return 0;
}
- END_CATCH
return result;
}
{
public:
ada_catchpoint_location (breakpoint *owner)
- : bp_location (owner)
+ : bp_location (owner, bp_loc_software_breakpoint)
{}
/* The condition that checks whether the exception that was raised
struct ada_catchpoint : public breakpoint
{
+ explicit ada_catchpoint (enum ada_exception_catchpoint_kind kind)
+ : m_kind (kind)
+ {
+ }
+
/* The name of the specific exception the user specified. */
std::string excep_string;
+
+ /* What kind of catchpoint this is. */
+ enum ada_exception_catchpoint_kind m_kind;
};
/* Parse the exception condition string in the context of each of the
const char *s;
s = cond_string.c_str ();
- TRY
+ try
{
exp = parse_exp_1 (&s, bl->address,
block_for_pc (bl->address),
0);
}
- CATCH (e, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &e)
{
warning (_("failed to reevaluate internal exception condition "
"for catchpoint %d: %s"),
- c->number, e.message);
+ c->number, e.what ());
}
- END_CATCH
}
ada_loc->excep_cond_expr = std::move (exp);
structure for all exception catchpoint kinds. */
static struct bp_location *
-allocate_location_exception (enum ada_exception_catchpoint_kind ex,
- struct breakpoint *self)
+allocate_location_exception (struct breakpoint *self)
{
return new ada_catchpoint_location (self);
}
exception catchpoint kinds. */
static void
-re_set_exception (enum ada_exception_catchpoint_kind ex, struct breakpoint *b)
+re_set_exception (struct breakpoint *b)
{
struct ada_catchpoint *c = (struct ada_catchpoint *) b;
/* Reparse the exception conditional expressions. One for each
location. */
- create_excep_cond_exprs (c, ex);
+ create_excep_cond_exprs (c, c->m_kind);
}
/* Returns true if we should stop for this breakpoint hit. If the
= (const struct ada_catchpoint_location *) bl;
int stop;
+ struct internalvar *var = lookup_internalvar ("_ada_exception");
+ if (c->m_kind == ada_catch_assert)
+ clear_internalvar (var);
+ else
+ {
+ try
+ {
+ const char *expr;
+
+ if (c->m_kind == ada_catch_handlers)
+ expr = ("GNAT_GCC_exception_Access(gcc_exception)"
+ ".all.occurrence.id");
+ else
+ expr = "e";
+
+ struct value *exc = parse_and_eval (expr);
+ set_internalvar (var, exc);
+ }
+ catch (const gdb_exception_error &ex)
+ {
+ clear_internalvar (var);
+ }
+ }
+
/* With no specific exception, should always stop. */
if (c->excep_string.empty ())
return 1;
}
stop = 1;
- TRY
+ try
{
struct value *mark;
stop = value_true (evaluate_expression (ada_loc->excep_cond_expr.get ()));
value_free_to_mark (mark);
}
- CATCH (ex, RETURN_MASK_ALL)
+ catch (const gdb_exception &ex)
{
exception_fprintf (gdb_stderr, ex,
_("Error in testing exception condition:\n"));
}
- END_CATCH
return stop;
}
for all exception catchpoint kinds. */
static void
-check_status_exception (enum ada_exception_catchpoint_kind ex, bpstat bs)
+check_status_exception (bpstat bs)
{
bs->stop = should_stop_exception (bs->bp_location_at);
}
for all exception catchpoint kinds. */
static enum print_stop_action
-print_it_exception (enum ada_exception_catchpoint_kind ex, bpstat bs)
+print_it_exception (bpstat bs)
{
struct ui_out *uiout = current_uiout;
struct breakpoint *b = bs->breakpoint_at;
uiout->text (b->disposition == disp_del
? "\nTemporary catchpoint " : "\nCatchpoint ");
- uiout->field_int ("bkptno", b->number);
+ uiout->field_signed ("bkptno", b->number);
uiout->text (", ");
/* ada_exception_name_addr relies on the selected frame being the
ada_find_printable_frame). */
select_frame (get_current_frame ());
- switch (ex)
+ struct ada_catchpoint *c = (struct ada_catchpoint *) b;
+ switch (c->m_kind)
{
case ada_catch_exception:
case ada_catch_exception_unhandled:
case ada_catch_handlers:
{
- const CORE_ADDR addr = ada_exception_name_addr (ex, b);
+ const CORE_ADDR addr = ada_exception_name_addr (c->m_kind, b);
char exception_name[256];
if (addr != 0)
it clearer to the user which kind of catchpoint just got
hit. We used ui_out_text to make sure that this extra
info does not pollute the exception name in the MI case. */
- if (ex == ada_catch_exception_unhandled)
+ if (c->m_kind == ada_catch_exception_unhandled)
uiout->text ("unhandled ");
uiout->field_string ("exception-name", exception_name);
}
for all exception catchpoint kinds. */
static void
-print_one_exception (enum ada_exception_catchpoint_kind ex,
- struct breakpoint *b, struct bp_location **last_loc)
+print_one_exception (struct breakpoint *b, struct bp_location **last_loc)
{
struct ui_out *uiout = current_uiout;
struct ada_catchpoint *c = (struct ada_catchpoint *) b;
struct value_print_options opts;
get_user_print_options (&opts);
+
if (opts.addressprint)
- {
- annotate_field (4);
- uiout->field_core_addr ("addr", b->loc->gdbarch, b->loc->address);
- }
+ uiout->field_skip ("addr");
annotate_field (5);
- *last_loc = b->loc;
- switch (ex)
+ switch (c->m_kind)
{
case ada_catch_exception:
if (!c->excep_string.empty ())
for all exception catchpoint kinds. */
static void
-print_mention_exception (enum ada_exception_catchpoint_kind ex,
- struct breakpoint *b)
+print_mention_exception (struct breakpoint *b)
{
struct ada_catchpoint *c = (struct ada_catchpoint *) b;
struct ui_out *uiout = current_uiout;
uiout->text (b->disposition == disp_del ? _("Temporary catchpoint ")
: _("Catchpoint "));
- uiout->field_int ("bkptno", b->number);
+ uiout->field_signed ("bkptno", b->number);
uiout->text (": ");
- switch (ex)
+ switch (c->m_kind)
{
case ada_catch_exception:
if (!c->excep_string.empty ())
for all exception catchpoint kinds. */
static void
-print_recreate_exception (enum ada_exception_catchpoint_kind ex,
- struct breakpoint *b, struct ui_file *fp)
+print_recreate_exception (struct breakpoint *b, struct ui_file *fp)
{
struct ada_catchpoint *c = (struct ada_catchpoint *) b;
- switch (ex)
+ switch (c->m_kind)
{
case ada_catch_exception:
fprintf_filtered (fp, "catch exception");
print_recreate_thread (b, fp);
}
-/* Virtual table for "catch exception" breakpoints. */
-
-static struct bp_location *
-allocate_location_catch_exception (struct breakpoint *self)
-{
- return allocate_location_exception (ada_catch_exception, self);
-}
-
-static void
-re_set_catch_exception (struct breakpoint *b)
-{
- re_set_exception (ada_catch_exception, b);
-}
-
-static void
-check_status_catch_exception (bpstat bs)
-{
- check_status_exception (ada_catch_exception, bs);
-}
-
-static enum print_stop_action
-print_it_catch_exception (bpstat bs)
-{
- return print_it_exception (ada_catch_exception, bs);
-}
-
-static void
-print_one_catch_exception (struct breakpoint *b, struct bp_location **last_loc)
-{
- print_one_exception (ada_catch_exception, b, last_loc);
-}
-
-static void
-print_mention_catch_exception (struct breakpoint *b)
-{
- print_mention_exception (ada_catch_exception, b);
-}
-
-static void
-print_recreate_catch_exception (struct breakpoint *b, struct ui_file *fp)
-{
- print_recreate_exception (ada_catch_exception, b, fp);
-}
-
+/* Virtual tables for various breakpoint types. */
static struct breakpoint_ops catch_exception_breakpoint_ops;
-
-/* Virtual table for "catch exception unhandled" breakpoints. */
-
-static struct bp_location *
-allocate_location_catch_exception_unhandled (struct breakpoint *self)
-{
- return allocate_location_exception (ada_catch_exception_unhandled, self);
-}
-
-static void
-re_set_catch_exception_unhandled (struct breakpoint *b)
-{
- re_set_exception (ada_catch_exception_unhandled, b);
-}
-
-static void
-check_status_catch_exception_unhandled (bpstat bs)
-{
- check_status_exception (ada_catch_exception_unhandled, bs);
-}
-
-static enum print_stop_action
-print_it_catch_exception_unhandled (bpstat bs)
-{
- return print_it_exception (ada_catch_exception_unhandled, bs);
-}
-
-static void
-print_one_catch_exception_unhandled (struct breakpoint *b,
- struct bp_location **last_loc)
-{
- print_one_exception (ada_catch_exception_unhandled, b, last_loc);
-}
-
-static void
-print_mention_catch_exception_unhandled (struct breakpoint *b)
-{
- print_mention_exception (ada_catch_exception_unhandled, b);
-}
-
-static void
-print_recreate_catch_exception_unhandled (struct breakpoint *b,
- struct ui_file *fp)
-{
- print_recreate_exception (ada_catch_exception_unhandled, b, fp);
-}
-
static struct breakpoint_ops catch_exception_unhandled_breakpoint_ops;
-
-/* Virtual table for "catch assert" breakpoints. */
-
-static struct bp_location *
-allocate_location_catch_assert (struct breakpoint *self)
-{
- return allocate_location_exception (ada_catch_assert, self);
-}
-
-static void
-re_set_catch_assert (struct breakpoint *b)
-{
- re_set_exception (ada_catch_assert, b);
-}
-
-static void
-check_status_catch_assert (bpstat bs)
-{
- check_status_exception (ada_catch_assert, bs);
-}
-
-static enum print_stop_action
-print_it_catch_assert (bpstat bs)
-{
- return print_it_exception (ada_catch_assert, bs);
-}
-
-static void
-print_one_catch_assert (struct breakpoint *b, struct bp_location **last_loc)
-{
- print_one_exception (ada_catch_assert, b, last_loc);
-}
-
-static void
-print_mention_catch_assert (struct breakpoint *b)
-{
- print_mention_exception (ada_catch_assert, b);
-}
-
-static void
-print_recreate_catch_assert (struct breakpoint *b, struct ui_file *fp)
-{
- print_recreate_exception (ada_catch_assert, b, fp);
-}
-
static struct breakpoint_ops catch_assert_breakpoint_ops;
+static struct breakpoint_ops catch_handlers_breakpoint_ops;
-/* Virtual table for "catch handlers" breakpoints. */
-
-static struct bp_location *
-allocate_location_catch_handlers (struct breakpoint *self)
-{
- return allocate_location_exception (ada_catch_handlers, self);
-}
-
-static void
-re_set_catch_handlers (struct breakpoint *b)
-{
- re_set_exception (ada_catch_handlers, b);
-}
-
-static void
-check_status_catch_handlers (bpstat bs)
-{
- check_status_exception (ada_catch_handlers, bs);
-}
-
-static enum print_stop_action
-print_it_catch_handlers (bpstat bs)
-{
- return print_it_exception (ada_catch_handlers, bs);
-}
-
-static void
-print_one_catch_handlers (struct breakpoint *b,
- struct bp_location **last_loc)
-{
- print_one_exception (ada_catch_handlers, b, last_loc);
-}
-
-static void
-print_mention_catch_handlers (struct breakpoint *b)
-{
- print_mention_exception (ada_catch_handlers, b);
-}
+/* See ada-lang.h. */
-static void
-print_recreate_catch_handlers (struct breakpoint *b,
- struct ui_file *fp)
+bool
+is_ada_exception_catchpoint (breakpoint *bp)
{
- print_recreate_exception (ada_catch_handlers, b, fp);
+ return (bp->ops == &catch_exception_breakpoint_ops
+ || bp->ops == &catch_exception_unhandled_breakpoint_ops
+ || bp->ops == &catch_assert_breakpoint_ops
+ || bp->ops == &catch_handlers_breakpoint_ops);
}
-static struct breakpoint_ops catch_handlers_breakpoint_ops;
-
/* Split the arguments specified in a "catch exception" command.
Set EX to the appropriate catchpoint type.
Set EXCEP_STRING to the name of the specific exception if
exception constraint_error" is rewritten into "catch exception
standard.constraint_error".
- If an exception named contraint_error is defined in another package of
+ If an exception named constraint_error is defined in another package of
the inferior program, then the only way to specify this exception as a
breakpoint condition is to use its fully-qualified named:
e.g. my_package.constraint_error. */
const struct breakpoint_ops *ops = NULL;
struct symtab_and_line sal = ada_exception_sal (ex_kind, &addr_string, &ops);
- std::unique_ptr<ada_catchpoint> c (new ada_catchpoint ());
+ std::unique_ptr<ada_catchpoint> c (new ada_catchpoint (ex_kind));
init_ada_exception_breakpoint (c.get (), gdbarch, sal, addr_string.c_str (),
ops, tempflag, disabled, from_tty);
c->excep_string = excep_string;
from_tty);
}
+/* Completion function for the Ada "catch" commands. */
+
+static void
+catch_ada_completer (struct cmd_list_element *cmd, completion_tracker &tracker,
+ const char *text, const char *word)
+{
+ std::vector<ada_exc_info> exceptions = ada_exceptions_list (NULL);
+
+ for (const ada_exc_info &info : exceptions)
+ {
+ if (startswith (info.name, word))
+ tracker.add_completion (make_unique_xstrdup (info.name));
+ }
+}
+
/* Split the arguments specified in a "catch assert" command.
ARGS contains the command's arguments (or the empty string if
static int
ada_is_exception_sym (struct symbol *sym)
{
- const char *type_name = TYPE_NAME (SYMBOL_TYPE (sym));
+ const char *type_name = SYMBOL_TYPE (sym)->name ();
return (SYMBOL_CLASS (sym) != LOC_TYPEDEF
&& SYMBOL_CLASS (sym) != LOC_BLOCK
return 0;
for (i = 0; i < ARRAY_SIZE (standard_exc); i++)
- if (strcmp (SYMBOL_LINKAGE_NAME (sym), standard_exc[i]) == 0)
+ if (strcmp (sym->linkage_name (), standard_exc[i]) == 0)
return 0; /* A standard exception. */
/* Numeric_Error is also a standard exception, so exclude it.
See the STANDARD_EXC description for more details as to why
this exception is not listed in that array. */
- if (strcmp (SYMBOL_LINKAGE_NAME (sym), "numeric_error") == 0)
+ if (strcmp (sym->linkage_name (), "numeric_error") == 0)
return 0;
return 1;
default:
if (ada_is_exception_sym (sym))
{
- struct ada_exc_info info = {SYMBOL_PRINT_NAME (sym),
+ struct ada_exc_info info = {sym->print_name (),
SYMBOL_VALUE_ADDRESS (sym)};
exceptions->push_back (info);
name_matches_regex (const char *name, compiled_regex *preg)
{
return (preg == NULL
- || preg->exec (ada_decode (name), 0, NULL, 0) == 0);
+ || preg->exec (ada_decode (name).c_str (), 0, NULL, 0) == 0);
}
/* Add all exceptions defined globally whose name name match
lookup_name_info::match_any (),
[&] (const char *search_name)
{
- const char *decoded = ada_decode (search_name);
- return name_matches_regex (decoded, preg);
+ std::string decoded = ada_decode (search_name);
+ return name_matches_regex (decoded.c_str (), preg);
},
NULL,
VARIABLES_DOMAIN);
ALL_BLOCK_SYMBOLS (b, iter, sym)
if (ada_is_non_standard_exception_sym (sym)
- && name_matches_regex (SYMBOL_NATURAL_NAME (sym), preg))
+ && name_matches_regex (sym->natural_name (), preg))
{
struct ada_exc_info info
- = {SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE_ADDRESS (sym)};
+ = {sym->print_name (), SYMBOL_VALUE_ADDRESS (sym)};
exceptions->push_back (info);
}
return;
case OP_VAR_VALUE:
- fputs_filtered (SYMBOL_NATURAL_NAME (exp->elts[pc + 2].symbol), stream);
+ fputs_filtered (exp->elts[pc + 2].symbol->natural_name (), stream);
return;
case BINOP_IN_BOUNDS:
case OP_ATR_VAL:
if (exp->elts[*pos].opcode == OP_TYPE)
{
- if (TYPE_CODE (exp->elts[*pos + 1].type) != TYPE_CODE_VOID)
+ if (exp->elts[*pos + 1].type->code () != TYPE_CODE_VOID)
LA_PRINT_TYPE (exp->elts[*pos + 1].type, "", stream, 0, 0,
&type_print_raw_options);
*pos += 3;
nr_ada_primitive_types
};
-static void
-ada_language_arch_info (struct gdbarch *gdbarch,
- struct language_arch_info *lai)
-{
- const struct builtin_type *builtin = builtin_type (gdbarch);
-
- lai->primitive_type_vector
- = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_ada_primitive_types + 1,
- struct type *);
-
- lai->primitive_type_vector [ada_primitive_type_int]
- = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
- 0, "integer");
- lai->primitive_type_vector [ada_primitive_type_long]
- = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
- 0, "long_integer");
- lai->primitive_type_vector [ada_primitive_type_short]
- = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
- 0, "short_integer");
- lai->string_char_type
- = lai->primitive_type_vector [ada_primitive_type_char]
- = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "character");
- lai->primitive_type_vector [ada_primitive_type_float]
- = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
- "float", gdbarch_float_format (gdbarch));
- lai->primitive_type_vector [ada_primitive_type_double]
- = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
- "long_float", gdbarch_double_format (gdbarch));
- lai->primitive_type_vector [ada_primitive_type_long_long]
- = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
- 0, "long_long_integer");
- lai->primitive_type_vector [ada_primitive_type_long_double]
- = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
- "long_long_float", gdbarch_long_double_format (gdbarch));
- lai->primitive_type_vector [ada_primitive_type_natural]
- = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
- 0, "natural");
- lai->primitive_type_vector [ada_primitive_type_positive]
- = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
- 0, "positive");
- lai->primitive_type_vector [ada_primitive_type_void]
- = builtin->builtin_void;
-
- lai->primitive_type_vector [ada_primitive_type_system_address]
- = lookup_pointer_type (arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT,
- "void"));
- TYPE_NAME (lai->primitive_type_vector [ada_primitive_type_system_address])
- = "system__address";
-
- /* Create the equivalent of the System.Storage_Elements.Storage_Offset
- type. This is a signed integral type whose size is the same as
- the size of addresses. */
- {
- unsigned int addr_length = TYPE_LENGTH
- (lai->primitive_type_vector [ada_primitive_type_system_address]);
-
- lai->primitive_type_vector [ada_primitive_type_storage_offset]
- = arch_integer_type (gdbarch, addr_length * HOST_CHAR_BIT, 0,
- "storage_offset");
- }
-
- lai->bool_type_symbol = NULL;
- lai->bool_type_default = builtin->builtin_bool;
-}
\f
/* Language vector */
ada_lookup_name_info::ada_lookup_name_info (const lookup_name_info &lookup_name)
{
- const std::string &user_name = lookup_name.name ();
+ gdb::string_view user_name = lookup_name.name ();
if (user_name[0] == '<')
{
if (user_name.back () == '>')
- m_encoded_name = user_name.substr (1, user_name.size () - 2);
+ m_encoded_name
+ = user_name.substr (1, user_name.size () - 2).to_string ();
else
- m_encoded_name = user_name.substr (1, user_name.size () - 1);
+ m_encoded_name
+ = user_name.substr (1, user_name.size () - 1).to_string ();
m_encoded_p = true;
m_verbatim_p = true;
m_wild_match_p = false;
{
m_verbatim_p = false;
- m_encoded_p = user_name.find ("__") != std::string::npos;
+ m_encoded_p = user_name.find ("__") != gdb::string_view::npos;
if (!m_encoded_p)
{
- const char *folded = ada_fold_name (user_name.c_str ());
+ const char *folded = ada_fold_name (user_name);
const char *encoded = ada_encode_1 (folded, false);
if (encoded != NULL)
m_encoded_name = encoded;
else
- m_encoded_name = user_name;
+ m_encoded_name = user_name.to_string ();
}
else
- m_encoded_name = user_name;
+ m_encoded_name = user_name.to_string ();
/* Handle the 'package Standard' special case. See description
of m_standard_p. */
const lookup_name_info &lookup_name,
completion_match_result *comp_match_res)
{
- const std::string &name = lookup_name.name ();
+ gdb::string_view name_view = lookup_name.name ();
- int cmp = (lookup_name.completion_mode ()
- ? strncmp (symbol_search_name, name.c_str (), name.size ())
- : strcmp (symbol_search_name, name.c_str ()));
- if (cmp == 0)
+ if (lookup_name.completion_mode ()
+ ? (strncmp (symbol_search_name, name_view.data (),
+ name_view.size ()) == 0)
+ : symbol_search_name == name_view)
{
if (comp_match_res != NULL)
comp_match_res->set_match (symbol_search_name);
}
}
-/* Implement the "la_read_var_value" language_defn method for Ada. */
-
-static struct value *
-ada_read_var_value (struct symbol *var, const struct block *var_block,
- struct frame_info *frame)
-{
- const struct block *frame_block = NULL;
- struct symbol *renaming_sym = NULL;
-
- /* The only case where default_read_var_value is not sufficient
- is when VAR is a renaming... */
- if (frame)
- frame_block = get_frame_block (frame, NULL);
- if (frame_block)
- renaming_sym = ada_find_renaming_symbol (var, frame_block);
- if (renaming_sym != NULL)
- return ada_read_renaming_var_value (renaming_sym, frame_block);
-
- /* This is a typical case where we expect the default_read_var_value
- function to work. */
- return default_read_var_value (var, var_block, frame);
-}
-
static const char *ada_extensions[] =
{
".adb", ".ads", ".a", ".ada", ".dg", NULL
};
-extern const struct language_defn ada_language_defn = {
+/* Constant data that describes the Ada language. */
+
+extern const struct language_data ada_language_data =
+{
"ada", /* Language name */
"Ada",
language_ada,
ada_printchar, /* Print a character constant */
ada_printstr, /* Function to print string constant */
emit_char, /* Function to print single char (not used) */
- ada_print_type, /* Print a type using appropriate syntax */
ada_print_typedef, /* Print a typedef using appropriate syntax */
- ada_val_print, /* Print a value using appropriate syntax */
+ ada_value_print_inner, /* la_value_print_inner */
ada_value_print, /* Print a top-level value */
- ada_read_var_value, /* la_read_var_value */
- NULL, /* Language specific skip_trampoline */
NULL, /* name_of_this */
true, /* la_store_sym_names_in_linkage_form_p */
ada_lookup_symbol_nonlocal, /* Looking up non-local symbols. */
- basic_lookup_transparent_type, /* lookup_transparent_type */
- ada_la_decode, /* Language specific symbol demangler */
- ada_sniff_from_mangled_name,
NULL, /* Language specific
class_name_from_physname */
ada_op_print_tab, /* expression operators for printing */
1, /* String lower bound */
ada_get_gdb_completer_word_break_characters,
ada_collect_symbol_completion_matches,
- ada_language_arch_info,
- ada_print_array_index,
- default_pass_by_reference,
- c_get_string,
ada_watch_location_expression,
ada_get_symbol_name_matcher, /* la_get_symbol_name_matcher */
- ada_iterate_over_symbols,
- default_search_name_hash,
&ada_varobj_ops,
NULL,
- NULL,
- LANG_MAGIC
+ ada_is_string_type,
+ "(...)" /* la_struct_too_deep_ellipsis */
};
-/* Command-list for the "set/show ada" prefix command. */
-static struct cmd_list_element *set_ada_list;
-static struct cmd_list_element *show_ada_list;
-
-/* Implement the "set ada" prefix command. */
+/* Class representing the Ada language. */
-static void
-set_ada_command (const char *arg, int from_tty)
+class ada_language : public language_defn
{
- printf_unfiltered (_(\
-"\"set ada\" must be followed by the name of a setting.\n"));
- help_list (set_ada_list, "set ada ", all_commands, gdb_stdout);
-}
+public:
+ ada_language ()
+ : language_defn (language_ada, ada_language_data)
+ { /* Nothing. */ }
-/* Implement the "show ada" prefix command. */
+ /* Print an array element index using the Ada syntax. */
-static void
-show_ada_command (const char *args, int from_tty)
-{
- cmd_show_list (show_ada_list, from_tty, "");
-}
+ void print_array_index (struct type *index_type,
+ LONGEST index,
+ struct ui_file *stream,
+ const value_print_options *options) const override
+ {
+ struct value *index_value = val_atr (index_type, index);
+
+ LA_VALUE_PRINT (index_value, stream, options);
+ fprintf_filtered (stream, " => ");
+ }
+
+ /* Implement the "read_var_value" language_defn method for Ada. */
+
+ struct value *read_var_value (struct symbol *var,
+ const struct block *var_block,
+ struct frame_info *frame) const override
+ {
+ /* The only case where default_read_var_value is not sufficient
+ is when VAR is a renaming... */
+ if (frame != nullptr)
+ {
+ const struct block *frame_block = get_frame_block (frame, NULL);
+ if (frame_block != nullptr && ada_is_renaming_symbol (var))
+ return ada_read_renaming_var_value (var, frame_block);
+ }
+
+ /* This is a typical case where we expect the default_read_var_value
+ function to work. */
+ return language_defn::read_var_value (var, var_block, frame);
+ }
+
+ /* See language.h. */
+ void language_arch_info (struct gdbarch *gdbarch,
+ struct language_arch_info *lai) const override
+ {
+ const struct builtin_type *builtin = builtin_type (gdbarch);
+
+ lai->primitive_type_vector
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_ada_primitive_types + 1,
+ struct type *);
+
+ lai->primitive_type_vector [ada_primitive_type_int]
+ = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
+ 0, "integer");
+ lai->primitive_type_vector [ada_primitive_type_long]
+ = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
+ 0, "long_integer");
+ lai->primitive_type_vector [ada_primitive_type_short]
+ = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
+ 0, "short_integer");
+ lai->string_char_type
+ = lai->primitive_type_vector [ada_primitive_type_char]
+ = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "character");
+ lai->primitive_type_vector [ada_primitive_type_float]
+ = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
+ "float", gdbarch_float_format (gdbarch));
+ lai->primitive_type_vector [ada_primitive_type_double]
+ = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
+ "long_float", gdbarch_double_format (gdbarch));
+ lai->primitive_type_vector [ada_primitive_type_long_long]
+ = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
+ 0, "long_long_integer");
+ lai->primitive_type_vector [ada_primitive_type_long_double]
+ = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
+ "long_long_float", gdbarch_long_double_format (gdbarch));
+ lai->primitive_type_vector [ada_primitive_type_natural]
+ = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
+ 0, "natural");
+ lai->primitive_type_vector [ada_primitive_type_positive]
+ = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
+ 0, "positive");
+ lai->primitive_type_vector [ada_primitive_type_void]
+ = builtin->builtin_void;
+
+ lai->primitive_type_vector [ada_primitive_type_system_address]
+ = lookup_pointer_type (arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT,
+ "void"));
+ lai->primitive_type_vector [ada_primitive_type_system_address]
+ ->set_name ("system__address");
+
+ /* Create the equivalent of the System.Storage_Elements.Storage_Offset
+ type. This is a signed integral type whose size is the same as
+ the size of addresses. */
+ {
+ unsigned int addr_length = TYPE_LENGTH
+ (lai->primitive_type_vector [ada_primitive_type_system_address]);
+
+ lai->primitive_type_vector [ada_primitive_type_storage_offset]
+ = arch_integer_type (gdbarch, addr_length * HOST_CHAR_BIT, 0,
+ "storage_offset");
+ }
+
+ lai->bool_type_symbol = NULL;
+ lai->bool_type_default = builtin->builtin_bool;
+ }
+
+ /* See language.h. */
+
+ bool iterate_over_symbols
+ (const struct block *block, const lookup_name_info &name,
+ domain_enum domain,
+ gdb::function_view<symbol_found_callback_ftype> callback) const override
+ {
+ std::vector<struct block_symbol> results;
+
+ ada_lookup_symbol_list_worker (name, block, domain, &results, 0);
+ for (block_symbol &sym : results)
+ {
+ if (!callback (&sym))
+ return false;
+ }
+
+ return true;
+ }
+
+ /* See language.h. */
+ bool sniff_from_mangled_name (const char *mangled,
+ char **out) const override
+ {
+ std::string demangled = ada_decode (mangled);
+
+ *out = NULL;
+
+ if (demangled != mangled && demangled[0] != '<')
+ {
+ /* Set the gsymbol language to Ada, but still return 0.
+ Two reasons for that:
+
+ 1. For Ada, we prefer computing the symbol's decoded name
+ on the fly rather than pre-compute it, in order to save
+ memory (Ada projects are typically very large).
+
+ 2. There are some areas in the definition of the GNAT
+ encoding where, with a bit of bad luck, we might be able
+ to decode a non-Ada symbol, generating an incorrect
+ demangled name (Eg: names ending with "TB" for instance
+ are identified as task bodies and so stripped from
+ the decoded name returned).
+
+ Returning true, here, but not setting *DEMANGLED, helps us get
+ a little bit of the best of both worlds. Because we're last,
+ we should not affect any of the other languages that were
+ able to demangle the symbol before us; we get to correctly
+ tag Ada symbols as such; and even if we incorrectly tagged a
+ non-Ada symbol, which should be rare, any routing through the
+ Ada language should be transparent (Ada tries to behave much
+ like C/C++ with non-Ada symbols). */
+ return true;
+ }
+
+ return false;
+ }
+
+ /* See language.h. */
+
+ char *demangle (const char *mangled, int options) const override
+ {
+ return ada_la_decode (mangled, options);
+ }
+
+ /* See language.h. */
+
+ void print_type (struct type *type, const char *varstring,
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags) const override
+ {
+ ada_print_type (type, varstring, stream, show, level, flags);
+ }
+};
+
+/* Single instance of the Ada language class. */
+
+static ada_language ada_language_defn;
+
+/* Command-list for the "set/show ada" prefix command. */
+static struct cmd_list_element *set_ada_list;
+static struct cmd_list_element *show_ada_list;
static void
initialize_ada_catchpoint_ops (void)
ops = &catch_exception_breakpoint_ops;
*ops = bkpt_breakpoint_ops;
- ops->allocate_location = allocate_location_catch_exception;
- ops->re_set = re_set_catch_exception;
- ops->check_status = check_status_catch_exception;
- ops->print_it = print_it_catch_exception;
- ops->print_one = print_one_catch_exception;
- ops->print_mention = print_mention_catch_exception;
- ops->print_recreate = print_recreate_catch_exception;
+ ops->allocate_location = allocate_location_exception;
+ ops->re_set = re_set_exception;
+ ops->check_status = check_status_exception;
+ ops->print_it = print_it_exception;
+ ops->print_one = print_one_exception;
+ ops->print_mention = print_mention_exception;
+ ops->print_recreate = print_recreate_exception;
ops = &catch_exception_unhandled_breakpoint_ops;
*ops = bkpt_breakpoint_ops;
- ops->allocate_location = allocate_location_catch_exception_unhandled;
- ops->re_set = re_set_catch_exception_unhandled;
- ops->check_status = check_status_catch_exception_unhandled;
- ops->print_it = print_it_catch_exception_unhandled;
- ops->print_one = print_one_catch_exception_unhandled;
- ops->print_mention = print_mention_catch_exception_unhandled;
- ops->print_recreate = print_recreate_catch_exception_unhandled;
+ ops->allocate_location = allocate_location_exception;
+ ops->re_set = re_set_exception;
+ ops->check_status = check_status_exception;
+ ops->print_it = print_it_exception;
+ ops->print_one = print_one_exception;
+ ops->print_mention = print_mention_exception;
+ ops->print_recreate = print_recreate_exception;
ops = &catch_assert_breakpoint_ops;
*ops = bkpt_breakpoint_ops;
- ops->allocate_location = allocate_location_catch_assert;
- ops->re_set = re_set_catch_assert;
- ops->check_status = check_status_catch_assert;
- ops->print_it = print_it_catch_assert;
- ops->print_one = print_one_catch_assert;
- ops->print_mention = print_mention_catch_assert;
- ops->print_recreate = print_recreate_catch_assert;
+ ops->allocate_location = allocate_location_exception;
+ ops->re_set = re_set_exception;
+ ops->check_status = check_status_exception;
+ ops->print_it = print_it_exception;
+ ops->print_one = print_one_exception;
+ ops->print_mention = print_mention_exception;
+ ops->print_recreate = print_recreate_exception;
ops = &catch_handlers_breakpoint_ops;
*ops = bkpt_breakpoint_ops;
- ops->allocate_location = allocate_location_catch_handlers;
- ops->re_set = re_set_catch_handlers;
- ops->check_status = check_status_catch_handlers;
- ops->print_it = print_it_catch_handlers;
- ops->print_one = print_one_catch_handlers;
- ops->print_mention = print_mention_catch_handlers;
- ops->print_recreate = print_recreate_catch_handlers;
+ ops->allocate_location = allocate_location_exception;
+ ops->re_set = re_set_exception;
+ ops->check_status = check_status_exception;
+ ops->print_it = print_it_exception;
+ ops->print_one = print_one_exception;
+ ops->print_mention = print_mention_exception;
+ ops->print_recreate = print_recreate_exception;
}
/* This module's 'new_objfile' observer. */
ada_clear_symbol_cache ();
}
+void _initialize_ada_language ();
void
-_initialize_ada_language (void)
+_initialize_ada_language ()
{
initialize_ada_catchpoint_ops ();
- add_prefix_cmd ("ada", no_class, set_ada_command,
- _("Prefix command for changing Ada-specific settings"),
- &set_ada_list, "set ada ", 0, &setlist);
+ add_basic_prefix_cmd ("ada", no_class,
+ _("Prefix command for changing Ada-specific settings."),
+ &set_ada_list, "set ada ", 0, &setlist);
- add_prefix_cmd ("ada", no_class, show_ada_command,
- _("Generic command for showing Ada-specific settings."),
- &show_ada_list, "show ada ", 0, &showlist);
+ add_show_prefix_cmd ("ada", no_class,
+ _("Generic command for showing Ada-specific settings."),
+ &show_ada_list, "show ada ", 0, &showlist);
add_setshow_boolean_cmd ("trust-PAD-over-XVS", class_obscure,
&trust_pad_over_xvs, _("\
-Enable or disable an optimization trusting PAD types over XVS types"), _("\
-Show whether an optimization trusting PAD types over XVS types is activated"),
+Enable or disable an optimization trusting PAD types over XVS types."), _("\
+Show whether an optimization trusting PAD types over XVS types is activated."),
_("\
This is related to the encoding used by the GNAT compiler. The debugger\n\
should normally trust the contents of PAD types, but certain older versions\n\
add_setshow_boolean_cmd ("print-signatures", class_vars,
&print_signatures, _("\
Enable or disable the output of formal and return types for functions in the \
-overloads selection menu"), _("\
+overloads selection menu."), _("\
Show whether the output of formal and return types for functions in the \
-overloads selection menu is activated"),
+overloads selection menu is activated."),
NULL, NULL, NULL, &set_ada_list, &show_ada_list);
add_catch_command ("exception", _("\
Catch Ada exceptions, when raised.\n\
-Usage: catch exception [ ARG ]\n\
-\n\
+Usage: catch exception [ARG] [if CONDITION]\n\
Without any argument, stop when any Ada exception is raised.\n\
If ARG is \"unhandled\" (without the quotes), only stop when the exception\n\
being raised does not have a handler (and will therefore lead to the task's\n\
termination).\n\
Otherwise, the catchpoint only stops when the name of the exception being\n\
-raised is the same as ARG."),
+raised is the same as ARG.\n\
+CONDITION is a boolean expression that is evaluated to see whether the\n\
+exception should cause a stop."),
catch_ada_exception_command,
- NULL,
+ catch_ada_completer,
CATCH_PERMANENT,
CATCH_TEMPORARY);
add_catch_command ("handlers", _("\
Catch Ada exceptions, when handled.\n\
-With an argument, catch only exceptions with the given name."),
+Usage: catch handlers [ARG] [if CONDITION]\n\
+Without any argument, stop when any Ada exception is handled.\n\
+With an argument, catch only exceptions with the given name.\n\
+CONDITION is a boolean expression that is evaluated to see whether the\n\
+exception should cause a stop."),
catch_ada_handlers_command,
- NULL,
+ catch_ada_completer,
CATCH_PERMANENT,
CATCH_TEMPORARY);
add_catch_command ("assert", _("\
Catch failed Ada assertions, when raised.\n\
-With an argument, catch only exceptions with the given name."),
+Usage: catch assert [if CONDITION]\n\
+CONDITION is a boolean expression that is evaluated to see whether the\n\
+exception should cause a stop."),
catch_assert_command,
NULL,
CATCH_PERMANENT,
add_info ("exceptions", info_exceptions_command,
_("\
List all Ada exception names.\n\
+Usage: info exceptions [REGEXP]\n\
If a regular expression is passed as an argument, only those matching\n\
the regular expression are listed."));
- add_prefix_cmd ("ada", class_maintenance, maint_set_ada_cmd,
- _("Set Ada maintenance-related variables."),
- &maint_set_ada_cmdlist, "maintenance set ada ",
- 0/*allow-unknown*/, &maintenance_set_cmdlist);
+ add_basic_prefix_cmd ("ada", class_maintenance,
+ _("Set Ada maintenance-related variables."),
+ &maint_set_ada_cmdlist, "maintenance set ada ",
+ 0/*allow-unknown*/, &maintenance_set_cmdlist);
- add_prefix_cmd ("ada", class_maintenance, maint_show_ada_cmd,
- _("Show Ada maintenance-related variables"),
- &maint_show_ada_cmdlist, "maintenance show ada ",
- 0/*allow-unknown*/, &maintenance_show_cmdlist);
+ add_show_prefix_cmd ("ada", class_maintenance,
+ _("Show Ada maintenance-related variables."),
+ &maint_show_ada_cmdlist, "maintenance show ada ",
+ 0/*allow-unknown*/, &maintenance_show_cmdlist);
add_setshow_boolean_cmd
("ignore-descriptive-types", class_maintenance,
gdb::observers::new_objfile.attach (ada_new_objfile_observer);
gdb::observers::free_objfile.attach (ada_free_objfile_observer);
gdb::observers::inferior_exit.attach (ada_inferior_exit);
-
- /* Setup various context-specific data. */
- ada_inferior_data
- = register_inferior_data_with_cleanup (NULL, ada_inferior_data_cleanup);
- ada_pspace_data_handle
- = register_program_space_data_with_cleanup (NULL, ada_pspace_data_cleanup);
}
projects / deliverable / binutils-gdb.git / blobdiff