X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fvalprint.c;h=d6ec64845f4be9bd3eb10664ac86cb623d5b3b42;hb=29ef4c0699e1b46d41ade00ae07a54f979ea21cc;hp=4bd643e938df5ecd8441ad40e9dd64f10fff1be1;hpb=7813437494ac39f3aef392d06ed5416e84fe386b;p=binutils-gdb.git diff --git a/gdb/valprint.c b/gdb/valprint.c index 4bd643e938d..d6ec64845f4 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 @@ -108,6 +113,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 */ @@ -184,7 +190,7 @@ 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); } @@ -201,6 +207,17 @@ show_repeat_count_threshold (struct ui_file *file, int from_tty, value); } +/* If nonzero, prints memory tag violations for pointers. */ + +static void +show_memory_tag_violations (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, + _("Printing of memory tag violations is %s.\n"), + value); +} + /* If nonzero, stops printing of char arrays at first null. */ static void @@ -298,10 +315,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, @@ -406,7 +423,7 @@ 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 (elttype->code () == TYPE_CODE_FUNC) { @@ -467,7 +484,7 @@ generic_value_print_ptr (struct value *val, struct ui_file *stream, { struct type *type = check_typedef (value_type (val)); struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type)); - const gdb_byte *valaddr = value_contents_for_printing (val); + const gdb_byte *valaddr = value_contents_for_printing (val).data (); CORE_ADDR addr = unpack_pointer (type, valaddr); print_unpacked_pointer (type, elttype, addr, stream, options); @@ -481,7 +498,7 @@ 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) { @@ -503,7 +520,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. */ @@ -528,7 +545,7 @@ generic_val_print_ref (struct type *type, 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 = value_contents_for_printing (original_value).data (); if (must_coerce_ref && type_is_defined) { @@ -587,21 +604,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; @@ -613,7 +630,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); @@ -628,8 +645,8 @@ generic_val_print_enum_1 (struct type *type, LONGEST val, else fputs_filtered (" | ", stream); - val &= ~TYPE_FIELD_ENUMVAL (type, i); - fputs_styled (TYPE_FIELD_NAME (type, i), + val &= ~type->field (i).loc_enumval (); + fputs_styled (type->field (i).name (), variable_name_style.style (), stream); } } @@ -671,12 +688,12 @@ 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); gdb_assert (!options->format); - const gdb_byte *valaddr = value_contents_for_printing (original_value); + const gdb_byte *valaddr = value_contents_for_printing (original_value).data (); val = unpack_long (type, valaddr + embedded_offset * unit_size); @@ -692,7 +709,7 @@ 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 (); gdb_assert (!options->format); @@ -723,7 +740,7 @@ generic_value_print_bool } else { - const gdb_byte *valaddr = value_contents_for_printing (value); + 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) @@ -766,34 +783,55 @@ generic_value_print_char (struct value *value, struct ui_file *stream, { struct type *unresolved_type = value_type (value); struct type *type = check_typedef (unresolved_type); - const gdb_byte *valaddr = value_contents_for_printing (value); + const gdb_byte *valaddr = value_contents_for_printing (value).data (); LONGEST val = unpack_long (type, valaddr); - if (TYPE_UNSIGNED (type)) + if (type->is_unsigned ()) fprintf_filtered (stream, "%u", (unsigned int) val); else fprintf_filtered (stream, "%d", (int) val); fputs_filtered (" ", stream); - LA_PRINT_CHAR (val, unresolved_type, stream); + current_language->printchar (val, unresolved_type, stream); } } /* generic_val_print helper for TYPE_CODE_FLT and TYPE_CODE_DECFLOAT. */ static void -generic_val_print_float (struct type *type, - int embedded_offset, struct ui_file *stream, +generic_val_print_float (struct type *type, struct ui_file *stream, struct value *original_value, const struct value_print_options *options) { - struct gdbarch *gdbarch = get_type_arch (type); - int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); - gdb_assert (!options->format); - const gdb_byte *valaddr = value_contents_for_printing (original_value); + const gdb_byte *valaddr = value_contents_for_printing (original_value).data (); - print_floating (valaddr + embedded_offset * unit_size, type, stream); + print_floating (valaddr, type, stream); +} + +/* generic_val_print helper for TYPE_CODE_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 = value_type (val); + + const gdb_byte *valaddr = value_contents_for_printing (val).data (); + gdb_mpf f; + + 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); + fprintf_filtered (stream, "%s", str.c_str ()); + } } /* generic_value_print helper for TYPE_CODE_COMPLEX. */ @@ -815,6 +853,27 @@ generic_value_print_complex (struct value *val, struct ui_file *stream, fprintf_filtered (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 + generic_value_print (val, stream, recurse, options, decorations); +} + /* See valprint.h. */ void @@ -825,6 +884,10 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, struct type *type = value_type (val); type = check_typedef (type); + + if (is_fixed_point_type (type)) + type = type->fixed_point_type_base_type (); + switch (type->code ()) { case TYPE_CODE_ARRAY: @@ -832,7 +895,8 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, 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: @@ -873,16 +937,6 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, 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; @@ -896,8 +950,11 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, if (options->format) value_print_scalar_formatted (val, options, 0, stream); else - generic_val_print_float (type, 0, stream, - val, options); + 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: @@ -910,8 +967,8 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, 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; @@ -919,25 +976,40 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, 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 ()); } } -/* 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)) + value_fetch_lazy (value); + struct value_print_options local_opts = *options; struct type *type = value_type (value); struct type *real_type = check_typedef (type); @@ -952,7 +1024,7 @@ do_val_print (struct value *value, struct ui_file *stream, int recurse, 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; @@ -963,9 +1035,8 @@ do_val_print (struct value *value, struct ui_file *stream, int recurse, 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; } @@ -984,12 +1055,12 @@ do_val_print (struct value *value, struct ui_file *stream, int recurse, 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 (), - _("")); + _(""), except.what ()); } } @@ -1002,8 +1073,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); + fputs_filtered (language->struct_too_deep_ellipsis (), stream); return true; } @@ -1066,30 +1137,6 @@ 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. */ - -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 @@ -1125,26 +1172,26 @@ value_print (struct value *val, struct ui_file *stream, return; } - LA_VALUE_PRINT (val, stream, options); + current_language->value_print (val, stream, options); } 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 = (value_contents_for_printing (original_value).data () + embedded_offset); ULONGEST val = unpack_long (type, valaddr); - int field, nfields = TYPE_NFIELDS (type); - struct gdbarch *gdbarch = get_type_arch (type); + int field, nfields = type->num_fields (); + struct gdbarch *gdbarch = type->arch (); struct type *bool_type = builtin_type (gdbarch)->builtin_bool; fputs_filtered ("[", stream); for (field = 0; field < nfields; field++) { - if (TYPE_FIELD_NAME (type, field)[0] != '\0') + if (type->field (field).name ()[0] != '\0') { - struct type *field_type = TYPE_FIELD_TYPE (type, field); + struct type *field_type = type->field (field).type (); if (field_type == bool_type /* We require boolean types here to be one bit wide. This is a @@ -1153,23 +1200,22 @@ val_print_type_code_flags (struct type *type, struct value *original_value, int. */ && TYPE_FIELD_BITSIZE (type, field) == 1) { - if (val & ((ULONGEST)1 << TYPE_FIELD_BITPOS (type, field))) + if (val & ((ULONGEST)1 << type->field (field).loc_bitpos ())) fprintf_filtered (stream, " %ps", styled_string (variable_name_style.style (), - TYPE_FIELD_NAME (type, field))); + type->field (field).name ())); } else { unsigned field_len = TYPE_FIELD_BITSIZE (type, field); - ULONGEST field_val - = val >> (TYPE_FIELD_BITPOS (type, field) - field_len + 1); + ULONGEST field_val = val >> type->field (field).loc_bitpos (); if (field_len < sizeof (ULONGEST) * TARGET_CHAR_BIT) field_val &= ((ULONGEST) 1 << field_len) - 1; fprintf_filtered (stream, " %ps=", styled_string (variable_name_style.style (), - TYPE_FIELD_NAME (type, field))); + type->field (field).name ())); if (field_type->code () == TYPE_CODE_ENUM) generic_val_print_enum_1 (field_type, field_val, stream); else @@ -1207,7 +1253,7 @@ value_print_scalar_formatted (struct value *val, /* 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. */ @@ -1664,7 +1710,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--; @@ -1781,43 +1827,6 @@ print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr, } } -/* VALADDR points to a char integer of LEN bytes. - Print it out in appropriate language form on stream. - Omit any leading zero chars. */ - -void -print_char_chars (struct ui_file *stream, struct type *type, - const gdb_byte *valaddr, - unsigned len, enum bfd_endian byte_order) -{ - const gdb_byte *p; - - if (byte_order == BFD_ENDIAN_BIG) - { - p = valaddr; - while (p < valaddr + len - 1 && *p == 0) - ++p; - - while (p < valaddr + len) - { - LA_EMIT_CHAR (*p, type, stream, '\''); - ++p; - } - } - else - { - p = valaddr + len - 1; - while (p > valaddr && *p == 0) - --p; - - while (p >= valaddr) - { - LA_EMIT_CHAR (*p, type, stream, '\''); - --p; - } - } -} - /* Print function pointer with inferior address ADDRESS onto stdio stream STREAM. */ @@ -1827,9 +1836,8 @@ 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. */ @@ -1848,17 +1856,13 @@ 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); } /* See valprint.h. */ @@ -1871,7 +1875,7 @@ value_print_array_elements (struct value *val, struct ui_file *stream, { 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. */ @@ -1879,43 +1883,26 @@ value_print_array_elements (struct value *val, struct ui_file *stream, /* 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 (index_type->code () == 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 { @@ -1945,9 +1932,9 @@ value_print_array_elements (struct value *val, struct ui_file *stream, fprintf_filtered (stream, "\n"); print_spaces_filtered (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); rep1 = i + 1; reps = 1; @@ -2053,13 +2040,7 @@ partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, Unless an exception is thrown, BUFFER will always be allocated, even on failure. In this case, some characters might have been read before the - failure happened. Check BYTES_READ to recognize this situation. - - Note: There was a FIXME asking to make this code use target_read_string, - but this function is more general (can read past null characters, up to - given LEN). Besides, it is used much more often than target_read_string - so it is more tested. Perhaps callers of target_read_string should use - this function instead? */ + failure happened. Check BYTES_READ to recognize this situation. */ int read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, @@ -2731,7 +2712,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); @@ -2765,8 +2746,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); @@ -2777,8 +2758,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; } @@ -2786,10 +2767,9 @@ 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) { @@ -3041,6 +3021,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; }, @@ -3132,37 +3123,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_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,