X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fc-valprint.c;h=ec4b3cf862db42cc0383111f7965741c17c01b44;hb=2f09097b734af8840d2141a26a53b9c67e67fcf2;hp=ee98fc46e3f5dcb1b36aed1b07c8c512b39fc2a5;hpb=0568ccb0acb963d00f5bc283b7389d2b397c6364;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c index ee98fc46e3..ec4b3cf862 100644 --- a/gdb/c-valprint.c +++ b/gdb/c-valprint.c @@ -1,22 +1,23 @@ /* Support for printing C values for GDB, the GNU debugger. - Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994 - Free Software Foundation, Inc. + Copyright 1986, 1988, 1989, 1991-1997, 2000 + Free Software Foundation, Inc. -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ #include "defs.h" #include "symtab.h" @@ -26,44 +27,9 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "demangle.h" #include "valprint.h" #include "language.h" - -/* BEGIN-FIXME */ - -extern int vtblprint; /* Controls printing of vtbl's */ - -extern void -cp_print_class_member PARAMS ((char *, struct type *, GDB_FILE *, char *)); - -extern void -cp_print_class_method PARAMS ((char *, struct type *, GDB_FILE *)); - -extern void -cp_print_value_fields PARAMS ((struct type *, char *, GDB_FILE *, int, int, - enum val_prettyprint, struct type **)); - -extern int -cp_is_vtbl_ptr_type PARAMS ((struct type *)); - -extern int -cp_is_vtbl_member PARAMS ((struct type *)); - -/* END-FIXME */ - - -/* BEGIN-FIXME: Hooks into c-typeprint.c */ - -extern void -c_type_print_varspec_prefix PARAMS ((struct type *, GDB_FILE *, int, int)); - -extern void -cp_type_print_method_args PARAMS ((struct type **, char *, char *, int, - GDB_FILE *)); -/* END-FIXME */ - - -extern struct obstack dont_print_obstack; - +#include "c-lang.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 FORMAT (a letter or 0 for natural format). The data at VALADDR is in @@ -78,30 +44,32 @@ extern struct obstack dont_print_obstack; The PRETTY parameter controls prettyprinting. */ int -c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, +c_val_print (type, valaddr, embedded_offset, address, stream, format, deref_ref, recurse, pretty) struct type *type; char *valaddr; + int embedded_offset; CORE_ADDR address; - GDB_FILE *stream; + struct ui_file *stream; int format; int deref_ref; int recurse; enum val_prettyprint pretty; { - register unsigned int i = 0; /* Number of characters printed */ + register unsigned int i = 0; /* Number of characters printed */ unsigned len; struct type *elttype; unsigned eltlen; LONGEST val; CORE_ADDR addr; + CHECK_TYPEDEF (type); switch (TYPE_CODE (type)) { case TYPE_CODE_ARRAY: + elttype = check_typedef (TYPE_TARGET_TYPE (type)); if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0) { - elttype = TYPE_TARGET_TYPE (type); eltlen = TYPE_LENGTH (elttype); len = TYPE_LENGTH (type) / eltlen; if (prettyprint_arrays) @@ -116,27 +84,27 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, && (format == 0 || format == 's')) { /* If requested, look for the first null char and only print - elements up to it. */ + elements up to it. */ if (stop_print_at_null) { - int temp_len; - + unsigned int temp_len; + /* Look for a NULL char. */ for (temp_len = 0; - valaddr[temp_len] + (valaddr + embedded_offset)[temp_len] && temp_len < len && temp_len < print_max; temp_len++); len = temp_len; } - - LA_PRINT_STRING (stream, valaddr, len, 0); + + LA_PRINT_STRING (stream, valaddr + embedded_offset, len, eltlen, 0); 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. */ + entry specially, and the rest of the members normally. */ if (cp_is_vtbl_ptr_type (elttype)) { i = 1; @@ -146,8 +114,8 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, { i = 0; } - val_print_array_elements (type, valaddr, address, stream, - format, deref_ref, recurse, pretty, i); + val_print_array_elements (type, valaddr + embedded_offset, address, stream, + format, deref_ref, recurse, pretty, i); fprintf_filtered (stream, "}"); } break; @@ -159,33 +127,34 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, case TYPE_CODE_PTR: if (format && format != 's') { - print_scalar_formatted (valaddr, type, format, 0, stream); + print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream); break; } - if (vtblprint && cp_is_vtbl_ptr_type(type)) + if (vtblprint && cp_is_vtbl_ptr_type (type)) { - /* Print the unmangled name if desired. */ + /* 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.) */ - print_address_demangle(extract_address (valaddr, TYPE_LENGTH (type)), - stream, demangle); + print_address_demangle (extract_address (valaddr + embedded_offset, TYPE_LENGTH (type)), + stream, demangle); break; } - if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD) + elttype = check_typedef (TYPE_TARGET_TYPE (type)); + if (TYPE_CODE (elttype) == TYPE_CODE_METHOD) { - cp_print_class_method (valaddr, type, stream); + cp_print_class_method (valaddr + embedded_offset, type, stream); } - else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_MEMBER) + else if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER) { - cp_print_class_member (valaddr, + cp_print_class_member (valaddr + embedded_offset, TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)), stream, "&"); } else { - addr = unpack_pointer (type, valaddr); + addr = unpack_pointer (type, valaddr + embedded_offset); print_unpacked_pointer: - elttype = TYPE_TARGET_TYPE (type); + elttype = check_typedef (TYPE_TARGET_TYPE (type)); if (TYPE_CODE (elttype) == TYPE_CODE_FUNC) { @@ -202,20 +171,22 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, /* For a pointer to char or unsigned char, also print the string pointed to, unless pointer is null. */ + /* FIXME: need to handle wchar_t here... */ + if (TYPE_LENGTH (elttype) == 1 && TYPE_CODE (elttype) == TYPE_CODE_INT && (format == 0 || format == 's') && addr != 0) { - i = val_print_string (addr, 0, stream); + i = val_print_string (addr, -1, TYPE_LENGTH (elttype), stream); } - else if (cp_is_vtbl_member(type)) - { + else if (cp_is_vtbl_member (type)) + { /* print vtbl's nicely */ - CORE_ADDR vt_address = unpack_pointer (type, valaddr); + CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset); struct minimal_symbol *msymbol = - lookup_minimal_symbol_by_pc (vt_address); + lookup_minimal_symbol_by_pc (vt_address); if ((msymbol != NULL) && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol))) { @@ -224,28 +195,28 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, fputs_filtered (">", stream); } if (vt_address && vtblprint) - { + { value_ptr vt_val; - struct symbol *wsym = (struct symbol *)NULL; - struct type *wtype; + struct symbol *wsym = (struct symbol *) NULL; + struct type *wtype; struct symtab *s; - struct block *block = (struct block *)NULL; + struct block *block = (struct block *) NULL; int is_this_fld; if (msymbol != NULL) - wsym = lookup_symbol (SYMBOL_NAME(msymbol), block, - VAR_NAMESPACE, &is_this_fld, &s); - + wsym = lookup_symbol (SYMBOL_NAME (msymbol), block, + VAR_NAMESPACE, &is_this_fld, &s); + if (wsym) { - wtype = SYMBOL_TYPE(wsym); + wtype = SYMBOL_TYPE (wsym); } else { - wtype = TYPE_TARGET_TYPE(type); + wtype = TYPE_TARGET_TYPE (type); } - vt_val = value_at (wtype, vt_address); - val_print (VALUE_TYPE (vt_val), VALUE_CONTENTS (vt_val), + vt_val = value_at (wtype, vt_address, NULL); + val_print (VALUE_TYPE (vt_val), VALUE_CONTENTS (vt_val), 0, VALUE_ADDRESS (vt_val), stream, format, deref_ref, recurse + 1, pretty); if (pretty) @@ -253,8 +224,8 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, 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 @@ -268,36 +239,43 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, break; case TYPE_CODE_REF: - if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_MEMBER) - { - cp_print_class_member (valaddr, - TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)), + elttype = check_typedef (TYPE_TARGET_TYPE (type)); + if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER) + { + cp_print_class_member (valaddr + embedded_offset, + TYPE_DOMAIN_TYPE (elttype), stream, ""); break; } if (addressprint) - { + { fprintf_filtered (stream, "@"); print_address_numeric - (extract_address (valaddr, + (extract_address (valaddr + embedded_offset, TARGET_PTR_BIT / HOST_CHAR_BIT), 1, stream); if (deref_ref) fputs_filtered (": ", stream); - } + } /* De-reference the reference. */ if (deref_ref) { - if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF) + if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) { value_ptr deref_val = - value_at - (TYPE_TARGET_TYPE (type), - unpack_pointer (lookup_pointer_type (builtin_type_void), - valaddr)); + value_at + (TYPE_TARGET_TYPE (type), + unpack_pointer (lookup_pointer_type (builtin_type_void), + valaddr + embedded_offset), + NULL); val_print (VALUE_TYPE (deref_val), VALUE_CONTENTS (deref_val), - VALUE_ADDRESS (deref_val), stream, format, - deref_ref, recurse + 1, pretty); + 0, + VALUE_ADDRESS (deref_val), + stream, + format, + deref_ref, + recurse, + pretty); } else fputs_filtered ("???", stream); @@ -312,28 +290,30 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, } /* Fall through. */ case TYPE_CODE_STRUCT: - if (vtblprint && cp_is_vtbl_ptr_type(type)) + if (vtblprint && cp_is_vtbl_ptr_type (type)) { - /* Print the unmangled name if desired. */ + /* Print the unmangled name if desired. */ /* Print vtable entry - we only get here if NOT using -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */ - print_address_demangle(*((int *) (valaddr + /* FIXME bytesex */ - TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8)), - stream, demangle); - break; + print_address_demangle (extract_address ( + valaddr + embedded_offset + + TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8, + TYPE_LENGTH (TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET))), + stream, demangle); } - cp_print_value_fields (type, valaddr, stream, format, recurse, pretty, - 0); + else + cp_print_value_fields (type, type, valaddr, embedded_offset, address, stream, format, + recurse, pretty, NULL, 0); break; case TYPE_CODE_ENUM: if (format) { - print_scalar_formatted (valaddr, type, format, 0, stream); + print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream); break; } len = TYPE_NFIELDS (type); - val = unpack_long (type, valaddr); + val = unpack_long (type, valaddr + embedded_offset); for (i = 0; i < len; i++) { QUIT; @@ -355,11 +335,11 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, case TYPE_CODE_FUNC: if (format) { - print_scalar_formatted (valaddr, type, format, 0, stream); + print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream); break; } /* FIXME, we should consider, at least for ANSI C language, eliminating - the distinction made between FUNCs and POINTERs to FUNCs. */ + the distinction made between FUNCs and POINTERs to FUNCs. */ fprintf_filtered (stream, "{"); type_print (type, "", stream, -1); fprintf_filtered (stream, "} "); @@ -368,28 +348,40 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, break; case TYPE_CODE_BOOL: - /* Do something at least vaguely reasonable, for example if the - language is set wrong. */ + format = format ? format : output_format; + if (format) + print_scalar_formatted (valaddr + embedded_offset, type, format, 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 + print_longest (stream, 'd', 0, 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. */ + 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). */ + print with the target type, though, because the size of our type + and the target type might differ). */ /* FALLTHROUGH */ case TYPE_CODE_INT: format = format ? format : output_format; if (format) { - print_scalar_formatted (valaddr, type, format, 0, stream); + print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream); } else { - val_print_type_code_int (type, valaddr, stream); + val_print_type_code_int (type, valaddr + embedded_offset, stream); /* C and C++ has no single byte int type, char is used instead. Since we don't know whether the value is really intended to be used as an integer or a character, print the character @@ -397,7 +389,7 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, if (TYPE_LENGTH (type) == 1) { fputs_filtered (" ", stream); - LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr), + LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr + embedded_offset), stream); } } @@ -407,28 +399,35 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, format = format ? format : output_format; if (format) { - print_scalar_formatted (valaddr, type, format, 0, stream); + print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream); } else { - fprintf_filtered (stream, TYPE_UNSIGNED (type) ? "%u" : "%d", - unpack_long (type, valaddr)); + 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) unpack_long (type, valaddr), stream); + LA_PRINT_CHAR ((unsigned char) val, stream); } break; case TYPE_CODE_FLT: if (format) { - print_scalar_formatted (valaddr, type, format, 0, stream); + print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream); } else { - print_floating (valaddr, type, stream); + print_floating (valaddr + embedded_offset, type, stream); } break; + case TYPE_CODE_METHOD: + cp_print_class_method (valaddr + embedded_offset, lookup_pointer_type (type), stream); + break; + case TYPE_CODE_VOID: fprintf_filtered (stream, "void"); break; @@ -439,8 +438,8 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, 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. */ + 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; @@ -454,60 +453,107 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, int c_value_print (val, stream, format, pretty) value_ptr val; - GDB_FILE *stream; + struct ui_file *stream; int format; enum val_prettyprint pretty; { - /* A "repeated" value really contains several values in a row. - They are made by the @ operator. - Print such values as if they were arrays. */ + struct type *type = VALUE_TYPE (val); + struct type *real_type; + int full, top, using_enc; + + /* If it is a pointer, indicate what it points to. - if (VALUE_REPEATED (val)) + Print type also if it is a reference. + + C++: 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) { - register unsigned int n = VALUE_REPETITIONS (val); - register unsigned int typelen = TYPE_LENGTH (VALUE_TYPE (val)); - fprintf_filtered (stream, "{"); - /* Print arrays of characters using string syntax. */ - if (typelen == 1 && TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT - && format == 0) - LA_PRINT_STRING (stream, VALUE_CONTENTS (val), n, 0); - else + /* 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 && + STREQ (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char")) { - value_print_array_elements (val, stream, format, pretty); + /* Print nothing */ } - fprintf_filtered (stream, "}"); - return (n * typelen); - } - else - { - struct type *type = VALUE_TYPE (val); - - /* If it is a pointer, indicate what it points to. - - Print type also if it is a reference. - - C++: 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) + else if (objectprint && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS)) { - /* Hack: remove (char *) for char strings. Their - type is indicated by the quoted string anyway. */ - if (TYPE_CODE (type) == TYPE_CODE_PTR && - TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof(char) && - TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_INT && - !TYPE_UNSIGNED (TYPE_TARGET_TYPE (type))) + + if (TYPE_CODE(type) == TYPE_CODE_REF) { - /* Print nothing */ + /* Copy value, change to pointer, so we don't get an + * error about a non-pointer type in value_rtti_target_type + */ + value_ptr temparg; + temparg=value_copy(val); + VALUE_TYPE (temparg) = lookup_pointer_type(TYPE_TARGET_TYPE(type)); + val=temparg; } - else + /* Pointer to class, check real type of object */ + fprintf_filtered (stream, "("); + real_type = value_rtti_target_type (val, &full, &top, &using_enc); + if (real_type) { - fprintf_filtered (stream, "("); - type_print (type, "", stream, -1); - fprintf_filtered (stream, ") "); - } + /* RTTI entry found */ + if (TYPE_CODE (type) == TYPE_CODE_PTR) + { + /* create a pointer type pointing to the real type */ + type = lookup_pointer_type (real_type); + } + else + { + /* create a reference type referencing the real type */ + type = lookup_reference_type (real_type); + } + /* JYG: Need to adjust pointer value. */ + val->aligner.contents[0] -= top; + + /* Note: When we look up RTTI entries, we don't get any + information on const or volatile attributes */ + } + type_print (type, "", stream, -1); + fprintf_filtered (stream, ") "); + } + else + { + /* normal case */ + fprintf_filtered (stream, "("); + type_print (type, "", stream, -1); + fprintf_filtered (stream, ") "); } - return (val_print (type, VALUE_CONTENTS (val), - VALUE_ADDRESS (val), stream, format, 1, 0, pretty)); } + if (objectprint && (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_CLASS)) + { + /* Attempt to determine real type of object */ + real_type = value_rtti_type (val, &full, &top, &using_enc); + if (real_type) + { + /* We have RTTI information, so use it */ + val = value_full_object (val, real_type, full, top, using_enc); + fprintf_filtered (stream, "(%s%s) ", + TYPE_NAME (real_type), + full ? "" : " [incomplete object]"); + /* Print out object: enclosing type is same as real_type if full */ + return val_print (VALUE_ENCLOSING_TYPE (val), VALUE_CONTENTS_ALL (val), 0, + VALUE_ADDRESS (val), stream, format, 1, 0, pretty); + /* Note: When we look up RTTI entries, we don't get any information on + const or volatile attributes */ + } + else if (type != VALUE_ENCLOSING_TYPE (val)) + { + /* No RTTI information, so let's do our best */ + fprintf_filtered (stream, "(%s ?) ", + TYPE_NAME (VALUE_ENCLOSING_TYPE (val))); + return val_print (VALUE_ENCLOSING_TYPE (val), VALUE_CONTENTS_ALL (val), 0, + VALUE_ADDRESS (val), stream, format, 1, 0, pretty); + } + /* Otherwise, we end up at the return outside this "if" */ + } + + return val_print (type, VALUE_CONTENTS_ALL (val), VALUE_EMBEDDED_OFFSET (val), + VALUE_ADDRESS (val), + stream, format, 1, 0, pretty); }