GDB (xrefs)
/tmp/gdb-7.10/gdb/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-2015 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 "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 
40 extern void _initialize_typeprint (void);
41 
42 static void ptype_command (char *, int);
43 
44 static void whatis_command (char *, int);
45 
46 static void whatis_exp (char *, int);
47 
48 const struct type_print_options type_print_raw_options =
49 {
50  1, /* raw */
51  1, /* print_methods */
52  1, /* print_typedefs */
53  NULL, /* local_typedefs */
54  NULL, /* global_table */
55  NULL /* global_printers */
56 };
57 
58 /* The default flags for 'ptype' and 'whatis'. */
59 
60 static struct type_print_options default_ptype_flags =
61 {
62  0, /* raw */
63  1, /* print_methods */
64  1, /* print_typedefs */
65  NULL, /* local_typedefs */
66  NULL, /* global_table */
67  NULL /* global_printers */
68 };
69 
70 
71 
72 /* A hash table holding typedef_field objects. This is more
73  complicated than an ordinary hash because it must also track the
74  lifetime of some -- but not all -- of the contained objects. */
75 
77 {
78  /* The actual hash table. */
79  htab_t table;
80 
81  /* Storage for typedef_field objects that must be synthesized. */
82  struct obstack storage;
83 };
84 
85 /* A hash function for a typedef_field. */
86 
87 static hashval_t
88 hash_typedef_field (const void *p)
89 {
90  const struct typedef_field *tf = p;
91  struct type *t = check_typedef (tf->type);
92 
93  return htab_hash_string (TYPE_SAFE_NAME (t));
94 }
95 
96 /* An equality function for a typedef field. */
97 
98 static int
99 eq_typedef_field (const void *a, const void *b)
100 {
101  const struct typedef_field *tfa = a;
102  const struct typedef_field *tfb = b;
103 
104  return types_equal (tfa->type, tfb->type);
105 }
106 
107 /* Add typedefs from T to the hash table TABLE. */
108 
109 void
111  struct type *t)
112 {
113  int i;
114 
115  if (table == NULL)
116  return;
117 
118  for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (t); ++i)
119  {
120  struct typedef_field *tdef = &TYPE_TYPEDEF_FIELD (t, i);
121  void **slot;
122 
123  slot = htab_find_slot (table->table, tdef, INSERT);
124  /* Only add a given typedef name once. Really this shouldn't
125  happen; but it is safe enough to do the updates breadth-first
126  and thus use the most specific typedef. */
127  if (*slot == NULL)
128  *slot = tdef;
129  }
130 
131  /* Recurse into superclasses. */
132  for (i = 0; i < TYPE_N_BASECLASSES (t); ++i)
134 }
135 
136 /* Add template parameters from T to the typedef hash TABLE. */
137 
138 void
140 {
141  int i;
142 
143  if (table == NULL)
144  return;
145 
146  for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (t); ++i)
147  {
148  struct typedef_field *tf;
149  void **slot;
150 
151  /* We only want type-valued template parameters in the hash. */
153  continue;
154 
155  tf = XOBNEW (&table->storage, struct typedef_field);
157  tf->type = SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t, i));
158 
159  slot = htab_find_slot (table->table, tf, INSERT);
160  if (*slot == NULL)
161  *slot = tf;
162  }
163 }
164 
165 /* Create a new typedef-lookup hash table. */
166 
167 struct typedef_hash_table *
169 {
170  struct typedef_hash_table *result;
171 
172  result = XNEW (struct typedef_hash_table);
173  result->table = htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
174  NULL, xcalloc, xfree);
175  obstack_init (&result->storage);
176 
177  return result;
178 }
179 
180 /* Free a typedef field table. */
181 
182 void
184 {
185  if (table != NULL)
186  {
187  htab_delete (table->table);
188  obstack_free (&table->storage, NULL);
189  xfree (table);
190  }
191 }
192 
193 /* A cleanup for freeing a typedef_hash_table. */
194 
195 static void
197 {
198  free_typedef_hash (arg);
199 }
200 
201 /* Return a new cleanup that frees TABLE. */
202 
203 struct cleanup *
205 {
206  return make_cleanup (do_free_typedef_hash, table);
207 }
208 
209 /* Helper function for copy_typedef_hash. */
210 
211 static int
212 copy_typedef_hash_element (void **slot, void *nt)
213 {
214  htab_t new_table = nt;
215  void **new_slot;
216 
217  new_slot = htab_find_slot (new_table, *slot, INSERT);
218  if (*new_slot == NULL)
219  *new_slot = *slot;
220 
221  return 1;
222 }
223 
224 /* Copy a typedef hash. */
225 
226 struct typedef_hash_table *
228 {
229  struct typedef_hash_table *result;
230 
231  if (table == NULL)
232  return NULL;
233 
234  result = create_typedef_hash ();
235  htab_traverse_noresize (table->table, copy_typedef_hash_element,
236  result->table);
237  return result;
238 }
239 
240 /* A cleanup to free the global typedef hash. */
241 
242 static void
244 {
245  struct type_print_options *flags = arg;
246 
249 }
250 
251 /* Create the global typedef hash. */
252 
253 static struct cleanup *
255 {
256  gdb_assert (flags->global_typedefs == NULL && flags->global_printers == NULL);
259  return make_cleanup (do_free_global_table, flags);
260 }
261 
262 /* Look up the type T in the global typedef hash. If it is found,
263  return the typedef name. If it is not found, apply the
264  type-printers, if any, given by start_script_type_printers and return the
265  result. A NULL return means that the name was not found. */
266 
267 static const char *
269  struct type *t)
270 {
271  char *applied;
272  void **slot;
273  struct typedef_field tf, *new_tf;
274 
275  if (flags->global_typedefs == NULL)
276  return NULL;
277 
278  tf.name = NULL;
279  tf.type = t;
280 
281  slot = htab_find_slot (flags->global_typedefs->table, &tf, INSERT);
282  if (*slot != NULL)
283  {
284  new_tf = *slot;
285  return new_tf->name;
286  }
287 
288  /* Put an entry into the hash table now, in case
289  apply_ext_lang_type_printers recurses. */
290  new_tf = XOBNEW (&flags->global_typedefs->storage, struct typedef_field);
291  new_tf->name = NULL;
292  new_tf->type = t;
293 
294  *slot = new_tf;
295 
296  applied = apply_ext_lang_type_printers (flags->global_printers, t);
297 
298  if (applied != NULL)
299  {
300  new_tf->name = obstack_copy0 (&flags->global_typedefs->storage, applied,
301  strlen (applied));
302  xfree (applied);
303  }
304 
305  return new_tf->name;
306 }
307 
308 /* Look up the type T in the typedef hash table in with FLAGS. If T
309  is in the table, return its short (class-relative) typedef name.
310  Otherwise return NULL. If the table is NULL, this always returns
311  NULL. */
312 
313 const char *
315 {
316  if (flags->local_typedefs != NULL)
317  {
318  struct typedef_field tf, *found;
319 
320  tf.name = NULL;
321  tf.type = t;
322  found = htab_find (flags->local_typedefs->table, &tf);
323 
324  if (found != NULL)
325  return found->name;
326  }
327 
328  return find_global_typedef (flags, t);
329 }
330 
331 
332 
333 /* Print a description of a type in the format of a
334  typedef for the current language.
335  NEW is the new name for a type TYPE. */
336 
337 void
338 typedef_print (struct type *type, struct symbol *newobj, struct ui_file *stream)
339 {
340  LA_PRINT_TYPEDEF (type, newobj, stream);
341 }
342 
343 /* The default way to print a typedef. */
344 
345 void
347  struct ui_file *stream)
348 {
349  error (_("Language not supported."));
350 }
351 
352 /* Print a description of a type TYPE in the form of a declaration of a
353  variable named VARSTRING. (VARSTRING is demangled if necessary.)
354  Output goes to STREAM (via stdio).
355  If SHOW is positive, we show the contents of the outermost level
356  of structure even if there is a type name that could be used instead.
357  If SHOW is negative, we never show the details of elements' types. */
358 
359 void
360 type_print (struct type *type, const char *varstring, struct ui_file *stream,
361  int show)
362 {
363  LA_PRINT_TYPE (type, varstring, stream, show, 0, &default_ptype_flags);
364 }
365 
366 /* Print TYPE to a string, returning it. The caller is responsible for
367  freeing the string. */
368 
369 char *
371 {
372  char *s = NULL;
373  struct ui_file *stb;
374  struct cleanup *old_chain;
375 
376  stb = mem_fileopen ();
377  old_chain = make_cleanup_ui_file_delete (stb);
378 
379  TRY
380  {
381  type_print (type, "", stb, -1);
382  s = ui_file_xstrdup (stb, NULL);
383  }
384  CATCH (except, RETURN_MASK_ALL)
385  {
386  s = NULL;
387  }
388  END_CATCH
389 
390  do_cleanups (old_chain);
391 
392  return s;
393 }
394 
395 /* Print type of EXP, or last thing in value history if EXP == NULL.
396  show is passed to type_print. */
397 
398 static void
399 whatis_exp (char *exp, int show)
400 {
401  struct expression *expr;
402  struct value *val;
403  struct cleanup *old_chain;
404  struct type *real_type = NULL;
405  struct type *type;
406  int full = 0;
407  int top = -1;
408  int using_enc = 0;
409  struct value_print_options opts;
411 
412  old_chain = make_cleanup (null_cleanup, NULL);
413 
414  if (exp)
415  {
416  if (*exp == '/')
417  {
418  int seen_one = 0;
419 
420  for (++exp; *exp && !isspace (*exp); ++exp)
421  {
422  switch (*exp)
423  {
424  case 'r':
425  flags.raw = 1;
426  break;
427  case 'm':
428  flags.print_methods = 0;
429  break;
430  case 'M':
431  flags.print_methods = 1;
432  break;
433  case 't':
434  flags.print_typedefs = 0;
435  break;
436  case 'T':
437  flags.print_typedefs = 1;
438  break;
439  default:
440  error (_("unrecognized flag '%c'"), *exp);
441  }
442  seen_one = 1;
443  }
444 
445  if (!*exp && !seen_one)
446  error (_("flag expected"));
447  if (!isspace (*exp))
448  error (_("expected space after format"));
449  exp = skip_spaces (exp);
450  }
451 
452  expr = parse_expression (exp);
454  val = evaluate_type (expr);
455  }
456  else
457  val = access_value_history (0);
458 
459  type = value_type (val);
460 
461  get_user_print_options (&opts);
462  if (opts.objectprint)
463  {
464  if (((TYPE_CODE (type) == TYPE_CODE_PTR)
465  || (TYPE_CODE (type) == TYPE_CODE_REF))
467  real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
468  else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
469  real_type = value_rtti_type (val, &full, &top, &using_enc);
470  }
471 
472  printf_filtered ("type = ");
473 
474  if (!flags.raw)
476 
477  if (real_type)
478  {
479  printf_filtered ("/* real type = ");
480  type_print (real_type, "", gdb_stdout, -1);
481  if (! full)
482  printf_filtered (" (incomplete object)");
483  printf_filtered (" */\n");
484  }
485 
486  LA_PRINT_TYPE (type, "", gdb_stdout, show, 0, &flags);
487  printf_filtered ("\n");
488 
489  do_cleanups (old_chain);
490 }
491 
492 static void
493 whatis_command (char *exp, int from_tty)
494 {
495  /* Most of the time users do not want to see all the fields
496  in a structure. If they do they can use the "ptype" command.
497  Hence the "-1" below. */
498  whatis_exp (exp, -1);
499 }
500 
501 /* TYPENAME is either the name of a type, or an expression. */
502 
503 static void
504 ptype_command (char *type_name, int from_tty)
505 {
506  whatis_exp (type_name, 1);
507 }
508 
509 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
510  Used to print data from type structures in a specified type. For example,
511  array bounds may be characters or booleans in some languages, and this
512  allows the ranges to be printed in their "natural" form rather than as
513  decimal integer values.
514 
515  FIXME: This is here simply because only the type printing routines
516  currently use it, and it wasn't clear if it really belonged somewhere
517  else (like printcmd.c). There are a lot of other gdb routines that do
518  something similar, but they are generally concerned with printing values
519  that come from the inferior in target byte order and target size. */
520 
521 void
522 print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
523 {
524  unsigned int i;
525  unsigned len;
526 
527  CHECK_TYPEDEF (type);
528 
529  switch (TYPE_CODE (type))
530  {
531 
532  case TYPE_CODE_ENUM:
533  len = TYPE_NFIELDS (type);
534  for (i = 0; i < len; i++)
535  {
536  if (TYPE_FIELD_ENUMVAL (type, i) == val)
537  {
538  break;
539  }
540  }
541  if (i < len)
542  {
543  fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
544  }
545  else
546  {
547  print_longest (stream, 'd', 0, val);
548  }
549  break;
550 
551  case TYPE_CODE_INT:
552  print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
553  break;
554 
555  case TYPE_CODE_CHAR:
556  LA_PRINT_CHAR ((unsigned char) val, type, stream);
557  break;
558 
559  case TYPE_CODE_BOOL:
560  fprintf_filtered (stream, val ? "TRUE" : "FALSE");
561  break;
562 
563  case TYPE_CODE_RANGE:
564  print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
565  return;
566 
567  case TYPE_CODE_UNDEF:
568  case TYPE_CODE_PTR:
569  case TYPE_CODE_ARRAY:
570  case TYPE_CODE_STRUCT:
571  case TYPE_CODE_UNION:
572  case TYPE_CODE_FUNC:
573  case TYPE_CODE_FLT:
574  case TYPE_CODE_VOID:
575  case TYPE_CODE_SET:
576  case TYPE_CODE_STRING:
577  case TYPE_CODE_ERROR:
578  case TYPE_CODE_MEMBERPTR:
579  case TYPE_CODE_METHODPTR:
580  case TYPE_CODE_METHOD:
581  case TYPE_CODE_REF:
582  case TYPE_CODE_NAMESPACE:
583  error (_("internal error: unhandled type in print_type_scalar"));
584  break;
585 
586  default:
587  error (_("Invalid type code in symbol table."));
588  }
589  gdb_flush (stream);
590 }
591 
592 /* Dump details of a type specified either directly or indirectly.
593  Uses the same sort of type lookup mechanism as ptype_command()
594  and whatis_command(). */
595 
596 void
597 maintenance_print_type (char *type_name, int from_tty)
598 {
599  struct value *val;
600  struct type *type;
601  struct cleanup *old_chain;
602  struct expression *expr;
603 
604  if (type_name != NULL)
605  {
606  expr = parse_expression (type_name);
607  old_chain = make_cleanup (free_current_contents, &expr);
608  if (expr->elts[0].opcode == OP_TYPE)
609  {
610  /* The user expression names a type directly, just use that type. */
611  type = expr->elts[1].type;
612  }
613  else
614  {
615  /* The user expression may name a type indirectly by naming an
616  object of that type. Find that indirectly named type. */
617  val = evaluate_type (expr);
618  type = value_type (val);
619  }
620  if (type != NULL)
621  {
622  recursive_dump_type (type, 0);
623  }
624  do_cleanups (old_chain);
625  }
626 }
627 
628 
630 
632 
633 static void
634 set_print_type (char *arg, int from_tty)
635 {
637  "\"set print type\" must be followed by the name of a subcommand.\n");
638  help_list (setprintlist, "set print type ", all_commands, gdb_stdout);
639 }
640 
641 static void
642 show_print_type (char *args, int from_tty)
643 {
644  cmd_show_list (showprinttypelist, from_tty, "");
645 }
646 
647 static int print_methods = 1;
648 
649 static void
650 set_print_type_methods (char *args, int from_tty, struct cmd_list_element *c)
651 {
652  default_ptype_flags.print_methods = print_methods;
653 }
654 
655 static void
656 show_print_type_methods (struct ui_file *file, int from_tty,
657  struct cmd_list_element *c, const char *value)
658 {
659  fprintf_filtered (file, _("Printing of methods defined in a class in %s\n"),
660  value);
661 }
662 
663 static int print_typedefs = 1;
664 
665 static void
666 set_print_type_typedefs (char *args, int from_tty, struct cmd_list_element *c)
667 {
668  default_ptype_flags.print_typedefs = print_typedefs;
669 }
670 
671 static void
672 show_print_type_typedefs (struct ui_file *file, int from_tty,
673  struct cmd_list_element *c, const char *value)
674 {
675  fprintf_filtered (file, _("Printing of typedefs defined in a class in %s\n"),
676  value);
677 }
678 
679 void
681 {
682  struct cmd_list_element *c;
683 
684  c = add_com ("ptype", class_vars, ptype_command, _("\
685 Print definition of type TYPE.\n\
686 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
687 Argument may be any type (for example a type name defined by typedef,\n\
688 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
689 or \"enum ENUM-TAG\") or an expression.\n\
690 The selected stack frame's lexical context is used to look up the name.\n\
691 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
692 \n\
693 Available FLAGS are:\n\
694  /r print in \"raw\" form; do not substitute typedefs\n\
695  /m do not print methods defined in a class\n\
696  /M print methods defined in a class\n\
697  /t do not print typedefs defined in a class\n\
698  /T print typedefs defined in a class"));
699  set_cmd_completer (c, expression_completer);
700 
701  c = add_com ("whatis", class_vars, whatis_command,
702  _("Print data type of expression EXP.\n\
703 Only one level of typedefs is unrolled. See also \"ptype\"."));
704  set_cmd_completer (c, expression_completer);
705 
707  _("Generic command for showing type-printing settings."),
708  &showprinttypelist, "show print type ", 0, &showprintlist);
710  _("Generic command for setting how types print."),
711  &setprinttypelist, "show print type ", 0, &setprintlist);
712 
714  _("\
715 Set printing of methods defined in classes."), _("\
716 Show printing of methods defined in classes."), NULL,
719  &setprinttypelist, &showprinttypelist);
721  _("\
722 Set printing of typedefs defined in classes."), _("\
723 Show printing of typedefs defined in classes."), NULL,
726  &setprinttypelist, &showprinttypelist);
727 }
union exp_element elts[1]
Definition: expression.h:85
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
static void whatis_exp(char *, int)
Definition: typeprint.c:399
#define LA_PRINT_TYPEDEF(type, new_symbol, stream)
Definition: language.h:485
static const char * find_global_typedef(const struct type_print_options *flags, struct type *t)
Definition: typeprint.c:268
static void set_print_type_typedefs(char *args, int from_tty, struct cmd_list_element *c)
Definition: typeprint.c:666
enum exp_opcode opcode
Definition: expression.h:65
#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
unsigned int raw
Definition: typeprint.h:30
struct ext_lang_type_printers * start_ext_lang_type_printers(void)
Definition: extension.c:408
char * ui_file_xstrdup(struct ui_file *file, long *length)
Definition: ui-file.c:345
struct ui_file * gdb_stdout
Definition: main.c:71
static int copy_typedef_hash_element(void **slot, void *nt)
Definition: typeprint.c:212
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
void _initialize_typeprint(void)
Definition: typeprint.c:680
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:360
static void show_print_type_typedefs(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: typeprint.c:672
char * skip_spaces(char *chp)
Definition: common-utils.c:259
#define _(String)
Definition: gdb_locale.h:40
struct typedef_hash_table * copy_typedef_hash(struct typedef_hash_table *table)
Definition: typeprint.c:227
struct ext_lang_type_printers * global_printers
Definition: typeprint.h:48
#define TYPE_FIELD_ENUMVAL(thistype, n)
Definition: gdbtypes.h:1372
#define END_CATCH
void printf_filtered(const char *format,...)
Definition: utils.c:2388
struct type * type
Definition: expression.h:73
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 do_free_typedef_hash(void *arg)
Definition: typeprint.c:196
#define TRY
static void do_free_global_table(void *arg)
Definition: typeprint.c:243
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define CATCH(EXCEPTION, MASK)
void typedef_print(struct type *type, struct symbol *newobj, struct ui_file *stream)
Definition: typeprint.c:338
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:159
void recursively_update_typedef_hash(struct typedef_hash_table *table, struct type *t)
Definition: typeprint.c:110
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
const char * name
Definition: gdbtypes.h:904
void free_current_contents(void *ptr)
Definition: utils.c:476
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
Definition: gdbtypes.h:749
static int print_typedefs
Definition: typeprint.c:663
unsigned int print_typedefs
Definition: typeprint.h:36
void free_typedef_hash(struct typedef_hash_table *table)
Definition: typeprint.c:183
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
void free_ext_lang_type_printers(struct ext_lang_type_printers *printers)
Definition: extension.c:466
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
struct type * type
Definition: gdbtypes.h:908
static struct type_print_options default_ptype_flags
Definition: typeprint.c:60
void print_type_scalar(struct type *type, LONGEST val, struct ui_file *stream)
Definition: typeprint.c:522
struct type * value_rtti_indirect_type(struct value *v, int *full, int *top, int *using_enc)
Definition: valops.c:3591
static struct symbol * new_symbol(struct die_info *, struct type *, struct dwarf2_cu *)
Definition: dwarf2read.c:18642
static void set_print_type_methods(char *args, int from_tty, struct cmd_list_element *c)
Definition: typeprint.c:650
static hashval_t hash_typedef_field(const void *p)
Definition: typeprint.c:88
static void ptype_command(char *, int)
Definition: typeprint.c:504
struct cmd_list_element * setprintlist
Definition: cli-cmds.c:169
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1326
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
unsigned int print_methods
Definition: typeprint.h:33
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
struct expression * parse_expression(const char *)
Definition: parse.c:1261
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
Definition: cli-setshow.c:672
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:233
Definition: value.c:172
#define LA_PRINT_TYPE(type, varstring, stream, show, level, flags)
Definition: language.h:482
static void set_print_type(char *arg, int from_tty)
Definition: typeprint.c:634
int types_equal(struct type *a, struct type *b)
Definition: gdbtypes.c:3085
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
void print_longest(struct ui_file *stream, int format, int use_c_format, LONGEST val_long)
Definition: valprint.c:1016
const char * find_typedef_in_hash(const struct type_print_options *flags, struct type *t)
Definition: typeprint.c:314
static int print_methods
Definition: typeprint.c:647
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
static void show_print_type(char *args, int from_tty)
Definition: typeprint.c:642
char * apply_ext_lang_type_printers(struct ext_lang_type_printers *printers, struct type *type)
Definition: extension.c:430
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
static int eq_typedef_field(const void *a, const void *b)
Definition: typeprint.c:99
static void whatis_command(char *, int)
Definition: typeprint.c:493
void recursive_dump_type(struct type *type, int spaces)
Definition: gdbtypes.c:3953
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:129
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
struct type * value_rtti_type(struct value *v, int *full, int *top, int *using_enc)
Definition: cp-abi.c:108
#define CHECK_TYPEDEF(TYPE)
Definition: gdbtypes.h:1817
struct cmd_list_element * showprintlist
Definition: cli-cmds.c:171
#define TYPE_TYPEDEF_FIELD(thistype, n)
Definition: gdbtypes.h:1446
#define TYPE_TYPEDEF_FIELD_COUNT(thistype)
Definition: gdbtypes.h:1452
#define TYPE_TEMPLATE_ARGUMENT(thistype, n)
Definition: gdbtypes.h:1419
void maintenance_print_type(char *type_name, int from_tty)
Definition: typeprint.c:597
struct type * value_type(const struct value *value)
Definition: value.c:1021
struct typedef_hash_table * global_typedefs
Definition: typeprint.h:44
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
struct value * access_value_history(int num)
Definition: value.c:1834
struct value * evaluate_type(struct expression *exp)
Definition: eval.c:170
void add_template_parameters(struct typedef_hash_table *table, struct type *t)
Definition: typeprint.c:139
struct cleanup * make_cleanup_free_typedef_hash(struct typedef_hash_table *table)
Definition: typeprint.c:204
void default_print_typedef(struct type *type, struct symbol *new_symbol, struct ui_file *stream)
Definition: typeprint.c:346
#define LA_PRINT_CHAR(ch, type, stream)
Definition: language.h:494
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
struct typedef_hash_table * create_typedef_hash(void)
Definition: typeprint.c:168
struct cmd_list_element * showprinttypelist
Definition: typeprint.c:631
static void show_print_type_methods(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: typeprint.c:656
static struct cleanup * create_global_typedef_table(struct type_print_options *flags)
Definition: typeprint.c:254
char * type_to_string(struct type *type)
Definition: typeprint.c:370
struct obstack storage
Definition: typeprint.c:82
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:71
struct typedef_hash_table * local_typedefs
Definition: typeprint.h:40
void error(const char *fmt,...)
Definition: errors.c:38
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
struct cmd_list_element * setprinttypelist
Definition: typeprint.c:629
#define TYPE_SAFE_NAME(type)
Definition: gdbtypes.h:1466
const ULONGEST const LONGEST len
Definition: target.h:309