GDB (xrefs)

/tmp/gdb-8.1/gdb/c-valprint.c
Go to the documentation of this file.
1 /* Support for printing C values for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "symtab.h"
22 #include "gdbtypes.h"
23 #include "expression.h"
24 #include "value.h"
25 #include "valprint.h"
26 #include "language.h"
27 #include "c-lang.h"
28 #include "cp-abi.h"
29 #include "target.h"
30 #include "objfiles.h"
31
32
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. */
36
37 static int
38 textual_name (const char *name)
39 {
40 return (!strcmp (name, "wchar_t")
41 || !strcmp (name, "char16_t")
42 || !strcmp (name, "char32_t"));
43 }
44
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
49 if none.
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
56 int
57 c_textual_element_type (struct type *type, char format)
58 {
59 struct type *true_type, *iter_type;
60
61 if (format != 0 && format != 's')
62 return 0;
63
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
68 /* TYPE_CODE_CHAR is always textual. */
69 if (TYPE_CODE (true_type) == TYPE_CODE_CHAR)
70 return 1;
71
72 /* Any other character-like types must be integral. */
73 if (TYPE_CODE (true_type) != TYPE_CODE_INT)
74 return 0;
75
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. */
81 if (TYPE_NAME (iter_type) && textual_name (TYPE_NAME (iter_type)))
82 return 1;
83
84 if (TYPE_CODE (iter_type) != TYPE_CODE_TYPEDEF)
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. */
90 if (TYPE_TARGET_TYPE (iter_type))
91 iter_type = TYPE_TARGET_TYPE (iter_type);
92 else
93 iter_type = check_typedef (iter_type);
94 }
95
96 if (format == 's')
97 {
98 /* Print this as a string if we can manage it. For now, no wide
99 character support. */
100 if (TYPE_CODE (true_type) == TYPE_CODE_INT
101 && TYPE_LENGTH (true_type) == 1)
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. */
109 if (TYPE_CODE (true_type) == TYPE_CODE_INT
110 && TYPE_LENGTH (true_type) == 1
111 && !TYPE_NOTTEXT (true_type))
112 return 1;
113 }
114
115 return 0;
116 }
117
118 /* Decorations for C. */
119
120 static const struct generic_val_print_decorations c_decorations =
121 {
122 "",
123 " + ",
124 " * I",
125 "true",
126 "false",
127 "void",
128 "{",
129 "}"
130 };
131
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
139 static void
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)
145 {
146 int want_space = 0;
147 struct gdbarch *gdbarch = get_type_arch (type);
148
149 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
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 {
161 fputs_filtered (paddress (gdbarch, address), stream);
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)
172 fputs_filtered (" ", stream);
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);
179 struct bound_minimal_symbol msymbol =
180 lookup_minimal_symbol_by_pc (vt_address);
181
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)))
186 {
187 if (want_space)
188 fputs_filtered (" ", stream);
189 fputs_filtered (" <", stream);
190 fputs_filtered (MSYMBOL_PRINT_NAME (msymbol.minsym), stream);
191 fputs_filtered (">", stream);
192 want_space = 1;
193 }
194
195 if (vt_address && options->vtblprint)
196 {
197 struct value *vt_val;
198 struct symbol *wsym = NULL;
199 struct type *wtype;
200 struct block *block = NULL;
201
202 if (want_space)
203 fputs_filtered (" ", stream);
204
205 if (msymbol.minsym != NULL)
206 {
207 const char *search_name
208 = MSYMBOL_SEARCH_NAME (msymbol.minsym);
209 wsym = lookup_symbol_search_name (search_name, block,
210 VAR_DOMAIN).symbol;
211 }
212
213 if (wsym)
214 {
215 wtype = SYMBOL_TYPE (wsym);
216 }
217 else
218 {
219 wtype = unresolved_elttype;
220 }
221 vt_val = value_at (wtype, vt_address);
222 common_val_print (vt_val, stream, recurse + 1, options,
223 current_language);
224 if (options->prettyformat)
225 {
226 fprintf_filtered (stream, "\n");
227 print_spaces_filtered (2 + 2 * recurse, stream);
228 }
229 }
230 }
231 }
232
233 /* c_val_print helper for TYPE_CODE_ARRAY. */
234
235 static void
236 c_val_print_array (struct type *type, const gdb_byte *valaddr,
237 int embedded_offset, CORE_ADDR address,
238 struct ui_file *stream, int recurse,
239 struct value *original_value,
240 const struct value_print_options *options)
241 {
242 struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
243 struct type *elttype = check_typedef (unresolved_elttype);
244 struct gdbarch *arch = get_type_arch (type);
245 int unit_size = gdbarch_addressable_memory_unit_size (arch);
246
247 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
248 {
249 LONGEST low_bound, high_bound;
250 int eltlen, len;
251 struct gdbarch *gdbarch = get_type_arch (type);
252 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
253 unsigned int i = 0; /* Number of characters printed. */
254
255 if (!get_array_bounds (type, &low_bound, &high_bound))
256 error (_("Could not determine the array high bound"));
257
258 eltlen = TYPE_LENGTH (elttype);
259 len = high_bound - low_bound + 1;
260 if (options->prettyformat_arrays)
261 {
262 print_spaces_filtered (2 + 2 * recurse, stream);
263 }
264
265 /* Print arrays of textual chars with a string syntax, as
266 long as the entire array is valid. */
267 if (c_textual_element_type (unresolved_elttype,
268 options->format)
269 && value_bytes_available (original_value, embedded_offset,
270 TYPE_LENGTH (type))
271 && !value_bits_any_optimized_out (original_value,
272 TARGET_CHAR_BIT * embedded_offset,
273 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
274 {
275 int force_ellipses = 0;
276
277 /* If requested, look for the first null char and only
278 print elements up to it. */
279 if (options->stop_print_at_null)
280 {
281 unsigned int temp_len;
282
283 for (temp_len = 0;
284 (temp_len < len
285 && temp_len < options->print_max
286 && extract_unsigned_integer (valaddr
287 + embedded_offset * unit_size
288 + temp_len * eltlen,
289 eltlen, byte_order) != 0);
290 ++temp_len)
291 ;
292
293 /* Force LA_PRINT_STRING to print ellipses if
294 we've printed the maximum characters and
295 the next character is not \000. */
296 if (temp_len == options->print_max && temp_len < len)
297 {
298 ULONGEST val
299 = extract_unsigned_integer (valaddr
300 + embedded_offset * unit_size
301 + temp_len * eltlen,
302 eltlen, byte_order);
303 if (val != 0)
304 force_ellipses = 1;
305 }
306
307 len = temp_len;
308 }
309
310 LA_PRINT_STRING (stream, unresolved_elttype,
311 valaddr + embedded_offset * unit_size, len,
312 NULL, force_ellipses, options);
313 i = len;
314 }
315 else
316 {
317 fprintf_filtered (stream, "{");
318 /* If this is a virtual function table, print the 0th
319 entry specially, and the rest of the members
320 normally. */
321 if (cp_is_vtbl_ptr_type (elttype))
322 {
323 i = 1;
324 fprintf_filtered (stream, _("%d vtable entries"),
325 len - 1);
326 }
327 else
328 {
329 i = 0;
330 }
331 val_print_array_elements (type, embedded_offset,
332 address, stream,
333 recurse, original_value, options, i);
334 fprintf_filtered (stream, "}");
335 }
336 }
337 else
338 {
339 /* Array of unspecified length: treat like pointer to first elt. */
340 print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
341 embedded_offset, address + embedded_offset,
342 stream, recurse, options);
343 }
344 }
345
346 /* c_val_print helper for TYPE_CODE_PTR. */
347
348 static void
349 c_val_print_ptr (struct type *type, const gdb_byte *valaddr,
350 int embedded_offset, struct ui_file *stream, int recurse,
351 struct value *original_value,
352 const struct value_print_options *options)
353 {
354 struct gdbarch *arch = get_type_arch (type);
355 int unit_size = gdbarch_addressable_memory_unit_size (arch);
356
357 if (options->format && options->format != 's')
358 {
359 val_print_scalar_formatted (type, embedded_offset,
360 original_value, options, 0, stream);
361 }
362 else if (options->vtblprint && cp_is_vtbl_ptr_type (type))
363 {
364 /* Print the unmangled name if desired. */
365 /* Print vtable entry - we only get here if we ARE using
366 -fvtable_thunks. (Otherwise, look under
367 TYPE_CODE_STRUCT.) */
368 CORE_ADDR addr
369 = extract_typed_address (valaddr + embedded_offset, type);
370 struct gdbarch *gdbarch = get_type_arch (type);
371
372 print_function_pointer_address (options, gdbarch, addr, stream);
373 }
374 else
375 {
376 struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
377 struct type *elttype = check_typedef (unresolved_elttype);
378 CORE_ADDR addr = unpack_pointer (type,
379 valaddr + embedded_offset * unit_size);
380
381 print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
382 embedded_offset, addr, stream, recurse, options);
383 }
384 }
385
386 /* c_val_print helper for TYPE_CODE_STRUCT. */
387
388 static void
389 c_val_print_struct (struct type *type, const gdb_byte *valaddr,
390 int embedded_offset, CORE_ADDR address,
391 struct ui_file *stream, int recurse,
392 struct value *original_value,
393 const struct value_print_options *options)
394 {
395 if (options->vtblprint && cp_is_vtbl_ptr_type (type))
396 {
397 /* Print the unmangled name if desired. */
398 /* Print vtable entry - we only get here if NOT using
399 -fvtable_thunks. (Otherwise, look under
400 TYPE_CODE_PTR.) */
401 struct gdbarch *gdbarch = get_type_arch (type);
402 int offset = (embedded_offset
403 + TYPE_FIELD_BITPOS (type,
404 VTBL_FNADDR_OFFSET) / 8);
405 struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
406 CORE_ADDR addr = extract_typed_address (valaddr + offset, field_type);
407
408 print_function_pointer_address (options, gdbarch, addr, stream);
409 }
410 else
411 cp_print_value_fields_rtti (type, valaddr,
412 embedded_offset, address,
413 stream, recurse,
414 original_value, options,
415 NULL, 0);
416 }
417
418 /* c_val_print helper for TYPE_CODE_UNION. */
419
420 static void
421 c_val_print_union (struct type *type, const gdb_byte *valaddr,
422 int embedded_offset, CORE_ADDR address,
423 struct ui_file *stream, int recurse,
424 struct value *original_value,
425 const struct value_print_options *options)
426 {
427 if (recurse && !options->unionprint)
428 {
429 fprintf_filtered (stream, "{...}");
430 }
431 else
432 {
433 c_val_print_struct (type, valaddr, embedded_offset, address, stream,
434 recurse, original_value, options);
435 }
436 }
437
438 /* c_val_print helper for TYPE_CODE_INT. */
439
440 static void
441 c_val_print_int (struct type *type, struct type *unresolved_type,
442 const gdb_byte *valaddr, int embedded_offset,
443 struct ui_file *stream, struct value *original_value,
444 const struct value_print_options *options)
445 {
446 struct gdbarch *arch = get_type_arch (type);
447 int unit_size = gdbarch_addressable_memory_unit_size (arch);
448
449 if (options->format || options->output_format)
450 {
451 struct value_print_options opts = *options;
452
453 opts.format = (options->format ? options->format
454 : options->output_format);
455 val_print_scalar_formatted (type, embedded_offset,
456 original_value, &opts, 0, stream);
457 }
458 else
459 {
460 val_print_scalar_formatted (type, embedded_offset,
461 original_value, options, 0, stream);
462 /* C and C++ has no single byte int type, char is used
463 instead. Since we don't know whether the value is really
464 intended to be used as an integer or a character, print
465 the character equivalent as well. */
466 if (c_textual_element_type (unresolved_type, options->format))
467 {
468 fputs_filtered (" ", stream);
469 LA_PRINT_CHAR (unpack_long (type,
470 valaddr + embedded_offset * unit_size),
471 unresolved_type, stream);
472 }
473 }
474 }
475
476 /* c_val_print helper for TYPE_CODE_MEMBERPTR. */
477
478 static void
479 c_val_print_memberptr (struct type *type, const gdb_byte *valaddr,
480 int embedded_offset, CORE_ADDR address,
481 struct ui_file *stream, int recurse,
482 struct value *original_value,
483 const struct value_print_options *options)
484 {
485 if (!options->format)
486 {
487 cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
488 }
489 else
490 {
491 generic_val_print (type, embedded_offset, address, stream,
492 recurse, original_value, options, &c_decorations);
493 }
494 }
495
496 /* See val_print for a description of the various parameters of this
497 function; they are identical. */
498
499 void
500 c_val_print (struct type *type,
501 int embedded_offset, CORE_ADDR address,
502 struct ui_file *stream, int recurse,
503 struct value *original_value,
504 const struct value_print_options *options)
505 {
506 struct type *unresolved_type = type;
507 const gdb_byte *valaddr = value_contents_for_printing (original_value);
508
509 type = check_typedef (type);
510 switch (TYPE_CODE (type))
511 {
512 case TYPE_CODE_ARRAY:
513 c_val_print_array (type, valaddr, embedded_offset, address, stream,
514 recurse, original_value, options);
515 break;
516
517 case TYPE_CODE_METHODPTR:
518 cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
519 break;
520
521 case TYPE_CODE_PTR:
522 c_val_print_ptr (type, valaddr, embedded_offset, stream, recurse,
523 original_value, options);
524 break;
525
526 case TYPE_CODE_UNION:
527 c_val_print_union (type, valaddr, embedded_offset, address, stream,
528 recurse, original_value, options);
529 break;
530
531 case TYPE_CODE_STRUCT:
532 c_val_print_struct (type, valaddr, embedded_offset, address, stream,
533 recurse, original_value, options);
534 break;
535
536 case TYPE_CODE_INT:
537 c_val_print_int (type, unresolved_type, valaddr, embedded_offset, stream,
538 original_value, options);
539 break;
540
541 case TYPE_CODE_MEMBERPTR:
542 c_val_print_memberptr (type, valaddr, embedded_offset, address, stream,
543 recurse, original_value, options);
544 break;
545
546 case TYPE_CODE_REF:
547 case TYPE_CODE_RVALUE_REF:
548 case TYPE_CODE_ENUM:
549 case TYPE_CODE_FLAGS:
550 case TYPE_CODE_FUNC:
551 case TYPE_CODE_METHOD:
552 case TYPE_CODE_BOOL:
553 case TYPE_CODE_RANGE:
554 case TYPE_CODE_FLT:
555 case TYPE_CODE_DECFLOAT:
556 case TYPE_CODE_VOID:
557 case TYPE_CODE_ERROR:
558 case TYPE_CODE_UNDEF:
559 case TYPE_CODE_COMPLEX:
560 case TYPE_CODE_CHAR:
561 default:
562 generic_val_print (type, embedded_offset, address,
563 stream, recurse, original_value, options,
564 &c_decorations);
565 break;
566 }
567 gdb_flush (stream);
568 }
569
570 void
571 c_value_print (struct value *val, struct ui_file *stream,
572 const struct value_print_options *options)
573 {
574 struct type *type, *real_type, *val_type;
575 int full, using_enc;
576 LONGEST top;
577 struct value_print_options opts = *options;
578
579 opts.deref_ref = 1;
580
581 /* If it is a pointer, indicate what it points to.
582
583 Print type also if it is a reference.
584
585 C++: if it is a member pointer, we will take care
586 of that when we print it. */
587
588 /* Preserve the original type before stripping typedefs. We prefer
589 to pass down the original type when possible, but for local
590 checks it is better to look past the typedefs. */
591 val_type = value_type (val);
592 type = check_typedef (val_type);
593
594 if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type))
595 {
596 /* Hack: remove (char *) for char strings. Their
597 type is indicated by the quoted string anyway.
598 (Don't use c_textual_element_type here; quoted strings
599 are always exactly (char *), (wchar_t *), or the like. */
600 if (TYPE_CODE (val_type) == TYPE_CODE_PTR
601 && TYPE_NAME (val_type) == NULL
602 && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
603 && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
604 "char") == 0
605 || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
606 {
607 /* Print nothing. */
608 }
609 else if (options->objectprint
610 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
611 {
612 int is_ref = TYPE_IS_REFERENCE (type);
613 enum type_code refcode = TYPE_CODE_UNDEF;
614
615 if (is_ref)
616 {
617 val = value_addr (val);
618 refcode = TYPE_CODE (type);
619 }
620
621 /* Pointer to class, check real type of object. */
622 fprintf_filtered (stream, "(");
623
624 if (value_entirely_available (val))
625 {
626 real_type = value_rtti_indirect_type (val, &full, &top,
627 &using_enc);
628 if (real_type)
629 {
630 /* RTTI entry found. */
631 type = real_type;
632
633 /* Need to adjust pointer value. */
634 val = value_from_pointer (real_type,
635 value_as_address (val) - top);
636
637 /* Note: When we look up RTTI entries, we don't get
638 any information on const or volatile
639 attributes. */
640 }
641 }
642
643 if (is_ref)
644 {
645 val = value_ref (value_ind (val), refcode);
646 type = value_type (val);
647 }
648
649 type_print (type, "", stream, -1);
650 fprintf_filtered (stream, ") ");
651 val_type = type;
652 }
653 else
654 {
655 /* normal case */
656 fprintf_filtered (stream, "(");
657 type_print (value_type (val), "", stream, -1);
658 fprintf_filtered (stream, ") ");
659 }
660 }
661
662 if (!value_initialized (val))
663 fprintf_filtered (stream, " [uninitialized] ");
664
665 if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_STRUCT))
666 {
667 /* Attempt to determine real type of object. */
668 real_type = value_rtti_type (val, &full, &top, &using_enc);
669 if (real_type)
670 {
671 /* We have RTTI information, so use it. */
672 val = value_full_object (val, real_type,
673 full, top, using_enc);
674 fprintf_filtered (stream, "(%s%s) ",
675 TYPE_NAME (real_type),
676 full ? "" : _(" [incomplete object]"));
677 /* Print out object: enclosing type is same as real_type if
678 full. */
679 val_print (value_enclosing_type (val),
680 0,
681 value_address (val), stream, 0,
682 val, &opts, current_language);
683 return;
684 /* Note: When we look up RTTI entries, we don't get any
685 information on const or volatile attributes. */
686 }
687 else if (type != check_typedef (value_enclosing_type (val)))
688 {
689 /* No RTTI information, so let's do our best. */
690 fprintf_filtered (stream, "(%s ?) ",
691 TYPE_NAME (value_enclosing_type (val)));
692 val_print (value_enclosing_type (val),
693 0,
694 value_address (val), stream, 0,
695 val, &opts, current_language);
696 return;
697 }
698 /* Otherwise, we end up at the return outside this "if". */
699 }
700
701 val_print (val_type,
702 value_embedded_offset (val),
703 value_address (val),
704 stream, 0,
705 val, &opts, current_language);
706 }
gdbarch
Definition: gdbarch.c:127
lookup_symbol_search_name
struct block_symbol lookup_symbol_search_name(const char *search_name, const struct block *block, domain_enum domain)
Definition: symtab.c:1905
value_rtti_type
struct type * value_rtti_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition: cp-abi.c:108
TYPE_CODE_BOOL
Definition: gdbtypes.h:164
type_code
type_code
Definition: gdbtypes.h:80
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
demangle
int demangle
Definition: demangle.c:47
extract_typed_address
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:154
value_addr
struct value * value_addr(struct value *arg1)
Definition: valops.c:1462
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
cp_is_vtbl_ptr_type
int cp_is_vtbl_ptr_type(struct type *)
Definition: cp-valprint.c:96
value_print_options::deref_ref
int deref_ref
Definition: valprint.h:75
c_val_print_union
static void c_val_print_union(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options)
Definition: c-valprint.c:421
c_decorations
static const struct generic_val_print_decorations c_decorations
Definition: c-valprint.c:120
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
unpack_pointer
CORE_ADDR unpack_pointer(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2934
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
value_embedded_offset
LONGEST value_embedded_offset(const struct value *value)
Definition: value.c:1477
cp_is_vtbl_member
int cp_is_vtbl_member(struct type *)
Definition: cp-valprint.c:107
TYPE_NAME
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1224
value_enclosing_type
struct type * value_enclosing_type(const struct value *value)
Definition: value.c:1175
value_at
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition: valops.c:933
TYPE_CODE_RANGE
Definition: gdbtypes.h:127
TYPE_CODE_FLAGS
Definition: gdbtypes.h:109
common_val_print
void common_val_print(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1136
cp_print_class_member
void cp_print_class_member(const gdb_byte *, struct type *, struct ui_file *, const char *)
Definition: cp-valprint.c:751
TYPE_CODE_INT
Definition: gdbtypes.h:111
type_print
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:358
TYPE_CODE_DECFLOAT
Definition: gdbtypes.h:173
value_ind
struct value * value_ind(struct value *arg1)
Definition: valops.c:1542
TYPE_CODE_UNDEF
Definition: gdbtypes.h:83
cp_print_value_fields_rtti
void cp_print_value_fields_rtti(struct type *, const gdb_byte *, LONGEST, CORE_ADDR, struct ui_file *, int, struct value *, const struct value_print_options *, struct type **, int)
Definition: cp-valprint.c:415
_
#define _(String)
Definition: gdb_locale.h:35
value_contents_for_printing
const gdb_byte * value_contents_for_printing(struct value *value)
Definition: value.c:1250
ui_file
Definition: ui-file.h:26
value_bytes_available
int value_bytes_available(const struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:357
TYPE_CODE_RVALUE_REF
Definition: gdbtypes.h:158
defs.h
value_bits_any_optimized_out
int value_bits_any_optimized_out(const struct value *value, int bit_offset, int bit_length)
Definition: value.c:366
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
value_print_options::prettyformat
enum val_prettyformat prettyformat
Definition: valprint.h:28
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
TYPE_IS_REFERENCE
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:332
gdbarch_addressable_memory_unit_size
int gdbarch_addressable_memory_unit_size(struct gdbarch *gdbarch)
Definition: gdbarch.c:5030
TYPE_CODE_VOID
Definition: gdbtypes.h:124
symtab.h
MSYMBOL_PRINT_NAME
#define MSYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:708
TYPE_CODE_TYPEDEF
Definition: gdbtypes.h:169
val_print_scalar_formatted
void val_print_scalar_formatted(struct type *type, LONGEST embedded_offset, struct value *val, const struct value_print_options *options, int size, struct ui_file *stream)
Definition: valprint.c:1240
name
const char *const name
Definition: aarch64-tdep.c:76
TYPE_NOTTEXT
#define TYPE_NOTTEXT(t)
Definition: gdbtypes.h:276
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
c_val_print
void c_val_print(struct type *type, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options)
Definition: c-valprint.c:500
value_print_options
Definition: valprint.h:25
TYPE_CODE_CHAR
Definition: gdbtypes.h:160
value_print_options::stop_print_at_null
int stop_print_at_null
Definition: valprint.h:67
c_textual_element_type
int c_textual_element_type(struct type *type, char format)
Definition: c-valprint.c:57
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
bound_minimal_symbol
Definition: minsyms.h:29
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
TYPE_CODE_FLT
Definition: gdbtypes.h:116
expression.h
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
TYPE_CODE_UNION
Definition: gdbtypes.h:107
TARGET_CHAR_BIT
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
type
Definition: gdbtypes.h:749
language.h
MSYMBOL_SEARCH_NAME
#define MSYMBOL_SEARCH_NAME(symbol)
Definition: symtab.h:714
get_type_arch
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:234
value_initialized
int value_initialized(const struct value *val)
Definition: value.c:3846
type
static const char * type
Definition: language.c:113
print_unpacked_pointer
static void print_unpacked_pointer(struct type *type, struct type *elttype, struct type *unresolved_elttype, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value_print_options *options)
Definition: c-valprint.c:140
c_val_print_int
static void c_val_print_int(struct type *type, struct type *unresolved_type, const gdb_byte *valaddr, int embedded_offset, struct ui_file *stream, struct value *original_value, const struct value_print_options *options)
Definition: c-valprint.c:441
c_val_print_array
static void c_val_print_array(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options)
Definition: c-valprint.c:236
value_print_options::format
int format
Definition: valprint.h:64
value_print_options::addressprint
int addressprint
Definition: valprint.h:43
c_val_print_memberptr
static void c_val_print_memberptr(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options)
Definition: c-valprint.c:479
TYPE_CODE_METHODPTR
Definition: gdbtypes.h:147
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
value_full_object
struct value * value_full_object(struct value *argp, struct type *rtype, int xfull, int xtop, int xusing_enc)
Definition: valops.c:3662
TYPE_CODE_ERROR
Definition: gdbtypes.h:138
unpack_long
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2880
TYPE_CODE_REF
Definition: gdbtypes.h:156
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
TYPE_FIELD_BITPOS
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1374
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
generic_val_print_decorations
Definition: valprint.h:169
block
Definition: block.h:60
value
Definition: value.c:169
value_ref
struct value * value_ref(struct value *arg1, enum type_code refcode)
Definition: valops.c:1521
TYPE_CODE_PTR
Definition: gdbtypes.h:84
VTBL_FNADDR_OFFSET
#define VTBL_FNADDR_OFFSET
Definition: symtab.h:1502
print_spaces_filtered
void print_spaces_filtered(int n, struct ui_file *stream)
Definition: utils.c:2121
value_print_options::unionprint
int unionprint
Definition: valprint.h:40
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
value_entirely_available
int value_entirely_available(struct value *value)
Definition: value.c:374
value_from_pointer
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3560
value_print_options::vtblprint
int vtblprint
Definition: valprint.h:37
current_language
const struct language_defn * current_language
Definition: language.c:81
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
lookup_minimal_symbol_by_pc
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:928
c_value_print
void c_value_print(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition: c-valprint.c:571
c_val_print_struct
static void c_val_print_struct(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options)
Definition: c-valprint.c:389
generic_val_print
void generic_val_print(struct type *type, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options, const struct generic_val_print_decorations *decorations)
Definition: valprint.c:884
value_print_options::prettyformat_arrays
int prettyformat_arrays
Definition: valprint.h:31
value_print_options::symbol_print
int symbol_print
Definition: valprint.h:94
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
cplus_print_method_ptr
void cplus_print_method_ptr(const gdb_byte *contents, struct type *type, struct ui_file *stream)
Definition: cp-abi.c:129
c-lang.h
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
offset
int offset
Definition: agent.c:65
print_address_demangle
int print_address_demangle(const struct value_print_options *opts, struct gdbarch *gdbarch, CORE_ADDR addr, struct ui_file *stream, int do_demangle)
Definition: printcmd.c:736
TYPE_CODE_MEMBERPTR
Definition: gdbtypes.h:154
target.h
VAR_DOMAIN
Definition: symtab.h:739
value.h
val_print
void val_print(struct type *type, LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *val, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1015
gdbtypes.h
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
value_print_options::print_max
unsigned int print_max
Definition: valprint.h:53
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
symbol
Definition: symtab.h:1049
value_as_address
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2762
LA_PRINT_STRING
#define LA_PRINT_STRING(stream, elttype, string, length, encoding, force_ellipses, options)
Definition: language.h:529
value_print_options::output_format
int output_format
Definition: valprint.h:60
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
val_print_string
int val_print_string(struct type *elttype, const char *encoding, CORE_ADDR addr, int len, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:2795
LA_PRINT_CHAR
#define LA_PRINT_CHAR(ch, type, stream)
Definition: language.h:527
print_function_pointer_address
void print_function_pointer_address(const struct value_print_options *options, struct gdbarch *gdbarch, CORE_ADDR address, struct ui_file *stream)
Definition: valprint.c:1884
gdb_flush
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:93
val_print_array_elements
void val_print_array_elements(struct type *type, LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *val, const struct value_print_options *options, unsigned int i)
Definition: valprint.c:1932
valprint.h
TYPE_CODE_METHOD
Definition: gdbtypes.h:141
value_address
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1529
get_array_bounds
int get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition: gdbtypes.c:1056
gdbarch::byte_order
enum bfd_endian byte_order
Definition: gdbarch.c:137
value_print_options::objectprint
int objectprint
Definition: valprint.h:47
c_val_print_ptr
static void c_val_print_ptr(struct type *type, const gdb_byte *valaddr, int embedded_offset, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options)
Definition: c-valprint.c:349
error
void error(const char *fmt,...)
Definition: errors.c:38
LONGEST
long long LONGEST
Definition: common-types.h:52
cp-abi.h
TYPE_CODE_COMPLEX
Definition: gdbtypes.h:167
value_rtti_indirect_type
struct type * value_rtti_indirect_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition: valops.c:3595
textual_name
static int textual_name(const char *name)
Definition: c-valprint.c:38