GDB (xrefs)

/tmp/gdb-8.1/gdb/cp-support.c
Go to the documentation of this file.
1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2002-2018 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 #include "selftest.h"
40
41 #define d_left(dc) (dc)->u.s_binary.left
42 #define d_right(dc) (dc)->u.s_binary.right
43
44 /* Functions related to demangled name parsing. */
45
46 static unsigned int cp_find_first_component_aux (const char *name,
47 int permissive);
48
49 static void demangled_name_complaint (const char *name);
50
51 /* Functions/variables related to overload resolution. */
52
53 static int sym_return_val_size = -1;
54 static int sym_return_val_index;
55 static struct symbol **sym_return_val;
56
57 static void overload_list_add_symbol (struct symbol *sym,
58 const char *oload_name);
59
60 static void make_symbol_overload_list_using (const char *func_name,
61 const char *the_namespace);
62
63 static void make_symbol_overload_list_qualified (const char *func_name);
64
65 /* The list of "maint cplus" commands. */
66
67 struct cmd_list_element *maint_cplus_cmd_list = NULL;
68
69 /* A list of typedefs which should not be substituted by replace_typedefs. */
70 static const char * const ignore_typedefs[] =
71 {
72 "std::istream", "std::iostream", "std::ostream", "std::string"
73 };
74
75 static void
76 replace_typedefs (struct demangle_parse_info *info,
77 struct demangle_component *ret_comp,
78 canonicalization_ftype *finder,
79 void *data);
80
81 /* A convenience function to copy STRING into OBSTACK, returning a pointer
82 to the newly allocated string and saving the number of bytes saved in LEN.
83
84 It does not copy the terminating '\0' byte! */
85
86 static char *
87 copy_string_to_obstack (struct obstack *obstack, const char *string,
88 long *len)
89 {
90 *len = strlen (string);
91 return (char *) obstack_copy (obstack, string, *len);
92 }
93
94 /* Return 1 if STRING is clearly already in canonical form. This
95 function is conservative; things which it does not recognize are
96 assumed to be non-canonical, and the parser will sort them out
97 afterwards. This speeds up the critical path for alphanumeric
98 identifiers. */
99
100 static int
101 cp_already_canonical (const char *string)
102 {
103 /* Identifier start character [a-zA-Z_]. */
104 if (!ISIDST (string[0]))
105 return 0;
106
107 /* These are the only two identifiers which canonicalize to other
108 than themselves or an error: unsigned -> unsigned int and
109 signed -> int. */
110 if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
111 return 0;
112 else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
113 return 0;
114
115 /* Identifier character [a-zA-Z0-9_]. */
116 while (ISIDNUM (string[1]))
117 string++;
118
119 if (string[1] == '\0')
120 return 1;
121 else
122 return 0;
123 }
124
125 /* Inspect the given RET_COMP for its type. If it is a typedef,
126 replace the node with the typedef's tree.
127
128 Returns 1 if any typedef substitutions were made, 0 otherwise. */
129
130 static int
131 inspect_type (struct demangle_parse_info *info,
132 struct demangle_component *ret_comp,
133 canonicalization_ftype *finder,
134 void *data)
135 {
136 int i;
137 char *name;
138 struct symbol *sym;
139
140 /* Copy the symbol's name from RET_COMP and look it up
141 in the symbol table. */
142 name = (char *) alloca (ret_comp->u.s_name.len + 1);
143 memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len);
144 name[ret_comp->u.s_name.len] = '\0';
145
146 /* Ignore any typedefs that should not be substituted. */
147 for (i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i)
148 {
149 if (strcmp (name, ignore_typedefs[i]) == 0)
150 return 0;
151 }
152
153 sym = NULL;
154
155 TRY
156 {
157 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol;
158 }
159 CATCH (except, RETURN_MASK_ALL)
160 {
161 return 0;
162 }
163 END_CATCH
164
165 if (sym != NULL)
166 {
167 struct type *otype = SYMBOL_TYPE (sym);
168
169 if (finder != NULL)
170 {
171 const char *new_name = (*finder) (otype, data);
172
173 if (new_name != NULL)
174 {
175 ret_comp->u.s_name.s = new_name;
176 ret_comp->u.s_name.len = strlen (new_name);
177 return 1;
178 }
179
180 return 0;
181 }
182
183 /* If the type is a typedef or namespace alias, replace it. */
184 if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF
185 || TYPE_CODE (otype) == TYPE_CODE_NAMESPACE)
186 {
187 long len;
188 int is_anon;
189 struct type *type;
190 std::unique_ptr<demangle_parse_info> i;
191
192 /* Get the real type of the typedef. */
193 type = check_typedef (otype);
194
195 /* If the symbol is a namespace and its type name is no different
196 than the name we looked up, this symbol is not a namespace
197 alias and does not need to be substituted. */
198 if (TYPE_CODE (otype) == TYPE_CODE_NAMESPACE
199 && strcmp (TYPE_NAME (type), name) == 0)
200 return 0;
201
202 is_anon = (TYPE_TAG_NAME (type) == NULL
203 && (TYPE_CODE (type) == TYPE_CODE_ENUM
204 || TYPE_CODE (type) == TYPE_CODE_STRUCT
205 || TYPE_CODE (type) == TYPE_CODE_UNION));
206 if (is_anon)
207 {
208 struct type *last = otype;
209
210 /* Find the last typedef for the type. */
211 while (TYPE_TARGET_TYPE (last) != NULL
212 && (TYPE_CODE (TYPE_TARGET_TYPE (last))
213 == TYPE_CODE_TYPEDEF))
214 last = TYPE_TARGET_TYPE (last);
215
216 /* If there is only one typedef for this anonymous type,
217 do not substitute it. */
218 if (type == otype)
219 return 0;
220 else
221 /* Use the last typedef seen as the type for this
222 anonymous type. */
223 type = last;
224 }
225
226 string_file buf;
227 TRY
228 {
229 type_print (type, "", &buf, -1);
230 }
231 /* If type_print threw an exception, there is little point
232 in continuing, so just bow out gracefully. */
233 CATCH (except, RETURN_MASK_ERROR)
234 {
235 return 0;
236 }
237 END_CATCH
238
239 len = buf.size ();
240 name = (char *) obstack_copy0 (&info->obstack, buf.c_str (), len);
241
242 /* Turn the result into a new tree. Note that this
243 tree will contain pointers into NAME, so NAME cannot
244 be free'd until all typedef conversion is done and
245 the final result is converted into a string. */
246 i = cp_demangled_name_to_comp (name, NULL);
247 if (i != NULL)
248 {
249 /* Merge the two trees. */
250 cp_merge_demangle_parse_infos (info, ret_comp, i.get ());
251
252 /* Replace any newly introduced typedefs -- but not
253 if the type is anonymous (that would lead to infinite
254 looping). */
255 if (!is_anon)
256 replace_typedefs (info, ret_comp, finder, data);
257 }
258 else
259 {
260 /* This shouldn't happen unless the type printer has
261 output something that the name parser cannot grok.
262 Nonetheless, an ounce of prevention...
263
264 Canonicalize the name again, and store it in the
265 current node (RET_COMP). */
266 std::string canon = cp_canonicalize_string_no_typedefs (name);
267
268 if (!canon.empty ())
269 {
270 /* Copy the canonicalization into the obstack. */
271 name = copy_string_to_obstack (&info->obstack, canon.c_str (), &len);
272 }
273
274 ret_comp->u.s_name.s = name;
275 ret_comp->u.s_name.len = len;
276 }
277
278 return 1;
279 }
280 }
281
282 return 0;
283 }
284
285 /* Replace any typedefs appearing in the qualified name
286 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
287 given in INFO. */
288
289 static void
290 replace_typedefs_qualified_name (struct demangle_parse_info *info,
291 struct demangle_component *ret_comp,
292 canonicalization_ftype *finder,
293 void *data)
294 {
295 string_file buf;
296 struct demangle_component *comp = ret_comp;
297
298 /* Walk each node of the qualified name, reconstructing the name of
299 this element. With every node, check for any typedef substitutions.
300 If a substitution has occurred, replace the qualified name node
301 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
302 substituted name. */
303 while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME)
304 {
305 if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME)
306 {
307 struct demangle_component newobj;
308
309 buf.write (d_left (comp)->u.s_name.s, d_left (comp)->u.s_name.len);
310 newobj.type = DEMANGLE_COMPONENT_NAME;
311 newobj.u.s_name.s
312 = (char *) obstack_copy0 (&info->obstack,
313 buf.c_str (), buf.size ());
314 newobj.u.s_name.len = buf.size ();
315 if (inspect_type (info, &newobj, finder, data))
316 {
317 char *s;
318 long slen;
319
320 /* A typedef was substituted in NEW. Convert it to a
321 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
322 node. */
323
324 buf.clear ();
325 gdb::unique_xmalloc_ptr<char> n
326 = cp_comp_to_string (&newobj, 100);
327 if (n == NULL)
328 {
329 /* If something went astray, abort typedef substitutions. */
330 return;
331 }
332
333 s = copy_string_to_obstack (&info->obstack, n.get (), &slen);
334
335 d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME;
336 d_left (ret_comp)->u.s_name.s = s;
337 d_left (ret_comp)->u.s_name.len = slen;
338 d_right (ret_comp) = d_right (comp);
339 comp = ret_comp;
340 continue;
341 }
342 }
343 else
344 {
345 /* The current node is not a name, so simply replace any
346 typedefs in it. Then print it to the stream to continue
347 checking for more typedefs in the tree. */
348 replace_typedefs (info, d_left (comp), finder, data);
349 gdb::unique_xmalloc_ptr<char> name
350 = cp_comp_to_string (d_left (comp), 100);
351 if (name == NULL)
352 {
353 /* If something went astray, abort typedef substitutions. */
354 return;
355 }
356 buf.puts (name.get ());
357 }
358
359 buf.write ("::", 2);
360 comp = d_right (comp);
361 }
362
363 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
364 name assembled above and append the name given by COMP. Then use this
365 reassembled name to check for a typedef. */
366
367 if (comp->type == DEMANGLE_COMPONENT_NAME)
368 {
369 buf.write (comp->u.s_name.s, comp->u.s_name.len);
370
371 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
372 with a DEMANGLE_COMPONENT_NAME node containing the whole
373 name. */
374 ret_comp->type = DEMANGLE_COMPONENT_NAME;
375 ret_comp->u.s_name.s
376 = (char *) obstack_copy0 (&info->obstack,
377 buf.c_str (), buf.size ());
378 ret_comp->u.s_name.len = buf.size ();
379 inspect_type (info, ret_comp, finder, data);
380 }
381 else
382 replace_typedefs (info, comp, finder, data);
383 }
384
385
386 /* A function to check const and volatile qualifiers for argument types.
387
388 "Parameter declarations that differ only in the presence
389 or absence of `const' and/or `volatile' are equivalent."
390 C++ Standard N3290, clause 13.1.3 #4. */
391
392 static void
393 check_cv_qualifiers (struct demangle_component *ret_comp)
394 {
395 while (d_left (ret_comp) != NULL
396 && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST
397 || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE))
398 {
399 d_left (ret_comp) = d_left (d_left (ret_comp));
400 }
401 }
402
403 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
404 their basic types. */
405
406 static void
407 replace_typedefs (struct demangle_parse_info *info,
408 struct demangle_component *ret_comp,
409 canonicalization_ftype *finder,
410 void *data)
411 {
412 if (ret_comp)
413 {
414 if (finder != NULL
415 && (ret_comp->type == DEMANGLE_COMPONENT_NAME
416 || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
417 || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE
418 || ret_comp->type == DEMANGLE_COMPONENT_BUILTIN_TYPE))
419 {
420 gdb::unique_xmalloc_ptr<char> local_name
421 = cp_comp_to_string (ret_comp, 10);
422
423 if (local_name != NULL)
424 {
425 struct symbol *sym = NULL;
426
427 sym = NULL;
428 TRY
429 {
430 sym = lookup_symbol (local_name.get (), 0,
431 VAR_DOMAIN, 0).symbol;
432 }
433 CATCH (except, RETURN_MASK_ALL)
434 {
435 }
436 END_CATCH
437
438 if (sym != NULL)
439 {
440 struct type *otype = SYMBOL_TYPE (sym);
441 const char *new_name = (*finder) (otype, data);
442
443 if (new_name != NULL)
444 {
445 ret_comp->type = DEMANGLE_COMPONENT_NAME;
446 ret_comp->u.s_name.s = new_name;
447 ret_comp->u.s_name.len = strlen (new_name);
448 return;
449 }
450 }
451 }
452 }
453
454 switch (ret_comp->type)
455 {
456 case DEMANGLE_COMPONENT_ARGLIST:
457 check_cv_qualifiers (ret_comp);
458 /* Fall through */
459
460 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
461 case DEMANGLE_COMPONENT_TEMPLATE:
462 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
463 case DEMANGLE_COMPONENT_TYPED_NAME:
464 replace_typedefs (info, d_left (ret_comp), finder, data);
465 replace_typedefs (info, d_right (ret_comp), finder, data);
466 break;
467
468 case DEMANGLE_COMPONENT_NAME:
469 inspect_type (info, ret_comp, finder, data);
470 break;
471
472 case DEMANGLE_COMPONENT_QUAL_NAME:
473 replace_typedefs_qualified_name (info, ret_comp, finder, data);
474 break;
475
476 case DEMANGLE_COMPONENT_LOCAL_NAME:
477 case DEMANGLE_COMPONENT_CTOR:
478 case DEMANGLE_COMPONENT_ARRAY_TYPE:
479 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
480 replace_typedefs (info, d_right (ret_comp), finder, data);
481 break;
482
483 case DEMANGLE_COMPONENT_CONST:
484 case DEMANGLE_COMPONENT_RESTRICT:
485 case DEMANGLE_COMPONENT_VOLATILE:
486 case DEMANGLE_COMPONENT_VOLATILE_THIS:
487 case DEMANGLE_COMPONENT_CONST_THIS:
488 case DEMANGLE_COMPONENT_RESTRICT_THIS:
489 case DEMANGLE_COMPONENT_POINTER:
490 case DEMANGLE_COMPONENT_REFERENCE:
491 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
492 replace_typedefs (info, d_left (ret_comp), finder, data);
493 break;
494
495 default:
496 break;
497 }
498 }
499 }
500
501 /* Parse STRING and convert it to canonical form, resolving any
502 typedefs. If parsing fails, or if STRING is already canonical,
503 return the empty string. Otherwise return the canonical form. If
504 FINDER is not NULL, then type components are passed to FINDER to be
505 looked up. DATA is passed verbatim to FINDER. */
506
507 std::string
508 cp_canonicalize_string_full (const char *string,
509 canonicalization_ftype *finder,
510 void *data)
511 {
512 std::string ret;
513 unsigned int estimated_len;
514 std::unique_ptr<demangle_parse_info> info;
515
516 estimated_len = strlen (string) * 2;
517 info = cp_demangled_name_to_comp (string, NULL);
518 if (info != NULL)
519 {
520 /* Replace all the typedefs in the tree. */
521 replace_typedefs (info.get (), info->tree, finder, data);
522
523 /* Convert the tree back into a string. */
524 gdb::unique_xmalloc_ptr<char> us = cp_comp_to_string (info->tree,
525 estimated_len);
526 gdb_assert (us);
527
528 ret = us.get ();
529 /* Finally, compare the original string with the computed
530 name, returning NULL if they are the same. */
531 if (ret == string)
532 return std::string ();
533 }
534
535 return ret;
536 }
537
538 /* Like cp_canonicalize_string_full, but always passes NULL for
539 FINDER. */
540
541 std::string
542 cp_canonicalize_string_no_typedefs (const char *string)
543 {
544 return cp_canonicalize_string_full (string, NULL, NULL);
545 }
546
547 /* Parse STRING and convert it to canonical form. If parsing fails,
548 or if STRING is already canonical, return the empty string.
549 Otherwise return the canonical form. */
550
551 std::string
552 cp_canonicalize_string (const char *string)
553 {
554 std::unique_ptr<demangle_parse_info> info;
555 unsigned int estimated_len;
556
557 if (cp_already_canonical (string))
558 return std::string ();
559
560 info = cp_demangled_name_to_comp (string, NULL);
561 if (info == NULL)
562 return std::string ();
563
564 estimated_len = strlen (string) * 2;
565 gdb::unique_xmalloc_ptr<char> us (cp_comp_to_string (info->tree,
566 estimated_len));
567
568 if (!us)
569 {
570 warning (_("internal error: string \"%s\" failed to be canonicalized"),
571 string);
572 return std::string ();
573 }
574
575 std::string ret (us.get ());
576
577 if (ret == string)
578 return std::string ();
579
580 return ret;
581 }
582
583 /* Convert a mangled name to a demangle_component tree. *MEMORY is
584 set to the block of used memory that should be freed when finished
585 with the tree. DEMANGLED_P is set to the char * that should be
586 freed when finished with the tree, or NULL if none was needed.
587 OPTIONS will be passed to the demangler. */
588
589 static std::unique_ptr<demangle_parse_info>
590 mangled_name_to_comp (const char *mangled_name, int options,
591 void **memory, char **demangled_p)
592 {
593 char *demangled_name;
594
595 /* If it looks like a v3 mangled name, then try to go directly
596 to trees. */
597 if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
598 {
599 struct demangle_component *ret;
600
601 ret = cplus_demangle_v3_components (mangled_name,
602 options, memory);
603 if (ret)
604 {
605 std::unique_ptr<demangle_parse_info> info (new demangle_parse_info);
606 info->tree = ret;
607 *demangled_p = NULL;
608 return info;
609 }
610 }
611
612 /* If it doesn't, or if that failed, then try to demangle the
613 name. */
614 demangled_name = gdb_demangle (mangled_name, options);
615 if (demangled_name == NULL)
616 return NULL;
617
618 /* If we could demangle the name, parse it to build the component
619 tree. */
620 std::unique_ptr<demangle_parse_info> info
621 = cp_demangled_name_to_comp (demangled_name, NULL);
622
623 if (info == NULL)
624 {
625 xfree (demangled_name);
626 return NULL;
627 }
628
629 *demangled_p = demangled_name;
630 return info;
631 }
632
633 /* Return the name of the class containing method PHYSNAME. */
634
635 char *
636 cp_class_name_from_physname (const char *physname)
637 {
638 void *storage = NULL;
639 char *demangled_name = NULL;
640 gdb::unique_xmalloc_ptr<char> ret;
641 struct demangle_component *ret_comp, *prev_comp, *cur_comp;
642 std::unique_ptr<demangle_parse_info> info;
643 int done;
644
645 info = mangled_name_to_comp (physname, DMGL_ANSI,
646 &storage, &demangled_name);
647 if (info == NULL)
648 return NULL;
649
650 done = 0;
651 ret_comp = info->tree;
652
653 /* First strip off any qualifiers, if we have a function or
654 method. */
655 while (!done)
656 switch (ret_comp->type)
657 {
658 case DEMANGLE_COMPONENT_CONST:
659 case DEMANGLE_COMPONENT_RESTRICT:
660 case DEMANGLE_COMPONENT_VOLATILE:
661 case DEMANGLE_COMPONENT_CONST_THIS:
662 case DEMANGLE_COMPONENT_RESTRICT_THIS:
663 case DEMANGLE_COMPONENT_VOLATILE_THIS:
664 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
665 ret_comp = d_left (ret_comp);
666 break;
667 default:
668 done = 1;
669 break;
670 }
671
672 /* If what we have now is a function, discard the argument list. */
673 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
674 ret_comp = d_left (ret_comp);
675
676 /* If what we have now is a template, strip off the template
677 arguments. The left subtree may be a qualified name. */
678 if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
679 ret_comp = d_left (ret_comp);
680
681 /* What we have now should be a name, possibly qualified.
682 Additional qualifiers could live in the left subtree or the right
683 subtree. Find the last piece. */
684 done = 0;
685 prev_comp = NULL;
686 cur_comp = ret_comp;
687 while (!done)
688 switch (cur_comp->type)
689 {
690 case DEMANGLE_COMPONENT_QUAL_NAME:
691 case DEMANGLE_COMPONENT_LOCAL_NAME:
692 prev_comp = cur_comp;
693 cur_comp = d_right (cur_comp);
694 break;
695 case DEMANGLE_COMPONENT_TEMPLATE:
696 case DEMANGLE_COMPONENT_NAME:
697 case DEMANGLE_COMPONENT_CTOR:
698 case DEMANGLE_COMPONENT_DTOR:
699 case DEMANGLE_COMPONENT_OPERATOR:
700 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
701 done = 1;
702 break;
703 default:
704 done = 1;
705 cur_comp = NULL;
706 break;
707 }
708
709 if (cur_comp != NULL && prev_comp != NULL)
710 {
711 /* We want to discard the rightmost child of PREV_COMP. */
712 *prev_comp = *d_left (prev_comp);
713 /* The ten is completely arbitrary; we don't have a good
714 estimate. */
715 ret = cp_comp_to_string (ret_comp, 10);
716 }
717
718 xfree (storage);
719 xfree (demangled_name);
720 return ret.release ();
721 }
722
723 /* Return the child of COMP which is the basename of a method,
724 variable, et cetera. All scope qualifiers are discarded, but
725 template arguments will be included. The component tree may be
726 modified. */
727
728 static struct demangle_component *
729 unqualified_name_from_comp (struct demangle_component *comp)
730 {
731 struct demangle_component *ret_comp = comp, *last_template;
732 int done;
733
734 done = 0;
735 last_template = NULL;
736 while (!done)
737 switch (ret_comp->type)
738 {
739 case DEMANGLE_COMPONENT_QUAL_NAME:
740 case DEMANGLE_COMPONENT_LOCAL_NAME:
741 ret_comp = d_right (ret_comp);
742 break;
743 case DEMANGLE_COMPONENT_TYPED_NAME:
744 ret_comp = d_left (ret_comp);
745 break;
746 case DEMANGLE_COMPONENT_TEMPLATE:
747 gdb_assert (last_template == NULL);
748 last_template = ret_comp;
749 ret_comp = d_left (ret_comp);
750 break;
751 case DEMANGLE_COMPONENT_CONST:
752 case DEMANGLE_COMPONENT_RESTRICT:
753 case DEMANGLE_COMPONENT_VOLATILE:
754 case DEMANGLE_COMPONENT_CONST_THIS:
755 case DEMANGLE_COMPONENT_RESTRICT_THIS:
756 case DEMANGLE_COMPONENT_VOLATILE_THIS:
757 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
758 ret_comp = d_left (ret_comp);
759 break;
760 case DEMANGLE_COMPONENT_NAME:
761 case DEMANGLE_COMPONENT_CTOR:
762 case DEMANGLE_COMPONENT_DTOR:
763 case DEMANGLE_COMPONENT_OPERATOR:
764 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
765 done = 1;
766 break;
767 default:
768 return NULL;
769 break;
770 }
771
772 if (last_template)
773 {
774 d_left (last_template) = ret_comp;
775 return last_template;
776 }
777
778 return ret_comp;
779 }
780
781 /* Return the name of the method whose linkage name is PHYSNAME. */
782
783 char *
784 method_name_from_physname (const char *physname)
785 {
786 void *storage = NULL;
787 char *demangled_name = NULL;
788 gdb::unique_xmalloc_ptr<char> ret;
789 struct demangle_component *ret_comp;
790 std::unique_ptr<demangle_parse_info> info;
791
792 info = mangled_name_to_comp (physname, DMGL_ANSI,
793 &storage, &demangled_name);
794 if (info == NULL)
795 return NULL;
796
797 ret_comp = unqualified_name_from_comp (info->tree);
798
799 if (ret_comp != NULL)
800 /* The ten is completely arbitrary; we don't have a good
801 estimate. */
802 ret = cp_comp_to_string (ret_comp, 10);
803
804 xfree (storage);
805 xfree (demangled_name);
806 return ret.release ();
807 }
808
809 /* If FULL_NAME is the demangled name of a C++ function (including an
810 arg list, possibly including namespace/class qualifications),
811 return a new string containing only the function name (without the
812 arg list/class qualifications). Otherwise, return NULL. The
813 caller is responsible for freeing the memory in question. */
814
815 char *
816 cp_func_name (const char *full_name)
817 {
818 gdb::unique_xmalloc_ptr<char> ret;
819 struct demangle_component *ret_comp;
820 std::unique_ptr<demangle_parse_info> info;
821
822 info = cp_demangled_name_to_comp (full_name, NULL);
823 if (!info)
824 return NULL;
825
826 ret_comp = unqualified_name_from_comp (info->tree);
827
828 if (ret_comp != NULL)
829 ret = cp_comp_to_string (ret_comp, 10);
830
831 return ret.release ();
832 }
833
834 /* Helper for cp_remove_params. DEMANGLED_NAME is the name of a
835 function, including parameters and (optionally) a return type.
836 Return the name of the function without parameters or return type,
837 or NULL if we can not parse the name. If REQUIRE_PARAMS is false,
838 then tolerate a non-existing or unbalanced parameter list. */
839
840 static gdb::unique_xmalloc_ptr<char>
841 cp_remove_params_1 (const char *demangled_name, bool require_params)
842 {
843 bool done = false;
844 struct demangle_component *ret_comp;
845 std::unique_ptr<demangle_parse_info> info;
846 gdb::unique_xmalloc_ptr<char> ret;
847
848 if (demangled_name == NULL)
849 return NULL;
850
851 info = cp_demangled_name_to_comp (demangled_name, NULL);
852 if (info == NULL)
853 return NULL;
854
855 /* First strip off any qualifiers, if we have a function or method. */
856 ret_comp = info->tree;
857 while (!done)
858 switch (ret_comp->type)
859 {
860 case DEMANGLE_COMPONENT_CONST:
861 case DEMANGLE_COMPONENT_RESTRICT:
862 case DEMANGLE_COMPONENT_VOLATILE:
863 case DEMANGLE_COMPONENT_CONST_THIS:
864 case DEMANGLE_COMPONENT_RESTRICT_THIS:
865 case DEMANGLE_COMPONENT_VOLATILE_THIS:
866 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
867 ret_comp = d_left (ret_comp);
868 break;
869 default:
870 done = true;
871 break;
872 }
873
874 /* What we have now should be a function. Return its name. */
875 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
876 ret = cp_comp_to_string (d_left (ret_comp), 10);
877 else if (!require_params
878 && (ret_comp->type == DEMANGLE_COMPONENT_NAME
879 || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
880 || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE))
881 ret = cp_comp_to_string (ret_comp, 10);
882
883 return ret;
884 }
885
886 /* DEMANGLED_NAME is the name of a function, including parameters and
887 (optionally) a return type. Return the name of the function
888 without parameters or return type, or NULL if we can not parse the
889 name. */
890
891 gdb::unique_xmalloc_ptr<char>
892 cp_remove_params (const char *demangled_name)
893 {
894 return cp_remove_params_1 (demangled_name, true);
895 }
896
897 /* See cp-support.h. */
898
899 gdb::unique_xmalloc_ptr<char>
900 cp_remove_params_if_any (const char *demangled_name, bool completion_mode)
901 {
902 /* Trying to remove parameters from the empty string fails. If
903 we're completing / matching everything, avoid returning NULL
904 which would make callers interpret the result as an error. */
905 if (demangled_name[0] == '\0' && completion_mode)
906 return gdb::unique_xmalloc_ptr<char> (xstrdup (""));
907
908 gdb::unique_xmalloc_ptr<char> without_params
909 = cp_remove_params_1 (demangled_name, false);
910
911 if (without_params == NULL && completion_mode)
912 {
913 std::string copy = demangled_name;
914
915 while (!copy.empty ())
916 {
917 copy.pop_back ();
918 without_params = cp_remove_params_1 (copy.c_str (), false);
919 if (without_params != NULL)
920 break;
921 }
922 }
923
924 return without_params;
925 }
926
927 /* Here are some random pieces of trivia to keep in mind while trying
928 to take apart demangled names:
929
930 - Names can contain function arguments or templates, so the process
931 has to be, to some extent recursive: maybe keep track of your
932 depth based on encountering <> and ().
933
934 - Parentheses don't just have to happen at the end of a name: they
935 can occur even if the name in question isn't a function, because
936 a template argument might be a type that's a function.
937
938 - Conversely, even if you're trying to deal with a function, its
939 demangled name might not end with ')': it could be a const or
940 volatile class method, in which case it ends with "const" or
941 "volatile".
942
943 - Parentheses are also used in anonymous namespaces: a variable
944 'foo' in an anonymous namespace gets demangled as "(anonymous
945 namespace)::foo".
946
947 - And operator names can contain parentheses or angle brackets. */
948
949 /* FIXME: carlton/2003-03-13: We have several functions here with
950 overlapping functionality; can we combine them? Also, do they
951 handle all the above considerations correctly? */
952
953
954 /* This returns the length of first component of NAME, which should be
955 the demangled name of a C++ variable/function/method/etc.
956 Specifically, it returns the index of the first colon forming the
957 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
958 it returns the 1, and given 'foo', it returns 0. */
959
960 /* The character in NAME indexed by the return value is guaranteed to
961 always be either ':' or '\0'. */
962
963 /* NOTE: carlton/2003-03-13: This function is currently only intended
964 for internal use: it's probably not entirely safe when called on
965 user-generated input, because some of the 'index += 2' lines in
966 cp_find_first_component_aux might go past the end of malformed
967 input. */
968
969 unsigned int
970 cp_find_first_component (const char *name)
971 {
972 return cp_find_first_component_aux (name, 0);
973 }
974
975 /* Helper function for cp_find_first_component. Like that function,
976 it returns the length of the first component of NAME, but to make
977 the recursion easier, it also stops if it reaches an unexpected ')'
978 or '>' if the value of PERMISSIVE is nonzero. */
979
980 static unsigned int
981 cp_find_first_component_aux (const char *name, int permissive)
982 {
983 unsigned int index = 0;
984 /* Operator names can show up in unexpected places. Since these can
985 contain parentheses or angle brackets, they can screw up the
986 recursion. But not every string 'operator' is part of an
987 operater name: e.g. you could have a variable 'cooperator'. So
988 this variable tells us whether or not we should treat the string
989 'operator' as starting an operator. */
990 int operator_possible = 1;
991
992 for (;; ++index)
993 {
994 switch (name[index])
995 {
996 case '<':
997 /* Template; eat it up. The calls to cp_first_component
998 should only return (I hope!) when they reach the '>'
999 terminating the component or a '::' between two
1000 components. (Hence the '+ 2'.) */
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 /* Similar comment as to '<'. */
1017 index += 1;
1018 for (index += cp_find_first_component_aux (name + index, 1);
1019 name[index] != ')';
1020 index += cp_find_first_component_aux (name + index, 1))
1021 {
1022 if (name[index] != ':')
1023 {
1024 demangled_name_complaint (name);
1025 return strlen (name);
1026 }
1027 index += 2;
1028 }
1029 operator_possible = 1;
1030 break;
1031 case '>':
1032 case ')':
1033 if (permissive)
1034 return index;
1035 else
1036 {
1037 demangled_name_complaint (name);
1038 return strlen (name);
1039 }
1040 case '\0':
1041 return index;
1042 case ':':
1043 /* ':' marks a component iff the next character is also a ':'.
1044 Otherwise it is probably malformed input. */
1045 if (name[index + 1] == ':')
1046 return index;
1047 break;
1048 case 'o':
1049 /* Operator names can screw up the recursion. */
1050 if (operator_possible
1051 && startswith (name + index, CP_OPERATOR_STR))
1052 {
1053 index += CP_OPERATOR_LEN;
1054 while (ISSPACE(name[index]))
1055 ++index;
1056 switch (name[index])
1057 {
1058 case '\0':
1059 return index;
1060 /* Skip over one less than the appropriate number of
1061 characters: the for loop will skip over the last
1062 one. */
1063 case '<':
1064 if (name[index + 1] == '<')
1065 index += 1;
1066 else
1067 index += 0;
1068 break;
1069 case '>':
1070 case '-':
1071 if (name[index + 1] == '>')
1072 index += 1;
1073 else
1074 index += 0;
1075 break;
1076 case '(':
1077 index += 1;
1078 break;
1079 default:
1080 index += 0;
1081 break;
1082 }
1083 }
1084 operator_possible = 0;
1085 break;
1086 case ' ':
1087 case ',':
1088 case '.':
1089 case '&':
1090 case '*':
1091 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1092 set of relevant characters are here: it's necessary to
1093 include any character that can show up before 'operator'
1094 in a demangled name, and it's safe to include any
1095 character that can't be part of an identifier's name. */
1096 operator_possible = 1;
1097 break;
1098 default:
1099 operator_possible = 0;
1100 break;
1101 }
1102 }
1103 }
1104
1105 /* Complain about a demangled name that we don't know how to parse.
1106 NAME is the demangled name in question. */
1107
1108 static void
1109 demangled_name_complaint (const char *name)
1110 {
1111 complaint (&symfile_complaints,
1112 "unexpected demangled name '%s'", name);
1113 }
1114
1115 /* If NAME is the fully-qualified name of a C++
1116 function/variable/method/etc., this returns the length of its
1117 entire prefix: all of the namespaces and classes that make up its
1118 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1119 4, given 'foo', it returns 0. */
1120
1121 unsigned int
1122 cp_entire_prefix_len (const char *name)
1123 {
1124 unsigned int current_len = cp_find_first_component (name);
1125 unsigned int previous_len = 0;
1126
1127 while (name[current_len] != '\0')
1128 {
1129 gdb_assert (name[current_len] == ':');
1130 previous_len = current_len;
1131 /* Skip the '::'. */
1132 current_len += 2;
1133 current_len += cp_find_first_component (name + current_len);
1134 }
1135
1136 return previous_len;
1137 }
1138
1139 /* Overload resolution functions. */
1140
1141 /* Test to see if SYM is a symbol that we haven't seen corresponding
1142 to a function named OLOAD_NAME. If so, add it to the current
1143 completion list. */
1144
1145 static void
1146 overload_list_add_symbol (struct symbol *sym,
1147 const char *oload_name)
1148 {
1149 int newsize;
1150 int i;
1151 gdb::unique_xmalloc_ptr<char> sym_name;
1152
1153 /* If there is no type information, we can't do anything, so
1154 skip. */
1155 if (SYMBOL_TYPE (sym) == NULL)
1156 return;
1157
1158 /* skip any symbols that we've already considered. */
1159 for (i = 0; i < sym_return_val_index; ++i)
1160 if (strcmp (SYMBOL_LINKAGE_NAME (sym),
1161 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
1162 return;
1163
1164 /* Get the demangled name without parameters */
1165 sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
1166 if (!sym_name)
1167 return;
1168
1169 /* skip symbols that cannot match */
1170 if (strcmp (sym_name.get (), oload_name) != 0)
1171 return;
1172
1173 /* We have a match for an overload instance, so add SYM to the
1174 current list of overload instances */
1175 if (sym_return_val_index + 3 > sym_return_val_size)
1176 {
1177 newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
1178 sym_return_val = (struct symbol **)
1179 xrealloc ((char *) sym_return_val, newsize);
1180 }
1181 sym_return_val[sym_return_val_index++] = sym;
1182 sym_return_val[sym_return_val_index] = NULL;
1183 }
1184
1185 /* Return a null-terminated list of pointers to function symbols that
1186 are named FUNC_NAME and are visible within NAMESPACE. */
1187
1188 struct symbol **
1189 make_symbol_overload_list (const char *func_name,
1190 const char *the_namespace)
1191 {
1192 struct cleanup *old_cleanups;
1193 const char *name;
1194
1195 sym_return_val_size = 100;
1196 sym_return_val_index = 0;
1197 sym_return_val = XNEWVEC (struct symbol *, sym_return_val_size + 1);
1198 sym_return_val[0] = NULL;
1199
1200 old_cleanups = make_cleanup (xfree, sym_return_val);
1201
1202 make_symbol_overload_list_using (func_name, the_namespace);
1203
1204 if (the_namespace[0] == '\0')
1205 name = func_name;
1206 else
1207 {
1208 char *concatenated_name
1209 = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1210 strcpy (concatenated_name, the_namespace);
1211 strcat (concatenated_name, "::");
1212 strcat (concatenated_name, func_name);
1213 name = concatenated_name;
1214 }
1215
1216 make_symbol_overload_list_qualified (name);
1217
1218 discard_cleanups (old_cleanups);
1219
1220 return sym_return_val;
1221 }
1222
1223 /* Add all symbols with a name matching NAME in BLOCK to the overload
1224 list. */
1225
1226 static void
1227 make_symbol_overload_list_block (const char *name,
1228 const struct block *block)
1229 {
1230 struct block_iterator iter;
1231 struct symbol *sym;
1232
1233 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
1234
1235 ALL_BLOCK_SYMBOLS_WITH_NAME (block, lookup_name, iter, sym)
1236 overload_list_add_symbol (sym, name);
1237 }
1238
1239 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1240
1241 static void
1242 make_symbol_overload_list_namespace (const char *func_name,
1243 const char *the_namespace)
1244 {
1245 const char *name;
1246 const struct block *block = NULL;
1247
1248 if (the_namespace[0] == '\0')
1249 name = func_name;
1250 else
1251 {
1252 char *concatenated_name
1253 = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1254
1255 strcpy (concatenated_name, the_namespace);
1256 strcat (concatenated_name, "::");
1257 strcat (concatenated_name, func_name);
1258 name = concatenated_name;
1259 }
1260
1261 /* Look in the static block. */
1262 block = block_static_block (get_selected_block (0));
1263 if (block)
1264 make_symbol_overload_list_block (name, block);
1265
1266 /* Look in the global block. */
1267 block = block_global_block (block);
1268 if (block)
1269 make_symbol_overload_list_block (name, block);
1270
1271 }
1272
1273 /* Search the namespace of the given type and namespace of and public
1274 base types. */
1275
1276 static void
1277 make_symbol_overload_list_adl_namespace (struct type *type,
1278 const char *func_name)
1279 {
1280 char *the_namespace;
1281 const char *type_name;
1282 int i, prefix_len;
1283
1284 while (TYPE_CODE (type) == TYPE_CODE_PTR
1285 || TYPE_IS_REFERENCE (type)
1286 || TYPE_CODE (type) == TYPE_CODE_ARRAY
1287 || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1288 {
1289 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1290 type = check_typedef(type);
1291 else
1292 type = TYPE_TARGET_TYPE (type);
1293 }
1294
1295 type_name = TYPE_NAME (type);
1296
1297 if (type_name == NULL)
1298 return;
1299
1300 prefix_len = cp_entire_prefix_len (type_name);
1301
1302 if (prefix_len != 0)
1303 {
1304 the_namespace = (char *) alloca (prefix_len + 1);
1305 strncpy (the_namespace, type_name, prefix_len);
1306 the_namespace[prefix_len] = '\0';
1307
1308 make_symbol_overload_list_namespace (func_name, the_namespace);
1309 }
1310
1311 /* Check public base type */
1312 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1313 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1314 {
1315 if (BASETYPE_VIA_PUBLIC (type, i))
1316 make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type,
1317 i),
1318 func_name);
1319 }
1320 }
1321
1322 /* Adds the overload list overload candidates for FUNC_NAME found
1323 through argument dependent lookup. */
1324
1325 struct symbol **
1326 make_symbol_overload_list_adl (struct type **arg_types, int nargs,
1327 const char *func_name)
1328 {
1329 int i;
1330
1331 gdb_assert (sym_return_val_size != -1);
1332
1333 for (i = 1; i <= nargs; i++)
1334 make_symbol_overload_list_adl_namespace (arg_types[i - 1],
1335 func_name);
1336
1337 return sym_return_val;
1338 }
1339
1340 /* This applies the using directives to add namespaces to search in,
1341 and then searches for overloads in all of those namespaces. It
1342 adds the symbols found to sym_return_val. Arguments are as in
1343 make_symbol_overload_list. */
1344
1345 static void
1346 make_symbol_overload_list_using (const char *func_name,
1347 const char *the_namespace)
1348 {
1349 struct using_direct *current;
1350 const struct block *block;
1351
1352 /* First, go through the using directives. If any of them apply,
1353 look in the appropriate namespaces for new functions to match
1354 on. */
1355
1356 for (block = get_selected_block (0);
1357 block != NULL;
1358 block = BLOCK_SUPERBLOCK (block))
1359 for (current = block_using (block);
1360 current != NULL;
1361 current = current->next)
1362 {
1363 /* Prevent recursive calls. */
1364 if (current->searched)
1365 continue;
1366
1367 /* If this is a namespace alias or imported declaration ignore
1368 it. */
1369 if (current->alias != NULL || current->declaration != NULL)
1370 continue;
1371
1372 if (strcmp (the_namespace, current->import_dest) == 0)
1373 {
1374 /* Mark this import as searched so that the recursive call
1375 does not search it again. */
1376 scoped_restore reset_directive_searched
1377 = make_scoped_restore (&current->searched, 1);
1378
1379 make_symbol_overload_list_using (func_name,
1380 current->import_src);
1381 }
1382 }
1383
1384 /* Now, add names for this namespace. */
1385 make_symbol_overload_list_namespace (func_name, the_namespace);
1386 }
1387
1388 /* This does the bulk of the work of finding overloaded symbols.
1389 FUNC_NAME is the name of the overloaded function we're looking for
1390 (possibly including namespace info). */
1391
1392 static void
1393 make_symbol_overload_list_qualified (const char *func_name)
1394 {
1395 struct compunit_symtab *cust;
1396 struct objfile *objfile;
1397 const struct block *b, *surrounding_static_block = 0;
1398
1399 /* Look through the partial symtabs for all symbols which begin by
1400 matching FUNC_NAME. Make sure we read that symbol table in. */
1401
1402 ALL_OBJFILES (objfile)
1403 {
1404 if (objfile->sf)
1405 objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
1406 }
1407
1408 /* Search upwards from currently selected frame (so that we can
1409 complete on local vars. */
1410
1411 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1412 make_symbol_overload_list_block (func_name, b);
1413
1414 surrounding_static_block = block_static_block (get_selected_block (0));
1415
1416 /* Go through the symtabs and check the externs and statics for
1417 symbols which match. */
1418
1419 ALL_COMPUNITS (objfile, cust)
1420 {
1421 QUIT;
1422 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), GLOBAL_BLOCK);
1423 make_symbol_overload_list_block (func_name, b);
1424 }
1425
1426 ALL_COMPUNITS (objfile, cust)
1427 {
1428 QUIT;
1429 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
1430 /* Don't do this block twice. */
1431 if (b == surrounding_static_block)
1432 continue;
1433 make_symbol_overload_list_block (func_name, b);
1434 }
1435 }
1436
1437 /* Lookup the rtti type for a class name. */
1438
1439 struct type *
1440 cp_lookup_rtti_type (const char *name, struct block *block)
1441 {
1442 struct symbol * rtti_sym;
1443 struct type * rtti_type;
1444
1445 /* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
1446 Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
1447 rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;
1448
1449 if (rtti_sym == NULL)
1450 {
1451 warning (_("RTTI symbol not found for class '%s'"), name);
1452 return NULL;
1453 }
1454
1455 if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1456 {
1457 warning (_("RTTI symbol for class '%s' is not a type"), name);
1458 return NULL;
1459 }
1460
1461 rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym));
1462
1463 switch (TYPE_CODE (rtti_type))
1464 {
1465 case TYPE_CODE_STRUCT:
1466 break;
1467 case TYPE_CODE_NAMESPACE:
1468 /* chastain/2003-11-26: the symbol tables often contain fake
1469 symbols for namespaces with the same name as the struct.
1470 This warning is an indication of a bug in the lookup order
1471 or a bug in the way that the symbol tables are populated. */
1472 warning (_("RTTI symbol for class '%s' is a namespace"), name);
1473 return NULL;
1474 default:
1475 warning (_("RTTI symbol for class '%s' has bad type"), name);
1476 return NULL;
1477 }
1478
1479 return rtti_type;
1480 }
1481
1482 #ifdef HAVE_WORKING_FORK
1483
1484 /* If nonzero, attempt to catch crashes in the demangler and print
1485 useful debugging information. */
1486
1487 static int catch_demangler_crashes = 1;
1488
1489 /* Stack context and environment for demangler crash recovery. */
1490
1491 static SIGJMP_BUF gdb_demangle_jmp_buf;
1492
1493 /* If nonzero, attempt to dump core from the signal handler. */
1494
1495 static int gdb_demangle_attempt_core_dump = 1;
1496
1497 /* Signal handler for gdb_demangle. */
1498
1499 static void
1500 gdb_demangle_signal_handler (int signo)
1501 {
1502 if (gdb_demangle_attempt_core_dump)
1503 {
1504 if (fork () == 0)
1505 dump_core ();
1506
1507 gdb_demangle_attempt_core_dump = 0;
1508 }
1509
1510 SIGLONGJMP (gdb_demangle_jmp_buf, signo);
1511 }
1512
1513 #endif
1514
1515 /* A wrapper for bfd_demangle. */
1516
1517 char *
1518 gdb_demangle (const char *name, int options)
1519 {
1520 char *result = NULL;
1521 int crash_signal = 0;
1522
1523 #ifdef HAVE_WORKING_FORK
1524 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1525 struct sigaction sa, old_sa;
1526 #else
1527 sighandler_t ofunc;
1528 #endif
1529 static int core_dump_allowed = -1;
1530
1531 if (core_dump_allowed == -1)
1532 {
1533 core_dump_allowed = can_dump_core (LIMIT_CUR);
1534
1535 if (!core_dump_allowed)
1536 gdb_demangle_attempt_core_dump = 0;
1537 }
1538
1539 if (catch_demangler_crashes)
1540 {
1541 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1542 sa.sa_handler = gdb_demangle_signal_handler;
1543 sigemptyset (&sa.sa_mask);
1544 #ifdef HAVE_SIGALTSTACK
1545 sa.sa_flags = SA_ONSTACK;
1546 #else
1547 sa.sa_flags = 0;
1548 #endif
1549 sigaction (SIGSEGV, &sa, &old_sa);
1550 #else
1551 ofunc = signal (SIGSEGV, gdb_demangle_signal_handler);
1552 #endif
1553
1554 crash_signal = SIGSETJMP (gdb_demangle_jmp_buf);
1555 }
1556 #endif
1557
1558 if (crash_signal == 0)
1559 result = bfd_demangle (NULL, name, options);
1560
1561 #ifdef HAVE_WORKING_FORK
1562 if (catch_demangler_crashes)
1563 {
1564 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1565 sigaction (SIGSEGV, &old_sa, NULL);
1566 #else
1567 signal (SIGSEGV, ofunc);
1568 #endif
1569
1570 if (crash_signal != 0)
1571 {
1572 static int error_reported = 0;
1573
1574 if (!error_reported)
1575 {
1576 std::string short_msg
1577 = string_printf (_("unable to demangle '%s' "
1578 "(demangler failed with signal %d)"),
1579 name, crash_signal);
1580
1581 std::string long_msg
1582 = string_printf ("%s:%d: %s: %s", __FILE__, __LINE__,
1583 "demangler-warning", short_msg.c_str ());
1584
1585 target_terminal::scoped_restore_terminal_state term_state;
1586 target_terminal::ours_for_output ();
1587
1588 begin_line ();
1589 if (core_dump_allowed)
1590 fprintf_unfiltered (gdb_stderr,
1591 _("%s\nAttempting to dump core.\n"),
1592 long_msg.c_str ());
1593 else
1594 warn_cant_dump_core (long_msg.c_str ());
1595
1596 demangler_warning (__FILE__, __LINE__, "%s", short_msg.c_str ());
1597
1598 error_reported = 1;
1599 }
1600
1601 result = NULL;
1602 }
1603 }
1604 #endif
1605
1606 return result;
1607 }
1608
1609 /* See cp-support.h. */
1610
1611 int
1612 gdb_sniff_from_mangled_name (const char *mangled, char **demangled)
1613 {
1614 *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
1615 return *demangled != NULL;
1616 }
1617
1618 /* See cp-support.h. */
1619
1620 unsigned int
1621 cp_search_name_hash (const char *search_name)
1622 {
1623 /* cp_entire_prefix_len assumes a fully-qualified name with no
1624 leading "::". */
1625 if (startswith (search_name, "::"))
1626 search_name += 2;
1627
1628 unsigned int prefix_len = cp_entire_prefix_len (search_name);
1629 if (prefix_len != 0)
1630 search_name += prefix_len + 2;
1631
1632 unsigned int hash = 0;
1633 for (const char *string = search_name; *string != '\0'; ++string)
1634 {
1635 string = skip_spaces (string);
1636
1637 if (*string == '(')
1638 break;
1639
1640 /* Ignore ABI tags such as "[abi:cxx11]. */
1641 if (*string == '['
1642 && startswith (string + 1, "abi:")
1643 && string[5] != ':')
1644 break;
1645
1646 hash = SYMBOL_HASH_NEXT (hash, *string);
1647 }
1648 return hash;
1649 }
1650
1651 /* Helper for cp_symbol_name_matches (i.e., symbol_name_matcher_ftype
1652 implementation for symbol_name_match_type::WILD matching). Split
1653 to a separate function for unit-testing convenience.
1654
1655 If SYMBOL_SEARCH_NAME has more scopes than LOOKUP_NAME, we try to
1656 match ignoring the extra leading scopes of SYMBOL_SEARCH_NAME.
1657 This allows conveniently setting breakpoints on functions/methods
1658 inside any namespace/class without specifying the fully-qualified
1659 name.
1660
1661 E.g., these match:
1662
1663 [symbol search name] [lookup name]
1664 foo::bar::func foo::bar::func
1665 foo::bar::func bar::func
1666 foo::bar::func func
1667
1668 While these don't:
1669
1670 [symbol search name] [lookup name]
1671 foo::zbar::func bar::func
1672 foo::bar::func foo::func
1673
1674 See more examples in the test_cp_symbol_name_matches selftest
1675 function below.
1676
1677 See symbol_name_matcher_ftype for description of SYMBOL_SEARCH_NAME
1678 and COMP_MATCH_RES.
1679
1680 LOOKUP_NAME/LOOKUP_NAME_LEN is the name we're looking up.
1681
1682 See strncmp_iw_with_mode for description of MODE.
1683 */
1684
1685 static bool
1686 cp_symbol_name_matches_1 (const char *symbol_search_name,
1687 const char *lookup_name,
1688 size_t lookup_name_len,
1689 strncmp_iw_mode mode,
1690 completion_match_result *comp_match_res)
1691 {
1692 const char *sname = symbol_search_name;
1693 completion_match_for_lcd *match_for_lcd
1694 = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL);
1695
1696 while (true)
1697 {
1698 if (strncmp_iw_with_mode (sname, lookup_name, lookup_name_len,
1699 mode, language_cplus, match_for_lcd) == 0)
1700 {
1701 if (comp_match_res != NULL)
1702 {
1703 /* Note here we set different MATCH and MATCH_FOR_LCD
1704 strings. This is because with
1705
1706 (gdb) b push_bac[TAB]
1707
1708 we want the completion matches to list
1709
1710 std::vector<int>::push_back(...)
1711 std::vector<char>::push_back(...)
1712
1713 etc., which are SYMBOL_SEARCH_NAMEs, while we want
1714 the input line to auto-complete to
1715
1716 (gdb) push_back(...)
1717
1718 which is SNAME, not to
1719
1720 (gdb) std::vector<
1721
1722 which would be the regular common prefix between all
1723 the matches otherwise. */
1724 comp_match_res->set_match (symbol_search_name, sname);
1725 }
1726 return true;
1727 }
1728
1729 unsigned int len = cp_find_first_component (sname);
1730
1731 if (sname[len] == '\0')
1732 return false;
1733
1734 gdb_assert (sname[len] == ':');
1735 /* Skip the '::'. */
1736 sname += len + 2;
1737 }
1738 }
1739
1740 /* C++ symbol_name_matcher_ftype implementation. */
1741
1742 static bool
1743 cp_fq_symbol_name_matches (const char *symbol_search_name,
1744 const lookup_name_info &lookup_name,
1745 completion_match_result *comp_match_res)
1746 {
1747 /* Get the demangled name. */
1748 const std::string &name = lookup_name.cplus ().lookup_name ();
1749 completion_match_for_lcd *match_for_lcd
1750 = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL);
1751 strncmp_iw_mode mode = (lookup_name.completion_mode ()
1752 ? strncmp_iw_mode::NORMAL
1753 : strncmp_iw_mode::MATCH_PARAMS);
1754
1755 if (strncmp_iw_with_mode (symbol_search_name,
1756 name.c_str (), name.size (),
1757 mode, language_cplus, match_for_lcd) == 0)
1758 {
1759 if (comp_match_res != NULL)
1760 comp_match_res->set_match (symbol_search_name);
1761 return true;
1762 }
1763
1764 return false;
1765 }
1766
1767 /* C++ symbol_name_matcher_ftype implementation for wild matches.
1768 Defers work to cp_symbol_name_matches_1. */
1769
1770 static bool
1771 cp_symbol_name_matches (const char *symbol_search_name,
1772 const lookup_name_info &lookup_name,
1773 completion_match_result *comp_match_res)
1774 {
1775 /* Get the demangled name. */
1776 const std::string &name = lookup_name.cplus ().lookup_name ();
1777
1778 strncmp_iw_mode mode = (lookup_name.completion_mode ()
1779 ? strncmp_iw_mode::NORMAL
1780 : strncmp_iw_mode::MATCH_PARAMS);
1781
1782 return cp_symbol_name_matches_1 (symbol_search_name,
1783 name.c_str (), name.size (),
1784 mode, comp_match_res);
1785 }
1786
1787 /* See cp-support.h. */
1788
1789 symbol_name_matcher_ftype *
1790 cp_get_symbol_name_matcher (const lookup_name_info &lookup_name)
1791 {
1792 switch (lookup_name.match_type ())
1793 {
1794 case symbol_name_match_type::FULL:
1795 case symbol_name_match_type::EXPRESSION:
1796 case symbol_name_match_type::SEARCH_NAME:
1797 return cp_fq_symbol_name_matches;
1798 case symbol_name_match_type::WILD:
1799 return cp_symbol_name_matches;
1800 }
1801
1802 gdb_assert_not_reached ("");
1803 }
1804
1805 #if GDB_SELF_TEST
1806
1807 namespace selftests {
1808
1809 void
1810 test_cp_symbol_name_matches ()
1811 {
1812 #define CHECK_MATCH(SYMBOL, INPUT) \
1813 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, \
1814 INPUT, sizeof (INPUT) - 1, \
1815 strncmp_iw_mode::MATCH_PARAMS, \
1816 NULL))
1817
1818 #define CHECK_NOT_MATCH(SYMBOL, INPUT) \
1819 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, \
1820 INPUT, sizeof (INPUT) - 1, \
1821 strncmp_iw_mode::MATCH_PARAMS, \
1822 NULL))
1823
1824 /* Like CHECK_MATCH, and also check that INPUT (and all substrings
1825 that start at index 0) completes to SYMBOL. */
1826 #define CHECK_MATCH_C(SYMBOL, INPUT) \
1827 do \
1828 { \
1829 CHECK_MATCH (SYMBOL, INPUT); \
1830 for (size_t i = 0; i < sizeof (INPUT) - 1; i++) \
1831 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, INPUT, i, \
1832 strncmp_iw_mode::NORMAL, \
1833 NULL)); \
1834 } while (0)
1835
1836 /* Like CHECK_NOT_MATCH, and also check that INPUT does NOT complete
1837 to SYMBOL. */
1838 #define CHECK_NOT_MATCH_C(SYMBOL, INPUT) \
1839 do \
1840 { \
1841 CHECK_NOT_MATCH (SYMBOL, INPUT); \
1842 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, INPUT, \
1843 sizeof (INPUT) - 1, \
1844 strncmp_iw_mode::NORMAL, \
1845 NULL)); \
1846 } while (0)
1847
1848 /* Lookup name without parens matches all overloads. */
1849 CHECK_MATCH_C ("function()", "function");
1850 CHECK_MATCH_C ("function(int)", "function");
1851
1852 /* Check whitespace around parameters is ignored. */
1853 CHECK_MATCH_C ("function()", "function ()");
1854 CHECK_MATCH_C ("function ( )", "function()");
1855 CHECK_MATCH_C ("function ()", "function( )");
1856 CHECK_MATCH_C ("func(int)", "func( int )");
1857 CHECK_MATCH_C ("func(int)", "func ( int ) ");
1858 CHECK_MATCH_C ("func ( int )", "func( int )");
1859 CHECK_MATCH_C ("func ( int )", "func ( int ) ");
1860
1861 /* Check symbol name prefixes aren't incorrectly matched. */
1862 CHECK_NOT_MATCH ("func", "function");
1863 CHECK_NOT_MATCH ("function", "func");
1864 CHECK_NOT_MATCH ("function()", "func");
1865
1866 /* Check that if the lookup name includes parameters, only the right
1867 overload matches. */
1868 CHECK_MATCH_C ("function(int)", "function(int)");
1869 CHECK_NOT_MATCH_C ("function(int)", "function()");
1870
1871 /* Check that whitespace within symbol names is not ignored. */
1872 CHECK_NOT_MATCH_C ("function", "func tion");
1873 CHECK_NOT_MATCH_C ("func__tion", "func_ _tion");
1874 CHECK_NOT_MATCH_C ("func11tion", "func1 1tion");
1875
1876 /* Check the converse, which can happen with template function,
1877 where the return type is part of the demangled name. */
1878 CHECK_NOT_MATCH_C ("func tion", "function");
1879 CHECK_NOT_MATCH_C ("func1 1tion", "func11tion");
1880 CHECK_NOT_MATCH_C ("func_ _tion", "func__tion");
1881
1882 /* Within parameters too. */
1883 CHECK_NOT_MATCH_C ("func(param)", "func(par am)");
1884
1885 /* Check handling of whitespace around C++ operators. */
1886 CHECK_NOT_MATCH_C ("operator<<", "opera tor<<");
1887 CHECK_NOT_MATCH_C ("operator<<", "operator< <");
1888 CHECK_NOT_MATCH_C ("operator<<", "operator < <");
1889 CHECK_NOT_MATCH_C ("operator==", "operator= =");
1890 CHECK_NOT_MATCH_C ("operator==", "operator = =");
1891 CHECK_MATCH_C ("operator<<", "operator <<");
1892 CHECK_MATCH_C ("operator<<()", "operator <<");
1893 CHECK_NOT_MATCH_C ("operator<<()", "operator<<(int)");
1894 CHECK_NOT_MATCH_C ("operator<<(int)", "operator<<()");
1895 CHECK_MATCH_C ("operator==", "operator ==");
1896 CHECK_MATCH_C ("operator==()", "operator ==");
1897 CHECK_MATCH_C ("operator <<", "operator<<");
1898 CHECK_MATCH_C ("operator ==", "operator==");
1899 CHECK_MATCH_C ("operator bool", "operator bool");
1900 CHECK_MATCH_C ("operator bool ()", "operator bool");
1901 CHECK_MATCH_C ("operatorX<<", "operatorX < <");
1902 CHECK_MATCH_C ("Xoperator<<", "Xoperator < <");
1903
1904 CHECK_MATCH_C ("operator()(int)", "operator()(int)");
1905 CHECK_MATCH_C ("operator()(int)", "operator ( ) ( int )");
1906 CHECK_MATCH_C ("operator()<long>(int)", "operator ( ) < long > ( int )");
1907 /* The first "()" is not the parameter list. */
1908 CHECK_NOT_MATCH ("operator()(int)", "operator");
1909
1910 /* Misc user-defined operator tests. */
1911
1912 CHECK_NOT_MATCH_C ("operator/=()", "operator ^=");
1913 /* Same length at end of input. */
1914 CHECK_NOT_MATCH_C ("operator>>", "operator[]");
1915 /* Same length but not at end of input. */
1916 CHECK_NOT_MATCH_C ("operator>>()", "operator[]()");
1917
1918 CHECK_MATCH_C ("base::operator char*()", "base::operator char*()");
1919 CHECK_MATCH_C ("base::operator char*()", "base::operator char * ()");
1920 CHECK_MATCH_C ("base::operator char**()", "base::operator char * * ()");
1921 CHECK_MATCH ("base::operator char**()", "base::operator char * *");
1922 CHECK_MATCH_C ("base::operator*()", "base::operator*()");
1923 CHECK_NOT_MATCH_C ("base::operator char*()", "base::operatorc");
1924 CHECK_NOT_MATCH ("base::operator char*()", "base::operator char");
1925 CHECK_NOT_MATCH ("base::operator char*()", "base::operat");
1926
1927 /* Check handling of whitespace around C++ scope operators. */
1928 CHECK_NOT_MATCH_C ("foo::bar", "foo: :bar");
1929 CHECK_MATCH_C ("foo::bar", "foo :: bar");
1930 CHECK_MATCH_C ("foo :: bar", "foo::bar");
1931
1932 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi()");
1933 CHECK_MATCH_C ("abc::def::ghi ( )", "abc::def::ghi()");
1934 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi ( )");
1935 CHECK_MATCH_C ("function()", "function()");
1936 CHECK_MATCH_C ("bar::function()", "bar::function()");
1937
1938 /* Wild matching tests follow. */
1939
1940 /* Tests matching symbols in some scope. */
1941 CHECK_MATCH_C ("foo::function()", "function");
1942 CHECK_MATCH_C ("foo::function(int)", "function");
1943 CHECK_MATCH_C ("foo::bar::function()", "function");
1944 CHECK_MATCH_C ("bar::function()", "bar::function");
1945 CHECK_MATCH_C ("foo::bar::function()", "bar::function");
1946 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function");
1947
1948 /* Same, with parameters in the lookup name. */
1949 CHECK_MATCH_C ("foo::function()", "function()");
1950 CHECK_MATCH_C ("foo::bar::function()", "function()");
1951 CHECK_MATCH_C ("foo::function(int)", "function(int)");
1952 CHECK_MATCH_C ("foo::function()", "foo::function()");
1953 CHECK_MATCH_C ("foo::bar::function()", "bar::function()");
1954 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function(int)");
1955 CHECK_MATCH_C ("bar::function()", "bar::function()");
1956
1957 CHECK_NOT_MATCH_C ("foo::bar::function(int)", "bar::function()");
1958
1959 CHECK_MATCH_C ("(anonymous namespace)::bar::function(int)",
1960 "bar::function(int)");
1961 CHECK_MATCH_C ("foo::(anonymous namespace)::bar::function(int)",
1962 "function(int)");
1963
1964 /* Lookup scope wider than symbol scope, should not match. */
1965 CHECK_NOT_MATCH_C ("function()", "bar::function");
1966 CHECK_NOT_MATCH_C ("function()", "bar::function()");
1967
1968 /* Explicit global scope doesn't match. */
1969 CHECK_NOT_MATCH_C ("foo::function()", "::function");
1970 CHECK_NOT_MATCH_C ("foo::function()", "::function()");
1971 CHECK_NOT_MATCH_C ("foo::function(int)", "::function()");
1972 CHECK_NOT_MATCH_C ("foo::function(int)", "::function(int)");
1973
1974 /* Test ABI tag matching/ignoring. */
1975
1976 /* If the symbol name has an ABI tag, but the lookup name doesn't,
1977 then the ABI tag in the symbol name is ignored. */
1978 CHECK_MATCH_C ("function[abi:foo]()", "function");
1979 CHECK_MATCH_C ("function[abi:foo](int)", "function");
1980 CHECK_MATCH_C ("function[abi:foo]()", "function ()");
1981 CHECK_NOT_MATCH_C ("function[abi:foo]()", "function (int)");
1982
1983 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo]");
1984 CHECK_MATCH_C ("function[abi:foo](int)", "function[abi:foo]");
1985 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo] ()");
1986 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function");
1987 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function");
1988 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo]");
1989 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function[abi:foo]");
1990 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] ()");
1991 CHECK_NOT_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] (int)");
1992
1993 CHECK_MATCH_C ("function [abi:foo][abi:bar] ( )", "function [abi:foo]");
1994
1995 /* If the symbol name does not have an ABI tag, while the lookup
1996 name has one, then there's no match. */
1997 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]()");
1998 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]");
1999 }
2000
2001 /* If non-NULL, return STR wrapped in quotes. Otherwise, return a
2002 "<null>" string (with no quotes). */
2003
2004 static std::string
2005 quote (const char *str)
2006 {
2007 if (str != NULL)
2008 return std::string (1, '\"') + str + '\"';
2009 else
2010 return "<null>";
2011 }
2012
2013 /* Check that removing parameter info out of NAME produces EXPECTED.
2014 COMPLETION_MODE indicates whether we're testing normal and
2015 completion mode. FILE and LINE are used to provide better test
2016 location information in case ithe check fails. */
2017
2018 static void
2019 check_remove_params (const char *file, int line,
2020 const char *name, const char *expected,
2021 bool completion_mode)
2022 {
2023 gdb::unique_xmalloc_ptr<char> result
2024 = cp_remove_params_if_any (name, completion_mode);
2025
2026 if ((expected == NULL) != (result == NULL)
2027 || (expected != NULL
2028 && strcmp (result.get (), expected) != 0))
2029 {
2030 error (_("%s:%d: make-paramless self-test failed: (completion=%d) "
2031 "\"%s\" -> %s, expected %s"),
2032 file, line, completion_mode, name,
2033 quote (result.get ()).c_str (), quote (expected).c_str ());
2034 }
2035 }
2036
2037 /* Entry point for cp_remove_params unit tests. */
2038
2039 static void
2040 test_cp_remove_params ()
2041 {
2042 /* Check that removing parameter info out of NAME produces EXPECTED.
2043 Checks both normal and completion modes. */
2044 #define CHECK(NAME, EXPECTED) \
2045 do \
2046 { \
2047 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, false); \
2048 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \
2049 } \
2050 while (0)
2051
2052 /* Similar, but used when NAME is incomplete -- i.e., is has
2053 unbalanced parentheses. In this case, looking for the exact name
2054 should fail / return empty. */
2055 #define CHECK_INCOMPL(NAME, EXPECTED) \
2056 do \
2057 { \
2058 check_remove_params (__FILE__, __LINE__, NAME, NULL, false); \
2059 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \
2060 } \
2061 while (0)
2062
2063 CHECK ("function()", "function");
2064 CHECK_INCOMPL ("function(", "function");
2065 CHECK ("function() const", "function");
2066
2067 CHECK ("(anonymous namespace)::A::B::C",
2068 "(anonymous namespace)::A::B::C");
2069
2070 CHECK ("A::(anonymous namespace)",
2071 "A::(anonymous namespace)");
2072
2073 CHECK_INCOMPL ("A::(anonymou", "A");
2074
2075 CHECK ("A::foo<int>()",
2076 "A::foo<int>");
2077
2078 CHECK_INCOMPL ("A::foo<int>(",
2079 "A::foo<int>");
2080
2081 CHECK ("A::foo<(anonymous namespace)::B>::func(int)",
2082 "A::foo<(anonymous namespace)::B>::func");
2083
2084 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::func(in",
2085 "A::foo<(anonymous namespace)::B>::func");
2086
2087 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::",
2088 "A::foo<(anonymous namespace)::B>");
2089
2090 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>:",
2091 "A::foo<(anonymous namespace)::B>");
2092
2093 CHECK ("A::foo<(anonymous namespace)::B>",
2094 "A::foo<(anonymous namespace)::B>");
2095
2096 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B",
2097 "A::foo");
2098
2099 /* Shouldn't this parse? Looks like a bug in
2100 cp_demangled_name_to_comp. See PR c++/22411. */
2101 #if 0
2102 CHECK ("A::foo<void(int)>::func(int)",
2103 "A::foo<void(int)>::func");
2104 #else
2105 CHECK_INCOMPL ("A::foo<void(int)>::func(int)",
2106 "A::foo");
2107 #endif
2108
2109 CHECK_INCOMPL ("A::foo<void(int",
2110 "A::foo");
2111
2112 #undef CHECK
2113 #undef CHECK_INCOMPL
2114 }
2115
2116 } // namespace selftests
2117
2118 #endif /* GDB_SELF_CHECK */
2119
2120 /* Don't allow just "maintenance cplus". */
2121
2122 static void
2123 maint_cplus_command (const char *arg, int from_tty)
2124 {
2125 printf_unfiltered (_("\"maintenance cplus\" must be followed "
2126 "by the name of a command.\n"));
2127 help_list (maint_cplus_cmd_list,
2128 "maintenance cplus ",
2129 all_commands, gdb_stdout);
2130 }
2131
2132 /* This is a front end for cp_find_first_component, for unit testing.
2133 Be careful when using it: see the NOTE above
2134 cp_find_first_component. */
2135
2136 static void
2137 first_component_command (const char *arg, int from_tty)
2138 {
2139 int len;
2140 char *prefix;
2141
2142 if (!arg)
2143 return;
2144
2145 len = cp_find_first_component (arg);
2146 prefix = (char *) alloca (len + 1);
2147
2148 memcpy (prefix, arg, len);
2149 prefix[len] = '\0';
2150
2151 printf_unfiltered ("%s\n", prefix);
2152 }
2153
2154 /* Implement "info vtbl". */
2155
2156 static void
2157 info_vtbl_command (const char *arg, int from_tty)
2158 {
2159 struct value *value;
2160
2161 value = parse_and_eval (arg);
2162 cplus_print_vtable (value);
2163 }
2164
2165 void
2166 _initialize_cp_support (void)
2167 {
2168 add_prefix_cmd ("cplus", class_maintenance,
2169 maint_cplus_command,
2170 _("C++ maintenance commands."),
2171 &maint_cplus_cmd_list,
2172 "maintenance cplus ",
2173 0, &maintenancelist);
2174 add_alias_cmd ("cp", "cplus",
2175 class_maintenance, 1,
2176 &maintenancelist);
2177
2178 add_cmd ("first_component",
2179 class_maintenance,
2180 first_component_command,
2181 _("Print the first class/namespace component of NAME."),
2182 &maint_cplus_cmd_list);
2183
2184 add_info ("vtbl", info_vtbl_command,
2185 _("Show the virtual function table for a C++ object.\n\
2186 Usage: info vtbl EXPRESSION\n\
2187 Evaluate EXPRESSION and display the virtual function table for the\n\
2188 resulting object."));
2189
2190 #ifdef HAVE_WORKING_FORK
2191 add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance,
2192 &catch_demangler_crashes, _("\
2193 Set whether to attempt to catch demangler crashes."), _("\
2194 Show whether to attempt to catch demangler crashes."), _("\
2195 If enabled GDB will attempt to catch demangler crashes and\n\
2196 display the offending symbol."),
2197 NULL,
2198 NULL,
2199 &maintenance_set_cmdlist,
2200 &maintenance_show_cmdlist);
2201 #endif
2202
2203 #if GDB_SELF_TEST
2204 selftests::register_test ("cp_symbol_name_matches",
2205 selftests::test_cp_symbol_name_matches);
2206 selftests::register_test ("cp_remove_params",
2207 selftests::test_cp_remove_params);
2208 #endif
2209 }
TYPE_CODE_NAMESPACE
Definition: gdbtypes.h:171
string
const char * string
Definition: signals.c:50
CHECK
#define CHECK(LANG, NAME, EXPECTED)
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
cp_already_canonical
static int cp_already_canonical(const char *string)
Definition: cp-support.c:101
cp_demangled_name_to_comp
struct std::unique_ptr< demangle_parse_info > cp_demangled_name_to_comp(const char *demangled_name, const char **errmsg)
Definition: cp-name-parser.c:4266
SIGSETJMP
#define SIGSETJMP(buf)
Definition: gdb_setjmp.h:30
using_direct::import_dest
const char * import_dest
Definition: namespace.h:93
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
using_direct::alias
const char * alias
Definition: namespace.h:95
maint_cplus_command
static void maint_cplus_command(const char *arg, int from_tty)
Definition: cp-support.c:2123
RETURN_MASK_ALL
Definition: common-exceptions.h:44
TYPE_N_BASECLASSES
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1331
using_direct::import_src
const char * import_src
Definition: namespace.h:92
cp_merge_demangle_parse_infos
void cp_merge_demangle_parse_infos(struct demangle_parse_info *dest, struct demangle_component *target, struct demangle_parse_info *src)
Definition: cp-name-parser.c:4241
sym_return_val
static struct symbol ** sym_return_val
Definition: cp-support.c:55
ignore_typedefs
static const char *const ignore_typedefs[]
Definition: cp-support.c:70
cp_remove_params_1
static gdb::unique_xmalloc_ptr< char > cp_remove_params_1(const char *demangled_name, bool require_params)
Definition: cp-support.c:841
xfree
void xfree(void *)
cp_comp_to_string
gdb::unique_xmalloc_ptr< char > cp_comp_to_string(struct demangle_component *result, int estimated_len)
Definition: cp-name-parser.c:4195
demangled_name_complaint
static void demangled_name_complaint(const char *name)
Definition: cp-support.c:1109
cmd_list_element
Definition: cli-decode.h:46
warning
void warning(const char *fmt,...)
Definition: errors.c:26
symbol_search_name
const char * symbol_search_name(const struct general_symbol_info *gsymbol)
Definition: symtab.c:943
TYPE_NAME
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1224
gdb_setjmp.h
demangle_for_lookup_info::lookup_name
const std::string & lookup_name() const
Definition: symtab.h:159
block_global_block
const struct block * block_global_block(const struct block *block)
Definition: block.c:379
cp_func_name
char * cp_func_name(const char *full_name)
Definition: cp-support.c:816
lookup_name_info::completion_mode
bool completion_mode() const
Definition: symtab.h:195
sym_return_val_index
static int sym_return_val_index
Definition: cp-support.c:54
add_info
struct cmd_list_element * add_info(const char *name, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:886
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
sym_return_val_size
static int sym_return_val_size
Definition: cp-support.c:53
strncmp_iw_mode::MATCH_PARAMS
symbol_name_matcher_ftype
bool() symbol_name_matcher_ftype(const char *symbol_search_name, const lookup_name_info &lookup_name, completion_match_result *comp_match_res)
Definition: symtab.h:324
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
type_print
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:358
cp-support.h
compunit_symtab
Definition: symtab.h:1380
string_file::write
void write(const char *buf, long length_buf) override
Definition: ui-file.c:138
LOC_TYPEDEF
Definition: symtab.h:844
BLOCKVECTOR_BLOCK
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:125
lookup_symbol
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1893
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
cleanup
Definition: cleanups.c:38
_
#define _(String)
Definition: gdb_locale.h:35
cp_find_first_component_aux
static unsigned int cp_find_first_component_aux(const char *name, int permissive)
Definition: cp-support.c:981
demangler_warning
void demangler_warning(const char *file, int line, const char *string,...)
Definition: utils.c:543
defs.h
cp_symbol_name_matches_1
static bool cp_symbol_name_matches_1(const char *symbol_search_name, const char *lookup_name, size_t lookup_name_len, strncmp_iw_mode mode, completion_match_result *comp_match_res)
Definition: cp-support.c:1686
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
replace_typedefs
static void replace_typedefs(struct demangle_parse_info *info, struct demangle_component *ret_comp, canonicalization_ftype *finder, void *data)
Definition: cp-support.c:407
selftests
Definition: selftest.c:25
maintenance_set_cmdlist
struct cmd_list_element * maintenance_set_cmdlist
Definition: maint.c:634
method_name_from_physname
char * method_name_from_physname(const char *physname)
Definition: cp-support.c:784
cp_search_name_hash
unsigned int cp_search_name_hash(const char *search_name)
Definition: cp-support.c:1621
objfiles.h
completion_match_result
Definition: completer.h:205
strncmp_iw_with_mode
int strncmp_iw_with_mode(const char *string1, const char *string2, size_t string2_len, strncmp_iw_mode mode, enum language language, completion_match_for_lcd *match_for_lcd)
Definition: utils.c:2277
TYPE_IS_REFERENCE
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:332
make_symbol_overload_list_adl
struct symbol ** make_symbol_overload_list_adl(struct type **arg_types, int nargs, const char *func_name)
Definition: cp-support.c:1326
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:367
lookup_name_info::match_type
symbol_name_match_type match_type() const
Definition: symtab.h:194
make_scoped_restore
scoped_restore_tmpl< T > make_scoped_restore(T *var)
Definition: scoped_restore.h:105
GLOBAL_BLOCK
Definition: defs.h:686
make_symbol_overload_list_qualified
static void make_symbol_overload_list_qualified(const char *func_name)
Definition: cp-support.c:1393
d_right
#define d_right(dc)
Definition: cp-support.c:42
TRY
#define TRY
Definition: common-exceptions.h:246
symtab.h
TYPE_CODE_TYPEDEF
Definition: gdbtypes.h:169
name
const char *const name
Definition: aarch64-tdep.c:76
gdb_demangle
char * gdb_demangle(const char *name, int options)
Definition: cp-support.c:1518
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
cp_canonicalize_string_no_typedefs
std::string cp_canonicalize_string_no_typedefs(const char *string)
Definition: cp-support.c:542
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
gdb_demangle_jmp_buf
static SIGJMP_BUF gdb_demangle_jmp_buf
Definition: cp-support.c:1491
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
cp_lookup_rtti_type
struct type * cp_lookup_rtti_type(const char *name, struct block *block)
Definition: cp-support.c:1440
SIGLONGJMP
#define SIGLONGJMP(buf, val)
Definition: gdb_setjmp.h:31
objfile::objfile
objfile(bfd *, const char *, objfile_flags)
Definition: objfiles.c:373
make_symbol_overload_list
struct symbol ** make_symbol_overload_list(const char *func_name, const char *the_namespace)
Definition: cp-support.c:1189
cp_find_first_component
unsigned int cp_find_first_component(const char *name)
Definition: cp-support.c:970
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
SYMBOL_HASH_NEXT
#define SYMBOL_HASH_NEXT(hash, c)
Definition: minsyms.h:184
namespace.h
symbol_name_match_type::EXPRESSION
frame.h
expression.h
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
objfile::sf
const struct sym_fns * sf
Definition: objfiles.h:381
_initialize_cp_support
void _initialize_cp_support(void)
Definition: cp-support.c:2166
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
info_vtbl_command
static void info_vtbl_command(const char *arg, int from_tty)
Definition: cp-support.c:2157
TYPE_CODE_UNION
Definition: gdbtypes.h:107
ALL_COMPUNITS
#define ALL_COMPUNITS(objfile, cu)
Definition: objfiles.h:619
block_using
struct using_direct * block_using(const struct block *block)
Definition: block.c:324
scoped_restore_base
Definition: scoped_restore.h:24
type
Definition: gdbtypes.h:749
demangle_parse_info::obstack
struct obstack obstack
Definition: cp-support.h:72
using_direct::searched
int searched
Definition: namespace.h:102
BLOCK_SUPERBLOCK
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:108
maint_cplus_cmd_list
struct cmd_list_element * maint_cplus_cmd_list
Definition: cp-support.c:67
unqualified_name_from_comp
static struct demangle_component * unqualified_name_from_comp(struct demangle_component *comp)
Definition: cp-support.c:729
using_direct
Definition: namespace.h:90
string_file::clear
void clear()
Definition: ui-file.h:140
type
static const char * type
Definition: language.c:113
SYMBOL_LINKAGE_NAME
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:523
canonicalization_ftype
const char *() canonicalization_ftype(struct type *, void *)
Definition: cp-support.h:82
complaint
#define complaint(COMPLAINTS, FMT,...)
Definition: complaints.h:40
startswith
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:107
strncmp_iw_mode::NORMAL
string_file::size
size_t size() const
Definition: ui-file.h:138
cp_get_symbol_name_matcher
symbol_name_matcher_ftype * cp_get_symbol_name_matcher(const lookup_name_info &lookup_name)
Definition: cp-support.c:1790
demangle_parse_info
Definition: cp-support.h:59
TYPE_BASECLASS
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1330
quick_symbol_functions::expand_symtabs_for_function
void(* expand_symtabs_for_function)(struct objfile *objfile, const char *func_name)
Definition: symfile.h:197
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
SIGJMP_BUF
#define SIGJMP_BUF
Definition: gdb_setjmp.h:29
make_symbol_overload_list_namespace
static void make_symbol_overload_list_namespace(const char *func_name, const char *the_namespace)
Definition: cp-support.c:1242
ui_file::puts
virtual void puts(const char *str)
Definition: ui-file.h:63
completion_match_result::match_for_lcd
completion_match_for_lcd match_for_lcd
Definition: completer.h:211
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
complaints.h
target_terminal::ours_for_output
static void ours_for_output()
Definition: target.c:501
target_terminal::scoped_restore_terminal_state
Definition: target.h:166
add_alias_cmd
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *old, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:306
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
value
Definition: value.c:169
hash
unsigned long hash(const void *addr, int length)
Definition: bcache.c:98
cp_canonicalize_string_full
std::string cp_canonicalize_string_full(const char *string, canonicalization_ftype *finder, void *data)
Definition: cp-support.c:508
using_direct::next
struct using_direct * next
Definition: namespace.h:98
CP_OPERATOR_STR
#define CP_OPERATOR_STR
Definition: cp-support.h:51
CP_OPERATOR_LEN
#define CP_OPERATOR_LEN
Definition: cp-support.h:55
cp_symbol_name_matches
static bool cp_symbol_name_matches(const char *symbol_search_name, const lookup_name_info &lookup_name, completion_match_result *comp_match_res)
Definition: cp-support.c:1771
xrealloc
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:52
cp_class_name_from_physname
char * cp_class_name_from_physname(const char *physname)
Definition: cp-support.c:636
objfile
Definition: objfiles.h:286
check_cv_qualifiers
static void check_cv_qualifiers(struct demangle_component *ret_comp)
Definition: cp-support.c:393
TYPE_CODE_PTR
Definition: gdbtypes.h:84
COMPUNIT_BLOCKVECTOR
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1465
mangled_name_to_comp
static std::unique_ptr< demangle_parse_info > mangled_name_to_comp(const char *mangled_name, int options, void **memory, char **demangled_p)
Definition: cp-support.c:590
help_list
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1071
XNEWVEC
#define XNEWVEC(T, N)
Definition: poison.h:145
discard_cleanups
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:212
lookup_name_info::cplus
const demangle_for_lookup_info & cplus() const
Definition: symtab.h:247
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
completion_match_result::set_match
void set_match(const char *m, const char *m_for_lcd=NULL)
Definition: completer.h:215
strncmp_iw_mode
strncmp_iw_mode
Definition: utils.h:36
overload_list_add_symbol
static void overload_list_add_symbol(struct symbol *sym, const char *oload_name)
Definition: cp-support.c:1146
gdb_stderr
#define gdb_stderr
Definition: utils.h:344
make_symbol_overload_list_block
static void make_symbol_overload_list_block(const char *name, const struct block *block)
Definition: cp-support.c:1227
block_static_block
const struct block * block_static_block(const struct block *block)
Definition: block.c:364
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
string_file::c_str
const char * c_str() const
Definition: ui-file.h:137
symbol_name_match_type::SEARCH_NAME
symfile_complaints
struct complaints * symfile_complaints
Definition: complaints.c:96
cp_remove_params_if_any
gdb::unique_xmalloc_ptr< char > cp_remove_params_if_any(const char *demangled_name, bool completion_mode)
Definition: cp-support.c:900
gdb_sniff_from_mangled_name
int gdb_sniff_from_mangled_name(const char *mangled, char **demangled)
Definition: cp-support.c:1612
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
LIMIT_CUR
Definition: utils.h:537
inspect_type
static int inspect_type(struct demangle_parse_info *info, struct demangle_component *ret_comp, canonicalization_ftype *finder, void *data)
Definition: cp-support.c:131
cp_fq_symbol_name_matches
static bool cp_fq_symbol_name_matches(const char *symbol_search_name, const lookup_name_info &lookup_name, completion_match_result *comp_match_res)
Definition: cp-support.c:1743
cp_canonicalize_string
std::string cp_canonicalize_string(const char *string)
Definition: cp-support.c:552
gdb_demangle_attempt_core_dump
static int gdb_demangle_attempt_core_dump
Definition: cp-support.c:1495
VAR_DOMAIN
Definition: symtab.h:739
string_printf
std::string string_printf(const char *fmt,...)
Definition: common-utils.c:150
value.h
ofunc
static sighandler_t ofunc
Definition: nto-procfs.c:53
block_iterator
Definition: block.h:197
TYPE_TAG_NAME
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1225
completion_match_for_lcd
Definition: completer.h:134
get_selected_block
const struct block * get_selected_block(CORE_ADDR *addr_in_block)
Definition: stack.c:2216
SYMBOL_NATURAL_NAME
#define SYMBOL_NATURAL_NAME(symbol)
Definition: symtab.h:513
gdbtypes.h
parse_and_eval
struct value * parse_and_eval(const char *exp)
Definition: eval.c:119
BASETYPE_VIA_PUBLIC
#define BASETYPE_VIA_PUBLIC(thistype, index)
Definition: gdbtypes.h:1334
STATIC_BLOCK
Definition: defs.h:687
CHECK_INCOMPL
#define CHECK_INCOMPL(LANG, NAME, EXPECTED)
can_dump_core
int can_dump_core(enum resource_limit_kind limit_kind)
Definition: utils.c:293
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
symbol
Definition: symtab.h:1049
selftest.h
maintenancelist
struct cmd_list_element * maintenancelist
Definition: cli-cmds.c:135
all_commands
Definition: command.h:39
warn_cant_dump_core
void warn_cant_dump_core(const char *reason)
Definition: utils.c:320
catch_demangler_crashes
static int catch_demangler_crashes
Definition: cp-support.c:1487
cplus_print_vtable
void cplus_print_vtable(struct value *value)
Definition: cp-abi.c:176
class_maintenance
Definition: command.h:43
ALL_BLOCK_SYMBOLS_WITH_NAME
#define ALL_BLOCK_SYMBOLS_WITH_NAME(block, name, iter, sym)
Definition: block.h:320
ALL_OBJFILES
#define ALL_OBJFILES(obj)
Definition: objfiles.h:582
QUIT
#define QUIT
Definition: defs.h:179
make_symbol_overload_list_adl_namespace
static void make_symbol_overload_list_adl_namespace(struct type *type, const char *func_name)
Definition: cp-support.c:1277
sym_fns::qf
const struct quick_symbol_functions * qf
Definition: symfile.h:369
first_component_command
static void first_component_command(const char *arg, int from_tty)
Definition: cp-support.c:2137
symbol_name_match_type::FULL
using_direct::declaration
const char * declaration
Definition: namespace.h:96
lookup_name_info
Definition: symtab.h:179
maintenance_show_cmdlist
struct cmd_list_element * maintenance_show_cmdlist
Definition: maint.c:635
d_left
#define d_left(dc)
Definition: cp-support.c:41
gdbcmd.h
cp_entire_prefix_len
unsigned int cp_entire_prefix_len(const char *name)
Definition: cp-support.c:1122
replace_typedefs_qualified_name
static void replace_typedefs_qualified_name(struct demangle_parse_info *info, struct demangle_component *ret_comp, canonicalization_ftype *finder, void *data)
Definition: cp-support.c:290
selftests::register_test
void register_test(const std::string &name, selftest *test)
Definition: selftest.c:52
language_cplus
Definition: defs.h:209
error
void error(const char *fmt,...)
Definition: errors.c:38
dictionary.h
make_symbol_overload_list_using
static void make_symbol_overload_list_using(const char *func_name, const char *the_namespace)
Definition: cp-support.c:1346
symbol_name_match_type::WILD
block.h
copy_string_to_obstack
static char * copy_string_to_obstack(struct obstack *obstack, const char *string, long *len)
Definition: cp-support.c:87
cp-abi.h
begin_line
void begin_line(void)
Definition: utils.c:1682
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
gdb_demangle_signal_handler
static void gdb_demangle_signal_handler(int signo)
Definition: cp-support.c:1500
dump_core
void dump_core(void)
Definition: utils.c:276
cp_remove_params
gdb::unique_xmalloc_ptr< char > cp_remove_params(const char *demangled_name)
Definition: cp-support.c:892
string_file
Definition: ui-file.h:106