X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fvalprint.c;h=471146769342a8874e57ca76ad318940c934b397;hb=c76d61da4a65eaadca861bf6c77d579a5cc3f422;hp=4383915de73443b1287e04c4b57a91c04d44d1bf;hpb=ce3acbe9fa876647649cc88f94264a5c56bf46a1;p=binutils-gdb.git diff --git a/gdb/valprint.c b/gdb/valprint.c index 4383915de73..47114676934 100644 --- a/gdb/valprint.c +++ b/gdb/valprint.c @@ -1,6 +1,6 @@ /* 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. @@ -30,7 +30,7 @@ #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 @@ -40,6 +40,11 @@ #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 @@ -80,15 +85,13 @@ struct cmd_list_element *showprintrawlist; /* 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); 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. */ @@ -107,6 +110,7 @@ struct value_print_options user_print_options = 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 */ @@ -149,10 +153,10 @@ 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, + _("Limit on string chars or array " + "elements to print is %s.\n"), + value); } @@ -163,9 +167,9 @@ static void 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; @@ -173,9 +177,9 @@ static void 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 @@ -183,9 +187,9 @@ show_output_radix (struct ui_file *file, int from_tty, 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 @@ -196,8 +200,19 @@ static void 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. */ @@ -206,10 +221,10 @@ static void 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. */ @@ -218,7 +233,7 @@ static void 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. */ @@ -227,7 +242,7 @@ static void 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 @@ -237,9 +252,9 @@ static void 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); } /* If nonzero, causes machine addresses to be printed in certain contexts. */ @@ -248,16 +263,16 @@ static void 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); } @@ -275,7 +290,7 @@ val_print_scalar_type_p (struct type *type) type = TYPE_TARGET_TYPE (type); type = check_typedef (type); } - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_ARRAY: case TYPE_CODE_STRUCT: @@ -297,10 +312,10 @@ val_print_scalar_or_string_type_p (struct type *type, 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, @@ -322,9 +337,9 @@ 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, @@ -337,7 +352,7 @@ valprint_check_validity (struct ui_file *stream, 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) @@ -405,9 +420,9 @@ print_unpacked_pointer (struct type *type, struct type *elttype, 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); @@ -417,20 +432,19 @@ print_unpacked_pointer (struct type *type, struct type *elttype, 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. */ 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); @@ -441,82 +455,55 @@ generic_val_print_array (struct type *type, 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); - fputs_filtered (decorations->array_end, stream); + gdb_puts (decorations->array_start, stream); + value_print_array_elements (val, stream, recurse, options, 0); + gdb_puts (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); + print_unpacked_pointer (type, elttype, value_address (val), + stream, options); } } -/* generic_val_print helper for TYPE_CODE_PTR. */ +/* generic_value_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) +generic_value_print_ptr (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); if (options->format && options->format != 's') - { - val_print_scalar_formatted (type, embedded_offset, - original_value, options, 0, stream); - } + value_print_scalar_formatted (val, options, 0, stream); 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); + 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).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) { 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. */ } @@ -530,7 +517,7 @@ get_value_addr_contents (struct value *deref_val) gdb_assert (deref_val != NULL); if (value_lval_const (deref_val) == lval_memory) - return value_contents_for_printing_const (value_addr (deref_val)); + 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. */ @@ -554,8 +541,8 @@ generic_val_print_ref (struct type *type, 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) { @@ -591,7 +578,7 @@ generic_val_print_ref (struct type *type, print_ref_address (type, address, embedded_offset, stream); if (options->deref_ref) - fputs_filtered (": ", stream); + gdb_puts (": ", stream); } if (options->deref_ref) @@ -600,7 +587,7 @@ generic_val_print_ref (struct type *type, common_val_print (deref_val, stream, recurse, options, current_language); else - fputs_filtered ("???", stream); + gdb_puts ("???", stream); } } @@ -614,21 +601,21 @@ generic_val_print_enum_1 (struct type *type, LONGEST val, 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; @@ -640,7 +627,7 @@ generic_val_print_enum_1 (struct type *type, LONGEST val, { 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); @@ -649,14 +636,14 @@ generic_val_print_enum_1 (struct type *type, LONGEST val, { 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); } } @@ -665,24 +652,24 @@ generic_val_print_enum_1 (struct type *type, LONGEST val, { /* 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 @@ -698,42 +685,16 @@ generic_val_print_enum (struct type *type, 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. */ - -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) + const gdb_byte *valaddr = value_contents_for_printing (original_value).data (); -{ - 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. */ @@ -745,322 +706,316 @@ generic_val_print_func (struct type *type, 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. */ + gdb_printf (stream, "{"); + type_print (type, "", stream, -1); + gdb_printf (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); + 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); } } -/* 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)) - fprintf_filtered (stream, "%u", (unsigned int) val); + LONGEST val = unpack_long (type, valaddr); + 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); } } /* 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); + + const gdb_byte *valaddr = value_contents_for_printing (original_value).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) - { - val_print_scalar_formatted (type, embedded_offset, - original_value, options, 0, stream); - } + value_print_scalar_formatted (val, options, 0, stream); else { - const gdb_byte *valaddr = value_contents_for_printing (original_value); + struct type *type = value_type (val); + + const gdb_byte *valaddr = value_contents_for_printing (val).data (); + gdb_mpf f; - print_floating (valaddr + embedded_offset * unit_size, type, stream); + f.read_fixed_point (gdb::make_array_view (valaddr, TYPE_LENGTH (type)), + type_byte_order (type), type->is_unsigned (), + type->fixed_point_scaling_factor ()); + + const char *fmt = TYPE_LENGTH (type) < 4 ? "%.11Fg" : "%.17Fg"; + std::string str = gmp_string_printf (fmt, f.val); + gdb_printf (stream, "%s", str.c_str ()); } } -/* generic_val_print helper for TYPE_CODE_COMPLEX. */ +/* generic_value_print helper for TYPE_CODE_COMPLEX. */ 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_value_print_complex (struct value *val, struct ui_file *stream, + const struct value_print_options *options, + const struct generic_val_print_decorations + *decorations) { - 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); + gdb_printf (stream, "%s", decorations->complex_prefix); - 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); + struct value *real_part = value_real_part (val); + value_print_scalar_formatted (real_part, options, 0, stream); + gdb_printf (stream, "%s", decorations->complex_infix); + + struct value *imag_part = value_imaginary_part (val); + value_print_scalar_formatted (imag_part, options, 0, stream); + 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 (value_type (val)); + const gdb_byte *valaddr = value_contents_for_printing (val).data (); + cp_print_class_member (valaddr, type, 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); + generic_value_print (val, stream, recurse, options, decorations); } -/* 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. */ +/* See valprint.h. */ 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) +generic_value_print (struct value *val, struct ui_file *stream, int recurse, + const struct value_print_options *options, + const struct generic_val_print_decorations *decorations) { - struct type *unresolved_type = type; + struct type *type = value_type (val); type = check_typedef (type); - switch (TYPE_CODE (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 (type)); + val = value_cast (type, val); + } + + switch (type->code ()) { case TYPE_CODE_ARRAY: - generic_val_print_array (type, embedded_offset, address, stream, - recurse, original_value, options, decorations); + generic_val_print_array (val, stream, recurse, options, decorations); break; case TYPE_CODE_MEMBERPTR: - generic_val_print_memberptr (type, embedded_offset, stream, - original_value, options); + generic_value_print_memberptr (val, stream, recurse, options, + decorations); break; case TYPE_CODE_PTR: - generic_val_print_ptr (type, embedded_offset, stream, - original_value, options); + generic_value_print_ptr (val, stream, options); break; case TYPE_CODE_REF: case TYPE_CODE_RVALUE_REF: - generic_val_print_ref (type, embedded_offset, stream, recurse, - original_value, options); + generic_val_print_ref (type, 0, stream, recurse, + val, options); break; case TYPE_CODE_ENUM: - generic_val_print_enum (type, embedded_offset, stream, - original_value, 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, embedded_offset, stream, - original_value, 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, embedded_offset, address, stream, - original_value, 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, embedded_offset, stream, - original_value, 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, embedded_offset, stream, - original_value, options); + generic_value_print_int (val, stream, options); break; case TYPE_CODE_CHAR: - generic_val_print_char (type, unresolved_type, embedded_offset, - stream, original_value, options); + generic_value_print_char (val, stream, options); break; case TYPE_CODE_FLT: case TYPE_CODE_DECFLOAT: - generic_val_print_float (type, embedded_offset, stream, - original_value, 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: - 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 (), _("")); break; case TYPE_CODE_COMPLEX: - generic_val_print_complex (type, embedded_offset, stream, - original_value, 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 ()); } } -/* 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?". +/* Print using the given LANGUAGE the value VAL onto stream STREAM according + to OPTIONS. - RECURSE indicates the amount of indentation to supply before - continuation lines; this amount is roughly twice the value of - RECURSE. */ + This is a preferable interface to val_print, above, because it uses + GDB's value mechanism. */ 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) +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)) + value_fetch_lazy (value); + 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) @@ -1073,21 +1028,19 @@ val_print (struct type *type, LONGEST embedded_offset, 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 (), _("")); 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; } @@ -1095,7 +1048,7 @@ val_print (struct type *type, LONGEST embedded_offset, otherwise, print an ellipsis. */ if (options->summary && !val_print_scalar_type_p (type)) { - fprintf_filtered (stream, "..."); + gdb_printf (stream, "..."); return; } @@ -1106,14 +1059,12 @@ val_print (struct type *type, LONGEST embedded_offset, try { - 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 (), - _("")); + _(""), except.what ()); } } @@ -1126,8 +1077,8 @@ val_print_check_max_depth (struct ui_file *stream, int recurse, { 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; } @@ -1152,7 +1103,7 @@ value_check_printable (struct value *val, struct ui_file *stream, if (value_entirely_optimized_out (val)) { if (options->summary && !val_print_scalar_type_p (value_type (val))) - fprintf_filtered (stream, "..."); + gdb_printf (stream, "..."); else val_print_optimized_out (val, stream); return 0; @@ -1161,13 +1112,13 @@ value_check_printable (struct value *val, struct ui_file *stream, if (value_entirely_unavailable (val)) { if (options->summary && !val_print_scalar_type_p (value_type (val))) - fprintf_filtered (stream, "..."); + gdb_printf (stream, "..."); else val_print_unavailable (stream); 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 (), _(""), @@ -1190,34 +1141,17 @@ value_check_printable (struct value *val, struct ui_file *stream, 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. */ +/* See valprint.h. */ void -common_val_print (struct value *val, struct ui_file *stream, int recurse, - const struct value_print_options *options, - const struct language_defn *language) +common_val_print_checked (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); - - val_print (value_type (val), - value_embedded_offset (val), value_address (val), - stream, recurse, - val, options, language); + common_val_print (val, stream, recurse, options, language); } /* Print on stream STREAM the value VAL according to OPTIONS. The value @@ -1235,34 +1169,33 @@ value_print (struct value *val, struct ui_file *stream, 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); + 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 @@ -1271,50 +1204,41 @@ val_print_type_code_flags (struct type *type, const gdb_byte *valaddr, 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))); - if (TYPE_CODE (field_type) == TYPE_CODE_ENUM) + 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 print_longest (stream, 'd', 0, field_val); } } } - fputs_filtered (" ]", stream); + gdb_puts (" ]", 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. */ +/* See valprint.h. */ 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) +value_print_scalar_formatted (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); + struct type *type = check_typedef (value_type (val)); gdb_assert (val != NULL); @@ -1326,27 +1250,24 @@ val_print_scalar_formatted (struct type *type, 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); + 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 = 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. */ - if (value_bits_any_optimized_out (val, - TARGET_CHAR_BIT * embedded_offset, + if (value_bits_any_optimized_out (val, 0, TARGET_CHAR_BIT * TYPE_LENGTH (type))) val_print_optimized_out (val, stream); - else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type))) + else if (!value_bytes_available (val, 0, TYPE_LENGTH (type))) val_print_unavailable (stream); else - print_scalar_formatted (valaddr + embedded_offset * unit_size, type, - options, size, stream); + print_scalar_formatted (valaddr, type, options, size, stream); } /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g. @@ -1397,7 +1318,7 @@ print_longest (struct ui_file *stream, int format, int use_c_format, internal_error (__FILE__, __LINE__, _("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 @@ -1431,7 +1352,7 @@ print_floating (const gdb_byte *valaddr, struct type *type, 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 @@ -1465,7 +1386,7 @@ print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr, b = '0'; if (zero_pad || seen_a_one || b == '1') - fputc_filtered (b, stream); + gdb_putc (b, stream); if (b == '1') seen_a_one = true; } @@ -1485,7 +1406,7 @@ print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr, b = '0'; if (zero_pad || seen_a_one || b == '1') - fputc_filtered (b, stream); + gdb_putc (b, stream); if (b == '1') seen_a_one = true; } @@ -1495,7 +1416,7 @@ print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr, /* 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, @@ -1505,7 +1426,7 @@ static void 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; } @@ -1560,7 +1481,7 @@ print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr, 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) { @@ -1737,7 +1658,7 @@ print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr, if (is_signed && maybe_negate_by_bytes (valaddr, len, byte_order, &negated_bytes)) { - fputs_filtered ("-", stream); + gdb_puts ("-", stream); valaddr = negated_bytes.data (); } @@ -1793,7 +1714,7 @@ print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr, /* 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--; @@ -1844,7 +1765,7 @@ print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr, for (; i >= 0; i--) { - fprintf_filtered (stream, "%1d", digits[i]); + gdb_printf (stream, "%1d", digits[i]); } } @@ -1857,7 +1778,7 @@ print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr, { const gdb_byte *p; - fputs_filtered ("0x", stream); + gdb_puts ("0x", stream); if (byte_order == BFD_ENDIAN_BIG) { p = valaddr; @@ -1878,9 +1799,9 @@ print_hex_chars (struct ui_file *stream, const gdb_byte *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 @@ -1903,46 +1824,9 @@ print_hex_chars (struct ui_file *stream, const gdb_byte *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); - } - } -} - -/* 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); } } } @@ -1956,17 +1840,16 @@ print_function_pointer_address (const struct value_print_options *options, 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); } @@ -1977,39 +1860,26 @@ print_function_pointer_address (const struct value_print_options *options, 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); + current_language->print_array_index (index_type, index, stream, options); } -/* Called by various _val_print routines to print elements of an - array in the form ", , , ...". - - (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. */ +/* See valprint.h. */ 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) +value_print_array_elements (struct value *val, struct ui_file *stream, + int recurse, + const struct value_print_options *options, + unsigned int i) { 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. */ @@ -2017,41 +1887,26 @@ val_print_array_elements (struct type *type, /* 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 { @@ -2064,21 +1919,26 @@ val_print_array_elements (struct type *type, for (; i < len && things_printed < options->print_max; i++) { + scoped_value_mark free_values; + if (i != 0) { 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, ", "); } - wrap_here (n_spaces (2 + 2 * recurse)); + else if (options->prettyformat_arrays) + { + gdb_printf (stream, "\n"); + print_spaces (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; @@ -2087,11 +1947,8 @@ val_print_array_elements (struct type *type, if (options->repeat_count_threshold < UINT_MAX) { while (rep1 < len - && value_contents_eq (val, - embedded_offset + i * eltlen, - val, - (embedded_offset - + rep1 * eltlen), + && value_contents_eq (val, i * eltlen, + val, rep1 * eltlen, eltlen)) { ++reps; @@ -2099,14 +1956,15 @@ val_print_array_elements (struct type *type, } } + 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) { - val_print (elttype, embedded_offset + i * eltlen, - address, stream, recurse + 1, val, options, - current_language); annotate_elt_rep (reps); - fprintf_filtered (stream, " %p[%p]", - metadata_style.style ().ptr (), reps, nullptr); + gdb_printf (stream, " %p[%p]", + metadata_style.style ().ptr (), reps, nullptr); annotate_elt_rep_end (); i = rep1 - 1; @@ -2114,192 +1972,18 @@ val_print_array_elements (struct type *type, } 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) + gdb_printf (stream, "..."); + if (options->prettyformat_arrays) { - fprintf_filtered (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; - } - 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 *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 */ + gdb_printf (stream, "\n"); + print_spaces (2 * recurse, stream); } - 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 @@ -2498,7 +2182,7 @@ generic_emit_char (int c, struct type *type, struct ui_file *stream, 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, @@ -2784,7 +2468,7 @@ generic_printstr (struct ui_file *stream, struct type *type, if (length == 0) { - fputs_filtered ("\"\"", stream); + gdb_puts ("\"\"", stream); return; } @@ -2841,7 +2525,7 @@ generic_printstr (struct ui_file *stream, struct type *type, 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 @@ -2864,7 +2548,7 @@ val_print_string (struct type *elttype, const char *encoding, unsigned int fetchlimit; /* Maximum number of chars to print. */ int bytes_read; gdb::unique_xmalloc_ptr 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); @@ -2879,8 +2563,8 @@ val_print_string (struct type *elttype, const char *encoding, fetchlimit = (len == -1 ? options->print_max : std::min ((unsigned) len, options->print_max)); - 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; @@ -2898,8 +2582,8 @@ val_print_string (struct type *elttype, const char *encoding, 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); @@ -2910,8 +2594,8 @@ val_print_string (struct type *elttype, const char *encoding, 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; } @@ -2919,18 +2603,17 @@ val_print_string (struct type *elttype, const char *encoding, 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, _(""), - styled_string (metadata_style.style (), - str.c_str ())); + gdb_printf (stream, _(""), + styled_string (metadata_style.style (), + str.c_str ())); } return (bytes_read / width); @@ -2942,7 +2625,7 @@ static void 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); } @@ -2981,9 +2664,9 @@ set_input_radix_1 (int from_tty, unsigned radix) 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); } } @@ -3024,9 +2707,9 @@ set_output_radix_1 (int from_tty, unsigned 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); } } @@ -3048,9 +2731,9 @@ set_radix (const char *arg, int from_tty) 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); } } @@ -3063,59 +2746,31 @@ show_radix (const char *arg, int from_tty) { 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); } } } -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, 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 @@ -3125,9 +2780,9 @@ show_objectprint (struct ui_file *file, int from_tty, 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 @@ -3135,9 +2790,9 @@ show_static_field_print (struct ui_file *file, int from_tty, 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); } @@ -3202,6 +2857,17 @@ will be replaced with either '{...}' or '(...)' depending on the language.\n\ 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; }, @@ -3293,37 +2959,61 @@ make_value_print_options_def_group (value_print_options *opts) 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,