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