X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fp-valprint.c;h=05d4c6f821bdc22be54fafb175bf381ef38c7b28;hb=a94e8645ac9603d401346663d3ef81ed736b0353;hp=34decb97f0814644d0a6cbc323c4e1b3949e5190;hpb=490f124f0943a59ca6829a030164f79716600166;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c index 34decb97f0..05d4c6f821 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, 2006, 2007, 2008, 2009, 2010, 2011 - Free Software Foundation, Inc. + Copyright (C) 2000-2013 Free Software Foundation, Inc. This file is part of GDB. @@ -38,19 +37,25 @@ #include "p-lang.h" #include "cp-abi.h" #include "cp-support.h" +#include "exceptions.h" +/* Decorations for Pascal. */ +static const struct generic_val_print_decorations p_decorations = +{ + "", + " + ", + " * I", + "true", + "false", + "void" +}; -/* 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. */ -int +void pascal_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, @@ -66,19 +71,19 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, unsigned eltlen; int length_pos, length_size, string_pos; struct type *char_type; - LONGEST val; CORE_ADDR addr; + int want_space = 0; CHECK_TYPEDEF (type); switch (TYPE_CODE (type)) { case TYPE_CODE_ARRAY: - if (get_array_bounds (type, &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 (options->prettyprint_arrays) + if (options->prettyformat_arrays) { print_spaces_filtered (2 + 2 * recurse, stream); } @@ -133,14 +138,14 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, break; } /* Array of unspecified length: treat like pointer to first elt. */ - addr = address; + addr = address + embedded_offset; goto print_unpacked_pointer; 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)) @@ -151,10 +156,10 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, /* Extract the address, assume that it is unsigned. */ addr = extract_unsigned_integer (valaddr + embedded_offset, TYPE_LENGTH (type), byte_order); - print_address_demangle (gdbarch, addr, stream, demangle); + print_address_demangle (options, gdbarch, addr, stream, demangle); break; } - elttype = check_typedef (TYPE_TARGET_TYPE (type)); + check_typedef (TYPE_TARGET_TYPE (type)); addr = unpack_pointer (type, valaddr + embedded_offset); print_unpacked_pointer: @@ -163,14 +168,14 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, 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); + 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 @@ -183,6 +188,8 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, && (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); } @@ -198,6 +205,8 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, ULONGEST string_length; void *buffer; + if (want_space) + fputs_filtered (" ", stream); buffer = xmalloc (length_size); read_memory (addr + length_pos, buffer, length_size); string_length = extract_unsigned_integer (buffer, length_size, @@ -212,15 +221,20 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, /* Print vtbl's nicely. */ CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset); - struct minimal_symbol *msymbol = + 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 == SYMBOL_VALUE_ADDRESS (msymbol.minsym))) { - fputs_filtered (" <", stream); - fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream); + if (want_space) + fputs_filtered (" ", stream); + fputs_filtered ("<", stream); + fputs_filtered (SYMBOL_PRINT_NAME (msymbol.minsym), stream); fputs_filtered (">", stream); + want_space = 1; } if (vt_address && options->vtblprint) { @@ -228,10 +242,14 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, struct symbol *wsym = (struct symbol *) NULL; struct type *wtype; struct block *block = (struct block *) NULL; - int is_this_fld; + struct field_of_this_result is_this_fld; + + if (want_space) + fputs_filtered (" ", stream); - if (msymbol != NULL) - wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), block, + if (msymbol.minsym != NULL) + wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol.minsym), + block, VAR_DOMAIN, &is_this_fld); if (wsym) @@ -245,7 +263,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); @@ -253,41 +271,23 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, } } - /* 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; + 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 = - 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_val_print (type, valaddr, embedded_offset, address, + stream, recurse, original_value, options, + &p_decorations); break; case TYPE_CODE_UNION: @@ -305,7 +305,7 @@ 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, + (options, gdbarch, extract_unsigned_integer (valaddr + embedded_offset + TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8, @@ -322,7 +322,7 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, len = extract_unsigned_integer (valaddr + embedded_offset + length_pos, length_size, byte_order); - LA_PRINT_STRING (stream, char_type, + LA_PRINT_STRING (stream, char_type, valaddr + embedded_offset + string_pos, len, NULL, 0, options); } @@ -334,143 +334,6 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, } break; - case TYPE_CODE_ENUM: - if (options->format) - { - print_scalar_formatted (valaddr + embedded_offset, type, - 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) - print_scalar_formatted (valaddr + embedded_offset, type, - options, 0, stream); - else - val_print_type_code_flags (type, valaddr + embedded_offset, stream); - break; - - case TYPE_CODE_FUNC: - if (options->format) - { - print_scalar_formatted (valaddr + embedded_offset, type, - 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); - print_scalar_formatted (valaddr + embedded_offset, type, - &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); - print_scalar_formatted (valaddr + embedded_offset, type, - &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); - print_scalar_formatted (valaddr + embedded_offset, type, - &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) - { - print_scalar_formatted (valaddr + embedded_offset, type, - options, 0, stream); - } - else - { - print_floating (valaddr + embedded_offset, type, stream); - } - break; - - case TYPE_CODE_BITSTRING: case TYPE_CODE_SET: elttype = TYPE_INDEX_TYPE (type); CHECK_TYPEDEF (elttype); @@ -485,13 +348,9 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, 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); if (low_bound == 0 && high_bound == -1 && TYPE_LENGTH (type) > 0) @@ -519,9 +378,7 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, 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); @@ -545,37 +402,18 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr, } } 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)); } gdb_flush (stream); - return (0); } -int +void pascal_value_print (struct value *val, struct ui_file *stream, const struct value_print_options *options) { @@ -595,7 +433,7 @@ pascal_value_print (struct value *val, struct ui_file *stream, { /* Hack: remove (char *) for char strings. Their type is indicated by the quoted string anyway. */ - if (TYPE_CODE (type) == TYPE_CODE_PTR + 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) @@ -609,7 +447,7 @@ pascal_value_print (struct value *val, struct ui_file *stream, fprintf_filtered (stream, ") "); } } - return common_val_print (val, stream, 0, &opts, current_language); + common_val_print (val, stream, 0, &opts, current_language); } @@ -645,7 +483,7 @@ const char pascal_vtbl_ptr_name[] = int pascal_object_is_vtbl_ptr_type (struct type *type) { - char *typename = type_name_no_tag (type); + const char *typename = type_name_no_tag (type); return (typename != NULL && strcmp (typename, pascal_vtbl_ptr_name) == 0); @@ -737,7 +575,7 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, 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); @@ -748,7 +586,7 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, } fields_seen = 1; - if (options->pretty) + if (options->prettyformat) { fprintf_filtered (stream, "\n"); print_spaces_filtered (2 + 2 * recurse, stream); @@ -757,36 +595,17 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, { wrap_here (n_spaces (2 + 2 * recurse)); } - if (options->inspect_it) - { - 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, - 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)); - - 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 (); - } + + annotate_field_begin (TYPE_FIELD_TYPE (type, i)); + + 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)) && TYPE_FIELD_PACKED (type, i)) @@ -810,15 +629,13 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, else if (!value_bits_valid (val, TYPE_FIELD_BITPOS (type, i), TYPE_FIELD_BITSIZE (type, i))) { - fputs_filtered (_(""), stream); + 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 + offset, i)); + v = value_field_bitfield (type, i, valaddr, offset, val); opts.deref_ref = 0; common_val_print (v, stream, recurse + 1, &opts, @@ -837,12 +654,10 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr, v4.17 specific. */ struct value *v; - v = value_from_longest - (TYPE_FIELD_TYPE (type, i), - unpack_field_as_long (type, valaddr + offset, 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); @@ -873,7 +688,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); @@ -910,11 +725,13 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr, for (i = 0; i < n_baseclasses; i++) { - int boffset; + int boffset = 0; struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); - char *basename = type_name_no_tag (baseclass); - const gdb_byte *base_valaddr; + const char *basename = type_name_no_tag (baseclass); + const gdb_byte *base_valaddr = NULL; int thisoffset; + volatile struct gdb_exception ex; + int skip = 0; if (BASETYPE_VIA_VIRTUAL (type, i)) { @@ -933,9 +750,44 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr, thisoffset = offset; - boffset = baseclass_offset (type, i, valaddr + offset, address + offset); + TRY_CATCH (ex, RETURN_MASK_ERROR) + { + boffset = baseclass_offset (type, i, valaddr, offset, address, val); + } + if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR) + skip = -1; + else if (ex.reason < 0) + skip = 1; + else + { + 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)) + { + gdb_byte *buf; + struct cleanup *back_to; + + buf = xmalloc (TYPE_LENGTH (baseclass)); + back_to = make_cleanup (xfree, buf); + + base_valaddr = buf; + if (target_read_memory (address + boffset, buf, + TYPE_LENGTH (baseclass)) != 0) + skip = 1; + address = address + boffset; + thisoffset = 0; + boffset = 0; + do_cleanups (back_to); + } + else + base_valaddr = valaddr; + } - if (options->pretty) + if (options->prettyformat) { fprintf_filtered (stream, "\n"); print_spaces_filtered (2 * recurse, stream); @@ -947,28 +799,10 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr, fputs_filtered (basename ? basename : "", stream); 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 - location. */ - - if (boffset != -1 && (boffset < 0 || boffset >= TYPE_LENGTH (type))) - { - /* 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; - - if (boffset == -1) - fprintf_filtered (stream, ""); + if (skip < 0) + val_print_unavailable (stream); + else if (skip > 0) + val_print_invalid_address (stream); else pascal_object_print_value_fields (baseclass, base_valaddr, thisoffset + boffset, address,