/* 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, 2009 Free Software Foundation, Inc.
+ 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+ 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"
{
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);
{
int j;
struct value_print_options opts = *options;
+
opts.deref_ref = 0;
for (j = i0; j < i; j += 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 */
len = strlen (result);
/* Modify for Ada rules. */
-
+
s = strstr (result, "inf");
if (s == NULL)
s = strstr (result, "Inf");
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), elttype, 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), elttype, 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, struct type *type, const gdb_byte *string,
- unsigned int length, int force_ellipses,
+ unsigned int length, const char *encoding, int force_ellipses,
const struct value_print_options *options)
{
printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
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);
CORE_ADDR address, struct ui_file *stream, int recurse,
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;
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;
}
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 (val == NULL)
{
int ret = c_val_print (type, valaddr0, embedded_offset, address,
stream, recurse, 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)
- {
- CORE_ADDR addr;
- addr = value_as_address (call_function_by_hand (func, 1, &val));
- val_print_string (builtin_type_true_char,
- addr, -1, stream, options);
- 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);
}
{
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.
-
- 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. */
+ System.Address values as a special case. */
- 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
{
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
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,
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);
- 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. */
/* 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);
}
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,
projects / binutils-gdb.git / blobdiff