/* Support for printing C values for GDB, the GNU debugger.
Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
- 1998, 1999, 2000, 2001, 2003, 2005, 2006, 2007, 2008, 2009
+ 1998, 1999, 2000, 2001, 2003, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GDB.
stream STREAM. */
static void
-print_function_pointer_address (CORE_ADDR address, struct ui_file *stream,
- int addressprint)
+print_function_pointer_address (struct gdbarch *gdbarch, CORE_ADDR address,
+ struct ui_file *stream, int addressprint)
{
- CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
- address,
+ CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
¤t_target);
/* If the function pointer is represented by a description, print the
if (addressprint && func_addr != address)
{
fputs_filtered ("@", stream);
- fputs_filtered (paddress (address), stream);
+ fputs_filtered (paddress (gdbarch, address), stream);
fputs_filtered (": ", stream);
}
- print_address_demangle (func_addr, stream, demangle);
+ print_address_demangle (gdbarch, func_addr, stream, demangle);
}
-/* A helper for textual_element_type. This checks the name of the
+/* 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. */
vector types is not. The user can override this by using the /s
format letter. */
-static int
-textual_element_type (struct type *type, char format)
+int
+c_textual_element_type (struct type *type, char format)
{
- struct type *true_type = check_typedef (type);
+ struct type *true_type, *iter_type;
if (format != 0 && format != 's')
return 0;
+ /* We also rely on this for its side effect of setting up all the
+ typedef pointers. */
+ true_type = check_typedef (type);
+
/* 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;
- /* Check the names of the type and the typedef. */
- if (TYPE_NAME (type) && textual_name (TYPE_NAME (type)))
- return 1;
- if (TYPE_NAME (true_type) && textual_name (TYPE_NAME (true_type)))
- return 1;
+ /* 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 (format == 's')
{
CORE_ADDR address, struct ui_file *stream, int recurse,
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;
struct type *elttype, *unresolved_elttype;
}
/* Print arrays of textual chars with a string syntax. */
- if (textual_element_type (unresolved_elttype, options->format))
+ if (c_textual_element_type (unresolved_elttype, options->format))
{
/* If requested, look for the first null char and only print
elements up to it. */
&& temp_len < options->print_max
&& extract_unsigned_integer (valaddr + embedded_offset
+ temp_len * eltlen,
- eltlen) == 0);
+ eltlen, byte_order) == 0);
++temp_len)
;
len = temp_len;
-fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
- print_function_pointer_address (addr, stream, options->addressprint);
+ print_function_pointer_address (gdbarch, addr, stream,
+ options->addressprint);
break;
}
unresolved_elttype = TYPE_TARGET_TYPE (type);
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
- print_function_pointer_address (addr, stream,
+ print_function_pointer_address (gdbarch, addr, stream,
options->addressprint);
/* Return value is irrelevant except for string pointers. */
return (0);
}
if (options->addressprint)
- fputs_filtered (paddress (addr), stream);
+ fputs_filtered (paddress (gdbarch, addr), stream);
/* For a pointer to a textual type, also print the string
pointed to, unless pointer is null. */
- if (textual_element_type (unresolved_elttype, options->format)
+ if (c_textual_element_type (unresolved_elttype, options->format)
&& addr != 0)
{
i = val_print_string (unresolved_elttype, addr, -1, stream,
struct minimal_symbol *msymbol =
lookup_minimal_symbol_by_pc (vt_address);
- if ((msymbol != NULL) &&
- (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
+ if ((msymbol != NULL)
+ && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
{
fputs_filtered (" <", stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
fprintf_filtered (stream, "@");
- fputs_filtered (paddress (addr), stream);
+ fputs_filtered (paddress (gdbarch, addr), stream);
if (options->deref_ref)
fputs_filtered (": ", stream);
}
CORE_ADDR addr
= extract_typed_address (valaddr + offset, field_type);
- print_function_pointer_address (addr, stream, options->addressprint);
+ print_function_pointer_address (gdbarch, addr, stream,
+ options->addressprint);
}
else
cp_print_value_fields (type, type, valaddr, embedded_offset, address, 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);
+ print_address_demangle (gdbarch, address, stream, demangle);
break;
case TYPE_CODE_BOOL:
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 (textual_element_type (unresolved_type, options->format))
+ if (c_textual_element_type (unresolved_type, options->format))
{
fputs_filtered (" ", stream);
LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr + embedded_offset),
{
/* Hack: remove (char *) for char strings. Their
type is indicated by the quoted string anyway.
- (Don't use textual_element_type here; quoted strings
+ (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
/* 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, 0,
+ value_address (val), stream, 0,
&opts, current_language);
/* Note: When we look up RTTI entries, we don't get any information on
const or volatile attributes */
TYPE_NAME (value_enclosing_type (val)));
return val_print (value_enclosing_type (val),
value_contents_all (val), 0,
- VALUE_ADDRESS (val), stream, 0,
+ value_address (val), stream, 0,
&opts, current_language);
}
/* Otherwise, we end up at the return outside this "if" */
return val_print (val_type, value_contents_all (val),
value_embedded_offset (val),
- VALUE_ADDRESS (val) + value_offset (val),
+ value_address (val),
stream, 0, &opts, current_language);
}
projects / deliverable / binutils-gdb.git / blobdiff