1 /* Parser for linespec for the GNU debugger, GDB. 2 3 Copyright (C) 1986-2013 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 #include "stack.h" 47 48 typedef struct symtab *symtab_p; 49 DEF_VEC_P (symtab_p); 50 51 typedef struct symbol *symbolp; 52 DEF_VEC_P (symbolp); 53 54 typedef struct type *typep; 55 DEF_VEC_P (typep); 56 57 /* An address entry is used to ensure that any given location is only 58 added to the result a single time. It holds an address and the 59 program space from which the address came. */ 60 61 struct address_entry 62 { 63 struct program_space *pspace; 64 CORE_ADDR addr; 65 }; 66 67 /* A helper struct which just holds a minimal symbol and the object 68 file from which it came. */ 69 70 typedef struct minsym_and_objfile 71 { 72 struct minimal_symbol *minsym; 73 struct objfile *objfile; 74 } minsym_and_objfile_d; 75 76 DEF_VEC_O (minsym_and_objfile_d); 77 78 /* An enumeration of possible signs for a line offset. */ 79 enum offset_relative_sign 80 { 81 /* No sign */ 82 LINE_OFFSET_NONE, 83 84 /* A plus sign ("+") */ 85 LINE_OFFSET_PLUS, 86 87 /* A minus sign ("-") */ 88 LINE_OFFSET_MINUS, 89 90 /* A special "sign" for unspecified offset. */ 91 LINE_OFFSET_UNKNOWN 92 }; 93 94 /* A line offset in a linespec. */ 95 96 struct line_offset 97 { 98 /* Line offset and any specified sign. */ 99 int offset; 100 enum offset_relative_sign sign; 101 }; 102 103 /* A linespec. Elements of this structure are filled in by a parser 104 (either parse_linespec or some other function). The structure is 105 then converted into SALs by convert_linespec_to_sals. */ 106 107 struct linespec 108 { 109 /* An expression and the resulting PC. Specifying an expression 110 currently precludes the use of other members. */ 111 112 /* The expression entered by the user. */ 113 const char *expression; 114 115 /* The resulting PC expression derived from evaluating EXPRESSION. */ 116 CORE_ADDR expr_pc; 117 118 /* Any specified file symtabs. */ 119 120 /* The user-supplied source filename or NULL if none was specified. */ 121 const char *source_filename; 122 123 /* The list of symtabs to search to which to limit the search. May not 124 be NULL. If SOURCE_FILENAME is NULL (no user-specified filename), 125 FILE_SYMTABS should contain one single NULL member. This will 126 cause the code to use the default symtab. */ 127 VEC (symtab_p) *file_symtabs; 128 129 /* The name of a function or method and any matching symbols. */ 130 131 /* The user-specified function name. If no function name was 132 supplied, this may be NULL. */ 133 const char *function_name; 134 135 /* A list of matching function symbols and minimal symbols. Both lists 136 may be NULL if no matching symbols were found. */ 137 VEC (symbolp) *function_symbols; 138 VEC (minsym_and_objfile_d) *minimal_symbols; 139 140 /* The name of a label and matching symbols. */ 141 142 /* The user-specified label name. */ 143 const char *label_name; 144 145 /* A structure of matching label symbols and the corresponding 146 function symbol in which the label was found. Both may be NULL 147 or both must be non-NULL. */ 148 struct 149 { 150 VEC (symbolp) *label_symbols; 151 VEC (symbolp) *function_symbols; 152 } labels; 153 154 /* Line offset. It may be LINE_OFFSET_UNKNOWN, meaning that no 155 offset was specified. */ 156 struct line_offset line_offset; 157 }; 158 typedef struct linespec *linespec_p; 159 160 /* A canonical linespec represented as a symtab-related string. 161 162 Each entry represents the "SYMTAB:SUFFIX" linespec string. 163 SYMTAB can be converted for example by symtab_to_fullname or 164 symtab_to_filename_for_display as needed. */ 165 166 struct linespec_canonical_name 167 { 168 /* Remaining text part of the linespec string. */ 169 char *suffix; 170 171 /* If NULL then SUFFIX is the whole linespec string. */ 172 struct symtab *symtab; 173 }; 174 175 /* An instance of this is used to keep all state while linespec 176 operates. This instance is passed around as a 'this' pointer to 177 the various implementation methods. */ 178 179 struct linespec_state 180 { 181 /* The language in use during linespec processing. */ 182 const struct language_defn *language; 183 184 /* The program space as seen when the module was entered. */ 185 struct program_space *program_space; 186 187 /* The default symtab to use, if no other symtab is specified. */ 188 struct symtab *default_symtab; 189 190 /* The default line to use. */ 191 int default_line; 192 193 /* The 'funfirstline' value that was passed in to decode_line_1 or 194 decode_line_full. */ 195 int funfirstline; 196 197 /* Nonzero if we are running in 'list' mode; see decode_line_list. */ 198 int list_mode; 199 200 /* The 'canonical' value passed to decode_line_full, or NULL. */ 201 struct linespec_result *canonical; 202 203 /* Canonical strings that mirror the symtabs_and_lines result. */ 204 struct linespec_canonical_name *canonical_names; 205 206 /* This is a set of address_entry objects which is used to prevent 207 duplicate symbols from being entered into the result. */ 208 htab_t addr_set; 209 }; 210 211 /* This is a helper object that is used when collecting symbols into a 212 result. */ 213 214 struct collect_info 215 { 216 /* The linespec object in use. */ 217 struct linespec_state *state; 218 219 /* A list of symtabs to which to restrict matches. */ 220 VEC (symtab_p) *file_symtabs; 221 222 /* The result being accumulated. */ 223 struct 224 { 225 VEC (symbolp) *symbols; 226 VEC (minsym_and_objfile_d) *minimal_symbols; 227 } result; 228 }; 229 230 /* Token types */ 231 232 enum ls_token_type 233 { 234 /* A keyword */ 235 LSTOKEN_KEYWORD = 0, 236 237 /* A colon "separator" */ 238 LSTOKEN_COLON, 239 240 /* A string */ 241 LSTOKEN_STRING, 242 243 /* A number */ 244 LSTOKEN_NUMBER, 245 246 /* A comma */ 247 LSTOKEN_COMMA, 248 249 /* EOI (end of input) */ 250 LSTOKEN_EOI, 251 252 /* Consumed token */ 253 LSTOKEN_CONSUMED 254 }; 255 typedef enum ls_token_type linespec_token_type; 256 257 /* List of keywords */ 258 259 static const char * const linespec_keywords[] = { "if", "thread", "task" }; 260 261 /* A token of the linespec lexer */ 262 263 struct ls_token 264 { 265 /* The type of the token */ 266 linespec_token_type type; 267 268 /* Data for the token */ 269 union 270 { 271 /* A string, given as a stoken */ 272 struct stoken string; 273 274 /* A keyword */ 275 const char *keyword; 276 } data; 277 }; 278 typedef struct ls_token linespec_token; 279 280 #define LS_TOKEN_STOKEN(TOK) (TOK).data.string 281 #define LS_TOKEN_KEYWORD(TOK) (TOK).data.keyword 282 283 /* An instance of the linespec parser. */ 284 285 struct ls_parser 286 { 287 /* Lexer internal data */ 288 struct 289 { 290 /* Save head of input stream. */ 291 char *saved_arg; 292 293 /* Head of the input stream. */ 294 char **stream; 295 #define PARSER_STREAM(P) (*(P)->lexer.stream) 296 297 /* The current token. */ 298 linespec_token current; 299 } lexer; 300 301 /* Is the entire linespec quote-enclosed? */ 302 int is_quote_enclosed; 303 304 /* Is a keyword syntactically valid at this point? 305 In, e.g., "break thread thread 1", the leading "keyword" must not 306 be interpreted as such. */ 307 int keyword_ok; 308 309 /* The state of the parse. */ 310 struct linespec_state state; 311 #define PARSER_STATE(PPTR) (&(PPTR)->state) 312 313 /* The result of the parse. */ 314 struct linespec result; 315 #define PARSER_RESULT(PPTR) (&(PPTR)->result) 316 }; 317 typedef struct ls_parser linespec_parser; 318 319 /* Prototypes for local functions. */ 320 321 static void iterate_over_file_blocks (struct symtab *symtab, 322 const char *name, domain_enum domain, 323 symbol_found_callback_ftype *callback, 324 void *data); 325 326 static void initialize_defaults (struct symtab **default_symtab, 327 int *default_line); 328 329 static CORE_ADDR linespec_expression_to_pc (const char **exp_ptr); 330 331 static struct symtabs_and_lines decode_objc (struct linespec_state *self, 332 linespec_p ls, 333 char **argptr); 334 335 static VEC (symtab_p) *symtabs_from_filename (const char *); 336 337 static VEC (symbolp) *find_label_symbols (struct linespec_state *self, 338 VEC (symbolp) *function_symbols, 339 VEC (symbolp) **label_funcs_ret, 340 const char *name); 341 342 static void find_linespec_symbols (struct linespec_state *self, 343 VEC (symtab_p) *file_symtabs, 344 const char *name, 345 VEC (symbolp) **symbols, 346 VEC (minsym_and_objfile_d) **minsyms); 347 348 static struct line_offset 349 linespec_parse_variable (struct linespec_state *self, 350 const char *variable); 351 352 static int symbol_to_sal (struct symtab_and_line *result, 353 int funfirstline, struct symbol *sym); 354 355 static void add_matching_symbols_to_info (const char *name, 356 struct collect_info *info, 357 struct program_space *pspace); 358 359 static void add_all_symbol_names_from_pspace (struct collect_info *info, 360 struct program_space *pspace, 361 VEC (const_char_ptr) *names); 362 363 static VEC (symtab_p) *collect_symtabs_from_filename (const char *file); 364 365 static void decode_digits_ordinary (struct linespec_state *self, 366 linespec_p ls, 367 int line, 368 struct symtabs_and_lines *sals, 369 struct linetable_entry **best_entry); 370 371 static void decode_digits_list_mode (struct linespec_state *self, 372 linespec_p ls, 373 struct symtabs_and_lines *values, 374 struct symtab_and_line val); 375 376 static void minsym_found (struct linespec_state *self, struct objfile *objfile, 377 struct minimal_symbol *msymbol, 378 struct symtabs_and_lines *result); 379 380 static int compare_symbols (const void *a, const void *b); 381 382 static int compare_msymbols (const void *a, const void *b); 383 384 static const char *find_toplevel_char (const char *s, char c); 385 386 /* Permitted quote characters for the parser. This is different from the 387 completer's quote characters to allow backward compatibility with the 388 previous parser. */ 389 static const char *const linespec_quote_characters = "\"\'"; 390 391 /* Lexer functions. */ 392 393 /* Lex a number from the input in PARSER. This only supports 394 decimal numbers. 395 396 Return true if input is decimal numbers. Return false if not. */ 397 398 static int 399 linespec_lexer_lex_number (linespec_parser *parser, linespec_token *tokenp) 400 { 401 tokenp->type = LSTOKEN_NUMBER; 402 LS_TOKEN_STOKEN (*tokenp).length = 0; 403 LS_TOKEN_STOKEN (*tokenp).ptr = PARSER_STREAM (parser); 404 405 /* Keep any sign at the start of the stream. */ 406 if (*PARSER_STREAM (parser) == '+' || *PARSER_STREAM (parser) == '-') 407 { 408 ++LS_TOKEN_STOKEN (*tokenp).length; 409 ++(PARSER_STREAM (parser)); 410 } 411 412 while (isdigit (*PARSER_STREAM (parser))) 413 { 414 ++LS_TOKEN_STOKEN (*tokenp).length; 415 ++(PARSER_STREAM (parser)); 416 } 417 418 /* If the next character in the input buffer is not a space, comma, 419 quote, or colon, this input does not represent a number. */ 420 if (*PARSER_STREAM (parser) != '\0' 421 && !isspace (*PARSER_STREAM (parser)) && *PARSER_STREAM (parser) != ',' 422 && *PARSER_STREAM (parser) != ':' 423 && !strchr (linespec_quote_characters, *PARSER_STREAM (parser))) 424 { 425 PARSER_STREAM (parser) = LS_TOKEN_STOKEN (*tokenp).ptr; 426 return 0; 427 } 428 429 return 1; 430 } 431 432 /* Does P represent one of the keywords? If so, return 433 the keyword. If not, return NULL. */ 434 435 static const char * 436 linespec_lexer_lex_keyword (const char *p) 437 { 438 int i; 439 440 if (p != NULL) 441 { 442 for (i = 0; i < ARRAY_SIZE (linespec_keywords); ++i) 443 { 444 int len = strlen (linespec_keywords[i]); 445 446 /* If P begins with one of the keywords and the next 447 character is not a valid identifier character, 448 we have found a keyword. */ 449 if (strncmp (p, linespec_keywords[i], len) == 0 450 && !(isalnum (p[len]) || p[len] == '_')) 451 return linespec_keywords[i]; 452 } 453 } 454 455 return NULL; 456 } 457 458 /* Does STRING represent an Ada operator? If so, return the length 459 of the decoded operator name. If not, return 0. */ 460 461 static int 462 is_ada_operator (const char *string) 463 { 464 const struct ada_opname_map *mapping; 465 466 for (mapping = ada_opname_table; 467 mapping->encoded != NULL 468 && strncmp (mapping->decoded, string, 469 strlen (mapping->decoded)) != 0; ++mapping) 470 ; 471 472 return mapping->decoded == NULL ? 0 : strlen (mapping->decoded); 473 } 474 475 /* Find QUOTE_CHAR in STRING, accounting for the ':' terminal. Return 476 the location of QUOTE_CHAR, or NULL if not found. */ 477 478 static const char * 479 skip_quote_char (const char *string, char quote_char) 480 { 481 const char *p, *last; 482 483 p = last = find_toplevel_char (string, quote_char); 484 while (p && *p != '\0' && *p != ':') 485 { 486 p = find_toplevel_char (p, quote_char); 487 if (p != NULL) 488 last = p++; 489 } 490 491 return last; 492 } 493 494 /* Make a writable copy of the string given in TOKEN, trimming 495 any trailing whitespace. */ 496 497 static char * 498 copy_token_string (linespec_token token) 499 { 500 char *str, *s; 501 502 if (token.type == LSTOKEN_KEYWORD) 503 return xstrdup (LS_TOKEN_KEYWORD (token)); 504 505 str = savestring (LS_TOKEN_STOKEN (token).ptr, 506 LS_TOKEN_STOKEN (token).length); 507 s = remove_trailing_whitespace (str, str + LS_TOKEN_STOKEN (token).length); 508 *s = '\0'; 509 510 return str; 511 } 512 513 /* Does P represent the end of a quote-enclosed linespec? */ 514 515 static int 516 is_closing_quote_enclosed (const char *p) 517 { 518 if (strchr (linespec_quote_characters, *p)) 519 ++p; 520 p = skip_spaces ((char *) p); 521 return (*p == '\0' || linespec_lexer_lex_keyword (p)); 522 } 523 524 /* Find the end of the parameter list that starts with *INPUT. 525 This helper function assists with lexing string segments 526 which might contain valid (non-terminating) commas. */ 527 528 static char * 529 find_parameter_list_end (char *input) 530 { 531 char end_char, start_char; 532 int depth; 533 char *p; 534 535 start_char = *input; 536 if (start_char == '(') 537 end_char = ')'; 538 else if (start_char == '<') 539 end_char = '>'; 540 else 541 return NULL; 542 543 p = input; 544 depth = 0; 545 while (*p) 546 { 547 if (*p == start_char) 548 ++depth; 549 else if (*p == end_char) 550 { 551 if (--depth == 0) 552 { 553 ++p; 554 break; 555 } 556 } 557 ++p; 558 } 559 560 return p; 561 } 562 563 564 /* Lex a string from the input in PARSER. */ 565 566 static linespec_token 567 linespec_lexer_lex_string (linespec_parser *parser) 568 { 569 linespec_token token; 570 char *start = PARSER_STREAM (parser); 571 572 token.type = LSTOKEN_STRING; 573 574 /* If the input stream starts with a quote character, skip to the next 575 quote character, regardless of the content. */ 576 if (strchr (linespec_quote_characters, *PARSER_STREAM (parser))) 577 { 578 const char *end; 579 char quote_char = *PARSER_STREAM (parser); 580 581 /* Special case: Ada operators. */ 582 if (PARSER_STATE (parser)->language->la_language == language_ada 583 && quote_char == '\"') 584 { 585 int len = is_ada_operator (PARSER_STREAM (parser)); 586 587 if (len != 0) 588 { 589 /* The input is an Ada operator. Return the quoted string 590 as-is. */ 591 LS_TOKEN_STOKEN (token).ptr = PARSER_STREAM (parser); 592 LS_TOKEN_STOKEN (token).length = len; 593 PARSER_STREAM (parser) += len; 594 return token; 595 } 596 597 /* The input does not represent an Ada operator -- fall through 598 to normal quoted string handling. */ 599 } 600 601 /* Skip past the beginning quote. */ 602 ++(PARSER_STREAM (parser)); 603 604 /* Mark the start of the string. */ 605 LS_TOKEN_STOKEN (token).ptr = PARSER_STREAM (parser); 606 607 /* Skip to the ending quote. */ 608 end = skip_quote_char (PARSER_STREAM (parser), quote_char); 609 610 /* Error if the input did not terminate properly. */ 611 if (end == NULL) 612 error (_("unmatched quote")); 613 614 /* Skip over the ending quote and mark the length of the string. */ 615 PARSER_STREAM (parser) = (char *) ++end; 616 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - 2 - start; 617 } 618 else 619 { 620 char *p; 621 622 /* Otherwise, only identifier characters are permitted. 623 Spaces are the exception. In general, we keep spaces, 624 but only if the next characters in the input do not resolve 625 to one of the keywords. 626 627 This allows users to forgo quoting CV-qualifiers, template arguments, 628 and similar common language constructs. */ 629 630 while (1) 631 { 632 if (isspace (*PARSER_STREAM (parser))) 633 { 634 p = skip_spaces (PARSER_STREAM (parser)); 635 /* When we get here we know we've found something followed by 636 a space (we skip over parens and templates below). 637 So if we find a keyword now, we know it is a keyword and not, 638 say, a function name. */ 639 if (linespec_lexer_lex_keyword (p) != NULL) 640 { 641 LS_TOKEN_STOKEN (token).ptr = start; 642 LS_TOKEN_STOKEN (token).length 643 = PARSER_STREAM (parser) - start; 644 return token; 645 } 646 647 /* Advance past the whitespace. */ 648 PARSER_STREAM (parser) = p; 649 } 650 651 /* If the next character is EOI or (single) ':', the 652 string is complete; return the token. */ 653 if (*PARSER_STREAM (parser) == 0) 654 { 655 LS_TOKEN_STOKEN (token).ptr = start; 656 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start; 657 return token; 658 } 659 else if (PARSER_STREAM (parser)[0] == ':') 660 { 661 /* Do not tokenize the C++ scope operator. */ 662 if (PARSER_STREAM (parser)[1] == ':') 663 ++(PARSER_STREAM (parser)); 664 665 /* Do not tokenify if the input length so far is one 666 (i.e, a single-letter drive name) and the next character 667 is a directory separator. This allows Windows-style 668 paths to be recognized as filenames without quoting it. */ 669 else if ((PARSER_STREAM (parser) - start) != 1 670 || !IS_DIR_SEPARATOR (PARSER_STREAM (parser)[1])) 671 { 672 LS_TOKEN_STOKEN (token).ptr = start; 673 LS_TOKEN_STOKEN (token).length 674 = PARSER_STREAM (parser) - start; 675 return token; 676 } 677 } 678 /* Special case: permit quote-enclosed linespecs. */ 679 else if (parser->is_quote_enclosed 680 && strchr (linespec_quote_characters, 681 *PARSER_STREAM (parser)) 682 && is_closing_quote_enclosed (PARSER_STREAM (parser))) 683 { 684 LS_TOKEN_STOKEN (token).ptr = start; 685 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start; 686 return token; 687 } 688 /* Because commas may terminate a linespec and appear in 689 the middle of valid string input, special cases for 690 '<' and '(' are necessary. */ 691 else if (*PARSER_STREAM (parser) == '<' 692 || *PARSER_STREAM (parser) == '(') 693 { 694 char *p; 695 696 p = find_parameter_list_end (PARSER_STREAM (parser)); 697 if (p != NULL) 698 { 699 PARSER_STREAM (parser) = p; 700 continue; 701 } 702 } 703 /* Commas are terminators, but not if they are part of an 704 operator name. */ 705 else if (*PARSER_STREAM (parser) == ',') 706 { 707 if ((PARSER_STATE (parser)->language->la_language 708 == language_cplus) 709 && (PARSER_STREAM (parser) - start) > 8 710 /* strlen ("operator") */) 711 { 712 char *p = strstr (start, "operator"); 713 714 if (p != NULL && is_operator_name (p)) 715 { 716 /* This is an operator name. Keep going. */ 717 ++(PARSER_STREAM (parser)); 718 continue; 719 } 720 } 721 722 /* Comma terminates the string. */ 723 LS_TOKEN_STOKEN (token).ptr = start; 724 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start; 725 return token; 726 } 727 728 /* Advance the stream. */ 729 ++(PARSER_STREAM (parser)); 730 } 731 } 732 733 return token; 734 } 735 736 /* Lex a single linespec token from PARSER. */ 737 738 static linespec_token 739 linespec_lexer_lex_one (linespec_parser *parser) 740 { 741 const char *keyword; 742 743 if (parser->lexer.current.type == LSTOKEN_CONSUMED) 744 { 745 /* Skip any whitespace. */ 746 PARSER_STREAM (parser) = skip_spaces (PARSER_STREAM (parser)); 747 748 /* Check for a keyword, they end the linespec. */ 749 keyword = NULL; 750 if (parser->keyword_ok) 751 keyword = linespec_lexer_lex_keyword (PARSER_STREAM (parser)); 752 if (keyword != NULL) 753 { 754 parser->lexer.current.type = LSTOKEN_KEYWORD; 755 LS_TOKEN_KEYWORD (parser->lexer.current) = keyword; 756 return parser->lexer.current; 757 } 758 759 /* Handle other tokens. */ 760 switch (*PARSER_STREAM (parser)) 761 { 762 case 0: 763 parser->lexer.current.type = LSTOKEN_EOI; 764 break; 765 766 case '+': case '-': 767 case '0': case '1': case '2': case '3': case '4': 768 case '5': case '6': case '7': case '8': case '9': 769 if (!linespec_lexer_lex_number (parser, &(parser->lexer.current))) 770 parser->lexer.current = linespec_lexer_lex_string (parser); 771 break; 772 773 case ':': 774 /* If we have a scope operator, lex the input as a string. 775 Otherwise, return LSTOKEN_COLON. */ 776 if (PARSER_STREAM (parser)[1] == ':') 777 parser->lexer.current = linespec_lexer_lex_string (parser); 778 else 779 { 780 parser->lexer.current.type = LSTOKEN_COLON; 781 ++(PARSER_STREAM (parser)); 782 } 783 break; 784 785 case '\'': case '\"': 786 /* Special case: permit quote-enclosed linespecs. */ 787 if (parser->is_quote_enclosed 788 && is_closing_quote_enclosed (PARSER_STREAM (parser))) 789 { 790 ++(PARSER_STREAM (parser)); 791 parser->lexer.current.type = LSTOKEN_EOI; 792 } 793 else 794 parser->lexer.current = linespec_lexer_lex_string (parser); 795 break; 796 797 case ',': 798 parser->lexer.current.type = LSTOKEN_COMMA; 799 LS_TOKEN_STOKEN (parser->lexer.current).ptr 800 = PARSER_STREAM (parser); 801 LS_TOKEN_STOKEN (parser->lexer.current).length = 1; 802 ++(PARSER_STREAM (parser)); 803 break; 804 805 default: 806 /* If the input is not a number, it must be a string. 807 [Keywords were already considered above.] */ 808 parser->lexer.current = linespec_lexer_lex_string (parser); 809 break; 810 } 811 } 812 813 return parser->lexer.current; 814 } 815 816 /* Consume the current token and return the next token in PARSER's 817 input stream. */ 818 819 static linespec_token 820 linespec_lexer_consume_token (linespec_parser *parser) 821 { 822 parser->lexer.current.type = LSTOKEN_CONSUMED; 823 return linespec_lexer_lex_one (parser); 824 } 825 826 /* Return the next token without consuming the current token. */ 827 828 static linespec_token 829 linespec_lexer_peek_token (linespec_parser *parser) 830 { 831 linespec_token next; 832 char *saved_stream = PARSER_STREAM (parser); 833 linespec_token saved_token = parser->lexer.current; 834 835 next = linespec_lexer_consume_token (parser); 836 PARSER_STREAM (parser) = saved_stream; 837 parser->lexer.current = saved_token; 838 return next; 839 } 840 841 /* Helper functions. */ 842 843 /* Add SAL to SALS. */ 844 845 static void 846 add_sal_to_sals_basic (struct symtabs_and_lines *sals, 847 struct symtab_and_line *sal) 848 { 849 ++sals->nelts; 850 sals->sals = xrealloc (sals->sals, sals->nelts * sizeof (sals->sals[0])); 851 sals->sals[sals->nelts - 1] = *sal; 852 } 853 854 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect 855 the new sal, if needed. If not NULL, SYMNAME is the name of the 856 symbol to use when constructing the new canonical name. 857 858 If LITERAL_CANONICAL is non-zero, SYMNAME will be used as the 859 canonical name for the SAL. */ 860 861 static void 862 add_sal_to_sals (struct linespec_state *self, 863 struct symtabs_and_lines *sals, 864 struct symtab_and_line *sal, 865 const char *symname, int literal_canonical) 866 { 867 add_sal_to_sals_basic (sals, sal); 868 869 if (self->canonical) 870 { 871 struct linespec_canonical_name *canonical; 872 873 self->canonical_names = xrealloc (self->canonical_names, 874 (sals->nelts 875 * sizeof (*self->canonical_names))); 876 canonical = &self->canonical_names[sals->nelts - 1]; 877 if (!literal_canonical && sal->symtab) 878 { 879 const char *fullname = symtab_to_fullname (sal->symtab); 880 881 /* Note that the filter doesn't have to be a valid linespec 882 input. We only apply the ":LINE" treatment to Ada for 883 the time being. */ 884 if (symname != NULL && sal->line != 0 885 && self->language->la_language == language_ada) 886 canonical->suffix = xstrprintf ("%s:%d", symname, sal->line); 887 else if (symname != NULL) 888 canonical->suffix = xstrdup (symname); 889 else 890 canonical->suffix = xstrprintf ("%d", sal->line); 891 canonical->symtab = sal->symtab; 892 } 893 else 894 { 895 if (symname != NULL) 896 canonical->suffix = xstrdup (symname); 897 else 898 canonical->suffix = NULL; 899 canonical->symtab = NULL; 900 } 901 } 902 } 903 904 /* A hash function for address_entry. */ 905 906 static hashval_t 907 hash_address_entry (const void *p) 908 { 909 const struct address_entry *aep = p; 910 hashval_t hash; 911 912 hash = iterative_hash_object (aep->pspace, 0); 913 return iterative_hash_object (aep->addr, hash); 914 } 915 916 /* An equality function for address_entry. */ 917 918 static int 919 eq_address_entry (const void *a, const void *b) 920 { 921 const struct address_entry *aea = a; 922 const struct address_entry *aeb = b; 923 924 return aea->pspace == aeb->pspace && aea->addr == aeb->addr; 925 } 926 927 /* Check whether the address, represented by PSPACE and ADDR, is 928 already in the set. If so, return 0. Otherwise, add it and return 929 1. */ 930 931 static int 932 maybe_add_address (htab_t set, struct program_space *pspace, CORE_ADDR addr) 933 { 934 struct address_entry e, *p; 935 void **slot; 936 937 e.pspace = pspace; 938 e.addr = addr; 939 slot = htab_find_slot (set, &e, INSERT); 940 if (*slot) 941 return 0; 942 943 p = XNEW (struct address_entry); 944 memcpy (p, &e, sizeof (struct address_entry)); 945 *slot = p; 946 947 return 1; 948 } 949 950 /* A callback function and the additional data to call it with. */ 951 952 struct symbol_and_data_callback 953 { 954 /* The callback to use. */ 955 symbol_found_callback_ftype *callback; 956 957 /* Data to be passed to the callback. */ 958 void *data; 959 }; 960 961 /* A helper for iterate_over_all_matching_symtabs that is used to 962 restrict calls to another callback to symbols representing inline 963 symbols only. */ 964 965 static int 966 iterate_inline_only (struct symbol *sym, void *d) 967 { 968 if (SYMBOL_INLINED (sym)) 969 { 970 struct symbol_and_data_callback *cad = d; 971 972 return cad->callback (sym, cad->data); 973 } 974 return 1; /* Continue iterating. */ 975 } 976 977 /* Some data for the expand_symtabs_matching callback. */ 978 979 struct symbol_matcher_data 980 { 981 /* The lookup name against which symbol name should be compared. */ 982 const char *lookup_name; 983 984 /* The routine to be used for comparison. */ 985 symbol_name_cmp_ftype symbol_name_cmp; 986 }; 987 988 /* A helper for iterate_over_all_matching_symtabs that is passed as a 989 callback to the expand_symtabs_matching method. */ 990 991 static int 992 iterate_name_matcher (const char *name, void *d) 993 { 994 const struct symbol_matcher_data *data = d; 995 996 if (data->symbol_name_cmp (name, data->lookup_name) == 0) 997 return 1; /* Expand this symbol's symbol table. */ 998 return 0; /* Skip this symbol. */ 999 } 1000 1001 /* A helper that walks over all matching symtabs in all objfiles and 1002 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is 1003 not NULL, then the search is restricted to just that program 1004 space. If INCLUDE_INLINE is nonzero then symbols representing 1005 inlined instances of functions will be included in the result. */ 1006 1007 static void 1008 iterate_over_all_matching_symtabs (struct linespec_state *state, 1009 const char *name, 1010 const domain_enum domain, 1011 symbol_found_callback_ftype *callback, 1012 void *data, 1013 struct program_space *search_pspace, 1014 int include_inline) 1015 { 1016 struct objfile *objfile; 1017 struct program_space *pspace; 1018 struct symbol_matcher_data matcher_data; 1019 1020 matcher_data.lookup_name = name; 1021 matcher_data.symbol_name_cmp = 1022 state->language->la_get_symbol_name_cmp != NULL 1023 ? state->language->la_get_symbol_name_cmp (name) 1024 : strcmp_iw; 1025 1026 ALL_PSPACES (pspace) 1027 { 1028 if (search_pspace != NULL && search_pspace != pspace) 1029 continue; 1030 if (pspace->executing_startup) 1031 continue; 1032 1033 set_current_program_space (pspace); 1034 1035 ALL_OBJFILES (objfile) 1036 { 1037 struct symtab *symtab; 1038 1039 if (objfile->sf) 1040 objfile->sf->qf->expand_symtabs_matching (objfile, NULL, 1041 iterate_name_matcher, 1042 ALL_DOMAIN, 1043 &matcher_data); 1044 1045 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, symtab) 1046 { 1047 iterate_over_file_blocks (symtab, name, domain, callback, data); 1048 1049 if (include_inline) 1050 { 1051 struct symbol_and_data_callback cad = { callback, data }; 1052 struct block *block; 1053 int i; 1054 1055 for (i = FIRST_LOCAL_BLOCK; 1056 i < BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (symtab)); i++) 1057 { 1058 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), i); 1059 state->language->la_iterate_over_symbols 1060 (block, name, domain, iterate_inline_only, &cad); 1061 } 1062 } 1063 } 1064 } 1065 } 1066 } 1067 1068 /* Returns the block to be used for symbol searches from 1069 the current location. */ 1070 1071 static struct block * 1072 get_current_search_block (void) 1073 { 1074 struct block *block; 1075 enum language save_language; 1076 1077 /* get_selected_block can change the current language when there is 1078 no selected frame yet. */ 1079 save_language = current_language->la_language; 1080 block = get_selected_block (0); 1081 set_language (save_language); 1082 1083 return block; 1084 } 1085 1086 /* Iterate over static and global blocks. */ 1087 1088 static void 1089 iterate_over_file_blocks (struct symtab *symtab, 1090 const char *name, domain_enum domain, 1091 symbol_found_callback_ftype *callback, void *data) 1092 { 1093 struct block *block; 1094 1095 for (block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK); 1096 block != NULL; 1097 block = BLOCK_SUPERBLOCK (block)) 1098 LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data); 1099 } 1100 1101 /* A helper for find_method. This finds all methods in type T which 1102 match NAME. It adds matching symbol names to RESULT_NAMES, and 1103 adds T's direct superclasses to SUPERCLASSES. */ 1104 1105 static void 1106 find_methods (struct type *t, const char *name, 1107 VEC (const_char_ptr) **result_names, 1108 VEC (typep) **superclasses) 1109 { 1110 int ibase; 1111 const char *class_name = type_name_no_tag (t); 1112 1113 /* Ignore this class if it doesn't have a name. This is ugly, but 1114 unless we figure out how to get the physname without the name of 1115 the class, then the loop can't do any good. */ 1116 if (class_name) 1117 { 1118 int method_counter; 1119 1120 CHECK_TYPEDEF (t); 1121 1122 /* Loop over each method name. At this level, all overloads of a name 1123 are counted as a single name. There is an inner loop which loops over 1124 each overload. */ 1125 1126 for (method_counter = TYPE_NFN_FIELDS (t) - 1; 1127 method_counter >= 0; 1128 --method_counter) 1129 { 1130 const char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter); 1131 char dem_opname[64]; 1132 1133 if (strncmp (method_name, "__", 2) == 0 || 1134 strncmp (method_name, "op", 2) == 0 || 1135 strncmp (method_name, "type", 4) == 0) 1136 { 1137 if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI)) 1138 method_name = dem_opname; 1139 else if (cplus_demangle_opname (method_name, dem_opname, 0)) 1140 method_name = dem_opname; 1141 } 1142 1143 if (strcmp_iw (method_name, name) == 0) 1144 { 1145 int field_counter; 1146 1147 for (field_counter = (TYPE_FN_FIELDLIST_LENGTH (t, method_counter) 1148 - 1); 1149 field_counter >= 0; 1150 --field_counter) 1151 { 1152 struct fn_field *f; 1153 const char *phys_name; 1154 1155 f = TYPE_FN_FIELDLIST1 (t, method_counter); 1156 if (TYPE_FN_FIELD_STUB (f, field_counter)) 1157 continue; 1158 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter); 1159 VEC_safe_push (const_char_ptr, *result_names, phys_name); 1160 } 1161 } 1162 } 1163 } 1164 1165 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++) 1166 VEC_safe_push (typep, *superclasses, TYPE_BASECLASS (t, ibase)); 1167 } 1168 1169 /* Find an instance of the character C in the string S that is outside 1170 of all parenthesis pairs, single-quoted strings, and double-quoted 1171 strings. Also, ignore the char within a template name, like a ',' 1172 within foo<int, int>. */ 1173 1174 static const char * 1175 find_toplevel_char (const char *s, char c) 1176 { 1177 int quoted = 0; /* zero if we're not in quotes; 1178 '"' if we're in a double-quoted string; 1179 '\'' if we're in a single-quoted string. */ 1180 int depth = 0; /* Number of unclosed parens we've seen. */ 1181 const char *scan; 1182 1183 for (scan = s; *scan; scan++) 1184 { 1185 if (quoted) 1186 { 1187 if (*scan == quoted) 1188 quoted = 0; 1189 else if (*scan == '\\' && *(scan + 1)) 1190 scan++; 1191 } 1192 else if (*scan == c && ! quoted && depth == 0) 1193 return scan; 1194 else if (*scan == '"' || *scan == '\'') 1195 quoted = *scan; 1196 else if (*scan == '(' || *scan == '<') 1197 depth++; 1198 else if ((*scan == ')' || *scan == '>') && depth > 0) 1199 depth--; 1200 } 1201 1202 return 0; 1203 } 1204 1205 /* The string equivalent of find_toplevel_char. Returns a pointer 1206 to the location of NEEDLE in HAYSTACK, ignoring any occurrences 1207 inside "()" and "<>". Returns NULL if NEEDLE was not found. */ 1208 1209 static const char * 1210 find_toplevel_string (const char *haystack, const char *needle) 1211 { 1212 const char *s = haystack; 1213 1214 do 1215 { 1216 s = find_toplevel_char (s, *needle); 1217 1218 if (s != NULL) 1219 { 1220 /* Found first char in HAYSTACK; check rest of string. */ 1221 if (strncmp (s, needle, strlen (needle)) == 0) 1222 return s; 1223 1224 /* Didn't find it; loop over HAYSTACK, looking for the next 1225 instance of the first character of NEEDLE. */ 1226 ++s; 1227 } 1228 } 1229 while (s != NULL && *s != '\0'); 1230 1231 /* NEEDLE was not found in HAYSTACK. */ 1232 return NULL; 1233 } 1234 1235 /* Convert CANONICAL to its string representation using 1236 symtab_to_fullname for SYMTAB. The caller must xfree the result. */ 1237 1238 static char * 1239 canonical_to_fullform (const struct linespec_canonical_name *canonical) 1240 { 1241 if (canonical->symtab == NULL) 1242 return xstrdup (canonical->suffix); 1243 else 1244 return xstrprintf ("%s:%s", symtab_to_fullname (canonical->symtab), 1245 canonical->suffix); 1246 } 1247 1248 /* Given FILTERS, a list of canonical names, filter the sals in RESULT 1249 and store the result in SELF->CANONICAL. */ 1250 1251 static void 1252 filter_results (struct linespec_state *self, 1253 struct symtabs_and_lines *result, 1254 VEC (const_char_ptr) *filters) 1255 { 1256 int i; 1257 const char *name; 1258 1259 for (i = 0; VEC_iterate (const_char_ptr, filters, i, name); ++i) 1260 { 1261 struct linespec_sals lsal; 1262 int j; 1263 1264 memset (&lsal, 0, sizeof (lsal)); 1265 1266 for (j = 0; j < result->nelts; ++j) 1267 { 1268 const struct linespec_canonical_name *canonical; 1269 char *fullform; 1270 struct cleanup *cleanup; 1271 1272 canonical = &self->canonical_names[j]; 1273 fullform = canonical_to_fullform (canonical); 1274 cleanup = make_cleanup (xfree, fullform); 1275 1276 if (strcmp (name, fullform) == 0) 1277 add_sal_to_sals_basic (&lsal.sals, &result->sals[j]); 1278 1279 do_cleanups (cleanup); 1280 } 1281 1282 if (lsal.sals.nelts > 0) 1283 { 1284 lsal.canonical = xstrdup (name); 1285 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal); 1286 } 1287 } 1288 1289 self->canonical->pre_expanded = 0; 1290 } 1291 1292 /* Store RESULT into SELF->CANONICAL. */ 1293 1294 static void 1295 convert_results_to_lsals (struct linespec_state *self, 1296 struct symtabs_and_lines *result) 1297 { 1298 struct linespec_sals lsal; 1299 1300 lsal.canonical = NULL; 1301 lsal.sals = *result; 1302 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal); 1303 } 1304 1305 /* A structure that contains two string representations of a struct 1306 linespec_canonical_name: 1307 - one where the the symtab's fullname is used; 1308 - one where the filename followed the "set filename-display" 1309 setting. */ 1310 1311 struct decode_line_2_item 1312 { 1313 /* The form using symtab_to_fullname. 1314 It must be xfree'ed after use. */ 1315 char *fullform; 1316 1317 /* The form using symtab_to_filename_for_display. 1318 It must be xfree'ed after use. */ 1319 char *displayform; 1320 1321 /* Field is initialized to zero and it is set to one if the user 1322 requested breakpoint for this entry. */ 1323 unsigned int selected : 1; 1324 }; 1325 1326 /* Helper for qsort to sort decode_line_2_item entries by DISPLAYFORM and 1327 secondarily by FULLFORM. */ 1328 1329 static int 1330 decode_line_2_compare_items (const void *ap, const void *bp) 1331 { 1332 const struct decode_line_2_item *a = ap; 1333 const struct decode_line_2_item *b = bp; 1334 int retval; 1335 1336 retval = strcmp (a->displayform, b->displayform); 1337 if (retval != 0) 1338 return retval; 1339 1340 return strcmp (a->fullform, b->fullform); 1341 } 1342 1343 /* Handle multiple results in RESULT depending on SELECT_MODE. This 1344 will either return normally, throw an exception on multiple 1345 results, or present a menu to the user. On return, the SALS vector 1346 in SELF->CANONICAL is set up properly. */ 1347 1348 static void 1349 decode_line_2 (struct linespec_state *self, 1350 struct symtabs_and_lines *result, 1351 const char *select_mode) 1352 { 1353 char *args, *prompt; 1354 int i; 1355 struct cleanup *old_chain; 1356 VEC (const_char_ptr) *filters = NULL; 1357 struct get_number_or_range_state state; 1358 struct decode_line_2_item *items; 1359 int items_count; 1360 1361 gdb_assert (select_mode != multiple_symbols_all); 1362 gdb_assert (self->canonical != NULL); 1363 gdb_assert (result->nelts >= 1); 1364 1365 old_chain = make_cleanup (VEC_cleanup (const_char_ptr), &filters); 1366 1367 /* Prepare ITEMS array. */ 1368 items_count = result->nelts; 1369 items = xmalloc (sizeof (*items) * items_count); 1370 make_cleanup (xfree, items); 1371 for (i = 0; i < items_count; ++i) 1372 { 1373 const struct linespec_canonical_name *canonical; 1374 struct decode_line_2_item *item; 1375 1376 canonical = &self->canonical_names[i]; 1377 gdb_assert (canonical->suffix != NULL); 1378 item = &items[i]; 1379 1380 item->fullform = canonical_to_fullform (canonical); 1381 make_cleanup (xfree, item->fullform); 1382 1383 if (canonical->symtab == NULL) 1384 item->displayform = canonical->suffix; 1385 else 1386 { 1387 const char *fn_for_display; 1388 1389 fn_for_display = symtab_to_filename_for_display (canonical->symtab); 1390 item->displayform = xstrprintf ("%s:%s", fn_for_display, 1391 canonical->suffix); 1392 make_cleanup (xfree, item->displayform); 1393 } 1394 1395 item->selected = 0; 1396 } 1397 1398 /* Sort the list of method names. */ 1399 qsort (items, items_count, sizeof (*items), decode_line_2_compare_items); 1400 1401 /* Remove entries with the same FULLFORM. */ 1402 if (items_count >= 2) 1403 { 1404 struct decode_line_2_item *dst, *src; 1405 1406 dst = items; 1407 for (src = &items[1]; src < &items[items_count]; src++) 1408 if (strcmp (src->fullform, dst->fullform) != 0) 1409 *++dst = *src; 1410 items_count = dst + 1 - items; 1411 } 1412 1413 if (select_mode == multiple_symbols_cancel && items_count > 1) 1414 error (_("canceled because the command is ambiguous\n" 1415 "See set/show multiple-symbol.")); 1416 1417 if (select_mode == multiple_symbols_all || items_count == 1) 1418 { 1419 do_cleanups (old_chain); 1420 convert_results_to_lsals (self, result); 1421 return; 1422 } 1423 1424 printf_unfiltered (_("[0] cancel\n[1] all\n")); 1425 for (i = 0; i < items_count; i++) 1426 printf_unfiltered ("[%d] %s\n", i + 2, items[i].displayform); 1427 1428 prompt = getenv ("PS2"); 1429 if (prompt == NULL) 1430 { 1431 prompt = "> "; 1432 } 1433 args = command_line_input (prompt, 0, "overload-choice"); 1434 1435 if (args == 0 || *args == 0) 1436 error_no_arg (_("one or more choice numbers")); 1437 1438 init_number_or_range (&state, args); 1439 while (!state.finished) 1440 { 1441 int num; 1442 1443 num = get_number_or_range (&state); 1444 1445 if (num == 0) 1446 error (_("canceled")); 1447 else if (num == 1) 1448 { 1449 /* We intentionally make this result in a single breakpoint, 1450 contrary to what older versions of gdb did. The 1451 rationale is that this lets a user get the 1452 multiple_symbols_all behavior even with the 'ask' 1453 setting; and he can get separate breakpoints by entering 1454 "2-57" at the query. */ 1455 do_cleanups (old_chain); 1456 convert_results_to_lsals (self, result); 1457 return; 1458 } 1459 1460 num -= 2; 1461 if (num >= items_count) 1462 printf_unfiltered (_("No choice number %d.\n"), num); 1463 else 1464 { 1465 struct decode_line_2_item *item = &items[num]; 1466 1467 if (!item->selected) 1468 { 1469 VEC_safe_push (const_char_ptr, filters, item->fullform); 1470 item->selected = 1; 1471 } 1472 else 1473 { 1474 printf_unfiltered (_("duplicate request for %d ignored.\n"), 1475 num + 2); 1476 } 1477 } 1478 } 1479 1480 filter_results (self, result, filters); 1481 do_cleanups (old_chain); 1482 } 1483 1484 1485 1486 /* The parser of linespec itself. */ 1487 1488 /* Throw an appropriate error when SYMBOL is not found (optionally in 1489 FILENAME). */ 1490 1491 static void ATTRIBUTE_NORETURN 1492 symbol_not_found_error (const char *symbol, const char *filename) 1493 { 1494 if (symbol == NULL) 1495 symbol = ""; 1496 1497 if (!have_full_symbols () 1498 && !have_partial_symbols () 1499 && !have_minimal_symbols ()) 1500 throw_error (NOT_FOUND_ERROR, 1501 _("No symbol table is loaded. Use the \"file\" command.")); 1502 1503 /* If SYMBOL starts with '$', the user attempted to either lookup 1504 a function/variable in his code starting with '$' or an internal 1505 variable of that name. Since we do not know which, be concise and 1506 explain both possibilities. */ 1507 if (*symbol == '$') 1508 { 1509 if (filename) 1510 throw_error (NOT_FOUND_ERROR, 1511 _("Undefined convenience variable or function \"%s\" " 1512 "not defined in \"%s\"."), symbol, filename); 1513 else 1514 throw_error (NOT_FOUND_ERROR, 1515 _("Undefined convenience variable or function \"%s\" " 1516 "not defined."), symbol); 1517 } 1518 else 1519 { 1520 if (filename) 1521 throw_error (NOT_FOUND_ERROR, 1522 _("Function \"%s\" not defined in \"%s\"."), 1523 symbol, filename); 1524 else 1525 throw_error (NOT_FOUND_ERROR, 1526 _("Function \"%s\" not defined."), symbol); 1527 } 1528 } 1529 1530 /* Throw an appropriate error when an unexpected token is encountered 1531 in the input. */ 1532 1533 static void ATTRIBUTE_NORETURN 1534 unexpected_linespec_error (linespec_parser *parser) 1535 { 1536 linespec_token token; 1537 static const char * token_type_strings[] 1538 = {"keyword", "colon", "string", "number", "comma", "end of input"}; 1539 1540 /* Get the token that generated the error. */ 1541 token = linespec_lexer_lex_one (parser); 1542 1543 /* Finally, throw the error. */ 1544 if (token.type == LSTOKEN_STRING || token.type == LSTOKEN_NUMBER 1545 || token.type == LSTOKEN_KEYWORD) 1546 { 1547 char *string; 1548 struct cleanup *cleanup; 1549 1550 string = copy_token_string (token); 1551 cleanup = make_cleanup (xfree, string); 1552 throw_error (GENERIC_ERROR, 1553 _("malformed linespec error: unexpected %s, \"%s\""), 1554 token_type_strings[token.type], string); 1555 } 1556 else 1557 throw_error (GENERIC_ERROR, 1558 _("malformed linespec error: unexpected %s"), 1559 token_type_strings[token.type]); 1560 } 1561 1562 /* Parse and return a line offset in STRING. */ 1563 1564 static struct line_offset 1565 linespec_parse_line_offset (const char *string) 1566 { 1567 struct line_offset line_offset = {0, LINE_OFFSET_NONE}; 1568 1569 if (*string == '+') 1570 { 1571 line_offset.sign = LINE_OFFSET_PLUS; 1572 ++string; 1573 } 1574 else if (*string == '-') 1575 { 1576 line_offset.sign = LINE_OFFSET_MINUS; 1577 ++string; 1578 } 1579 1580 /* Right now, we only allow base 10 for offsets. */ 1581 line_offset.offset = atoi (string); 1582 return line_offset; 1583 } 1584 1585 /* Parse the basic_spec in PARSER's input. */ 1586 1587 static void 1588 linespec_parse_basic (linespec_parser *parser) 1589 { 1590 char *name; 1591 linespec_token token; 1592 VEC (symbolp) *symbols, *labels; 1593 VEC (minsym_and_objfile_d) *minimal_symbols; 1594 struct cleanup *cleanup; 1595 1596 /* Get the next token. */ 1597 token = linespec_lexer_lex_one (parser); 1598 1599 /* If it is EOI or KEYWORD, issue an error. */ 1600 if (token.type == LSTOKEN_KEYWORD || token.type == LSTOKEN_EOI) 1601 unexpected_linespec_error (parser); 1602 /* If it is a LSTOKEN_NUMBER, we have an offset. */ 1603 else if (token.type == LSTOKEN_NUMBER) 1604 { 1605 /* Record the line offset and get the next token. */ 1606 name = copy_token_string (token); 1607 cleanup = make_cleanup (xfree, name); 1608 PARSER_RESULT (parser)->line_offset = linespec_parse_line_offset (name); 1609 do_cleanups (cleanup); 1610 1611 /* Get the next token. */ 1612 token = linespec_lexer_consume_token (parser); 1613 1614 /* If the next token is a comma, stop parsing and return. */ 1615 if (token.type == LSTOKEN_COMMA) 1616 return; 1617 1618 /* If the next token is anything but EOI or KEYWORD, issue 1619 an error. */ 1620 if (token.type != LSTOKEN_KEYWORD && token.type != LSTOKEN_EOI) 1621 unexpected_linespec_error (parser); 1622 } 1623 1624 if (token.type == LSTOKEN_KEYWORD || token.type == LSTOKEN_EOI) 1625 return; 1626 1627 /* Next token must be LSTOKEN_STRING. */ 1628 if (token.type != LSTOKEN_STRING) 1629 unexpected_linespec_error (parser); 1630 1631 /* The current token will contain the name of a function, method, 1632 or label. */ 1633 name = copy_token_string (token); 1634 cleanup = make_cleanup (xfree, name); 1635 1636 /* Try looking it up as a function/method. */ 1637 find_linespec_symbols (PARSER_STATE (parser), 1638 PARSER_RESULT (parser)->file_symtabs, name, 1639 &symbols, &minimal_symbols); 1640 1641 if (symbols != NULL || minimal_symbols != NULL) 1642 { 1643 PARSER_RESULT (parser)->function_symbols = symbols; 1644 PARSER_RESULT (parser)->minimal_symbols = minimal_symbols; 1645 PARSER_RESULT (parser)->function_name = name; 1646 symbols = NULL; 1647 discard_cleanups (cleanup); 1648 } 1649 else 1650 { 1651 /* NAME was not a function or a method. So it must be a label 1652 name. */ 1653 labels = find_label_symbols (PARSER_STATE (parser), NULL, 1654 &symbols, name); 1655 if (labels != NULL) 1656 { 1657 PARSER_RESULT (parser)->labels.label_symbols = labels; 1658 PARSER_RESULT (parser)->labels.function_symbols = symbols; 1659 PARSER_RESULT (parser)->label_name = name; 1660 symbols = NULL; 1661 discard_cleanups (cleanup); 1662 } 1663 else 1664 { 1665 /* The name is also not a label. Abort parsing. Do not throw 1666 an error here. parse_linespec will do it for us. */ 1667 1668 /* Save a copy of the name we were trying to lookup. */ 1669 PARSER_RESULT (parser)->function_name = name; 1670 discard_cleanups (cleanup); 1671 return; 1672 } 1673 } 1674 1675 /* Get the next token. */ 1676 token = linespec_lexer_consume_token (parser); 1677 1678 if (token.type == LSTOKEN_COLON) 1679 { 1680 /* User specified a label or a lineno. */ 1681 token = linespec_lexer_consume_token (parser); 1682 1683 if (token.type == LSTOKEN_NUMBER) 1684 { 1685 /* User specified an offset. Record the line offset and 1686 get the next token. */ 1687 name = copy_token_string (token); 1688 cleanup = make_cleanup (xfree, name); 1689 PARSER_RESULT (parser)->line_offset 1690 = linespec_parse_line_offset (name); 1691 do_cleanups (cleanup); 1692 1693 /* Ge the next token. */ 1694 token = linespec_lexer_consume_token (parser); 1695 } 1696 else if (token.type == LSTOKEN_STRING) 1697 { 1698 /* Grab a copy of the label's name and look it up. */ 1699 name = copy_token_string (token); 1700 cleanup = make_cleanup (xfree, name); 1701 labels = find_label_symbols (PARSER_STATE (parser), 1702 PARSER_RESULT (parser)->function_symbols, 1703 &symbols, name); 1704 1705 if (labels != NULL) 1706 { 1707 PARSER_RESULT (parser)->labels.label_symbols = labels; 1708 PARSER_RESULT (parser)->labels.function_symbols = symbols; 1709 PARSER_RESULT (parser)->label_name = name; 1710 symbols = NULL; 1711 discard_cleanups (cleanup); 1712 } 1713 else 1714 { 1715 /* We don't know what it was, but it isn't a label. */ 1716 throw_error (NOT_FOUND_ERROR, 1717 _("No label \"%s\" defined in function \"%s\"."), 1718 name, PARSER_RESULT (parser)->function_name); 1719 } 1720 1721 /* Check for a line offset. */ 1722 token = linespec_lexer_consume_token (parser); 1723 if (token.type == LSTOKEN_COLON) 1724 { 1725 /* Get the next token. */ 1726 token = linespec_lexer_consume_token (parser); 1727 1728 /* It must be a line offset. */ 1729 if (token.type != LSTOKEN_NUMBER) 1730 unexpected_linespec_error (parser); 1731 1732 /* Record the lione offset and get the next token. */ 1733 name = copy_token_string (token); 1734 cleanup = make_cleanup (xfree, name); 1735 1736 PARSER_RESULT (parser)->line_offset 1737 = linespec_parse_line_offset (name); 1738 do_cleanups (cleanup); 1739 1740 /* Get the next token. */ 1741 token = linespec_lexer_consume_token (parser); 1742 } 1743 } 1744 else 1745 { 1746 /* Trailing ':' in the input. Issue an error. */ 1747 unexpected_linespec_error (parser); 1748 } 1749 } 1750 } 1751 1752 /* Canonicalize the linespec contained in LS. The result is saved into 1753 STATE->canonical. */ 1754 1755 static void 1756 canonicalize_linespec (struct linespec_state *state, linespec_p ls) 1757 { 1758 /* If canonicalization was not requested, no need to do anything. */ 1759 if (!state->canonical) 1760 return; 1761 1762 /* Shortcut expressions, which can only appear by themselves. */ 1763 if (ls->expression != NULL) 1764 state->canonical->addr_string = xstrdup (ls->expression); 1765 else 1766 { 1767 struct ui_file *buf; 1768 int need_colon = 0; 1769 1770 buf = mem_fileopen (); 1771 if (ls->source_filename) 1772 { 1773 fputs_unfiltered (ls->source_filename, buf); 1774 need_colon = 1; 1775 } 1776 1777 if (ls->function_name) 1778 { 1779 if (need_colon) 1780 fputc_unfiltered (':', buf); 1781 fputs_unfiltered (ls->function_name, buf); 1782 need_colon = 1; 1783 } 1784 1785 if (ls->label_name) 1786 { 1787 if (need_colon) 1788 fputc_unfiltered (':', buf); 1789 1790 if (ls->function_name == NULL) 1791 { 1792 struct symbol *s; 1793 1794 /* No function was specified, so add the symbol name. */ 1795 gdb_assert (ls->labels.function_symbols != NULL 1796 && (VEC_length (symbolp, ls->labels.function_symbols) 1797 == 1)); 1798 s = VEC_index (symbolp, ls->labels.function_symbols, 0); 1799 fputs_unfiltered (SYMBOL_NATURAL_NAME (s), buf); 1800 fputc_unfiltered (':', buf); 1801 } 1802 1803 fputs_unfiltered (ls->label_name, buf); 1804 need_colon = 1; 1805 state->canonical->special_display = 1; 1806 } 1807 1808 if (ls->line_offset.sign != LINE_OFFSET_UNKNOWN) 1809 { 1810 if (need_colon) 1811 fputc_unfiltered (':', buf); 1812 fprintf_filtered (buf, "%s%d", 1813 (ls->line_offset.sign == LINE_OFFSET_NONE ? "" 1814 : (ls->line_offset.sign 1815 == LINE_OFFSET_PLUS ? "+" : "-")), 1816 ls->line_offset.offset); 1817 } 1818 1819 state->canonical->addr_string = ui_file_xstrdup (buf, NULL); 1820 ui_file_delete (buf); 1821 } 1822 } 1823 1824 /* Given a line offset in LS, construct the relevant SALs. */ 1825 1826 static struct symtabs_and_lines 1827 create_sals_line_offset (struct linespec_state *self, 1828 linespec_p ls) 1829 { 1830 struct symtabs_and_lines values; 1831 struct symtab_and_line val; 1832 int use_default = 0; 1833 1834 init_sal (&val); 1835 values.sals = NULL; 1836 values.nelts = 0; 1837 1838 /* This is where we need to make sure we have good defaults. 1839 We must guarantee that this section of code is never executed 1840 when we are called with just a function name, since 1841 set_default_source_symtab_and_line uses 1842 select_source_symtab that calls us with such an argument. */ 1843 1844 if (VEC_length (symtab_p, ls->file_symtabs) == 1 1845 && VEC_index (symtab_p, ls->file_symtabs, 0) == NULL) 1846 { 1847 const char *fullname; 1848 1849 set_current_program_space (self->program_space); 1850 1851 /* Make sure we have at least a default source line. */ 1852 set_default_source_symtab_and_line (); 1853 initialize_defaults (&self->default_symtab, &self->default_line); 1854 fullname = symtab_to_fullname (self->default_symtab); 1855 VEC_pop (symtab_p, ls->file_symtabs); 1856 VEC_free (symtab_p, ls->file_symtabs); 1857 ls->file_symtabs = collect_symtabs_from_filename (fullname); 1858 use_default = 1; 1859 } 1860 1861 val.line = ls->line_offset.offset; 1862 switch (ls->line_offset.sign) 1863 { 1864 case LINE_OFFSET_PLUS: 1865 if (ls->line_offset.offset == 0) 1866 val.line = 5; 1867 if (use_default) 1868 val.line = self->default_line + val.line; 1869 break; 1870 1871 case LINE_OFFSET_MINUS: 1872 if (ls->line_offset.offset == 0) 1873 val.line = 15; 1874 if (use_default) 1875 val.line = self->default_line - val.line; 1876 else 1877 val.line = -val.line; 1878 break; 1879 1880 case LINE_OFFSET_NONE: 1881 break; /* No need to adjust val.line. */ 1882 } 1883 1884 if (self->list_mode) 1885 decode_digits_list_mode (self, ls, &values, val); 1886 else 1887 { 1888 struct linetable_entry *best_entry = NULL; 1889 int *filter; 1890 struct block **blocks; 1891 struct cleanup *cleanup; 1892 struct symtabs_and_lines intermediate_results; 1893 int i, j; 1894 1895 intermediate_results.sals = NULL; 1896 intermediate_results.nelts = 0; 1897 1898 decode_digits_ordinary (self, ls, val.line, &intermediate_results, 1899 &best_entry); 1900 if (intermediate_results.nelts == 0 && best_entry != NULL) 1901 decode_digits_ordinary (self, ls, best_entry->line, 1902 &intermediate_results, &best_entry); 1903 1904 cleanup = make_cleanup (xfree, intermediate_results.sals); 1905 1906 /* For optimized code, the compiler can scatter one source line 1907 across disjoint ranges of PC values, even when no duplicate 1908 functions or inline functions are involved. For example, 1909 'for (;;)' inside a non-template, non-inline, and non-ctor-or-dtor 1910 function can result in two PC ranges. In this case, we don't 1911 want to set a breakpoint on the first PC of each range. To filter 1912 such cases, we use containing blocks -- for each PC found 1913 above, we see if there are other PCs that are in the same 1914 block. If yes, the other PCs are filtered out. */ 1915 1916 filter = XNEWVEC (int, intermediate_results.nelts); 1917 make_cleanup (xfree, filter); 1918 blocks = XNEWVEC (struct block *, intermediate_results.nelts); 1919 make_cleanup (xfree, blocks); 1920 1921 for (i = 0; i < intermediate_results.nelts; ++i) 1922 { 1923 set_current_program_space (intermediate_results.sals[i].pspace); 1924 1925 filter[i] = 1; 1926 blocks[i] = block_for_pc_sect (intermediate_results.sals[i].pc, 1927 intermediate_results.sals[i].section); 1928 } 1929 1930 for (i = 0; i < intermediate_results.nelts; ++i) 1931 { 1932 if (blocks[i] != NULL) 1933 for (j = i + 1; j < intermediate_results.nelts; ++j) 1934 { 1935 if (blocks[j] == blocks[i]) 1936 { 1937 filter[j] = 0; 1938 break; 1939 } 1940 } 1941 } 1942 1943 for (i = 0; i < intermediate_results.nelts; ++i) 1944 if (filter[i]) 1945 { 1946 struct symbol *sym = (blocks[i] 1947 ? block_containing_function (blocks[i]) 1948 : NULL); 1949 1950 if (self->funfirstline) 1951 skip_prologue_sal (&intermediate_results.sals[i]); 1952 /* Make sure the line matches the request, not what was 1953 found. */ 1954 intermediate_results.sals[i].line = val.line; 1955 add_sal_to_sals (self, &values, &intermediate_results.sals[i], 1956 sym ? SYMBOL_NATURAL_NAME (sym) : NULL, 0); 1957 } 1958 1959 do_cleanups (cleanup); 1960 } 1961 1962 if (values.nelts == 0) 1963 { 1964 if (ls->source_filename) 1965 throw_error (NOT_FOUND_ERROR, _("No line %d in file \"%s\"."), 1966 val.line, ls->source_filename); 1967 else 1968 throw_error (NOT_FOUND_ERROR, _("No line %d in the current file."), 1969 val.line); 1970 } 1971 1972 return values; 1973 } 1974 1975 /* Create and return SALs from the linespec LS. */ 1976 1977 static struct symtabs_and_lines 1978 convert_linespec_to_sals (struct linespec_state *state, linespec_p ls) 1979 { 1980 struct symtabs_and_lines sals = {NULL, 0}; 1981 1982 if (ls->expression != NULL) 1983 { 1984 struct symtab_and_line sal; 1985 1986 /* We have an expression. No other attribute is allowed. */ 1987 sal = find_pc_line (ls->expr_pc, 0); 1988 sal.pc = ls->expr_pc; 1989 sal.section = find_pc_overlay (ls->expr_pc); 1990 sal.explicit_pc = 1; 1991 add_sal_to_sals (state, &sals, &sal, ls->expression, 1); 1992 } 1993 else if (ls->labels.label_symbols != NULL) 1994 { 1995 /* We have just a bunch of functions/methods or labels. */ 1996 int i; 1997 struct symtab_and_line sal; 1998 struct symbol *sym; 1999 2000 for (i = 0; VEC_iterate (symbolp, ls->labels.label_symbols, i, sym); ++i) 2001 { 2002 if (symbol_to_sal (&sal, state->funfirstline, sym)) 2003 add_sal_to_sals (state, &sals, &sal, 2004 SYMBOL_NATURAL_NAME (sym), 0); 2005 } 2006 } 2007 else if (ls->function_symbols != NULL || ls->minimal_symbols != NULL) 2008 { 2009 /* We have just a bunch of functions and/or methods. */ 2010 int i; 2011 struct symtab_and_line sal; 2012 struct symbol *sym; 2013 minsym_and_objfile_d *elem; 2014 struct program_space *pspace; 2015 2016 if (ls->function_symbols != NULL) 2017 { 2018 /* Sort symbols so that symbols with the same program space are next 2019 to each other. */ 2020 qsort (VEC_address (symbolp, ls->function_symbols), 2021 VEC_length (symbolp, ls->function_symbols), 2022 sizeof (symbolp), compare_symbols); 2023 2024 for (i = 0; VEC_iterate (symbolp, ls->function_symbols, i, sym); ++i) 2025 { 2026 pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)); 2027 set_current_program_space (pspace); 2028 if (symbol_to_sal (&sal, state->funfirstline, sym) 2029 && maybe_add_address (state->addr_set, pspace, sal.pc)) 2030 add_sal_to_sals (state, &sals, &sal, 2031 SYMBOL_NATURAL_NAME (sym), 0); 2032 } 2033 } 2034 2035 if (ls->minimal_symbols != NULL) 2036 { 2037 /* Sort minimal symbols by program space, too. */ 2038 qsort (VEC_address (minsym_and_objfile_d, ls->minimal_symbols), 2039 VEC_length (minsym_and_objfile_d, ls->minimal_symbols), 2040 sizeof (minsym_and_objfile_d), compare_msymbols); 2041 2042 for (i = 0; 2043 VEC_iterate (minsym_and_objfile_d, ls->minimal_symbols, i, elem); 2044 ++i) 2045 { 2046 pspace = elem->objfile->pspace; 2047 set_current_program_space (pspace); 2048 minsym_found (state, elem->objfile, elem->minsym, &sals); 2049 } 2050 } 2051 } 2052 else if (ls->line_offset.sign != LINE_OFFSET_UNKNOWN) 2053 { 2054 /* Only an offset was specified. */ 2055 sals = create_sals_line_offset (state, ls); 2056 2057 /* Make sure we have a filename for canonicalization. */ 2058 if (ls->source_filename == NULL) 2059 { 2060 const char *fullname = symtab_to_fullname (state->default_symtab); 2061 2062 ls->source_filename = xstrdup (fullname); 2063 } 2064 } 2065 else 2066 { 2067 /* We haven't found any results... */ 2068 return sals; 2069 } 2070 2071 canonicalize_linespec (state, ls); 2072 2073 if (sals.nelts > 0 && state->canonical != NULL) 2074 state->canonical->pre_expanded = 1; 2075 2076 return sals; 2077 } 2078 2079 /* Parse a string that specifies a linespec. 2080 Pass the address of a char * variable; that variable will be 2081 advanced over the characters actually parsed. 2082 2083 The basic grammar of linespecs: 2084 2085 linespec -> expr_spec | var_spec | basic_spec 2086 expr_spec -> '*' STRING 2087 var_spec -> '$' (STRING | NUMBER) 2088 2089 basic_spec -> file_offset_spec | function_spec | label_spec 2090 file_offset_spec -> opt_file_spec offset_spec 2091 function_spec -> opt_file_spec function_name_spec opt_label_spec 2092 label_spec -> label_name_spec 2093 2094 opt_file_spec -> "" | file_name_spec ':' 2095 opt_label_spec -> "" | ':' label_name_spec 2096 2097 file_name_spec -> STRING 2098 function_name_spec -> STRING 2099 label_name_spec -> STRING 2100 function_name_spec -> STRING 2101 offset_spec -> NUMBER 2102 -> '+' NUMBER 2103 -> '-' NUMBER 2104 2105 This may all be followed by several keywords such as "if EXPR", 2106 which we ignore. 2107 2108 A comma will terminate parsing. 2109 2110 The function may be an undebuggable function found in minimal symbol table. 2111 2112 If the argument FUNFIRSTLINE is nonzero, we want the first line 2113 of real code inside a function when a function is specified, and it is 2114 not OK to specify a variable or type to get its line number. 2115 2116 DEFAULT_SYMTAB specifies the file to use if none is specified. 2117 It defaults to current_source_symtab. 2118 DEFAULT_LINE specifies the line number to use for relative 2119 line numbers (that start with signs). Defaults to current_source_line. 2120 If CANONICAL is non-NULL, store an array of strings containing the canonical 2121 line specs there if necessary. Currently overloaded member functions and 2122 line numbers or static functions without a filename yield a canonical 2123 line spec. The array and the line spec strings are allocated on the heap, 2124 it is the callers responsibility to free them. 2125 2126 Note that it is possible to return zero for the symtab 2127 if no file is validly specified. Callers must check that. 2128 Also, the line number returned may be invalid. */ 2129 2130 /* Parse the linespec in ARGPTR. */ 2131 2132 static struct symtabs_and_lines 2133 parse_linespec (linespec_parser *parser, char **argptr) 2134 { 2135 linespec_token token; 2136 struct symtabs_and_lines values; 2137 volatile struct gdb_exception file_exception; 2138 struct cleanup *cleanup; 2139 2140 /* A special case to start. It has become quite popular for 2141 IDEs to work around bugs in the previous parser by quoting 2142 the entire linespec, so we attempt to deal with this nicely. */ 2143 parser->is_quote_enclosed = 0; 2144 if (!is_ada_operator (*argptr) 2145 && strchr (linespec_quote_characters, **argptr) != NULL) 2146 { 2147 const char *end; 2148 2149 end = skip_quote_char (*argptr + 1, **argptr); 2150 if (end != NULL && is_closing_quote_enclosed (end)) 2151 { 2152 /* Here's the special case. Skip ARGPTR past the initial 2153 quote. */ 2154 ++(*argptr); 2155 parser->is_quote_enclosed = 1; 2156 } 2157 } 2158 2159 /* A keyword at the start cannot be interpreted as such. 2160 Consider "b thread thread 42". */ 2161 parser->keyword_ok = 0; 2162 2163 parser->lexer.saved_arg = *argptr; 2164 parser->lexer.stream = argptr; 2165 file_exception.reason = 0; 2166 2167 /* Initialize the default symtab and line offset. */ 2168 initialize_defaults (&PARSER_STATE (parser)->default_symtab, 2169 &PARSER_STATE (parser)->default_line); 2170 2171 /* Objective-C shortcut. */ 2172 values = decode_objc (PARSER_STATE (parser), PARSER_RESULT (parser), argptr); 2173 if (values.sals != NULL) 2174 return values; 2175 2176 /* Start parsing. */ 2177 2178 /* Get the first token. */ 2179 token = linespec_lexer_lex_one (parser); 2180 2181 /* It must be either LSTOKEN_STRING or LSTOKEN_NUMBER. */ 2182 if (token.type == LSTOKEN_STRING && *LS_TOKEN_STOKEN (token).ptr == '*') 2183 { 2184 char *expr; 2185 const char *copy; 2186 2187 /* User specified an expression, *EXPR. */ 2188 copy = expr = copy_token_string (token); 2189 cleanup = make_cleanup (xfree, expr); 2190 PARSER_RESULT (parser)->expr_pc = linespec_expression_to_pc (©); 2191 discard_cleanups (cleanup); 2192 PARSER_RESULT (parser)->expression = expr; 2193 2194 /* This is a little hacky/tricky. If linespec_expression_to_pc 2195 did not evaluate the entire token, then we must find the 2196 string COPY inside the original token buffer. */ 2197 if (*copy != '\0') 2198 { 2199 PARSER_STREAM (parser) = strstr (parser->lexer.saved_arg, copy); 2200 gdb_assert (PARSER_STREAM (parser) != NULL); 2201 } 2202 2203 /* Consume the token. */ 2204 linespec_lexer_consume_token (parser); 2205 2206 goto convert_to_sals; 2207 } 2208 else if (token.type == LSTOKEN_STRING && *LS_TOKEN_STOKEN (token).ptr == '$') 2209 { 2210 char *var; 2211 2212 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */ 2213 VEC_safe_push (symtab_p, PARSER_RESULT (parser)->file_symtabs, NULL); 2214 2215 /* User specified a convenience variable or history value. */ 2216 var = copy_token_string (token); 2217 cleanup = make_cleanup (xfree, var); 2218 PARSER_RESULT (parser)->line_offset 2219 = linespec_parse_variable (PARSER_STATE (parser), var); 2220 do_cleanups (cleanup); 2221 2222 /* If a line_offset wasn't found (VAR is the name of a user 2223 variable/function), then skip to normal symbol processing. */ 2224 if (PARSER_RESULT (parser)->line_offset.sign != LINE_OFFSET_UNKNOWN) 2225 { 2226 /* Consume this token. */ 2227 linespec_lexer_consume_token (parser); 2228 2229 goto convert_to_sals; 2230 } 2231 } 2232 else if (token.type != LSTOKEN_STRING && token.type != LSTOKEN_NUMBER) 2233 unexpected_linespec_error (parser); 2234 2235 /* Now we can recognize keywords. */ 2236 parser->keyword_ok = 1; 2237 2238 /* Shortcut: If the next token is not LSTOKEN_COLON, we know that 2239 this token cannot represent a filename. */ 2240 token = linespec_lexer_peek_token (parser); 2241 2242 if (token.type == LSTOKEN_COLON) 2243 { 2244 char *user_filename; 2245 2246 /* Get the current token again and extract the filename. */ 2247 token = linespec_lexer_lex_one (parser); 2248 user_filename = copy_token_string (token); 2249 2250 /* Check if the input is a filename. */ 2251 TRY_CATCH (file_exception, RETURN_MASK_ERROR) 2252 { 2253 PARSER_RESULT (parser)->file_symtabs 2254 = symtabs_from_filename (user_filename); 2255 } 2256 2257 if (file_exception.reason >= 0) 2258 { 2259 /* Symtabs were found for the file. Record the filename. */ 2260 PARSER_RESULT (parser)->source_filename = user_filename; 2261 2262 /* Get the next token. */ 2263 token = linespec_lexer_consume_token (parser); 2264 2265 /* This is LSTOKEN_COLON; consume it. */ 2266 linespec_lexer_consume_token (parser); 2267 } 2268 else 2269 { 2270 /* No symtabs found -- discard user_filename. */ 2271 xfree (user_filename); 2272 2273 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */ 2274 VEC_safe_push (symtab_p, PARSER_RESULT (parser)->file_symtabs, NULL); 2275 } 2276 } 2277 /* If the next token is not EOI, KEYWORD, or COMMA, issue an error. */ 2278 else if (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD 2279 && token.type != LSTOKEN_COMMA) 2280 { 2281 /* TOKEN is the _next_ token, not the one currently in the parser. 2282 Consuming the token will give the correct error message. */ 2283 linespec_lexer_consume_token (parser); 2284 unexpected_linespec_error (parser); 2285 } 2286 else 2287 { 2288 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */ 2289 VEC_safe_push (symtab_p, PARSER_RESULT (parser)->file_symtabs, NULL); 2290 } 2291 2292 /* Parse the rest of the linespec. */ 2293 linespec_parse_basic (parser); 2294 2295 if (PARSER_RESULT (parser)->function_symbols == NULL 2296 && PARSER_RESULT (parser)->labels.label_symbols == NULL 2297 && PARSER_RESULT (parser)->line_offset.sign == LINE_OFFSET_UNKNOWN 2298 && PARSER_RESULT (parser)->minimal_symbols == NULL) 2299 { 2300 /* The linespec didn't parse. Re-throw the file exception if 2301 there was one. */ 2302 if (file_exception.reason < 0) 2303 throw_exception (file_exception); 2304 2305 /* Otherwise, the symbol is not found. */ 2306 symbol_not_found_error (PARSER_RESULT (parser)->function_name, 2307 PARSER_RESULT (parser)->source_filename); 2308 } 2309 2310 convert_to_sals: 2311 2312 /* Get the last token and record how much of the input was parsed, 2313 if necessary. */ 2314 token = linespec_lexer_lex_one (parser); 2315 if (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD) 2316 PARSER_STREAM (parser) = LS_TOKEN_STOKEN (token).ptr; 2317 2318 /* Convert the data in PARSER_RESULT to SALs. */ 2319 values = convert_linespec_to_sals (PARSER_STATE (parser), 2320 PARSER_RESULT (parser)); 2321 2322 return values; 2323 } 2324 2325 2326 /* A constructor for linespec_state. */ 2327 2328 static void 2329 linespec_state_constructor (struct linespec_state *self, 2330 int flags, const struct language_defn *language, 2331 struct symtab *default_symtab, 2332 int default_line, 2333 struct linespec_result *canonical) 2334 { 2335 memset (self, 0, sizeof (*self)); 2336 self->language = language; 2337 self->funfirstline = (flags & DECODE_LINE_FUNFIRSTLINE) ? 1 : 0; 2338 self->list_mode = (flags & DECODE_LINE_LIST_MODE) ? 1 : 0; 2339 self->default_symtab = default_symtab; 2340 self->default_line = default_line; 2341 self->canonical = canonical; 2342 self->program_space = current_program_space; 2343 self->addr_set = htab_create_alloc (10, hash_address_entry, eq_address_entry, 2344 xfree, xcalloc, xfree); 2345 } 2346 2347 /* Initialize a new linespec parser. */ 2348 2349 static void 2350 linespec_parser_new (linespec_parser *parser, 2351 int flags, const struct language_defn *language, 2352 struct symtab *default_symtab, 2353 int default_line, 2354 struct linespec_result *canonical) 2355 { 2356 parser->lexer.current.type = LSTOKEN_CONSUMED; 2357 memset (PARSER_RESULT (parser), 0, sizeof (struct linespec)); 2358 PARSER_RESULT (parser)->line_offset.sign = LINE_OFFSET_UNKNOWN; 2359 linespec_state_constructor (PARSER_STATE (parser), flags, language, 2360 default_symtab, default_line, canonical); 2361 } 2362 2363 /* A destructor for linespec_state. */ 2364 2365 static void 2366 linespec_state_destructor (struct linespec_state *self) 2367 { 2368 htab_delete (self->addr_set); 2369 } 2370 2371 /* Delete a linespec parser. */ 2372 2373 static void 2374 linespec_parser_delete (void *arg) 2375 { 2376 linespec_parser *parser = (linespec_parser *) arg; 2377 2378 xfree ((char *) PARSER_RESULT (parser)->expression); 2379 xfree ((char *) PARSER_RESULT (parser)->source_filename); 2380 xfree ((char *) PARSER_RESULT (parser)->label_name); 2381 xfree ((char *) PARSER_RESULT (parser)->function_name); 2382 2383 if (PARSER_RESULT (parser)->file_symtabs != NULL) 2384 VEC_free (symtab_p, PARSER_RESULT (parser)->file_symtabs); 2385 2386 if (PARSER_RESULT (parser)->function_symbols != NULL) 2387 VEC_free (symbolp, PARSER_RESULT (parser)->function_symbols); 2388 2389 if (PARSER_RESULT (parser)->minimal_symbols != NULL) 2390 VEC_free (minsym_and_objfile_d, PARSER_RESULT (parser)->minimal_symbols); 2391 2392 if (PARSER_RESULT (parser)->labels.label_symbols != NULL) 2393 VEC_free (symbolp, PARSER_RESULT (parser)->labels.label_symbols); 2394 2395 if (PARSER_RESULT (parser)->labels.function_symbols != NULL) 2396 VEC_free (symbolp, PARSER_RESULT (parser)->labels.function_symbols); 2397 2398 linespec_state_destructor (PARSER_STATE (parser)); 2399 } 2400 2401 /* See linespec.h. */ 2402 2403 void 2404 decode_line_full (char **argptr, int flags, 2405 struct symtab *default_symtab, 2406 int default_line, struct linespec_result *canonical, 2407 const char *select_mode, 2408 const char *filter) 2409 { 2410 struct symtabs_and_lines result; 2411 struct cleanup *cleanups; 2412 VEC (const_char_ptr) *filters = NULL; 2413 linespec_parser parser; 2414 struct linespec_state *state; 2415 2416 gdb_assert (canonical != NULL); 2417 /* The filter only makes sense for 'all'. */ 2418 gdb_assert (filter == NULL || select_mode == multiple_symbols_all); 2419 gdb_assert (select_mode == NULL 2420 || select_mode == multiple_symbols_all 2421 || select_mode == multiple_symbols_ask 2422 || select_mode == multiple_symbols_cancel); 2423 gdb_assert ((flags & DECODE_LINE_LIST_MODE) == 0); 2424 2425 linespec_parser_new (&parser, flags, current_language, default_symtab, 2426 default_line, canonical); 2427 cleanups = make_cleanup (linespec_parser_delete, &parser); 2428 save_current_program_space (); 2429 2430 result = parse_linespec (&parser, argptr); 2431 state = PARSER_STATE (&parser); 2432 2433 gdb_assert (result.nelts == 1 || canonical->pre_expanded); 2434 gdb_assert (canonical->addr_string != NULL); 2435 canonical->pre_expanded = 1; 2436 2437 /* Arrange for allocated canonical names to be freed. */ 2438 if (result.nelts > 0) 2439 { 2440 int i; 2441 2442 make_cleanup (xfree, state->canonical_names); 2443 for (i = 0; i < result.nelts; ++i) 2444 { 2445 gdb_assert (state->canonical_names[i].suffix != NULL); 2446 make_cleanup (xfree, state->canonical_names[i].suffix); 2447 } 2448 } 2449 2450 if (select_mode == NULL) 2451 { 2452 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))) 2453 select_mode = multiple_symbols_all; 2454 else 2455 select_mode = multiple_symbols_select_mode (); 2456 } 2457 2458 if (select_mode == multiple_symbols_all) 2459 { 2460 if (filter != NULL) 2461 { 2462 make_cleanup (VEC_cleanup (const_char_ptr), &filters); 2463 VEC_safe_push (const_char_ptr, filters, filter); 2464 filter_results (state, &result, filters); 2465 } 2466 else 2467 convert_results_to_lsals (state, &result); 2468 } 2469 else 2470 decode_line_2 (state, &result, select_mode); 2471 2472 do_cleanups (cleanups); 2473 } 2474 2475 /* See linespec.h. */ 2476 2477 struct symtabs_and_lines 2478 decode_line_1 (char **argptr, int flags, 2479 struct symtab *default_symtab, 2480 int default_line) 2481 { 2482 struct symtabs_and_lines result; 2483 linespec_parser parser; 2484 struct cleanup *cleanups; 2485 2486 linespec_parser_new (&parser, flags, current_language, default_symtab, 2487 default_line, NULL); 2488 cleanups = make_cleanup (linespec_parser_delete, &parser); 2489 save_current_program_space (); 2490 2491 result = parse_linespec (&parser, argptr); 2492 2493 do_cleanups (cleanups); 2494 return result; 2495 } 2496 2497 /* See linespec.h. */ 2498 2499 struct symtabs_and_lines 2500 decode_line_with_current_source (char *string, int flags) 2501 { 2502 struct symtabs_and_lines sals; 2503 struct symtab_and_line cursal; 2504 2505 if (string == 0) 2506 error (_("Empty line specification.")); 2507 2508 /* We use whatever is set as the current source line. We do not try 2509 and get a default source symtab+line or it will recursively call us! */ 2510 cursal = get_current_source_symtab_and_line (); 2511 2512 sals = decode_line_1 (&string, flags, 2513 cursal.symtab, cursal.line); 2514 2515 if (*string) 2516 error (_("Junk at end of line specification: %s"), string); 2517 return sals; 2518 } 2519 2520 /* See linespec.h. */ 2521 2522 struct symtabs_and_lines 2523 decode_line_with_last_displayed (char *string, int flags) 2524 { 2525 struct symtabs_and_lines sals; 2526 2527 if (string == 0) 2528 error (_("Empty line specification.")); 2529 2530 if (last_displayed_sal_is_valid ()) 2531 sals = decode_line_1 (&string, flags, 2532 get_last_displayed_symtab (), 2533 get_last_displayed_line ()); 2534 else 2535 sals = decode_line_1 (&string, flags, (struct symtab *) NULL, 0); 2536 2537 if (*string) 2538 error (_("Junk at end of line specification: %s"), string); 2539 return sals; 2540 } 2541 2542 2543 2544 /* First, some functions to initialize stuff at the beggining of the 2545 function. */ 2546 2547 static void 2548 initialize_defaults (struct symtab **default_symtab, int *default_line) 2549 { 2550 if (*default_symtab == 0) 2551 { 2552 /* Use whatever we have for the default source line. We don't use 2553 get_current_or_default_symtab_and_line as it can recurse and call 2554 us back! */ 2555 struct symtab_and_line cursal = 2556 get_current_source_symtab_and_line (); 2557 2558 *default_symtab = cursal.symtab; 2559 *default_line = cursal.line; 2560 } 2561 } 2562 2563 2564 2565 /* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR, 2566 advancing EXP_PTR past any parsed text. */ 2567 2568 static CORE_ADDR 2569 linespec_expression_to_pc (const char **exp_ptr) 2570 { 2571 if (current_program_space->executing_startup) 2572 /* The error message doesn't really matter, because this case 2573 should only hit during breakpoint reset. */ 2574 throw_error (NOT_FOUND_ERROR, _("cannot evaluate expressions while " 2575 "program space is in startup")); 2576 2577 (*exp_ptr)++; 2578 return value_as_address (parse_to_comma_and_eval (exp_ptr)); 2579 } 2580 2581 2582 2583 /* Here's where we recognise an Objective-C Selector. An Objective C 2584 selector may be implemented by more than one class, therefore it 2585 may represent more than one method/function. This gives us a 2586 situation somewhat analogous to C++ overloading. If there's more 2587 than one method that could represent the selector, then use some of 2588 the existing C++ code to let the user choose one. */ 2589 2590 static struct symtabs_and_lines 2591 decode_objc (struct linespec_state *self, linespec_p ls, char **argptr) 2592 { 2593 struct collect_info info; 2594 VEC (const_char_ptr) *symbol_names = NULL; 2595 struct symtabs_and_lines values; 2596 char *new_argptr; 2597 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr), 2598 &symbol_names); 2599 2600 info.state = self; 2601 info.file_symtabs = NULL; 2602 VEC_safe_push (symtab_p, info.file_symtabs, NULL); 2603 make_cleanup (VEC_cleanup (symtab_p), &info.file_symtabs); 2604 info.result.symbols = NULL; 2605 info.result.minimal_symbols = NULL; 2606 values.nelts = 0; 2607 values.sals = NULL; 2608 2609 new_argptr = find_imps (*argptr, &symbol_names); 2610 if (VEC_empty (const_char_ptr, symbol_names)) 2611 { 2612 do_cleanups (cleanup); 2613 return values; 2614 } 2615 2616 add_all_symbol_names_from_pspace (&info, NULL, symbol_names); 2617 2618 if (!VEC_empty (symbolp, info.result.symbols) 2619 || !VEC_empty (minsym_and_objfile_d, info.result.minimal_symbols)) 2620 { 2621 char *saved_arg; 2622 2623 saved_arg = alloca (new_argptr - *argptr + 1); 2624 memcpy (saved_arg, *argptr, new_argptr - *argptr); 2625 saved_arg[new_argptr - *argptr] = '\0'; 2626 2627 ls->function_name = xstrdup (saved_arg); 2628 ls->function_symbols = info.result.symbols; 2629 ls->minimal_symbols = info.result.minimal_symbols; 2630 values = convert_linespec_to_sals (self, ls); 2631 2632 if (self->canonical) 2633 { 2634 self->canonical->pre_expanded = 1; 2635 if (ls->source_filename) 2636 self->canonical->addr_string 2637 = xstrprintf ("%s:%s", ls->source_filename, saved_arg); 2638 else 2639 self->canonical->addr_string = xstrdup (saved_arg); 2640 } 2641 } 2642 2643 *argptr = new_argptr; 2644 2645 do_cleanups (cleanup); 2646 2647 return values; 2648 } 2649 2650 /* An instance of this type is used when collecting prefix symbols for 2651 decode_compound. */ 2652 2653 struct decode_compound_collector 2654 { 2655 /* The result vector. */ 2656 VEC (symbolp) *symbols; 2657 2658 /* A hash table of all symbols we found. We use this to avoid 2659 adding any symbol more than once. */ 2660 htab_t unique_syms; 2661 }; 2662 2663 /* A callback for iterate_over_symbols that is used by 2664 lookup_prefix_sym to collect type symbols. */ 2665 2666 static int 2667 collect_one_symbol (struct symbol *sym, void *d) 2668 { 2669 struct decode_compound_collector *collector = d; 2670 void **slot; 2671 struct type *t; 2672 2673 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF) 2674 return 1; /* Continue iterating. */ 2675 2676 t = SYMBOL_TYPE (sym); 2677 CHECK_TYPEDEF (t); 2678 if (TYPE_CODE (t) != TYPE_CODE_STRUCT 2679 && TYPE_CODE (t) != TYPE_CODE_UNION 2680 && TYPE_CODE (t) != TYPE_CODE_NAMESPACE) 2681 return 1; /* Continue iterating. */ 2682 2683 slot = htab_find_slot (collector->unique_syms, sym, INSERT); 2684 if (!*slot) 2685 { 2686 *slot = sym; 2687 VEC_safe_push (symbolp, collector->symbols, sym); 2688 } 2689 2690 return 1; /* Continue iterating. */ 2691 } 2692 2693 /* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */ 2694 2695 static VEC (symbolp) * 2696 lookup_prefix_sym (struct linespec_state *state, VEC (symtab_p) *file_symtabs, 2697 const char *class_name) 2698 { 2699 int ix; 2700 struct symtab *elt; 2701 struct decode_compound_collector collector; 2702 struct cleanup *outer; 2703 struct cleanup *cleanup; 2704 2705 collector.symbols = NULL; 2706 outer = make_cleanup (VEC_cleanup (symbolp), &collector.symbols); 2707 2708 collector.unique_syms = htab_create_alloc (1, htab_hash_pointer, 2709 htab_eq_pointer, NULL, 2710 xcalloc, xfree); 2711 cleanup = make_cleanup_htab_delete (collector.unique_syms); 2712 2713 for (ix = 0; VEC_iterate (symtab_p, file_symtabs, ix, elt); ++ix) 2714 { 2715 if (elt == NULL) 2716 { 2717 iterate_over_all_matching_symtabs (state, class_name, STRUCT_DOMAIN, 2718 collect_one_symbol, &collector, 2719 NULL, 0); 2720 iterate_over_all_matching_symtabs (state, class_name, VAR_DOMAIN, 2721 collect_one_symbol, &collector, 2722 NULL, 0); 2723 } 2724 else 2725 { 2726 /* Program spaces that are executing startup should have 2727 been filtered out earlier. */ 2728 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup); 2729 set_current_program_space (SYMTAB_PSPACE (elt)); 2730 iterate_over_file_blocks (elt, class_name, STRUCT_DOMAIN, 2731 collect_one_symbol, &collector); 2732 iterate_over_file_blocks (elt, class_name, VAR_DOMAIN, 2733 collect_one_symbol, &collector); 2734 } 2735 } 2736 2737 do_cleanups (cleanup); 2738 discard_cleanups (outer); 2739 return collector.symbols; 2740 } 2741 2742 /* A qsort comparison function for symbols. The resulting order does 2743 not actually matter; we just need to be able to sort them so that 2744 symbols with the same program space end up next to each other. */ 2745 2746 static int 2747 compare_symbols (const void *a, const void *b) 2748 { 2749 struct symbol * const *sa = a; 2750 struct symbol * const *sb = b; 2751 uintptr_t uia, uib; 2752 2753 uia = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa)); 2754 uib = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb)); 2755 2756 if (uia < uib) 2757 return -1; 2758 if (uia > uib) 2759 return 1; 2760 2761 uia = (uintptr_t) *sa; 2762 uib = (uintptr_t) *sb; 2763 2764 if (uia < uib) 2765 return -1; 2766 if (uia > uib) 2767 return 1; 2768 2769 return 0; 2770 } 2771 2772 /* Like compare_symbols but for minimal symbols. */ 2773 2774 static int 2775 compare_msymbols (const void *a, const void *b) 2776 { 2777 const struct minsym_and_objfile *sa = a; 2778 const struct minsym_and_objfile *sb = b; 2779 uintptr_t uia, uib; 2780 2781 uia = (uintptr_t) sa->objfile->pspace; 2782 uib = (uintptr_t) sa->objfile->pspace; 2783 2784 if (uia < uib) 2785 return -1; 2786 if (uia > uib) 2787 return 1; 2788 2789 uia = (uintptr_t) sa->minsym; 2790 uib = (uintptr_t) sb->minsym; 2791 2792 if (uia < uib) 2793 return -1; 2794 if (uia > uib) 2795 return 1; 2796 2797 return 0; 2798 } 2799 2800 /* Look for all the matching instances of each symbol in NAMES. Only 2801 instances from PSPACE are considered; other program spaces are 2802 handled by our caller. If PSPACE is NULL, then all program spaces 2803 are considered. Results are stored into INFO. */ 2804 2805 static void 2806 add_all_symbol_names_from_pspace (struct collect_info *info, 2807 struct program_space *pspace, 2808 VEC (const_char_ptr) *names) 2809 { 2810 int ix; 2811 const char *iter; 2812 2813 for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix) 2814 add_matching_symbols_to_info (iter, info, pspace); 2815 } 2816 2817 static void 2818 find_superclass_methods (VEC (typep) *superclasses, 2819 const char *name, 2820 VEC (const_char_ptr) **result_names) 2821 { 2822 int old_len = VEC_length (const_char_ptr, *result_names); 2823 VEC (typep) *iter_classes; 2824 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); 2825 2826 iter_classes = superclasses; 2827 while (1) 2828 { 2829 VEC (typep) *new_supers = NULL; 2830 int ix; 2831 struct type *t; 2832 2833 make_cleanup (VEC_cleanup (typep), &new_supers); 2834 for (ix = 0; VEC_iterate (typep, iter_classes, ix, t); ++ix) 2835 find_methods (t, name, result_names, &new_supers); 2836 2837 if (VEC_length (const_char_ptr, *result_names) != old_len 2838 || VEC_empty (typep, new_supers)) 2839 break; 2840 2841 iter_classes = new_supers; 2842 } 2843 2844 do_cleanups (cleanup); 2845 } 2846 2847 /* This finds the method METHOD_NAME in the class CLASS_NAME whose type is 2848 given by one of the symbols in SYM_CLASSES. Matches are returned 2849 in SYMBOLS (for debug symbols) and MINSYMS (for minimal symbols). */ 2850 2851 static void 2852 find_method (struct linespec_state *self, VEC (symtab_p) *file_symtabs, 2853 const char *class_name, const char *method_name, 2854 VEC (symbolp) *sym_classes, VEC (symbolp) **symbols, 2855 VEC (minsym_and_objfile_d) **minsyms) 2856 { 2857 struct symbol *sym; 2858 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); 2859 int ix; 2860 int last_result_len; 2861 VEC (typep) *superclass_vec; 2862 VEC (const_char_ptr) *result_names; 2863 struct collect_info info; 2864 2865 /* Sort symbols so that symbols with the same program space are next 2866 to each other. */ 2867 qsort (VEC_address (symbolp, sym_classes), 2868 VEC_length (symbolp, sym_classes), 2869 sizeof (symbolp), 2870 compare_symbols); 2871 2872 info.state = self; 2873 info.file_symtabs = file_symtabs; 2874 info.result.symbols = NULL; 2875 info.result.minimal_symbols = NULL; 2876 2877 /* Iterate over all the types, looking for the names of existing 2878 methods matching METHOD_NAME. If we cannot find a direct method in a 2879 given program space, then we consider inherited methods; this is 2880 not ideal (ideal would be to respect C++ hiding rules), but it 2881 seems good enough and is what GDB has historically done. We only 2882 need to collect the names because later we find all symbols with 2883 those names. This loop is written in a somewhat funny way 2884 because we collect data across the program space before deciding 2885 what to do. */ 2886 superclass_vec = NULL; 2887 make_cleanup (VEC_cleanup (typep), &superclass_vec); 2888 result_names = NULL; 2889 make_cleanup (VEC_cleanup (const_char_ptr), &result_names); 2890 last_result_len = 0; 2891 for (ix = 0; VEC_iterate (symbolp, sym_classes, ix, sym); ++ix) 2892 { 2893 struct type *t; 2894 struct program_space *pspace; 2895 2896 /* Program spaces that are executing startup should have 2897 been filtered out earlier. */ 2898 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym))->executing_startup); 2899 pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)); 2900 set_current_program_space (pspace); 2901 t = check_typedef (SYMBOL_TYPE (sym)); 2902 find_methods (t, method_name, &result_names, &superclass_vec); 2903 2904 /* Handle all items from a single program space at once; and be 2905 sure not to miss the last batch. */ 2906 if (ix == VEC_length (symbolp, sym_classes) - 1 2907 || (pspace 2908 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp, sym_classes, 2909 ix + 1))))) 2910 { 2911 /* If we did not find a direct implementation anywhere in 2912 this program space, consider superclasses. */ 2913 if (VEC_length (const_char_ptr, result_names) == last_result_len) 2914 find_superclass_methods (superclass_vec, method_name, 2915 &result_names); 2916 2917 /* We have a list of candidate symbol names, so now we 2918 iterate over the symbol tables looking for all 2919 matches in this pspace. */ 2920 add_all_symbol_names_from_pspace (&info, pspace, result_names); 2921 2922 VEC_truncate (typep, superclass_vec, 0); 2923 last_result_len = VEC_length (const_char_ptr, result_names); 2924 } 2925 } 2926 2927 if (!VEC_empty (symbolp, info.result.symbols) 2928 || !VEC_empty (minsym_and_objfile_d, info.result.minimal_symbols)) 2929 { 2930 *symbols = info.result.symbols; 2931 *minsyms = info.result.minimal_symbols; 2932 do_cleanups (cleanup); 2933 return; 2934 } 2935 2936 /* Throw an NOT_FOUND_ERROR. This will be caught by the caller 2937 and other attempts to locate the symbol will be made. */ 2938 throw_error (NOT_FOUND_ERROR, _("see caller, this text doesn't matter")); 2939 } 2940 2941 2942 2943 /* This object is used when collecting all matching symtabs. */ 2944 2945 struct symtab_collector 2946 { 2947 /* The result vector of symtabs. */ 2948 VEC (symtab_p) *symtabs; 2949 2950 /* This is used to ensure the symtabs are unique. */ 2951 htab_t symtab_table; 2952 }; 2953 2954 /* Callback for iterate_over_symtabs. */ 2955 2956 static int 2957 add_symtabs_to_list (struct symtab *symtab, void *d) 2958 { 2959 struct symtab_collector *data = d; 2960 void **slot; 2961 2962 slot = htab_find_slot (data->symtab_table, symtab, INSERT); 2963 if (!*slot) 2964 { 2965 *slot = symtab; 2966 VEC_safe_push (symtab_p, data->symtabs, symtab); 2967 } 2968 2969 return 0; 2970 } 2971 2972 /* Given a file name, return a VEC of all matching symtabs. */ 2973 2974 static VEC (symtab_p) * 2975 collect_symtabs_from_filename (const char *file) 2976 { 2977 struct symtab_collector collector; 2978 struct cleanup *cleanups; 2979 struct program_space *pspace; 2980 2981 collector.symtabs = NULL; 2982 collector.symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer, 2983 NULL); 2984 cleanups = make_cleanup_htab_delete (collector.symtab_table); 2985 2986 /* Find that file's data. */ 2987 ALL_PSPACES (pspace) 2988 { 2989 if (pspace->executing_startup) 2990 continue; 2991 2992 set_current_program_space (pspace); 2993 iterate_over_symtabs (file, add_symtabs_to_list, &collector); 2994 } 2995 2996 do_cleanups (cleanups); 2997 return collector.symtabs; 2998 } 2999 3000 /* Return all the symtabs associated to the FILENAME. */ 3001 3002 static VEC (symtab_p) * 3003 symtabs_from_filename (const char *filename) 3004 { 3005 VEC (symtab_p) *result; 3006 3007 result = collect_symtabs_from_filename (filename); 3008 3009 if (VEC_empty (symtab_p, result)) 3010 { 3011 if (!have_full_symbols () && !have_partial_symbols ()) 3012 throw_error (NOT_FOUND_ERROR, 3013 _("No symbol table is loaded. " 3014 "Use the \"file\" command.")); 3015 throw_error (NOT_FOUND_ERROR, _("No source file named %s."), filename); 3016 } 3017 3018 return result; 3019 } 3020 3021 /* Look up a function symbol named NAME in symtabs FILE_SYMTABS. Matching 3022 debug symbols are returned in SYMBOLS. Matching minimal symbols are 3023 returned in MINSYMS. */ 3024 3025 static void 3026 find_function_symbols (struct linespec_state *state, 3027 VEC (symtab_p) *file_symtabs, const char *name, 3028 VEC (symbolp) **symbols, 3029 VEC (minsym_and_objfile_d) **minsyms) 3030 { 3031 struct collect_info info; 3032 VEC (const_char_ptr) *symbol_names = NULL; 3033 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr), 3034 &symbol_names); 3035 3036 info.state = state; 3037 info.result.symbols = NULL; 3038 info.result.minimal_symbols = NULL; 3039 info.file_symtabs = file_symtabs; 3040 3041 /* Try NAME as an Objective-C selector. */ 3042 find_imps ((char *) name, &symbol_names); 3043 if (!VEC_empty (const_char_ptr, symbol_names)) 3044 add_all_symbol_names_from_pspace (&info, NULL, symbol_names); 3045 else 3046 add_matching_symbols_to_info (name, &info, NULL); 3047 3048 do_cleanups (cleanup); 3049 3050 if (VEC_empty (symbolp, info.result.symbols)) 3051 { 3052 VEC_free (symbolp, info.result.symbols); 3053 *symbols = NULL; 3054 } 3055 else 3056 *symbols = info.result.symbols; 3057 3058 if (VEC_empty (minsym_and_objfile_d, info.result.minimal_symbols)) 3059 { 3060 VEC_free (minsym_and_objfile_d, info.result.minimal_symbols); 3061 *minsyms = NULL; 3062 } 3063 else 3064 *minsyms = info.result.minimal_symbols; 3065 } 3066 3067 /* Find all symbols named NAME in FILE_SYMTABS, returning debug symbols 3068 in SYMBOLS and minimal symbols in MINSYMS. */ 3069 3070 static void 3071 find_linespec_symbols (struct linespec_state *state, 3072 VEC (symtab_p) *file_symtabs, 3073 const char *name, 3074 VEC (symbolp) **symbols, 3075 VEC (minsym_and_objfile_d) **minsyms) 3076 { 3077 struct cleanup *cleanup; 3078 char *canon; 3079 const char *lookup_name; 3080 volatile struct gdb_exception except; 3081 3082 cleanup = demangle_for_lookup (name, state->language->la_language, 3083 &lookup_name); 3084 if (state->language->la_language == language_ada) 3085 { 3086 /* In Ada, the symbol lookups are performed using the encoded 3087 name rather than the demangled name. */ 3088 lookup_name = ada_name_for_lookup (name); 3089 make_cleanup (xfree, (void *) lookup_name); 3090 } 3091 3092 canon = cp_canonicalize_string_no_typedefs (lookup_name); 3093 if (canon != NULL) 3094 { 3095 lookup_name = canon; 3096 cleanup = make_cleanup (xfree, canon); 3097 } 3098 3099 /* It's important to not call expand_symtabs_matching unnecessarily 3100 as it can really slow things down (by unnecessarily expanding 3101 potentially 1000s of symtabs, which when debugging some apps can 3102 cost 100s of seconds). Avoid this to some extent by *first* calling 3103 find_function_symbols, and only if that doesn't find anything 3104 *then* call find_method. This handles two important cases: 3105 1) break (anonymous namespace)::foo 3106 2) break class::method where method is in class (and not a baseclass) */ 3107 3108 find_function_symbols (state, file_symtabs, lookup_name, 3109 symbols, minsyms); 3110 3111 /* If we were unable to locate a symbol of the same name, try dividing 3112 the name into class and method names and searching the class and its 3113 baseclasses. */ 3114 if (VEC_empty (symbolp, *symbols) 3115 && VEC_empty (minsym_and_objfile_d, *minsyms)) 3116 { 3117 char *klass, *method; 3118 const char *last, *p, *scope_op; 3119 VEC (symbolp) *classes; 3120 3121 /* See if we can find a scope operator and break this symbol 3122 name into namespaces${SCOPE_OPERATOR}class_name and method_name. */ 3123 scope_op = "::"; 3124 p = find_toplevel_string (lookup_name, scope_op); 3125 if (p == NULL) 3126 { 3127 /* No C++ scope operator. Try Java. */ 3128 scope_op = "."; 3129 p = find_toplevel_string (lookup_name, scope_op); 3130 } 3131 3132 last = NULL; 3133 while (p != NULL) 3134 { 3135 last = p; 3136 p = find_toplevel_string (p + strlen (scope_op), scope_op); 3137 } 3138 3139 /* If no scope operator was found, there is nothing more we can do; 3140 we already attempted to lookup the entire name as a symbol 3141 and failed. */ 3142 if (last == NULL) 3143 { 3144 do_cleanups (cleanup); 3145 return; 3146 } 3147 3148 /* LOOKUP_NAME points to the class name. 3149 LAST points to the method name. */ 3150 klass = xmalloc ((last - lookup_name + 1) * sizeof (char)); 3151 make_cleanup (xfree, klass); 3152 strncpy (klass, lookup_name, last - lookup_name); 3153 klass[last - lookup_name] = '\0'; 3154 3155 /* Skip past the scope operator. */ 3156 last += strlen (scope_op); 3157 method = xmalloc ((strlen (last) + 1) * sizeof (char)); 3158 make_cleanup (xfree, method); 3159 strcpy (method, last); 3160 3161 /* Find a list of classes named KLASS. */ 3162 classes = lookup_prefix_sym (state, file_symtabs, klass); 3163 make_cleanup (VEC_cleanup (symbolp), &classes); 3164 3165 if (!VEC_empty (symbolp, classes)) 3166 { 3167 /* Now locate a list of suitable methods named METHOD. */ 3168 TRY_CATCH (except, RETURN_MASK_ERROR) 3169 { 3170 find_method (state, file_symtabs, klass, method, classes, 3171 symbols, minsyms); 3172 } 3173 3174 /* If successful, we're done. If NOT_FOUND_ERROR 3175 was not thrown, rethrow the exception that we did get. */ 3176 if (except.reason < 0 && except.error != NOT_FOUND_ERROR) 3177 throw_exception (except); 3178 } 3179 } 3180 3181 do_cleanups (cleanup); 3182 } 3183 3184 /* Return all labels named NAME in FUNCTION_SYMBOLS. Return the 3185 actual function symbol in which the label was found in LABEL_FUNC_RET. */ 3186 3187 static VEC (symbolp) * 3188 find_label_symbols (struct linespec_state *self, 3189 VEC (symbolp) *function_symbols, 3190 VEC (symbolp) **label_funcs_ret, const char *name) 3191 { 3192 int ix; 3193 struct block *block; 3194 struct symbol *sym; 3195 struct symbol *fn_sym; 3196 VEC (symbolp) *result = NULL; 3197 3198 if (function_symbols == NULL) 3199 { 3200 set_current_program_space (self->program_space); 3201 block = get_current_search_block (); 3202 3203 for (; 3204 block && !BLOCK_FUNCTION (block); 3205 block = BLOCK_SUPERBLOCK (block)) 3206 ; 3207 if (!block) 3208 return NULL; 3209 fn_sym = BLOCK_FUNCTION (block); 3210 3211 sym = lookup_symbol (name, block, LABEL_DOMAIN, 0); 3212 3213 if (sym != NULL) 3214 { 3215 VEC_safe_push (symbolp, result, sym); 3216 VEC_safe_push (symbolp, *label_funcs_ret, fn_sym); 3217 } 3218 } 3219 else 3220 { 3221 for (ix = 0; 3222 VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix) 3223 { 3224 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym))); 3225 block = SYMBOL_BLOCK_VALUE (fn_sym); 3226 sym = lookup_symbol (name, block, LABEL_DOMAIN, 0); 3227 3228 if (sym != NULL) 3229 { 3230 VEC_safe_push (symbolp, result, sym); 3231 VEC_safe_push (symbolp, *label_funcs_ret, fn_sym); 3232 } 3233 } 3234 } 3235 3236 return result; 3237 } 3238 3239 3240 3241 /* A helper for create_sals_line_offset that handles the 'list_mode' case. */ 3242 3243 static void 3244 decode_digits_list_mode (struct linespec_state *self, 3245 linespec_p ls, 3246 struct symtabs_and_lines *values, 3247 struct symtab_and_line val) 3248 { 3249 int ix; 3250 struct symtab *elt; 3251 3252 gdb_assert (self->list_mode); 3253 3254 for (ix = 0; VEC_iterate (symtab_p, ls->file_symtabs, ix, elt); 3255 ++ix) 3256 { 3257 /* The logic above should ensure this. */ 3258 gdb_assert (elt != NULL); 3259 3260 set_current_program_space (SYMTAB_PSPACE (elt)); 3261 3262 /* Simplistic search just for the list command. */ 3263 val.symtab = find_line_symtab (elt, val.line, NULL, NULL); 3264 if (val.symtab == NULL) 3265 val.symtab = elt; 3266 val.pspace = SYMTAB_PSPACE (elt); 3267 val.pc = 0; 3268 val.explicit_line = 1; 3269 3270 add_sal_to_sals (self, values, &val, NULL, 0); 3271 } 3272 } 3273 3274 /* A helper for create_sals_line_offset that iterates over the symtabs, 3275 adding lines to the VEC. */ 3276 3277 static void 3278 decode_digits_ordinary (struct linespec_state *self, 3279 linespec_p ls, 3280 int line, 3281 struct symtabs_and_lines *sals, 3282 struct linetable_entry **best_entry) 3283 { 3284 int ix; 3285 struct symtab *elt; 3286 3287 for (ix = 0; VEC_iterate (symtab_p, ls->file_symtabs, ix, elt); ++ix) 3288 { 3289 int i; 3290 VEC (CORE_ADDR) *pcs; 3291 CORE_ADDR pc; 3292 3293 /* The logic above should ensure this. */ 3294 gdb_assert (elt != NULL); 3295 3296 set_current_program_space (SYMTAB_PSPACE (elt)); 3297 3298 pcs = find_pcs_for_symtab_line (elt, line, best_entry); 3299 for (i = 0; VEC_iterate (CORE_ADDR, pcs, i, pc); ++i) 3300 { 3301 struct symtab_and_line sal; 3302 3303 init_sal (&sal); 3304 sal.pspace = SYMTAB_PSPACE (elt); 3305 sal.symtab = elt; 3306 sal.line = line; 3307 sal.pc = pc; 3308 add_sal_to_sals_basic (sals, &sal); 3309 } 3310 3311 VEC_free (CORE_ADDR, pcs); 3312 } 3313 } 3314 3315 3316 3317 /* Return the line offset represented by VARIABLE. */ 3318 3319 static struct line_offset 3320 linespec_parse_variable (struct linespec_state *self, const char *variable) 3321 { 3322 int index = 0; 3323 const char *p; 3324 struct line_offset offset = {0, LINE_OFFSET_NONE}; 3325 3326 p = (variable[1] == '$') ? variable + 2 : variable + 1; 3327 if (*p == '$') 3328 ++p; 3329 while (*p >= '0' && *p <= '9') 3330 ++p; 3331 if (!*p) /* Reached end of token without hitting non-digit. */ 3332 { 3333 /* We have a value history reference. */ 3334 struct value *val_history; 3335 3336 sscanf ((variable[1] == '$') ? variable + 2 : variable + 1, "%d", &index); 3337 val_history 3338 = access_value_history ((variable[1] == '$') ? -index : index); 3339 if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT) 3340 error (_("History values used in line " 3341 "specs must have integer values.")); 3342 offset.offset = value_as_long (val_history); 3343 } 3344 else 3345 { 3346 /* Not all digits -- may be user variable/function or a 3347 convenience variable. */ 3348 LONGEST valx; 3349 struct internalvar *ivar; 3350 3351 /* Try it as a convenience variable. If it is not a convenience 3352 variable, return and allow normal symbol lookup to occur. */ 3353 ivar = lookup_only_internalvar (variable + 1); 3354 if (ivar == NULL) 3355 /* No internal variable with that name. Mark the offset 3356 as unknown to allow the name to be looked up as a symbol. */ 3357 offset.sign = LINE_OFFSET_UNKNOWN; 3358 else 3359 { 3360 /* We found a valid variable name. If it is not an integer, 3361 throw an error. */ 3362 if (!get_internalvar_integer (ivar, &valx)) 3363 error (_("Convenience variables used in line " 3364 "specs must have integer values.")); 3365 else 3366 offset.offset = valx; 3367 } 3368 } 3369 3370 return offset; 3371 } 3372 3373 3374 /* A callback used to possibly add a symbol to the results. */ 3375 3376 static int 3377 collect_symbols (struct symbol *sym, void *data) 3378 { 3379 struct collect_info *info = data; 3380 3381 /* In list mode, add all matching symbols, regardless of class. 3382 This allows the user to type "list a_global_variable". */ 3383 if (SYMBOL_CLASS (sym) == LOC_BLOCK || info->state->list_mode) 3384 VEC_safe_push (symbolp, info->result.symbols, sym); 3385 return 1; /* Continue iterating. */ 3386 } 3387 3388 /* We've found a minimal symbol MSYMBOL in OBJFILE to associate with our 3389 linespec; return the SAL in RESULT. */ 3390 3391 static void 3392 minsym_found (struct linespec_state *self, struct objfile *objfile, 3393 struct minimal_symbol *msymbol, 3394 struct symtabs_and_lines *result) 3395 { 3396 struct gdbarch *gdbarch = get_objfile_arch (objfile); 3397 CORE_ADDR pc; 3398 struct symtab_and_line sal; 3399 3400 sal = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol), 3401 (struct obj_section *) 0, 0); 3402 sal.section = SYMBOL_OBJ_SECTION (msymbol); 3403 3404 /* The minimal symbol might point to a function descriptor; 3405 resolve it to the actual code address instead. */ 3406 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, ¤t_target); 3407 if (pc != sal.pc) 3408 sal = find_pc_sect_line (pc, NULL, 0); 3409 3410 if (self->funfirstline) 3411 skip_prologue_sal (&sal); 3412 3413 if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc)) 3414 add_sal_to_sals (self, result, &sal, SYMBOL_NATURAL_NAME (msymbol), 0); 3415 } 3416 3417 /* A helper struct to pass some data through 3418 iterate_over_minimal_symbols. */ 3419 3420 struct collect_minsyms 3421 { 3422 /* The objfile we're examining. */ 3423 struct objfile *objfile; 3424 3425 /* The funfirstline setting from the initial call. */ 3426 int funfirstline; 3427 3428 /* The list_mode setting from the initial call. */ 3429 int list_mode; 3430 3431 /* The resulting symbols. */ 3432 VEC (minsym_and_objfile_d) *msyms; 3433 }; 3434 3435 /* A helper function to classify a minimal_symbol_type according to 3436 priority. */ 3437 3438 static int 3439 classify_mtype (enum minimal_symbol_type t) 3440 { 3441 switch (t) 3442 { 3443 case mst_file_text: 3444 case mst_file_data: 3445 case mst_file_bss: 3446 /* Intermediate priority. */ 3447 return 1; 3448 3449 case mst_solib_trampoline: 3450 /* Lowest priority. */ 3451 return 2; 3452 3453 default: 3454 /* Highest priority. */ 3455 return 0; 3456 } 3457 } 3458 3459 /* Callback for qsort that sorts symbols by priority. */ 3460 3461 static int 3462 compare_msyms (const void *a, const void *b) 3463 { 3464 const minsym_and_objfile_d *moa = a; 3465 const minsym_and_objfile_d *mob = b; 3466 enum minimal_symbol_type ta = MSYMBOL_TYPE (moa->minsym); 3467 enum minimal_symbol_type tb = MSYMBOL_TYPE (mob->minsym); 3468 3469 return classify_mtype (ta) - classify_mtype (tb); 3470 } 3471 3472 /* Callback for iterate_over_minimal_symbols that adds the symbol to 3473 the result. */ 3474 3475 static void 3476 add_minsym (struct minimal_symbol *minsym, void *d) 3477 { 3478 struct collect_minsyms *info = d; 3479 minsym_and_objfile_d mo; 3480 3481 /* Exclude data symbols when looking for breakpoint locations. */ 3482 if (!info->list_mode) 3483 switch (minsym->type) 3484 { 3485 case mst_slot_got_plt: 3486 case mst_data: 3487 case mst_bss: 3488 case mst_abs: 3489 case mst_file_data: 3490 case mst_file_bss: 3491 { 3492 /* Make sure this minsym is not a function descriptor 3493 before we decide to discard it. */ 3494 struct gdbarch *gdbarch = info->objfile->gdbarch; 3495 CORE_ADDR addr = gdbarch_convert_from_func_ptr_addr 3496 (gdbarch, SYMBOL_VALUE_ADDRESS (minsym), 3497 ¤t_target); 3498 3499 if (addr == SYMBOL_VALUE_ADDRESS (minsym)) 3500 return; 3501 } 3502 } 3503 3504 mo.minsym = minsym; 3505 mo.objfile = info->objfile; 3506 VEC_safe_push (minsym_and_objfile_d, info->msyms, &mo); 3507 } 3508 3509 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE 3510 is not NULL, the search is restricted to just that program 3511 space. */ 3512 3513 static void 3514 search_minsyms_for_name (struct collect_info *info, const char *name, 3515 struct program_space *search_pspace) 3516 { 3517 struct objfile *objfile; 3518 struct program_space *pspace; 3519 3520 ALL_PSPACES (pspace) 3521 { 3522 struct collect_minsyms local; 3523 struct cleanup *cleanup; 3524 3525 if (search_pspace != NULL && search_pspace != pspace) 3526 continue; 3527 if (pspace->executing_startup) 3528 continue; 3529 3530 set_current_program_space (pspace); 3531 3532 memset (&local, 0, sizeof (local)); 3533 local.funfirstline = info->state->funfirstline; 3534 local.list_mode = info->state->list_mode; 3535 3536 cleanup = make_cleanup (VEC_cleanup (minsym_and_objfile_d), 3537 &local.msyms); 3538 3539 ALL_OBJFILES (objfile) 3540 { 3541 local.objfile = objfile; 3542 iterate_over_minimal_symbols (objfile, name, add_minsym, &local); 3543 } 3544 3545 if (!VEC_empty (minsym_and_objfile_d, local.msyms)) 3546 { 3547 int classification; 3548 int ix; 3549 minsym_and_objfile_d *item; 3550 3551 qsort (VEC_address (minsym_and_objfile_d, local.msyms), 3552 VEC_length (minsym_and_objfile_d, local.msyms), 3553 sizeof (minsym_and_objfile_d), 3554 compare_msyms); 3555 3556 /* Now the minsyms are in classification order. So, we walk 3557 over them and process just the minsyms with the same 3558 classification as the very first minsym in the list. */ 3559 item = VEC_index (minsym_and_objfile_d, local.msyms, 0); 3560 classification = classify_mtype (MSYMBOL_TYPE (item->minsym)); 3561 3562 for (ix = 0; 3563 VEC_iterate (minsym_and_objfile_d, local.msyms, ix, item); 3564 ++ix) 3565 { 3566 if (classify_mtype (MSYMBOL_TYPE (item->minsym)) != classification) 3567 break; 3568 3569 VEC_safe_push (minsym_and_objfile_d, 3570 info->result.minimal_symbols, item); 3571 } 3572 } 3573 3574 do_cleanups (cleanup); 3575 } 3576 } 3577 3578 /* A helper function to add all symbols matching NAME to INFO. If 3579 PSPACE is not NULL, the search is restricted to just that program 3580 space. */ 3581 3582 static void 3583 add_matching_symbols_to_info (const char *name, 3584 struct collect_info *info, 3585 struct program_space *pspace) 3586 { 3587 int ix; 3588 struct symtab *elt; 3589 3590 for (ix = 0; VEC_iterate (symtab_p, info->file_symtabs, ix, elt); ++ix) 3591 { 3592 if (elt == NULL) 3593 { 3594 iterate_over_all_matching_symtabs (info->state, name, VAR_DOMAIN, 3595 collect_symbols, info, 3596 pspace, 1); 3597 search_minsyms_for_name (info, name, pspace); 3598 } 3599 else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt)) 3600 { 3601 /* Program spaces that are executing startup should have 3602 been filtered out earlier. */ 3603 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup); 3604 set_current_program_space (SYMTAB_PSPACE (elt)); 3605 iterate_over_file_blocks (elt, name, VAR_DOMAIN, 3606 collect_symbols, info); 3607 } 3608 } 3609 } 3610 3611 3612 3613 /* Now come some functions that are called from multiple places within 3614 decode_line_1. */ 3615 3616 static int 3617 symbol_to_sal (struct symtab_and_line *result, 3618 int funfirstline, struct symbol *sym) 3619 { 3620 if (SYMBOL_CLASS (sym) == LOC_BLOCK) 3621 { 3622 *result = find_function_start_sal (sym, funfirstline); 3623 return 1; 3624 } 3625 else 3626 { 3627 if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0) 3628 { 3629 init_sal (result); 3630 result->symtab = SYMBOL_SYMTAB (sym); 3631 result->line = SYMBOL_LINE (sym); 3632 result->pc = SYMBOL_VALUE_ADDRESS (sym); 3633 result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)); 3634 result->explicit_pc = 1; 3635 return 1; 3636 } 3637 else if (funfirstline) 3638 { 3639 /* Nothing. */ 3640 } 3641 else if (SYMBOL_LINE (sym) != 0) 3642 { 3643 /* We know its line number. */ 3644 init_sal (result); 3645 result->symtab = SYMBOL_SYMTAB (sym); 3646 result->line = SYMBOL_LINE (sym); 3647 result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)); 3648 return 1; 3649 } 3650 } 3651 3652 return 0; 3653 } 3654 3655 /* See the comment in linespec.h. */ 3656 3657 void 3658 init_linespec_result (struct linespec_result *lr) 3659 { 3660 memset (lr, 0, sizeof (*lr)); 3661 } 3662 3663 /* See the comment in linespec.h. */ 3664 3665 void 3666 destroy_linespec_result (struct linespec_result *ls) 3667 { 3668 int i; 3669 struct linespec_sals *lsal; 3670 3671 xfree (ls->addr_string); 3672 for (i = 0; VEC_iterate (linespec_sals, ls->sals, i, lsal); ++i) 3673 { 3674 xfree (lsal->canonical); 3675 xfree (lsal->sals.sals); 3676 } 3677 VEC_free (linespec_sals, ls->sals); 3678 } 3679 3680 /* Cleanup function for a linespec_result. */ 3681 3682 static void 3683 cleanup_linespec_result (void *a) 3684 { 3685 destroy_linespec_result (a); 3686 } 3687 3688 /* See the comment in linespec.h. */ 3689 3690 struct cleanup * 3691 make_cleanup_destroy_linespec_result (struct linespec_result *ls) 3692 { 3693 return make_cleanup (cleanup_linespec_result, ls); 3694 } 3695