Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
- 2009 Free Software Foundation, Inc.
+ 2009, 2010 Free Software Foundation, Inc.
This file is part of GDB.
#include "doublest.h"
#include "exceptions.h"
#include "dfp.h"
+#include "python/python.h"
+#include "ada-lang.h"
#include <errno.h>
0, /* print_array_indexes */
0, /* deref_ref */
1, /* static_field_print */
- 1 /* pascal_static_field_print */
+ 1, /* pascal_static_field_print */
+ 0, /* raw */
+ 0 /* summary */
};
/* Initialize *OPTS to be a copy of the user print options. */
}
\f
+/* A helper function for val_print. When printing in "summary" mode,
+ we want to print scalar arguments, but not aggregate arguments.
+ This function distinguishes between the two. */
+
+static int
+scalar_type_p (struct type *type)
+{
+ CHECK_TYPEDEF (type);
+ while (TYPE_CODE (type) == TYPE_CODE_REF)
+ {
+ type = TYPE_TARGET_TYPE (type);
+ CHECK_TYPEDEF (type);
+ }
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_ARRAY:
+ case TYPE_CODE_STRUCT:
+ case TYPE_CODE_UNION:
+ case TYPE_CODE_SET:
+ case TYPE_CODE_STRING:
+ case TYPE_CODE_BITSTRING:
+ return 0;
+ default:
+ return 1;
+ }
+}
+
+/* Helper function to check the validity of some bits of a value.
+
+ If TYPE represents some aggregate type (e.g., a structure), return 1.
+
+ Otherwise, any of the bytes starting at OFFSET and extending for
+ TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and
+ return 0. The checking is done using FUNCS.
+
+ Otherwise, return 1. */
+
+static int
+valprint_check_validity (struct ui_file *stream,
+ struct type *type,
+ int offset,
+ const struct value *val)
+{
+ CHECK_TYPEDEF (type);
+
+ if (TYPE_CODE (type) != TYPE_CODE_UNION
+ && TYPE_CODE (type) != TYPE_CODE_STRUCT
+ && TYPE_CODE (type) != TYPE_CODE_ARRAY)
+ {
+ if (! value_bits_valid (val, TARGET_CHAR_BIT * offset,
+ TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+ {
+ fprintf_filtered (stream, _("<value optimized out>"));
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
/* Print using the given LANGUAGE the data of type TYPE located at VALADDR
(within GDB), which came from the inferior at address ADDRESS, onto
stdio stream STREAM according to OPTIONS.
int
val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
CORE_ADDR address, struct ui_file *stream, int recurse,
+ const struct value *val,
const struct value_print_options *options,
const struct language_defn *language)
{
if (TYPE_STUB (real_type))
{
- fprintf_filtered (stream, "<incomplete type>");
+ fprintf_filtered (stream, _("<incomplete type>"));
gdb_flush (stream);
return (0);
}
+ if (!valprint_check_validity (stream, real_type, embedded_offset, val))
+ return 0;
+
+ if (!options->raw)
+ {
+ ret = apply_val_pretty_printer (type, valaddr, embedded_offset,
+ address, stream, recurse,
+ val, options, language);
+ if (ret)
+ return ret;
+ }
+
+ /* Handle summary mode. If the value is a scalar, print it;
+ otherwise, print an ellipsis. */
+ if (options->summary && !scalar_type_p (type))
+ {
+ fprintf_filtered (stream, "...");
+ return 0;
+ }
+
TRY_CATCH (except, RETURN_MASK_ERROR)
{
ret = language->la_val_print (type, valaddr, embedded_offset, address,
- stream, recurse, &local_opts);
+ stream, recurse, val,
+ &local_opts);
}
if (except.reason < 0)
fprintf_filtered (stream, _("<error reading variable>"));
return 0;
}
- if (value_optimized_out (val))
+ if (value_entirely_optimized_out (val))
{
fprintf_filtered (stream, _("<value optimized out>"));
return 0;
}
+ if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
+ {
+ fprintf_filtered (stream, _("<internal function %s>"),
+ value_internal_function_name (val));
+ return 0;
+ }
+
return 1;
}
if (!value_check_printable (val, stream))
return 0;
- return val_print (value_type (val), value_contents_all (val),
- value_embedded_offset (val), VALUE_ADDRESS (val),
- stream, recurse, options, language);
+ if (language->la_language == language_ada)
+ /* The value might have a dynamic type, which would cause trouble
+ below when trying to extract the value contents (since the value
+ size is determined from the type size which is unknown). So
+ get a fixed representation of our value. */
+ val = ada_to_fixed_value (val);
+
+ return val_print (value_type (val), value_contents_for_printing (val),
+ value_embedded_offset (val), value_address (val),
+ stream, recurse,
+ val, options, language);
}
-/* Print the value VAL in C-ish syntax on stream STREAM according to
- OPTIONS.
- If the object printed is a string pointer, returns
- the number of string bytes printed. */
+/* Print on stream STREAM the value VAL according to OPTIONS. The value
+ is printed using the current_language syntax.
+
+ If the object printed is a string pointer, return the number of string
+ bytes printed. */
int
value_print (struct value *val, struct ui_file *stream,
if (!value_check_printable (val, stream))
return 0;
+ if (!options->raw)
+ {
+ int r = apply_val_pretty_printer (value_type (val),
+ value_contents_for_printing (val),
+ value_embedded_offset (val),
+ value_address (val),
+ stream, 0,
+ val, options, current_language);
+
+ if (r)
+ return r;
+ }
+
return LA_VALUE_PRINT (val, stream, options);
}
val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
struct ui_file *stream)
{
- enum bfd_endian byte_order = gdbarch_byte_order (current_gdbarch);
+ enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
if (TYPE_LENGTH (type) > sizeof (LONGEST))
{
if (TYPE_UNSIGNED (type)
&& extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
- &val))
+ byte_order, &val))
{
print_longest (stream, 'u', 0, val);
}
print_decimal_floating (const gdb_byte *valaddr, struct type *type,
struct ui_file *stream)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
char decstr[MAX_DECIMAL_STRING];
unsigned len = TYPE_LENGTH (type);
- decimal_to_string (valaddr, len, decstr);
+ decimal_to_string (valaddr, len, byte_order, decstr);
fputs_filtered (decstr, stream);
return;
}
Omit any leading zero chars. */
void
-print_char_chars (struct ui_file *stream, const gdb_byte *valaddr,
+print_char_chars (struct ui_file *stream, struct type *type,
+ const gdb_byte *valaddr,
unsigned len, enum bfd_endian byte_order)
{
const gdb_byte *p;
while (p < valaddr + len)
{
- LA_EMIT_CHAR (*p, stream, '\'');
+ LA_EMIT_CHAR (*p, type, stream, '\'');
++p;
}
}
while (p >= valaddr)
{
- LA_EMIT_CHAR (*p, stream, '\'');
+ LA_EMIT_CHAR (*p, type, stream, '\'');
--p;
}
}
Return 1 if the operation was successful. Return zero otherwise,
in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
-
- Computing the array upper and lower bounds is pretty easy, but this
- function does some additional verifications before returning them.
- If something incorrect is detected, it is better to return a status
- rather than throwing an error, making it easier for the caller to
- implement an error-recovery plan. For instance, it may decide to
- warn the user that the bounds were not found and then use some
- default values instead. */
+
+ We now simply use get_discrete_bounds call to get the values
+ of the low and high bounds.
+ get_discrete_bounds can return three values:
+ 1, meaning that index is a range,
+ 0, meaning that index is a discrete type,
+ or -1 for failure. */
int
-get_array_bounds (struct type *type, long *low_bound, long *high_bound)
+get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
{
struct type *index = TYPE_INDEX_TYPE (type);
- long low = 0;
- long high = 0;
-
+ LONGEST low = 0;
+ LONGEST high = 0;
+ int res;
+
if (index == NULL)
return 0;
- if (TYPE_CODE (index) == TYPE_CODE_RANGE)
- {
- low = TYPE_LOW_BOUND (index);
- high = TYPE_HIGH_BOUND (index);
- }
- else if (TYPE_CODE (index) == TYPE_CODE_ENUM)
- {
- const int n_enums = TYPE_NFIELDS (index);
-
- low = TYPE_FIELD_BITPOS (index, 0);
- high = TYPE_FIELD_BITPOS (index, n_enums - 1);
- }
- else
- return 0;
-
- /* Abort if the lower bound is greater than the higher bound, except
- when low = high + 1. This is a very common idiom used in Ada when
- defining empty ranges (for instance "range 1 .. 0"). */
- if (low > high + 1)
+ res = get_discrete_bounds (index, &low, &high);
+ if (res == -1)
return 0;
if (low_bound)
val_print_array_elements (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,
unsigned int i)
{
unsigned int rep1;
/* Number of repetitions we have detected so far. */
unsigned int reps;
- long low_bound_index = 0;
+ LONGEST low_bound_index = 0;
elttype = TYPE_TARGET_TYPE (type);
eltlen = TYPE_LENGTH (check_typedef (elttype));
len = TYPE_LENGTH (type) / eltlen;
else
{
- long low, hi;
+ LONGEST low, hi;
+
if (get_array_bounds (type, &low, &hi))
len = hi - low + 1;
else
if (reps > options->repeat_count_threshold)
{
val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
- stream, recurse + 1, options, current_language);
+ stream, recurse + 1, val, options, current_language);
annotate_elt_rep (reps);
fprintf_filtered (stream, " <repeats %u times>", reps);
annotate_elt_rep_end ();
else
{
val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
- stream, recurse + 1, options, current_language);
+ stream, recurse + 1, val, options, current_language);
annotate_elt ();
things_printed++;
}
int
read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
- gdb_byte **buffer, int *bytes_read)
+ enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
{
int found_nul; /* Non-zero if we found the nul char. */
int errcode; /* Errno returned from bad reads. */
some error, such as bumping into the end of the address space. */
found_nul = 0;
- old_chain = make_cleanup (null_cleanup, 0);
+ *buffer = NULL;
+
+ old_chain = make_cleanup (free_current_contents, buffer);
if (len > 0)
{
*buffer = (gdb_byte *) xmalloc (len * width);
bufptr = *buffer;
- old_chain = make_cleanup (xfree, *buffer);
nfetch = partial_memory_read (addr, bufptr, len * width, &errcode)
/ width;
{
unsigned long bufsize = 0;
- *buffer = NULL;
-
do
{
QUIT;
if (*buffer == NULL)
*buffer = (gdb_byte *) xmalloc (nfetch * width);
else
- {
- discard_cleanups (old_chain);
- *buffer = (gdb_byte *) xrealloc (*buffer,
- (nfetch + bufsize) * width);
- }
+ *buffer = (gdb_byte *) xrealloc (*buffer,
+ (nfetch + bufsize) * width);
- old_chain = make_cleanup (xfree, *buffer);
bufptr = *buffer + bufsize * width;
bufsize += nfetch;
{
unsigned long c;
- c = extract_unsigned_integer (bufptr, width);
+ c = extract_unsigned_integer (bufptr, width, byte_order);
addr += width;
bufptr += width;
if (c == 0)
whichever is smaller. */
int
-val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream,
+val_print_string (struct type *elttype, CORE_ADDR addr, int len,
+ struct ui_file *stream,
const struct value_print_options *options)
{
int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
int bytes_read;
gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */
struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
+ struct gdbarch *gdbarch = get_type_arch (elttype);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ int width = TYPE_LENGTH (elttype);
/* First we need to figure out the limit on the number of characters we are
going to attempt to fetch and print. This is actually pretty simple. If
fetchlimit = (len == -1 ? options->print_max : min (len, options->print_max));
- errcode = read_string (addr, len, width, fetchlimit, &buffer, &bytes_read);
+ errcode = read_string (addr, len, width, fetchlimit, byte_order,
+ &buffer, &bytes_read);
old_chain = make_cleanup (xfree, buffer);
addr += bytes_read;
terminated early due to an error or finding a null char when LEN is -1. */
/* Determine found_nul by looking at the last character read. */
- found_nul = extract_unsigned_integer (buffer + bytes_read - width, width) == 0;
-
+ found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
+ byte_order) == 0;
if (len == -1 && !found_nul)
{
gdb_byte *peekbuf;
peekbuf = (gdb_byte *) alloca (width);
if (target_read_memory (addr, peekbuf, width) == 0
- && extract_unsigned_integer (peekbuf, width) != 0)
+ && extract_unsigned_integer (peekbuf, width, byte_order) != 0)
force_ellipsis = 1;
}
else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
{
fputs_filtered (" ", stream);
}
- LA_PRINT_STRING (stream, buffer, bytes_read / width, width, force_ellipsis, options);
+ LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
+ NULL, force_ellipsis, options);
}
if (errcode != 0)
if (errcode == EIO)
{
fprintf_filtered (stream, " <Address ");
- fputs_filtered (paddress (addr), stream);
+ fputs_filtered (paddress (gdbarch, addr), stream);
fprintf_filtered (stream, " out of bounds>");
}
else
{
fprintf_filtered (stream, " <Error reading address ");
- fputs_filtered (paddress (addr), stream);
+ fputs_filtered (paddress (gdbarch, addr), stream);
fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
}
}
void
_initialize_valprint (void)
{
- struct cmd_list_element *c;
-
add_prefix_cmd ("print", no_class, set_print,
_("Generic command for setting how things print."),
&setprintlist, "set print ", 0, &setlist);
projects / deliverable / binutils-gdb.git / blobdiff