GDB (xrefs)
Loading...
Searching...
No Matches
p-typeprint.c
Go to the documentation of this file.
1/* Support for printing Pascal types for GDB, the GNU debugger.
2 Copyright (C) 2000-2023 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
18
19/* This file is derived from p-typeprint.c */
20
21#include "defs.h"
22#include "gdbsupport/gdb_obstack.h"
23#include "bfd.h" /* Binary File Description */
24#include "symtab.h"
25#include "gdbtypes.h"
26#include "expression.h"
27#include "value.h"
28#include "gdbcore.h"
29#include "target.h"
30#include "language.h"
31#include "p-lang.h"
32#include "typeprint.h"
33#include "gdb-demangle.h"
34#include <ctype.h>
35#include "cli/cli-style.h"
36
37/* See language.h. */
38
39void
40pascal_language::print_type (struct type *type, const char *varstring,
41 struct ui_file *stream, int show, int level,
42 const struct type_print_options *flags) const
43{
44 enum type_code code;
45 int demangled_args;
46
47 code = type->code ();
48
49 if (show > 0)
51
52 if ((code == TYPE_CODE_FUNC
53 || code == TYPE_CODE_METHOD))
54 {
55 type_print_varspec_prefix (type, stream, show, 0, flags);
56 }
57 /* first the name */
58 gdb_puts (varstring, stream);
59
60 if ((varstring != NULL && *varstring != '\0')
61 && !(code == TYPE_CODE_FUNC
62 || code == TYPE_CODE_METHOD))
63 {
64 gdb_puts (" : ", stream);
65 }
66
67 if (!(code == TYPE_CODE_FUNC
68 || code == TYPE_CODE_METHOD))
69 {
70 type_print_varspec_prefix (type, stream, show, 0, flags);
71 }
72
73 type_print_base (type, stream, show, level, flags);
74 /* For demangled function names, we have the arglist as part of the name,
75 so don't print an additional pair of ()'s. */
76
77 demangled_args = varstring ? strchr (varstring, '(') != NULL : 0;
78 type_print_varspec_suffix (type, stream, show, 0, demangled_args,
79 flags);
80
81}
82
83/* See language.h. */
84
85void
87 struct ui_file *stream) const
88{
90 gdb_printf (stream, "type ");
91 gdb_printf (stream, "%s = ", new_symbol->print_name ());
92 type_print (type, "", stream, 0);
93 gdb_printf (stream, ";");
94}
95
96/* See p-lang.h. */
97
98void
100 struct type *type) const
101{
102 const char *name;
103 int i;
104
105 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
106 {
107 gdb_puts (i == 0 ? ": " : ", ", stream);
108 gdb_printf (stream, "%s%s ",
109 BASETYPE_VIA_PUBLIC (type, i) ? "public" : "private",
110 BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
111 name = TYPE_BASECLASS (type, i)->name ();
112 gdb_printf (stream, "%s", name ? name : "(null)");
113 }
114 if (i > 0)
115 {
116 gdb_puts (" ", stream);
117 }
118}
119
120/* See p-lang.h. */
121
122void
124 const char *methodname,
125 struct ui_file *stream) const
126{
127 int is_constructor = (startswith (physname, "__ct__"));
128 int is_destructor = (startswith (physname, "__dt__"));
129
130 if (is_constructor || is_destructor)
131 {
132 physname += 6;
133 }
134
135 gdb_puts (methodname, stream);
136
137 if (physname && (*physname != 0))
138 {
139 gdb_puts (" (", stream);
140 /* We must demangle this. */
141 while (isdigit (physname[0]))
142 {
143 int len = 0;
144 int i, j;
145 char *argname;
146
147 while (isdigit (physname[len]))
148 {
149 len++;
150 }
151 i = strtol (physname, &argname, 0);
152 physname += len;
153
154 for (j = 0; j < i; ++j)
155 gdb_putc (physname[j], stream);
156
157 physname += i;
158 if (physname[0] != 0)
159 {
160 gdb_puts (", ", stream);
161 }
162 }
163 gdb_puts (")", stream);
164 }
165}
166
167/* See p-lang.h. */
168
169void
171 struct ui_file *stream,
172 int show, int passed_a_ptr,
173 const struct type_print_options *flags) const
174{
175 if (type == 0)
176 return;
177
178 if (type->name () && show <= 0)
179 return;
180
181 QUIT;
182
183 switch (type->code ())
184 {
185 case TYPE_CODE_PTR:
186 gdb_printf (stream, "^");
187 type_print_varspec_prefix (type->target_type (), stream, 0, 1,
188 flags);
189 break; /* Pointer should be handled normally
190 in pascal. */
191
192 case TYPE_CODE_METHOD:
193 if (passed_a_ptr)
194 gdb_printf (stream, "(");
195 if (type->target_type () != NULL
196 && type->target_type ()->code () != TYPE_CODE_VOID)
197 {
198 gdb_printf (stream, "function ");
199 }
200 else
201 {
202 gdb_printf (stream, "procedure ");
203 }
204
205 if (passed_a_ptr)
206 {
207 gdb_printf (stream, " ");
209 stream, 0, passed_a_ptr, flags);
210 gdb_printf (stream, "::");
211 }
212 break;
213
214 case TYPE_CODE_REF:
215 type_print_varspec_prefix (type->target_type (), stream, 0, 1,
216 flags);
217 gdb_printf (stream, "&");
218 break;
219
220 case TYPE_CODE_FUNC:
221 if (passed_a_ptr)
222 gdb_printf (stream, "(");
223
224 if (type->target_type () != NULL
225 && type->target_type ()->code () != TYPE_CODE_VOID)
226 {
227 gdb_printf (stream, "function ");
228 }
229 else
230 {
231 gdb_printf (stream, "procedure ");
232 }
233
234 break;
235
236 case TYPE_CODE_ARRAY:
237 if (passed_a_ptr)
238 gdb_printf (stream, "(");
239 gdb_printf (stream, "array ");
240 if (type->target_type ()->length () > 0
241 && type->bounds ()->high.kind () != PROP_UNDEFINED)
242 gdb_printf (stream, "[%s..%s] ",
243 plongest (type->bounds ()->low.const_val ()),
244 plongest (type->bounds ()->high.const_val ()));
245 gdb_printf (stream, "of ");
246 break;
247
248 case TYPE_CODE_UNDEF:
249 case TYPE_CODE_STRUCT:
250 case TYPE_CODE_UNION:
251 case TYPE_CODE_ENUM:
252 case TYPE_CODE_INT:
253 case TYPE_CODE_FLT:
254 case TYPE_CODE_VOID:
255 case TYPE_CODE_ERROR:
256 case TYPE_CODE_CHAR:
257 case TYPE_CODE_BOOL:
258 case TYPE_CODE_SET:
259 case TYPE_CODE_RANGE:
260 case TYPE_CODE_STRING:
261 case TYPE_CODE_COMPLEX:
262 case TYPE_CODE_TYPEDEF:
263 case TYPE_CODE_FIXED_POINT:
264 /* These types need no prefix. They are listed here so that
265 gcc -Wall will reveal any types that haven't been handled. */
266 break;
267 default:
268 gdb_assert_not_reached ("unexpected type");
269 break;
270 }
271}
272
273/* See p-lang.h. */
274
275void
277 const struct type_print_options *flags) const
278{
279 int i, len = type->num_fields ();
280
281 if (len)
282 {
283 gdb_printf (stream, "(");
284 }
285 for (i = 0; i < len; i++)
286 {
287 if (i > 0)
288 {
289 gdb_puts (", ", stream);
290 stream->wrap_here (4);
291 }
292 /* Can we find if it is a var parameter ??
293 if ( TYPE_FIELD(type, i) == )
294 {
295 gdb_printf (stream, "var ");
296 } */
297 print_type (type->field (i).type (), "" /* TYPE_FIELD_NAME
298 seems invalid! */
299 ,stream, -1, 0, flags);
300 }
301 if (len)
302 {
303 gdb_printf (stream, ")");
304 }
305}
306
307/* See p-lang.h. */
308
309void
311 struct ui_file *stream,
312 int show, int passed_a_ptr,
313 int demangled_args,
314 const struct type_print_options *flags) const
315{
316 if (type->target_type () == NULL
317 || type->target_type ()->code () != TYPE_CODE_VOID)
318 {
319 gdb_printf (stream, " : ");
321 stream, 0, 0, flags);
322
323 if (type->target_type () == NULL)
325 else
326 type_print_base (type->target_type (), stream, show, 0,
327 flags);
328
330 passed_a_ptr, 0, flags);
331 }
332}
333
334/* See p-lang.h. */
335
336void
338 struct ui_file *stream,
339 int show, int passed_a_ptr,
340 int demangled_args,
341 const struct type_print_options *flags) const
342{
343 if (type == 0)
344 return;
345
346 if (type->name () && show <= 0)
347 return;
348
349 QUIT;
350
351 switch (type->code ())
352 {
353 case TYPE_CODE_ARRAY:
354 if (passed_a_ptr)
355 gdb_printf (stream, ")");
356 break;
357
358 case TYPE_CODE_METHOD:
359 if (passed_a_ptr)
360 gdb_printf (stream, ")");
361 type_print_method_args ("", "", stream);
363 passed_a_ptr, 0, flags);
364 break;
365
366 case TYPE_CODE_PTR:
367 case TYPE_CODE_REF:
369 stream, 0, 1, 0, flags);
370 break;
371
372 case TYPE_CODE_FUNC:
373 if (passed_a_ptr)
374 gdb_printf (stream, ")");
375 if (!demangled_args)
376 print_func_args (type, stream, flags);
378 passed_a_ptr, 0, flags);
379 break;
380
381 case TYPE_CODE_UNDEF:
382 case TYPE_CODE_STRUCT:
383 case TYPE_CODE_UNION:
384 case TYPE_CODE_ENUM:
385 case TYPE_CODE_INT:
386 case TYPE_CODE_FLT:
387 case TYPE_CODE_VOID:
388 case TYPE_CODE_ERROR:
389 case TYPE_CODE_CHAR:
390 case TYPE_CODE_BOOL:
391 case TYPE_CODE_SET:
392 case TYPE_CODE_RANGE:
393 case TYPE_CODE_STRING:
394 case TYPE_CODE_COMPLEX:
395 case TYPE_CODE_TYPEDEF:
396 case TYPE_CODE_FIXED_POINT:
397 /* These types do not need a suffix. They are listed so that
398 gcc -Wall will report types that may not have been considered. */
399 break;
400 default:
401 gdb_assert_not_reached ("unexpected type");
402 break;
403 }
404}
405
406/* See p-lang.h. */
407
408void
409pascal_language::type_print_base (struct type *type, struct ui_file *stream, int show,
410 int level, const struct type_print_options *flags) const
411{
412 int i;
413 int len;
414 LONGEST lastval;
415 enum
416 {
418 }
419 section_type;
420
421 QUIT;
422 stream->wrap_here (4);
423 if (type == NULL)
424 {
425 fputs_styled ("<type unknown>", metadata_style.style (), stream);
426 return;
427 }
428
429 /* void pointer */
430 if ((type->code () == TYPE_CODE_PTR)
431 && (type->target_type ()->code () == TYPE_CODE_VOID))
432 {
433 gdb_puts (type->name () ? type->name () : "pointer",
434 stream);
435 return;
436 }
437 /* When SHOW is zero or less, and there is a valid type name, then always
438 just print the type name directly from the type. */
439
440 if (show <= 0
441 && type->name () != NULL)
442 {
443 gdb_puts (type->name (), stream);
444 return;
445 }
446
448
449 switch (type->code ())
450 {
451 case TYPE_CODE_TYPEDEF:
452 case TYPE_CODE_PTR:
453 case TYPE_CODE_REF:
454 type_print_base (type->target_type (), stream, show, level,
455 flags);
456 break;
457
458 case TYPE_CODE_ARRAY:
459 print_type (type->target_type (), NULL, stream, 0, 0, flags);
460 break;
461
462 case TYPE_CODE_FUNC:
463 case TYPE_CODE_METHOD:
464 break;
465 case TYPE_CODE_STRUCT:
466 if (type->name () != NULL)
467 {
468 gdb_puts (type->name (), stream);
469 gdb_puts (" = ", stream);
470 }
472 {
473 gdb_printf (stream, "class ");
474 }
475 else
476 {
477 gdb_printf (stream, "record ");
478 }
479 goto struct_union;
480
481 case TYPE_CODE_UNION:
482 if (type->name () != NULL)
483 {
484 gdb_puts (type->name (), stream);
485 gdb_puts (" = ", stream);
486 }
487 gdb_printf (stream, "case <?> of ");
488
489 struct_union:
490 stream->wrap_here (4);
491 if (show < 0)
492 {
493 /* If we just printed a tag name, no need to print anything else. */
494 if (type->name () == NULL)
495 gdb_printf (stream, "{...}");
496 }
497 else if (show > 0 || type->name () == NULL)
498 {
500
501 gdb_printf (stream, "\n");
502 if ((type->num_fields () == 0) && (TYPE_NFN_FIELDS (type) == 0))
503 {
504 if (type->is_stub ())
505 gdb_printf (stream, "%*s<incomplete type>\n",
506 level + 4, "");
507 else
508 gdb_printf (stream, "%*s<no data fields>\n",
509 level + 4, "");
510 }
511
512 /* Start off with no specific section type, so we can print
513 one for the first field we find, and use that section type
514 thereafter until we find another type. */
515
516 section_type = s_none;
517
518 /* If there is a base class for this type,
519 do not print the field that it occupies. */
520
521 len = type->num_fields ();
522 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
523 {
524 QUIT;
525 /* Don't print out virtual function table. */
526 if ((startswith (type->field (i).name (), "_vptr"))
527 && is_cplus_marker ((type->field (i).name ())[5]))
528 continue;
529
530 /* If this is a pascal object or class we can print the
531 various section labels. */
532
534 {
535 if (TYPE_FIELD_PROTECTED (type, i))
536 {
537 if (section_type != s_protected)
538 {
539 section_type = s_protected;
540 gdb_printf (stream, "%*sprotected\n",
541 level + 2, "");
542 }
543 }
544 else if (TYPE_FIELD_PRIVATE (type, i))
545 {
546 if (section_type != s_private)
547 {
548 section_type = s_private;
549 gdb_printf (stream, "%*sprivate\n",
550 level + 2, "");
551 }
552 }
553 else
554 {
555 if (section_type != s_public)
556 {
557 section_type = s_public;
558 gdb_printf (stream, "%*spublic\n",
559 level + 2, "");
560 }
561 }
562 }
563
564 print_spaces (level + 4, stream);
565 if (field_is_static (&type->field (i)))
566 gdb_printf (stream, "static ");
567 print_type (type->field (i).type (),
568 type->field (i).name (),
569 stream, show - 1, level + 4, flags);
570 if (!field_is_static (&type->field (i))
571 && TYPE_FIELD_PACKED (type, i))
572 {
573 /* It is a bitfield. This code does not attempt
574 to look at the bitpos and reconstruct filler,
575 unnamed fields. This would lead to misleading
576 results if the compiler does not put out fields
577 for such things (I don't know what it does). */
578 gdb_printf (stream, " : %d",
580 }
581 gdb_printf (stream, ";\n");
582 }
583
584 /* If there are both fields and methods, put a space between. */
585 len = TYPE_NFN_FIELDS (type);
586 if (len && section_type != s_none)
587 gdb_printf (stream, "\n");
588
589 /* Object pascal: print out the methods. */
590
591 for (i = 0; i < len; i++)
592 {
593 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
594 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
595 const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
596
597 /* this is GNU C++ specific
598 how can we know constructor/destructor?
599 It might work for GNU pascal. */
600 for (j = 0; j < len2; j++)
601 {
602 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
603
604 int is_constructor = (startswith (physname, "__ct__"));
605 int is_destructor = (startswith (physname, "__dt__"));
606
607 QUIT;
608 if (TYPE_FN_FIELD_PROTECTED (f, j))
609 {
610 if (section_type != s_protected)
611 {
612 section_type = s_protected;
613 gdb_printf (stream, "%*sprotected\n",
614 level + 2, "");
615 }
616 }
617 else if (TYPE_FN_FIELD_PRIVATE (f, j))
618 {
619 if (section_type != s_private)
620 {
621 section_type = s_private;
622 gdb_printf (stream, "%*sprivate\n",
623 level + 2, "");
624 }
625 }
626 else
627 {
628 if (section_type != s_public)
629 {
630 section_type = s_public;
631 gdb_printf (stream, "%*spublic\n",
632 level + 2, "");
633 }
634 }
635
636 print_spaces (level + 4, stream);
637 if (TYPE_FN_FIELD_STATIC_P (f, j))
638 gdb_printf (stream, "static ");
639 if (TYPE_FN_FIELD_TYPE (f, j)->target_type () == 0)
640 {
641 /* Keep GDB from crashing here. */
642 gdb_printf (stream, "<undefined type> %s;\n",
644 break;
645 }
646
647 if (is_constructor)
648 {
649 gdb_printf (stream, "constructor ");
650 }
651 else if (is_destructor)
652 {
653 gdb_printf (stream, "destructor ");
654 }
655 else if (TYPE_FN_FIELD_TYPE (f, j)->target_type () != 0
656 && (TYPE_FN_FIELD_TYPE(f, j)->target_type ()->code ()
657 != TYPE_CODE_VOID))
658 {
659 gdb_printf (stream, "function ");
660 }
661 else
662 {
663 gdb_printf (stream, "procedure ");
664 }
665 /* This does not work, no idea why !! */
666
667 type_print_method_args (physname, method_name, stream);
668
669 if (TYPE_FN_FIELD_TYPE (f, j)->target_type () != 0
670 && (TYPE_FN_FIELD_TYPE(f, j)->target_type ()->code ()
671 != TYPE_CODE_VOID))
672 {
673 gdb_puts (" : ", stream);
674 type_print (TYPE_FN_FIELD_TYPE (f, j)->target_type (),
675 "", stream, -1);
676 }
677 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
678 gdb_printf (stream, "; virtual");
679
680 gdb_printf (stream, ";\n");
681 }
682 }
683 gdb_printf (stream, "%*send", level, "");
684 }
685 break;
686
687 case TYPE_CODE_ENUM:
688 if (type->name () != NULL)
689 {
690 gdb_puts (type->name (), stream);
691 if (show > 0)
692 gdb_puts (" ", stream);
693 }
694 /* enum is just defined by
695 type enume_name = (enum_member1,enum_member2,...) */
696 gdb_printf (stream, " = ");
697 stream->wrap_here (4);
698 if (show < 0)
699 {
700 /* If we just printed a tag name, no need to print anything else. */
701 if (type->name () == NULL)
702 gdb_printf (stream, "(...)");
703 }
704 else if (show > 0 || type->name () == NULL)
705 {
706 gdb_printf (stream, "(");
707 len = type->num_fields ();
708 lastval = 0;
709 for (i = 0; i < len; i++)
710 {
711 QUIT;
712 if (i)
713 gdb_printf (stream, ", ");
714 stream->wrap_here (4);
715 gdb_puts (type->field (i).name (), stream);
716 if (lastval != type->field (i).loc_enumval ())
717 {
718 gdb_printf (stream,
719 " := %s",
720 plongest (type->field (i).loc_enumval ()));
721 lastval = type->field (i).loc_enumval ();
722 }
723 lastval++;
724 }
725 gdb_printf (stream, ")");
726 }
727 break;
728
729 case TYPE_CODE_VOID:
730 gdb_printf (stream, "void");
731 break;
732
733 case TYPE_CODE_UNDEF:
734 gdb_printf (stream, "record <unknown>");
735 break;
736
737 case TYPE_CODE_ERROR:
738 gdb_printf (stream, "%s", TYPE_ERROR_NAME (type));
739 break;
740
741 /* this probably does not work for enums. */
742 case TYPE_CODE_RANGE:
743 {
744 struct type *target = type->target_type ();
745
746 print_type_scalar (target, type->bounds ()->low.const_val (), stream);
747 gdb_puts ("..", stream);
748 print_type_scalar (target, type->bounds ()->high.const_val (), stream);
749 }
750 break;
751
752 case TYPE_CODE_SET:
753 gdb_puts ("set of ", stream);
754 print_type (type->index_type (), "", stream,
755 show - 1, level, flags);
756 break;
757
758 case TYPE_CODE_STRING:
759 gdb_puts ("String", stream);
760 break;
761
762 default:
763 /* Handle types not explicitly handled by the other cases,
764 such as fundamental types. For these, just print whatever
765 the type name is, as recorded in the type itself. If there
766 is no type name, then complain. */
767 if (type->name () != NULL)
768 {
769 gdb_puts (type->name (), stream);
770 }
771 else
772 {
773 /* At least for dump_symtab, it is important that this not be
774 an error (). */
776 "<invalid unnamed pascal type code %d>",
777 type->code ());
778 }
779 break;
780 }
781}
int code
Definition ada-lex.l:688
void f()
Definition 1.cc:36
@ s_none
Definition c-typeprint.c:40
@ s_private
Definition c-typeprint.c:42
@ s_protected
Definition c-typeprint.c:43
@ s_public
Definition c-typeprint.c:41
ui_file_style style() const
Definition cli-style.c:169
void type_print_method_args(const char *physname, const char *methodname, struct ui_file *stream) const
void print_type(struct type *type, const char *varstring, struct ui_file *stream, int show, int level, const struct type_print_options *flags) const override
Definition p-typeprint.c:40
void print_func_args(struct type *type, struct ui_file *stream, const struct type_print_options *flags) const
void print_typedef(struct type *type, struct symbol *new_symbol, struct ui_file *stream) const override
Definition p-typeprint.c:86
void type_print_varspec_prefix(struct type *type, struct ui_file *stream, int show, int passed_a_ptr, const struct type_print_options *flags) const
void type_print_derivation_info(struct ui_file *stream, struct type *type) const
Definition p-typeprint.c:99
void type_print_varspec_suffix(struct type *type, struct ui_file *stream, int show, int passed_a_ptr, int demangled_args, const struct type_print_options *flags) const
const char * name() const override
Definition p-lang.h:67
void type_print_base(struct type *type, struct ui_file *stream, int show, int level, const struct type_print_options *flags) const
void type_print_func_varspec_suffix(struct type *type, struct ui_file *stream, int show, int passed_a_ptr, int demangled_args, const struct type_print_options *flags) const
virtual void wrap_here(int indent)
Definition ui-file.h:117
cli_style_option metadata_style
#define QUIT
Definition defs.h:186
bool is_cplus_marker(int c)
int field_is_static(struct field *f)
Definition gdbtypes.c:5048
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:3010
#define TYPE_FN_FIELD_PHYSNAME(thisfn, n)
Definition gdbtypes.h:2169
#define TYPE_NFN_FIELDS(thistype)
Definition gdbtypes.h:2086
@ PROP_UNDEFINED
Definition gdbtypes.h:292
#define TYPE_FN_FIELDLIST1(thistype, n)
Definition gdbtypes.h:2157
#define TYPE_SELF_TYPE(thistype)
Definition gdbtypes.h:2074
#define TYPE_FN_FIELD_TYPE(thisfn, n)
Definition gdbtypes.h:2170
#define TYPE_BASECLASS(thistype, index)
Definition gdbtypes.h:2107
#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n)
Definition gdbtypes.h:2181
type_code
Definition gdbtypes.h:99
@ TYPE_CODE_UNDEF
Definition gdbtypes.h:100
#define TYPE_FN_FIELDLIST_LENGTH(thistype, n)
Definition gdbtypes.h:2159
#define TYPE_FN_FIELD_PROTECTED(thisfn, n)
Definition gdbtypes.h:2175
#define TYPE_FN_FIELD_PRIVATE(thisfn, n)
Definition gdbtypes.h:2174
#define HAVE_CPLUS_STRUCT(type)
Definition gdbtypes.h:1987
#define TYPE_FIELD_PROTECTED(thistype, n)
Definition gdbtypes.h:2145
#define TYPE_FN_FIELD_STATIC_P(thisfn, n)
Definition gdbtypes.h:2182
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition gdbtypes.h:2123
#define TYPE_ERROR_NAME(type)
Definition gdbtypes.h:2234
#define TYPE_FIELD_PACKED(thistype, n)
Definition gdbtypes.h:2124
#define BASETYPE_VIA_VIRTUAL(thistype, index)
Definition gdbtypes.h:2115
#define TYPE_FN_FIELDLIST_NAME(thistype, n)
Definition gdbtypes.h:2158
#define BASETYPE_VIA_PUBLIC(thistype, index)
Definition gdbtypes.h:2111
#define TYPE_FIELD_PRIVATE(thistype, n)
Definition gdbtypes.h:2142
#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
static struct symbol * new_symbol(struct die_info *, struct type *, struct dwarf2_cu *, struct symbol *=NULL)
Definition read.c:20766
LONGEST const_val() const
Definition gdbtypes.h:347
dynamic_prop_kind kind() const
Definition gdbtypes.h:337
LONGEST loc_enumval() const
Definition gdbtypes.h:598
const char * name() const
Definition gdbtypes.h:569
struct type * type() const
Definition gdbtypes.h:559
const char * print_name() const
Definition symtab.h:474
struct dynamic_prop high
Definition gdbtypes.h:696
struct dynamic_prop low
Definition gdbtypes.h:692
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
int num_fields() const
Definition gdbtypes.h:965
bool is_stub() const
Definition gdbtypes.h:1091
range_bounds * bounds() const
Definition gdbtypes.h:1028
const char * name() const
Definition gdbtypes.h:939
type * index_type() const
Definition gdbtypes.h:995
void print_type_scalar(struct type *type, LONGEST val, struct ui_file *stream)
Definition typeprint.c:613
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition typeprint.c:391
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 gdb_putc(int c)
Definition utils.c:1841
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 fputs_styled(const char *linebuffer, const ui_file_style &style, struct ui_file *stream)
Definition utils.c:1796
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1788