/* Print values for GDB, the GNU debugger.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2023 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
/* Prototypes for local functions */
-static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
- int len, int *errptr);
-
static void set_input_radix_1 (int, unsigned);
static void set_output_radix_1 (int, unsigned);
int embedded_offset,
struct ui_file *stream);
-#define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
-#define PRINT_MAX_DEPTH_DEFAULT 20 /* Start print_max_depth off at this value. */
+/* Start print_max at this value. */
+#define PRINT_MAX_DEFAULT 200
+
+/* Start print_max_chars at this value (meaning follow print_max). */
+#define PRINT_MAX_CHARS_DEFAULT PRINT_MAX_CHARS_ELEMENTS
+
+/* Start print_max_depth at this value. */
+#define PRINT_MAX_DEPTH_DEFAULT 20
struct value_print_options user_print_options =
{
Val_prettyformat_default, /* prettyformat */
- 0, /* prettyformat_arrays */
- 0, /* prettyformat_structs */
- 0, /* vtblprint */
- 1, /* unionprint */
- 1, /* addressprint */
- 0, /* objectprint */
+ false, /* prettyformat_arrays */
+ false, /* prettyformat_structs */
+ false, /* vtblprint */
+ true, /* unionprint */
+ true, /* addressprint */
+ false, /* nibblesprint */
+ false, /* objectprint */
PRINT_MAX_DEFAULT, /* print_max */
+ PRINT_MAX_CHARS_DEFAULT, /* print_max_chars */
10, /* repeat_count_threshold */
0, /* output_format */
0, /* format */
- 0, /* stop_print_at_null */
- 0, /* print_array_indexes */
- 0, /* deref_ref */
- 1, /* static_field_print */
- 1, /* pascal_static_field_print */
- 0, /* raw */
- 0, /* summary */
- 1, /* symbol_print */
+ true, /* memory_tag_violations */
+ false, /* stop_print_at_null */
+ false, /* print_array_indexes */
+ false, /* deref_ref */
+ true, /* static_field_print */
+ true, /* pascal_static_field_print */
+ false, /* raw */
+ false, /* summary */
+ true, /* symbol_print */
PRINT_MAX_DEPTH_DEFAULT, /* max_depth */
- 1 /* finish_print */
};
/* Initialize *OPTS to be a copy of the user print options. */
opts->format = format;
}
+/* Implement 'show print elements'. */
+
static void
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"),
- value);
+ gdb_printf
+ (file,
+ (user_print_options.print_max_chars != PRINT_MAX_CHARS_ELEMENTS
+ ? _("Limit on array elements to print is %s.\n")
+ : _("Limit on string chars or array elements to print is %s.\n")),
+ value);
}
+/* Implement 'show print characters'. */
+
+static void
+show_print_max_chars (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ gdb_printf (file,
+ _("Limit on string characters to print is %s.\n"),
+ value);
+}
/* Default input and output radixes, and output format letter. */
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"),
- value);
+ gdb_printf (file,
+ _("Default input radix for entering numbers is %s.\n"),
+ value);
}
unsigned output_radix = 10;
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"),
- value);
+ gdb_printf (file,
+ _("Default output radix for printing of values is %s.\n"),
+ value);
}
/* By default we print arrays without printing the index of each element in
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);
+ gdb_printf (file, _("Printing of array indexes is %s.\n"), value);
}
/* Print repeat counts if there are more than this many repetitions of an
show_repeat_count_threshold (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
- value);
+ gdb_printf (file, _("Threshold for repeated print elements is %s.\n"),
+ 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)
+{
+ gdb_printf (file,
+ _("Printing of memory tag violations is %s.\n"),
+ value);
}
/* If nonzero, stops printing of char arrays at first null. */
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"),
- value);
+ gdb_printf (file,
+ _("Printing of char arrays to stop "
+ "at first null char is %s.\n"),
+ value);
}
/* Controls pretty printing of structures. */
show_prettyformat_structs (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Pretty formatting of structures is %s.\n"), value);
+ gdb_printf (file, _("Pretty formatting of structures is %s.\n"), value);
}
/* Controls pretty printing of arrays. */
show_prettyformat_arrays (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Pretty formatting of arrays is %s.\n"), value);
+ gdb_printf (file, _("Pretty formatting of arrays is %s.\n"), value);
}
/* If nonzero, causes unions inside structures or other unions to be
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"),
- value);
+ gdb_printf (file,
+ _("Printing of unions interior to structures is %s.\n"),
+ value);
+}
+
+/* Controls the format of printing binary values. */
+
+static void
+show_nibbles (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ gdb_printf (file,
+ _("Printing binary values in groups is %s.\n"),
+ value);
}
/* If nonzero, causes machine addresses to be printed in certain contexts. */
show_addressprint (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
+ gdb_printf (file, _("Printing of addresses is %s.\n"), value);
}
static void
show_symbol_print (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file,
- _("Printing of symbols when printing pointers is %s.\n"),
- value);
+ gdb_printf (file,
+ _("Printing of symbols when printing pointers is %s.\n"),
+ value);
}
\f
type = check_typedef (type);
while (TYPE_IS_REFERENCE (type))
{
- type = TYPE_TARGET_TYPE (type);
+ type = type->target_type ();
type = check_typedef (type);
}
switch (type->code ())
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,
&& type->code () != TYPE_CODE_STRUCT
&& type->code () != TYPE_CODE_ARRAY)
{
- if (value_bits_any_optimized_out (val,
- TARGET_CHAR_BIT * embedded_offset,
- TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+ if (val->bits_any_optimized_out (TARGET_CHAR_BIT * embedded_offset,
+ TARGET_CHAR_BIT * type->length ()))
{
val_print_optimized_out (val, stream);
return 0;
}
- if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * embedded_offset,
- TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+ if (val->bits_synthetic_pointer (TARGET_CHAR_BIT * embedded_offset,
+ TARGET_CHAR_BIT * type->length ()))
{
const int is_ref = type->code () == TYPE_CODE_REF;
int ref_is_addressable = 0;
const struct value *deref_val = coerce_ref_if_computed (val);
if (deref_val != NULL)
- ref_is_addressable = value_lval_const (deref_val) == lval_memory;
+ ref_is_addressable = deref_val->lval () == lval_memory;
}
if (!is_ref || !ref_is_addressable)
return is_ref;
}
- if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
+ if (!val->bytes_available (embedded_offset, type->length ()))
{
val_print_unavailable (stream);
return 0;
void
val_print_optimized_out (const struct value *val, struct ui_file *stream)
{
- if (val != NULL && value_lval_const (val) == lval_register)
+ if (val != NULL && val->lval () == lval_register)
val_print_not_saved (stream);
else
fprintf_styled (stream, metadata_style.style (), _("<optimized out>"));
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 (elttype->code () == TYPE_CODE_FUNC)
{
if (options->symbol_print)
print_address_demangle (options, gdbarch, address, stream, demangle);
else if (options->addressprint)
- fputs_filtered (paddress (gdbarch, address), stream);
+ gdb_puts (paddress (gdbarch, address), stream);
}
/* generic_val_print helper for TYPE_CODE_ARRAY. */
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 *type = check_typedef (val->type ());
+ struct type *unresolved_elttype = type->target_type ();
struct type *elttype = check_typedef (unresolved_elttype);
- if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
+ if (type->length () > 0 && unresolved_elttype->length () > 0)
{
LONGEST low_bound, high_bound;
if (!get_array_bounds (type, &low_bound, &high_bound))
error (_("Could not determine the array high bound"));
- fputs_filtered (decorations->array_start, stream);
+ gdb_puts (decorations->array_start, stream);
value_print_array_elements (val, stream, recurse, options, 0);
- fputs_filtered (decorations->array_end, stream);
+ gdb_puts (decorations->array_end, stream);
}
else
{
/* Array of unspecified length: treat like pointer to first elt. */
- print_unpacked_pointer (type, elttype, value_address (val),
+ print_unpacked_pointer (type, elttype, val->address (),
stream, options);
}
value_print_scalar_formatted (val, options, 0, stream);
else
{
- 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);
+ struct type *type = check_typedef (val->type ());
+ struct type *elttype = check_typedef (type->target_type ());
+ const gdb_byte *valaddr = val->contents_for_printing ().data ();
CORE_ADDR addr = unpack_pointer (type, valaddr);
print_unpacked_pointer (type, elttype, addr, stream, options);
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)
{
CORE_ADDR address
= extract_typed_address (address_buffer + embedded_offset, type);
- fprintf_filtered (stream, "@");
- fputs_filtered (paddress (gdbarch, address), stream);
+ gdb_printf (stream, "@");
+ gdb_puts (paddress (gdbarch, address), stream);
}
/* Else: we have a non-addressable value, such as a DW_AT_const_value. */
}
{
gdb_assert (deref_val != NULL);
- if (value_lval_const (deref_val) == lval_memory)
- return value_contents_for_printing_const (value_addr (deref_val));
+ if (deref_val->lval () == lval_memory)
+ return value_addr (deref_val)->contents_for_printing ().data ();
else
{
/* We have a non-addressable value, such as a DW_AT_const_value. */
struct value *original_value,
const struct value_print_options *options)
{
- struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+ struct type *elttype = check_typedef (type->target_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 bool value_is_synthetic
+ = original_value->bits_synthetic_pointer (TARGET_CHAR_BIT * embedded_offset,
+ TARGET_CHAR_BIT * type->length ());
const int must_coerce_ref = ((options->addressprint && value_is_synthetic)
|| options->deref_ref);
const int type_is_defined = elttype->code () != TYPE_CODE_UNDEF;
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ const gdb_byte *valaddr = original_value->contents_for_printing ().data ();
if (must_coerce_ref && type_is_defined)
{
gdb_assert (embedded_offset == 0);
}
else
- deref_val = value_at (TYPE_TARGET_TYPE (type),
+ deref_val = value_at (type->target_type (),
unpack_pointer (type, valaddr + embedded_offset));
}
/* Else, original_value isn't a synthetic reference or we don't have to print
print_ref_address (type, address, embedded_offset, stream);
if (options->deref_ref)
- fputs_filtered (": ", stream);
+ gdb_puts (": ", stream);
}
if (options->deref_ref)
common_val_print (deref_val, stream, recurse, options,
current_language);
else
- fputs_filtered ("???", stream);
+ gdb_puts ("???", stream);
}
}
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);
{
if (first)
{
- fputs_filtered ("(", stream);
+ gdb_puts ("(", stream);
first = 0;
}
else
- fputs_filtered (" | ", stream);
+ gdb_puts (" | ", 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);
}
}
{
/* There are leftover bits, print them. */
if (first)
- fputs_filtered ("(", stream);
+ gdb_puts ("(", stream);
else
- fputs_filtered (" | ", stream);
+ gdb_puts (" | ", stream);
- fputs_filtered ("unknown: 0x", stream);
+ gdb_puts ("unknown: 0x", stream);
print_longest (stream, 'x', 0, val);
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
}
else if (first)
{
/* Nothing has been printed and the value is 0, the enum value must
have been 0. */
- fputs_filtered ("0", stream);
+ gdb_puts ("0", stream);
}
else
{
/* Something has been printed, close the parenthesis. */
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
}
}
else
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);
gdb_assert (!options->format);
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ const gdb_byte *valaddr = original_value->contents_for_printing ().data ();
val = unpack_long (type, valaddr + embedded_offset * unit_size);
struct value *original_value,
const struct value_print_options *options)
{
- struct gdbarch *gdbarch = get_type_arch (type);
+ struct gdbarch *gdbarch = type->arch ();
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, "{");
+ gdb_printf (stream, "{");
type_print (type, "", stream, -1);
- fprintf_filtered (stream, "} ");
+ gdb_printf (stream, "} ");
/* Try to print what function it points to, and its address. */
print_address_demangle (options, gdbarch, address, stream, demangle);
}
}
else
{
- const gdb_byte *valaddr = value_contents_for_printing (value);
- struct type *type = check_typedef (value_type (value));
+ const gdb_byte *valaddr = value->contents_for_printing ().data ();
+ struct type *type = check_typedef (value->type ());
LONGEST val = unpack_long (type, valaddr);
if (val == 0)
- fputs_filtered (decorations->false_name, stream);
+ gdb_puts (decorations->false_name, stream);
else if (val == 1)
- fputs_filtered (decorations->true_name, stream);
+ gdb_puts (decorations->true_name, stream);
else
print_longest (stream, 'd', 0, val);
}
}
else
{
- struct type *unresolved_type = value_type (value);
+ struct type *unresolved_type = value->type ();
struct type *type = check_typedef (unresolved_type);
- const gdb_byte *valaddr = value_contents_for_printing (value);
+ const gdb_byte *valaddr = value->contents_for_printing ().data ();
LONGEST val = unpack_long (type, valaddr);
- if (TYPE_UNSIGNED (type))
- fprintf_filtered (stream, "%u", (unsigned int) val);
+ if (type->is_unsigned ())
+ gdb_printf (stream, "%u", (unsigned int) val);
else
- fprintf_filtered (stream, "%d", (int) val);
- fputs_filtered (" ", stream);
- LA_PRINT_CHAR (val, unresolved_type, stream);
+ gdb_printf (stream, "%d", (int) val);
+ gdb_puts (" ", stream);
+ current_language->printchar (val, unresolved_type, stream);
}
}
{
gdb_assert (!options->format);
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ const gdb_byte *valaddr = original_value->contents_for_printing ().data ();
print_floating (valaddr, type, stream);
}
+/* generic_val_print helper for TYPE_CODE_FIXED_POINT. */
+
+static void
+generic_val_print_fixed_point (struct value *val, struct ui_file *stream,
+ const struct value_print_options *options)
+{
+ if (options->format)
+ value_print_scalar_formatted (val, options, 0, stream);
+ else
+ {
+ struct type *type = val->type ();
+
+ const gdb_byte *valaddr = val->contents_for_printing ().data ();
+ gdb_mpf f;
+
+ f.read_fixed_point (gdb::make_array_view (valaddr, type->length ()),
+ type_byte_order (type), type->is_unsigned (),
+ type->fixed_point_scaling_factor ());
+
+ const char *fmt = type->length () < 4 ? "%.11Fg" : "%.17Fg";
+ std::string str = f.str (fmt);
+ gdb_printf (stream, "%s", str.c_str ());
+ }
+}
+
/* generic_value_print helper for TYPE_CODE_COMPLEX. */
static void
const struct generic_val_print_decorations
*decorations)
{
- fprintf_filtered (stream, "%s", decorations->complex_prefix);
+ gdb_printf (stream, "%s", decorations->complex_prefix);
struct value *real_part = value_real_part (val);
value_print_scalar_formatted (real_part, options, 0, stream);
- fprintf_filtered (stream, "%s", decorations->complex_infix);
+ gdb_printf (stream, "%s", decorations->complex_infix);
struct value *imag_part = value_imaginary_part (val);
value_print_scalar_formatted (imag_part, options, 0, stream);
- fprintf_filtered (stream, "%s", decorations->complex_suffix);
+ gdb_printf (stream, "%s", decorations->complex_suffix);
+}
+
+/* generic_value_print helper for TYPE_CODE_MEMBERPTR. */
+
+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 (val->type ());
+ const gdb_byte *valaddr = val->contents_for_printing ().data ();
+ cp_print_class_member (valaddr, type, stream, "&");
+ }
+ else
+ value_print_scalar_formatted (val, options, 0, stream);
}
/* See valprint.h. */
const struct value_print_options *options,
const struct generic_val_print_decorations *decorations)
{
- struct type *type = value_type (val);
+ struct type *type = val->type ();
type = check_typedef (type);
+
+ if (is_fixed_point_type (type))
+ type = type->fixed_point_type_base_type ();
+
+ /* Widen a subrange to its target type, then use that type's
+ printer. */
+ while (type->code () == TYPE_CODE_RANGE)
+ {
+ type = check_typedef (type->target_type ());
+ val = value_cast (type, val);
+ }
+
switch (type->code ())
{
case TYPE_CODE_ARRAY:
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:
if (options->format)
value_print_scalar_formatted (val, options, 0, stream);
else
- generic_val_print_func (type, 0, value_address (val), stream,
+ generic_val_print_func (type, 0, val->address (), stream,
val, options);
break;
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_value_print_int (val, stream, options);
break;
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:
- fputs_filtered (decorations->void_name, stream);
+ gdb_puts (decorations->void_name, stream);
break;
case TYPE_CODE_ERROR:
- fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
+ gdb_printf (stream, "%s", TYPE_ERROR_NAME (type));
break;
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;
generic_value_print_complex (val, stream, options, decorations);
break;
+ case TYPE_CODE_METHODPTR:
+ cplus_print_method_ptr (val->contents_for_printing ().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 ());
}
}
-/* 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.
-static void
-do_val_print (struct value *value, struct ui_file *stream, int recurse,
- const struct value_print_options *options,
- const struct language_defn *language)
+ 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)
{
- int ret = 0;
+ 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->fetch_lazy ();
+
struct value_print_options local_opts = *options;
- struct type *type = value_type (value);
+ struct type *type = value->type ();
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 (!options->raw)
{
- ret = apply_ext_lang_val_pretty_printer (value, stream, recurse, options,
- language);
- if (ret)
+ if (apply_ext_lang_val_pretty_printer (value, stream, recurse, options,
+ language))
return;
}
otherwise, print an ellipsis. */
if (options->summary && !val_print_scalar_type_p (type))
{
- fprintf_filtered (stream, "...");
+ gdb_printf (stream, "...");
return;
}
try
{
- language->la_value_print_inner (value, stream, recurse, &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 ());
}
}
{
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);
+ gdb_puts (language->struct_too_deep_ellipsis (), stream);
return true;
}
return 0;
}
- if (value_entirely_optimized_out (val))
+ if (val->entirely_optimized_out ())
{
- if (options->summary && !val_print_scalar_type_p (value_type (val)))
- fprintf_filtered (stream, "...");
+ if (options->summary && !val_print_scalar_type_p (val->type ()))
+ gdb_printf (stream, "...");
else
val_print_optimized_out (val, stream);
return 0;
}
- if (value_entirely_unavailable (val))
+ if (val->entirely_unavailable ())
{
- if (options->summary && !val_print_scalar_type_p (value_type (val)))
- fprintf_filtered (stream, "...");
+ if (options->summary && !val_print_scalar_type_p (val->type ()))
+ gdb_printf (stream, "...");
else
val_print_unavailable (stream);
return 0;
}
- if (value_type (val)->code () == TYPE_CODE_INTERNAL_FUNCTION)
+ if (val->type ()->code () == TYPE_CODE_INTERNAL_FUNCTION)
{
fprintf_styled (stream, metadata_style.style (),
_("<internal function %s>"),
return 0;
}
- if (type_not_associated (value_type (val)))
+ if (type_not_associated (val->type ()))
{
val_print_not_associated (stream);
return 0;
}
- if (type_not_allocated (value_type (val)))
+ if (type_not_allocated (val->type ()))
{
val_print_not_allocated (stream);
return 0;
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 (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, stream, recurse, options, language);
-}
-
/* See valprint.h. */
void
return;
}
- LA_VALUE_PRINT (val, stream, options);
+ current_language->value_print (val, stream, options);
+}
+
+/* Meant to be used in debug sessions, so don't export it in a header file. */
+extern void ATTRIBUTE_UNUSED debug_val (struct value *val);
+
+/* Print VAL. */
+
+void ATTRIBUTE_UNUSED
+debug_val (struct value *val)
+{
+ value_print (val, gdb_stdlog, &user_print_options);
+ gdb_flush (gdb_stdlog);
}
static void
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)
+ const gdb_byte *valaddr = (original_value->contents_for_printing ().data ()
+ embedded_offset);
ULONGEST val = unpack_long (type, valaddr);
int field, nfields = type->num_fields ();
- struct gdbarch *gdbarch = get_type_arch (type);
+ struct gdbarch *gdbarch = type->arch ();
struct type *bool_type = builtin_type (gdbarch)->builtin_bool;
- fputs_filtered ("[", stream);
+ gdb_puts ("[", 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)))
- fprintf_filtered
+ if (val & ((ULONGEST)1 << type->field (field).loc_bitpos ()))
+ gdb_printf
(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)));
+ gdb_printf (stream, " %ps=",
+ styled_string (variable_name_style.style (),
+ type->field (field).name ()));
if (field_type->code () == TYPE_CODE_ENUM)
generic_val_print_enum_1 (field_type, field_val, stream);
else
}
}
}
- fputs_filtered (" ]", stream);
+ gdb_puts (" ]", stream);
}
/* See valprint.h. */
int size,
struct ui_file *stream)
{
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
gdb_assert (val != NULL);
{
struct value_print_options opts = *options;
opts.format = 0;
- opts.deref_ref = 0;
+ opts.deref_ref = false;
common_val_print (val, stream, 0, &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);
+ const gdb_byte *valaddr = val->contents_for_printing ().data ();
/* 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, 0,
- TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+ if (val->bits_any_optimized_out (0,
+ TARGET_CHAR_BIT * type->length ()))
val_print_optimized_out (val, stream);
- else if (!value_bytes_available (val, 0, TYPE_LENGTH (type)))
+ else if (!val->bytes_available (0, type->length ()))
val_print_unavailable (stream);
else
print_scalar_formatted (valaddr, type, options, size, stream);
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 (_("failed internal consistency check"));
}
- fputs_filtered (val, stream);
+ gdb_puts (val, stream);
}
/* This used to be a macro, but I don't think it is called often enough
struct ui_file *stream)
{
std::string str = target_float_to_string (valaddr, type);
- fputs_filtered (str.c_str (), stream);
+ gdb_puts (str.c_str (), stream);
}
void
print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
- unsigned len, enum bfd_endian byte_order, bool zero_pad)
+ unsigned len, enum bfd_endian byte_order, bool zero_pad,
+ const struct value_print_options *options)
{
const gdb_byte *p;
unsigned int i;
int b;
bool seen_a_one = false;
+ const char *digit_separator = nullptr;
/* Declared "int" so it will be signed.
This ensures that right shift will shift in zeros. */
const int mask = 0x080;
+ if (options->nibblesprint)
+ digit_separator = current_language->get_digit_separator();
+
if (byte_order == BFD_ENDIAN_BIG)
{
for (p = valaddr;
for (i = 0; i < (HOST_CHAR_BIT * sizeof (*p)); i++)
{
+ if (options->nibblesprint && seen_a_one && i % 4 == 0)
+ gdb_putc (*digit_separator, stream);
+
if (*p & (mask >> i))
b = '1';
else
b = '0';
if (zero_pad || seen_a_one || b == '1')
- fputc_filtered (b, stream);
+ gdb_putc (b, stream);
+ else if (options->nibblesprint)
+ {
+ if ((0xf0 & (mask >> i) && (*p & 0xf0))
+ || (0x0f & (mask >> i) && (*p & 0x0f)))
+ gdb_putc (b, stream);
+ }
+
if (b == '1')
seen_a_one = true;
}
{
for (i = 0; i < (HOST_CHAR_BIT * sizeof (*p)); i++)
{
+ if (options->nibblesprint && seen_a_one && i % 4 == 0)
+ gdb_putc (*digit_separator, stream);
+
if (*p & (mask >> i))
b = '1';
else
b = '0';
if (zero_pad || seen_a_one || b == '1')
- fputc_filtered (b, stream);
+ gdb_putc (b, stream);
+ else if (options->nibblesprint)
+ {
+ if ((0xf0 & (mask >> i) && (*p & 0xf0))
+ || (0x0f & (mask >> i) && (*p & 0x0f)))
+ gdb_putc (b, stream);
+ }
+
if (b == '1')
seen_a_one = true;
}
/* When not zero-padding, ensure that something is printed when the
input is 0. */
if (!zero_pad && !seen_a_one)
- fputc_filtered ('0', stream);
+ gdb_putc ('0', stream);
}
/* A helper for print_octal_chars that emits a single octal digit,
emit_octal_digit (struct ui_file *stream, bool *seen_a_one, int digit)
{
if (*seen_a_one || digit != 0)
- fprintf_filtered (stream, "%o", digit);
+ gdb_printf (stream, "%o", digit);
if (digit != 0)
*seen_a_one = true;
}
cycle = (len * HOST_CHAR_BIT) % BITS_IN_OCTAL;
carry = 0;
- fputs_filtered ("0", stream);
+ gdb_puts ("0", stream);
bool seen_a_one = false;
if (byte_order == BFD_ENDIAN_BIG)
{
if (is_signed
&& maybe_negate_by_bytes (valaddr, len, byte_order, &negated_bytes))
{
- fputs_filtered ("-", stream);
+ gdb_puts ("-", stream);
valaddr = negated_bytes.data ();
}
/* 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--;
for (; i >= 0; i--)
{
- fprintf_filtered (stream, "%1d", digits[i]);
+ gdb_printf (stream, "%1d", digits[i]);
}
}
{
const gdb_byte *p;
- fputs_filtered ("0x", stream);
+ gdb_puts ("0x", stream);
if (byte_order == BFD_ENDIAN_BIG)
{
p = valaddr;
/* When not zero-padding, use a different format for the
very first byte printed. */
if (!zero_pad && p == first)
- fprintf_filtered (stream, "%x", *p);
+ gdb_printf (stream, "%x", *p);
else
- fprintf_filtered (stream, "%02x", *p);
+ gdb_printf (stream, "%02x", *p);
}
}
else
/* When not zero-padding, use a different format for the
very first byte printed. */
if (!zero_pad && p == first)
- fprintf_filtered (stream, "%x", *p);
+ gdb_printf (stream, "%x", *p);
else
- fprintf_filtered (stream, "%02x", *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;
+ gdb_printf (stream, "%02x", *p);
}
}
}
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. */
if (options->addressprint && func_addr != address)
{
- fputs_filtered ("@", stream);
- fputs_filtered (paddress (gdbarch, address), stream);
- fputs_filtered (": ", stream);
+ gdb_puts ("@", stream);
+ gdb_puts (paddress (gdbarch, address), stream);
+ gdb_puts (": ", stream);
}
print_address_demangle (options, gdbarch, func_addr, stream, demangle);
}
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)
{
if (!options->print_array_indexes)
return;
-
- LA_PRINT_ARRAY_INDEX (index_type, index, stream, options);
+
+ 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;
- unsigned eltlen;
/* Position of the array element we are examining to see
whether it is repeated. */
unsigned int rep1;
unsigned int reps;
LONGEST low_bound, high_bound;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
- elttype = TYPE_TARGET_TYPE (type);
- eltlen = type_length_units (check_typedef (elttype));
- index_type = TYPE_INDEX_TYPE (type);
+ elttype = type->target_type ();
+ unsigned bit_stride = type->bit_stride ();
+ if (bit_stride == 0)
+ bit_stride = 8 * check_typedef (elttype)->length ();
+ index_type = type->index_type ();
if (index_type->code () == TYPE_CODE_RANGE)
- index_type = TYPE_TARGET_TYPE (index_type);
+ index_type = index_type->target_type ();
if (get_array_bounds (type, &low_bound, &high_bound))
{
/* 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! */
+ 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
{
if (options->prettyformat_arrays)
{
- fprintf_filtered (stream, ",\n");
- print_spaces_filtered (2 + 2 * recurse, stream);
+ gdb_printf (stream, ",\n");
+ print_spaces (2 + 2 * recurse, stream);
}
else
- fprintf_filtered (stream, ", ");
+ gdb_printf (stream, ", ");
}
else if (options->prettyformat_arrays)
{
- fprintf_filtered (stream, "\n");
- print_spaces_filtered (2 + 2 * recurse, stream);
+ gdb_printf (stream, "\n");
+ print_spaces (2 + 2 * recurse, stream);
}
- wrap_here (n_spaces (2 + 2 * recurse));
+ stream->wrap_here (2 + 2 * recurse);
maybe_print_array_index (index_type, i + low_bound,
- stream, options);
+ stream, options);
+ struct value *element = val->from_component_bitsize (elttype,
+ bit_stride * i,
+ bit_stride);
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, i * eltlen,
- val, rep1 * eltlen,
- eltlen))
+ bool unavailable = element->entirely_unavailable ();
+ bool available = element->entirely_available ();
+
+ while (rep1 < len)
{
+ struct value *rep_elt
+ = val->from_component_bitsize (elttype,
+ rep1 * bit_stride,
+ bit_stride);
+ bool repeated = ((available
+ && rep_elt->entirely_available ()
+ && element->contents_eq (rep_elt))
+ || (unavailable
+ && rep_elt->entirely_unavailable ()));
+ if (!repeated)
+ break;
++reps;
++rep1;
}
}
- struct value *element = value_from_component (val, elttype, eltlen * i);
common_val_print (element, stream, recurse + 1, options,
current_language);
if (reps > options->repeat_count_threshold)
{
annotate_elt_rep (reps);
- fprintf_filtered (stream, " %p[<repeats %u times>%p]",
- metadata_style.style ().ptr (), reps, nullptr);
+ gdb_printf (stream, " %p[<repeats %u times>%p]",
+ metadata_style.style ().ptr (), reps, nullptr);
annotate_elt_rep_end ();
i = rep1 - 1;
}
annotate_array_section_end ();
if (i < len)
- fprintf_filtered (stream, "...");
+ gdb_printf (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
- results in GDB's memory at MYADDR. Returns a count of the bytes
- actually read, and optionally a target_xfer_status value in the
- location pointed to by ERRPTR if ERRPTR is non-null. */
-
-/* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
- function be eliminated. */
-
-static int
-partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
- int len, int *errptr)
-{
- int nread; /* Number of bytes actually read. */
- int errcode; /* Error from last read. */
-
- /* First try a complete read. */
- errcode = target_read_memory (memaddr, myaddr, len);
- if (errcode == 0)
- {
- /* Got it all. */
- nread = len;
- }
- else
- {
- /* Loop, reading one byte at a time until we get as much as we can. */
- for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
- {
- errcode = target_read_memory (memaddr++, myaddr++, 1);
- }
- /* If an error, the last read was unsuccessful, so adjust count. */
- if (errcode != 0)
- {
- nread--;
- }
- }
- if (errptr != NULL)
- {
- *errptr = errcode;
+ gdb_printf (stream, "\n");
+ print_spaces (2 * recurse, stream);
}
- return (nread);
-}
-
-/* Read a string from the inferior, at ADDR, with LEN characters of
- WIDTH bytes each. Fetch at most FETCHLIMIT characters. BUFFER
- will be set to a newly allocated buffer containing the string, and
- BYTES_READ will be set to the number of bytes read. Returns 0 on
- success, or a target_xfer_status on failure.
-
- If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
- (including eventual NULs in the middle or end of the string).
-
- If LEN is -1, stops at the first null character (not necessarily
- the first null byte) up to a maximum of FETCHLIMIT characters. Set
- FETCHLIMIT to UINT_MAX to read as many characters as possible from
- the string.
-
- 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? */
-
-int
-read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
- enum bfd_endian byte_order, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
- int *bytes_read)
-{
- int errcode; /* Errno returned from bad reads. */
- unsigned int nfetch; /* Chars to fetch / chars fetched. */
- gdb_byte *bufptr; /* Pointer to next available byte in
- buffer. */
-
- /* Loop until we either have all the characters, or we encounter
- some error, such as bumping into the end of the address space. */
-
- buffer->reset (nullptr);
-
- if (len > 0)
- {
- /* We want fetchlimit chars, so we might as well read them all in
- one operation. */
- unsigned int fetchlen = std::min ((unsigned) len, fetchlimit);
-
- buffer->reset ((gdb_byte *) xmalloc (fetchlen * width));
- bufptr = buffer->get ();
-
- nfetch = partial_memory_read (addr, bufptr, fetchlen * width, &errcode)
- / width;
- addr += nfetch * width;
- bufptr += nfetch * width;
- }
- else if (len == -1)
- {
- unsigned long bufsize = 0;
- unsigned int chunksize; /* Size of each fetch, in chars. */
- int found_nul; /* Non-zero if we found the nul char. */
- gdb_byte *limit; /* First location past end of fetch buffer. */
-
- found_nul = 0;
- /* We are looking for a NUL terminator to end the fetching, so we
- might as well read in blocks that are large enough to be efficient,
- but not so large as to be slow if fetchlimit happens to be large.
- 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 = std::min (8u, fetchlimit);
-
- do
- {
- QUIT;
- nfetch = std::min ((unsigned long) chunksize, fetchlimit - bufsize);
-
- if (*buffer == NULL)
- buffer->reset ((gdb_byte *) xmalloc (nfetch * width));
- else
- buffer->reset ((gdb_byte *) xrealloc (buffer->release (),
- (nfetch + bufsize) * width));
-
- bufptr = buffer->get () + bufsize * width;
- bufsize += nfetch;
-
- /* Read as much as we can. */
- nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
- / width;
-
- /* Scan this chunk for the null character that terminates the string
- to print. If found, we don't need to fetch any more. Note
- that bufptr is explicitly left pointing at the next character
- after the null character, or at the next character after the end
- of the buffer. */
-
- limit = bufptr + nfetch * width;
- while (bufptr < limit)
- {
- unsigned long c;
-
- c = extract_unsigned_integer (bufptr, width, byte_order);
- addr += width;
- bufptr += width;
- if (c == 0)
- {
- /* We don't care about any error which happened after
- the NUL terminator. */
- errcode = 0;
- found_nul = 1;
- break;
- }
- }
- }
- while (errcode == 0 /* no error */
- && bufptr - buffer->get () < fetchlimit * width /* no overrun */
- && !found_nul); /* haven't found NUL yet */
- }
- else
- { /* Length of string is really 0! */
- /* We always allocate *buffer. */
- buffer->reset ((gdb_byte *) xmalloc (1));
- bufptr = buffer->get ();
- errcode = 0;
- }
-
- /* bufptr and addr now point immediately beyond the last byte which we
- consider part of the string (including a '\0' which ends the string). */
- *bytes_read = bufptr - buffer->get ();
-
- QUIT;
-
- return errcode;
}
/* Return true if print_wchar can display W without resorting to a
int orig_len, int width,
enum bfd_endian byte_order,
struct obstack *output,
- int quoter, int *need_escapep)
+ int quoter, bool *need_escapep)
{
- int need_escape = *need_escapep;
+ bool need_escape = *need_escapep;
- *need_escapep = 0;
+ *need_escapep = false;
- /* iswprint implementation on Windows returns 1 for tab character.
- In order to avoid different printout on this host, we explicitly
- use wchar_printable function. */
+ /* If any additional cases are added to this switch block, then the
+ function wchar_printable will likely need updating too. */
switch (w)
{
case LCST ('\a'):
break;
default:
{
- if (wchar_printable (w) && (!need_escape || (!gdb_iswdigit (w)
- && w != LCST ('8')
- && w != LCST ('9'))))
+ if (gdb_iswprint (w) && !(need_escape && gdb_iswxdigit (w)))
{
gdb_wchar_t wchar = w;
/* If the value fits in 3 octal digits, print it that
way. Otherwise, print it as a hex escape. */
if (value <= 0777)
- xsnprintf (octal, sizeof (octal), "\\%.3o",
- (int) (value & 0777));
+ {
+ xsnprintf (octal, sizeof (octal), "\\%.3o",
+ (int) (value & 0777));
+ *need_escapep = false;
+ }
else
- xsnprintf (octal, sizeof (octal), "\\x%lx", (long) value);
+ {
+ xsnprintf (octal, sizeof (octal), "\\x%lx", (long) value);
+ /* A hex escape might require the next character
+ to be escaped, because, unlike with octal,
+ hex escapes have no length limit. */
+ *need_escapep = true;
+ }
append_string_as_wide (octal, output);
}
/* If we somehow have extra bytes, print them now. */
char octal[5];
xsnprintf (octal, sizeof (octal), "\\%.3o", orig[i] & 0xff);
+ *need_escapep = false;
append_string_as_wide (octal, output);
++i;
}
-
- *need_escapep = 1;
}
break;
}
enum bfd_endian byte_order
= type_byte_order (type);
gdb_byte *c_buf;
- int need_escape = 0;
+ bool need_escape = false;
- c_buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
+ c_buf = (gdb_byte *) alloca (type->length ());
pack_long (c_buf, type, c);
- wchar_iterator iter (c_buf, TYPE_LENGTH (type), encoding, TYPE_LENGTH (type));
+ wchar_iterator iter (c_buf, type->length (), encoding, type->length ());
/* This holds the printable form of the wchar_t data. */
auto_obstack wchar_buf;
{
for (i = 0; i < num_chars; ++i)
print_wchar (chars[i], buf, buflen,
- TYPE_LENGTH (type), byte_order,
+ type->length (), byte_order,
&wchar_buf, quoter, &need_escape);
}
}
/* This handles the NUM_CHARS == 0 case as well. */
if (print_escape)
- print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type),
+ print_wchar (gdb_WEOF, buf, buflen, type->length (),
byte_order, &wchar_buf, quoter, &need_escape);
}
sizeof (gdb_wchar_t), &output, translit_char);
obstack_1grow (&output, '\0');
- fputs_filtered ((const char *) obstack_base (&output), stream);
+ gdb_puts ((const char *) obstack_base (&output), stream);
}
/* Return the repeat count of the next character/byte in ITER,
/* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
character to use with string output. WIDTH is the size of the output
character type. BYTE_ORDER is the target byte order. OPTIONS
- is the user's print options. */
+ is the user's print options. *FINISHED is set to 0 if we didn't print
+ all the elements in CHARS. */
static void
print_converted_chars_to_obstack (struct obstack *obstack,
const std::vector<converted_character> &chars,
int quote_char, int width,
enum bfd_endian byte_order,
- const struct value_print_options *options)
+ const struct value_print_options *options,
+ int *finished)
{
- unsigned int idx;
+ unsigned int idx, num_elements;
const converted_character *elem;
enum {START, SINGLE, REPEAT, INCOMPLETE, FINISH} state, last;
gdb_wchar_t wide_quote_char = gdb_btowc (quote_char);
- int need_escape = 0;
+ bool need_escape = false;
+ const int print_max = options->print_max_chars > 0
+ ? options->print_max_chars : options->print_max;
/* Set the start state. */
- idx = 0;
+ idx = num_elements = 0;
last = state = START;
elem = NULL;
obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
}
/* Output the character. */
- for (j = 0; j < elem->repeat_count; ++j)
+ int repeat_count = elem->repeat_count;
+ if (print_max < repeat_count + num_elements)
+ {
+ repeat_count = print_max - num_elements;
+ *finished = 0;
+ }
+ for (j = 0; j < repeat_count; ++j)
{
if (elem->result == wchar_iterate_ok)
print_wchar (elem->chars[0], elem->buf, elem->buflen, width,
else
print_wchar (gdb_WEOF, elem->buf, elem->buflen, width,
byte_order, obstack, quote_char, &need_escape);
+ num_elements += 1;
}
}
break;
obstack_grow_wstr (obstack, LCST ("'"));
std::string s = string_printf (_(" <repeats %u times>"),
elem->repeat_count);
+ num_elements += elem->repeat_count;
for (j = 0; s[j]; ++j)
{
gdb_wchar_t w = gdb_btowc (s[j]);
print_wchar (gdb_WEOF, elem->buf, elem->buflen, width, byte_order,
obstack, 0, &need_escape);
obstack_grow_wstr (obstack, LCST (">"));
+ num_elements += 1;
/* We do not attempt to output anything after this. */
state = FINISH;
/* Print the character string STRING, printing at most LENGTH
characters. LENGTH is -1 if the string is nul terminated. TYPE is
the type of each character. OPTIONS holds the printing options;
- printing stops early if the number hits print_max; repeat counts
- are printed as appropriate. Print ellipses at the end if we had to
- stop before printing LENGTH characters, or if FORCE_ELLIPSES.
+ printing stops early if the number hits print_max_chars; repeat
+ counts are printed as appropriate. Print ellipses at the end if we
+ had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
QUOTE_CHAR is the character to print at each end of the string. If
C_STYLE_TERMINATOR is true, and the last character is 0, then it is
omitted. */
{
enum bfd_endian byte_order = type_byte_order (type);
unsigned int i;
- int width = TYPE_LENGTH (type);
+ int width = type->length ();
int finished = 0;
struct converted_character *last;
if (length == 0)
{
- fputs_filtered ("\"\"", stream);
+ gdb_printf (stream, "%c%c", quote_char, quote_char);
return;
}
/* Convert characters until the string is over or the maximum
number of printed characters has been reached. */
i = 0;
- while (i < options->print_max)
+ unsigned int print_max_chars = get_print_max_chars (options);
+ while (i < print_max_chars)
{
int r;
/* Print the output string to the obstack. */
print_converted_chars_to_obstack (&wchar_buf, converted_chars, quote_char,
- width, byte_order, options);
+ width, byte_order, options, &finished);
if (force_ellipses || !finished)
obstack_grow_wstr (&wchar_buf, LCST ("..."));
sizeof (gdb_wchar_t), &output, translit_char);
obstack_1grow (&output, '\0');
- fputs_filtered ((const char *) obstack_base (&output), stream);
+ gdb_puts ((const char *) obstack_base (&output), stream);
}
/* Print a string from the inferior, starting at ADDR and printing up to LEN
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,
+ bytes) until either print_max_chars or LEN characters have been printed,
whichever is smaller. ENCODING is the name of the string's
encoding. It can be NULL, in which case the target encoding is
assumed. */
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);
+ int width = elttype->length ();
/* 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
- LEN >= zero, then the limit is the minimum of LEN and print_max. If
- LEN is -1, then the limit is print_max. This is true regardless of
- whether print_max is zero, UINT_MAX (unlimited), or something in between,
- because finding the null byte (or available memory) is what actually
- limits the fetch. */
+ going to attempt to fetch and print. This is actually pretty simple.
+ If LEN >= zero, then the limit is the minimum of LEN and print_max_chars.
+ If LEN is -1, then the limit is print_max_chars. This is true regardless
+ of whether print_max_chars is zero, UINT_MAX (unlimited), or something in
+ between, because finding the null byte (or available memory) is what
+ actually limits the fetch. */
- fetchlimit = (len == -1 ? options->print_max : std::min ((unsigned) len,
- options->print_max));
+ unsigned int print_max_chars = get_print_max_chars (options);
+ fetchlimit = (len == -1
+ ? print_max_chars
+ : std::min ((unsigned) len, print_max_chars));
- err = read_string (addr, len, width, fetchlimit, byte_order,
- &buffer, &bytes_read);
+ err = target_read_string (addr, len, width, fetchlimit,
+ &buffer, &bytes_read);
addr += bytes_read;
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)
{
std::string str = memory_error_message (TARGET_XFER_E_IO, gdbarch, addr);
- fprintf_filtered (stream, _("<error: %ps>"),
- styled_string (metadata_style.style (),
- str.c_str ()));
+ gdb_printf (stream, _("<error: %ps>"),
+ styled_string (metadata_style.style (),
+ str.c_str ()));
}
return (bytes_read / width);
show_print_max_depth (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Maximum print depth is %s.\n"), value);
+ gdb_printf (file, _("Maximum print depth is %s.\n"), value);
}
\f
input_radix_1 = input_radix = radix;
if (from_tty)
{
- printf_filtered (_("Input radix now set to "
- "decimal %u, hex %x, octal %o.\n"),
- radix, radix, radix);
+ gdb_printf (_("Input radix now set to "
+ "decimal %u, hex %x, octal %o.\n"),
+ radix, radix, radix);
}
}
output_radix_1 = output_radix = radix;
if (from_tty)
{
- printf_filtered (_("Output radix now set to "
- "decimal %u, hex %x, octal %o.\n"),
- radix, radix, radix);
+ gdb_printf (_("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"),
- radix, radix, radix);
+ gdb_printf (_("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"),
- input_radix, input_radix, input_radix);
+ gdb_printf (_("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"),
- input_radix, input_radix, input_radix);
- printf_filtered (_("Output radix set to decimal "
- "%u, hex %x, octal %o.\n"),
- output_radix, output_radix, output_radix);
+ gdb_printf (_("Input radix set to decimal "
+ "%u, hex %x, octal %o.\n"),
+ input_radix, input_radix, input_radix);
+ gdb_printf (_("Output radix set to decimal "
+ "%u, hex %x, octal %o.\n"),
+ output_radix, output_radix, output_radix);
}
}
}
show_vtblprint (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
+ gdb_printf (file, _("\
Printing of C++ virtual function tables is %s.\n"),
- value);
+ value);
}
/* Controls looking up an object's derived type using what we find in
struct cmd_list_element *c,
const char *value)
{
- fprintf_filtered (file, _("\
+ gdb_printf (file, _("\
Printing of object's derived type based on vtable info is %s.\n"),
- value);
+ value);
}
static void
struct cmd_list_element *c,
const char *value)
{
- fprintf_filtered (file,
- _("Printing of C++ static members is %s.\n"),
- value);
+ gdb_printf (file,
+ _("Printing of C++ static members is %s.\n"),
+ value);
}
\f
= gdb::option::boolean_option_def<value_print_options>;
using uinteger_option_def
= gdb::option::uinteger_option_def<value_print_options>;
-using zuinteger_unlimited_option_def
- = gdb::option::zuinteger_unlimited_option_def<value_print_options>;
+using pinteger_option_def
+ = gdb::option::pinteger_option_def<value_print_options>;
+
+/* Extra literals supported with the `set print characters' and
+ `print -characters' commands. */
+static const literal_def print_characters_literals[] =
+ {
+ { "elements", PRINT_MAX_CHARS_ELEMENTS },
+ { "unlimited", PRINT_MAX_CHARS_UNLIMITED, 0 },
+ { nullptr }
+ };
/* Definitions of options for the "print" and "compile print"
commands. */
NULL, /* help_doc */
},
+ boolean_option_def {
+ "nibbles",
+ [] (value_print_options *opt) { return &opt->nibblesprint; },
+ show_nibbles, /* show_cmd_cb */
+ N_("Set whether to print binary values in groups of four bits."),
+ N_("Show whether to print binary values in groups of four bits."),
+ NULL, /* help_doc */
+ },
+
+ uinteger_option_def {
+ "characters",
+ [] (value_print_options *opt) { return &opt->print_max_chars; },
+ print_characters_literals,
+ show_print_max_chars, /* show_cmd_cb */
+ N_("Set limit on string chars to print."),
+ N_("Show limit on string chars to print."),
+ N_("\"elements\" causes the array element limit to be used.\n"
+ "\"unlimited\" causes there to be no limit."),
+ },
+
uinteger_option_def {
"elements",
[] (value_print_options *opt) { return &opt->print_max; },
+ uinteger_unlimited_literals,
show_print_max, /* show_cmd_cb */
- N_("Set limit on string chars or array elements to print."),
- N_("Show limit on string chars or array elements to print."),
- N_("\"unlimited\" causes there to be no limit."),
+ N_("Set limit on array elements to print."),
+ N_("Show limit on array elements to print."),
+ N_("\"unlimited\" causes there to be no limit.\n"
+ "This setting also applies to string chars when \"print characters\"\n"
+ "is set to \"elements\"."),
},
- zuinteger_unlimited_option_def {
+ pinteger_option_def {
"max-depth",
[] (value_print_options *opt) { return &opt->max_depth; },
+ pinteger_unlimited_literals,
show_print_max_depth, /* show_cmd_cb */
N_("Set maximum print depth for nested structures, unions and arrays."),
N_("Show maximum print depth for nested structures, unions, and arrays."),
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; },
uinteger_option_def {
"repeats",
[] (value_print_options *opt) { return &opt->repeat_count_threshold; },
+ uinteger_unlimited_literals,
show_repeat_count_threshold, /* show_cmd_cb */
N_("Set threshold for repeated print elements."),
N_("Show threshold for repeated print elements."),
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 = value::allocate (flags_type);
+ gdb_byte *contents = val->contents_writeable ().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_basic_prefix_cmd ("print", no_class,
- _("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_show_prefix_cmd ("print", no_class,
- _("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_basic_prefix_cmd ("raw", no_class,
- _("\
-Generic command for setting what things to print in \"raw\" mode."),
- &setprintrawlist, "set print raw ", 0,
- &setprintlist);
- deprecate_cmd (cmd, nullptr);
-
- cmd = add_show_prefix_cmd ("raw", no_class,
- _("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,