/* Support for printing Ada values for GDB, the GNU debugger.
Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001, 2002,
- 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+ 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+ 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, see <http://www.gnu.org/licenses/>. */
-#include <ctype.h>
#include "defs.h"
+#include <ctype.h>
#include "gdb_string.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "exceptions.h"
#include "objfiles.h"
-/* Encapsulates arguments to ada_val_print. */
-struct ada_val_print_args
-{
- struct type *type;
- const gdb_byte *valaddr0;
- int embedded_offset;
- CORE_ADDR address;
- struct ui_file *stream;
- int recurse;
- const struct value_print_options *options;
-};
-
static void print_record (struct type *, const gdb_byte *, struct ui_file *,
- int, const struct value_print_options *);
+ int,
+ const struct value *,
+ const struct value_print_options *);
static int print_field_values (struct type *, const gdb_byte *,
struct ui_file *, int,
+ const struct value *,
const struct value_print_options *,
int, struct type *,
const gdb_byte *);
static void adjust_type_signedness (struct type *);
-static int ada_val_print_stub (void *args0);
-
static int ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
struct ui_file *, int,
+ const struct value *,
const struct value_print_options *);
\f
const struct value_print_options *options)
{
struct type *index_type;
- long low_bound;
- long high_bound;
+ LONGEST low_bound;
+ LONGEST high_bound;
if (options->print_array_indexes)
return 0;
return 0;
break;
case TYPE_CODE_UNDEF:
- index_type = builtin_type_int32;
+ index_type = NULL;
/* FALL THROUGH */
default:
if (low_bound == 1)
break;
}
- ada_print_scalar (index_type, (LONGEST) low_bound, stream);
+ ada_print_scalar (index_type, low_bound, stream);
fprintf_filtered (stream, " => ");
return 1;
}
val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
int bitoffset, struct ui_file *stream,
int recurse,
+ const struct value *val,
const struct value_print_options *options)
{
unsigned int i;
{
LONGEST high;
+
if (get_discrete_bounds (index_type, &low, &high) < 0)
len = 1;
else
if (i - i0 > options->repeat_count_threshold)
{
struct value_print_options opts = *options;
+
opts.deref_ref = 0;
val_print (elttype, value_contents (v0), 0, 0, stream,
- recurse + 1, &opts, current_language);
+ recurse + 1, val, &opts, current_language);
annotate_elt_rep (i - i0);
fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
annotate_elt_rep_end ();
{
int j;
struct value_print_options opts = *options;
+
opts.deref_ref = 0;
for (j = i0; j < i; j += 1)
{
stream, options);
}
val_print (elttype, value_contents (v0), 0, 0, stream,
- recurse + 1, &opts, current_language);
+ recurse + 1, val, &opts, current_language);
annotate_elt ();
}
}
(1 or 2) of the character. */
void
-ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len)
+ada_emit_char (int c, struct type *type, struct ui_file *stream,
+ int quoter, int type_len)
{
if (type_len != 2)
type_len = 1;
or 2) of a character. */
static int
-char_at (const gdb_byte *string, int i, int type_len)
+char_at (const gdb_byte *string, int i, int type_len,
+ enum bfd_endian byte_order)
{
if (type_len == 1)
return string[i];
else
- return (int) extract_unsigned_integer (string + 2 * i, 2);
+ return (int) extract_unsigned_integer (string + 2 * i, 2, byte_order);
}
-/* Wrapper around memcpy to make it legal argument to ui_file_put */
+/* Wrapper around memcpy to make it legal argument to ui_file_put. */
static void
ui_memcpy (void *dest, const char *buffer, long len)
{
len = strlen (result);
/* Modify for Ada rules. */
-
+
s = strstr (result, "inf");
if (s == NULL)
s = strstr (result, "Inf");
}
void
-ada_printchar (int c, struct ui_file *stream)
+ada_printchar (int c, struct type *type, struct ui_file *stream)
{
fputs_filtered ("'", stream);
- ada_emit_char (c, stream, '\'', 1);
+ ada_emit_char (c, type, stream, '\'', 1);
fputs_filtered ("'", stream);
}
/* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
- form appropriate for TYPE. */
+ form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
+ like a default signed integer. */
void
ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
unsigned int i;
unsigned len;
+ if (!type)
+ {
+ print_longest (stream, 'd', 0, val);
+ return;
+ }
+
type = ada_check_typedef (type);
switch (TYPE_CODE (type))
break;
case TYPE_CODE_CHAR:
- LA_PRINT_CHAR ((unsigned char) val, stream);
+ LA_PRINT_CHAR ((unsigned char) val, type, stream);
break;
case TYPE_CODE_BOOL:
/* Print the character string STRING, printing at most LENGTH characters.
Printing stops early if the number hits print_max; repeat counts
are printed as appropriate. Print ellipses at the end if we
- had to stop before printing LENGTH characters, or if
- FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type.
- */
+ had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
+ TYPE_LEN is the length (1 or 2) of the character type. */
static void
-printstr (struct ui_file *stream, const gdb_byte *string,
+printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
unsigned int length, int force_ellipses, int type_len,
const struct value_print_options *options)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype));
unsigned int i;
unsigned int things_printed = 0;
int in_quotes = 0;
rep1 = i + 1;
reps = 1;
while (rep1 < length
- && char_at (string, rep1, type_len) == char_at (string, i,
- type_len))
+ && char_at (string, rep1, type_len, byte_order)
+ == char_at (string, i, type_len, byte_order))
{
rep1 += 1;
reps += 1;
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, byte_order),
+ elttype, stream, '\'', type_len);
fputs_filtered ("'", stream);
fprintf_filtered (stream, _(" <repeats %u times>"), reps);
i = rep1 - 1;
fputs_filtered ("\"", stream);
in_quotes = 1;
}
- ada_emit_char (char_at (string, i, type_len), stream, '"',
- type_len);
+ ada_emit_char (char_at (string, i, type_len, byte_order),
+ elttype, stream, '"', type_len);
things_printed += 1;
}
}
}
void
-ada_printstr (struct ui_file *stream, const gdb_byte *string,
- unsigned int length, int width, int force_ellipses,
+ada_printstr (struct ui_file *stream, struct type *type,
+ const gdb_byte *string, unsigned int length,
+ const char *encoding, int force_ellipses,
const struct value_print_options *options)
{
- printstr (stream, string, length, force_ellipses, width, options);
+ printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
+ options);
}
ada_val_print (struct type *type, const gdb_byte *valaddr0,
int embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
+ const struct value *val,
const struct value_print_options *options)
{
- struct ada_val_print_args args;
- args.type = type;
- args.valaddr0 = valaddr0;
- args.embedded_offset = embedded_offset;
- args.address = address;
- args.stream = stream;
- args.recurse = recurse;
- args.options = options;
-
- return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
-}
+ volatile struct gdb_exception except;
+ int result = 0;
-/* Helper for ada_val_print; used as argument to catch_errors to
- unmarshal the arguments to ada_val_print_1, which does the work. */
-static int
-ada_val_print_stub (void *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->recurse, argsp->options);
+ TRY_CATCH (except, RETURN_MASK_ALL)
+ {
+ result = ada_val_print_1 (type, valaddr0, embedded_offset, address,
+ stream, recurse, val, options);
+ }
+
+ if (except.reason < 0)
+ result = 0;
+
+ return result;
}
/* Assuming TYPE is a simple array, print the value of this array located
static int
ada_val_print_array (struct type *type, const gdb_byte *valaddr,
CORE_ADDR address, struct ui_file *stream, int recurse,
+ const struct value *val,
const struct value_print_options *options)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
struct type *elttype = TYPE_TARGET_TYPE (type);
- unsigned int eltlen;
- unsigned int len;
int result = 0;
- if (elttype == NULL)
- eltlen = 0;
- else
- eltlen = TYPE_LENGTH (elttype);
- if (eltlen == 0)
- len = 0;
- else
- len = TYPE_LENGTH (type) / eltlen;
-
/* For an array of chars, print with string syntax. */
if (ada_is_string_type (type)
&& (options->format == 0 || options->format == 's'))
{
+ unsigned int eltlen;
+ unsigned int len;
+
+ if (elttype == NULL)
+ eltlen = 0;
+ else
+ eltlen = TYPE_LENGTH (elttype);
+ if (eltlen == 0)
+ len = 0;
+ else
+ len = TYPE_LENGTH (type) / eltlen;
+
if (options->prettyprint_arrays)
print_spaces_filtered (2 + 2 * recurse, stream);
for (temp_len = 0;
(temp_len < len
&& temp_len < options->print_max
- && char_at (valaddr, temp_len, eltlen) != 0);
+ && char_at (valaddr, temp_len, eltlen, byte_order) != 0);
temp_len += 1);
len = temp_len;
}
- printstr (stream, valaddr, len, 0, eltlen, options);
+ printstr (stream, elttype, valaddr, len, 0, eltlen, options);
result = len;
}
else
print_optional_low_bound (stream, type, options);
if (TYPE_FIELD_BITSIZE (type, 0) > 0)
val_print_packed_array_elements (type, valaddr, 0, stream,
- recurse, options);
+ recurse, val, options);
else
val_print_array_elements (type, valaddr, address, stream,
- recurse, options, 0);
+ recurse, val, options, 0);
fprintf_filtered (stream, ")");
}
ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
int embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
+ const struct value *original_value,
const struct value_print_options *options)
{
unsigned int len;
int i;
struct type *elttype;
- unsigned int eltlen;
LONGEST val;
const gdb_byte *valaddr = valaddr0 + embedded_offset;
type = ada_check_typedef (type);
- if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type))
+ if (ada_is_array_descriptor_type (type)
+ || ada_is_constrained_packed_array_type (type))
{
int retn;
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 (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) /* array access type. */
+ val = ada_coerce_to_simple_array_ptr (val);
+ else
+ val = ada_coerce_to_simple_array (val);
if (val == NULL)
{
- fprintf_filtered (stream, "(null)");
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_TYPEDEF);
+ fprintf_filtered (stream, "0x0");
retn = 0;
}
else
retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
- VALUE_ADDRESS (val), stream, recurse, options);
+ value_address (val), stream, recurse,
+ NULL, options);
value_free_to_mark (mark);
return retn;
}
{
default:
return c_val_print (type, valaddr0, embedded_offset, address, stream,
- recurse, options);
+ recurse, original_value, options);
case TYPE_CODE_PTR:
{
int ret = c_val_print (type, valaddr0, embedded_offset, address,
- stream, recurse, options);
+ stream, recurse, original_value, options);
+
if (ada_is_tag_type (type))
{
struct value *val =
value_from_contents_and_address (type, valaddr, address);
const char *name = ada_tag_name (val);
+
if (name != NULL)
fprintf_filtered (stream, " (%s)", name);
return 0;
(double) ada_fixed_to_float (type, v));
return 0;
}
- else if (ada_is_vax_floating_type (type))
- {
- struct value *val =
- value_from_contents_and_address (type, valaddr, address);
- struct value *func = ada_vax_float_print_function (type);
- if (func != 0)
- {
- 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_true_char,
- create_range_type (NULL, builtin_type_int32, 0, 32)), NULL);
-
- printable_val =
- value_ind (value_cast (parray_of_char,
- call_function_by_hand (func, 1,
- &val)));
-
- fprintf_filtered (stream, "%s", value_contents (printable_val));
- return 0;
- }
- /* No special printing function. Do as best we can. */
- }
else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
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
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, recurse + 1, options);
+ stream, recurse + 1, NULL, options);
}
else
return ada_val_print_1 (TYPE_TARGET_TYPE (type),
valaddr0, embedded_offset,
- address, stream, recurse, options);
+ address, stream, recurse,
+ original_value, options);
}
else
{
int format = (options->format ? options->format
: options->output_format);
+
if (format)
{
struct value_print_options opts = *options;
+
opts.format = format;
print_scalar_formatted (valaddr, type, &opts, 0, stream);
}
- else if (ada_is_system_address_type (type)
- && TYPE_OBJFILE (type) != NULL)
+ else if (ada_is_system_address_type (type))
{
/* FIXME: We want to print System.Address variables using
the same format as for any access type. But for some
reason GNAT encodes the System.Address type as an int,
so we have to work-around this deficiency by handling
- System.Address values as a special case.
+ System.Address values as a special case. */
- We do this only for System.Address types defined in an
- objfile. For the built-in version of System.Address we
- have installed the proper type to begin with. */
-
- struct gdbarch *gdbarch = get_objfile_arch (TYPE_OBJFILE (type));
+ struct gdbarch *gdbarch = get_type_arch (type);
struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
+ CORE_ADDR addr = extract_typed_address (valaddr, ptr_type);
fprintf_filtered (stream, "(");
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
- fputs_filtered (paddress (extract_typed_address
- (valaddr, ptr_type)),
- stream);
+ fputs_filtered (paddress (gdbarch, addr), stream);
}
else
{
{
fputs_filtered (" ", stream);
ada_printchar ((unsigned char) unpack_long (type, valaddr),
- stream);
+ type, stream);
}
}
return 0;
if (i < len)
{
const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
+
if (name[0] == '\'')
fprintf_filtered (stream, "%ld %s", (long) val, name);
else
case TYPE_CODE_FLT:
if (options->format)
return c_val_print (type, valaddr0, embedded_offset, address, stream,
- recurse, options);
+ recurse, original_value, options);
else
ada_print_floating (valaddr0 + embedded_offset, type, stream);
break;
}
else
{
- print_record (type, valaddr, stream, recurse, options);
+ print_record (type, valaddr, stream, recurse, original_value,
+ options);
return 0;
}
case TYPE_CODE_ARRAY:
return ada_val_print_array (type, valaddr, address, stream,
- recurse, options);
+ recurse, original_value, options);
case TYPE_CODE_REF:
/* For references, the debugger is expected to print the value as
if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
{
LONGEST deref_val_int = (LONGEST) unpack_pointer (type, valaddr);
+
if (deref_val_int != 0)
{
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,
- VALUE_ADDRESS (deref_val), stream, recurse + 1,
- options, current_language);
+ value_address (deref_val), stream, recurse + 1,
+ original_value, options, current_language);
}
else
fputs_filtered ("(null)", stream);
static int
print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
struct ui_file *stream, int recurse,
- const struct value_print_options *options, int comma_needed,
+ const struct value *val,
+ const struct value_print_options *options,
+ int comma_needed,
struct type *outer_type, const gdb_byte *outer_valaddr)
{
struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
(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,
- stream, recurse, options,
+ stream, recurse, val, options,
comma_needed, outer_type, outer_valaddr);
}
ada_value_print (struct value *val0, struct ui_file *stream,
const struct value_print_options *options)
{
- const gdb_byte *valaddr = value_contents (val0);
- CORE_ADDR address = VALUE_ADDRESS (val0) + value_offset (val0);
- struct type *type =
- ada_to_fixed_type (value_type (val0), valaddr, address, NULL, 1);
- struct value *val =
- value_from_contents_and_address (type, valaddr, address);
+ struct value *val = ada_to_fixed_value (val0);
+ CORE_ADDR address = value_address (val);
+ struct type *type = value_type (val);
struct value_print_options opts;
/* If it is a pointer, indicate what it points to. */
}
else if (ada_is_array_descriptor_type (type))
{
- fprintf_filtered (stream, "(");
- type_print (type, "", stream, -1);
- fprintf_filtered (stream, ") ");
+ /* We do not print the type description unless TYPE is an array
+ access type (this is encoded by the compiler as a typedef to
+ a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
+ if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ {
+ fprintf_filtered (stream, "(");
+ type_print (type, "", stream, -1);
+ fprintf_filtered (stream, ") ");
+ }
}
else if (ada_is_bogus_array_descriptor (type))
{
opts = *options;
opts.deref_ref = 1;
return (val_print (type, value_contents (val), 0, address,
- stream, 0, &opts, current_language));
+ stream, 0, val, &opts, current_language));
}
static void
print_record (struct type *type, const gdb_byte *valaddr,
struct ui_file *stream, int recurse,
+ const struct value *val,
const struct value_print_options *options)
{
type = ada_check_typedef (type);
fprintf_filtered (stream, "(");
- if (print_field_values (type, valaddr, stream, recurse, options,
+ if (print_field_values (type, valaddr, stream, recurse, val, options,
0, type, valaddr) != 0 && options->pretty)
{
fprintf_filtered (stream, "\n");
static int
print_field_values (struct type *type, const gdb_byte *valaddr,
struct ui_file *stream, int recurse,
+ const struct value *val,
const struct value_print_options *options,
int comma_needed,
struct type *outer_type, const gdb_byte *outer_valaddr)
print_field_values (TYPE_FIELD_TYPE (type, i),
valaddr
+ TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
- stream, recurse, options,
+ stream, recurse, val, options,
comma_needed, type, valaddr);
continue;
}
{
comma_needed =
print_variant_part (type, i, valaddr,
- stream, recurse, options, comma_needed,
+ stream, recurse, val, options, comma_needed,
outer_type, outer_valaddr);
continue;
}
/* Bitfields require special handling, especially due to byte
order problems. */
- if (TYPE_CPLUS_SPECIFIC (type) != NULL
- && TYPE_FIELD_IGNORE (type, i))
+ if (HAVE_CPLUS_STRUCT (type) && TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered (_("<optimized out or zero length>"), stream);
}
opts = *options;
opts.deref_ref = 0;
val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
- stream, recurse + 1, &opts, current_language);
+ stream, recurse + 1, v,
+ &opts, current_language);
}
}
else
{
struct value_print_options opts = *options;
+
opts.deref_ref = 0;
ada_val_print (TYPE_FIELD_TYPE (type, i),
valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
- 0, 0, stream, recurse + 1, &opts);
+ 0, 0, stream, recurse + 1, val, &opts);
}
annotate_field_end ();
}
projects / deliverable / binutils-gdb.git / blobdiff