GDB (xrefs)
/tmp/gdb-7.10/gdb/c-typeprint.c
Go to the documentation of this file.
1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2  Copyright (C) 1986-2015 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 #include "defs.h"
20 #include "gdb_obstack.h"
21 #include "bfd.h" /* Binary File Description. */
22 #include "symtab.h"
23 #include "gdbtypes.h"
24 #include "expression.h"
25 #include "value.h"
26 #include "gdbcore.h"
27 #include "target.h"
28 #include "language.h"
29 #include "demangle.h"
30 #include "c-lang.h"
31 #include "typeprint.h"
32 #include "cp-abi.h"
33 #include "jv-lang.h"
34 #include "cp-support.h"
35 
36 static void c_type_print_varspec_prefix (struct type *,
37  struct ui_file *,
38  int, int, int,
39  const struct type_print_options *);
40 
41 /* Print "const", "volatile", or address space modifiers. */
42 static void c_type_print_modifier (struct type *,
43  struct ui_file *,
44  int, int);
45 
46 
47 /* A callback function for cp_canonicalize_string_full that uses
48  find_typedef_in_hash. */
49 
50 static const char *
51 find_typedef_for_canonicalize (struct type *t, void *data)
52 {
53  return find_typedef_in_hash (data, t);
54 }
55 
56 /* Print NAME on STREAM. If the 'raw' field of FLAGS is not set,
57  canonicalize NAME using the local typedefs first. */
58 
59 static void
61  const struct type_print_options *flags,
62  struct ui_file *stream)
63 {
64  char *s = NULL;
65 
66  if (!flags->raw)
69  (void *) flags);
70 
71  fputs_filtered (s ? s : name, stream);
72  xfree (s);
73 }
74 
75 
76 
77 /* LEVEL is the depth to indent lines by. */
78 
79 void
81  const char *varstring,
82  struct ui_file *stream,
83  int show, int level,
84  const struct type_print_options *flags)
85 {
86  enum type_code code;
87  int demangled_args;
88  int need_post_space;
89  const char *local_name;
90 
91  if (show > 0)
92  CHECK_TYPEDEF (type);
93 
94  local_name = find_typedef_in_hash (flags, type);
95  if (local_name != NULL)
96  {
97  fputs_filtered (local_name, stream);
98  if (varstring != NULL && *varstring != '\0')
99  fputs_filtered (" ", stream);
100  }
101  else
102  {
103  c_type_print_base (type, stream, show, level, flags);
104  code = TYPE_CODE (type);
105  if ((varstring != NULL && *varstring != '\0')
106  /* Need a space if going to print stars or brackets;
107  but not if we will print just a type name. */
108  || ((show > 0 || TYPE_NAME (type) == 0)
109  && (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
110  || code == TYPE_CODE_METHOD
111  || (code == TYPE_CODE_ARRAY
112  && !TYPE_VECTOR (type))
113  || code == TYPE_CODE_MEMBERPTR
114  || code == TYPE_CODE_METHODPTR
115  || code == TYPE_CODE_REF)))
116  fputs_filtered (" ", stream);
117  need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
118  c_type_print_varspec_prefix (type, stream, show, 0, need_post_space,
119  flags);
120  }
121 
122  if (varstring != NULL)
123  {
124  fputs_filtered (varstring, stream);
125 
126  /* For demangled function names, we have the arglist as part of
127  the name, so don't print an additional pair of ()'s. */
128  if (local_name == NULL)
129  {
130  demangled_args = strchr (varstring, '(') != NULL;
131  c_type_print_varspec_suffix (type, stream, show,
132  0, demangled_args,
133  flags);
134  }
135  }
136 }
137 
138 /* Print a typedef using C syntax. TYPE is the underlying type.
139  NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
140  which to print. */
141 
142 void
144  struct symbol *new_symbol,
145  struct ui_file *stream)
146 {
147  CHECK_TYPEDEF (type);
148  fprintf_filtered (stream, "typedef ");
149  type_print (type, "", stream, 0);
150  if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0
151  || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
152  SYMBOL_LINKAGE_NAME (new_symbol)) != 0
153  || TYPE_CODE (SYMBOL_TYPE (new_symbol)) == TYPE_CODE_TYPEDEF)
154  fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));
155  fprintf_filtered (stream, ";\n");
156 }
157 
158 /* If TYPE is a derived type, then print out derivation information.
159  Print only the actual base classes of this type, not the base
160  classes of the base classes. I.e. for the derivation hierarchy:
161 
162  class A { int a; };
163  class B : public A {int b; };
164  class C : public B {int c; };
165 
166  Print the type of class C as:
167 
168  class C : public B {
169  int c;
170  }
171 
172  Not as the following (like gdb used to), which is not legal C++
173  syntax for derived types and may be confused with the multiple
174  inheritance form:
175 
176  class C : public B : public A {
177  int c;
178  }
179 
180  In general, gdb should try to print the types as closely as
181  possible to the form that they appear in the source code. */
182 
183 static void
185  struct type *type,
186  const struct type_print_options *flags)
187 {
188  const char *name;
189  int i;
190 
191  for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
192  {
193  wrap_here (" ");
194  fputs_filtered (i == 0 ? ": " : ", ", stream);
195  fprintf_filtered (stream, "%s%s ",
196  BASETYPE_VIA_PUBLIC (type, i)
197  ? "public" : (TYPE_FIELD_PROTECTED (type, i)
198  ? "protected" : "private"),
199  BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
200  name = type_name_no_tag (TYPE_BASECLASS (type, i));
201  if (name)
202  print_name_maybe_canonical (name, flags, stream);
203  else
204  fprintf_filtered (stream, "(null)");
205  }
206  if (i > 0)
207  {
208  fputs_filtered (" ", stream);
209  }
210 }
211 
212 /* Print the C++ method arguments ARGS to the file STREAM. */
213 
214 static void
215 cp_type_print_method_args (struct type *mtype, const char *prefix,
216  const char *varstring, int staticp,
217  struct ui_file *stream,
218  const struct type_print_options *flags)
219 {
220  struct field *args = TYPE_FIELDS (mtype);
221  int nargs = TYPE_NFIELDS (mtype);
222  int varargs = TYPE_VARARGS (mtype);
223  int i;
224 
225  fprintf_symbol_filtered (stream, prefix,
226  language_cplus, DMGL_ANSI);
227  fprintf_symbol_filtered (stream, varstring,
228  language_cplus, DMGL_ANSI);
229  fputs_filtered ("(", stream);
230 
231  /* Skip the class variable. */
232  i = staticp ? 0 : 1;
233  if (nargs > i)
234  {
235  while (i < nargs)
236  {
237  c_print_type (args[i++].type, "", stream, 0, 0, flags);
238 
239  if (i == nargs && varargs)
240  fprintf_filtered (stream, ", ...");
241  else if (i < nargs)
242  {
243  fprintf_filtered (stream, ", ");
244  wrap_here (" ");
245  }
246  }
247  }
248  else if (varargs)
249  fprintf_filtered (stream, "...");
251  fprintf_filtered (stream, "void");
252 
253  fprintf_filtered (stream, ")");
254 
255  /* For non-static methods, read qualifiers from the type of
256  THIS. */
257  if (!staticp)
258  {
259  struct type *domain;
260 
261  gdb_assert (nargs > 0);
262  gdb_assert (TYPE_CODE (args[0].type) == TYPE_CODE_PTR);
263  domain = TYPE_TARGET_TYPE (args[0].type);
264 
265  if (TYPE_CONST (domain))
266  fprintf_filtered (stream, " const");
267 
268  if (TYPE_VOLATILE (domain))
269  fprintf_filtered (stream, " volatile");
270 
271  if (TYPE_RESTRICT (domain))
272  fprintf_filtered (stream, " restrict");
273 
274  if (TYPE_ATOMIC (domain))
275  fprintf_filtered (stream, " _Atomic");
276  }
277 }
278 
279 
280 /* Print any asterisks or open-parentheses needed before the
281  variable name (to describe its type).
282 
283  On outermost call, pass 0 for PASSED_A_PTR.
284  On outermost call, SHOW > 0 means should ignore
285  any typename for TYPE and show its details.
286  SHOW is always zero on recursive calls.
287 
288  NEED_POST_SPACE is non-zero when a space will be be needed
289  between a trailing qualifier and a field, variable, or function
290  name. */
291 
292 static void
294  struct ui_file *stream,
295  int show, int passed_a_ptr,
296  int need_post_space,
297  const struct type_print_options *flags)
298 {
299  const char *name;
300 
301  if (type == 0)
302  return;
303 
304  if (TYPE_NAME (type) && show <= 0)
305  return;
306 
307  QUIT;
308 
309  switch (TYPE_CODE (type))
310  {
311  case TYPE_CODE_PTR:
313  stream, show, 1, 1, flags);
314  fprintf_filtered (stream, "*");
315  c_type_print_modifier (type, stream, 1, need_post_space);
316  break;
317 
318  case TYPE_CODE_MEMBERPTR:
320  stream, show, 0, 0, flags);
321  name = type_name_no_tag (TYPE_SELF_TYPE (type));
322  if (name)
323  print_name_maybe_canonical (name, flags, stream);
324  else
326  stream, -1, passed_a_ptr, flags);
327  fprintf_filtered (stream, "::*");
328  break;
329 
330  case TYPE_CODE_METHODPTR:
332  stream, show, 0, 0, flags);
333  fprintf_filtered (stream, "(");
334  name = type_name_no_tag (TYPE_SELF_TYPE (type));
335  if (name)
336  print_name_maybe_canonical (name, flags, stream);
337  else
339  stream, -1, passed_a_ptr, flags);
340  fprintf_filtered (stream, "::*");
341  break;
342 
343  case TYPE_CODE_REF:
345  stream, show, 1, 0, flags);
346  fprintf_filtered (stream, "&");
347  c_type_print_modifier (type, stream, 1, need_post_space);
348  break;
349 
350  case TYPE_CODE_METHOD:
351  case TYPE_CODE_FUNC:
353  stream, show, 0, 0, flags);
354  if (passed_a_ptr)
355  fprintf_filtered (stream, "(");
356  break;
357 
358  case TYPE_CODE_ARRAY:
360  stream, show, 0, 0, flags);
361  if (passed_a_ptr)
362  fprintf_filtered (stream, "(");
363  break;
364 
365  case TYPE_CODE_TYPEDEF:
367  stream, show, passed_a_ptr, 0, flags);
368  break;
369 
370  case TYPE_CODE_UNDEF:
371  case TYPE_CODE_STRUCT:
372  case TYPE_CODE_UNION:
373  case TYPE_CODE_ENUM:
374  case TYPE_CODE_INT:
375  case TYPE_CODE_FLT:
376  case TYPE_CODE_VOID:
377  case TYPE_CODE_ERROR:
378  case TYPE_CODE_CHAR:
379  case TYPE_CODE_BOOL:
380  case TYPE_CODE_SET:
381  case TYPE_CODE_RANGE:
382  case TYPE_CODE_STRING:
383  case TYPE_CODE_COMPLEX:
384  case TYPE_CODE_NAMESPACE:
385  case TYPE_CODE_DECFLOAT:
386  /* These types need no prefix. They are listed here so that
387  gcc -Wall will reveal any types that haven't been handled. */
388  break;
389  default:
390  error (_("type not handled in c_type_print_varspec_prefix()"));
391  break;
392  }
393 }
394 
395 /* Print out "const" and "volatile" attributes,
396  and address space id if present.
397  TYPE is a pointer to the type being printed out.
398  STREAM is the output destination.
399  NEED_PRE_SPACE = 1 indicates an initial white space is needed.
400  NEED_POST_SPACE = 1 indicates a final white space is needed. */
401 
402 static void
403 c_type_print_modifier (struct type *type, struct ui_file *stream,
404  int need_pre_space, int need_post_space)
405 {
406  int did_print_modifier = 0;
407  const char *address_space_id;
408 
409  /* We don't print `const' qualifiers for references --- since all
410  operators affect the thing referenced, not the reference itself,
411  every reference is `const'. */
412  if (TYPE_CONST (type)
413  && TYPE_CODE (type) != TYPE_CODE_REF)
414  {
415  if (need_pre_space)
416  fprintf_filtered (stream, " ");
417  fprintf_filtered (stream, "const");
418  did_print_modifier = 1;
419  }
420 
421  if (TYPE_VOLATILE (type))
422  {
423  if (did_print_modifier || need_pre_space)
424  fprintf_filtered (stream, " ");
425  fprintf_filtered (stream, "volatile");
426  did_print_modifier = 1;
427  }
428 
429  if (TYPE_RESTRICT (type))
430  {
431  if (did_print_modifier || need_pre_space)
432  fprintf_filtered (stream, " ");
433  fprintf_filtered (stream, "restrict");
434  did_print_modifier = 1;
435  }
436 
437  if (TYPE_ATOMIC (type))
438  {
439  if (did_print_modifier || need_pre_space)
440  fprintf_filtered (stream, " ");
441  fprintf_filtered (stream, "_Atomic");
442  did_print_modifier = 1;
443  }
444 
445  address_space_id = address_space_int_to_name (get_type_arch (type),
446  TYPE_INSTANCE_FLAGS (type));
447  if (address_space_id)
448  {
449  if (did_print_modifier || need_pre_space)
450  fprintf_filtered (stream, " ");
451  fprintf_filtered (stream, "@%s", address_space_id);
452  did_print_modifier = 1;
453  }
454 
455  if (did_print_modifier && need_post_space)
456  fprintf_filtered (stream, " ");
457 }
458 
459 
460 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
461  or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
462  in non-static methods, are displayed if LINKAGE_NAME is zero. If
463  LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
464  parameter types get removed their possible const and volatile qualifiers to
465  match demangled linkage name parameters part of such function type.
466  LANGUAGE is the language in which TYPE was defined. This is a necessary
467  evil since this code is used by the C, C++, and Java backends. */
468 
469 void
470 c_type_print_args (struct type *type, struct ui_file *stream,
471  int linkage_name, enum language language,
472  const struct type_print_options *flags)
473 {
474  int i;
475  int printed_any = 0;
476 
477  fprintf_filtered (stream, "(");
478 
479  for (i = 0; i < TYPE_NFIELDS (type); i++)
480  {
481  struct type *param_type;
482 
483  if (TYPE_FIELD_ARTIFICIAL (type, i) && linkage_name)
484  continue;
485 
486  if (printed_any)
487  {
488  fprintf_filtered (stream, ", ");
489  wrap_here (" ");
490  }
491 
492  param_type = TYPE_FIELD_TYPE (type, i);
493 
494  if (language == language_cplus && linkage_name)
495  {
496  /* C++ standard, 13.1 Overloadable declarations, point 3, item:
497  - Parameter declarations that differ only in the presence or
498  absence of const and/or volatile are equivalent.
499 
500  And the const/volatile qualifiers are not present in the mangled
501  names as produced by GCC. */
502 
503  param_type = make_cv_type (0, 0, param_type, NULL);
504  }
505 
506  if (language == language_java)
507  java_print_type (param_type, "", stream, -1, 0, flags);
508  else
509  c_print_type (param_type, "", stream, -1, 0, flags);
510  printed_any = 1;
511  }
512 
513  if (printed_any && TYPE_VARARGS (type))
514  {
515  /* Print out a trailing ellipsis for varargs functions. Ignore
516  TYPE_VARARGS if the function has no named arguments; that
517  represents unprototyped (K&R style) C functions. */
518  if (printed_any && TYPE_VARARGS (type))
519  {
520  fprintf_filtered (stream, ", ");
521  wrap_here (" ");
522  fprintf_filtered (stream, "...");
523  }
524  }
525  else if (!printed_any
526  && ((TYPE_PROTOTYPED (type) && language != language_java)
527  || language == language_cplus))
528  fprintf_filtered (stream, "void");
529 
530  fprintf_filtered (stream, ")");
531 }
532 
533 /* Return true iff the j'th overloading of the i'th method of TYPE
534  is a type conversion operator, like `operator int () { ... }'.
535  When listing a class's methods, we don't print the return type of
536  such operators. */
537 
538 static int
539 is_type_conversion_operator (struct type *type, int i, int j)
540 {
541  /* I think the whole idea of recognizing type conversion operators
542  by their name is pretty terrible. But I don't think our present
543  data structure gives us any other way to tell. If you know of
544  some other way, feel free to rewrite this function. */
545  const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
546 
547  if (!startswith (name, "operator"))
548  return 0;
549 
550  name += 8;
551  if (! strchr (" \t\f\n\r", *name))
552  return 0;
553 
554  while (strchr (" \t\f\n\r", *name))
555  name++;
556 
557  if (!('a' <= *name && *name <= 'z')
558  && !('A' <= *name && *name <= 'Z')
559  && *name != '_')
560  /* If this doesn't look like the start of an identifier, then it
561  isn't a type conversion operator. */
562  return 0;
563  else if (startswith (name, "new"))
564  name += 3;
565  else if (startswith (name, "delete"))
566  name += 6;
567  else
568  /* If it doesn't look like new or delete, it's a type conversion
569  operator. */
570  return 1;
571 
572  /* Is that really the end of the name? */
573  if (('a' <= *name && *name <= 'z')
574  || ('A' <= *name && *name <= 'Z')
575  || ('0' <= *name && *name <= '9')
576  || *name == '_')
577  /* No, so the identifier following "operator" must be a type name,
578  and this is a type conversion operator. */
579  return 1;
580 
581  /* That was indeed the end of the name, so it was `operator new' or
582  `operator delete', neither of which are type conversion
583  operators. */
584  return 0;
585 }
586 
587 /* Given a C++ qualified identifier QID, strip off the qualifiers,
588  yielding the unqualified name. The return value is a pointer into
589  the original string.
590 
591  It's a pity we don't have this information in some more structured
592  form. Even the author of this function feels that writing little
593  parsers like this everywhere is stupid. */
594 
595 static char *
596 remove_qualifiers (char *qid)
597 {
598  int quoted = 0; /* Zero if we're not in quotes;
599  '"' if we're in a double-quoted string;
600  '\'' if we're in a single-quoted string. */
601  int depth = 0; /* Number of unclosed parens we've seen. */
602  char *parenstack = (char *) alloca (strlen (qid));
603  char *scan;
604  char *last = 0; /* The character after the rightmost
605  `::' token we've seen so far. */
606 
607  for (scan = qid; *scan; scan++)
608  {
609  if (quoted)
610  {
611  if (*scan == quoted)
612  quoted = 0;
613  else if (*scan == '\\' && *(scan + 1))
614  scan++;
615  }
616  else if (scan[0] == ':' && scan[1] == ':')
617  {
618  /* If we're inside parenthesis (i.e., an argument list) or
619  angle brackets (i.e., a list of template arguments), then
620  we don't record the position of this :: token, since it's
621  not relevant to the top-level structure we're trying to
622  operate on. */
623  if (depth == 0)
624  {
625  last = scan + 2;
626  scan++;
627  }
628  }
629  else if (*scan == '"' || *scan == '\'')
630  quoted = *scan;
631  else if (*scan == '(')
632  parenstack[depth++] = ')';
633  else if (*scan == '[')
634  parenstack[depth++] = ']';
635  /* We're going to treat <> as a pair of matching characters,
636  since we're more likely to see those in template id's than
637  real less-than characters. What a crock. */
638  else if (*scan == '<')
639  parenstack[depth++] = '>';
640  else if (*scan == ')' || *scan == ']' || *scan == '>')
641  {
642  if (depth > 0 && parenstack[depth - 1] == *scan)
643  depth--;
644  else
645  {
646  /* We're going to do a little error recovery here. If
647  we don't find a match for *scan on the paren stack,
648  but there is something lower on the stack that does
649  match, we pop the stack to that point. */
650  int i;
651 
652  for (i = depth - 1; i >= 0; i--)
653  if (parenstack[i] == *scan)
654  {
655  depth = i;
656  break;
657  }
658  }
659  }
660  }
661 
662  if (last)
663  return last;
664  else
665  /* We didn't find any :: tokens at the top level, so declare the
666  whole thing an unqualified identifier. */
667  return qid;
668 }
669 
670 /* Print any array sizes, function arguments or close parentheses
671  needed after the variable name (to describe its type).
672  Args work like c_type_print_varspec_prefix. */
673 
674 void
676  struct ui_file *stream,
677  int show, int passed_a_ptr,
678  int demangled_args,
679  const struct type_print_options *flags)
680 {
681  if (type == 0)
682  return;
683 
684  if (TYPE_NAME (type) && show <= 0)
685  return;
686 
687  QUIT;
688 
689  switch (TYPE_CODE (type))
690  {
691  case TYPE_CODE_ARRAY:
692  {
693  LONGEST low_bound, high_bound;
694  int is_vector = TYPE_VECTOR (type);
695 
696  if (passed_a_ptr)
697  fprintf_filtered (stream, ")");
698 
699  fprintf_filtered (stream, (is_vector ?
700  " __attribute__ ((vector_size(" : "["));
701  /* Bounds are not yet resolved, print a bounds placeholder instead. */
704  fprintf_filtered (stream, "variable length");
705  else if (get_array_bounds (type, &low_bound, &high_bound))
706  fprintf_filtered (stream, "%s",
707  plongest (high_bound - low_bound + 1));
708  fprintf_filtered (stream, (is_vector ? ")))" : "]"));
709 
711  show, 0, 0, flags);
712  }
713  break;
714 
715  case TYPE_CODE_MEMBERPTR:
717  show, 0, 0, flags);
718  break;
719 
720  case TYPE_CODE_METHODPTR:
721  fprintf_filtered (stream, ")");
723  show, 0, 0, flags);
724  break;
725 
726  case TYPE_CODE_PTR:
727  case TYPE_CODE_REF:
729  show, 1, 0, flags);
730  break;
731 
732  case TYPE_CODE_METHOD:
733  case TYPE_CODE_FUNC:
734  if (passed_a_ptr)
735  fprintf_filtered (stream, ")");
736  if (!demangled_args)
738  flags);
740  show, passed_a_ptr, 0, flags);
741  break;
742 
743  case TYPE_CODE_TYPEDEF:
745  show, passed_a_ptr, 0, flags);
746  break;
747 
748  case TYPE_CODE_UNDEF:
749  case TYPE_CODE_STRUCT:
750  case TYPE_CODE_UNION:
751  case TYPE_CODE_ENUM:
752  case TYPE_CODE_INT:
753  case TYPE_CODE_FLT:
754  case TYPE_CODE_VOID:
755  case TYPE_CODE_ERROR:
756  case TYPE_CODE_CHAR:
757  case TYPE_CODE_BOOL:
758  case TYPE_CODE_SET:
759  case TYPE_CODE_RANGE:
760  case TYPE_CODE_STRING:
761  case TYPE_CODE_COMPLEX:
762  case TYPE_CODE_NAMESPACE:
763  case TYPE_CODE_DECFLOAT:
764  /* These types do not need a suffix. They are listed so that
765  gcc -Wall will report types that may not have been
766  considered. */
767  break;
768  default:
769  error (_("type not handled in c_type_print_varspec_suffix()"));
770  break;
771  }
772 }
773 
774 /* A helper for c_type_print_base that displays template
775  parameters and their bindings, if needed.
776 
777  TABLE is the local bindings table to use. If NULL, no printing is
778  done. Note that, at this point, TABLE won't have any useful
779  information in it -- but it is also used as a flag to
780  print_name_maybe_canonical to activate searching the global typedef
781  table.
782 
783  TYPE is the type whose template arguments are being displayed.
784 
785  STREAM is the stream on which to print. */
786 
787 static void
789  struct type *type, struct ui_file *stream)
790 {
791  int first = 1, i;
792 
793  if (flags->raw)
794  return;
795 
796  for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
797  {
798  struct symbol *sym = TYPE_TEMPLATE_ARGUMENT (type, i);
799 
800  if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
801  continue;
802 
803  if (first)
804  {
805  wrap_here (" ");
806  fprintf_filtered (stream, _("[with %s = "),
807  SYMBOL_LINKAGE_NAME (sym));
808  first = 0;
809  }
810  else
811  {
812  fputs_filtered (", ", stream);
813  wrap_here (" ");
814  fprintf_filtered (stream, "%s = ", SYMBOL_LINKAGE_NAME (sym));
815  }
816 
817  c_print_type (SYMBOL_TYPE (sym), "", stream, -1, 0, flags);
818  }
819 
820  if (!first)
821  fputs_filtered (_("] "), stream);
822 }
823 
824 /* Print the name of the type (or the ultimate pointer target,
825  function value or array element), or the description of a structure
826  or union.
827 
828  SHOW positive means print details about the type (e.g. enum
829  values), and print structure elements passing SHOW - 1 for show.
830 
831  SHOW negative means just print the type name or struct tag if there
832  is one. If there is no name, print something sensible but concise
833  like "struct {...}".
834 
835  SHOW zero means just print the type name or struct tag if there is
836  one. If there is no name, print something sensible but not as
837  concise like "struct {int x; int y;}".
838 
839  LEVEL is the number of spaces to indent by.
840  We increase it for some recursive calls. */
841 
842 void
843 c_type_print_base (struct type *type, struct ui_file *stream,
844  int show, int level, const struct type_print_options *flags)
845 {
846  int i;
847  int len, real_len;
848  enum
849  {
850  s_none, s_public, s_private, s_protected
851  }
852  section_type;
853  int need_access_label = 0;
854  int j, len2;
855 
856  QUIT;
857 
858  if (type == NULL)
859  {
860  fputs_filtered (_("<type unknown>"), stream);
861  return;
862  }
863 
864  /* When SHOW is zero or less, and there is a valid type name, then
865  always just print the type name directly from the type. */
866  /* If we have "typedef struct foo {. . .} bar;" do we want to print
867  it as "struct foo" or as "bar"? Pick the latter, because C++
868  folk tend to expect things like "class5 *foo" rather than "struct
869  class5 *foo". */
870 
871  if (show <= 0
872  && TYPE_NAME (type) != NULL)
873  {
874  c_type_print_modifier (type, stream, 0, 1);
875  print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
876  return;
877  }
878 
879  CHECK_TYPEDEF (type);
880 
881  switch (TYPE_CODE (type))
882  {
883  case TYPE_CODE_TYPEDEF:
884  /* If we get here, the typedef doesn't have a name, and we
885  couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
886  gdb_assert (TYPE_NAME (type) == NULL);
887  gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
888  fprintf_filtered (stream, _("<unnamed typedef>"));
889  break;
890 
891  case TYPE_CODE_ARRAY:
892  case TYPE_CODE_PTR:
893  case TYPE_CODE_MEMBERPTR:
894  case TYPE_CODE_REF:
895  case TYPE_CODE_FUNC:
896  case TYPE_CODE_METHOD:
897  case TYPE_CODE_METHODPTR:
899  stream, show, level, flags);
900  break;
901 
902  case TYPE_CODE_STRUCT:
903  case TYPE_CODE_UNION:
904  {
905  struct type_print_options local_flags = *flags;
906  struct type_print_options semi_local_flags = *flags;
907  struct cleanup *local_cleanups = make_cleanup (null_cleanup, NULL);
908 
909  local_flags.local_typedefs = NULL;
910  semi_local_flags.local_typedefs = NULL;
911 
912  if (!flags->raw)
913  {
914  if (flags->local_typedefs)
915  local_flags.local_typedefs
917  else
918  local_flags.local_typedefs = create_typedef_hash ();
919 
921  }
922 
923  c_type_print_modifier (type, stream, 0, 1);
924  if (TYPE_CODE (type) == TYPE_CODE_UNION)
925  fprintf_filtered (stream, "union ");
926  else if (TYPE_DECLARED_CLASS (type))
927  fprintf_filtered (stream, "class ");
928  else
929  fprintf_filtered (stream, "struct ");
930 
931  /* Print the tag if it exists. The HP aCC compiler emits a
932  spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
933  enum}" tag for unnamed struct/union/enum's, which we don't
934  want to print. */
935  if (TYPE_TAG_NAME (type) != NULL
936  && !startswith (TYPE_TAG_NAME (type), "{unnamed"))
937  {
938  /* When printing the tag name, we are still effectively
939  printing in the outer context, hence the use of FLAGS
940  here. */
941  print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
942  if (show > 0)
943  fputs_filtered (" ", stream);
944  }
945 
946  if (show < 0)
947  {
948  /* If we just printed a tag name, no need to print anything
949  else. */
950  if (TYPE_TAG_NAME (type) == NULL)
951  fprintf_filtered (stream, "{...}");
952  }
953  else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
954  {
955  struct type *basetype;
956  int vptr_fieldno;
957 
958  c_type_print_template_args (&local_flags, type, stream);
959 
960  /* Add in template parameters when printing derivation info. */
961  add_template_parameters (local_flags.local_typedefs, type);
962  cp_type_print_derivation_info (stream, type, &local_flags);
963 
964  /* This holds just the global typedefs and the template
965  parameters. */
966  semi_local_flags.local_typedefs
967  = copy_typedef_hash (local_flags.local_typedefs);
968  if (semi_local_flags.local_typedefs)
970 
971  /* Now add in the local typedefs. */
973 
974  fprintf_filtered (stream, "{\n");
975  if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
976  && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
977  {
978  if (TYPE_STUB (type))
979  fprintfi_filtered (level + 4, stream,
980  _("<incomplete type>\n"));
981  else
982  fprintfi_filtered (level + 4, stream,
983  _("<no data fields>\n"));
984  }
985 
986  /* Start off with no specific section type, so we can print
987  one for the first field we find, and use that section type
988  thereafter until we find another type. */
989 
990  section_type = s_none;
991 
992  /* For a class, if all members are private, there's no need
993  for a "private:" label; similarly, for a struct or union
994  masquerading as a class, if all members are public, there's
995  no need for a "public:" label. */
996 
997  if (TYPE_DECLARED_CLASS (type))
998  {
999  QUIT;
1000  len = TYPE_NFIELDS (type);
1001  for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1002  if (!TYPE_FIELD_PRIVATE (type, i))
1003  {
1004  need_access_label = 1;
1005  break;
1006  }
1007  QUIT;
1008  if (!need_access_label)
1009  {
1010  len2 = TYPE_NFN_FIELDS (type);
1011  for (j = 0; j < len2; j++)
1012  {
1013  len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1014  for (i = 0; i < len; i++)
1016  j), i))
1017  {
1018  need_access_label = 1;
1019  break;
1020  }
1021  if (need_access_label)
1022  break;
1023  }
1024  }
1025  }
1026  else
1027  {
1028  QUIT;
1029  len = TYPE_NFIELDS (type);
1030  for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1031  if (TYPE_FIELD_PRIVATE (type, i)
1032  || TYPE_FIELD_PROTECTED (type, i))
1033  {
1034  need_access_label = 1;
1035  break;
1036  }
1037  QUIT;
1038  if (!need_access_label)
1039  {
1040  len2 = TYPE_NFN_FIELDS (type);
1041  for (j = 0; j < len2; j++)
1042  {
1043  QUIT;
1044  len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1045  for (i = 0; i < len; i++)
1047  j), i)
1049  j),
1050  i))
1051  {
1052  need_access_label = 1;
1053  break;
1054  }
1055  if (need_access_label)
1056  break;
1057  }
1058  }
1059  }
1060 
1061  /* If there is a base class for this type,
1062  do not print the field that it occupies. */
1063 
1064  len = TYPE_NFIELDS (type);
1065  vptr_fieldno = get_vptr_fieldno (type, &basetype);
1066  for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1067  {
1068  QUIT;
1069 
1070  /* If we have a virtual table pointer, omit it. Even if
1071  virtual table pointers are not specifically marked in
1072  the debug info, they should be artificial. */
1073  if ((i == vptr_fieldno && type == basetype)
1074  || TYPE_FIELD_ARTIFICIAL (type, i))
1075  continue;
1076 
1077  if (need_access_label)
1078  {
1079  if (TYPE_FIELD_PROTECTED (type, i))
1080  {
1081  if (section_type != s_protected)
1082  {
1083  section_type = s_protected;
1084  fprintfi_filtered (level + 2, stream,
1085  "protected:\n");
1086  }
1087  }
1088  else if (TYPE_FIELD_PRIVATE (type, i))
1089  {
1090  if (section_type != s_private)
1091  {
1092  section_type = s_private;
1093  fprintfi_filtered (level + 2, stream,
1094  "private:\n");
1095  }
1096  }
1097  else
1098  {
1099  if (section_type != s_public)
1100  {
1101  section_type = s_public;
1102  fprintfi_filtered (level + 2, stream,
1103  "public:\n");
1104  }
1105  }
1106  }
1107 
1108  print_spaces_filtered (level + 4, stream);
1109  if (field_is_static (&TYPE_FIELD (type, i)))
1110  fprintf_filtered (stream, "static ");
1111  c_print_type (TYPE_FIELD_TYPE (type, i),
1112  TYPE_FIELD_NAME (type, i),
1113  stream, show - 1, level + 4,
1114  &local_flags);
1115  if (!field_is_static (&TYPE_FIELD (type, i))
1116  && TYPE_FIELD_PACKED (type, i))
1117  {
1118  /* It is a bitfield. This code does not attempt
1119  to look at the bitpos and reconstruct filler,
1120  unnamed fields. This would lead to misleading
1121  results if the compiler does not put out fields
1122  for such things (I don't know what it does). */
1123  fprintf_filtered (stream, " : %d",
1124  TYPE_FIELD_BITSIZE (type, i));
1125  }
1126  fprintf_filtered (stream, ";\n");
1127  }
1128 
1129  /* If there are both fields and methods, put a blank line
1130  between them. Make sure to count only method that we
1131  will display; artificial methods will be hidden. */
1132  len = TYPE_NFN_FIELDS (type);
1133  if (!flags->print_methods)
1134  len = 0;
1135  real_len = 0;
1136  for (i = 0; i < len; i++)
1137  {
1138  struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1139  int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1140  int j;
1141 
1142  for (j = 0; j < len2; j++)
1143  if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
1144  real_len++;
1145  }
1146  if (real_len > 0 && section_type != s_none)
1147  fprintf_filtered (stream, "\n");
1148 
1149  /* C++: print out the methods. */
1150  for (i = 0; i < len; i++)
1151  {
1152  struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1153  int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1154  const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
1155  const char *name = type_name_no_tag (type);
1156  int is_constructor = name && strcmp (method_name,
1157  name) == 0;
1158 
1159  for (j = 0; j < len2; j++)
1160  {
1161  const char *mangled_name;
1162  char *demangled_name;
1163  struct cleanup *inner_cleanup;
1164  const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1165  int is_full_physname_constructor =
1167  || is_constructor_name (physname)
1168  || is_destructor_name (physname)
1169  || method_name[0] == '~';
1170 
1171  /* Do not print out artificial methods. */
1172  if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
1173  continue;
1174 
1175  inner_cleanup = make_cleanup (null_cleanup, NULL);
1176 
1177  QUIT;
1178  if (TYPE_FN_FIELD_PROTECTED (f, j))
1179  {
1180  if (section_type != s_protected)
1181  {
1182  section_type = s_protected;
1183  fprintfi_filtered (level + 2, stream,
1184  "protected:\n");
1185  }
1186  }
1187  else if (TYPE_FN_FIELD_PRIVATE (f, j))
1188  {
1189  if (section_type != s_private)
1190  {
1191  section_type = s_private;
1192  fprintfi_filtered (level + 2, stream,
1193  "private:\n");
1194  }
1195  }
1196  else
1197  {
1198  if (section_type != s_public)
1199  {
1200  section_type = s_public;
1201  fprintfi_filtered (level + 2, stream,
1202  "public:\n");
1203  }
1204  }
1205 
1206  print_spaces_filtered (level + 4, stream);
1207  if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1208  fprintf_filtered (stream, "virtual ");
1209  else if (TYPE_FN_FIELD_STATIC_P (f, j))
1210  fprintf_filtered (stream, "static ");
1211  if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1212  {
1213  /* Keep GDB from crashing here. */
1214  fprintf_filtered (stream,
1215  _("<undefined type> %s;\n"),
1216  TYPE_FN_FIELD_PHYSNAME (f, j));
1217  break;
1218  }
1219  else if (!is_constructor /* Constructors don't
1220  have declared
1221  types. */
1222  && !is_full_physname_constructor /* " " */
1223  && !is_type_conversion_operator (type, i, j))
1224  {
1226  "", stream, -1, 0,
1227  &local_flags);
1228  fputs_filtered (" ", stream);
1229  }
1230  if (TYPE_FN_FIELD_STUB (f, j))
1231  {
1232  char *tem;
1233 
1234  /* Build something we can demangle. */
1235  tem = gdb_mangle_name (type, i, j);
1236  make_cleanup (xfree, tem);
1237  mangled_name = tem;
1238  }
1239  else
1240  mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1241 
1242  demangled_name =
1243  gdb_demangle (mangled_name,
1244  DMGL_ANSI | DMGL_PARAMS);
1245  if (demangled_name == NULL)
1246  {
1247  /* In some cases (for instance with the HP
1248  demangling), if a function has more than 10
1249  arguments, the demangling will fail.
1250  Let's try to reconstruct the function
1251  signature from the symbol information. */
1252  if (!TYPE_FN_FIELD_STUB (f, j))
1253  {
1254  int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1255  struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1256 
1258  "",
1259  method_name,
1260  staticp,
1261  stream, &local_flags);
1262  }
1263  else
1264  fprintf_filtered (stream,
1265  _("<badly mangled name '%s'>"),
1266  mangled_name);
1267  }
1268  else
1269  {
1270  char *p;
1271  char *demangled_no_class
1272  = remove_qualifiers (demangled_name);
1273 
1274  /* Get rid of the `static' appended by the
1275  demangler. */
1276  p = strstr (demangled_no_class, " static");
1277  if (p != NULL)
1278  {
1279  int length = p - demangled_no_class;
1280  char *demangled_no_static;
1281 
1282  demangled_no_static
1283  = (char *) xmalloc (length + 1);
1284  strncpy (demangled_no_static,
1285  demangled_no_class, length);
1286  *(demangled_no_static + length) = '\0';
1287  fputs_filtered (demangled_no_static, stream);
1288  xfree (demangled_no_static);
1289  }
1290  else
1291  fputs_filtered (demangled_no_class, stream);
1292  xfree (demangled_name);
1293  }
1294 
1295  do_cleanups (inner_cleanup);
1296 
1297  fprintf_filtered (stream, ";\n");
1298  }
1299  }
1300 
1301  /* Print typedefs defined in this class. */
1302 
1303  if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0 && flags->print_typedefs)
1304  {
1305  if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1306  fprintf_filtered (stream, "\n");
1307 
1308  for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1309  {
1310  struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1311 
1312  /* Dereference the typedef declaration itself. */
1313  gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1314  target = TYPE_TARGET_TYPE (target);
1315 
1316  print_spaces_filtered (level + 4, stream);
1317  fprintf_filtered (stream, "typedef ");
1318 
1319  /* We want to print typedefs with substitutions
1320  from the template parameters or globally-known
1321  typedefs but not local typedefs. */
1322  c_print_type (target,
1323  TYPE_TYPEDEF_FIELD_NAME (type, i),
1324  stream, show - 1, level + 4,
1325  &semi_local_flags);
1326  fprintf_filtered (stream, ";\n");
1327  }
1328  }
1329 
1330  fprintfi_filtered (level, stream, "}");
1331  }
1332 
1333  do_cleanups (local_cleanups);
1334  }
1335  break;
1336 
1337  case TYPE_CODE_ENUM:
1338  c_type_print_modifier (type, stream, 0, 1);
1339  fprintf_filtered (stream, "enum ");
1340  if (TYPE_DECLARED_CLASS (type))
1341  fprintf_filtered (stream, "class ");
1342  /* Print the tag name if it exists.
1343  The aCC compiler emits a spurious
1344  "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1345  tag for unnamed struct/union/enum's, which we don't
1346  want to print. */
1347  if (TYPE_TAG_NAME (type) != NULL
1348  && !startswith (TYPE_TAG_NAME (type), "{unnamed"))
1349  {
1350  print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
1351  if (show > 0)
1352  fputs_filtered (" ", stream);
1353  }
1354 
1355  wrap_here (" ");
1356  if (show < 0)
1357  {
1358  /* If we just printed a tag name, no need to print anything
1359  else. */
1360  if (TYPE_TAG_NAME (type) == NULL)
1361  fprintf_filtered (stream, "{...}");
1362  }
1363  else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1364  {
1365  LONGEST lastval = 0;
1366 
1367  /* We can't handle this case perfectly, as DWARF does not
1368  tell us whether or not the underlying type was specified
1369  in the source (and other debug formats don't provide this
1370  at all). We choose to print the underlying type, if it
1371  has a name, when in C++ on the theory that it's better to
1372  print too much than too little; but conversely not to
1373  print something egregiously outside the current
1374  language's syntax. */
1376  && TYPE_TARGET_TYPE (type) != NULL)
1377  {
1378  struct type *underlying = check_typedef (TYPE_TARGET_TYPE (type));
1379 
1380  if (TYPE_NAME (underlying) != NULL)
1381  fprintf_filtered (stream, ": %s ", TYPE_NAME (underlying));
1382  }
1383 
1384  fprintf_filtered (stream, "{");
1385  len = TYPE_NFIELDS (type);
1386  for (i = 0; i < len; i++)
1387  {
1388  QUIT;
1389  if (i)
1390  fprintf_filtered (stream, ", ");
1391  wrap_here (" ");
1392  fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1393  if (lastval != TYPE_FIELD_ENUMVAL (type, i))
1394  {
1395  fprintf_filtered (stream, " = %s",
1396  plongest (TYPE_FIELD_ENUMVAL (type, i)));
1397  lastval = TYPE_FIELD_ENUMVAL (type, i);
1398  }
1399  lastval++;
1400  }
1401  fprintf_filtered (stream, "}");
1402  }
1403  break;
1404 
1405  case TYPE_CODE_VOID:
1406  fprintf_filtered (stream, "void");
1407  break;
1408 
1409  case TYPE_CODE_UNDEF:
1410  fprintf_filtered (stream, _("struct <unknown>"));
1411  break;
1412 
1413  case TYPE_CODE_ERROR:
1414  fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1415  break;
1416 
1417  case TYPE_CODE_RANGE:
1418  /* This should not occur. */
1419  fprintf_filtered (stream, _("<range type>"));
1420  break;
1421 
1422  case TYPE_CODE_NAMESPACE:
1423  fputs_filtered ("namespace ", stream);
1424  fputs_filtered (TYPE_TAG_NAME (type), stream);
1425  break;
1426 
1427  default:
1428  /* Handle types not explicitly handled by the other cases, such
1429  as fundamental types. For these, just print whatever the
1430  type name is, as recorded in the type itself. If there is no
1431  type name, then complain. */
1432  if (TYPE_NAME (type) != NULL)
1433  {
1434  c_type_print_modifier (type, stream, 0, 1);
1435  print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1436  }
1437  else
1438  {
1439  /* At least for dump_symtab, it is important that this not
1440  be an error (). */
1441  fprintf_filtered (stream, _("<invalid type code %d>"),
1442  TYPE_CODE (type));
1443  }
1444  break;
1445  }
1446 }
#define TYPE_HIGH_BOUND_KIND(range_type)
Definition: gdbtypes.h:1254
#define TYPE_ERROR_NAME(type)
Definition: gdbtypes.h:1472
#define TYPE_FIELD_PRIVATE(thistype, n)
Definition: gdbtypes.h:1396
type_code
Definition: gdbtypes.h:85
void fprintf_symbol_filtered(struct ui_file *stream, const char *name, enum language lang, int arg_mode)
Definition: utils.c:2477
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
int get_vptr_fieldno(struct type *type, struct type **basetypep)
Definition: gdbtypes.c:1738
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1369
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1327
void xfree(void *)
Definition: common-utils.c:97
#define TYPE_NFN_FIELDS(thistype)
Definition: gdbtypes.h:1307
unsigned int raw
Definition: typeprint.h:30
static void scan(struct macro_buffer *dest, struct macro_buffer *src, struct macro_name_list *no_loop, macro_lookup_ftype *lookup_func, void *lookup_baton)
Definition: macroexp.c:1367
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
#define TYPE_FIELD_ARTIFICIAL(thistype, n)
Definition: gdbtypes.h:1376
#define TYPE_VOLATILE(t)
Definition: gdbtypes.h:350
void c_type_print_base(struct type *type, struct ui_file *stream, int show, int level, const struct type_print_options *flags)
Definition: c-typeprint.c:843
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
#define BASETYPE_VIA_VIRTUAL(thistype, index)
Definition: gdbtypes.h:1335
char * gdb_mangle_name(struct type *, int, int)
Definition: symtab.c:504
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:360
#define TYPE_FN_FIELD_STATIC_P(thisfn, n)
Definition: gdbtypes.h:1442
enum language la_language
Definition: language.h:152
static void c_type_print_modifier(struct type *, struct ui_file *, int, int)
Definition: c-typeprint.c:403
#define _(String)
Definition: gdb_locale.h:40
struct typedef_hash_table * copy_typedef_hash(struct typedef_hash_table *table)
Definition: typeprint.c:227
void java_print_type(struct type *, const char *, struct ui_file *, int, int, const struct type_print_options *)
Definition: jv-typeprint.c:335
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1367
#define TYPE_PROTOTYPED(t)
Definition: gdbtypes.h:267
#define TYPE_FIELD_ENUMVAL(thistype, n)
Definition: gdbtypes.h:1372
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
char * cp_canonicalize_string_full(const char *string, canonicalization_ftype *finder, void *data)
Definition: cp-support.c:538
void c_type_print_args(struct type *type, struct ui_file *stream, int linkage_name, enum language language, const struct type_print_options *flags)
Definition: c-typeprint.c:470
static void print_name_maybe_canonical(const char *name, const struct type_print_options *flags, struct ui_file *stream)
Definition: c-typeprint.c:60
mach_port_t kern_return_t mach_port_t msgports 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:1885
#define TYPE_N_TEMPLATE_ARGUMENTS(thistype)
Definition: gdbtypes.h:1415
void null_cleanup(void *arg)
Definition: cleanups.c:295
static void cp_type_print_method_args(struct type *mtype, const char *prefix, const char *varstring, int staticp, struct ui_file *stream, const struct type_print_options *flags)
Definition: c-typeprint.c:215
const char *const name
Definition: aarch64-tdep.c:68
char * gdb_demangle(const char *name, int options)
Definition: cp-support.c:1529
#define TYPE_INSTANCE_FLAGS(thistype)
Definition: gdbtypes.h:1225
#define TYPE_FN_FIELD_PHYSNAME(thisfn, n)
Definition: gdbtypes.h:1423
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n)
Definition: gdbtypes.h:1441
#define TYPE_FN_FIELD_PRIVATE(thisfn, n)
Definition: gdbtypes.h:1428
#define TYPE_TYPEDEF_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1448
static char * remove_qualifiers(char *qid)
Definition: c-typeprint.c:596
#define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n)
Definition: gdbtypes.h:1435
int field_is_static(struct field *f)
Definition: gdbtypes.c:3797
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
enum ctor_kinds is_constructor_name(const char *name)
Definition: cp-abi.c:36
void recursively_update_typedef_hash(struct typedef_hash_table *table, struct type *t)
Definition: typeprint.c:110
void c_print_type(struct type *type, const char *varstring, struct ui_file *stream, int show, int level, const struct type_print_options *flags)
Definition: c-typeprint.c:80
#define TYPE_VECTOR(t)
Definition: gdbtypes.h:287
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
#define TYPE_TYPEDEF_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1450
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
Definition: gdbtypes.h:749
enum dtor_kinds is_destructor_name(const char *name)
Definition: cp-abi.c:44
void c_print_typedef(struct type *type, struct symbol *new_symbol, struct ui_file *stream)
Definition: c-typeprint.c:143
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:232
unsigned int print_typedefs
Definition: typeprint.h:36
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
static struct symbol * new_symbol(struct die_info *, struct type *, struct dwarf2_cu *)
Definition: dwarf2read.c:18642
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1326
void wrap_here(char *indent)
Definition: utils.c:1930
#define TYPE_FIELD_PACKED(thistype, n)
Definition: gdbtypes.h:1378
#define TYPE_FIELDS(thistype)
Definition: gdbtypes.h:1242
unsigned int print_methods
Definition: typeprint.h:33
static void c_type_print_template_args(const struct type_print_options *flags, struct type *type, struct ui_file *stream)
Definition: c-typeprint.c:788
void * xmalloc(YYSIZE_T)
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1377
static void cp_type_print_derivation_info(struct ui_file *stream, struct type *type, const struct type_print_options *flags)
Definition: c-typeprint.c:184
#define TYPE_FIELD_PROTECTED(thistype, n)
Definition: gdbtypes.h:1399
void fprintfi_filtered(int spaces, struct ui_file *stream, const char *format,...)
Definition: utils.c:2374
void print_spaces_filtered(int n, struct ui_file *stream)
Definition: utils.c:2464
#define TYPE_FN_FIELD_TYPE(thisfn, n)
Definition: gdbtypes.h:1424
unsigned length
Definition: gdbtypes.h:807
struct type * make_cv_type(int cnst, int voltl, struct type *type, struct type **typeptr)
Definition: gdbtypes.c:651
#define TYPE_VARARGS(t)
Definition: gdbtypes.h:282
const struct language_defn * current_language
Definition: language.c:85
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
def is_constructor(decl)
const char * find_typedef_in_hash(const struct type_print_options *flags, struct type *t)
Definition: typeprint.c:314
#define TYPE_RESTRICT(t)
Definition: gdbtypes.h:356
#define TYPE_ATOMIC(t)
Definition: gdbtypes.h:362
#define TYPE_FN_FIELD_PROTECTED(thisfn, n)
Definition: gdbtypes.h:1429
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
const char * address_space_int_to_name(struct gdbarch *gdbarch, int space_flag)
Definition: gdbtypes.c:550
#define TYPE_INDEX_TYPE(type)
Definition: gdbtypes.h:1244
int code
Definition: ser-unix.c:684
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
static void c_type_print_varspec_prefix(struct type *, struct ui_file *, int, int, int, const struct type_print_options *)
Definition: c-typeprint.c:293
#define CHECK_TYPEDEF(TYPE)
Definition: gdbtypes.h:1817
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1228
#define TYPE_STUB(t)
Definition: gdbtypes.h:245
#define BASETYPE_VIA_PUBLIC(thistype, index)
Definition: gdbtypes.h:1330
#define TYPE_TYPEDEF_FIELD_COUNT(thistype)
Definition: gdbtypes.h:1452
language
Definition: defs.h:167
#define TYPE_TEMPLATE_ARGUMENT(thistype, n)
Definition: gdbtypes.h:1419
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
void add_template_parameters(struct typedef_hash_table *table, struct type *t)
Definition: typeprint.c:139
#define TYPE_FN_FIELDLIST_NAME(thistype, n)
Definition: gdbtypes.h:1412
const char * type_name_no_tag(const struct type *type)
Definition: gdbtypes.c:1361
struct cleanup * make_cleanup_free_typedef_hash(struct typedef_hash_table *table)
Definition: typeprint.c:204
#define TYPE_FN_FIELDLIST_LENGTH(thistype, n)
Definition: gdbtypes.h:1413
#define TYPE_FN_FIELD_CONSTRUCTOR(thisfn, n)
Definition: gdbtypes.h:1438
#define QUIT
Definition: defs.h:160
struct typedef_hash_table * create_typedef_hash(void)
Definition: typeprint.c:168
#define TYPE_DECLARED_CLASS(t)
Definition: gdbtypes.h:334
static int is_type_conversion_operator(struct type *type, int i, int j)
Definition: c-typeprint.c:539
struct typedef_hash_table * local_typedefs
Definition: typeprint.h:40
int get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition: gdbtypes.c:978
#define TYPE_CONST(t)
Definition: gdbtypes.h:345
#define TYPE_SELF_TYPE(thistype)
Definition: gdbtypes.h:1295
void error(const char *fmt,...)
Definition: errors.c:38
#define TYPE_FN_FIELDLIST1(thistype, n)
Definition: gdbtypes.h:1411
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void c_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)
Definition: c-typeprint.c:675
const ULONGEST const LONGEST len
Definition: target.h:309
#define TYPE_FN_FIELD_STUB(thisfn, n)
Definition: gdbtypes.h:1437
static const char * find_typedef_for_canonicalize(struct type *t, void *data)
Definition: c-typeprint.c:51