-/* Ada language support routines for GDB, the GNU debugger. Copyright
+/* 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.
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. */
+Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#include "defs.h"
static int is_dynamic_field (struct type *, int);
static struct type *to_fixed_variant_branch_type (struct type *,
- const bfd_byte *,
+ 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 *);
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 *);
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 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[] =
return ada_completer_word_break_characters;
}
+/* Print an array element index using the Ada syntax. */
+
+static void
+ada_print_array_index (struct value *index_value, struct ui_file *stream,
+ int format, enum val_prettyprint pretty)
+{
+ LA_VALUE_PRINT (index_value, stream, format, pretty);
+ fprintf_filtered (stream, " => ");
+}
+
/* Read the string located at ADDR from the inferior and store the
result into BUF. */
struct value *
value_from_contents_and_address (struct type *type,
- const bfd_byte *valaddr,
+ 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;
result = allocate_value (type);
VALUE_LVAL (result) = VALUE_LVAL (val);
- result->bitsize = value_bitsize (val);
- result->bitpos = value_bitpos (val);
+ 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)
+ if (value_lazy (val)
|| TYPE_LENGTH (type) > TYPE_LENGTH (value_type (val)))
- VALUE_LAZY (result) = 1;
+ 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 const bfd_byte *
-cond_offset_host (const bfd_byte *valaddr, long offset)
+static const gdb_byte *
+cond_offset_host (const gdb_byte *valaddr, long offset)
{
if (valaddr == NULL)
return NULL;
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
|| 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
arity -= 1;
create_range_type (range_type, value_type (low),
- (int) value_as_long (low),
- (int) value_as_long (high));
+ 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 *arrVal = ada_coerce_to_simple_array_ptr (arr);
if (arrVal == NULL)
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)))
struct value *mark = value_mark ();
struct value *dummy = value_from_longest (builtin_type_long, 0);
struct type *result;
- dummy->type = type;
+ deprecated_set_value_type (dummy, type);
result = ada_type_of_array (dummy, 0);
value_free_to_mark (mark);
return result;
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;
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);
else
{
v = allocate_value (type);
- bytes = (unsigned char *) VALUE_CONTENTS (obj) + offset;
+ bytes = (unsigned char *) value_contents (obj) + offset;
}
if (obj != NULL)
if (VALUE_LVAL (obj) == lval_internalvar)
VALUE_LVAL (v) = lval_internalvar_component;
VALUE_ADDRESS (v) = VALUE_ADDRESS (obj) + value_offset (obj) + offset;
- v->bitpos = bit_offset + value_bitpos (obj);
- v->bitsize = bit_size;
+ 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;
- v->bitpos -= HOST_CHAR_BIT;
+ set_value_bitpos (v, value_bitpos (v) - HOST_CHAR_BIT);
}
}
else
- v->bitsize = 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
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);
+
+ 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);
- toval = coerce_ref (toval);
+ if (!deprecated_value_modifiable (toval))
+ error (_("Left operand of assignment is not a modifiable lvalue."));
if (VALUE_LVAL (toval) == lval_memory
&& bits > 0
+ 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),
+ 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));
- val->type = 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. */
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:
}
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:
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"),
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);
result[len] = '\000';
return result;
}
+
\f
/* Evaluation: Function Calls */
*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;
struct value *val;
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);
}
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));
size_t tmp;
struct ada_symbol_info *prevDefns = defns_collected (obstackp, 0);
- if (SYMBOL_TYPE (sym) != NULL)
- SYMBOL_TYPE (sym) = ada_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))
"_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;
*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]
+ _E[0-9]+[bs]$ [protected object entry suffixes]
(X[nb]*)?((\$|__)[0-9](_?[0-9]+)|___(JM|LJM|X([FDBUP].*|R[^T]?)))?$
*/
return 1;
}
- if (matching[0] == '.')
+ if (matching[0] == '.' || matching[0] == '$')
{
matching += 1;
while (isdigit (matching[0]))
return 1;
}
+#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
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;
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
static struct value *
value_tag_from_contents_and_address (struct type *type,
- const bfd_byte *valaddr,
+ 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))
{
- const bfd_byte *valaddr1 = ((valaddr == NULL)
+ const gdb_byte *valaddr1 = ((valaddr == NULL)
? NULL
: valaddr + tag_byte_offset);
CORE_ADDR address1 = (address == 0) ? 0 : address + tag_byte_offset;
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;
- val = ada_value_struct_elt (val, "expanded_name", NULL);
+ 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", 1);
if (val == NULL)
return 0;
read_memory_string (value_as_address (val), name, sizeof (name) - 1);
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;
type = ada_check_typedef (type);
- *field_type_p = NULL;
- *byte_offset_p = *bit_offset_p = *bit_size_p = 0;
- for (i = TYPE_NFIELDS (type) - 1; i >= 0; i -= 1)
+ 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 = 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 = ada_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.
int i;
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 = 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;
{
t1 = TYPE_TARGET_TYPE (t);
if (t1 == NULL)
- {
- if (err == NULL)
- return NULL;
- else
- error (_("Bad value type in a %s."), err);
- }
+ goto BadValue;
t1 = ada_check_typedef (t1);
if (TYPE_CODE (t1) == TYPE_CODE_PTR)
{
{
t1 = TYPE_TARGET_TYPE (t);
if (t1 == NULL)
- {
- if (err == NULL)
- return NULL;
- else
- error (_("Bad value type in a %s."), err);
- }
+ goto BadValue;
t1 = ada_check_typedef (t1);
if (TYPE_CODE (t1) == TYPE_CODE_PTR)
{
}
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)
{
}
}
- if (v == NULL && err != NULL)
+ 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.
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;
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
struct type *
ada_template_to_fixed_record_type_1 (struct type *type,
- const bfd_byte *valaddr,
+ const gdb_byte *valaddr,
CORE_ADDR address, struct value *dval0,
int keep_dynamic_fields)
{
of 1. */
static struct type *
-template_to_fixed_record_type (struct type *type, const bfd_byte *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,
contains the necessary discriminant values. */
static struct type *
-to_record_with_fixed_variant_part (struct type *type, const bfd_byte *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, const bfd_byte *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, const bfd_byte *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));
/* 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. */
+ /* 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)
{
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, const bfd_byte *valaddr,
+ada_to_fixed_type (struct type *type, const gdb_byte *valaddr,
CORE_ADDR address, struct value *dval)
{
type = ada_check_typedef (type);
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,
{
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
/* 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),
|| TYPE_LENGTH (TYPE_TARGET_TYPE (type2))
!= TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
error (_("Incompatible types in assignment"));
- val->type = type;
+ deprecated_set_value_type (val, type);
}
return val;
}
}
val = allocate_value (type1);
- store_unsigned_integer (VALUE_CONTENTS_RAW (val),
+ store_unsigned_integer (value_contents_raw (val),
TYPE_LENGTH (value_type (val)), v);
return val;
}
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),
+ && 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;
case BINOP_ASSIGN:
arg1 = evaluate_subexp (NULL_TYPE, 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;
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. */
+ invalid. */
error (_("Unexpected unresolved symbol, %s, during evaluation"),
SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
nargs, argvec + 1));
default:
- error (_("Attempt to index or call something other than an \
-array or function"));
+ error (_("Attempt to index or call something other than an "
+ "array or function"));
}
case TERNOP_SLICE:
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)
else if (high_bound < 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"));
+ lim_warning (_("Membership test incompletely implemented; "
+ "always returns true"));
return value_from_longest (builtin_type_int, (LONGEST) 1);
case TYPE_CODE_RANGE:
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. */
return allocate_value (builtin_type_void);
else
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:
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);
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;
+ }
}
}
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:
/* XXX: sprint_subexp */
- *pos += oplen;
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 */
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,
ada_get_gdb_completer_word_break_characters,
ada_language_arch_info,
+ ada_print_array_index,
LANG_MAGIC
};
projects / deliverable / binutils-gdb.git / blobdiff