1 /* Support for printing C values for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "expression.h"
33 /* A helper for c_textual_element_type. This checks the name of the
34 typedef. This is bogus but it isn't apparent that the compiler
35 provides us the help we may need. */
38 textual_name (const char *name
)
40 return (!strcmp (name
, "wchar_t")
41 || !strcmp (name
, "char16_t")
42 || !strcmp (name
, "char32_t"));
45 /* Apply a heuristic to decide whether an array of TYPE or a pointer
46 to TYPE should be printed as a textual string. Return non-zero if
47 it should, or zero if it should be treated as an array of integers
48 or pointer to integers. FORMAT is the current format letter, or 0
51 We guess that "char" is a character. Explicitly signed and
52 unsigned character types are also characters. Integer data from
53 vector types is not. The user can override this by using the /s
57 c_textual_element_type (struct type
*type
, char format
)
59 struct type
*true_type
, *iter_type
;
61 if (format
!= 0 && format
!= 's')
64 /* We also rely on this for its side effect of setting up all the
66 true_type
= check_typedef (type
);
68 /* TYPE_CODE_CHAR is always textual. */
69 if (TYPE_CODE (true_type
) == TYPE_CODE_CHAR
)
72 /* Any other character-like types must be integral. */
73 if (TYPE_CODE (true_type
) != TYPE_CODE_INT
)
76 /* We peel typedefs one by one, looking for a match. */
80 /* Check the name of the type. */
81 if (TYPE_NAME (iter_type
) && textual_name (TYPE_NAME (iter_type
)))
84 if (TYPE_CODE (iter_type
) != TYPE_CODE_TYPEDEF
)
87 /* Peel a single typedef. If the typedef doesn't have a target
88 type, we use check_typedef and hope the result is ok -- it
89 might be for C++, where wchar_t is a built-in type. */
90 if (TYPE_TARGET_TYPE (iter_type
))
91 iter_type
= TYPE_TARGET_TYPE (iter_type
);
93 iter_type
= check_typedef (iter_type
);
98 /* Print this as a string if we can manage it. For now, no wide
100 if (TYPE_CODE (true_type
) == TYPE_CODE_INT
101 && TYPE_LENGTH (true_type
) == 1)
106 /* If a one-byte TYPE_CODE_INT is missing the not-a-character
107 flag, then we treat it as text; otherwise, we assume it's
108 being used as data. */
109 if (TYPE_CODE (true_type
) == TYPE_CODE_INT
110 && TYPE_LENGTH (true_type
) == 1
111 && !TYPE_NOTTEXT (true_type
))
118 /* Decorations for C. */
120 static const struct generic_val_print_decorations c_decorations
=
132 /* Print a pointer based on the type of its target.
134 Arguments to this functions are roughly the same as those in c_val_print.
135 A difference is that ADDRESS is the address to print, with embedded_offset
136 already added. UNRESOLVED_ELTTYPE and ELTTYPE represent the pointed type,
137 respectively before and after check_typedef. */
140 print_unpacked_pointer (struct type
*type
, struct type
*elttype
,
141 struct type
*unresolved_elttype
,
142 const gdb_byte
*valaddr
, int embedded_offset
,
143 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
144 const struct value_print_options
*options
)
147 struct gdbarch
*gdbarch
= get_type_arch (type
);
149 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
151 /* Try to print what function it points to. */
152 print_function_pointer_address (options
, gdbarch
, address
, stream
);
156 if (options
->symbol_print
)
157 want_space
= print_address_demangle (options
, gdbarch
, address
, stream
,
159 else if (options
->addressprint
)
161 fputs_filtered (paddress (gdbarch
, address
), stream
);
165 /* For a pointer to a textual type, also print the string
166 pointed to, unless pointer is null. */
168 if (c_textual_element_type (unresolved_elttype
, options
->format
)
172 fputs_filtered (" ", stream
);
173 val_print_string (unresolved_elttype
, NULL
, address
, -1, stream
, options
);
175 else if (cp_is_vtbl_member (type
))
177 /* Print vtbl's nicely. */
178 CORE_ADDR vt_address
= unpack_pointer (type
, valaddr
+ embedded_offset
);
179 struct bound_minimal_symbol msymbol
=
180 lookup_minimal_symbol_by_pc (vt_address
);
182 /* If 'symbol_print' is set, we did the work above. */
183 if (!options
->symbol_print
184 && (msymbol
.minsym
!= NULL
)
185 && (vt_address
== BMSYMBOL_VALUE_ADDRESS (msymbol
)))
188 fputs_filtered (" ", stream
);
189 fputs_filtered (" <", stream
);
190 fputs_filtered (msymbol
.minsym
->print_name (), stream
);
191 fputs_filtered (">", stream
);
195 if (vt_address
&& options
->vtblprint
)
197 struct value
*vt_val
;
198 struct symbol
*wsym
= NULL
;
202 fputs_filtered (" ", stream
);
204 if (msymbol
.minsym
!= NULL
)
206 const char *search_name
= msymbol
.minsym
->search_name ();
207 wsym
= lookup_symbol_search_name (search_name
, NULL
,
213 wtype
= SYMBOL_TYPE (wsym
);
217 wtype
= unresolved_elttype
;
219 vt_val
= value_at (wtype
, vt_address
);
220 common_val_print (vt_val
, stream
, recurse
+ 1, options
,
222 if (options
->prettyformat
)
224 fprintf_filtered (stream
, "\n");
225 print_spaces_filtered (2 + 2 * recurse
, stream
);
231 /* c_val_print helper for TYPE_CODE_ARRAY. */
234 c_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
235 int embedded_offset
, CORE_ADDR address
,
236 struct ui_file
*stream
, int recurse
,
237 struct value
*original_value
,
238 const struct value_print_options
*options
)
240 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE (type
);
241 struct type
*elttype
= check_typedef (unresolved_elttype
);
242 struct gdbarch
*arch
= get_type_arch (type
);
243 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
245 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (unresolved_elttype
) > 0)
247 LONGEST low_bound
, high_bound
;
249 enum bfd_endian byte_order
= type_byte_order (type
);
251 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
252 error (_("Could not determine the array high bound"));
254 eltlen
= TYPE_LENGTH (elttype
);
255 len
= high_bound
- low_bound
+ 1;
256 if (options
->prettyformat_arrays
)
258 print_spaces_filtered (2 + 2 * recurse
, stream
);
261 /* Print arrays of textual chars with a string syntax, as
262 long as the entire array is valid. */
263 if (c_textual_element_type (unresolved_elttype
,
265 && value_bytes_available (original_value
, embedded_offset
,
267 && !value_bits_any_optimized_out (original_value
,
268 TARGET_CHAR_BIT
* embedded_offset
,
269 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
271 int force_ellipses
= 0;
273 /* If requested, look for the first null char and only
274 print elements up to it. */
275 if (options
->stop_print_at_null
)
277 unsigned int temp_len
;
281 && temp_len
< options
->print_max
282 && extract_unsigned_integer (valaddr
283 + embedded_offset
* unit_size
285 eltlen
, byte_order
) != 0);
289 /* Force LA_PRINT_STRING to print ellipses if
290 we've printed the maximum characters and
291 the next character is not \000. */
292 if (temp_len
== options
->print_max
&& temp_len
< len
)
295 = extract_unsigned_integer (valaddr
296 + embedded_offset
* unit_size
306 LA_PRINT_STRING (stream
, unresolved_elttype
,
307 valaddr
+ embedded_offset
* unit_size
, len
,
308 NULL
, force_ellipses
, options
);
313 fprintf_filtered (stream
, "{");
314 /* If this is a virtual function table, print the 0th
315 entry specially, and the rest of the members
317 if (cp_is_vtbl_ptr_type (elttype
))
320 fprintf_filtered (stream
, _("%d vtable entries"),
323 val_print_array_elements (type
, embedded_offset
,
325 recurse
, original_value
, options
, i
);
326 fprintf_filtered (stream
, "}");
331 /* Array of unspecified length: treat like pointer to first elt. */
332 print_unpacked_pointer (type
, elttype
, unresolved_elttype
, valaddr
,
333 embedded_offset
, address
+ embedded_offset
,
334 stream
, recurse
, options
);
338 /* c_value_print helper for TYPE_CODE_ARRAY. */
341 c_value_print_array (struct value
*val
,
342 struct ui_file
*stream
, int recurse
,
343 const struct value_print_options
*options
)
345 struct type
*type
= check_typedef (value_type (val
));
346 CORE_ADDR address
= value_address (val
);
347 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
348 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE (type
);
349 struct type
*elttype
= check_typedef (unresolved_elttype
);
351 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (unresolved_elttype
) > 0)
353 LONGEST low_bound
, high_bound
;
355 enum bfd_endian byte_order
= type_byte_order (type
);
357 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
358 error (_("Could not determine the array high bound"));
360 eltlen
= TYPE_LENGTH (elttype
);
361 len
= high_bound
- low_bound
+ 1;
362 if (options
->prettyformat_arrays
)
364 print_spaces_filtered (2 + 2 * recurse
, stream
);
367 /* Print arrays of textual chars with a string syntax, as
368 long as the entire array is valid. */
369 if (c_textual_element_type (unresolved_elttype
,
371 && value_bytes_available (val
, 0, TYPE_LENGTH (type
))
372 && !value_bits_any_optimized_out (val
, 0,
373 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
375 int force_ellipses
= 0;
377 /* If requested, look for the first null char and only
378 print elements up to it. */
379 if (options
->stop_print_at_null
)
381 unsigned int temp_len
;
385 && temp_len
< options
->print_max
386 && extract_unsigned_integer (valaddr
+ temp_len
* eltlen
,
387 eltlen
, byte_order
) != 0);
391 /* Force LA_PRINT_STRING to print ellipses if
392 we've printed the maximum characters and
393 the next character is not \000. */
394 if (temp_len
== options
->print_max
&& temp_len
< len
)
397 = extract_unsigned_integer (valaddr
+ temp_len
* eltlen
,
406 LA_PRINT_STRING (stream
, unresolved_elttype
, valaddr
, len
,
407 NULL
, force_ellipses
, options
);
412 fprintf_filtered (stream
, "{");
413 /* If this is a virtual function table, print the 0th
414 entry specially, and the rest of the members
416 if (cp_is_vtbl_ptr_type (elttype
))
419 fprintf_filtered (stream
, _("%d vtable entries"),
422 value_print_array_elements (val
, stream
, recurse
, options
, i
);
423 fprintf_filtered (stream
, "}");
428 /* Array of unspecified length: treat like pointer to first elt. */
429 print_unpacked_pointer (type
, elttype
, unresolved_elttype
, valaddr
,
430 0, address
, stream
, recurse
, options
);
434 /* c_val_print helper for TYPE_CODE_PTR. */
437 c_val_print_ptr (struct type
*type
, const gdb_byte
*valaddr
,
438 int embedded_offset
, struct ui_file
*stream
, int recurse
,
439 struct value
*original_value
,
440 const struct value_print_options
*options
)
442 struct gdbarch
*arch
= get_type_arch (type
);
443 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
445 if (options
->format
&& options
->format
!= 's')
447 val_print_scalar_formatted (type
, embedded_offset
,
448 original_value
, options
, 0, stream
);
450 else if (options
->vtblprint
&& cp_is_vtbl_ptr_type (type
))
452 /* Print the unmangled name if desired. */
453 /* Print vtable entry - we only get here if we ARE using
454 -fvtable_thunks. (Otherwise, look under
455 TYPE_CODE_STRUCT.) */
457 = extract_typed_address (valaddr
+ embedded_offset
, type
);
458 struct gdbarch
*gdbarch
= get_type_arch (type
);
460 print_function_pointer_address (options
, gdbarch
, addr
, stream
);
464 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE (type
);
465 struct type
*elttype
= check_typedef (unresolved_elttype
);
466 CORE_ADDR addr
= unpack_pointer (type
,
467 valaddr
+ embedded_offset
* unit_size
);
469 print_unpacked_pointer (type
, elttype
, unresolved_elttype
, valaddr
,
470 embedded_offset
, addr
, stream
, recurse
, options
);
474 /* c_value_print_inner helper for TYPE_CODE_PTR. */
477 c_value_print_ptr (struct value
*val
, struct ui_file
*stream
, int recurse
,
478 const struct value_print_options
*options
)
480 if (options
->format
&& options
->format
!= 's')
482 value_print_scalar_formatted (val
, options
, 0, stream
);
486 struct type
*type
= check_typedef (value_type (val
));
487 struct gdbarch
*arch
= get_type_arch (type
);
488 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
490 if (options
->vtblprint
&& cp_is_vtbl_ptr_type (type
))
492 /* Print the unmangled name if desired. */
493 /* Print vtable entry - we only get here if we ARE using
494 -fvtable_thunks. (Otherwise, look under
495 TYPE_CODE_STRUCT.) */
496 CORE_ADDR addr
= extract_typed_address (valaddr
, type
);
498 print_function_pointer_address (options
, arch
, addr
, stream
);
502 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE (type
);
503 struct type
*elttype
= check_typedef (unresolved_elttype
);
504 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
506 print_unpacked_pointer (type
, elttype
, unresolved_elttype
, valaddr
,
507 0, addr
, stream
, recurse
, options
);
511 /* c_val_print helper for TYPE_CODE_STRUCT. */
514 c_val_print_struct (struct type
*type
, const gdb_byte
*valaddr
,
515 int embedded_offset
, CORE_ADDR address
,
516 struct ui_file
*stream
, int recurse
,
517 struct value
*original_value
,
518 const struct value_print_options
*options
)
520 if (options
->vtblprint
&& cp_is_vtbl_ptr_type (type
))
522 /* Print the unmangled name if desired. */
523 /* Print vtable entry - we only get here if NOT using
524 -fvtable_thunks. (Otherwise, look under
526 struct gdbarch
*gdbarch
= get_type_arch (type
);
527 int offset
= (embedded_offset
528 + TYPE_FIELD_BITPOS (type
,
529 VTBL_FNADDR_OFFSET
) / 8);
530 struct type
*field_type
= TYPE_FIELD_TYPE (type
, VTBL_FNADDR_OFFSET
);
531 CORE_ADDR addr
= extract_typed_address (valaddr
+ offset
, field_type
);
533 print_function_pointer_address (options
, gdbarch
, addr
, stream
);
536 cp_print_value_fields_rtti (type
, valaddr
,
537 embedded_offset
, address
,
539 original_value
, options
,
543 /* c_val_print helper for TYPE_CODE_UNION. */
546 c_val_print_union (struct type
*type
, const gdb_byte
*valaddr
,
547 int embedded_offset
, CORE_ADDR address
,
548 struct ui_file
*stream
, int recurse
,
549 struct value
*original_value
,
550 const struct value_print_options
*options
)
552 if (recurse
&& !options
->unionprint
)
554 fprintf_filtered (stream
, "{...}");
558 c_val_print_struct (type
, valaddr
, embedded_offset
, address
, stream
,
559 recurse
, original_value
, options
);
563 /* c_val_print helper for TYPE_CODE_INT. */
566 c_val_print_int (struct type
*type
, struct type
*unresolved_type
,
567 const gdb_byte
*valaddr
, int embedded_offset
,
568 struct ui_file
*stream
, struct value
*original_value
,
569 const struct value_print_options
*options
)
571 struct gdbarch
*arch
= get_type_arch (type
);
572 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
574 if (options
->format
|| options
->output_format
)
576 struct value_print_options opts
= *options
;
578 opts
.format
= (options
->format
? options
->format
579 : options
->output_format
);
580 val_print_scalar_formatted (type
, embedded_offset
,
581 original_value
, &opts
, 0, stream
);
585 val_print_scalar_formatted (type
, embedded_offset
,
586 original_value
, options
, 0, stream
);
587 /* C and C++ has no single byte int type, char is used
588 instead. Since we don't know whether the value is really
589 intended to be used as an integer or a character, print
590 the character equivalent as well. */
591 if (c_textual_element_type (unresolved_type
, options
->format
))
593 fputs_filtered (" ", stream
);
594 LA_PRINT_CHAR (unpack_long (type
,
595 valaddr
+ embedded_offset
* unit_size
),
596 unresolved_type
, stream
);
601 /* c_value_print helper for TYPE_CODE_INT. */
604 c_value_print_int (struct value
*val
, struct ui_file
*stream
,
605 const struct value_print_options
*options
)
607 if (options
->format
|| options
->output_format
)
609 struct value_print_options opts
= *options
;
611 opts
.format
= (options
->format
? options
->format
612 : options
->output_format
);
613 value_print_scalar_formatted (val
, &opts
, 0, stream
);
617 value_print_scalar_formatted (val
, options
, 0, stream
);
618 /* C and C++ has no single byte int type, char is used
619 instead. Since we don't know whether the value is really
620 intended to be used as an integer or a character, print
621 the character equivalent as well. */
622 struct type
*type
= value_type (val
);
623 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
624 if (c_textual_element_type (type
, options
->format
))
626 fputs_filtered (" ", stream
);
627 LA_PRINT_CHAR (unpack_long (type
, valaddr
), type
, stream
);
632 /* c_val_print helper for TYPE_CODE_MEMBERPTR. */
635 c_val_print_memberptr (struct type
*type
, const gdb_byte
*valaddr
,
636 int embedded_offset
, CORE_ADDR address
,
637 struct ui_file
*stream
, int recurse
,
638 struct value
*original_value
,
639 const struct value_print_options
*options
)
641 if (!options
->format
)
643 cp_print_class_member (valaddr
+ embedded_offset
, type
, stream
, "&");
647 generic_val_print (type
, embedded_offset
, address
, stream
,
648 recurse
, original_value
, options
, &c_decorations
);
652 /* c_value_print helper for TYPE_CODE_MEMBERPTR. */
655 c_value_print_memberptr (struct value
*val
, struct ui_file
*stream
,
657 const struct value_print_options
*options
)
659 if (!options
->format
)
661 struct type
*type
= check_typedef (value_type (val
));
662 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
663 cp_print_class_member (valaddr
, type
, stream
, "&");
666 generic_value_print (val
, stream
, recurse
, options
, &c_decorations
);
669 /* See val_print for a description of the various parameters of this
670 function; they are identical. */
673 c_val_print (struct type
*type
,
674 int embedded_offset
, CORE_ADDR address
,
675 struct ui_file
*stream
, int recurse
,
676 struct value
*original_value
,
677 const struct value_print_options
*options
)
679 struct type
*unresolved_type
= type
;
680 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
682 type
= check_typedef (type
);
683 switch (TYPE_CODE (type
))
685 case TYPE_CODE_ARRAY
:
686 c_val_print_array (type
, valaddr
, embedded_offset
, address
, stream
,
687 recurse
, original_value
, options
);
690 case TYPE_CODE_METHODPTR
:
691 cplus_print_method_ptr (valaddr
+ embedded_offset
, type
, stream
);
695 c_val_print_ptr (type
, valaddr
, embedded_offset
, stream
, recurse
,
696 original_value
, options
);
699 case TYPE_CODE_UNION
:
700 c_val_print_union (type
, valaddr
, embedded_offset
, address
, stream
,
701 recurse
, original_value
, options
);
704 case TYPE_CODE_STRUCT
:
705 c_val_print_struct (type
, valaddr
, embedded_offset
, address
, stream
,
706 recurse
, original_value
, options
);
710 c_val_print_int (type
, unresolved_type
, valaddr
, embedded_offset
, stream
,
711 original_value
, options
);
714 case TYPE_CODE_MEMBERPTR
:
715 c_val_print_memberptr (type
, valaddr
, embedded_offset
, address
, stream
,
716 recurse
, original_value
, options
);
720 case TYPE_CODE_RVALUE_REF
:
722 case TYPE_CODE_FLAGS
:
724 case TYPE_CODE_METHOD
:
726 case TYPE_CODE_RANGE
:
728 case TYPE_CODE_DECFLOAT
:
730 case TYPE_CODE_ERROR
:
731 case TYPE_CODE_UNDEF
:
732 case TYPE_CODE_COMPLEX
:
735 generic_val_print (type
, embedded_offset
, address
,
736 stream
, recurse
, original_value
, options
,
745 c_value_print_inner (struct value
*val
, struct ui_file
*stream
, int recurse
,
746 const struct value_print_options
*options
)
748 struct type
*type
= value_type (val
);
749 CORE_ADDR address
= value_address (val
);
750 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
752 type
= check_typedef (type
);
753 switch (TYPE_CODE (type
))
755 case TYPE_CODE_ARRAY
:
756 c_value_print_array (val
, stream
, recurse
, options
);
759 case TYPE_CODE_METHODPTR
:
760 cplus_print_method_ptr (valaddr
, type
, stream
);
764 c_value_print_ptr (val
, stream
, recurse
, options
);
767 case TYPE_CODE_UNION
:
768 c_val_print_union (type
, valaddr
, 0, address
, stream
,
769 recurse
, val
, options
);
772 case TYPE_CODE_STRUCT
:
773 c_val_print_struct (type
, valaddr
, 0, address
, stream
,
774 recurse
, val
, options
);
778 c_value_print_int (val
, stream
, options
);
781 case TYPE_CODE_MEMBERPTR
:
782 c_value_print_memberptr (val
, stream
, recurse
, options
);
786 case TYPE_CODE_RVALUE_REF
:
788 case TYPE_CODE_FLAGS
:
790 case TYPE_CODE_METHOD
:
792 case TYPE_CODE_RANGE
:
794 case TYPE_CODE_DECFLOAT
:
796 case TYPE_CODE_ERROR
:
797 case TYPE_CODE_UNDEF
:
798 case TYPE_CODE_COMPLEX
:
801 generic_value_print (val
, stream
, recurse
, options
, &c_decorations
);
808 c_value_print (struct value
*val
, struct ui_file
*stream
,
809 const struct value_print_options
*options
)
811 struct type
*type
, *real_type
;
814 struct value_print_options opts
= *options
;
818 /* If it is a pointer, indicate what it points to.
820 Print type also if it is a reference.
822 C++: if it is a member pointer, we will take care
823 of that when we print it. */
825 type
= check_typedef (value_type (val
));
827 if (TYPE_CODE (type
) == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (type
))
829 struct type
*original_type
= value_type (val
);
831 /* Hack: remove (char *) for char strings. Their
832 type is indicated by the quoted string anyway.
833 (Don't use c_textual_element_type here; quoted strings
834 are always exactly (char *), (wchar_t *), or the like. */
835 if (TYPE_CODE (original_type
) == TYPE_CODE_PTR
836 && TYPE_NAME (original_type
) == NULL
837 && TYPE_NAME (TYPE_TARGET_TYPE (original_type
)) != NULL
838 && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (original_type
)),
840 || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (original_type
)))))
844 else if (options
->objectprint
845 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
847 int is_ref
= TYPE_IS_REFERENCE (type
);
848 enum type_code refcode
= TYPE_CODE_UNDEF
;
852 val
= value_addr (val
);
853 refcode
= TYPE_CODE (type
);
856 /* Pointer to class, check real type of object. */
857 fprintf_filtered (stream
, "(");
859 if (value_entirely_available (val
))
861 real_type
= value_rtti_indirect_type (val
, &full
, &top
,
865 /* RTTI entry found. */
867 /* Need to adjust pointer value. */
868 val
= value_from_pointer (real_type
,
869 value_as_address (val
) - top
);
871 /* Note: When we look up RTTI entries, we don't get
872 any information on const or volatile
878 val
= value_ref (value_ind (val
), refcode
);
880 type
= value_type (val
);
881 type_print (type
, "", stream
, -1);
882 fprintf_filtered (stream
, ") ");
887 fprintf_filtered (stream
, "(");
888 type_print (value_type (val
), "", stream
, -1);
889 fprintf_filtered (stream
, ") ");
893 if (!value_initialized (val
))
894 fprintf_filtered (stream
, " [uninitialized] ");
896 if (options
->objectprint
&& (TYPE_CODE (type
) == TYPE_CODE_STRUCT
))
898 /* Attempt to determine real type of object. */
899 real_type
= value_rtti_type (val
, &full
, &top
, &using_enc
);
902 /* We have RTTI information, so use it. */
903 val
= value_full_object (val
, real_type
,
904 full
, top
, using_enc
);
905 /* In a destructor we might see a real type that is a
906 superclass of the object's type. In this case it is
907 better to leave the object as-is. */
909 && (TYPE_LENGTH (real_type
)
910 < TYPE_LENGTH (value_enclosing_type (val
)))))
911 val
= value_cast (real_type
, val
);
912 fprintf_filtered (stream
, "(%s%s) ",
913 TYPE_NAME (real_type
),
914 full
? "" : _(" [incomplete object]"));
916 else if (type
!= check_typedef (value_enclosing_type (val
)))
918 /* No RTTI information, so let's do our best. */
919 fprintf_filtered (stream
, "(%s ?) ",
920 TYPE_NAME (value_enclosing_type (val
)));
921 val
= value_cast (value_enclosing_type (val
), val
);
925 common_val_print (val
, stream
, 0, &opts
, current_language
);