1 /* Parser for linespec for the GNU debugger, GDB. 2 3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 5 2009, 2010, 2011 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "symtab.h" 24 #include "frame.h" 25 #include "command.h" 26 #include "symfile.h" 27 #include "objfiles.h" 28 #include "source.h" 29 #include "demangle.h" 30 #include "value.h" 31 #include "completer.h" 32 #include "cp-abi.h" 33 #include "cp-support.h" 34 #include "parser-defs.h" 35 #include "block.h" 36 #include "objc-lang.h" 37 #include "linespec.h" 38 #include "exceptions.h" 39 #include "language.h" 40 #include "interps.h" 41 #include "mi/mi-cmds.h" 42 #include "target.h" 43 #include "arch-utils.h" 44 #include <ctype.h> 45 #include "cli/cli-utils.h" 46 47 /* We share this one with symtab.c, but it is not exported widely. */ 48 49 extern char *operator_chars (char *, char **); 50 51 /* Prototypes for local functions. */ 52 53 static void initialize_defaults (struct symtab **default_symtab, 54 int *default_line); 55 56 static struct symtabs_and_lines decode_indirect (char **argptr); 57 58 static char *locate_first_half (char **argptr, int *is_quote_enclosed); 59 60 static struct symtabs_and_lines decode_objc (char **argptr, 61 int funfirstline, 62 struct symtab *file_symtab, 63 struct linespec_result *canonical, 64 char *saved_arg); 65 66 static struct symtabs_and_lines decode_compound (char **argptr, 67 int funfirstline, 68 struct linespec_result *canonical, 69 struct symtab *file_symtab, 70 char *saved_arg, 71 char *p); 72 73 static struct symbol *lookup_prefix_sym (char **argptr, char *p, 74 struct symtab *); 75 76 static struct symtabs_and_lines find_method (int funfirstline, 77 struct linespec_result *canonical, 78 char *saved_arg, 79 char *copy, 80 struct type *t, 81 struct symbol *sym_class, 82 struct symtab *); 83 84 static void cplusplus_error (const char *name, const char *fmt, ...) 85 ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 3); 86 87 static int total_number_of_methods (struct type *type); 88 89 static int find_methods (struct type *, char *, 90 enum language, struct symbol **, struct symtab *); 91 92 static int add_matching_methods (int method_counter, struct type *t, 93 enum language language, 94 struct symbol **sym_arr); 95 96 static int add_constructors (int method_counter, struct type *t, 97 enum language language, 98 struct symbol **sym_arr); 99 100 static void build_canonical_line_spec (struct symtab_and_line *, 101 char *, struct linespec_result *); 102 103 static char *find_toplevel_char (char *s, char c); 104 105 static int is_objc_method_format (const char *s); 106 107 static struct symtabs_and_lines decode_line_2 (struct symbol *[], 108 int, int, 109 struct linespec_result *); 110 111 static struct symtab *symtab_from_filename (char **argptr, 112 char *p, int is_quote_enclosed); 113 114 static struct symbol *find_function_symbol (char **argptr, char *p, 115 int is_quote_enclosed); 116 117 static struct 118 symtabs_and_lines decode_all_digits (char **argptr, 119 struct symtab *default_symtab, 120 int default_line, 121 struct linespec_result *canonical, 122 struct symtab *file_symtab, 123 char *q); 124 125 static struct symtabs_and_lines decode_dollar (char *copy, 126 int funfirstline, 127 struct symtab *default_symtab, 128 struct linespec_result *canonical, 129 struct symtab *file_symtab); 130 131 static int decode_label (struct symbol *function_symbol, 132 char *copy, struct linespec_result *canonical, 133 struct symtabs_and_lines *result); 134 135 static struct symtabs_and_lines decode_variable (char *copy, 136 int funfirstline, 137 struct linespec_result *canonical, 138 struct symtab *file_symtab); 139 140 static struct 141 symtabs_and_lines symbol_found (int funfirstline, 142 struct linespec_result *canonical, 143 char *copy, 144 struct symbol *sym, 145 struct symtab *file_symtab, 146 struct symbol *function_symbol); 147 148 static struct 149 symtabs_and_lines minsym_found (int funfirstline, 150 struct minimal_symbol *msymbol); 151 152 /* Helper functions. */ 153 154 /* Issue a helpful hint on using the command completion feature on 155 single quoted demangled C++ symbols as part of the completion 156 error. */ 157 158 static void 159 cplusplus_error (const char *name, const char *fmt, ...) 160 { 161 struct ui_file *tmp_stream; 162 char *message; 163 164 tmp_stream = mem_fileopen (); 165 make_cleanup_ui_file_delete (tmp_stream); 166 167 { 168 va_list args; 169 170 va_start (args, fmt); 171 vfprintf_unfiltered (tmp_stream, fmt, args); 172 va_end (args); 173 } 174 175 while (*name == '\'') 176 name++; 177 fprintf_unfiltered (tmp_stream, 178 ("Hint: try '%s<TAB> or '%s<ESC-?>\n" 179 "(Note leading single quote.)"), 180 name, name); 181 182 message = ui_file_xstrdup (tmp_stream, NULL); 183 make_cleanup (xfree, message); 184 throw_error (NOT_FOUND_ERROR, "%s", message); 185 } 186 187 /* Return the number of methods described for TYPE, including the 188 methods from types it derives from. This can't be done in the symbol 189 reader because the type of the baseclass might still be stubbed 190 when the definition of the derived class is parsed. */ 191 192 static int 193 total_number_of_methods (struct type *type) 194 { 195 int n; 196 int count; 197 198 CHECK_TYPEDEF (type); 199 if (! HAVE_CPLUS_STRUCT (type)) 200 return 0; 201 count = TYPE_NFN_FIELDS_TOTAL (type); 202 203 for (n = 0; n < TYPE_N_BASECLASSES (type); n++) 204 count += total_number_of_methods (TYPE_BASECLASS (type, n)); 205 206 return count; 207 } 208 209 /* Returns the block to be used for symbol searches for the given SYMTAB, 210 which may be NULL. */ 211 212 static struct block * 213 get_search_block (struct symtab *symtab) 214 { 215 struct block *block; 216 217 if (symtab != NULL) 218 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK); 219 else 220 { 221 enum language save_language; 222 223 /* get_selected_block can change the current language when there is 224 no selected frame yet. */ 225 save_language = current_language->la_language; 226 block = get_selected_block (0); 227 set_language (save_language); 228 } 229 230 return block; 231 } 232 233 /* Recursive helper function for decode_line_1. 234 Look for methods named NAME in type T. 235 Return number of matches. 236 Put matches in SYM_ARR, which should have been allocated with 237 a size of total_number_of_methods (T) * sizeof (struct symbol *). 238 Note that this function is g++ specific. */ 239 240 static int 241 find_methods (struct type *t, char *name, enum language language, 242 struct symbol **sym_arr, struct symtab *file_symtab) 243 { 244 int i1 = 0; 245 int ibase; 246 char *class_name = type_name_no_tag (t); 247 struct cleanup *cleanup; 248 char *canon; 249 250 /* NAME is typed by the user: it needs to be canonicalized before 251 passing to lookup_symbol. */ 252 canon = cp_canonicalize_string (name); 253 if (canon != NULL) 254 { 255 name = canon; 256 cleanup = make_cleanup (xfree, name); 257 } 258 else 259 cleanup = make_cleanup (null_cleanup, NULL); 260 261 /* Ignore this class if it doesn't have a name. This is ugly, but 262 unless we figure out how to get the physname without the name of 263 the class, then the loop can't do any good. */ 264 if (class_name 265 && (lookup_symbol_in_language (class_name, get_search_block (file_symtab), 266 STRUCT_DOMAIN, language, (int *) NULL))) 267 { 268 int method_counter; 269 int name_len = strlen (name); 270 271 CHECK_TYPEDEF (t); 272 273 /* Loop over each method name. At this level, all overloads of a name 274 are counted as a single name. There is an inner loop which loops over 275 each overload. */ 276 277 for (method_counter = TYPE_NFN_FIELDS (t) - 1; 278 method_counter >= 0; 279 --method_counter) 280 { 281 char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter); 282 char dem_opname[64]; 283 284 if (strncmp (method_name, "__", 2) == 0 || 285 strncmp (method_name, "op", 2) == 0 || 286 strncmp (method_name, "type", 4) == 0) 287 { 288 if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI)) 289 method_name = dem_opname; 290 else if (cplus_demangle_opname (method_name, dem_opname, 0)) 291 method_name = dem_opname; 292 } 293 294 if (strcmp_iw (name, method_name) == 0) 295 /* Find all the overloaded methods with that name. */ 296 i1 += add_matching_methods (method_counter, t, language, 297 sym_arr + i1); 298 else if (strncmp (class_name, name, name_len) == 0 299 && (class_name[name_len] == '\0' 300 || class_name[name_len] == '<')) 301 i1 += add_constructors (method_counter, t, language, 302 sym_arr + i1); 303 } 304 } 305 306 /* Only search baseclasses if there is no match yet, since names in 307 derived classes override those in baseclasses. 308 309 FIXME: The above is not true; it is only true of member functions 310 if they have the same number of arguments (??? - section 13.1 of the 311 ARM says the function members are not in the same scope but doesn't 312 really spell out the rules in a way I understand. In any case, if 313 the number of arguments differ this is a case in which we can overload 314 rather than hiding without any problem, and gcc 2.4.5 does overload 315 rather than hiding in this case). */ 316 317 if (i1 == 0) 318 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++) 319 i1 += find_methods (TYPE_BASECLASS (t, ibase), name, 320 language, sym_arr + i1, file_symtab); 321 322 do_cleanups (cleanup); 323 return i1; 324 } 325 326 /* Add the symbols associated to methods of the class whose type is T 327 and whose name matches the method indexed by METHOD_COUNTER in the 328 array SYM_ARR. Return the number of methods added. */ 329 330 static int 331 add_matching_methods (int method_counter, struct type *t, 332 enum language language, struct symbol **sym_arr) 333 { 334 int field_counter; 335 int i1 = 0; 336 337 for (field_counter = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1; 338 field_counter >= 0; 339 --field_counter) 340 { 341 struct fn_field *f; 342 char *phys_name; 343 344 f = TYPE_FN_FIELDLIST1 (t, method_counter); 345 346 if (TYPE_FN_FIELD_STUB (f, field_counter)) 347 { 348 char *tmp_name; 349 350 tmp_name = gdb_mangle_name (t, 351 method_counter, 352 field_counter); 353 phys_name = alloca (strlen (tmp_name) + 1); 354 strcpy (phys_name, tmp_name); 355 xfree (tmp_name); 356 } 357 else 358 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter); 359 360 sym_arr[i1] = lookup_symbol_in_language (phys_name, 361 NULL, VAR_DOMAIN, 362 language, 363 (int *) NULL); 364 if (sym_arr[i1]) 365 i1++; 366 else 367 { 368 /* This error message gets printed, but the method 369 still seems to be found. 370 fputs_filtered("(Cannot find method ", gdb_stdout); 371 fprintf_symbol_filtered (gdb_stdout, phys_name, 372 language_cplus, 373 DMGL_PARAMS | DMGL_ANSI); 374 fputs_filtered(" - possibly inlined.)\n", gdb_stdout); 375 */ 376 } 377 } 378 379 return i1; 380 } 381 382 /* Add the symbols associated to constructors of the class whose type 383 is CLASS_TYPE and which are indexed by by METHOD_COUNTER to the 384 array SYM_ARR. Return the number of methods added. */ 385 386 static int 387 add_constructors (int method_counter, struct type *t, 388 enum language language, struct symbol **sym_arr) 389 { 390 int field_counter; 391 int i1 = 0; 392 393 /* For GCC 3.x and stabs, constructors and destructors 394 have names like __base_ctor and __complete_dtor. 395 Check the physname for now if we're looking for a 396 constructor. */ 397 for (field_counter 398 = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1; 399 field_counter >= 0; 400 --field_counter) 401 { 402 struct fn_field *f; 403 char *phys_name; 404 405 f = TYPE_FN_FIELDLIST1 (t, method_counter); 406 407 /* GCC 3.x will never produce stabs stub methods, so 408 we don't need to handle this case. */ 409 if (TYPE_FN_FIELD_STUB (f, field_counter)) 410 continue; 411 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter); 412 if (! is_constructor_name (phys_name)) 413 continue; 414 415 /* If this method is actually defined, include it in the 416 list. */ 417 sym_arr[i1] = lookup_symbol_in_language (phys_name, 418 NULL, VAR_DOMAIN, 419 language, 420 (int *) NULL); 421 if (sym_arr[i1]) 422 i1++; 423 } 424 425 return i1; 426 } 427 428 /* Helper function for decode_line_1. 429 Build a canonical line spec in CANONICAL if it is non-NULL and if 430 the SAL has a symtab. 431 If SYMNAME is non-NULL the canonical line spec is `filename:symname'. 432 If SYMNAME is NULL the line number from SAL is used and the canonical 433 line spec is `filename:linenum'. */ 434 435 static void 436 build_canonical_line_spec (struct symtab_and_line *sal, char *symname, 437 struct linespec_result *canonical) 438 { 439 char **canonical_arr; 440 char *canonical_name; 441 char *filename; 442 struct symtab *s = sal->symtab; 443 444 if (s == (struct symtab *) NULL 445 || s->filename == (char *) NULL 446 || canonical == NULL) 447 return; 448 449 canonical_arr = (char **) xmalloc (sizeof (char *)); 450 canonical->canonical = canonical_arr; 451 452 filename = s->filename; 453 if (symname != NULL) 454 { 455 canonical_name = xmalloc (strlen (filename) + strlen (symname) + 2); 456 sprintf (canonical_name, "%s:%s", filename, symname); 457 } 458 else 459 { 460 canonical_name = xmalloc (strlen (filename) + 30); 461 sprintf (canonical_name, "%s:%d", filename, sal->line); 462 } 463 canonical_arr[0] = canonical_name; 464 } 465 466 467 468 /* Find an instance of the character C in the string S that is outside 469 of all parenthesis pairs, single-quoted strings, and double-quoted 470 strings. Also, ignore the char within a template name, like a ',' 471 within foo<int, int>. */ 472 473 static char * 474 find_toplevel_char (char *s, char c) 475 { 476 int quoted = 0; /* zero if we're not in quotes; 477 '"' if we're in a double-quoted string; 478 '\'' if we're in a single-quoted string. */ 479 int depth = 0; /* Number of unclosed parens we've seen. */ 480 char *scan; 481 482 for (scan = s; *scan; scan++) 483 { 484 if (quoted) 485 { 486 if (*scan == quoted) 487 quoted = 0; 488 else if (*scan == '\\' && *(scan + 1)) 489 scan++; 490 } 491 else if (*scan == c && ! quoted && depth == 0) 492 return scan; 493 else if (*scan == '"' || *scan == '\'') 494 quoted = *scan; 495 else if (*scan == '(' || *scan == '<') 496 depth++; 497 else if ((*scan == ')' || *scan == '>') && depth > 0) 498 depth--; 499 } 500 501 return 0; 502 } 503 504 /* Determines if the gives string corresponds to an Objective-C method 505 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols 506 are allowed to have spaces and parentheses in them. */ 507 508 static int 509 is_objc_method_format (const char *s) 510 { 511 if (s == NULL || *s == '\0') 512 return 0; 513 /* Handle arguments with the format FILENAME:SYMBOL. */ 514 if ((s[0] == ':') && (strchr ("+-", s[1]) != NULL) 515 && (s[2] == '[') && strchr(s, ']')) 516 return 1; 517 /* Handle arguments that are just SYMBOL. */ 518 else if ((strchr ("+-", s[0]) != NULL) && (s[1] == '[') && strchr(s, ']')) 519 return 1; 520 return 0; 521 } 522 523 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to 524 operate on (ask user if necessary). 525 If CANONICAL is non-NULL return a corresponding array of mangled names 526 as canonical line specs there. */ 527 528 static struct symtabs_and_lines 529 decode_line_2 (struct symbol *sym_arr[], int nelts, int funfirstline, 530 struct linespec_result *canonical) 531 { 532 struct symtabs_and_lines values, return_values; 533 char *args, *arg1; 534 int i; 535 char *prompt; 536 char *symname; 537 struct cleanup *old_chain; 538 char **canonical_arr = (char **) NULL; 539 const char *select_mode = multiple_symbols_select_mode (); 540 541 if (select_mode == multiple_symbols_cancel) 542 error (_("canceled because the command is ambiguous\n" 543 "See set/show multiple-symbol.")); 544 545 values.sals = (struct symtab_and_line *) 546 alloca (nelts * sizeof (struct symtab_and_line)); 547 return_values.sals = (struct symtab_and_line *) 548 xmalloc (nelts * sizeof (struct symtab_and_line)); 549 old_chain = make_cleanup (xfree, return_values.sals); 550 551 if (canonical) 552 { 553 canonical_arr = (char **) xmalloc (nelts * sizeof (char *)); 554 make_cleanup (xfree, canonical_arr); 555 memset (canonical_arr, 0, nelts * sizeof (char *)); 556 canonical->canonical = canonical_arr; 557 } 558 559 i = 0; 560 while (i < nelts) 561 { 562 init_sal (&return_values.sals[i]); /* Initialize to zeroes. */ 563 init_sal (&values.sals[i]); 564 if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK) 565 values.sals[i] = find_function_start_sal (sym_arr[i], funfirstline); 566 i++; 567 } 568 569 /* If select_mode is "all", then do not print the multiple-choice 570 menu and act as if the user had chosen choice "1" (all). */ 571 if (select_mode == multiple_symbols_all 572 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))) 573 args = "1"; 574 else 575 { 576 i = 0; 577 printf_unfiltered (_("[0] cancel\n[1] all\n")); 578 while (i < nelts) 579 { 580 if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK) 581 { 582 if (values.sals[i].symtab) 583 printf_unfiltered ("[%d] %s at %s:%d\n", 584 (i + 2), 585 SYMBOL_PRINT_NAME (sym_arr[i]), 586 values.sals[i].symtab->filename, 587 values.sals[i].line); 588 else 589 printf_unfiltered (_("[%d] %s at ?FILE:%d [No symtab? " 590 "Probably broken debug info...]\n"), 591 (i + 2), 592 SYMBOL_PRINT_NAME (sym_arr[i]), 593 values.sals[i].line); 594 595 } 596 else 597 printf_unfiltered (_("?HERE\n")); 598 i++; 599 } 600 601 prompt = getenv ("PS2"); 602 if (prompt == NULL) 603 { 604 prompt = "> "; 605 } 606 args = command_line_input (prompt, 0, "overload-choice"); 607 } 608 609 if (args == 0 || *args == 0) 610 error_no_arg (_("one or more choice numbers")); 611 612 i = 0; 613 while (*args) 614 { 615 int num; 616 617 arg1 = args; 618 while (*arg1 >= '0' && *arg1 <= '9') 619 arg1++; 620 if (*arg1 && *arg1 != ' ' && *arg1 != '\t') 621 error (_("Arguments must be choice numbers.")); 622 623 num = atoi (args); 624 625 if (num == 0) 626 error (_("canceled")); 627 else if (num == 1) 628 { 629 if (canonical_arr) 630 { 631 for (i = 0; i < nelts; i++) 632 { 633 if (canonical_arr[i] == NULL) 634 { 635 symname = SYMBOL_LINKAGE_NAME (sym_arr[i]); 636 canonical_arr[i] = xstrdup (symname); 637 } 638 } 639 } 640 memcpy (return_values.sals, values.sals, 641 (nelts * sizeof (struct symtab_and_line))); 642 return_values.nelts = nelts; 643 discard_cleanups (old_chain); 644 return return_values; 645 } 646 647 if (num >= nelts + 2) 648 { 649 printf_unfiltered (_("No choice number %d.\n"), num); 650 } 651 else 652 { 653 num -= 2; 654 if (values.sals[num].pc) 655 { 656 if (canonical_arr) 657 { 658 symname = SYMBOL_LINKAGE_NAME (sym_arr[num]); 659 make_cleanup (xfree, symname); 660 canonical_arr[i] = xstrdup (symname); 661 } 662 return_values.sals[i++] = values.sals[num]; 663 values.sals[num].pc = 0; 664 } 665 else 666 { 667 printf_unfiltered (_("duplicate request for %d ignored.\n"), 668 num); 669 } 670 } 671 672 args = arg1; 673 while (*args == ' ' || *args == '\t') 674 args++; 675 } 676 return_values.nelts = i; 677 discard_cleanups (old_chain); 678 return return_values; 679 } 680 681 /* Valid delimiters for linespec keywords "if", "thread" or "task". */ 682 683 static int 684 is_linespec_boundary (char c) 685 { 686 return c == ' ' || c == '\t' || c == '\0' || c == ','; 687 } 688 689 /* A helper function for decode_line_1 and friends which skips P 690 past any method overload information at the beginning of P, e.g., 691 "(const struct foo *)". 692 693 This function assumes that P has already been validated to contain 694 overload information, and it will assert if *P != '('. */ 695 static char * 696 find_method_overload_end (char *p) 697 { 698 int depth = 0; 699 700 gdb_assert (*p == '('); 701 702 while (*p) 703 { 704 if (*p == '(') 705 ++depth; 706 else if (*p == ')') 707 { 708 if (--depth == 0) 709 { 710 ++p; 711 break; 712 } 713 } 714 ++p; 715 } 716 717 return p; 718 } 719 720 /* Keep important information used when looking up a name. This includes 721 template parameters, overload information, and important keywords, including 722 the possible Java trailing type. */ 723 724 static char * 725 keep_name_info (char *p, int on_boundary) 726 { 727 const char *quotes = get_gdb_completer_quote_characters (); 728 char *saved_p = p; 729 int nest = 0; 730 731 while (*p) 732 { 733 if (strchr (quotes, *p)) 734 break; 735 736 if (*p == ',' && !nest) 737 break; 738 739 if (on_boundary && !nest) 740 { 741 const char *const words[] = { "if", "thread", "task" }; 742 int wordi; 743 744 for (wordi = 0; wordi < ARRAY_SIZE (words); wordi++) 745 if (strncmp (p, words[wordi], strlen (words[wordi])) == 0 746 && is_linespec_boundary (p[strlen (words[wordi])])) 747 break; 748 if (wordi < ARRAY_SIZE (words)) 749 break; 750 } 751 752 if (*p == '(' || *p == '<' || *p == '[') 753 nest++; 754 else if ((*p == ')' || *p == '>' || *p == ']') && nest > 0) 755 nest--; 756 757 p++; 758 759 /* The ',' check could fail on "operator ,". */ 760 p += cp_validate_operator (p); 761 762 on_boundary = is_linespec_boundary (p[-1]); 763 } 764 765 while (p > saved_p && is_linespec_boundary (p[-1])) 766 p--; 767 768 return p; 769 } 770 771 772 /* The parser of linespec itself. */ 773 774 /* Parse a string that specifies a line number. 775 Pass the address of a char * variable; that variable will be 776 advanced over the characters actually parsed. 777 778 The string can be: 779 780 LINENUM -- that line number in current file. PC returned is 0. 781 FILE:LINENUM -- that line in that file. PC returned is 0. 782 FUNCTION -- line number of openbrace of that function. 783 PC returned is the start of the function. 784 LABEL -- a label in the current scope 785 VARIABLE -- line number of definition of that variable. 786 PC returned is 0. 787 FILE:FUNCTION -- likewise, but prefer functions in that file. 788 *EXPR -- line in which address EXPR appears. 789 790 This may all be followed by an "if EXPR", which we ignore. 791 792 FUNCTION may be an undebuggable function found in minimal symbol table. 793 794 If the argument FUNFIRSTLINE is nonzero, we want the first line 795 of real code inside a function when a function is specified, and it is 796 not OK to specify a variable or type to get its line number. 797 798 DEFAULT_SYMTAB specifies the file to use if none is specified. 799 It defaults to current_source_symtab. 800 DEFAULT_LINE specifies the line number to use for relative 801 line numbers (that start with signs). Defaults to current_source_line. 802 If CANONICAL is non-NULL, store an array of strings containing the canonical 803 line specs there if necessary. Currently overloaded member functions and 804 line numbers or static functions without a filename yield a canonical 805 line spec. The array and the line spec strings are allocated on the heap, 806 it is the callers responsibility to free them. 807 808 Note that it is possible to return zero for the symtab 809 if no file is validly specified. Callers must check that. 810 Also, the line number returned may be invalid. */ 811 812 /* We allow single quotes in various places. This is a hideous 813 kludge, which exists because the completer can't yet deal with the 814 lack of single quotes. FIXME: write a linespec_completer which we 815 can use as appropriate instead of make_symbol_completion_list. */ 816 817 struct symtabs_and_lines 818 decode_line_1 (char **argptr, int funfirstline, struct symtab *default_symtab, 819 int default_line, struct linespec_result *canonical) 820 { 821 char *p; 822 char *q; 823 /* If a file name is specified, this is its symtab. */ 824 struct symtab *file_symtab = NULL; 825 826 char *copy; 827 /* This says whether or not something in *ARGPTR is quoted with 828 completer_quotes (i.e. with single quotes). */ 829 int is_quoted; 830 /* Is *ARGPTR is enclosed in double quotes? */ 831 int is_quote_enclosed; 832 int is_objc_method = 0; 833 char *saved_arg = *argptr; 834 /* If IS_QUOTED, the end of the quoted bit. */ 835 char *end_quote = NULL; 836 /* Is *ARGPTR enclosed in single quotes? */ 837 int is_squote_enclosed = 0; 838 /* The "first half" of the linespec. */ 839 char *first_half; 840 841 /* If we are parsing `function:label', this holds the symbol for the 842 function. */ 843 struct symbol *function_symbol = NULL; 844 /* If FUNCTION_SYMBOL is not NULL, then this is the exception that 845 was thrown when trying to parse a filename. */ 846 volatile struct gdb_exception file_exception; 847 848 /* Defaults have defaults. */ 849 850 initialize_defaults (&default_symtab, &default_line); 851 852 /* See if arg is *PC. */ 853 854 if (**argptr == '*') 855 return decode_indirect (argptr); 856 857 is_quoted = (strchr (get_gdb_completer_quote_characters (), 858 **argptr) != NULL); 859 860 if (is_quoted) 861 { 862 end_quote = skip_quoted (*argptr); 863 if (*end_quote == '\0') 864 is_squote_enclosed = 1; 865 } 866 867 /* Check to see if it's a multipart linespec (with colons or 868 periods). */ 869 870 /* Locate the end of the first half of the linespec. 871 After the call, for instance, if the argptr string is "foo.c:123" 872 p will point at "123". If there is only one part, like "foo", p 873 will point to "". If this is a C++ name, like "A::B::foo", p will 874 point to "::B::foo". Argptr is not changed by this call. */ 875 876 first_half = p = locate_first_half (argptr, &is_quote_enclosed); 877 878 /* First things first: if ARGPTR starts with a filename, get its 879 symtab and strip the filename from ARGPTR. */ 880 TRY_CATCH (file_exception, RETURN_MASK_ERROR) 881 { 882 file_symtab = symtab_from_filename (argptr, p, is_quote_enclosed); 883 } 884 885 if (file_exception.reason >= 0) 886 { 887 /* Check for single quotes on the non-filename part. */ 888 is_quoted = (**argptr 889 && strchr (get_gdb_completer_quote_characters (), 890 **argptr) != NULL); 891 if (is_quoted) 892 end_quote = skip_quoted (*argptr); 893 894 /* Locate the next "half" of the linespec. */ 895 first_half = p = locate_first_half (argptr, &is_quote_enclosed); 896 } 897 898 /* Check if this is an Objective-C method (anything that starts with 899 a '+' or '-' and a '['). */ 900 if (is_objc_method_format (p)) 901 is_objc_method = 1; 902 903 /* Check if the symbol could be an Objective-C selector. */ 904 905 { 906 struct symtabs_and_lines values; 907 908 values = decode_objc (argptr, funfirstline, file_symtab, 909 canonical, saved_arg); 910 if (values.sals != NULL) 911 return values; 912 } 913 914 /* Does it look like there actually were two parts? */ 915 916 if (p[0] == ':' || p[0] == '.') 917 { 918 /* Is it a C++ or Java compound data structure? 919 The check on p[1] == ':' is capturing the case of "::", 920 since p[0]==':' was checked above. 921 Note that the call to decode_compound does everything 922 for us, including the lookup on the symbol table, so we 923 can return now. */ 924 925 if (p[0] == '.' || p[1] == ':') 926 { 927 struct symtabs_and_lines values; 928 volatile struct gdb_exception ex; 929 char *saved_argptr = *argptr; 930 931 if (is_quote_enclosed) 932 ++saved_arg; 933 934 /* Initialize it just to avoid a GCC false warning. */ 935 memset (&values, 0, sizeof (values)); 936 937 TRY_CATCH (ex, RETURN_MASK_ERROR) 938 { 939 values = decode_compound (argptr, funfirstline, canonical, 940 file_symtab, saved_arg, p); 941 } 942 if ((is_quoted || is_squote_enclosed) && **argptr == '\'') 943 *argptr = *argptr + 1; 944 945 if (ex.reason >= 0) 946 return values; 947 948 if (ex.error != NOT_FOUND_ERROR) 949 throw_exception (ex); 950 951 *argptr = saved_argptr; 952 } 953 else 954 { 955 /* If there was an exception looking up a specified filename earlier, 956 then check whether we were really given `function:label'. */ 957 if (file_exception.reason < 0) 958 { 959 function_symbol = find_function_symbol (argptr, p, 960 is_quote_enclosed); 961 /* If we did not find a function, re-throw the original 962 exception. */ 963 if (!function_symbol) 964 throw_exception (file_exception); 965 } 966 967 /* Check for single quotes on the non-filename part. */ 968 if (!is_quoted) 969 { 970 is_quoted = (**argptr 971 && strchr (get_gdb_completer_quote_characters (), 972 **argptr) != NULL); 973 if (is_quoted) 974 end_quote = skip_quoted (*argptr); 975 } 976 } 977 } 978 979 /* file_symtab is specified file's symtab, or 0 if no file specified. 980 If we are parsing `function:symbol', then FUNCTION_SYMBOL is the 981 function before the `:'. 982 arg no longer contains the file name. */ 983 984 /* If the filename was quoted, we must re-check the quotation. */ 985 986 if (end_quote == first_half && *end_quote!= '\0') 987 { 988 is_quoted = (**argptr 989 && strchr (get_gdb_completer_quote_characters (), 990 **argptr) != NULL); 991 if (is_quoted) 992 end_quote = skip_quoted (*argptr); 993 } 994 995 /* Check whether arg is all digits (and sign). */ 996 997 q = *argptr; 998 if (*q == '-' || *q == '+') 999 q++; 1000 while (*q >= '0' && *q <= '9') 1001 q++; 1002 1003 if (q != *argptr && (*q == 0 || *q == ' ' || *q == '\t' || *q == ',') 1004 && function_symbol == NULL) 1005 /* We found a token consisting of all digits -- at least one digit. */ 1006 return decode_all_digits (argptr, default_symtab, default_line, 1007 canonical, file_symtab, q); 1008 1009 /* Arg token is not digits => try it as a variable name 1010 Find the next token (everything up to end or next whitespace). */ 1011 1012 if (**argptr == '$') /* May be a convenience variable. */ 1013 /* One or two $ chars possible. */ 1014 p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1)); 1015 else if (is_quoted || is_squote_enclosed) 1016 { 1017 p = end_quote; 1018 if (p[-1] != '\'') 1019 error (_("Unmatched single quote.")); 1020 } 1021 else if (is_objc_method) 1022 { 1023 /* allow word separators in method names for Obj-C. */ 1024 p = skip_quoted_chars (*argptr, NULL, ""); 1025 } 1026 else 1027 { 1028 p = skip_quoted (*argptr); 1029 } 1030 1031 /* Keep any important naming information. */ 1032 p = keep_name_info (p, p == saved_arg || is_linespec_boundary (p[-1])); 1033 1034 copy = (char *) alloca (p - *argptr + 1); 1035 memcpy (copy, *argptr, p - *argptr); 1036 copy[p - *argptr] = '\0'; 1037 if (p != *argptr 1038 && copy[0] 1039 && copy[0] == copy[p - *argptr - 1] 1040 && strchr (get_gdb_completer_quote_characters (), copy[0]) != NULL) 1041 { 1042 copy[p - *argptr - 1] = '\0'; 1043 copy++; 1044 } 1045 else if (is_quoted || is_squote_enclosed) 1046 copy[p - *argptr - 1] = '\0'; 1047 while (*p == ' ' || *p == '\t') 1048 p++; 1049 *argptr = p; 1050 1051 /* If it starts with $: may be a legitimate variable or routine name 1052 (e.g. HP-UX millicode routines such as $$dyncall), or it may 1053 be history value, or it may be a convenience variable. */ 1054 1055 if (*copy == '$' && function_symbol == NULL) 1056 return decode_dollar (copy, funfirstline, default_symtab, 1057 canonical, file_symtab); 1058 1059 /* Try the token as a label, but only if no file was specified, 1060 because we can only really find labels in the current scope. */ 1061 1062 if (!file_symtab) 1063 { 1064 struct symtabs_and_lines label_result; 1065 if (decode_label (function_symbol, copy, canonical, &label_result)) 1066 return label_result; 1067 } 1068 1069 if (function_symbol) 1070 throw_exception (file_exception); 1071 1072 /* Look up that token as a variable. 1073 If file specified, use that file's per-file block to start with. */ 1074 1075 return decode_variable (copy, funfirstline, canonical, file_symtab); 1076 } 1077 1078 1079 1080 /* Now, more helper functions for decode_line_1. Some conventions 1081 that these functions follow: 1082 1083 Decode_line_1 typically passes along some of its arguments or local 1084 variables to the subfunctions. It passes the variables by 1085 reference if they are modified by the subfunction, and by value 1086 otherwise. 1087 1088 Some of the functions have side effects that don't arise from 1089 variables that are passed by reference. In particular, if a 1090 function is passed ARGPTR as an argument, it modifies what ARGPTR 1091 points to; typically, it advances *ARGPTR past whatever substring 1092 it has just looked at. (If it doesn't modify *ARGPTR, then the 1093 function gets passed *ARGPTR instead, which is then called ARG.) 1094 Also, functions that return a struct symtabs_and_lines may modify 1095 CANONICAL, as in the description of decode_line_1. 1096 1097 If a function returns a struct symtabs_and_lines, then that struct 1098 will immediately make its way up the call chain to be returned by 1099 decode_line_1. In particular, all of the functions decode_XXX 1100 calculate the appropriate struct symtabs_and_lines, under the 1101 assumption that their argument is of the form XXX. */ 1102 1103 /* First, some functions to initialize stuff at the beggining of the 1104 function. */ 1105 1106 static void 1107 initialize_defaults (struct symtab **default_symtab, int *default_line) 1108 { 1109 if (*default_symtab == 0) 1110 { 1111 /* Use whatever we have for the default source line. We don't use 1112 get_current_or_default_symtab_and_line as it can recurse and call 1113 us back! */ 1114 struct symtab_and_line cursal = 1115 get_current_source_symtab_and_line (); 1116 1117 *default_symtab = cursal.symtab; 1118 *default_line = cursal.line; 1119 } 1120 } 1121 1122 1123 1124 /* Decode arg of the form *PC. */ 1125 1126 static struct symtabs_and_lines 1127 decode_indirect (char **argptr) 1128 { 1129 struct symtabs_and_lines values; 1130 CORE_ADDR pc; 1131 1132 (*argptr)++; 1133 pc = value_as_address (parse_to_comma_and_eval (argptr)); 1134 1135 values.sals = (struct symtab_and_line *) 1136 xmalloc (sizeof (struct symtab_and_line)); 1137 1138 values.nelts = 1; 1139 values.sals[0] = find_pc_line (pc, 0); 1140 values.sals[0].pc = pc; 1141 values.sals[0].section = find_pc_overlay (pc); 1142 values.sals[0].explicit_pc = 1; 1143 1144 return values; 1145 } 1146 1147 1148 1149 /* Locate the first half of the linespec, ending in a colon, period, 1150 or whitespace. (More or less.) Also, check to see if *ARGPTR is 1151 enclosed in double quotes; if so, set is_quote_enclosed, advance 1152 ARGPTR past that and zero out the trailing double quote. 1153 If ARGPTR is just a simple name like "main", p will point to "" 1154 at the end. */ 1155 1156 static char * 1157 locate_first_half (char **argptr, int *is_quote_enclosed) 1158 { 1159 char *ii; 1160 char *p, *p1; 1161 int has_comma; 1162 1163 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM 1164 and we must isolate the first half. Outer layers will call again later 1165 for the second half. 1166 1167 Don't count commas that appear in argument lists of overloaded 1168 functions, or in quoted strings. It's stupid to go to this much 1169 trouble when the rest of the function is such an obvious roach hotel. */ 1170 ii = find_toplevel_char (*argptr, ','); 1171 has_comma = (ii != 0); 1172 1173 /* Temporarily zap out second half to not confuse the code below. 1174 This is undone below. Do not change ii!! */ 1175 if (has_comma) 1176 { 1177 *ii = '\0'; 1178 } 1179 1180 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be 1181 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore 1182 inside of <>. */ 1183 1184 p = *argptr; 1185 if (p[0] == '"') 1186 { 1187 *is_quote_enclosed = 1; 1188 (*argptr)++; 1189 p++; 1190 } 1191 else 1192 { 1193 *is_quote_enclosed = 0; 1194 if (strchr (get_gdb_completer_quote_characters (), *p)) 1195 { 1196 ++(*argptr); 1197 ++p; 1198 } 1199 } 1200 for (; *p; p++) 1201 { 1202 if (p[0] == '<') 1203 { 1204 char *temp_end = find_template_name_end (p); 1205 1206 if (!temp_end) 1207 error (_("malformed template specification in command")); 1208 p = temp_end; 1209 } 1210 1211 if (p[0] == '(') 1212 p = find_method_overload_end (p); 1213 1214 /* Check for a colon and a plus or minus and a [ (which 1215 indicates an Objective-C method). */ 1216 if (is_objc_method_format (p)) 1217 { 1218 break; 1219 } 1220 /* Check for the end of the first half of the linespec. End of 1221 line, a tab, a colon or a space. But if enclosed in double 1222 quotes we do not break on enclosed spaces. */ 1223 if (!*p 1224 || p[0] == '\t' 1225 || (p[0] == ':') 1226 || ((p[0] == ' ') && !*is_quote_enclosed)) 1227 break; 1228 if (p[0] == '.' && strchr (p, ':') == NULL) 1229 { 1230 /* Java qualified method. Find the *last* '.', since the 1231 others are package qualifiers. Stop at any open parenthesis 1232 which might provide overload information. */ 1233 for (p1 = p; *p1 && *p1 != '('; p1++) 1234 { 1235 if (*p1 == '.') 1236 p = p1; 1237 } 1238 break; 1239 } 1240 } 1241 while (p[0] == ' ' || p[0] == '\t') 1242 p++; 1243 1244 /* If the closing double quote was left at the end, remove it. */ 1245 if (*is_quote_enclosed) 1246 { 1247 char *closing_quote = strchr (p - 1, '"'); 1248 1249 if (closing_quote && closing_quote[1] == '\0') 1250 *closing_quote = '\0'; 1251 } 1252 1253 /* Now that we've safely parsed the first half, put back ',' so 1254 outer layers can see it. */ 1255 if (has_comma) 1256 *ii = ','; 1257 1258 return p; 1259 } 1260 1261 1262 1263 /* Here's where we recognise an Objective-C Selector. An Objective C 1264 selector may be implemented by more than one class, therefore it 1265 may represent more than one method/function. This gives us a 1266 situation somewhat analogous to C++ overloading. If there's more 1267 than one method that could represent the selector, then use some of 1268 the existing C++ code to let the user choose one. */ 1269 1270 struct symtabs_and_lines 1271 decode_objc (char **argptr, int funfirstline, struct symtab *file_symtab, 1272 struct linespec_result *canonical, char *saved_arg) 1273 { 1274 struct symtabs_and_lines values; 1275 struct symbol **sym_arr = NULL; 1276 struct symbol *sym = NULL; 1277 struct block *block = NULL; 1278 unsigned i1 = 0; 1279 unsigned i2 = 0; 1280 1281 values.sals = NULL; 1282 values.nelts = 0; 1283 1284 find_imps (file_symtab, get_search_block (file_symtab), *argptr, 1285 NULL, &i1, &i2); 1286 1287 if (i1 > 0) 1288 { 1289 sym_arr = (struct symbol **) 1290 alloca ((i1 + 1) * sizeof (struct symbol *)); 1291 sym_arr[i1] = NULL; 1292 1293 *argptr = find_imps (file_symtab, block, *argptr, sym_arr, &i1, &i2); 1294 } 1295 1296 /* i1 now represents the TOTAL number of matches found. 1297 i2 represents how many HIGH-LEVEL (struct symbol) matches, 1298 which will come first in the sym_arr array. Any low-level 1299 (minimal_symbol) matches will follow those. */ 1300 1301 if (i1 == 1) 1302 { 1303 if (i2 > 0) 1304 { 1305 /* Already a struct symbol. */ 1306 sym = sym_arr[0]; 1307 } 1308 else 1309 { 1310 sym = find_pc_function (SYMBOL_VALUE_ADDRESS (sym_arr[0])); 1311 if ((sym != NULL) && strcmp (SYMBOL_LINKAGE_NAME (sym_arr[0]), 1312 SYMBOL_LINKAGE_NAME (sym)) != 0) 1313 { 1314 warning (_("debugging symbol \"%s\" does " 1315 "not match selector; ignoring"), 1316 SYMBOL_LINKAGE_NAME (sym)); 1317 sym = NULL; 1318 } 1319 } 1320 1321 values.sals = (struct symtab_and_line *) 1322 xmalloc (sizeof (struct symtab_and_line)); 1323 values.nelts = 1; 1324 1325 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK) 1326 { 1327 /* Canonicalize this, so it remains resolved for dylib loads. */ 1328 values.sals[0] = find_function_start_sal (sym, funfirstline); 1329 build_canonical_line_spec (values.sals, 1330 SYMBOL_NATURAL_NAME (sym), canonical); 1331 } 1332 else 1333 { 1334 /* The only match was a non-debuggable symbol, which might point 1335 to a function descriptor; resolve it to the actual code address 1336 instead. */ 1337 struct minimal_symbol *msymbol = (struct minimal_symbol *)sym_arr[0]; 1338 struct objfile *objfile = msymbol_objfile (msymbol); 1339 struct gdbarch *gdbarch = get_objfile_arch (objfile); 1340 CORE_ADDR pc = SYMBOL_VALUE_ADDRESS (msymbol); 1341 1342 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, pc, 1343 ¤t_target); 1344 1345 init_sal (&values.sals[0]); 1346 values.sals[0].pc = pc; 1347 } 1348 return values; 1349 } 1350 1351 if (i1 > 1) 1352 { 1353 /* More than one match. The user must choose one or more. */ 1354 return decode_line_2 (sym_arr, i2, funfirstline, canonical); 1355 } 1356 1357 return values; 1358 } 1359 1360 /* This handles C++ and Java compound data structures. P should point 1361 at the first component separator, i.e. double-colon or period. As 1362 an example, on entrance to this function we could have ARGPTR 1363 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */ 1364 1365 static struct symtabs_and_lines 1366 decode_compound (char **argptr, int funfirstline, 1367 struct linespec_result *canonical, struct symtab *file_symtab, 1368 char *the_real_saved_arg, char *p) 1369 { 1370 struct symtabs_and_lines values; 1371 char *p2; 1372 char *saved_arg2 = *argptr; 1373 char *temp_end; 1374 struct symbol *sym; 1375 char *copy; 1376 struct symbol *sym_class; 1377 struct type *t; 1378 char *saved_arg; 1379 1380 /* If the user specified any completer quote characters in the input, 1381 strip them. They are superfluous. */ 1382 saved_arg = alloca (strlen (the_real_saved_arg) + 1); 1383 { 1384 char *dst = saved_arg; 1385 char *src = the_real_saved_arg; 1386 char *quotes = get_gdb_completer_quote_characters (); 1387 while (*src != '\0') 1388 { 1389 if (strchr (quotes, *src) == NULL) 1390 *dst++ = *src; 1391 ++src; 1392 } 1393 *dst = '\0'; 1394 } 1395 1396 /* First check for "global" namespace specification, of the form 1397 "::foo". If found, skip over the colons and jump to normal 1398 symbol processing. I.e. the whole line specification starts with 1399 "::" (note the condition that *argptr == p). */ 1400 if (p[0] == ':' 1401 && ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t'))) 1402 saved_arg2 += 2; 1403 1404 /* Given our example "AAA::inA::fun", we have two cases to consider: 1405 1406 1) AAA::inA is the name of a class. In that case, presumably it 1407 has a method called "fun"; we then look up that method using 1408 find_method. 1409 1410 2) AAA::inA isn't the name of a class. In that case, either the 1411 user made a typo, AAA::inA is the name of a namespace, or it is 1412 the name of a minimal symbol. 1413 We just look up AAA::inA::fun with lookup_symbol. If that fails, 1414 try lookup_minimal_symbol. 1415 1416 Thus, our first task is to find everything before the last set of 1417 double-colons and figure out if it's the name of a class. So we 1418 first loop through all of the double-colons. */ 1419 1420 p2 = p; /* Save for restart. */ 1421 1422 /* This is very messy. Following the example above we have now the 1423 following pointers: 1424 p -> "::inA::fun" 1425 argptr -> "AAA::inA::fun 1426 saved_arg -> "AAA::inA::fun 1427 saved_arg2 -> "AAA::inA::fun 1428 p2 -> "::inA::fun". */ 1429 1430 /* In the loop below, with these strings, we'll make 2 passes, each 1431 is marked in comments. */ 1432 1433 while (1) 1434 { 1435 static char *break_characters = " \t("; 1436 1437 /* Move pointer up to next possible class/namespace token. */ 1438 1439 p = p2 + 1; /* Restart with old value +1. */ 1440 1441 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun", 1442 i.e. if there is a double-colon, p will now point to the 1443 second colon. */ 1444 /* PASS2: p2->"::fun", p->":fun" */ 1445 1446 /* Move pointer ahead to next double-colon. */ 1447 while (*p 1448 && strchr (break_characters, *p) == NULL 1449 && strchr (get_gdb_completer_quote_characters (), *p) == NULL) 1450 { 1451 if (current_language->la_language == language_cplus) 1452 p += cp_validate_operator (p); 1453 1454 if (p[0] == '<') 1455 { 1456 temp_end = find_template_name_end (p); 1457 if (!temp_end) 1458 error (_("malformed template specification in command")); 1459 p = temp_end; 1460 } 1461 /* Note that, since, at the start of this loop, p would be 1462 pointing to the second colon in a double-colon, we only 1463 satisfy the condition below if there is another 1464 double-colon to the right (after). I.e. there is another 1465 component that can be a class or a namespace. I.e, if at 1466 the beginning of this loop (PASS1), we had 1467 p->":inA::fun", we'll trigger this when p has been 1468 advanced to point to "::fun". */ 1469 /* PASS2: we will not trigger this. */ 1470 else if ((p[0] == ':') && (p[1] == ':')) 1471 break; /* Found double-colon. */ 1472 else 1473 { 1474 /* PASS2: We'll keep getting here, until P points to one of the 1475 break characters, at which point we exit this loop. */ 1476 if (*p) 1477 { 1478 if (p[1] == '(' 1479 && strncmp (&p[1], CP_ANONYMOUS_NAMESPACE_STR, 1480 CP_ANONYMOUS_NAMESPACE_LEN) == 0) 1481 p += CP_ANONYMOUS_NAMESPACE_LEN; 1482 else if (strchr (break_characters, *p) == NULL) 1483 ++p; 1484 } 1485 } 1486 } 1487 1488 if (*p != ':') 1489 break; /* Out of the while (1). This would happen 1490 for instance if we have looked up 1491 unsuccessfully all the components of the 1492 string, and p->""(PASS2). */ 1493 1494 /* We get here if p points to one of the break characters or "" (i.e., 1495 string ended). */ 1496 /* Save restart for next time around. */ 1497 p2 = p; 1498 /* Restore argptr as it was on entry to this function. */ 1499 *argptr = saved_arg2; 1500 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun", 1501 p2->"::fun". */ 1502 1503 /* All ready for next pass through the loop. */ 1504 } /* while (1) */ 1505 1506 1507 /* Start of lookup in the symbol tables. */ 1508 1509 /* Lookup in the symbol table the substring between argptr and 1510 p. Note, this call changes the value of argptr. */ 1511 /* Before the call, argptr->"AAA::inA::fun", 1512 p->"", p2->"::fun". After the call: argptr->"fun", p, p2 1513 unchanged. */ 1514 sym_class = lookup_prefix_sym (argptr, p2, file_symtab); 1515 1516 /* If sym_class has been found, and if "AAA::inA" is a class, then 1517 we're in case 1 above. So we look up "fun" as a method of that 1518 class. */ 1519 if (sym_class && 1520 (t = check_typedef (SYMBOL_TYPE (sym_class)), 1521 (TYPE_CODE (t) == TYPE_CODE_STRUCT 1522 || TYPE_CODE (t) == TYPE_CODE_UNION))) 1523 { 1524 /* Arg token is not digits => try it as a function name. 1525 Find the next token (everything up to end or next 1526 blank). */ 1527 if (**argptr 1528 && strchr (get_gdb_completer_quote_characters (), 1529 **argptr) != NULL) 1530 { 1531 p = skip_quoted (*argptr); 1532 *argptr = *argptr + 1; 1533 } 1534 else 1535 { 1536 /* At this point argptr->"fun". */ 1537 char *a; 1538 1539 p = *argptr; 1540 while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':' 1541 && *p != '(') 1542 p++; 1543 /* At this point p->"". String ended. */ 1544 /* Nope, C++ operators could have spaces in them 1545 ("foo::operator <" or "foo::operator delete []"). 1546 I apologize, this is a bit hacky... */ 1547 if (current_language->la_language == language_cplus 1548 && *p == ' ' && p - 8 - *argptr + 1 > 0) 1549 { 1550 /* The above loop has already swallowed "operator". */ 1551 p += cp_validate_operator (p - 8) - 8; 1552 } 1553 1554 /* Keep any important naming information. */ 1555 p = keep_name_info (p, 1); 1556 } 1557 1558 /* Allocate our own copy of the substring between argptr and 1559 p. */ 1560 copy = (char *) alloca (p - *argptr + 1); 1561 memcpy (copy, *argptr, p - *argptr); 1562 copy[p - *argptr] = '\0'; 1563 if (p != *argptr 1564 && copy[p - *argptr - 1] 1565 && strchr (get_gdb_completer_quote_characters (), 1566 copy[p - *argptr - 1]) != NULL) 1567 copy[p - *argptr - 1] = '\0'; 1568 1569 /* At this point copy->"fun", p->"". */ 1570 1571 /* No line number may be specified. */ 1572 while (*p == ' ' || *p == '\t') 1573 p++; 1574 *argptr = p; 1575 /* At this point arptr->"". */ 1576 1577 /* Look for copy as a method of sym_class. */ 1578 /* At this point copy->"fun", sym_class is "AAA:inA", 1579 saved_arg->"AAA::inA::fun". This concludes the scanning of 1580 the string for possible components matches. If we find it 1581 here, we return. If not, and we are at the and of the string, 1582 we'll lookup the whole string in the symbol tables. */ 1583 1584 return find_method (funfirstline, canonical, saved_arg, copy, t, 1585 sym_class, file_symtab); 1586 } /* End if symbol found. */ 1587 1588 1589 /* We couldn't find a class, so we're in case 2 above. We check the 1590 entire name as a symbol instead. */ 1591 1592 p = keep_name_info (p, 1); 1593 1594 copy = (char *) alloca (p - saved_arg2 + 1); 1595 memcpy (copy, saved_arg2, p - saved_arg2); 1596 /* Note: if is_quoted should be true, we snuff out quote here 1597 anyway. */ 1598 copy[p - saved_arg2] = '\000'; 1599 /* Set argptr to skip over the name. */ 1600 *argptr = (*p == '\'') ? p + 1 : p; 1601 1602 /* Look up entire name. */ 1603 sym = lookup_symbol (copy, get_selected_block (0), VAR_DOMAIN, 0); 1604 if (sym) 1605 return symbol_found (funfirstline, canonical, copy, sym, NULL, NULL); 1606 else 1607 { 1608 struct minimal_symbol *msym; 1609 1610 /* Couldn't find any interpretation as classes/namespaces. As a last 1611 resort, try the minimal symbol tables. */ 1612 msym = lookup_minimal_symbol (copy, NULL, NULL); 1613 if (msym != NULL) 1614 return minsym_found (funfirstline, msym); 1615 } 1616 1617 /* Couldn't find a minimal symbol, either, so give up. */ 1618 cplusplus_error (the_real_saved_arg, 1619 "Can't find member of namespace, " 1620 "class, struct, or union named \"%s\"\n", 1621 copy); 1622 } 1623 1624 /* Next come some helper functions for decode_compound. */ 1625 1626 /* Return the symbol corresponding to the substring of *ARGPTR ending 1627 at P, allowing whitespace. Also, advance *ARGPTR past the symbol 1628 name in question, the compound object separator ("::" or "."), and 1629 whitespace. Note that *ARGPTR is changed whether or not the 1630 lookup_symbol call finds anything (i.e we return NULL). As an 1631 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */ 1632 1633 static struct symbol * 1634 lookup_prefix_sym (char **argptr, char *p, struct symtab *file_symtab) 1635 { 1636 char *p1; 1637 char *copy; 1638 struct symbol *sym; 1639 1640 /* Extract the class name. */ 1641 p1 = p; 1642 while (p != *argptr && p[-1] == ' ') 1643 --p; 1644 copy = (char *) alloca (p - *argptr + 1); 1645 memcpy (copy, *argptr, p - *argptr); 1646 copy[p - *argptr] = 0; 1647 1648 /* Discard the class name from the argptr. */ 1649 p = p1 + (p1[0] == ':' ? 2 : 1); 1650 while (*p == ' ' || *p == '\t') 1651 p++; 1652 *argptr = p; 1653 1654 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA", 1655 argptr->"inA::fun". */ 1656 1657 sym = lookup_symbol (copy, get_search_block (file_symtab), STRUCT_DOMAIN, 0); 1658 if (sym == NULL) 1659 { 1660 /* Typedefs are in VAR_DOMAIN so the above symbol lookup will 1661 fail when the user attempts to lookup a method of a class 1662 via a typedef'd name (NOT via the class's name, which is already 1663 handled in symbol_matches_domain). So try the lookup again 1664 using VAR_DOMAIN (where typedefs live) and double-check that we 1665 found a struct/class type. */ 1666 struct symbol *s = lookup_symbol (copy, 0, VAR_DOMAIN, 0); 1667 1668 if (s != NULL) 1669 { 1670 struct type *t = SYMBOL_TYPE (s); 1671 1672 CHECK_TYPEDEF (t); 1673 if (TYPE_CODE (t) == TYPE_CODE_STRUCT) 1674 return s; 1675 } 1676 } 1677 1678 return sym; 1679 } 1680 1681 /* This finds the method COPY in the class whose type is T and whose 1682 symbol is SYM_CLASS. */ 1683 1684 static struct symtabs_and_lines 1685 find_method (int funfirstline, struct linespec_result *canonical, 1686 char *saved_arg, 1687 char *copy, struct type *t, struct symbol *sym_class, 1688 struct symtab *file_symtab) 1689 { 1690 struct symtabs_and_lines values; 1691 struct symbol *sym = NULL; 1692 int i1; /* Counter for the symbol array. */ 1693 struct symbol **sym_arr = alloca (total_number_of_methods (t) 1694 * sizeof (struct symbol *)); 1695 1696 /* Find all methods with a matching name, and put them in 1697 sym_arr. */ 1698 1699 i1 = find_methods (t, copy, SYMBOL_LANGUAGE (sym_class), sym_arr, 1700 file_symtab); 1701 1702 /* If we were given a specific overload instance in COPY, defer the field 1703 acceptance till the strcmp_iw verification below, even if we found just 1704 a single field with that name. */ 1705 if (i1 == 1 && strchr (copy, '(') == NULL) 1706 { 1707 /* There is exactly one field with that name. */ 1708 sym = sym_arr[0]; 1709 1710 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK) 1711 { 1712 values.sals = (struct symtab_and_line *) 1713 xmalloc (sizeof (struct symtab_and_line)); 1714 values.nelts = 1; 1715 values.sals[0] = find_function_start_sal (sym, 1716 funfirstline); 1717 } 1718 else 1719 { 1720 values.sals = NULL; 1721 values.nelts = 0; 1722 } 1723 return values; 1724 } 1725 if (i1 > 0) 1726 { 1727 /* If we were given a specific overload instance, use that 1728 (or error if no matches were found). Otherwise ask the user 1729 which one to use. */ 1730 if (strchr (copy, '(')) 1731 { 1732 int i; 1733 char *name; 1734 char *canon; 1735 struct cleanup *cleanup; 1736 1737 /* Construct the proper search name based on SYM_CLASS and COPY. 1738 SAVED_ARG may contain a valid name, but that name might not be 1739 what is actually stored in the symbol table. For example, 1740 if SAVED_ARG (and SYM_CLASS) were found via an import 1741 ("using namespace" in C++), then the physname of 1742 SYM_CLASS ("A::myclass") may not be the same as SAVED_ARG 1743 ("myclass"). */ 1744 name = xmalloc (strlen (SYMBOL_NATURAL_NAME (sym_class)) 1745 + 2 /* "::" */ + strlen (copy) + 1); 1746 strcpy (name, SYMBOL_NATURAL_NAME (sym_class)); 1747 strcat (name, "::"); 1748 strcat (name, copy); 1749 canon = cp_canonicalize_string (name); 1750 if (canon != NULL) 1751 { 1752 xfree (name); 1753 name = canon; 1754 } 1755 cleanup = make_cleanup (xfree, name); 1756 1757 for (i = 0; i < i1; ++i) 1758 { 1759 if (strcmp_iw (name, SYMBOL_LINKAGE_NAME (sym_arr[i])) == 0) 1760 { 1761 values.sals = (struct symtab_and_line *) 1762 xmalloc (sizeof (struct symtab_and_line)); 1763 values.nelts = 1; 1764 values.sals[0] = find_function_start_sal (sym_arr[i], 1765 funfirstline); 1766 do_cleanups (cleanup); 1767 return values; 1768 } 1769 } 1770 1771 cplusplus_error (saved_arg, _("the class `%s' does not have " 1772 "any method instance named %s"), 1773 SYMBOL_PRINT_NAME (sym_class), copy); 1774 } 1775 1776 return decode_line_2 (sym_arr, i1, funfirstline, canonical); 1777 } 1778 else 1779 { 1780 if (copy[0] == '~') 1781 cplusplus_error (saved_arg, 1782 "the class `%s' does not have destructor defined\n", 1783 SYMBOL_PRINT_NAME (sym_class)); 1784 else 1785 cplusplus_error (saved_arg, 1786 "the class %s does not have any method named %s\n", 1787 SYMBOL_PRINT_NAME (sym_class), copy); 1788 } 1789 } 1790 1791 1792 1793 /* Return the symtab associated to the filename given by the substring 1794 of *ARGPTR ending at P, and advance ARGPTR past that filename. */ 1795 1796 static struct symtab * 1797 symtab_from_filename (char **argptr, char *p, int is_quote_enclosed) 1798 { 1799 char *p1; 1800 char *copy; 1801 struct symtab *file_symtab; 1802 1803 p1 = p; 1804 while (p != *argptr && p[-1] == ' ') 1805 --p; 1806 if ((*p == '"') && is_quote_enclosed) 1807 --p; 1808 copy = (char *) alloca (p - *argptr + 1); 1809 memcpy (copy, *argptr, p - *argptr); 1810 /* It may have the ending quote right after the file name. */ 1811 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"') 1812 || copy[p - *argptr - 1] == '\'') 1813 copy[p - *argptr - 1] = 0; 1814 else 1815 copy[p - *argptr] = 0; 1816 1817 /* Find that file's data. */ 1818 file_symtab = lookup_symtab (copy); 1819 if (file_symtab == 0) 1820 { 1821 if (!have_full_symbols () && !have_partial_symbols ()) 1822 throw_error (NOT_FOUND_ERROR, 1823 _("No symbol table is loaded. " 1824 "Use the \"file\" command.")); 1825 throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy); 1826 } 1827 1828 /* Discard the file name from the arg. */ 1829 p = p1 + 1; 1830 while (*p == ' ' || *p == '\t') 1831 p++; 1832 *argptr = p; 1833 1834 return file_symtab; 1835 } 1836 1837 /* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR 1838 and return the symbol. If not found, return NULL. */ 1839 1840 static struct symbol * 1841 find_function_symbol (char **argptr, char *p, int is_quote_enclosed) 1842 { 1843 char *p1; 1844 char *copy; 1845 struct symbol *function_symbol; 1846 1847 p1 = p; 1848 while (p != *argptr && p[-1] == ' ') 1849 --p; 1850 if ((*p == '"') && is_quote_enclosed) 1851 --p; 1852 copy = (char *) alloca (p - *argptr + 1); 1853 memcpy (copy, *argptr, p - *argptr); 1854 /* It may have the ending quote right after the file name. */ 1855 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"') 1856 || copy[p - *argptr - 1] == '\'') 1857 copy[p - *argptr - 1] = 0; 1858 else 1859 copy[p - *argptr] = 0; 1860 1861 function_symbol = lookup_symbol (copy, get_selected_block (0), 1862 VAR_DOMAIN, 0); 1863 if (!function_symbol || SYMBOL_CLASS (function_symbol) != LOC_BLOCK) 1864 return NULL; 1865 1866 /* Discard the file name from the arg. */ 1867 p = p1 + 1; 1868 while (*p == ' ' || *p == '\t') 1869 p++; 1870 *argptr = p; 1871 1872 return function_symbol; 1873 } 1874 1875 1876 1877 /* This decodes a line where the argument is all digits (possibly 1878 preceded by a sign). Q should point to the end of those digits; 1879 the other arguments are as usual. */ 1880 1881 static struct symtabs_and_lines 1882 decode_all_digits (char **argptr, struct symtab *default_symtab, 1883 int default_line, struct linespec_result *canonical, 1884 struct symtab *file_symtab, char *q) 1885 1886 { 1887 struct symtabs_and_lines values; 1888 struct symtab_and_line val; 1889 1890 enum sign 1891 { 1892 none, plus, minus 1893 } 1894 sign = none; 1895 1896 /* We might need a canonical line spec if no file was specified. */ 1897 int need_canonical = (file_symtab == NULL) ? 1 : 0; 1898 1899 init_sal (&val); 1900 1901 val.pspace = current_program_space; 1902 1903 /* This is where we need to make sure that we have good defaults. 1904 We must guarantee that this section of code is never executed 1905 when we are called with just a function name, since 1906 set_default_source_symtab_and_line uses 1907 select_source_symtab that calls us with such an argument. */ 1908 1909 if (file_symtab == 0 && default_symtab == 0) 1910 { 1911 /* Make sure we have at least a default source file. */ 1912 set_default_source_symtab_and_line (); 1913 initialize_defaults (&default_symtab, &default_line); 1914 } 1915 1916 if (**argptr == '+') 1917 sign = plus, (*argptr)++; 1918 else if (**argptr == '-') 1919 sign = minus, (*argptr)++; 1920 val.line = atoi (*argptr); 1921 switch (sign) 1922 { 1923 case plus: 1924 if (q == *argptr) 1925 val.line = 5; 1926 if (file_symtab == 0) 1927 val.line = default_line + val.line; 1928 break; 1929 case minus: 1930 if (q == *argptr) 1931 val.line = 15; 1932 if (file_symtab == 0) 1933 val.line = default_line - val.line; 1934 else 1935 val.line = 1; 1936 break; 1937 case none: 1938 break; /* No need to adjust val.line. */ 1939 } 1940 1941 while (*q == ' ' || *q == '\t') 1942 q++; 1943 *argptr = q; 1944 if (file_symtab == 0) 1945 file_symtab = default_symtab; 1946 1947 /* It is possible that this source file has more than one symtab, 1948 and that the new line number specification has moved us from the 1949 default (in file_symtab) to a new one. */ 1950 val.symtab = find_line_symtab (file_symtab, val.line, NULL, NULL); 1951 if (val.symtab == 0) 1952 val.symtab = file_symtab; 1953 1954 val.pspace = SYMTAB_PSPACE (val.symtab); 1955 val.pc = 0; 1956 values.sals = (struct symtab_and_line *) 1957 xmalloc (sizeof (struct symtab_and_line)); 1958 values.sals[0] = val; 1959 values.nelts = 1; 1960 if (need_canonical) 1961 build_canonical_line_spec (values.sals, NULL, canonical); 1962 values.sals[0].explicit_line = 1; 1963 return values; 1964 } 1965 1966 1967 1968 /* Decode a linespec starting with a dollar sign. */ 1969 1970 static struct symtabs_and_lines 1971 decode_dollar (char *copy, int funfirstline, struct symtab *default_symtab, 1972 struct linespec_result *canonical, struct symtab *file_symtab) 1973 { 1974 LONGEST valx; 1975 int index = 0; 1976 int need_canonical = 0; 1977 struct symtabs_and_lines values; 1978 struct symtab_and_line val; 1979 char *p; 1980 struct symbol *sym; 1981 struct minimal_symbol *msymbol; 1982 1983 p = (copy[1] == '$') ? copy + 2 : copy + 1; 1984 while (*p >= '0' && *p <= '9') 1985 p++; 1986 if (!*p) /* Reached end of token without hitting non-digit. */ 1987 { 1988 /* We have a value history reference. */ 1989 struct value *val_history; 1990 1991 sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index); 1992 val_history = access_value_history ((copy[1] == '$') ? -index : index); 1993 if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT) 1994 error (_("History values used in line " 1995 "specs must have integer values.")); 1996 valx = value_as_long (val_history); 1997 } 1998 else 1999 { 2000 /* Not all digits -- may be user variable/function or a 2001 convenience variable. */ 2002 2003 /* Look up entire name as a symbol first. */ 2004 sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0); 2005 file_symtab = (struct symtab *) NULL; 2006 need_canonical = 1; 2007 /* Symbol was found --> jump to normal symbol processing. */ 2008 if (sym) 2009 return symbol_found (funfirstline, canonical, copy, sym, NULL, NULL); 2010 2011 /* If symbol was not found, look in minimal symbol tables. */ 2012 msymbol = lookup_minimal_symbol (copy, NULL, NULL); 2013 /* Min symbol was found --> jump to minsym processing. */ 2014 if (msymbol) 2015 return minsym_found (funfirstline, msymbol); 2016 2017 /* Not a user variable or function -- must be convenience variable. */ 2018 if (!get_internalvar_integer (lookup_internalvar (copy + 1), &valx)) 2019 error (_("Convenience variables used in line " 2020 "specs must have integer values.")); 2021 } 2022 2023 init_sal (&val); 2024 2025 /* Either history value or convenience value from above, in valx. */ 2026 val.symtab = file_symtab ? file_symtab : default_symtab; 2027 val.line = valx; 2028 val.pc = 0; 2029 val.pspace = current_program_space; 2030 2031 values.sals = (struct symtab_and_line *) xmalloc (sizeof val); 2032 values.sals[0] = val; 2033 values.nelts = 1; 2034 2035 if (need_canonical) 2036 build_canonical_line_spec (values.sals, NULL, canonical); 2037 2038 return values; 2039 } 2040 2041 2042 2043 /* A helper for decode_line_1 that tries to find a label. The label 2044 is searched for in the current block. 2045 FUNCTION_SYMBOL is the enclosing function; or NULL if none 2046 specified. 2047 COPY is the name of the label to find. 2048 CANONICAL is the same as the "canonical" argument to decode_line_1. 2049 RESULT is a pointer to a symtabs_and_lines structure which will be 2050 filled in on success. 2051 This function returns 1 if a label was found, 0 otherwise. */ 2052 2053 static int 2054 decode_label (struct symbol *function_symbol, char *copy, 2055 struct linespec_result *canonical, 2056 struct symtabs_and_lines *result) 2057 { 2058 struct symbol *sym; 2059 struct block *block; 2060 2061 if (function_symbol) 2062 block = SYMBOL_BLOCK_VALUE (function_symbol); 2063 else 2064 { 2065 block = get_selected_block (0); 2066 for (; 2067 block && !BLOCK_FUNCTION (block); 2068 block = BLOCK_SUPERBLOCK (block)) 2069 ; 2070 if (!block) 2071 return 0; 2072 function_symbol = BLOCK_FUNCTION (block); 2073 } 2074 2075 sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0); 2076 2077 if (sym != NULL) 2078 *result = symbol_found (0, canonical, copy, sym, NULL, function_symbol); 2079 2080 return sym != NULL; 2081 } 2082 2083 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL, 2084 look in that symtab's static variables first. */ 2085 2086 static struct symtabs_and_lines 2087 decode_variable (char *copy, int funfirstline, 2088 struct linespec_result *canonical, 2089 struct symtab *file_symtab) 2090 { 2091 struct symbol *sym; 2092 struct minimal_symbol *msymbol; 2093 2094 sym = lookup_symbol (copy, get_search_block (file_symtab), 2095 VAR_DOMAIN, 0); 2096 2097 if (sym != NULL) 2098 return symbol_found (funfirstline, canonical, copy, sym, file_symtab, NULL); 2099 2100 msymbol = lookup_minimal_symbol (copy, NULL, NULL); 2101 2102 if (msymbol != NULL) 2103 return minsym_found (funfirstline, msymbol); 2104 2105 if (!have_full_symbols () 2106 && !have_partial_symbols () 2107 && !have_minimal_symbols ()) 2108 throw_error (NOT_FOUND_ERROR, 2109 _("No symbol table is loaded. Use the \"file\" command.")); 2110 throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined."), copy); 2111 } 2112 2113 2114 2115 2116 /* Now come some functions that are called from multiple places within 2117 decode_line_1. */ 2118 2119 /* We've found a symbol SYM to associate with our linespec; build a 2120 corresponding struct symtabs_and_lines. */ 2121 2122 static struct symtabs_and_lines 2123 symbol_found (int funfirstline, struct linespec_result *canonical, char *copy, 2124 struct symbol *sym, struct symtab *file_symtab, 2125 struct symbol *function_symbol) 2126 { 2127 struct symtabs_and_lines values; 2128 2129 if (SYMBOL_CLASS (sym) == LOC_BLOCK) 2130 { 2131 /* Arg is the name of a function. */ 2132 values.sals = (struct symtab_and_line *) 2133 xmalloc (sizeof (struct symtab_and_line)); 2134 values.sals[0] = find_function_start_sal (sym, funfirstline); 2135 values.nelts = 1; 2136 2137 /* Don't use the SYMBOL_LINE; if used at all it points to 2138 the line containing the parameters or thereabouts, not 2139 the first line of code. */ 2140 2141 /* We might need a canonical line spec if it is a static 2142 function. */ 2143 if (file_symtab == 0) 2144 { 2145 struct blockvector *bv = BLOCKVECTOR (SYMBOL_SYMTAB (sym)); 2146 struct block *b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); 2147 2148 if (lookup_block_symbol (b, copy, VAR_DOMAIN) != NULL) 2149 build_canonical_line_spec (values.sals, copy, canonical); 2150 } 2151 return values; 2152 } 2153 else 2154 { 2155 if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0) 2156 { 2157 /* We know its line number. */ 2158 values.sals = (struct symtab_and_line *) 2159 xmalloc (sizeof (struct symtab_and_line)); 2160 values.nelts = 1; 2161 init_sal (&values.sals[0]); 2162 values.sals[0].symtab = SYMBOL_SYMTAB (sym); 2163 values.sals[0].line = SYMBOL_LINE (sym); 2164 values.sals[0].pc = SYMBOL_VALUE_ADDRESS (sym); 2165 values.sals[0].pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)); 2166 values.sals[0].explicit_pc = 1; 2167 2168 if (canonical) 2169 { 2170 canonical->special_display = 1; 2171 canonical->canonical = xmalloc (sizeof (char *)); 2172 canonical->canonical[0] 2173 = xstrprintf ("%s:%s", 2174 SYMBOL_NATURAL_NAME (function_symbol), 2175 SYMBOL_NATURAL_NAME (sym)); 2176 } 2177 2178 return values; 2179 } 2180 else if (funfirstline) 2181 { 2182 /* NOT_FOUND_ERROR is not correct but it ensures COPY will be 2183 searched also as a minimal symbol. */ 2184 2185 throw_error (NOT_FOUND_ERROR, _("\"%s\" is not a function"), copy); 2186 } 2187 else if (SYMBOL_LINE (sym) != 0) 2188 { 2189 /* We know its line number. */ 2190 values.sals = (struct symtab_and_line *) 2191 xmalloc (sizeof (struct symtab_and_line)); 2192 values.nelts = 1; 2193 memset (&values.sals[0], 0, sizeof (values.sals[0])); 2194 values.sals[0].symtab = SYMBOL_SYMTAB (sym); 2195 values.sals[0].line = SYMBOL_LINE (sym); 2196 values.sals[0].pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)); 2197 return values; 2198 } 2199 else 2200 /* This can happen if it is compiled with a compiler which doesn't 2201 put out line numbers for variables. */ 2202 /* FIXME: Shouldn't we just set .line and .symtab to zero 2203 and return? For example, "info line foo" could print 2204 the address. */ 2205 error (_("Line number not known for symbol \"%s\""), copy); 2206 } 2207 } 2208 2209 /* We've found a minimal symbol MSYMBOL to associate with our 2210 linespec; build a corresponding struct symtabs_and_lines. */ 2211 2212 static struct symtabs_and_lines 2213 minsym_found (int funfirstline, struct minimal_symbol *msymbol) 2214 { 2215 struct objfile *objfile = msymbol_objfile (msymbol); 2216 struct gdbarch *gdbarch = get_objfile_arch (objfile); 2217 struct symtabs_and_lines values; 2218 CORE_ADDR pc; 2219 2220 values.sals = (struct symtab_and_line *) 2221 xmalloc (sizeof (struct symtab_and_line)); 2222 values.sals[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol), 2223 (struct obj_section *) 0, 0); 2224 values.sals[0].section = SYMBOL_OBJ_SECTION (msymbol); 2225 2226 /* The minimal symbol might point to a function descriptor; 2227 resolve it to the actual code address instead. */ 2228 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, 2229 values.sals[0].pc, 2230 ¤t_target); 2231 if (pc != values.sals[0].pc) 2232 values.sals[0] = find_pc_sect_line (pc, NULL, 0); 2233 2234 if (funfirstline) 2235 skip_prologue_sal (&values.sals[0]); 2236 2237 values.nelts = 1; 2238 return values; 2239 } 2240 2241 void 2242 init_linespec_result (struct linespec_result *lr) 2243 { 2244 memset (lr, 0, sizeof (*lr)); 2245 } 2246