1 /* Support for printing C values for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 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_PRINT_NAME (msymbol
.minsym
), 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
207 = MSYMBOL_SEARCH_NAME (msymbol
.minsym
);
208 wsym
= lookup_symbol_search_name (search_name
, NULL
,
214 wtype
= SYMBOL_TYPE (wsym
);
218 wtype
= unresolved_elttype
;
220 vt_val
= value_at (wtype
, vt_address
);
221 common_val_print (vt_val
, stream
, recurse
+ 1, options
,
223 if (options
->prettyformat
)
225 fprintf_filtered (stream
, "\n");
226 print_spaces_filtered (2 + 2 * recurse
, stream
);
232 /* c_val_print helper for TYPE_CODE_ARRAY. */
235 c_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
236 int embedded_offset
, CORE_ADDR address
,
237 struct ui_file
*stream
, int recurse
,
238 struct value
*original_value
,
239 const struct value_print_options
*options
)
241 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE (type
);
242 struct type
*elttype
= check_typedef (unresolved_elttype
);
243 struct gdbarch
*arch
= get_type_arch (type
);
244 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
246 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (unresolved_elttype
) > 0)
248 LONGEST low_bound
, high_bound
;
250 enum bfd_endian byte_order
= type_byte_order (type
);
251 unsigned int i
= 0; /* Number of characters printed. */
253 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
254 error (_("Could not determine the array high bound"));
256 eltlen
= TYPE_LENGTH (elttype
);
257 len
= high_bound
- low_bound
+ 1;
258 if (options
->prettyformat_arrays
)
260 print_spaces_filtered (2 + 2 * recurse
, stream
);
263 /* Print arrays of textual chars with a string syntax, as
264 long as the entire array is valid. */
265 if (c_textual_element_type (unresolved_elttype
,
267 && value_bytes_available (original_value
, embedded_offset
,
269 && !value_bits_any_optimized_out (original_value
,
270 TARGET_CHAR_BIT
* embedded_offset
,
271 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
273 int force_ellipses
= 0;
275 /* If requested, look for the first null char and only
276 print elements up to it. */
277 if (options
->stop_print_at_null
)
279 unsigned int temp_len
;
283 && temp_len
< options
->print_max
284 && extract_unsigned_integer (valaddr
285 + embedded_offset
* unit_size
287 eltlen
, byte_order
) != 0);
291 /* Force LA_PRINT_STRING to print ellipses if
292 we've printed the maximum characters and
293 the next character is not \000. */
294 if (temp_len
== options
->print_max
&& temp_len
< len
)
297 = extract_unsigned_integer (valaddr
298 + embedded_offset
* unit_size
308 LA_PRINT_STRING (stream
, unresolved_elttype
,
309 valaddr
+ embedded_offset
* unit_size
, len
,
310 NULL
, force_ellipses
, options
);
315 fprintf_filtered (stream
, "{");
316 /* If this is a virtual function table, print the 0th
317 entry specially, and the rest of the members
319 if (cp_is_vtbl_ptr_type (elttype
))
322 fprintf_filtered (stream
, _("%d vtable entries"),
329 val_print_array_elements (type
, embedded_offset
,
331 recurse
, original_value
, options
, i
);
332 fprintf_filtered (stream
, "}");
337 /* Array of unspecified length: treat like pointer to first elt. */
338 print_unpacked_pointer (type
, elttype
, unresolved_elttype
, valaddr
,
339 embedded_offset
, address
+ embedded_offset
,
340 stream
, recurse
, options
);
344 /* c_val_print helper for TYPE_CODE_PTR. */
347 c_val_print_ptr (struct type
*type
, const gdb_byte
*valaddr
,
348 int embedded_offset
, struct ui_file
*stream
, int recurse
,
349 struct value
*original_value
,
350 const struct value_print_options
*options
)
352 struct gdbarch
*arch
= get_type_arch (type
);
353 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
355 if (options
->format
&& options
->format
!= 's')
357 val_print_scalar_formatted (type
, embedded_offset
,
358 original_value
, options
, 0, stream
);
360 else if (options
->vtblprint
&& cp_is_vtbl_ptr_type (type
))
362 /* Print the unmangled name if desired. */
363 /* Print vtable entry - we only get here if we ARE using
364 -fvtable_thunks. (Otherwise, look under
365 TYPE_CODE_STRUCT.) */
367 = extract_typed_address (valaddr
+ embedded_offset
, type
);
368 struct gdbarch
*gdbarch
= get_type_arch (type
);
370 print_function_pointer_address (options
, gdbarch
, addr
, stream
);
374 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE (type
);
375 struct type
*elttype
= check_typedef (unresolved_elttype
);
376 CORE_ADDR addr
= unpack_pointer (type
,
377 valaddr
+ embedded_offset
* unit_size
);
379 print_unpacked_pointer (type
, elttype
, unresolved_elttype
, valaddr
,
380 embedded_offset
, addr
, stream
, recurse
, options
);
384 /* c_val_print helper for TYPE_CODE_STRUCT. */
387 c_val_print_struct (struct type
*type
, const gdb_byte
*valaddr
,
388 int embedded_offset
, CORE_ADDR address
,
389 struct ui_file
*stream
, int recurse
,
390 struct value
*original_value
,
391 const struct value_print_options
*options
)
393 if (options
->vtblprint
&& cp_is_vtbl_ptr_type (type
))
395 /* Print the unmangled name if desired. */
396 /* Print vtable entry - we only get here if NOT using
397 -fvtable_thunks. (Otherwise, look under
399 struct gdbarch
*gdbarch
= get_type_arch (type
);
400 int offset
= (embedded_offset
401 + TYPE_FIELD_BITPOS (type
,
402 VTBL_FNADDR_OFFSET
) / 8);
403 struct type
*field_type
= TYPE_FIELD_TYPE (type
, VTBL_FNADDR_OFFSET
);
404 CORE_ADDR addr
= extract_typed_address (valaddr
+ offset
, field_type
);
406 print_function_pointer_address (options
, gdbarch
, addr
, stream
);
409 cp_print_value_fields_rtti (type
, valaddr
,
410 embedded_offset
, address
,
412 original_value
, options
,
416 /* c_val_print helper for TYPE_CODE_UNION. */
419 c_val_print_union (struct type
*type
, const gdb_byte
*valaddr
,
420 int embedded_offset
, CORE_ADDR address
,
421 struct ui_file
*stream
, int recurse
,
422 struct value
*original_value
,
423 const struct value_print_options
*options
)
425 if (recurse
&& !options
->unionprint
)
427 fprintf_filtered (stream
, "{...}");
431 c_val_print_struct (type
, valaddr
, embedded_offset
, address
, stream
,
432 recurse
, original_value
, options
);
436 /* c_val_print helper for TYPE_CODE_INT. */
439 c_val_print_int (struct type
*type
, struct type
*unresolved_type
,
440 const gdb_byte
*valaddr
, int embedded_offset
,
441 struct ui_file
*stream
, struct value
*original_value
,
442 const struct value_print_options
*options
)
444 struct gdbarch
*arch
= get_type_arch (type
);
445 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
447 if (options
->format
|| options
->output_format
)
449 struct value_print_options opts
= *options
;
451 opts
.format
= (options
->format
? options
->format
452 : options
->output_format
);
453 val_print_scalar_formatted (type
, embedded_offset
,
454 original_value
, &opts
, 0, stream
);
458 val_print_scalar_formatted (type
, embedded_offset
,
459 original_value
, options
, 0, stream
);
460 /* C and C++ has no single byte int type, char is used
461 instead. Since we don't know whether the value is really
462 intended to be used as an integer or a character, print
463 the character equivalent as well. */
464 if (c_textual_element_type (unresolved_type
, options
->format
))
466 fputs_filtered (" ", stream
);
467 LA_PRINT_CHAR (unpack_long (type
,
468 valaddr
+ embedded_offset
* unit_size
),
469 unresolved_type
, stream
);
474 /* c_val_print helper for TYPE_CODE_MEMBERPTR. */
477 c_val_print_memberptr (struct type
*type
, const gdb_byte
*valaddr
,
478 int embedded_offset
, CORE_ADDR address
,
479 struct ui_file
*stream
, int recurse
,
480 struct value
*original_value
,
481 const struct value_print_options
*options
)
483 if (!options
->format
)
485 cp_print_class_member (valaddr
+ embedded_offset
, type
, stream
, "&");
489 generic_val_print (type
, embedded_offset
, address
, stream
,
490 recurse
, original_value
, options
, &c_decorations
);
494 /* See val_print for a description of the various parameters of this
495 function; they are identical. */
498 c_val_print (struct type
*type
,
499 int embedded_offset
, CORE_ADDR address
,
500 struct ui_file
*stream
, int recurse
,
501 struct value
*original_value
,
502 const struct value_print_options
*options
)
504 struct type
*unresolved_type
= type
;
505 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
507 type
= check_typedef (type
);
508 switch (TYPE_CODE (type
))
510 case TYPE_CODE_ARRAY
:
511 c_val_print_array (type
, valaddr
, embedded_offset
, address
, stream
,
512 recurse
, original_value
, options
);
515 case TYPE_CODE_METHODPTR
:
516 cplus_print_method_ptr (valaddr
+ embedded_offset
, type
, stream
);
520 c_val_print_ptr (type
, valaddr
, embedded_offset
, stream
, recurse
,
521 original_value
, options
);
524 case TYPE_CODE_UNION
:
525 c_val_print_union (type
, valaddr
, embedded_offset
, address
, stream
,
526 recurse
, original_value
, options
);
529 case TYPE_CODE_STRUCT
:
530 c_val_print_struct (type
, valaddr
, embedded_offset
, address
, stream
,
531 recurse
, original_value
, options
);
535 c_val_print_int (type
, unresolved_type
, valaddr
, embedded_offset
, stream
,
536 original_value
, options
);
539 case TYPE_CODE_MEMBERPTR
:
540 c_val_print_memberptr (type
, valaddr
, embedded_offset
, address
, stream
,
541 recurse
, original_value
, options
);
545 case TYPE_CODE_RVALUE_REF
:
547 case TYPE_CODE_FLAGS
:
549 case TYPE_CODE_METHOD
:
551 case TYPE_CODE_RANGE
:
553 case TYPE_CODE_DECFLOAT
:
555 case TYPE_CODE_ERROR
:
556 case TYPE_CODE_UNDEF
:
557 case TYPE_CODE_COMPLEX
:
560 generic_val_print (type
, embedded_offset
, address
,
561 stream
, recurse
, original_value
, options
,
568 c_value_print (struct value
*val
, struct ui_file
*stream
,
569 const struct value_print_options
*options
)
571 struct type
*type
, *real_type
, *val_type
;
574 struct value_print_options opts
= *options
;
578 /* If it is a pointer, indicate what it points to.
580 Print type also if it is a reference.
582 C++: if it is a member pointer, we will take care
583 of that when we print it. */
585 /* Preserve the original type before stripping typedefs. We prefer
586 to pass down the original type when possible, but for local
587 checks it is better to look past the typedefs. */
588 val_type
= value_type (val
);
589 type
= check_typedef (val_type
);
591 if (TYPE_CODE (type
) == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (type
))
593 /* Hack: remove (char *) for char strings. Their
594 type is indicated by the quoted string anyway.
595 (Don't use c_textual_element_type here; quoted strings
596 are always exactly (char *), (wchar_t *), or the like. */
597 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
598 && TYPE_NAME (val_type
) == NULL
599 && TYPE_NAME (TYPE_TARGET_TYPE (val_type
)) != NULL
600 && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type
)),
602 || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type
)))))
606 else if (options
->objectprint
607 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
609 int is_ref
= TYPE_IS_REFERENCE (type
);
610 enum type_code refcode
= TYPE_CODE_UNDEF
;
614 val
= value_addr (val
);
615 refcode
= TYPE_CODE (type
);
618 /* Pointer to class, check real type of object. */
619 fprintf_filtered (stream
, "(");
621 if (value_entirely_available (val
))
623 real_type
= value_rtti_indirect_type (val
, &full
, &top
,
627 /* RTTI entry found. */
630 /* Need to adjust pointer value. */
631 val
= value_from_pointer (real_type
,
632 value_as_address (val
) - top
);
634 /* Note: When we look up RTTI entries, we don't get
635 any information on const or volatile
642 val
= value_ref (value_ind (val
), refcode
);
643 type
= value_type (val
);
646 type_print (type
, "", stream
, -1);
647 fprintf_filtered (stream
, ") ");
653 fprintf_filtered (stream
, "(");
654 type_print (value_type (val
), "", stream
, -1);
655 fprintf_filtered (stream
, ") ");
659 if (!value_initialized (val
))
660 fprintf_filtered (stream
, " [uninitialized] ");
662 if (options
->objectprint
&& (TYPE_CODE (type
) == TYPE_CODE_STRUCT
))
664 /* Attempt to determine real type of object. */
665 real_type
= value_rtti_type (val
, &full
, &top
, &using_enc
);
668 /* We have RTTI information, so use it. */
669 val
= value_full_object (val
, real_type
,
670 full
, top
, using_enc
);
671 fprintf_filtered (stream
, "(%s%s) ",
672 TYPE_NAME (real_type
),
673 full
? "" : _(" [incomplete object]"));
674 /* Print out object: enclosing type is same as real_type if
676 val_print (value_enclosing_type (val
),
678 value_address (val
), stream
, 0,
679 val
, &opts
, current_language
);
681 /* Note: When we look up RTTI entries, we don't get any
682 information on const or volatile attributes. */
684 else if (type
!= check_typedef (value_enclosing_type (val
)))
686 /* No RTTI information, so let's do our best. */
687 fprintf_filtered (stream
, "(%s ?) ",
688 TYPE_NAME (value_enclosing_type (val
)));
689 val_print (value_enclosing_type (val
),
691 value_address (val
), stream
, 0,
692 val
, &opts
, current_language
);
695 /* Otherwise, we end up at the return outside this "if". */
699 value_embedded_offset (val
),
702 val
, &opts
, current_language
);