1 /* Parser for linespec for the GNU debugger, GDB.
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 Free Software Foundation, Inc.
7 This file is part of GDB.
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.
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.
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/>. */
31 #include "completer.h"
33 #include "cp-support.h"
34 #include "parser-defs.h"
36 #include "objc-lang.h"
38 #include "exceptions.h"
41 #include "mi/mi-cmds.h"
43 #include "arch-utils.h"
45 /* We share this one with symtab.c, but it is not exported widely. */
47 extern char *operator_chars (char *, char **);
49 /* Prototypes for local functions */
51 static void initialize_defaults (struct symtab **default_symtab,
54 static struct symtabs_and_lines decode_indirect (char **argptr);
56 static char *locate_first_half (char **argptr, int *is_quote_enclosed);
58 static struct symtabs_and_lines decode_objc (char **argptr,
60 struct symtab *file_symtab,
64 static struct symtabs_and_lines decode_compound (char **argptr,
71 static struct symbol *lookup_prefix_sym (char **argptr, char *p);
73 static struct symtabs_and_lines find_method (int funfirstline,
78 struct symbol *sym_class,
81 static void cplusplus_error (const char *name, const char *fmt, ...)
82 ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 3);
84 static int total_number_of_methods (struct type *type);
86 static int find_methods (struct type *, char *,
87 enum language, struct symbol **);
89 static int add_matching_methods (int method_counter, struct type *t,
90 enum language language,
91 struct symbol **sym_arr);
93 static int add_constructors (int method_counter, struct type *t,
94 enum language language,
95 struct symbol **sym_arr);
97 static void build_canonical_line_spec (struct symtab_and_line *,
100 static char *find_toplevel_char (char *s, char c);
102 static int is_objc_method_format (const char *s);
104 static struct symtabs_and_lines decode_line_2 (struct symbol *[],
107 static struct symtab *symtab_from_filename (char **argptr,
108 char *p, int is_quote_enclosed,
112 symtabs_and_lines decode_all_digits (char **argptr,
113 struct symtab *default_symtab,
116 struct symtab *file_symtab,
119 static struct symtabs_and_lines decode_dollar (char *copy,
121 struct symtab *default_symtab,
123 struct symtab *file_symtab);
125 static struct symtabs_and_lines decode_variable (char *copy,
128 struct symtab *file_symtab,
132 symtabs_and_lines symbol_found (int funfirstline,
136 struct symtab *file_symtab);
139 symtabs_and_lines minsym_found (int funfirstline,
140 struct minimal_symbol *msymbol);
142 /* Helper functions. */
144 /* Issue a helpful hint on using the command completion feature on
145 single quoted demangled C++ symbols as part of the completion
149 cplusplus_error (const char *name, const char *fmt, ...)
151 struct ui_file *tmp_stream;
153 tmp_stream = mem_fileopen ();
154 make_cleanup_ui_file_delete (tmp_stream);
158 va_start (args, fmt);
159 vfprintf_unfiltered (tmp_stream, fmt, args);
163 while (*name == '\'')
165 fprintf_unfiltered (tmp_stream,
166 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
167 "(Note leading single quote.)"),
170 message = ui_file_xstrdup (tmp_stream, NULL);
171 make_cleanup (xfree, message);
172 throw_error (NOT_FOUND_ERROR, "%s", message);
175 /* Return the number of methods described for TYPE, including the
176 methods from types it derives from. This can't be done in the symbol
177 reader because the type of the baseclass might still be stubbed
178 when the definition of the derived class is parsed. */
181 total_number_of_methods (struct type *type)
186 CHECK_TYPEDEF (type);
187 if (! HAVE_CPLUS_STRUCT (type))
189 count = TYPE_NFN_FIELDS_TOTAL (type);
191 for (n = 0; n < TYPE_N_BASECLASSES (type); n++)
192 count += total_number_of_methods (TYPE_BASECLASS (type, n));
197 /* Recursive helper function for decode_line_1.
198 Look for methods named NAME in type T.
199 Return number of matches.
200 Put matches in SYM_ARR, which should have been allocated with
201 a size of total_number_of_methods (T) * sizeof (struct symbol *).
202 Note that this function is g++ specific. */
205 find_methods (struct type *t, char *name, enum language language,
206 struct symbol **sym_arr)
210 char *class_name = type_name_no_tag (t);
212 /* Ignore this class if it doesn't have a name. This is ugly, but
213 unless we figure out how to get the physname without the name of
214 the class, then the loop can't do any good. */
216 && (lookup_symbol_in_language (class_name, (struct block *) NULL,
217 STRUCT_DOMAIN, language, (int *) NULL)))
220 int name_len = strlen (name);
224 /* Loop over each method name. At this level, all overloads of a name
225 are counted as a single name. There is an inner loop which loops over
228 for (method_counter = TYPE_NFN_FIELDS (t) - 1;
232 char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
235 if (strncmp (method_name, "__", 2) == 0 ||
236 strncmp (method_name, "op", 2) == 0 ||
237 strncmp (method_name, "type", 4) == 0)
239 if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI))
240 method_name = dem_opname;
241 else if (cplus_demangle_opname (method_name, dem_opname, 0))
242 method_name = dem_opname;
245 if (strcmp_iw (name, method_name) == 0)
246 /* Find all the overloaded methods with that name. */
247 i1 += add_matching_methods (method_counter, t, language,
249 else if (strncmp (class_name, name, name_len) == 0
250 && (class_name[name_len] == '\0'
251 || class_name[name_len] == '<'))
252 i1 += add_constructors (method_counter, t, language,
257 /* Only search baseclasses if there is no match yet, since names in
258 derived classes override those in baseclasses.
260 FIXME: The above is not true; it is only true of member functions
261 if they have the same number of arguments (??? - section 13.1 of the
262 ARM says the function members are not in the same scope but doesn't
263 really spell out the rules in a way I understand. In any case, if
264 the number of arguments differ this is a case in which we can overload
265 rather than hiding without any problem, and gcc 2.4.5 does overload
266 rather than hiding in this case). */
269 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
270 i1 += find_methods (TYPE_BASECLASS (t, ibase), name,
271 language, sym_arr + i1);
276 /* Add the symbols associated to methods of the class whose type is T
277 and whose name matches the method indexed by METHOD_COUNTER in the
278 array SYM_ARR. Return the number of methods added. */
281 add_matching_methods (int method_counter, struct type *t,
282 enum language language, struct symbol **sym_arr)
287 for (field_counter = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1;
294 f = TYPE_FN_FIELDLIST1 (t, method_counter);
296 if (TYPE_FN_FIELD_STUB (f, field_counter))
300 tmp_name = gdb_mangle_name (t,
303 phys_name = alloca (strlen (tmp_name) + 1);
304 strcpy (phys_name, tmp_name);
308 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
310 sym_arr[i1] = lookup_symbol_in_language (phys_name,
318 /* This error message gets printed, but the method
319 still seems to be found
320 fputs_filtered("(Cannot find method ", gdb_stdout);
321 fprintf_symbol_filtered (gdb_stdout, phys_name,
323 DMGL_PARAMS | DMGL_ANSI);
324 fputs_filtered(" - possibly inlined.)\n", gdb_stdout);
332 /* Add the symbols associated to constructors of the class whose type
333 is CLASS_TYPE and which are indexed by by METHOD_COUNTER to the
334 array SYM_ARR. Return the number of methods added. */
337 add_constructors (int method_counter, struct type *t,
338 enum language language, struct symbol **sym_arr)
343 /* For GCC 3.x and stabs, constructors and destructors
344 have names like __base_ctor and __complete_dtor.
345 Check the physname for now if we're looking for a
348 = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1;
355 f = TYPE_FN_FIELDLIST1 (t, method_counter);
357 /* GCC 3.x will never produce stabs stub methods, so
358 we don't need to handle this case. */
359 if (TYPE_FN_FIELD_STUB (f, field_counter))
361 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
362 if (! is_constructor_name (phys_name))
365 /* If this method is actually defined, include it in the
367 sym_arr[i1] = lookup_symbol_in_language (phys_name,
378 /* Helper function for decode_line_1.
379 Build a canonical line spec in CANONICAL if it is non-NULL and if
380 the SAL has a symtab.
381 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
382 If SYMNAME is NULL the line number from SAL is used and the canonical
383 line spec is `filename:linenum'. */
386 build_canonical_line_spec (struct symtab_and_line *sal, char *symname,
389 char **canonical_arr;
390 char *canonical_name;
392 struct symtab *s = sal->symtab;
394 if (s == (struct symtab *) NULL
395 || s->filename == (char *) NULL
396 || canonical == (char ***) NULL)
399 canonical_arr = (char **) xmalloc (sizeof (char *));
400 *canonical = canonical_arr;
402 filename = s->filename;
405 canonical_name = xmalloc (strlen (filename) + strlen (symname) + 2);
406 sprintf (canonical_name, "%s:%s", filename, symname);
410 canonical_name = xmalloc (strlen (filename) + 30);
411 sprintf (canonical_name, "%s:%d", filename, sal->line);
413 canonical_arr[0] = canonical_name;
418 /* Find an instance of the character C in the string S that is outside
419 of all parenthesis pairs, single-quoted strings, and double-quoted
420 strings. Also, ignore the char within a template name, like a ','
421 within foo<int, int>. */
424 find_toplevel_char (char *s, char c)
426 int quoted = 0; /* zero if we're not in quotes;
427 '"' if we're in a double-quoted string;
428 '\'' if we're in a single-quoted string. */
429 int depth = 0; /* Number of unclosed parens we've seen. */
432 for (scan = s; *scan; scan++)
438 else if (*scan == '\\' && *(scan + 1))
441 else if (*scan == c && ! quoted && depth == 0)
443 else if (*scan == '"' || *scan == '\'')
445 else if (*scan == '(' || *scan == '<')
447 else if ((*scan == ')' || *scan == '>') && depth > 0)
454 /* Determines if the gives string corresponds to an Objective-C method
455 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
456 are allowed to have spaces and parentheses in them. */
459 is_objc_method_format (const char *s)
461 if (s == NULL || *s == '\0')
463 /* Handle arguments with the format FILENAME:SYMBOL. */
464 if ((s[0] == ':') && (strchr ("+-", s[1]) != NULL)
465 && (s[2] == '[') && strchr(s, ']'))
467 /* Handle arguments that are just SYMBOL. */
468 else if ((strchr ("+-", s[0]) != NULL) && (s[1] == '[') && strchr(s, ']'))
473 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
474 operate on (ask user if necessary).
475 If CANONICAL is non-NULL return a corresponding array of mangled names
476 as canonical line specs there. */
478 static struct symtabs_and_lines
479 decode_line_2 (struct symbol *sym_arr[], int nelts, int funfirstline,
482 struct symtabs_and_lines values, return_values;
487 struct cleanup *old_chain;
488 char **canonical_arr = (char **) NULL;
489 const char *select_mode = multiple_symbols_select_mode ();
491 if (select_mode == multiple_symbols_cancel)
493 canceled because the command is ambiguous\n\
494 See set/show multiple-symbol."));
496 values.sals = (struct symtab_and_line *)
497 alloca (nelts * sizeof (struct symtab_and_line));
498 return_values.sals = (struct symtab_and_line *)
499 xmalloc (nelts * sizeof (struct symtab_and_line));
500 old_chain = make_cleanup (xfree, return_values.sals);
504 canonical_arr = (char **) xmalloc (nelts * sizeof (char *));
505 make_cleanup (xfree, canonical_arr);
506 memset (canonical_arr, 0, nelts * sizeof (char *));
507 *canonical = canonical_arr;
513 init_sal (&return_values.sals[i]); /* Initialize to zeroes. */
514 init_sal (&values.sals[i]);
515 if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
516 values.sals[i] = find_function_start_sal (sym_arr[i], funfirstline);
520 /* If select_mode is "all", then do not print the multiple-choice
521 menu and act as if the user had chosen choice "1" (all). */
522 if (select_mode == multiple_symbols_all
523 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
528 printf_unfiltered (_("[0] cancel\n[1] all\n"));
531 if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
533 if (values.sals[i].symtab)
534 printf_unfiltered ("[%d] %s at %s:%d\n",
536 SYMBOL_PRINT_NAME (sym_arr[i]),
537 values.sals[i].symtab->filename,
538 values.sals[i].line);
540 printf_unfiltered (_("[%d] %s at ?FILE:%d [No symtab? Probably broken debug info...]\n"),
542 SYMBOL_PRINT_NAME (sym_arr[i]),
543 values.sals[i].line);
547 printf_unfiltered (_("?HERE\n"));
551 prompt = getenv ("PS2");
556 args = command_line_input (prompt, 0, "overload-choice");
559 if (args == 0 || *args == 0)
560 error_no_arg (_("one or more choice numbers"));
568 while (*arg1 >= '0' && *arg1 <= '9')
570 if (*arg1 && *arg1 != ' ' && *arg1 != '\t')
571 error (_("Arguments must be choice numbers."));
576 error (_("canceled"));
581 for (i = 0; i < nelts; i++)
583 if (canonical_arr[i] == NULL)
585 symname = SYMBOL_LINKAGE_NAME (sym_arr[i]);
586 canonical_arr[i] = xstrdup (symname);
590 memcpy (return_values.sals, values.sals,
591 (nelts * sizeof (struct symtab_and_line)));
592 return_values.nelts = nelts;
593 discard_cleanups (old_chain);
594 return return_values;
597 if (num >= nelts + 2)
599 printf_unfiltered (_("No choice number %d.\n"), num);
604 if (values.sals[num].pc)
608 symname = SYMBOL_LINKAGE_NAME (sym_arr[num]);
609 make_cleanup (xfree, symname);
610 canonical_arr[i] = xstrdup (symname);
612 return_values.sals[i++] = values.sals[num];
613 values.sals[num].pc = 0;
617 printf_unfiltered (_("duplicate request for %d ignored.\n"), num);
622 while (*args == ' ' || *args == '\t')
625 return_values.nelts = i;
626 discard_cleanups (old_chain);
627 return return_values;
630 /* A helper function for decode_line_1 and friends which skips P
631 past any method overload information at the beginning of P, e.g.,
632 "(const struct foo *)".
634 This function assumes that P has already been validated to contain
635 overload information, and it will assert if *P != '('. */
637 find_method_overload_end (char *p)
641 gdb_assert (*p == '(');
661 /* The parser of linespec itself. */
663 /* Parse a string that specifies a line number.
664 Pass the address of a char * variable; that variable will be
665 advanced over the characters actually parsed.
669 LINENUM -- that line number in current file. PC returned is 0.
670 FILE:LINENUM -- that line in that file. PC returned is 0.
671 FUNCTION -- line number of openbrace of that function.
672 PC returned is the start of the function.
673 VARIABLE -- line number of definition of that variable.
675 FILE:FUNCTION -- likewise, but prefer functions in that file.
676 *EXPR -- line in which address EXPR appears.
678 This may all be followed by an "if EXPR", which we ignore.
680 FUNCTION may be an undebuggable function found in minimal symbol table.
682 If the argument FUNFIRSTLINE is nonzero, we want the first line
683 of real code inside a function when a function is specified, and it is
684 not OK to specify a variable or type to get its line number.
686 DEFAULT_SYMTAB specifies the file to use if none is specified.
687 It defaults to current_source_symtab.
688 DEFAULT_LINE specifies the line number to use for relative
689 line numbers (that start with signs). Defaults to current_source_line.
690 If CANONICAL is non-NULL, store an array of strings containing the canonical
691 line specs there if necessary. Currently overloaded member functions and
692 line numbers or static functions without a filename yield a canonical
693 line spec. The array and the line spec strings are allocated on the heap,
694 it is the callers responsibility to free them.
696 Note that it is possible to return zero for the symtab
697 if no file is validly specified. Callers must check that.
698 Also, the line number returned may be invalid.
700 If NOT_FOUND_PTR is not null, store a boolean true/false value at the location, based
701 on whether or not failure occurs due to an unknown function or file. In the case
702 where failure does occur due to an unknown function or file, do not issue an error
705 /* We allow single quotes in various places. This is a hideous
706 kludge, which exists because the completer can't yet deal with the
707 lack of single quotes. FIXME: write a linespec_completer which we
708 can use as appropriate instead of make_symbol_completion_list. */
710 struct symtabs_and_lines
711 decode_line_1 (char **argptr, int funfirstline, struct symtab *default_symtab,
712 int default_line, char ***canonical, int *not_found_ptr)
716 /* If a file name is specified, this is its symtab. */
717 struct symtab *file_symtab = NULL;
720 /* This says whether or not something in *ARGPTR is quoted with
721 completer_quotes (i.e. with single quotes). */
723 /* Is *ARGPTR is enclosed in double quotes? */
724 int is_quote_enclosed;
725 int is_objc_method = 0;
726 char *saved_arg = *argptr;
727 /* If IS_QUOTED, the end of the quoted bit. */
728 char *end_quote = NULL;
729 /* The "first half" of the linespec. */
735 /* Defaults have defaults. */
737 initialize_defaults (&default_symtab, &default_line);
739 /* See if arg is *PC. */
742 return decode_indirect (argptr);
745 && strchr (get_gdb_completer_quote_characters (),
748 end_quote = skip_quoted (*argptr);
750 /* Check to see if it's a multipart linespec (with colons or
753 /* Locate the end of the first half of the linespec.
754 After the call, for instance, if the argptr string is "foo.c:123"
755 p will point at "123". If there is only one part, like "foo", p
756 will point to "". If this is a C++ name, like "A::B::foo", p will
757 point to "::B::foo". Argptr is not changed by this call. */
759 first_half = p = locate_first_half (argptr, &is_quote_enclosed);
761 /* Check if this is an Objective-C method (anything that starts with
762 a '+' or '-' and a '['). */
763 if (is_objc_method_format (p))
766 /* Check if the symbol could be an Objective-C selector. */
769 struct symtabs_and_lines values;
770 values = decode_objc (argptr, funfirstline, NULL,
771 canonical, saved_arg);
772 if (values.sals != NULL)
776 /* Does it look like there actually were two parts? */
778 if (p[0] == ':' || p[0] == '.')
780 /* Is it a C++ or Java compound data structure?
781 The check on p[1] == ':' is capturing the case of "::",
782 since p[0]==':' was checked above.
783 Note that the call to decode_compound does everything
784 for us, including the lookup on the symbol table, so we
787 if (p[0] == '.' || p[1] == ':')
789 struct symtabs_and_lines values;
791 if (is_quote_enclosed)
793 values = decode_compound (argptr, funfirstline, canonical,
794 saved_arg, p, not_found_ptr);
795 if (is_quoted && **argptr == '\'')
796 *argptr = *argptr + 1;
800 /* No, the first part is a filename; set file_symtab to be that file's
801 symtab. Also, move argptr past the filename. */
803 file_symtab = symtab_from_filename (argptr, p, is_quote_enclosed,
806 /* Check for single quotes on the non-filename part. */
809 is_quoted = (**argptr
810 && strchr (get_gdb_completer_quote_characters (),
813 end_quote = skip_quoted (*argptr);
817 /* file_symtab is specified file's symtab, or 0 if no file specified.
818 arg no longer contains the file name. */
820 /* If the filename was quoted, we must re-check the quotation. */
822 if (end_quote == first_half && *end_quote!= '\0')
824 is_quoted = (**argptr
825 && strchr (get_gdb_completer_quote_characters (),
828 end_quote = skip_quoted (*argptr);
831 /* Check whether arg is all digits (and sign). */
834 if (*q == '-' || *q == '+')
836 while (*q >= '0' && *q <= '9')
839 if (q != *argptr && (*q == 0 || *q == ' ' || *q == '\t' || *q == ','))
840 /* We found a token consisting of all digits -- at least one digit. */
841 return decode_all_digits (argptr, default_symtab, default_line,
842 canonical, file_symtab, q);
844 /* Arg token is not digits => try it as a variable name
845 Find the next token (everything up to end or next whitespace). */
847 if (**argptr == '$') /* May be a convenience variable. */
848 /* One or two $ chars possible. */
849 p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1));
854 error (_("Unmatched single quote."));
856 else if (is_objc_method)
858 /* allow word separators in method names for Obj-C */
859 p = skip_quoted_chars (*argptr, NULL, "");
863 p = skip_quoted (*argptr);
866 /* Keep any template parameters */
868 p = find_template_name_end (p);
870 /* Keep method overload information. */
872 p = find_method_overload_end (p);
874 /* Make sure we keep important kewords like "const" */
875 if (strncmp (p, " const", 6) == 0)
878 copy = (char *) alloca (p - *argptr + 1);
879 memcpy (copy, *argptr, p - *argptr);
880 copy[p - *argptr] = '\0';
883 && copy[0] == copy[p - *argptr - 1]
884 && strchr (get_gdb_completer_quote_characters (), copy[0]) != NULL)
886 copy[p - *argptr - 1] = '\0';
890 copy[p - *argptr - 1] = '\0';
891 while (*p == ' ' || *p == '\t')
895 /* If it starts with $: may be a legitimate variable or routine name
896 (e.g. HP-UX millicode routines such as $$dyncall), or it may
897 be history value, or it may be a convenience variable. */
900 return decode_dollar (copy, funfirstline, default_symtab,
901 canonical, file_symtab);
903 /* Look up that token as a variable.
904 If file specified, use that file's per-file block to start with. */
906 return decode_variable (copy, funfirstline, canonical,
907 file_symtab, not_found_ptr);
912 /* Now, more helper functions for decode_line_1. Some conventions
913 that these functions follow:
915 Decode_line_1 typically passes along some of its arguments or local
916 variables to the subfunctions. It passes the variables by
917 reference if they are modified by the subfunction, and by value
920 Some of the functions have side effects that don't arise from
921 variables that are passed by reference. In particular, if a
922 function is passed ARGPTR as an argument, it modifies what ARGPTR
923 points to; typically, it advances *ARGPTR past whatever substring
924 it has just looked at. (If it doesn't modify *ARGPTR, then the
925 function gets passed *ARGPTR instead, which is then called ARG.)
926 Also, functions that return a struct symtabs_and_lines may modify
927 CANONICAL, as in the description of decode_line_1.
929 If a function returns a struct symtabs_and_lines, then that struct
930 will immediately make its way up the call chain to be returned by
931 decode_line_1. In particular, all of the functions decode_XXX
932 calculate the appropriate struct symtabs_and_lines, under the
933 assumption that their argument is of the form XXX. */
935 /* First, some functions to initialize stuff at the beggining of the
939 initialize_defaults (struct symtab **default_symtab, int *default_line)
941 if (*default_symtab == 0)
943 /* Use whatever we have for the default source line. We don't use
944 get_current_or_default_symtab_and_line as it can recurse and call
946 struct symtab_and_line cursal =
947 get_current_source_symtab_and_line ();
949 *default_symtab = cursal.symtab;
950 *default_line = cursal.line;
956 /* Decode arg of the form *PC. */
958 static struct symtabs_and_lines
959 decode_indirect (char **argptr)
961 struct symtabs_and_lines values;
965 pc = parse_and_eval_address_1 (argptr);
967 values.sals = (struct symtab_and_line *)
968 xmalloc (sizeof (struct symtab_and_line));
971 values.sals[0] = find_pc_line (pc, 0);
972 values.sals[0].pc = pc;
973 values.sals[0].section = find_pc_overlay (pc);
974 values.sals[0].explicit_pc = 1;
981 /* Locate the first half of the linespec, ending in a colon, period,
982 or whitespace. (More or less.) Also, check to see if *ARGPTR is
983 enclosed in double quotes; if so, set is_quote_enclosed, advance
984 ARGPTR past that and zero out the trailing double quote.
985 If ARGPTR is just a simple name like "main", p will point to ""
989 locate_first_half (char **argptr, int *is_quote_enclosed)
995 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
996 and we must isolate the first half. Outer layers will call again later
999 Don't count commas that appear in argument lists of overloaded
1000 functions, or in quoted strings. It's stupid to go to this much
1001 trouble when the rest of the function is such an obvious roach hotel. */
1002 ii = find_toplevel_char (*argptr, ',');
1003 has_comma = (ii != 0);
1005 /* Temporarily zap out second half to not confuse the code below.
1006 This is undone below. Do not change ii!! */
1012 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
1013 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
1019 *is_quote_enclosed = 1;
1025 *is_quote_enclosed = 0;
1026 if (strchr (get_gdb_completer_quote_characters (), *p))
1036 char *temp_end = find_template_name_end (p);
1038 error (_("malformed template specification in command"));
1041 /* Check for a colon and a plus or minus and a [ (which
1042 indicates an Objective-C method) */
1043 if (is_objc_method_format (p))
1047 /* Check for the end of the first half of the linespec. End of
1048 line, a tab, a double colon or the last single colon, or a
1049 space. But if enclosed in double quotes we do not break on
1054 && ((p[1] == ':') || (strchr (p + 1, ':') == NULL)))
1055 || ((p[0] == ' ') && !*is_quote_enclosed))
1057 if (p[0] == '.' && strchr (p, ':') == NULL)
1059 /* Java qualified method. Find the *last* '.', since the
1060 others are package qualifiers. Stop at any open parenthesis
1061 which might provide overload information. */
1062 for (p1 = p; *p1 && *p1 != '('; p1++)
1070 while (p[0] == ' ' || p[0] == '\t')
1073 /* If the closing double quote was left at the end, remove it. */
1074 if (*is_quote_enclosed)
1076 char *closing_quote = strchr (p - 1, '"');
1077 if (closing_quote && closing_quote[1] == '\0')
1078 *closing_quote = '\0';
1081 /* Now that we've safely parsed the first half, put back ',' so
1082 outer layers can see it. */
1091 /* Here's where we recognise an Objective-C Selector. An Objective C
1092 selector may be implemented by more than one class, therefore it
1093 may represent more than one method/function. This gives us a
1094 situation somewhat analogous to C++ overloading. If there's more
1095 than one method that could represent the selector, then use some of
1096 the existing C++ code to let the user choose one. */
1098 struct symtabs_and_lines
1099 decode_objc (char **argptr, int funfirstline, struct symtab *file_symtab,
1100 char ***canonical, char *saved_arg)
1102 struct symtabs_and_lines values;
1103 struct symbol **sym_arr = NULL;
1104 struct symbol *sym = NULL;
1106 struct block *block = NULL;
1113 if (file_symtab != NULL)
1114 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab), STATIC_BLOCK);
1117 enum language save_language;
1119 /* get_selected_block can change the current language when there is
1120 no selected frame yet. */
1121 save_language = current_language->la_language;
1122 block = get_selected_block (0);
1123 set_language (save_language);
1126 copy = find_imps (file_symtab, block, *argptr, NULL, &i1, &i2);
1130 sym_arr = (struct symbol **) alloca ((i1 + 1) * sizeof (struct symbol *));
1133 copy = find_imps (file_symtab, block, *argptr, sym_arr, &i1, &i2);
1137 /* i1 now represents the TOTAL number of matches found.
1138 i2 represents how many HIGH-LEVEL (struct symbol) matches,
1139 which will come first in the sym_arr array. Any low-level
1140 (minimal_symbol) matches will follow those. */
1146 /* Already a struct symbol. */
1151 sym = find_pc_function (SYMBOL_VALUE_ADDRESS (sym_arr[0]));
1152 if ((sym != NULL) && strcmp (SYMBOL_LINKAGE_NAME (sym_arr[0]), SYMBOL_LINKAGE_NAME (sym)) != 0)
1154 warning (_("debugging symbol \"%s\" does not match selector; ignoring"), SYMBOL_LINKAGE_NAME (sym));
1159 values.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
1162 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1164 /* Canonicalize this, so it remains resolved for dylib loads. */
1165 values.sals[0] = find_function_start_sal (sym, funfirstline);
1166 build_canonical_line_spec (values.sals, SYMBOL_NATURAL_NAME (sym), canonical);
1170 /* The only match was a non-debuggable symbol, which might point
1171 to a function descriptor; resolve it to the actual code address
1173 struct minimal_symbol *msymbol = (struct minimal_symbol *)sym_arr[0];
1174 struct objfile *objfile = msymbol_objfile (msymbol);
1175 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1176 CORE_ADDR pc = SYMBOL_VALUE_ADDRESS (msymbol);
1178 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, pc,
1181 init_sal (&values.sals[0]);
1182 values.sals[0].pc = pc;
1189 /* More than one match. The user must choose one or more. */
1190 return decode_line_2 (sym_arr, i2, funfirstline, canonical);
1196 /* This handles C++ and Java compound data structures. P should point
1197 at the first component separator, i.e. double-colon or period. As
1198 an example, on entrance to this function we could have ARGPTR
1199 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
1201 static struct symtabs_and_lines
1202 decode_compound (char **argptr, int funfirstline, char ***canonical,
1203 char *saved_arg, char *p, int *not_found_ptr)
1205 struct symtabs_and_lines values;
1207 char *saved_arg2 = *argptr;
1211 struct symbol *sym_class;
1213 char *saved_java_argptr = NULL;
1215 /* First check for "global" namespace specification, of the form
1216 "::foo". If found, skip over the colons and jump to normal
1217 symbol processing. I.e. the whole line specification starts with
1218 "::" (note the condition that *argptr == p). */
1220 && ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t')))
1223 /* Given our example "AAA::inA::fun", we have two cases to consider:
1225 1) AAA::inA is the name of a class. In that case, presumably it
1226 has a method called "fun"; we then look up that method using
1229 2) AAA::inA isn't the name of a class. In that case, either the
1230 user made a typo or AAA::inA is the name of a namespace.
1231 Either way, we just look up AAA::inA::fun with lookup_symbol.
1233 Thus, our first task is to find everything before the last set of
1234 double-colons and figure out if it's the name of a class. So we
1235 first loop through all of the double-colons. */
1237 p2 = p; /* Save for restart. */
1239 /* This is very messy. Following the example above we have now the
1242 argptr -> "AAA::inA::fun
1243 saved_arg -> "AAA::inA::fun
1244 saved_arg2 -> "AAA::inA::fun
1245 p2 -> "::inA::fun". */
1247 /* In the loop below, with these strings, we'll make 2 passes, each
1248 is marked in comments.*/
1252 /* Move pointer up to next possible class/namespace token. */
1254 p = p2 + 1; /* Restart with old value +1. */
1256 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1257 i.e. if there is a double-colon, p will now point to the
1259 /* PASS2: p2->"::fun", p->":fun" */
1261 /* Move pointer ahead to next double-colon. */
1262 while (*p && (p[0] != ' ') && (p[0] != '\t') && (p[0] != '\'')
1265 if (current_language->la_language == language_cplus)
1266 p += cp_validate_operator (p);
1270 temp_end = find_template_name_end (p);
1272 error (_("malformed template specification in command"));
1275 /* Note that, since, at the start of this loop, p would be
1276 pointing to the second colon in a double-colon, we only
1277 satisfy the condition below if there is another
1278 double-colon to the right (after). I.e. there is another
1279 component that can be a class or a namespace. I.e, if at
1280 the beginning of this loop (PASS1), we had
1281 p->":inA::fun", we'll trigger this when p has been
1282 advanced to point to "::fun". */
1283 /* PASS2: we will not trigger this. */
1284 else if ((p[0] == ':') && (p[1] == ':'))
1285 break; /* Found double-colon. */
1287 /* PASS2: We'll keep getting here, until p->"", at which point
1288 we exit this loop. */
1293 break; /* Out of the while (1). This would happen
1294 for instance if we have looked up
1295 unsuccessfully all the components of the
1296 string, and p->""(PASS2) */
1298 /* We get here if p points to ' ', '\t', '\'', "::" or ""(i.e
1300 /* Save restart for next time around. */
1302 /* Restore argptr as it was on entry to this function. */
1303 *argptr = saved_arg2;
1304 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1307 /* All ready for next pass through the loop. */
1311 /* Start of lookup in the symbol tables. */
1313 /* Lookup in the symbol table the substring between argptr and
1314 p. Note, this call changes the value of argptr. */
1315 /* Before the call, argptr->"AAA::inA::fun",
1316 p->"", p2->"::fun". After the call: argptr->"fun", p, p2
1318 sym_class = lookup_prefix_sym (argptr, p2);
1320 /* If sym_class has been found, and if "AAA::inA" is a class, then
1321 we're in case 1 above. So we look up "fun" as a method of that
1324 (t = check_typedef (SYMBOL_TYPE (sym_class)),
1325 (TYPE_CODE (t) == TYPE_CODE_STRUCT
1326 || TYPE_CODE (t) == TYPE_CODE_UNION)))
1328 /* Arg token is not digits => try it as a function name.
1329 Find the next token (everything up to end or next
1332 && strchr (get_gdb_completer_quote_characters (),
1335 p = skip_quoted (*argptr);
1336 *argptr = *argptr + 1;
1340 /* At this point argptr->"fun". */
1343 while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':'
1346 /* At this point p->"". String ended. */
1347 /* Nope, C++ operators could have spaces in them
1348 ("foo::operator <" or "foo::operator delete []").
1349 I apologize, this is a bit hacky... */
1350 if (current_language->la_language == language_cplus
1351 && *p == ' ' && p - 8 - *argptr + 1 > 0)
1353 /* The above loop has already swallowed "operator". */
1354 p += cp_validate_operator (p - 8) - 8;
1357 /* Keep any template parameters */
1359 p = find_template_name_end (p);
1361 /* Keep method overload information. */
1362 a = strchr (p, '(');
1364 p = find_method_overload_end (a);
1366 /* Make sure we keep important kewords like "const" */
1367 if (strncmp (p, " const", 6) == 0)
1370 /* Java may append typenames, so assume that if there is
1371 anything else left in *argptr, it must be a typename. */
1372 if (*p && current_language->la_language == language_java)
1378 copy = (char *) alloca (p2 - p + 1);
1379 memcpy (copy, p, p2 - p);
1380 copy[p2 - p] = '\0';
1381 type = lookup_typename (current_language, get_current_arch (),
1385 /* Save the location of this just in case this
1386 method/type combination isn't actually defined.
1387 It will be checked later. */
1388 saved_java_argptr = p;
1394 /* Allocate our own copy of the substring between argptr and
1396 copy = (char *) alloca (p - *argptr + 1);
1397 memcpy (copy, *argptr, p - *argptr);
1398 copy[p - *argptr] = '\0';
1400 && copy[p - *argptr - 1]
1401 && strchr (get_gdb_completer_quote_characters (),
1402 copy[p - *argptr - 1]) != NULL)
1403 copy[p - *argptr - 1] = '\0';
1405 /* At this point copy->"fun", p->"" */
1407 /* No line number may be specified. */
1408 while (*p == ' ' || *p == '\t')
1411 /* At this point arptr->"". */
1413 /* Look for copy as a method of sym_class. */
1414 /* At this point copy->"fun", sym_class is "AAA:inA",
1415 saved_arg->"AAA::inA::fun". This concludes the scanning of
1416 the string for possible components matches. If we find it
1417 here, we return. If not, and we are at the and of the string,
1418 we'll lookup the whole string in the symbol tables. */
1420 values = find_method (funfirstline, canonical, saved_arg,
1421 copy, t, sym_class, not_found_ptr);
1422 if (saved_java_argptr != NULL && values.nelts == 1)
1424 /* The user specified a specific return type for a java method.
1425 Double-check that it really is the one the user specified.
1426 [This is a necessary evil because strcmp_iw_ordered stops
1427 comparisons too prematurely.] */
1428 sym = find_pc_sect_function (values.sals[0].pc,
1429 values.sals[0].section);
1430 /* We just found a SAL, we had better be able to go backwards! */
1431 gdb_assert (sym != NULL);
1432 if (strcmp_iw (SYMBOL_LINKAGE_NAME (sym), saved_arg) != 0)
1434 xfree (values.sals);
1435 error (_("the class `%s' does not have any method instance named %s\n"),
1436 SYMBOL_PRINT_NAME (sym_class), copy);
1440 } /* End if symbol found */
1443 /* We couldn't find a class, so we're in case 2 above. We check the
1444 entire name as a symbol instead. */
1446 copy = (char *) alloca (p - saved_arg2 + 1);
1447 memcpy (copy, saved_arg2, p - saved_arg2);
1448 /* Note: if is_quoted should be true, we snuff out quote here
1450 copy[p - saved_arg2] = '\000';
1451 /* Set argptr to skip over the name. */
1452 *argptr = (*p == '\'') ? p + 1 : p;
1454 /* Look up entire name */
1455 sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
1457 return symbol_found (funfirstline, canonical, copy, sym, NULL);
1459 /* Couldn't find any interpretation as classes/namespaces, so give
1460 up. The quotes are important if copy is empty. */
1463 cplusplus_error (saved_arg,
1464 "Can't find member of namespace, class, struct, or union named \"%s\"\n",
1468 /* Next come some helper functions for decode_compound. */
1470 /* Return the symbol corresponding to the substring of *ARGPTR ending
1471 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1472 name in question, the compound object separator ("::" or "."), and
1473 whitespace. Note that *ARGPTR is changed whether or not the
1474 lookup_symbol call finds anything (i.e we return NULL). As an
1475 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
1477 static struct symbol *
1478 lookup_prefix_sym (char **argptr, char *p)
1484 /* Extract the class name. */
1486 while (p != *argptr && p[-1] == ' ')
1488 copy = (char *) alloca (p - *argptr + 1);
1489 memcpy (copy, *argptr, p - *argptr);
1490 copy[p - *argptr] = 0;
1492 /* Discard the class name from the argptr. */
1493 p = p1 + (p1[0] == ':' ? 2 : 1);
1494 while (*p == ' ' || *p == '\t')
1498 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1499 argptr->"inA::fun" */
1501 sym = lookup_symbol (copy, 0, STRUCT_DOMAIN, 0);
1504 /* Typedefs are in VAR_DOMAIN so the above symbol lookup will
1505 fail when the user attempts to lookup a method of a class
1506 via a typedef'd name (NOT via the class's name, which is already
1507 handled in symbol_matches_domain). So try the lookup again
1508 using VAR_DOMAIN (where typedefs live) and double-check that we
1509 found a struct/class type. */
1510 struct symbol *s = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
1513 struct type *t = SYMBOL_TYPE (s);
1515 if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
1523 /* This finds the method COPY in the class whose type is T and whose
1524 symbol is SYM_CLASS. */
1526 static struct symtabs_and_lines
1527 find_method (int funfirstline, char ***canonical, char *saved_arg,
1528 char *copy, struct type *t, struct symbol *sym_class, int *not_found_ptr)
1530 struct symtabs_and_lines values;
1531 struct symbol *sym = NULL;
1532 int i1; /* Counter for the symbol array. */
1533 struct symbol **sym_arr = alloca (total_number_of_methods (t)
1534 * sizeof (struct symbol *));
1536 /* Find all methods with a matching name, and put them in
1539 i1 = find_methods (t, copy, SYMBOL_LANGUAGE (sym_class), sym_arr);
1543 /* There is exactly one field with that name. */
1546 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1548 values.sals = (struct symtab_and_line *)
1549 xmalloc (sizeof (struct symtab_and_line));
1551 values.sals[0] = find_function_start_sal (sym,
1563 /* If we were given a specific overload instance, use that
1564 (or error if no matches were found). Otherwise ask the user
1565 which one to use. */
1566 if (strchr (saved_arg, '(') != NULL)
1569 for (i = 0; i < i1; ++i)
1571 char *name = saved_arg;
1572 char *canon = cp_canonicalize_string (name);
1576 if (strcmp_iw (name, SYMBOL_LINKAGE_NAME (sym_arr[i])) == 0)
1578 values.sals = (struct symtab_and_line *)
1579 xmalloc (sizeof (struct symtab_and_line));
1581 values.sals[0] = find_function_start_sal (sym_arr[i],
1592 error (_("the class `%s' does not have any method instance named %s\n"),
1593 SYMBOL_PRINT_NAME (sym_class), copy);
1596 return decode_line_2 (sym_arr, i1, funfirstline, canonical);
1603 cplusplus_error (saved_arg,
1604 "the class `%s' does not have destructor defined\n",
1605 SYMBOL_PRINT_NAME (sym_class));
1607 cplusplus_error (saved_arg,
1608 "the class %s does not have any method named %s\n",
1609 SYMBOL_PRINT_NAME (sym_class), copy);
1615 /* Return the symtab associated to the filename given by the substring
1616 of *ARGPTR ending at P, and advance ARGPTR past that filename. If
1617 NOT_FOUND_PTR is not null and the source file is not found, store
1618 boolean true at the location pointed to and do not issue an
1621 static struct symtab *
1622 symtab_from_filename (char **argptr, char *p, int is_quote_enclosed,
1627 struct symtab *file_symtab;
1630 while (p != *argptr && p[-1] == ' ')
1632 if ((*p == '"') && is_quote_enclosed)
1634 copy = (char *) alloca (p - *argptr + 1);
1635 memcpy (copy, *argptr, p - *argptr);
1636 /* It may have the ending quote right after the file name. */
1637 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
1638 || copy[p - *argptr - 1] == '\'')
1639 copy[p - *argptr - 1] = 0;
1641 copy[p - *argptr] = 0;
1643 /* Find that file's data. */
1644 file_symtab = lookup_symtab (copy);
1645 if (file_symtab == 0)
1649 if (!have_full_symbols () && !have_partial_symbols ())
1650 throw_error (NOT_FOUND_ERROR,
1651 _("No symbol table is loaded. Use the \"file\" command."));
1652 throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy);
1655 /* Discard the file name from the arg. */
1657 while (*p == ' ' || *p == '\t')
1666 /* This decodes a line where the argument is all digits (possibly
1667 preceded by a sign). Q should point to the end of those digits;
1668 the other arguments are as usual. */
1670 static struct symtabs_and_lines
1671 decode_all_digits (char **argptr, struct symtab *default_symtab,
1672 int default_line, char ***canonical,
1673 struct symtab *file_symtab, char *q)
1676 struct symtabs_and_lines values;
1677 struct symtab_and_line val;
1685 /* We might need a canonical line spec if no file was specified. */
1686 int need_canonical = (file_symtab == NULL) ? 1 : 0;
1690 val.pspace = current_program_space;
1692 /* This is where we need to make sure that we have good defaults.
1693 We must guarantee that this section of code is never executed
1694 when we are called with just a function name, since
1695 set_default_source_symtab_and_line uses
1696 select_source_symtab that calls us with such an argument. */
1698 if (file_symtab == 0 && default_symtab == 0)
1700 /* Make sure we have at least a default source file. */
1701 set_default_source_symtab_and_line ();
1702 initialize_defaults (&default_symtab, &default_line);
1705 if (**argptr == '+')
1706 sign = plus, (*argptr)++;
1707 else if (**argptr == '-')
1708 sign = minus, (*argptr)++;
1709 val.line = atoi (*argptr);
1715 if (file_symtab == 0)
1716 val.line = default_line + val.line;
1721 if (file_symtab == 0)
1722 val.line = default_line - val.line;
1727 break; /* No need to adjust val.line. */
1730 while (*q == ' ' || *q == '\t')
1733 if (file_symtab == 0)
1734 file_symtab = default_symtab;
1736 /* It is possible that this source file has more than one symtab,
1737 and that the new line number specification has moved us from the
1738 default (in file_symtab) to a new one. */
1739 val.symtab = find_line_symtab (file_symtab, val.line, NULL, NULL);
1740 if (val.symtab == 0)
1741 val.symtab = file_symtab;
1743 val.pspace = SYMTAB_PSPACE (val.symtab);
1745 values.sals = (struct symtab_and_line *)
1746 xmalloc (sizeof (struct symtab_and_line));
1747 values.sals[0] = val;
1750 build_canonical_line_spec (values.sals, NULL, canonical);
1751 values.sals[0].explicit_line = 1;
1757 /* Decode a linespec starting with a dollar sign. */
1759 static struct symtabs_and_lines
1760 decode_dollar (char *copy, int funfirstline, struct symtab *default_symtab,
1761 char ***canonical, struct symtab *file_symtab)
1765 int need_canonical = 0;
1766 struct symtabs_and_lines values;
1767 struct symtab_and_line val;
1770 struct minimal_symbol *msymbol;
1772 p = (copy[1] == '$') ? copy + 2 : copy + 1;
1773 while (*p >= '0' && *p <= '9')
1775 if (!*p) /* Reached end of token without hitting non-digit. */
1777 /* We have a value history reference. */
1778 struct value *val_history;
1779 sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index);
1780 val_history = access_value_history ((copy[1] == '$') ? -index : index);
1781 if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
1782 error (_("History values used in line specs must have integer values."));
1783 valx = value_as_long (val_history);
1787 /* Not all digits -- may be user variable/function or a
1788 convenience variable. */
1790 /* Look up entire name as a symbol first. */
1791 sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
1792 file_symtab = (struct symtab *) NULL;
1794 /* Symbol was found --> jump to normal symbol processing. */
1796 return symbol_found (funfirstline, canonical, copy, sym, NULL);
1798 /* If symbol was not found, look in minimal symbol tables. */
1799 msymbol = lookup_minimal_symbol (copy, NULL, NULL);
1800 /* Min symbol was found --> jump to minsym processing. */
1802 return minsym_found (funfirstline, msymbol);
1804 /* Not a user variable or function -- must be convenience variable. */
1805 if (!get_internalvar_integer (lookup_internalvar (copy + 1), &valx))
1806 error (_("Convenience variables used in line specs must have integer values."));
1811 /* Either history value or convenience value from above, in valx. */
1812 val.symtab = file_symtab ? file_symtab : default_symtab;
1815 val.pspace = current_program_space;
1817 values.sals = (struct symtab_and_line *) xmalloc (sizeof val);
1818 values.sals[0] = val;
1822 build_canonical_line_spec (values.sals, NULL, canonical);
1829 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
1830 look in that symtab's static variables first. If NOT_FOUND_PTR is not NULL and
1831 the function cannot be found, store boolean true in the location pointed to
1832 and do not issue an error message. */
1834 static struct symtabs_and_lines
1835 decode_variable (char *copy, int funfirstline, char ***canonical,
1836 struct symtab *file_symtab, int *not_found_ptr)
1840 struct minimal_symbol *msymbol;
1842 sym = lookup_symbol (copy,
1844 ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab),
1846 : get_selected_block (0)),
1850 return symbol_found (funfirstline, canonical, copy, sym, file_symtab);
1852 msymbol = lookup_minimal_symbol (copy, NULL, NULL);
1854 if (msymbol != NULL)
1855 return minsym_found (funfirstline, msymbol);
1860 if (!have_full_symbols ()
1861 && !have_partial_symbols ()
1862 && !have_minimal_symbols ())
1863 throw_error (NOT_FOUND_ERROR,
1864 _("No symbol table is loaded. Use the \"file\" command."));
1865 throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined."), copy);
1871 /* Now come some functions that are called from multiple places within
1874 /* We've found a symbol SYM to associate with our linespec; build a
1875 corresponding struct symtabs_and_lines. */
1877 static struct symtabs_and_lines
1878 symbol_found (int funfirstline, char ***canonical, char *copy,
1879 struct symbol *sym, struct symtab *file_symtab)
1881 struct symtabs_and_lines values;
1883 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
1885 /* Arg is the name of a function */
1886 values.sals = (struct symtab_and_line *)
1887 xmalloc (sizeof (struct symtab_and_line));
1888 values.sals[0] = find_function_start_sal (sym, funfirstline);
1891 /* Don't use the SYMBOL_LINE; if used at all it points to
1892 the line containing the parameters or thereabouts, not
1893 the first line of code. */
1895 /* We might need a canonical line spec if it is a static
1897 if (file_symtab == 0)
1899 struct blockvector *bv = BLOCKVECTOR (SYMBOL_SYMTAB (sym));
1900 struct block *b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1901 if (lookup_block_symbol (b, copy, VAR_DOMAIN) != NULL)
1902 build_canonical_line_spec (values.sals, copy, canonical);
1909 error (_("\"%s\" is not a function"), copy);
1910 else if (SYMBOL_LINE (sym) != 0)
1912 /* We know its line number. */
1913 values.sals = (struct symtab_and_line *)
1914 xmalloc (sizeof (struct symtab_and_line));
1916 memset (&values.sals[0], 0, sizeof (values.sals[0]));
1917 values.sals[0].symtab = SYMBOL_SYMTAB (sym);
1918 values.sals[0].line = SYMBOL_LINE (sym);
1922 /* This can happen if it is compiled with a compiler which doesn't
1923 put out line numbers for variables. */
1924 /* FIXME: Shouldn't we just set .line and .symtab to zero
1925 and return? For example, "info line foo" could print
1927 error (_("Line number not known for symbol \"%s\""), copy);
1931 /* We've found a minimal symbol MSYMBOL to associate with our
1932 linespec; build a corresponding struct symtabs_and_lines. */
1934 static struct symtabs_and_lines
1935 minsym_found (int funfirstline, struct minimal_symbol *msymbol)
1937 struct objfile *objfile = msymbol_objfile (msymbol);
1938 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1939 struct symtabs_and_lines values;
1942 values.sals = (struct symtab_and_line *)
1943 xmalloc (sizeof (struct symtab_and_line));
1944 values.sals[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol),
1945 (struct obj_section *) 0, 0);
1946 values.sals[0].section = SYMBOL_OBJ_SECTION (msymbol);
1948 /* The minimal symbol might point to a function descriptor;
1949 resolve it to the actual code address instead. */
1950 pc = gdbarch_convert_from_func_ptr_addr (gdbarch,
1953 if (pc != values.sals[0].pc)
1954 values.sals[0] = find_pc_sect_line (pc, NULL, 0);
1957 skip_prologue_sal (&values.sals[0]);