GDB (xrefs)
Loading...
Searching...
No Matches
typeprint.c
Go to the documentation of this file.
1/* Language independent support for printing types for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2023 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 "gdbsupport/gdb_obstack.h"
22#include "bfd.h" /* Binary File Description */
23#include "symtab.h"
24#include "gdbtypes.h"
25#include "expression.h"
26#include "value.h"
27#include "gdbcore.h"
28#include "command.h"
29#include "gdbcmd.h"
30#include "target.h"
31#include "language.h"
32#include "cp-abi.h"
33#include "typeprint.h"
34#include "valprint.h"
35#include <ctype.h>
36#include "cli/cli-utils.h"
37#include "extension.h"
38#include "completer.h"
39#include "cli/cli-style.h"
40
42{
43 1, /* raw */
44 1, /* print_methods */
45 1, /* print_typedefs */
46 0, /* print_offsets */
47 0, /* print_in_hex */
48 0, /* print_nested_type_limit */
49 NULL, /* local_typedefs */
50 NULL, /* global_table */
51 NULL /* global_printers */
52};
53
54/* The default flags for 'ptype' and 'whatis'. */
55
57{
58 0, /* raw */
59 1, /* print_methods */
60 1, /* print_typedefs */
61 0, /* print_offsets */
62 0, /* print_in_hex */
63 0, /* print_nested_type_limit */
64 NULL, /* local_typedefs */
65 NULL, /* global_table */
66 NULL /* global_printers */
67};
68
69
70
71/* See typeprint.h. */
72
74
75/* See typeprint.h. */
76
78{
79 if (flags != nullptr)
80 print_in_hex = flags->print_in_hex;
81}
82
83/* See typeprint.h. */
84
85void
87 unsigned int bitpos,
88 const char *for_what)
89{
90 /* We check for END_BITPOS > 0 because there is a specific
91 scenario when END_BITPOS can be zero and BITPOS can be >
92 0: when we are dealing with a struct/class with a virtual method.
93 Because of the vtable, the first field of the struct/class will
94 have an offset of sizeof (void *) (the size of the vtable). If
95 we do not check for END_BITPOS > 0 here, GDB will report
96 a hole before the first field, which is not accurate. */
97 if (end_bitpos > 0 && end_bitpos < bitpos)
98 {
99 /* If END_BITPOS is smaller than the current type's
100 bitpos, it means there's a hole in the struct, so we report
101 it here. */
102 unsigned int hole = bitpos - end_bitpos;
103 unsigned int hole_byte = hole / TARGET_CHAR_BIT;
104 unsigned int hole_bit = hole % TARGET_CHAR_BIT;
105
106 if (hole_bit > 0)
107 {
109 "/* XXX %2u-bit %-7s */", hole_bit, for_what);
110 gdb_puts ("\n", stream);
111 }
112
113 if (hole_byte > 0)
114 {
116 "/* XXX %2u-byte %-7s */", hole_byte, for_what);
117 gdb_puts ("\n", stream);
118 }
119 }
120}
121
122/* See typeprint.h. */
123
124void
125print_offset_data::update (struct type *type, unsigned int field_idx,
126 struct ui_file *stream)
127{
128 if (field_is_static (&type->field (field_idx)))
129 {
130 print_spaces (indentation, stream);
131 return;
132 }
133
134 struct type *ftype = check_typedef (type->field (field_idx).type ());
135 if (type->code () == TYPE_CODE_UNION)
136 {
137 /* Since union fields don't have the concept of offsets, we just
138 print their sizes. */
139 gdb_printf (stream, "/* %6s */",
140 (print_in_hex ?
141 hex_string_custom (ftype->length (), 4) :
142 pulongest (ftype->length ())));
143 return;
144 }
145
146 unsigned int bitpos = type->field (field_idx).loc_bitpos ();
147 unsigned int fieldsize_byte = ftype->length ();
148 unsigned int fieldsize_bit = fieldsize_byte * TARGET_CHAR_BIT;
149
150 maybe_print_hole (stream, bitpos, "hole");
151
152 if (TYPE_FIELD_PACKED (type, field_idx)
153 || offset_bitpos % TARGET_CHAR_BIT != 0)
154 {
155 /* We're dealing with a bitfield. Print the bit offset. */
156 fieldsize_bit = TYPE_FIELD_BITSIZE (type, field_idx);
157
158 unsigned real_bitpos = bitpos + offset_bitpos;
159
160 gdb_printf (stream,
161 (print_in_hex ? "/* 0x%04x: 0x%x" : "/* %6u:%2u "),
162 real_bitpos / TARGET_CHAR_BIT,
163 real_bitpos % TARGET_CHAR_BIT);
164 }
165 else
166 {
167 /* The position of the field, relative to the beginning of the
168 struct. */
169 gdb_printf (stream, (print_in_hex ? "/* 0x%04x" : "/* %6u"),
170 (bitpos + offset_bitpos) / TARGET_CHAR_BIT);
171
172 gdb_printf (stream, " ");
173 }
174
175 gdb_printf (stream, (print_in_hex ? " | 0x%04x */" : " | %6u */"),
176 fieldsize_byte);
177
178 end_bitpos = bitpos + fieldsize_bit;
179}
180
181/* See typeprint.h. */
182
183void
185 struct ui_file *stream)
186{
187 unsigned int bitpos = type->length () * TARGET_CHAR_BIT;
188 maybe_print_hole (stream, bitpos, "padding");
189
190 gdb_puts ("\n", stream);
191 print_spaces (level + 4 + print_offset_data::indentation, stream);
192 gdb_printf (stream, "/* total size (bytes): %4s */\n",
193 pulongest (type->length ()));
194}
195
196
197
198/* A hash function for a typedef_field. */
199
200static hashval_t
201hash_typedef_field (const void *p)
202{
203 const struct decl_field *tf = (const struct decl_field *) p;
204
205 return htab_hash_string (TYPE_SAFE_NAME (tf->type));
206}
207
208/* An equality function for a typedef field. */
209
210static int
211eq_typedef_field (const void *a, const void *b)
212{
213 const struct decl_field *tfa = (const struct decl_field *) a;
214 const struct decl_field *tfb = (const struct decl_field *) b;
215
216 return types_equal (tfa->type, tfb->type);
217}
218
219/* See typeprint.h. */
220
221void
223{
224 int i;
225
226 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (t); ++i)
227 {
228 struct decl_field *tdef = &TYPE_TYPEDEF_FIELD (t, i);
229 void **slot;
230
231 slot = htab_find_slot (m_table.get (), tdef, INSERT);
232 /* Only add a given typedef name once. Really this shouldn't
233 happen; but it is safe enough to do the updates breadth-first
234 and thus use the most specific typedef. */
235 if (*slot == NULL)
236 *slot = tdef;
237 }
238
239 /* Recurse into superclasses. */
240 for (i = 0; i < TYPE_N_BASECLASSES (t); ++i)
242}
243
244/* See typeprint.h. */
245
246void
248{
249 int i;
250
251 for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (t); ++i)
252 {
253 struct decl_field *tf;
254 void **slot;
255
256 /* We only want type-valued template parameters in the hash. */
257 if (TYPE_TEMPLATE_ARGUMENT (t, i)->aclass () != LOC_TYPEDEF)
258 continue;
259
260 tf = XOBNEW (&m_storage, struct decl_field);
261 tf->name = TYPE_TEMPLATE_ARGUMENT (t, i)->linkage_name ();
262 tf->type = TYPE_TEMPLATE_ARGUMENT (t, i)->type ();
263
264 slot = htab_find_slot (m_table.get (), tf, INSERT);
265 if (*slot == NULL)
266 *slot = tf;
267 }
268}
269
270/* See typeprint.h. */
271
273 : m_table (htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
274 NULL, xcalloc, xfree))
275{
276}
277
278/* Helper function for typedef_hash_table::copy. */
279
280static int
281copy_typedef_hash_element (void **slot, void *nt)
282{
283 htab_t new_table = (htab_t) nt;
284 void **new_slot;
285
286 new_slot = htab_find_slot (new_table, *slot, INSERT);
287 if (*new_slot == NULL)
288 *new_slot = *slot;
289
290 return 1;
291}
292
293/* See typeprint.h. */
294
296{
297 m_table.reset (htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
298 NULL, xcalloc, xfree));
299 htab_traverse_noresize (table.m_table.get (), copy_typedef_hash_element,
300 m_table.get ());
301}
302
303/* Look up the type T in the global typedef hash. If it is found,
304 return the typedef name. If it is not found, apply the
305 type-printers, if any, given by start_script_type_printers and return the
306 result. A NULL return means that the name was not found. */
307
308const char *
310 struct type *t)
311{
312 char *applied;
313 void **slot;
314 struct decl_field tf, *new_tf;
315
316 if (flags->global_typedefs == NULL)
317 return NULL;
318
319 tf.name = NULL;
320 tf.type = t;
321
322 slot = htab_find_slot (flags->global_typedefs->m_table.get (), &tf, INSERT);
323 if (*slot != NULL)
324 {
325 new_tf = (struct decl_field *) *slot;
326 return new_tf->name;
327 }
328
329 /* Put an entry into the hash table now, in case
330 apply_ext_lang_type_printers recurses. */
331 new_tf = XOBNEW (&flags->global_typedefs->m_storage, struct decl_field);
332 new_tf->name = NULL;
333 new_tf->type = t;
334
335 *slot = new_tf;
336
337 applied = apply_ext_lang_type_printers (flags->global_printers, t);
338
339 if (applied != NULL)
340 {
341 new_tf->name = obstack_strdup (&flags->global_typedefs->m_storage,
342 applied);
343 xfree (applied);
344 }
345
346 return new_tf->name;
347}
348
349/* See typeprint.h. */
350
351const char *
353 struct type *t)
354{
355 if (flags->local_typedefs != NULL)
356 {
357 struct decl_field tf, *found;
358
359 tf.name = NULL;
360 tf.type = t;
361 htab_t table = flags->local_typedefs->m_table.get ();
362 found = (struct decl_field *) htab_find (table, &tf);
363
364 if (found != NULL)
365 return found->name;
366 }
367
368 return find_global_typedef (flags, t);
369}
370
371
372
373/* Print a description of a type in the format of a
374 typedef for the current language.
375 NEW is the new name for a type TYPE. */
376
377void
378typedef_print (struct type *type, struct symbol *newobj, struct ui_file *stream)
379{
380 current_language->print_typedef (type, newobj, stream);
381}
382
383/* Print a description of a type TYPE in the form of a declaration of a
384 variable named VARSTRING. (VARSTRING is demangled if necessary.)
385 Output goes to STREAM (via stdio).
386 If SHOW is positive, we show the contents of the outermost level
387 of structure even if there is a type name that could be used instead.
388 If SHOW is negative, we never show the details of elements' types. */
389
390void
391type_print (struct type *type, const char *varstring, struct ui_file *stream,
392 int show)
393{
394 current_language->print_type (type, varstring, stream, show, 0,
396}
397
398/* Print TYPE to a string, returning it. The caller is responsible for
399 freeing the string. */
400
401std::string
403{
404 try
405 {
406 string_file stb;
407
408 type_print (type, "", &stb, -1);
409 return stb.release ();
410 }
411 catch (const gdb_exception &except)
412 {
413 }
414
415 return {};
416}
417
418/* See typeprint.h. */
419
420void
422{
424 _("<unknown return type>"));
425}
426
427/* See typeprint.h. */
428
429void
430error_unknown_type (const char *sym_print_name)
431{
432 error (_("'%s' has unknown type; cast it to its declared type"),
433 sym_print_name);
434}
435
436/* Print type of EXP, or last thing in value history if EXP == NULL.
437 show is passed to type_print. */
438
439static void
440whatis_exp (const char *exp, int show)
441{
442 struct value *val;
443 struct type *real_type = NULL;
444 struct type *type;
445 int full = 0;
446 LONGEST top = -1;
447 int using_enc = 0;
448 struct value_print_options opts;
450
451 if (exp)
452 {
453 if (*exp == '/')
454 {
455 int seen_one = 0;
456
457 for (++exp; *exp && !isspace (*exp); ++exp)
458 {
459 switch (*exp)
460 {
461 case 'r':
462 flags.raw = 1;
463 break;
464 case 'm':
465 flags.print_methods = 0;
466 break;
467 case 'M':
468 flags.print_methods = 1;
469 break;
470 case 't':
471 flags.print_typedefs = 0;
472 break;
473 case 'T':
474 flags.print_typedefs = 1;
475 break;
476 case 'o':
477 {
478 /* Filter out languages which don't implement the
479 feature. */
480 if (show > 0
482 {
483 flags.print_offsets = 1;
484 flags.print_typedefs = 0;
485 flags.print_methods = 0;
486 }
487 break;
488 }
489 case 'x':
490 flags.print_in_hex = 1;
491 break;
492 case 'd':
493 flags.print_in_hex = 0;
494 break;
495 default:
496 error (_("unrecognized flag '%c'"), *exp);
497 }
498 seen_one = 1;
499 }
500
501 if (!*exp && !seen_one)
502 error (_("flag expected"));
503 if (!isspace (*exp))
504 error (_("expected space after format"));
505 exp = skip_spaces (exp);
506 }
507
509
510 /* The behavior of "whatis" depends on whether the user
511 expression names a type directly, or a language expression
512 (including variable names). If the former, then "whatis"
513 strips one level of typedefs, only. If an expression,
514 "whatis" prints the type of the expression without stripping
515 any typedef level. "ptype" always strips all levels of
516 typedefs. */
517 val = evaluate_type (expr.get ());
518 type = value_type (val);
519
520 if (show == -1 && expr->first_opcode () == OP_TYPE)
521 {
522 /* The user expression names a type directly. */
523
524 /* If this is a typedef, then find its immediate target.
525 Use check_typedef to resolve stubs, but ignore its result
526 because we do not want to dig past all typedefs. */
528 if (type->code () == TYPE_CODE_TYPEDEF)
529 type = type->target_type ();
530
531 /* If the expression is actually a type, then there's no
532 value to fetch the dynamic type from. */
533 val = NULL;
534 }
535 }
536 else
537 {
538 val = access_value_history (0);
539 type = value_type (val);
540 }
541
543 if (val != NULL && opts.objectprint)
544 {
546 && (type->target_type ()->code () == TYPE_CODE_STRUCT))
547 real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
548 else if (type->code () == TYPE_CODE_STRUCT)
549 real_type = value_rtti_type (val, &full, &top, &using_enc);
550 }
551
552 if (flags.print_offsets
553 && (type->code () == TYPE_CODE_STRUCT
554 || type->code () == TYPE_CODE_UNION))
555 gdb_printf ("/* offset | size */ ");
556
557 gdb_printf ("type = ");
558
559 std::unique_ptr<typedef_hash_table> table_holder;
560 std::unique_ptr<ext_lang_type_printers> printer_holder;
561 if (!flags.raw)
562 {
563 table_holder.reset (new typedef_hash_table);
564 flags.global_typedefs = table_holder.get ();
565
566 printer_holder.reset (new ext_lang_type_printers);
567 flags.global_printers = printer_holder.get ();
568 }
569
570 if (real_type)
571 {
572 gdb_printf ("/* real type = ");
573 type_print (real_type, "", gdb_stdout, -1);
574 if (! full)
575 gdb_printf (" (incomplete object)");
576 gdb_printf (" */\n");
577 }
578
580 gdb_printf ("\n");
581}
582
583static void
584whatis_command (const char *exp, int from_tty)
585{
586 /* Most of the time users do not want to see all the fields
587 in a structure. If they do they can use the "ptype" command.
588 Hence the "-1" below. */
589 whatis_exp (exp, -1);
590}
591
592/* TYPENAME is either the name of a type, or an expression. */
593
594static void
595ptype_command (const char *type_name, int from_tty)
596{
597 whatis_exp (type_name, 1);
598}
599
600/* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
601 Used to print data from type structures in a specified type. For example,
602 array bounds may be characters or booleans in some languages, and this
603 allows the ranges to be printed in their "natural" form rather than as
604 decimal integer values.
605
606 FIXME: This is here simply because only the type printing routines
607 currently use it, and it wasn't clear if it really belonged somewhere
608 else (like printcmd.c). There are a lot of other gdb routines that do
609 something similar, but they are generally concerned with printing values
610 that come from the inferior in target byte order and target size. */
611
612void
613print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
614{
615 unsigned int i;
616 unsigned len;
617
619
620 switch (type->code ())
621 {
622
623 case TYPE_CODE_ENUM:
624 len = type->num_fields ();
625 for (i = 0; i < len; i++)
626 {
627 if (type->field (i).loc_enumval () == val)
628 {
629 break;
630 }
631 }
632 if (i < len)
633 {
634 gdb_puts (type->field (i).name (), stream);
635 }
636 else
637 {
638 print_longest (stream, 'd', 0, val);
639 }
640 break;
641
642 case TYPE_CODE_INT:
643 print_longest (stream, type->is_unsigned () ? 'u' : 'd', 0, val);
644 break;
645
646 case TYPE_CODE_CHAR:
647 current_language->printchar ((unsigned char) val, type, stream);
648 break;
649
650 case TYPE_CODE_BOOL:
651 gdb_printf (stream, val ? "TRUE" : "FALSE");
652 break;
653
654 case TYPE_CODE_RANGE:
655 print_type_scalar (type->target_type (), val, stream);
656 return;
657
658 case TYPE_CODE_FIXED_POINT:
660 break;
661
662 case TYPE_CODE_UNDEF:
663 case TYPE_CODE_PTR:
664 case TYPE_CODE_ARRAY:
665 case TYPE_CODE_STRUCT:
666 case TYPE_CODE_UNION:
667 case TYPE_CODE_FUNC:
668 case TYPE_CODE_FLT:
669 case TYPE_CODE_VOID:
670 case TYPE_CODE_SET:
671 case TYPE_CODE_STRING:
672 case TYPE_CODE_ERROR:
673 case TYPE_CODE_MEMBERPTR:
674 case TYPE_CODE_METHODPTR:
675 case TYPE_CODE_METHOD:
676 case TYPE_CODE_REF:
677 case TYPE_CODE_RVALUE_REF:
678 case TYPE_CODE_NAMESPACE:
679 error (_("internal error: unhandled type in print_type_scalar"));
680 break;
681
682 default:
683 error (_("Invalid type code in symbol table."));
684 }
685}
686
687/* See typeprint.h. */
688
689void
690print_type_fixed_point (struct type *type, struct ui_file *stream)
691{
692 std::string small_img = type->fixed_point_scaling_factor ().str ();
693
694 gdb_printf (stream, "%s-byte fixed point (small = %s)",
695 pulongest (type->length ()), small_img.c_str ());
696}
697
698/* Dump details of a type specified either directly or indirectly.
699 Uses the same sort of type lookup mechanism as ptype_command()
700 and whatis_command(). */
701
702void
703maintenance_print_type (const char *type_name, int from_tty)
704{
705 if (type_name != NULL)
706 {
707 expression_up expr = parse_expression (type_name);
708 struct value *val = evaluate_type (expr.get ());
709 struct type *type = value_type (val);
710
711 if (type != nullptr)
713 }
714}
715
716
718
720
721static bool print_methods = true;
722
723static void
724set_print_type_methods (const char *args,
725 int from_tty, struct cmd_list_element *c)
726{
728}
729
730static void
731show_print_type_methods (struct ui_file *file, int from_tty,
732 struct cmd_list_element *c, const char *value)
733{
734 gdb_printf (file, _("Printing of methods defined in a class in %s\n"),
735 value);
736}
737
738static bool print_typedefs = true;
739
740static void
741set_print_type_typedefs (const char *args,
742 int from_tty, struct cmd_list_element *c)
743{
745}
746
747static void
748show_print_type_typedefs (struct ui_file *file, int from_tty,
749 struct cmd_list_element *c, const char *value)
750{
751 gdb_printf (file, _("Printing of typedefs defined in a class in %s\n"),
752 value);
753}
754
755/* Limit on the number of nested type definitions to print or -1 to print
756 all nested type definitions in a class. By default, we do not print
757 nested definitions. */
758
760
761/* Set how many nested type definitions should be printed by the type
762 printer. */
763
764static void
765set_print_type_nested_types (const char *args, int from_tty,
766 struct cmd_list_element *c)
767{
769}
770
771/* Show how many nested type definitions the type printer will print. */
772
773static void
774show_print_type_nested_types (struct ui_file *file, int from_tty,
775 struct cmd_list_element *c, const char *value)
776{
777 if (*value == '0')
778 {
779 gdb_printf (file,
780 _("Will not print nested types defined in a class\n"));
781 }
782 else
783 {
784 gdb_printf (file,
785 _("Will print %s nested types defined in a class\n"),
786 value);
787 }
788}
789
790/* When printing structs, offsets and sizes of members can be displayed using
791 decimal notation or hexadecimal notation. By default, Decimal notation is
792 used. */
793
795
796/* Set the flags that instructs if sizes and offsets of struct members are
797 displayed in hexadecimal or decimal notation. */
798
799static void
801 int from_tty, struct cmd_list_element *c)
802{
804}
805
806/* Display whether struct members sizes and offsets are printed
807 using decimal or hexadecimal notation. */
808
809static void
811 struct cmd_list_element *c,
812 const char *value)
813{
814 gdb_printf (file, _("\
815Display of struct members offsets and sizes in hexadecimal is %s\n"),
816 value);
817}
818
820void
822{
823 struct cmd_list_element *c;
824
825 c = add_com ("ptype", class_vars, ptype_command, _("\
826Print definition of type TYPE.\n\
827Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
828Argument may be any type (for example a type name defined by typedef,\n\
829or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
830or \"enum ENUM-TAG\") or an expression.\n\
831The selected stack frame's lexical context is used to look up the name.\n\
832Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
833\n\
834Available FLAGS are:\n\
835 /r print in \"raw\" form; do not substitute typedefs\n\
836 /m do not print methods defined in a class\n\
837 /M print methods defined in a class\n\
838 /t do not print typedefs defined in a class\n\
839 /T print typedefs defined in a class\n\
840 /o print offsets and sizes of fields in a struct (like pahole)\n\
841 /x use hexadecimal notation when displaying sizes and offsets\n\
842 of struct members\n\
843 /d use decimal notation when displaying sizes and offsets\n\
844 of struct members "));
846
847 c = add_com ("whatis", class_vars, whatis_command,
848 _("Print data type of expression EXP.\n\
849Only one level of typedefs is unrolled. See also \"ptype\"."));
851
853 _("Generic command for showing type-printing settings."),
854 _("Generic command for setting how types print."),
857
859 _("\
860Set printing of methods defined in classes."), _("\
861Show printing of methods defined in classes."), NULL,
866 _("\
867Set printing of typedefs defined in classes."), _("\
868Show printing of typedefs defined in classes."), NULL,
872
873 add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class,
875 _("\
876Set the number of recursive nested type definitions to print \
877(\"unlimited\" or -1 to show all)."), _("\
878Show the number of recursive nested type definitions to print."), NULL,
882
884 _("\
885Set printing of struct members sizes and offsets using hex notation."), _("\
886Show whether sizes and offsets of struct members are printed using hex \
887notation."), nullptr, set_print_offsets_and_sizes_in_hex,
890}
891
892/* Print <not allocated> status to stream STREAM. */
893
894void
896{
897 fprintf_styled (stream, metadata_style.style (), _("<not allocated>"));
898}
899
900/* Print <not associated> status to stream STREAM. */
901
902void
904{
905 fprintf_styled (stream, metadata_style.style (), _("<not associated>"));
906}
void xfree(void *)
void * xcalloc(size_t number, size_t size)
Definition alloc.c:85
ui_file_style style() const
Definition cli-style.c:169
std::string release()
Definition ui-file.h:200
auto_obstack m_storage
Definition typeprint.h:157
void add_template_parameters(struct type *t)
Definition typeprint.c:247
static const char * find_global_typedef(const struct type_print_options *flags, struct type *t)
Definition typeprint.c:309
static const char * find_typedef(const struct type_print_options *flags, struct type *t)
Definition typeprint.c:352
void recursively_update(struct type *)
Definition typeprint.c:222
struct cmd_list_element * showprintlist
Definition cli-cmds.c:161
struct cmd_list_element * setprintlist
Definition cli-cmds.c:159
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition cli-decode.c:117
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
set_show_commands add_setshow_zuinteger_unlimited_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
set_show_commands add_setshow_prefix_cmd(const char *name, command_class theclass, const char *set_doc, const char *show_doc, cmd_list_element **set_subcommands_list, cmd_list_element **show_subcommands_list, cmd_list_element **set_list, cmd_list_element **show_list)
Definition cli-decode.c:428
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:739
cli_style_option highlight_style
cli_style_option metadata_style
@ class_vars
Definition command.h:55
@ no_class
Definition command.h:53
void expression_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition completer.c:1092
struct type * value_rtti_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition cp-abi.c:107
struct value * evaluate_type(struct expression *exp)
Definition eval.c:122
std::unique_ptr< expression > expression_up
Definition expression.h:229
expression_up parse_expression(const char *, innermost_block_tracker *=nullptr, bool void_context_p=false)
Definition parse.c:546
char * apply_ext_lang_type_printers(struct ext_lang_type_printers *printers, struct type *type)
Definition extension.c:422
int field_is_static(struct field *f)
Definition gdbtypes.c:5048
bool types_equal(struct type *a, struct type *b)
Definition gdbtypes.c:4232
void recursive_dump_type(struct type *type, int spaces)
Definition gdbtypes.c:5235
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:3010
#define TYPE_SAFE_NAME(type)
Definition gdbtypes.h:2228
#define TYPE_BASECLASS(thistype, index)
Definition gdbtypes.h:2107
@ TYPE_CODE_UNDEF
Definition gdbtypes.h:100
#define TYPE_N_TEMPLATE_ARGUMENTS(thistype)
Definition gdbtypes.h:2161
#define TYPE_TEMPLATE_ARGUMENT(thistype, n)
Definition gdbtypes.h:2165
#define TYPE_TYPEDEF_FIELD(thistype, n)
Definition gdbtypes.h:2189
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition gdbtypes.h:2123
#define TYPE_TYPEDEF_FIELD_COUNT(thistype)
Definition gdbtypes.h:2195
#define TYPE_FIELD_PACKED(thistype, n)
Definition gdbtypes.h:2124
#define TYPE_N_BASECLASSES(thistype)
Definition gdbtypes.h:2108
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition gnu-nat.c:1862
const struct language_defn * current_language
Definition language.c:83
Definition ada-exp.h:80
const char * name
Definition gdbtypes.h:1557
struct type * type
Definition gdbtypes.h:1561
LONGEST loc_bitpos() const
Definition gdbtypes.h:586
LONGEST loc_enumval() const
Definition gdbtypes.h:598
const char * name() const
Definition gdbtypes.h:569
struct type * type() const
Definition gdbtypes.h:559
std::string str() const
Definition gmp-utils.h:185
virtual bool can_print_type_offsets() const
Definition language.h:456
virtual void print_type(struct type *type, const char *varstring, struct ui_file *stream, int show, int level, const struct type_print_options *flags) const =0
virtual void printchar(int ch, struct type *chtype, struct ui_file *stream) const
Definition c-lang.c:159
virtual void print_typedef(struct type *type, struct symbol *new_symbol, struct ui_file *stream) const
Definition language.c:634
void update(struct type *type, unsigned int field_idx, struct ui_file *stream)
Definition typeprint.c:125
static const int indentation
Definition typeprint.h:100
void finish(struct type *type, int level, struct ui_file *stream)
Definition typeprint.c:184
unsigned int offset_bitpos
Definition typeprint.h:72
print_offset_data(const struct type_print_options *flags)
Definition typeprint.c:77
void maybe_print_hole(struct ui_file *stream, unsigned int bitpos, const char *for_what)
Definition typeprint.c:86
unsigned int end_bitpos
Definition typeprint.h:77
unsigned int print_in_hex
Definition typeprint.h:44
unsigned int print_methods
Definition typeprint.h:35
unsigned int print_typedefs
Definition typeprint.h:38
int print_nested_type_limit
Definition typeprint.h:47
struct type * target_type() const
Definition gdbtypes.h:1000
type_code code() const
Definition gdbtypes.h:927
ULONGEST length() const
Definition gdbtypes.h:954
struct field & field(int idx) const
Definition gdbtypes.h:983
bool is_unsigned() const
Definition gdbtypes.h:1063
int num_fields() const
Definition gdbtypes.h:965
const gdb_mpq & fixed_point_scaling_factor()
Definition gdbtypes.c:6143
bool is_pointer_or_reference() const
Definition gdbtypes.h:1394
Definition value.c:181
@ LOC_TYPEDEF
Definition symtab.h:989
static void set_print_offsets_and_sizes_in_hex(const char *args, int from_tty, struct cmd_list_element *c)
Definition typeprint.c:800
static struct type_print_options default_ptype_flags
Definition typeprint.c:56
void val_print_not_allocated(struct ui_file *stream)
Definition typeprint.c:895
void print_type_fixed_point(struct type *type, struct ui_file *stream)
Definition typeprint.c:690
static int eq_typedef_field(const void *a, const void *b)
Definition typeprint.c:211
void maintenance_print_type(const char *type_name, int from_tty)
Definition typeprint.c:703
struct cmd_list_element * showprinttypelist
Definition typeprint.c:719
void print_type_scalar(struct type *type, LONGEST val, struct ui_file *stream)
Definition typeprint.c:613
static void show_print_type_methods(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition typeprint.c:731
static void set_print_type_typedefs(const char *args, int from_tty, struct cmd_list_element *c)
Definition typeprint.c:741
static void set_print_type_nested_types(const char *args, int from_tty, struct cmd_list_element *c)
Definition typeprint.c:765
static int copy_typedef_hash_element(void **slot, void *nt)
Definition typeprint.c:281
const struct type_print_options type_print_raw_options
Definition typeprint.c:41
static void whatis_command(const char *exp, int from_tty)
Definition typeprint.c:584
std::string type_to_string(struct type *type)
Definition typeprint.c:402
static void show_print_type_nested_types(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition typeprint.c:774
static void ptype_command(const char *type_name, int from_tty)
Definition typeprint.c:595
static bool print_offsets_and_sizes_in_hex
Definition typeprint.c:794
static void whatis_exp(const char *exp, int show)
Definition typeprint.c:440
static void show_print_offsets_and_sizes_in_hex(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition typeprint.c:810
void val_print_not_associated(struct ui_file *stream)
Definition typeprint.c:903
static hashval_t hash_typedef_field(const void *p)
Definition typeprint.c:201
static bool print_typedefs
Definition typeprint.c:738
static int print_nested_type_limit
Definition typeprint.c:759
static void show_print_type_typedefs(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition typeprint.c:748
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition typeprint.c:391
void _initialize_typeprint()
Definition typeprint.c:821
void error_unknown_type(const char *sym_print_name)
Definition typeprint.c:430
static bool print_methods
Definition typeprint.c:721
void typedef_print(struct type *type, struct symbol *newobj, struct ui_file *stream)
Definition typeprint.c:378
static void set_print_type_methods(const char *args, int from_tty, struct cmd_list_element *c)
Definition typeprint.c:724
struct cmd_list_element * setprinttypelist
Definition typeprint.c:717
void type_print_unknown_return_type(struct ui_file *stream)
Definition typeprint.c:421
void print_spaces(int n, struct ui_file *stream)
Definition utils.c:1947
void fprintf_styled(struct ui_file *stream, const ui_file_style &style, const char *format,...)
Definition utils.c:1877
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1788
#define gdb_stdout
Definition utils.h:188
struct type * value_rtti_indirect_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition valops.c:3850
void get_user_print_options(struct value_print_options *opts)
Definition valprint.c:128
void print_longest(struct ui_file *stream, int format, int use_c_format, LONGEST val_long)
Definition valprint.c:1316
struct type * value_type(const struct value *value)
Definition value.c:1109
struct value * access_value_history(int num)
Definition value.c:1947