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