/* Print values for GDB, the GNU debugger.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "target-float.h"
#include "extension.h"
#include "ada-lang.h"
-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.h"
#include "charset.h"
#include "typeprint.h"
#include <ctype.h>
#include "gdbarch.h"
#include "cli/cli-style.h"
#include "count-one-bits.h"
+#include "c-lang.h"
+#include "cp-abi.h"
+#include "inferior.h"
+#include "gdbsupport/selftest.h"
+#include "selftest-arch.h"
/* 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 value *original_value,
+ int embedded_offset,
struct ui_file *stream);
#define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
10, /* repeat_count_threshold */
0, /* output_format */
0, /* format */
+ 1, /* memory_tag_violations */
0, /* stop_print_at_null */
0, /* print_array_indexes */
0, /* deref_ref */
static void
show_print_array_indexes (struct ui_file *file, int from_tty,
- struct cmd_list_element *c, const char *value)
+ struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
}
value);
}
+/* If nonzero, prints memory tag violations for pointers. */
+
+static void
+show_memory_tag_violations (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file,
+ _("Printing of memory tag violations is %s.\n"),
+ value);
+}
+
/* If nonzero, stops printing of char arrays at first null. */
static void
type = TYPE_TARGET_TYPE (type);
type = check_typedef (type);
}
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_ARRAY:
case TYPE_CODE_STRUCT:
const struct language_defn *language)
{
return (val_print_scalar_type_p (type)
- || language->la_is_string_type_p (type));
+ || language->is_string_type_p (type));
}
-/* See its definition in value.h. */
+/* See valprint.h. */
int
valprint_check_validity (struct ui_file *stream,
return 0;
}
- if (TYPE_CODE (type) != TYPE_CODE_UNION
- && TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_ARRAY)
+ if (type->code () != TYPE_CODE_UNION
+ && type->code () != TYPE_CODE_STRUCT
+ && type->code () != TYPE_CODE_ARRAY)
{
if (value_bits_any_optimized_out (val,
TARGET_CHAR_BIT * embedded_offset,
if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * embedded_offset,
TARGET_CHAR_BIT * TYPE_LENGTH (type)))
{
- const int is_ref = TYPE_CODE (type) == TYPE_CODE_REF;
+ const int is_ref = type->code () == TYPE_CODE_REF;
int ref_is_addressable = 0;
if (is_ref)
CORE_ADDR address, struct ui_file *stream,
const struct value_print_options *options)
{
- struct gdbarch *gdbarch = get_type_arch (type);
+ struct gdbarch *gdbarch = type->arch ();
- if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
+ if (elttype->code () == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
print_function_pointer_address (options, gdbarch, address, stream);
/* generic_val_print helper for TYPE_CODE_ARRAY. */
static void
-generic_val_print_array (struct type *type,
- int embedded_offset, CORE_ADDR address,
+generic_val_print_array (struct value *val,
struct ui_file *stream, int recurse,
- struct value *original_value,
const struct value_print_options *options,
const struct
generic_val_print_decorations *decorations)
{
+ struct type *type = check_typedef (value_type (val));
struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
struct type *elttype = check_typedef (unresolved_elttype);
if (!get_array_bounds (type, &low_bound, &high_bound))
error (_("Could not determine the array high bound"));
- if (options->prettyformat_arrays)
- {
- print_spaces_filtered (2 + 2 * recurse, stream);
- }
-
fputs_filtered (decorations->array_start, stream);
- val_print_array_elements (type, embedded_offset,
- address, stream,
- recurse, original_value, options, 0);
+ value_print_array_elements (val, stream, recurse, options, 0);
fputs_filtered (decorations->array_end, stream);
}
else
{
/* Array of unspecified length: treat like pointer to first elt. */
- print_unpacked_pointer (type, elttype, address + embedded_offset, stream,
- options);
- }
-
-}
-
-/* generic_val_print helper for TYPE_CODE_PTR. */
-
-static void
-generic_val_print_ptr (struct type *type,
- int embedded_offset, struct ui_file *stream,
- 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, embedded_offset,
- original_value, options, 0, stream);
+ print_unpacked_pointer (type, elttype, value_address (val),
+ stream, options);
}
- else
- {
- struct type *unresolved_elttype = TYPE_TARGET_TYPE(type);
- struct type *elttype = check_typedef (unresolved_elttype);
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
- CORE_ADDR addr = unpack_pointer (type,
- valaddr + embedded_offset * unit_size);
- print_unpacked_pointer (type, elttype, addr, stream, options);
- }
}
/* generic_value_print helper for TYPE_CODE_PTR. */
{
struct type *type = check_typedef (value_type (val));
struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
- const gdb_byte *valaddr = value_contents_for_printing (val);
+ const gdb_byte *valaddr = value_contents_for_printing (val).data ();
CORE_ADDR addr = unpack_pointer (type, valaddr);
print_unpacked_pointer (type, elttype, addr, stream, options);
}
-/* generic_val_print helper for TYPE_CODE_MEMBERPTR. */
-
-static void
-generic_val_print_memberptr (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options)
-{
- val_print_scalar_formatted (type, embedded_offset,
- 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);
+ struct gdbarch *gdbarch = type->arch ();
if (address_buffer != NULL)
{
gdb_assert (deref_val != NULL);
if (value_lval_const (deref_val) == lval_memory)
- return value_contents_for_printing_const (value_addr (deref_val));
+ return value_contents_for_printing_const (value_addr (deref_val)).data ();
else
{
/* We have a non-addressable value, such as a DW_AT_const_value. */
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;
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ const int type_is_defined = elttype->code () != TYPE_CODE_UNDEF;
+ const gdb_byte *valaddr = value_contents_for_printing (original_value).data ();
if (must_coerce_ref && type_is_defined)
{
unsigned int i;
unsigned int len;
- len = TYPE_NFIELDS (type);
+ len = type->num_fields ();
for (i = 0; i < len; i++)
{
QUIT;
- if (val == TYPE_FIELD_ENUMVAL (type, i))
+ if (val == type->field (i).loc_enumval ())
{
break;
}
}
if (i < len)
{
- fputs_styled (TYPE_FIELD_NAME (type, i), variable_name_style.style (),
+ fputs_styled (type->field (i).name (), variable_name_style.style (),
stream);
}
- else if (TYPE_FLAG_ENUM (type))
+ else if (type->is_flag_enum ())
{
int first = 1;
{
QUIT;
- ULONGEST enumval = TYPE_FIELD_ENUMVAL (type, i);
+ ULONGEST enumval = type->field (i).loc_enumval ();
int nbits = count_one_bits_ll (enumval);
gdb_assert (nbits == 0 || nbits == 1);
else
fputs_filtered (" | ", stream);
- val &= ~TYPE_FIELD_ENUMVAL (type, i);
- fputs_styled (TYPE_FIELD_NAME (type, i),
+ val &= ~type->field (i).loc_enumval ();
+ fputs_styled (type->field (i).name (),
variable_name_style.style (), stream);
}
}
const struct value_print_options *options)
{
LONGEST val;
- struct gdbarch *gdbarch = get_type_arch (type);
+ struct gdbarch *gdbarch = type->arch ();
int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
- if (options->format)
- {
- val_print_scalar_formatted (type, embedded_offset,
- original_value, options, 0, stream);
- }
- else
- {
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
-
- val = unpack_long (type, valaddr + embedded_offset * unit_size);
-
- generic_val_print_enum_1 (type, val, stream);
- }
-}
+ gdb_assert (!options->format);
-/* generic_val_print helper for TYPE_CODE_FLAGS. */
+ const gdb_byte *valaddr = value_contents_for_printing (original_value).data ();
-static void
-generic_val_print_flags (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options)
-
-{
- if (options->format)
- val_print_scalar_formatted (type, embedded_offset, original_value,
- options, 0, stream);
- else
- {
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ val = unpack_long (type, valaddr + embedded_offset * unit_size);
- val_print_type_code_flags (type, valaddr + embedded_offset, stream);
- }
+ generic_val_print_enum_1 (type, val, stream);
}
/* generic_val_print helper for TYPE_CODE_FUNC and TYPE_CODE_METHOD. */
struct value *original_value,
const struct value_print_options *options)
{
- struct gdbarch *gdbarch = get_type_arch (type);
+ struct gdbarch *gdbarch = type->arch ();
- if (options->format)
- {
- val_print_scalar_formatted (type, embedded_offset,
- original_value, options, 0, stream);
- }
- else
- {
- /* FIXME, we should consider, at least for ANSI C language,
- eliminating the distinction made between FUNCs and POINTERs
- to FUNCs. */
- fprintf_filtered (stream, "{");
- type_print (type, "", stream, -1);
- fprintf_filtered (stream, "} ");
- /* Try to print what function it points to, and its address. */
- print_address_demangle (options, gdbarch, address, stream, demangle);
- }
+ gdb_assert (!options->format);
+
+ /* FIXME, we should consider, at least for ANSI C language,
+ eliminating the distinction made between FUNCs and POINTERs to
+ FUNCs. */
+ fprintf_filtered (stream, "{");
+ type_print (type, "", stream, -1);
+ fprintf_filtered (stream, "} ");
+ /* Try to print what function it points to, and its address. */
+ print_address_demangle (options, gdbarch, address, stream, demangle);
}
-/* generic_val_print helper for TYPE_CODE_BOOL. */
+/* generic_value_print helper for TYPE_CODE_BOOL. */
static void
-generic_val_print_bool (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options,
- const struct generic_val_print_decorations *decorations)
+generic_value_print_bool
+ (struct value *value, struct ui_file *stream,
+ const struct value_print_options *options,
+ 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)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
- val_print_scalar_formatted (type, embedded_offset,
- original_value, &opts, 0, stream);
+ value_print_scalar_formatted (value, &opts, 0, stream);
}
else
{
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
-
- val = unpack_long (type, valaddr + embedded_offset * unit_size);
+ const gdb_byte *valaddr = value_contents_for_printing (value).data ();
+ struct type *type = check_typedef (value_type (value));
+ LONGEST val = unpack_long (type, valaddr);
if (val == 0)
fputs_filtered (decorations->false_name, stream);
else if (val == 1)
}
}
-/* generic_val_print helper for TYPE_CODE_INT. */
+/* generic_value_print helper for TYPE_CODE_INT. */
static void
-generic_val_print_int (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options)
+generic_value_print_int (struct value *val, struct ui_file *stream,
+ const struct value_print_options *options)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
- val_print_scalar_formatted (type, embedded_offset,
- original_value, &opts, 0, stream);
+ value_print_scalar_formatted (val, &opts, 0, stream);
}
-/* generic_val_print helper for TYPE_CODE_CHAR. */
+/* generic_value_print helper for TYPE_CODE_CHAR. */
static void
-generic_val_print_char (struct type *type, struct type *unresolved_type,
- int embedded_offset,
- struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options)
+generic_value_print_char (struct value *value, struct ui_file *stream,
+ 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)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
- val_print_scalar_formatted (type, embedded_offset,
- original_value, &opts, 0, stream);
+ value_print_scalar_formatted (value, &opts, 0, stream);
}
else
{
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ struct type *unresolved_type = value_type (value);
+ struct type *type = check_typedef (unresolved_type);
+ const gdb_byte *valaddr = value_contents_for_printing (value).data ();
- val = unpack_long (type, valaddr + embedded_offset * unit_size);
- if (TYPE_UNSIGNED (type))
+ LONGEST val = unpack_long (type, valaddr);
+ if (type->is_unsigned ())
fprintf_filtered (stream, "%u", (unsigned int) val);
else
fprintf_filtered (stream, "%d", (int) val);
fputs_filtered (" ", stream);
- LA_PRINT_CHAR (val, unresolved_type, stream);
+ current_language->printchar (val, unresolved_type, stream);
}
}
/* generic_val_print helper for TYPE_CODE_FLT and TYPE_CODE_DECFLOAT. */
static void
-generic_val_print_float (struct type *type,
- int embedded_offset, struct ui_file *stream,
+generic_val_print_float (struct type *type, struct ui_file *stream,
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);
+ gdb_assert (!options->format);
- if (options->format)
- {
- val_print_scalar_formatted (type, embedded_offset,
- original_value, options, 0, stream);
- }
- else
- {
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ const gdb_byte *valaddr = value_contents_for_printing (original_value).data ();
- print_floating (valaddr + embedded_offset * unit_size, type, stream);
- }
+ print_floating (valaddr, type, stream);
}
-/* generic_val_print helper for TYPE_CODE_COMPLEX. */
+/* generic_val_print helper for TYPE_CODE_FIXED_POINT. */
static void
-generic_val_print_complex (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options,
- const struct generic_val_print_decorations
- *decorations)
+generic_val_print_fixed_point (struct value *val, struct ui_file *stream,
+ const struct value_print_options *options)
{
- struct gdbarch *gdbarch = get_type_arch (type);
- int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
-
- fprintf_filtered (stream, "%s", decorations->complex_prefix);
- if (options->format)
- val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
- embedded_offset, original_value, options, 0,
- stream);
- else
- 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),
- embedded_offset
- + type_length_units (TYPE_TARGET_TYPE (type)),
- original_value, options, 0, stream);
+ value_print_scalar_formatted (val, options, 0, stream);
else
- 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);
-}
-
-/* A generic val_print that is suitable for use by language
- implementations of the la_val_print method. This function can
- handle most type codes, though not all, notably exception
- TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
- the caller.
-
- Most arguments are as to val_print.
-
- The additional DECORATIONS argument can be used to customize the
- output in some small, language-specific ways. */
-
-void
-generic_val_print (struct type *type,
- int embedded_offset, CORE_ADDR address,
- struct ui_file *stream, int recurse,
- struct value *original_value,
- const struct value_print_options *options,
- const struct generic_val_print_decorations *decorations)
-{
- struct type *unresolved_type = type;
-
- type = check_typedef (type);
- switch (TYPE_CODE (type))
{
- case TYPE_CODE_ARRAY:
- generic_val_print_array (type, embedded_offset, address, stream,
- recurse, original_value, options, decorations);
- break;
+ struct type *type = value_type (val);
- case TYPE_CODE_MEMBERPTR:
- generic_val_print_memberptr (type, embedded_offset, stream,
- original_value, options);
- break;
-
- case TYPE_CODE_PTR:
- generic_val_print_ptr (type, embedded_offset, stream,
- original_value, options);
- break;
-
- case TYPE_CODE_REF:
- case TYPE_CODE_RVALUE_REF:
- generic_val_print_ref (type, embedded_offset, stream, recurse,
- original_value, options);
- break;
-
- case TYPE_CODE_ENUM:
- generic_val_print_enum (type, embedded_offset, stream,
- original_value, options);
- break;
-
- case TYPE_CODE_FLAGS:
- generic_val_print_flags (type, embedded_offset, stream,
- original_value, options);
- break;
+ const gdb_byte *valaddr = value_contents_for_printing (val).data ();
+ gdb_mpf f;
- case TYPE_CODE_FUNC:
- case TYPE_CODE_METHOD:
- generic_val_print_func (type, embedded_offset, address, stream,
- original_value, options);
- break;
-
- case TYPE_CODE_BOOL:
- generic_val_print_bool (type, embedded_offset, stream,
- original_value, options, decorations);
- break;
-
- case TYPE_CODE_RANGE:
- /* FIXME: create_static_range_type does not set the unsigned bit in a
- range type (I think it probably should copy it from the
- target type), so we won't print values which are too large to
- fit in a signed integer correctly. */
- /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
- print with the target type, though, because the size of our
- type and the target type might differ). */
-
- /* FALLTHROUGH */
-
- case TYPE_CODE_INT:
- generic_val_print_int (type, embedded_offset, stream,
- original_value, options);
- break;
+ f.read_fixed_point (gdb::make_array_view (valaddr, TYPE_LENGTH (type)),
+ type_byte_order (type), type->is_unsigned (),
+ type->fixed_point_scaling_factor ());
- case TYPE_CODE_CHAR:
- generic_val_print_char (type, unresolved_type, embedded_offset,
- stream, original_value, options);
- break;
+ const char *fmt = TYPE_LENGTH (type) < 4 ? "%.11Fg" : "%.17Fg";
+ std::string str = gmp_string_printf (fmt, f.val);
+ fprintf_filtered (stream, "%s", str.c_str ());
+ }
+}
- case TYPE_CODE_FLT:
- case TYPE_CODE_DECFLOAT:
- generic_val_print_float (type, embedded_offset, stream,
- original_value, options);
- break;
+/* generic_value_print helper for TYPE_CODE_COMPLEX. */
- case TYPE_CODE_VOID:
- fputs_filtered (decorations->void_name, stream);
- break;
+static void
+generic_value_print_complex (struct value *val, struct ui_file *stream,
+ const struct value_print_options *options,
+ const struct generic_val_print_decorations
+ *decorations)
+{
+ fprintf_filtered (stream, "%s", decorations->complex_prefix);
- case TYPE_CODE_ERROR:
- fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
- break;
+ struct value *real_part = value_real_part (val);
+ value_print_scalar_formatted (real_part, options, 0, stream);
+ fprintf_filtered (stream, "%s", decorations->complex_infix);
- case TYPE_CODE_UNDEF:
- /* 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_styled (stream, metadata_style.style (), _("<incomplete type>"));
- break;
+ struct value *imag_part = value_imaginary_part (val);
+ value_print_scalar_formatted (imag_part, options, 0, stream);
+ fprintf_filtered (stream, "%s", decorations->complex_suffix);
+}
- case TYPE_CODE_COMPLEX:
- generic_val_print_complex (type, embedded_offset, stream,
- original_value, options, decorations);
- break;
+/* generic_value_print helper for TYPE_CODE_MEMBERPTR. */
- case TYPE_CODE_UNION:
- case TYPE_CODE_STRUCT:
- case TYPE_CODE_METHODPTR:
- default:
- error (_("Unhandled type code %d in symbol table."),
- TYPE_CODE (type));
+static void
+generic_value_print_memberptr
+ (struct value *val, struct ui_file *stream,
+ int recurse,
+ const struct value_print_options *options,
+ const struct generic_val_print_decorations *decorations)
+{
+ if (!options->format)
+ {
+ /* Member pointers are essentially specific to C++, and so if we
+ encounter one, we should print it according to C++ rules. */
+ struct type *type = check_typedef (value_type (val));
+ const gdb_byte *valaddr = value_contents_for_printing (val).data ();
+ cp_print_class_member (valaddr, type, stream, "&");
}
+ else
+ generic_value_print (val, stream, recurse, options, decorations);
}
/* See valprint.h. */
const struct generic_val_print_decorations *decorations)
{
struct type *type = value_type (val);
- struct type *unresolved_type = type;
type = check_typedef (type);
- switch (TYPE_CODE (type))
+
+ if (is_fixed_point_type (type))
+ type = type->fixed_point_type_base_type ();
+
+ switch (type->code ())
{
case TYPE_CODE_ARRAY:
- generic_val_print_array (type, 0, value_address (val), stream,
- recurse, val, options, decorations);
+ generic_val_print_array (val, stream, recurse, options, decorations);
break;
case TYPE_CODE_MEMBERPTR:
- value_print_scalar_formatted (val, options, 0, stream);
+ generic_value_print_memberptr (val, stream, recurse, options,
+ decorations);
break;
case TYPE_CODE_PTR:
break;
case TYPE_CODE_ENUM:
- generic_val_print_enum (type, 0, stream,
- val, options);
+ if (options->format)
+ value_print_scalar_formatted (val, options, 0, stream);
+ else
+ generic_val_print_enum (type, 0, stream, val, options);
break;
case TYPE_CODE_FLAGS:
- generic_val_print_flags (type, 0, stream,
- val, options);
+ if (options->format)
+ value_print_scalar_formatted (val, options, 0, stream);
+ else
+ val_print_type_code_flags (type, val, 0, stream);
break;
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
- generic_val_print_func (type, 0, value_address (val), stream,
- val, options);
+ if (options->format)
+ value_print_scalar_formatted (val, options, 0, stream);
+ else
+ generic_val_print_func (type, 0, value_address (val), stream,
+ val, options);
break;
case TYPE_CODE_BOOL:
- generic_val_print_bool (type, 0, stream,
- val, options, decorations);
+ generic_value_print_bool (val, stream, options, decorations);
break;
case TYPE_CODE_RANGE:
- /* FIXME: create_static_range_type does not set the unsigned bit in a
- range type (I think it probably should copy it from the
- target type), so we won't print values which are too large to
- fit in a signed integer correctly. */
- /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
- print with the target type, though, because the size of our
- type and the target type might differ). */
-
- /* FALLTHROUGH */
-
case TYPE_CODE_INT:
- generic_val_print_int (type, 0, stream,
- val, options);
+ generic_value_print_int (val, stream, options);
break;
case TYPE_CODE_CHAR:
- generic_val_print_char (type, unresolved_type, 0,
- stream, val, options);
+ generic_value_print_char (val, stream, options);
break;
case TYPE_CODE_FLT:
case TYPE_CODE_DECFLOAT:
- generic_val_print_float (type, 0, stream,
- val, options);
+ if (options->format)
+ value_print_scalar_formatted (val, options, 0, stream);
+ else
+ generic_val_print_float (type, stream, val, options);
+ break;
+
+ case TYPE_CODE_FIXED_POINT:
+ generic_val_print_fixed_point (val, stream, options);
break;
case TYPE_CODE_VOID:
case TYPE_CODE_UNDEF:
/* 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. */
+ 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_styled (stream, metadata_style.style (), _("<incomplete type>"));
break;
case TYPE_CODE_COMPLEX:
- generic_val_print_complex (type, 0, stream,
- val, options, decorations);
+ generic_value_print_complex (val, stream, options, decorations);
+ break;
+
+ case TYPE_CODE_METHODPTR:
+ cplus_print_method_ptr (value_contents_for_printing (val).data (), type,
+ stream);
break;
case TYPE_CODE_UNION:
case TYPE_CODE_STRUCT:
- case TYPE_CODE_METHODPTR:
default:
error (_("Unhandled type code %d in symbol table."),
- TYPE_CODE (type));
+ type->code ());
}
}
-/* Helper function for val_print and common_val_print that does the
- work. Arguments are as to val_print, but FULL_VALUE, if given, is
- the value to be printed. */
+/* Print using the given LANGUAGE the value VAL onto stream STREAM according
+ to OPTIONS.
+
+ This is a preferable interface to val_print, above, because it uses
+ GDB's value mechanism. */
+
+void
+common_val_print (struct value *value, struct ui_file *stream, int recurse,
+ const struct value_print_options *options,
+ const struct language_defn *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. */
+ value = ada_to_fixed_value (value);
+
+ if (value_lazy (value))
+ value_fetch_lazy (value);
-static void
-do_val_print (struct value *full_value,
- struct type *type, LONGEST embedded_offset,
- CORE_ADDR address, struct ui_file *stream, int recurse,
- struct value *val,
- const struct value_print_options *options,
- const struct language_defn *language)
-{
- int ret = 0;
struct value_print_options local_opts = *options;
+ struct type *type = value_type (value);
struct type *real_type = check_typedef (type);
if (local_opts.prettyformat == Val_prettyformat_default)
only a stub and we can't find and substitute its complete type, then
print appropriate string and return. */
- if (TYPE_STUB (real_type))
+ if (real_type->is_stub ())
{
fprintf_styled (stream, metadata_style.style (), _("<incomplete type>"));
return;
}
- if (!valprint_check_validity (stream, real_type, embedded_offset, val))
+ if (!valprint_check_validity (stream, real_type, 0, value))
return;
if (!options->raw)
{
- ret = apply_ext_lang_val_pretty_printer (type, embedded_offset,
- address, stream, recurse,
- val, options, language);
- if (ret)
+ if (apply_ext_lang_val_pretty_printer (value, stream, recurse, options,
+ language))
return;
}
try
{
- if (full_value != nullptr && language->la_value_print_inner != nullptr)
- language->la_value_print_inner (full_value, stream, recurse,
- &local_opts);
- else
- language->la_val_print (type, embedded_offset, address,
- stream, recurse, val,
- &local_opts);
+ language->value_print_inner (value, stream, recurse, &local_opts);
}
catch (const gdb_exception_error &except)
{
fprintf_styled (stream, metadata_style.style (),
- _("<error reading variable>"));
+ _("<error reading variable: %s>"), except.what ());
}
}
-/* Print using the given LANGUAGE the data of type TYPE located at
- VAL's contents buffer + EMBEDDED_OFFSET (within GDB), which came
- from the inferior at address ADDRESS + EMBEDDED_OFFSET, onto
- stdio stream STREAM according to OPTIONS. VAL is the whole object
- that came from ADDRESS.
-
- The language printers will pass down an adjusted EMBEDDED_OFFSET to
- further helper subroutines as subfields of TYPE are printed. In
- such cases, VAL is passed down unadjusted, so
- that VAL can be queried for metadata about the contents data being
- printed, using EMBEDDED_OFFSET as an offset into VAL's contents
- buffer. For example: "has this field been optimized out", or "I'm
- printing an object while inspecting a traceframe; has this
- particular piece of data been collected?".
-
- RECURSE indicates the amount of indentation to supply before
- continuation lines; this amount is roughly twice the value of
- RECURSE. */
-
-void
-val_print (struct type *type, LONGEST embedded_offset,
- CORE_ADDR address, struct ui_file *stream, int recurse,
- struct value *val,
- const struct value_print_options *options,
- const struct language_defn *language)
-{
- do_val_print (nullptr, type, embedded_offset, address, stream,
- recurse, val, options, language);
-}
-
/* See valprint.h. */
bool
{
if (options->max_depth > -1 && recurse >= options->max_depth)
{
- gdb_assert (language->la_struct_too_deep_ellipsis != NULL);
- fputs_filtered (language->la_struct_too_deep_ellipsis, stream);
+ gdb_assert (language->struct_too_deep_ellipsis () != NULL);
+ fputs_filtered (language->struct_too_deep_ellipsis (), stream);
return true;
}
return 0;
}
- if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
+ if (value_type (val)->code () == TYPE_CODE_INTERNAL_FUNCTION)
{
fprintf_styled (stream, metadata_style.style (),
_("<internal function %s>"),
return 1;
}
-/* Print using the given LANGUAGE the value VAL onto stream STREAM according
- to OPTIONS.
-
- This is a preferable interface to val_print, above, because it uses
- GDB's value mechanism. */
-
-void
-common_val_print (struct value *val, struct ui_file *stream, int recurse,
- const struct value_print_options *options,
- const struct language_defn *language)
-{
- if (!value_check_printable (val, stream, options))
- return;
-
- 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);
-
- if (value_lazy (val))
- value_fetch_lazy (val);
-
- do_val_print (val, value_type (val),
- value_embedded_offset (val), value_address (val),
- stream, recurse,
- val, options, language);
-}
-
/* See valprint.h. */
void
if (!options->raw)
{
int r
- = apply_ext_lang_val_pretty_printer (value_type (val),
- value_embedded_offset (val),
- value_address (val),
- stream, 0,
- val, options, current_language);
+ = apply_ext_lang_val_pretty_printer (val, stream, 0, options,
+ current_language);
if (r)
return;
}
- LA_VALUE_PRINT (val, stream, options);
+ current_language->value_print (val, stream, options);
}
static void
-val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
- struct ui_file *stream)
+val_print_type_code_flags (struct type *type, struct value *original_value,
+ int embedded_offset, struct ui_file *stream)
{
+ const gdb_byte *valaddr = (value_contents_for_printing (original_value).data ()
+ + embedded_offset);
ULONGEST val = unpack_long (type, valaddr);
- int field, nfields = TYPE_NFIELDS (type);
- struct gdbarch *gdbarch = get_type_arch (type);
+ int field, nfields = type->num_fields ();
+ struct gdbarch *gdbarch = type->arch ();
struct type *bool_type = builtin_type (gdbarch)->builtin_bool;
fputs_filtered ("[", stream);
for (field = 0; field < nfields; field++)
{
- if (TYPE_FIELD_NAME (type, field)[0] != '\0')
+ if (type->field (field).name ()[0] != '\0')
{
- struct type *field_type = TYPE_FIELD_TYPE (type, field);
+ struct type *field_type = type->field (field).type ();
if (field_type == bool_type
/* We require boolean types here to be one bit wide. This is a
int. */
&& TYPE_FIELD_BITSIZE (type, field) == 1)
{
- if (val & ((ULONGEST)1 << TYPE_FIELD_BITPOS (type, field)))
+ if (val & ((ULONGEST)1 << type->field (field).loc_bitpos ()))
fprintf_filtered
(stream, " %ps",
styled_string (variable_name_style.style (),
- TYPE_FIELD_NAME (type, field)));
+ type->field (field).name ()));
}
else
{
unsigned field_len = TYPE_FIELD_BITSIZE (type, field);
- ULONGEST field_val
- = val >> (TYPE_FIELD_BITPOS (type, field) - field_len + 1);
+ ULONGEST field_val = val >> type->field (field).loc_bitpos ();
if (field_len < sizeof (ULONGEST) * TARGET_CHAR_BIT)
field_val &= ((ULONGEST) 1 << field_len) - 1;
fprintf_filtered (stream, " %ps=",
styled_string (variable_name_style.style (),
- TYPE_FIELD_NAME (type, field)));
- if (TYPE_CODE (field_type) == TYPE_CODE_ENUM)
+ type->field (field).name ()));
+ if (field_type->code () == TYPE_CODE_ENUM)
generic_val_print_enum_1 (field_type, field_val, stream);
else
print_longest (stream, 'd', 0, field_val);
fputs_filtered (" ]", stream);
}
-/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
- according to OPTIONS and SIZE on STREAM. Format i is not supported
- at this level.
-
- This is how the elements of an array or structure are printed
- with a format. */
-
-void
-val_print_scalar_formatted (struct type *type,
- LONGEST embedded_offset,
- 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);
-
- /* If we get here with a string format, try again without it. Go
- all the way back to the language printers, which may call us
- again. */
- if (options->format == 's')
- {
- struct value_print_options opts = *options;
- opts.format = 0;
- opts.deref_ref = 0;
- val_print (type, embedded_offset, 0, stream, 0, val, &opts,
- current_language);
- return;
- }
-
- /* value_contents_for_printing fetches all VAL's contents. They are
- needed to check whether VAL is optimized-out or unavailable
- below. */
- const gdb_byte *valaddr = value_contents_for_printing (val);
-
- /* A scalar object that does not have all bits available can't be
- printed, because all bits contribute to its representation. */
- if (value_bits_any_optimized_out (val,
- TARGET_CHAR_BIT * embedded_offset,
- TARGET_CHAR_BIT * TYPE_LENGTH (type)))
- val_print_optimized_out (val, stream);
- else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
- val_print_unavailable (stream);
- else
- print_scalar_formatted (valaddr + embedded_offset * unit_size, type,
- options, size, stream);
-}
-
/* See valprint.h. */
void
/* value_contents_for_printing fetches all VAL's contents. They are
needed to check whether VAL is optimized-out or unavailable
below. */
- const gdb_byte *valaddr = value_contents_for_printing (val);
+ const gdb_byte *valaddr = value_contents_for_printing (val).data ();
/* A scalar object that does not have all bits available can't be
printed, because all bits contribute to its representation. */
/* Take low nibble and bump our pointer "p". */
digits[0] += LOW_NIBBLE (*p);
- if (byte_order == BFD_ENDIAN_BIG)
+ if (byte_order == BFD_ENDIAN_BIG)
p++;
else
p--;
}
}
-/* 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, struct type *type,
- const gdb_byte *valaddr,
- unsigned len, enum bfd_endian byte_order)
-{
- const gdb_byte *p;
-
- if (byte_order == BFD_ENDIAN_BIG)
- {
- p = valaddr;
- while (p < valaddr + len - 1 && *p == 0)
- ++p;
-
- while (p < valaddr + len)
- {
- LA_EMIT_CHAR (*p, type, stream, '\'');
- ++p;
- }
- }
- else
- {
- p = valaddr + len - 1;
- while (p > valaddr && *p == 0)
- --p;
-
- while (p >= valaddr)
- {
- LA_EMIT_CHAR (*p, type, stream, '\'');
- --p;
- }
- }
-}
-
/* Print function pointer with inferior address ADDRESS onto stdio
stream STREAM. */
CORE_ADDR address,
struct ui_file *stream)
{
- CORE_ADDR func_addr
- = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
- current_top_target ());
+ CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr
+ (gdbarch, address, current_inferior ()->top_target ());
/* If the function pointer is represented by a description, print
the address of the description. */
void
maybe_print_array_index (struct type *index_type, LONGEST index,
- struct ui_file *stream,
+ struct ui_file *stream,
const struct value_print_options *options)
{
- struct value *index_value;
-
if (!options->print_array_indexes)
return;
-
- index_value = value_from_longest (index_type, index);
- LA_PRINT_ARRAY_INDEX (index_value, stream, options);
-}
-
-/* Called by various <lang>_val_print routines to print elements of an
- array in the form "<elem1>, <elem2>, <elem3>, ...".
-
- (FIXME?) Assumes array element separator is a comma, which is correct
- for all languages currently handled.
- (FIXME?) Some languages have a notation for repeated array elements,
- perhaps we should try to use that notation when appropriate. */
-
-void
-val_print_array_elements (struct type *type,
- LONGEST embedded_offset,
- CORE_ADDR address, struct ui_file *stream,
- int recurse,
- struct value *val,
- const struct value_print_options *options,
- unsigned int i)
-{
- unsigned int things_printed = 0;
- unsigned len;
- struct type *elttype, *index_type, *base_index_type;
- unsigned eltlen;
- /* Position of the array element we are examining to see
- whether it is repeated. */
- unsigned int rep1;
- /* Number of repetitions we have detected so far. */
- unsigned int reps;
- LONGEST low_bound, high_bound;
- LONGEST low_pos, high_pos;
-
- elttype = TYPE_TARGET_TYPE (type);
- eltlen = type_length_units (check_typedef (elttype));
- index_type = TYPE_INDEX_TYPE (type);
-
- if (get_array_bounds (type, &low_bound, &high_bound))
- {
- if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
- base_index_type = TYPE_TARGET_TYPE (index_type);
- else
- base_index_type = index_type;
-
- /* Non-contiguous enumerations types can by used as index types
- in some languages (e.g. Ada). In this case, the array length
- shall be computed from the positions of the first and last
- literal in the enumeration type, and not from the values
- of these literals. */
- if (!discrete_position (base_index_type, low_bound, &low_pos)
- || !discrete_position (base_index_type, high_bound, &high_pos))
- {
- warning (_("unable to get positions in array, use bounds instead"));
- low_pos = low_bound;
- high_pos = high_bound;
- }
-
- /* The array length should normally be HIGH_POS - LOW_POS + 1.
- But we have to be a little extra careful, because some languages
- such as Ada allow LOW_POS to be greater than HIGH_POS for
- empty arrays. In that situation, the array length is just zero,
- not negative! */
- if (low_pos > high_pos)
- len = 0;
- else
- len = high_pos - low_pos + 1;
- }
- else
- {
- warning (_("unable to get bounds of array, assuming null array"));
- low_bound = 0;
- len = 0;
- }
-
- annotate_array_section_begin (i, elttype);
-
- for (; i < len && things_printed < options->print_max; i++)
- {
- if (i != 0)
- {
- if (options->prettyformat_arrays)
- {
- fprintf_filtered (stream, ",\n");
- print_spaces_filtered (2 + 2 * recurse, stream);
- }
- else
- {
- fprintf_filtered (stream, ", ");
- }
- }
- wrap_here (n_spaces (2 + 2 * recurse));
- maybe_print_array_index (index_type, i + low_bound,
- stream, options);
-
- rep1 = i + 1;
- reps = 1;
- /* Only check for reps if repeat_count_threshold is not set to
- UINT_MAX (unlimited). */
- if (options->repeat_count_threshold < UINT_MAX)
- {
- while (rep1 < len
- && value_contents_eq (val,
- embedded_offset + i * eltlen,
- val,
- (embedded_offset
- + rep1 * eltlen),
- eltlen))
- {
- ++reps;
- ++rep1;
- }
- }
-
- if (reps > options->repeat_count_threshold)
- {
- val_print (elttype, embedded_offset + i * eltlen,
- address, stream, recurse + 1, val, options,
- current_language);
- annotate_elt_rep (reps);
- fprintf_filtered (stream, " %p[<repeats %u times>%p]",
- metadata_style.style ().ptr (), reps, nullptr);
- annotate_elt_rep_end ();
-
- i = rep1 - 1;
- things_printed += options->repeat_count_threshold;
- }
- else
- {
- val_print (elttype, embedded_offset + i * eltlen,
- address,
- stream, recurse + 1, val, options, current_language);
- annotate_elt ();
- things_printed++;
- }
- }
- annotate_array_section_end ();
- if (i < len)
- {
- fprintf_filtered (stream, "...");
- }
+ current_language->print_array_index (index_type, index, stream, options);
}
/* See valprint.h. */
{
unsigned int things_printed = 0;
unsigned len;
- struct type *elttype, *index_type, *base_index_type;
+ struct type *elttype, *index_type;
unsigned eltlen;
/* Position of the array element we are examining to see
whether it is repeated. */
/* Number of repetitions we have detected so far. */
unsigned int reps;
LONGEST low_bound, high_bound;
- LONGEST low_pos, high_pos;
struct type *type = check_typedef (value_type (val));
elttype = TYPE_TARGET_TYPE (type);
eltlen = type_length_units (check_typedef (elttype));
- index_type = TYPE_INDEX_TYPE (type);
+ index_type = type->index_type ();
+ if (index_type->code () == TYPE_CODE_RANGE)
+ index_type = TYPE_TARGET_TYPE (index_type);
if (get_array_bounds (type, &low_bound, &high_bound))
{
- if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
- base_index_type = TYPE_TARGET_TYPE (index_type);
- else
- base_index_type = index_type;
-
- /* Non-contiguous enumerations types can by used as index types
- in some languages (e.g. Ada). In this case, the array length
- shall be computed from the positions of the first and last
- literal in the enumeration type, and not from the values
- of these literals. */
- if (!discrete_position (base_index_type, low_bound, &low_pos)
- || !discrete_position (base_index_type, high_bound, &high_pos))
- {
- warning (_("unable to get positions in array, use bounds instead"));
- low_pos = low_bound;
- high_pos = high_bound;
- }
-
- /* The array length should normally be HIGH_POS - LOW_POS + 1.
- But we have to be a little extra careful, because some languages
- such as Ada allow LOW_POS to be greater than HIGH_POS for
- empty arrays. In that situation, the array length is just zero,
- not negative! */
- if (low_pos > high_pos)
+ /* 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
- len = high_pos - low_pos + 1;
+ len = high_bound - low_bound + 1;
}
else
{
else
fprintf_filtered (stream, ", ");
}
- wrap_here (n_spaces (2 + 2 * recurse));
+ else if (options->prettyformat_arrays)
+ {
+ fprintf_filtered (stream, "\n");
+ print_spaces_filtered (2 + 2 * recurse, stream);
+ }
+ stream->wrap_here (2 + 2 * recurse);
maybe_print_array_index (index_type, i + low_bound,
- stream, options);
+ stream, options);
rep1 = i + 1;
reps = 1;
annotate_array_section_end ();
if (i < len)
fprintf_filtered (stream, "...");
+ if (options->prettyformat_arrays)
+ {
+ fprintf_filtered (stream, "\n");
+ print_spaces_filtered (2 * recurse, stream);
+ }
}
/* Read LEN bytes of target memory at address MEMADDR, placing the
Unless an exception is thrown, BUFFER will always be allocated, even on
failure. In this case, some characters might have been read before the
- failure happened. Check BYTES_READ to recognize this situation.
-
- Note: There was a FIXME asking to make this code use target_read_string,
- but this function is more general (can read past null characters, up to
- given LEN). Besides, it is used much more often than target_read_string
- so it is more tested. Perhaps callers of target_read_string should use
- this function instead? */
+ failure happened. Check BYTES_READ to recognize this situation. */
int
read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
unsigned int fetchlimit; /* Maximum number of chars to print. */
int bytes_read;
gdb::unique_xmalloc_ptr<gdb_byte> buffer; /* Dynamically growable fetch buffer. */
- struct gdbarch *gdbarch = get_type_arch (elttype);
+ struct gdbarch *gdbarch = elttype->arch ();
enum bfd_endian byte_order = type_byte_order (elttype);
int width = TYPE_LENGTH (elttype);
gdb_byte *peekbuf;
/* We didn't find a NUL terminator we were looking for. Attempt
- to peek at the next character. If not successful, or it is not
- a null byte, then force ellipsis to be printed. */
+ to peek at the next character. If not successful, or it is not
+ a null byte, then force ellipsis to be printed. */
peekbuf = (gdb_byte *) alloca (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
- print ellipsis. */
+ than the number of characters actually requested, always make us
+ print ellipsis. */
force_ellipsis = 1;
}
But if we fetch something and then get an error, print the string
and then the error message. */
if (err == 0 || bytes_read > 0)
- {
- LA_PRINT_STRING (stream, elttype, buffer.get (), bytes_read / width,
- encoding, force_ellipsis, options);
- }
+ current_language->printstr (stream, elttype, buffer.get (),
+ bytes_read / width,
+ encoding, force_ellipsis, options);
if (err != 0)
{
}
\f
-static void
-set_print (const char *arg, int from_tty)
-{
- printf_unfiltered (
- "\"set print\" must be followed by the name of a print subcommand.\n");
- help_list (setprintlist, "set print ", all_commands, gdb_stdout);
-}
-
-static void
-show_print (const char *args, int from_tty)
-{
- cmd_show_list (showprintlist, from_tty, "");
-}
-
-static void
-set_print_raw (const char *arg, int from_tty)
-{
- printf_unfiltered (
- "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n");
- help_list (setprintrawlist, "set print raw ", all_commands, gdb_stdout);
-}
-
-static void
-show_print_raw (const char *args, int from_tty)
-{
- cmd_show_list (showprintrawlist, from_tty, "");
-}
-
/* Controls printing of vtbl's. */
static void
show_vtblprint (struct ui_file *file, int from_tty,
Use \"unlimited\" to print the complete structure.")
},
+ boolean_option_def {
+ "memory-tag-violations",
+ [] (value_print_options *opt) { return &opt->memory_tag_violations; },
+ show_memory_tag_violations, /* show_cmd_cb */
+ N_("Set printing of memory tag violations for pointers."),
+ N_("Show printing of memory tag violations for pointers."),
+ N_("Issue a warning when the printed value is a pointer\n\
+whose logical tag doesn't match the allocation tag of the memory\n\
+location it points to."),
+ },
+
boolean_option_def {
"null-stop",
[] (value_print_options *opt) { return &opt->stop_print_at_null; },
return {{value_print_option_defs}, opts};
}
+#if GDB_SELF_TEST
+
+/* Test printing of TYPE_CODE_FLAGS values. */
+
+static void
+test_print_flags (gdbarch *arch)
+{
+ type *flags_type = arch_flags_type (arch, "test_type", 32);
+ type *field_type = builtin_type (arch)->builtin_uint32;
+
+ /* Value: 1010 1010
+ Fields: CCCB BAAA */
+ append_flags_type_field (flags_type, 0, 3, field_type, "A");
+ append_flags_type_field (flags_type, 3, 2, field_type, "B");
+ append_flags_type_field (flags_type, 5, 3, field_type, "C");
+
+ value *val = allocate_value (flags_type);
+ gdb_byte *contents = value_contents_writeable (val).data ();
+ store_unsigned_integer (contents, 4, gdbarch_byte_order (arch), 0xaa);
+
+ string_file out;
+ val_print_type_code_flags (flags_type, val, 0, &out);
+ SELF_CHECK (out.string () == "[ A=2 B=1 C=5 ]");
+}
+
+#endif
+
void _initialize_valprint ();
void
_initialize_valprint ()
{
- cmd_list_element *cmd;
-
- add_prefix_cmd ("print", no_class, set_print,
- _("Generic command for setting how things print."),
- &setprintlist, "set print ", 0, &setlist);
- add_alias_cmd ("p", "print", no_class, 1, &setlist);
+#if GDB_SELF_TEST
+ selftests::register_test_foreach_arch ("print-flags", test_print_flags);
+#endif
+
+ set_show_commands setshow_print_cmds
+ = add_setshow_prefix_cmd ("print", no_class,
+ _("Generic command for setting how things print."),
+ _("Generic command for showing print settings."),
+ &setprintlist, &showprintlist,
+ &setlist, &showlist);
+ add_alias_cmd ("p", setshow_print_cmds.set, no_class, 1, &setlist);
/* Prefer set print to set prompt. */
- add_alias_cmd ("pr", "print", no_class, 1, &setlist);
-
- add_prefix_cmd ("print", no_class, show_print,
- _("Generic command for showing print settings."),
- &showprintlist, "show print ", 0, &showlist);
- add_alias_cmd ("p", "print", no_class, 1, &showlist);
- add_alias_cmd ("pr", "print", no_class, 1, &showlist);
-
- cmd = add_prefix_cmd ("raw", no_class, set_print_raw,
- _("\
-Generic command for setting what things to print in \"raw\" mode."),
- &setprintrawlist, "set print raw ", 0,
- &setprintlist);
- deprecate_cmd (cmd, nullptr);
-
- cmd = add_prefix_cmd ("raw", no_class, show_print_raw,
- _("Generic command for showing \"print raw\" settings."),
- &showprintrawlist, "show print raw ", 0,
- &showprintlist);
- deprecate_cmd (cmd, nullptr);
+ add_alias_cmd ("pr", setshow_print_cmds.set, no_class, 1, &setlist);
+ add_alias_cmd ("p", setshow_print_cmds.show, no_class, 1, &showlist);
+ add_alias_cmd ("pr", setshow_print_cmds.show, no_class, 1, &showlist);
+
+ set_show_commands setshow_print_raw_cmds
+ = add_setshow_prefix_cmd
+ ("raw", no_class,
+ _("Generic command for setting what things to print in \"raw\" mode."),
+ _("Generic command for showing \"print raw\" settings."),
+ &setprintrawlist, &showprintrawlist, &setprintlist, &showprintlist);
+ deprecate_cmd (setshow_print_raw_cmds.set, nullptr);
+ deprecate_cmd (setshow_print_raw_cmds.show, nullptr);
gdb::option::add_setshow_cmds_for_options
(class_support, &user_print_options, value_print_option_defs,
projects / binutils-gdb.git / blobdiff