]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/c-valprint.c
Automatic date update in version.in
[thirdparty/binutils-gdb.git] / gdb / c-valprint.c
CommitLineData
c906108c 1/* Support for printing C values for GDB, the GNU debugger.
1bac305b 2
d01e8234 3 Copyright (C) 1986-2025 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
c5aa993b 10 (at your option) any later version.
c906108c 11
c5aa993b
JM
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.
c906108c 16
c5aa993b 17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c 19
ec452525 20#include "extract-store-integer.h"
4de283e4 21#include "symtab.h"
d55e5aa6 22#include "gdbtypes.h"
4de283e4
TT
23#include "expression.h"
24#include "value.h"
25#include "valprint.h"
d55e5aa6 26#include "language.h"
4de283e4
TT
27#include "c-lang.h"
28#include "cp-abi.h"
d55e5aa6 29#include "target.h"
4de283e4 30#include "objfiles.h"
c906108c 31\f
c5aa993b 32
96c07c5b 33/* A helper for c_textual_element_type. This checks the name of the
6c7a06a3
TT
34 typedef. This is bogus but it isn't apparent that the compiler
35 provides us the help we may need. */
36
37static int
38textual_name (const char *name)
39{
40 return (!strcmp (name, "wchar_t")
41 || !strcmp (name, "char16_t")
42 || !strcmp (name, "char32_t"));
43}
44
ea37ba09
DJ
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
aff410f1
MS
48 or pointer to integers. FORMAT is the current format letter, or 0
49 if none.
ea37ba09
DJ
50
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
54 format letter. */
55
96c07c5b
TT
56int
57c_textual_element_type (struct type *type, char format)
ea37ba09 58{
85e306ed 59 struct type *true_type, *iter_type;
ea37ba09
DJ
60
61 if (format != 0 && format != 's')
62 return 0;
63
85e306ed
TT
64 /* We also rely on this for its side effect of setting up all the
65 typedef pointers. */
66 true_type = check_typedef (type);
67
ea37ba09 68 /* TYPE_CODE_CHAR is always textual. */
78134374 69 if (true_type->code () == TYPE_CODE_CHAR)
ea37ba09 70 return 1;
85e306ed 71
6c7a06a3 72 /* Any other character-like types must be integral. */
78134374 73 if (true_type->code () != TYPE_CODE_INT)
6c7a06a3
TT
74 return 0;
75
85e306ed
TT
76 /* We peel typedefs one by one, looking for a match. */
77 iter_type = type;
78 while (iter_type)
79 {
80 /* Check the name of the type. */
7d93a1e0 81 if (iter_type->name () && textual_name (iter_type->name ()))
85e306ed
TT
82 return 1;
83
78134374 84 if (iter_type->code () != TYPE_CODE_TYPEDEF)
85e306ed
TT
85 break;
86
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. */
27710edb
SM
90 if (iter_type->target_type ())
91 iter_type = iter_type->target_type ();
85e306ed
TT
92 else
93 iter_type = check_typedef (iter_type);
94 }
ea37ba09
DJ
95
96 if (format == 's')
97 {
aff410f1
MS
98 /* Print this as a string if we can manage it. For now, no wide
99 character support. */
78134374 100 if (true_type->code () == TYPE_CODE_INT
df86565b 101 && true_type->length () == 1)
ea37ba09
DJ
102 return 1;
103 }
104 else
105 {
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. */
78134374 109 if (true_type->code () == TYPE_CODE_INT
df86565b 110 && true_type->length () == 1
ea37ba09
DJ
111 && !TYPE_NOTTEXT (true_type))
112 return 1;
113 }
114
115 return 0;
116}
117
e88acd96
TT
118/* Decorations for C. */
119
120static const struct generic_val_print_decorations c_decorations =
121{
122 "",
123 " + ",
981c08ce 124 "i",
e88acd96
TT
125 "true",
126 "false",
00272ec4
TT
127 "void",
128 "{",
129 "}"
e88acd96
TT
130};
131
1033c33c
SM
132/* Print a pointer based on the type of its target.
133
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. */
138
139static void
140print_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)
145{
146 int want_space = 0;
8ee511af 147 struct gdbarch *gdbarch = type->arch ();
1033c33c 148
78134374 149 if (elttype->code () == TYPE_CODE_FUNC)
1033c33c
SM
150 {
151 /* Try to print what function it points to. */
152 print_function_pointer_address (options, gdbarch, address, stream);
153 return;
154 }
155
156 if (options->symbol_print)
157 want_space = print_address_demangle (options, gdbarch, address, stream,
158 demangle);
159 else if (options->addressprint)
160 {
0426ad51 161 gdb_puts (paddress (gdbarch, address), stream);
1033c33c
SM
162 want_space = 1;
163 }
164
165 /* For a pointer to a textual type, also print the string
166 pointed to, unless pointer is null. */
167
168 if (c_textual_element_type (unresolved_elttype, options->format)
169 && address != 0)
170 {
171 if (want_space)
0426ad51 172 gdb_puts (" ", stream);
1033c33c
SM
173 val_print_string (unresolved_elttype, NULL, address, -1, stream, options);
174 }
175 else if (cp_is_vtbl_member (type))
176 {
177 /* Print vtbl's nicely. */
178 CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
03b40f6f 179 bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (vt_address);
1033c33c
SM
180
181 /* If 'symbol_print' is set, we did the work above. */
182 if (!options->symbol_print
183 && (msymbol.minsym != NULL)
4aeddc50 184 && (vt_address == msymbol.value_address ()))
1033c33c
SM
185 {
186 if (want_space)
0426ad51
TT
187 gdb_puts (" ", stream);
188 gdb_puts (" <", stream);
189 gdb_puts (msymbol.minsym->print_name (), stream);
190 gdb_puts (">", stream);
1033c33c
SM
191 want_space = 1;
192 }
193
194 if (vt_address && options->vtblprint)
195 {
196 struct value *vt_val;
be903358 197 struct symbol *wsym = NULL;
1033c33c 198 struct type *wtype;
1033c33c
SM
199
200 if (want_space)
0426ad51 201 gdb_puts (" ", stream);
1033c33c
SM
202
203 if (msymbol.minsym != NULL)
de63c46b 204 {
c9d95fa3 205 const char *search_name = msymbol.minsym->search_name ();
582942f4 206 wsym = lookup_symbol_search_name (search_name, NULL,
ccf41c24 207 SEARCH_VAR_DOMAIN).symbol;
de63c46b 208 }
1033c33c
SM
209
210 if (wsym)
211 {
5f9c5a63 212 wtype = wsym->type ();
1033c33c
SM
213 }
214 else
215 {
216 wtype = unresolved_elttype;
217 }
218 vt_val = value_at (wtype, vt_address);
219 common_val_print (vt_val, stream, recurse + 1, options,
220 current_language);
221 if (options->prettyformat)
222 {
6cb06a8c 223 gdb_printf (stream, "\n");
d0b1020b 224 print_spaces (2 + 2 * recurse, stream);
1033c33c
SM
225 }
226 }
227 }
228}
229
6999f067
TT
230/* c_value_print helper for TYPE_CODE_ARRAY. */
231
232static void
233c_value_print_array (struct value *val,
234 struct ui_file *stream, int recurse,
235 const struct value_print_options *options)
236{
d0c97917 237 struct type *type = check_typedef (val->type ());
9feb2d07 238 CORE_ADDR address = val->address ();
efaf1ae0 239 const gdb_byte *valaddr = val->contents_for_printing ().data ();
27710edb 240 struct type *unresolved_elttype = type->target_type ();
6999f067
TT
241 struct type *elttype = check_typedef (unresolved_elttype);
242
df86565b 243 if (type->length () > 0 && unresolved_elttype->length () > 0)
6999f067
TT
244 {
245 LONGEST low_bound, high_bound;
246 int eltlen, len;
247 enum bfd_endian byte_order = type_byte_order (type);
248
249 if (!get_array_bounds (type, &low_bound, &high_bound))
250 error (_("Could not determine the array high bound"));
251
df86565b 252 eltlen = elttype->length ();
6999f067 253 len = high_bound - low_bound + 1;
6999f067
TT
254
255 /* Print arrays of textual chars with a string syntax, as
256 long as the entire array is valid. */
257 if (c_textual_element_type (unresolved_elttype,
258 options->format)
d00664db
TT
259 && val->bytes_available (0, type->length ())
260 && !val->bits_any_optimized_out (0,
261 TARGET_CHAR_BIT * type->length ()))
6999f067
TT
262 {
263 int force_ellipses = 0;
264
265 /* If requested, look for the first null char and only
266 print elements up to it. */
267 if (options->stop_print_at_null)
268 {
76b58849 269 unsigned int print_max_chars = get_print_max_chars (options);
6999f067
TT
270 unsigned int temp_len;
271
272 for (temp_len = 0;
273 (temp_len < len
76b58849 274 && temp_len < print_max_chars
6999f067
TT
275 && extract_unsigned_integer (valaddr + temp_len * eltlen,
276 eltlen, byte_order) != 0);
277 ++temp_len)
278 ;
279
660da3c1 280 /* Force printstr to print ellipses if
6999f067
TT
281 we've printed the maximum characters and
282 the next character is not \000. */
76b58849 283 if (temp_len == print_max_chars && temp_len < len)
6999f067
TT
284 {
285 ULONGEST ival
286 = extract_unsigned_integer (valaddr + temp_len * eltlen,
287 eltlen, byte_order);
288 if (ival != 0)
289 force_ellipses = 1;
290 }
291
292 len = temp_len;
293 }
294
660da3c1
TT
295 current_language->printstr (stream, unresolved_elttype, valaddr, len,
296 NULL, force_ellipses, options);
6999f067
TT
297 }
298 else
299 {
300 unsigned int i = 0;
6cb06a8c 301 gdb_printf (stream, "{");
6999f067
TT
302 /* If this is a virtual function table, print the 0th
303 entry specially, and the rest of the members
304 normally. */
305 if (cp_is_vtbl_ptr_type (elttype))
306 {
307 i = 1;
6cb06a8c
TT
308 gdb_printf (stream, _("%d vtable entries"),
309 len - 1);
6999f067
TT
310 }
311 value_print_array_elements (val, stream, recurse, options, i);
6cb06a8c 312 gdb_printf (stream, "}");
6999f067
TT
313 }
314 }
315 else
316 {
317 /* Array of unspecified length: treat like pointer to first elt. */
318 print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
319 0, address, stream, recurse, options);
320 }
321}
322
da3e2c29
TT
323/* c_value_print_inner helper for TYPE_CODE_PTR. */
324
325static void
326c_value_print_ptr (struct value *val, struct ui_file *stream, int recurse,
327 const struct value_print_options *options)
328{
329 if (options->format && options->format != 's')
330 {
331 value_print_scalar_formatted (val, options, 0, stream);
332 return;
333 }
334
d0c97917 335 struct type *type = check_typedef (val->type ());
efaf1ae0 336 const gdb_byte *valaddr = val->contents_for_printing ().data ();
da3e2c29
TT
337
338 if (options->vtblprint && cp_is_vtbl_ptr_type (type))
339 {
340 /* Print the unmangled name if desired. */
341 /* Print vtable entry - we only get here if we ARE using
342 -fvtable_thunks. (Otherwise, look under
343 TYPE_CODE_STRUCT.) */
344 CORE_ADDR addr = extract_typed_address (valaddr, type);
345
8ee511af 346 print_function_pointer_address (options, type->arch (), addr, stream);
da3e2c29
TT
347 }
348 else
349 {
27710edb 350 struct type *unresolved_elttype = type->target_type ();
da3e2c29
TT
351 struct type *elttype = check_typedef (unresolved_elttype);
352 CORE_ADDR addr = unpack_pointer (type, valaddr);
353
354 print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
355 0, addr, stream, recurse, options);
356 }
357}
358
64b653ca
TT
359/* c_value_print helper for TYPE_CODE_STRUCT and TYPE_CODE_UNION. */
360
361static void
362c_value_print_struct (struct value *val, struct ui_file *stream, int recurse,
363 const struct value_print_options *options)
364{
d0c97917 365 struct type *type = check_typedef (val->type ());
64b653ca 366
78134374 367 if (type->code () == TYPE_CODE_UNION && recurse && !options->unionprint)
6cb06a8c 368 gdb_printf (stream, "{...}");
64b653ca
TT
369 else if (options->vtblprint && cp_is_vtbl_ptr_type (type))
370 {
371 /* Print the unmangled name if desired. */
372 /* Print vtable entry - we only get here if NOT using
373 -fvtable_thunks. (Otherwise, look under
374 TYPE_CODE_PTR.) */
b610c045 375 int offset = type->field (VTBL_FNADDR_OFFSET).loc_bitpos () / 8;
940da03e 376 struct type *field_type = type->field (VTBL_FNADDR_OFFSET).type ();
efaf1ae0 377 const gdb_byte *valaddr = val->contents_for_printing ().data ();
64b653ca
TT
378 CORE_ADDR addr = extract_typed_address (valaddr + offset, field_type);
379
8ee511af 380 print_function_pointer_address (options, type->arch (), addr, stream);
64b653ca
TT
381 }
382 else
383 cp_print_value_fields (val, stream, recurse, options, NULL, 0);
384}
385
2faac269
TT
386/* c_value_print helper for TYPE_CODE_INT. */
387
388static void
389c_value_print_int (struct value *val, struct ui_file *stream,
390 const struct value_print_options *options)
391{
392 if (options->format || options->output_format)
393 {
394 struct value_print_options opts = *options;
395
396 opts.format = (options->format ? options->format
397 : options->output_format);
398 value_print_scalar_formatted (val, &opts, 0, stream);
399 }
400 else
401 {
402 value_print_scalar_formatted (val, options, 0, stream);
403 /* C and C++ has no single byte int type, char is used
404 instead. Since we don't know whether the value is really
405 intended to be used as an integer or a character, print
406 the character equivalent as well. */
d0c97917 407 struct type *type = val->type ();
efaf1ae0 408 const gdb_byte *valaddr = val->contents_for_printing ().data ();
2faac269
TT
409 if (c_textual_element_type (type, options->format))
410 {
0426ad51 411 gdb_puts (" ", stream);
362501dc
TT
412 current_language->printchar (unpack_long (type, valaddr), type,
413 stream);
2faac269
TT
414 }
415 }
416}
417
62182190
TT
418/* See c-lang.h. */
419
420void
421c_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
422 const struct value_print_options *options)
423{
d0c97917 424 struct type *type = val->type ();
50836231
TT
425
426 type = check_typedef (type);
78134374 427 switch (type->code ())
50836231
TT
428 {
429 case TYPE_CODE_ARRAY:
6999f067 430 c_value_print_array (val, stream, recurse, options);
50836231
TT
431 break;
432
50836231 433 case TYPE_CODE_PTR:
da3e2c29 434 c_value_print_ptr (val, stream, recurse, options);
50836231
TT
435 break;
436
437 case TYPE_CODE_UNION:
50836231 438 case TYPE_CODE_STRUCT:
64b653ca 439 c_value_print_struct (val, stream, recurse, options);
50836231
TT
440 break;
441
1c0e4363 442 case TYPE_CODE_CHAR:
50836231 443 case TYPE_CODE_INT:
2faac269 444 c_value_print_int (val, stream, options);
50836231
TT
445 break;
446
6b5a7bc7 447 case TYPE_CODE_METHODPTR:
50836231 448 case TYPE_CODE_MEMBERPTR:
50836231
TT
449 case TYPE_CODE_REF:
450 case TYPE_CODE_RVALUE_REF:
451 case TYPE_CODE_ENUM:
452 case TYPE_CODE_FLAGS:
453 case TYPE_CODE_FUNC:
454 case TYPE_CODE_METHOD:
455 case TYPE_CODE_BOOL:
456 case TYPE_CODE_RANGE:
457 case TYPE_CODE_FLT:
458 case TYPE_CODE_DECFLOAT:
459 case TYPE_CODE_VOID:
460 case TYPE_CODE_ERROR:
461 case TYPE_CODE_UNDEF:
462 case TYPE_CODE_COMPLEX:
50836231
TT
463 default:
464 generic_value_print (val, stream, recurse, options, &c_decorations);
465 break;
466 }
62182190
TT
467}
468
c906108c 469\f
8e069a98 470void
79a45b7d
TT
471c_value_print (struct value *val, struct ui_file *stream,
472 const struct value_print_options *options)
c906108c 473{
a1f6a07c 474 struct type *type, *real_type;
6b850546
DT
475 int full, using_enc;
476 LONGEST top;
79a45b7d
TT
477 struct value_print_options opts = *options;
478
dad6b350 479 opts.deref_ref = true;
c5aa993b 480
c906108c
SS
481 /* If it is a pointer, indicate what it points to.
482
483 Print type also if it is a reference.
484
485 C++: if it is a member pointer, we will take care
486 of that when we print it. */
88750304 487
d0c97917 488 type = check_typedef (val->type ());
88750304 489
809f3be1 490 if (type->is_pointer_or_reference ())
c906108c 491 {
d0c97917 492 struct type *original_type = val->type ();
a1f6a07c 493
c906108c 494 /* Hack: remove (char *) for char strings. Their
dda83cd7
SM
495 type is indicated by the quoted string anyway.
496 (Don't use c_textual_element_type here; quoted strings
497 are always exactly (char *), (wchar_t *), or the like. */
78134374 498 if (original_type->code () == TYPE_CODE_PTR
7d93a1e0 499 && original_type->name () == NULL
27710edb
SM
500 && original_type->target_type ()->name () != NULL
501 && (strcmp (original_type->target_type ()->name (),
aff410f1 502 "char") == 0
27710edb 503 || textual_name (original_type->target_type ()->name ())))
c906108c 504 {
aff410f1 505 /* Print nothing. */
c906108c 506 }
79a45b7d 507 else if (options->objectprint
27710edb 508 && (type->target_type ()->code () == TYPE_CODE_STRUCT))
c5aa993b 509 {
a65cfae5
AV
510 int is_ref = TYPE_IS_REFERENCE (type);
511 enum type_code refcode = TYPE_CODE_UNDEF;
5f2e6b00
TT
512
513 if (is_ref)
a65cfae5
AV
514 {
515 val = value_addr (val);
78134374 516 refcode = type->code ();
a65cfae5 517 }
070ad9f0 518
aff410f1 519 /* Pointer to class, check real type of object. */
6cb06a8c 520 gdb_printf (stream, "(");
ec0a52e1 521
d00664db 522 if (val->entirely_available ())
476350ba 523 {
dfcee124
AG
524 real_type = value_rtti_indirect_type (val, &full, &top,
525 &using_enc);
ec0a52e1
PA
526 if (real_type)
527 {
528 /* RTTI entry found. */
dfcee124 529
ec0a52e1 530 /* Need to adjust pointer value. */
5f2e6b00
TT
531 val = value_from_pointer (real_type,
532 value_as_address (val) - top);
533
ec0a52e1
PA
534 /* Note: When we look up RTTI entries, we don't get
535 any information on const or volatile
536 attributes. */
537 }
538 }
476350ba
MG
539
540 if (is_ref)
a1f6a07c 541 val = value_ref (value_ind (val), refcode);
476350ba 542
d0c97917 543 type = val->type ();
476350ba 544 type_print (type, "", stream, -1);
6cb06a8c 545 gdb_printf (stream, ") ");
c5aa993b 546 }
c906108c
SS
547 else
548 {
c5aa993b 549 /* normal case */
6cb06a8c 550 gdb_printf (stream, "(");
d0c97917 551 type_print (val->type (), "", stream, -1);
6cb06a8c 552 gdb_printf (stream, ") ");
c906108c
SS
553 }
554 }
88750304 555
8e5b19ad 556 if (!val->initialized ())
6cb06a8c 557 gdb_printf (stream, " [uninitialized] ");
42be36b3 558
78134374 559 if (options->objectprint && (type->code () == TYPE_CODE_STRUCT))
c906108c 560 {
aff410f1 561 /* Attempt to determine real type of object. */
c906108c 562 real_type = value_rtti_type (val, &full, &top, &using_enc);
c5aa993b
JM
563 if (real_type)
564 {
aff410f1
MS
565 /* We have RTTI information, so use it. */
566 val = value_full_object (val, real_type,
567 full, top, using_enc);
a1f6a07c
TT
568 /* In a destructor we might see a real type that is a
569 superclass of the object's type. In this case it is
570 better to leave the object as-is. */
571 if (!(full
df86565b 572 && (real_type->length ()
463b870d 573 < val->enclosing_type ()->length ())))
a1f6a07c 574 val = value_cast (real_type, val);
6cb06a8c
TT
575 gdb_printf (stream, "(%s%s) ",
576 real_type->name (),
577 full ? "" : _(" [incomplete object]"));
c5aa993b 578 }
463b870d 579 else if (type != check_typedef (val->enclosing_type ()))
c5aa993b 580 {
aff410f1 581 /* No RTTI information, so let's do our best. */
6cb06a8c 582 gdb_printf (stream, "(%s ?) ",
463b870d
TT
583 val->enclosing_type ()->name ());
584 val = value_cast (val->enclosing_type (), val);
c5aa993b 585 }
c906108c 586 }
c5aa993b 587
a1f6a07c 588 common_val_print (val, stream, 0, &opts, current_language);
c906108c 589}