/* Print values for GDB, the GNU debugger.
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2016 Free Software Foundation, Inc.
This file is part of GDB.
#include "ada-lang.h"
#include "gdb_obstack.h"
#include "charset.h"
+#include "typeprint.h"
#include <ctype.h>
+#include <algorithm>
/* Maximum number of wchars returned from wchar_iterate. */
#define MAX_WCHARS 4
static void set_output_radix_1 (int, unsigned);
+static void val_print_type_code_flags (struct type *type,
+ const gdb_byte *valaddr,
+ struct ui_file *stream);
+
void _initialize_valprint (void);
#define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
int
valprint_check_validity (struct ui_file *stream,
struct type *type,
- int embedded_offset,
+ LONGEST embedded_offset,
const struct value *val)
{
type = check_typedef (type);
+ if (type_not_associated (type))
+ {
+ val_print_not_associated (stream);
+ return 0;
+ }
+
+ if (type_not_allocated (type))
+ {
+ val_print_not_allocated (stream);
+ return 0;
+ }
+
if (TYPE_CODE (type) != TYPE_CODE_UNION
&& TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_ARRAY)
if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * embedded_offset,
TARGET_CHAR_BIT * TYPE_LENGTH (type)))
{
- fputs_filtered (_("<synthetic pointer>"), stream);
- return 0;
+ const int is_ref = TYPE_CODE (type) == TYPE_CODE_REF;
+ int ref_is_addressable = 0;
+
+ if (is_ref)
+ {
+ const struct value *deref_val = coerce_ref_if_computed (val);
+
+ if (deref_val != NULL)
+ ref_is_addressable = value_lval_const (deref_val) == lval_memory;
+ }
+
+ if (!is_ref || !ref_is_addressable)
+ fputs_filtered (_("<synthetic pointer>"), stream);
+
+ /* C++ references should be valid even if they're synthetic. */
+ return is_ref;
}
if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
static void
generic_val_print_array (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, CORE_ADDR address,
- struct ui_file *stream, int recurse,
- const struct value *original_value,
- const struct value_print_options *options)
+ int embedded_offset, CORE_ADDR address,
+ struct ui_file *stream, int recurse,
+ const struct value *original_value,
+ const struct value_print_options *options,
+ const struct
+ generic_val_print_decorations *decorations)
{
struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
struct type *elttype = check_typedef (unresolved_elttype);
print_spaces_filtered (2 + 2 * recurse, stream);
}
- fprintf_filtered (stream, "{");
+ fputs_filtered (decorations->array_start, stream);
val_print_array_elements (type, valaddr, embedded_offset,
address, stream,
recurse, original_value, options, 0);
- fprintf_filtered (stream, "}");
+ fputs_filtered (decorations->array_end, stream);
}
else
{
const struct value *original_value,
const struct value_print_options *options)
{
+ struct gdbarch *gdbarch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
+
if (options->format && options->format != 's')
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
{
struct type *unresolved_elttype = TYPE_TARGET_TYPE(type);
struct type *elttype = check_typedef (unresolved_elttype);
- CORE_ADDR addr = unpack_pointer (type, valaddr + embedded_offset);
+ CORE_ADDR addr = unpack_pointer (type,
+ valaddr + embedded_offset * unit_size);
print_unpacked_pointer (type, elttype, addr, stream, options);
}
original_value, options, 0, stream);
}
+/* Print '@' followed by the address contained in ADDRESS_BUFFER. */
+
+static void
+print_ref_address (struct type *type, const gdb_byte *address_buffer,
+ int embedded_offset, struct ui_file *stream)
+{
+ struct gdbarch *gdbarch = get_type_arch (type);
+
+ if (address_buffer != NULL)
+ {
+ CORE_ADDR address
+ = extract_typed_address (address_buffer + embedded_offset, type);
+
+ fprintf_filtered (stream, "@");
+ fputs_filtered (paddress (gdbarch, address), stream);
+ }
+ /* Else: we have a non-addressable value, such as a DW_AT_const_value. */
+}
+
+/* If VAL is addressable, return the value contents buffer of a value that
+ represents a pointer to VAL. Otherwise return NULL. */
+
+static const gdb_byte *
+get_value_addr_contents (struct value *deref_val)
+{
+ gdb_assert (deref_val != NULL);
+
+ if (value_lval_const (deref_val) == lval_memory)
+ return value_contents_for_printing_const (value_addr (deref_val));
+ else
+ {
+ /* We have a non-addressable value, such as a DW_AT_const_value. */
+ return NULL;
+ }
+}
+
/* generic_val_print helper for TYPE_CODE_REF. */
static void
const struct value *original_value,
const struct value_print_options *options)
{
- struct gdbarch *gdbarch = get_type_arch (type);
struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+ struct value *deref_val = NULL;
+ const int value_is_synthetic
+ = value_bits_synthetic_pointer (original_value,
+ TARGET_CHAR_BIT * embedded_offset,
+ TARGET_CHAR_BIT * TYPE_LENGTH (type));
+ const int must_coerce_ref = ((options->addressprint && value_is_synthetic)
+ || options->deref_ref);
+ const int type_is_defined = TYPE_CODE (elttype) != TYPE_CODE_UNDEF;
+
+ if (must_coerce_ref && type_is_defined)
+ {
+ deref_val = coerce_ref_if_computed (original_value);
+
+ if (deref_val != NULL)
+ {
+ /* More complicated computed references are not supported. */
+ gdb_assert (embedded_offset == 0);
+ }
+ else
+ deref_val = value_at (TYPE_TARGET_TYPE (type),
+ unpack_pointer (type, valaddr + embedded_offset));
+ }
+ /* Else, original_value isn't a synthetic reference or we don't have to print
+ the reference's contents.
+
+ Notice that for references to TYPE_CODE_STRUCT, 'set print object on' will
+ cause original_value to be a not_lval instead of an lval_computed,
+ which will make value_bits_synthetic_pointer return false.
+ This happens because if options->objectprint is true, c_value_print will
+ overwrite original_value's contents with the result of coercing
+ the reference through value_addr, and then set its type back to
+ TYPE_CODE_REF. In that case we don't have to coerce the reference again;
+ we can simply treat it as non-synthetic and move on. */
if (options->addressprint)
{
- CORE_ADDR addr
- = extract_typed_address (valaddr + embedded_offset, type);
+ const gdb_byte *address = (value_is_synthetic && type_is_defined
+ ? get_value_addr_contents (deref_val)
+ : valaddr);
+
+ print_ref_address (type, address, embedded_offset, stream);
- fprintf_filtered (stream, "@");
- fputs_filtered (paddress (gdbarch, addr), stream);
if (options->deref_ref)
fputs_filtered (": ", stream);
}
- /* De-reference the reference. */
+
if (options->deref_ref)
{
- if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
- {
- struct value *deref_val;
-
- deref_val = coerce_ref_if_computed (original_value);
- if (deref_val != NULL)
- {
- /* More complicated computed references are not supported. */
- gdb_assert (embedded_offset == 0);
- }
- else
- deref_val = value_at (TYPE_TARGET_TYPE (type),
- unpack_pointer (type,
- (valaddr
- + embedded_offset)));
-
- common_val_print (deref_val, stream, recurse, options,
- current_language);
- }
+ if (type_is_defined)
+ common_val_print (deref_val, stream, recurse, options,
+ current_language);
else
fputs_filtered ("???", stream);
}
}
-/* generic_val_print helper for TYPE_CODE_ENUM. */
+/* Helper function for generic_val_print_enum.
+ This is also used to print enums in TYPE_CODE_FLAGS values. */
static void
-generic_val_print_enum (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, struct ui_file *stream,
- const struct value *original_value,
- const struct value_print_options *options)
+generic_val_print_enum_1 (struct type *type, LONGEST val,
+ struct ui_file *stream)
{
unsigned int i;
unsigned int len;
- LONGEST val;
- if (options->format)
- {
- val_print_scalar_formatted (type, valaddr, embedded_offset,
- original_value, options, 0, stream);
- return;
- }
len = TYPE_NFIELDS (type);
- val = unpack_long (type, valaddr + embedded_offset);
for (i = 0; i < len; i++)
{
QUIT;
print_longest (stream, 'd', 0, val);
}
+/* generic_val_print helper for TYPE_CODE_ENUM. */
+
+static void
+generic_val_print_enum (struct type *type, const gdb_byte *valaddr,
+ int embedded_offset, struct ui_file *stream,
+ const struct value *original_value,
+ const struct value_print_options *options)
+{
+ LONGEST val;
+ struct gdbarch *gdbarch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
+
+ if (options->format)
+ {
+ val_print_scalar_formatted (type, valaddr, embedded_offset,
+ original_value, options, 0, stream);
+ return;
+ }
+ val = unpack_long (type, valaddr + embedded_offset * unit_size);
+
+ generic_val_print_enum_1 (type, val, stream);
+}
+
/* generic_val_print helper for TYPE_CODE_FLAGS. */
static void
const struct generic_val_print_decorations *decorations)
{
LONGEST val;
+ struct gdbarch *gdbarch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
if (options->format || options->output_format)
{
}
else
{
- val = unpack_long (type, valaddr + embedded_offset);
+ val = unpack_long (type, valaddr + embedded_offset * unit_size);
if (val == 0)
fputs_filtered (decorations->false_name, stream);
else if (val == 1)
const struct value *original_value,
const struct value_print_options *options)
{
+ struct gdbarch *gdbarch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
+
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
original_value, &opts, 0, stream);
}
else
- val_print_type_code_int (type, valaddr + embedded_offset, stream);
+ val_print_type_code_int (type, valaddr + embedded_offset * unit_size,
+ stream);
}
/* generic_val_print helper for TYPE_CODE_CHAR. */
const struct value_print_options *options)
{
LONGEST val;
+ struct gdbarch *gdbarch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
if (options->format || options->output_format)
{
}
else
{
- val = unpack_long (type, valaddr + embedded_offset);
+ val = unpack_long (type, valaddr + embedded_offset * unit_size);
if (TYPE_UNSIGNED (type))
fprintf_filtered (stream, "%u", (unsigned int) val);
else
const struct value *original_value,
const struct value_print_options *options)
{
+ struct gdbarch *gdbarch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
+
if (options->format)
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
}
else
{
- print_floating (valaddr + embedded_offset, type, stream);
+ print_floating (valaddr + embedded_offset * unit_size, type, stream);
}
}
const struct value *original_value,
const struct value_print_options *options)
{
+ struct gdbarch *gdbarch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
+
if (options->format)
val_print_scalar_formatted (type, valaddr, embedded_offset, original_value,
options, 0, stream);
else
- print_decimal_floating (valaddr + embedded_offset, type, stream);
+ print_decimal_floating (valaddr + embedded_offset * unit_size, type,
+ stream);
}
/* generic_val_print helper for TYPE_CODE_COMPLEX. */
const struct generic_val_print_decorations
*decorations)
{
+ struct gdbarch *gdbarch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
+
fprintf_filtered (stream, "%s", decorations->complex_prefix);
if (options->format)
val_print_scalar_formatted (TYPE_TARGET_TYPE (type), valaddr,
embedded_offset, original_value, options, 0,
stream);
else
- print_floating (valaddr + embedded_offset, TYPE_TARGET_TYPE (type),
- stream);
+ print_floating (valaddr + embedded_offset * unit_size,
+ TYPE_TARGET_TYPE (type), stream);
fprintf_filtered (stream, "%s", decorations->complex_infix);
if (options->format)
val_print_scalar_formatted (TYPE_TARGET_TYPE (type), valaddr,
embedded_offset
- + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
+ + type_length_units (TYPE_TARGET_TYPE (type)),
original_value, options, 0, stream);
else
- print_floating (valaddr + embedded_offset
+ print_floating (valaddr + embedded_offset * unit_size
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
TYPE_TARGET_TYPE (type), stream);
fprintf_filtered (stream, "%s", decorations->complex_suffix);
{
case TYPE_CODE_ARRAY:
generic_val_print_array (type, valaddr, embedded_offset, address, stream,
- recurse, original_value, options);
+ recurse, original_value, options, decorations);
break;
case TYPE_CODE_MEMBERPTR:
break;
case TYPE_CODE_UNDEF:
- /* This happens (without TYPE_FLAG_STUB set) on systems which
- don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
- "struct foo *bar" and no complete type for struct foo in that
- file. */
+ /* This happens (without TYPE_STUB set) on systems which don't use
+ dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
+ and no complete type for struct foo in that file. */
fprintf_filtered (stream, _("<incomplete type>"));
break;
RECURSE. */
void
-val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
+val_print (struct type *type, const gdb_byte *valaddr, LONGEST embedded_offset,
CORE_ADDR address, struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
return 0;
}
+ if (type_not_associated (value_type (val)))
+ {
+ val_print_not_associated (stream);
+ return 0;
+ }
+
+ if (type_not_allocated (value_type (val)))
+ {
+ val_print_not_allocated (stream);
+ return 0;
+ }
+
return 1;
}
}
}
-void
+static void
val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
struct ui_file *stream)
{
ULONGEST val = unpack_long (type, valaddr);
- int bitpos, nfields = TYPE_NFIELDS (type);
+ int field, nfields = TYPE_NFIELDS (type);
+ struct gdbarch *gdbarch = get_type_arch (type);
+ struct type *bool_type = builtin_type (gdbarch)->builtin_bool;
- fputs_filtered ("[ ", stream);
- for (bitpos = 0; bitpos < nfields; bitpos++)
+ fputs_filtered ("[", stream);
+ for (field = 0; field < nfields; field++)
{
- if (TYPE_FIELD_BITPOS (type, bitpos) != -1
- && (val & ((ULONGEST)1 << bitpos)))
+ if (TYPE_FIELD_NAME (type, field)[0] != '\0')
{
- if (TYPE_FIELD_NAME (type, bitpos))
- fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos));
+ struct type *field_type = TYPE_FIELD_TYPE (type, field);
+
+ if (field_type == bool_type
+ /* We require boolean types here to be one bit wide. This is a
+ problematic place to notify the user of an internal error
+ though. Instead just fall through and print the field as an
+ int. */
+ && TYPE_FIELD_BITSIZE (type, field) == 1)
+ {
+ if (val & ((ULONGEST)1 << TYPE_FIELD_BITPOS (type, field)))
+ fprintf_filtered (stream, " %s",
+ TYPE_FIELD_NAME (type, field));
+ }
else
- fprintf_filtered (stream, "#%d ", bitpos);
+ {
+ unsigned field_len = TYPE_FIELD_BITSIZE (type, field);
+ ULONGEST field_val
+ = val >> (TYPE_FIELD_BITPOS (type, field) - field_len + 1);
+
+ if (field_len < sizeof (ULONGEST) * TARGET_CHAR_BIT)
+ field_val &= ((ULONGEST) 1 << field_len) - 1;
+ fprintf_filtered (stream, " %s=",
+ TYPE_FIELD_NAME (type, field));
+ if (TYPE_CODE (field_type) == TYPE_CODE_ENUM)
+ generic_val_print_enum_1 (field_type, field_val, stream);
+ else
+ print_longest (stream, 'd', 0, field_val);
+ }
}
}
- fputs_filtered ("]", stream);
+ fputs_filtered (" ]", stream);
}
/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
void
val_print_scalar_formatted (struct type *type,
- const gdb_byte *valaddr, int embedded_offset,
+ const gdb_byte *valaddr, LONGEST embedded_offset,
const struct value *val,
const struct value_print_options *options,
int size,
struct ui_file *stream)
{
+ struct gdbarch *arch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (arch);
+
gdb_assert (val != NULL);
gdb_assert (valaddr == value_contents_for_printing_const (val));
else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
val_print_unavailable (stream);
else
- print_scalar_formatted (valaddr + embedded_offset, type,
+ print_scalar_formatted (valaddr + embedded_offset * unit_size, type,
options, size, stream);
}
as the base 16 number, which is 2 digits per byte. */
decimal_len = len * 2 * 2;
- digits = xmalloc (decimal_len);
+ digits = (unsigned char *) xmalloc (decimal_len);
for (i = 0; i < decimal_len; i++)
{
void
val_print_array_elements (struct type *type,
- const gdb_byte *valaddr, int embedded_offset,
+ const gdb_byte *valaddr, LONGEST embedded_offset,
CORE_ADDR address, struct ui_file *stream,
int recurse,
const struct value *val,
LONGEST low_pos, high_pos;
elttype = TYPE_TARGET_TYPE (type);
- eltlen = TYPE_LENGTH (check_typedef (elttype));
+ eltlen = type_length_units (check_typedef (elttype));
index_type = TYPE_INDEX_TYPE (type);
if (get_array_bounds (type, &low_bound, &high_bound))
{
/* We want fetchlimit chars, so we might as well read them all in
one operation. */
- unsigned int fetchlen = min (len, fetchlimit);
+ unsigned int fetchlen = std::min ((unsigned) len, fetchlimit);
*buffer = (gdb_byte *) xmalloc (fetchlen * width);
bufptr = *buffer;
So we choose the minimum of 8 and fetchlimit. We used to use 200
instead of 8 but 200 is way too big for remote debugging over a
serial line. */
- chunksize = min (8, fetchlimit);
+ chunksize = std::min (8u, fetchlimit);
do
{
QUIT;
- nfetch = min (chunksize, fetchlimit - bufsize);
+ nfetch = std::min ((unsigned long) chunksize, fetchlimit - bufsize);
if (*buffer == NULL)
*buffer = (gdb_byte *) xmalloc (nfetch * width);
else
{ /* Length of string is really 0! */
/* We always allocate *buffer. */
- *buffer = bufptr = xmalloc (1);
+ *buffer = bufptr = (gdb_byte *) xmalloc (1);
errcode = 0;
}
struct wchar_iterator *iter;
int need_escape = 0;
- buf = alloca (TYPE_LENGTH (type));
+ buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
pack_long (buf, type, c);
iter = make_wchar_iterator (buf, TYPE_LENGTH (type),
sizeof (gdb_wchar_t), &output, translit_char);
obstack_1grow (&output, '\0');
- fputs_filtered (obstack_base (&output), stream);
+ fputs_filtered ((const char *) obstack_base (&output), stream);
do_cleanups (cleanups);
}
sizeof (gdb_wchar_t), &output, translit_char);
obstack_1grow (&output, '\0');
- fputs_filtered (obstack_base (&output), stream);
+ fputs_filtered ((const char *) obstack_base (&output), stream);
do_cleanups (cleanup);
}
const struct value_print_options *options)
{
int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
- int errcode; /* Errno returned from bad reads. */
+ int err; /* Non-zero if we got a bad read. */
int found_nul; /* Non-zero if we found the nul char. */
unsigned int fetchlimit; /* Maximum number of chars to print. */
int bytes_read;
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 : std::min ((unsigned) len,
+ options->print_max));
- errcode = read_string (addr, len, width, fetchlimit, byte_order,
- &buffer, &bytes_read);
+ err = read_string (addr, len, width, fetchlimit, byte_order,
+ &buffer, &bytes_read);
old_chain = make_cleanup (xfree, buffer);
addr += bytes_read;
&& extract_unsigned_integer (peekbuf, width, byte_order) != 0)
force_ellipsis = 1;
}
- else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
+ else if ((len >= 0 && err != 0) || (len > bytes_read / width))
{
/* Getting an error when we have a requested length, or fetching less
than the number of characters actually requested, always make us
/* If we get an error before fetching anything, don't print a string.
But if we fetch something and then get an error, print the string
and then the error message. */
- if (errcode == 0 || bytes_read > 0)
+ if (err == 0 || bytes_read > 0)
{
LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
encoding, force_ellipsis, options);
}
- if (errcode != 0)
+ if (err != 0)
{
char *str;
- str = memory_error_message (errcode, gdbarch, addr);
+ str = memory_error_message (TARGET_XFER_E_IO, gdbarch, addr);
make_cleanup (xfree, str);
fprintf_filtered (stream, "<error: ");