Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity

* ada-lang.c: run through gdb_indent.sh

Browse Source 
* ada-lang.h: run through gdb_indent.sh
        * ada-tasks.c: run through gdb_indent.sh
        * ada-typeprint.c: run through gdb_indent.sh
        * ada-valprint.c: run through gdb_indent.sh
This commit is contained in:
Aidan Skinner
2002-08-18 18:11:12 +00:00
parent 01fc4e33eb
commit d2e4a39e32
6 changed files with 3279 additions and 3167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

281
gdb/ada-valprint.c
View File

@@ -32,9 +32,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "c-lang.h"
/* Encapsulates arguments to ada_val_print. */
struct ada_val_print_args {
struct type* type;
char* valaddr0;
struct ada_val_print_args
{
struct type *type;
char *valaddr0;
int embedded_offset;
CORE_ADDR address;
struct ui_file *stream;
@@ -47,45 +48,47 @@ struct ada_val_print_args {
extern int inspect_it;
extern unsigned int repeat_count_threshold;
static void print_record (struct type*, char*, struct ui_file*, int,
static void print_record (struct type *, char *, struct ui_file *, int,
int, enum val_prettyprint);
static int print_field_values (struct type*, char*, struct ui_file*,
static int print_field_values (struct type *, char *, struct ui_file *,
int, int, enum val_prettyprint,
int, struct type*, char*);
int, struct type *, char *);
static int print_variant_part (struct type*, int, char*,
struct ui_file*, int, int, enum val_prettyprint,
int, struct type*, char*);
static int print_variant_part (struct type *, int, char *,
struct ui_file *, int, int,
enum val_prettyprint, int, struct type *,
char *);
static void val_print_packed_array_elements (struct type*, char *valaddr, int,
struct ui_file*, int, int,
static void val_print_packed_array_elements (struct type *, char *valaddr,
int, struct ui_file *, int, int,
enum val_prettyprint);
static void adjust_type_signedness (struct type*);
static void adjust_type_signedness (struct type *);
static int ada_val_print_stub (PTR args0);
static int ada_val_print_1 (struct type*, char*, int, CORE_ADDR, struct ui_file*,
int, int, int, enum val_prettyprint);
static int ada_val_print_1 (struct type *, char *, int, CORE_ADDR,
struct ui_file *, int, int, int,
enum val_prettyprint);
/* Make TYPE unsigned if its range of values includes no negatives. */
static void
static void
adjust_type_signedness (type)
struct type* type;
struct type *type;
{
if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
&& TYPE_LOW_BOUND (type) >= 0)
TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
}
}
/* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
if non-standard (i.e., other than 1 for numbers, other than lower bound
of index type for enumerated type). Returns 1 if something printed,
otherwise 0. */
static int
static int
print_optional_low_bound (struct ui_file *stream, struct type *type)
{
struct type *index_type;
@@ -96,27 +99,28 @@ print_optional_low_bound (struct ui_file *stream, struct type *type)
if (index_type == NULL)
return 0;
if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
{
low_bound = TYPE_LOW_BOUND (index_type);
index_type = TYPE_TARGET_TYPE (index_type);
}
else
return 0;
switch (TYPE_CODE (index_type)) {
case TYPE_CODE_ENUM:
if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
return 0;
break;
case TYPE_CODE_UNDEF:
index_type = builtin_type_long;
/* FALL THROUGH */
default:
if (low_bound == 1)
return 0;
break;
}
switch (TYPE_CODE (index_type))
{
case TYPE_CODE_ENUM:
if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
return 0;
break;
case TYPE_CODE_UNDEF:
index_type = builtin_type_long;
/* FALL THROUGH */
default:
if (low_bound == 1)
return 0;
break;
}
ada_print_scalar (index_type, (LONGEST) low_bound, stream);
fprintf_filtered (stream, " => ");
@@ -128,7 +132,7 @@ print_optional_low_bound (struct ui_file *stream, struct type *type)
BITOFFSET from VALADDR on STREAM. Formats according to FORMAT and
separates with commas. RECURSE is the recursion (nesting) level.
If PRETTY, uses "prettier" format. TYPE must have been decoded (as
by ada_coerce_to_simple_array). */
by ada_coerce_to_simple_array). */
static void
val_print_packed_array_elements (struct type *type, char *valaddr,
@@ -147,8 +151,8 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
/* Number of repetitions we have detected so far. */
unsigned int reps;
unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
struct value* mark = value_mark ();
struct value *mark = value_mark ();
elttype = TYPE_TARGET_TYPE (type);
eltlen = TYPE_LENGTH (check_typedef (elttype));
@@ -183,7 +187,7 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
wrap_here (n_spaces (2 + 2 * recurse));
i0 = i;
v0 = ada_value_primitive_packed_val (NULL, valaddr,
v0 = ada_value_primitive_packed_val (NULL, valaddr,
(i0 * bitsize) / HOST_CHAR_BIT,
(i0 * bitsize) % HOST_CHAR_BIT,
bitsize, elttype);
@@ -192,12 +196,11 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
i += 1;
if (i >= len)
break;
v1 = ada_value_primitive_packed_val (NULL, valaddr,
v1 = ada_value_primitive_packed_val (NULL, valaddr,
(i * bitsize) / HOST_CHAR_BIT,
(i * bitsize) % HOST_CHAR_BIT,
bitsize, elttype);
if (memcmp (VALUE_CONTENTS (v0), VALUE_CONTENTS (v1), eltlen)
!= 0)
if (memcmp (VALUE_CONTENTS (v0), VALUE_CONTENTS (v1), eltlen) != 0)
break;
}
@@ -215,7 +218,7 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
int j;
for (j = i0; j < i; j += 1)
{
if (j > i0)
if (j > i0)
{
if (prettyprint_arrays)
{
@@ -244,8 +247,8 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
value_free_to_mark (mark);
}
static struct type*
printable_val_type (struct type* type, char* valaddr)
static struct type *
printable_val_type (struct type *type, char *valaddr)
{
return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL);
}
@@ -270,19 +273,19 @@ ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len)
fprintf_filtered (stream, "%c", c);
}
else
fprintf_filtered (stream, "[\"%0*x\"]", type_len*2, c);
fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
}
/* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
or 2) of a character. */
static int
char_at (char* string, int i, int type_len)
char_at (char *string, int i, int type_len)
{
if (type_len == 1)
return string[i];
else
return (int) extract_unsigned_integer (string + 2*i, 2);
else
return (int) extract_unsigned_integer (string + 2 * i, 2);
}
void
@@ -390,7 +393,7 @@ printstr (struct ui_file *stream, char *string, unsigned int length,
for (i = 0; i < length && things_printed < print_max; i += 1)
{
/* Position of the character we are examining
to see whether it is repeated. */
to see whether it is repeated. */
unsigned int rep1;
/* Number of repetitions we have detected so far. */
unsigned int reps;
@@ -405,8 +408,9 @@ printstr (struct ui_file *stream, char *string, unsigned int length,
rep1 = i + 1;
reps = 1;
while (rep1 < length &&
char_at(string, rep1, type_len) == char_at (string, i, type_len))
while (rep1 < length &&
char_at (string, rep1, type_len) == char_at (string, i,
type_len))
{
rep1 += 1;
reps += 1;
@@ -423,7 +427,8 @@ printstr (struct ui_file *stream, char *string, unsigned int length,
in_quotes = 0;
}
fputs_filtered ("'", stream);
ada_emit_char (char_at (string, i, type_len), stream, '\'', type_len);
ada_emit_char (char_at (string, i, type_len), stream, '\'',
type_len);
fputs_filtered ("'", stream);
fprintf_filtered (stream, " <repeats %u times>", reps);
i = rep1 - 1;
@@ -487,12 +492,13 @@ ada_printstr (struct ui_file *stream, char *string, unsigned int length,
arrays.) */
int
ada_val_print (struct type* type, char* valaddr0, int embedded_offset,
ada_val_print (struct type *type, char *valaddr0, int embedded_offset,
CORE_ADDR address, struct ui_file *stream, int format,
int deref_ref, int recurse, enum val_prettyprint pretty)
{
struct ada_val_print_args args;
args.type = type; args.valaddr0 = valaddr0;
args.type = type;
args.valaddr0 = valaddr0;
args.embedded_offset = embedded_offset;
args.address = address;
args.stream = stream;
@@ -509,18 +515,18 @@ ada_val_print (struct type* type, char* valaddr0, int embedded_offset,
static int
ada_val_print_stub (PTR args0)
{
struct ada_val_print_args* argsp = (struct ada_val_print_args*) args0;
return ada_val_print_1 (argsp->type, argsp->valaddr0, argsp->embedded_offset,
argsp->address, argsp->stream, argsp->format,
argsp->deref_ref, argsp->recurse,
argsp->pretty);
struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
return ada_val_print_1 (argsp->type, argsp->valaddr0,
argsp->embedded_offset, argsp->address,
argsp->stream, argsp->format, argsp->deref_ref,
argsp->recurse, argsp->pretty);
}
/* See the comment on ada_val_print. This function differs in that it
* does not catch evaluation errors (leaving that to ada_val_print). */
static int
ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
ada_val_print_1 (struct type *type, char *valaddr0, int embedded_offset,
CORE_ADDR address, struct ui_file *stream, int format,
int deref_ref, int recurse, enum val_prettyprint pretty)
{
@@ -530,15 +536,15 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
unsigned int eltlen;
LONGEST val;
CORE_ADDR addr;
char* valaddr = valaddr0 + embedded_offset;
char *valaddr = valaddr0 + embedded_offset;
CHECK_TYPEDEF (type);
if (ada_is_array_descriptor (type) || ada_is_packed_array_type (type))
{
int retn;
struct value* mark = value_mark ();
struct value* val;
struct value *mark = value_mark ();
struct value *val;
val = value_from_contents_and_address (type, valaddr, address);
val = ada_coerce_to_simple_array_ptr (val);
if (val == NULL)
@@ -548,7 +554,7 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
}
else
retn = ada_val_print_1 (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
VALUE_ADDRESS (val), stream, format,
VALUE_ADDRESS (val), stream, format,
deref_ref, recurse, pretty);
value_free_to_mark (mark);
return retn;
@@ -561,7 +567,7 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
switch (TYPE_CODE (type))
{
default:
return c_val_print (type, valaddr0, embedded_offset, address, stream,
return c_val_print (type, valaddr0, embedded_offset, address, stream,
format, deref_ref, recurse, pretty);
case TYPE_CODE_INT:
@@ -577,26 +583,26 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
}
else if (ada_is_vax_floating_type (type))
{
struct value* val =
struct value *val =
value_from_contents_and_address (type, valaddr, address);
struct value* func = ada_vax_float_print_function (type);
struct value *func = ada_vax_float_print_function (type);
if (func != 0)
{
static struct type* parray_of_char = NULL;
struct value* printable_val;
static struct type *parray_of_char = NULL;
struct value *printable_val;
if (parray_of_char == NULL)
parray_of_char =
make_pointer_type
(create_array_type
(NULL, builtin_type_char,
create_range_type (NULL, builtin_type_int, 0, 32)),
NULL);
if (parray_of_char == NULL)
parray_of_char =
make_pointer_type
(create_array_type
(NULL, builtin_type_char,
create_range_type (NULL, builtin_type_int, 0, 32)), NULL);
printable_val =
printable_val =
value_ind (value_cast (parray_of_char,
call_function_by_hand (func, 1, &val)));
call_function_by_hand (func, 1,
&val)));
fprintf_filtered (stream, "%s", VALUE_CONTENTS (printable_val));
return 0;
}
@@ -604,26 +610,26 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
}
else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
struct type* target_type = TYPE_TARGET_TYPE (type);
struct type *target_type = TYPE_TARGET_TYPE (type);
if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
{
/* Obscure case of range type that has different length from
its base type. Perform a conversion, or we will get a
nonsense value. Actually, we could use the same
code regardless of lengths; I'm just avoiding a cast. */
struct value* v =
value_cast (target_type,
value_from_contents_and_address (type, valaddr, 0));
its base type. Perform a conversion, or we will get a
nonsense value. Actually, we could use the same
code regardless of lengths; I'm just avoiding a cast. */
struct value *v = value_cast (target_type,
value_from_contents_and_address
(type, valaddr, 0));
return ada_val_print_1 (target_type, VALUE_CONTENTS (v), 0, 0,
stream, format, 0, recurse + 1, pretty);
}
else
return ada_val_print_1 (TYPE_TARGET_TYPE (type),
return ada_val_print_1 (TYPE_TARGET_TYPE (type),
valaddr0, embedded_offset,
address, stream, format, deref_ref,
address, stream, format, deref_ref,
recurse, pretty);
}
else
else
{
format = format ? format : output_format;
if (format)
@@ -661,8 +667,8 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
}
if (i < len)
{
const char* name = ada_enum_name (TYPE_FIELD_NAME (type, i));
if (name[0] == '\'')
const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
if (name[0] == '\'')
fprintf_filtered (stream, "%ld %s", (long) val, name);
else
fputs_filtered (name, stream);
@@ -672,18 +678,17 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
print_longest (stream, 'd', 0, val);
}
break;
case TYPE_CODE_UNION:
case TYPE_CODE_STRUCT:
if (ada_is_bogus_array_descriptor (type))
{
fprintf_filtered (stream, "(...?)");
return 0;
}
}
else
{
print_record (type, valaddr, stream, format,
recurse, pretty);
print_record (type, valaddr, stream, format, recurse, pretty);
return 0;
}
@@ -693,21 +698,20 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
elttype = TYPE_TARGET_TYPE (type);
eltlen = TYPE_LENGTH (elttype);
len = TYPE_LENGTH (type) / eltlen;
/* For an array of chars, print with string syntax. */
if (ada_is_string_type (type)
&& (format == 0 || format == 's'))
if (ada_is_string_type (type) && (format == 0 || format == 's'))
{
if (prettyprint_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
/* If requested, look for the first null char and only print
elements up to it. */
elements up to it. */
if (stop_print_at_null)
{
int temp_len;
/* Look for a NULL char. */
for (temp_len = 0;
temp_len < len && temp_len < print_max
@@ -715,7 +719,7 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
temp_len += 1);
len = temp_len;
}
printstr (stream, valaddr, len, 0, eltlen);
}
else
@@ -723,10 +727,9 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
len = 0;
fprintf_filtered (stream, "(");
print_optional_low_bound (stream, type);
if (TYPE_FIELD_BITSIZE (type, 0) > 0)
if (TYPE_FIELD_BITSIZE (type, 0) > 0)
val_print_packed_array_elements (type, valaddr, 0, stream,
format, recurse,
pretty);
format, recurse, pretty);
else
val_print_array_elements (type, valaddr, address, stream,
format, deref_ref, recurse,
@@ -740,27 +743,27 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
case TYPE_CODE_REF:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (addressprint)
{
{
fprintf_filtered (stream, "@");
print_address_numeric
(extract_address (valaddr,
TARGET_PTR_BIT / HOST_CHAR_BIT), 1, stream);
if (deref_ref)
fputs_filtered (": ", stream);
}
}
/* De-reference the reference */
if (deref_ref)
{
if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
{
LONGEST deref_val_int = (LONGEST)
unpack_pointer (lookup_pointer_type (builtin_type_void),
LONGEST deref_val_int = (LONGEST)
unpack_pointer (lookup_pointer_type (builtin_type_void),
valaddr);
if (deref_val_int != 0)
if (deref_val_int != 0)
{
struct value* deref_val =
ada_value_ind (value_from_longest
(lookup_pointer_type (elttype),
struct value *deref_val =
ada_value_ind (value_from_longest
(lookup_pointer_type (elttype),
deref_val_int));
val_print (VALUE_TYPE (deref_val),
VALUE_CONTENTS (deref_val), 0,
@@ -785,13 +788,12 @@ print_variant_part (struct type *type, int field_num, char *valaddr,
struct type *outer_type, char *outer_valaddr)
{
struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
int which =
ada_which_variant_applies (var_type, outer_type, outer_valaddr);
int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
if (which < 0)
return 0;
else
return print_field_values
return print_field_values
(TYPE_FIELD_TYPE (var_type, which),
valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
+ TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
@@ -800,23 +802,23 @@ print_variant_part (struct type *type, int field_num, char *valaddr,
}
int
ada_value_print (struct value* val0, struct ui_file *stream, int format,
ada_value_print (struct value *val0, struct ui_file *stream, int format,
enum val_prettyprint pretty)
{
char* valaddr = VALUE_CONTENTS (val0);
char *valaddr = VALUE_CONTENTS (val0);
CORE_ADDR address = VALUE_ADDRESS (val0) + VALUE_OFFSET (val0);
struct type* type =
struct type *type =
ada_to_fixed_type (VALUE_TYPE (val0), valaddr, address, NULL);
struct value* val = value_from_contents_and_address (type, valaddr, address);
struct value *val =
value_from_contents_and_address (type, valaddr, address);
/* If it is a pointer, indicate what it points to. */
if (TYPE_CODE (type) == TYPE_CODE_PTR ||
TYPE_CODE (type) == TYPE_CODE_REF)
if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF)
{
/* Hack: remove (char *) for char strings. Their
type is indicated by the quoted string anyway. */
type is indicated by the quoted string anyway. */
if (TYPE_CODE (type) == TYPE_CODE_PTR &&
TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof(char) &&
TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof (char) &&
TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_INT &&
!TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
{
@@ -829,7 +831,7 @@ ada_value_print (struct value* val0, struct ui_file *stream, int format,
fprintf_filtered (stream, ") ");
}
}
else if (ada_is_array_descriptor (type))
else if (ada_is_array_descriptor (type))
{
fprintf_filtered (stream, "(");
type_print (type, "", stream, -1);
@@ -842,10 +844,10 @@ ada_value_print (struct value* val0, struct ui_file *stream, int format,
fprintf_filtered (stream, ") (...?)");
return 0;
}
return (val_print (type, VALUE_CONTENTS (val), 0, address,
return (val_print (type, VALUE_CONTENTS (val), 0, address,
stream, format, 1, 0, pretty));
}
static void
print_record (struct type *type, char *valaddr, struct ui_file *stream,
int format, int recurse, enum val_prettyprint pretty)
@@ -855,8 +857,7 @@ print_record (struct type *type, char *valaddr, struct ui_file *stream,
fprintf_filtered (stream, "(");
if (print_field_values (type, valaddr, stream, format, recurse, pretty,
0, type, valaddr) != 0
&& pretty)
0, type, valaddr) != 0 && pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
@@ -892,13 +893,13 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
for (i = 0; i < len; i += 1)
{
if (ada_is_ignored_field (type, i))
continue;
continue;
if (ada_is_wrapper_field (type, i))
{
comma_needed =
comma_needed =
print_field_values (TYPE_FIELD_TYPE (type, i),
valaddr
valaddr
+ TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
stream, format, recurse, pretty,
comma_needed, type, valaddr);
@@ -922,7 +923,7 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
else
{
wrap_here (n_spaces (2 + 2 * recurse));
}
@@ -942,7 +943,7 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
else
{
annotate_field_begin (TYPE_FIELD_TYPE (type, i));
fprintf_filtered (stream, "%.*s",
fprintf_filtered (stream, "%.*s",
ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
TYPE_FIELD_NAME (type, i));
annotate_field_name_end ();
@@ -952,7 +953,7 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
if (TYPE_FIELD_PACKED (type, i))
{
struct value* v;
struct value *v;
/* Bitfields require special handling, especially due to byte
order problems. */
@@ -965,21 +966,21 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
{
int bit_pos = TYPE_FIELD_BITPOS (type, i);
int bit_size = TYPE_FIELD_BITSIZE (type, i);
adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
v = ada_value_primitive_packed_val (NULL, valaddr,
bit_pos / HOST_CHAR_BIT,
bit_pos % HOST_CHAR_BIT,
bit_size,
bit_size,
TYPE_FIELD_TYPE (type, i));
val_print (TYPE_FIELD_TYPE(type, i), VALUE_CONTENTS (v), 0, 0,
val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0, 0,
stream, format, 0, recurse + 1, pretty);
}
}
else
ada_val_print (TYPE_FIELD_TYPE (type, i),
valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
0, 0, stream, format, 0, recurse + 1, pretty);
ada_val_print (TYPE_FIELD_TYPE (type, i),
valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
0, 0, stream, format, 0, recurse + 1, pretty);
annotate_field_end ();
}