1 /* Helper routines for C++ support in GDB. 2 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010 3 Free Software Foundation, Inc. 4 5 Contributed by MontaVista Software. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "cp-support.h" 24 #include "gdb_string.h" 25 #include "demangle.h" 26 #include "gdb_assert.h" 27 #include "gdbcmd.h" 28 #include "dictionary.h" 29 #include "objfiles.h" 30 #include "frame.h" 31 #include "symtab.h" 32 #include "block.h" 33 #include "complaints.h" 34 #include "gdbtypes.h" 35 #include "exceptions.h" 36 #include "expression.h" 37 #include "value.h" 38 39 #include "safe-ctype.h" 40 41 #include "psymtab.h" 42 43 #define d_left(dc) (dc)->u.s_binary.left 44 #define d_right(dc) (dc)->u.s_binary.right 45 46 /* Functions related to demangled name parsing. */ 47 48 static unsigned int cp_find_first_component_aux (const char *name, 49 int permissive); 50 51 static void demangled_name_complaint (const char *name); 52 53 /* Functions/variables related to overload resolution. */ 54 55 static int sym_return_val_size = -1; 56 static int sym_return_val_index; 57 static struct symbol **sym_return_val; 58 59 static void overload_list_add_symbol (struct symbol *sym, 60 const char *oload_name); 61 62 static void make_symbol_overload_list_using (const char *func_name, 63 const char *namespace); 64 65 static void make_symbol_overload_list_qualified (const char *func_name); 66 67 /* The list of "maint cplus" commands. */ 68 69 struct cmd_list_element *maint_cplus_cmd_list = NULL; 70 71 /* The actual commands. */ 72 73 static void maint_cplus_command (char *arg, int from_tty); 74 static void first_component_command (char *arg, int from_tty); 75 76 /* Operator validation. 77 NOTE: Multi-byte operators (usually the assignment variety operator) 78 must appear before the single byte version, i.e., "+=" before "+". */ 79 static const char *operator_tokens[] = 80 { 81 "++", "+=", "+", "->*", "->", "--", "-=", "-", "*=", "*", "/=", "/", 82 "%=", "%", "!=", "==", "!", "&&", "<<=", "<<", ">>=", ">>", 83 "<=", "<", ">=", ">", "~", "&=", "&", "|=", "||", "|", "^=", "^", 84 "=", "()", "[]", ",", "new", "delete" 85 /* new[] and delete[] require special whitespace handling */ 86 }; 87 88 /* Return 1 if STRING is clearly already in canonical form. This 89 function is conservative; things which it does not recognize are 90 assumed to be non-canonical, and the parser will sort them out 91 afterwards. This speeds up the critical path for alphanumeric 92 identifiers. */ 93 94 static int 95 cp_already_canonical (const char *string) 96 { 97 /* Identifier start character [a-zA-Z_]. */ 98 if (!ISIDST (string[0])) 99 return 0; 100 101 /* These are the only two identifiers which canonicalize to other 102 than themselves or an error: unsigned -> unsigned int and 103 signed -> int. */ 104 if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0) 105 return 0; 106 else if (string[0] == 's' && strcmp (&string[1], "igned") == 0) 107 return 0; 108 109 /* Identifier character [a-zA-Z0-9_]. */ 110 while (ISIDNUM (string[1])) 111 string++; 112 113 if (string[1] == '\0') 114 return 1; 115 else 116 return 0; 117 } 118 119 /* Parse STRING and convert it to canonical form. If parsing fails, 120 or if STRING is already canonical, return NULL. Otherwise return 121 the canonical form. The return value is allocated via xmalloc. */ 122 123 char * 124 cp_canonicalize_string (const char *string) 125 { 126 struct demangle_component *ret_comp; 127 unsigned int estimated_len; 128 char *ret; 129 130 if (cp_already_canonical (string)) 131 return NULL; 132 133 ret_comp = cp_demangled_name_to_comp (string, NULL); 134 if (ret_comp == NULL) 135 return NULL; 136 137 estimated_len = strlen (string) * 2; 138 ret = cp_comp_to_string (ret_comp, estimated_len); 139 140 if (strcmp (string, ret) == 0) 141 { 142 xfree (ret); 143 return NULL; 144 } 145 146 return ret; 147 } 148 149 /* Convert a mangled name to a demangle_component tree. *MEMORY is set to the 150 block of used memory that should be freed when finished with the tree. 151 DEMANGLED_P is set to the char * that should be freed when finished with 152 the tree, or NULL if none was needed. OPTIONS will be passed to the 153 demangler. */ 154 155 static struct demangle_component * 156 mangled_name_to_comp (const char *mangled_name, int options, 157 void **memory, char **demangled_p) 158 { 159 struct demangle_component *ret; 160 char *demangled_name; 161 162 /* If it looks like a v3 mangled name, then try to go directly 163 to trees. */ 164 if (mangled_name[0] == '_' && mangled_name[1] == 'Z') 165 { 166 ret = cplus_demangle_v3_components (mangled_name, options, memory); 167 if (ret) 168 { 169 *demangled_p = NULL; 170 return ret; 171 } 172 } 173 174 /* If it doesn't, or if that failed, then try to demangle the name. */ 175 demangled_name = cplus_demangle (mangled_name, options); 176 if (demangled_name == NULL) 177 return NULL; 178 179 /* If we could demangle the name, parse it to build the component tree. */ 180 ret = cp_demangled_name_to_comp (demangled_name, NULL); 181 182 if (ret == NULL) 183 { 184 xfree (demangled_name); 185 return NULL; 186 } 187 188 *demangled_p = demangled_name; 189 return ret; 190 } 191 192 /* Return the name of the class containing method PHYSNAME. */ 193 194 char * 195 cp_class_name_from_physname (const char *physname) 196 { 197 void *storage = NULL; 198 char *demangled_name = NULL, *ret; 199 struct demangle_component *ret_comp, *prev_comp, *cur_comp; 200 int done; 201 202 ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage, 203 &demangled_name); 204 if (ret_comp == NULL) 205 return NULL; 206 207 done = 0; 208 209 /* First strip off any qualifiers, if we have a function or method. */ 210 while (!done) 211 switch (ret_comp->type) 212 { 213 case DEMANGLE_COMPONENT_CONST: 214 case DEMANGLE_COMPONENT_RESTRICT: 215 case DEMANGLE_COMPONENT_VOLATILE: 216 case DEMANGLE_COMPONENT_CONST_THIS: 217 case DEMANGLE_COMPONENT_RESTRICT_THIS: 218 case DEMANGLE_COMPONENT_VOLATILE_THIS: 219 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 220 ret_comp = d_left (ret_comp); 221 break; 222 default: 223 done = 1; 224 break; 225 } 226 227 /* If what we have now is a function, discard the argument list. */ 228 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME) 229 ret_comp = d_left (ret_comp); 230 231 /* If what we have now is a template, strip off the template 232 arguments. The left subtree may be a qualified name. */ 233 if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE) 234 ret_comp = d_left (ret_comp); 235 236 /* What we have now should be a name, possibly qualified. Additional 237 qualifiers could live in the left subtree or the right subtree. Find 238 the last piece. */ 239 done = 0; 240 prev_comp = NULL; 241 cur_comp = ret_comp; 242 while (!done) 243 switch (cur_comp->type) 244 { 245 case DEMANGLE_COMPONENT_QUAL_NAME: 246 case DEMANGLE_COMPONENT_LOCAL_NAME: 247 prev_comp = cur_comp; 248 cur_comp = d_right (cur_comp); 249 break; 250 case DEMANGLE_COMPONENT_TEMPLATE: 251 case DEMANGLE_COMPONENT_NAME: 252 case DEMANGLE_COMPONENT_CTOR: 253 case DEMANGLE_COMPONENT_DTOR: 254 case DEMANGLE_COMPONENT_OPERATOR: 255 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 256 done = 1; 257 break; 258 default: 259 done = 1; 260 cur_comp = NULL; 261 break; 262 } 263 264 ret = NULL; 265 if (cur_comp != NULL && prev_comp != NULL) 266 { 267 /* We want to discard the rightmost child of PREV_COMP. */ 268 *prev_comp = *d_left (prev_comp); 269 /* The ten is completely arbitrary; we don't have a good estimate. */ 270 ret = cp_comp_to_string (ret_comp, 10); 271 } 272 273 xfree (storage); 274 if (demangled_name) 275 xfree (demangled_name); 276 return ret; 277 } 278 279 /* Return the child of COMP which is the basename of a method, variable, 280 et cetera. All scope qualifiers are discarded, but template arguments 281 will be included. The component tree may be modified. */ 282 283 static struct demangle_component * 284 unqualified_name_from_comp (struct demangle_component *comp) 285 { 286 struct demangle_component *ret_comp = comp, *last_template; 287 int done; 288 289 done = 0; 290 last_template = NULL; 291 while (!done) 292 switch (ret_comp->type) 293 { 294 case DEMANGLE_COMPONENT_QUAL_NAME: 295 case DEMANGLE_COMPONENT_LOCAL_NAME: 296 ret_comp = d_right (ret_comp); 297 break; 298 case DEMANGLE_COMPONENT_TYPED_NAME: 299 ret_comp = d_left (ret_comp); 300 break; 301 case DEMANGLE_COMPONENT_TEMPLATE: 302 gdb_assert (last_template == NULL); 303 last_template = ret_comp; 304 ret_comp = d_left (ret_comp); 305 break; 306 case DEMANGLE_COMPONENT_CONST: 307 case DEMANGLE_COMPONENT_RESTRICT: 308 case DEMANGLE_COMPONENT_VOLATILE: 309 case DEMANGLE_COMPONENT_CONST_THIS: 310 case DEMANGLE_COMPONENT_RESTRICT_THIS: 311 case DEMANGLE_COMPONENT_VOLATILE_THIS: 312 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 313 ret_comp = d_left (ret_comp); 314 break; 315 case DEMANGLE_COMPONENT_NAME: 316 case DEMANGLE_COMPONENT_CTOR: 317 case DEMANGLE_COMPONENT_DTOR: 318 case DEMANGLE_COMPONENT_OPERATOR: 319 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 320 done = 1; 321 break; 322 default: 323 return NULL; 324 break; 325 } 326 327 if (last_template) 328 { 329 d_left (last_template) = ret_comp; 330 return last_template; 331 } 332 333 return ret_comp; 334 } 335 336 /* Return the name of the method whose linkage name is PHYSNAME. */ 337 338 char * 339 method_name_from_physname (const char *physname) 340 { 341 void *storage = NULL; 342 char *demangled_name = NULL, *ret; 343 struct demangle_component *ret_comp; 344 345 ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage, 346 &demangled_name); 347 if (ret_comp == NULL) 348 return NULL; 349 350 ret_comp = unqualified_name_from_comp (ret_comp); 351 352 ret = NULL; 353 if (ret_comp != NULL) 354 /* The ten is completely arbitrary; we don't have a good estimate. */ 355 ret = cp_comp_to_string (ret_comp, 10); 356 357 xfree (storage); 358 if (demangled_name) 359 xfree (demangled_name); 360 return ret; 361 } 362 363 /* If FULL_NAME is the demangled name of a C++ function (including an 364 arg list, possibly including namespace/class qualifications), 365 return a new string containing only the function name (without the 366 arg list/class qualifications). Otherwise, return NULL. The 367 caller is responsible for freeing the memory in question. */ 368 369 char * 370 cp_func_name (const char *full_name) 371 { 372 char *ret; 373 struct demangle_component *ret_comp; 374 375 ret_comp = cp_demangled_name_to_comp (full_name, NULL); 376 if (!ret_comp) 377 return NULL; 378 379 ret_comp = unqualified_name_from_comp (ret_comp); 380 381 ret = NULL; 382 if (ret_comp != NULL) 383 ret = cp_comp_to_string (ret_comp, 10); 384 385 return ret; 386 } 387 388 /* DEMANGLED_NAME is the name of a function, including parameters and 389 (optionally) a return type. Return the name of the function without 390 parameters or return type, or NULL if we can not parse the name. */ 391 392 char * 393 cp_remove_params (const char *demangled_name) 394 { 395 int done = 0; 396 struct demangle_component *ret_comp; 397 char *ret = NULL; 398 399 if (demangled_name == NULL) 400 return NULL; 401 402 ret_comp = cp_demangled_name_to_comp (demangled_name, NULL); 403 if (ret_comp == NULL) 404 return NULL; 405 406 /* First strip off any qualifiers, if we have a function or method. */ 407 while (!done) 408 switch (ret_comp->type) 409 { 410 case DEMANGLE_COMPONENT_CONST: 411 case DEMANGLE_COMPONENT_RESTRICT: 412 case DEMANGLE_COMPONENT_VOLATILE: 413 case DEMANGLE_COMPONENT_CONST_THIS: 414 case DEMANGLE_COMPONENT_RESTRICT_THIS: 415 case DEMANGLE_COMPONENT_VOLATILE_THIS: 416 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 417 ret_comp = d_left (ret_comp); 418 break; 419 default: 420 done = 1; 421 break; 422 } 423 424 /* What we have now should be a function. Return its name. */ 425 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME) 426 ret = cp_comp_to_string (d_left (ret_comp), 10); 427 428 return ret; 429 } 430 431 /* Here are some random pieces of trivia to keep in mind while trying 432 to take apart demangled names: 433 434 - Names can contain function arguments or templates, so the process 435 has to be, to some extent recursive: maybe keep track of your 436 depth based on encountering <> and (). 437 438 - Parentheses don't just have to happen at the end of a name: they 439 can occur even if the name in question isn't a function, because 440 a template argument might be a type that's a function. 441 442 - Conversely, even if you're trying to deal with a function, its 443 demangled name might not end with ')': it could be a const or 444 volatile class method, in which case it ends with "const" or 445 "volatile". 446 447 - Parentheses are also used in anonymous namespaces: a variable 448 'foo' in an anonymous namespace gets demangled as "(anonymous 449 namespace)::foo". 450 451 - And operator names can contain parentheses or angle brackets. */ 452 453 /* FIXME: carlton/2003-03-13: We have several functions here with 454 overlapping functionality; can we combine them? Also, do they 455 handle all the above considerations correctly? */ 456 457 458 /* This returns the length of first component of NAME, which should be 459 the demangled name of a C++ variable/function/method/etc. 460 Specifically, it returns the index of the first colon forming the 461 boundary of the first component: so, given 'A::foo' or 'A::B::foo' 462 it returns the 1, and given 'foo', it returns 0. */ 463 464 /* The character in NAME indexed by the return value is guaranteed to 465 always be either ':' or '\0'. */ 466 467 /* NOTE: carlton/2003-03-13: This function is currently only intended 468 for internal use: it's probably not entirely safe when called on 469 user-generated input, because some of the 'index += 2' lines in 470 cp_find_first_component_aux might go past the end of malformed 471 input. */ 472 473 unsigned int 474 cp_find_first_component (const char *name) 475 { 476 return cp_find_first_component_aux (name, 0); 477 } 478 479 /* Helper function for cp_find_first_component. Like that function, 480 it returns the length of the first component of NAME, but to make 481 the recursion easier, it also stops if it reaches an unexpected ')' 482 or '>' if the value of PERMISSIVE is nonzero. */ 483 484 /* Let's optimize away calls to strlen("operator"). */ 485 486 #define LENGTH_OF_OPERATOR 8 487 488 static unsigned int 489 cp_find_first_component_aux (const char *name, int permissive) 490 { 491 unsigned int index = 0; 492 /* Operator names can show up in unexpected places. Since these can 493 contain parentheses or angle brackets, they can screw up the 494 recursion. But not every string 'operator' is part of an 495 operater name: e.g. you could have a variable 'cooperator'. So 496 this variable tells us whether or not we should treat the string 497 'operator' as starting an operator. */ 498 int operator_possible = 1; 499 500 for (;; ++index) 501 { 502 switch (name[index]) 503 { 504 case '<': 505 /* Template; eat it up. The calls to cp_first_component 506 should only return (I hope!) when they reach the '>' 507 terminating the component or a '::' between two 508 components. (Hence the '+ 2'.) */ 509 index += 1; 510 for (index += cp_find_first_component_aux (name + index, 1); 511 name[index] != '>'; 512 index += cp_find_first_component_aux (name + index, 1)) 513 { 514 if (name[index] != ':') 515 { 516 demangled_name_complaint (name); 517 return strlen (name); 518 } 519 index += 2; 520 } 521 operator_possible = 1; 522 break; 523 case '(': 524 /* Similar comment as to '<'. */ 525 index += 1; 526 for (index += cp_find_first_component_aux (name + index, 1); 527 name[index] != ')'; 528 index += cp_find_first_component_aux (name + index, 1)) 529 { 530 if (name[index] != ':') 531 { 532 demangled_name_complaint (name); 533 return strlen (name); 534 } 535 index += 2; 536 } 537 operator_possible = 1; 538 break; 539 case '>': 540 case ')': 541 if (permissive) 542 return index; 543 else 544 { 545 demangled_name_complaint (name); 546 return strlen (name); 547 } 548 case '\0': 549 case ':': 550 return index; 551 case 'o': 552 /* Operator names can screw up the recursion. */ 553 if (operator_possible 554 && strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0) 555 { 556 index += LENGTH_OF_OPERATOR; 557 while (ISSPACE(name[index])) 558 ++index; 559 switch (name[index]) 560 { 561 /* Skip over one less than the appropriate number of 562 characters: the for loop will skip over the last 563 one. */ 564 case '<': 565 if (name[index + 1] == '<') 566 index += 1; 567 else 568 index += 0; 569 break; 570 case '>': 571 case '-': 572 if (name[index + 1] == '>') 573 index += 1; 574 else 575 index += 0; 576 break; 577 case '(': 578 index += 1; 579 break; 580 default: 581 index += 0; 582 break; 583 } 584 } 585 operator_possible = 0; 586 break; 587 case ' ': 588 case ',': 589 case '.': 590 case '&': 591 case '*': 592 /* NOTE: carlton/2003-04-18: I'm not sure what the precise 593 set of relevant characters are here: it's necessary to 594 include any character that can show up before 'operator' 595 in a demangled name, and it's safe to include any 596 character that can't be part of an identifier's name. */ 597 operator_possible = 1; 598 break; 599 default: 600 operator_possible = 0; 601 break; 602 } 603 } 604 } 605 606 /* Complain about a demangled name that we don't know how to parse. 607 NAME is the demangled name in question. */ 608 609 static void 610 demangled_name_complaint (const char *name) 611 { 612 complaint (&symfile_complaints, 613 "unexpected demangled name '%s'", name); 614 } 615 616 /* If NAME is the fully-qualified name of a C++ 617 function/variable/method/etc., this returns the length of its 618 entire prefix: all of the namespaces and classes that make up its 619 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns 620 4, given 'foo', it returns 0. */ 621 622 unsigned int 623 cp_entire_prefix_len (const char *name) 624 { 625 unsigned int current_len = cp_find_first_component (name); 626 unsigned int previous_len = 0; 627 628 while (name[current_len] != '\0') 629 { 630 gdb_assert (name[current_len] == ':'); 631 previous_len = current_len; 632 /* Skip the '::'. */ 633 current_len += 2; 634 current_len += cp_find_first_component (name + current_len); 635 } 636 637 return previous_len; 638 } 639 640 /* Overload resolution functions. */ 641 642 /* Test to see if SYM is a symbol that we haven't seen corresponding 643 to a function named OLOAD_NAME. If so, add it to the current 644 completion list. */ 645 646 static void 647 overload_list_add_symbol (struct symbol *sym, const char *oload_name) 648 { 649 int newsize; 650 int i; 651 char *sym_name; 652 653 /* If there is no type information, we can't do anything, so skip */ 654 if (SYMBOL_TYPE (sym) == NULL) 655 return; 656 657 /* skip any symbols that we've already considered. */ 658 for (i = 0; i < sym_return_val_index; ++i) 659 if (strcmp (SYMBOL_LINKAGE_NAME (sym), 660 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0) 661 return; 662 663 /* Get the demangled name without parameters */ 664 sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym)); 665 if (!sym_name) 666 return; 667 668 /* skip symbols that cannot match */ 669 if (strcmp (sym_name, oload_name) != 0) 670 { 671 xfree (sym_name); 672 return; 673 } 674 675 xfree (sym_name); 676 677 /* We have a match for an overload instance, so add SYM to the current list 678 * of overload instances */ 679 if (sym_return_val_index + 3 > sym_return_val_size) 680 { 681 newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *); 682 sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize); 683 } 684 sym_return_val[sym_return_val_index++] = sym; 685 sym_return_val[sym_return_val_index] = NULL; 686 } 687 688 /* Return a null-terminated list of pointers to function symbols that 689 are named FUNC_NAME and are visible within NAMESPACE. */ 690 691 struct symbol ** 692 make_symbol_overload_list (const char *func_name, 693 const char *namespace) 694 { 695 struct cleanup *old_cleanups; 696 const char *name; 697 698 sym_return_val_size = 100; 699 sym_return_val_index = 0; 700 sym_return_val = xmalloc ((sym_return_val_size + 1) * 701 sizeof (struct symbol *)); 702 sym_return_val[0] = NULL; 703 704 old_cleanups = make_cleanup (xfree, sym_return_val); 705 706 make_symbol_overload_list_using (func_name, namespace); 707 708 if (namespace[0] == '\0') 709 name = func_name; 710 else 711 { 712 char *concatenated_name 713 = alloca (strlen (namespace) + 2 + strlen (func_name) + 1); 714 strcpy (concatenated_name, namespace); 715 strcat (concatenated_name, "::"); 716 strcat (concatenated_name, func_name); 717 name = concatenated_name; 718 } 719 720 make_symbol_overload_list_qualified (name); 721 722 discard_cleanups (old_cleanups); 723 724 return sym_return_val; 725 } 726 727 /* Add all symbols with a name matching NAME in BLOCK to the overload 728 list. */ 729 730 static void 731 make_symbol_overload_list_block (const char *name, 732 const struct block *block) 733 { 734 struct dict_iterator iter; 735 struct symbol *sym; 736 737 const struct dictionary *dict = BLOCK_DICT (block); 738 739 for (sym = dict_iter_name_first (dict, name, &iter); 740 sym != NULL; 741 sym = dict_iter_name_next (name, &iter)) 742 overload_list_add_symbol (sym, name); 743 } 744 745 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */ 746 747 static void 748 make_symbol_overload_list_namespace (const char *func_name, 749 const char *namespace) 750 { 751 const char *name; 752 const struct block *block = NULL; 753 754 if (namespace[0] == '\0') 755 name = func_name; 756 else 757 { 758 char *concatenated_name 759 = alloca (strlen (namespace) + 2 + strlen (func_name) + 1); 760 761 strcpy (concatenated_name, namespace); 762 strcat (concatenated_name, "::"); 763 strcat (concatenated_name, func_name); 764 name = concatenated_name; 765 } 766 767 /* Look in the static block. */ 768 block = block_static_block (get_selected_block (0)); 769 make_symbol_overload_list_block (name, block); 770 771 /* Look in the global block. */ 772 block = block_global_block (block); 773 make_symbol_overload_list_block (name, block); 774 775 } 776 777 /* Search the namespace of the given type and namespace of and public base 778 types. */ 779 780 static void 781 make_symbol_overload_list_adl_namespace (struct type *type, 782 const char *func_name) 783 { 784 char *namespace; 785 char *type_name; 786 int i, prefix_len; 787 788 while (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF 789 || TYPE_CODE (type) == TYPE_CODE_ARRAY 790 || TYPE_CODE (type) == TYPE_CODE_TYPEDEF) 791 { 792 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) 793 type = check_typedef(type); 794 else 795 type = TYPE_TARGET_TYPE (type); 796 } 797 798 type_name = TYPE_NAME (type); 799 800 if (type_name == NULL) 801 return; 802 803 prefix_len = cp_entire_prefix_len (type_name); 804 805 if (prefix_len != 0) 806 { 807 namespace = alloca (prefix_len + 1); 808 strncpy (namespace, type_name, prefix_len); 809 namespace[prefix_len] = '\0'; 810 811 make_symbol_overload_list_namespace (func_name, namespace); 812 } 813 814 /* Check public base type */ 815 if (TYPE_CODE (type) == TYPE_CODE_CLASS) 816 for (i = 0; i < TYPE_N_BASECLASSES (type); i++) 817 { 818 if (BASETYPE_VIA_PUBLIC (type, i)) 819 make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type, i), 820 func_name); 821 } 822 } 823 824 /* Adds the the overload list overload candidates for FUNC_NAME found through 825 argument dependent lookup. */ 826 827 struct symbol ** 828 make_symbol_overload_list_adl (struct type **arg_types, int nargs, 829 const char *func_name) 830 { 831 int i; 832 833 gdb_assert (sym_return_val_size != -1); 834 835 for (i = 1; i <= nargs; i++) 836 make_symbol_overload_list_adl_namespace (arg_types[i - 1], func_name); 837 838 return sym_return_val; 839 } 840 841 /* Used for cleanups to reset the "searched" flag in case of an error. */ 842 843 static void 844 reset_directive_searched (void *data) 845 { 846 struct using_direct *direct = data; 847 direct->searched = 0; 848 } 849 850 /* This applies the using directives to add namespaces to search in, 851 and then searches for overloads in all of those namespaces. It 852 adds the symbols found to sym_return_val. Arguments are as in 853 make_symbol_overload_list. */ 854 855 static void 856 make_symbol_overload_list_using (const char *func_name, 857 const char *namespace) 858 { 859 struct using_direct *current; 860 const struct block *block; 861 862 /* First, go through the using directives. If any of them apply, 863 look in the appropriate namespaces for new functions to match 864 on. */ 865 866 for (block = get_selected_block (0); 867 block != NULL; 868 block = BLOCK_SUPERBLOCK (block)) 869 for (current = block_using (block); 870 current != NULL; 871 current = current->next) 872 { 873 /* Prevent recursive calls. */ 874 if (current->searched) 875 continue; 876 877 /* If this is a namespace alias or imported declaration ignore it. */ 878 if (current->alias != NULL || current->declaration != NULL) 879 continue; 880 881 if (strcmp (namespace, current->import_dest) == 0) 882 { 883 /* Mark this import as searched so that the recursive call does 884 not search it again. */ 885 struct cleanup *old_chain; 886 current->searched = 1; 887 old_chain = make_cleanup (reset_directive_searched, current); 888 889 make_symbol_overload_list_using (func_name, current->import_src); 890 891 current->searched = 0; 892 discard_cleanups (old_chain); 893 } 894 } 895 896 /* Now, add names for this namespace. */ 897 make_symbol_overload_list_namespace (func_name, namespace); 898 } 899 900 /* This does the bulk of the work of finding overloaded symbols. 901 FUNC_NAME is the name of the overloaded function we're looking for 902 (possibly including namespace info). */ 903 904 static void 905 make_symbol_overload_list_qualified (const char *func_name) 906 { 907 struct symbol *sym; 908 struct symtab *s; 909 struct objfile *objfile; 910 const struct block *b, *surrounding_static_block = 0; 911 struct dict_iterator iter; 912 const struct dictionary *dict; 913 914 /* Look through the partial symtabs for all symbols which begin 915 by matching FUNC_NAME. Make sure we read that symbol table in. */ 916 917 ALL_OBJFILES (objfile) 918 { 919 if (objfile->sf) 920 objfile->sf->qf->expand_symtabs_for_function (objfile, func_name); 921 } 922 923 /* Search upwards from currently selected frame (so that we can 924 complete on local vars. */ 925 926 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b)) 927 make_symbol_overload_list_block (func_name, b); 928 929 surrounding_static_block = block_static_block (get_selected_block (0)); 930 931 /* Go through the symtabs and check the externs and statics for 932 symbols which match. */ 933 934 ALL_PRIMARY_SYMTABS (objfile, s) 935 { 936 QUIT; 937 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); 938 make_symbol_overload_list_block (func_name, b); 939 } 940 941 ALL_PRIMARY_SYMTABS (objfile, s) 942 { 943 QUIT; 944 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); 945 /* Don't do this block twice. */ 946 if (b == surrounding_static_block) 947 continue; 948 make_symbol_overload_list_block (func_name, b); 949 } 950 } 951 952 /* Lookup the rtti type for a class name. */ 953 954 struct type * 955 cp_lookup_rtti_type (const char *name, struct block *block) 956 { 957 struct symbol * rtti_sym; 958 struct type * rtti_type; 959 960 rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL); 961 962 if (rtti_sym == NULL) 963 { 964 warning (_("RTTI symbol not found for class '%s'"), name); 965 return NULL; 966 } 967 968 if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF) 969 { 970 warning (_("RTTI symbol for class '%s' is not a type"), name); 971 return NULL; 972 } 973 974 rtti_type = SYMBOL_TYPE (rtti_sym); 975 976 switch (TYPE_CODE (rtti_type)) 977 { 978 case TYPE_CODE_CLASS: 979 break; 980 case TYPE_CODE_NAMESPACE: 981 /* chastain/2003-11-26: the symbol tables often contain fake 982 symbols for namespaces with the same name as the struct. 983 This warning is an indication of a bug in the lookup order 984 or a bug in the way that the symbol tables are populated. */ 985 warning (_("RTTI symbol for class '%s' is a namespace"), name); 986 return NULL; 987 default: 988 warning (_("RTTI symbol for class '%s' has bad type"), name); 989 return NULL; 990 } 991 992 return rtti_type; 993 } 994 995 /* Don't allow just "maintenance cplus". */ 996 997 static void 998 maint_cplus_command (char *arg, int from_tty) 999 { 1000 printf_unfiltered (_("\"maintenance cplus\" must be followed by the name of a command.\n")); 1001 help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout); 1002 } 1003 1004 /* This is a front end for cp_find_first_component, for unit testing. 1005 Be careful when using it: see the NOTE above 1006 cp_find_first_component. */ 1007 1008 static void 1009 first_component_command (char *arg, int from_tty) 1010 { 1011 int len; 1012 char *prefix; 1013 1014 if (!arg) 1015 return; 1016 1017 len = cp_find_first_component (arg); 1018 prefix = alloca (len + 1); 1019 1020 memcpy (prefix, arg, len); 1021 prefix[len] = '\0'; 1022 1023 printf_unfiltered ("%s\n", prefix); 1024 } 1025 1026 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */ 1027 1028 #define SKIP_SPACE(P) \ 1029 do \ 1030 { \ 1031 while (*(P) == ' ' || *(P) == '\t') \ 1032 ++(P); \ 1033 } \ 1034 while (0) 1035 1036 /* Returns the length of the operator name or 0 if INPUT does not 1037 point to a valid C++ operator. INPUT should start with "operator". */ 1038 int 1039 cp_validate_operator (const char *input) 1040 { 1041 int i; 1042 char *copy; 1043 const char *p; 1044 struct expression *expr; 1045 struct value *val; 1046 struct gdb_exception except; 1047 1048 p = input; 1049 1050 if (strncmp (p, "operator", 8) == 0) 1051 { 1052 int valid = 0; 1053 1054 p += 8; 1055 SKIP_SPACE (p); 1056 for (i = 0; i < sizeof (operator_tokens) / sizeof (operator_tokens[0]); 1057 ++i) 1058 { 1059 int length = strlen (operator_tokens[i]); 1060 1061 /* By using strncmp here, we MUST have operator_tokens ordered! 1062 See additional notes where operator_tokens is defined above. */ 1063 if (strncmp (p, operator_tokens[i], length) == 0) 1064 { 1065 const char *op = p; 1066 1067 valid = 1; 1068 p += length; 1069 1070 if (strncmp (op, "new", 3) == 0 1071 || strncmp (op, "delete", 6) == 0) 1072 { 1073 1074 /* Special case: new[] and delete[]. We must be careful 1075 to swallow whitespace before/in "[]". */ 1076 SKIP_SPACE (p); 1077 1078 if (*p == '[') 1079 { 1080 ++p; 1081 SKIP_SPACE (p); 1082 if (*p == ']') 1083 ++p; 1084 else 1085 valid = 0; 1086 } 1087 } 1088 1089 if (valid) 1090 return (p - input); 1091 } 1092 } 1093 1094 /* Check input for a conversion operator. */ 1095 1096 /* Skip past base typename */ 1097 while (*p != '*' && *p != '&' && *p != 0 && *p != ' ') 1098 ++p; 1099 SKIP_SPACE (p); 1100 1101 /* Add modifiers '*'/'&' */ 1102 while (*p == '*' || *p == '&') 1103 { 1104 ++p; 1105 SKIP_SPACE (p); 1106 } 1107 1108 /* Check for valid type. [Remember: input starts with 1109 "operator".] */ 1110 copy = savestring (input + 8, p - input - 8); 1111 expr = NULL; 1112 val = NULL; 1113 TRY_CATCH (except, RETURN_MASK_ALL) 1114 { 1115 expr = parse_expression (copy); 1116 val = evaluate_type (expr); 1117 } 1118 1119 xfree (copy); 1120 if (expr) 1121 xfree (expr); 1122 1123 if (val != NULL && value_type (val) != NULL) 1124 return (p - input); 1125 } 1126 1127 return 0; 1128 } 1129 1130 void 1131 _initialize_cp_support (void) 1132 { 1133 add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command, 1134 _("C++ maintenance commands."), &maint_cplus_cmd_list, 1135 "maintenance cplus ", 0, &maintenancelist); 1136 add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist); 1137 1138 add_cmd ("first_component", class_maintenance, first_component_command, 1139 _("Print the first class/namespace component of NAME."), 1140 &maint_cplus_cmd_list); 1141 } 1142