X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalprint.c;h=d678ad3091a46848f47b86a4e0f0b51480a76955;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=50b5a1ff50d9a4b418920242d20e881b8f6ebc2b;hpb=abc66ce95eee79db058123b985e19dcfc03dc1a7;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/valprint.c b/gdb/valprint.c index 50b5a1ff50..d678ad3091 100644 --- a/gdb/valprint.c +++ b/gdb/valprint.c @@ -88,7 +88,8 @@ 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. */ @@ -275,7 +276,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: @@ -322,9 +323,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 +338,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) @@ -407,7 +408,7 @@ print_unpacked_pointer (struct type *type, struct type *elttype, { struct gdbarch *gdbarch = get_type_arch (type); - 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); @@ -423,14 +424,13 @@ print_unpacked_pointer (struct type *type, struct type *elttype, /* 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,67 +441,40 @@ 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); + value_print_array_elements (val, stream, recurse, options, 0); fputs_filtered (decorations->array_end, stream); } else { /* Array of unspecified length: treat like pointer to first elt. */ - print_unpacked_pointer (type, elttype, address + embedded_offset, stream, - options); + 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); + 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 @@ -554,7 +527,7 @@ 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 int type_is_defined = elttype->code () != TYPE_CODE_UNDEF; const gdb_byte *valaddr = value_contents_for_printing (original_value); if (must_coerce_ref && type_is_defined) @@ -614,7 +587,7 @@ 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; @@ -701,39 +674,13 @@ generic_val_print_enum (struct type *type, struct gdbarch *gdbarch = get_type_arch (type); 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); -{ - 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. */ @@ -747,50 +694,38 @@ generic_val_print_func (struct type *type, { struct gdbarch *gdbarch = get_type_arch (type); - if (options->format) - { - val_print_scalar_formatted (type, embedded_offset, - original_value, options, 0, stream); - } - else - { - /* FIXME, we should consider, at least for ANSI C language, - eliminating the distinction made between FUNCs and POINTERs - to FUNCs. */ - fprintf_filtered (stream, "{"); - type_print (type, "", stream, -1); - fprintf_filtered (stream, "} "); - /* Try to print what function it points to, and its address. */ - print_address_demangle (options, gdbarch, address, stream, demangle); - } + gdb_assert (!options->format); + + /* FIXME, we should consider, at least for ANSI C language, + eliminating the distinction made between FUNCs and POINTERs to + FUNCs. */ + fprintf_filtered (stream, "{"); + type_print (type, "", stream, -1); + fprintf_filtered (stream, "} "); + /* Try to print what function it points to, and its address. */ + print_address_demangle (options, gdbarch, address, stream, demangle); } -/* generic_val_print helper for TYPE_CODE_BOOL. */ +/* generic_value_print helper for TYPE_CODE_BOOL. */ static void -generic_val_print_bool (struct type *type, - int embedded_offset, struct ui_file *stream, - struct value *original_value, - const struct value_print_options *options, - const struct generic_val_print_decorations *decorations) +generic_value_print_bool + (struct value *value, struct ui_file *stream, + const struct value_print_options *options, + const struct generic_val_print_decorations *decorations) { - LONGEST val; - struct gdbarch *gdbarch = get_type_arch (type); - int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); - if (options->format || options->output_format) { struct value_print_options opts = *options; opts.format = (options->format ? options->format : options->output_format); - val_print_scalar_formatted (type, embedded_offset, - original_value, &opts, 0, stream); + value_print_scalar_formatted (value, &opts, 0, stream); } else { - const gdb_byte *valaddr = value_contents_for_printing (original_value); - - val = unpack_long (type, valaddr + embedded_offset * unit_size); + const gdb_byte *valaddr = value_contents_for_printing (value); + struct type *type = check_typedef (value_type (value)); + LONGEST val = unpack_long (type, valaddr); if (val == 0) fputs_filtered (decorations->false_name, stream); else if (val == 1) @@ -800,49 +735,40 @@ generic_val_print_bool (struct type *type, } } -/* 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); - val = unpack_long (type, valaddr + embedded_offset * unit_size); + LONGEST val = unpack_long (type, valaddr); if (TYPE_UNSIGNED (type)) fprintf_filtered (stream, "%u", (unsigned int) val); else @@ -863,174 +789,30 @@ generic_val_print_float (struct type *type, struct gdbarch *gdbarch = get_type_arch (type); 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); - - print_floating (valaddr + embedded_offset * unit_size, type, stream); - } -} - -/* generic_val_print helper for TYPE_CODE_COMPLEX. */ + gdb_assert (!options->format); -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) -{ - struct gdbarch *gdbarch = get_type_arch (type); - int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); const gdb_byte *valaddr = value_contents_for_printing (original_value); - fprintf_filtered (stream, "%s", decorations->complex_prefix); - if (options->format) - val_print_scalar_formatted (TYPE_TARGET_TYPE (type), - embedded_offset, original_value, options, 0, - stream); - else - print_floating (valaddr + embedded_offset * unit_size, - TYPE_TARGET_TYPE (type), stream); - fprintf_filtered (stream, "%s", decorations->complex_infix); - if (options->format) - val_print_scalar_formatted (TYPE_TARGET_TYPE (type), - embedded_offset - + type_length_units (TYPE_TARGET_TYPE (type)), - original_value, options, 0, stream); - 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); + print_floating (valaddr + embedded_offset * unit_size, type, stream); } -/* 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. */ +/* generic_value_print helper for TYPE_CODE_COMPLEX. */ -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) +static void +generic_value_print_complex (struct value *val, struct ui_file *stream, + const struct value_print_options *options, + const struct generic_val_print_decorations + *decorations) { - struct type *unresolved_type = type; - - type = check_typedef (type); - switch (TYPE_CODE (type)) - { - case TYPE_CODE_ARRAY: - generic_val_print_array (type, embedded_offset, address, stream, - recurse, original_value, options, decorations); - break; - - case TYPE_CODE_MEMBERPTR: - generic_val_print_memberptr (type, embedded_offset, stream, - original_value, options); - break; - - case TYPE_CODE_PTR: - generic_val_print_ptr (type, embedded_offset, stream, - original_value, options); - break; - - case TYPE_CODE_REF: - case TYPE_CODE_RVALUE_REF: - generic_val_print_ref (type, embedded_offset, stream, recurse, - original_value, options); - break; - - case TYPE_CODE_ENUM: - generic_val_print_enum (type, embedded_offset, stream, - original_value, options); - break; - - case TYPE_CODE_FLAGS: - generic_val_print_flags (type, embedded_offset, stream, - original_value, options); - break; - - case TYPE_CODE_FUNC: - case TYPE_CODE_METHOD: - generic_val_print_func (type, embedded_offset, address, stream, - original_value, options); - break; - - case TYPE_CODE_BOOL: - generic_val_print_bool (type, embedded_offset, stream, - original_value, options, decorations); - break; - - case TYPE_CODE_RANGE: - /* FIXME: create_static_range_type does not set the unsigned bit in a - range type (I think it probably should copy it from the - target type), so we won't print values which are too large to - fit in a signed integer correctly. */ - /* FIXME: Doesn't handle ranges of enums correctly. (Can't just - print with the target type, though, because the size of our - type and the target type might differ). */ - - /* FALLTHROUGH */ - - case TYPE_CODE_INT: - generic_val_print_int (type, embedded_offset, stream, - original_value, options); - break; - - case TYPE_CODE_CHAR: - generic_val_print_char (type, unresolved_type, embedded_offset, - stream, original_value, options); - break; - - case TYPE_CODE_FLT: - case TYPE_CODE_DECFLOAT: - generic_val_print_float (type, embedded_offset, stream, - original_value, options); - break; - - case TYPE_CODE_VOID: - fputs_filtered (decorations->void_name, stream); - break; - - case TYPE_CODE_ERROR: - fprintf_filtered (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. */ - fprintf_styled (stream, metadata_style.style (), _("")); - break; + fprintf_filtered (stream, "%s", decorations->complex_prefix); - case TYPE_CODE_COMPLEX: - generic_val_print_complex (type, embedded_offset, stream, - original_value, options, decorations); - break; + struct value *real_part = value_real_part (val); + value_print_scalar_formatted (real_part, options, 0, stream); + fprintf_filtered (stream, "%s", decorations->complex_infix); - case TYPE_CODE_UNION: - case TYPE_CODE_STRUCT: - case TYPE_CODE_METHODPTR: - default: - error (_("Unhandled type code %d in symbol table."), - TYPE_CODE (type)); - } + struct value *imag_part = value_imaginary_part (val); + value_print_scalar_formatted (imag_part, options, 0, stream); + fprintf_filtered (stream, "%s", decorations->complex_suffix); } /* See valprint.h. */ @@ -1041,24 +823,20 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, const struct generic_val_print_decorations *decorations) { struct type *type = value_type (val); - struct type *unresolved_type = type; type = check_typedef (type); - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_ARRAY: - generic_val_print_array (type, 0, value_address (val), stream, - recurse, val, options, decorations); + generic_val_print_array (val, stream, recurse, options, decorations); break; case TYPE_CODE_MEMBERPTR: - generic_val_print_memberptr (type, 0, stream, - val, options); + value_print_scalar_formatted (val, options, 0, stream); break; case TYPE_CODE_PTR: - generic_val_print_ptr (type, 0, stream, - val, options); + generic_value_print_ptr (val, stream, options); break; case TYPE_CODE_REF: @@ -1068,24 +846,30 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, break; case TYPE_CODE_ENUM: - generic_val_print_enum (type, 0, stream, - val, options); + if (options->format) + value_print_scalar_formatted (val, options, 0, stream); + else + generic_val_print_enum (type, 0, stream, val, options); break; case TYPE_CODE_FLAGS: - generic_val_print_flags (type, 0, stream, - val, options); + if (options->format) + value_print_scalar_formatted (val, options, 0, stream); + else + val_print_type_code_flags (type, val, 0, stream); break; case TYPE_CODE_FUNC: case TYPE_CODE_METHOD: - generic_val_print_func (type, 0, value_address (val), stream, - val, options); + if (options->format) + value_print_scalar_formatted (val, options, 0, stream); + else + generic_val_print_func (type, 0, value_address (val), stream, + val, options); break; case TYPE_CODE_BOOL: - generic_val_print_bool (type, 0, stream, - val, options, decorations); + generic_value_print_bool (val, stream, options, decorations); break; case TYPE_CODE_RANGE: @@ -1100,19 +884,20 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, /* FALLTHROUGH */ case TYPE_CODE_INT: - generic_val_print_int (type, 0, stream, - val, options); + generic_value_print_int (val, stream, options); break; case TYPE_CODE_CHAR: - generic_val_print_char (type, unresolved_type, 0, - stream, val, options); + generic_value_print_char (val, stream, options); break; case TYPE_CODE_FLT: case TYPE_CODE_DECFLOAT: - generic_val_print_float (type, 0, stream, - val, options); + if (options->format) + value_print_scalar_formatted (val, options, 0, stream); + else + generic_val_print_float (type, 0, stream, + val, options); break; case TYPE_CODE_VOID: @@ -1131,8 +916,7 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, break; case TYPE_CODE_COMPLEX: - generic_val_print_complex (type, 0, stream, - val, options, decorations); + generic_value_print_complex (val, stream, options, decorations); break; case TYPE_CODE_UNION: @@ -1140,7 +924,7 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, case TYPE_CODE_METHODPTR: default: error (_("Unhandled type code %d in symbol table."), - TYPE_CODE (type)); + type->code ()); } } @@ -1149,15 +933,13 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse, the value to be printed. */ static void -do_val_print (struct value *full_value, - struct type *type, LONGEST embedded_offset, - CORE_ADDR address, struct ui_file *stream, int recurse, - struct value *val, +do_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; 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) @@ -1176,14 +958,13 @@ do_val_print (struct value *full_value, 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); + ret = apply_ext_lang_val_pretty_printer (value, stream, recurse, options, + language); if (ret) return; } @@ -1203,13 +984,7 @@ do_val_print (struct value *full_value, try { - if (full_value != nullptr && language->la_value_print_inner != nullptr) - language->la_value_print_inner (full_value, stream, recurse, - &local_opts); - else - language->la_val_print (type, embedded_offset, address, - stream, recurse, val, - &local_opts); + language->la_value_print_inner (value, stream, recurse, &local_opts); } catch (const gdb_exception_error &except) { @@ -1218,36 +993,6 @@ do_val_print (struct value *full_value, } } -/* Print using the given LANGUAGE the data of type TYPE located at - VAL's contents buffer + EMBEDDED_OFFSET (within GDB), which came - from the inferior at address ADDRESS + EMBEDDED_OFFSET, onto - stdio stream STREAM according to OPTIONS. VAL is the whole object - that came from ADDRESS. - - The language printers will pass down an adjusted EMBEDDED_OFFSET to - further helper subroutines as subfields of TYPE are printed. In - such cases, VAL is passed down unadjusted, so - that VAL can be queried for metadata about the contents data being - printed, using EMBEDDED_OFFSET as an offset into VAL's contents - buffer. For example: "has this field been optimized out", or "I'm - printing an object while inspecting a traceframe; has this - particular piece of data been collected?". - - RECURSE indicates the amount of indentation to supply before - continuation lines; this amount is roughly twice the value of - RECURSE. */ - -void -val_print (struct type *type, LONGEST embedded_offset, - CORE_ADDR address, struct ui_file *stream, int recurse, - struct value *val, - const struct value_print_options *options, - const struct language_defn *language) -{ - do_val_print (nullptr, type, embedded_offset, address, stream, - recurse, val, options, language); -} - /* See valprint.h. */ bool @@ -1298,7 +1043,7 @@ value_check_printable (struct value *val, struct ui_file *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 (), _(""), @@ -1332,9 +1077,6 @@ common_val_print (struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language) { - if (!value_check_printable (val, stream, options)) - return; - if (language->la_language == language_ada) /* The value might have a dynamic type, which would cause trouble below when trying to extract the value contents (since the value @@ -1345,10 +1087,7 @@ common_val_print (struct value *val, struct ui_file *stream, int recurse, if (value_lazy (val)) value_fetch_lazy (val); - do_val_print (val, value_type (val), - value_embedded_offset (val), value_address (val), - stream, recurse, - val, options, language); + do_val_print (val, stream, recurse, options, language); } /* See valprint.h. */ @@ -1379,11 +1118,8 @@ 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; @@ -1393,11 +1129,13 @@ value_print (struct value *val, struct ui_file *stream, } 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) + + embedded_offset); ULONGEST val = unpack_long (type, valaddr); - int field, nfields = TYPE_NFIELDS (type); + int field, nfields = type->num_fields (); struct gdbarch *gdbarch = get_type_arch (type); struct type *bool_type = builtin_type (gdbarch)->builtin_bool; @@ -1432,7 +1170,7 @@ val_print_type_code_flags (struct type *type, const gdb_byte *valaddr, fprintf_filtered (stream, " %ps=", styled_string (variable_name_style.style (), TYPE_FIELD_NAME (type, field))); - if (TYPE_CODE (field_type) == TYPE_CODE_ENUM) + 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); @@ -1442,57 +1180,6 @@ val_print_type_code_flags (struct type *type, const gdb_byte *valaddr, fputs_filtered (" ]", stream); } -/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR, - according to OPTIONS and SIZE on STREAM. Format i is not supported - at this level. - - This is how the elements of an array or structure are printed - with a format. */ - -void -val_print_scalar_formatted (struct type *type, - LONGEST embedded_offset, - struct value *val, - const struct value_print_options *options, - int size, - struct ui_file *stream) -{ - struct gdbarch *arch = get_type_arch (type); - int unit_size = gdbarch_addressable_memory_unit_size (arch); - - gdb_assert (val != NULL); - - /* If we get here with a string format, try again without it. Go - all the way back to the language printers, which may call us - again. */ - if (options->format == 's') - { - struct value_print_options opts = *options; - opts.format = 0; - opts.deref_ref = 0; - val_print (type, embedded_offset, 0, stream, 0, val, &opts, - current_language); - return; - } - - /* value_contents_for_printing fetches all VAL's contents. They are - needed to check whether VAL is optimized-out or unavailable - below. */ - const gdb_byte *valaddr = value_contents_for_printing (val); - - /* A scalar object that does not have all bits available can't be - printed, because all bits contribute to its representation. */ - if (value_bits_any_optimized_out (val, - TARGET_CHAR_BIT * embedded_offset, - TARGET_CHAR_BIT * TYPE_LENGTH (type))) - val_print_optimized_out (val, stream); - else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type))) - val_print_unavailable (stream); - else - print_scalar_formatted (valaddr + embedded_offset * unit_size, type, - options, size, stream); -} - /* See valprint.h. */ void @@ -2164,152 +1851,10 @@ maybe_print_array_index (struct type *index_type, LONGEST index, struct ui_file *stream, const struct value_print_options *options) { - struct value *index_value; - if (!options->print_array_indexes) return; - index_value = value_from_longest (index_type, index); - - LA_PRINT_ARRAY_INDEX (index_value, stream, options); -} - -/* Called by various _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. */ - -void -val_print_array_elements (struct type *type, - LONGEST embedded_offset, - CORE_ADDR address, struct ui_file *stream, - int recurse, - struct value *val, - const struct value_print_options *options, - unsigned int i) -{ - unsigned int things_printed = 0; - unsigned len; - struct type *elttype, *index_type, *base_index_type; - unsigned eltlen; - /* Position of the array element we are examining to see - whether it is repeated. */ - unsigned int rep1; - /* Number of repetitions we have detected so far. */ - unsigned int reps; - LONGEST low_bound, high_bound; - LONGEST low_pos, high_pos; - - elttype = TYPE_TARGET_TYPE (type); - eltlen = type_length_units (check_typedef (elttype)); - index_type = TYPE_INDEX_TYPE (type); - - if (get_array_bounds (type, &low_bound, &high_bound)) - { - if (TYPE_CODE (index_type) == TYPE_CODE_RANGE) - base_index_type = TYPE_TARGET_TYPE (index_type); - else - base_index_type = index_type; - - /* Non-contiguous enumerations types can by used as index types - in some languages (e.g. Ada). In this case, the array length - shall be computed from the positions of the first and last - literal in the enumeration type, and not from the values - of these literals. */ - if (!discrete_position (base_index_type, low_bound, &low_pos) - || !discrete_position (base_index_type, high_bound, &high_pos)) - { - warning (_("unable to get positions in array, use bounds instead")); - low_pos = low_bound; - high_pos = high_bound; - } - - /* The array length should normally be HIGH_POS - LOW_POS + 1. - But we have to be a little extra careful, because some languages - such as Ada allow LOW_POS to be greater than HIGH_POS for - empty arrays. In that situation, the array length is just zero, - not negative! */ - if (low_pos > high_pos) - len = 0; - else - len = high_pos - low_pos + 1; - } - else - { - warning (_("unable to get bounds of array, assuming null array")); - low_bound = 0; - len = 0; - } - - annotate_array_section_begin (i, elttype); - - for (; i < len && things_printed < options->print_max; i++) - { - if (i != 0) - { - if (options->prettyformat_arrays) - { - fprintf_filtered (stream, ",\n"); - print_spaces_filtered (2 + 2 * recurse, stream); - } - else - { - fprintf_filtered (stream, ", "); - } - } - wrap_here (n_spaces (2 + 2 * recurse)); - maybe_print_array_index (index_type, i + low_bound, - stream, options); - - rep1 = i + 1; - reps = 1; - /* Only check for reps if repeat_count_threshold is not set to - UINT_MAX (unlimited). */ - if (options->repeat_count_threshold < UINT_MAX) - { - while (rep1 < len - && value_contents_eq (val, - embedded_offset + i * eltlen, - val, - (embedded_offset - + rep1 * eltlen), - eltlen)) - { - ++reps; - ++rep1; - } - } - - if (reps > options->repeat_count_threshold) - { - val_print (elttype, embedded_offset + i * eltlen, - address, stream, recurse + 1, val, options, - current_language); - annotate_elt_rep (reps); - fprintf_filtered (stream, " %p[%p]", - metadata_style.style ().ptr (), reps, nullptr); - annotate_elt_rep_end (); - - i = rep1 - 1; - things_printed += options->repeat_count_threshold; - } - else - { - val_print (elttype, embedded_offset + i * eltlen, - address, - stream, recurse + 1, val, options, current_language); - annotate_elt (); - things_printed++; - } - } - annotate_array_section_end (); - if (i < len) - { - fprintf_filtered (stream, "..."); - } + LA_PRINT_ARRAY_INDEX (index_type, index, stream, options); } /* See valprint.h. */ @@ -2322,7 +1867,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. */ @@ -2330,43 +1875,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); + 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 { @@ -2391,6 +1919,11 @@ value_print_array_elements (struct value *val, struct ui_file *stream, else fprintf_filtered (stream, ", "); } + else if (options->prettyformat_arrays) + { + fprintf_filtered (stream, "\n"); + print_spaces_filtered (2 + 2 * recurse, stream); + } wrap_here (n_spaces (2 + 2 * recurse)); maybe_print_array_index (index_type, i + low_bound, stream, options); @@ -2434,6 +1967,11 @@ value_print_array_elements (struct value *val, struct ui_file *stream, annotate_array_section_end (); if (i < len) fprintf_filtered (stream, "..."); + if (options->prettyformat_arrays) + { + fprintf_filtered (stream, "\n"); + print_spaces_filtered (2 * recurse, stream); + } } /* Read LEN bytes of target memory at address MEMADDR, placing the @@ -3388,34 +2926,6 @@ show_radix (const char *arg, int from_tty) } -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, @@ -3607,30 +3117,30 @@ _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_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); /* 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_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_prefix_cmd ("raw", no_class, set_print_raw, - _("\ + 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); + &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); + 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); gdb::option::add_setshow_cmds_for_options