X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fp-valprint.c;h=cf902ac7fbe1758ae2442887ae69e11f7625ca75;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=a46f3440fbcf376c64c61ccf0af6ed1f0c1bb47b;hpb=d3eab38a48ec521922e7d07595fd693df7ff3510;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c index a46f3440fb..cf902ac7fb 100644 --- a/gdb/p-valprint.c +++ b/gdb/p-valprint.c @@ -1,7 +1,6 @@ /* Support for printing Pascal values for GDB, the GNU debugger. - Copyright (C) 2000-2001, 2003, 2005-2012 Free Software Foundation, - Inc. + Copyright (C) 2000-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -38,103 +37,117 @@ #include "p-lang.h" #include "cp-abi.h" #include "cp-support.h" -#include "exceptions.h" +#include "objfiles.h" +#include "gdbsupport/byte-vector.h" +#include "cli/cli-style.h" -/* See val_print for a description of the various parameters of this - function; they are identical. */ +static void pascal_object_print_value_fields (struct value *, struct ui_file *, + int, + const struct value_print_options *, + struct type **, int); + +/* Decorations for Pascal. */ + +static const struct generic_val_print_decorations p_decorations = +{ + "", + " + ", + " * I", + "true", + "false", + "void", + "{", + "}" +}; + +/* See p-lang.h. */ void -pascal_val_print (struct type *type, const gdb_byte *valaddr, - int embedded_offset, CORE_ADDR address, - struct ui_file *stream, int recurse, - const struct value *original_value, - const struct value_print_options *options) +pascal_value_print_inner (struct value *val, struct ui_file *stream, + int recurse, + const struct value_print_options *options) + { + struct type *type = check_typedef (value_type (val)); struct gdbarch *gdbarch = get_type_arch (type); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum bfd_endian byte_order = type_byte_order (type); unsigned int i = 0; /* Number of characters printed */ unsigned len; - LONGEST low_bound, high_bound; struct type *elttype; unsigned eltlen; int length_pos, length_size, string_pos; struct type *char_type; - LONGEST val; CORE_ADDR addr; + int want_space = 0; + const gdb_byte *valaddr = value_contents_for_printing (val); - CHECK_TYPEDEF (type); - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_ARRAY: - if (get_array_bounds (type, &low_bound, &high_bound)) - { - len = high_bound - low_bound + 1; - elttype = check_typedef (TYPE_TARGET_TYPE (type)); - eltlen = TYPE_LENGTH (elttype); - if (options->prettyprint_arrays) - { - print_spaces_filtered (2 + 2 * recurse, stream); - } - /* If 's' format is used, try to print out as string. - If no format is given, print as string if element type - is of TYPE_CODE_CHAR and element size is 1,2 or 4. */ - if (options->format == 's' - || ((eltlen == 1 || eltlen == 2 || eltlen == 4) - && TYPE_CODE (elttype) == TYPE_CODE_CHAR - && options->format == 0)) - { - /* If requested, look for the first null char and only print - elements up to it. */ - if (options->stop_print_at_null) - { - unsigned int temp_len; - - /* Look for a NULL char. */ - for (temp_len = 0; - extract_unsigned_integer (valaddr + embedded_offset + - temp_len * eltlen, eltlen, - byte_order) - && temp_len < len && temp_len < options->print_max; - temp_len++); - len = temp_len; - } - - LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type), - valaddr + embedded_offset, len, NULL, 0, - options); - i = len; - } - else - { - fprintf_filtered (stream, "{"); - /* If this is a virtual function table, print the 0th - entry specially, and the rest of the members normally. */ - if (pascal_object_is_vtbl_ptr_type (elttype)) - { - i = 1; - fprintf_filtered (stream, "%d vtable entries", len - 1); - } - else - { - i = 0; - } - val_print_array_elements (type, valaddr, embedded_offset, - address, stream, recurse, - original_value, options, i); - fprintf_filtered (stream, "}"); - } - break; - } - /* Array of unspecified length: treat like pointer to first elt. */ - addr = address + embedded_offset; + { + LONGEST low_bound, high_bound; + + if (get_array_bounds (type, &low_bound, &high_bound)) + { + len = high_bound - low_bound + 1; + elttype = check_typedef (TYPE_TARGET_TYPE (type)); + eltlen = TYPE_LENGTH (elttype); + /* If 's' format is used, try to print out as string. + If no format is given, print as string if element type + is of TYPE_CODE_CHAR and element size is 1,2 or 4. */ + if (options->format == 's' + || ((eltlen == 1 || eltlen == 2 || eltlen == 4) + && elttype->code () == TYPE_CODE_CHAR + && options->format == 0)) + { + /* If requested, look for the first null char and only print + elements up to it. */ + if (options->stop_print_at_null) + { + unsigned int temp_len; + + /* Look for a NULL char. */ + for (temp_len = 0; + extract_unsigned_integer (valaddr + temp_len * eltlen, + eltlen, byte_order) + && temp_len < len && temp_len < options->print_max; + temp_len++); + len = temp_len; + } + + LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type), + valaddr, len, NULL, 0, options); + i = len; + } + else + { + fprintf_filtered (stream, "{"); + /* If this is a virtual function table, print the 0th + entry specially, and the rest of the members normally. */ + if (pascal_object_is_vtbl_ptr_type (elttype)) + { + i = 1; + fprintf_filtered (stream, "%d vtable entries", len - 1); + } + else + { + i = 0; + } + value_print_array_elements (val, stream, recurse, options, i); + fprintf_filtered (stream, "}"); + } + break; + } + /* Array of unspecified length: treat like pointer to first elt. */ + addr = value_address (val); + } goto print_unpacked_pointer; case TYPE_CODE_PTR: if (options->format && options->format != 's') { - val_print_scalar_formatted (type, valaddr, embedded_offset, - original_value, options, 0, stream); + value_print_scalar_formatted (val, options, 0, stream); break; } if (options->vtblprint && pascal_object_is_vtbl_ptr_type (type)) @@ -143,39 +156,42 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, /* Print vtable entry - we only get here if we ARE using -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */ /* Extract the address, assume that it is unsigned. */ - addr = extract_unsigned_integer (valaddr + embedded_offset, + addr = extract_unsigned_integer (valaddr, TYPE_LENGTH (type), byte_order); - print_address_demangle (gdbarch, addr, stream, demangle); + print_address_demangle (options, gdbarch, addr, stream, demangle); break; } check_typedef (TYPE_TARGET_TYPE (type)); - addr = unpack_pointer (type, valaddr + embedded_offset); + addr = unpack_pointer (type, valaddr); print_unpacked_pointer: elttype = check_typedef (TYPE_TARGET_TYPE (type)); - if (TYPE_CODE (elttype) == TYPE_CODE_FUNC) + if (elttype->code () == TYPE_CODE_FUNC) { /* Try to print what function it points to. */ - print_address_demangle (gdbarch, addr, stream, demangle); + print_address_demangle (options, gdbarch, addr, stream, demangle); return; } if (options->addressprint && options->format != 's') { fputs_filtered (paddress (gdbarch, addr), stream); + want_space = 1; } /* For a pointer to char or unsigned char, also print the string pointed to, unless pointer is null. */ if (((TYPE_LENGTH (elttype) == 1 - && (TYPE_CODE (elttype) == TYPE_CODE_INT - || TYPE_CODE (elttype) == TYPE_CODE_CHAR)) - || ((TYPE_LENGTH (elttype) == 2 || TYPE_LENGTH (elttype) == 4) - && TYPE_CODE (elttype) == TYPE_CODE_CHAR)) + && (elttype->code () == TYPE_CODE_INT + || elttype->code () == TYPE_CODE_CHAR)) + || ((TYPE_LENGTH (elttype) == 2 || TYPE_LENGTH (elttype) == 4) + && elttype->code () == TYPE_CODE_CHAR)) && (options->format == 0 || options->format == 's') && addr != 0) { + if (want_space) + fputs_filtered (" ", stream); /* No wide string yet. */ i = val_print_string (elttype, NULL, addr, -1, stream, options); } @@ -189,9 +205,11 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, && addr != 0) { ULONGEST string_length; - void *buffer; + gdb_byte *buffer; - buffer = xmalloc (length_size); + if (want_space) + fputs_filtered (" ", stream); + buffer = (gdb_byte *) xmalloc (length_size); read_memory (addr + length_pos, buffer, length_size); string_length = extract_unsigned_integer (buffer, length_size, byte_order); @@ -203,29 +221,37 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, else if (pascal_object_is_vtbl_member (type)) { /* Print vtbl's nicely. */ - CORE_ADDR vt_address = unpack_pointer (type, - valaddr + embedded_offset); - struct minimal_symbol *msymbol = + CORE_ADDR vt_address = unpack_pointer (type, valaddr); + struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (vt_address); - if ((msymbol != NULL) - && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol))) + /* If 'symbol_print' is set, we did the work above. */ + if (!options->symbol_print + && (msymbol.minsym != NULL) + && (vt_address == BMSYMBOL_VALUE_ADDRESS (msymbol))) { - fputs_filtered (" <", stream); - fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream); + if (want_space) + fputs_filtered (" ", stream); + fputs_filtered ("<", stream); + fputs_filtered (msymbol.minsym->print_name (), stream); fputs_filtered (">", stream); + want_space = 1; } if (vt_address && options->vtblprint) { struct value *vt_val; - struct symbol *wsym = (struct symbol *) NULL; + struct symbol *wsym = NULL; struct type *wtype; - struct block *block = (struct block *) NULL; - int is_this_fld; - if (msymbol != NULL) - wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), block, - VAR_DOMAIN, &is_this_fld); + if (want_space) + fputs_filtered (" ", stream); + + if (msymbol.minsym != NULL) + { + const char *search_name = msymbol.minsym->search_name (); + wsym = lookup_symbol_search_name (search_name, NULL, + VAR_DOMAIN).symbol; + } if (wsym) { @@ -238,7 +264,7 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, vt_val = value_at (wtype, vt_address); common_val_print (vt_val, stream, recurse + 1, options, current_language); - if (options->pretty) + if (options->prettyformat) { fprintf_filtered (stream, "\n"); print_spaces_filtered (2 + 2 * recurse, stream); @@ -249,42 +275,18 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, return; case TYPE_CODE_REF: - elttype = check_typedef (TYPE_TARGET_TYPE (type)); - if (options->addressprint) - { - CORE_ADDR addr - = extract_typed_address (valaddr + embedded_offset, type); - - fprintf_filtered (stream, "@"); - fputs_filtered (paddress (gdbarch, addr), stream); - if (options->deref_ref) - fputs_filtered (": ", stream); - } - /* De-reference the reference. */ - if (options->deref_ref) - { - if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) - { - struct value *deref_val; - - deref_val = coerce_ref_if_computed (original_value); - if (deref_val != NULL) - { - /* More complicated computed references are not supported. */ - gdb_assert (embedded_offset == 0); - } - else - deref_val = value_at (TYPE_TARGET_TYPE (type), - unpack_pointer (type, - (valaddr - + embedded_offset))); - - common_val_print (deref_val, stream, recurse + 1, options, - current_language); - } - else - fputs_filtered ("???", stream); - } + case TYPE_CODE_ENUM: + case TYPE_CODE_FLAGS: + case TYPE_CODE_FUNC: + case TYPE_CODE_RANGE: + case TYPE_CODE_INT: + case TYPE_CODE_FLT: + case TYPE_CODE_VOID: + case TYPE_CODE_ERROR: + case TYPE_CODE_UNDEF: + case TYPE_CODE_BOOL: + case TYPE_CODE_CHAR: + generic_value_print (val, stream, recurse, options, &p_decorations); break; case TYPE_CODE_UNION: @@ -302,8 +304,8 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */ /* Extract the address, assume that it is unsigned. */ print_address_demangle - (gdbarch, - extract_unsigned_integer (valaddr + embedded_offset + (options, gdbarch, + extract_unsigned_integer (valaddr + TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8, TYPE_LENGTH (TYPE_FIELD_TYPE (type, @@ -316,209 +318,59 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, if (is_pascal_string_type (type, &length_pos, &length_size, &string_pos, &char_type, NULL)) { - len = extract_unsigned_integer (valaddr + embedded_offset - + length_pos, length_size, - byte_order); - LA_PRINT_STRING (stream, char_type, - valaddr + embedded_offset + string_pos, + len = extract_unsigned_integer (valaddr + length_pos, + length_size, byte_order); + LA_PRINT_STRING (stream, char_type, valaddr + string_pos, len, NULL, 0, options); } else - pascal_object_print_value_fields (type, valaddr, embedded_offset, - address, stream, recurse, - original_value, options, - NULL, 0); - } - break; - - case TYPE_CODE_ENUM: - if (options->format) - { - val_print_scalar_formatted (type, valaddr, embedded_offset, - original_value, options, 0, stream); - break; - } - len = TYPE_NFIELDS (type); - val = unpack_long (type, valaddr + embedded_offset); - for (i = 0; i < len; i++) - { - QUIT; - if (val == TYPE_FIELD_BITPOS (type, i)) - { - break; - } - } - if (i < len) - { - fputs_filtered (TYPE_FIELD_NAME (type, i), stream); - } - else - { - print_longest (stream, 'd', 0, val); - } - break; - - case TYPE_CODE_FLAGS: - if (options->format) - val_print_scalar_formatted (type, valaddr, embedded_offset, - original_value, options, 0, stream); - else - val_print_type_code_flags (type, valaddr + embedded_offset, stream); - break; - - case TYPE_CODE_FUNC: - if (options->format) - { - val_print_scalar_formatted (type, valaddr, embedded_offset, - original_value, options, 0, stream); - break; - } - /* 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 (gdbarch, address, stream, demangle); - break; - - case TYPE_CODE_BOOL: - 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, valaddr, embedded_offset, - original_value, &opts, 0, stream); - } - else - { - val = unpack_long (type, valaddr + embedded_offset); - if (val == 0) - fputs_filtered ("false", stream); - else if (val == 1) - fputs_filtered ("true", stream); - else - { - fputs_filtered ("true (", stream); - fprintf_filtered (stream, "%ld)", (long int) val); - } - } - break; - - case TYPE_CODE_RANGE: - /* FIXME: create_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: - 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, valaddr, embedded_offset, - original_value, &opts, 0, stream); - } - else - { - val_print_type_code_int (type, valaddr + embedded_offset, stream); - } - break; - - case TYPE_CODE_CHAR: - 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, valaddr, embedded_offset, - original_value, &opts, 0, stream); - } - else - { - val = unpack_long (type, valaddr + embedded_offset); - if (TYPE_UNSIGNED (type)) - fprintf_filtered (stream, "%u", (unsigned int) val); - else - fprintf_filtered (stream, "%d", (int) val); - fputs_filtered (" ", stream); - LA_PRINT_CHAR ((unsigned char) val, type, stream); - } - break; - - case TYPE_CODE_FLT: - if (options->format) - { - val_print_scalar_formatted (type, valaddr, embedded_offset, - original_value, options, 0, stream); - } - else - { - print_floating (valaddr + embedded_offset, type, stream); + pascal_object_print_value_fields (val, stream, recurse, + options, NULL, 0); } break; - case TYPE_CODE_BITSTRING: case TYPE_CODE_SET: elttype = TYPE_INDEX_TYPE (type); - CHECK_TYPEDEF (elttype); + elttype = check_typedef (elttype); if (TYPE_STUB (elttype)) { - fprintf_filtered (stream, ""); - gdb_flush (stream); + fprintf_styled (stream, metadata_style.style (), ""); break; } else { struct type *range = elttype; LONGEST low_bound, high_bound; - int i; - int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING; int need_comma = 0; - if (is_bitstring) - fputs_filtered ("B'", stream); - else - fputs_filtered ("[", stream); + fputs_filtered ("[", stream); - i = get_discrete_bounds (range, &low_bound, &high_bound); + int bound_info = get_discrete_bounds (range, &low_bound, &high_bound); if (low_bound == 0 && high_bound == -1 && TYPE_LENGTH (type) > 0) { /* If we know the size of the set type, we can figure out the maximum value. */ - i = 0; + bound_info = 0; high_bound = TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1; TYPE_HIGH_BOUND (range) = high_bound; } maybe_bad_bstring: - if (i < 0) + if (bound_info < 0) { - fputs_filtered ("", stream); + fputs_styled ("", metadata_style.style (), stream); goto done; } for (i = low_bound; i <= high_bound; i++) { - int element = value_bit_index (type, - valaddr + embedded_offset, i); + int element = value_bit_index (type, valaddr, i); if (element < 0) { i = element; goto maybe_bad_bstring; } - if (is_bitstring) - fprintf_filtered (stream, "%d", element); - else if (element) + if (element) { if (need_comma) fputs_filtered (", ", stream); @@ -526,50 +378,29 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, need_comma = 1; if (i + 1 <= high_bound - && value_bit_index (type, - valaddr + embedded_offset, ++i)) + && value_bit_index (type, valaddr, ++i)) { int j = i; fputs_filtered ("..", stream); while (i + 1 <= high_bound - && value_bit_index (type, - valaddr + embedded_offset, - ++i)) + && value_bit_index (type, valaddr, ++i)) j = i; print_type_scalar (range, j, stream); } } } done: - if (is_bitstring) - fputs_filtered ("'", stream); - else - fputs_filtered ("]", stream); + fputs_filtered ("]", stream); } break; - case TYPE_CODE_VOID: - fprintf_filtered (stream, "void"); - break; - - case TYPE_CODE_ERROR: - fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type)); - break; - - case TYPE_CODE_UNDEF: - /* This happens (without TYPE_FLAG_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_filtered (stream, ""); - break; - default: error (_("Invalid pascal type code %d in symbol table."), - TYPE_CODE (type)); + type->code ()); } - gdb_flush (stream); } + void pascal_value_print (struct value *val, struct ui_file *stream, @@ -586,15 +417,15 @@ pascal_value_print (struct value *val, struct ui_file *stream, Object pascal: if it is a member pointer, we will take care of that when we print it. */ - if (TYPE_CODE (type) == TYPE_CODE_PTR - || TYPE_CODE (type) == TYPE_CODE_REF) + if (type->code () == TYPE_CODE_PTR + || type->code () == TYPE_CODE_REF) { /* Hack: remove (char *) for char strings. Their type is indicated by the quoted string anyway. */ - if (TYPE_CODE (type) == TYPE_CODE_PTR - && TYPE_NAME (type) == NULL - && TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL - && strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0) + if (type->code () == TYPE_CODE_PTR + && type->name () == NULL + && TYPE_TARGET_TYPE (type)->name () != NULL + && strcmp (TYPE_TARGET_TYPE (type)->name (), "char") == 0) { /* Print nothing. */ } @@ -624,10 +455,7 @@ static void pascal_object_print_static_field (struct value *, struct ui_file *, int, const struct value_print_options *); -static void pascal_object_print_value (struct type *, const gdb_byte *, - int, - CORE_ADDR, struct ui_file *, int, - const struct value *, +static void pascal_object_print_value (struct value *, struct ui_file *, int, const struct value_print_options *, struct type **); @@ -641,10 +469,10 @@ const char pascal_vtbl_ptr_name[] = int pascal_object_is_vtbl_ptr_type (struct type *type) { - const char *typename = type_name_no_tag (type); + const char *type_name = type->name (); - return (typename != NULL - && strcmp (typename, pascal_vtbl_ptr_name) == 0); + return (type_name != NULL + && strcmp (type_name, pascal_vtbl_ptr_name) == 0); } /* Return truth value for the assertion that TYPE is of the type @@ -653,15 +481,15 @@ pascal_object_is_vtbl_ptr_type (struct type *type) int pascal_object_is_vtbl_member (struct type *type) { - if (TYPE_CODE (type) == TYPE_CODE_PTR) + if (type->code () == TYPE_CODE_PTR) { type = TYPE_TARGET_TYPE (type); - if (TYPE_CODE (type) == TYPE_CODE_ARRAY) + if (type->code () == TYPE_CODE_ARRAY) { type = TYPE_TARGET_TYPE (type); - if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* If not using + if (type->code () == TYPE_CODE_STRUCT /* If not using thunks. */ - || TYPE_CODE (type) == TYPE_CODE_PTR) /* If using thunks. */ + || type->code () == TYPE_CODE_PTR) /* If using thunks. */ { /* Virtual functions tables are full of pointers to virtual functions. */ @@ -673,47 +501,45 @@ pascal_object_is_vtbl_member (struct type *type) } /* Mutually recursive subroutines of pascal_object_print_value and - c_val_print to print out a structure's fields: + pascal_value_print to print out a structure's fields: pascal_object_print_value_fields and pascal_object_print_value. - TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the - same meanings as in pascal_object_print_value and c_val_print. + VAL, STREAM, RECURSE, and OPTIONS have the same meanings as in + pascal_object_print_value and c_value_print. DONT_PRINT is an array of baseclass types that we should not print, or zero if called from top level. */ -void -pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, - int offset, - CORE_ADDR address, struct ui_file *stream, +static void +pascal_object_print_value_fields (struct value *val, struct ui_file *stream, int recurse, - const struct value *val, const struct value_print_options *options, struct type **dont_print_vb, int dont_print_statmem) { int i, len, n_baseclasses; - char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack); + char *last_dont_print + = (char *) obstack_next_free (&dont_print_statmem_obstack); - CHECK_TYPEDEF (type); + struct type *type = check_typedef (value_type (val)); fprintf_filtered (stream, "{"); - len = TYPE_NFIELDS (type); + len = type->num_fields (); n_baseclasses = TYPE_N_BASECLASSES (type); /* Print out baseclasses such that we don't print duplicates of virtual baseclasses. */ if (n_baseclasses > 0) - pascal_object_print_value (type, valaddr, offset, address, - stream, recurse + 1, val, + pascal_object_print_value (val, stream, recurse + 1, options, dont_print_vb); if (!len && n_baseclasses == 1) - fprintf_filtered (stream, ""); + fprintf_styled (stream, metadata_style.style (), ""); else { struct obstack tmp_obstack = dont_print_statmem_obstack; int fields_seen = 0; + const gdb_byte *valaddr = value_contents_for_printing (val); if (dont_print_statmem == 0) { @@ -727,24 +553,24 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, { /* If requested, skip printing of static fields. */ if (!options->pascal_static_field_print - && field_is_static (&TYPE_FIELD (type, i))) + && field_is_static (&type->field (i))) continue; if (fields_seen) fprintf_filtered (stream, ", "); else if (n_baseclasses > 0) { - if (options->pretty) + if (options->prettyformat) { fprintf_filtered (stream, "\n"); print_spaces_filtered (2 + 2 * recurse, stream); fputs_filtered ("members of ", stream); - fputs_filtered (type_name_no_tag (type), stream); + fputs_filtered (type->name (), stream); fputs_filtered (": ", stream); } } fields_seen = 1; - if (options->pretty) + if (options->prettyformat) { fprintf_filtered (stream, "\n"); print_spaces_filtered (2 + 2 * recurse, stream); @@ -753,38 +579,25 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, { wrap_here (n_spaces (2 + 2 * recurse)); } - if (options->inspect_it) + + annotate_field_begin (TYPE_FIELD_TYPE (type, i)); + + if (field_is_static (&type->field (i))) { - if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR) - fputs_filtered ("\"( ptr \"", stream); - else - fputs_filtered ("\"( nodef \"", stream); - if (field_is_static (&TYPE_FIELD (type, i))) - fputs_filtered ("static ", stream); - fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i), - language_cplus, + fputs_filtered ("static ", stream); + fprintf_symbol_filtered (stream, + TYPE_FIELD_NAME (type, i), + current_language->la_language, DMGL_PARAMS | DMGL_ANSI); - fputs_filtered ("\" \"", stream); - fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i), - language_cplus, - DMGL_PARAMS | DMGL_ANSI); - fputs_filtered ("\") \"", stream); } else - { - annotate_field_begin (TYPE_FIELD_TYPE (type, i)); + fputs_styled (TYPE_FIELD_NAME (type, i), + variable_name_style.style (), stream); + annotate_field_name_end (); + fputs_filtered (" = ", stream); + annotate_field_value (); - if (field_is_static (&TYPE_FIELD (type, i))) - fputs_filtered ("static ", stream); - fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i), - language_cplus, - DMGL_PARAMS | DMGL_ANSI); - annotate_field_name_end (); - fputs_filtered (" = ", stream); - annotate_field_value (); - } - - if (!field_is_static (&TYPE_FIELD (type, i)) + if (!field_is_static (&type->field (i)) && TYPE_FIELD_PACKED (type, i)) { struct value *v; @@ -793,7 +606,8 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, order problems. */ if (TYPE_FIELD_IGNORE (type, i)) { - fputs_filtered ("", stream); + fputs_styled ("", + metadata_style.style (), stream); } else if (value_bits_synthetic_pointer (val, TYPE_FIELD_BITPOS (type, @@ -801,18 +615,14 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, TYPE_FIELD_BITSIZE (type, i))) { - fputs_filtered (_(""), stream); - } - else if (!value_bits_valid (val, TYPE_FIELD_BITPOS (type, i), - TYPE_FIELD_BITSIZE (type, i))) - { - val_print_optimized_out (stream); + fputs_styled (_(""), + metadata_style.style (), stream); } else { struct value_print_options opts = *options; - v = value_field_bitfield (type, i, valaddr, offset, val); + v = value_field_bitfield (type, i, valaddr, 0, val); opts.deref_ref = 0; common_val_print (v, stream, recurse + 1, &opts, @@ -823,18 +633,19 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, { if (TYPE_FIELD_IGNORE (type, i)) { - fputs_filtered ("", stream); + fputs_styled ("", + metadata_style.style (), stream); } - else if (field_is_static (&TYPE_FIELD (type, i))) + else if (field_is_static (&type->field (i))) { /* struct value *v = value_static_field (type, i); v4.17 specific. */ struct value *v; - v = value_field_bitfield (type, i, valaddr, offset, val); + v = value_field_bitfield (type, i, valaddr, 0, val); if (v == NULL) - val_print_optimized_out (stream); + val_print_optimized_out (NULL, stream); else pascal_object_print_static_field (v, stream, recurse + 1, options); @@ -844,14 +655,11 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, struct value_print_options opts = *options; opts.deref_ref = 0; - /* val_print (TYPE_FIELD_TYPE (type, i), - valaddr + TYPE_FIELD_BITPOS (type, i) / 8, - address + TYPE_FIELD_BITPOS (type, i) / 8, 0, - stream, format, 0, recurse + 1, pretty); */ - val_print (TYPE_FIELD_TYPE (type, i), - valaddr, offset + TYPE_FIELD_BITPOS (type, i) / 8, - address, stream, recurse + 1, val, &opts, - current_language); + + struct value *v = value_primitive_field (val, 0, i, + value_type (val)); + common_val_print (v, stream, recurse + 1, &opts, + current_language); } } annotate_field_end (); @@ -865,7 +673,7 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, dont_print_statmem_obstack = tmp_obstack; } - if (options->pretty) + if (options->prettyformat) { fprintf_filtered (stream, "\n"); print_spaces_filtered (2 * recurse, stream); @@ -878,17 +686,15 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, baseclasses. */ static void -pascal_object_print_value (struct type *type, const gdb_byte *valaddr, - int offset, - CORE_ADDR address, struct ui_file *stream, +pascal_object_print_value (struct value *val, struct ui_file *stream, int recurse, - const struct value *val, const struct value_print_options *options, struct type **dont_print_vb) { struct type **last_dont_print = (struct type **) obstack_next_free (&dont_print_vb_obstack); struct obstack tmp_obstack = dont_print_vb_obstack; + struct type *type = check_typedef (value_type (val)); int i, n_baseclasses = TYPE_N_BASECLASSES (type); if (dont_print_vb == 0) @@ -902,12 +708,9 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr, for (i = 0; i < n_baseclasses; i++) { - int boffset = 0; + LONGEST boffset = 0; struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); - const char *basename = type_name_no_tag (baseclass); - const gdb_byte *base_valaddr = NULL; - int thisoffset; - volatile struct gdb_exception ex; + const char *basename = baseclass->name (); int skip = 0; if (BASETYPE_VIA_VIRTUAL (type, i)) @@ -925,42 +728,43 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr, obstack_ptr_grow (&dont_print_vb_obstack, baseclass); } - thisoffset = offset; - - TRY_CATCH (ex, RETURN_MASK_ERROR) + struct value *base_value; + try { - boffset = baseclass_offset (type, i, valaddr, offset, address, val); + base_value = value_primitive_field (val, 0, i, type); } - if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR) - skip = -1; - else if (ex.reason < 0) - skip = 1; - else + catch (const gdb_exception_error &ex) { - skip = 0; + base_value = nullptr; + if (ex.error == NOT_AVAILABLE_ERROR) + skip = -1; + else + skip = 1; + } + if (skip == 0) + { /* The virtual base class pointer might have been clobbered by the user program. Make sure that it still points to a valid memory location. */ if (boffset < 0 || boffset >= TYPE_LENGTH (type)) { - /* FIXME (alloc): not safe is baseclass is really really big. */ - gdb_byte *buf = alloca (TYPE_LENGTH (baseclass)); + CORE_ADDR address= value_address (val); + gdb::byte_vector buf (TYPE_LENGTH (baseclass)); - base_valaddr = buf; - if (target_read_memory (address + boffset, buf, + if (target_read_memory (address + boffset, buf.data (), TYPE_LENGTH (baseclass)) != 0) skip = 1; - address = address + boffset; - thisoffset = 0; + base_value = value_from_contents_and_address (baseclass, + buf.data (), + address + boffset); + baseclass = value_type (base_value); boffset = 0; } - else - base_valaddr = valaddr; } - if (options->pretty) + if (options->prettyformat) { fprintf_filtered (stream, "\n"); print_spaces_filtered (2 * recurse, stream); @@ -977,11 +781,10 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr, else if (skip > 0) val_print_invalid_address (stream); else - pascal_object_print_value_fields (baseclass, base_valaddr, - thisoffset + boffset, address, - stream, recurse, val, options, - (struct type **) obstack_base (&dont_print_vb_obstack), - 0); + pascal_object_print_value_fields + (base_value, stream, recurse, options, + (struct type **) obstack_base (&dont_print_vb_obstack), + 0); fputs_filtered (", ", stream); flush_it: @@ -1017,7 +820,13 @@ pascal_object_print_static_field (struct value *val, struct type *type = value_type (val); struct value_print_options opts; - if (TYPE_CODE (type) == TYPE_CODE_STRUCT) + if (value_entirely_optimized_out (val)) + { + val_print_optimized_out (val, stream); + return; + } + + if (type->code () == TYPE_CODE_STRUCT) { CORE_ADDR *first_dont_print, addr; int i; @@ -1031,9 +840,9 @@ pascal_object_print_static_field (struct value *val, { if (value_address (val) == first_dont_print[i]) { - fputs_filtered ("\ -", - stream); + fputs_styled (_("\ +"), + metadata_style.style (), stream); return; } } @@ -1042,13 +851,9 @@ pascal_object_print_static_field (struct value *val, obstack_grow (&dont_print_statmem_obstack, (char *) &addr, sizeof (CORE_ADDR)); - CHECK_TYPEDEF (type); - pascal_object_print_value_fields (type, - value_contents_for_printing (val), - value_embedded_offset (val), - addr, - stream, recurse, - val, options, NULL, 1); + type = check_typedef (type); + pascal_object_print_value_fields (val, stream, recurse, + options, NULL, 1); return; } @@ -1057,11 +862,9 @@ pascal_object_print_static_field (struct value *val, common_val_print (val, stream, recurse, &opts, current_language); } -/* -Wmissing-prototypes */ -extern initialize_file_ftype _initialize_pascal_valprint; - +void _initialize_pascal_valprint (); void -_initialize_pascal_valprint (void) +_initialize_pascal_valprint () { add_setshow_boolean_cmd ("pascal_static-members", class_support, &user_print_options.pascal_static_field_print, _("\