1 /* Support for printing C values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2003, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
26 #include "expression.h"
35 /* Print function pointer with inferior address ADDRESS onto stdio
39 print_function_pointer_address (struct gdbarch
*gdbarch
, CORE_ADDR address
,
40 struct ui_file
*stream
, int addressprint
)
42 CORE_ADDR func_addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
45 /* If the function pointer is represented by a description, print the
46 address of the description. */
47 if (addressprint
&& func_addr
!= address
)
49 fputs_filtered ("@", stream
);
50 fputs_filtered (paddress (gdbarch
, address
), stream
);
51 fputs_filtered (": ", stream
);
53 print_address_demangle (gdbarch
, func_addr
, stream
, demangle
);
57 /* A helper for c_textual_element_type. This checks the name of the
58 typedef. This is bogus but it isn't apparent that the compiler
59 provides us the help we may need. */
62 textual_name (const char *name
)
64 return (!strcmp (name
, "wchar_t")
65 || !strcmp (name
, "char16_t")
66 || !strcmp (name
, "char32_t"));
69 /* Apply a heuristic to decide whether an array of TYPE or a pointer
70 to TYPE should be printed as a textual string. Return non-zero if
71 it should, or zero if it should be treated as an array of integers
72 or pointer to integers. FORMAT is the current format letter,
75 We guess that "char" is a character. Explicitly signed and
76 unsigned character types are also characters. Integer data from
77 vector types is not. The user can override this by using the /s
81 c_textual_element_type (struct type
*type
, char format
)
83 struct type
*true_type
, *iter_type
;
85 if (format
!= 0 && format
!= 's')
88 /* We also rely on this for its side effect of setting up all the
90 true_type
= check_typedef (type
);
92 /* TYPE_CODE_CHAR is always textual. */
93 if (TYPE_CODE (true_type
) == TYPE_CODE_CHAR
)
96 /* Any other character-like types must be integral. */
97 if (TYPE_CODE (true_type
) != TYPE_CODE_INT
)
100 /* We peel typedefs one by one, looking for a match. */
104 /* Check the name of the type. */
105 if (TYPE_NAME (iter_type
) && textual_name (TYPE_NAME (iter_type
)))
108 if (TYPE_CODE (iter_type
) != TYPE_CODE_TYPEDEF
)
111 /* Peel a single typedef. If the typedef doesn't have a target
112 type, we use check_typedef and hope the result is ok -- it
113 might be for C++, where wchar_t is a built-in type. */
114 if (TYPE_TARGET_TYPE (iter_type
))
115 iter_type
= TYPE_TARGET_TYPE (iter_type
);
117 iter_type
= check_typedef (iter_type
);
122 /* Print this as a string if we can manage it. For now, no
123 wide character support. */
124 if (TYPE_CODE (true_type
) == TYPE_CODE_INT
125 && TYPE_LENGTH (true_type
) == 1)
130 /* If a one-byte TYPE_CODE_INT is missing the not-a-character
131 flag, then we treat it as text; otherwise, we assume it's
132 being used as data. */
133 if (TYPE_CODE (true_type
) == TYPE_CODE_INT
134 && TYPE_LENGTH (true_type
) == 1
135 && !TYPE_NOTTEXT (true_type
))
143 /* Print data of type TYPE located at VALADDR (within GDB), which came from
144 the inferior at address ADDRESS, onto stdio stream STREAM according to
145 OPTIONS. The data at VALADDR is in target byte order.
147 If the data are a string pointer, returns the number of string characters
151 c_val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
152 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
153 const struct value
*original_value
,
154 const struct value_print_options
*options
)
156 struct gdbarch
*gdbarch
= get_type_arch (type
);
157 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
158 unsigned int i
= 0; /* Number of characters printed */
160 struct type
*elttype
, *unresolved_elttype
;
161 struct type
*unresolved_type
= type
;
166 CHECK_TYPEDEF (type
);
167 switch (TYPE_CODE (type
))
169 case TYPE_CODE_ARRAY
:
170 unresolved_elttype
= TYPE_TARGET_TYPE (type
);
171 elttype
= check_typedef (unresolved_elttype
);
172 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (unresolved_elttype
) > 0)
174 eltlen
= TYPE_LENGTH (elttype
);
175 len
= TYPE_LENGTH (type
) / eltlen
;
176 if (options
->prettyprint_arrays
)
178 print_spaces_filtered (2 + 2 * recurse
, stream
);
181 /* Print arrays of textual chars with a string syntax, as
182 long as the entire array is valid. */
183 if (c_textual_element_type (unresolved_elttype
, options
->format
)
184 && value_bits_valid (original_value
,
185 TARGET_CHAR_BIT
* embedded_offset
,
186 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
188 /* If requested, look for the first null char and only print
189 elements up to it. */
190 if (options
->stop_print_at_null
)
192 unsigned int temp_len
;
196 && temp_len
< options
->print_max
197 && extract_unsigned_integer (valaddr
+ embedded_offset
199 eltlen
, byte_order
) != 0);
205 LA_PRINT_STRING (stream
, unresolved_elttype
,
206 valaddr
+ embedded_offset
, len
,
212 fprintf_filtered (stream
, "{");
213 /* If this is a virtual function table, print the 0th
214 entry specially, and the rest of the members normally. */
215 if (cp_is_vtbl_ptr_type (elttype
))
218 fprintf_filtered (stream
, _("%d vtable entries"), len
- 1);
224 val_print_array_elements (type
, valaddr
+ embedded_offset
, address
, stream
,
225 recurse
, original_value
, options
, i
);
226 fprintf_filtered (stream
, "}");
230 /* Array of unspecified length: treat like pointer to first elt. */
232 goto print_unpacked_pointer
;
234 case TYPE_CODE_MEMBERPTR
:
237 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
241 cp_print_class_member (valaddr
+ embedded_offset
, type
, stream
, "&");
244 case TYPE_CODE_METHODPTR
:
245 cplus_print_method_ptr (valaddr
+ embedded_offset
, type
, stream
);
249 if (options
->format
&& options
->format
!= 's')
251 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
255 if (options
->vtblprint
&& cp_is_vtbl_ptr_type (type
))
257 /* Print the unmangled name if desired. */
258 /* Print vtable entry - we only get here if we ARE using
259 -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
261 = extract_typed_address (valaddr
+ embedded_offset
, type
);
263 print_function_pointer_address (gdbarch
, addr
, stream
,
264 options
->addressprint
);
267 unresolved_elttype
= TYPE_TARGET_TYPE (type
);
268 elttype
= check_typedef (unresolved_elttype
);
270 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
);
271 print_unpacked_pointer
:
273 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
275 /* Try to print what function it points to. */
276 print_function_pointer_address (gdbarch
, addr
, stream
,
277 options
->addressprint
);
278 /* Return value is irrelevant except for string pointers. */
282 if (options
->addressprint
)
283 fputs_filtered (paddress (gdbarch
, addr
), stream
);
285 /* For a pointer to a textual type, also print the string
286 pointed to, unless pointer is null. */
288 if (c_textual_element_type (unresolved_elttype
, options
->format
)
291 i
= val_print_string (unresolved_elttype
, addr
, -1, stream
,
294 else if (cp_is_vtbl_member (type
))
296 /* print vtbl's nicely */
297 CORE_ADDR vt_address
= unpack_pointer (type
, valaddr
+ embedded_offset
);
299 struct minimal_symbol
*msymbol
=
300 lookup_minimal_symbol_by_pc (vt_address
);
301 if ((msymbol
!= NULL
)
302 && (vt_address
== SYMBOL_VALUE_ADDRESS (msymbol
)))
304 fputs_filtered (" <", stream
);
305 fputs_filtered (SYMBOL_PRINT_NAME (msymbol
), stream
);
306 fputs_filtered (">", stream
);
308 if (vt_address
&& options
->vtblprint
)
310 struct value
*vt_val
;
311 struct symbol
*wsym
= (struct symbol
*) NULL
;
313 struct block
*block
= (struct block
*) NULL
;
317 wsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
), block
,
318 VAR_DOMAIN
, &is_this_fld
);
322 wtype
= SYMBOL_TYPE (wsym
);
326 wtype
= unresolved_elttype
;
328 vt_val
= value_at (wtype
, vt_address
);
329 common_val_print (vt_val
, stream
, recurse
+ 1, options
,
333 fprintf_filtered (stream
, "\n");
334 print_spaces_filtered (2 + 2 * recurse
, stream
);
339 /* Return number of characters printed, including the terminating
340 '\0' if we reached the end. val_print_string takes care including
341 the terminating '\0' if necessary. */
347 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
348 if (options
->addressprint
)
351 = extract_typed_address (valaddr
+ embedded_offset
, type
);
353 fprintf_filtered (stream
, "@");
354 fputs_filtered (paddress (gdbarch
, addr
), stream
);
355 if (options
->deref_ref
)
356 fputs_filtered (": ", stream
);
358 /* De-reference the reference. */
359 if (options
->deref_ref
)
361 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
363 struct value
*deref_val
=
365 (TYPE_TARGET_TYPE (type
),
366 unpack_pointer (type
, valaddr
+ embedded_offset
));
368 common_val_print (deref_val
, stream
, recurse
, options
,
372 fputs_filtered ("???", stream
);
376 case TYPE_CODE_UNION
:
377 if (recurse
&& !options
->unionprint
)
379 fprintf_filtered (stream
, "{...}");
383 case TYPE_CODE_STRUCT
:
384 /*FIXME: Abstract this away */
385 if (options
->vtblprint
&& cp_is_vtbl_ptr_type (type
))
387 /* Print the unmangled name if desired. */
388 /* Print vtable entry - we only get here if NOT using
389 -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */
390 int offset
= (embedded_offset
+
391 TYPE_FIELD_BITPOS (type
, VTBL_FNADDR_OFFSET
) / 8);
392 struct type
*field_type
= TYPE_FIELD_TYPE (type
, VTBL_FNADDR_OFFSET
);
394 = extract_typed_address (valaddr
+ offset
, field_type
);
396 print_function_pointer_address (gdbarch
, addr
, stream
,
397 options
->addressprint
);
400 cp_print_value_fields_rtti (type
, valaddr
,
401 embedded_offset
, address
, stream
,
402 recurse
, original_value
, options
, NULL
, 0);
408 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
412 len
= TYPE_NFIELDS (type
);
413 val
= unpack_long (type
, valaddr
+ embedded_offset
);
414 for (i
= 0; i
< len
; i
++)
417 if (val
== TYPE_FIELD_BITPOS (type
, i
))
424 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
428 print_longest (stream
, 'd', 0, val
);
432 case TYPE_CODE_FLAGS
:
434 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
437 val_print_type_code_flags (type
, valaddr
+ embedded_offset
, stream
);
441 case TYPE_CODE_METHOD
:
444 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
448 /* FIXME, we should consider, at least for ANSI C language, eliminating
449 the distinction made between FUNCs and POINTERs to FUNCs. */
450 fprintf_filtered (stream
, "{");
451 type_print (type
, "", stream
, -1);
452 fprintf_filtered (stream
, "} ");
453 /* Try to print what function it points to, and its address. */
454 print_address_demangle (gdbarch
, address
, stream
, demangle
);
458 if (options
->format
|| options
->output_format
)
460 struct value_print_options opts
= *options
;
461 opts
.format
= (options
->format
? options
->format
462 : options
->output_format
);
463 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
468 val
= unpack_long (type
, valaddr
+ embedded_offset
);
470 fputs_filtered ("false", stream
);
472 fputs_filtered ("true", stream
);
474 print_longest (stream
, 'd', 0, val
);
478 case TYPE_CODE_RANGE
:
479 /* FIXME: create_range_type does not set the unsigned bit in a
480 range type (I think it probably should copy it from the target
481 type), so we won't print values which are too large to
482 fit in a signed integer correctly. */
483 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
484 print with the target type, though, because the size of our type
485 and the target type might differ). */
489 if (options
->format
|| options
->output_format
)
491 struct value_print_options opts
= *options
;
493 opts
.format
= (options
->format
? options
->format
494 : options
->output_format
);
495 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
500 val_print_type_code_int (type
, valaddr
+ embedded_offset
, stream
);
501 /* C and C++ has no single byte int type, char is used instead.
502 Since we don't know whether the value is really intended to
503 be used as an integer or a character, print the character
504 equivalent as well. */
505 if (c_textual_element_type (unresolved_type
, options
->format
))
507 fputs_filtered (" ", stream
);
508 LA_PRINT_CHAR ((unsigned char) unpack_long (type
, valaddr
+ embedded_offset
),
509 unresolved_type
, stream
);
515 if (options
->format
|| options
->output_format
)
517 struct value_print_options opts
= *options
;
518 opts
.format
= (options
->format
? options
->format
519 : options
->output_format
);
520 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
525 val
= unpack_long (type
, valaddr
+ embedded_offset
);
526 if (TYPE_UNSIGNED (type
))
527 fprintf_filtered (stream
, "%u", (unsigned int) val
);
529 fprintf_filtered (stream
, "%d", (int) val
);
530 fputs_filtered (" ", stream
);
531 LA_PRINT_CHAR ((unsigned char) val
, unresolved_type
, stream
);
538 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
543 print_floating (valaddr
+ embedded_offset
, type
, stream
);
547 case TYPE_CODE_DECFLOAT
:
549 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
552 print_decimal_floating (valaddr
+ embedded_offset
, type
, stream
);
556 fprintf_filtered (stream
, "void");
559 case TYPE_CODE_ERROR
:
560 fprintf_filtered (stream
, _("<error type>"));
563 case TYPE_CODE_UNDEF
:
564 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
565 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
566 and no complete type for struct foo in that file. */
567 fprintf_filtered (stream
, _("<incomplete type>"));
570 case TYPE_CODE_COMPLEX
:
572 print_scalar_formatted (valaddr
+ embedded_offset
,
573 TYPE_TARGET_TYPE (type
),
576 print_floating (valaddr
+ embedded_offset
, TYPE_TARGET_TYPE (type
),
578 fprintf_filtered (stream
, " + ");
580 print_scalar_formatted (valaddr
+ embedded_offset
581 + TYPE_LENGTH (TYPE_TARGET_TYPE (type
)),
582 TYPE_TARGET_TYPE (type
),
585 print_floating (valaddr
+ embedded_offset
586 + TYPE_LENGTH (TYPE_TARGET_TYPE (type
)),
587 TYPE_TARGET_TYPE (type
),
589 fprintf_filtered (stream
, " * I");
593 error (_("Invalid C/C++ type code %d in symbol table."), TYPE_CODE (type
));
600 c_value_print (struct value
*val
, struct ui_file
*stream
,
601 const struct value_print_options
*options
)
603 struct type
*type
, *real_type
, *val_type
;
604 int full
, top
, using_enc
;
605 struct value_print_options opts
= *options
;
609 /* If it is a pointer, indicate what it points to.
611 Print type also if it is a reference.
613 C++: if it is a member pointer, we will take care
614 of that when we print it. */
616 /* Preserve the original type before stripping typedefs. We prefer
617 to pass down the original type when possible, but for local
618 checks it is better to look past the typedefs. */
619 val_type
= value_type (val
);
620 type
= check_typedef (val_type
);
622 if (TYPE_CODE (type
) == TYPE_CODE_PTR
623 || TYPE_CODE (type
) == TYPE_CODE_REF
)
625 /* Hack: remove (char *) for char strings. Their
626 type is indicated by the quoted string anyway.
627 (Don't use c_textual_element_type here; quoted strings
628 are always exactly (char *), (wchar_t *), or the like. */
629 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
630 && TYPE_NAME (val_type
) == NULL
631 && TYPE_NAME (TYPE_TARGET_TYPE (val_type
)) != NULL
632 && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type
)), "char") == 0
633 || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type
)))))
637 else if (options
->objectprint
638 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
641 if (TYPE_CODE(type
) == TYPE_CODE_REF
)
643 /* Copy value, change to pointer, so we don't get an
644 * error about a non-pointer type in value_rtti_target_type
646 struct value
*temparg
;
647 temparg
=value_copy(val
);
648 deprecated_set_value_type (temparg
, lookup_pointer_type (TYPE_TARGET_TYPE(type
)));
651 /* Pointer to class, check real type of object */
652 fprintf_filtered (stream
, "(");
653 real_type
= value_rtti_target_type (val
, &full
, &top
, &using_enc
);
656 /* RTTI entry found */
657 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
659 /* create a pointer type pointing to the real type */
660 type
= lookup_pointer_type (real_type
);
664 /* create a reference type referencing the real type */
665 type
= lookup_reference_type (real_type
);
667 /* JYG: Need to adjust pointer value. */
668 /* NOTE: cagney/2005-01-02: THIS IS BOGUS. */
669 value_contents_writeable (val
)[0] -= top
;
671 /* Note: When we look up RTTI entries, we don't get any
672 information on const or volatile attributes */
674 type_print (type
, "", stream
, -1);
675 fprintf_filtered (stream
, ") ");
681 fprintf_filtered (stream
, "(");
682 type_print (value_type (val
), "", stream
, -1);
683 fprintf_filtered (stream
, ") ");
687 if (!value_initialized (val
))
688 fprintf_filtered (stream
, " [uninitialized] ");
690 if (options
->objectprint
&& (TYPE_CODE (type
) == TYPE_CODE_CLASS
))
692 /* Attempt to determine real type of object */
693 real_type
= value_rtti_type (val
, &full
, &top
, &using_enc
);
696 /* We have RTTI information, so use it */
697 val
= value_full_object (val
, real_type
, full
, top
, using_enc
);
698 fprintf_filtered (stream
, "(%s%s) ",
699 TYPE_NAME (real_type
),
700 full
? "" : _(" [incomplete object]"));
701 /* Print out object: enclosing type is same as real_type if full */
702 return val_print (value_enclosing_type (val
),
703 value_contents_for_printing (val
), 0,
704 value_address (val
), stream
, 0,
705 val
, &opts
, current_language
);
706 /* Note: When we look up RTTI entries, we don't get any information on
707 const or volatile attributes */
709 else if (type
!= check_typedef (value_enclosing_type (val
)))
711 /* No RTTI information, so let's do our best */
712 fprintf_filtered (stream
, "(%s ?) ",
713 TYPE_NAME (value_enclosing_type (val
)));
714 return val_print (value_enclosing_type (val
),
715 value_contents_for_printing (val
), 0,
716 value_address (val
), stream
, 0,
717 val
, &opts
, current_language
);
719 /* Otherwise, we end up at the return outside this "if" */
722 return val_print (val_type
, value_contents_for_printing (val
),
723 value_embedded_offset (val
),
726 val
, &opts
, current_language
);