1 /* Helper routines for C++ support in GDB.
2 Copyright 2002, 2003 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 2 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, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 #include "defs.h"
24 #include <ctype.h>
25 #include "cp-support.h"
26 #include "gdb_string.h"
27 #include "demangle.h"
28 #include "gdb_assert.h"
29 #include "gdbcmd.h"
30 #include "dictionary.h"
31 #include "objfiles.h"
32 #include "frame.h"
33 #include "symtab.h"
34 #include "block.h"
35 #include "complaints.h"
36 #include "gdbtypes.h"
37
38 /* Functions related to demangled name parsing. */
39
40 static const char *find_last_component (const char *name);
41
42 static unsigned int cp_find_first_component_aux (const char *name,
43 int permissive);
44
45 static void demangled_name_complaint (const char *name);
46
47 /* Functions/variables related to overload resolution. */
48
49 static int sym_return_val_size;
50 static int sym_return_val_index;
51 static struct symbol **sym_return_val;
52
53 static char *remove_params (const char *demangled_name);
54
55 static void overload_list_add_symbol (struct symbol *sym,
56 const char *oload_name);
57
58 static void make_symbol_overload_list_using (const char *func_name,
59 const char *namespace);
60
61 static void make_symbol_overload_list_qualified (const char *func_name);
62
63 static void read_in_psymtabs (const char *oload_name);
64
65 /* The list of "maint cplus" commands. */
66
67 struct cmd_list_element *maint_cplus_cmd_list = NULL;
68
69 /* The actual commands. */
70
71 static void maint_cplus_command (char *arg, int from_tty);
72 static void first_component_command (char *arg, int from_tty);
73
74 /* Here are some random pieces of trivia to keep in mind while trying
75 to take apart demangled names:
76
77 - Names can contain function arguments or templates, so the process
78 has to be, to some extent recursive: maybe keep track of your
79 depth based on encountering <> and ().
80
81 - Parentheses don't just have to happen at the end of a name: they
82 can occur even if the name in question isn't a function, because
83 a template argument might be a type that's a function.
84
85 - Conversely, even if you're trying to deal with a function, its
86 demangled name might not end with ')': it could be a const or
87 volatile class method, in which case it ends with "const" or
88 "volatile".
89
90 - Parentheses are also used in anonymous namespaces: a variable
91 'foo' in an anonymous namespace gets demangled as "(anonymous
92 namespace)::foo".
93
94 - And operator names can contain parentheses or angle brackets. */
95
96 /* FIXME: carlton/2003-03-13: We have several functions here with
97 overlapping functionality; can we combine them? Also, do they
98 handle all the above considerations correctly? */
99
100 /* Find the last component of the demangled C++ name NAME. NAME
101 must be a method name including arguments, in order to correctly
102 locate the last component.
103
104 This function return a pointer to the first colon before the
105 last component, or NULL if the name had only one component. */
106
107 static const char *
find_last_component(const char * name)108 find_last_component (const char *name)
109 {
110 const char *p;
111 int depth;
112
113 /* Functions can have local classes, so we need to find the
114 beginning of the last argument list, not the end of the first
115 one. */
116 p = name + strlen (name) - 1;
117 while (p > name && *p != ')')
118 p--;
119
120 if (p == name)
121 return NULL;
122
123 /* P now points at the `)' at the end of the argument list. Walk
124 back to the beginning. */
125 p--;
126 depth = 1;
127 while (p > name && depth > 0)
128 {
129 if (*p == '<' || *p == '(')
130 depth--;
131 else if (*p == '>' || *p == ')')
132 depth++;
133 p--;
134 }
135
136 if (p == name)
137 return NULL;
138
139 while (p > name && *p != ':')
140 p--;
141
142 if (p == name || p == name + 1 || p[-1] != ':')
143 return NULL;
144
145 return p - 1;
146 }
147
148 /* Return the name of the class containing method PHYSNAME. */
149
150 char *
cp_class_name_from_physname(const char * physname)151 cp_class_name_from_physname (const char *physname)
152 {
153 char *ret = NULL;
154 const char *end;
155 int depth = 0;
156 char *demangled_name = cplus_demangle (physname, DMGL_ANSI | DMGL_PARAMS);
157
158 if (demangled_name == NULL)
159 return NULL;
160
161 end = find_last_component (demangled_name);
162 if (end != NULL)
163 {
164 ret = xmalloc (end - demangled_name + 1);
165 memcpy (ret, demangled_name, end - demangled_name);
166 ret[end - demangled_name] = '\0';
167 }
168
169 xfree (demangled_name);
170 return ret;
171 }
172
173 /* Return the name of the method whose linkage name is PHYSNAME. */
174
175 char *
method_name_from_physname(const char * physname)176 method_name_from_physname (const char *physname)
177 {
178 char *ret = NULL;
179 const char *end;
180 int depth = 0;
181 char *demangled_name = cplus_demangle (physname, DMGL_ANSI | DMGL_PARAMS);
182
183 if (demangled_name == NULL)
184 return NULL;
185
186 end = find_last_component (demangled_name);
187 if (end != NULL)
188 {
189 char *args;
190 int len;
191
192 /* Skip "::". */
193 end = end + 2;
194
195 /* Find the argument list, if any. */
196 args = strchr (end, '(');
197 if (args == NULL)
198 len = strlen (end + 2);
199 else
200 {
201 args --;
202 while (*args == ' ')
203 args --;
204 len = args - end + 1;
205 }
206 ret = xmalloc (len + 1);
207 memcpy (ret, end, len);
208 ret[len] = 0;
209 }
210
211 xfree (demangled_name);
212 return ret;
213 }
214
215 /* This returns the length of first component of NAME, which should be
216 the demangled name of a C++ variable/function/method/etc.
217 Specifically, it returns the index of the first colon forming the
218 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
219 it returns the 1, and given 'foo', it returns 0. */
220
221 /* The character in NAME indexed by the return value is guaranteed to
222 always be either ':' or '\0'. */
223
224 /* NOTE: carlton/2003-03-13: This function is currently only intended
225 for internal use: it's probably not entirely safe when called on
226 user-generated input, because some of the 'index += 2' lines in
227 cp_find_first_component_aux might go past the end of malformed
228 input. */
229
230 unsigned int
cp_find_first_component(const char * name)231 cp_find_first_component (const char *name)
232 {
233 return cp_find_first_component_aux (name, 0);
234 }
235
236 /* Helper function for cp_find_first_component. Like that function,
237 it returns the length of the first component of NAME, but to make
238 the recursion easier, it also stops if it reaches an unexpected ')'
239 or '>' if the value of PERMISSIVE is nonzero. */
240
241 /* Let's optimize away calls to strlen("operator"). */
242
243 #define LENGTH_OF_OPERATOR 8
244
245 static unsigned int
cp_find_first_component_aux(const char * name,int permissive)246 cp_find_first_component_aux (const char *name, int permissive)
247 {
248 unsigned int index = 0;
249 /* Operator names can show up in unexpected places. Since these can
250 contain parentheses or angle brackets, they can screw up the
251 recursion. But not every string 'operator' is part of an
252 operater name: e.g. you could have a variable 'cooperator'. So
253 this variable tells us whether or not we should treat the string
254 'operator' as starting an operator. */
255 int operator_possible = 1;
256
257 for (;; ++index)
258 {
259 switch (name[index])
260 {
261 case '<':
262 /* Template; eat it up. The calls to cp_first_component
263 should only return (I hope!) when they reach the '>'
264 terminating the component or a '::' between two
265 components. (Hence the '+ 2'.) */
266 index += 1;
267 for (index += cp_find_first_component_aux (name + index, 1);
268 name[index] != '>';
269 index += cp_find_first_component_aux (name + index, 1))
270 {
271 if (name[index] != ':')
272 {
273 demangled_name_complaint (name);
274 return strlen (name);
275 }
276 index += 2;
277 }
278 operator_possible = 1;
279 break;
280 case '(':
281 /* Similar comment as to '<'. */
282 index += 1;
283 for (index += cp_find_first_component_aux (name + index, 1);
284 name[index] != ')';
285 index += cp_find_first_component_aux (name + index, 1))
286 {
287 if (name[index] != ':')
288 {
289 demangled_name_complaint (name);
290 return strlen (name);
291 }
292 index += 2;
293 }
294 operator_possible = 1;
295 break;
296 case '>':
297 case ')':
298 if (permissive)
299 return index;
300 else
301 {
302 demangled_name_complaint (name);
303 return strlen (name);
304 }
305 case '\0':
306 case ':':
307 return index;
308 case 'o':
309 /* Operator names can screw up the recursion. */
310 if (operator_possible
311 && strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0)
312 {
313 index += LENGTH_OF_OPERATOR;
314 while (isspace(name[index]))
315 ++index;
316 switch (name[index])
317 {
318 /* Skip over one less than the appropriate number of
319 characters: the for loop will skip over the last
320 one. */
321 case '<':
322 if (name[index + 1] == '<')
323 index += 1;
324 else
325 index += 0;
326 break;
327 case '>':
328 case '-':
329 if (name[index + 1] == '>')
330 index += 1;
331 else
332 index += 0;
333 break;
334 case '(':
335 index += 1;
336 break;
337 default:
338 index += 0;
339 break;
340 }
341 }
342 operator_possible = 0;
343 break;
344 case ' ':
345 case ',':
346 case '.':
347 case '&':
348 case '*':
349 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
350 set of relevant characters are here: it's necessary to
351 include any character that can show up before 'operator'
352 in a demangled name, and it's safe to include any
353 character that can't be part of an identifier's name. */
354 operator_possible = 1;
355 break;
356 default:
357 operator_possible = 0;
358 break;
359 }
360 }
361 }
362
363 /* Complain about a demangled name that we don't know how to parse.
364 NAME is the demangled name in question. */
365
366 static void
demangled_name_complaint(const char * name)367 demangled_name_complaint (const char *name)
368 {
369 complaint (&symfile_complaints,
370 "unexpected demangled name '%s'", name);
371 }
372
373 /* If NAME is the fully-qualified name of a C++
374 function/variable/method/etc., this returns the length of its
375 entire prefix: all of the namespaces and classes that make up its
376 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
377 4, given 'foo', it returns 0. */
378
379 unsigned int
cp_entire_prefix_len(const char * name)380 cp_entire_prefix_len (const char *name)
381 {
382 unsigned int current_len = cp_find_first_component (name);
383 unsigned int previous_len = 0;
384
385 while (name[current_len] != '\0')
386 {
387 gdb_assert (name[current_len] == ':');
388 previous_len = current_len;
389 /* Skip the '::'. */
390 current_len += 2;
391 current_len += cp_find_first_component (name + current_len);
392 }
393
394 return previous_len;
395 }
396
397 /* If FULL_NAME is the demangled name of a C++ function (including an
398 arg list, possibly including namespace/class qualifications),
399 return a new string containing only the function name (without the
400 arg list/class qualifications). Otherwise, return NULL. The
401 caller is responsible for freeing the memory in question. */
402
403 char *
cp_func_name(const char * full_name)404 cp_func_name (const char *full_name)
405 {
406 const char *previous_component = full_name;
407 const char *next_component;
408
409 if (!full_name)
410 return NULL;
411
412 for (next_component = (previous_component
413 + cp_find_first_component (previous_component));
414 *next_component == ':';
415 next_component = (previous_component
416 + cp_find_first_component (previous_component)))
417 {
418 /* Skip '::'. */
419 previous_component = next_component + 2;
420 }
421
422 return remove_params (previous_component);
423 }
424
425 /* Overload resolution functions. */
426
427 static char *
remove_params(const char * demangled_name)428 remove_params (const char *demangled_name)
429 {
430 const char *argp;
431 char *new_name;
432 int depth;
433
434 if (demangled_name == NULL)
435 return NULL;
436
437 /* First find the end of the arg list. */
438 argp = strrchr (demangled_name, ')');
439 if (argp == NULL)
440 return NULL;
441
442 /* Back up to the beginning. */
443 depth = 1;
444
445 while (argp-- > demangled_name)
446 {
447 if (*argp == ')')
448 depth ++;
449 else if (*argp == '(')
450 {
451 depth --;
452
453 if (depth == 0)
454 break;
455 }
456 }
457 if (depth != 0)
458 internal_error (__FILE__, __LINE__,
459 "bad demangled name %s\n", demangled_name);
460 while (argp[-1] == ' ' && argp > demangled_name)
461 argp --;
462
463 new_name = xmalloc (argp - demangled_name + 1);
464 memcpy (new_name, demangled_name, argp - demangled_name);
465 new_name[argp - demangled_name] = '\0';
466 return new_name;
467 }
468
469 /* Test to see if SYM is a symbol that we haven't seen corresponding
470 to a function named OLOAD_NAME. If so, add it to the current
471 completion list. */
472
473 static void
overload_list_add_symbol(struct symbol * sym,const char * oload_name)474 overload_list_add_symbol (struct symbol *sym, const char *oload_name)
475 {
476 int newsize;
477 int i;
478 char *sym_name;
479
480 /* If there is no type information, we can't do anything, so skip */
481 if (SYMBOL_TYPE (sym) == NULL)
482 return;
483
484 /* skip any symbols that we've already considered. */
485 for (i = 0; i < sym_return_val_index; ++i)
486 if (strcmp (SYMBOL_LINKAGE_NAME (sym),
487 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
488 return;
489
490 /* Get the demangled name without parameters */
491 sym_name = remove_params (SYMBOL_NATURAL_NAME (sym));
492 if (!sym_name)
493 return;
494
495 /* skip symbols that cannot match */
496 if (strcmp (sym_name, oload_name) != 0)
497 {
498 xfree (sym_name);
499 return;
500 }
501
502 xfree (sym_name);
503
504 /* We have a match for an overload instance, so add SYM to the current list
505 * of overload instances */
506 if (sym_return_val_index + 3 > sym_return_val_size)
507 {
508 newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
509 sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize);
510 }
511 sym_return_val[sym_return_val_index++] = sym;
512 sym_return_val[sym_return_val_index] = NULL;
513 }
514
515 /* Return a null-terminated list of pointers to function symbols that
516 are named FUNC_NAME and are visible within NAMESPACE. */
517
518 struct symbol **
make_symbol_overload_list(const char * func_name,const char * namespace)519 make_symbol_overload_list (const char *func_name,
520 const char *namespace)
521 {
522 struct cleanup *old_cleanups;
523
524 sym_return_val_size = 100;
525 sym_return_val_index = 0;
526 sym_return_val = xmalloc ((sym_return_val_size + 1) *
527 sizeof (struct symbol *));
528 sym_return_val[0] = NULL;
529
530 old_cleanups = make_cleanup (xfree, sym_return_val);
531
532 make_symbol_overload_list_using (func_name, namespace);
533
534 discard_cleanups (old_cleanups);
535
536 return sym_return_val;
537 }
538
539 /* This applies the using directives to add namespaces to search in,
540 and then searches for overloads in all of those namespaces. It
541 adds the symbols found to sym_return_val. Arguments are as in
542 make_symbol_overload_list. */
543
544 static void
make_symbol_overload_list_using(const char * func_name,const char * namespace)545 make_symbol_overload_list_using (const char *func_name,
546 const char *namespace)
547 {
548 const struct using_direct *current;
549
550 /* First, go through the using directives. If any of them apply,
551 look in the appropriate namespaces for new functions to match
552 on. */
553
554 for (current = block_using (get_selected_block (0));
555 current != NULL;
556 current = current->next)
557 {
558 if (strcmp (namespace, current->outer) == 0)
559 {
560 make_symbol_overload_list_using (func_name,
561 current->inner);
562 }
563 }
564
565 /* Now, add names for this namespace. */
566
567 if (namespace[0] == '\0')
568 {
569 make_symbol_overload_list_qualified (func_name);
570 }
571 else
572 {
573 char *concatenated_name
574 = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
575 strcpy (concatenated_name, namespace);
576 strcat (concatenated_name, "::");
577 strcat (concatenated_name, func_name);
578 make_symbol_overload_list_qualified (concatenated_name);
579 }
580 }
581
582 /* This does the bulk of the work of finding overloaded symbols.
583 FUNC_NAME is the name of the overloaded function we're looking for
584 (possibly including namespace info). */
585
586 static void
make_symbol_overload_list_qualified(const char * func_name)587 make_symbol_overload_list_qualified (const char *func_name)
588 {
589 struct symbol *sym;
590 struct symtab *s;
591 struct objfile *objfile;
592 const struct block *b, *surrounding_static_block = 0;
593 struct dict_iterator iter;
594 const struct dictionary *dict;
595
596 /* Look through the partial symtabs for all symbols which begin
597 by matching FUNC_NAME. Make sure we read that symbol table in. */
598
599 read_in_psymtabs (func_name);
600
601 /* Search upwards from currently selected frame (so that we can
602 complete on local vars. */
603
604 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
605 {
606 dict = BLOCK_DICT (b);
607
608 for (sym = dict_iter_name_first (dict, func_name, &iter);
609 sym;
610 sym = dict_iter_name_next (func_name, &iter))
611 {
612 overload_list_add_symbol (sym, func_name);
613 }
614 }
615
616 surrounding_static_block = block_static_block (get_selected_block (0));
617
618 /* Go through the symtabs and check the externs and statics for
619 symbols which match. */
620
621 ALL_SYMTABS (objfile, s)
622 {
623 QUIT;
624 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
625 dict = BLOCK_DICT (b);
626
627 for (sym = dict_iter_name_first (dict, func_name, &iter);
628 sym;
629 sym = dict_iter_name_next (func_name, &iter))
630 {
631 overload_list_add_symbol (sym, func_name);
632 }
633 }
634
635 ALL_SYMTABS (objfile, s)
636 {
637 QUIT;
638 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
639 /* Don't do this block twice. */
640 if (b == surrounding_static_block)
641 continue;
642 dict = BLOCK_DICT (b);
643
644 for (sym = dict_iter_name_first (dict, func_name, &iter);
645 sym;
646 sym = dict_iter_name_next (func_name, &iter))
647 {
648 overload_list_add_symbol (sym, func_name);
649 }
650 }
651 }
652
653 /* Look through the partial symtabs for all symbols which begin
654 by matching FUNC_NAME. Make sure we read that symbol table in. */
655
656 static void
read_in_psymtabs(const char * func_name)657 read_in_psymtabs (const char *func_name)
658 {
659 struct partial_symtab *ps;
660 struct objfile *objfile;
661
662 ALL_PSYMTABS (objfile, ps)
663 {
664 if (ps->readin)
665 continue;
666
667 if ((lookup_partial_symbol (ps, func_name, NULL, 1, VAR_DOMAIN)
668 != NULL)
669 || (lookup_partial_symbol (ps, func_name, NULL, 0, VAR_DOMAIN)
670 != NULL))
671 psymtab_to_symtab (ps);
672 }
673 }
674
675 /* Lookup the rtti type for a class name. */
676
677 struct type *
cp_lookup_rtti_type(const char * name,struct block * block)678 cp_lookup_rtti_type (const char *name, struct block *block)
679 {
680 struct symbol * rtti_sym;
681 struct type * rtti_type;
682
683 rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL, NULL);
684
685 if (rtti_sym == NULL)
686 {
687 warning ("RTTI symbol not found for class '%s'", name);
688 return NULL;
689 }
690
691 if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
692 {
693 warning ("RTTI symbol for class '%s' is not a type", name);
694 return NULL;
695 }
696
697 rtti_type = SYMBOL_TYPE (rtti_sym);
698
699 switch (TYPE_CODE (rtti_type))
700 {
701 case TYPE_CODE_CLASS:
702 break;
703 case TYPE_CODE_NAMESPACE:
704 /* chastain/2003-11-26: the symbol tables often contain fake
705 symbols for namespaces with the same name as the struct.
706 This warning is an indication of a bug in the lookup order
707 or a bug in the way that the symbol tables are populated. */
708 warning ("RTTI symbol for class '%s' is a namespace", name);
709 return NULL;
710 default:
711 warning ("RTTI symbol for class '%s' has bad type", name);
712 return NULL;
713 }
714
715 return rtti_type;
716 }
717
718 /* Don't allow just "maintenance cplus". */
719
720 static void
maint_cplus_command(char * arg,int from_tty)721 maint_cplus_command (char *arg, int from_tty)
722 {
723 printf_unfiltered ("\"maintenance cplus\" must be followed by the name of a command.\n");
724 help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout);
725 }
726
727 /* This is a front end for cp_find_first_component, for unit testing.
728 Be careful when using it: see the NOTE above
729 cp_find_first_component. */
730
731 static void
first_component_command(char * arg,int from_tty)732 first_component_command (char *arg, int from_tty)
733 {
734 int len = cp_find_first_component (arg);
735 char *prefix = alloca (len + 1);
736
737 memcpy (prefix, arg, len);
738 prefix[len] = '\0';
739
740 printf_unfiltered ("%s\n", prefix);
741 }
742
743 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
744
745 void
_initialize_cp_support(void)746 _initialize_cp_support (void)
747 {
748 add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command,
749 "C++ maintenance commands.", &maint_cplus_cmd_list,
750 "maintenance cplus ", 0, &maintenancelist);
751 add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist);
752
753 add_cmd ("first_component", class_maintenance, first_component_command,
754 "Print the first class/namespace component of NAME.",
755 &maint_cplus_cmd_list);
756
757 }
758