GDB (xrefs)
/tmp/gdb-7.10/gdb/cp-support.c
Go to the documentation of this file.
1 /* Helper routines for C++ support in GDB.
2  Copyright (C) 2002-2015 Free Software Foundation, Inc.
3 
4  Contributed by MontaVista Software.
5 
6  This file is part of GDB.
7 
8  This program is free software; you can redistribute it and/or modify
9  it under the terms of the GNU General Public License as published by
10  the Free Software Foundation; either version 3 of the License, or
11  (at your option) any later version.
12 
13  This program is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 
21 #include "defs.h"
22 #include "cp-support.h"
23 #include "demangle.h"
24 #include "gdbcmd.h"
25 #include "dictionary.h"
26 #include "objfiles.h"
27 #include "frame.h"
28 #include "symtab.h"
29 #include "block.h"
30 #include "complaints.h"
31 #include "gdbtypes.h"
32 #include "expression.h"
33 #include "value.h"
34 #include "cp-abi.h"
35 #include <signal.h>
36 
37 #include "safe-ctype.h"
38 
39 #define d_left(dc) (dc)->u.s_binary.left
40 #define d_right(dc) (dc)->u.s_binary.right
41 
42 /* Functions related to demangled name parsing. */
43 
44 static unsigned int cp_find_first_component_aux (const char *name,
45  int permissive);
46 
47 static void demangled_name_complaint (const char *name);
48 
49 /* Functions/variables related to overload resolution. */
50 
51 static int sym_return_val_size = -1;
53 static struct symbol **sym_return_val;
54 
55 static void overload_list_add_symbol (struct symbol *sym,
56  const char *oload_name);
57 
58 static void make_symbol_overload_list_using (const char *func_name,
59  const char *the_namespace);
60 
61 static void make_symbol_overload_list_qualified (const char *func_name);
62 
63 /* The list of "maint cplus" commands. */
64 
65 struct cmd_list_element *maint_cplus_cmd_list = NULL;
66 
67 /* The actual commands. */
68 
69 static void maint_cplus_command (char *arg, int from_tty);
70 static void first_component_command (char *arg, int from_tty);
71 
72 /* A list of typedefs which should not be substituted by replace_typedefs. */
73 static const char * const ignore_typedefs[] =
74  {
75  "std::istream", "std::iostream", "std::ostream", "std::string"
76  };
77 
78 static void
80  struct demangle_component *ret_comp,
81  canonicalization_ftype *finder,
82  void *data);
83 
84 /* A convenience function to copy STRING into OBSTACK, returning a pointer
85  to the newly allocated string and saving the number of bytes saved in LEN.
86 
87  It does not copy the terminating '\0' byte! */
88 
89 static char *
90 copy_string_to_obstack (struct obstack *obstack, const char *string,
91  long *len)
92 {
93  *len = strlen (string);
94  return obstack_copy (obstack, string, *len);
95 }
96 
97 /* A cleanup wrapper for cp_demangled_name_parse_free. */
98 
99 static void
101 {
102  struct demangle_parse_info *info = (struct demangle_parse_info *) data;
103 
105 }
106 
107 /* Create a cleanup for C++ name parsing. */
108 
109 struct cleanup *
111 {
113 }
114 
115 /* Return 1 if STRING is clearly already in canonical form. This
116  function is conservative; things which it does not recognize are
117  assumed to be non-canonical, and the parser will sort them out
118  afterwards. This speeds up the critical path for alphanumeric
119  identifiers. */
120 
121 static int
122 cp_already_canonical (const char *string)
123 {
124  /* Identifier start character [a-zA-Z_]. */
125  if (!ISIDST (string[0]))
126  return 0;
127 
128  /* These are the only two identifiers which canonicalize to other
129  than themselves or an error: unsigned -> unsigned int and
130  signed -> int. */
131  if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
132  return 0;
133  else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
134  return 0;
135 
136  /* Identifier character [a-zA-Z0-9_]. */
137  while (ISIDNUM (string[1]))
138  string++;
139 
140  if (string[1] == '\0')
141  return 1;
142  else
143  return 0;
144 }
145 
146 /* Inspect the given RET_COMP for its type. If it is a typedef,
147  replace the node with the typedef's tree.
148 
149  Returns 1 if any typedef substitutions were made, 0 otherwise. */
150 
151 static int
153  struct demangle_component *ret_comp,
154  canonicalization_ftype *finder,
155  void *data)
156 {
157  int i;
158  char *name;
159  struct symbol *sym;
160 
161  /* Copy the symbol's name from RET_COMP and look it up
162  in the symbol table. */
163  name = (char *) alloca (ret_comp->u.s_name.len + 1);
164  memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len);
165  name[ret_comp->u.s_name.len] = '\0';
166 
167  /* Ignore any typedefs that should not be substituted. */
168  for (i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i)
169  {
170  if (strcmp (name, ignore_typedefs[i]) == 0)
171  return 0;
172  }
173 
174  sym = NULL;
175 
176  TRY
177  {
178  sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
179  }
180  CATCH (except, RETURN_MASK_ALL)
181  {
182  return 0;
183  }
184  END_CATCH
185 
186  if (sym != NULL)
187  {
188  struct type *otype = SYMBOL_TYPE (sym);
189 
190  if (finder != NULL)
191  {
192  const char *new_name = (*finder) (otype, data);
193 
194  if (new_name != NULL)
195  {
196  ret_comp->u.s_name.s = new_name;
197  ret_comp->u.s_name.len = strlen (new_name);
198  return 1;
199  }
200 
201  return 0;
202  }
203 
204  /* If the type is a typedef or namespace alias, replace it. */
205  if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF
206  || TYPE_CODE (otype) == TYPE_CODE_NAMESPACE)
207  {
208  long len;
209  int is_anon;
210  struct type *type;
211  struct demangle_parse_info *i;
212  struct ui_file *buf;
213 
214  /* Get the real type of the typedef. */
215  type = check_typedef (otype);
216 
217  /* If the symbol is a namespace and its type name is no different
218  than the name we looked up, this symbol is not a namespace
219  alias and does not need to be substituted. */
220  if (TYPE_CODE (otype) == TYPE_CODE_NAMESPACE
221  && strcmp (TYPE_NAME (type), name) == 0)
222  return 0;
223 
224  is_anon = (TYPE_TAG_NAME (type) == NULL
225  && (TYPE_CODE (type) == TYPE_CODE_ENUM
226  || TYPE_CODE (type) == TYPE_CODE_STRUCT
227  || TYPE_CODE (type) == TYPE_CODE_UNION));
228  if (is_anon)
229  {
230  struct type *last = otype;
231 
232  /* Find the last typedef for the type. */
233  while (TYPE_TARGET_TYPE (last) != NULL
234  && (TYPE_CODE (TYPE_TARGET_TYPE (last))
235  == TYPE_CODE_TYPEDEF))
236  last = TYPE_TARGET_TYPE (last);
237 
238  /* If there is only one typedef for this anonymous type,
239  do not substitute it. */
240  if (type == otype)
241  return 0;
242  else
243  /* Use the last typedef seen as the type for this
244  anonymous type. */
245  type = last;
246  }
247 
248  buf = mem_fileopen ();
249  TRY
250  {
251  type_print (type, "", buf, -1);
252  }
253 
254  /* If type_print threw an exception, there is little point
255  in continuing, so just bow out gracefully. */
256  CATCH (except, RETURN_MASK_ERROR)
257  {
258  ui_file_delete (buf);
259  return 0;
260  }
261  END_CATCH
262 
263  name = ui_file_obsavestring (buf, &info->obstack, &len);
264  ui_file_delete (buf);
265 
266  /* Turn the result into a new tree. Note that this
267  tree will contain pointers into NAME, so NAME cannot
268  be free'd until all typedef conversion is done and
269  the final result is converted into a string. */
270  i = cp_demangled_name_to_comp (name, NULL);
271  if (i != NULL)
272  {
273  /* Merge the two trees. */
274  cp_merge_demangle_parse_infos (info, ret_comp, i);
275 
276  /* Replace any newly introduced typedefs -- but not
277  if the type is anonymous (that would lead to infinite
278  looping). */
279  if (!is_anon)
280  replace_typedefs (info, ret_comp, finder, data);
281  }
282  else
283  {
284  /* This shouldn't happen unless the type printer has
285  output something that the name parser cannot grok.
286  Nonetheless, an ounce of prevention...
287 
288  Canonicalize the name again, and store it in the
289  current node (RET_COMP). */
290  char *canon = cp_canonicalize_string_no_typedefs (name);
291 
292  if (canon != NULL)
293  {
294  /* Copy the canonicalization into the obstack and
295  free CANON. */
296  name = copy_string_to_obstack (&info->obstack, canon, &len);
297  xfree (canon);
298  }
299 
300  ret_comp->u.s_name.s = name;
301  ret_comp->u.s_name.len = len;
302  }
303 
304  return 1;
305  }
306  }
307 
308  return 0;
309 }
310 
311 /* Replace any typedefs appearing in the qualified name
312  (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
313  given in INFO. */
314 
315 static void
317  struct demangle_component *ret_comp,
318  canonicalization_ftype *finder,
319  void *data)
320 {
321  long len;
322  char *name;
323  struct ui_file *buf = mem_fileopen ();
324  struct demangle_component *comp = ret_comp;
325 
326  /* Walk each node of the qualified name, reconstructing the name of
327  this element. With every node, check for any typedef substitutions.
328  If a substitution has occurred, replace the qualified name node
329  with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
330  substituted name. */
331  while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME)
332  {
333  if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME)
334  {
335  struct demangle_component newobj;
336 
337  ui_file_write (buf, d_left (comp)->u.s_name.s,
338  d_left (comp)->u.s_name.len);
339  name = ui_file_obsavestring (buf, &info->obstack, &len);
340  newobj.type = DEMANGLE_COMPONENT_NAME;
341  newobj.u.s_name.s = name;
342  newobj.u.s_name.len = len;
343  if (inspect_type (info, &newobj, finder, data))
344  {
345  char *n, *s;
346  long slen;
347 
348  /* A typedef was substituted in NEW. Convert it to a
349  string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
350  node. */
351 
352  ui_file_rewind (buf);
353  n = cp_comp_to_string (&newobj, 100);
354  if (n == NULL)
355  {
356  /* If something went astray, abort typedef substitutions. */
357  ui_file_delete (buf);
358  return;
359  }
360 
361  s = copy_string_to_obstack (&info->obstack, n, &slen);
362  xfree (n);
363 
364  d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME;
365  d_left (ret_comp)->u.s_name.s = s;
366  d_left (ret_comp)->u.s_name.len = slen;
367  d_right (ret_comp) = d_right (comp);
368  comp = ret_comp;
369  continue;
370  }
371  }
372  else
373  {
374  /* The current node is not a name, so simply replace any
375  typedefs in it. Then print it to the stream to continue
376  checking for more typedefs in the tree. */
377  replace_typedefs (info, d_left (comp), finder, data);
378  name = cp_comp_to_string (d_left (comp), 100);
379  if (name == NULL)
380  {
381  /* If something went astray, abort typedef substitutions. */
382  ui_file_delete (buf);
383  return;
384  }
385  fputs_unfiltered (name, buf);
386  xfree (name);
387  }
388 
389  ui_file_write (buf, "::", 2);
390  comp = d_right (comp);
391  }
392 
393  /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
394  name assembled above and append the name given by COMP. Then use this
395  reassembled name to check for a typedef. */
396 
397  if (comp->type == DEMANGLE_COMPONENT_NAME)
398  {
399  ui_file_write (buf, comp->u.s_name.s, comp->u.s_name.len);
400  name = ui_file_obsavestring (buf, &info->obstack, &len);
401 
402  /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
403  with a DEMANGLE_COMPONENT_NAME node containing the whole
404  name. */
405  ret_comp->type = DEMANGLE_COMPONENT_NAME;
406  ret_comp->u.s_name.s = name;
407  ret_comp->u.s_name.len = len;
408  inspect_type (info, ret_comp, finder, data);
409  }
410  else
411  replace_typedefs (info, comp, finder, data);
412 
413  ui_file_delete (buf);
414 }
415 
416 
417 /* A function to check const and volatile qualifiers for argument types.
418 
419  "Parameter declarations that differ only in the presence
420  or absence of `const' and/or `volatile' are equivalent."
421  C++ Standard N3290, clause 13.1.3 #4. */
422 
423 static void
424 check_cv_qualifiers (struct demangle_component *ret_comp)
425 {
426  while (d_left (ret_comp) != NULL
427  && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST
428  || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE))
429  {
430  d_left (ret_comp) = d_left (d_left (ret_comp));
431  }
432 }
433 
434 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
435  their basic types. */
436 
437 static void
439  struct demangle_component *ret_comp,
440  canonicalization_ftype *finder,
441  void *data)
442 {
443  if (ret_comp)
444  {
445  if (finder != NULL
446  && (ret_comp->type == DEMANGLE_COMPONENT_NAME
447  || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
448  || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE
449  || ret_comp->type == DEMANGLE_COMPONENT_BUILTIN_TYPE))
450  {
451  char *local_name = cp_comp_to_string (ret_comp, 10);
452 
453  if (local_name != NULL)
454  {
455  struct symbol *sym = NULL;
456 
457  sym = NULL;
458  TRY
459  {
460  sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0);
461  }
462  CATCH (except, RETURN_MASK_ALL)
463  {
464  }
465  END_CATCH
466 
467  xfree (local_name);
468 
469  if (sym != NULL)
470  {
471  struct type *otype = SYMBOL_TYPE (sym);
472  const char *new_name = (*finder) (otype, data);
473 
474  if (new_name != NULL)
475  {
476  ret_comp->type = DEMANGLE_COMPONENT_NAME;
477  ret_comp->u.s_name.s = new_name;
478  ret_comp->u.s_name.len = strlen (new_name);
479  return;
480  }
481  }
482  }
483  }
484 
485  switch (ret_comp->type)
486  {
487  case DEMANGLE_COMPONENT_ARGLIST:
488  check_cv_qualifiers (ret_comp);
489  /* Fall through */
490 
491  case DEMANGLE_COMPONENT_FUNCTION_TYPE:
492  case DEMANGLE_COMPONENT_TEMPLATE:
493  case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
494  case DEMANGLE_COMPONENT_TYPED_NAME:
495  replace_typedefs (info, d_left (ret_comp), finder, data);
496  replace_typedefs (info, d_right (ret_comp), finder, data);
497  break;
498 
499  case DEMANGLE_COMPONENT_NAME:
500  inspect_type (info, ret_comp, finder, data);
501  break;
502 
503  case DEMANGLE_COMPONENT_QUAL_NAME:
504  replace_typedefs_qualified_name (info, ret_comp, finder, data);
505  break;
506 
507  case DEMANGLE_COMPONENT_LOCAL_NAME:
508  case DEMANGLE_COMPONENT_CTOR:
509  case DEMANGLE_COMPONENT_ARRAY_TYPE:
510  case DEMANGLE_COMPONENT_PTRMEM_TYPE:
511  replace_typedefs (info, d_right (ret_comp), finder, data);
512  break;
513 
514  case DEMANGLE_COMPONENT_CONST:
515  case DEMANGLE_COMPONENT_RESTRICT:
516  case DEMANGLE_COMPONENT_VOLATILE:
517  case DEMANGLE_COMPONENT_VOLATILE_THIS:
518  case DEMANGLE_COMPONENT_CONST_THIS:
519  case DEMANGLE_COMPONENT_RESTRICT_THIS:
520  case DEMANGLE_COMPONENT_POINTER:
521  case DEMANGLE_COMPONENT_REFERENCE:
522  replace_typedefs (info, d_left (ret_comp), finder, data);
523  break;
524 
525  default:
526  break;
527  }
528  }
529 }
530 
531 /* Parse STRING and convert it to canonical form, resolving any typedefs.
532  If parsing fails, or if STRING is already canonical, return NULL.
533  Otherwise return the canonical form. The return value is allocated via
534  xmalloc. If FINDER is not NULL, then type components are passed to
535  FINDER to be looked up. DATA is passed verbatim to FINDER. */
536 
537 char *
538 cp_canonicalize_string_full (const char *string,
539  canonicalization_ftype *finder,
540  void *data)
541 {
542  char *ret;
543  unsigned int estimated_len;
544  struct demangle_parse_info *info;
545 
546  ret = NULL;
547  estimated_len = strlen (string) * 2;
548  info = cp_demangled_name_to_comp (string, NULL);
549  if (info != NULL)
550  {
551  /* Replace all the typedefs in the tree. */
552  replace_typedefs (info, info->tree, finder, data);
553 
554  /* Convert the tree back into a string. */
555  ret = cp_comp_to_string (info->tree, estimated_len);
556  gdb_assert (ret != NULL);
557 
558  /* Free the parse information. */
560 
561  /* Finally, compare the original string with the computed
562  name, returning NULL if they are the same. */
563  if (strcmp (string, ret) == 0)
564  {
565  xfree (ret);
566  return NULL;
567  }
568  }
569 
570  return ret;
571 }
572 
573 /* Like cp_canonicalize_string_full, but always passes NULL for
574  FINDER. */
575 
576 char *
578 {
579  return cp_canonicalize_string_full (string, NULL, NULL);
580 }
581 
582 /* Parse STRING and convert it to canonical form. If parsing fails,
583  or if STRING is already canonical, return NULL. Otherwise return
584  the canonical form. The return value is allocated via xmalloc. */
585 
586 char *
587 cp_canonicalize_string (const char *string)
588 {
589  struct demangle_parse_info *info;
590  unsigned int estimated_len;
591  char *ret;
592 
593  if (cp_already_canonical (string))
594  return NULL;
595 
596  info = cp_demangled_name_to_comp (string, NULL);
597  if (info == NULL)
598  return NULL;
599 
600  estimated_len = strlen (string) * 2;
601  ret = cp_comp_to_string (info->tree, estimated_len);
603 
604  if (ret == NULL)
605  {
606  warning (_("internal error: string \"%s\" failed to be canonicalized"),
607  string);
608  return NULL;
609  }
610 
611  if (strcmp (string, ret) == 0)
612  {
613  xfree (ret);
614  return NULL;
615  }
616 
617  return ret;
618 }
619 
620 /* Convert a mangled name to a demangle_component tree. *MEMORY is
621  set to the block of used memory that should be freed when finished
622  with the tree. DEMANGLED_P is set to the char * that should be
623  freed when finished with the tree, or NULL if none was needed.
624  OPTIONS will be passed to the demangler. */
625 
626 static struct demangle_parse_info *
627 mangled_name_to_comp (const char *mangled_name, int options,
628  void **memory, char **demangled_p)
629 {
630  char *demangled_name;
631  struct demangle_parse_info *info;
632 
633  /* If it looks like a v3 mangled name, then try to go directly
634  to trees. */
635  if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
636  {
637  struct demangle_component *ret;
638 
639  ret = cplus_demangle_v3_components (mangled_name,
640  options, memory);
641  if (ret)
642  {
643  info = cp_new_demangle_parse_info ();
644  info->tree = ret;
645  *demangled_p = NULL;
646  return info;
647  }
648  }
649 
650  /* If it doesn't, or if that failed, then try to demangle the
651  name. */
652  demangled_name = gdb_demangle (mangled_name, options);
653  if (demangled_name == NULL)
654  return NULL;
655 
656  /* If we could demangle the name, parse it to build the component
657  tree. */
658  info = cp_demangled_name_to_comp (demangled_name, NULL);
659 
660  if (info == NULL)
661  {
662  xfree (demangled_name);
663  return NULL;
664  }
665 
666  *demangled_p = demangled_name;
667  return info;
668 }
669 
670 /* Return the name of the class containing method PHYSNAME. */
671 
672 char *
673 cp_class_name_from_physname (const char *physname)
674 {
675  void *storage = NULL;
676  char *demangled_name = NULL, *ret;
677  struct demangle_component *ret_comp, *prev_comp, *cur_comp;
678  struct demangle_parse_info *info;
679  int done;
680 
681  info = mangled_name_to_comp (physname, DMGL_ANSI,
682  &storage, &demangled_name);
683  if (info == NULL)
684  return NULL;
685 
686  done = 0;
687  ret_comp = info->tree;
688 
689  /* First strip off any qualifiers, if we have a function or
690  method. */
691  while (!done)
692  switch (ret_comp->type)
693  {
694  case DEMANGLE_COMPONENT_CONST:
695  case DEMANGLE_COMPONENT_RESTRICT:
696  case DEMANGLE_COMPONENT_VOLATILE:
697  case DEMANGLE_COMPONENT_CONST_THIS:
698  case DEMANGLE_COMPONENT_RESTRICT_THIS:
699  case DEMANGLE_COMPONENT_VOLATILE_THIS:
700  case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
701  ret_comp = d_left (ret_comp);
702  break;
703  default:
704  done = 1;
705  break;
706  }
707 
708  /* If what we have now is a function, discard the argument list. */
709  if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
710  ret_comp = d_left (ret_comp);
711 
712  /* If what we have now is a template, strip off the template
713  arguments. The left subtree may be a qualified name. */
714  if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
715  ret_comp = d_left (ret_comp);
716 
717  /* What we have now should be a name, possibly qualified.
718  Additional qualifiers could live in the left subtree or the right
719  subtree. Find the last piece. */
720  done = 0;
721  prev_comp = NULL;
722  cur_comp = ret_comp;
723  while (!done)
724  switch (cur_comp->type)
725  {
726  case DEMANGLE_COMPONENT_QUAL_NAME:
727  case DEMANGLE_COMPONENT_LOCAL_NAME:
728  prev_comp = cur_comp;
729  cur_comp = d_right (cur_comp);
730  break;
731  case DEMANGLE_COMPONENT_TEMPLATE:
732  case DEMANGLE_COMPONENT_NAME:
733  case DEMANGLE_COMPONENT_CTOR:
734  case DEMANGLE_COMPONENT_DTOR:
735  case DEMANGLE_COMPONENT_OPERATOR:
736  case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
737  done = 1;
738  break;
739  default:
740  done = 1;
741  cur_comp = NULL;
742  break;
743  }
744 
745  ret = NULL;
746  if (cur_comp != NULL && prev_comp != NULL)
747  {
748  /* We want to discard the rightmost child of PREV_COMP. */
749  *prev_comp = *d_left (prev_comp);
750  /* The ten is completely arbitrary; we don't have a good
751  estimate. */
752  ret = cp_comp_to_string (ret_comp, 10);
753  }
754 
755  xfree (storage);
756  xfree (demangled_name);
758  return ret;
759 }
760 
761 /* Return the child of COMP which is the basename of a method,
762  variable, et cetera. All scope qualifiers are discarded, but
763  template arguments will be included. The component tree may be
764  modified. */
765 
766 static struct demangle_component *
767 unqualified_name_from_comp (struct demangle_component *comp)
768 {
769  struct demangle_component *ret_comp = comp, *last_template;
770  int done;
771 
772  done = 0;
773  last_template = NULL;
774  while (!done)
775  switch (ret_comp->type)
776  {
777  case DEMANGLE_COMPONENT_QUAL_NAME:
778  case DEMANGLE_COMPONENT_LOCAL_NAME:
779  ret_comp = d_right (ret_comp);
780  break;
781  case DEMANGLE_COMPONENT_TYPED_NAME:
782  ret_comp = d_left (ret_comp);
783  break;
784  case DEMANGLE_COMPONENT_TEMPLATE:
785  gdb_assert (last_template == NULL);
786  last_template = ret_comp;
787  ret_comp = d_left (ret_comp);
788  break;
789  case DEMANGLE_COMPONENT_CONST:
790  case DEMANGLE_COMPONENT_RESTRICT:
791  case DEMANGLE_COMPONENT_VOLATILE:
792  case DEMANGLE_COMPONENT_CONST_THIS:
793  case DEMANGLE_COMPONENT_RESTRICT_THIS:
794  case DEMANGLE_COMPONENT_VOLATILE_THIS:
795  case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
796  ret_comp = d_left (ret_comp);
797  break;
798  case DEMANGLE_COMPONENT_NAME:
799  case DEMANGLE_COMPONENT_CTOR:
800  case DEMANGLE_COMPONENT_DTOR:
801  case DEMANGLE_COMPONENT_OPERATOR:
802  case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
803  done = 1;
804  break;
805  default:
806  return NULL;
807  break;
808  }
809 
810  if (last_template)
811  {
812  d_left (last_template) = ret_comp;
813  return last_template;
814  }
815 
816  return ret_comp;
817 }
818 
819 /* Return the name of the method whose linkage name is PHYSNAME. */
820 
821 char *
822 method_name_from_physname (const char *physname)
823 {
824  void *storage = NULL;
825  char *demangled_name = NULL, *ret;
826  struct demangle_component *ret_comp;
827  struct demangle_parse_info *info;
828 
829  info = mangled_name_to_comp (physname, DMGL_ANSI,
830  &storage, &demangled_name);
831  if (info == NULL)
832  return NULL;
833 
834  ret_comp = unqualified_name_from_comp (info->tree);
835 
836  ret = NULL;
837  if (ret_comp != NULL)
838  /* The ten is completely arbitrary; we don't have a good
839  estimate. */
840  ret = cp_comp_to_string (ret_comp, 10);
841 
842  xfree (storage);
843  xfree (demangled_name);
845  return ret;
846 }
847 
848 /* If FULL_NAME is the demangled name of a C++ function (including an
849  arg list, possibly including namespace/class qualifications),
850  return a new string containing only the function name (without the
851  arg list/class qualifications). Otherwise, return NULL. The
852  caller is responsible for freeing the memory in question. */
853 
854 char *
855 cp_func_name (const char *full_name)
856 {
857  char *ret;
858  struct demangle_component *ret_comp;
859  struct demangle_parse_info *info;
860 
861  info = cp_demangled_name_to_comp (full_name, NULL);
862  if (!info)
863  return NULL;
864 
865  ret_comp = unqualified_name_from_comp (info->tree);
866 
867  ret = NULL;
868  if (ret_comp != NULL)
869  ret = cp_comp_to_string (ret_comp, 10);
870 
872  return ret;
873 }
874 
875 /* DEMANGLED_NAME is the name of a function, including parameters and
876  (optionally) a return type. Return the name of the function without
877  parameters or return type, or NULL if we can not parse the name. */
878 
879 char *
880 cp_remove_params (const char *demangled_name)
881 {
882  int done = 0;
883  struct demangle_component *ret_comp;
884  struct demangle_parse_info *info;
885  char *ret = NULL;
886 
887  if (demangled_name == NULL)
888  return NULL;
889 
890  info = cp_demangled_name_to_comp (demangled_name, NULL);
891  if (info == NULL)
892  return NULL;
893 
894  /* First strip off any qualifiers, if we have a function or method. */
895  ret_comp = info->tree;
896  while (!done)
897  switch (ret_comp->type)
898  {
899  case DEMANGLE_COMPONENT_CONST:
900  case DEMANGLE_COMPONENT_RESTRICT:
901  case DEMANGLE_COMPONENT_VOLATILE:
902  case DEMANGLE_COMPONENT_CONST_THIS:
903  case DEMANGLE_COMPONENT_RESTRICT_THIS:
904  case DEMANGLE_COMPONENT_VOLATILE_THIS:
905  case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
906  ret_comp = d_left (ret_comp);
907  break;
908  default:
909  done = 1;
910  break;
911  }
912 
913  /* What we have now should be a function. Return its name. */
914  if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
915  ret = cp_comp_to_string (d_left (ret_comp), 10);
916 
918  return ret;
919 }
920 
921 /* Here are some random pieces of trivia to keep in mind while trying
922  to take apart demangled names:
923 
924  - Names can contain function arguments or templates, so the process
925  has to be, to some extent recursive: maybe keep track of your
926  depth based on encountering <> and ().
927 
928  - Parentheses don't just have to happen at the end of a name: they
929  can occur even if the name in question isn't a function, because
930  a template argument might be a type that's a function.
931 
932  - Conversely, even if you're trying to deal with a function, its
933  demangled name might not end with ')': it could be a const or
934  volatile class method, in which case it ends with "const" or
935  "volatile".
936 
937  - Parentheses are also used in anonymous namespaces: a variable
938  'foo' in an anonymous namespace gets demangled as "(anonymous
939  namespace)::foo".
940 
941  - And operator names can contain parentheses or angle brackets. */
942 
943 /* FIXME: carlton/2003-03-13: We have several functions here with
944  overlapping functionality; can we combine them? Also, do they
945  handle all the above considerations correctly? */
946 
947 
948 /* This returns the length of first component of NAME, which should be
949  the demangled name of a C++ variable/function/method/etc.
950  Specifically, it returns the index of the first colon forming the
951  boundary of the first component: so, given 'A::foo' or 'A::B::foo'
952  it returns the 1, and given 'foo', it returns 0. */
953 
954 /* The character in NAME indexed by the return value is guaranteed to
955  always be either ':' or '\0'. */
956 
957 /* NOTE: carlton/2003-03-13: This function is currently only intended
958  for internal use: it's probably not entirely safe when called on
959  user-generated input, because some of the 'index += 2' lines in
960  cp_find_first_component_aux might go past the end of malformed
961  input. */
962 
963 unsigned int
965 {
966  return cp_find_first_component_aux (name, 0);
967 }
968 
969 /* Helper function for cp_find_first_component. Like that function,
970  it returns the length of the first component of NAME, but to make
971  the recursion easier, it also stops if it reaches an unexpected ')'
972  or '>' if the value of PERMISSIVE is nonzero. */
973 
974 /* Let's optimize away calls to strlen("operator"). */
975 
976 #define LENGTH_OF_OPERATOR 8
977 
978 static unsigned int
979 cp_find_first_component_aux (const char *name, int permissive)
980 {
981  unsigned int index = 0;
982  /* Operator names can show up in unexpected places. Since these can
983  contain parentheses or angle brackets, they can screw up the
984  recursion. But not every string 'operator' is part of an
985  operater name: e.g. you could have a variable 'cooperator'. So
986  this variable tells us whether or not we should treat the string
987  'operator' as starting an operator. */
988  int operator_possible = 1;
989 
990  for (;; ++index)
991  {
992  switch (name[index])
993  {
994  case '<':
995  /* Template; eat it up. The calls to cp_first_component
996  should only return (I hope!) when they reach the '>'
997  terminating the component or a '::' between two
998  components. (Hence the '+ 2'.) */
999  index += 1;
1000  for (index += cp_find_first_component_aux (name + index, 1);
1001  name[index] != '>';
1002  index += cp_find_first_component_aux (name + index, 1))
1003  {
1004  if (name[index] != ':')
1005  {
1006  demangled_name_complaint (name);
1007  return strlen (name);
1008  }
1009  index += 2;
1010  }
1011  operator_possible = 1;
1012  break;
1013  case '(':
1014  /* Similar comment as to '<'. */
1015  index += 1;
1016  for (index += cp_find_first_component_aux (name + index, 1);
1017  name[index] != ')';
1018  index += cp_find_first_component_aux (name + index, 1))
1019  {
1020  if (name[index] != ':')
1021  {
1022  demangled_name_complaint (name);
1023  return strlen (name);
1024  }
1025  index += 2;
1026  }
1027  operator_possible = 1;
1028  break;
1029  case '>':
1030  case ')':
1031  if (permissive)
1032  return index;
1033  else
1034  {
1035  demangled_name_complaint (name);
1036  return strlen (name);
1037  }
1038  case '\0':
1039  case ':':
1040  return index;
1041  case 'o':
1042  /* Operator names can screw up the recursion. */
1043  if (operator_possible
1044  && strncmp (name + index, "operator",
1045  LENGTH_OF_OPERATOR) == 0)
1046  {
1047  index += LENGTH_OF_OPERATOR;
1048  while (ISSPACE(name[index]))
1049  ++index;
1050  switch (name[index])
1051  {
1052  /* Skip over one less than the appropriate number of
1053  characters: the for loop will skip over the last
1054  one. */
1055  case '<':
1056  if (name[index + 1] == '<')
1057  index += 1;
1058  else
1059  index += 0;
1060  break;
1061  case '>':
1062  case '-':
1063  if (name[index + 1] == '>')
1064  index += 1;
1065  else
1066  index += 0;
1067  break;
1068  case '(':
1069  index += 1;
1070  break;
1071  default:
1072  index += 0;
1073  break;
1074  }
1075  }
1076  operator_possible = 0;
1077  break;
1078  case ' ':
1079  case ',':
1080  case '.':
1081  case '&':
1082  case '*':
1083  /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1084  set of relevant characters are here: it's necessary to
1085  include any character that can show up before 'operator'
1086  in a demangled name, and it's safe to include any
1087  character that can't be part of an identifier's name. */
1088  operator_possible = 1;
1089  break;
1090  default:
1091  operator_possible = 0;
1092  break;
1093  }
1094  }
1095 }
1096 
1097 /* Complain about a demangled name that we don't know how to parse.
1098  NAME is the demangled name in question. */
1099 
1100 static void
1102 {
1104  "unexpected demangled name '%s'", name);
1105 }
1106 
1107 /* If NAME is the fully-qualified name of a C++
1108  function/variable/method/etc., this returns the length of its
1109  entire prefix: all of the namespaces and classes that make up its
1110  name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1111  4, given 'foo', it returns 0. */
1112 
1113 unsigned int
1115 {
1116  unsigned int current_len = cp_find_first_component (name);
1117  unsigned int previous_len = 0;
1118 
1119  while (name[current_len] != '\0')
1120  {
1121  gdb_assert (name[current_len] == ':');
1122  previous_len = current_len;
1123  /* Skip the '::'. */
1124  current_len += 2;
1125  current_len += cp_find_first_component (name + current_len);
1126  }
1127 
1128  return previous_len;
1129 }
1130 
1131 /* Overload resolution functions. */
1132 
1133 /* Test to see if SYM is a symbol that we haven't seen corresponding
1134  to a function named OLOAD_NAME. If so, add it to the current
1135  completion list. */
1136 
1137 static void
1139  const char *oload_name)
1140 {
1141  int newsize;
1142  int i;
1143  char *sym_name;
1144 
1145  /* If there is no type information, we can't do anything, so
1146  skip. */
1147  if (SYMBOL_TYPE (sym) == NULL)
1148  return;
1149 
1150  /* skip any symbols that we've already considered. */
1151  for (i = 0; i < sym_return_val_index; ++i)
1152  if (strcmp (SYMBOL_LINKAGE_NAME (sym),
1153  SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
1154  return;
1155 
1156  /* Get the demangled name without parameters */
1157  sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
1158  if (!sym_name)
1159  return;
1160 
1161  /* skip symbols that cannot match */
1162  if (strcmp (sym_name, oload_name) != 0)
1163  {
1164  xfree (sym_name);
1165  return;
1166  }
1167 
1168  xfree (sym_name);
1169 
1170  /* We have a match for an overload instance, so add SYM to the
1171  current list of overload instances */
1172  if (sym_return_val_index + 3 > sym_return_val_size)
1173  {
1174  newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
1175  sym_return_val = (struct symbol **)
1176  xrealloc ((char *) sym_return_val, newsize);
1177  }
1178  sym_return_val[sym_return_val_index++] = sym;
1179  sym_return_val[sym_return_val_index] = NULL;
1180 }
1181 
1182 /* Return a null-terminated list of pointers to function symbols that
1183  are named FUNC_NAME and are visible within NAMESPACE. */
1184 
1185 struct symbol **
1186 make_symbol_overload_list (const char *func_name,
1187  const char *the_namespace)
1188 {
1189  struct cleanup *old_cleanups;
1190  const char *name;
1191 
1192  sym_return_val_size = 100;
1194  sym_return_val = xmalloc ((sym_return_val_size + 1) *
1195  sizeof (struct symbol *));
1196  sym_return_val[0] = NULL;
1197 
1198  old_cleanups = make_cleanup (xfree, sym_return_val);
1199 
1200  make_symbol_overload_list_using (func_name, the_namespace);
1201 
1202  if (the_namespace[0] == '\0')
1203  name = func_name;
1204  else
1205  {
1206  char *concatenated_name
1207  = alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1208  strcpy (concatenated_name, the_namespace);
1209  strcat (concatenated_name, "::");
1210  strcat (concatenated_name, func_name);
1211  name = concatenated_name;
1212  }
1213 
1215 
1216  discard_cleanups (old_cleanups);
1217 
1218  return sym_return_val;
1219 }
1220 
1221 /* Add all symbols with a name matching NAME in BLOCK to the overload
1222  list. */
1223 
1224 static void
1226  const struct block *block)
1227 {
1228  struct block_iterator iter;
1229  struct symbol *sym;
1230 
1231  ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
1232  overload_list_add_symbol (sym, name);
1233 }
1234 
1235 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1236 
1237 static void
1239  const char *the_namespace)
1240 {
1241  const char *name;
1242  const struct block *block = NULL;
1243 
1244  if (the_namespace[0] == '\0')
1245  name = func_name;
1246  else
1247  {
1248  char *concatenated_name
1249  = alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1250 
1251  strcpy (concatenated_name, the_namespace);
1252  strcat (concatenated_name, "::");
1253  strcat (concatenated_name, func_name);
1254  name = concatenated_name;
1255  }
1256 
1257  /* Look in the static block. */
1258  block = block_static_block (get_selected_block (0));
1259  if (block)
1260  make_symbol_overload_list_block (name, block);
1261 
1262  /* Look in the global block. */
1263  block = block_global_block (block);
1264  if (block)
1265  make_symbol_overload_list_block (name, block);
1266 
1267 }
1268 
1269 /* Search the namespace of the given type and namespace of and public
1270  base types. */
1271 
1272 static void
1274  const char *func_name)
1275 {
1276  char *the_namespace;
1277  const char *type_name;
1278  int i, prefix_len;
1279 
1280  while (TYPE_CODE (type) == TYPE_CODE_PTR
1281  || TYPE_CODE (type) == TYPE_CODE_REF
1282  || TYPE_CODE (type) == TYPE_CODE_ARRAY
1283  || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1284  {
1285  if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1286  type = check_typedef(type);
1287  else
1288  type = TYPE_TARGET_TYPE (type);
1289  }
1290 
1291  type_name = TYPE_NAME (type);
1292 
1293  if (type_name == NULL)
1294  return;
1295 
1296  prefix_len = cp_entire_prefix_len (type_name);
1297 
1298  if (prefix_len != 0)
1299  {
1300  the_namespace = alloca (prefix_len + 1);
1301  strncpy (the_namespace, type_name, prefix_len);
1302  the_namespace[prefix_len] = '\0';
1303 
1304  make_symbol_overload_list_namespace (func_name, the_namespace);
1305  }
1306 
1307  /* Check public base type */
1308  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1309  for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1310  {
1311  if (BASETYPE_VIA_PUBLIC (type, i))
1313  i),
1314  func_name);
1315  }
1316 }
1317 
1318 /* Adds the overload list overload candidates for FUNC_NAME found
1319  through argument dependent lookup. */
1320 
1321 struct symbol **
1322 make_symbol_overload_list_adl (struct type **arg_types, int nargs,
1323  const char *func_name)
1324 {
1325  int i;
1326 
1328 
1329  for (i = 1; i <= nargs; i++)
1330  make_symbol_overload_list_adl_namespace (arg_types[i - 1],
1331  func_name);
1332 
1333  return sym_return_val;
1334 }
1335 
1336 /* Used for cleanups to reset the "searched" flag in case of an
1337  error. */
1338 
1339 static void
1341 {
1342  struct using_direct *direct = data;
1343  direct->searched = 0;
1344 }
1345 
1346 /* This applies the using directives to add namespaces to search in,
1347  and then searches for overloads in all of those namespaces. It
1348  adds the symbols found to sym_return_val. Arguments are as in
1349  make_symbol_overload_list. */
1350 
1351 static void
1352 make_symbol_overload_list_using (const char *func_name,
1353  const char *the_namespace)
1354 {
1355  struct using_direct *current;
1356  const struct block *block;
1357 
1358  /* First, go through the using directives. If any of them apply,
1359  look in the appropriate namespaces for new functions to match
1360  on. */
1361 
1362  for (block = get_selected_block (0);
1363  block != NULL;
1364  block = BLOCK_SUPERBLOCK (block))
1365  for (current = block_using (block);
1366  current != NULL;
1367  current = current->next)
1368  {
1369  /* Prevent recursive calls. */
1370  if (current->searched)
1371  continue;
1372 
1373  /* If this is a namespace alias or imported declaration ignore
1374  it. */
1375  if (current->alias != NULL || current->declaration != NULL)
1376  continue;
1377 
1378  if (strcmp (the_namespace, current->import_dest) == 0)
1379  {
1380  /* Mark this import as searched so that the recursive call
1381  does not search it again. */
1382  struct cleanup *old_chain;
1383  current->searched = 1;
1385  current);
1386 
1388  current->import_src);
1389 
1390  current->searched = 0;
1391  discard_cleanups (old_chain);
1392  }
1393  }
1394 
1395  /* Now, add names for this namespace. */
1396  make_symbol_overload_list_namespace (func_name, the_namespace);
1397 }
1398 
1399 /* This does the bulk of the work of finding overloaded symbols.
1400  FUNC_NAME is the name of the overloaded function we're looking for
1401  (possibly including namespace info). */
1402 
1403 static void
1405 {
1406  struct compunit_symtab *cust;
1407  struct objfile *objfile;
1408  const struct block *b, *surrounding_static_block = 0;
1409 
1410  /* Look through the partial symtabs for all symbols which begin by
1411  matching FUNC_NAME. Make sure we read that symbol table in. */
1412 
1413  ALL_OBJFILES (objfile)
1414  {
1415  if (objfile->sf)
1416  objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
1417  }
1418 
1419  /* Search upwards from currently selected frame (so that we can
1420  complete on local vars. */
1421 
1422  for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1423  make_symbol_overload_list_block (func_name, b);
1424 
1425  surrounding_static_block = block_static_block (get_selected_block (0));
1426 
1427  /* Go through the symtabs and check the externs and statics for
1428  symbols which match. */
1429 
1430  ALL_COMPUNITS (objfile, cust)
1431  {
1432  QUIT;
1434  make_symbol_overload_list_block (func_name, b);
1435  }
1436 
1437  ALL_COMPUNITS (objfile, cust)
1438  {
1439  QUIT;
1441  /* Don't do this block twice. */
1442  if (b == surrounding_static_block)
1443  continue;
1444  make_symbol_overload_list_block (func_name, b);
1445  }
1446 }
1447 
1448 /* Lookup the rtti type for a class name. */
1449 
1450 struct type *
1451 cp_lookup_rtti_type (const char *name, struct block *block)
1452 {
1453  struct symbol * rtti_sym;
1454  struct type * rtti_type;
1455 
1456  /* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
1457  Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
1458  rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL);
1459 
1460  if (rtti_sym == NULL)
1461  {
1462  warning (_("RTTI symbol not found for class '%s'"), name);
1463  return NULL;
1464  }
1465 
1466  if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1467  {
1468  warning (_("RTTI symbol for class '%s' is not a type"), name);
1469  return NULL;
1470  }
1471 
1472  rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym));
1473 
1474  switch (TYPE_CODE (rtti_type))
1475  {
1476  case TYPE_CODE_STRUCT:
1477  break;
1478  case TYPE_CODE_NAMESPACE:
1479  /* chastain/2003-11-26: the symbol tables often contain fake
1480  symbols for namespaces with the same name as the struct.
1481  This warning is an indication of a bug in the lookup order
1482  or a bug in the way that the symbol tables are populated. */
1483  warning (_("RTTI symbol for class '%s' is a namespace"), name);
1484  return NULL;
1485  default:
1486  warning (_("RTTI symbol for class '%s' has bad type"), name);
1487  return NULL;
1488  }
1489 
1490  return rtti_type;
1491 }
1492 
1493 #ifdef HAVE_WORKING_FORK
1494 
1495 /* If nonzero, attempt to catch crashes in the demangler and print
1496  useful debugging information. */
1497 
1499 
1500 /* Stack context and environment for demangler crash recovery. */
1501 
1503 
1504 /* If nonzero, attempt to dump core from the signal handler. */
1505 
1507 
1508 /* Signal handler for gdb_demangle. */
1509 
1510 static void
1512 {
1514  {
1515  if (fork () == 0)
1516  dump_core ();
1517 
1519  }
1520 
1522 }
1523 
1524 #endif
1525 
1526 /* A wrapper for bfd_demangle. */
1527 
1528 char *
1529 gdb_demangle (const char *name, int options)
1530 {
1531  char *result = NULL;
1532  int crash_signal = 0;
1533 
1534 #ifdef HAVE_WORKING_FORK
1535 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1536  struct sigaction sa, old_sa;
1537 #else
1538  void (*ofunc) ();
1539 #endif
1540  static int core_dump_allowed = -1;
1541 
1542  if (core_dump_allowed == -1)
1543  {
1544  core_dump_allowed = can_dump_core (LIMIT_CUR);
1545 
1546  if (!core_dump_allowed)
1548  }
1549 
1551  {
1552 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1553  sa.sa_handler = gdb_demangle_signal_handler;
1554  sigemptyset (&sa.sa_mask);
1555 #ifdef HAVE_SIGALTSTACK
1556  sa.sa_flags = SA_ONSTACK;
1557 #else
1558  sa.sa_flags = 0;
1559 #endif
1560  sigaction (SIGSEGV, &sa, &old_sa);
1561 #else
1562  ofunc = (void (*)()) signal (SIGSEGV, gdb_demangle_signal_handler);
1563 #endif
1564 
1565  crash_signal = SIGSETJMP (gdb_demangle_jmp_buf);
1566  }
1567 #endif
1568 
1569  if (crash_signal == 0)
1570  result = bfd_demangle (NULL, name, options);
1571 
1572 #ifdef HAVE_WORKING_FORK
1574  {
1575 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1576  sigaction (SIGSEGV, &old_sa, NULL);
1577 #else
1578  signal (SIGSEGV, ofunc);
1579 #endif
1580 
1581  if (crash_signal != 0)
1582  {
1583  static int error_reported = 0;
1584 
1585  if (!error_reported)
1586  {
1587  char *short_msg, *long_msg;
1588  struct cleanup *back_to;
1589 
1590  short_msg = xstrprintf (_("unable to demangle '%s' "
1591  "(demangler failed with signal %d)"),
1592  name, crash_signal);
1593  back_to = make_cleanup (xfree, short_msg);
1594 
1595  long_msg = xstrprintf ("%s:%d: %s: %s", __FILE__, __LINE__,
1596  "demangler-warning", short_msg);
1597  make_cleanup (xfree, long_msg);
1598 
1600  begin_line ();
1601  if (core_dump_allowed)
1603  _("%s\nAttempting to dump core.\n"),
1604  long_msg);
1605  else
1606  warn_cant_dump_core (long_msg);
1607 
1608  demangler_warning (__FILE__, __LINE__, "%s", short_msg);
1609 
1610  do_cleanups (back_to);
1611 
1612  error_reported = 1;
1613  }
1614 
1615  result = NULL;
1616  }
1617  }
1618 #endif
1619 
1620  return result;
1621 }
1622 
1623 /* Don't allow just "maintenance cplus". */
1624 
1625 static void
1626 maint_cplus_command (char *arg, int from_tty)
1627 {
1628  printf_unfiltered (_("\"maintenance cplus\" must be followed "
1629  "by the name of a command.\n"));
1630  help_list (maint_cplus_cmd_list,
1631  "maintenance cplus ",
1633 }
1634 
1635 /* This is a front end for cp_find_first_component, for unit testing.
1636  Be careful when using it: see the NOTE above
1637  cp_find_first_component. */
1638 
1639 static void
1640 first_component_command (char *arg, int from_tty)
1641 {
1642  int len;
1643  char *prefix;
1644 
1645  if (!arg)
1646  return;
1647 
1648  len = cp_find_first_component (arg);
1649  prefix = alloca (len + 1);
1650 
1651  memcpy (prefix, arg, len);
1652  prefix[len] = '\0';
1653 
1654  printf_unfiltered ("%s\n", prefix);
1655 }
1656 
1657 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
1658 
1659 
1660 /* Implement "info vtbl". */
1661 
1662 static void
1663 info_vtbl_command (char *arg, int from_tty)
1664 {
1665  struct value *value;
1666 
1667  value = parse_and_eval (arg);
1668  cplus_print_vtable (value);
1669 }
1670 
1671 void
1673 {
1676  _("C++ maintenance commands."),
1677  &maint_cplus_cmd_list,
1678  "maintenance cplus ",
1679  0, &maintenancelist);
1680  add_alias_cmd ("cp", "cplus",
1681  class_maintenance, 1,
1682  &maintenancelist);
1683 
1684  add_cmd ("first_component",
1687  _("Print the first class/namespace component of NAME."),
1688  &maint_cplus_cmd_list);
1689 
1690  add_info ("vtbl", info_vtbl_command,
1691  _("Show the virtual function table for a C++ object.\n\
1692 Usage: info vtbl EXPRESSION\n\
1693 Evaluate EXPRESSION and display the virtual function table for the\n\
1694 resulting object."));
1695 
1696 #ifdef HAVE_WORKING_FORK
1697  add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance,
1699 Set whether to attempt to catch demangler crashes."), _("\
1700 Show whether to attempt to catch demangler crashes."), _("\
1701 If enabled GDB will attempt to catch demangler crashes and\n\
1702 display the offending symbol."),
1703  NULL,
1704  NULL,
1707 #endif
1708 }
void target_terminal_ours(void)
Definition: target.c:491
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 info_vtbl_command(char *arg, int from_tty)
Definition: cp-support.c:1663
static void reset_directive_searched(void *data)
Definition: cp-support.c:1340
static int cp_already_canonical(const char *string)
Definition: cp-support.c:122
#define SIGSETJMP(buf)
Definition: gdb_setjmp.h:30
const char * import_dest
Definition: cp-support.h:129
const char * alias
Definition: cp-support.h:131
static void first_component_command(char *arg, int from_tty)
Definition: cp-support.c:1640
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1327
const char * import_src
Definition: cp-support.h:128
void cp_merge_demangle_parse_infos(struct demangle_parse_info *dest, struct demangle_component *target, struct demangle_parse_info *src)
static struct symbol ** sym_return_val
Definition: cp-support.c:53
static const char *const ignore_typedefs[]
Definition: cp-support.c:73
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
#define LENGTH_OF_OPERATOR
Definition: cp-support.c:976
void xfree(void *)
Definition: common-utils.c:97
static void demangled_name_complaint(const char *name)
Definition: cp-support.c:1101
void warning(const char *fmt,...)
Definition: errors.c:26
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
static void maint_cplus_command(char *arg, int from_tty)
Definition: cp-support.c:1626
const struct block * block_global_block(const struct block *block)
Definition: block.c:380
char * cp_func_name(const char *full_name)
Definition: cp-support.c:855
void ui_file_delete(struct ui_file *file)
Definition: ui-file.c:76
struct ui_file * gdb_stdout
Definition: main.c:71
static int sym_return_val_index
Definition: cp-support.c:52
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
static int sym_return_val_size
Definition: cp-support.c:51
struct demangle_component * tree
Definition: cp-support.h:56
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:360
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:136
struct cleanup * make_cleanup_cp_demangled_name_parse_free(struct demangle_parse_info *info)
Definition: cp-support.c:110
#define _(String)
Definition: gdb_locale.h:40
static unsigned int cp_find_first_component_aux(const char *name, int permissive)
Definition: cp-support.c:979
void demangler_warning(const char *file, int line, const char *string,...)
Definition: utils.c:819
#define END_CATCH
static void replace_typedefs(struct demangle_parse_info *info, struct demangle_component *ret_comp, canonicalization_ftype *finder, void *data)
Definition: cp-support.c:438
struct cmd_list_element * maintenance_set_cmdlist
Definition: maint.c:646
char * method_name_from_physname(const char *physname)
Definition: cp-support.c:822
static void do_demangled_name_parse_free_cleanup(void *data)
Definition: cp-support.c:100
struct demangle_info * info
Definition: cp-support.h:53
char * cp_canonicalize_string_full(const char *string, canonicalization_ftype *finder, void *data)
Definition: cp-support.c:538
struct symbol ** make_symbol_overload_list_adl(struct type **arg_types, int nargs, const char *func_name)
Definition: cp-support.c:1322
static void make_symbol_overload_list_qualified(const char *func_name)
Definition: cp-support.c:1404
#define d_right(dc)
Definition: cp-support.c:40
#define TRY
const char *const name
Definition: aarch64-tdep.c:68
char * gdb_demangle(const char *name, int options)
Definition: cp-support.c:1529
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define CATCH(EXCEPTION, MASK)
static SIGJMP_BUF gdb_demangle_jmp_buf
Definition: cp-support.c:1502
struct type * cp_lookup_rtti_type(const char *name, struct block *block)
Definition: cp-support.c:1451
#define SIGLONGJMP(buf, val)
Definition: gdb_setjmp.h:31
void initialize_file_ftype(void)
Definition: defs.h:281
char * cp_remove_params(const char *demangled_name)
Definition: cp-support.c:880
struct symbol ** make_symbol_overload_list(const char *func_name, const char *the_namespace)
Definition: cp-support.c:1186
char * cp_canonicalize_string_no_typedefs(const char *string)
Definition: cp-support.c:577
unsigned int cp_find_first_component(const char *name)
Definition: cp-support.c:964
char * ui_file_obsavestring(struct ui_file *file, struct obstack *obstack, long *length)
Definition: ui-file.c:368
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
const struct sym_fns * sf
Definition: objfiles.h:347
void complaint(struct complaints **complaints, const char *fmt,...)
Definition: complaints.c:251
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
static void(* ofunc)()
Definition: monitor.c:79
#define ALL_COMPUNITS(objfile, cu)
Definition: objfiles.h:616
struct using_direct * block_using(const struct block *block)
Definition: block.c:324
struct demangle_parse_info * cp_demangled_name_to_comp(const char *demangled_name, const char **errmsg)
Definition: gdbtypes.h:749
struct obstack obstack
Definition: cp-support.h:59
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:119
static struct demangle_component * unqualified_name_from_comp(struct demangle_component *comp)
Definition: cp-support.c:767
struct cmd_list_element * add_info(const char *name, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:857
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
struct cmd_list_element * add_alias_cmd(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:286
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1326
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
void(* expand_symtabs_for_function)(struct objfile *objfile, const char *func_name)
Definition: symfile.h:229
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
#define SIGJMP_BUF
Definition: gdb_setjmp.h:29
static void make_symbol_overload_list_namespace(const char *func_name, const char *the_namespace)
Definition: cp-support.c:1238
char * cp_canonicalize_string(const char *string)
Definition: cp-support.c:587
void * xmalloc(YYSIZE_T)
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
char * cp_comp_to_string(struct demangle_component *result, int estimated_len)
Definition: block.h:60
Definition: value.c:172
struct using_direct * next
Definition: cp-support.h:134
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
char * cp_class_name_from_physname(const char *physname)
Definition: cp-support.c:673
static void check_cv_qualifiers(struct demangle_component *ret_comp)
Definition: cp-support.c:424
struct demangle_parse_info * cp_new_demangle_parse_info(void)
struct block_namespace_info * the_namespace
Definition: block.h:95
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1099
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
static void overload_list_add_symbol(struct symbol *sym, const char *oload_name)
Definition: cp-support.c:1138
static void make_symbol_overload_list_block(const char *name, const struct block *block)
Definition: cp-support.c:1225
const char *( canonicalization_ftype)(struct type *, void *)
Definition: cp-support.h:152
const struct block * block_static_block(const struct block *block)
Definition: block.c:365
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
static struct demangle_parse_info * mangled_name_to_comp(const char *mangled_name, int options, void **memory, char **demangled_p)
Definition: cp-support.c:627
struct ui_file * gdb_stderr
Definition: main.c:72
struct complaints * symfile_complaints
Definition: complaints.c:105
struct symbol * lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
void ui_file_write(struct ui_file *file, const char *buf, long length_buf)
Definition: ui-file.c:218
static int inspect_type(struct demangle_parse_info *info, struct demangle_component *ret_comp, canonicalization_ftype *finder, void *data)
Definition: cp-support.c:152
static int gdb_demangle_attempt_core_dump
Definition: cp-support.c:1506
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1228
void ui_file_rewind(struct ui_file *file)
Definition: ui-file.c:204
const struct block * get_selected_block(CORE_ADDR *addr_in_block)
Definition: stack.c:2230
#define SYMBOL_NATURAL_NAME(symbol)
Definition: symtab.h:231
struct value * parse_and_eval(const char *exp)
Definition: eval.c:124
#define BASETYPE_VIA_PUBLIC(thistype, index)
Definition: gdbtypes.h:1330
void cp_demangled_name_parse_free(struct demangle_parse_info *parse_info)
int can_dump_core(enum resource_limit_kind limit_kind)
Definition: utils.c:569
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
struct cmd_list_element * maintenancelist
Definition: cli-cmds.c:159
void warn_cant_dump_core(const char *reason)
Definition: utils.c:596
static int catch_demangler_crashes
Definition: cp-support.c:1498
void cplus_print_vtable(struct value *value)
Definition: cp-abi.c:176
void * arg
Definition: cleanups.c:43
#define ALL_BLOCK_SYMBOLS_WITH_NAME(block, name, iter, sym)
Definition: block.h:342
#define QUIT
Definition: defs.h:160
static void make_symbol_overload_list_adl_namespace(struct type *type, const char *func_name)
Definition: cp-support.c:1273
const struct quick_symbol_functions * qf
Definition: symfile.h:398
const char * declaration
Definition: cp-support.h:132
struct cmd_list_element * maintenance_show_cmdlist
Definition: maint.c:647
#define d_left(dc)
Definition: cp-support.c:39
unsigned int cp_entire_prefix_len(const char *name)
Definition: cp-support.c:1114
static void replace_typedefs_qualified_name(struct demangle_parse_info *info, struct demangle_component *ret_comp, canonicalization_ftype *finder, void *data)
Definition: cp-support.c:316
static void make_symbol_overload_list_using(const char *func_name, const char *the_namespace)
Definition: cp-support.c:1352
static char * copy_string_to_obstack(struct obstack *obstack, const char *string, long *len)
Definition: cp-support.c:90
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
void begin_line(void)
Definition: utils.c:2016
initialize_file_ftype _initialize_cp_support
static void gdb_demangle_signal_handler(int signo)
Definition: cp-support.c:1511
void dump_core(void)
Definition: utils.c:552
const ULONGEST const LONGEST len
Definition: target.h:309