X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fp-valprint.c;h=7031a771108986bfc1233d31149205d5e86891fa;hb=1b28d0b3beda72343ea25f135f17746340cae89c;hp=27ae619a14b964b0a5abdca7782a8f34a154e94f;hpb=581594903a0e952e9976f6f41f12968dd51189ee;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c index 27ae619a14..7031a77110 100644 --- a/gdb/p-valprint.c +++ b/gdb/p-valprint.c @@ -1,6 +1,6 @@ /* Support for printing Pascal values for GDB, the GNU debugger. - Copyright (C) 2000, 2001, 2003, 2005, 2006, 2007, 2008, 2009 + Copyright (C) 2000, 2001, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. This file is part of GDB. @@ -40,28 +40,26 @@ #include "cp-support.h" - - -/* Print data of type TYPE located at VALADDR (within GDB), which came from - the inferior at address ADDRESS, onto stdio stream STREAM according to - OPTIONS. The data at VALADDR is in target byte order. - - If the data are a string pointer, returns the number of string characters - printed. */ - +/* See val_print for a description of the various parameters of this + function; they are identical. The semantics of the return value is + also identical to val_print. */ int 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) { + struct gdbarch *gdbarch = get_type_arch (type); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 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; - int char_size; + struct type *char_type; LONGEST val; CORE_ADDR addr; @@ -69,21 +67,22 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, switch (TYPE_CODE (type)) { case TYPE_CODE_ARRAY: - if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0) + 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); - len = TYPE_LENGTH (type) / eltlen; if (options->prettyprint_arrays) { print_spaces_filtered (2 + 2 * recurse, stream); } - /* For an array of chars, print with string syntax. */ - if ((eltlen == 1 || eltlen == 2 || eltlen == 4) - && ((TYPE_CODE (elttype) == TYPE_CODE_INT) - || ((current_language->la_language == language_pascal) - && (TYPE_CODE (elttype) == TYPE_CODE_CHAR))) - && (options->format == 0 || options->format == 's')) + /* 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. */ @@ -91,17 +90,19 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, { unsigned int temp_len; - /* Look for a NULL char. */ + /* Look for a NULL char. */ for (temp_len = 0; extract_unsigned_integer (valaddr + embedded_offset + - temp_len * eltlen, eltlen) + temp_len * eltlen, eltlen, + byte_order) && temp_len < len && temp_len < options->print_max; temp_len++); len = temp_len; } - LA_PRINT_STRING (stream, valaddr + embedded_offset, len, - eltlen, 0, options); + LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type), + valaddr + embedded_offset, len, NULL, 0, + options); i = len; } else @@ -118,8 +119,9 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, { i = 0; } - val_print_array_elements (type, valaddr + embedded_offset, address, stream, - recurse, options, i); + val_print_array_elements (type, valaddr, embedded_offset, + address, stream, recurse, + original_value, options, i); fprintf_filtered (stream, "}"); } break; @@ -131,131 +133,136 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, case TYPE_CODE_PTR: if (options->format && options->format != 's') { - print_scalar_formatted (valaddr + embedded_offset, type, - options, 0, stream); + val_print_scalar_formatted (type, valaddr, embedded_offset, + original_value, options, 0, stream); break; } if (options->vtblprint && pascal_object_is_vtbl_ptr_type (type)) { /* Print the unmangled name if desired. */ /* Print vtable entry - we only get here if we ARE using - -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */ + -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */ /* Extract the address, assume that it is unsigned. */ - print_address_demangle (extract_unsigned_integer (valaddr + embedded_offset, TYPE_LENGTH (type)), - stream, demangle); + addr = extract_unsigned_integer (valaddr + embedded_offset, + TYPE_LENGTH (type), byte_order); + print_address_demangle (gdbarch, addr, stream, demangle); break; } elttype = check_typedef (TYPE_TARGET_TYPE (type)); - { - addr = unpack_pointer (type, valaddr + embedded_offset); - print_unpacked_pointer: - elttype = check_typedef (TYPE_TARGET_TYPE (type)); - if (TYPE_CODE (elttype) == TYPE_CODE_FUNC) - { - /* Try to print what function it points to. */ - print_address_demangle (addr, stream, demangle); - /* Return value is irrelevant except for string pointers. */ - return (0); - } + addr = unpack_pointer (type, valaddr + embedded_offset); + print_unpacked_pointer: + elttype = check_typedef (TYPE_TARGET_TYPE (type)); - if (options->addressprint && options->format != 's') - { - fputs_filtered (paddress (addr), stream); - } + if (TYPE_CODE (elttype) == TYPE_CODE_FUNC) + { + /* Try to print what function it points to. */ + print_address_demangle (gdbarch, addr, stream, demangle); + /* Return value is irrelevant except for string pointers. */ + return (0); + } - /* 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)) - && (options->format == 0 || options->format == 's') - && addr != 0) - { - /* no wide string yet */ - i = val_print_string (addr, -1, TYPE_LENGTH (elttype), stream, - options); - } - /* also for pointers to pascal strings */ - /* Note: this is Free Pascal specific: - as GDB does not recognize stabs pascal strings - Pascal strings are mapped to records - with lowercase names PM */ - if (is_pascal_string_type (elttype, &length_pos, &length_size, - &string_pos, &char_size, NULL) - && addr != 0) + if (options->addressprint && options->format != 's') + { + fputs_filtered (paddress (gdbarch, addr), stream); + } + + /* 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)) + && (options->format == 0 || options->format == 's') + && addr != 0) + { + /* No wide string yet. */ + i = val_print_string (elttype, NULL, addr, -1, stream, options); + } + /* Also for pointers to pascal strings. */ + /* Note: this is Free Pascal specific: + as GDB does not recognize stabs pascal strings + Pascal strings are mapped to records + with lowercase names PM. */ + if (is_pascal_string_type (elttype, &length_pos, &length_size, + &string_pos, &char_type, NULL) + && addr != 0) + { + ULONGEST string_length; + void *buffer; + + buffer = xmalloc (length_size); + read_memory (addr + length_pos, buffer, length_size); + string_length = extract_unsigned_integer (buffer, length_size, + byte_order); + xfree (buffer); + i = val_print_string (char_type, NULL, + addr + string_pos, string_length, + stream, options); + } + 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 = + lookup_minimal_symbol_by_pc (vt_address); + + if ((msymbol != NULL) + && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol))) { - ULONGEST string_length; - void *buffer; - buffer = xmalloc (length_size); - read_memory (addr + length_pos, buffer, length_size); - string_length = extract_unsigned_integer (buffer, length_size); - xfree (buffer); - i = val_print_string (addr + string_pos, string_length, char_size, stream, options); + fputs_filtered (" <", stream); + fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream); + fputs_filtered (">", stream); } - else if (pascal_object_is_vtbl_member (type)) + if (vt_address && options->vtblprint) { - /* print vtbl's nicely */ - CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset); + struct value *vt_val; + struct symbol *wsym = (struct symbol *) 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); - struct minimal_symbol *msymbol = - lookup_minimal_symbol_by_pc (vt_address); - if ((msymbol != NULL) - && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol))) + if (wsym) { - fputs_filtered (" <", stream); - fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream); - fputs_filtered (">", stream); + wtype = SYMBOL_TYPE (wsym); } - if (vt_address && options->vtblprint) + else { - struct value *vt_val; - struct symbol *wsym = (struct symbol *) 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 (wsym) - { - wtype = SYMBOL_TYPE (wsym); - } - else - { - wtype = TYPE_TARGET_TYPE (type); - } - vt_val = value_at (wtype, vt_address); - common_val_print (vt_val, stream, recurse + 1, options, - current_language); - if (options->pretty) - { - fprintf_filtered (stream, "\n"); - print_spaces_filtered (2 + 2 * recurse, stream); - } + wtype = TYPE_TARGET_TYPE (type); + } + vt_val = value_at (wtype, vt_address); + common_val_print (vt_val, stream, recurse + 1, options, + current_language); + if (options->pretty) + { + fprintf_filtered (stream, "\n"); + print_spaces_filtered (2 + 2 * recurse, stream); } } - - /* Return number of characters printed, including the terminating - '\0' if we reached the end. val_print_string takes care including - the terminating '\0' if necessary. */ - return i; } + + /* Return number of characters printed, including the terminating + '\0' if we reached the end. val_print_string takes care including + the terminating '\0' if necessary. */ + return i; + break; 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, "@"); - /* Extract the address, assume that it is unsigned. */ - fputs_filtered (paddress ( - extract_unsigned_integer (valaddr + embedded_offset, - gdbarch_ptr_bit (current_gdbarch) / HOST_CHAR_BIT)), stream); + fputs_filtered (paddress (gdbarch, addr), stream); if (options->deref_ref) fputs_filtered (": ", stream); } @@ -265,9 +272,10 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) { struct value *deref_val = - value_at - (TYPE_TARGET_TYPE (type), - unpack_pointer (type, valaddr + embedded_offset)); + value_at + (TYPE_TARGET_TYPE (type), + unpack_pointer (type, valaddr + embedded_offset)); + common_val_print (deref_val, stream, recurse + 1, options, current_language); } @@ -288,32 +296,43 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, { /* Print the unmangled name if desired. */ /* Print vtable entry - we only get here if NOT using - -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */ + -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */ /* Extract the address, assume that it is unsigned. */ print_address_demangle - (extract_unsigned_integer (valaddr + embedded_offset + TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8, - TYPE_LENGTH (TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET))), + (gdbarch, + extract_unsigned_integer (valaddr + embedded_offset + + TYPE_FIELD_BITPOS (type, + VTBL_FNADDR_OFFSET) / 8, + TYPE_LENGTH (TYPE_FIELD_TYPE (type, + VTBL_FNADDR_OFFSET)), + byte_order), stream, demangle); } else { if (is_pascal_string_type (type, &length_pos, &length_size, - &string_pos, &char_size, NULL)) + &string_pos, &char_type, NULL)) { - len = extract_unsigned_integer (valaddr + embedded_offset + length_pos, length_size); - LA_PRINT_STRING (stream, valaddr + embedded_offset + string_pos, len, char_size, 0, options); + 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, NULL, 0, options); } else - pascal_object_print_value_fields (type, valaddr + embedded_offset, address, stream, - recurse, options, NULL, 0); + 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) { - print_scalar_formatted (valaddr + embedded_offset, type, - options, 0, stream); + val_print_scalar_formatted (type, valaddr, embedded_offset, + original_value, options, 0, stream); break; } len = TYPE_NFIELDS (type); @@ -338,8 +357,8 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, case TYPE_CODE_FLAGS: if (options->format) - print_scalar_formatted (valaddr + embedded_offset, type, - options, 0, stream); + 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; @@ -347,8 +366,8 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, case TYPE_CODE_FUNC: if (options->format) { - print_scalar_formatted (valaddr + embedded_offset, type, - options, 0, stream); + 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 @@ -357,17 +376,18 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, type_print (type, "", stream, -1); fprintf_filtered (stream, "} "); /* Try to print what function it points to, and its address. */ - print_address_demangle (address, stream, demangle); + 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); - print_scalar_formatted (valaddr + embedded_offset, type, - &opts, 0, stream); + val_print_scalar_formatted (type, valaddr, embedded_offset, + original_value, &opts, 0, stream); } else { @@ -398,10 +418,11 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, if (options->format || options->output_format) { struct value_print_options opts = *options; + opts.format = (options->format ? options->format : options->output_format); - print_scalar_formatted (valaddr + embedded_offset, type, - &opts, 0, stream); + val_print_scalar_formatted (type, valaddr, embedded_offset, + original_value, &opts, 0, stream); } else { @@ -413,10 +434,11 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, if (options->format || options->output_format) { struct value_print_options opts = *options; + opts.format = (options->format ? options->format : options->output_format); - print_scalar_formatted (valaddr + embedded_offset, type, - &opts, 0, stream); + val_print_scalar_formatted (type, valaddr, embedded_offset, + original_value, &opts, 0, stream); } else { @@ -426,15 +448,15 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, else fprintf_filtered (stream, "%d", (int) val); fputs_filtered (" ", stream); - LA_PRINT_CHAR ((unsigned char) val, stream); + LA_PRINT_CHAR ((unsigned char) val, type, stream); } break; case TYPE_CODE_FLT: if (options->format) { - print_scalar_formatted (valaddr + embedded_offset, type, - options, 0, stream); + val_print_scalar_formatted (type, valaddr, embedded_offset, + original_value, options, 0, stream); } else { @@ -466,6 +488,14 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, fputs_filtered ("[", stream); i = 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; + high_bound = TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1; + TYPE_HIGH_BOUND (range) = high_bound; + } maybe_bad_bstring: if (i < 0) { @@ -475,7 +505,9 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, 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 + embedded_offset, i); + if (element < 0) { i = element; @@ -490,12 +522,17 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, print_type_scalar (range, i, stream); need_comma = 1; - if (i + 1 <= high_bound && value_bit_index (type, valaddr + embedded_offset, ++i)) + if (i + 1 <= high_bound + && value_bit_index (type, + valaddr + embedded_offset, ++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 + embedded_offset, + ++i)) j = i; print_type_scalar (range, j, stream); } @@ -514,7 +551,7 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, break; case TYPE_CODE_ERROR: - fprintf_filtered (stream, ""); + fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type)); break; case TYPE_CODE_UNDEF: @@ -525,7 +562,8 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, break; default: - error (_("Invalid pascal type code %d in symbol table."), TYPE_CODE (type)); + error (_("Invalid pascal type code %d in symbol table."), + TYPE_CODE (type)); } gdb_flush (stream); return (0); @@ -536,6 +574,9 @@ pascal_value_print (struct value *val, struct ui_file *stream, const struct value_print_options *options) { struct type *type = value_type (val); + struct value_print_options opts = *options; + + opts.deref_ref = 1; /* If it is a pointer, indicate what it points to. @@ -547,13 +588,13 @@ pascal_value_print (struct value *val, struct ui_file *stream, || TYPE_CODE (type) == TYPE_CODE_REF) { /* Hack: remove (char *) for char strings. Their - type is indicated by the quoted string anyway. */ + 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) { - /* Print nothing */ + /* Print nothing. */ } else { @@ -562,7 +603,7 @@ pascal_value_print (struct value *val, struct ui_file *stream, fprintf_filtered (stream, ") "); } } - return common_val_print (val, stream, 0, options, current_language); + return common_val_print (val, stream, 0, &opts, current_language); } @@ -582,7 +623,9 @@ static void pascal_object_print_static_field (struct value *, 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 *, const struct value_print_options *, struct type **); @@ -614,11 +657,12 @@ pascal_object_is_vtbl_member (struct type *type) if (TYPE_CODE (type) == TYPE_CODE_ARRAY) { type = TYPE_TARGET_TYPE (type); - if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */ - || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */ + if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* If not using + thunks. */ + || TYPE_CODE (type) == TYPE_CODE_PTR) /* If using thunks. */ { /* Virtual functions tables are full of pointers - to virtual functions. */ + to virtual functions. */ return pascal_object_is_vtbl_ptr_type (type); } } @@ -638,8 +682,10 @@ pascal_object_is_vtbl_member (struct type *type) void pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, + int offset, CORE_ADDR address, 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) @@ -656,8 +702,9 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, /* Print out baseclasses such that we don't print duplicates of virtual baseclasses. */ if (n_baseclasses > 0) - pascal_object_print_value (type, valaddr, address, stream, - recurse + 1, options, dont_print_vb); + pascal_object_print_value (type, valaddr, offset, address, + stream, recurse + 1, val, + options, dont_print_vb); if (!len && n_baseclasses == 1) fprintf_filtered (stream, ""); @@ -746,11 +793,24 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, { fputs_filtered ("", stream); } + else if (value_bits_synthetic_pointer (val, + TYPE_FIELD_BITPOS (type, + i), + 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); + } else { struct value_print_options opts = *options; - v = value_from_longest (TYPE_FIELD_TYPE (type, i), - unpack_field_as_long (type, valaddr, i)); + + v = value_field_bitfield (type, i, valaddr, offset, val); opts.deref_ref = 0; common_val_print (v, stream, recurse + 1, &opts, @@ -765,13 +825,14 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, } else if (field_is_static (&TYPE_FIELD (type, i))) { - /* struct value *v = value_static_field (type, i); v4.17 specific */ + /* struct value *v = value_static_field (type, i); + v4.17 specific. */ struct value *v; - v = value_from_longest (TYPE_FIELD_TYPE (type, i), - unpack_field_as_long (type, valaddr, i)); + + v = value_field_bitfield (type, i, valaddr, offset, val); if (v == NULL) - fputs_filtered ("", stream); + val_print_optimized_out (stream); else pascal_object_print_static_field (v, stream, recurse + 1, options); @@ -779,15 +840,15 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, else { 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, TYPE_FIELD_BITPOS (type, i) / 8, - address + TYPE_FIELD_BITPOS (type, i) / 8, - stream, recurse + 1, &opts, + valaddr, offset + TYPE_FIELD_BITPOS (type, i) / 8, + address, stream, recurse + 1, val, &opts, current_language); } } @@ -816,13 +877,15 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, static void pascal_object_print_value (struct type *type, const gdb_byte *valaddr, + int offset, CORE_ADDR address, 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 type **) obstack_next_free (&dont_print_vb_obstack); struct obstack tmp_obstack = dont_print_vb_obstack; int i, n_baseclasses = TYPE_N_BASECLASSES (type); @@ -841,14 +904,15 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr, struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); char *basename = type_name_no_tag (baseclass); const gdb_byte *base_valaddr; + int thisoffset; if (BASETYPE_VIA_VIRTUAL (type, i)) { struct type **first_dont_print - = (struct type **) obstack_base (&dont_print_vb_obstack); + = (struct type **) obstack_base (&dont_print_vb_obstack); int j = (struct type **) obstack_next_free (&dont_print_vb_obstack) - - first_dont_print; + - first_dont_print; while (--j >= 0) if (baseclass == first_dont_print[j]) @@ -857,7 +921,9 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr, obstack_ptr_grow (&dont_print_vb_obstack, baseclass); } - boffset = baseclass_offset (type, i, valaddr, address); + thisoffset = offset; + + boffset = baseclass_offset (type, i, valaddr + offset, address + offset); if (options->pretty) { @@ -872,26 +938,31 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr, fputs_filtered ("> = ", stream); /* The virtual base class pointer might have been clobbered by the - user program. Make sure that it still points to a valid memory + user program. Make sure that it still points to a valid memory location. */ if (boffset != -1 && (boffset < 0 || boffset >= TYPE_LENGTH (type))) { - /* FIXME (alloc): not safe is baseclass is really really big. */ + /* FIXME (alloc): not safe is baseclass is really really big. */ gdb_byte *buf = alloca (TYPE_LENGTH (baseclass)); + base_valaddr = buf; if (target_read_memory (address + boffset, buf, TYPE_LENGTH (baseclass)) != 0) boffset = -1; + address = address + boffset; + thisoffset = 0; + boffset = 0; } else - base_valaddr = valaddr + boffset; + base_valaddr = valaddr; if (boffset == -1) fprintf_filtered (stream, ""); else - pascal_object_print_value_fields (baseclass, base_valaddr, address + boffset, - stream, recurse, options, + pascal_object_print_value_fields (baseclass, base_valaddr, + thisoffset + boffset, address, + stream, recurse, val, options, (struct type **) obstack_base (&dont_print_vb_obstack), 0); fputs_filtered (", ", stream); @@ -931,7 +1002,7 @@ pascal_object_print_static_field (struct value *val, if (TYPE_CODE (type) == TYPE_CODE_STRUCT) { - CORE_ADDR *first_dont_print; + CORE_ADDR *first_dont_print, addr; int i; first_dont_print @@ -941,20 +1012,26 @@ pascal_object_print_static_field (struct value *val, while (--i >= 0) { - if (VALUE_ADDRESS (val) == first_dont_print[i]) + if (value_address (val) == first_dont_print[i]) { - fputs_filtered ("", + fputs_filtered ("\ +", stream); return; } } - obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val), + addr = value_address (val); + obstack_grow (&dont_print_statmem_obstack, (char *) &addr, sizeof (CORE_ADDR)); CHECK_TYPEDEF (type); - pascal_object_print_value_fields (type, value_contents (val), VALUE_ADDRESS (val), - stream, recurse, options, NULL, 1); + pascal_object_print_value_fields (type, + value_contents_for_printing (val), + value_embedded_offset (val), + addr, + stream, recurse, + val, options, NULL, 1); return; } @@ -963,7 +1040,8 @@ pascal_object_print_static_field (struct value *val, common_val_print (val, stream, recurse, &opts, current_language); } -extern initialize_file_ftype _initialize_pascal_valprint; /* -Wmissing-prototypes */ +/* -Wmissing-prototypes */ +extern initialize_file_ftype _initialize_pascal_valprint; void _initialize_pascal_valprint (void)