X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fc-valprint.c;h=c61e18e925cbb7b13b6202557b6d357ecd17127c;hb=5d921cbd81554867007e903b634acc6bc8281f9f;hp=f5866e2bd1915f87d952fbd513ac8124dc74d71f;hpb=6c9638b444fd6ebdd189fe05c3e44dfbc95c878c;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index f5866e2bd1..c61e18e925 100644
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -1,511 +1,589 @@
/* Support for printing C values for GDB, the GNU debugger.
- Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995
- Free Software Foundation, Inc.
-This file is part of GDB.
+ Copyright (C) 1986-2014 Free Software Foundation, Inc.
-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 file is part of GDB.
-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 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 3 of the License, or
+ (at your option) any later version.
-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. */
+ 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, see . */
#include "defs.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"
+#include "objfiles.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 **, int));
+/* A helper for c_textual_element_type. This checks the name of the
+ typedef. This is bogus but it isn't apparent that the compiler
+ provides us the help we may need. */
-extern int
-cp_is_vtbl_ptr_type PARAMS ((struct type *));
+static int
+textual_name (const char *name)
+{
+ return (!strcmp (name, "wchar_t")
+ || !strcmp (name, "char16_t")
+ || !strcmp (name, "char32_t"));
+}
-extern int
-cp_is_vtbl_member PARAMS ((struct type *));
+/* Apply a heuristic to decide whether an array of TYPE or a pointer
+ to TYPE should be printed as a textual string. Return non-zero if
+ it should, or zero if it should be treated as an array of integers
+ or pointer to integers. FORMAT is the current format letter, or 0
+ if none.
-/* END-FIXME */
+ We guess that "char" is a character. Explicitly signed and
+ unsigned character types are also characters. Integer data from
+ vector types is not. The user can override this by using the /s
+ format letter. */
+int
+c_textual_element_type (struct type *type, char format)
+{
+ struct type *true_type, *iter_type;
-/* BEGIN-FIXME: Hooks into c-typeprint.c */
+ if (format != 0 && format != 's')
+ return 0;
-extern void
-c_type_print_varspec_prefix PARAMS ((struct type *, GDB_FILE *, int, int));
+ /* We also rely on this for its side effect of setting up all the
+ typedef pointers. */
+ true_type = check_typedef (type);
-extern void
-cp_type_print_method_args PARAMS ((struct type **, char *, char *, int,
- GDB_FILE *));
-/* END-FIXME */
+ /* TYPE_CODE_CHAR is always textual. */
+ if (TYPE_CODE (true_type) == TYPE_CODE_CHAR)
+ return 1;
+ /* Any other character-like types must be integral. */
+ if (TYPE_CODE (true_type) != TYPE_CODE_INT)
+ return 0;
-
-/* 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
- target byte order.
+ /* We peel typedefs one by one, looking for a match. */
+ iter_type = type;
+ while (iter_type)
+ {
+ /* Check the name of the type. */
+ if (TYPE_NAME (iter_type) && textual_name (TYPE_NAME (iter_type)))
+ return 1;
+
+ if (TYPE_CODE (iter_type) != TYPE_CODE_TYPEDEF)
+ break;
+
+ /* Peel a single typedef. If the typedef doesn't have a target
+ type, we use check_typedef and hope the result is ok -- it
+ might be for C++, where wchar_t is a built-in type. */
+ if (TYPE_TARGET_TYPE (iter_type))
+ iter_type = TYPE_TARGET_TYPE (iter_type);
+ else
+ iter_type = check_typedef (iter_type);
+ }
- If the data are a string pointer, returns the number of string characters
- printed.
+ if (format == 's')
+ {
+ /* Print this as a string if we can manage it. For now, no wide
+ character support. */
+ if (TYPE_CODE (true_type) == TYPE_CODE_INT
+ && TYPE_LENGTH (true_type) == 1)
+ return 1;
+ }
+ else
+ {
+ /* If a one-byte TYPE_CODE_INT is missing the not-a-character
+ flag, then we treat it as text; otherwise, we assume it's
+ being used as data. */
+ if (TYPE_CODE (true_type) == TYPE_CODE_INT
+ && TYPE_LENGTH (true_type) == 1
+ && !TYPE_NOTTEXT (true_type))
+ return 1;
+ }
- If DEREF_REF is nonzero, then dereference references, otherwise just print
- them like pointers.
+ return 0;
+}
- The PRETTY parameter controls prettyprinting. */
+/* Decorations for C. */
-int
-c_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
- pretty)
- struct type *type;
- char *valaddr;
- CORE_ADDR address;
- GDB_FILE *stream;
- int format;
- int deref_ref;
- int recurse;
- enum val_prettyprint pretty;
+static const struct generic_val_print_decorations c_decorations =
+{
+ "",
+ " + ",
+ " * I",
+ "true",
+ "false",
+ "void"
+};
+
+/* See val_print for a description of the various parameters of this
+ function; they are identical. */
+
+void
+c_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)
{
- register unsigned int i = 0; /* Number of characters printed */
+ 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;
- struct type *elttype;
+ struct type *elttype, *unresolved_elttype;
+ struct type *unresolved_type = type;
unsigned eltlen;
- LONGEST val;
CORE_ADDR addr;
+ CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
- if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
+ unresolved_elttype = TYPE_TARGET_TYPE (type);
+ elttype = check_typedef (unresolved_elttype);
+ if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
{
- elttype = TYPE_TARGET_TYPE (type);
+ LONGEST low_bound, high_bound;
+
+ if (!get_array_bounds (type, &low_bound, &high_bound))
+ error (_("Could not determine the array high bound"));
+
eltlen = TYPE_LENGTH (elttype);
- len = TYPE_LENGTH (type) / eltlen;
- if (prettyprint_arrays)
+ len = high_bound - low_bound + 1;
+ if (options->prettyformat_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
- /* For an array of chars, print with string syntax. */
- if (eltlen == 1 &&
- ((TYPE_CODE (elttype) == TYPE_CODE_INT)
- || ((current_language->la_language == language_m2)
- && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
- && (format == 0 || format == 's'))
+
+ /* Print arrays of textual chars with a string syntax, as
+ long as the entire array is valid. */
+ if (c_textual_element_type (unresolved_elttype,
+ options->format)
+ && value_bytes_available (original_value, embedded_offset,
+ TYPE_LENGTH (type))
+ && !value_bits_any_optimized_out (original_value,
+ TARGET_CHAR_BIT * embedded_offset,
+ TARGET_CHAR_BIT * TYPE_LENGTH (type)))
{
- /* If requested, look for the first null char and only print
- elements up to it. */
- if (stop_print_at_null)
+ int force_ellipses = 0;
+
+ /* If requested, look for the first null char and only
+ print elements up to it. */
+ if (options->stop_print_at_null)
{
- int temp_len;
-
- /* Look for a NULL char. */
+ unsigned int temp_len;
+
for (temp_len = 0;
- valaddr[temp_len]
- && temp_len < len && temp_len < print_max;
- temp_len++);
+ (temp_len < len
+ && temp_len < options->print_max
+ && extract_unsigned_integer (valaddr + embedded_offset
+ + temp_len * eltlen,
+ eltlen, byte_order) != 0);
+ ++temp_len)
+ ;
+
+ /* Force LA_PRINT_STRING to print ellipses if
+ we've printed the maximum characters and
+ the next character is not \000. */
+ if (temp_len == options->print_max && temp_len < len)
+ {
+ ULONGEST val
+ = extract_unsigned_integer (valaddr + embedded_offset
+ + temp_len * eltlen,
+ eltlen, byte_order);
+ if (val != 0)
+ force_ellipses = 1;
+ }
+
len = temp_len;
}
-
- LA_PRINT_STRING (stream, valaddr, len, 0);
+
+ LA_PRINT_STRING (stream, unresolved_elttype,
+ valaddr + embedded_offset, len,
+ NULL, force_ellipses, 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. */
+ entry specially, and the rest of the members
+ normally. */
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
{
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,
+ recurse, original_value, options, i);
fprintf_filtered (stream, "}");
}
break;
}
- /* Array of unspecified length: treat like pointer to first elt. */
- addr = address;
+ /* Array of unspecified length: treat like pointer to first
+ elt. */
+ addr = address + embedded_offset;
goto print_unpacked_pointer;
+ case TYPE_CODE_METHODPTR:
+ cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
+ break;
+
case TYPE_CODE_PTR:
- if (format && format != 's')
+ if (options->format && options->format != 's')
{
- print_scalar_formatted (valaddr, type, format, 0, stream);
+ val_print_scalar_formatted (type, valaddr, embedded_offset,
+ original_value, options, 0, stream);
break;
}
- if (vtblprint && cp_is_vtbl_ptr_type(type))
+ if (options->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);
+ -fvtable_thunks. (Otherwise, look under
+ TYPE_CODE_STRUCT.) */
+ CORE_ADDR addr
+ = extract_typed_address (valaddr + embedded_offset, type);
+
+ print_function_pointer_address (options, gdbarch, addr, stream);
break;
}
- if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
+ unresolved_elttype = TYPE_TARGET_TYPE (type);
+ elttype = check_typedef (unresolved_elttype);
{
- cp_print_class_method (valaddr, type, stream);
- }
- else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_MEMBER)
- {
- cp_print_class_member (valaddr,
- TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
- stream, "&");
- }
- else
- {
- addr = unpack_pointer (type, valaddr);
+ int want_space;
+
+ addr = unpack_pointer (type, valaddr + embedded_offset);
print_unpacked_pointer:
- elttype = TYPE_TARGET_TYPE (type);
+
+ want_space = 0;
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);
+ print_function_pointer_address (options, gdbarch, addr, stream);
+ return;
}
- if (addressprint && format != 's')
+ if (options->symbol_print)
+ want_space = print_address_demangle (options, gdbarch, addr,
+ stream, demangle);
+ else if (options->addressprint)
{
- print_address_numeric (addr, 1, stream);
+ fputs_filtered (paddress (gdbarch, addr), stream);
+ want_space = 1;
}
- /* For a pointer to char or unsigned char, also print the string
+ /* For a pointer to a textual type, also print the string
pointed to, unless pointer is null. */
- if (TYPE_LENGTH (elttype) == 1
- && TYPE_CODE (elttype) == TYPE_CODE_INT
- && (format == 0 || format == 's')
+
+ if (c_textual_element_type (unresolved_elttype,
+ options->format)
&& addr != 0)
{
- i = val_print_string (addr, 0, stream);
+ if (want_space)
+ fputs_filtered (" ", stream);
+ i = val_print_string (unresolved_elttype, NULL,
+ addr, -1,
+ stream, options);
}
- else if (cp_is_vtbl_member(type))
- {
- /* print vtbl's nicely */
- CORE_ADDR vt_address = unpack_pointer (type, valaddr);
-
- struct minimal_symbol *msymbol =
+ else if (cp_is_vtbl_member (type))
+ {
+ /* Print vtbl's nicely. */
+ CORE_ADDR vt_address = unpack_pointer (type,
+ valaddr
+ + embedded_offset);
+ 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)))
{
+ if (want_space)
+ fputs_filtered (" ", stream);
fputs_filtered (" <", stream);
- fputs_filtered (SYMBOL_SOURCE_NAME (msymbol), stream);
+ fputs_filtered (MSYMBOL_PRINT_NAME (msymbol.minsym), stream);
fputs_filtered (">", stream);
+ want_space = 1;
}
- if (vt_address && vtblprint)
- {
- value_ptr 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);
-
+
+ if (vt_address && options->vtblprint)
+ {
+ struct value *vt_val;
+ struct symbol *wsym = (struct symbol *) NULL;
+ struct type *wtype;
+ struct block *block = (struct block *) NULL;
+ struct field_of_this_result is_this_fld;
+
+ if (want_space)
+ fputs_filtered (" ", stream);
+
+ if (msymbol.minsym != NULL)
+ wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
+ block, VAR_DOMAIN,
+ &is_this_fld);
+
if (wsym)
{
- wtype = SYMBOL_TYPE(wsym);
+ wtype = SYMBOL_TYPE (wsym);
}
else
{
- wtype = TYPE_TARGET_TYPE(type);
+ wtype = unresolved_elttype;
}
vt_val = value_at (wtype, vt_address);
- val_print (VALUE_TYPE (vt_val), VALUE_CONTENTS (vt_val),
- VALUE_ADDRESS (vt_val), stream, format,
- deref_ref, recurse + 1, pretty);
- if (pretty)
+ common_val_print (vt_val, stream, recurse + 1,
+ options, current_language);
+ if (options->prettyformat)
{
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;
- }
- break;
-
- case TYPE_CODE_MEMBER:
- error ("not implemented: member type in c_val_print");
- 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)),
- stream, "");
- break;
- }
- if (addressprint)
- {
- fprintf_filtered (stream, "@");
- print_address_numeric
- (extract_address (valaddr,
- 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)
- {
- value_ptr deref_val =
- value_at
- (TYPE_TARGET_TYPE (type),
- unpack_pointer (lookup_pointer_type (builtin_type_void),
- valaddr));
- val_print (VALUE_TYPE (deref_val),
- VALUE_CONTENTS (deref_val),
- VALUE_ADDRESS (deref_val), stream, format,
- deref_ref, recurse + 1, pretty);
+ }
}
- else
- fputs_filtered ("???", stream);
+ return;
}
break;
case TYPE_CODE_UNION:
- if (recurse && !unionprint)
+ if (recurse && !options->unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
- if (vtblprint && cp_is_vtbl_ptr_type(type))
+ /*FIXME: Abstract this away. */
+ if (options->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;
- }
- cp_print_value_fields (type, valaddr, stream, format, recurse, pretty,
- NULL, 0);
- break;
-
- case TYPE_CODE_ENUM:
- if (format)
- {
- print_scalar_formatted (valaddr, type, format, 0, stream);
- break;
- }
- len = TYPE_NFIELDS (type);
- val = unpack_long (type, valaddr);
- 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);
+ -fvtable_thunks. (Otherwise, look under
+ TYPE_CODE_PTR.) */
+ int offset = (embedded_offset
+ + TYPE_FIELD_BITPOS (type,
+ VTBL_FNADDR_OFFSET) / 8);
+ struct type *field_type = TYPE_FIELD_TYPE (type,
+ VTBL_FNADDR_OFFSET);
+ CORE_ADDR addr
+ = extract_typed_address (valaddr + offset, field_type);
+
+ print_function_pointer_address (options, gdbarch, addr, stream);
}
else
- {
- print_longest (stream, 'd', 0, val);
- }
- break;
-
- case TYPE_CODE_FUNC:
- if (format)
- {
- print_scalar_formatted (valaddr, 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. */
- 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 (address, stream, demangle);
+ cp_print_value_fields_rtti (type, valaddr,
+ embedded_offset, address,
+ stream, recurse,
+ original_value, options,
+ NULL, 0);
break;
- case TYPE_CODE_BOOL:
- /* Do something at least vaguely reasonable, for example if the
- language is set wrong. */
-
- 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:
- format = format ? format : output_format;
- if (format)
+ if (options->format || options->output_format)
{
- print_scalar_formatted (valaddr, type, format, 0, stream);
+ 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, 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
- equivalent as well. */
- if (TYPE_LENGTH (type) == 1)
+ 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 equivalent as well. */
+ if (c_textual_element_type (unresolved_type, options->format))
{
fputs_filtered (" ", stream);
- LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr),
- stream);
+ LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
+ unresolved_type, stream);
}
}
break;
- case TYPE_CODE_CHAR:
- format = format ? format : output_format;
- if (format)
- {
- print_scalar_formatted (valaddr, type, format, 0, stream);
- }
- else
+ case TYPE_CODE_MEMBERPTR:
+ if (!options->format)
{
- fprintf_filtered (stream, TYPE_UNSIGNED (type) ? "%u" : "%d",
- unpack_long (type, valaddr));
- fputs_filtered (" ", stream);
- LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr), stream);
+ cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
+ break;
}
- break;
+ /* FALLTHROUGH */
+ case TYPE_CODE_REF:
+ case TYPE_CODE_ENUM:
+ case TYPE_CODE_FLAGS:
+ case TYPE_CODE_FUNC:
+ case TYPE_CODE_METHOD:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_RANGE:
case TYPE_CODE_FLT:
- if (format)
- {
- print_scalar_formatted (valaddr, type, format, 0, stream);
- }
- else
- {
- print_floating (valaddr, type, stream);
- }
- break;
-
+ case TYPE_CODE_DECFLOAT:
case TYPE_CODE_VOID:
- fprintf_filtered (stream, "void");
- break;
-
case TYPE_CODE_ERROR:
- 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, "");
- break;
-
+ case TYPE_CODE_COMPLEX:
+ case TYPE_CODE_CHAR:
default:
- error ("Invalid C/C++ type code %d in symbol table.", TYPE_CODE (type));
+ generic_val_print (type, valaddr, embedded_offset, address,
+ stream, recurse, original_value, options,
+ &c_decorations);
+ break;
}
gdb_flush (stream);
- return (0);
}
-int
-c_value_print (val, stream, format, pretty)
- value_ptr val;
- GDB_FILE *stream;
- int format;
- enum val_prettyprint pretty;
+void
+c_value_print (struct value *val, struct ui_file *stream,
+ const struct value_print_options *options)
{
- /* 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, *real_type, *val_type;
+ int full, top, using_enc;
+ struct value_print_options opts = *options;
+
+ opts.deref_ref = 1;
+
+ /* 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. */
+
+ /* Preserve the original type before stripping typedefs. We prefer
+ to pass down the original type when possible, but for local
+ checks it is better to look past the typedefs. */
+ val_type = value_type (val);
+ type = check_typedef (val_type);
- if (VALUE_REPEATED (val))
+ 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);
+ /* Hack: remove (char *) for char strings. Their
+ type is indicated by the quoted string anyway.
+ (Don't use c_textual_element_type here; quoted strings
+ are always exactly (char *), (wchar_t *), or the like. */
+ if (TYPE_CODE (val_type) == TYPE_CODE_PTR
+ && TYPE_NAME (val_type) == NULL
+ && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
+ && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
+ "char") == 0
+ || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
+ {
+ /* Print nothing. */
+ }
+ else if (options->objectprint
+ && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
+ {
+ int is_ref = TYPE_CODE (type) == TYPE_CODE_REF;
+
+ if (is_ref)
+ val = value_addr (val);
+
+ /* Pointer to class, check real type of object. */
+ fprintf_filtered (stream, "(");
+
+ if (value_entirely_available (val))
+ {
+ real_type = value_rtti_indirect_type (val, &full, &top,
+ &using_enc);
+ if (real_type)
+ {
+ /* RTTI entry found. */
+ type = real_type;
+
+ /* Need to adjust pointer value. */
+ val = value_from_pointer (real_type,
+ value_as_address (val) - top);
+
+ if (is_ref)
+ {
+ val = value_ref (value_ind (val));
+ type = value_type (val);
+ }
+
+ /* 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, ") ");
+ val_type = type;
+ }
else
{
- value_print_array_elements (val, stream, format, pretty);
+ /* normal case */
+ fprintf_filtered (stream, "(");
+ type_print (value_type (val), "", stream, -1);
+ fprintf_filtered (stream, ") ");
}
- 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.
+ if (!value_initialized (val))
+ fprintf_filtered (stream, " [uninitialized] ");
- 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)
+ if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_STRUCT))
+ {
+ /* Attempt to determine real type of object. */
+ real_type = value_rtti_type (val, &full, &top, &using_enc);
+ if (real_type)
{
- /* 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"))
- {
- /* Print nothing */
- }
- else
- {
- fprintf_filtered (stream, "(");
- type_print (type, "", stream, -1);
- fprintf_filtered (stream, ") ");
- }
+ /* 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. */
+ val_print (value_enclosing_type (val),
+ value_contents_for_printing (val), 0,
+ value_address (val), stream, 0,
+ val, &opts, current_language);
+ return;
+ /* Note: When we look up RTTI entries, we don't get any
+ information on const or volatile attributes. */
+ }
+ else if (type != check_typedef (value_enclosing_type (val)))
+ {
+ /* No RTTI information, so let's do our best. */
+ fprintf_filtered (stream, "(%s ?) ",
+ TYPE_NAME (value_enclosing_type (val)));
+ val_print (value_enclosing_type (val),
+ value_contents_for_printing (val), 0,
+ value_address (val), stream, 0,
+ val, &opts, current_language);
+ return;
}
- return (val_print (type, VALUE_CONTENTS (val),
- VALUE_ADDRESS (val), stream, format, 1, 0, pretty));
+ /* Otherwise, we end up at the return outside this "if". */
}
+
+ val_print (val_type, value_contents_for_printing (val),
+ value_embedded_offset (val),
+ value_address (val),
+ stream, 0,
+ val, &opts, current_language);
}