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, 2011 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. */
show_print_max (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Limit on string chars or array elements to print is %s.\n"),
+ fprintf_filtered (file,
+ _("Limit on string chars or array "
+ "elements to print is %s.\n"),
value);
}
show_input_radix (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Default input radix for entering numbers is %s.\n"),
+ fprintf_filtered (file,
+ _("Default input radix for entering numbers is %s.\n"),
value);
}
show_output_radix (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Default output radix for printing of values is %s.\n"),
+ fprintf_filtered (file,
+ _("Default output radix for printing of values is %s.\n"),
value);
}
show_stop_print_at_null (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Printing of char arrays to stop at first null char is %s.\n"),
+ fprintf_filtered (file,
+ _("Printing of char arrays to stop "
+ "at first null char is %s.\n"),
value);
}
show_unionprint (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Printing of unions interior to structures is %s.\n"),
+ fprintf_filtered (file,
+ _("Printing of unions interior to structures is %s.\n"),
value);
}
}
\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;
+ }
+
+ if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * offset,
+ TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+ {
+ fputs_filtered (_("<synthetic pointer>"), stream);
+ 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);
}
case 'o':
val = int_string (val_long, 8, 0, 0, use_c_format); break;
default:
- internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
+ internal_error (__FILE__, __LINE__,
+ _("failed internal consistency check"));
}
fputs_filtered (val, stream);
}
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;
}
}
}
-/* VALADDR points to a char integer of LEN bytes. Print it out in appropriate language form on stream.
+/* VALADDR points to a char integer of LEN bytes.
+ Print it out in appropriate language form on stream.
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;
}
}
}
-/* Assuming TYPE is a simple, non-empty array type, compute its upper
- and lower bound. Save the low bound into LOW_BOUND if not NULL.
- Save the high bound into HIGH_BOUND if not NULL.
-
- 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. */
-
-int
-get_array_bounds (struct type *type, long *low_bound, long *high_bound)
-{
- struct type *index = TYPE_INDEX_TYPE (type);
- long low = 0;
- long high = 0;
-
- 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)
- return 0;
-
- if (low_bound)
- *low_bound = low;
-
- if (high_bound)
- *high_bound = high;
-
- return 1;
-}
-
/* Print on STREAM using the given OPTIONS the index for the element
at INDEX of an array whose index type is INDEX_TYPE. */
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, high_bound;
elttype = TYPE_TARGET_TYPE (type);
eltlen = TYPE_LENGTH (check_typedef (elttype));
index_type = TYPE_INDEX_TYPE (type);
- /* Compute the number of elements in the array. On most arrays,
- the size of its elements is not zero, and so the number of elements
- is simply the size of the array divided by the size of the elements.
- But for arrays of elements whose size is zero, we need to look at
- the bounds. */
- if (eltlen != 0)
- len = TYPE_LENGTH (type) / eltlen;
- else
+ if (get_array_bounds (type, &low_bound, &high_bound))
{
- long low, hi;
- if (get_array_bounds (type, &low, &hi))
- len = hi - low + 1;
+ /* The array length should normally be HIGH_BOUND - LOW_BOUND + 1.
+ But we have to be a little extra careful, because some languages
+ such as Ada allow LOW_BOUND to be greater than HIGH_BOUND for
+ empty arrays. In that situation, the array length is just zero,
+ not negative! */
+ if (low_bound > high_bound)
+ len = 0;
else
- {
- warning (_("unable to get bounds of array, assuming null array"));
- len = 0;
- }
+ len = high_bound - low_bound + 1;
}
-
- /* Get the array low bound. This only makes sense if the array
- has one or more element in it. */
- if (len > 0 && !get_array_bounds (type, &low_bound_index, NULL))
+ else
{
- warning (_("unable to get low bound of array, using zero as default"));
- low_bound_index = 0;
+ warning (_("unable to get bounds of array, assuming null array"));
+ low_bound = 0;
+ len = 0;
}
annotate_array_section_begin (i, elttype);
}
}
wrap_here (n_spaces (2 + 2 * recurse));
- maybe_print_array_index (index_type, i + low_bound_index,
+ maybe_print_array_index (index_type, i + low_bound,
stream, options);
rep1 = i + 1;
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++;
}
function be eliminated. */
static int
-partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int *errnoptr)
+partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
+ int len, int *errnoptr)
{
int nread; /* Number of bytes actually read. */
int errcode; /* Error from last read. */
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. */
unsigned int nfetch; /* Chars to fetch / chars fetched. */
unsigned int chunksize; /* Size of each fetch, in chars. */
- gdb_byte *bufptr; /* Pointer to next available byte in buffer. */
+ gdb_byte *bufptr; /* Pointer to next available byte in
+ buffer. */
gdb_byte *limit; /* First location past end of fetch buffer. */
struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
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)
characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
stops at the first null byte, otherwise printing proceeds (including null
bytes) until either print_max or LEN characters have been printed,
- whichever is smaller. */
+ whichever is smaller. ENCODING is the name of the string's
+ encoding. It can be NULL, in which case the target encoding is
+ assumed. */
int
-val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream,
+val_print_string (struct type *elttype, const char *encoding,
+ 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
because finding the null byte (or available memory) is what actually
limits the fetch. */
- fetchlimit = (len == -1 ? options->print_max : min (len, options->print_max));
+ 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;
- /* We now have either successfully filled the buffer to fetchlimit, or
- terminated early due to an error or finding a null char when LEN is -1. */
+ /* We now have either successfully filled the buffer to fetchlimit,
+ or 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,
+ encoding, 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));
}
}
input_radix_1 = input_radix = radix;
if (from_tty)
{
- printf_filtered (_("Input radix now set to decimal %u, hex %x, octal %o.\n"),
+ printf_filtered (_("Input radix now set to "
+ "decimal %u, hex %x, octal %o.\n"),
radix, radix, radix);
}
}
break;
default:
output_radix_1 = output_radix;
- error (_("Unsupported output radix ``decimal %u''; output radix unchanged."),
+ error (_("Unsupported output radix ``decimal %u''; "
+ "output radix unchanged."),
radix);
}
output_radix_1 = output_radix = radix;
if (from_tty)
{
- printf_filtered (_("Output radix now set to decimal %u, hex %x, octal %o.\n"),
+ printf_filtered (_("Output radix now set to "
+ "decimal %u, hex %x, octal %o.\n"),
radix, radix, radix);
}
}
set_input_radix_1 (0, radix);
if (from_tty)
{
- printf_filtered (_("Input and output radices now set to decimal %u, hex %x, octal %o.\n"),
+ printf_filtered (_("Input and output radices now set to "
+ "decimal %u, hex %x, octal %o.\n"),
radix, radix, radix);
}
}
{
if (input_radix == output_radix)
{
- printf_filtered (_("Input and output radices set to decimal %u, hex %x, octal %o.\n"),
+ printf_filtered (_("Input and output radices set to "
+ "decimal %u, hex %x, octal %o.\n"),
input_radix, input_radix, input_radix);
}
else
{
- printf_filtered (_("Input radix set to decimal %u, hex %x, octal %o.\n"),
+ printf_filtered (_("Input radix set to decimal "
+ "%u, hex %x, octal %o.\n"),
input_radix, input_radix, input_radix);
- printf_filtered (_("Output radix set to decimal %u, hex %x, octal %o.\n"),
+ printf_filtered (_("Output radix set to decimal "
+ "%u, hex %x, octal %o.\n"),
output_radix, output_radix, output_radix);
}
}
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