X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fc-valprint.c;h=64f0f42537964bfa40cc8a8b89a01c07ac4ce1d1;hb=0fd88904d91d1a137779cd5da6dc9d223fa88d14;hp=784cbc8bbdc4f2fda9f86adc01d5878ef59e3ed6;hpb=fba45db2faf619e71856ee38ec63949c0ef6903e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c index 784cbc8bbd..64f0f42537 100644 --- a/gdb/c-valprint.c +++ b/gdb/c-valprint.c @@ -1,6 +1,8 @@ /* Support for printing C values for GDB, the GNU debugger. - Copyright 1986, 1988, 1989, 1991-1997, 2000 - Free Software Foundation, Inc. + + Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, + 1997, 1998, 1999, 2000, 2001, 2003, 2005 Free Software Foundation, + Inc. This file is part of GDB. @@ -20,16 +22,40 @@ Boston, MA 02111-1307, USA. */ #include "defs.h" +#include "gdb_string.h" #include "symtab.h" #include "gdbtypes.h" #include "expression.h" #include "value.h" -#include "demangle.h" #include "valprint.h" #include "language.h" #include "c-lang.h" +#include "cp-abi.h" +#include "target.h" +/* Print function pointer with inferior address ADDRESS onto stdio + stream STREAM. */ + +static void +print_function_pointer_address (CORE_ADDR address, struct ui_file *stream) +{ + CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch, + address, + ¤t_target); + + /* If the function pointer is represented by a description, print the + address of the description. */ + if (addressprint && func_addr != address) + { + fputs_filtered ("@", stream); + print_address_numeric (address, 1, stream); + fputs_filtered (": ", stream); + } + print_address_demangle (func_addr, stream, demangle); +} + + /* 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 @@ -44,11 +70,11 @@ The PRETTY parameter controls prettyprinting. */ int -c_val_print (struct type *type, char *valaddr, int embedded_offset, +c_val_print (struct type *type, const bfd_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int format, int deref_ref, int recurse, enum val_prettyprint pretty) { - register unsigned int i = 0; /* Number of characters printed */ + unsigned int i = 0; /* Number of characters printed */ unsigned len; struct type *elttype; unsigned eltlen; @@ -100,7 +126,7 @@ c_val_print (struct type *type, char *valaddr, int embedded_offset, if (cp_is_vtbl_ptr_type (elttype)) { i = 1; - fprintf_filtered (stream, "%d vtable entries", len - 1); + fprintf_filtered (stream, _("%d vtable entries"), len - 1); } else { @@ -129,7 +155,7 @@ c_val_print (struct type *type, char *valaddr, int embedded_offset, -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */ CORE_ADDR addr = extract_typed_address (valaddr + embedded_offset, type); - print_address_demangle (addr, stream, demangle); + print_function_pointer_address (addr, stream); break; } elttype = check_typedef (TYPE_TARGET_TYPE (type)); @@ -147,12 +173,11 @@ c_val_print (struct type *type, char *valaddr, int embedded_offset, { 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); + print_function_pointer_address (addr, stream); /* Return value is irrelevant except for string pointers. */ return (0); } @@ -184,21 +209,20 @@ c_val_print (struct type *type, char *valaddr, int embedded_offset, (vt_address == SYMBOL_VALUE_ADDRESS (msymbol))) { fputs_filtered (" <", stream); - fputs_filtered (SYMBOL_SOURCE_NAME (msymbol), stream); + fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream); fputs_filtered (">", stream); } if (vt_address && vtblprint) { - value_ptr vt_val; + struct value *vt_val; struct symbol *wsym = (struct symbol *) NULL; struct type *wtype; - struct symtab *s; 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 (DEPRECATED_SYMBOL_NAME (msymbol), block, + VAR_DOMAIN, &is_this_fld, NULL); if (wsym) { @@ -208,8 +232,8 @@ c_val_print (struct type *type, char *valaddr, int embedded_offset, { wtype = TYPE_TARGET_TYPE (type); } - vt_val = value_at (wtype, vt_address, NULL); - val_print (VALUE_TYPE (vt_val), VALUE_CONTENTS (vt_val), 0, + vt_val = value_at (wtype, vt_address); + val_print (value_type (vt_val), value_contents (vt_val), 0, VALUE_ADDRESS (vt_val), stream, format, deref_ref, recurse + 1, pretty); if (pretty) @@ -228,7 +252,7 @@ c_val_print (struct type *type, char *valaddr, int embedded_offset, break; case TYPE_CODE_MEMBER: - error ("not implemented: member type in c_val_print"); + error (_("not implemented: member type in c_val_print")); break; case TYPE_CODE_REF: @@ -254,14 +278,13 @@ c_val_print (struct type *type, char *valaddr, int embedded_offset, { if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) { - value_ptr deref_val = + struct value *deref_val = 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), + valaddr + embedded_offset)); + val_print (value_type (deref_val), + value_contents (deref_val), 0, VALUE_ADDRESS (deref_val), stream, @@ -283,6 +306,7 @@ c_val_print (struct type *type, char *valaddr, int embedded_offset, } /* Fall through. */ case TYPE_CODE_STRUCT: + /*FIXME: Abstract this away */ if (vtblprint && cp_is_vtbl_ptr_type (type)) { /* Print the unmangled name if desired. */ @@ -294,7 +318,7 @@ c_val_print (struct type *type, char *valaddr, int embedded_offset, CORE_ADDR addr = extract_typed_address (valaddr + offset, field_type); - print_address_demangle (addr, stream, demangle); + print_function_pointer_address (addr, stream); } else cp_print_value_fields (type, type, valaddr, embedded_offset, address, stream, format, @@ -420,36 +444,62 @@ c_val_print (struct type *type, char *valaddr, int embedded_offset, break; case TYPE_CODE_METHOD: - cp_print_class_method (valaddr + embedded_offset, lookup_pointer_type (type), stream); - break; + { + struct value *v = value_at (type, address); + cp_print_class_method (value_contents (value_addr (v)), + lookup_pointer_type (type), stream); + break; + } case TYPE_CODE_VOID: fprintf_filtered (stream, "void"); break; case TYPE_CODE_ERROR: - fprintf_filtered (stream, ""); + fprintf_filtered (stream, _("")); 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, ""); + fprintf_filtered (stream, _("")); + break; + + case TYPE_CODE_COMPLEX: + if (format) + print_scalar_formatted (valaddr + embedded_offset, + TYPE_TARGET_TYPE (type), + format, 0, stream); + else + print_floating (valaddr + embedded_offset, TYPE_TARGET_TYPE (type), + stream); + fprintf_filtered (stream, " + "); + if (format) + print_scalar_formatted (valaddr + embedded_offset + + TYPE_LENGTH (TYPE_TARGET_TYPE (type)), + TYPE_TARGET_TYPE (type), + format, 0, stream); + else + print_floating (valaddr + embedded_offset + + TYPE_LENGTH (TYPE_TARGET_TYPE (type)), + TYPE_TARGET_TYPE (type), + stream); + fprintf_filtered (stream, " * I"); break; default: - error ("Invalid C/C++ type code %d in symbol table.", TYPE_CODE (type)); + error (_("Invalid C/C++ type code %d in symbol table."), TYPE_CODE (type)); } gdb_flush (stream); return (0); } int -c_value_print (value_ptr val, struct ui_file *stream, int format, +c_value_print (struct value *val, struct ui_file *stream, int format, enum val_prettyprint pretty) { - struct type *type = VALUE_TYPE (val); + struct type *type = value_type (val); struct type *real_type; int full, top, using_enc; @@ -467,7 +517,7 @@ c_value_print (value_ptr val, struct ui_file *stream, int format, 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")) + strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0) { /* Print nothing */ } @@ -479,9 +529,9 @@ c_value_print (value_ptr val, struct ui_file *stream, int format, /* 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; + struct value *temparg; temparg=value_copy(val); - VALUE_TYPE (temparg) = lookup_pointer_type(TYPE_TARGET_TYPE(type)); + temparg->type = lookup_pointer_type (TYPE_TARGET_TYPE(type)); val=temparg; } /* Pointer to class, check real type of object */ @@ -517,7 +567,7 @@ c_value_print (value_ptr val, struct ui_file *stream, int format, fprintf_filtered (stream, ") "); } } - if (objectprint && (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_CLASS)) + 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); @@ -527,25 +577,28 @@ c_value_print (value_ptr val, struct ui_file *stream, int format, val = value_full_object (val, real_type, full, top, using_enc); fprintf_filtered (stream, "(%s%s) ", TYPE_NAME (real_type), - full ? "" : " [incomplete object]"); + 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); + 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)) + 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); + 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), + return val_print (type, value_contents_all (val), + VALUE_EMBEDDED_OFFSET (val), + VALUE_ADDRESS (val) + value_offset (val), stream, format, 1, 0, pretty); }