1 /* Parser for linespec for the GNU debugger, GDB. 2 3 Copyright (C) 1986-2005, 2007-2012 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "symtab.h" 22 #include "frame.h" 23 #include "command.h" 24 #include "symfile.h" 25 #include "objfiles.h" 26 #include "source.h" 27 #include "demangle.h" 28 #include "value.h" 29 #include "completer.h" 30 #include "cp-abi.h" 31 #include "cp-support.h" 32 #include "parser-defs.h" 33 #include "block.h" 34 #include "objc-lang.h" 35 #include "linespec.h" 36 #include "exceptions.h" 37 #include "language.h" 38 #include "interps.h" 39 #include "mi/mi-cmds.h" 40 #include "target.h" 41 #include "arch-utils.h" 42 #include <ctype.h> 43 #include "cli/cli-utils.h" 44 #include "filenames.h" 45 #include "ada-lang.h" 46 47 typedef struct symtab *symtab_p; 48 DEF_VEC_P (symtab_p); 49 50 typedef struct symbol *symbolp; 51 DEF_VEC_P (symbolp); 52 53 typedef struct type *typep; 54 DEF_VEC_P (typep); 55 56 /* An address entry is used to ensure that any given location is only 57 added to the result a single time. It holds an address and the 58 program space from which the address came. */ 59 60 struct address_entry 61 { 62 struct program_space *pspace; 63 CORE_ADDR addr; 64 }; 65 66 /* An instance of this is used to keep all state while linespec 67 operates. This instance is passed around as a 'this' pointer to 68 the various implementation methods. */ 69 70 struct linespec_state 71 { 72 /* The program space as seen when the module was entered. */ 73 struct program_space *program_space; 74 75 /* The default symtab to use, if no other symtab is specified. */ 76 struct symtab *default_symtab; 77 78 /* The default line to use. */ 79 int default_line; 80 81 /* If the linespec started with "FILE:", this holds all the matching 82 symtabs. Otherwise, it will hold a single NULL entry, meaning 83 that the default symtab should be used. */ 84 VEC (symtab_p) *file_symtabs; 85 86 /* If the linespec started with "FILE:", this holds an xmalloc'd 87 copy of "FILE". */ 88 char *user_filename; 89 90 /* If the linespec is "FUNCTION:LABEL", this holds an xmalloc'd copy 91 of "FUNCTION". */ 92 char *user_function; 93 94 /* The 'funfirstline' value that was passed in to decode_line_1 or 95 decode_line_full. */ 96 int funfirstline; 97 98 /* Nonzero if we are running in 'list' mode; see decode_line_list. */ 99 int list_mode; 100 101 /* The 'canonical' value passed to decode_line_full, or NULL. */ 102 struct linespec_result *canonical; 103 104 /* Canonical strings that mirror the symtabs_and_lines result. */ 105 char **canonical_names; 106 107 /* This is a set of address_entry objects which is used to prevent 108 duplicate symbols from being entered into the result. */ 109 htab_t addr_set; 110 }; 111 112 /* This is a helper object that is used when collecting symbols into a 113 result. */ 114 115 struct collect_info 116 { 117 /* The linespec object in use. */ 118 struct linespec_state *state; 119 120 /* The result being accumulated. */ 121 struct symtabs_and_lines result; 122 }; 123 124 /* Prototypes for local functions. */ 125 126 static void initialize_defaults (struct symtab **default_symtab, 127 int *default_line); 128 129 static struct symtabs_and_lines decode_indirect (struct linespec_state *self, 130 char **argptr); 131 132 static char *locate_first_half (char **argptr, int *is_quote_enclosed); 133 134 static struct symtabs_and_lines decode_objc (struct linespec_state *self, 135 char **argptr); 136 137 static struct symtabs_and_lines decode_compound (struct linespec_state *self, 138 char **argptr, 139 char *saved_arg, 140 char *p); 141 142 static VEC (symbolp) *lookup_prefix_sym (char **argptr, char *p, 143 VEC (symtab_p) *, 144 char **); 145 146 static struct symtabs_and_lines find_method (struct linespec_state *self, 147 char *saved_arg, 148 char *copy, 149 const char *class_name, 150 VEC (symbolp) *sym_classes); 151 152 static void cplusplus_error (const char *name, const char *fmt, ...) 153 ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 3); 154 155 static char *find_toplevel_char (char *s, char c); 156 157 static int is_objc_method_format (const char *s); 158 159 static VEC (symtab_p) *symtabs_from_filename (char **argptr, 160 char *p, int is_quote_enclosed, 161 char **user_filename); 162 163 static VEC (symbolp) *find_function_symbols (char **argptr, char *p, 164 int is_quote_enclosed, 165 char **user_function); 166 167 static struct symtabs_and_lines decode_all_digits (struct linespec_state *self, 168 char **argptr, 169 char *q); 170 171 static struct symtabs_and_lines decode_dollar (struct linespec_state *self, 172 char *copy); 173 174 static int decode_label (struct linespec_state *self, 175 VEC (symbolp) *function_symbols, 176 char *copy, 177 struct symtabs_and_lines *result); 178 179 static struct symtabs_and_lines decode_variable (struct linespec_state *self, 180 char *copy); 181 182 static int symbol_to_sal (struct symtab_and_line *result, 183 int funfirstline, struct symbol *sym); 184 185 static void add_matching_symbols_to_info (const char *name, 186 struct collect_info *info, 187 struct program_space *pspace); 188 189 static void add_all_symbol_names_from_pspace (struct collect_info *info, 190 struct program_space *pspace, 191 VEC (const_char_ptr) *names); 192 193 /* Helper functions. */ 194 195 /* Add SAL to SALS. */ 196 197 static void 198 add_sal_to_sals_basic (struct symtabs_and_lines *sals, 199 struct symtab_and_line *sal) 200 { 201 ++sals->nelts; 202 sals->sals = xrealloc (sals->sals, sals->nelts * sizeof (sals->sals[0])); 203 sals->sals[sals->nelts - 1] = *sal; 204 } 205 206 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect 207 the new sal, if needed. If not NULL, SYMNAME is the name of the 208 symbol to use when constructing the new canonical name. */ 209 210 static void 211 add_sal_to_sals (struct linespec_state *self, 212 struct symtabs_and_lines *sals, 213 struct symtab_and_line *sal, 214 const char *symname) 215 { 216 add_sal_to_sals_basic (sals, sal); 217 218 if (self->canonical) 219 { 220 char *canonical_name = NULL; 221 222 self->canonical_names = xrealloc (self->canonical_names, 223 sals->nelts * sizeof (char *)); 224 if (sal->symtab && sal->symtab->filename) 225 { 226 char *filename = sal->symtab->filename; 227 228 /* Note that the filter doesn't have to be a valid linespec 229 input. We only apply the ":LINE" treatment to Ada for 230 the time being. */ 231 if (symname != NULL && sal->line != 0 232 && current_language->la_language == language_ada) 233 canonical_name = xstrprintf ("%s:%s:%d", filename, symname, 234 sal->line); 235 else if (symname != NULL) 236 canonical_name = xstrprintf ("%s:%s", filename, symname); 237 else 238 canonical_name = xstrprintf ("%s:%d", filename, sal->line); 239 } 240 241 self->canonical_names[sals->nelts - 1] = canonical_name; 242 } 243 } 244 245 /* A hash function for address_entry. */ 246 247 static hashval_t 248 hash_address_entry (const void *p) 249 { 250 const struct address_entry *aep = p; 251 hashval_t hash; 252 253 hash = iterative_hash_object (aep->pspace, 0); 254 return iterative_hash_object (aep->addr, hash); 255 } 256 257 /* An equality function for address_entry. */ 258 259 static int 260 eq_address_entry (const void *a, const void *b) 261 { 262 const struct address_entry *aea = a; 263 const struct address_entry *aeb = b; 264 265 return aea->pspace == aeb->pspace && aea->addr == aeb->addr; 266 } 267 268 /* Check whether the address, represented by PSPACE and ADDR, is 269 already in the set. If so, return 0. Otherwise, add it and return 270 1. */ 271 272 static int 273 maybe_add_address (htab_t set, struct program_space *pspace, CORE_ADDR addr) 274 { 275 struct address_entry e, *p; 276 void **slot; 277 278 e.pspace = pspace; 279 e.addr = addr; 280 slot = htab_find_slot (set, &e, INSERT); 281 if (*slot) 282 return 0; 283 284 p = XNEW (struct address_entry); 285 memcpy (p, &e, sizeof (struct address_entry)); 286 *slot = p; 287 288 return 1; 289 } 290 291 /* Issue a helpful hint on using the command completion feature on 292 single quoted demangled C++ symbols as part of the completion 293 error. */ 294 295 static void 296 cplusplus_error (const char *name, const char *fmt, ...) 297 { 298 struct ui_file *tmp_stream; 299 char *message; 300 301 tmp_stream = mem_fileopen (); 302 make_cleanup_ui_file_delete (tmp_stream); 303 304 { 305 va_list args; 306 307 va_start (args, fmt); 308 vfprintf_unfiltered (tmp_stream, fmt, args); 309 va_end (args); 310 } 311 312 while (*name == '\'') 313 name++; 314 fprintf_unfiltered (tmp_stream, 315 ("Hint: try '%s<TAB> or '%s<ESC-?>\n" 316 "(Note leading single quote.)"), 317 name, name); 318 319 message = ui_file_xstrdup (tmp_stream, NULL); 320 make_cleanup (xfree, message); 321 throw_error (NOT_FOUND_ERROR, "%s", message); 322 } 323 324 /* A helper for iterate_over_all_matching_symtabs that is passed as a 325 callback to the expand_symtabs_matching method. */ 326 327 static int 328 iterate_name_matcher (const struct language_defn *language, 329 const char *name, void *d) 330 { 331 const char **dname = d; 332 333 if (language->la_symbol_name_compare (name, *dname) == 0) 334 return 1; 335 return 0; 336 } 337 338 /* A helper that walks over all matching symtabs in all objfiles and 339 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is 340 not NULL, then the search is restricted to just that program 341 space. */ 342 343 static void 344 iterate_over_all_matching_symtabs (const char *name, 345 const domain_enum domain, 346 int (*callback) (struct symbol *, void *), 347 void *data, 348 struct program_space *search_pspace) 349 { 350 struct objfile *objfile; 351 struct program_space *pspace; 352 353 ALL_PSPACES (pspace) 354 { 355 if (search_pspace != NULL && search_pspace != pspace) 356 continue; 357 if (pspace->executing_startup) 358 continue; 359 360 set_current_program_space (pspace); 361 362 ALL_OBJFILES (objfile) 363 { 364 struct symtab *symtab; 365 366 if (objfile->sf) 367 objfile->sf->qf->expand_symtabs_matching (objfile, NULL, 368 iterate_name_matcher, 369 ALL_DOMAIN, 370 &name); 371 372 ALL_OBJFILE_SYMTABS (objfile, symtab) 373 { 374 if (symtab->primary) 375 { 376 struct block *block; 377 378 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK); 379 LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data); 380 } 381 } 382 } 383 } 384 } 385 386 /* Returns the block to be used for symbol searches for the given SYMTAB, 387 which may be NULL. */ 388 389 static struct block * 390 get_search_block (struct symtab *symtab) 391 { 392 struct block *block; 393 394 if (symtab != NULL) 395 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK); 396 else 397 { 398 enum language save_language; 399 400 /* get_selected_block can change the current language when there is 401 no selected frame yet. */ 402 save_language = current_language->la_language; 403 block = get_selected_block (0); 404 set_language (save_language); 405 } 406 407 return block; 408 } 409 410 /* A helper for find_method. This finds all methods in type T which 411 match NAME. It adds resulting symbol names to RESULT_NAMES, and 412 adds T's direct superclasses to SUPERCLASSES. */ 413 414 static void 415 find_methods (struct type *t, const char *name, 416 VEC (const_char_ptr) **result_names, 417 VEC (typep) **superclasses) 418 { 419 int i1 = 0; 420 int ibase; 421 char *class_name = type_name_no_tag (t); 422 char *canon; 423 424 /* Ignore this class if it doesn't have a name. This is ugly, but 425 unless we figure out how to get the physname without the name of 426 the class, then the loop can't do any good. */ 427 if (class_name) 428 { 429 int method_counter; 430 int name_len = strlen (name); 431 432 CHECK_TYPEDEF (t); 433 434 /* Loop over each method name. At this level, all overloads of a name 435 are counted as a single name. There is an inner loop which loops over 436 each overload. */ 437 438 for (method_counter = TYPE_NFN_FIELDS (t) - 1; 439 method_counter >= 0; 440 --method_counter) 441 { 442 char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter); 443 char dem_opname[64]; 444 445 if (strncmp (method_name, "__", 2) == 0 || 446 strncmp (method_name, "op", 2) == 0 || 447 strncmp (method_name, "type", 4) == 0) 448 { 449 if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI)) 450 method_name = dem_opname; 451 else if (cplus_demangle_opname (method_name, dem_opname, 0)) 452 method_name = dem_opname; 453 } 454 455 if (strcmp_iw (method_name, name) == 0) 456 { 457 int field_counter; 458 459 for (field_counter = (TYPE_FN_FIELDLIST_LENGTH (t, method_counter) 460 - 1); 461 field_counter >= 0; 462 --field_counter) 463 { 464 struct fn_field *f; 465 const char *phys_name; 466 467 f = TYPE_FN_FIELDLIST1 (t, method_counter); 468 if (TYPE_FN_FIELD_STUB (f, field_counter)) 469 continue; 470 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter); 471 VEC_safe_push (const_char_ptr, *result_names, phys_name); 472 } 473 } 474 } 475 } 476 477 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++) 478 VEC_safe_push (typep, *superclasses, TYPE_BASECLASS (t, ibase)); 479 } 480 481 /* Find an instance of the character C in the string S that is outside 482 of all parenthesis pairs, single-quoted strings, and double-quoted 483 strings. Also, ignore the char within a template name, like a ',' 484 within foo<int, int>. */ 485 486 static char * 487 find_toplevel_char (char *s, char c) 488 { 489 int quoted = 0; /* zero if we're not in quotes; 490 '"' if we're in a double-quoted string; 491 '\'' if we're in a single-quoted string. */ 492 int depth = 0; /* Number of unclosed parens we've seen. */ 493 char *scan; 494 495 for (scan = s; *scan; scan++) 496 { 497 if (quoted) 498 { 499 if (*scan == quoted) 500 quoted = 0; 501 else if (*scan == '\\' && *(scan + 1)) 502 scan++; 503 } 504 else if (*scan == c && ! quoted && depth == 0) 505 return scan; 506 else if (*scan == '"' || *scan == '\'') 507 quoted = *scan; 508 else if (*scan == '(' || *scan == '<') 509 depth++; 510 else if ((*scan == ')' || *scan == '>') && depth > 0) 511 depth--; 512 } 513 514 return 0; 515 } 516 517 /* Determines if the gives string corresponds to an Objective-C method 518 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols 519 are allowed to have spaces and parentheses in them. */ 520 521 static int 522 is_objc_method_format (const char *s) 523 { 524 if (s == NULL || *s == '\0') 525 return 0; 526 /* Handle arguments with the format FILENAME:SYMBOL. */ 527 if ((s[0] == ':') && (strchr ("+-", s[1]) != NULL) 528 && (s[2] == '[') && strchr(s, ']')) 529 return 1; 530 /* Handle arguments that are just SYMBOL. */ 531 else if ((strchr ("+-", s[0]) != NULL) && (s[1] == '[') && strchr(s, ']')) 532 return 1; 533 return 0; 534 } 535 536 /* Given FILTERS, a list of canonical names, filter the sals in RESULT 537 and store the result in SELF->CANONICAL. */ 538 539 static void 540 filter_results (struct linespec_state *self, 541 struct symtabs_and_lines *result, 542 VEC (const_char_ptr) *filters) 543 { 544 int i; 545 const char *name; 546 547 for (i = 0; VEC_iterate (const_char_ptr, filters, i, name); ++i) 548 { 549 struct linespec_sals lsal; 550 int j; 551 552 memset (&lsal, 0, sizeof (lsal)); 553 554 for (j = 0; j < result->nelts; ++j) 555 { 556 if (strcmp (name, self->canonical_names[j]) == 0) 557 add_sal_to_sals_basic (&lsal.sals, &result->sals[j]); 558 } 559 560 if (lsal.sals.nelts > 0) 561 { 562 lsal.canonical = xstrdup (name); 563 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal); 564 } 565 } 566 567 self->canonical->pre_expanded = 0; 568 } 569 570 /* Store RESULT into SELF->CANONICAL. */ 571 572 static void 573 convert_results_to_lsals (struct linespec_state *self, 574 struct symtabs_and_lines *result) 575 { 576 struct linespec_sals lsal; 577 578 lsal.canonical = NULL; 579 lsal.sals = *result; 580 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal); 581 } 582 583 /* Handle multiple results in RESULT depending on SELECT_MODE. This 584 will either return normally, throw an exception on multiple 585 results, or present a menu to the user. On return, the SALS vector 586 in SELF->CANONICAL is set up properly. */ 587 588 static void 589 decode_line_2 (struct linespec_state *self, 590 struct symtabs_and_lines *result, 591 const char *select_mode) 592 { 593 const char *iter; 594 char *args, *prompt; 595 int i; 596 struct cleanup *old_chain; 597 VEC (const_char_ptr) *item_names = NULL, *filters = NULL; 598 struct get_number_or_range_state state; 599 600 gdb_assert (select_mode != multiple_symbols_all); 601 gdb_assert (self->canonical != NULL); 602 603 old_chain = make_cleanup (VEC_cleanup (const_char_ptr), &item_names); 604 make_cleanup (VEC_cleanup (const_char_ptr), &filters); 605 for (i = 0; i < result->nelts; ++i) 606 { 607 int j, found = 0; 608 const char *iter; 609 610 gdb_assert (self->canonical_names[i] != NULL); 611 for (j = 0; VEC_iterate (const_char_ptr, item_names, j, iter); ++j) 612 { 613 if (strcmp (iter, self->canonical_names[i]) == 0) 614 { 615 found = 1; 616 break; 617 } 618 } 619 620 if (!found) 621 VEC_safe_push (const_char_ptr, item_names, self->canonical_names[i]); 622 } 623 624 if (select_mode == multiple_symbols_cancel 625 && VEC_length (const_char_ptr, item_names) > 1) 626 error (_("canceled because the command is ambiguous\n" 627 "See set/show multiple-symbol.")); 628 629 if (select_mode == multiple_symbols_all 630 || VEC_length (const_char_ptr, item_names) == 1) 631 { 632 do_cleanups (old_chain); 633 convert_results_to_lsals (self, result); 634 return; 635 } 636 637 printf_unfiltered (_("[0] cancel\n[1] all\n")); 638 for (i = 0; VEC_iterate (const_char_ptr, item_names, i, iter); ++i) 639 printf_unfiltered ("[%d] %s\n", i + 2, iter); 640 641 prompt = getenv ("PS2"); 642 if (prompt == NULL) 643 { 644 prompt = "> "; 645 } 646 args = command_line_input (prompt, 0, "overload-choice"); 647 648 if (args == 0 || *args == 0) 649 error_no_arg (_("one or more choice numbers")); 650 651 init_number_or_range (&state, args); 652 while (!state.finished) 653 { 654 int num; 655 656 num = get_number_or_range (&state); 657 658 if (num == 0) 659 error (_("canceled")); 660 else if (num == 1) 661 { 662 /* We intentionally make this result in a single breakpoint, 663 contrary to what older versions of gdb did. The 664 rationale is that this lets a user get the 665 multiple_symbols_all behavior even with the 'ask' 666 setting; and he can get separate breakpoints by entering 667 "2-57" at the query. */ 668 do_cleanups (old_chain); 669 convert_results_to_lsals (self, result); 670 return; 671 } 672 673 num -= 2; 674 if (num >= VEC_length (const_char_ptr, item_names)) 675 printf_unfiltered (_("No choice number %d.\n"), num); 676 else 677 { 678 const char *elt = VEC_index (const_char_ptr, item_names, num); 679 680 if (elt != NULL) 681 { 682 VEC_safe_push (const_char_ptr, filters, elt); 683 VEC_replace (const_char_ptr, item_names, num, NULL); 684 } 685 else 686 { 687 printf_unfiltered (_("duplicate request for %d ignored.\n"), 688 num); 689 } 690 } 691 } 692 693 filter_results (self, result, filters); 694 do_cleanups (old_chain); 695 } 696 697 /* Valid delimiters for linespec keywords "if", "thread" or "task". */ 698 699 static int 700 is_linespec_boundary (char c) 701 { 702 return c == ' ' || c == '\t' || c == '\0' || c == ','; 703 } 704 705 /* A helper function for decode_line_1 and friends which skips P 706 past any method overload information at the beginning of P, e.g., 707 "(const struct foo *)". 708 709 This function assumes that P has already been validated to contain 710 overload information, and it will assert if *P != '('. */ 711 static char * 712 find_method_overload_end (char *p) 713 { 714 int depth = 0; 715 716 gdb_assert (*p == '('); 717 718 while (*p) 719 { 720 if (*p == '(') 721 ++depth; 722 else if (*p == ')') 723 { 724 if (--depth == 0) 725 { 726 ++p; 727 break; 728 } 729 } 730 ++p; 731 } 732 733 return p; 734 } 735 736 /* Keep important information used when looking up a name. This includes 737 template parameters, overload information, and important keywords, including 738 the possible Java trailing type. */ 739 740 static char * 741 keep_name_info (char *p, int on_boundary) 742 { 743 const char *quotes = get_gdb_completer_quote_characters (); 744 char *saved_p = p; 745 int nest = 0; 746 747 while (*p) 748 { 749 if (strchr (quotes, *p)) 750 break; 751 752 if (*p == ',' && !nest) 753 break; 754 755 if (on_boundary && !nest) 756 { 757 const char *const words[] = { "if", "thread", "task" }; 758 int wordi; 759 760 for (wordi = 0; wordi < ARRAY_SIZE (words); wordi++) 761 if (strncmp (p, words[wordi], strlen (words[wordi])) == 0 762 && is_linespec_boundary (p[strlen (words[wordi])])) 763 break; 764 if (wordi < ARRAY_SIZE (words)) 765 break; 766 } 767 768 if (*p == '(' || *p == '<' || *p == '[') 769 nest++; 770 else if ((*p == ')' || *p == '>' || *p == ']') && nest > 0) 771 nest--; 772 773 p++; 774 775 /* The ',' check could fail on "operator ,". */ 776 p += cp_validate_operator (p); 777 778 on_boundary = is_linespec_boundary (p[-1]); 779 } 780 781 while (p > saved_p && is_linespec_boundary (p[-1])) 782 p--; 783 784 return p; 785 } 786 787 788 /* The parser of linespec itself. */ 789 790 /* Parse a string that specifies a line number. 791 Pass the address of a char * variable; that variable will be 792 advanced over the characters actually parsed. 793 794 The string can be: 795 796 LINENUM -- that line number in current file. PC returned is 0. 797 FILE:LINENUM -- that line in that file. PC returned is 0. 798 FUNCTION -- line number of openbrace of that function. 799 PC returned is the start of the function. 800 LABEL -- a label in the current scope 801 VARIABLE -- line number of definition of that variable. 802 PC returned is 0. 803 FILE:FUNCTION -- likewise, but prefer functions in that file. 804 *EXPR -- line in which address EXPR appears. 805 806 This may all be followed by an "if EXPR", which we ignore. 807 808 FUNCTION may be an undebuggable function found in minimal symbol table. 809 810 If the argument FUNFIRSTLINE is nonzero, we want the first line 811 of real code inside a function when a function is specified, and it is 812 not OK to specify a variable or type to get its line number. 813 814 DEFAULT_SYMTAB specifies the file to use if none is specified. 815 It defaults to current_source_symtab. 816 DEFAULT_LINE specifies the line number to use for relative 817 line numbers (that start with signs). Defaults to current_source_line. 818 If CANONICAL is non-NULL, store an array of strings containing the canonical 819 line specs there if necessary. Currently overloaded member functions and 820 line numbers or static functions without a filename yield a canonical 821 line spec. The array and the line spec strings are allocated on the heap, 822 it is the callers responsibility to free them. 823 824 Note that it is possible to return zero for the symtab 825 if no file is validly specified. Callers must check that. 826 Also, the line number returned may be invalid. */ 827 828 /* We allow single quotes in various places. This is a hideous 829 kludge, which exists because the completer can't yet deal with the 830 lack of single quotes. FIXME: write a linespec_completer which we 831 can use as appropriate instead of make_symbol_completion_list. */ 832 833 struct symtabs_and_lines 834 decode_line_internal (struct linespec_state *self, char **argptr) 835 { 836 char *p; 837 char *q; 838 839 char *copy; 840 /* This says whether or not something in *ARGPTR is quoted with 841 completer_quotes (i.e. with single quotes). */ 842 int is_quoted; 843 /* Is *ARGPTR enclosed in double quotes? */ 844 int is_quote_enclosed; 845 int is_objc_method = 0; 846 char *saved_arg = *argptr; 847 /* If IS_QUOTED, the end of the quoted bit. */ 848 char *end_quote = NULL; 849 /* Is *ARGPTR enclosed in single quotes? */ 850 int is_squote_enclosed = 0; 851 /* The "first half" of the linespec. */ 852 char *first_half; 853 854 /* If we are parsing `function:label', this holds the symbols 855 matching the function name. */ 856 VEC (symbolp) *function_symbols = NULL; 857 /* If FUNCTION_SYMBOLS is not NULL, then this is the exception that 858 was thrown when trying to parse a filename. */ 859 volatile struct gdb_exception file_exception; 860 861 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); 862 863 /* Defaults have defaults. */ 864 865 initialize_defaults (&self->default_symtab, &self->default_line); 866 867 /* See if arg is *PC. */ 868 869 if (**argptr == '*') 870 { 871 do_cleanups (cleanup); 872 return decode_indirect (self, argptr); 873 } 874 875 is_quoted = (strchr (get_gdb_completer_quote_characters (), 876 **argptr) != NULL); 877 878 if (is_quoted) 879 { 880 end_quote = skip_quoted (*argptr); 881 if (*end_quote == '\0') 882 is_squote_enclosed = 1; 883 } 884 885 /* Check to see if it's a multipart linespec (with colons or 886 periods). */ 887 888 /* Locate the end of the first half of the linespec. 889 After the call, for instance, if the argptr string is "foo.c:123" 890 p will point at "123". If there is only one part, like "foo", p 891 will point to "". If this is a C++ name, like "A::B::foo", p will 892 point to "::B::foo". Argptr is not changed by this call. */ 893 894 first_half = p = locate_first_half (argptr, &is_quote_enclosed); 895 896 /* First things first: if ARGPTR starts with a filename, get its 897 symtab and strip the filename from ARGPTR. */ 898 TRY_CATCH (file_exception, RETURN_MASK_ERROR) 899 { 900 self->file_symtabs = symtabs_from_filename (argptr, p, is_quote_enclosed, 901 &self->user_filename); 902 } 903 904 if (VEC_empty (symtab_p, self->file_symtabs)) 905 { 906 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */ 907 VEC_safe_push (symtab_p, self->file_symtabs, NULL); 908 } 909 910 if (file_exception.reason >= 0) 911 { 912 /* Check for single quotes on the non-filename part. */ 913 is_quoted = (**argptr 914 && strchr (get_gdb_completer_quote_characters (), 915 **argptr) != NULL); 916 if (is_quoted) 917 end_quote = skip_quoted (*argptr); 918 919 /* Locate the next "half" of the linespec. */ 920 first_half = p = locate_first_half (argptr, &is_quote_enclosed); 921 } 922 923 /* Check if this is an Objective-C method (anything that starts with 924 a '+' or '-' and a '['). */ 925 if (is_objc_method_format (p)) 926 is_objc_method = 1; 927 928 /* Check if the symbol could be an Objective-C selector. */ 929 930 { 931 struct symtabs_and_lines values; 932 933 values = decode_objc (self, argptr); 934 if (values.sals != NULL) 935 { 936 do_cleanups (cleanup); 937 return values; 938 } 939 } 940 941 /* Does it look like there actually were two parts? */ 942 943 if (p[0] == ':' || p[0] == '.') 944 { 945 /* Is it a C++ or Java compound data structure? 946 The check on p[1] == ':' is capturing the case of "::", 947 since p[0]==':' was checked above. 948 Note that the call to decode_compound does everything 949 for us, including the lookup on the symbol table, so we 950 can return now. */ 951 952 if (p[0] == '.' || p[1] == ':') 953 { 954 struct symtabs_and_lines values; 955 volatile struct gdb_exception ex; 956 char *saved_argptr = *argptr; 957 958 if (is_quote_enclosed) 959 ++saved_arg; 960 961 /* Initialize it just to avoid a GCC false warning. */ 962 memset (&values, 0, sizeof (values)); 963 964 TRY_CATCH (ex, RETURN_MASK_ERROR) 965 { 966 values = decode_compound (self, argptr, saved_arg, p); 967 } 968 if ((is_quoted || is_squote_enclosed) && **argptr == '\'') 969 *argptr = *argptr + 1; 970 971 if (ex.reason >= 0) 972 { 973 do_cleanups (cleanup); 974 return values; 975 } 976 977 if (ex.error != NOT_FOUND_ERROR) 978 throw_exception (ex); 979 980 *argptr = saved_argptr; 981 } 982 else 983 { 984 /* If there was an exception looking up a specified filename earlier, 985 then check whether we were really given `function:label'. */ 986 if (file_exception.reason < 0) 987 { 988 function_symbols = find_function_symbols (argptr, p, 989 is_quote_enclosed, 990 &self->user_function); 991 992 /* If we did not find a function, re-throw the original 993 exception. */ 994 if (!function_symbols) 995 throw_exception (file_exception); 996 997 make_cleanup (VEC_cleanup (symbolp), &function_symbols); 998 } 999 1000 /* Check for single quotes on the non-filename part. */ 1001 if (!is_quoted) 1002 { 1003 is_quoted = (**argptr 1004 && strchr (get_gdb_completer_quote_characters (), 1005 **argptr) != NULL); 1006 if (is_quoted) 1007 end_quote = skip_quoted (*argptr); 1008 } 1009 } 1010 } 1011 1012 /* self->file_symtabs holds the specified file symtabs, or 0 if no file 1013 specified. 1014 If we are parsing `function:symbol', then FUNCTION_SYMBOLS holds the 1015 functions before the `:'. 1016 arg no longer contains the file name. */ 1017 1018 /* If the filename was quoted, we must re-check the quotation. */ 1019 1020 if (end_quote == first_half && *end_quote!= '\0') 1021 { 1022 is_quoted = (**argptr 1023 && strchr (get_gdb_completer_quote_characters (), 1024 **argptr) != NULL); 1025 if (is_quoted) 1026 end_quote = skip_quoted (*argptr); 1027 } 1028 1029 /* Check whether arg is all digits (and sign). */ 1030 1031 q = *argptr; 1032 if (*q == '-' || *q == '+') 1033 q++; 1034 while (*q >= '0' && *q <= '9') 1035 q++; 1036 1037 if (q != *argptr && (*q == 0 || *q == ' ' || *q == '\t' || *q == ',') 1038 && function_symbols == NULL) 1039 { 1040 struct symtabs_and_lines values; 1041 1042 /* We found a token consisting of all digits -- at least one digit. */ 1043 values = decode_all_digits (self, argptr, q); 1044 do_cleanups (cleanup); 1045 return values; 1046 } 1047 1048 /* Arg token is not digits => try it as a variable name 1049 Find the next token (everything up to end or next whitespace). */ 1050 1051 if (**argptr == '$') /* May be a convenience variable. */ 1052 /* One or two $ chars possible. */ 1053 p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1)); 1054 else if (is_quoted || is_squote_enclosed) 1055 { 1056 p = end_quote; 1057 if (p[-1] != '\'') 1058 error (_("Unmatched single quote.")); 1059 } 1060 else if (is_objc_method) 1061 { 1062 /* allow word separators in method names for Obj-C. */ 1063 p = skip_quoted_chars (*argptr, NULL, ""); 1064 } 1065 else 1066 { 1067 p = skip_quoted (*argptr); 1068 } 1069 1070 /* Keep any important naming information. */ 1071 p = keep_name_info (p, p == saved_arg || is_linespec_boundary (p[-1])); 1072 1073 copy = (char *) alloca (p - *argptr + 1); 1074 memcpy (copy, *argptr, p - *argptr); 1075 copy[p - *argptr] = '\0'; 1076 if (p != *argptr 1077 && copy[0] 1078 && copy[0] == copy[p - *argptr - 1] 1079 && strchr (get_gdb_completer_quote_characters (), copy[0]) != NULL) 1080 { 1081 copy[p - *argptr - 1] = '\0'; 1082 copy++; 1083 } 1084 else if (is_quoted || is_squote_enclosed) 1085 copy[p - *argptr - 1] = '\0'; 1086 1087 *argptr = skip_spaces (p); 1088 1089 /* If it starts with $: may be a legitimate variable or routine name 1090 (e.g. HP-UX millicode routines such as $$dyncall), or it may 1091 be history value, or it may be a convenience variable. */ 1092 1093 if (*copy == '$' && function_symbols == NULL) 1094 { 1095 struct symtabs_and_lines values; 1096 1097 values = decode_dollar (self, copy); 1098 do_cleanups (cleanup); 1099 return values; 1100 } 1101 1102 /* Try the token as a label, but only if no file was specified, 1103 because we can only really find labels in the current scope. */ 1104 1105 if (VEC_length (symtab_p, self->file_symtabs) == 1 1106 && VEC_index (symtab_p, self->file_symtabs, 0) == NULL) 1107 { 1108 struct symtabs_and_lines label_result; 1109 if (decode_label (self, function_symbols, copy, &label_result)) 1110 { 1111 do_cleanups (cleanup); 1112 return label_result; 1113 } 1114 } 1115 1116 if (function_symbols) 1117 throw_exception (file_exception); 1118 1119 /* Look up that token as a variable. 1120 If file specified, use that file's per-file block to start with. */ 1121 1122 { 1123 struct symtabs_and_lines values; 1124 1125 values = decode_variable (self, copy); 1126 do_cleanups (cleanup); 1127 return values; 1128 } 1129 } 1130 1131 /* A constructor for linespec_state. */ 1132 1133 static void 1134 linespec_state_constructor (struct linespec_state *self, 1135 int flags, 1136 struct symtab *default_symtab, 1137 int default_line, 1138 struct linespec_result *canonical) 1139 { 1140 memset (self, 0, sizeof (*self)); 1141 self->funfirstline = (flags & DECODE_LINE_FUNFIRSTLINE) ? 1 : 0; 1142 self->list_mode = (flags & DECODE_LINE_LIST_MODE) ? 1 : 0; 1143 self->default_symtab = default_symtab; 1144 self->default_line = default_line; 1145 self->canonical = canonical; 1146 self->program_space = current_program_space; 1147 self->addr_set = htab_create_alloc (10, hash_address_entry, eq_address_entry, 1148 xfree, xcalloc, xfree); 1149 } 1150 1151 /* A destructor for linespec_state. */ 1152 1153 static void 1154 linespec_state_destructor (void *arg) 1155 { 1156 struct linespec_state *self = arg; 1157 1158 xfree (self->user_filename); 1159 xfree (self->user_function); 1160 VEC_free (symtab_p, self->file_symtabs); 1161 htab_delete (self->addr_set); 1162 } 1163 1164 /* See linespec.h. */ 1165 1166 void 1167 decode_line_full (char **argptr, int flags, 1168 struct symtab *default_symtab, 1169 int default_line, struct linespec_result *canonical, 1170 const char *select_mode, 1171 const char *filter) 1172 { 1173 struct symtabs_and_lines result; 1174 struct linespec_state state; 1175 struct cleanup *cleanups; 1176 char *arg_start = *argptr; 1177 VEC (const_char_ptr) *filters = NULL; 1178 1179 gdb_assert (canonical != NULL); 1180 /* The filter only makes sense for 'all'. */ 1181 gdb_assert (filter == NULL || select_mode == multiple_symbols_all); 1182 gdb_assert (select_mode == NULL 1183 || select_mode == multiple_symbols_all 1184 || select_mode == multiple_symbols_ask 1185 || select_mode == multiple_symbols_cancel); 1186 gdb_assert ((flags & DECODE_LINE_LIST_MODE) == 0); 1187 1188 linespec_state_constructor (&state, flags, 1189 default_symtab, default_line, canonical); 1190 cleanups = make_cleanup (linespec_state_destructor, &state); 1191 save_current_program_space (); 1192 1193 result = decode_line_internal (&state, argptr); 1194 1195 gdb_assert (result.nelts == 1 || canonical->pre_expanded); 1196 gdb_assert (canonical->addr_string != NULL); 1197 canonical->pre_expanded = 1; 1198 1199 /* Fill in the missing canonical names. */ 1200 if (result.nelts > 0) 1201 { 1202 int i; 1203 1204 if (state.canonical_names == NULL) 1205 state.canonical_names = xcalloc (result.nelts, sizeof (char *)); 1206 make_cleanup (xfree, state.canonical_names); 1207 for (i = 0; i < result.nelts; ++i) 1208 { 1209 if (state.canonical_names[i] == NULL) 1210 state.canonical_names[i] = savestring (arg_start, 1211 *argptr - arg_start); 1212 make_cleanup (xfree, state.canonical_names[i]); 1213 } 1214 } 1215 1216 if (select_mode == NULL) 1217 { 1218 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))) 1219 select_mode = multiple_symbols_all; 1220 else 1221 select_mode = multiple_symbols_select_mode (); 1222 } 1223 1224 if (select_mode == multiple_symbols_all) 1225 { 1226 if (filter != NULL) 1227 { 1228 make_cleanup (VEC_cleanup (const_char_ptr), &filters); 1229 VEC_safe_push (const_char_ptr, filters, filter); 1230 filter_results (&state, &result, filters); 1231 } 1232 else 1233 convert_results_to_lsals (&state, &result); 1234 } 1235 else 1236 decode_line_2 (&state, &result, select_mode); 1237 1238 do_cleanups (cleanups); 1239 } 1240 1241 struct symtabs_and_lines 1242 decode_line_1 (char **argptr, int flags, 1243 struct symtab *default_symtab, 1244 int default_line) 1245 { 1246 struct symtabs_and_lines result; 1247 struct linespec_state state; 1248 struct cleanup *cleanups; 1249 1250 linespec_state_constructor (&state, flags, 1251 default_symtab, default_line, NULL); 1252 cleanups = make_cleanup (linespec_state_destructor, &state); 1253 save_current_program_space (); 1254 1255 result = decode_line_internal (&state, argptr); 1256 do_cleanups (cleanups); 1257 return result; 1258 } 1259 1260 1261 1262 /* First, some functions to initialize stuff at the beggining of the 1263 function. */ 1264 1265 static void 1266 initialize_defaults (struct symtab **default_symtab, int *default_line) 1267 { 1268 if (*default_symtab == 0) 1269 { 1270 /* Use whatever we have for the default source line. We don't use 1271 get_current_or_default_symtab_and_line as it can recurse and call 1272 us back! */ 1273 struct symtab_and_line cursal = 1274 get_current_source_symtab_and_line (); 1275 1276 *default_symtab = cursal.symtab; 1277 *default_line = cursal.line; 1278 } 1279 } 1280 1281 1282 1283 /* Decode arg of the form *PC. */ 1284 1285 static struct symtabs_and_lines 1286 decode_indirect (struct linespec_state *self, char **argptr) 1287 { 1288 struct symtabs_and_lines values; 1289 CORE_ADDR pc; 1290 char *initial = *argptr; 1291 1292 if (current_program_space->executing_startup) 1293 /* The error message doesn't really matter, because this case 1294 should only hit during breakpoint reset. */ 1295 throw_error (NOT_FOUND_ERROR, _("cannot evaluate expressions while " 1296 "program space is in startup")); 1297 1298 (*argptr)++; 1299 pc = value_as_address (parse_to_comma_and_eval (argptr)); 1300 1301 values.sals = (struct symtab_and_line *) 1302 xmalloc (sizeof (struct symtab_and_line)); 1303 1304 values.nelts = 1; 1305 values.sals[0] = find_pc_line (pc, 0); 1306 values.sals[0].pc = pc; 1307 values.sals[0].section = find_pc_overlay (pc); 1308 values.sals[0].explicit_pc = 1; 1309 1310 if (self->canonical) 1311 self->canonical->addr_string = savestring (initial, *argptr - initial); 1312 1313 return values; 1314 } 1315 1316 1317 1318 /* Locate the first half of the linespec, ending in a colon, period, 1319 or whitespace. (More or less.) Also, check to see if *ARGPTR is 1320 enclosed in double quotes; if so, set is_quote_enclosed, advance 1321 ARGPTR past that and zero out the trailing double quote. 1322 If ARGPTR is just a simple name like "main", p will point to "" 1323 at the end. */ 1324 1325 static char * 1326 locate_first_half (char **argptr, int *is_quote_enclosed) 1327 { 1328 char *ii; 1329 char *p, *p1; 1330 int has_comma; 1331 1332 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM 1333 and we must isolate the first half. Outer layers will call again later 1334 for the second half. 1335 1336 Don't count commas that appear in argument lists of overloaded 1337 functions, or in quoted strings. It's stupid to go to this much 1338 trouble when the rest of the function is such an obvious roach hotel. */ 1339 ii = find_toplevel_char (*argptr, ','); 1340 has_comma = (ii != 0); 1341 1342 /* Temporarily zap out second half to not confuse the code below. 1343 This is undone below. Do not change ii!! */ 1344 if (has_comma) 1345 { 1346 *ii = '\0'; 1347 } 1348 1349 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be 1350 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore 1351 inside of <>. */ 1352 1353 p = *argptr; 1354 if (p[0] == '"') 1355 { 1356 *is_quote_enclosed = 1; 1357 (*argptr)++; 1358 p++; 1359 } 1360 else 1361 { 1362 *is_quote_enclosed = 0; 1363 if (strchr (get_gdb_completer_quote_characters (), *p)) 1364 { 1365 ++(*argptr); 1366 ++p; 1367 } 1368 } 1369 1370 1371 /* Check for a drive letter in the filename. This is done on all hosts 1372 to capture cross-compilation environments. On Unixen, directory 1373 separators are illegal in filenames, so if the user enters "e:/foo.c", 1374 he is referring to a directory named "e:" and a source file named 1375 "foo.c", and we still want to keep these two pieces together. */ 1376 if (isalpha (p[0]) && p[1] == ':' && IS_DIR_SEPARATOR (p[2])) 1377 p += 3; 1378 1379 for (; *p; p++) 1380 { 1381 if (p[0] == '<') 1382 { 1383 char *temp_end = find_template_name_end (p); 1384 1385 if (!temp_end) 1386 error (_("malformed template specification in command")); 1387 p = temp_end; 1388 } 1389 1390 if (p[0] == '(') 1391 p = find_method_overload_end (p); 1392 1393 /* Check for a colon and a plus or minus and a [ (which 1394 indicates an Objective-C method). */ 1395 if (is_objc_method_format (p)) 1396 { 1397 break; 1398 } 1399 /* Check for the end of the first half of the linespec. End of 1400 line, a tab, a colon or a space. But if enclosed in double 1401 quotes we do not break on enclosed spaces. */ 1402 if (!*p 1403 || p[0] == '\t' 1404 || (p[0] == ':') 1405 || ((p[0] == ' ') && !*is_quote_enclosed)) 1406 break; 1407 if (p[0] == '.' && strchr (p, ':') == NULL) 1408 { 1409 /* Java qualified method. Find the *last* '.', since the 1410 others are package qualifiers. Stop at any open parenthesis 1411 which might provide overload information. */ 1412 for (p1 = p; *p1 && *p1 != '('; p1++) 1413 { 1414 if (*p1 == '.') 1415 p = p1; 1416 } 1417 break; 1418 } 1419 } 1420 p = skip_spaces (p); 1421 1422 /* If the closing double quote was left at the end, remove it. */ 1423 if (*is_quote_enclosed) 1424 { 1425 char *closing_quote = strchr (p - 1, '"'); 1426 1427 if (closing_quote && closing_quote[1] == '\0') 1428 *closing_quote = '\0'; 1429 } 1430 1431 /* Now that we've safely parsed the first half, put back ',' so 1432 outer layers can see it. */ 1433 if (has_comma) 1434 *ii = ','; 1435 1436 return p; 1437 } 1438 1439 1440 1441 /* Here's where we recognise an Objective-C Selector. An Objective C 1442 selector may be implemented by more than one class, therefore it 1443 may represent more than one method/function. This gives us a 1444 situation somewhat analogous to C++ overloading. If there's more 1445 than one method that could represent the selector, then use some of 1446 the existing C++ code to let the user choose one. */ 1447 1448 static struct symtabs_and_lines 1449 decode_objc (struct linespec_state *self, char **argptr) 1450 { 1451 struct collect_info info; 1452 VEC (const_char_ptr) *symbol_names = NULL; 1453 char *new_argptr; 1454 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr), 1455 &symbol_names); 1456 1457 info.state = self; 1458 info.result.sals = NULL; 1459 info.result.nelts = 0; 1460 1461 new_argptr = find_imps (*argptr, &symbol_names); 1462 if (VEC_empty (const_char_ptr, symbol_names)) 1463 { 1464 do_cleanups (cleanup); 1465 return info.result; 1466 } 1467 1468 add_all_symbol_names_from_pspace (&info, NULL, symbol_names); 1469 1470 if (info.result.nelts > 0) 1471 { 1472 char *saved_arg; 1473 1474 saved_arg = alloca (new_argptr - *argptr + 1); 1475 memcpy (saved_arg, *argptr, new_argptr - *argptr); 1476 saved_arg[new_argptr - *argptr] = '\0'; 1477 1478 if (self->canonical) 1479 { 1480 self->canonical->pre_expanded = 1; 1481 if (self->user_filename) 1482 self->canonical->addr_string 1483 = xstrprintf ("%s:%s", self->user_filename, saved_arg); 1484 else 1485 self->canonical->addr_string = xstrdup (saved_arg); 1486 } 1487 } 1488 1489 *argptr = new_argptr; 1490 1491 do_cleanups (cleanup); 1492 return info.result; 1493 } 1494 1495 /* This handles C++ and Java compound data structures. P should point 1496 at the first component separator, i.e. double-colon or period. As 1497 an example, on entrance to this function we could have ARGPTR 1498 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */ 1499 1500 static struct symtabs_and_lines 1501 decode_compound (struct linespec_state *self, 1502 char **argptr, char *the_real_saved_arg, char *p) 1503 { 1504 struct symtabs_and_lines values; 1505 char *p2; 1506 char *saved_arg2 = *argptr; 1507 char *temp_end; 1508 struct symbol *sym; 1509 char *copy; 1510 VEC (symbolp) *sym_classes; 1511 char *saved_arg, *class_name; 1512 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); 1513 1514 /* If the user specified any completer quote characters in the input, 1515 strip them. They are superfluous. */ 1516 saved_arg = alloca (strlen (the_real_saved_arg) + 1); 1517 { 1518 char *dst = saved_arg; 1519 char *src = the_real_saved_arg; 1520 char *quotes = get_gdb_completer_quote_characters (); 1521 while (*src != '\0') 1522 { 1523 if (strchr (quotes, *src) == NULL) 1524 *dst++ = *src; 1525 ++src; 1526 } 1527 *dst = '\0'; 1528 } 1529 1530 /* First check for "global" namespace specification, of the form 1531 "::foo". If found, skip over the colons and jump to normal 1532 symbol processing. I.e. the whole line specification starts with 1533 "::" (note the condition that *argptr == p). */ 1534 if (p[0] == ':' 1535 && ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t'))) 1536 saved_arg2 += 2; 1537 1538 /* Given our example "AAA::inA::fun", we have two cases to consider: 1539 1540 1) AAA::inA is the name of a class. In that case, presumably it 1541 has a method called "fun"; we then look up that method using 1542 find_method. 1543 1544 2) AAA::inA isn't the name of a class. In that case, either the 1545 user made a typo, AAA::inA is the name of a namespace, or it is 1546 the name of a minimal symbol. 1547 In this case we just delegate to decode_variable. 1548 1549 Thus, our first task is to find everything before the last set of 1550 double-colons and figure out if it's the name of a class. So we 1551 first loop through all of the double-colons. */ 1552 1553 p2 = p; /* Save for restart. */ 1554 1555 /* This is very messy. Following the example above we have now the 1556 following pointers: 1557 p -> "::inA::fun" 1558 argptr -> "AAA::inA::fun 1559 saved_arg -> "AAA::inA::fun 1560 saved_arg2 -> "AAA::inA::fun 1561 p2 -> "::inA::fun". */ 1562 1563 /* In the loop below, with these strings, we'll make 2 passes, each 1564 is marked in comments. */ 1565 1566 while (1) 1567 { 1568 static char *break_characters = " \t("; 1569 1570 /* Move pointer up to next possible class/namespace token. */ 1571 1572 p = p2 + 1; /* Restart with old value +1. */ 1573 1574 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun", 1575 i.e. if there is a double-colon, p will now point to the 1576 second colon. */ 1577 /* PASS2: p2->"::fun", p->":fun" */ 1578 1579 /* Move pointer ahead to next double-colon. */ 1580 while (*p 1581 && strchr (break_characters, *p) == NULL 1582 && strchr (get_gdb_completer_quote_characters (), *p) == NULL) 1583 { 1584 if (current_language->la_language == language_cplus) 1585 p += cp_validate_operator (p); 1586 1587 if (p[0] == '<') 1588 { 1589 temp_end = find_template_name_end (p); 1590 if (!temp_end) 1591 error (_("malformed template specification in command")); 1592 p = temp_end; 1593 } 1594 /* Note that, since, at the start of this loop, p would be 1595 pointing to the second colon in a double-colon, we only 1596 satisfy the condition below if there is another 1597 double-colon to the right (after). I.e. there is another 1598 component that can be a class or a namespace. I.e, if at 1599 the beginning of this loop (PASS1), we had 1600 p->":inA::fun", we'll trigger this when p has been 1601 advanced to point to "::fun". */ 1602 /* PASS2: we will not trigger this. */ 1603 else if ((p[0] == ':') && (p[1] == ':')) 1604 break; /* Found double-colon. */ 1605 else 1606 { 1607 /* PASS2: We'll keep getting here, until P points to one of the 1608 break characters, at which point we exit this loop. */ 1609 if (*p) 1610 { 1611 if (p[1] == '(' 1612 && strncmp (&p[1], CP_ANONYMOUS_NAMESPACE_STR, 1613 CP_ANONYMOUS_NAMESPACE_LEN) == 0) 1614 p += CP_ANONYMOUS_NAMESPACE_LEN; 1615 else if (strchr (break_characters, *p) == NULL) 1616 ++p; 1617 } 1618 } 1619 } 1620 1621 if (*p != ':') 1622 break; /* Out of the while (1). This would happen 1623 for instance if we have looked up 1624 unsuccessfully all the components of the 1625 string, and p->""(PASS2). */ 1626 1627 /* We get here if p points to one of the break characters or "" (i.e., 1628 string ended). */ 1629 /* Save restart for next time around. */ 1630 p2 = p; 1631 /* Restore argptr as it was on entry to this function. */ 1632 *argptr = saved_arg2; 1633 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun", 1634 p2->"::fun". */ 1635 1636 /* All ready for next pass through the loop. */ 1637 } /* while (1) */ 1638 1639 1640 /* Start of lookup in the symbol tables. */ 1641 1642 /* Lookup in the symbol table the substring between argptr and 1643 p. Note, this call changes the value of argptr. */ 1644 /* Before the call, argptr->"AAA::inA::fun", 1645 p->"", p2->"::fun". After the call: argptr->"fun", p, p2 1646 unchanged. */ 1647 sym_classes = lookup_prefix_sym (argptr, p2, self->file_symtabs, 1648 &class_name); 1649 make_cleanup (VEC_cleanup (symbolp), &sym_classes); 1650 make_cleanup (xfree, class_name); 1651 1652 /* If a class has been found, then we're in case 1 above. So we 1653 look up "fun" as a method of those classes. */ 1654 if (!VEC_empty (symbolp, sym_classes)) 1655 { 1656 /* Arg token is not digits => try it as a function name. 1657 Find the next token (everything up to end or next 1658 blank). */ 1659 if (**argptr 1660 && strchr (get_gdb_completer_quote_characters (), 1661 **argptr) != NULL) 1662 { 1663 p = skip_quoted (*argptr); 1664 *argptr = *argptr + 1; 1665 } 1666 else 1667 { 1668 /* At this point argptr->"fun". */ 1669 char *a; 1670 1671 p = *argptr; 1672 while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':' 1673 && *p != '(') 1674 p++; 1675 /* At this point p->"". String ended. */ 1676 /* Nope, C++ operators could have spaces in them 1677 ("foo::operator <" or "foo::operator delete []"). 1678 I apologize, this is a bit hacky... */ 1679 if (current_language->la_language == language_cplus 1680 && *p == ' ' && p - 8 - *argptr + 1 > 0) 1681 { 1682 /* The above loop has already swallowed "operator". */ 1683 p += cp_validate_operator (p - 8) - 8; 1684 } 1685 1686 /* Keep any important naming information. */ 1687 p = keep_name_info (p, 1); 1688 } 1689 1690 /* Allocate our own copy of the substring between argptr and 1691 p. */ 1692 copy = (char *) alloca (p - *argptr + 1); 1693 memcpy (copy, *argptr, p - *argptr); 1694 copy[p - *argptr] = '\0'; 1695 if (p != *argptr 1696 && copy[p - *argptr - 1] 1697 && strchr (get_gdb_completer_quote_characters (), 1698 copy[p - *argptr - 1]) != NULL) 1699 copy[p - *argptr - 1] = '\0'; 1700 1701 /* At this point copy->"fun", p->"". */ 1702 1703 /* No line number may be specified. */ 1704 *argptr = skip_spaces (p); 1705 /* At this point arptr->"". */ 1706 1707 /* Look for copy as a method of sym_class. */ 1708 /* At this point copy->"fun", sym_class is "AAA:inA", 1709 saved_arg->"AAA::inA::fun". This concludes the scanning of 1710 the string for possible components matches. If we find it 1711 here, we return. If not, and we are at the and of the string, 1712 we'll lookup the whole string in the symbol tables. */ 1713 1714 values = find_method (self, saved_arg, copy, class_name, sym_classes); 1715 1716 do_cleanups (cleanup); 1717 return values; 1718 } /* End if symbol found. */ 1719 1720 1721 /* We couldn't find a class, so we're in case 2 above. We check the 1722 entire name as a symbol instead. The simplest way to do this is 1723 to just throw an exception and let our caller fall through to 1724 decode_variable. */ 1725 1726 throw_error (NOT_FOUND_ERROR, _("see caller, this text doesn't matter")); 1727 } 1728 1729 /* An instance of this type is used when collecting prefix symbols for 1730 decode_compound. */ 1731 1732 struct decode_compound_collector 1733 { 1734 /* The result vector. */ 1735 VEC (symbolp) *symbols; 1736 1737 /* A hash table of all symbols we found. We use this to avoid 1738 adding any symbol more than once. */ 1739 htab_t unique_syms; 1740 }; 1741 1742 /* A callback for iterate_over_symbols that is used by 1743 lookup_prefix_sym to collect type symbols. */ 1744 1745 static int 1746 collect_one_symbol (struct symbol *sym, void *d) 1747 { 1748 struct decode_compound_collector *collector = d; 1749 void **slot; 1750 struct type *t; 1751 1752 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF) 1753 return 1; 1754 1755 t = SYMBOL_TYPE (sym); 1756 CHECK_TYPEDEF (t); 1757 if (TYPE_CODE (t) != TYPE_CODE_STRUCT 1758 && TYPE_CODE (t) != TYPE_CODE_UNION 1759 && TYPE_CODE (t) != TYPE_CODE_NAMESPACE) 1760 return 1; 1761 1762 slot = htab_find_slot (collector->unique_syms, sym, INSERT); 1763 if (!*slot) 1764 { 1765 *slot = sym; 1766 VEC_safe_push (symbolp, collector->symbols, sym); 1767 } 1768 1769 return 1; 1770 } 1771 1772 /* Return the symbol corresponding to the substring of *ARGPTR ending 1773 at P, allowing whitespace. Also, advance *ARGPTR past the symbol 1774 name in question, the compound object separator ("::" or "."), and 1775 whitespace. Note that *ARGPTR is changed whether or not the 1776 this call finds anything (i.e we return NULL). As an 1777 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */ 1778 1779 static VEC (symbolp) * 1780 lookup_prefix_sym (char **argptr, char *p, VEC (symtab_p) *file_symtabs, 1781 char **class_name) 1782 { 1783 char *p1; 1784 char *copy; 1785 int ix; 1786 struct symtab *elt; 1787 struct decode_compound_collector collector; 1788 struct cleanup *outer; 1789 struct cleanup *cleanup; 1790 struct block *search_block; 1791 1792 /* Extract the class name. */ 1793 p1 = p; 1794 while (p != *argptr && p[-1] == ' ') 1795 --p; 1796 copy = (char *) xmalloc (p - *argptr + 1); 1797 memcpy (copy, *argptr, p - *argptr); 1798 copy[p - *argptr] = 0; 1799 *class_name = copy; 1800 outer = make_cleanup (xfree, copy); 1801 1802 /* Discard the class name from the argptr. */ 1803 p = p1 + (p1[0] == ':' ? 2 : 1); 1804 p = skip_spaces (p); 1805 *argptr = p; 1806 1807 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA", 1808 argptr->"inA::fun". */ 1809 1810 collector.symbols = NULL; 1811 make_cleanup (VEC_cleanup (symbolp), &collector.symbols); 1812 1813 collector.unique_syms = htab_create_alloc (1, htab_hash_pointer, 1814 htab_eq_pointer, NULL, 1815 xcalloc, xfree); 1816 cleanup = make_cleanup_htab_delete (collector.unique_syms); 1817 1818 for (ix = 0; VEC_iterate (symtab_p, file_symtabs, ix, elt); ++ix) 1819 { 1820 if (elt == NULL) 1821 { 1822 iterate_over_all_matching_symtabs (copy, STRUCT_DOMAIN, 1823 collect_one_symbol, &collector, 1824 NULL); 1825 iterate_over_all_matching_symtabs (copy, VAR_DOMAIN, 1826 collect_one_symbol, &collector, 1827 NULL); 1828 } 1829 else 1830 { 1831 struct block *search_block; 1832 1833 /* Program spaces that are executing startup should have 1834 been filtered out earlier. */ 1835 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup); 1836 set_current_program_space (SYMTAB_PSPACE (elt)); 1837 search_block = get_search_block (elt); 1838 LA_ITERATE_OVER_SYMBOLS (search_block, copy, STRUCT_DOMAIN, 1839 collect_one_symbol, &collector); 1840 LA_ITERATE_OVER_SYMBOLS (search_block, copy, VAR_DOMAIN, 1841 collect_one_symbol, &collector); 1842 } 1843 } 1844 1845 do_cleanups (cleanup); 1846 discard_cleanups (outer); 1847 return collector.symbols; 1848 } 1849 1850 /* A qsort comparison function for symbols. The resulting order does 1851 not actually matter; we just need to be able to sort them so that 1852 symbols with the same program space end up next to each other. */ 1853 1854 static int 1855 compare_symbols (const void *a, const void *b) 1856 { 1857 struct symbol * const *sa = a; 1858 struct symbol * const *sb = b; 1859 uintptr_t uia, uib; 1860 1861 uia = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa)); 1862 uib = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb)); 1863 1864 if (uia < uib) 1865 return -1; 1866 if (uia > uib) 1867 return 1; 1868 1869 uia = (uintptr_t) *sa; 1870 uib = (uintptr_t) *sb; 1871 1872 if (uia < uib) 1873 return -1; 1874 if (uia > uib) 1875 return 1; 1876 1877 return 0; 1878 } 1879 1880 /* Look for all the matching instances of each symbol in NAMES. Only 1881 instances from PSPACE are considered; other program spaces are 1882 handled by our caller. If PSPACE is NULL, then all program spaces 1883 are considered. Results are stored into INFO. */ 1884 1885 static void 1886 add_all_symbol_names_from_pspace (struct collect_info *info, 1887 struct program_space *pspace, 1888 VEC (const_char_ptr) *names) 1889 { 1890 int ix; 1891 const char *iter; 1892 1893 for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix) 1894 add_matching_symbols_to_info (iter, info, pspace); 1895 } 1896 1897 static void 1898 find_superclass_methods (VEC (typep) *superclasses, 1899 const char *name, 1900 VEC (const_char_ptr) **result_names) 1901 { 1902 int old_len = VEC_length (const_char_ptr, *result_names); 1903 VEC (typep) *iter_classes; 1904 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); 1905 1906 iter_classes = superclasses; 1907 while (1) 1908 { 1909 VEC (typep) *new_supers = NULL; 1910 int ix; 1911 struct type *t; 1912 1913 make_cleanup (VEC_cleanup (typep), &new_supers); 1914 for (ix = 0; VEC_iterate (typep, iter_classes, ix, t); ++ix) 1915 find_methods (t, name, result_names, &new_supers); 1916 1917 if (VEC_length (const_char_ptr, *result_names) != old_len 1918 || VEC_empty (typep, new_supers)) 1919 break; 1920 1921 iter_classes = new_supers; 1922 } 1923 1924 do_cleanups (cleanup); 1925 } 1926 1927 /* This finds the method COPY in the class whose type is given by one 1928 of the symbols in SYM_CLASSES. */ 1929 1930 static struct symtabs_and_lines 1931 find_method (struct linespec_state *self, char *saved_arg, 1932 char *copy, const char *class_name, VEC (symbolp) *sym_classes) 1933 { 1934 char *canon; 1935 struct symbol *sym; 1936 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); 1937 int ix; 1938 int last_result_len; 1939 VEC (typep) *superclass_vec; 1940 VEC (const_char_ptr) *result_names; 1941 struct collect_info info; 1942 char *name_iter; 1943 1944 /* NAME is typed by the user: it needs to be canonicalized before 1945 searching the symbol tables. */ 1946 canon = cp_canonicalize_string_no_typedefs (copy); 1947 if (canon != NULL) 1948 { 1949 copy = canon; 1950 make_cleanup (xfree, copy); 1951 } 1952 1953 /* Sort symbols so that symbols with the same program space are next 1954 to each other. */ 1955 qsort (VEC_address (symbolp, sym_classes), 1956 VEC_length (symbolp, sym_classes), 1957 sizeof (symbolp), 1958 compare_symbols); 1959 1960 info.state = self; 1961 info.result.sals = NULL; 1962 info.result.nelts = 0; 1963 1964 /* Iterate over all the types, looking for the names of existing 1965 methods matching COPY. If we cannot find a direct method in a 1966 given program space, then we consider inherited methods; this is 1967 not ideal (ideal would be to respect C++ hiding rules), but it 1968 seems good enough and is what GDB has historically done. We only 1969 need to collect the names because later we find all symbols with 1970 those names. This loop is written in a somewhat funny way 1971 because we collect data across the program space before deciding 1972 what to do. */ 1973 superclass_vec = NULL; 1974 make_cleanup (VEC_cleanup (typep), &superclass_vec); 1975 result_names = NULL; 1976 make_cleanup (VEC_cleanup (const_char_ptr), &result_names); 1977 last_result_len = 0; 1978 for (ix = 0; VEC_iterate (symbolp, sym_classes, ix, sym); ++ix) 1979 { 1980 struct type *t; 1981 struct program_space *pspace; 1982 1983 /* Program spaces that are executing startup should have 1984 been filtered out earlier. */ 1985 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym))->executing_startup); 1986 pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)); 1987 set_current_program_space (pspace); 1988 t = check_typedef (SYMBOL_TYPE (sym)); 1989 find_methods (t, copy, &result_names, &superclass_vec); 1990 1991 /* Handle all items from a single program space at once; and be 1992 sure not to miss the last batch. */ 1993 if (ix == VEC_length (symbolp, sym_classes) - 1 1994 || (pspace 1995 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp, sym_classes, 1996 ix + 1))))) 1997 { 1998 /* If we did not find a direct implementation anywhere in 1999 this program space, consider superclasses. */ 2000 if (VEC_length (const_char_ptr, result_names) == last_result_len) 2001 find_superclass_methods (superclass_vec, copy, &result_names); 2002 2003 /* We have a list of candidate symbol names, so now we 2004 iterate over the symbol tables looking for all 2005 matches in this pspace. */ 2006 add_all_symbol_names_from_pspace (&info, pspace, result_names); 2007 2008 VEC_truncate (typep, superclass_vec, 0); 2009 last_result_len = VEC_length (const_char_ptr, result_names); 2010 } 2011 } 2012 2013 if (info.result.nelts > 0) 2014 { 2015 if (self->canonical) 2016 { 2017 self->canonical->pre_expanded = 1; 2018 if (self->user_filename) 2019 self->canonical->addr_string 2020 = xstrprintf ("%s:%s", self->user_filename, saved_arg); 2021 else 2022 self->canonical->addr_string = xstrdup (saved_arg); 2023 } 2024 2025 do_cleanups (cleanup); 2026 2027 return info.result; 2028 } 2029 2030 if (copy[0] == '~') 2031 cplusplus_error (saved_arg, 2032 "the class `%s' does not have destructor defined\n", 2033 class_name); 2034 else 2035 cplusplus_error (saved_arg, 2036 "the class %s does not have any method named %s\n", 2037 class_name, copy); 2038 } 2039 2040 2041 2042 /* This object is used when collecting all matching symtabs. */ 2043 2044 struct symtab_collector 2045 { 2046 /* The result vector of symtabs. */ 2047 VEC (symtab_p) *symtabs; 2048 2049 /* This is used to ensure the symtabs are unique. */ 2050 htab_t symtab_table; 2051 }; 2052 2053 /* Callback for iterate_over_symtabs. */ 2054 2055 static int 2056 add_symtabs_to_list (struct symtab *symtab, void *d) 2057 { 2058 struct symtab_collector *data = d; 2059 void **slot; 2060 2061 slot = htab_find_slot (data->symtab_table, symtab, INSERT); 2062 if (!*slot) 2063 { 2064 *slot = symtab; 2065 VEC_safe_push (symtab_p, data->symtabs, symtab); 2066 } 2067 2068 return 0; 2069 } 2070 2071 /* Given a file name, return a VEC of all matching symtabs. */ 2072 2073 static VEC (symtab_p) * 2074 collect_symtabs_from_filename (const char *file) 2075 { 2076 struct symtab_collector collector; 2077 struct cleanup *cleanups; 2078 struct program_space *pspace; 2079 2080 collector.symtabs = NULL; 2081 collector.symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer, 2082 NULL); 2083 cleanups = make_cleanup_htab_delete (collector.symtab_table); 2084 2085 /* Find that file's data. */ 2086 ALL_PSPACES (pspace) 2087 { 2088 if (pspace->executing_startup) 2089 continue; 2090 2091 set_current_program_space (pspace); 2092 iterate_over_symtabs (file, add_symtabs_to_list, &collector); 2093 } 2094 2095 do_cleanups (cleanups); 2096 return collector.symtabs; 2097 } 2098 2099 /* Return all the symtabs associated to the filename given by the 2100 substring of *ARGPTR ending at P, and advance ARGPTR past that 2101 filename. */ 2102 2103 static VEC (symtab_p) * 2104 symtabs_from_filename (char **argptr, char *p, int is_quote_enclosed, 2105 char **user_filename) 2106 { 2107 char *p1; 2108 char *copy; 2109 struct cleanup *outer; 2110 VEC (symtab_p) *result; 2111 2112 p1 = p; 2113 while (p != *argptr && p[-1] == ' ') 2114 --p; 2115 if ((*p == '"') && is_quote_enclosed) 2116 --p; 2117 copy = xmalloc (p - *argptr + 1); 2118 outer = make_cleanup (xfree, copy); 2119 memcpy (copy, *argptr, p - *argptr); 2120 /* It may have the ending quote right after the file name. */ 2121 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"') 2122 || copy[p - *argptr - 1] == '\'') 2123 copy[p - *argptr - 1] = 0; 2124 else 2125 copy[p - *argptr] = 0; 2126 2127 result = collect_symtabs_from_filename (copy); 2128 2129 if (VEC_empty (symtab_p, result)) 2130 { 2131 if (!have_full_symbols () && !have_partial_symbols ()) 2132 throw_error (NOT_FOUND_ERROR, 2133 _("No symbol table is loaded. " 2134 "Use the \"file\" command.")); 2135 throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy); 2136 } 2137 2138 /* Discard the file name from the arg. */ 2139 if (*p1 == '\0') 2140 *argptr = p1; 2141 else 2142 *argptr = skip_spaces (p1 + 1); 2143 2144 discard_cleanups (outer); 2145 *user_filename = copy; 2146 return result; 2147 } 2148 2149 /* A callback used by iterate_over_all_matching_symtabs that collects 2150 symbols for find_function_symbols. */ 2151 2152 static int 2153 collect_function_symbols (struct symbol *sym, void *arg) 2154 { 2155 VEC (symbolp) **syms = arg; 2156 2157 if (SYMBOL_CLASS (sym) == LOC_BLOCK) 2158 VEC_safe_push (symbolp, *syms, sym); 2159 2160 return 1; 2161 } 2162 2163 /* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR 2164 and return the symbol. If not found, return NULL. */ 2165 2166 static VEC (symbolp) * 2167 find_function_symbols (char **argptr, char *p, int is_quote_enclosed, 2168 char **user_function) 2169 { 2170 char *p1; 2171 char *copy; 2172 VEC (symbolp) *result = NULL; 2173 2174 p1 = p; 2175 while (p != *argptr && p[-1] == ' ') 2176 --p; 2177 if ((*p == '"') && is_quote_enclosed) 2178 --p; 2179 copy = (char *) xmalloc (p - *argptr + 1); 2180 *user_function = copy; 2181 memcpy (copy, *argptr, p - *argptr); 2182 /* It may have the ending quote right after the file name. */ 2183 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"') 2184 || copy[p - *argptr - 1] == '\'') 2185 copy[p - *argptr - 1] = 0; 2186 else 2187 copy[p - *argptr] = 0; 2188 2189 iterate_over_all_matching_symtabs (copy, VAR_DOMAIN, 2190 collect_function_symbols, &result, NULL); 2191 2192 if (VEC_empty (symbolp, result)) 2193 VEC_free (symbolp, result); 2194 else 2195 { 2196 /* Discard the file name from the arg. */ 2197 *argptr = skip_spaces (p1 + 1); 2198 } 2199 2200 return result; 2201 } 2202 2203 2204 2205 /* A helper for decode_all_digits that handles the 'list_mode' case. */ 2206 2207 static void 2208 decode_digits_list_mode (struct linespec_state *self, 2209 struct symtabs_and_lines *values, 2210 struct symtab_and_line val) 2211 { 2212 int ix; 2213 struct symtab *elt; 2214 2215 gdb_assert (self->list_mode); 2216 2217 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix) 2218 { 2219 /* The logic above should ensure this. */ 2220 gdb_assert (elt != NULL); 2221 2222 set_current_program_space (SYMTAB_PSPACE (elt)); 2223 2224 /* Simplistic search just for the list command. */ 2225 val.symtab = find_line_symtab (elt, val.line, NULL, NULL); 2226 if (val.symtab == NULL) 2227 val.symtab = elt; 2228 val.pspace = SYMTAB_PSPACE (elt); 2229 val.pc = 0; 2230 val.explicit_line = 1; 2231 2232 add_sal_to_sals (self, values, &val, NULL); 2233 } 2234 } 2235 2236 /* A helper for decode_all_digits that iterates over the symtabs, 2237 adding lines to the VEC. */ 2238 2239 static void 2240 decode_digits_ordinary (struct linespec_state *self, 2241 int line, 2242 struct symtabs_and_lines *sals, 2243 struct linetable_entry **best_entry) 2244 { 2245 int ix; 2246 struct symtab *elt; 2247 2248 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix) 2249 { 2250 int i; 2251 VEC (CORE_ADDR) *pcs; 2252 CORE_ADDR pc; 2253 2254 /* The logic above should ensure this. */ 2255 gdb_assert (elt != NULL); 2256 2257 set_current_program_space (SYMTAB_PSPACE (elt)); 2258 2259 pcs = find_pcs_for_symtab_line (elt, line, best_entry); 2260 for (i = 0; VEC_iterate (CORE_ADDR, pcs, i, pc); ++i) 2261 { 2262 struct symtab_and_line sal; 2263 2264 init_sal (&sal); 2265 sal.pspace = SYMTAB_PSPACE (elt); 2266 sal.symtab = elt; 2267 sal.line = line; 2268 sal.pc = pc; 2269 add_sal_to_sals_basic (sals, &sal); 2270 } 2271 2272 VEC_free (CORE_ADDR, pcs); 2273 } 2274 } 2275 2276 /* This decodes a line where the argument is all digits (possibly 2277 preceded by a sign). Q should point to the end of those digits; 2278 the other arguments are as usual. */ 2279 2280 static struct symtabs_and_lines 2281 decode_all_digits (struct linespec_state *self, 2282 char **argptr, 2283 char *q) 2284 { 2285 struct symtabs_and_lines values; 2286 struct symtab_and_line val; 2287 int use_default = 0; 2288 char *saved_arg = *argptr; 2289 2290 enum sign 2291 { 2292 none, plus, minus 2293 } 2294 sign = none; 2295 2296 init_sal (&val); 2297 values.sals = NULL; 2298 values.nelts = 0; 2299 2300 /* This is where we need to make sure that we have good defaults. 2301 We must guarantee that this section of code is never executed 2302 when we are called with just a function name, since 2303 set_default_source_symtab_and_line uses 2304 select_source_symtab that calls us with such an argument. */ 2305 2306 if (VEC_length (symtab_p, self->file_symtabs) == 1 2307 && VEC_index (symtab_p, self->file_symtabs, 0) == NULL) 2308 { 2309 set_current_program_space (self->program_space); 2310 2311 /* Make sure we have at least a default source file. */ 2312 set_default_source_symtab_and_line (); 2313 initialize_defaults (&self->default_symtab, &self->default_line); 2314 VEC_pop (symtab_p, self->file_symtabs); 2315 VEC_free (symtab_p, self->file_symtabs); 2316 self->file_symtabs 2317 = collect_symtabs_from_filename (self->default_symtab->filename); 2318 use_default = 1; 2319 } 2320 2321 if (**argptr == '+') 2322 sign = plus, (*argptr)++; 2323 else if (**argptr == '-') 2324 sign = minus, (*argptr)++; 2325 val.line = atoi (*argptr); 2326 switch (sign) 2327 { 2328 case plus: 2329 if (q == *argptr) 2330 val.line = 5; 2331 if (use_default) 2332 val.line = self->default_line + val.line; 2333 break; 2334 case minus: 2335 if (q == *argptr) 2336 val.line = 15; 2337 if (use_default) 2338 val.line = self->default_line - val.line; 2339 else 2340 val.line = 1; 2341 break; 2342 case none: 2343 break; /* No need to adjust val.line. */ 2344 } 2345 2346 *argptr = skip_spaces (q); 2347 2348 if (self->list_mode) 2349 decode_digits_list_mode (self, &values, val); 2350 else 2351 { 2352 struct linetable_entry *best_entry = NULL; 2353 int *filter; 2354 struct block **blocks; 2355 struct cleanup *cleanup; 2356 struct symtabs_and_lines intermediate_results; 2357 int i, j; 2358 2359 intermediate_results.sals = NULL; 2360 intermediate_results.nelts = 0; 2361 2362 decode_digits_ordinary (self, val.line, &intermediate_results, 2363 &best_entry); 2364 if (intermediate_results.nelts == 0 && best_entry != NULL) 2365 decode_digits_ordinary (self, best_entry->line, &intermediate_results, 2366 &best_entry); 2367 2368 cleanup = make_cleanup (xfree, intermediate_results.sals); 2369 2370 /* For optimized code, compiler can scatter one source line 2371 accross disjoint ranges of PC values, even when no duplicate 2372 functions or inline functions are involved. For example, 2373 'for (;;)' inside non-template non-inline non-ctor-or-dtor 2374 function can result in two PC ranges. In this case, we don't 2375 want to set breakpoint on first PC of each range. To filter 2376 such cases, we use containing blocks -- for each PC found 2377 above we see if there are other PCs that are in the same 2378 block. If yes, the other PCs are filtered out. */ 2379 2380 filter = xmalloc (intermediate_results.nelts * sizeof (int)); 2381 make_cleanup (xfree, filter); 2382 blocks = xmalloc (intermediate_results.nelts * sizeof (struct block *)); 2383 make_cleanup (xfree, blocks); 2384 2385 for (i = 0; i < intermediate_results.nelts; ++i) 2386 { 2387 set_current_program_space (intermediate_results.sals[i].pspace); 2388 2389 filter[i] = 1; 2390 blocks[i] = block_for_pc_sect (intermediate_results.sals[i].pc, 2391 intermediate_results.sals[i].section); 2392 } 2393 2394 for (i = 0; i < intermediate_results.nelts; ++i) 2395 { 2396 if (blocks[i] != NULL) 2397 for (j = i + 1; j < intermediate_results.nelts; ++j) 2398 { 2399 if (blocks[j] == blocks[i]) 2400 { 2401 filter[j] = 0; 2402 break; 2403 } 2404 } 2405 } 2406 2407 for (i = 0; i < intermediate_results.nelts; ++i) 2408 if (filter[i]) 2409 { 2410 struct symbol *sym = (blocks[i] 2411 ? block_containing_function (blocks[i]) 2412 : NULL); 2413 2414 if (self->funfirstline) 2415 skip_prologue_sal (&intermediate_results.sals[i]); 2416 /* Make sure the line matches the request, not what was 2417 found. */ 2418 intermediate_results.sals[i].line = val.line; 2419 add_sal_to_sals (self, &values, &intermediate_results.sals[i], 2420 sym ? SYMBOL_NATURAL_NAME (sym) : NULL); 2421 } 2422 2423 do_cleanups (cleanup); 2424 } 2425 2426 if (values.nelts == 0) 2427 { 2428 if (self->user_filename) 2429 throw_error (NOT_FOUND_ERROR, _("No line %d in file \"%s\"."), 2430 val.line, self->user_filename); 2431 else 2432 throw_error (NOT_FOUND_ERROR, _("No line %d in the current file."), 2433 val.line); 2434 } 2435 2436 if (self->canonical) 2437 { 2438 char *copy = savestring (saved_arg, q - saved_arg); 2439 2440 self->canonical->pre_expanded = 1; 2441 gdb_assert (self->user_filename || use_default); 2442 self->canonical->addr_string 2443 = xstrprintf ("%s:%s", (self->user_filename 2444 ? self->user_filename 2445 : self->default_symtab->filename), 2446 copy); 2447 xfree (copy); 2448 } 2449 2450 return values; 2451 } 2452 2453 2454 2455 /* Decode a linespec starting with a dollar sign. */ 2456 2457 static struct symtabs_and_lines 2458 decode_dollar (struct linespec_state *self, char *copy) 2459 { 2460 LONGEST valx; 2461 int index = 0; 2462 struct symtabs_and_lines values; 2463 struct symtab_and_line val; 2464 char *p; 2465 struct symbol *sym; 2466 struct minimal_symbol *msymbol; 2467 int ix; 2468 struct symtab *elt; 2469 2470 p = (copy[1] == '$') ? copy + 2 : copy + 1; 2471 while (*p >= '0' && *p <= '9') 2472 p++; 2473 if (!*p) /* Reached end of token without hitting non-digit. */ 2474 { 2475 /* We have a value history reference. */ 2476 struct value *val_history; 2477 2478 sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index); 2479 val_history = access_value_history ((copy[1] == '$') ? -index : index); 2480 if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT) 2481 error (_("History values used in line " 2482 "specs must have integer values.")); 2483 valx = value_as_long (val_history); 2484 } 2485 else 2486 { 2487 /* Not all digits -- may be user variable/function or a 2488 convenience variable. */ 2489 2490 volatile struct gdb_exception exc; 2491 2492 /* Avoid "may be used uninitialized" warning. */ 2493 values.sals = NULL; 2494 values.nelts = 0; 2495 2496 TRY_CATCH (exc, RETURN_MASK_ERROR) 2497 { 2498 values = decode_variable (self, copy); 2499 } 2500 2501 if (exc.reason == 0) 2502 return values; 2503 2504 if (exc.error != NOT_FOUND_ERROR) 2505 throw_exception (exc); 2506 2507 /* Not a user variable or function -- must be convenience variable. */ 2508 if (!get_internalvar_integer (lookup_internalvar (copy + 1), &valx)) 2509 error (_("Convenience variables used in line " 2510 "specs must have integer values.")); 2511 } 2512 2513 init_sal (&val); 2514 2515 values.sals = NULL; 2516 values.nelts = 0; 2517 2518 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix) 2519 { 2520 if (elt == NULL) 2521 { 2522 elt = self->default_symtab; 2523 set_current_program_space (self->program_space); 2524 } 2525 else 2526 set_current_program_space (SYMTAB_PSPACE (elt)); 2527 2528 /* Either history value or convenience value from above, in valx. */ 2529 val.symtab = elt; 2530 val.line = valx; 2531 val.pc = 0; 2532 val.pspace = elt ? SYMTAB_PSPACE (elt) : current_program_space; 2533 2534 add_sal_to_sals (self, &values, &val, NULL); 2535 } 2536 2537 if (self->canonical) 2538 { 2539 self->canonical->pre_expanded = 1; 2540 if (self->user_filename) 2541 self->canonical->addr_string = xstrprintf ("%s:%s", 2542 self->user_filename, copy); 2543 else 2544 self->canonical->addr_string = xstrdup (copy); 2545 } 2546 2547 return values; 2548 } 2549 2550 2551 2552 /* A helper for decode_line_1 that tries to find a label. The label 2553 is searched for in the current block. 2554 FUNCTION_SYMBOLS is a list of the enclosing functions; or NULL if none 2555 specified. 2556 COPY is the name of the label to find. 2557 CANONICAL is the same as the "canonical" argument to decode_line_1. 2558 RESULT is a pointer to a symtabs_and_lines structure which will be 2559 filled in on success. 2560 This function returns 1 if a label was found, 0 otherwise. */ 2561 2562 static int 2563 decode_label (struct linespec_state *self, 2564 VEC (symbolp) *function_symbols, char *copy, 2565 struct symtabs_and_lines *result) 2566 { 2567 struct symbol *fn_sym; 2568 int ix; 2569 2570 if (function_symbols == NULL) 2571 { 2572 struct block *block; 2573 struct symbol *sym; 2574 struct symtab_and_line sal; 2575 struct symtabs_and_lines values; 2576 2577 values.nelts = 0; 2578 values.sals = NULL; 2579 2580 set_current_program_space (self->program_space); 2581 block = get_search_block (NULL); 2582 2583 for (; 2584 block && !BLOCK_FUNCTION (block); 2585 block = BLOCK_SUPERBLOCK (block)) 2586 ; 2587 if (!block) 2588 return 0; 2589 fn_sym = BLOCK_FUNCTION (block); 2590 2591 sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0); 2592 2593 if (sym == NULL) 2594 return 0; 2595 2596 symbol_to_sal (&sal, self->funfirstline, sym); 2597 add_sal_to_sals (self, &values, &sal, 2598 SYMBOL_NATURAL_NAME (fn_sym)); 2599 2600 if (self->canonical) 2601 { 2602 self->canonical->special_display = 1; 2603 self->canonical->addr_string 2604 = xstrprintf ("%s:%s", SYMBOL_NATURAL_NAME (fn_sym), 2605 copy); 2606 } 2607 2608 *result = values; 2609 2610 return 1; 2611 } 2612 2613 result->sals = NULL; 2614 result->nelts = 0; 2615 2616 for (ix = 0; VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix) 2617 { 2618 struct block *block; 2619 struct symbol *sym; 2620 2621 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym))); 2622 block = SYMBOL_BLOCK_VALUE (fn_sym); 2623 sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0); 2624 2625 if (sym != NULL) 2626 { 2627 struct symtab_and_line sal; 2628 char *symname; 2629 2630 symbol_to_sal (&sal, self->funfirstline, sym); 2631 symname = xstrprintf ("%s:%s", 2632 SYMBOL_NATURAL_NAME (fn_sym), 2633 SYMBOL_NATURAL_NAME (sym)); 2634 add_sal_to_sals (self, result, &sal, symname); 2635 xfree (symname); 2636 } 2637 } 2638 2639 if (self->canonical && result->nelts > 0) 2640 { 2641 self->canonical->pre_expanded = 1; 2642 self->canonical->special_display = 1; 2643 2644 gdb_assert (self->user_function); 2645 self->canonical->addr_string 2646 = xstrprintf ("%s:%s", self->user_function, copy); 2647 } 2648 2649 return result->nelts > 0; 2650 } 2651 2652 /* A callback used to possibly add a symbol to the results. */ 2653 2654 static int 2655 collect_symbols (struct symbol *sym, void *data) 2656 { 2657 struct collect_info *info = data; 2658 struct symtab_and_line sal; 2659 2660 if (symbol_to_sal (&sal, info->state->funfirstline, sym) 2661 && maybe_add_address (info->state->addr_set, 2662 SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)), 2663 sal.pc)) 2664 add_sal_to_sals (info->state, &info->result, &sal, 2665 SYMBOL_NATURAL_NAME (sym)); 2666 2667 return 1; 2668 } 2669 2670 /* We've found a minimal symbol MSYMBOL to associate with our 2671 linespec; add it to the result symtabs_and_lines. */ 2672 2673 static void 2674 minsym_found (struct linespec_state *self, struct objfile *objfile, 2675 struct minimal_symbol *msymbol, 2676 struct symtabs_and_lines *result) 2677 { 2678 struct gdbarch *gdbarch = get_objfile_arch (objfile); 2679 CORE_ADDR pc; 2680 struct symtab_and_line sal; 2681 2682 sal = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol), 2683 (struct obj_section *) 0, 0); 2684 sal.section = SYMBOL_OBJ_SECTION (msymbol); 2685 2686 /* The minimal symbol might point to a function descriptor; 2687 resolve it to the actual code address instead. */ 2688 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, ¤t_target); 2689 if (pc != sal.pc) 2690 sal = find_pc_sect_line (pc, NULL, 0); 2691 2692 if (self->funfirstline) 2693 skip_prologue_sal (&sal); 2694 2695 if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc)) 2696 add_sal_to_sals (self, result, &sal, SYMBOL_NATURAL_NAME (msymbol)); 2697 } 2698 2699 /* A helper struct which just holds a minimal symbol and the object 2700 file from which it came. */ 2701 2702 typedef struct minsym_and_objfile 2703 { 2704 struct minimal_symbol *minsym; 2705 struct objfile *objfile; 2706 } minsym_and_objfile_d; 2707 2708 DEF_VEC_O (minsym_and_objfile_d); 2709 2710 /* A helper struct to pass some data through 2711 iterate_over_minimal_symbols. */ 2712 2713 struct collect_minsyms 2714 { 2715 /* The objfile we're examining. */ 2716 struct objfile *objfile; 2717 2718 /* The funfirstline setting from the initial call. */ 2719 int funfirstline; 2720 2721 /* The list_mode setting from the initial call. */ 2722 int list_mode; 2723 2724 /* The resulting symbols. */ 2725 VEC (minsym_and_objfile_d) *msyms; 2726 }; 2727 2728 /* A helper function to classify a minimal_symbol_type according to 2729 priority. */ 2730 2731 static int 2732 classify_mtype (enum minimal_symbol_type t) 2733 { 2734 switch (t) 2735 { 2736 case mst_file_text: 2737 case mst_file_data: 2738 case mst_file_bss: 2739 /* Intermediate priority. */ 2740 return 1; 2741 2742 case mst_solib_trampoline: 2743 /* Lowest priority. */ 2744 return 2; 2745 2746 default: 2747 /* Highest priority. */ 2748 return 0; 2749 } 2750 } 2751 2752 /* Callback for qsort that sorts symbols by priority. */ 2753 2754 static int 2755 compare_msyms (const void *a, const void *b) 2756 { 2757 const minsym_and_objfile_d *moa = a; 2758 const minsym_and_objfile_d *mob = b; 2759 enum minimal_symbol_type ta = MSYMBOL_TYPE (moa->minsym); 2760 enum minimal_symbol_type tb = MSYMBOL_TYPE (mob->minsym); 2761 2762 return classify_mtype (ta) - classify_mtype (tb); 2763 } 2764 2765 /* Callback for iterate_over_minimal_symbols that adds the symbol to 2766 the result. */ 2767 2768 static void 2769 add_minsym (struct minimal_symbol *minsym, void *d) 2770 { 2771 struct collect_minsyms *info = d; 2772 minsym_and_objfile_d mo; 2773 2774 /* Exclude data symbols when looking for breakpoint locations. */ 2775 if (!info->list_mode) 2776 switch (minsym->type) 2777 { 2778 case mst_slot_got_plt: 2779 case mst_data: 2780 case mst_bss: 2781 case mst_abs: 2782 case mst_file_data: 2783 case mst_file_bss: 2784 { 2785 /* Make sure this minsym is not a function descriptor 2786 before we decide to discard it. */ 2787 struct gdbarch *gdbarch = info->objfile->gdbarch; 2788 CORE_ADDR addr = gdbarch_convert_from_func_ptr_addr 2789 (gdbarch, SYMBOL_VALUE_ADDRESS (minsym), 2790 ¤t_target); 2791 2792 if (addr == SYMBOL_VALUE_ADDRESS (minsym)) 2793 return; 2794 } 2795 } 2796 2797 mo.minsym = minsym; 2798 mo.objfile = info->objfile; 2799 VEC_safe_push (minsym_and_objfile_d, info->msyms, &mo); 2800 } 2801 2802 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE 2803 is not NULL, the search is restricted to just that program 2804 space. */ 2805 2806 static void 2807 search_minsyms_for_name (struct collect_info *info, const char *name, 2808 struct program_space *search_pspace) 2809 { 2810 struct objfile *objfile; 2811 struct program_space *pspace; 2812 2813 ALL_PSPACES (pspace) 2814 { 2815 struct collect_minsyms local; 2816 struct cleanup *cleanup; 2817 2818 if (search_pspace != NULL && search_pspace != pspace) 2819 continue; 2820 if (pspace->executing_startup) 2821 continue; 2822 2823 set_current_program_space (pspace); 2824 2825 memset (&local, 0, sizeof (local)); 2826 local.funfirstline = info->state->funfirstline; 2827 local.list_mode = info->state->list_mode; 2828 2829 cleanup = make_cleanup (VEC_cleanup (minsym_and_objfile_d), 2830 &local.msyms); 2831 2832 ALL_OBJFILES (objfile) 2833 { 2834 local.objfile = objfile; 2835 iterate_over_minimal_symbols (objfile, name, add_minsym, &local); 2836 } 2837 2838 if (!VEC_empty (minsym_and_objfile_d, local.msyms)) 2839 { 2840 int classification; 2841 int ix; 2842 minsym_and_objfile_d *item; 2843 2844 qsort (VEC_address (minsym_and_objfile_d, local.msyms), 2845 VEC_length (minsym_and_objfile_d, local.msyms), 2846 sizeof (minsym_and_objfile_d), 2847 compare_msyms); 2848 2849 /* Now the minsyms are in classification order. So, we walk 2850 over them and process just the minsyms with the same 2851 classification as the very first minsym in the list. */ 2852 item = VEC_index (minsym_and_objfile_d, local.msyms, 0); 2853 classification = classify_mtype (MSYMBOL_TYPE (item->minsym)); 2854 2855 for (ix = 0; 2856 VEC_iterate (minsym_and_objfile_d, local.msyms, ix, item); 2857 ++ix) 2858 { 2859 if (classify_mtype (MSYMBOL_TYPE (item->minsym)) != classification) 2860 break; 2861 2862 minsym_found (info->state, item->objfile, item->minsym, 2863 &info->result); 2864 } 2865 } 2866 2867 do_cleanups (cleanup); 2868 } 2869 } 2870 2871 /* A helper function to add all symbols matching NAME to INFO. If 2872 PSPACE is not NULL, the search is restricted to just that program 2873 space. */ 2874 2875 static void 2876 add_matching_symbols_to_info (const char *name, 2877 struct collect_info *info, 2878 struct program_space *pspace) 2879 { 2880 int ix; 2881 struct symtab *elt; 2882 2883 for (ix = 0; VEC_iterate (symtab_p, info->state->file_symtabs, ix, elt); ++ix) 2884 { 2885 struct symbol *sym; 2886 2887 if (elt == NULL) 2888 { 2889 iterate_over_all_matching_symtabs (name, VAR_DOMAIN, 2890 collect_symbols, info, 2891 pspace); 2892 search_minsyms_for_name (info, name, pspace); 2893 } 2894 else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt)) 2895 { 2896 /* Program spaces that are executing startup should have 2897 been filtered out earlier. */ 2898 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup); 2899 set_current_program_space (SYMTAB_PSPACE (elt)); 2900 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt), name, 2901 VAR_DOMAIN, collect_symbols, 2902 info); 2903 } 2904 } 2905 } 2906 2907 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL, 2908 look in that symtab's static variables first. */ 2909 2910 static struct symtabs_and_lines 2911 decode_variable (struct linespec_state *self, char *copy) 2912 { 2913 struct collect_info info; 2914 const char *lookup_name; 2915 char *canon; 2916 struct cleanup *cleanup; 2917 2918 info.state = self; 2919 info.result.sals = NULL; 2920 info.result.nelts = 0; 2921 2922 cleanup = demangle_for_lookup (copy, current_language->la_language, 2923 &lookup_name); 2924 if (current_language->la_language == language_ada) 2925 { 2926 /* In Ada, the symbol lookups are performed using the encoded 2927 name rather than the demangled name. */ 2928 lookup_name = ada_name_for_lookup (copy); 2929 make_cleanup (xfree, (void *) lookup_name); 2930 } 2931 2932 canon = cp_canonicalize_string_no_typedefs (lookup_name); 2933 if (canon != NULL) 2934 { 2935 make_cleanup (xfree, canon); 2936 lookup_name = canon; 2937 } 2938 2939 add_matching_symbols_to_info (lookup_name, &info, NULL); 2940 2941 if (info.result.nelts > 0) 2942 { 2943 if (self->canonical) 2944 { 2945 self->canonical->pre_expanded = 1; 2946 if (self->user_filename) 2947 self->canonical->addr_string 2948 = xstrprintf ("%s:%s", self->user_filename, copy); 2949 else 2950 self->canonical->addr_string = xstrdup (copy); 2951 } 2952 return info.result; 2953 } 2954 2955 if (!have_full_symbols () 2956 && !have_partial_symbols () 2957 && !have_minimal_symbols ()) 2958 throw_error (NOT_FOUND_ERROR, 2959 _("No symbol table is loaded. Use the \"file\" command.")); 2960 if (self->user_filename) 2961 throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined in \"%s\"."), 2962 copy, self->user_filename); 2963 else 2964 throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined."), copy); 2965 } 2966 2967 2968 2969 2970 /* Now come some functions that are called from multiple places within 2971 decode_line_1. */ 2972 2973 static int 2974 symbol_to_sal (struct symtab_and_line *result, 2975 int funfirstline, struct symbol *sym) 2976 { 2977 if (SYMBOL_CLASS (sym) == LOC_BLOCK) 2978 { 2979 *result = find_function_start_sal (sym, funfirstline); 2980 return 1; 2981 } 2982 else 2983 { 2984 if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0) 2985 { 2986 init_sal (result); 2987 result->symtab = SYMBOL_SYMTAB (sym); 2988 result->line = SYMBOL_LINE (sym); 2989 result->pc = SYMBOL_VALUE_ADDRESS (sym); 2990 result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)); 2991 result->explicit_pc = 1; 2992 return 1; 2993 } 2994 else if (funfirstline) 2995 { 2996 /* Nothing. */ 2997 } 2998 else if (SYMBOL_LINE (sym) != 0) 2999 { 3000 /* We know its line number. */ 3001 init_sal (result); 3002 result->symtab = SYMBOL_SYMTAB (sym); 3003 result->line = SYMBOL_LINE (sym); 3004 result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)); 3005 return 1; 3006 } 3007 } 3008 3009 return 0; 3010 } 3011 3012 /* See the comment in linespec.h. */ 3013 3014 void 3015 init_linespec_result (struct linespec_result *lr) 3016 { 3017 memset (lr, 0, sizeof (*lr)); 3018 } 3019 3020 /* See the comment in linespec.h. */ 3021 3022 void 3023 destroy_linespec_result (struct linespec_result *ls) 3024 { 3025 int i; 3026 struct linespec_sals *lsal; 3027 3028 xfree (ls->addr_string); 3029 for (i = 0; VEC_iterate (linespec_sals, ls->sals, i, lsal); ++i) 3030 { 3031 xfree (lsal->canonical); 3032 xfree (lsal->sals.sals); 3033 } 3034 VEC_free (linespec_sals, ls->sals); 3035 } 3036 3037 /* Cleanup function for a linespec_result. */ 3038 3039 static void 3040 cleanup_linespec_result (void *a) 3041 { 3042 destroy_linespec_result (a); 3043 } 3044 3045 /* See the comment in linespec.h. */ 3046 3047 struct cleanup * 3048 make_cleanup_destroy_linespec_result (struct linespec_result *ls) 3049 { 3050 return make_cleanup (cleanup_linespec_result, ls); 3051 } 3052