-/* Ada language support routines for GDB, the GNU debugger. Copyright
- 1992, 1993, 1994, 1997, 1998, 1999, 2000, 2003, 2004.
- Free Software Foundation, Inc.
+/* Ada language support routines for GDB, the GNU debugger. Copyright (C)
+
+ 1992, 1993, 1994, 1997, 1998, 1999, 2000, 2003, 2004, 2005 Free
+ Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-
-
-/* Sections of code marked
-
- #ifdef GNAT_GDB
- ...
- #endif
+Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
- indicate sections that are used in sources distributed by
- ACT, Inc., but not yet integrated into the public tree (where
- GNAT_GDB is not defined). They are retained here nevertheless
- to minimize the problems of maintaining different versions
- of the source and to make the full source available. */
#include "defs.h"
#include <stdio.h>
#include "block.h"
#include "infcall.h"
#include "dictionary.h"
+#include "exceptions.h"
#ifndef ADA_RETAIN_DOTS
#define ADA_RETAIN_DOTS 0
#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
#endif
-#ifdef GNAT_GDB
-/* A structure that contains a vector of strings.
- The main purpose of this type is to group the vector and its
- associated parameters in one structure. This makes it easier
- to handle and pass around. */
-
-struct string_vector
-{
- char **array; /* The vector itself. */
- int index; /* Index of the next available element in the array. */
- size_t size; /* The number of entries allocated in the array. */
-};
-
-static struct string_vector xnew_string_vector (int initial_size);
-static void string_vector_append (struct string_vector *sv, char *str);
-#endif /* GNAT_GDB */
-static const char *ada_unqualified_name (const char *decoded_name);
-static char *add_angle_brackets (const char *str);
static void extract_string (CORE_ADDR addr, char *buf);
-static char *function_name_from_pc (CORE_ADDR pc);
static struct type *ada_create_fundamental_type (struct objfile *, int);
static struct type *ada_lookup_struct_elt_type (struct type *, char *,
int, int, int *);
-static char *extended_canonical_line_spec (struct symtab_and_line,
- const char *);
-
static struct value *evaluate_subexp (struct type *, struct expression *,
int *, enum noside);
static struct value *evaluate_subexp_type (struct expression *, int *);
-static struct type *ada_create_fundamental_type (struct objfile *, int);
-
static int is_dynamic_field (struct type *, int);
-static struct type *to_fixed_variant_branch_type (struct type *, char *,
+static struct type *to_fixed_variant_branch_type (struct type *,
+ const gdb_byte *,
CORE_ADDR, struct value *);
static struct type *to_fixed_array_type (struct type *, struct value *, int);
static struct value *value_subscript_packed (struct value *, int,
struct value **);
+static void move_bits (gdb_byte *, int, const gdb_byte *, int, int);
+
static struct value *coerce_unspec_val_to_type (struct value *,
struct type *);
static int wild_match (const char *, int, const char *);
-static struct symtabs_and_lines
-find_sal_from_funcs_and_line (const char *, int,
- struct ada_symbol_info *, int);
-
-static int find_line_in_linetable (struct linetable *, int,
- struct ada_symbol_info *, int, int *);
-
-static int find_next_line_in_linetable (struct linetable *, int, int, int);
-
-static void read_all_symtabs (const char *);
-
-static int is_plausible_func_for_line (struct symbol *, int);
-
static struct value *ada_coerce_ref (struct value *);
static LONGEST pos_atr (struct value *);
struct type *);
static int find_struct_field (char *, struct type *, int,
- struct type **, int *, int *, int *);
+ struct type **, int *, int *, int *, int *);
static struct value *ada_to_fixed_value_create (struct type *, CORE_ADDR,
struct value *);
static struct value *ada_to_fixed_value (struct value *);
-static void adjust_pc_past_prologue (CORE_ADDR *);
-
static int ada_resolve_function (struct ada_symbol_info *, int,
struct value **, int, const char *,
struct type *);
static int ada_is_direct_array_type (struct type *);
-static void error_breakpoint_runtime_sym_not_found (const char *err_desc);
+static void ada_language_arch_info (struct gdbarch *,
+ struct language_arch_info *);
+
+static void check_size (const struct type *);
+
+static struct value *ada_index_struct_field (int, struct value *, int,
+ struct type *);
+
+static struct value *assign_aggregate (struct value *, struct value *,
+ struct expression *, int *, enum noside);
+
+static void aggregate_assign_from_choices (struct value *, struct value *,
+ struct expression *,
+ int *, LONGEST *, int *,
+ int, LONGEST, LONGEST);
+
+static void aggregate_assign_positional (struct value *, struct value *,
+ struct expression *,
+ int *, LONGEST *, int *, int,
+ LONGEST, LONGEST);
+
-static int is_runtime_sym_defined (const char *name, int allow_tramp);
+static void aggregate_assign_others (struct value *, struct value *,
+ struct expression *,
+ int *, LONGEST *, int, LONGEST, LONGEST);
+
+
+static void add_component_interval (LONGEST, LONGEST, LONGEST *, int *, int);
+
+
+static struct value *ada_evaluate_subexp (struct type *, struct expression *,
+ int *, enum noside);
+
+static void ada_forward_operator_length (struct expression *, int, int *,
+ int *);
\f
static const char raise_assert_sym_name[] =
"system__assertions__raise_assert_failure";
-/* When GDB stops on an unhandled exception, GDB will go up the stack until
- if finds a frame corresponding to this function, in order to extract the
- name of the exception that has been raised from one of the parameters. */
-static const char process_raise_exception_name[] =
- "ada__exceptions__process_raise_exception";
-
/* A string that reflects the longest exception expression rewrite,
aside from the exception name. */
static const char longest_exception_template[] =
/* Utilities */
-#ifdef GNAT_GDB
-
-/* Create a new empty string_vector struct with an initial size of
- INITIAL_SIZE. */
-
-static struct string_vector
-xnew_string_vector (int initial_size)
-{
- struct string_vector result;
-
- result.array = (char **) xmalloc ((initial_size + 1) * sizeof (char *));
- result.index = 0;
- result.size = initial_size;
-
- return result;
-}
-
-/* Add STR at the end of the given string vector SV. If SV is already
- full, its size is automatically increased (doubled). */
-
-static void
-string_vector_append (struct string_vector *sv, char *str)
-{
- if (sv->index >= sv->size)
- GROW_VECT (sv->array, sv->size, sv->size * 2);
-
- sv->array[sv->index] = str;
- sv->index++;
-}
-
-/* Given DECODED_NAME a string holding a symbol name in its
- decoded form (ie using the Ada dotted notation), returns
- its unqualified name. */
-
-static const char *
-ada_unqualified_name (const char *decoded_name)
-{
- const char *result = strrchr (decoded_name, '.');
-
- if (result != NULL)
- result++; /* Skip the dot... */
- else
- result = decoded_name;
-
- return result;
-}
-
-/* Return a string starting with '<', followed by STR, and '>'.
- The result is good until the next call. */
static char *
-add_angle_brackets (const char *str)
+ada_get_gdb_completer_word_break_characters (void)
{
- static char *result = NULL;
-
- xfree (result);
- result = (char *) xmalloc ((strlen (str) + 3) * sizeof (char));
-
- sprintf (result, "<%s>", str);
- return result;
+ return ada_completer_word_break_characters;
}
-#endif /* GNAT_GDB */
+/* Print an array element index using the Ada syntax. */
-static char *
-ada_get_gdb_completer_word_break_characters (void)
+static void
+ada_print_array_index (struct value *index_value, struct ui_file *stream,
+ int format, enum val_prettyprint pretty)
{
- return ada_completer_word_break_characters;
+ LA_VALUE_PRINT (index_value, stream, format, pretty);
+ fprintf_filtered (stream, " => ");
}
/* Read the string located at ADDR from the inferior and store the
while (buf[char_index - 1] != '\000');
}
-/* Return the name of the function owning the instruction located at PC.
- Return NULL if no such function could be found. */
-
-static char *
-function_name_from_pc (CORE_ADDR pc)
-{
- char *func_name;
-
- if (!find_pc_partial_function (pc, &func_name, NULL, NULL))
- return NULL;
-
- return func_name;
-}
-
-/* Assuming *OLD_VECT points to an array of *SIZE objects of size
+/* Assuming VECT points to an array of *SIZE objects of size
ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
- updating *OLD_VECT and *SIZE as necessary. */
+ updating *SIZE as necessary and returning the (new) array. */
-void
-grow_vect (void **old_vect, size_t * size, size_t min_size, int element_size)
+void *
+grow_vect (void *vect, size_t *size, size_t min_size, int element_size)
{
if (*size < min_size)
{
*size *= 2;
if (*size < min_size)
*size = min_size;
- *old_vect = xrealloc (*old_vect, *size * element_size);
+ vect = xrealloc (vect, *size * element_size);
}
+ return vect;
}
/* True (non-zero) iff TARGET matches FIELD_NAME up to any trailing
return fieldno;
if (!maybe_missing)
- error ("Unable to find field %s in struct %s. Aborting",
+ error (_("Unable to find field %s in struct %s. Aborting"),
field_name, TYPE_NAME (type));
return -1;
ADDRESS. */
struct value *
-value_from_contents_and_address (struct type *type, char *valaddr,
+value_from_contents_and_address (struct type *type,
+ const gdb_byte *valaddr,
CORE_ADDR address)
{
struct value *v = allocate_value (type);
if (valaddr == NULL)
- VALUE_LAZY (v) = 1;
+ set_value_lazy (v, 1);
else
- memcpy (VALUE_CONTENTS_RAW (v), valaddr, TYPE_LENGTH (type));
+ memcpy (value_contents_raw (v), valaddr, TYPE_LENGTH (type));
VALUE_ADDRESS (v) = address;
if (address != 0)
VALUE_LVAL (v) = lval_memory;
static struct value *
coerce_unspec_val_to_type (struct value *val, struct type *type)
{
- CHECK_TYPEDEF (type);
- if (VALUE_TYPE (val) == type)
+ type = ada_check_typedef (type);
+ if (value_type (val) == type)
return val;
else
{
/* Make sure that the object size is not unreasonable before
trying to allocate some memory for it. */
- if (TYPE_LENGTH (type) > varsize_limit)
- error ("object size is larger than varsize-limit");
+ check_size (type);
result = allocate_value (type);
VALUE_LVAL (result) = VALUE_LVAL (val);
- VALUE_BITSIZE (result) = VALUE_BITSIZE (val);
- VALUE_BITPOS (result) = VALUE_BITPOS (val);
- VALUE_ADDRESS (result) = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
- if (VALUE_LAZY (val)
- || TYPE_LENGTH (type) > TYPE_LENGTH (VALUE_TYPE (val)))
- VALUE_LAZY (result) = 1;
+ set_value_bitsize (result, value_bitsize (val));
+ set_value_bitpos (result, value_bitpos (val));
+ VALUE_ADDRESS (result) = VALUE_ADDRESS (val) + value_offset (val);
+ if (value_lazy (val)
+ || TYPE_LENGTH (type) > TYPE_LENGTH (value_type (val)))
+ set_value_lazy (result, 1);
else
- memcpy (VALUE_CONTENTS_RAW (result), VALUE_CONTENTS (val),
+ memcpy (value_contents_raw (result), value_contents (val),
TYPE_LENGTH (type));
return result;
}
}
-static char *
-cond_offset_host (char *valaddr, long offset)
+static const gdb_byte *
+cond_offset_host (const gdb_byte *valaddr, long offset)
{
if (valaddr == NULL)
return NULL;
with exactly one argument rather than ...), unless the limit on the
number of warnings has passed during the evaluation of the current
expression. */
+
+/* FIXME: cagney/2004-10-10: This function is mimicking the behavior
+ provided by "complaint". */
+static void lim_warning (const char *format, ...) ATTR_FORMAT (printf, 1, 2);
+
static void
-lim_warning (const char *format, long arg)
+lim_warning (const char *format, ...)
{
+ va_list args;
+ va_start (args, format);
+
warnings_issued += 1;
if (warnings_issued <= warning_limit)
- warning (format, arg);
+ vwarning (format, args);
+
+ va_end (args);
}
-static const char *
-ada_translate_error_message (const char *string)
+/* Issue an error if the size of an object of type T is unreasonable,
+ i.e. if it would be a bad idea to allocate a value of this type in
+ GDB. */
+
+static void
+check_size (const struct type *type)
{
- if (strcmp (string, "Invalid cast.") == 0)
- return "Invalid type conversion.";
- else
- return string;
+ if (TYPE_LENGTH (type) > varsize_limit)
+ error (_("object size is larger than varsize-limit"));
}
+
/* Note: would have used MAX_OF_TYPE and MIN_OF_TYPE macros from
gdbtypes.h, but some of the necessary definitions in that file
seem to have gone missing. */
case TYPE_CODE_INT:
return value_from_longest (type, max_of_type (type));
default:
- error ("Unexpected type in discrete_type_high_bound.");
+ error (_("Unexpected type in discrete_type_high_bound."));
}
}
case TYPE_CODE_INT:
return value_from_longest (type, min_of_type (type));
default:
- error ("Unexpected type in discrete_type_low_bound.");
+ error (_("Unexpected type in discrete_type_low_bound."));
}
}
struct minimal_symbol *msym;
CORE_ADDR main_program_name_addr;
static char main_program_name[1024];
+
/* For Ada, the name of the main procedure is stored in a specific
string constant, generated by the binder. Look for that symbol,
extract its address, and then read that string. If we didn't find
{
main_program_name_addr = SYMBOL_VALUE_ADDRESS (msym);
if (main_program_name_addr == 0)
- error ("Invalid address for Ada main program name.");
+ error (_("Invalid address for Ada main program name."));
extract_string (main_program_name_addr, main_program_name);
return main_program_name;
strlen (mapping->decoded)) != 0; mapping += 1)
;
if (mapping->encoded == NULL)
- error ("invalid Ada operator name: %s", p);
+ error (_("invalid Ada operator name: %s"), p);
strcpy (encoding_buffer + k, mapping->encoded);
k += strlen (mapping->encoded);
break;
return fold_buffer;
}
-/* decode:
- 0. Discard trailing .{DIGIT}+ or trailing ___{DIGIT}+
+/* Return nonzero if C is either a digit or a lowercase alphabet character. */
+
+static int
+is_lower_alphanum (const char c)
+{
+ return (isdigit (c) || (isalpha (c) && islower (c)));
+}
+
+/* Decode:
+ . Discard trailing .{DIGIT}+, ${DIGIT}+ or ___{DIGIT}+
These are suffixes introduced by GNAT5 to nested subprogram
names, and do not serve any purpose for the debugger.
- 1. Discard final __{DIGIT}+ or $({DIGIT}+(__{DIGIT}+)*)
- 2. Convert other instances of embedded "__" to `.'.
- 3. Discard leading _ada_.
- 4. Convert operator names to the appropriate quoted symbols.
- 5. Remove everything after first ___ if it is followed by
+ . Discard final __{DIGIT}+ or $({DIGIT}+(__{DIGIT}+)*)
+ . Discard final N if it follows a lowercase alphanumeric character
+ (protected object subprogram suffix)
+ . Convert other instances of embedded "__" to `.'.
+ . Discard leading _ada_.
+ . Convert operator names to the appropriate quoted symbols.
+ . Remove everything after first ___ if it is followed by
'X'.
- 6. Replace TK__ with __, and a trailing B or TKB with nothing.
- 7. Put symbols that should be suppressed in <...> brackets.
- 8. Remove trailing X[bn]* suffix (indicating names in package bodies).
+ . Replace TK__ with __, and a trailing B or TKB with nothing.
+ . Replace _[EB]{DIGIT}+[sb] with nothing (protected object entries)
+ . Put symbols that should be suppressed in <...> brackets.
+ . Remove trailing X[bn]* suffix (indicating names in package bodies).
The resulting string is valid until the next call of ada_decode.
If the string is unchanged by demangling, the original string pointer
if (encoded[0] == '_' || encoded[0] == '<')
goto Suppress;
- /* Remove trailing .{DIGIT}+ or ___{DIGIT}+. */
+ /* Remove trailing .{DIGIT}+ or ___{DIGIT}+ or __{DIGIT}+. */
len0 = strlen (encoded);
if (len0 > 1 && isdigit (encoded[len0 - 1]))
{
i--;
if (i >= 0 && encoded[i] == '.')
len0 = i;
+ else if (i >= 0 && encoded[i] == '$')
+ len0 = i;
else if (i >= 2 && strncmp (encoded + i - 2, "___", 3) == 0)
len0 = i - 2;
+ else if (i >= 1 && strncmp (encoded + i - 1, "__", 2) == 0)
+ len0 = i - 1;
}
+ /* Remove trailing N. */
+
+ /* Protected entry subprograms are broken into two
+ separate subprograms: The first one is unprotected, and has
+ a 'N' suffix; the second is the protected version, and has
+ the 'P' suffix. The second calls the first one after handling
+ the protection. Since the P subprograms are internally generated,
+ we leave these names undecoded, giving the user a clue that this
+ entity is internal. */
+
+ if (len0 > 1
+ && encoded[len0 - 1] == 'N'
+ && (isdigit (encoded[len0 - 2]) || islower (encoded[len0 - 2])))
+ len0--;
+
/* Remove the ___X.* suffix if present. Do not forget to verify that
the suffix is located before the current "end" of ENCODED. We want
to avoid re-matching parts of ENCODED that have previously been
}
at_start_name = 0;
+ /* Replace "TK__" with "__", which will eventually be translated
+ into "." (just below). */
+
if (i < len0 - 4 && strncmp (encoded + i, "TK__", 4) == 0)
i += 2;
+
+ /* Remove _E{DIGITS}+[sb] */
+
+ /* Just as for protected object subprograms, there are 2 categories
+ of subprograms created by the compiler for each entry. The first
+ one implements the actual entry code, and has a suffix following
+ the convention above; the second one implements the barrier and
+ uses the same convention as above, except that the 'E' is replaced
+ by a 'B'.
+
+ Just as above, we do not decode the name of barrier functions
+ to give the user a clue that the code he is debugging has been
+ internally generated. */
+
+ if (len0 - i > 3 && encoded [i] == '_' && encoded[i+1] == 'E'
+ && isdigit (encoded[i+2]))
+ {
+ int k = i + 3;
+
+ while (k < len0 && isdigit (encoded[k]))
+ k++;
+
+ if (k < len0
+ && (encoded[k] == 'b' || encoded[k] == 's'))
+ {
+ k++;
+ /* Just as an extra precaution, make sure that if this
+ suffix is followed by anything else, it is a '_'.
+ Otherwise, we matched this sequence by accident. */
+ if (k == len0
+ || (k < len0 && encoded[k] == '_'))
+ i = k;
+ }
+ }
+
+ /* Remove trailing "N" in [a-z0-9]+N__. The N is added by
+ the GNAT front-end in protected object subprograms. */
+
+ if (i < len0 + 3
+ && encoded[i] == 'N' && encoded[i+1] == '_' && encoded[i+2] == '_')
+ {
+ /* Backtrack a bit up until we reach either the begining of
+ the encoded name, or "__". Make sure that we only find
+ digits or lowercase characters. */
+ const char *ptr = encoded + i - 1;
+
+ while (ptr >= encoded && is_lower_alphanum (ptr[0]))
+ ptr--;
+ if (ptr < encoded
+ || (ptr > encoded && ptr[0] == '_' && ptr[-1] == '_'))
+ i++;
+ }
+
if (encoded[i] == 'X' && i != 0 && isalnum (encoded[i - 1]))
{
do
{
if (type == NULL)
return NULL;
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
if (type != NULL
&& (TYPE_CODE (type) == TYPE_CODE_PTR
|| TYPE_CODE (type) == TYPE_CODE_REF))
- return check_typedef (TYPE_TARGET_TYPE (type));
+ return ada_check_typedef (TYPE_TARGET_TYPE (type));
else
return type;
}
static struct value *
thin_data_pntr (struct value *val)
{
- struct type *type = VALUE_TYPE (val);
+ struct type *type = value_type (val);
if (TYPE_CODE (type) == TYPE_CODE_PTR)
return value_cast (desc_data_type (thin_descriptor_type (type)),
value_copy (val));
else
return value_from_longest (desc_data_type (thin_descriptor_type (type)),
- VALUE_ADDRESS (val) + VALUE_OFFSET (val));
+ VALUE_ADDRESS (val) + value_offset (val));
}
/* True iff TYPE indicates a "thick" array pointer type. */
return NULL;
r = lookup_struct_elt_type (type, "BOUNDS", 1);
if (r != NULL)
- return check_typedef (r);
+ return ada_check_typedef (r);
}
else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
{
r = lookup_struct_elt_type (type, "P_BOUNDS", 1);
if (r != NULL)
- return check_typedef (TYPE_TARGET_TYPE (check_typedef (r)));
+ return ada_check_typedef (TYPE_TARGET_TYPE (ada_check_typedef (r)));
}
return NULL;
}
static struct value *
desc_bounds (struct value *arr)
{
- struct type *type = check_typedef (VALUE_TYPE (arr));
+ struct type *type = ada_check_typedef (value_type (arr));
if (is_thin_pntr (type))
{
struct type *bounds_type =
LONGEST addr;
if (desc_bounds_type == NULL)
- error ("Bad GNAT array descriptor");
+ error (_("Bad GNAT array descriptor"));
/* NOTE: The following calculation is not really kosher, but
since desc_type is an XVE-encoded type (and shouldn't be),
if (TYPE_CODE (type) == TYPE_CODE_PTR)
addr = value_as_long (arr);
else
- addr = VALUE_ADDRESS (arr) + VALUE_OFFSET (arr);
+ addr = VALUE_ADDRESS (arr) + value_offset (arr);
return
value_from_longest (lookup_pointer_type (bounds_type),
else if (is_thick_pntr (type))
return value_struct_elt (&arr, NULL, "P_BOUNDS", NULL,
- "Bad GNAT array descriptor");
+ _("Bad GNAT array descriptor"));
else
return NULL;
}
if (TYPE_FIELD_BITSIZE (type, 1) > 0)
return TYPE_FIELD_BITSIZE (type, 1);
else
- return 8 * TYPE_LENGTH (check_typedef (TYPE_FIELD_TYPE (type, 1)));
+ return 8 * TYPE_LENGTH (ada_check_typedef (TYPE_FIELD_TYPE (type, 1)));
}
/* If TYPE is the type of an array descriptor (fat or thin pointer) or a
static struct value *
desc_data (struct value *arr)
{
- struct type *type = VALUE_TYPE (arr);
+ struct type *type = value_type (arr);
if (is_thin_pntr (type))
return thin_data_pntr (arr);
else if (is_thick_pntr (type))
return value_struct_elt (&arr, NULL, "P_ARRAY", NULL,
- "Bad GNAT array descriptor");
+ _("Bad GNAT array descriptor"));
else
return NULL;
}
desc_one_bound (struct value *bounds, int i, int which)
{
return value_struct_elt (&bounds, NULL, bound_name[2 * i + which - 2], NULL,
- "Bad GNAT array descriptor bounds");
+ _("Bad GNAT array descriptor bounds"));
}
/* If BOUNDS is an array-bounds structure type, return the bit position
{
if (type == NULL)
return 0;
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
return (TYPE_CODE (type) == TYPE_CODE_ARRAY
|| ada_is_array_descriptor_type (type));
}
+/* Non-zero iff TYPE represents any kind of array in Ada, or a pointer
+ * to one. */
+
+int
+ada_is_array_type (struct type *type)
+{
+ while (type != NULL
+ && (TYPE_CODE (type) == TYPE_CODE_PTR
+ || TYPE_CODE (type) == TYPE_CODE_REF))
+ type = TYPE_TARGET_TYPE (type);
+ return ada_is_direct_array_type (type);
+}
+
/* Non-zero iff TYPE is a simple array type or pointer to one. */
int
{
if (type == NULL)
return 0;
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
return (TYPE_CODE (type) == TYPE_CODE_ARRAY
|| (TYPE_CODE (type) == TYPE_CODE_PTR
&& TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_ARRAY));
if (type == NULL)
return 0;
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
return
data_type != NULL
&& ((TYPE_CODE (data_type) == TYPE_CODE_PTR
struct type *
ada_type_of_array (struct value *arr, int bounds)
{
- if (ada_is_packed_array_type (VALUE_TYPE (arr)))
- return decode_packed_array_type (VALUE_TYPE (arr));
+ if (ada_is_packed_array_type (value_type (arr)))
+ return decode_packed_array_type (value_type (arr));
- if (!ada_is_array_descriptor_type (VALUE_TYPE (arr)))
- return VALUE_TYPE (arr);
+ if (!ada_is_array_descriptor_type (value_type (arr)))
+ return value_type (arr);
if (!bounds)
return
- check_typedef (TYPE_TARGET_TYPE (desc_data_type (VALUE_TYPE (arr))));
+ ada_check_typedef (TYPE_TARGET_TYPE (desc_data_type (value_type (arr))));
else
{
struct type *elt_type;
int arity;
struct value *descriptor;
- struct objfile *objf = TYPE_OBJFILE (VALUE_TYPE (arr));
+ struct objfile *objf = TYPE_OBJFILE (value_type (arr));
- elt_type = ada_array_element_type (VALUE_TYPE (arr), -1);
- arity = ada_array_arity (VALUE_TYPE (arr));
+ elt_type = ada_array_element_type (value_type (arr), -1);
+ arity = ada_array_arity (value_type (arr));
if (elt_type == NULL || arity == 0)
- return check_typedef (VALUE_TYPE (arr));
+ return ada_check_typedef (value_type (arr));
descriptor = desc_bounds (arr);
if (value_as_long (descriptor) == 0)
struct value *high = desc_one_bound (descriptor, arity, 1);
arity -= 1;
- create_range_type (range_type, VALUE_TYPE (low),
- (int) value_as_long (low),
- (int) value_as_long (high));
+ create_range_type (range_type, value_type (low),
+ longest_to_int (value_as_long (low)),
+ longest_to_int (value_as_long (high)));
elt_type = create_array_type (array_type, elt_type, range_type);
}
struct value *
ada_coerce_to_simple_array_ptr (struct value *arr)
{
- if (ada_is_array_descriptor_type (VALUE_TYPE (arr)))
+ if (ada_is_array_descriptor_type (value_type (arr)))
{
struct type *arrType = ada_type_of_array (arr, 1);
if (arrType == NULL)
return NULL;
return value_cast (arrType, value_copy (desc_data (arr)));
}
- else if (ada_is_packed_array_type (VALUE_TYPE (arr)))
+ else if (ada_is_packed_array_type (value_type (arr)))
return decode_packed_array (arr);
else
return arr;
static struct value *
ada_coerce_to_simple_array (struct value *arr)
{
- if (ada_is_array_descriptor_type (VALUE_TYPE (arr)))
+ if (ada_is_array_descriptor_type (value_type (arr)))
{
struct value *arrVal = ada_coerce_to_simple_array_ptr (arr);
if (arrVal == NULL)
- error ("Bounds unavailable for null array pointer.");
+ error (_("Bounds unavailable for null array pointer."));
+ check_size (TYPE_TARGET_TYPE (value_type (arrVal)));
return value_ind (arrVal);
}
- else if (ada_is_packed_array_type (VALUE_TYPE (arr)))
+ else if (ada_is_packed_array_type (value_type (arr)))
return decode_packed_array (arr);
else
return arr;
struct value *mark = value_mark ();
struct value *dummy = value_from_longest (builtin_type_long, 0);
struct type *result;
- VALUE_TYPE (dummy) = type;
+ deprecated_set_value_type (dummy, type);
result = ada_type_of_array (dummy, 0);
value_free_to_mark (mark);
return result;
if (type == NULL)
return 0;
type = desc_base_type (type);
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
return
ada_type_name (type) != NULL
&& strstr (ada_type_name (type), "___XP") != NULL;
struct type *new_type;
LONGEST low_bound, high_bound;
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
return type;
new_type = alloc_type (TYPE_OBJFILE (type));
- new_elt_type = packed_array_type (check_typedef (TYPE_TARGET_TYPE (type)),
+ new_elt_type = packed_array_type (ada_check_typedef (TYPE_TARGET_TYPE (type)),
elt_bits);
create_array_type (new_type, new_elt_type, TYPE_FIELD_TYPE (type, 0));
TYPE_FIELD_BITSIZE (new_type, 0) = *elt_bits;
{
struct symbol *sym;
struct block **blocks;
- const char *raw_name = ada_type_name (check_typedef (type));
+ const char *raw_name = ada_type_name (ada_check_typedef (type));
char *name = (char *) alloca (strlen (raw_name) + 1);
char *tail = strstr (raw_name, "___XP");
struct type *shadow_type;
sym = standard_lookup (name, get_selected_block (0), VAR_DOMAIN);
if (sym == NULL || SYMBOL_TYPE (sym) == NULL)
{
- lim_warning ("could not find bounds information on packed array", 0);
+ lim_warning (_("could not find bounds information on packed array"));
return NULL;
}
shadow_type = SYMBOL_TYPE (sym);
if (TYPE_CODE (shadow_type) != TYPE_CODE_ARRAY)
{
- lim_warning ("could not understand bounds information on packed array",
- 0);
+ lim_warning (_("could not understand bounds information on packed array"));
return NULL;
}
if (sscanf (tail + sizeof ("___XP") - 1, "%ld", &bits) != 1)
{
lim_warning
- ("could not understand bit size information on packed array", 0);
+ (_("could not understand bit size information on packed array"));
return NULL;
}
struct type *type;
arr = ada_coerce_ref (arr);
- if (TYPE_CODE (VALUE_TYPE (arr)) == TYPE_CODE_PTR)
+ if (TYPE_CODE (value_type (arr)) == TYPE_CODE_PTR)
arr = ada_value_ind (arr);
- type = decode_packed_array_type (VALUE_TYPE (arr));
+ type = decode_packed_array_type (value_type (arr));
if (type == NULL)
{
- error ("can't unpack array");
+ error (_("can't unpack array"));
return NULL;
}
+
+ if (BITS_BIG_ENDIAN && ada_is_modular_type (value_type (arr)))
+ {
+ /* This is a (right-justified) modular type representing a packed
+ array with no wrapper. In order to interpret the value through
+ the (left-justified) packed array type we just built, we must
+ first left-justify it. */
+ int bit_size, bit_pos;
+ ULONGEST mod;
+
+ mod = ada_modulus (value_type (arr)) - 1;
+ bit_size = 0;
+ while (mod > 0)
+ {
+ bit_size += 1;
+ mod >>= 1;
+ }
+ bit_pos = HOST_CHAR_BIT * TYPE_LENGTH (value_type (arr)) - bit_size;
+ arr = ada_value_primitive_packed_val (arr, NULL,
+ bit_pos / HOST_CHAR_BIT,
+ bit_pos % HOST_CHAR_BIT,
+ bit_size,
+ type);
+ }
+
return coerce_unspec_val_to_type (arr, type);
}
bits = 0;
elt_total_bit_offset = 0;
- elt_type = check_typedef (VALUE_TYPE (arr));
+ elt_type = ada_check_typedef (value_type (arr));
for (i = 0; i < arity; i += 1)
{
if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY
|| TYPE_FIELD_BITSIZE (elt_type, 0) == 0)
error
- ("attempt to do packed indexing of something other than a packed array");
+ (_("attempt to do packed indexing of something other than a packed array"));
else
{
struct type *range_type = TYPE_INDEX_TYPE (elt_type);
if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
{
- lim_warning ("don't know bounds of array", 0);
+ lim_warning (_("don't know bounds of array"));
lowerbound = upperbound = 0;
}
idx = value_as_long (value_pos_atr (ind[i]));
if (idx < lowerbound || idx > upperbound)
- lim_warning ("packed array index %ld out of bounds", (long) idx);
+ lim_warning (_("packed array index %ld out of bounds"), (long) idx);
bits = TYPE_FIELD_BITSIZE (elt_type, 0);
elt_total_bit_offset += (idx - lowerbound) * bits;
- elt_type = check_typedef (TYPE_TARGET_TYPE (elt_type));
+ elt_type = ada_check_typedef (TYPE_TARGET_TYPE (elt_type));
}
}
elt_off = elt_total_bit_offset / HOST_CHAR_BIT;
Assumes 0 <= BIT_OFFSET < HOST_CHAR_BIT. */
struct value *
-ada_value_primitive_packed_val (struct value *obj, char *valaddr, long offset,
- int bit_offset, int bit_size,
+ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
+ long offset, int bit_offset, int bit_size,
struct type *type)
{
struct value *v;
the indices move. */
int delta = BITS_BIG_ENDIAN ? -1 : 1;
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
if (obj == NULL)
{
v = allocate_value (type);
bytes = (unsigned char *) (valaddr + offset);
}
- else if (VALUE_LAZY (obj))
+ else if (value_lazy (obj))
{
v = value_at (type,
- VALUE_ADDRESS (obj) + VALUE_OFFSET (obj) + offset, NULL);
+ VALUE_ADDRESS (obj) + value_offset (obj) + offset);
bytes = (unsigned char *) alloca (len);
read_memory (VALUE_ADDRESS (v), bytes, len);
}
else
{
v = allocate_value (type);
- bytes = (unsigned char *) VALUE_CONTENTS (obj) + offset;
+ bytes = (unsigned char *) value_contents (obj) + offset;
}
if (obj != NULL)
VALUE_LVAL (v) = VALUE_LVAL (obj);
if (VALUE_LVAL (obj) == lval_internalvar)
VALUE_LVAL (v) = lval_internalvar_component;
- VALUE_ADDRESS (v) = VALUE_ADDRESS (obj) + VALUE_OFFSET (obj) + offset;
- VALUE_BITPOS (v) = bit_offset + VALUE_BITPOS (obj);
- VALUE_BITSIZE (v) = bit_size;
- if (VALUE_BITPOS (v) >= HOST_CHAR_BIT)
+ VALUE_ADDRESS (v) = VALUE_ADDRESS (obj) + value_offset (obj) + offset;
+ set_value_bitpos (v, bit_offset + value_bitpos (obj));
+ set_value_bitsize (v, bit_size);
+ if (value_bitpos (v) >= HOST_CHAR_BIT)
{
VALUE_ADDRESS (v) += 1;
- VALUE_BITPOS (v) -= HOST_CHAR_BIT;
+ set_value_bitpos (v, value_bitpos (v) - HOST_CHAR_BIT);
}
}
else
- VALUE_BITSIZE (v) = bit_size;
- unpacked = (unsigned char *) VALUE_CONTENTS (v);
+ set_value_bitsize (v, bit_size);
+ unpacked = (unsigned char *) value_contents (v);
srcBitsLeft = bit_size;
nsrc = len;
(HOST_CHAR_BIT - bit_size % HOST_CHAR_BIT) % HOST_CHAR_BIT;
/* ... And are placed at the beginning (most-significant) bytes
of the target. */
- targ = src;
+ targ = (bit_size + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT - 1;
break;
default:
accumSize = 0;
TARGET, starting at bit offset TARG_OFFSET. SOURCE and TARGET must
not overlap. */
static void
-move_bits (char *target, int targ_offset, char *source, int src_offset, int n)
+move_bits (gdb_byte *target, int targ_offset, const gdb_byte *source,
+ int src_offset, int n)
{
unsigned int accum, mask;
int accum_bits, chunk_size;
}
}
-
/* Store the contents of FROMVAL into the location of TOVAL.
Return a new value with the location of TOVAL and contents of
FROMVAL. Handles assignment into packed fields that have
static struct value *
ada_value_assign (struct value *toval, struct value *fromval)
{
- struct type *type = VALUE_TYPE (toval);
- int bits = VALUE_BITSIZE (toval);
+ struct type *type = value_type (toval);
+ int bits = value_bitsize (toval);
- if (!toval->modifiable)
- error ("Left operand of assignment is not a modifiable lvalue.");
+ toval = ada_coerce_ref (toval);
+ fromval = ada_coerce_ref (fromval);
- COERCE_REF (toval);
+ if (ada_is_direct_array_type (value_type (toval)))
+ toval = ada_coerce_to_simple_array (toval);
+ if (ada_is_direct_array_type (value_type (fromval)))
+ fromval = ada_coerce_to_simple_array (fromval);
+
+ if (!deprecated_value_modifiable (toval))
+ error (_("Left operand of assignment is not a modifiable lvalue."));
if (VALUE_LVAL (toval) == lval_memory
&& bits > 0
&& (TYPE_CODE (type) == TYPE_CODE_FLT
|| TYPE_CODE (type) == TYPE_CODE_STRUCT))
{
- int len =
- (VALUE_BITPOS (toval) + bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
+ int len = (value_bitpos (toval)
+ + bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
char *buffer = (char *) alloca (len);
struct value *val;
+ CORE_ADDR to_addr = VALUE_ADDRESS (toval) + value_offset (toval);
if (TYPE_CODE (type) == TYPE_CODE_FLT)
fromval = value_cast (type, fromval);
- read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), buffer, len);
+ read_memory (to_addr, buffer, len);
if (BITS_BIG_ENDIAN)
- move_bits (buffer, VALUE_BITPOS (toval),
- VALUE_CONTENTS (fromval),
- TYPE_LENGTH (VALUE_TYPE (fromval)) * TARGET_CHAR_BIT -
+ move_bits (buffer, value_bitpos (toval),
+ value_contents (fromval),
+ TYPE_LENGTH (value_type (fromval)) * TARGET_CHAR_BIT -
bits, bits);
else
- move_bits (buffer, VALUE_BITPOS (toval), VALUE_CONTENTS (fromval),
+ move_bits (buffer, value_bitpos (toval), value_contents (fromval),
0, bits);
- write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), buffer,
- len);
-
+ write_memory (to_addr, buffer, len);
+ if (deprecated_memory_changed_hook)
+ deprecated_memory_changed_hook (to_addr, len);
+
val = value_copy (toval);
- memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
+ memcpy (value_contents_raw (val), value_contents (fromval),
TYPE_LENGTH (type));
- VALUE_TYPE (val) = type;
+ deprecated_set_value_type (val, type);
return val;
}
}
+/* Given that COMPONENT is a memory lvalue that is part of the lvalue
+ * CONTAINER, assign the contents of VAL to COMPONENTS's place in
+ * CONTAINER. Modifies the VALUE_CONTENTS of CONTAINER only, not
+ * COMPONENT, and not the inferior's memory. The current contents
+ * of COMPONENT are ignored. */
+static void
+value_assign_to_component (struct value *container, struct value *component,
+ struct value *val)
+{
+ LONGEST offset_in_container =
+ (LONGEST) (VALUE_ADDRESS (component) + value_offset (component)
+ - VALUE_ADDRESS (container) - value_offset (container));
+ int bit_offset_in_container =
+ value_bitpos (component) - value_bitpos (container);
+ int bits;
+
+ val = value_cast (value_type (component), val);
+
+ if (value_bitsize (component) == 0)
+ bits = TARGET_CHAR_BIT * TYPE_LENGTH (value_type (component));
+ else
+ bits = value_bitsize (component);
+
+ if (BITS_BIG_ENDIAN)
+ move_bits (value_contents_writeable (container) + offset_in_container,
+ value_bitpos (container) + bit_offset_in_container,
+ value_contents (val),
+ TYPE_LENGTH (value_type (component)) * TARGET_CHAR_BIT - bits,
+ bits);
+ else
+ move_bits (value_contents_writeable (container) + offset_in_container,
+ value_bitpos (container) + bit_offset_in_container,
+ value_contents (val), 0, bits);
+}
+
/* The value of the element of array ARR at the ARITY indices given in IND.
ARR may be either a simple array, GNAT array descriptor, or pointer
thereto. */
elt = ada_coerce_to_simple_array (arr);
- elt_type = check_typedef (VALUE_TYPE (elt));
+ elt_type = ada_check_typedef (value_type (elt));
if (TYPE_CODE (elt_type) == TYPE_CODE_ARRAY
&& TYPE_FIELD_BITSIZE (elt_type, 0) > 0)
return value_subscript_packed (elt, arity, ind);
for (k = 0; k < arity; k += 1)
{
if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY)
- error ("too many subscripts (%d expected)", k);
+ error (_("too many subscripts (%d expected)"), k);
elt = value_subscript (elt, value_pos_atr (ind[k]));
}
return elt;
struct value *idx;
if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
- error ("too many subscripts (%d expected)", k);
+ 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);
the Ada slice of HIGH-LOW+1 elements starting at index LOW. The lower
bound of this array is LOW, as per Ada rules. */
static struct value *
-ada_value_slice_ptr (struct value *array_ptr, struct type *type,
+ada_value_slice_ptr (struct value *array_ptr, struct type *type,
int low, int high)
{
- CORE_ADDR base = value_as_address (array_ptr)
+ CORE_ADDR base = value_as_address (array_ptr)
+ ((low - TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)))
* TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
- struct type *index_type =
- create_range_type (NULL, TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (type)),
+ struct type *index_type =
+ create_range_type (NULL, TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (type)),
low, high);
- struct type *slice_type =
+ struct type *slice_type =
create_array_type (NULL, TYPE_TARGET_TYPE (type), index_type);
return value_from_pointer (lookup_reference_type (slice_type), base);
}
static struct value *
ada_value_slice (struct value *array, int low, int high)
{
- struct type *type = VALUE_TYPE (array);
- struct type *index_type =
+ struct type *type = value_type (array);
+ struct type *index_type =
create_range_type (NULL, TYPE_INDEX_TYPE (type), low, high);
- struct type *slice_type =
+ struct type *slice_type =
create_array_type (NULL, TYPE_TARGET_TYPE (type), index_type);
- return value_cast (slice_type, value_slice (array, low, high-low+1));
+ return value_cast (slice_type, value_slice (array, low, high - low + 1));
}
/* If type is a record type in the form of a standard GNAT array
while (TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
arity += 1;
- type = check_typedef (TYPE_TARGET_TYPE (type));
+ type = ada_check_typedef (TYPE_TARGET_TYPE (type));
}
return arity;
p_array_type = TYPE_TARGET_TYPE (p_array_type);
while (k > 0 && p_array_type != NULL)
{
- p_array_type = check_typedef (TYPE_TARGET_TYPE (p_array_type));
+ p_array_type = ada_check_typedef (TYPE_TARGET_TYPE (p_array_type));
k -= 1;
}
return p_array_type;
struct value *
ada_array_bound (struct value *arr, int n, int which)
{
- struct type *arr_type = VALUE_TYPE (arr);
+ struct type *arr_type = value_type (arr);
if (ada_is_packed_array_type (arr_type))
return ada_array_bound (decode_packed_array (arr), n, which);
struct value *
ada_array_length (struct value *arr, int n)
{
- struct type *arr_type = check_typedef (VALUE_TYPE (arr));
+ struct type *arr_type = ada_check_typedef (value_type (arr));
if (ada_is_packed_array_type (arr_type))
return ada_array_length (decode_packed_array (arr), n);
}
else
return
- value_from_longest (builtin_type_ada_int,
+ value_from_longest (builtin_type_int,
value_as_long (desc_one_bound (desc_bounds (arr),
n, 1))
- value_as_long (desc_one_bound (desc_bounds (arr),
static struct value *
empty_array (struct type *arr_type, int low)
{
- struct type *index_type =
+ struct type *index_type =
create_range_type (NULL, TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (arr_type)),
low, low - 1);
struct type *elt_type = ada_array_element_type (arr_type, 1);
if (ada_opname_table[i].op == op)
return ada_opname_table[i].decoded;
}
- error ("Could not find operator name for opcode");
+ error (_("Could not find operator name for opcode"));
}
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;
- /* Pass one: resolve operands, saving their types and updating *pos. */
+ /* Pass one: resolve operands, saving their types and updating *pos,
+ if needed. */
switch (op)
{
case OP_FUNCALL:
nargs = longest_to_int (exp->elts[pc + 1].longconst);
break;
- case UNOP_QUAL:
- *pos += 3;
- resolve_subexp (expp, pos, 1, exp->elts[pc + 1].type);
- break;
-
case UNOP_ADDR:
*pos += 1;
resolve_subexp (expp, pos, 0, NULL);
break;
- case OP_ATR_MODULUS:
- *pos += 4;
+ case UNOP_QUAL:
+ *pos += 3;
+ resolve_subexp (expp, pos, 1, exp->elts[pc + 1].type);
break;
+ case OP_ATR_MODULUS:
case OP_ATR_SIZE:
case OP_ATR_TAG:
- *pos += 1;
- nargs = 1;
- break;
-
case OP_ATR_FIRST:
case OP_ATR_LAST:
case OP_ATR_LENGTH:
case OP_ATR_POS:
case OP_ATR_VAL:
- *pos += 1;
- nargs = 2;
- break;
-
case OP_ATR_MIN:
case OP_ATR_MAX:
- *pos += 1;
- nargs = 3;
+ 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:
if (arg1 == NULL)
resolve_subexp (expp, pos, 1, NULL);
else
- resolve_subexp (expp, pos, 1, VALUE_TYPE (arg1));
+ resolve_subexp (expp, pos, 1, value_type (arg1));
break;
}
case UNOP_CAST:
- case UNOP_IN_RANGE:
*pos += 3;
nargs = 1;
break;
case BINOP_REPEAT:
case BINOP_SUBSCRIPT:
case BINOP_COMMA:
- *pos += 1;
- nargs = 2;
- break;
case UNOP_NEG:
case UNOP_PLUS:
nargs = 1;
break;
- case OP_STRING:
- (*pos) += 3
- + BYTES_TO_EXP_ELEM (longest_to_int (exp->elts[pc + 1].longconst)
- + 1);
- break;
-
case TERNOP_SLICE:
- case TERNOP_IN_RANGE:
*pos += 1;
nargs = 3;
break;
- case BINOP_IN_BOUNDS:
- *pos += 3;
- nargs = 2;
+ case OP_STRING:
break;
default:
- error ("Unexpected operator during name resolution");
+ error (_("Unexpected operator during name resolution"));
}
argvec = (struct value * *) alloca (sizeof (struct value *) * (nargs + 1));
}
if (n_candidates == 0)
- error ("No definition found for %s",
+ error (_("No definition found for %s"),
SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
else if (n_candidates == 1)
i = 0;
SYMBOL_LINKAGE_NAME (exp->elts[pc + 2].symbol),
context_type);
if (i < 0)
- error ("Could not find a match for %s",
+ error (_("Could not find a match for %s"),
SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
}
else
{
- printf_filtered ("Multiple matches for %s\n",
+ printf_filtered (_("Multiple matches for %s\n"),
SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
user_select_syms (candidates, n_candidates, 1);
i = 0;
SYMBOL_LINKAGE_NAME (exp->elts[pc + 5].symbol),
context_type);
if (i < 0)
- error ("Could not find a match for %s",
+ error (_("Could not find a match for %s"),
SYMBOL_PRINT_NAME (exp->elts[pc + 5].symbol));
}
static int
ada_type_match (struct type *ftype, struct type *atype, int may_deref)
{
- CHECK_TYPEDEF (ftype);
- CHECK_TYPEDEF (atype);
+ ftype = ada_check_typedef (ftype);
+ atype = ada_check_typedef (atype);
if (TYPE_CODE (ftype) == TYPE_CODE_REF)
ftype = TYPE_TARGET_TYPE (ftype);
return 0;
else
{
- struct type *ftype = check_typedef (TYPE_FIELD_TYPE (func_type, i));
- struct type *atype = check_typedef (VALUE_TYPE (actuals[i]));
+ 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;
{
for (k = 0; k < nsyms; k += 1)
{
- struct type *type = check_typedef (SYMBOL_TYPE (syms[k].sym));
+ struct type *type = ada_check_typedef (SYMBOL_TYPE (syms[k].sym));
if (ada_args_match (syms[k].sym, args, nargs)
&& return_match (type, return_type))
return -1;
else if (m > 1)
{
- printf_filtered ("Multiple matches for %s\n", name);
+ printf_filtered (_("Multiple matches for %s\n"), name);
user_select_syms (syms, m, 1);
return 0;
}
int first_choice = (max_results == 1) ? 1 : 2;
if (max_results < 1)
- error ("Request to select 0 symbols!");
+ error (_("Request to select 0 symbols!"));
if (nsyms <= 1)
return nsyms;
- printf_unfiltered ("[0] cancel\n");
+ printf_unfiltered (_("[0] cancel\n"));
if (max_results > 1)
- printf_unfiltered ("[1] all\n");
+ printf_unfiltered (_("[1] all\n"));
sort_choices (syms, nsyms);
{
struct symtab_and_line sal =
find_function_start_sal (syms[i].sym, 1);
- printf_unfiltered ("[%d] %s at %s:%d\n", i + first_choice,
- SYMBOL_PRINT_NAME (syms[i].sym),
- (sal.symtab == NULL
- ? "<no source file available>"
- : sal.symtab->filename), sal.line);
+ if (sal.symtab == NULL)
+ printf_unfiltered (_("[%d] %s at <no source file available>:%d\n"),
+ i + first_choice,
+ SYMBOL_PRINT_NAME (syms[i].sym),
+ sal.line);
+ else
+ printf_unfiltered (_("[%d] %s at %s:%d\n"), i + first_choice,
+ SYMBOL_PRINT_NAME (syms[i].sym),
+ sal.symtab->filename, sal.line);
continue;
}
else
struct symtab *symtab = symtab_for_sym (syms[i].sym);
if (SYMBOL_LINE (syms[i].sym) != 0 && symtab != NULL)
- printf_unfiltered ("[%d] %s at %s:%d\n",
+ printf_unfiltered (_("[%d] %s at %s:%d\n"),
i + first_choice,
SYMBOL_PRINT_NAME (syms[i].sym),
symtab->filename, SYMBOL_LINE (syms[i].sym));
else if (is_enumeral
&& TYPE_NAME (SYMBOL_TYPE (syms[i].sym)) != NULL)
{
- printf_unfiltered ("[%d] ", i + first_choice);
+ printf_unfiltered (("[%d] "), i + first_choice);
ada_print_type (SYMBOL_TYPE (syms[i].sym), NULL,
gdb_stdout, -1, 0);
- printf_unfiltered ("'(%s) (enumeral)\n",
+ printf_unfiltered (_("'(%s) (enumeral)\n"),
SYMBOL_PRINT_NAME (syms[i].sym));
}
else if (symtab != NULL)
printf_unfiltered (is_enumeral
- ? "[%d] %s in %s (enumeral)\n"
- : "[%d] %s at %s:?\n",
+ ? _("[%d] %s in %s (enumeral)\n")
+ : _("[%d] %s at %s:?\n"),
i + first_choice,
SYMBOL_PRINT_NAME (syms[i].sym),
symtab->filename);
else
printf_unfiltered (is_enumeral
- ? "[%d] %s (enumeral)\n"
- : "[%d] %s at ?\n",
+ ? _("[%d] %s (enumeral)\n")
+ : _("[%d] %s at ?\n"),
i + first_choice,
SYMBOL_PRINT_NAME (syms[i].sym));
}
if (prompt == NULL)
prompt = ">";
- printf_unfiltered ("%s ", prompt);
+ printf_unfiltered (("%s "), prompt);
gdb_flush (gdb_stdout);
args = command_line_input ((char *) NULL, 0, annotation_suffix);
if (args == NULL)
- error_no_arg ("one or more choice numbers");
+ error_no_arg (_("one or more choice numbers"));
n_chosen = 0;
while (isspace (*args))
args += 1;
if (*args == '\0' && n_chosen == 0)
- error_no_arg ("one or more choice numbers");
+ 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");
+ error (_("Argument must be choice number"));
args = args2;
if (choice == 0)
- error ("cancelled");
+ error (_("cancelled"));
if (choice < first_choice)
{
}
if (n_chosen > max_results)
- error ("Select no more than %d of the above", max_results);
+ error (_("Select no more than %d of the above"), max_results);
return n_chosen;
}
possible_user_operator_p (enum exp_opcode op, struct value *args[])
{
struct type *type0 =
- (args[0] == NULL) ? NULL : check_typedef (VALUE_TYPE (args[0]));
+ (args[0] == NULL) ? NULL : ada_check_typedef (value_type (args[0]));
struct type *type1 =
- (args[1] == NULL) ? NULL : check_typedef (VALUE_TYPE (args[1]));
+ (args[1] == NULL) ? NULL : ada_check_typedef (value_type (args[1]));
if (type0 == NULL)
return 0;
type = SYMBOL_TYPE (sym);
if (type == NULL || TYPE_NFIELDS (type) < 1)
- error ("Improperly encoded renaming.");
+ error (_("Improperly encoded renaming."));
raw_name = TYPE_FIELD_NAME (type, 0);
len = (raw_name == NULL ? 0 : strlen (raw_name)) - 5;
if (len <= 0)
- error ("Improperly encoded renaming.");
+ error (_("Improperly encoded renaming."));
result = xmalloc (len + 1);
strncpy (result, raw_name, len);
result[len] = '\000';
return result;
}
+
\f
/* Evaluation: Function Calls */
{
if (! VALUE_LVAL (val))
{
- int len = TYPE_LENGTH (check_typedef (VALUE_TYPE (val)));
+ int len = TYPE_LENGTH (ada_check_typedef (value_type (val)));
/* The following is taken from the structure-return code in
call_function_by_hand. FIXME: Therefore, some refactoring seems
*sp = gdbarch_frame_align (current_gdbarch, *sp);
}
- write_memory (VALUE_ADDRESS (val), VALUE_CONTENTS_RAW (val), len);
+ write_memory (VALUE_ADDRESS (val), value_contents_raw (val), len);
}
return val;
convert_actual (struct value *actual, struct type *formal_type0,
CORE_ADDR *sp)
{
- struct type *actual_type = check_typedef (VALUE_TYPE (actual));
- struct type *formal_type = check_typedef (formal_type0);
+ 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
- ? check_typedef (TYPE_TARGET_TYPE (formal_type)) : formal_type;
+ ? ada_check_typedef (TYPE_TARGET_TYPE (formal_type)) : formal_type;
struct type *actual_target =
TYPE_CODE (actual_type) == TYPE_CODE_PTR
- ? check_typedef (TYPE_TARGET_TYPE (actual_type)) : actual_type;
+ ? 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)
if (VALUE_LVAL (actual) != lval_memory)
{
struct value *val;
- actual_type = check_typedef (VALUE_TYPE (actual));
+ actual_type = ada_check_typedef (value_type (actual));
val = allocate_value (actual_type);
- memcpy ((char *) VALUE_CONTENTS_RAW (val),
- (char *) VALUE_CONTENTS (actual),
+ memcpy ((char *) value_contents_raw (val),
+ (char *) value_contents (actual),
TYPE_LENGTH (actual_type));
actual = ensure_lval (val, sp);
}
struct value *bounds = allocate_value (bounds_type);
int i;
- for (i = ada_array_arity (check_typedef (VALUE_TYPE (arr))); i > 0; i -= 1)
+ for (i = ada_array_arity (ada_check_typedef (value_type (arr))); i > 0; i -= 1)
{
- modify_general_field (VALUE_CONTENTS (bounds),
+ modify_general_field (value_contents_writeable (bounds),
value_as_long (ada_array_bound (arr, i, 0)),
desc_bound_bitpos (bounds_type, i, 0),
desc_bound_bitsize (bounds_type, i, 0));
- modify_general_field (VALUE_CONTENTS (bounds),
+ modify_general_field (value_contents_writeable (bounds),
value_as_long (ada_array_bound (arr, i, 1)),
desc_bound_bitpos (bounds_type, i, 1),
desc_bound_bitsize (bounds_type, i, 1));
bounds = ensure_lval (bounds, sp);
- modify_general_field (VALUE_CONTENTS (descriptor),
+ modify_general_field (value_contents_writeable (descriptor),
VALUE_ADDRESS (ensure_lval (arr, sp)),
fat_pntr_data_bitpos (desc_type),
fat_pntr_data_bitsize (desc_type));
- modify_general_field (VALUE_CONTENTS (descriptor),
+ modify_general_field (value_contents_writeable (descriptor),
VALUE_ADDRESS (bounds),
fat_pntr_bounds_bitpos (desc_type),
fat_pntr_bounds_bitsize (desc_type));
{
int i;
- if (TYPE_NFIELDS (VALUE_TYPE (func)) == 0
- || nargs != TYPE_NFIELDS (VALUE_TYPE (func)))
+ if (TYPE_NFIELDS (value_type (func)) == 0
+ || nargs != TYPE_NFIELDS (value_type (func)))
return;
for (i = 0; i < nargs; i += 1)
args[i] =
- convert_actual (args[i], TYPE_FIELD_TYPE (VALUE_TYPE (func), i), sp);
+ convert_actual (args[i], TYPE_FIELD_TYPE (value_type (func), i), sp);
}
\f
- /* Experimental Symbol Cache Module */
-
-/* This module may well have been OBE, due to improvements in the
- symbol-table module. So until proven otherwise, it is disabled in
- the submitted public code, and may be removed from all sources
- in the future. */
-
-#ifdef GNAT_GDB
-
-/* This section implements a simple, fixed-sized hash table for those
- Ada-mode symbols that get looked up in the course of executing the user's
- commands. The size is fixed on the grounds that there are not
- likely to be all that many symbols looked up during any given
- session, regardless of the size of the symbol table. If we decide
- to go to a resizable table, let's just use the stuff from libiberty
- instead. */
-
-#define HASH_SIZE 1009
-
-struct cache_entry
-{
- const char *name;
- domain_enum namespace;
- struct symbol *sym;
- struct symtab *symtab;
- struct block *block;
- struct cache_entry *next;
-};
-
-static struct obstack cache_space;
-
-static struct cache_entry *cache[HASH_SIZE];
-
-/* Clear all entries from the symbol cache. */
-
-void
-clear_ada_sym_cache (void)
-{
- obstack_free (&cache_space, NULL);
- obstack_init (&cache_space);
- memset (cache, '\000', sizeof (cache));
-}
-
-static struct cache_entry **
-find_entry (const char *name, domain_enum namespace)
-{
- int h = msymbol_hash (name) % HASH_SIZE;
- struct cache_entry **e;
- for (e = &cache[h]; *e != NULL; e = &(*e)->next)
- {
- if (namespace == (*e)->namespace && strcmp (name, (*e)->name) == 0)
- return e;
- }
- return NULL;
-}
-
-/* Return (in SYM) the last cached definition for global or static symbol NAME
- in namespace DOMAIN. Returns 1 if entry found, 0 otherwise.
- If SYMTAB is non-NULL, store the symbol
- table in which the symbol was found there, or NULL if not found.
- *BLOCK is set to the block in which NAME is found. */
-
-static int
-lookup_cached_symbol (const char *name, domain_enum namespace,
- struct symbol **sym, struct block **block,
- struct symtab **symtab)
-{
- struct cache_entry **e = find_entry (name, namespace);
- if (e == NULL)
- return 0;
- if (sym != NULL)
- *sym = (*e)->sym;
- if (block != NULL)
- *block = (*e)->block;
- if (symtab != NULL)
- *symtab = (*e)->symtab;
- return 1;
-}
+/* Dummy definitions for an experimental caching module that is not
+ * used in the public sources. */
-/* Set the cached definition of NAME in DOMAIN to SYM in block
- BLOCK and symbol table SYMTAB. */
-
-static void
-cache_symbol (const char *name, domain_enum namespace, struct symbol *sym,
- struct block *block, struct symtab *symtab)
-{
- int h = msymbol_hash (name) % HASH_SIZE;
- char *copy;
- struct cache_entry *e =
- (struct cache_entry *) obstack_alloc (&cache_space, sizeof (*e));
- e->next = cache[h];
- cache[h] = e;
- e->name = copy = obstack_alloc (&cache_space, strlen (name) + 1);
- strcpy (copy, name);
- e->sym = sym;
- e->namespace = namespace;
- e->symtab = symtab;
- e->block = block;
-}
-
-#else
static int
lookup_cached_symbol (const char *name, domain_enum namespace,
struct symbol **sym, struct block **block,
struct block *block, struct symtab *symtab)
{
}
-#endif /* GNAT_GDB */
\f
/* Symbol Lookup */
size_t tmp;
struct ada_symbol_info *prevDefns = defns_collected (obstackp, 0);
- if (SYMBOL_TYPE (sym) != NULL)
- CHECK_TYPEDEF (SYMBOL_TYPE (sym));
+ /* Do not try to complete stub types, as the debugger is probably
+ already scanning all symbols matching a certain name at the
+ time when this function is called. Trying to replace the stub
+ type by its associated full type will cause us to restart a scan
+ which may lead to an infinite recursion. Instead, the client
+ collecting the matching symbols will end up collecting several
+ matches, with at least one of them complete. It can then filter
+ out the stub ones if needed. */
+
for (i = num_defns_collected (obstackp) - 1; i >= 0; i -= 1)
{
if (lesseq_defined_than (sym, prevDefns[i].sym))
return NULL;
}
-/* Return up minimal symbol for NAME, folded and encoded according to
- Ada conventions, or NULL if none. The last two arguments are ignored. */
-
-static struct minimal_symbol *
-ada_lookup_minimal_symbol (const char *name, const char *sfile,
- struct objfile *objf)
-{
- return ada_lookup_simple_minsym (ada_encode (name));
-}
-
/* For all subprograms that statically enclose the subprogram of the
selected frame, add symbols matching identifier NAME in DOMAIN
and their blocks to the list of data in OBSTACKP, as for
const char *name, domain_enum namespace,
int wild_match)
{
-#ifdef HAVE_ADD_SYMBOLS_FROM_ENCLOSING_PROCS
- /* Use a heuristic to find the frames of enclosing subprograms: treat the
- pointer-sized value at location 0 from the local-variable base of a
- frame as a static link, and then search up the call stack for a
- frame with that same local-variable base. */
- static struct symbol static_link_sym;
- static struct symbol *static_link;
- struct value *target_link_val;
-
- struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
- struct frame_info *frame;
-
- if (!target_has_stack)
- return;
-
- if (static_link == NULL)
- {
- /* Initialize the local variable symbol that stands for the
- static link (when there is one). */
- static_link = &static_link_sym;
- SYMBOL_LINKAGE_NAME (static_link) = "";
- SYMBOL_LANGUAGE (static_link) = language_unknown;
- SYMBOL_CLASS (static_link) = LOC_LOCAL;
- SYMBOL_DOMAIN (static_link) = VAR_DOMAIN;
- SYMBOL_TYPE (static_link) = lookup_pointer_type (builtin_type_void);
- SYMBOL_VALUE (static_link) =
- -(long) TYPE_LENGTH (SYMBOL_TYPE (static_link));
- }
-
- frame = get_selected_frame ();
- if (frame == NULL || inside_main_func (get_frame_address_in_block (frame)))
- return;
-
- target_link_val = read_var_value (static_link, frame);
- while (target_link_val != NULL
- && num_defns_collected (obstackp) == 0
- && frame_relative_level (frame) <= MAX_ENCLOSING_FRAME_LEVELS)
- {
- CORE_ADDR target_link = value_as_address (target_link_val);
-
- frame = get_prev_frame (frame);
- if (frame == NULL)
- break;
-
- if (get_frame_locals_address (frame) == target_link)
- {
- struct block *block;
-
- QUIT;
-
- block = get_frame_block (frame, 0);
- while (block != NULL && block_function (block) != NULL
- && num_defns_collected (obstackp) == 0)
- {
- QUIT;
-
- ada_add_block_symbols (obstackp, block, name, namespace,
- NULL, NULL, wild_match);
-
- block = BLOCK_SUPERBLOCK (block);
- }
- }
- }
-
- do_cleanups (old_chain);
-#endif
}
/* FIXME: The next two routines belong in symtab.c */
"_ada_" followed by NAME can be found. */
/* Do a quick check that NAME does not contain "__", since library-level
- functions names can not contain "__" in them. */
+ functions names cannot contain "__" in them. */
if (strstr (name, "__") != NULL)
return 0;
/* 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,
- but is disambiguated by user query if needed. *IS_A_FIELD_OF_THIS is
- set to 0 and *SYMTAB is set to the symbol table in which the symbol
- was found (in both cases, these assignments occur only if the
- pointers are non-null). */
-
+ choosing the first symbol if there are multiple choices.
+ *IS_A_FIELD_OF_THIS is set to 0 and *SYMTAB is set to the symbol
+ table in which the symbol was found (in both cases, these
+ assignments occur only if the pointers are non-null). */
struct symbol *
ada_lookup_symbol (const char *name, const struct block *block0,
if (n_candidates == 0)
return NULL;
- else if (n_candidates != 1)
- user_select_syms (candidates, n_candidates, 1);
if (is_a_field_of_this != NULL)
*is_a_field_of_this = 0;
*symtab = s;
return fixup_symbol_section (candidates[0].sym, objfile);
}
- return fixup_symbol_section (candidates[0].sym, NULL);
}
+ /* FIXME: brobecker/2004-11-12: I think that we should never
+ reach this point. I don't see a reason why we would not
+ find a symtab for a given block, so I suggest raising an
+ internal_error exception here. Otherwise, we end up
+ returning a symbol but no symtab, which certain parts of
+ the code that rely (indirectly) on this function do not
+ expect, eventually causing a SEGV. */
+ return fixup_symbol_section (candidates[0].sym, NULL);
}
}
return candidates[0].sym;
names (e.g., XVE) are not included here. Currently, the possible suffixes
are given by either of the regular expression:
- (__[0-9]+)?\.[0-9]+ [nested subprogram suffix, on platforms such
- as GNU/Linux]
+ (__[0-9]+)?[.$][0-9]+ [nested subprogram suffix, on platforms such
+ as GNU/Linux]
___[0-9]+ [nested subprogram suffix, on platforms such as HP/UX]
- (X[nb]*)?((\$|__)[0-9](_?[0-9]+)|___(LJM|X([FDBUP].*|R[^T]?)))?$
+ _E[0-9]+[bs]$ [protected object entry suffixes]
+ (X[nb]*)?((\$|__)[0-9](_?[0-9]+)|___(JM|LJM|X([FDBUP].*|R[^T]?)))?$
*/
static int
return 1;
}
- if (matching[0] == '.')
+ if (matching[0] == '.' || matching[0] == '$')
{
matching += 1;
while (isdigit (matching[0]))
return 1;
}
- /* ??? We should not modify STR directly, as we are doing below. This
- is fine in this case, but may become problematic later if we find
- that this alternative did not work, and want to try matching
- another one from the begining of STR. Since we modified it, we
- won't be able to find the begining of the string anymore! */
- if (str[0] == 'X')
+#if 0
+ /* FIXME: brobecker/2005-09-23: Protected Object subprograms end
+ with a N at the end. Unfortunately, the compiler uses the same
+ convention for other internal types it creates. So treating
+ all entity names that end with an "N" as a name suffix causes
+ some regressions. For instance, consider the case of an enumerated
+ type. To support the 'Image attribute, it creates an array whose
+ name ends with N.
+ Having a single character like this as a suffix carrying some
+ information is a bit risky. Perhaps we should change the encoding
+ to be something like "_N" instead. In the meantime, do not do
+ the following check. */
+ /* Protected Object Subprograms */
+ if (len == 1 && str [0] == 'N')
+ return 1;
+#endif
+
+ /* _E[0-9]+[bs]$ */
+ if (len > 3 && str[0] == '_' && str [1] == 'E' && isdigit (str[2]))
+ {
+ matching = str + 3;
+ while (isdigit (matching[0]))
+ matching += 1;
+ if ((matching[0] == 'b' || matching[0] == 's')
+ && matching [1] == '\0')
+ return 1;
+ }
+
+ /* ??? We should not modify STR directly, as we are doing below. This
+ is fine in this case, but may become problematic later if we find
+ that this alternative did not work, and want to try matching
+ another one from the begining of STR. Since we modified it, we
+ won't be able to find the begining of the string anymore! */
+ if (str[0] == 'X')
{
str += 1;
while (str[0] != '_' && str[0] != '\0')
return 0;
if (str[2] == '_')
{
+ if (strcmp (str + 3, "JM") == 0)
+ return 1;
+ /* FIXME: brobecker/2004-09-30: GNAT will soon stop using
+ the LJM suffix in favor of the JM one. But we will
+ still accept LJM as a valid suffix for a reasonable
+ amount of time, just to allow ourselves to debug programs
+ compiled using an older version of GNAT. */
if (strcmp (str + 3, "LJM") == 0)
return 1;
if (str[3] != 'X')
return (str[0] == '\0');
}
+/* Return non-zero if NAME0 is a valid match when doing wild matching.
+ Certain symbols appear at first to match, except that they turn out
+ not to follow the Ada encoding and hence should not be used as a wild
+ match of a given pattern. */
+
+static int
+is_valid_name_for_wild_match (const char *name0)
+{
+ const char *decoded_name = ada_decode (name0);
+ int i;
+
+ for (i=0; decoded_name[i] != '\0'; i++)
+ if (isalpha (decoded_name[i]) && !islower (decoded_name[i]))
+ return 0;
+
+ return 1;
+}
+
/* True if NAME represents a name of the form A1.A2....An, n>=1 and
PATN[0..PATN_LEN-1] = Ak.Ak+1.....An for some k >= 1. Ignores
informational suffixes of NAME (i.e., for which is_name_suffix is
{
if (strncmp (patn, name, patn_len) == 0
&& is_name_suffix (name + patn_len))
- return 1;
+ return (is_valid_name_for_wild_match (name0));
do
{
name += 1;
fixup_symbol_section (arg_sym, objfile),
block, symtab);
}
-
- if (!wild)
- {
- arg_sym = NULL;
- found_sym = 0;
-
- ALL_BLOCK_SYMBOLS (block, iter, sym)
- {
- if (SYMBOL_DOMAIN (sym) == domain)
- {
- int cmp;
-
- cmp = (int) '_' - (int) SYMBOL_LINKAGE_NAME (sym)[0];
- if (cmp == 0)
- {
- cmp = strncmp ("_ada_", SYMBOL_LINKAGE_NAME (sym), 5);
- if (cmp == 0)
- cmp = strncmp (name, SYMBOL_LINKAGE_NAME (sym) + 5,
- name_len);
- }
-
- if (cmp == 0
- && is_name_suffix (SYMBOL_LINKAGE_NAME (sym) + name_len + 5))
- {
- switch (SYMBOL_CLASS (sym))
- {
- case LOC_ARG:
- case LOC_LOCAL_ARG:
- case LOC_REF_ARG:
- case LOC_REGPARM:
- case LOC_REGPARM_ADDR:
- case LOC_BASEREG_ARG:
- case LOC_COMPUTED_ARG:
- arg_sym = sym;
- break;
- case LOC_UNRESOLVED:
- break;
- default:
- found_sym = 1;
- add_defn_to_vec (obstackp,
- fixup_symbol_section (sym, objfile),
- block, symtab);
- break;
- }
- }
- }
- end_loop2:;
- }
-
- /* NOTE: This really shouldn't be needed for _ada_ symbols.
- They aren't parameters, right? */
- if (!found_sym && arg_sym != NULL)
- {
- add_defn_to_vec (obstackp,
- fixup_symbol_section (arg_sym, objfile),
- block, symtab);
- }
- }
-}
-\f
-#ifdef GNAT_GDB
-
- /* Symbol Completion */
-
-/* If SYM_NAME is a completion candidate for TEXT, return this symbol
- name in a form that's appropriate for the completion. The result
- does not need to be deallocated, but is only good until the next call.
-
- TEXT_LEN is equal to the length of TEXT.
- Perform a wild match if WILD_MATCH is set.
- ENCODED should be set if TEXT represents the start of a symbol name
- in its encoded form. */
-
-static const char *
-symbol_completion_match (const char *sym_name,
- const char *text, int text_len,
- int wild_match, int encoded)
-{
- char *result;
- const int verbatim_match = (text[0] == '<');
- int match = 0;
-
- if (verbatim_match)
- {
- /* Strip the leading angle bracket. */
- text = text + 1;
- text_len--;
- }
-
- /* First, test against the fully qualified name of the symbol. */
-
- if (strncmp (sym_name, text, text_len) == 0)
- match = 1;
-
- if (match && !encoded)
- {
- /* 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;
- int has_angle_bracket;
-
- sym_name = ada_decode (sym_name);
- has_angle_bracket = (sym_name[0] == '<');
- match = (has_angle_bracket == verbatim_match);
- sym_name = sym_name_copy;
- }
-
- if (match && !verbatim_match)
- {
- /* When doing non-verbatim match, another check that needs to
- be done is to verify that the potentially matching symbol name
- does not include capital letters, because the ada-mode would
- not be able to understand these symbol names without the
- angle bracket notation. */
- const char *tmp;
-
- for (tmp = sym_name; *tmp != '\0' && !isupper (*tmp); tmp++);
- if (*tmp != '\0')
- match = 0;
- }
-
- /* Second: Try wild matching... */
-
- if (!match && wild_match)
- {
- /* 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));
-
- if (strncmp (sym_name, text, text_len) == 0)
- match = 1;
- }
-
- /* Finally: If we found a mach, prepare the result to return. */
-
- if (!match)
- return NULL;
-
- if (verbatim_match)
- sym_name = add_angle_brackets (sym_name);
-
- if (!encoded)
- sym_name = ada_decode (sym_name);
-
- return sym_name;
-}
-
-/* A companion function to ada_make_symbol_completion_list().
- Check if SYM_NAME represents a symbol which name would be suitable
- to complete TEXT (TEXT_LEN is the length of TEXT), in which case
- it is appended at the end of the given string vector SV.
-
- ORIG_TEXT is the string original string from the user command
- that needs to be completed. WORD is the entire command on which
- completion should be performed. These two parameters are used to
- determine which part of the symbol name should be added to the
- completion vector.
- if WILD_MATCH is set, then wild matching is performed.
- ENCODED should be set if TEXT represents a symbol name in its
- encoded formed (in which case the completion should also be
- encoded). */
-
-static void
-symbol_completion_add (struct string_vector *sv,
- const char *sym_name,
- const char *text, int text_len,
- const char *orig_text, const char *word,
- int wild_match, int encoded)
-{
- const char *match = symbol_completion_match (sym_name, text, text_len,
- wild_match, encoded);
- char *completion;
-
- if (match == NULL)
- return;
-
- /* We found a match, so add the appropriate completion to the given
- string vector. */
-
- if (word == orig_text)
- {
- completion = xmalloc (strlen (match) + 5);
- strcpy (completion, match);
- }
- else if (word > orig_text)
- {
- /* Return some portion of sym_name. */
- completion = xmalloc (strlen (match) + 5);
- strcpy (completion, match + (word - orig_text));
- }
- else
- {
- /* Return some of ORIG_TEXT plus sym_name. */
- completion = xmalloc (strlen (match) + (orig_text - word) + 5);
- strncpy (completion, word, orig_text - word);
- completion[orig_text - word] = '\0';
- strcat (completion, match);
- }
-
- string_vector_append (sv, completion);
-}
-
-/* Return a list of possible symbol names completing TEXT0. The list
- is NULL terminated. WORD is the entire command on which completion
- is made. */
-
-char **
-ada_make_symbol_completion_list (const char *text0, const char *word)
-{
- /* Note: This function is almost a copy of make_symbol_completion_list(),
- except it has been adapted for Ada. It is somewhat of a shame to
- duplicate so much code, but we don't really have the infrastructure
- yet to develop a language-aware version of he symbol completer... */
- char *text;
- int text_len;
- int wild_match;
- int encoded;
- struct string_vector result = xnew_string_vector (128);
- struct symbol *sym;
- struct symtab *s;
- struct partial_symtab *ps;
- struct minimal_symbol *msymbol;
- struct objfile *objfile;
- struct block *b, *surrounding_static_block = 0;
- int i;
- struct dict_iterator iter;
-
- if (text0[0] == '<')
- {
- text = xstrdup (text0);
- make_cleanup (xfree, text);
- text_len = strlen (text);
- wild_match = 0;
- encoded = 1;
- }
- else
- {
- text = xstrdup (ada_encode (text0));
- make_cleanup (xfree, text);
- text_len = strlen (text);
- for (i = 0; i < text_len; i++)
- text[i] = tolower (text[i]);
-
- /* FIXME: brobecker/2003-09-17: When we get rid of ADA_RETAIN_DOTS,
- we can restrict the wild_match check to searching "__" only. */
- wild_match = (strstr (text0, "__") == NULL
- && strchr (text0, '.') == NULL);
- encoded = (strstr (text0, "__") != NULL);
- }
-
- /* First, look at the partial symtab symbols. */
- ALL_PSYMTABS (objfile, ps)
- {
- struct partial_symbol **psym;
-
- /* If the psymtab's been read in we'll get it when we search
- through the blockvector. */
- if (ps->readin)
- continue;
-
- for (psym = objfile->global_psymbols.list + ps->globals_offset;
- psym < (objfile->global_psymbols.list + ps->globals_offset
- + ps->n_global_syms); psym++)
- {
- QUIT;
- symbol_completion_add (&result, SYMBOL_LINKAGE_NAME (*psym),
- text, text_len, text0, word,
- wild_match, encoded);
- }
-
- for (psym = objfile->static_psymbols.list + ps->statics_offset;
- psym < (objfile->static_psymbols.list + ps->statics_offset
- + ps->n_static_syms); psym++)
- {
- QUIT;
- symbol_completion_add (&result, SYMBOL_LINKAGE_NAME (*psym),
- text, text_len, text0, word,
- wild_match, encoded);
- }
- }
-
- /* At this point scan through the misc symbol vectors and add each
- symbol you find to the list. Eventually we want to ignore
- anything that isn't a text symbol (everything else will be
- handled by the psymtab code above). */
-
- ALL_MSYMBOLS (objfile, msymbol)
- {
- QUIT;
- symbol_completion_add (&result, SYMBOL_LINKAGE_NAME (msymbol),
- text, text_len, text0, word, wild_match, encoded);
- }
-
- /* Search upwards from currently selected frame (so that we can
- complete on local vars. */
-
- for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
- {
- if (!BLOCK_SUPERBLOCK (b))
- surrounding_static_block = b; /* For elmin of dups */
-
- ALL_BLOCK_SYMBOLS (b, iter, sym)
- {
- symbol_completion_add (&result, SYMBOL_LINKAGE_NAME (sym),
- text, text_len, text0, word,
- wild_match, encoded);
- }
- }
-
- /* Go through the symtabs and check the externs and statics for
- symbols which match. */
-
- ALL_SYMTABS (objfile, s)
- {
- QUIT;
- b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
- ALL_BLOCK_SYMBOLS (b, iter, sym)
- {
- symbol_completion_add (&result, SYMBOL_LINKAGE_NAME (sym),
- text, text_len, text0, word,
- wild_match, encoded);
- }
- }
-
- ALL_SYMTABS (objfile, s)
- {
- QUIT;
- b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
- /* Don't do this block twice. */
- if (b == surrounding_static_block)
- continue;
- ALL_BLOCK_SYMBOLS (b, iter, sym)
- {
- symbol_completion_add (&result, SYMBOL_LINKAGE_NAME (sym),
- text, text_len, text0, word,
- wild_match, encoded);
- }
- }
-
- /* Append the closing NULL entry. */
- string_vector_append (&result, NULL);
-
- return (result.array);
-}
-
-#endif /* GNAT_GDB */
-\f
-#ifdef GNAT_GDB
- /* Breakpoint-related */
-
-/* Assuming that LINE is pointing at the beginning of an argument to
- 'break', return a pointer to the delimiter for the initial segment
- of that name. This is the first ':', ' ', or end of LINE. */
-
-char *
-ada_start_decode_line_1 (char *line)
-{
- /* NOTE: strpbrk would be more elegant, but I am reluctant to be
- the first to use such a library function in GDB code. */
- char *p;
- for (p = line; *p != '\000' && *p != ' ' && *p != ':'; p += 1)
- ;
- return p;
-}
-
-/* *SPEC points to a function and line number spec (as in a break
- command), following any initial file name specification.
-
- Return all symbol table/line specfications (sals) consistent with the
- information in *SPEC and FILE_TABLE in the following sense:
- + FILE_TABLE is null, or the sal refers to a line in the file
- named by FILE_TABLE.
- + If *SPEC points to an argument with a trailing ':LINENUM',
- then the sal refers to that line (or one following it as closely as
- possible).
- + If *SPEC does not start with '*', the sal is in a function with
- that name.
-
- Returns with 0 elements if no matching non-minimal symbols found.
-
- If *SPEC begins with a function name of the form <NAME>, then NAME
- is taken as a literal name; otherwise the function name is subject
- to the usual encoding.
-
- *SPEC is updated to point after the function/line number specification.
-
- FUNFIRSTLINE is non-zero if we desire the first line of real code
- in each function.
-
- If CANONICAL is non-NULL, and if any of the sals require a
- 'canonical line spec', then *CANONICAL is set to point to an array
- of strings, corresponding to and equal in length to the returned
- list of sals, such that (*CANONICAL)[i] is non-null and contains a
- canonical line spec for the ith returned sal, if needed. If no
- canonical line specs are required and CANONICAL is non-null,
- *CANONICAL is set to NULL.
-
- A 'canonical line spec' is simply a name (in the format of the
- breakpoint command) that uniquely identifies a breakpoint position,
- with no further contextual information or user selection. It is
- needed whenever the file name, function name, and line number
- information supplied is insufficient for this unique
- identification. Currently overloaded functions, the name '*',
- or static functions without a filename yield a canonical line spec.
- The array and the line spec strings are allocated on the heap; it
- is the caller's responsibility to free them. */
-
-struct symtabs_and_lines
-ada_finish_decode_line_1 (char **spec, struct symtab *file_table,
- int funfirstline, char ***canonical)
-{
- struct ada_symbol_info *symbols;
- const struct block *block;
- int n_matches, i, line_num;
- struct symtabs_and_lines selected;
- struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
- char *name;
- int is_quoted;
-
- int len;
- char *lower_name;
- char *unquoted_name;
-
- if (file_table == NULL)
- block = block_static_block (get_selected_block (0));
- else
- block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_table), STATIC_BLOCK);
-
- if (canonical != NULL)
- *canonical = (char **) NULL;
-
- is_quoted = (**spec && strchr (get_gdb_completer_quote_characters (),
- **spec) != NULL);
-
- name = *spec;
- if (**spec == '*')
- *spec += 1;
- else
- {
- if (is_quoted)
- *spec = skip_quoted (*spec);
- while (**spec != '\000'
- && !strchr (ada_completer_word_break_characters, **spec))
- *spec += 1;
- }
- len = *spec - name;
-
- line_num = -1;
- if (file_table != NULL && (*spec)[0] == ':' && isdigit ((*spec)[1]))
- {
- line_num = strtol (*spec + 1, spec, 10);
- while (**spec == ' ' || **spec == '\t')
- *spec += 1;
- }
-
- if (name[0] == '*')
- {
- if (line_num == -1)
- error ("Wild-card function with no line number or file name.");
-
- return ada_sals_for_line (file_table->filename, line_num,
- funfirstline, canonical, 0);
- }
-
- if (name[0] == '\'')
- {
- name += 1;
- len -= 2;
- }
-
- if (name[0] == '<')
- {
- unquoted_name = (char *) alloca (len - 1);
- memcpy (unquoted_name, name + 1, len - 2);
- unquoted_name[len - 2] = '\000';
- lower_name = NULL;
- }
- else
- {
- unquoted_name = (char *) alloca (len + 1);
- memcpy (unquoted_name, name, len);
- unquoted_name[len] = '\000';
- lower_name = (char *) alloca (len + 1);
- for (i = 0; i < len; i += 1)
- lower_name[i] = tolower (name[i]);
- lower_name[len] = '\000';
- }
-
- n_matches = 0;
- if (lower_name != NULL)
- n_matches = ada_lookup_symbol_list (ada_encode (lower_name), block,
- VAR_DOMAIN, &symbols);
- if (n_matches == 0)
- n_matches = ada_lookup_symbol_list (unquoted_name, block,
- VAR_DOMAIN, &symbols);
- if (n_matches == 0 && line_num >= 0)
- error ("No line number information found for %s.", unquoted_name);
- else if (n_matches == 0)
- {
-#ifdef HPPA_COMPILER_BUG
- /* FIXME: See comment in symtab.c::decode_line_1 */
-#undef volatile
- volatile struct symtab_and_line val;
-#define volatile /*nothing */
-#else
- struct symtab_and_line val;
-#endif
- struct minimal_symbol *msymbol;
-
- init_sal (&val);
-
- msymbol = NULL;
- if (lower_name != NULL)
- msymbol = ada_lookup_simple_minsym (ada_encode (lower_name));
- if (msymbol == NULL)
- msymbol = ada_lookup_simple_minsym (unquoted_name);
- if (msymbol != NULL)
- {
- val.pc = SYMBOL_VALUE_ADDRESS (msymbol);
- val.section = SYMBOL_BFD_SECTION (msymbol);
- if (funfirstline)
- {
- val.pc = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
- val.pc,
- ¤t_target);
- SKIP_PROLOGUE (val.pc);
- }
- selected.sals = (struct symtab_and_line *)
- xmalloc (sizeof (struct symtab_and_line));
- selected.sals[0] = val;
- selected.nelts = 1;
- return selected;
- }
-
- if (!have_full_symbols ()
- && !have_partial_symbols () && !have_minimal_symbols ())
- error ("No symbol table is loaded. Use the \"file\" command.");
-
- error ("Function \"%s\" not defined.", unquoted_name);
- return selected; /* for lint */
- }
-
- if (line_num >= 0)
- {
- struct symtabs_and_lines best_sal =
- find_sal_from_funcs_and_line (file_table->filename, line_num,
- symbols, n_matches);
- if (funfirstline)
- adjust_pc_past_prologue (&best_sal.sals[0].pc);
- return best_sal;
- }
- else
- {
- selected.nelts = user_select_syms (symbols, n_matches, n_matches);
- }
-
- selected.sals = (struct symtab_and_line *)
- xmalloc (sizeof (struct symtab_and_line) * selected.nelts);
- memset (selected.sals, 0, selected.nelts * sizeof (selected.sals[i]));
- make_cleanup (xfree, selected.sals);
-
- i = 0;
- while (i < selected.nelts)
- {
- if (SYMBOL_CLASS (symbols[i].sym) == LOC_BLOCK)
- selected.sals[i]
- = find_function_start_sal (symbols[i].sym, funfirstline);
- else if (SYMBOL_LINE (symbols[i].sym) != 0)
- {
- selected.sals[i].symtab =
- symbols[i].symtab
- ? symbols[i].symtab : symtab_for_sym (symbols[i].sym);
- selected.sals[i].line = SYMBOL_LINE (symbols[i].sym);
- }
- else if (line_num >= 0)
- {
- /* Ignore this choice */
- symbols[i] = symbols[selected.nelts - 1];
- selected.nelts -= 1;
- continue;
- }
- else
- error ("Line number not known for symbol \"%s\"", unquoted_name);
- i += 1;
- }
-
- if (canonical != NULL && (line_num >= 0 || n_matches > 1))
- {
- *canonical = (char **) xmalloc (sizeof (char *) * selected.nelts);
- for (i = 0; i < selected.nelts; i += 1)
- (*canonical)[i] =
- extended_canonical_line_spec (selected.sals[i],
- SYMBOL_PRINT_NAME (symbols[i].sym));
- }
-
- discard_cleanups (old_chain);
- return selected;
-}
-
-/* The (single) sal corresponding to line LINE_NUM in a symbol table
- with file name FILENAME that occurs in one of the functions listed
- in the symbol fields of SYMBOLS[0 .. NSYMS-1]. */
-
-static struct symtabs_and_lines
-find_sal_from_funcs_and_line (const char *filename, int line_num,
- struct ada_symbol_info *symbols, int nsyms)
-{
- struct symtabs_and_lines sals;
- int best_index, best;
- struct linetable *best_linetable;
- struct objfile *objfile;
- struct symtab *s;
- struct symtab *best_symtab;
-
- read_all_symtabs (filename);
-
- best_index = 0;
- best_linetable = NULL;
- best_symtab = NULL;
- best = 0;
- ALL_SYMTABS (objfile, s)
- {
- struct linetable *l;
- int ind, exact;
-
- QUIT;
-
- if (strcmp (filename, s->filename) != 0)
- continue;
- l = LINETABLE (s);
- ind = find_line_in_linetable (l, line_num, symbols, nsyms, &exact);
- if (ind >= 0)
- {
- if (exact)
- {
- best_index = ind;
- best_linetable = l;
- best_symtab = s;
- goto done;
- }
- if (best == 0 || l->item[ind].line < best)
- {
- best = l->item[ind].line;
- best_index = ind;
- best_linetable = l;
- best_symtab = s;
- }
- }
- }
-
- if (best == 0)
- error ("Line number not found in designated function.");
-
-done:
-
- sals.nelts = 1;
- sals.sals = (struct symtab_and_line *) xmalloc (sizeof (sals.sals[0]));
-
- init_sal (&sals.sals[0]);
-
- sals.sals[0].line = best_linetable->item[best_index].line;
- sals.sals[0].pc = best_linetable->item[best_index].pc;
- sals.sals[0].symtab = best_symtab;
-
- return sals;
-}
-
-/* Return the index in LINETABLE of the best match for LINE_NUM whose
- pc falls within one of the functions denoted by the symbol fields
- of SYMBOLS[0..NSYMS-1]. Set *EXACTP to 1 if the match is exact,
- and 0 otherwise. */
-
-static int
-find_line_in_linetable (struct linetable *linetable, int line_num,
- struct ada_symbol_info *symbols, int nsyms,
- int *exactp)
-{
- int i, len, best_index, best;
-
- if (line_num <= 0 || linetable == NULL)
- return -1;
-
- len = linetable->nitems;
- for (i = 0, best_index = -1, best = 0; i < len; i += 1)
- {
- int k;
- struct linetable_entry *item = &(linetable->item[i]);
-
- for (k = 0; k < nsyms; k += 1)
- {
- if (symbols[k].sym != NULL
- && SYMBOL_CLASS (symbols[k].sym) == LOC_BLOCK
- && item->pc >= BLOCK_START (SYMBOL_BLOCK_VALUE (symbols[k].sym))
- && item->pc < BLOCK_END (SYMBOL_BLOCK_VALUE (symbols[k].sym)))
- goto candidate;
- }
- continue;
-
- candidate:
-
- if (item->line == line_num)
- {
- *exactp = 1;
- return i;
- }
-
- if (item->line > line_num && (best == 0 || item->line < best))
- {
- best = item->line;
- best_index = i;
- }
- }
-
- *exactp = 0;
- return best_index;
-}
-
-/* Find the smallest k >= LINE_NUM such that k is a line number in
- LINETABLE, and k falls strictly within a named function that begins at
- or before LINE_NUM. Return -1 if there is no such k. */
-
-static int
-nearest_line_number_in_linetable (struct linetable *linetable, int line_num)
-{
- int i, len, best;
-
- if (line_num <= 0 || linetable == NULL || linetable->nitems == 0)
- return -1;
- len = linetable->nitems;
-
- i = 0;
- best = INT_MAX;
- while (i < len)
- {
- struct linetable_entry *item = &(linetable->item[i]);
-
- if (item->line >= line_num && item->line < best)
- {
- char *func_name;
- CORE_ADDR start, end;
-
- func_name = NULL;
- find_pc_partial_function (item->pc, &func_name, &start, &end);
-
- if (func_name != NULL && item->pc < end)
- {
- if (item->line == line_num)
- return line_num;
- else
- {
- struct symbol *sym =
- standard_lookup (func_name, NULL, VAR_DOMAIN);
- if (is_plausible_func_for_line (sym, line_num))
- best = item->line;
- else
- {
- do
- i += 1;
- while (i < len && linetable->item[i].pc < end);
- continue;
- }
- }
- }
- }
-
- i += 1;
- }
-
- return (best == INT_MAX) ? -1 : best;
-}
-
-
-/* Return the next higher index, k, into LINETABLE such that k > IND,
- entry k in LINETABLE has a line number equal to LINE_NUM, k
- corresponds to a PC that is in a function different from that
- corresponding to IND, and falls strictly within a named function
- that begins at a line at or preceding STARTING_LINE.
- Return -1 if there is no such k.
- IND == -1 corresponds to no function. */
-
-static int
-find_next_line_in_linetable (struct linetable *linetable, int line_num,
- int starting_line, int ind)
-{
- int i, len;
-
- if (line_num <= 0 || linetable == NULL || ind >= linetable->nitems)
- return -1;
- len = linetable->nitems;
-
- if (ind >= 0)
- {
- CORE_ADDR start, end;
-
- if (find_pc_partial_function (linetable->item[ind].pc,
- (char **) NULL, &start, &end))
- {
- while (ind < len && linetable->item[ind].pc < end)
- ind += 1;
- }
- else
- ind += 1;
- }
- else
- ind = 0;
-
- i = ind;
- while (i < len)
- {
- struct linetable_entry *item = &(linetable->item[i]);
-
- if (item->line >= line_num)
- {
- char *func_name;
- CORE_ADDR start, end;
-
- func_name = NULL;
- find_pc_partial_function (item->pc, &func_name, &start, &end);
-
- if (func_name != NULL && item->pc < end)
- {
- if (item->line == line_num)
- {
- struct symbol *sym =
- standard_lookup (func_name, NULL, VAR_DOMAIN);
- if (is_plausible_func_for_line (sym, starting_line))
- return i;
- else
- {
- while ((i + 1) < len && linetable->item[i + 1].pc < end)
- i += 1;
- }
- }
- }
- }
- i += 1;
- }
-
- return -1;
-}
-
-/* True iff function symbol SYM starts somewhere at or before line #
- LINE_NUM. */
-
-static int
-is_plausible_func_for_line (struct symbol *sym, int line_num)
-{
- struct symtab_and_line start_sal;
-
- if (sym == NULL)
- return 0;
-
- start_sal = find_function_start_sal (sym, 0);
-
- return (start_sal.line != 0 && line_num >= start_sal.line);
-}
-
-/* Read in all symbol tables corresponding to partial symbol tables
- with file name FILENAME. */
-
-static void
-read_all_symtabs (const char *filename)
-{
- struct partial_symtab *ps;
- struct objfile *objfile;
-
- ALL_PSYMTABS (objfile, ps)
- {
- QUIT;
-
- if (strcmp (filename, ps->filename) == 0)
- PSYMTAB_TO_SYMTAB (ps);
- }
-}
-
-/* All sals corresponding to line LINE_NUM in a symbol table from file
- FILENAME, as filtered by the user. Filter out any lines that
- reside in functions with "suppressed" names (not corresponding to
- explicit Ada functions), if there is at least one in a function
- with a non-suppressed name. If CANONICAL is not null, set
- it to a corresponding array of canonical line specs.
- If ONE_LOCATION_ONLY is set and several matches are found for
- the given location, then automatically select the first match found
- instead of asking the user which instance should be returned. */
-
-struct symtabs_and_lines
-ada_sals_for_line (const char *filename, int line_num,
- int funfirstline, char ***canonical, int one_location_only)
-{
- struct symtabs_and_lines result;
- struct objfile *objfile;
- struct symtab *s;
- struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
- size_t len;
-
- read_all_symtabs (filename);
-
- result.sals =
- (struct symtab_and_line *) xmalloc (4 * sizeof (result.sals[0]));
- result.nelts = 0;
- len = 4;
- make_cleanup (free_current_contents, &result.sals);
-
- ALL_SYMTABS (objfile, s)
- {
- int ind, target_line_num;
-
- QUIT;
-
- if (strcmp (s->filename, filename) != 0)
- continue;
-
- target_line_num =
- nearest_line_number_in_linetable (LINETABLE (s), line_num);
- if (target_line_num == -1)
- continue;
-
- ind = -1;
- while (1)
- {
- ind =
- find_next_line_in_linetable (LINETABLE (s),
- target_line_num, line_num, ind);
-
- if (ind < 0)
- break;
-
- GROW_VECT (result.sals, len, result.nelts + 1);
- init_sal (&result.sals[result.nelts]);
- result.sals[result.nelts].line = line_num;
- result.sals[result.nelts].pc = LINETABLE (s)->item[ind].pc;
- result.sals[result.nelts].symtab = s;
-
- if (funfirstline)
- adjust_pc_past_prologue (&result.sals[result.nelts].pc);
-
- result.nelts += 1;
- }
- }
-
- if (canonical != NULL || result.nelts > 1)
- {
- int k, j, n;
- char **func_names = (char **) alloca (result.nelts * sizeof (char *));
- int first_choice = (result.nelts > 1) ? 2 : 1;
- int *choices = (int *) alloca (result.nelts * sizeof (int));
-
- for (k = 0; k < result.nelts; k += 1)
- {
- find_pc_partial_function (result.sals[k].pc, &func_names[k],
- (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
- if (func_names[k] == NULL)
- error ("Could not find function for one or more breakpoints.");
- }
-
- /* Remove suppressed names, unless all are suppressed. */
- for (j = 0; j < result.nelts; j += 1)
- if (!is_suppressed_name (func_names[j]))
- {
- /* At least one name is unsuppressed, so remove all
- suppressed names. */
- for (k = n = 0; k < result.nelts; k += 1)
- if (!is_suppressed_name (func_names[k]))
- {
- func_names[n] = func_names[k];
- result.sals[n] = result.sals[k];
- n += 1;
- }
- result.nelts = n;
- break;
- }
-
- if (result.nelts > 1)
- {
- if (one_location_only)
- {
- /* Automatically select the first of all possible choices. */
- n = 1;
- choices[0] = 0;
- }
- else
- {
- printf_unfiltered ("[0] cancel\n");
- if (result.nelts > 1)
- printf_unfiltered ("[1] all\n");
- for (k = 0; k < result.nelts; k += 1)
- printf_unfiltered ("[%d] %s\n", k + first_choice,
- ada_decode (func_names[k]));
-
- n = get_selections (choices, result.nelts, result.nelts,
- result.nelts > 1, "instance-choice");
- }
-
- for (k = 0; k < n; k += 1)
- {
- result.sals[k] = result.sals[choices[k]];
- func_names[k] = func_names[choices[k]];
- }
- result.nelts = n;
- }
-
- if (canonical != NULL && result.nelts == 0)
- *canonical = NULL;
- else if (canonical != NULL)
- {
- *canonical = (char **) xmalloc (result.nelts * sizeof (char **));
- make_cleanup (xfree, *canonical);
- for (k = 0; k < result.nelts; k += 1)
- {
- (*canonical)[k] =
- extended_canonical_line_spec (result.sals[k], func_names[k]);
- if ((*canonical)[k] == NULL)
- error ("Could not locate one or more breakpoints.");
- make_cleanup (xfree, (*canonical)[k]);
- }
- }
- }
-
- if (result.nelts == 0)
- {
- do_cleanups (old_chain);
- result.sals = NULL;
- }
- else
- discard_cleanups (old_chain);
- return result;
-}
-
-
-/* A canonical line specification of the form FILE:NAME:LINENUM for
- symbol table and line data SAL. NULL if insufficient
- information. The caller is responsible for releasing any space
- allocated. */
-
-static char *
-extended_canonical_line_spec (struct symtab_and_line sal, const char *name)
-{
- char *r;
-
- if (sal.symtab == NULL || sal.symtab->filename == NULL || sal.line <= 0)
- return NULL;
-
- r = (char *) xmalloc (strlen (name) + strlen (sal.symtab->filename)
- + sizeof (sal.line) * 3 + 3);
- sprintf (r, "%s:'%s':%d", sal.symtab->filename, name, sal.line);
- return r;
-}
-
-/* Return type of Ada breakpoint associated with bp_stat:
- 0 if not an Ada-specific breakpoint, 1 for break on specific exception,
- 2 for break on unhandled exception, 3 for assert. */
-
-static int
-ada_exception_breakpoint_type (bpstat bs)
-{
- return ((!bs || !bs->breakpoint_at) ? 0
- : bs->breakpoint_at->break_on_exception);
-}
-
-/* True iff FRAME is very likely to be that of a function that is
- part of the runtime system. This is all very heuristic, but is
- intended to be used as advice as to what frames are uninteresting
- to most users. */
-
-static int
-is_known_support_routine (struct frame_info *frame)
-{
- struct frame_info *next_frame = get_next_frame (frame);
- /* If frame is not innermost, that normally means that frame->pc
- points to *after* the call instruction, and we want to get the line
- containing the call, never the next line. But if the next frame is
- a signal_handler_caller or a dummy frame, then the next frame was
- not entered as the result of a call, and we want to get the line
- containing frame->pc. */
- const int pc_is_after_call =
- next_frame != NULL
- && get_frame_type (next_frame) != SIGTRAMP_FRAME
- && get_frame_type (next_frame) != DUMMY_FRAME;
- struct symtab_and_line sal
- = find_pc_line (get_frame_pc (frame), pc_is_after_call);
- char *func_name;
- int i;
- struct stat st;
-
- /* The heuristic:
- 1. The symtab is null (indicating no debugging symbols)
- 2. The symtab's filename does not exist.
- 3. The object file's name is one of the standard libraries.
- 4. The symtab's file name has the form of an Ada library source file.
- 5. The function at frame's PC has a GNAT-compiler-generated name. */
-
- if (sal.symtab == NULL)
- return 1;
-
- /* On some systems (e.g. VxWorks), the kernel contains debugging
- symbols; in this case, the filename referenced by these symbols
- does not exists. */
-
- if (stat (sal.symtab->filename, &st))
- return 1;
-
- for (i = 0; known_runtime_file_name_patterns[i] != NULL; i += 1)
- {
- re_comp (known_runtime_file_name_patterns[i]);
- if (re_exec (sal.symtab->filename))
- return 1;
- }
- if (sal.symtab->objfile != NULL)
- {
- for (i = 0; known_runtime_file_name_patterns[i] != NULL; i += 1)
- {
- re_comp (known_runtime_file_name_patterns[i]);
- if (re_exec (sal.symtab->objfile->name))
- return 1;
- }
- }
-
- /* If the frame PC points after the call instruction, then we need to
- decrement it in order to search for the function associated to this
- PC. Otherwise, if the associated call was the last instruction of
- the function, we might either find the wrong function or even fail
- during the function name lookup. */
- if (pc_is_after_call)
- func_name = function_name_from_pc (get_frame_pc (frame) - 1);
- else
- func_name = function_name_from_pc (get_frame_pc (frame));
-
- if (func_name == NULL)
- return 1;
-
- for (i = 0; known_auxiliary_function_name_patterns[i] != NULL; i += 1)
- {
- re_comp (known_auxiliary_function_name_patterns[i]);
- if (re_exec (func_name))
- return 1;
- }
-
- return 0;
-}
-
-/* Find the first frame that contains debugging information and that is not
- part of the Ada run-time, starting from FI and moving upward. */
-
-void
-ada_find_printable_frame (struct frame_info *fi)
-{
- for (; fi != NULL; fi = get_prev_frame (fi))
- {
- if (!is_known_support_routine (fi))
- {
- select_frame (fi);
- break;
- }
- }
-
-}
-
-/* Name found for exception associated with last bpstat sent to
- ada_adjust_exception_stop. Set to the null string if that bpstat
- did not correspond to an Ada exception or no name could be found. */
-
-static char last_exception_name[256];
-
-/* If BS indicates a stop in an Ada exception, try to go up to a frame
- that will be meaningful to the user, and save the name of the last
- exception (truncated, if necessary) in last_exception_name. */
-
-void
-ada_adjust_exception_stop (bpstat bs)
-{
- CORE_ADDR addr;
- struct frame_info *fi;
- int frame_level;
- char *selected_frame_func;
-
- addr = 0;
- last_exception_name[0] = '\0';
- fi = get_selected_frame ();
- selected_frame_func = function_name_from_pc (get_frame_pc (fi));
-
- switch (ada_exception_breakpoint_type (bs))
- {
- default:
- return;
- case 1:
- break;
- case 2:
- /* Unhandled exceptions. Select the frame corresponding to
- ada.exceptions.process_raise_exception. This frame is at
- least 2 levels up, so we simply skip the first 2 frames
- without checking the name of their associated function. */
- for (frame_level = 0; frame_level < 2; frame_level += 1)
- if (fi != NULL)
- fi = get_prev_frame (fi);
- while (fi != NULL)
- {
- const char *func_name = function_name_from_pc (get_frame_pc (fi));
- if (func_name != NULL
- && strcmp (func_name, process_raise_exception_name) == 0)
- break; /* We found the frame we were looking for... */
- fi = get_prev_frame (fi);
- }
- if (fi == NULL)
- break;
- select_frame (fi);
- break;
- }
-
- addr = parse_and_eval_address ("e.full_name");
-
- if (addr != 0)
- read_memory (addr, last_exception_name, sizeof (last_exception_name) - 1);
- last_exception_name[sizeof (last_exception_name) - 1] = '\0';
- ada_find_printable_frame (get_selected_frame ());
-}
-
-/* Output Ada exception name (if any) associated with last call to
- ada_adjust_exception_stop. */
-
-void
-ada_print_exception_stop (bpstat bs)
-{
- if (last_exception_name[0] != '\000')
- {
- ui_out_text (uiout, last_exception_name);
- ui_out_text (uiout, " at ");
- }
-}
-
-/* Parses the CONDITION string associated with a breakpoint exception
- to get the name of the exception on which the breakpoint has been
- set. The returned string needs to be deallocated after use. */
-
-static char *
-exception_name_from_cond (const char *condition)
-{
- char *start, *end, *exception_name;
- int exception_name_len;
-
- start = strrchr (condition, '&') + 1;
- end = strchr (start, ')') - 1;
- exception_name_len = end - start + 1;
-
- exception_name =
- (char *) xmalloc ((exception_name_len + 1) * sizeof (char));
- sprintf (exception_name, "%.*s", exception_name_len, start);
-
- return exception_name;
-}
-
-/* Print Ada-specific exception information about B, other than task
- clause. Return non-zero iff B was an Ada exception breakpoint. */
-
-int
-ada_print_exception_breakpoint_nontask (struct breakpoint *b)
-{
- if (b->break_on_exception == 1)
- {
- if (b->cond_string) /* the breakpoint is on a specific exception. */
- {
- char *exception_name = exception_name_from_cond (b->cond_string);
-
- make_cleanup (xfree, exception_name);
-
- ui_out_text (uiout, "on ");
- if (ui_out_is_mi_like_p (uiout))
- ui_out_field_string (uiout, "exception", exception_name);
- else
- {
- ui_out_text (uiout, "exception ");
- ui_out_text (uiout, exception_name);
- ui_out_text (uiout, " ");
- }
- }
- else
- ui_out_text (uiout, "on all exceptions");
- }
- else if (b->break_on_exception == 2)
- ui_out_text (uiout, "on unhandled exception");
- else if (b->break_on_exception == 3)
- ui_out_text (uiout, "on assert failure");
- else
- return 0;
- return 1;
-}
-
-/* Print task identifier for breakpoint B, if it is an Ada-specific
- breakpoint with non-zero tasking information. */
-
-void
-ada_print_exception_breakpoint_task (struct breakpoint *b)
-{
- if (b->task != 0)
- {
- ui_out_text (uiout, " task ");
- ui_out_field_int (uiout, "task", b->task);
- }
-}
-
-int
-ada_is_exception_sym (struct symbol *sym)
-{
- char *type_name = type_name_no_tag (SYMBOL_TYPE (sym));
-
- return (SYMBOL_CLASS (sym) != LOC_TYPEDEF
- && SYMBOL_CLASS (sym) != LOC_BLOCK
- && SYMBOL_CLASS (sym) != LOC_CONST
- && type_name != NULL && strcmp (type_name, "exception") == 0);
-}
-
-int
-ada_maybe_exception_partial_symbol (struct partial_symbol *sym)
-{
- return (SYMBOL_CLASS (sym) != LOC_TYPEDEF
- && SYMBOL_CLASS (sym) != LOC_BLOCK
- && SYMBOL_CLASS (sym) != LOC_CONST);
-}
-
-/* Cause the appropriate error if no appropriate runtime symbol is
- found to set a breakpoint, using ERR_DESC to describe the
- breakpoint. */
-
-static void
-error_breakpoint_runtime_sym_not_found (const char *err_desc)
-{
- /* If we are not debugging an Ada program, we can not put exception
- breakpoints! */
-
- if (ada_update_initial_language (language_unknown, NULL) != language_ada)
- error ("Unable to break on %s. Is this an Ada main program?", err_desc);
-
- /* If the symbol does not exist, then check that the program is
- already started, to make sure that shared libraries have been
- loaded. If it is not started, this may mean that the symbol is
- in a shared library. */
-
- if (ptid_get_pid (inferior_ptid) == 0)
- error ("Unable to break on %s. Try to start the program first.",
- err_desc);
-
- /* At this point, we know that we are debugging an Ada program and
- that the inferior has been started, but we still are not able to
- find the run-time symbols. That can mean that we are in
- configurable run time mode, or that a-except as been optimized
- out by the linker... In any case, at this point it is not worth
- supporting this feature. */
-
- error ("Cannot break on %s in this configuration.", err_desc);
-}
-
-/* Test if NAME is currently defined, and that either ALLOW_TRAMP or
- the symbol is not a shared-library trampoline. Return the result of
- the test. */
-
-static int
-is_runtime_sym_defined (const char *name, int allow_tramp)
-{
- struct minimal_symbol *msym;
-
- msym = lookup_minimal_symbol (name, NULL, NULL);
- return (msym != NULL && msym->type != mst_unknown
- && (allow_tramp || msym->type != mst_solib_trampoline));
-}
-
-/* If ARG points to an Ada exception or assert breakpoint, rewrite
- into equivalent form. Return resulting argument string. Set
- *BREAK_ON_EXCEPTIONP to 1 for ordinary break on exception, 2 for
- break on unhandled, 3 for assert, 0 otherwise. */
-
-char *
-ada_breakpoint_rewrite (char *arg, int *break_on_exceptionp)
-{
- if (arg == NULL)
- return arg;
- *break_on_exceptionp = 0;
- if (current_language->la_language == language_ada
- && strncmp (arg, "exception", 9) == 0
- && (arg[9] == ' ' || arg[9] == '\t' || arg[9] == '\0'))
- {
- char *tok, *end_tok;
- int toklen;
- int has_exception_propagation =
- is_runtime_sym_defined (raise_sym_name, 1);
-
- *break_on_exceptionp = 1;
-
- tok = arg + 9;
- while (*tok == ' ' || *tok == '\t')
- tok += 1;
-
- end_tok = tok;
-
- while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
- end_tok += 1;
-
- toklen = end_tok - tok;
-
- arg = (char *) xmalloc (sizeof (longest_exception_template) + toklen);
- make_cleanup (xfree, arg);
- if (toklen == 0)
- {
- if (has_exception_propagation)
- sprintf (arg, "'%s'", raise_sym_name);
- else
- error_breakpoint_runtime_sym_not_found ("exception");
- }
- else if (strncmp (tok, "unhandled", toklen) == 0)
- {
- if (is_runtime_sym_defined (raise_unhandled_sym_name, 1))
- sprintf (arg, "'%s'", raise_unhandled_sym_name);
- else
- error_breakpoint_runtime_sym_not_found ("exception");
-
- *break_on_exceptionp = 2;
- }
- else
- {
- if (is_runtime_sym_defined (raise_sym_name, 0))
- sprintf (arg, "'%s' if long_integer(e) = long_integer(&%.*s)",
- raise_sym_name, toklen, tok);
- else
- error_breakpoint_runtime_sym_not_found ("specific exception");
- }
- }
- else if (current_language->la_language == language_ada
- && strncmp (arg, "assert", 6) == 0
- && (arg[6] == ' ' || arg[6] == '\t' || arg[6] == '\0'))
+
+ if (!wild)
{
- char *tok = arg + 6;
+ arg_sym = NULL;
+ found_sym = 0;
+
+ ALL_BLOCK_SYMBOLS (block, iter, sym)
+ {
+ if (SYMBOL_DOMAIN (sym) == domain)
+ {
+ int cmp;
- if (!is_runtime_sym_defined (raise_assert_sym_name, 1))
- error_breakpoint_runtime_sym_not_found ("failed assertion");
+ cmp = (int) '_' - (int) SYMBOL_LINKAGE_NAME (sym)[0];
+ if (cmp == 0)
+ {
+ cmp = strncmp ("_ada_", SYMBOL_LINKAGE_NAME (sym), 5);
+ if (cmp == 0)
+ cmp = strncmp (name, SYMBOL_LINKAGE_NAME (sym) + 5,
+ name_len);
+ }
- *break_on_exceptionp = 3;
+ if (cmp == 0
+ && is_name_suffix (SYMBOL_LINKAGE_NAME (sym) + name_len + 5))
+ {
+ switch (SYMBOL_CLASS (sym))
+ {
+ case LOC_ARG:
+ case LOC_LOCAL_ARG:
+ case LOC_REF_ARG:
+ case LOC_REGPARM:
+ case LOC_REGPARM_ADDR:
+ case LOC_BASEREG_ARG:
+ case LOC_COMPUTED_ARG:
+ arg_sym = sym;
+ break;
+ case LOC_UNRESOLVED:
+ break;
+ default:
+ found_sym = 1;
+ add_defn_to_vec (obstackp,
+ fixup_symbol_section (sym, objfile),
+ block, symtab);
+ break;
+ }
+ }
+ }
+ }
- arg =
- (char *) xmalloc (sizeof (raise_assert_sym_name) + strlen (tok) + 2);
- make_cleanup (xfree, arg);
- sprintf (arg, "'%s'%s", raise_assert_sym_name, tok);
+ /* NOTE: This really shouldn't be needed for _ada_ symbols.
+ They aren't parameters, right? */
+ if (!found_sym && arg_sym != NULL)
+ {
+ add_defn_to_vec (obstackp,
+ fixup_symbol_section (arg_sym, objfile),
+ block, symtab);
+ }
}
- return arg;
}
-#endif
\f
/* Field Access */
struct type *
ada_tag_type (struct value *val)
{
- return ada_lookup_struct_elt_type (VALUE_TYPE (val), "_tag", 1, 0, NULL);
+ return ada_lookup_struct_elt_type (value_type (val), "_tag", 1, 0, NULL);
}
/* The value of the tag on VAL. */
struct value *
ada_value_tag (struct value *val)
{
- return ada_value_struct_elt (val, "_tag", "record");
+ return ada_value_struct_elt (val, "_tag", 0);
}
/* The value of the tag on the object of type TYPE whose contents are
ADDRESS. */
static struct value *
-value_tag_from_contents_and_address (struct type *type, char *valaddr,
+value_tag_from_contents_and_address (struct type *type,
+ const gdb_byte *valaddr,
CORE_ADDR address)
{
int tag_byte_offset, dummy1, dummy2;
struct type *tag_type;
if (find_struct_field ("_tag", type, 0, &tag_type, &tag_byte_offset,
- &dummy1, &dummy2))
+ NULL, NULL, NULL))
{
- char *valaddr1 = (valaddr == NULL) ? NULL : valaddr + tag_byte_offset;
+ const gdb_byte *valaddr1 = ((valaddr == NULL)
+ ? NULL
+ : valaddr + tag_byte_offset);
CORE_ADDR address1 = (address == 0) ? 0 : address + tag_byte_offset;
return value_from_contents_and_address (tag_type, valaddr1, address1);
char *name;
};
+
+static int ada_tag_name_1 (void *);
+static int ada_tag_name_2 (struct tag_args *);
+
/* Wrapper function used by ada_tag_name. Given a struct tag_args*
value ARGS, sets ARGS->name to the tag name of ARGS->tag.
The value stored in ARGS->name is valid until the next call to
char *p;
struct value *val;
args->name = NULL;
- val = ada_value_struct_elt (args->tag, "tsd", NULL);
+ val = ada_value_struct_elt (args->tag, "tsd", 1);
+ if (val == NULL)
+ return ada_tag_name_2 (args);
+ val = ada_value_struct_elt (val, "expanded_name", 1);
+ if (val == NULL)
+ return 0;
+ read_memory_string (value_as_address (val), name, sizeof (name) - 1);
+ for (p = name; *p != '\0'; p += 1)
+ if (isalpha (*p))
+ *p = tolower (*p);
+ args->name = name;
+ return 0;
+}
+
+/* Utility function for ada_tag_name_1 that tries the second
+ representation for the dispatch table (in which there is no
+ explicit 'tsd' field in the referent of the tag pointer, and instead
+ the tsd pointer is stored just before the dispatch table. */
+
+static int
+ada_tag_name_2 (struct tag_args *args)
+{
+ struct type *info_type;
+ static char name[1024];
+ char *p;
+ struct value *val, *valp;
+
+ args->name = NULL;
+ info_type = ada_find_any_type ("ada__tags__type_specific_data");
+ if (info_type == NULL)
+ return 0;
+ info_type = lookup_pointer_type (lookup_pointer_type (info_type));
+ valp = value_cast (info_type, args->tag);
+ if (valp == NULL)
+ return 0;
+ val = value_ind (value_add (valp, value_from_longest (builtin_type_int, -1)));
if (val == NULL)
return 0;
- val = ada_value_struct_elt (val, "expanded_name", NULL);
+ val = ada_value_struct_elt (val, "expanded_name", 1);
if (val == NULL)
return 0;
read_memory_string (value_as_address (val), name, sizeof (name) - 1);
ada_tag_name (struct value *tag)
{
struct tag_args args;
- if (!ada_is_tag_type (VALUE_TYPE (tag)))
+ if (!ada_is_tag_type (value_type (tag)))
return NULL;
args.tag = tag;
args.name = NULL;
{
int i;
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
if (type == NULL || TYPE_CODE (type) != TYPE_CODE_STRUCT)
return NULL;
for (i = 0; i < TYPE_NFIELDS (type); i += 1)
if (ada_is_parent_field (type, i))
- return check_typedef (TYPE_FIELD_TYPE (type, i));
+ return ada_check_typedef (TYPE_FIELD_TYPE (type, i));
return NULL;
}
int
ada_is_parent_field (struct type *type, int field_num)
{
- const char *name = TYPE_FIELD_NAME (check_typedef (type), field_num);
+ const char *name = TYPE_FIELD_NAME (ada_check_typedef (type), field_num);
return (name != NULL
&& (strncmp (name, "PARENT", 6) == 0
|| strncmp (name, "_parent", 7) == 0));
{
struct type *type;
- CHECK_TYPEDEF (arg_type);
+ arg_type = ada_check_typedef (arg_type);
type = TYPE_FIELD_TYPE (arg_type, fieldno);
/* Handle packed fields. */
int bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
int bit_size = TYPE_FIELD_BITSIZE (arg_type, fieldno);
- return ada_value_primitive_packed_val (arg1, VALUE_CONTENTS (arg1),
+ return ada_value_primitive_packed_val (arg1, value_contents (arg1),
offset + bit_pos / 8,
bit_pos % 8, bit_size, type);
}
return value_primitive_field (arg1, offset, fieldno, arg_type);
}
-/* Find field with name NAME in object of type TYPE. If found, return 1
- after setting *FIELD_TYPE_P to the field's type, *BYTE_OFFSET_P to
- OFFSET + the byte offset of the field within an object of that type,
- *BIT_OFFSET_P to the bit offset modulo byte size of the field, and
- *BIT_SIZE_P to its size in bits if the field is packed, and 0 otherwise.
- Looks inside wrappers for the field. Returns 0 if field not
- found. */
+/* Find field with name NAME in object of type TYPE. If found,
+ set the following for each argument that is non-null:
+ - *FIELD_TYPE_P to the field's type;
+ - *BYTE_OFFSET_P to OFFSET + the byte offset of the field within
+ an object of that type;
+ - *BIT_OFFSET_P to the bit offset modulo byte size of the field;
+ - *BIT_SIZE_P to its size in bits if the field is packed, and
+ 0 otherwise;
+ If INDEX_P is non-null, increment *INDEX_P by the number of source-visible
+ fields up to but not including the desired field, or by the total
+ number of fields if not found. A NULL value of NAME never
+ matches; the function just counts visible fields in this case.
+
+ Returns 1 if found, 0 otherwise. */
+
static int
find_struct_field (char *name, struct type *type, int offset,
struct type **field_type_p,
- int *byte_offset_p, int *bit_offset_p, int *bit_size_p)
+ int *byte_offset_p, int *bit_offset_p, int *bit_size_p,
+ int *index_p)
{
int i;
- CHECK_TYPEDEF (type);
- *field_type_p = NULL;
- *byte_offset_p = *bit_offset_p = *bit_size_p = 0;
+ type = ada_check_typedef (type);
+
+ if (field_type_p != NULL)
+ *field_type_p = NULL;
+ if (byte_offset_p != NULL)
+ *byte_offset_p;
+ if (bit_offset_p != NULL)
+ *bit_offset_p = 0;
+ if (bit_size_p != NULL)
+ *bit_size_p = 0;
- for (i = TYPE_NFIELDS (type) - 1; i >= 0; i -= 1)
+ for (i = 0; i < TYPE_NFIELDS (type); i += 1)
{
int bit_pos = TYPE_FIELD_BITPOS (type, i);
int fld_offset = offset + bit_pos / 8;
if (t_field_name == NULL)
continue;
- else if (field_name_match (t_field_name, name))
+ else if (name != NULL && field_name_match (t_field_name, name))
{
int bit_size = TYPE_FIELD_BITSIZE (type, i);
- *field_type_p = TYPE_FIELD_TYPE (type, i);
- *byte_offset_p = fld_offset;
- *bit_offset_p = bit_pos % 8;
- *bit_size_p = bit_size;
+ if (field_type_p != NULL)
+ *field_type_p = TYPE_FIELD_TYPE (type, i);
+ if (byte_offset_p != NULL)
+ *byte_offset_p = fld_offset;
+ if (bit_offset_p != NULL)
+ *bit_offset_p = bit_pos % 8;
+ if (bit_size_p != NULL)
+ *bit_size_p = bit_size;
return 1;
}
else if (ada_is_wrapper_field (type, i))
{
- if (find_struct_field (name, TYPE_FIELD_TYPE (type, i), fld_offset,
- field_type_p, byte_offset_p, bit_offset_p,
- bit_size_p))
+ if (find_struct_field (name, TYPE_FIELD_TYPE (type, i), fld_offset,
+ field_type_p, byte_offset_p, bit_offset_p,
+ bit_size_p, index_p))
return 1;
}
else if (ada_is_variant_part (type, i))
{
+ /* PNH: Wait. Do we ever execute this section, or is ARG always of
+ fixed type?? */
int j;
- struct type *field_type = check_typedef (TYPE_FIELD_TYPE (type, i));
+ 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 = 0; j < TYPE_NFIELDS (field_type); j += 1)
{
if (find_struct_field (name, TYPE_FIELD_TYPE (field_type, j),
fld_offset
+ TYPE_FIELD_BITPOS (field_type, j) / 8,
field_type_p, byte_offset_p,
- bit_offset_p, bit_size_p))
+ bit_offset_p, bit_size_p, index_p))
return 1;
}
}
+ else if (index_p != NULL)
+ *index_p += 1;
}
return 0;
}
+/* Number of user-visible fields in record type TYPE. */
+static int
+num_visible_fields (struct type *type)
+{
+ int n;
+ n = 0;
+ find_struct_field (NULL, type, 0, NULL, NULL, NULL, NULL, &n);
+ return n;
+}
/* Look for a field NAME in ARG. Adjust the address of ARG by OFFSET bytes,
and search in it assuming it has (class) type TYPE.
struct type *type)
{
int i;
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
- for (i = TYPE_NFIELDS (type) - 1; i >= 0; i -= 1)
+ for (i = 0; i < TYPE_NFIELDS (type); i += 1)
{
char *t_field_name = TYPE_FIELD_NAME (type, i);
else if (ada_is_variant_part (type, i))
{
+ /* PNH: Do we ever get here? See find_struct_field. */
int j;
- struct type *field_type = check_typedef (TYPE_FIELD_TYPE (type, i));
+ struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type, i));
int var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
- for (j = TYPE_NFIELDS (field_type) - 1; j >= 0; j -= 1)
+ for (j = 0; j < TYPE_NFIELDS (field_type); j += 1)
{
struct value *v = ada_search_struct_field /* Force line break. */
(name, arg,
return NULL;
}
+static struct value *ada_index_struct_field_1 (int *, struct value *,
+ int, struct type *);
+
+
+/* Return field #INDEX in ARG, where the index is that returned by
+ * find_struct_field through its INDEX_P argument. Adjust the address
+ * of ARG by OFFSET bytes, and search in it assuming it has (class) type TYPE.
+ * If found, return value, else return NULL. */
+
+static struct value *
+ada_index_struct_field (int index, struct value *arg, int offset,
+ struct type *type)
+{
+ return ada_index_struct_field_1 (&index, arg, offset, type);
+}
+
+
+/* Auxiliary function for ada_index_struct_field. Like
+ * ada_index_struct_field, but takes index from *INDEX_P and modifies
+ * *INDEX_P. */
+
+static struct value *
+ada_index_struct_field_1 (int *index_p, struct value *arg, int offset,
+ struct type *type)
+{
+ int i;
+ type = ada_check_typedef (type);
+
+ for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+ {
+ if (TYPE_FIELD_NAME (type, i) == NULL)
+ continue;
+ else if (ada_is_wrapper_field (type, i))
+ {
+ struct value *v = /* Do not let indent join lines here. */
+ ada_index_struct_field_1 (index_p, arg,
+ offset + TYPE_FIELD_BITPOS (type, i) / 8,
+ TYPE_FIELD_TYPE (type, i));
+ if (v != NULL)
+ return v;
+ }
+
+ else if (ada_is_variant_part (type, i))
+ {
+ /* PNH: Do we ever get here? See ada_search_struct_field,
+ find_struct_field. */
+ error (_("Cannot assign this kind of variant record"));
+ }
+ else if (*index_p == 0)
+ return ada_value_primitive_field (arg, offset, i, type);
+ else
+ *index_p -= 1;
+ }
+ 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
and (recursively) among all members of any wrapper members
(e.g., '_parent').
- ERR is a name (for use in error messages) that identifies the class
- of entity that ARG is supposed to be. ERR may be null, indicating
- that on error, the function simply returns NULL, and does not
- throw an error. (FIXME: True only if ARG is a pointer or reference
- at the moment). */
+ If NO_ERR, then simply return NULL in case of error, rather than
+ calling error. */
struct value *
-ada_value_struct_elt (struct value *arg, char *name, char *err)
+ada_value_struct_elt (struct value *arg, char *name, int no_err)
{
struct type *t, *t1;
struct value *v;
v = NULL;
- t1 = t = check_typedef (VALUE_TYPE (arg));
+ t1 = t = ada_check_typedef (value_type (arg));
if (TYPE_CODE (t) == TYPE_CODE_REF)
{
t1 = TYPE_TARGET_TYPE (t);
if (t1 == NULL)
- {
- if (err == NULL)
- return NULL;
- else
- error ("Bad value type in a %s.", err);
- }
- CHECK_TYPEDEF (t1);
+ goto BadValue;
+ t1 = ada_check_typedef (t1);
if (TYPE_CODE (t1) == TYPE_CODE_PTR)
{
- COERCE_REF (arg);
+ arg = coerce_ref (arg);
t = t1;
}
}
{
t1 = TYPE_TARGET_TYPE (t);
if (t1 == NULL)
- {
- if (err == NULL)
- return NULL;
- else
- error ("Bad value type in a %s.", err);
- }
- CHECK_TYPEDEF (t1);
+ goto BadValue;
+ t1 = ada_check_typedef (t1);
if (TYPE_CODE (t1) == TYPE_CODE_PTR)
{
arg = value_ind (arg);
}
if (TYPE_CODE (t1) != TYPE_CODE_STRUCT && TYPE_CODE (t1) != TYPE_CODE_UNION)
- {
- if (err == NULL)
- return NULL;
- else
- error ("Attempt to extract a component of a value that is not a %s.",
- err);
- }
+ goto BadValue;
if (t1 == t)
v = ada_search_struct_field (name, arg, 0, t);
if (TYPE_CODE (t) == TYPE_CODE_PTR)
address = value_as_address (arg);
else
- address = unpack_pointer (t, VALUE_CONTENTS (arg));
+ address = unpack_pointer (t, value_contents (arg));
t1 = ada_to_fixed_type (ada_get_base_type (t1), NULL, address, NULL);
if (find_struct_field (name, t1, 0,
&field_type, &byte_offset, &bit_offset,
- &bit_size))
+ &bit_size, NULL))
{
if (bit_size != 0)
{
- arg = ada_value_ind (arg);
+ 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);
}
}
- if (v == NULL && err != NULL)
- error ("There is no member named %s.", name);
+ if (v != NULL || no_err)
+ return v;
+ else
+ error (_("There is no member named %s."), name);
- return v;
+ BadValue:
+ if (no_err)
+ return NULL;
+ else
+ error (_("Attempt to extract a component of a value that is not a record."));
}
/* Given a type TYPE, look up the type of the component of type named NAME.
if (refok && type != NULL)
while (1)
{
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
if (TYPE_CODE (type) != TYPE_CODE_PTR
&& TYPE_CODE (type) != TYPE_CODE_REF)
break;
{
target_terminal_ours ();
gdb_flush (gdb_stdout);
- fprintf_unfiltered (gdb_stderr, "Type ");
- if (type == NULL)
- fprintf_unfiltered (gdb_stderr, "(null)");
- else
- type_print (type, "", gdb_stderr, -1);
- error (" is not a structure or union type");
+ if (type == NULL)
+ error (_("Type (null) is not a structure or union type"));
+ else
+ {
+ /* XXX: type_sprint */
+ fprintf_unfiltered (gdb_stderr, _("Type "));
+ type_print (type, "", gdb_stderr, -1);
+ error (_(" is not a structure or union type"));
+ }
}
}
{
if (dispp != NULL)
*dispp += TYPE_FIELD_BITPOS (type, i) / 8;
- return check_typedef (TYPE_FIELD_TYPE (type, i));
+ return ada_check_typedef (TYPE_FIELD_TYPE (type, i));
}
else if (ada_is_wrapper_field (type, i))
else if (ada_is_variant_part (type, i))
{
int j;
- struct type *field_type = check_typedef (TYPE_FIELD_TYPE (type, i));
+ struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type, i));
for (j = TYPE_NFIELDS (field_type) - 1; j >= 0; j -= 1)
{
{
target_terminal_ours ();
gdb_flush (gdb_stdout);
- fprintf_unfiltered (gdb_stderr, "Type ");
- type_print (type, "", gdb_stderr, -1);
- fprintf_unfiltered (gdb_stderr, " has no component named ");
- error ("%s", name == NULL ? "<null>" : name);
+ if (name == NULL)
+ {
+ /* XXX: type_sprint */
+ fprintf_unfiltered (gdb_stderr, _("Type "));
+ type_print (type, "", gdb_stderr, -1);
+ error (_(" has no component named <null>"));
+ }
+ else
+ {
+ /* XXX: type_sprint */
+ fprintf_unfiltered (gdb_stderr, _("Type "));
+ type_print (type, "", gdb_stderr, -1);
+ error (_(" has no component named %s"), name);
+ }
}
return NULL;
int
ada_which_variant_applies (struct type *var_type, struct type *outer_type,
- char *outer_valaddr)
+ const gdb_byte *outer_valaddr)
{
int others_clause;
int i;
static struct value *
ada_coerce_ref (struct value *val0)
{
- if (TYPE_CODE (VALUE_TYPE (val0)) == TYPE_CODE_REF)
+ if (TYPE_CODE (value_type (val0)) == TYPE_CODE_REF)
{
struct value *val = val0;
- COERCE_REF (val);
+ val = coerce_ref (val);
val = unwrap_value (val);
return ada_to_fixed_value (val);
}
as well as adding the ``___XR'' suffix to build the name of
the associated renaming symbol. */
char *function_name = SYMBOL_LINKAGE_NAME (function_sym);
- const int function_name_len = strlen (function_name);
+ /* 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. */
+ const 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. */
+ function_name[function_name_len] = '\0';
+
/* Library-level functions are a special case, as GNAT adds
a ``_ada_'' prefix to the function name to avoid namespace
pollution. However, the renaming symbol themselves do not
static struct type *
dynamic_template_type (struct type *type)
{
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
if (type == NULL || TYPE_CODE (type) != TYPE_CODE_STRUCT
|| ada_type_name (type) == NULL)
the value of type TYPE at VALADDR or ADDRESS (see comments at
the beginning of this section) VAL according to GNAT conventions.
DVAL0 should describe the (portion of a) record that contains any
- necessary discriminants. It should be NULL if VALUE_TYPE (VAL) is
+ necessary discriminants. It should be NULL if value_type (VAL) is
an outer-level type (i.e., as opposed to a branch of a variant.) A
variant field (unless unchecked) is replaced by a particular branch
of the variant.
byte-aligned. */
struct type *
-ada_template_to_fixed_record_type_1 (struct type *type, char *valaddr,
+ada_template_to_fixed_record_type_1 (struct type *type,
+ const gdb_byte *valaddr,
CORE_ADDR address, struct value *dval0,
int keep_dynamic_fields)
{
for (f = 0; f < nfields; f += 1)
{
- off =
- align_value (off,
- field_alignment (type, f)) + TYPE_FIELD_BITPOS (type, f);
+ off = align_value (off, field_alignment (type, f))
+ + TYPE_FIELD_BITPOS (type, f);
TYPE_FIELD_BITPOS (rtype, f) = off;
TYPE_FIELD_BITSIZE (rtype, f) = 0;
}
}
- TYPE_LENGTH (rtype) = align_value (TYPE_LENGTH (rtype), TYPE_LENGTH (type));
+ /* According to exp_dbug.ads, the size of TYPE for variable-size records
+ should contain the alignment of that record, which should be a strictly
+ positive value. If null or negative, then something is wrong, most
+ probably in the debug info. In that case, we don't round up the size
+ of the resulting type. If this record is not part of another structure,
+ the current RTYPE length might be good enough for our purposes. */
+ if (TYPE_LENGTH (type) <= 0)
+ {
+ if (TYPE_NAME (rtype))
+ warning (_("Invalid type size for `%s' detected: %d."),
+ TYPE_NAME (rtype), TYPE_LENGTH (type));
+ else
+ warning (_("Invalid type size for <unnamed> detected: %d."),
+ TYPE_LENGTH (type));
+ }
+ else
+ {
+ TYPE_LENGTH (rtype) = align_value (TYPE_LENGTH (rtype),
+ TYPE_LENGTH (type));
+ }
value_free_to_mark (mark);
if (TYPE_LENGTH (rtype) > varsize_limit)
- error ("record type with dynamic size is larger than varsize-limit");
+ error (_("record type with dynamic size is larger than varsize-limit"));
return rtype;
}
of 1. */
static struct type *
-template_to_fixed_record_type (struct type *type, char *valaddr,
+template_to_fixed_record_type (struct type *type, const gdb_byte *valaddr,
CORE_ADDR address, struct value *dval0)
{
return ada_template_to_fixed_record_type_1 (type, valaddr,
for (f = 0; f < nfields; f += 1)
{
- struct type *field_type = CHECK_TYPEDEF (TYPE_FIELD_TYPE (type0, f));
+ struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type0, f));
struct type *new_type;
if (is_dynamic_field (type0, f))
contains the necessary discriminant values. */
static struct type *
-to_record_with_fixed_variant_part (struct type *type, char *valaddr,
+to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
CORE_ADDR address, struct value *dval0)
{
struct value *mark = value_mark ();
shortcut and suspect the compiler should be altered. FIXME. */
static struct type *
-to_fixed_record_type (struct type *type0, char *valaddr,
+to_fixed_record_type (struct type *type0, const gdb_byte *valaddr,
CORE_ADDR address, struct value *dval)
{
struct type *templ_type;
indicated in the union's type name. */
static struct type *
-to_fixed_variant_branch_type (struct type *var_type0, char *valaddr,
+to_fixed_variant_branch_type (struct type *var_type0, const gdb_byte *valaddr,
CORE_ADDR address, struct value *dval)
{
int which;
which =
ada_which_variant_applies (var_type,
- VALUE_TYPE (dval), VALUE_CONTENTS (dval));
+ value_type (dval), value_contents (dval));
if (which < 0)
return empty_record (TYPE_OBJFILE (var_type));
index_type_desc = ada_find_parallel_type (type0, "___XA");
if (index_type_desc == NULL)
{
- struct type *elt_type0 = check_typedef (TYPE_TARGET_TYPE (type0));
+ struct type *elt_type0 = ada_check_typedef (TYPE_TARGET_TYPE (type0));
/* NOTE: elt_type---the fixed version of elt_type0---should never
depend on the contents of the array in properly constructed
debugging data. */
+ /* Create a fixed version of the array element type.
+ We're not providing the address of an element here,
+ and thus the actual object value cannot be inspected to do
+ the conversion. This should not be a problem, since arrays of
+ unconstrained objects are not allowed. In particular, all
+ the elements of an array of a tagged type should all be of
+ the same type specified in the debugging info. No need to
+ consult the object tag. */
struct type *elt_type = ada_to_fixed_type (elt_type0, 0, 0, dval);
if (elt_type0 == elt_type)
/* NOTE: result---the fixed version of elt_type0---should never
depend on the contents of the array in properly constructed
debugging data. */
- result = ada_to_fixed_type (check_typedef (elt_type0), 0, 0, dval);
+ /* Create a fixed version of the array element type.
+ We're not providing the address of an element here,
+ and thus the actual object value cannot be inspected to do
+ the conversion. This should not be a problem, since arrays of
+ unconstrained objects are not allowed. In particular, all
+ the elements of an array of a tagged type should all be of
+ the same type specified in the debugging info. No need to
+ consult the object tag. */
+ result = ada_to_fixed_type (ada_check_typedef (elt_type0), 0, 0, dval);
for (i = TYPE_NFIELDS (index_type_desc) - 1; i >= 0; i -= 1)
{
struct type *range_type =
result, range_type);
}
if (!ignore_too_big && TYPE_LENGTH (result) > varsize_limit)
- error ("array type with dynamic size is larger than varsize-limit");
+ error (_("array type with dynamic size is larger than varsize-limit"));
}
TYPE_FLAGS (result) |= TYPE_FLAG_FIXED_INSTANCE;
corresponding to TYPE for the value (TYPE, VALADDR, ADDRESS)
DVAL describes a record containing any discriminants used in TYPE0,
and may be NULL if there are none, or if the object of type TYPE at
- ADDRESS or in VALADDR contains these discriminants. */
-
+ ADDRESS or in VALADDR contains these discriminants.
+
+ In the case of tagged types, this function attempts to locate the object's
+ tag and use it to compute the actual type. However, when ADDRESS is null,
+ we cannot use it to determine the location of the tag, and therefore
+ compute the tagged type's actual type. So we return the tagged type
+ without consulting the tag. */
+
struct type *
-ada_to_fixed_type (struct type *type, char *valaddr,
+ada_to_fixed_type (struct type *type, const gdb_byte *valaddr,
CORE_ADDR address, struct value *dval)
{
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
switch (TYPE_CODE (type))
{
default:
case TYPE_CODE_STRUCT:
{
struct type *static_type = to_static_fixed_type (type);
- if (ada_is_tagged_type (static_type, 0))
+
+ /* If STATIC_TYPE is a tagged type and we know the object's address,
+ then we can determine its tag, and compute the object's actual
+ type from there. */
+
+ if (address != 0 && ada_is_tagged_type (static_type, 0))
{
struct type *real_type =
type_from_tag (value_tag_from_contents_and_address (static_type,
if (TYPE_FLAGS (type0) & TYPE_FLAG_FIXED_INSTANCE)
return type0;
- CHECK_TYPEDEF (type0);
+ type0 = ada_check_typedef (type0);
switch (TYPE_CODE (type0))
{
{
if (ada_is_aligner_type (type))
{
- struct type *type1 = TYPE_FIELD_TYPE (check_typedef (type), 0);
+ struct type *type1 = TYPE_FIELD_TYPE (ada_check_typedef (type), 0);
if (ada_type_name (type1) == NULL)
TYPE_NAME (type1) = ada_type_name (type);
exists, otherwise TYPE. */
struct type *
-ada_completed_type (struct type *type)
+ada_check_typedef (struct type *type)
{
CHECK_TYPEDEF (type);
if (type == NULL || TYPE_CODE (type) != TYPE_CODE_ENUM
- || (TYPE_FLAGS (type) & TYPE_FLAG_STUB) == 0
+ || !TYPE_STUB (type)
|| TYPE_TAG_NAME (type) == NULL)
return type;
else
static struct value *
ada_to_fixed_value (struct value *val)
{
- return ada_to_fixed_value_create (VALUE_TYPE (val),
- VALUE_ADDRESS (val) + VALUE_OFFSET (val),
+ return ada_to_fixed_value_create (value_type (val),
+ VALUE_ADDRESS (val) + value_offset (val),
val);
}
-/* If the PC is pointing inside a function prologue, then re-adjust it
- past this prologue. */
-
-static void
-adjust_pc_past_prologue (CORE_ADDR *pc)
-{
- struct symbol *func_sym = find_pc_function (*pc);
-
- if (func_sym)
- {
- const struct symtab_and_line sal =
- find_function_start_sal (func_sym, 1);
-
- if (*pc <= sal.pc)
- *pc = sal.pc;
- }
-}
-
/* A value representing VAL, but with a standard (static-sized) type
chosen to approximate the real type of VAL as well as possible, but
without consulting any runtime values. For Ada dynamic-sized
ada_to_static_fixed_value (struct value *val)
{
struct type *type =
- to_static_fixed_type (static_unwrap_type (VALUE_TYPE (val)));
- if (type == VALUE_TYPE (val))
+ to_static_fixed_type (static_unwrap_type (value_type (val)));
+ if (type == value_type (val))
return val;
else
return coerce_unspec_val_to_type (val, type);
static LONGEST
pos_atr (struct value *arg)
{
- struct type *type = VALUE_TYPE (arg);
+ struct type *type = value_type (arg);
if (!discrete_type_p (type))
- error ("'POS only defined on discrete types");
+ error (_("'POS only defined on discrete types"));
if (TYPE_CODE (type) == TYPE_CODE_ENUM)
{
if (v == TYPE_FIELD_BITPOS (type, i))
return i;
}
- error ("enumeration value is invalid: can't find 'POS");
+ error (_("enumeration value is invalid: can't find 'POS"));
}
else
return value_as_long (arg);
static struct value *
value_pos_atr (struct value *arg)
{
- return value_from_longest (builtin_type_ada_int, pos_atr (arg));
+ return value_from_longest (builtin_type_int, pos_atr (arg));
}
/* Evaluate the TYPE'VAL attribute applied to ARG. */
value_val_atr (struct type *type, struct value *arg)
{
if (!discrete_type_p (type))
- error ("'VAL only defined on discrete types");
- if (!integer_type_p (VALUE_TYPE (arg)))
- error ("'VAL requires integral argument");
+ error (_("'VAL only defined on discrete types"));
+ 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");
+ error (_("argument to 'VAL out of range"));
return value_from_longest (type, TYPE_FIELD_BITPOS (type, pos));
}
else
int
ada_is_string_type (struct type *type)
{
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
if (type != NULL
&& TYPE_CODE (type) != TYPE_CODE_PTR
&& (ada_is_simple_array_type (type)
int
ada_is_aligner_type (struct type *type)
{
- CHECK_TYPEDEF (type);
+ type = ada_check_typedef (type);
+
+ /* If we can find a parallel XVS type, then the XVS type should
+ be used instead of this type. And hence, this is not an aligner
+ type. */
+ if (ada_find_parallel_type (type, "___XVS") != NULL)
+ return 0;
+
return (TYPE_CODE (type) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type) == 1
&& strcmp (TYPE_FIELD_NAME (type, 0), "F") == 0);
/* The address of the aligned value in an object at address VALADDR
having type TYPE. Assumes ada_is_aligner_type (TYPE). */
-char *
-ada_aligned_value_addr (struct type *type, char *valaddr)
+const gdb_byte *
+ada_aligned_value_addr (struct type *type, const gdb_byte *valaddr)
{
if (ada_is_aligner_type (type))
return ada_aligned_value_addr (TYPE_FIELD_TYPE (type, 0),
static struct value *
unwrap_value (struct value *val)
{
- struct type *type = check_typedef (VALUE_TYPE (val));
+ struct type *type = ada_check_typedef (value_type (val));
if (ada_is_aligner_type (type))
{
struct value *v = value_struct_elt (&val, NULL, "F",
NULL, "internal structure");
- struct type *val_type = check_typedef (VALUE_TYPE (v));
+ 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);
else
{
struct type *raw_real_type =
- ada_completed_type (ada_get_base_type (type));
+ ada_check_typedef (ada_get_base_type (type));
if (type == raw_real_type)
return val;
return
coerce_unspec_val_to_type
(val, ada_to_fixed_type (raw_real_type, 0,
- VALUE_ADDRESS (val) + VALUE_OFFSET (val),
+ VALUE_ADDRESS (val) + value_offset (val),
NULL));
}
}
{
LONGEST val;
- if (type == VALUE_TYPE (arg))
+ if (type == value_type (arg))
return arg;
- else if (ada_is_fixed_point_type (VALUE_TYPE (arg)))
+ else if (ada_is_fixed_point_type (value_type (arg)))
val = ada_float_to_fixed (type,
- ada_fixed_to_float (VALUE_TYPE (arg),
+ ada_fixed_to_float (value_type (arg),
value_as_long (arg)));
else
{
static struct value *
cast_from_fixed_to_double (struct value *arg)
{
- DOUBLEST val = ada_fixed_to_float (VALUE_TYPE (arg),
+ DOUBLEST val = ada_fixed_to_float (value_type (arg),
value_as_long (arg));
return value_from_double (builtin_type_double, val);
}
static struct value *
coerce_for_assign (struct type *type, struct value *val)
{
- struct type *type2 = VALUE_TYPE (val);
+ struct type *type2 = value_type (val);
if (type == type2)
return val;
- CHECK_TYPEDEF (type2);
- CHECK_TYPEDEF (type);
+ type2 = ada_check_typedef (type2);
+ type = ada_check_typedef (type);
if (TYPE_CODE (type2) == TYPE_CODE_PTR
&& TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
val = ada_value_ind (val);
- type2 = VALUE_TYPE (val);
+ type2 = value_type (val);
}
if (TYPE_CODE (type2) == TYPE_CODE_ARRAY
if (TYPE_LENGTH (type2) != TYPE_LENGTH (type)
|| TYPE_LENGTH (TYPE_TARGET_TYPE (type2))
!= TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
- error ("Incompatible types in assignment");
- VALUE_TYPE (val) = type;
+ error (_("Incompatible types in assignment"));
+ deprecated_set_value_type (val, type);
}
return val;
}
struct type *type1, *type2;
LONGEST v, v1, v2;
- COERCE_REF (arg1);
- COERCE_REF (arg2);
- type1 = base_type (check_typedef (VALUE_TYPE (arg1)));
- type2 = base_type (check_typedef (VALUE_TYPE (arg2)));
+ arg1 = coerce_ref (arg1);
+ arg2 = coerce_ref (arg2);
+ type1 = base_type (ada_check_typedef (value_type (arg1)));
+ type2 = base_type (ada_check_typedef (value_type (arg2)));
if (TYPE_CODE (type1) != TYPE_CODE_INT
|| TYPE_CODE (type2) != TYPE_CODE_INT)
v2 = value_as_long (arg2);
if (v2 == 0)
- error ("second operand of %s must not be zero.", op_string (op));
+ error (_("second operand of %s must not be zero."), op_string (op));
if (TYPE_UNSIGNED (type1) || op == BINOP_MOD)
return value_binop (arg1, arg2, op);
}
val = allocate_value (type1);
- store_unsigned_integer (VALUE_CONTENTS_RAW (val),
- TYPE_LENGTH (VALUE_TYPE (val)), v);
+ store_unsigned_integer (value_contents_raw (val),
+ TYPE_LENGTH (value_type (val)), v);
return val;
}
static int
ada_value_equal (struct value *arg1, struct value *arg2)
{
- if (ada_is_direct_array_type (VALUE_TYPE (arg1))
- || ada_is_direct_array_type (VALUE_TYPE (arg2)))
+ if (ada_is_direct_array_type (value_type (arg1))
+ || ada_is_direct_array_type (value_type (arg2)))
{
arg1 = ada_coerce_to_simple_array (arg1);
arg2 = ada_coerce_to_simple_array (arg2);
- if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_ARRAY
- || TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_ARRAY)
- error ("Attempt to compare array with non-array");
+ if (TYPE_CODE (value_type (arg1)) != TYPE_CODE_ARRAY
+ || TYPE_CODE (value_type (arg2)) != 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)
and do not have user-defined equality. */
return
- TYPE_LENGTH (VALUE_TYPE (arg1)) == TYPE_LENGTH (VALUE_TYPE (arg2))
- && memcmp (VALUE_CONTENTS (arg1), VALUE_CONTENTS (arg2),
- TYPE_LENGTH (VALUE_TYPE (arg1))) == 0;
+ TYPE_LENGTH (value_type (arg1)) == TYPE_LENGTH (value_type (arg2))
+ && memcmp (value_contents (arg1), value_contents (arg2),
+ TYPE_LENGTH (value_type (arg1))) == 0;
}
return value_equal (arg1, arg2);
}
-struct value *
+/* Total number of component associations in the aggregate starting at
+ index PC in EXP. Assumes that index PC is the start of an
+ OP_AGGREGATE. */
+
+static int
+num_component_specs (struct expression *exp, int pc)
+{
+ int n, m, i;
+ m = exp->elts[pc + 1].longconst;
+ pc += 3;
+ n = 0;
+ for (i = 0; i < m; i += 1)
+ {
+ switch (exp->elts[pc].opcode)
+ {
+ default:
+ n += 1;
+ break;
+ case OP_CHOICES:
+ n += exp->elts[pc + 1].longconst;
+ break;
+ }
+ ada_evaluate_subexp (NULL, exp, &pc, EVAL_SKIP);
+ }
+ return n;
+}
+
+/* Assign the result of evaluating EXP starting at *POS to the INDEXth
+ component of LHS (a simple array or a record), updating *POS past
+ the expression, assuming that LHS is contained in CONTAINER. Does
+ not modify the inferior's memory, nor does it modify LHS (unless
+ LHS == CONTAINER). */
+
+static void
+assign_component (struct value *container, struct value *lhs, LONGEST index,
+ struct expression *exp, int *pos)
+{
+ struct value *mark = value_mark ();
+ struct value *elt;
+ if (TYPE_CODE (value_type (lhs)) == TYPE_CODE_ARRAY)
+ {
+ struct value *index_val = value_from_longest (builtin_type_int, index);
+ elt = unwrap_value (ada_value_subscript (lhs, 1, &index_val));
+ }
+ else
+ {
+ elt = ada_index_struct_field (index, lhs, 0, value_type (lhs));
+ elt = ada_to_fixed_value (unwrap_value (elt));
+ }
+
+ if (exp->elts[*pos].opcode == OP_AGGREGATE)
+ assign_aggregate (container, elt, exp, pos, EVAL_NORMAL);
+ else
+ value_assign_to_component (container, elt,
+ ada_evaluate_subexp (NULL, exp, pos,
+ EVAL_NORMAL));
+
+ value_free_to_mark (mark);
+}
+
+/* Assuming that LHS represents an lvalue having a record or array
+ type, and EXP->ELTS[*POS] is an OP_AGGREGATE, evaluate an assignment
+ of that aggregate's value to LHS, advancing *POS past the
+ aggregate. NOSIDE is as for evaluate_subexp. CONTAINER is an
+ lvalue containing LHS (possibly LHS itself). Does not modify
+ the inferior's memory, nor does it modify the contents of
+ LHS (unless == CONTAINER). Returns the modified CONTAINER. */
+
+static struct value *
+assign_aggregate (struct value *container,
+ struct value *lhs, struct expression *exp,
+ int *pos, enum noside noside)
+{
+ struct type *lhs_type;
+ int n = exp->elts[*pos+1].longconst;
+ LONGEST low_index, high_index;
+ int num_specs;
+ LONGEST *indices;
+ int max_indices, num_indices;
+ int is_array_aggregate;
+ int i;
+ struct value *mark = value_mark ();
+
+ *pos += 3;
+ if (noside != EVAL_NORMAL)
+ {
+ int i;
+ for (i = 0; i < n; i += 1)
+ ada_evaluate_subexp (NULL, exp, pos, noside);
+ return container;
+ }
+
+ container = ada_coerce_ref (container);
+ if (ada_is_direct_array_type (value_type (container)))
+ container = ada_coerce_to_simple_array (container);
+ lhs = ada_coerce_ref (lhs);
+ if (!deprecated_value_modifiable (lhs))
+ error (_("Left operand of assignment is not a modifiable lvalue."));
+
+ lhs_type = value_type (lhs);
+ if (ada_is_direct_array_type (lhs_type))
+ {
+ lhs = ada_coerce_to_simple_array (lhs);
+ lhs_type = value_type (lhs);
+ low_index = TYPE_ARRAY_LOWER_BOUND_VALUE (lhs_type);
+ high_index = TYPE_ARRAY_UPPER_BOUND_VALUE (lhs_type);
+ is_array_aggregate = 1;
+ }
+ else if (TYPE_CODE (lhs_type) == TYPE_CODE_STRUCT)
+ {
+ low_index = 0;
+ high_index = num_visible_fields (lhs_type) - 1;
+ is_array_aggregate = 0;
+ }
+ else
+ error (_("Left-hand side must be array or record."));
+
+ num_specs = num_component_specs (exp, *pos - 3);
+ max_indices = 4 * num_specs + 4;
+ indices = alloca (max_indices * sizeof (indices[0]));
+ indices[0] = indices[1] = low_index - 1;
+ indices[2] = indices[3] = high_index + 1;
+ num_indices = 4;
+
+ for (i = 0; i < n; i += 1)
+ {
+ switch (exp->elts[*pos].opcode)
+ {
+ case OP_CHOICES:
+ aggregate_assign_from_choices (container, lhs, exp, pos, indices,
+ &num_indices, max_indices,
+ low_index, high_index);
+ break;
+ case OP_POSITIONAL:
+ aggregate_assign_positional (container, lhs, exp, pos, indices,
+ &num_indices, max_indices,
+ low_index, high_index);
+ break;
+ case OP_OTHERS:
+ if (i != n-1)
+ error (_("Misplaced 'others' clause"));
+ aggregate_assign_others (container, lhs, exp, pos, indices,
+ num_indices, low_index, high_index);
+ break;
+ default:
+ error (_("Internal error: bad aggregate clause"));
+ }
+ }
+
+ return container;
+}
+
+/* Assign into the component of LHS indexed by the OP_POSITIONAL
+ construct at *POS, updating *POS past the construct, given that
+ the positions are relative to lower bound LOW, where HIGH is the
+ upper bound. Record the position in INDICES[0 .. MAX_INDICES-1]
+ updating *NUM_INDICES as needed. CONTAINER is as for
+ assign_aggregate. */
+static void
+aggregate_assign_positional (struct value *container,
+ struct value *lhs, struct expression *exp,
+ int *pos, LONGEST *indices, int *num_indices,
+ int max_indices, LONGEST low, LONGEST high)
+{
+ LONGEST ind = longest_to_int (exp->elts[*pos + 1].longconst) + low;
+
+ if (ind - 1 == high)
+ warning (_("Extra components in aggregate ignored."));
+ if (ind <= high)
+ {
+ add_component_interval (ind, ind, indices, num_indices, max_indices);
+ *pos += 3;
+ assign_component (container, lhs, ind, exp, pos);
+ }
+ else
+ ada_evaluate_subexp (NULL, exp, pos, EVAL_SKIP);
+}
+
+/* Assign into the components of LHS indexed by the OP_CHOICES
+ construct at *POS, updating *POS past the construct, given that
+ the allowable indices are LOW..HIGH. Record the indices assigned
+ to in INDICES[0 .. MAX_INDICES-1], updating *NUM_INDICES as
+ needed. CONTAINER is as for assign_aggregate. */
+static void
+aggregate_assign_from_choices (struct value *container,
+ struct value *lhs, struct expression *exp,
+ int *pos, LONGEST *indices, int *num_indices,
+ int max_indices, LONGEST low, LONGEST high)
+{
+ int j;
+ int n_choices = longest_to_int (exp->elts[*pos+1].longconst);
+ int choice_pos, expr_pc;
+ int is_array = ada_is_direct_array_type (value_type (lhs));
+
+ choice_pos = *pos += 3;
+
+ for (j = 0; j < n_choices; j += 1)
+ ada_evaluate_subexp (NULL, exp, pos, EVAL_SKIP);
+ expr_pc = *pos;
+ ada_evaluate_subexp (NULL, exp, pos, EVAL_SKIP);
+
+ for (j = 0; j < n_choices; j += 1)
+ {
+ LONGEST lower, upper;
+ enum exp_opcode op = exp->elts[choice_pos].opcode;
+ if (op == OP_DISCRETE_RANGE)
+ {
+ choice_pos += 1;
+ lower = value_as_long (ada_evaluate_subexp (NULL, exp, pos,
+ EVAL_NORMAL));
+ upper = value_as_long (ada_evaluate_subexp (NULL, exp, pos,
+ EVAL_NORMAL));
+ }
+ else if (is_array)
+ {
+ lower = value_as_long (ada_evaluate_subexp (NULL, exp, &choice_pos,
+ EVAL_NORMAL));
+ upper = lower;
+ }
+ else
+ {
+ int ind;
+ char *name;
+ switch (op)
+ {
+ case OP_NAME:
+ name = &exp->elts[choice_pos + 2].string;
+ break;
+ case OP_VAR_VALUE:
+ name = SYMBOL_NATURAL_NAME (exp->elts[choice_pos + 2].symbol);
+ break;
+ default:
+ error (_("Invalid record component association."));
+ }
+ ada_evaluate_subexp (NULL, exp, &choice_pos, EVAL_SKIP);
+ ind = 0;
+ if (! find_struct_field (name, value_type (lhs), 0,
+ NULL, NULL, NULL, NULL, &ind))
+ error (_("Unknown component name: %s."), name);
+ lower = upper = ind;
+ }
+
+ if (lower <= upper && (lower < low || upper > high))
+ error (_("Index in component association out of bounds."));
+
+ add_component_interval (lower, upper, indices, num_indices,
+ max_indices);
+ while (lower <= upper)
+ {
+ int pos1;
+ pos1 = expr_pc;
+ assign_component (container, lhs, lower, exp, &pos1);
+ lower += 1;
+ }
+ }
+}
+
+/* Assign the value of the expression in the OP_OTHERS construct in
+ EXP at *POS into the components of LHS indexed from LOW .. HIGH that
+ have not been previously assigned. The index intervals already assigned
+ are in INDICES[0 .. NUM_INDICES-1]. Updates *POS to after the
+ OP_OTHERS clause. CONTAINER is as for assign_aggregate*/
+static void
+aggregate_assign_others (struct value *container,
+ struct value *lhs, struct expression *exp,
+ int *pos, LONGEST *indices, int num_indices,
+ LONGEST low, LONGEST high)
+{
+ int i;
+ int expr_pc = *pos+1;
+
+ for (i = 0; i < num_indices - 2; i += 2)
+ {
+ LONGEST ind;
+ for (ind = indices[i + 1] + 1; ind < indices[i + 2]; ind += 1)
+ {
+ int pos;
+ pos = expr_pc;
+ assign_component (container, lhs, ind, exp, &pos);
+ }
+ }
+ ada_evaluate_subexp (NULL, exp, pos, EVAL_SKIP);
+}
+
+/* Add the interval [LOW .. HIGH] to the sorted set of intervals
+ [ INDICES[0] .. INDICES[1] ],..., [ INDICES[*SIZE-2] .. INDICES[*SIZE-1] ],
+ modifying *SIZE as needed. It is an error if *SIZE exceeds
+ MAX_SIZE. The resulting intervals do not overlap. */
+static void
+add_component_interval (LONGEST low, LONGEST high,
+ LONGEST* indices, int *size, int max_size)
+{
+ int i, j;
+ for (i = 0; i < *size; i += 2) {
+ if (high >= indices[i] && low <= indices[i + 1])
+ {
+ int kh;
+ for (kh = i + 2; kh < *size; kh += 2)
+ if (high < indices[kh])
+ break;
+ if (low < indices[i])
+ indices[i] = low;
+ indices[i + 1] = indices[kh - 1];
+ if (high > indices[i + 1])
+ indices[i + 1] = high;
+ memcpy (indices + i + 2, indices + kh, *size - kh);
+ *size -= kh - i - 2;
+ return;
+ }
+ else if (high < indices[i])
+ break;
+ }
+
+ if (*size == max_size)
+ error (_("Internal error: miscounted aggregate components."));
+ *size += 2;
+ for (j = *size-1; j >= i+2; j -= 1)
+ indices[j] = indices[j - 2];
+ indices[i] = low;
+ indices[i + 1] = high;
+}
+
+static struct value *
ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
int pc;
struct value *arg1 = NULL, *arg2 = NULL, *arg3;
struct type *type;
- int nargs;
+ int nargs, oplen;
struct value **argvec;
pc = *pos;
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 (TYPE_CODE (value_type (result)) == TYPE_CODE_STRING)
+ TYPE_CODE (value_type (result)) = TYPE_CODE_ARRAY;
return result;
}
arg1 = evaluate_subexp (type, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- if (type != check_typedef (VALUE_TYPE (arg1)))
+ if (type != ada_check_typedef (value_type (arg1)))
{
if (ada_is_fixed_point_type (type))
arg1 = cast_to_fixed (type, arg1);
- else if (ada_is_fixed_point_type (VALUE_TYPE (arg1)))
+ else if (ada_is_fixed_point_type (value_type (arg1)))
arg1 = value_cast (type, cast_from_fixed_to_double (arg1));
else if (VALUE_LVAL (arg1) == lval_memory)
{
return value_zero (to_static_fixed_type (type), not_lval);
arg1 =
ada_to_fixed_value_create
- (type, VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1), 0);
+ (type, VALUE_ADDRESS (arg1) + value_offset (arg1), 0);
}
else
arg1 = value_cast (type, arg1);
case BINOP_ASSIGN:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+ if (exp->elts[*pos].opcode == OP_AGGREGATE)
+ {
+ arg1 = assign_aggregate (arg1, arg1, exp, pos, noside);
+ if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+ return arg1;
+ return ada_value_assign (arg1, arg1);
+ }
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
return arg1;
- if (ada_is_fixed_point_type (VALUE_TYPE (arg1)))
- arg2 = cast_to_fixed (VALUE_TYPE (arg1), arg2);
- else if (ada_is_fixed_point_type (VALUE_TYPE (arg2)))
+ if (ada_is_fixed_point_type (value_type (arg1)))
+ arg2 = cast_to_fixed (value_type (arg1), arg2);
+ else if (ada_is_fixed_point_type (value_type (arg2)))
error
- ("Fixed-point values must be assigned to fixed-point variables");
+ (_("Fixed-point values must be assigned to fixed-point variables"));
else
- arg2 = coerce_for_assign (VALUE_TYPE (arg1), arg2);
+ arg2 = coerce_for_assign (value_type (arg1), arg2);
return ada_value_assign (arg1, arg2);
case BINOP_ADD:
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- if ((ada_is_fixed_point_type (VALUE_TYPE (arg1))
- || ada_is_fixed_point_type (VALUE_TYPE (arg2)))
- && VALUE_TYPE (arg1) != VALUE_TYPE (arg2))
- error ("Operands of fixed-point addition must have the same type");
- return value_cast (VALUE_TYPE (arg1), value_add (arg1, arg2));
+ if ((ada_is_fixed_point_type (value_type (arg1))
+ || ada_is_fixed_point_type (value_type (arg2)))
+ && value_type (arg1) != value_type (arg2))
+ error (_("Operands of fixed-point addition must have the same type"));
+ return value_cast (value_type (arg1), value_add (arg1, arg2));
case BINOP_SUB:
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- if ((ada_is_fixed_point_type (VALUE_TYPE (arg1))
- || ada_is_fixed_point_type (VALUE_TYPE (arg2)))
- && VALUE_TYPE (arg1) != VALUE_TYPE (arg2))
- error ("Operands of fixed-point subtraction must have the same type");
- return value_cast (VALUE_TYPE (arg1), value_sub (arg1, arg2));
+ if ((ada_is_fixed_point_type (value_type (arg1))
+ || ada_is_fixed_point_type (value_type (arg2)))
+ && value_type (arg1) != value_type (arg2))
+ error (_("Operands of fixed-point subtraction must have the same type"));
+ return value_cast (value_type (arg1), value_sub (arg1, arg2));
case BINOP_MUL:
case BINOP_DIV:
goto nosideret;
else if (noside == EVAL_AVOID_SIDE_EFFECTS
&& (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD))
- return value_zero (VALUE_TYPE (arg1), not_lval);
+ return value_zero (value_type (arg1), not_lval);
else
{
- if (ada_is_fixed_point_type (VALUE_TYPE (arg1)))
+ if (ada_is_fixed_point_type (value_type (arg1)))
arg1 = cast_from_fixed_to_double (arg1);
- if (ada_is_fixed_point_type (VALUE_TYPE (arg2)))
+ if (ada_is_fixed_point_type (value_type (arg2)))
arg2 = cast_from_fixed_to_double (arg2);
return ada_value_binop (arg1, arg2, op);
}
goto nosideret;
else if (noside == EVAL_AVOID_SIDE_EFFECTS
&& (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD))
- return value_zero (VALUE_TYPE (arg1), not_lval);
+ return value_zero (value_type (arg1), not_lval);
else
return ada_value_binop (arg1, arg2, op);
case BINOP_EQUAL:
case BINOP_NOTEQUAL:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
if (noside == EVAL_AVOID_SIDE_EFFECTS)
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- else if (ada_is_fixed_point_type (VALUE_TYPE (arg1)))
- return value_cast (VALUE_TYPE (arg1), value_neg (arg1));
+ else if (ada_is_fixed_point_type (value_type (arg1)))
+ return value_cast (value_type (arg1), value_neg (arg1));
else
return value_neg (arg1);
else if (SYMBOL_DOMAIN (exp->elts[pc + 2].symbol) == UNDEF_DOMAIN)
/* Only encountered when an unresolved symbol occurs in a
context other than a function call, in which case, it is
- illegal. */
- error ("Unexpected unresolved symbol, %s, during evaluation",
+ invalid. */
+ error (_("Unexpected unresolved symbol, %s, during evaluation"),
SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
if (exp->elts[*pos].opcode == OP_VAR_VALUE
&& SYMBOL_DOMAIN (exp->elts[pc + 5].symbol) == UNDEF_DOMAIN)
- error ("Unexpected unresolved symbol, %s, during evaluation",
+ error (_("Unexpected unresolved symbol, %s, during evaluation"),
SYMBOL_PRINT_NAME (exp->elts[pc + 5].symbol));
else
{
goto nosideret;
}
- if (ada_is_packed_array_type (desc_base_type (VALUE_TYPE (argvec[0]))))
+ if (ada_is_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_REF
- || (TYPE_CODE (VALUE_TYPE (argvec[0])) == TYPE_CODE_ARRAY
+ else if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_REF
+ || (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_ARRAY
&& VALUE_LVAL (argvec[0]) == lval_memory))
argvec[0] = value_addr (argvec[0]);
- type = check_typedef (VALUE_TYPE (argvec[0]));
+ type = ada_check_typedef (value_type (argvec[0]));
if (TYPE_CODE (type) == TYPE_CODE_PTR)
{
- switch (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (type))))
+ switch (TYPE_CODE (ada_check_typedef (TYPE_TARGET_TYPE (type))))
{
case TYPE_CODE_FUNC:
- type = check_typedef (TYPE_TARGET_TYPE (type));
+ type = ada_check_typedef (TYPE_TARGET_TYPE (type));
break;
case TYPE_CODE_ARRAY:
break;
case TYPE_CODE_STRUCT:
if (noside != EVAL_AVOID_SIDE_EFFECTS)
argvec[0] = ada_value_ind (argvec[0]);
- type = check_typedef (TYPE_TARGET_TYPE (type));
+ type = ada_check_typedef (TYPE_TARGET_TYPE (type));
break;
default:
- error ("cannot subscript or call something of type `%s'",
- ada_type_name (VALUE_TYPE (argvec[0])));
+ error (_("cannot subscript or call something of type `%s'"),
+ ada_type_name (value_type (argvec[0])));
break;
}
}
arity = ada_array_arity (type);
type = ada_array_element_type (type, nargs);
if (type == NULL)
- error ("cannot subscript or call a record");
+ error (_("cannot subscript or call a record"));
if (arity != nargs)
- error ("wrong number of subscripts; expecting %d", arity);
+ error (_("wrong number of subscripts; expecting %d"), arity);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return allocate_value (ada_aligned_type (type));
return
{
type = ada_array_element_type (type, nargs);
if (type == NULL)
- error ("element type of array unknown");
+ error (_("element type of array unknown"));
else
return allocate_value (ada_aligned_type (type));
}
{
type = ada_array_element_type (type, nargs);
if (type == NULL)
- error ("element type of array unknown");
+ error (_("element type of array unknown"));
else
return allocate_value (ada_aligned_type (type));
}
nargs, argvec + 1));
default:
- error ("Internal error in evaluate_subexp");
+ error (_("Attempt to index or call something other than an "
+ "array or function"));
}
case TERNOP_SLICE:
struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
struct value *low_bound_val =
evaluate_subexp (NULL_TYPE, exp, pos, noside);
- LONGEST low_bound = pos_atr (low_bound_val);
- LONGEST high_bound
- = pos_atr (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+ struct value *high_bound_val =
+ evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ LONGEST low_bound;
+ LONGEST high_bound;
+ low_bound_val = coerce_ref (low_bound_val);
+ high_bound_val = coerce_ref (high_bound_val);
+ low_bound = pos_atr (low_bound_val);
+ high_bound = pos_atr (high_bound_val);
+
if (noside == EVAL_SKIP)
goto nosideret;
/* If this is a reference to an aligner type, then remove all
the aligners. */
- if (TYPE_CODE (VALUE_TYPE (array)) == 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 (TYPE_CODE (value_type (array)) == 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 (ada_is_packed_array_type (VALUE_TYPE (array)))
- error ("cannot slice a packed array");
+ if (ada_is_packed_array_type (value_type (array)))
+ error (_("cannot slice a packed 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 (TYPE_CODE (value_type (array)) == TYPE_CODE_REF
+ || (TYPE_CODE (value_type (array)) == TYPE_CODE_ARRAY
&& VALUE_LVAL (array) == lval_memory))
array = value_addr (array);
if (noside == EVAL_AVOID_SIDE_EFFECTS
- && ada_is_array_descriptor_type (check_typedef
- (VALUE_TYPE (array))))
+ && ada_is_array_descriptor_type (ada_check_typedef
+ (value_type (array))))
return empty_array (ada_type_of_array (array, 0), low_bound);
array = ada_coerce_to_simple_array_ptr (array);
- if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_PTR)
+ /* 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)))
+ == TYPE_CODE_PTR))
+ array = value_ind (array);
+
+ /* Make sure we really do have an array type before going further,
+ to avoid a SEGV when trying to get the index type or the target
+ type later down the road if the debug info generated by
+ the compiler is incorrect or incomplete. */
+ if (!ada_is_simple_array_type (value_type (array)))
+ error (_("cannot take slice of non-array"));
+
+ if (TYPE_CODE (value_type (array)) == TYPE_CODE_PTR)
{
if (high_bound < low_bound || noside == EVAL_AVOID_SIDE_EFFECTS)
- return empty_array (TYPE_TARGET_TYPE (VALUE_TYPE (array)),
+ return empty_array (TYPE_TARGET_TYPE (value_type (array)),
low_bound);
else
{
struct type *arr_type0 =
- to_fixed_array_type (TYPE_TARGET_TYPE (VALUE_TYPE (array)),
+ to_fixed_array_type (TYPE_TARGET_TYPE (value_type (array)),
NULL, 1);
return ada_value_slice_ptr (array, arr_type0,
- (int) low_bound, (int) high_bound);
+ longest_to_int (low_bound),
+ longest_to_int (high_bound));
}
}
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
return array;
else if (high_bound < low_bound)
- return empty_array (VALUE_TYPE (array), low_bound);
+ return empty_array (value_type (array), low_bound);
else
- return ada_value_slice (array, (int) low_bound, (int) high_bound);
+ return ada_value_slice (array, longest_to_int (low_bound),
+ longest_to_int (high_bound));
}
case UNOP_IN_RANGE:
switch (TYPE_CODE (type))
{
default:
- lim_warning ("Membership test incompletely implemented; "
- "always returns true", 0);
+ lim_warning (_("Membership test incompletely implemented; "
+ "always returns true"));
return value_from_longest (builtin_type_int, (LONGEST) 1);
case TYPE_CODE_RANGE:
tem = longest_to_int (exp->elts[pc + 1].longconst);
- if (tem < 1 || tem > ada_array_arity (VALUE_TYPE (arg2)))
- error ("invalid dimension number to '%s", "range");
+ if (tem < 1 || tem > ada_array_arity (value_type (arg2)))
+ error (_("invalid dimension number to 'range"));
arg3 = ada_array_bound (arg2, tem, 1);
arg2 = ada_array_bound (arg2, tem, 0);
}
if (exp->elts[*pos].opcode != OP_LONG)
- error ("illegal operand to '%s", ada_attribute_name (op));
+ error (_("Invalid operand to '%s"), ada_attribute_name (op));
tem = longest_to_int (exp->elts[*pos + 2].longconst);
*pos += 4;
{
arg1 = ada_coerce_ref (arg1);
- if (ada_is_packed_array_type (VALUE_TYPE (arg1)))
+ if (ada_is_packed_array_type (value_type (arg1)))
arg1 = ada_coerce_to_simple_array (arg1);
- if (tem < 1 || tem > ada_array_arity (VALUE_TYPE (arg1)))
- error ("invalid dimension number to '%s",
+ if (tem < 1 || tem > ada_array_arity (value_type (arg1)))
+ error (_("invalid dimension number to '%s"),
ada_attribute_name (op));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- type = ada_index_type (VALUE_TYPE (arg1), tem);
+ type = ada_index_type (value_type (arg1), tem);
if (type == NULL)
error
- ("attempt to take bound of something that is not an array");
+ (_("attempt to take bound of something that is not an array"));
return allocate_value (type);
}
switch (op)
{
default: /* Should never happen. */
- error ("unexpected attribute encountered");
+ error (_("unexpected attribute encountered"));
case OP_ATR_FIRST:
return ada_array_bound (arg1, tem, 0);
case OP_ATR_LAST:
switch (op)
{
default:
- error ("unexpected attribute encountered");
+ error (_("unexpected attribute encountered"));
case OP_ATR_FIRST:
return discrete_type_low_bound (range_type);
case OP_ATR_LAST:
return discrete_type_high_bound (range_type);
case OP_ATR_LENGTH:
- error ("the 'length attribute applies only to array types");
+ error (_("the 'length attribute applies only to array types"));
}
}
else if (TYPE_CODE (type_arg) == TYPE_CODE_FLT)
- error ("unimplemented type attribute");
+ error (_("unimplemented type attribute"));
else
{
LONGEST low, high;
type_arg = decode_packed_array_type (type_arg);
if (tem < 1 || tem > ada_array_arity (type_arg))
- error ("invalid dimension number to '%s",
+ error (_("invalid dimension number to '%s"),
ada_attribute_name (op));
type = ada_index_type (type_arg, tem);
if (type == NULL)
error
- ("attempt to take bound of something that is not an array");
+ (_("attempt to take bound of something that is not an array"));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return allocate_value (type);
switch (op)
{
default:
- error ("unexpected attribute encountered");
+ error (_("unexpected attribute encountered"));
case OP_ATR_FIRST:
low = ada_array_bound_from_type (type_arg, tem, 0, &type);
return value_from_longest (type, low);
if (noside == EVAL_SKIP)
goto nosideret;
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (VALUE_TYPE (arg1), not_lval);
+ return value_zero (value_type (arg1), not_lval);
else
return value_binop (arg1, arg2,
op == OP_ATR_MIN ? BINOP_MIN : BINOP_MAX);
goto nosideret;
if (!ada_is_modular_type (type_arg))
- error ("'modulus must be applied to modular type");
+ error (_("'modulus must be applied to modular type"));
return value_from_longest (TYPE_TARGET_TYPE (type_arg),
ada_modulus (type_arg));
if (noside == EVAL_SKIP)
goto nosideret;
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (builtin_type_ada_int, not_lval);
+ return value_zero (builtin_type_int, not_lval);
else
return value_pos_atr (arg1);
if (noside == EVAL_SKIP)
goto nosideret;
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (builtin_type_ada_int, not_lval);
+ return value_zero (builtin_type_int, not_lval);
else
- return value_from_longest (builtin_type_ada_int,
+ return value_from_longest (builtin_type_int,
TARGET_CHAR_BIT
- * TYPE_LENGTH (VALUE_TYPE (arg1)));
+ * TYPE_LENGTH (value_type (arg1)));
case OP_ATR_VAL:
evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
if (noside == EVAL_SKIP)
goto nosideret;
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (VALUE_TYPE (arg1), not_lval);
+ return value_zero (value_type (arg1), not_lval);
else
return value_binop (arg1, arg2, op);
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- if (value_less (arg1, value_zero (VALUE_TYPE (arg1), not_lval)))
+ if (value_less (arg1, value_zero (value_type (arg1), not_lval)))
return value_neg (arg1);
else
return arg1;
case UNOP_IND:
if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
- expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
+ expect_type = TYPE_TARGET_TYPE (ada_check_typedef (expect_type));
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- type = check_typedef (VALUE_TYPE (arg1));
+ type = ada_check_typedef (value_type (arg1));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
if (ada_is_array_descriptor_type (type))
{
struct type *arrType = ada_type_of_array (arg1, 0);
if (arrType == NULL)
- error ("Attempt to dereference null array pointer.");
- return value_at_lazy (arrType, 0, NULL);
+ 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
/* In C you can dereference an array to get the 1st elt. */
|| TYPE_CODE (type) == TYPE_CODE_ARRAY)
- return
- value_zero
- (to_static_fixed_type
- (ada_aligned_type (check_typedef (TYPE_TARGET_TYPE (type)))),
- lval_memory);
+ {
+ type = to_static_fixed_type
+ (ada_aligned_type
+ (ada_check_typedef (TYPE_TARGET_TYPE (type))));
+ check_size (type);
+ return value_zero (type, lval_memory);
+ }
else if (TYPE_CODE (type) == TYPE_CODE_INT)
/* GDB allows dereferencing an int. */
return value_zero (builtin_type_int, lval_memory);
else
- error ("Attempt to take contents of a non-pointer value.");
+ error (_("Attempt to take contents of a non-pointer value."));
}
arg1 = ada_coerce_ref (arg1); /* FIXME: What is this for?? */
- type = check_typedef (VALUE_TYPE (arg1));
+ type = ada_check_typedef (value_type (arg1));
if (ada_is_array_descriptor_type (type))
/* GDB allows dereferencing GNAT array descriptors. */
goto nosideret;
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- struct type *type1 = VALUE_TYPE (arg1);
+ struct type *type1 = value_type (arg1);
if (ada_is_tagged_type (type1, 1))
{
type = ada_lookup_struct_elt_type (type1,
return
ada_to_fixed_value (unwrap_value
(ada_value_struct_elt
- (arg1, &exp->elts[pc + 2].string, "record")));
+ (arg1, &exp->elts[pc + 2].string, 0)));
case OP_TYPE:
/* The value is not supposed to be used. This is here to make it
easier to accommodate expressions that contain types. */
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
return allocate_value (builtin_type_void);
else
- error ("Attempt to use a type name as an expression");
+ error (_("Attempt to use a type name as an expression"));
+
+ case OP_AGGREGATE:
+ case OP_CHOICES:
+ case OP_OTHERS:
+ case OP_DISCRETE_RANGE:
+ case OP_POSITIONAL:
+ case OP_NAME:
+ if (noside == EVAL_NORMAL)
+ switch (op)
+ {
+ case OP_NAME:
+ error (_("Undefined name, ambiguous name, or renaming used in "
+ "component association: %s."), &exp->elts[pc+2].string);
+ case OP_AGGREGATE:
+ error (_("Aggregates only allowed on the right of an assignment"));
+ default:
+ internal_error (__FILE__, __LINE__, _("aggregate apparently mangled"));
+ }
+
+ ada_forward_operator_length (exp, pc, &oplen, &nargs);
+ *pos += oplen - 1;
+ for (tem = 0; tem < nargs; tem += 1)
+ ada_evaluate_subexp (NULL, exp, pos, noside);
+ goto nosideret;
}
nosideret:
case 'G':
return get_var_value ("DEBUG_STRING_G", 0);
default:
- error ("invalid VAX floating-point type");
+ error (_("invalid VAX floating-point type"));
}
}
\f
k = pend - str;
}
- bound_val = ada_search_struct_field (bound, dval, 0, VALUE_TYPE (dval));
+ bound_val = ada_search_struct_field (bound, dval, 0, value_type (dval));
if (bound_val == NULL)
return 0;
if (err_msg == NULL)
return 0;
else
- error ("%s", err_msg);
+ error (("%s"), err_msg);
}
return value_of_variable (syms[0].sym, syms[0].block);
L = get_int_var_value (name_buf, &ok);
if (!ok)
{
- lim_warning ("Unknown lower bound, using 1.", 1);
+ lim_warning (_("Unknown lower bound, using 1."));
L = 1;
}
}
U = get_int_var_value (name_buf, &ok);
if (!ok)
{
- lim_warning ("Unknown upper bound, using %ld.", (long) L);
+ lim_warning (_("Unknown upper bound, using %ld."), (long) L);
U = L;
}
}
/* Assuming ada_is_modular_type (TYPE), the modulus of TYPE. */
-LONGEST
+ULONGEST
ada_modulus (struct type * type)
{
- return TYPE_HIGH_BOUND (type) + 1;
+ return (ULONGEST) TYPE_HIGH_BOUND (type) + 1;
}
\f
/* Operators */
OP_DEFN (OP_ATR_TAG, 1, 1, 0) \
OP_DEFN (OP_ATR_VAL, 1, 2, 0) \
OP_DEFN (UNOP_QUAL, 3, 1, 0) \
- OP_DEFN (UNOP_IN_RANGE, 3, 1, 0)
+ OP_DEFN (UNOP_IN_RANGE, 3, 1, 0) \
+ OP_DEFN (OP_OTHERS, 1, 1, 0) \
+ OP_DEFN (OP_POSITIONAL, 3, 1, 0) \
+ OP_DEFN (OP_DISCRETE_RANGE, 1, 2, 0)
static void
ada_operator_length (struct expression *exp, int pc, int *oplenp, int *argsp)
case op: *oplenp = len; *argsp = args; break;
ADA_OPERATORS;
#undef OP_DEFN
+
+ case OP_AGGREGATE:
+ *oplenp = 3;
+ *argsp = longest_to_int (exp->elts[pc - 2].longconst);
+ break;
+
+ case OP_CHOICES:
+ *oplenp = 3;
+ *argsp = longest_to_int (exp->elts[pc - 2].longconst) + 1;
+ break;
}
}
{
default:
return op_name_standard (opcode);
+
#define OP_DEFN(op, len, args, binop) case op: return #op;
ADA_OPERATORS;
#undef OP_DEFN
+
+ case OP_AGGREGATE:
+ return "OP_AGGREGATE";
+ case OP_CHOICES:
+ return "OP_CHOICES";
+ case OP_NAME:
+ return "OP_NAME";
}
}
/* As for operator_length, but assumes PC is pointing at the first
element of the operator, and gives meaningful results only for the
- Ada-specific operators. */
+ Ada-specific operators, returning 0 for *OPLENP and *ARGSP otherwise. */
static void
ada_forward_operator_length (struct expression *exp, int pc,
default:
*oplenp = *argsp = 0;
break;
+
#define OP_DEFN(op, len, args, binop) \
case op: *oplenp = len; *argsp = args; break;
ADA_OPERATORS;
#undef OP_DEFN
+
+ case OP_AGGREGATE:
+ *oplenp = 3;
+ *argsp = longest_to_int (exp->elts[pc + 1].longconst);
+ break;
+
+ case OP_CHOICES:
+ *oplenp = 3;
+ *argsp = longest_to_int (exp->elts[pc + 1].longconst) + 1;
+ break;
+
+ case OP_STRING:
+ case OP_NAME:
+ {
+ int len = longest_to_int (exp->elts[pc + 1].longconst);
+ *oplenp = 4 + BYTES_TO_EXP_ELEM (len + 1);
+ *argsp = 0;
+ break;
+ }
}
}
case UNOP_IN_RANGE:
case UNOP_QUAL:
- fprintf_filtered (stream, "Type @");
+ /* XXX: gdb_sprint_host_address, type_sprint */
+ fprintf_filtered (stream, _("Type @"));
gdb_print_host_address (exp->elts[pc + 1].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[pc + 1].type, NULL, stream, 0);
fprintf_filtered (stream, ")");
break;
case BINOP_IN_BOUNDS:
- fprintf_filtered (stream, " (%d)", (int) exp->elts[pc + 2].longconst);
+ fprintf_filtered (stream, " (%d)",
+ longest_to_int (exp->elts[pc + 2].longconst));
break;
case TERNOP_IN_RANGE:
break;
+ case OP_AGGREGATE:
+ case OP_OTHERS:
+ case OP_DISCRETE_RANGE:
+ case OP_POSITIONAL:
+ case OP_CHOICES:
+ break;
+
+ case OP_NAME:
+ case OP_STRING:
+ {
+ char *name = &exp->elts[elt + 2].string;
+ int len = longest_to_int (exp->elts[elt + 1].longconst);
+ fprintf_filtered (stream, "Text: `%.*s'", len, name);
+ break;
+ }
+
default:
return dump_subexp_body_standard (exp, stream, elt);
}
ada_print_subexp (struct expression *exp, int *pos,
struct ui_file *stream, enum precedence prec)
{
- int oplen, nargs;
+ int oplen, nargs, i;
int pc = *pos;
enum exp_opcode op = exp->elts[pc].opcode;
ada_forward_operator_length (exp, pc, &oplen, &nargs);
+ *pos += oplen;
switch (op)
{
default:
+ *pos -= oplen;
print_subexp_standard (exp, pos, stream, prec);
return;
case OP_VAR_VALUE:
- *pos += oplen;
fputs_filtered (SYMBOL_NATURAL_NAME (exp->elts[pc + 2].symbol), stream);
return;
case BINOP_IN_BOUNDS:
- *pos += oplen;
+ /* XXX: sprint_subexp */
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (" in ", stream);
print_subexp (exp, pos, stream, PREC_SUFFIX);
return;
case TERNOP_IN_RANGE:
- *pos += oplen;
if (prec >= PREC_EQUAL)
fputs_filtered ("(", stream);
+ /* XXX: sprint_subexp */
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (" in ", stream);
print_subexp (exp, pos, stream, PREC_EQUAL);
case OP_ATR_SIZE:
case OP_ATR_TAG:
case OP_ATR_VAL:
- *pos += oplen;
if (exp->elts[*pos].opcode == OP_TYPE)
{
if (TYPE_CODE (exp->elts[*pos + 1].type) != TYPE_CODE_VOID)
return;
case UNOP_QUAL:
- *pos += oplen;
type_print (exp->elts[pc + 1].type, "", stream, 0);
fputs_filtered ("'(", stream);
print_subexp (exp, pos, stream, PREC_PREFIX);
return;
case UNOP_IN_RANGE:
- *pos += oplen;
+ /* XXX: sprint_subexp */
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (" in ", stream);
LA_PRINT_TYPE (exp->elts[pc + 1].type, "", stream, 1, 0);
return;
+
+ case OP_DISCRETE_RANGE:
+ print_subexp (exp, pos, stream, PREC_SUFFIX);
+ fputs_filtered ("..", stream);
+ print_subexp (exp, pos, stream, PREC_SUFFIX);
+ return;
+
+ case OP_OTHERS:
+ fputs_filtered ("others => ", stream);
+ print_subexp (exp, pos, stream, PREC_SUFFIX);
+ return;
+
+ case OP_CHOICES:
+ for (i = 0; i < nargs-1; i += 1)
+ {
+ if (i > 0)
+ fputs_filtered ("|", stream);
+ print_subexp (exp, pos, stream, PREC_SUFFIX);
+ }
+ fputs_filtered (" => ", stream);
+ print_subexp (exp, pos, stream, PREC_SUFFIX);
+ return;
+
+ case OP_POSITIONAL:
+ print_subexp (exp, pos, stream, PREC_SUFFIX);
+ return;
+
+ case OP_AGGREGATE:
+ fputs_filtered ("(", stream);
+ for (i = 0; i < nargs; i += 1)
+ {
+ if (i > 0)
+ fputs_filtered (", ", stream);
+ print_subexp (exp, pos, stream, PREC_SUFFIX);
+ }
+ fputs_filtered (")", stream);
+ return;
}
}
{NULL, 0, 0, 0}
};
\f
- /* Assorted Types and Interfaces */
-
-struct type *builtin_type_ada_int;
-struct type *builtin_type_ada_short;
-struct type *builtin_type_ada_long;
-struct type *builtin_type_ada_long_long;
-struct type *builtin_type_ada_char;
-struct type *builtin_type_ada_float;
-struct type *builtin_type_ada_double;
-struct type *builtin_type_ada_long_double;
-struct type *builtin_type_ada_natural;
-struct type *builtin_type_ada_positive;
-struct type *builtin_type_ada_system_address;
-
-struct type **const (ada_builtin_types[]) =
-{
- &builtin_type_ada_int,
- &builtin_type_ada_long,
- &builtin_type_ada_short,
- &builtin_type_ada_char,
- &builtin_type_ada_float,
- &builtin_type_ada_double,
- &builtin_type_ada_long_long,
- &builtin_type_ada_long_double,
- &builtin_type_ada_natural, &builtin_type_ada_positive,
- /* The following types are carried over from C for convenience. */
-&builtin_type_int,
- &builtin_type_long,
- &builtin_type_short,
- &builtin_type_char,
- &builtin_type_float,
- &builtin_type_double,
- &builtin_type_long_long,
- &builtin_type_void,
- &builtin_type_signed_char,
- &builtin_type_unsigned_char,
- &builtin_type_unsigned_short,
- &builtin_type_unsigned_int,
- &builtin_type_unsigned_long,
- &builtin_type_unsigned_long_long,
- &builtin_type_long_double,
- &builtin_type_complex, &builtin_type_double_complex, 0};
-
-/* Not really used, but needed in the ada_language_defn. */
-
-static void
-emit_char (int c, struct ui_file *stream, int quoter)
-{
- ada_emit_char (c, stream, quoter, 1);
-}
-
-static int
-parse (void)
-{
- warnings_issued = 0;
- return ada_parse ();
-}
-
-static const struct exp_descriptor ada_exp_descriptor = {
- ada_print_subexp,
- ada_operator_length,
- ada_op_name,
- ada_dump_subexp_body,
- ada_evaluate_subexp
-};
-
-const struct language_defn ada_language_defn = {
- "ada", /* Language name */
- language_ada,
- ada_builtin_types,
- range_check_off,
- type_check_off,
- case_sensitive_on, /* Yes, Ada is case-insensitive, but
- that's not quite what this means. */
-#ifdef GNAT_GDB
- ada_lookup_symbol,
- ada_lookup_minimal_symbol,
-#endif /* GNAT_GDB */
- &ada_exp_descriptor,
- parse,
- ada_error,
- resolve,
- ada_printchar, /* Print a character constant */
- ada_printstr, /* Function to print string constant */
- emit_char, /* Function to print single char (not used) */
- ada_create_fundamental_type, /* Create fundamental type in this language */
- ada_print_type, /* Print a type using appropriate syntax */
- ada_val_print, /* Print a value using appropriate syntax */
- ada_value_print, /* Print a top-level value */
- NULL, /* Language specific skip_trampoline */
- NULL, /* value_of_this */
- ada_lookup_symbol_nonlocal, /* Looking up non-local symbols. */
- basic_lookup_transparent_type, /* lookup_transparent_type */
- ada_la_decode, /* Language specific symbol demangler */
- NULL, /* Language specific class_name_from_physname */
- {"", "", "", ""}, /* Binary format info */
- /* Copied from c-lang.c. */
- {"0%lo", "0", "o", ""}, /* Octal format info */
- {"%ld", "", "d", ""}, /* Decimal format info */
- {"0x%lx", "0x", "x", ""}, /* Hex format info */
- ada_op_print_tab, /* expression operators for printing */
- 0, /* c-style arrays */
- 1, /* String lower bound */
- &builtin_type_ada_char,
- ada_get_gdb_completer_word_break_characters,
-#ifdef GNAT_GDB
- ada_translate_error_message, /* Substitute Ada-specific terminology
- in errors and warnings. */
-#endif /* GNAT_GDB */
- LANG_MAGIC
-};
-
-static void
-build_ada_types (struct gdbarch *current_gdbarch)
-{
- builtin_type_ada_int =
- init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
- 0, "integer", (struct objfile *) NULL);
- builtin_type_ada_long =
- init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
- 0, "long_integer", (struct objfile *) NULL);
- builtin_type_ada_short =
- init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
- 0, "short_integer", (struct objfile *) NULL);
- builtin_type_ada_char =
- init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
- 0, "character", (struct objfile *) NULL);
- builtin_type_ada_float =
- init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
- 0, "float", (struct objfile *) NULL);
- builtin_type_ada_double =
- init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
- 0, "long_float", (struct objfile *) NULL);
- builtin_type_ada_long_long =
- init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
- 0, "long_long_integer", (struct objfile *) NULL);
- builtin_type_ada_long_double =
- init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
- 0, "long_long_float", (struct objfile *) NULL);
- builtin_type_ada_natural =
- init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
- 0, "natural", (struct objfile *) NULL);
- builtin_type_ada_positive =
- init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
- 0, "positive", (struct objfile *) NULL);
-
-
- builtin_type_ada_system_address =
- lookup_pointer_type (init_type (TYPE_CODE_VOID, 1, 0, "void",
- (struct objfile *) NULL));
- TYPE_NAME (builtin_type_ada_system_address) = "system__address";
-}
-
-void
-_initialize_ada_language (void)
-{
-
- build_ada_types (current_gdbarch);
- gdbarch_data_register_post_init (build_ada_types);
- add_language (&ada_language_defn);
-
- varsize_limit = 65536;
-#ifdef GNAT_GDB
- add_setshow_uinteger_cmd ("varsize-limit", class_support,
- &varsize_limit, "\
-Set the maximum number of bytes allowed in a dynamic-sized object.", "\
-Show the maximum number of bytes allowed in a dynamic-sized object.",
- NULL, NULL, &setlist, &showlist);
- obstack_init (&cache_space);
-#endif /* GNAT_GDB */
-
- obstack_init (&symbol_list_obstack);
-
- decoded_names_store = htab_create_alloc_ex
- (256, htab_hash_string, (int (*)(const void *, const void *)) streq,
- NULL, NULL, xmcalloc, xmfree);
-}
+ /* Fundamental Ada Types */
/* Create a fundamental Ada type using default reasonable for the current
target machine.
type = init_type (TYPE_CODE_INT,
TARGET_INT_BIT / TARGET_CHAR_BIT,
0, "<?type?>", objfile);
- warning ("internal error: no Ada fundamental type %d", typeid);
+ warning (_("internal error: no Ada fundamental type %d"), typeid);
break;
case FT_VOID:
type = init_type (TYPE_CODE_VOID,
0, "integer", objfile);
break;
case FT_SIGNED_INTEGER:
- type = init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT, 0, "integer", objfile); /* FIXME -fnf */
+ type = init_type (TYPE_CODE_INT, TARGET_INT_BIT /
+ TARGET_CHAR_BIT,
+ 0, "integer", objfile); /* FIXME -fnf */
break;
case FT_UNSIGNED_INTEGER:
type = init_type (TYPE_CODE_INT,
return (type);
}
+enum ada_primitive_types {
+ ada_primitive_type_int,
+ ada_primitive_type_long,
+ ada_primitive_type_short,
+ ada_primitive_type_char,
+ ada_primitive_type_float,
+ ada_primitive_type_double,
+ ada_primitive_type_void,
+ ada_primitive_type_long_long,
+ ada_primitive_type_long_double,
+ ada_primitive_type_natural,
+ ada_primitive_type_positive,
+ ada_primitive_type_system_address,
+ nr_ada_primitive_types
+};
+
+static void
+ada_language_arch_info (struct gdbarch *current_gdbarch,
+ struct language_arch_info *lai)
+{
+ const struct builtin_type *builtin = builtin_type (current_gdbarch);
+ lai->primitive_type_vector
+ = GDBARCH_OBSTACK_CALLOC (current_gdbarch, nr_ada_primitive_types + 1,
+ struct type *);
+ lai->primitive_type_vector [ada_primitive_type_int] =
+ init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+ 0, "integer", (struct objfile *) NULL);
+ lai->primitive_type_vector [ada_primitive_type_long] =
+ init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
+ 0, "long_integer", (struct objfile *) NULL);
+ lai->primitive_type_vector [ada_primitive_type_short] =
+ init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
+ 0, "short_integer", (struct objfile *) NULL);
+ lai->string_char_type =
+ lai->primitive_type_vector [ada_primitive_type_char] =
+ init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+ 0, "character", (struct objfile *) NULL);
+ lai->primitive_type_vector [ada_primitive_type_float] =
+ init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
+ 0, "float", (struct objfile *) NULL);
+ lai->primitive_type_vector [ada_primitive_type_double] =
+ init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
+ 0, "long_float", (struct objfile *) NULL);
+ lai->primitive_type_vector [ada_primitive_type_long_long] =
+ init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
+ 0, "long_long_integer", (struct objfile *) NULL);
+ lai->primitive_type_vector [ada_primitive_type_long_double] =
+ init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
+ 0, "long_long_float", (struct objfile *) NULL);
+ lai->primitive_type_vector [ada_primitive_type_natural] =
+ init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+ 0, "natural", (struct objfile *) NULL);
+ lai->primitive_type_vector [ada_primitive_type_positive] =
+ init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+ 0, "positive", (struct objfile *) NULL);
+ lai->primitive_type_vector [ada_primitive_type_void] = builtin->builtin_void;
+
+ lai->primitive_type_vector [ada_primitive_type_system_address] =
+ lookup_pointer_type (init_type (TYPE_CODE_VOID, 1, 0, "void",
+ (struct objfile *) NULL));
+ TYPE_NAME (lai->primitive_type_vector [ada_primitive_type_system_address])
+ = "system__address";
+}
+\f
+ /* Language vector */
+
+/* Not really used, but needed in the ada_language_defn. */
+
+static void
+emit_char (int c, struct ui_file *stream, int quoter)
+{
+ ada_emit_char (c, stream, quoter, 1);
+}
+
+static int
+parse (void)
+{
+ warnings_issued = 0;
+ return ada_parse ();
+}
+
+static const struct exp_descriptor ada_exp_descriptor = {
+ ada_print_subexp,
+ ada_operator_length,
+ ada_op_name,
+ ada_dump_subexp_body,
+ ada_evaluate_subexp
+};
+
+const struct language_defn ada_language_defn = {
+ "ada", /* Language name */
+ language_ada,
+ NULL,
+ range_check_off,
+ type_check_off,
+ case_sensitive_on, /* Yes, Ada is case-insensitive, but
+ that's not quite what this means. */
+ array_row_major,
+ &ada_exp_descriptor,
+ parse,
+ ada_error,
+ resolve,
+ ada_printchar, /* Print a character constant */
+ ada_printstr, /* Function to print string constant */
+ emit_char, /* Function to print single char (not used) */
+ ada_create_fundamental_type, /* Create fundamental type in this language */
+ ada_print_type, /* Print a type using appropriate syntax */
+ ada_val_print, /* Print a value using appropriate syntax */
+ ada_value_print, /* Print a top-level value */
+ NULL, /* Language specific skip_trampoline */
+ NULL, /* value_of_this */
+ ada_lookup_symbol_nonlocal, /* Looking up non-local symbols. */
+ basic_lookup_transparent_type, /* lookup_transparent_type */
+ ada_la_decode, /* Language specific symbol demangler */
+ NULL, /* Language specific class_name_from_physname */
+ ada_op_print_tab, /* expression operators for printing */
+ 0, /* c-style arrays */
+ 1, /* String lower bound */
+ NULL,
+ ada_get_gdb_completer_word_break_characters,
+ ada_language_arch_info,
+ ada_print_array_index,
+ LANG_MAGIC
+};
+
void
-ada_dump_symtab (struct symtab *s)
+_initialize_ada_language (void)
{
- int i;
- fprintf (stderr, "New symtab: [\n");
- fprintf (stderr, " Name: %s/%s;\n",
- s->dirname ? s->dirname : "?", s->filename ? s->filename : "?");
- fprintf (stderr, " Format: %s;\n", s->debugformat);
- if (s->linetable != NULL)
- {
- fprintf (stderr, " Line table (section %d):\n", s->block_line_section);
- for (i = 0; i < s->linetable->nitems; i += 1)
- {
- struct linetable_entry *e = s->linetable->item + i;
- fprintf (stderr, " %4ld: %8lx\n", (long) e->line, (long) e->pc);
- }
- }
- fprintf (stderr, "]\n");
+ add_language (&ada_language_defn);
+
+ varsize_limit = 65536;
+
+ obstack_init (&symbol_list_obstack);
+
+ decoded_names_store = htab_create_alloc
+ (256, htab_hash_string, (int (*)(const void *, const void *)) streq,
+ NULL, xcalloc, xfree);
}
projects / deliverable / binutils-gdb.git / blobdiff