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, 2011 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 #include "cli/cli-utils.h"
46 #include "filenames.h"
49 typedef struct symtab *symtab_p;
52 typedef struct symbol *symbolp;
55 typedef struct type *typep;
58 /* An address entry is used to ensure that any given location is only
59 added to the result a single time. It holds an address and the
60 program space from which the address came. */
64 struct program_space *pspace;
68 /* An instance of this is used to keep all state while linespec
69 operates. This instance is passed around as a 'this' pointer to
70 the various implementation methods. */
74 /* The program space as seen when the module was entered. */
75 struct program_space *program_space;
77 /* The default symtab to use, if no other symtab is specified. */
78 struct symtab *default_symtab;
80 /* The default line to use. */
83 /* If the linespec started with "FILE:", this holds all the matching
84 symtabs. Otherwise, it will hold a single NULL entry, meaning
85 that the default symtab should be used. */
86 VEC (symtab_p) *file_symtabs;
88 /* If the linespec started with "FILE:", this holds an xmalloc'd
92 /* If the linespec is "FUNCTION:LABEL", this holds an xmalloc'd copy
96 /* The 'funfirstline' value that was passed in to decode_line_1 or
100 /* Nonzero if we are running in 'list' mode; see decode_line_list. */
103 /* The 'canonical' value passed to decode_line_full, or NULL. */
104 struct linespec_result *canonical;
106 /* Canonical strings that mirror the symtabs_and_lines result. */
107 char **canonical_names;
109 /* This is a set of address_entry objects which is used to prevent
110 duplicate symbols from being entered into the result. */
114 /* This is a helper object that is used when collecting symbols into a
119 /* The linespec object in use. */
120 struct linespec_state *state;
122 /* The result being accumulated. */
123 struct symtabs_and_lines result;
125 /* The current objfile; used only by the minimal symbol code. */
126 struct objfile *objfile;
129 /* Prototypes for local functions. */
131 static void initialize_defaults (struct symtab **default_symtab,
134 static struct symtabs_and_lines decode_indirect (struct linespec_state *self,
137 static char *locate_first_half (char **argptr, int *is_quote_enclosed);
139 static struct symtabs_and_lines decode_objc (struct linespec_state *self,
142 static struct symtabs_and_lines decode_compound (struct linespec_state *self,
147 static VEC (symbolp) *lookup_prefix_sym (char **argptr, char *p,
151 static struct symtabs_and_lines find_method (struct linespec_state *self,
154 const char *class_name,
155 VEC (symbolp) *sym_classes);
157 static void cplusplus_error (const char *name, const char *fmt, ...)
158 ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 3);
160 static char *find_toplevel_char (char *s, char c);
162 static int is_objc_method_format (const char *s);
164 static VEC (symtab_p) *symtabs_from_filename (char **argptr,
165 char *p, int is_quote_enclosed,
166 char **user_filename);
168 static VEC (symbolp) *find_function_symbols (char **argptr, char *p,
169 int is_quote_enclosed,
170 char **user_function);
172 static struct symtabs_and_lines decode_all_digits (struct linespec_state *self,
176 static struct symtabs_and_lines decode_dollar (struct linespec_state *self,
179 static int decode_label (struct linespec_state *self,
180 VEC (symbolp) *function_symbols,
182 struct symtabs_and_lines *result);
184 static struct symtabs_and_lines decode_variable (struct linespec_state *self,
187 static int symbol_to_sal (struct symtab_and_line *result,
188 int funfirstline, struct symbol *sym);
190 static void add_matching_symbols_to_info (const char *name,
191 struct collect_info *info,
192 struct program_space *pspace);
194 static void add_all_symbol_names_from_pspace (struct collect_info *info,
195 struct program_space *pspace,
196 VEC (const_char_ptr) *names);
198 /* Helper functions. */
200 /* Add SAL to SALS. */
203 add_sal_to_sals_basic (struct symtabs_and_lines *sals,
204 struct symtab_and_line *sal)
207 sals->sals = xrealloc (sals->sals, sals->nelts * sizeof (sals->sals[0]));
208 sals->sals[sals->nelts - 1] = *sal;
211 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
212 the new sal, if needed. If not NULL, SYMNAME is the name of the
213 symbol to use when constructing the new canonical name. */
216 add_sal_to_sals (struct linespec_state *self,
217 struct symtabs_and_lines *sals,
218 struct symtab_and_line *sal,
221 add_sal_to_sals_basic (sals, sal);
225 char *canonical_name = NULL;
227 self->canonical_names = xrealloc (self->canonical_names,
228 sals->nelts * sizeof (char *));
229 if (sal->symtab && sal->symtab->filename)
231 char *filename = sal->symtab->filename;
233 /* Note that the filter doesn't have to be a valid linespec
234 input. We only apply the ":LINE" treatment to Ada for
236 if (symname != NULL && sal->line != 0
237 && current_language->la_language == language_ada)
238 canonical_name = xstrprintf ("%s:%s:%d", filename, symname,
240 else if (symname != NULL)
241 canonical_name = xstrprintf ("%s:%s", filename, symname);
243 canonical_name = xstrprintf ("%s:%d", filename, sal->line);
246 self->canonical_names[sals->nelts - 1] = canonical_name;
250 /* A hash function for address_entry. */
253 hash_address_entry (const void *p)
255 const struct address_entry *aep = p;
257 return iterative_hash_object (*aep, 0);
260 /* An equality function for address_entry. */
263 eq_address_entry (const void *a, const void *b)
265 const struct address_entry *aea = a;
266 const struct address_entry *aeb = b;
268 return aea->pspace == aeb->pspace && aea->addr == aeb->addr;
271 /* Check whether the address, represented by PSPACE and ADDR, is
272 already in the set. If so, return 0. Otherwise, add it and return
276 maybe_add_address (htab_t set, struct program_space *pspace, CORE_ADDR addr)
278 struct address_entry e, *p;
283 slot = htab_find_slot (set, &e, INSERT);
287 p = XNEW (struct address_entry);
288 memcpy (p, &e, sizeof (struct address_entry));
294 /* Issue a helpful hint on using the command completion feature on
295 single quoted demangled C++ symbols as part of the completion
299 cplusplus_error (const char *name, const char *fmt, ...)
301 struct ui_file *tmp_stream;
304 tmp_stream = mem_fileopen ();
305 make_cleanup_ui_file_delete (tmp_stream);
310 va_start (args, fmt);
311 vfprintf_unfiltered (tmp_stream, fmt, args);
315 while (*name == '\'')
317 fprintf_unfiltered (tmp_stream,
318 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
319 "(Note leading single quote.)"),
322 message = ui_file_xstrdup (tmp_stream, NULL);
323 make_cleanup (xfree, message);
324 throw_error (NOT_FOUND_ERROR, "%s", message);
327 /* A helper for iterate_over_all_matching_symtabs that is passed as a
328 callback to the expand_symtabs_matching method. */
331 iterate_name_matcher (const struct language_defn *language,
332 const char *name, void *d)
334 const char **dname = d;
336 if (language->la_symbol_name_compare (name, *dname) == 0)
341 /* A helper that walks over all matching symtabs in all objfiles and
342 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
343 not NULL, then the search is restricted to just that program
347 iterate_over_all_matching_symtabs (const char *name,
348 const domain_enum domain,
349 int (*callback) (struct symbol *, void *),
351 struct program_space *search_pspace)
353 struct objfile *objfile;
354 struct program_space *pspace;
358 if (search_pspace != NULL && search_pspace != pspace)
360 if (pspace->executing_startup)
363 set_current_program_space (pspace);
365 ALL_OBJFILES (objfile)
367 struct symtab *symtab;
370 objfile->sf->qf->expand_symtabs_matching (objfile, NULL,
371 iterate_name_matcher,
375 ALL_OBJFILE_SYMTABS (objfile, symtab)
381 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
382 LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data);
389 /* Returns the block to be used for symbol searches for the given SYMTAB,
390 which may be NULL. */
392 static struct block *
393 get_search_block (struct symtab *symtab)
398 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
401 enum language save_language;
403 /* get_selected_block can change the current language when there is
404 no selected frame yet. */
405 save_language = current_language->la_language;
406 block = get_selected_block (0);
407 set_language (save_language);
413 /* A helper for find_method. This finds all methods in type T which
414 match NAME. It adds resulting symbol names to RESULT_NAMES, and
415 adds T's direct superclasses to SUPERCLASSES. */
418 find_methods (struct type *t, const char *name,
419 VEC (const_char_ptr) **result_names,
420 VEC (typep) **superclasses)
424 char *class_name = type_name_no_tag (t);
427 /* Ignore this class if it doesn't have a name. This is ugly, but
428 unless we figure out how to get the physname without the name of
429 the class, then the loop can't do any good. */
433 int name_len = strlen (name);
437 /* Loop over each method name. At this level, all overloads of a name
438 are counted as a single name. There is an inner loop which loops over
441 for (method_counter = TYPE_NFN_FIELDS (t) - 1;
445 char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
448 if (strncmp (method_name, "__", 2) == 0 ||
449 strncmp (method_name, "op", 2) == 0 ||
450 strncmp (method_name, "type", 4) == 0)
452 if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI))
453 method_name = dem_opname;
454 else if (cplus_demangle_opname (method_name, dem_opname, 0))
455 method_name = dem_opname;
458 if (strcmp_iw (method_name, name) == 0)
462 for (field_counter = (TYPE_FN_FIELDLIST_LENGTH (t, method_counter)
468 const char *phys_name;
470 f = TYPE_FN_FIELDLIST1 (t, method_counter);
471 if (TYPE_FN_FIELD_STUB (f, field_counter))
473 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
474 VEC_safe_push (const_char_ptr, *result_names, phys_name);
480 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
481 VEC_safe_push (typep, *superclasses, TYPE_BASECLASS (t, ibase));
484 /* Find an instance of the character C in the string S that is outside
485 of all parenthesis pairs, single-quoted strings, and double-quoted
486 strings. Also, ignore the char within a template name, like a ','
487 within foo<int, int>. */
490 find_toplevel_char (char *s, char c)
492 int quoted = 0; /* zero if we're not in quotes;
493 '"' if we're in a double-quoted string;
494 '\'' if we're in a single-quoted string. */
495 int depth = 0; /* Number of unclosed parens we've seen. */
498 for (scan = s; *scan; scan++)
504 else if (*scan == '\\' && *(scan + 1))
507 else if (*scan == c && ! quoted && depth == 0)
509 else if (*scan == '"' || *scan == '\'')
511 else if (*scan == '(' || *scan == '<')
513 else if ((*scan == ')' || *scan == '>') && depth > 0)
520 /* Determines if the gives string corresponds to an Objective-C method
521 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
522 are allowed to have spaces and parentheses in them. */
525 is_objc_method_format (const char *s)
527 if (s == NULL || *s == '\0')
529 /* Handle arguments with the format FILENAME:SYMBOL. */
530 if ((s[0] == ':') && (strchr ("+-", s[1]) != NULL)
531 && (s[2] == '[') && strchr(s, ']'))
533 /* Handle arguments that are just SYMBOL. */
534 else if ((strchr ("+-", s[0]) != NULL) && (s[1] == '[') && strchr(s, ']'))
539 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
540 and store the result in SELF->CANONICAL. */
543 filter_results (struct linespec_state *self,
544 struct symtabs_and_lines *result,
545 VEC (const_char_ptr) *filters)
550 for (i = 0; VEC_iterate (const_char_ptr, filters, i, name); ++i)
552 struct linespec_sals lsal;
555 memset (&lsal, 0, sizeof (lsal));
557 for (j = 0; j < result->nelts; ++j)
559 if (strcmp (name, self->canonical_names[j]) == 0)
560 add_sal_to_sals_basic (&lsal.sals, &result->sals[j]);
563 if (lsal.sals.nelts > 0)
565 lsal.canonical = xstrdup (name);
566 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
570 self->canonical->pre_expanded = 0;
573 /* Store RESULT into SELF->CANONICAL. */
576 convert_results_to_lsals (struct linespec_state *self,
577 struct symtabs_and_lines *result)
579 struct linespec_sals lsal;
581 lsal.canonical = NULL;
583 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
586 /* Handle multiple results in RESULT depending on SELECT_MODE. This
587 will either return normally, throw an exception on multiple
588 results, or present a menu to the user. On return, the SALS vector
589 in SELF->CANONICAL is set up properly. */
592 decode_line_2 (struct linespec_state *self,
593 struct symtabs_and_lines *result,
594 const char *select_mode)
599 struct cleanup *old_chain;
600 VEC (const_char_ptr) *item_names = NULL, *filters = NULL;
601 struct get_number_or_range_state state;
603 gdb_assert (select_mode != multiple_symbols_all);
604 gdb_assert (self->canonical != NULL);
606 old_chain = make_cleanup (VEC_cleanup (const_char_ptr), &item_names);
607 make_cleanup (VEC_cleanup (const_char_ptr), &filters);
608 for (i = 0; i < result->nelts; ++i)
613 gdb_assert (self->canonical_names[i] != NULL);
614 for (j = 0; VEC_iterate (const_char_ptr, item_names, j, iter); ++j)
616 if (strcmp (iter, self->canonical_names[i]) == 0)
624 VEC_safe_push (const_char_ptr, item_names, self->canonical_names[i]);
627 if (select_mode == multiple_symbols_cancel
628 && VEC_length (const_char_ptr, item_names) > 1)
629 error (_("canceled because the command is ambiguous\n"
630 "See set/show multiple-symbol."));
632 if (select_mode == multiple_symbols_all
633 || VEC_length (const_char_ptr, item_names) == 1)
635 do_cleanups (old_chain);
636 convert_results_to_lsals (self, result);
640 printf_unfiltered (_("[0] cancel\n[1] all\n"));
641 for (i = 0; VEC_iterate (const_char_ptr, item_names, i, iter); ++i)
642 printf_unfiltered ("[%d] %s\n", i + 2, iter);
644 prompt = getenv ("PS2");
649 args = command_line_input (prompt, 0, "overload-choice");
651 if (args == 0 || *args == 0)
652 error_no_arg (_("one or more choice numbers"));
654 init_number_or_range (&state, args);
655 while (!state.finished)
659 num = get_number_or_range (&state);
662 error (_("canceled"));
665 /* We intentionally make this result in a single breakpoint,
666 contrary to what older versions of gdb did. The
667 rationale is that this lets a user get the
668 multiple_symbols_all behavior even with the 'ask'
669 setting; and he can get separate breakpoints by entering
670 "2-57" at the query. */
671 do_cleanups (old_chain);
672 convert_results_to_lsals (self, result);
677 if (num >= VEC_length (const_char_ptr, item_names))
678 printf_unfiltered (_("No choice number %d.\n"), num);
681 const char *elt = VEC_index (const_char_ptr, item_names, num);
685 VEC_safe_push (const_char_ptr, filters, elt);
686 VEC_replace (const_char_ptr, item_names, num, NULL);
690 printf_unfiltered (_("duplicate request for %d ignored.\n"),
696 filter_results (self, result, filters);
697 do_cleanups (old_chain);
700 /* Valid delimiters for linespec keywords "if", "thread" or "task". */
703 is_linespec_boundary (char c)
705 return c == ' ' || c == '\t' || c == '\0' || c == ',';
708 /* A helper function for decode_line_1 and friends which skips P
709 past any method overload information at the beginning of P, e.g.,
710 "(const struct foo *)".
712 This function assumes that P has already been validated to contain
713 overload information, and it will assert if *P != '('. */
715 find_method_overload_end (char *p)
719 gdb_assert (*p == '(');
739 /* Keep important information used when looking up a name. This includes
740 template parameters, overload information, and important keywords, including
741 the possible Java trailing type. */
744 keep_name_info (char *p, int on_boundary)
746 const char *quotes = get_gdb_completer_quote_characters ();
752 if (strchr (quotes, *p))
755 if (*p == ',' && !nest)
758 if (on_boundary && !nest)
760 const char *const words[] = { "if", "thread", "task" };
763 for (wordi = 0; wordi < ARRAY_SIZE (words); wordi++)
764 if (strncmp (p, words[wordi], strlen (words[wordi])) == 0
765 && is_linespec_boundary (p[strlen (words[wordi])]))
767 if (wordi < ARRAY_SIZE (words))
771 if (*p == '(' || *p == '<' || *p == '[')
773 else if ((*p == ')' || *p == '>' || *p == ']') && nest > 0)
778 /* The ',' check could fail on "operator ,". */
779 p += cp_validate_operator (p);
781 on_boundary = is_linespec_boundary (p[-1]);
784 while (p > saved_p && is_linespec_boundary (p[-1]))
791 /* The parser of linespec itself. */
793 /* Parse a string that specifies a line number.
794 Pass the address of a char * variable; that variable will be
795 advanced over the characters actually parsed.
799 LINENUM -- that line number in current file. PC returned is 0.
800 FILE:LINENUM -- that line in that file. PC returned is 0.
801 FUNCTION -- line number of openbrace of that function.
802 PC returned is the start of the function.
803 LABEL -- a label in the current scope
804 VARIABLE -- line number of definition of that variable.
806 FILE:FUNCTION -- likewise, but prefer functions in that file.
807 *EXPR -- line in which address EXPR appears.
809 This may all be followed by an "if EXPR", which we ignore.
811 FUNCTION may be an undebuggable function found in minimal symbol table.
813 If the argument FUNFIRSTLINE is nonzero, we want the first line
814 of real code inside a function when a function is specified, and it is
815 not OK to specify a variable or type to get its line number.
817 DEFAULT_SYMTAB specifies the file to use if none is specified.
818 It defaults to current_source_symtab.
819 DEFAULT_LINE specifies the line number to use for relative
820 line numbers (that start with signs). Defaults to current_source_line.
821 If CANONICAL is non-NULL, store an array of strings containing the canonical
822 line specs there if necessary. Currently overloaded member functions and
823 line numbers or static functions without a filename yield a canonical
824 line spec. The array and the line spec strings are allocated on the heap,
825 it is the callers responsibility to free them.
827 Note that it is possible to return zero for the symtab
828 if no file is validly specified. Callers must check that.
829 Also, the line number returned may be invalid. */
831 /* We allow single quotes in various places. This is a hideous
832 kludge, which exists because the completer can't yet deal with the
833 lack of single quotes. FIXME: write a linespec_completer which we
834 can use as appropriate instead of make_symbol_completion_list. */
836 struct symtabs_and_lines
837 decode_line_internal (struct linespec_state *self, char **argptr)
843 /* This says whether or not something in *ARGPTR is quoted with
844 completer_quotes (i.e. with single quotes). */
846 /* Is *ARGPTR enclosed in double quotes? */
847 int is_quote_enclosed;
848 int is_objc_method = 0;
849 char *saved_arg = *argptr;
850 /* If IS_QUOTED, the end of the quoted bit. */
851 char *end_quote = NULL;
852 /* Is *ARGPTR enclosed in single quotes? */
853 int is_squote_enclosed = 0;
854 /* The "first half" of the linespec. */
857 /* If we are parsing `function:label', this holds the symbols
858 matching the function name. */
859 VEC (symbolp) *function_symbols = NULL;
860 /* If FUNCTION_SYMBOLS is not NULL, then this is the exception that
861 was thrown when trying to parse a filename. */
862 volatile struct gdb_exception file_exception;
864 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
866 /* Defaults have defaults. */
868 initialize_defaults (&self->default_symtab, &self->default_line);
870 /* See if arg is *PC. */
874 do_cleanups (cleanup);
875 return decode_indirect (self, argptr);
878 is_quoted = (strchr (get_gdb_completer_quote_characters (),
883 end_quote = skip_quoted (*argptr);
884 if (*end_quote == '\0')
885 is_squote_enclosed = 1;
888 /* Check to see if it's a multipart linespec (with colons or
891 /* Locate the end of the first half of the linespec.
892 After the call, for instance, if the argptr string is "foo.c:123"
893 p will point at "123". If there is only one part, like "foo", p
894 will point to "". If this is a C++ name, like "A::B::foo", p will
895 point to "::B::foo". Argptr is not changed by this call. */
897 first_half = p = locate_first_half (argptr, &is_quote_enclosed);
899 /* First things first: if ARGPTR starts with a filename, get its
900 symtab and strip the filename from ARGPTR. */
901 TRY_CATCH (file_exception, RETURN_MASK_ERROR)
903 self->file_symtabs = symtabs_from_filename (argptr, p, is_quote_enclosed,
904 &self->user_filename);
907 if (VEC_empty (symtab_p, self->file_symtabs))
909 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
910 VEC_safe_push (symtab_p, self->file_symtabs, NULL);
913 if (file_exception.reason >= 0)
915 /* Check for single quotes on the non-filename part. */
916 is_quoted = (**argptr
917 && strchr (get_gdb_completer_quote_characters (),
920 end_quote = skip_quoted (*argptr);
922 /* Locate the next "half" of the linespec. */
923 first_half = p = locate_first_half (argptr, &is_quote_enclosed);
926 /* Check if this is an Objective-C method (anything that starts with
927 a '+' or '-' and a '['). */
928 if (is_objc_method_format (p))
931 /* Check if the symbol could be an Objective-C selector. */
934 struct symtabs_and_lines values;
936 values = decode_objc (self, argptr);
937 if (values.sals != NULL)
939 do_cleanups (cleanup);
944 /* Does it look like there actually were two parts? */
946 if (p[0] == ':' || p[0] == '.')
948 /* Is it a C++ or Java compound data structure?
949 The check on p[1] == ':' is capturing the case of "::",
950 since p[0]==':' was checked above.
951 Note that the call to decode_compound does everything
952 for us, including the lookup on the symbol table, so we
955 if (p[0] == '.' || p[1] == ':')
957 struct symtabs_and_lines values;
958 volatile struct gdb_exception ex;
959 char *saved_argptr = *argptr;
961 if (is_quote_enclosed)
964 /* Initialize it just to avoid a GCC false warning. */
965 memset (&values, 0, sizeof (values));
967 TRY_CATCH (ex, RETURN_MASK_ERROR)
969 values = decode_compound (self, argptr, saved_arg, p);
971 if ((is_quoted || is_squote_enclosed) && **argptr == '\'')
972 *argptr = *argptr + 1;
976 do_cleanups (cleanup);
980 if (ex.error != NOT_FOUND_ERROR)
981 throw_exception (ex);
983 *argptr = saved_argptr;
987 /* If there was an exception looking up a specified filename earlier,
988 then check whether we were really given `function:label'. */
989 if (file_exception.reason < 0)
991 function_symbols = find_function_symbols (argptr, p,
993 &self->user_function);
995 /* If we did not find a function, re-throw the original
997 if (!function_symbols)
998 throw_exception (file_exception);
1000 make_cleanup (VEC_cleanup (symbolp), &function_symbols);
1003 /* Check for single quotes on the non-filename part. */
1006 is_quoted = (**argptr
1007 && strchr (get_gdb_completer_quote_characters (),
1010 end_quote = skip_quoted (*argptr);
1015 /* self->file_symtabs holds the specified file symtabs, or 0 if no file
1017 If we are parsing `function:symbol', then FUNCTION_SYMBOLS holds the
1018 functions before the `:'.
1019 arg no longer contains the file name. */
1021 /* If the filename was quoted, we must re-check the quotation. */
1023 if (end_quote == first_half && *end_quote!= '\0')
1025 is_quoted = (**argptr
1026 && strchr (get_gdb_completer_quote_characters (),
1029 end_quote = skip_quoted (*argptr);
1032 /* Check whether arg is all digits (and sign). */
1035 if (*q == '-' || *q == '+')
1037 while (*q >= '0' && *q <= '9')
1040 if (q != *argptr && (*q == 0 || *q == ' ' || *q == '\t' || *q == ',')
1041 && function_symbols == NULL)
1043 struct symtabs_and_lines values;
1045 /* We found a token consisting of all digits -- at least one digit. */
1046 values = decode_all_digits (self, argptr, q);
1047 do_cleanups (cleanup);
1051 /* Arg token is not digits => try it as a variable name
1052 Find the next token (everything up to end or next whitespace). */
1054 if (**argptr == '$') /* May be a convenience variable. */
1055 /* One or two $ chars possible. */
1056 p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1));
1057 else if (is_quoted || is_squote_enclosed)
1061 error (_("Unmatched single quote."));
1063 else if (is_objc_method)
1065 /* allow word separators in method names for Obj-C. */
1066 p = skip_quoted_chars (*argptr, NULL, "");
1070 p = skip_quoted (*argptr);
1073 /* Keep any important naming information. */
1074 p = keep_name_info (p, p == saved_arg || is_linespec_boundary (p[-1]));
1076 copy = (char *) alloca (p - *argptr + 1);
1077 memcpy (copy, *argptr, p - *argptr);
1078 copy[p - *argptr] = '\0';
1081 && copy[0] == copy[p - *argptr - 1]
1082 && strchr (get_gdb_completer_quote_characters (), copy[0]) != NULL)
1084 copy[p - *argptr - 1] = '\0';
1087 else if (is_quoted || is_squote_enclosed)
1088 copy[p - *argptr - 1] = '\0';
1090 *argptr = skip_spaces (p);
1092 /* If it starts with $: may be a legitimate variable or routine name
1093 (e.g. HP-UX millicode routines such as $$dyncall), or it may
1094 be history value, or it may be a convenience variable. */
1096 if (*copy == '$' && function_symbols == NULL)
1098 struct symtabs_and_lines values;
1100 values = decode_dollar (self, copy);
1101 do_cleanups (cleanup);
1105 /* Try the token as a label, but only if no file was specified,
1106 because we can only really find labels in the current scope. */
1108 if (VEC_length (symtab_p, self->file_symtabs) == 1
1109 && VEC_index (symtab_p, self->file_symtabs, 0) == NULL)
1111 struct symtabs_and_lines label_result;
1112 if (decode_label (self, function_symbols, copy, &label_result))
1114 do_cleanups (cleanup);
1115 return label_result;
1119 if (function_symbols)
1120 throw_exception (file_exception);
1122 /* Look up that token as a variable.
1123 If file specified, use that file's per-file block to start with. */
1126 struct symtabs_and_lines values;
1128 values = decode_variable (self, copy);
1129 do_cleanups (cleanup);
1134 /* A constructor for linespec_state. */
1137 linespec_state_constructor (struct linespec_state *self,
1139 struct symtab *default_symtab,
1141 struct linespec_result *canonical)
1143 memset (self, 0, sizeof (*self));
1144 self->funfirstline = (flags & DECODE_LINE_FUNFIRSTLINE) ? 1 : 0;
1145 self->list_mode = (flags & DECODE_LINE_LIST_MODE) ? 1 : 0;
1146 self->default_symtab = default_symtab;
1147 self->default_line = default_line;
1148 self->canonical = canonical;
1149 self->program_space = current_program_space;
1150 self->addr_set = htab_create_alloc (10, hash_address_entry, eq_address_entry,
1151 xfree, xcalloc, xfree);
1154 /* A destructor for linespec_state. */
1157 linespec_state_destructor (void *arg)
1159 struct linespec_state *self = arg;
1161 xfree (self->user_filename);
1162 xfree (self->user_function);
1163 VEC_free (symtab_p, self->file_symtabs);
1164 htab_delete (self->addr_set);
1167 /* See linespec.h. */
1170 decode_line_full (char **argptr, int flags,
1171 struct symtab *default_symtab,
1172 int default_line, struct linespec_result *canonical,
1173 const char *select_mode,
1176 struct symtabs_and_lines result;
1177 struct linespec_state state;
1178 struct cleanup *cleanups;
1179 char *arg_start = *argptr;
1180 VEC (const_char_ptr) *filters = NULL;
1182 gdb_assert (canonical != NULL);
1183 /* The filter only makes sense for 'all'. */
1184 gdb_assert (filter == NULL || select_mode == multiple_symbols_all);
1185 gdb_assert (select_mode == NULL
1186 || select_mode == multiple_symbols_all
1187 || select_mode == multiple_symbols_ask
1188 || select_mode == multiple_symbols_cancel);
1189 gdb_assert ((flags & DECODE_LINE_LIST_MODE) == 0);
1191 linespec_state_constructor (&state, flags,
1192 default_symtab, default_line, canonical);
1193 cleanups = make_cleanup (linespec_state_destructor, &state);
1194 save_current_program_space ();
1196 result = decode_line_internal (&state, argptr);
1198 gdb_assert (result.nelts == 1 || canonical->pre_expanded);
1199 gdb_assert (canonical->addr_string != NULL);
1200 canonical->pre_expanded = 1;
1202 /* Fill in the missing canonical names. */
1203 if (result.nelts > 0)
1207 if (state.canonical_names == NULL)
1208 state.canonical_names = xcalloc (result.nelts, sizeof (char *));
1209 make_cleanup (xfree, state.canonical_names);
1210 for (i = 0; i < result.nelts; ++i)
1212 if (state.canonical_names[i] == NULL)
1213 state.canonical_names[i] = savestring (arg_start,
1214 *argptr - arg_start);
1215 make_cleanup (xfree, state.canonical_names[i]);
1219 if (select_mode == NULL)
1221 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
1222 select_mode = multiple_symbols_all;
1224 select_mode = multiple_symbols_select_mode ();
1227 if (select_mode == multiple_symbols_all)
1231 make_cleanup (VEC_cleanup (const_char_ptr), &filters);
1232 VEC_safe_push (const_char_ptr, filters, filter);
1233 filter_results (&state, &result, filters);
1236 convert_results_to_lsals (&state, &result);
1239 decode_line_2 (&state, &result, select_mode);
1241 do_cleanups (cleanups);
1244 struct symtabs_and_lines
1245 decode_line_1 (char **argptr, int flags,
1246 struct symtab *default_symtab,
1249 struct symtabs_and_lines result;
1250 struct linespec_state state;
1251 struct cleanup *cleanups;
1253 linespec_state_constructor (&state, flags,
1254 default_symtab, default_line, NULL);
1255 cleanups = make_cleanup (linespec_state_destructor, &state);
1256 save_current_program_space ();
1258 result = decode_line_internal (&state, argptr);
1259 do_cleanups (cleanups);
1265 /* First, some functions to initialize stuff at the beggining of the
1269 initialize_defaults (struct symtab **default_symtab, int *default_line)
1271 if (*default_symtab == 0)
1273 /* Use whatever we have for the default source line. We don't use
1274 get_current_or_default_symtab_and_line as it can recurse and call
1276 struct symtab_and_line cursal =
1277 get_current_source_symtab_and_line ();
1279 *default_symtab = cursal.symtab;
1280 *default_line = cursal.line;
1286 /* Decode arg of the form *PC. */
1288 static struct symtabs_and_lines
1289 decode_indirect (struct linespec_state *self, char **argptr)
1291 struct symtabs_and_lines values;
1293 char *initial = *argptr;
1295 if (current_program_space->executing_startup)
1296 /* The error message doesn't really matter, because this case
1297 should only hit during breakpoint reset. */
1298 throw_error (NOT_FOUND_ERROR, _("cannot evaluate expressions while "
1299 "program space is in startup"));
1302 pc = value_as_address (parse_to_comma_and_eval (argptr));
1304 values.sals = (struct symtab_and_line *)
1305 xmalloc (sizeof (struct symtab_and_line));
1308 values.sals[0] = find_pc_line (pc, 0);
1309 values.sals[0].pc = pc;
1310 values.sals[0].section = find_pc_overlay (pc);
1311 values.sals[0].explicit_pc = 1;
1313 if (self->canonical)
1314 self->canonical->addr_string = savestring (initial, *argptr - initial);
1321 /* Locate the first half of the linespec, ending in a colon, period,
1322 or whitespace. (More or less.) Also, check to see if *ARGPTR is
1323 enclosed in double quotes; if so, set is_quote_enclosed, advance
1324 ARGPTR past that and zero out the trailing double quote.
1325 If ARGPTR is just a simple name like "main", p will point to ""
1329 locate_first_half (char **argptr, int *is_quote_enclosed)
1335 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1336 and we must isolate the first half. Outer layers will call again later
1337 for the second half.
1339 Don't count commas that appear in argument lists of overloaded
1340 functions, or in quoted strings. It's stupid to go to this much
1341 trouble when the rest of the function is such an obvious roach hotel. */
1342 ii = find_toplevel_char (*argptr, ',');
1343 has_comma = (ii != 0);
1345 /* Temporarily zap out second half to not confuse the code below.
1346 This is undone below. Do not change ii!! */
1352 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
1353 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
1359 *is_quote_enclosed = 1;
1365 *is_quote_enclosed = 0;
1366 if (strchr (get_gdb_completer_quote_characters (), *p))
1374 /* Check for a drive letter in the filename. This is done on all hosts
1375 to capture cross-compilation environments. On Unixen, directory
1376 separators are illegal in filenames, so if the user enters "e:/foo.c",
1377 he is referring to a directory named "e:" and a source file named
1378 "foo.c", and we still want to keep these two pieces together. */
1379 if (isalpha (p[0]) && p[1] == ':' && IS_DIR_SEPARATOR (p[2]))
1386 char *temp_end = find_template_name_end (p);
1389 error (_("malformed template specification in command"));
1394 p = find_method_overload_end (p);
1396 /* Check for a colon and a plus or minus and a [ (which
1397 indicates an Objective-C method). */
1398 if (is_objc_method_format (p))
1402 /* Check for the end of the first half of the linespec. End of
1403 line, a tab, a colon or a space. But if enclosed in double
1404 quotes we do not break on enclosed spaces. */
1408 || ((p[0] == ' ') && !*is_quote_enclosed))
1410 if (p[0] == '.' && strchr (p, ':') == NULL)
1412 /* Java qualified method. Find the *last* '.', since the
1413 others are package qualifiers. Stop at any open parenthesis
1414 which might provide overload information. */
1415 for (p1 = p; *p1 && *p1 != '('; p1++)
1423 p = skip_spaces (p);
1425 /* If the closing double quote was left at the end, remove it. */
1426 if (*is_quote_enclosed)
1428 char *closing_quote = strchr (p - 1, '"');
1430 if (closing_quote && closing_quote[1] == '\0')
1431 *closing_quote = '\0';
1434 /* Now that we've safely parsed the first half, put back ',' so
1435 outer layers can see it. */
1444 /* Here's where we recognise an Objective-C Selector. An Objective C
1445 selector may be implemented by more than one class, therefore it
1446 may represent more than one method/function. This gives us a
1447 situation somewhat analogous to C++ overloading. If there's more
1448 than one method that could represent the selector, then use some of
1449 the existing C++ code to let the user choose one. */
1451 static struct symtabs_and_lines
1452 decode_objc (struct linespec_state *self, char **argptr)
1454 struct collect_info info;
1455 VEC (const_char_ptr) *symbol_names = NULL;
1457 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
1461 info.result.sals = NULL;
1462 info.result.nelts = 0;
1463 info.objfile = NULL;
1465 new_argptr = find_imps (*argptr, &symbol_names);
1466 if (VEC_empty (const_char_ptr, symbol_names))
1468 do_cleanups (cleanup);
1472 add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
1474 if (info.result.nelts > 0)
1478 saved_arg = alloca (new_argptr - *argptr + 1);
1479 memcpy (saved_arg, *argptr, new_argptr - *argptr);
1480 saved_arg[new_argptr - *argptr] = '\0';
1482 if (self->canonical)
1484 self->canonical->pre_expanded = 1;
1485 if (self->user_filename)
1486 self->canonical->addr_string
1487 = xstrprintf ("%s:%s", self->user_filename, saved_arg);
1489 self->canonical->addr_string = xstrdup (saved_arg);
1493 *argptr = new_argptr;
1495 do_cleanups (cleanup);
1499 /* This handles C++ and Java compound data structures. P should point
1500 at the first component separator, i.e. double-colon or period. As
1501 an example, on entrance to this function we could have ARGPTR
1502 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
1504 static struct symtabs_and_lines
1505 decode_compound (struct linespec_state *self,
1506 char **argptr, char *the_real_saved_arg, char *p)
1508 struct symtabs_and_lines values;
1510 char *saved_arg2 = *argptr;
1514 VEC (symbolp) *sym_classes;
1515 char *saved_arg, *class_name;
1516 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1518 /* If the user specified any completer quote characters in the input,
1519 strip them. They are superfluous. */
1520 saved_arg = alloca (strlen (the_real_saved_arg) + 1);
1522 char *dst = saved_arg;
1523 char *src = the_real_saved_arg;
1524 char *quotes = get_gdb_completer_quote_characters ();
1525 while (*src != '\0')
1527 if (strchr (quotes, *src) == NULL)
1534 /* First check for "global" namespace specification, of the form
1535 "::foo". If found, skip over the colons and jump to normal
1536 symbol processing. I.e. the whole line specification starts with
1537 "::" (note the condition that *argptr == p). */
1539 && ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t')))
1542 /* Given our example "AAA::inA::fun", we have two cases to consider:
1544 1) AAA::inA is the name of a class. In that case, presumably it
1545 has a method called "fun"; we then look up that method using
1548 2) AAA::inA isn't the name of a class. In that case, either the
1549 user made a typo, AAA::inA is the name of a namespace, or it is
1550 the name of a minimal symbol.
1551 In this case we just delegate to decode_variable.
1553 Thus, our first task is to find everything before the last set of
1554 double-colons and figure out if it's the name of a class. So we
1555 first loop through all of the double-colons. */
1557 p2 = p; /* Save for restart. */
1559 /* This is very messy. Following the example above we have now the
1562 argptr -> "AAA::inA::fun
1563 saved_arg -> "AAA::inA::fun
1564 saved_arg2 -> "AAA::inA::fun
1565 p2 -> "::inA::fun". */
1567 /* In the loop below, with these strings, we'll make 2 passes, each
1568 is marked in comments. */
1572 static char *break_characters = " \t(";
1574 /* Move pointer up to next possible class/namespace token. */
1576 p = p2 + 1; /* Restart with old value +1. */
1578 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1579 i.e. if there is a double-colon, p will now point to the
1581 /* PASS2: p2->"::fun", p->":fun" */
1583 /* Move pointer ahead to next double-colon. */
1585 && strchr (break_characters, *p) == NULL
1586 && strchr (get_gdb_completer_quote_characters (), *p) == NULL)
1588 if (current_language->la_language == language_cplus)
1589 p += cp_validate_operator (p);
1593 temp_end = find_template_name_end (p);
1595 error (_("malformed template specification in command"));
1598 /* Note that, since, at the start of this loop, p would be
1599 pointing to the second colon in a double-colon, we only
1600 satisfy the condition below if there is another
1601 double-colon to the right (after). I.e. there is another
1602 component that can be a class or a namespace. I.e, if at
1603 the beginning of this loop (PASS1), we had
1604 p->":inA::fun", we'll trigger this when p has been
1605 advanced to point to "::fun". */
1606 /* PASS2: we will not trigger this. */
1607 else if ((p[0] == ':') && (p[1] == ':'))
1608 break; /* Found double-colon. */
1611 /* PASS2: We'll keep getting here, until P points to one of the
1612 break characters, at which point we exit this loop. */
1616 && strncmp (&p[1], CP_ANONYMOUS_NAMESPACE_STR,
1617 CP_ANONYMOUS_NAMESPACE_LEN) == 0)
1618 p += CP_ANONYMOUS_NAMESPACE_LEN;
1619 else if (strchr (break_characters, *p) == NULL)
1626 break; /* Out of the while (1). This would happen
1627 for instance if we have looked up
1628 unsuccessfully all the components of the
1629 string, and p->""(PASS2). */
1631 /* We get here if p points to one of the break characters or "" (i.e.,
1633 /* Save restart for next time around. */
1635 /* Restore argptr as it was on entry to this function. */
1636 *argptr = saved_arg2;
1637 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1640 /* All ready for next pass through the loop. */
1644 /* Start of lookup in the symbol tables. */
1646 /* Lookup in the symbol table the substring between argptr and
1647 p. Note, this call changes the value of argptr. */
1648 /* Before the call, argptr->"AAA::inA::fun",
1649 p->"", p2->"::fun". After the call: argptr->"fun", p, p2
1651 sym_classes = lookup_prefix_sym (argptr, p2, self->file_symtabs,
1653 make_cleanup (VEC_cleanup (symbolp), &sym_classes);
1654 make_cleanup (xfree, class_name);
1656 /* If a class has been found, then we're in case 1 above. So we
1657 look up "fun" as a method of those classes. */
1658 if (!VEC_empty (symbolp, sym_classes))
1660 /* Arg token is not digits => try it as a function name.
1661 Find the next token (everything up to end or next
1664 && strchr (get_gdb_completer_quote_characters (),
1667 p = skip_quoted (*argptr);
1668 *argptr = *argptr + 1;
1672 /* At this point argptr->"fun". */
1676 while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':'
1679 /* At this point p->"". String ended. */
1680 /* Nope, C++ operators could have spaces in them
1681 ("foo::operator <" or "foo::operator delete []").
1682 I apologize, this is a bit hacky... */
1683 if (current_language->la_language == language_cplus
1684 && *p == ' ' && p - 8 - *argptr + 1 > 0)
1686 /* The above loop has already swallowed "operator". */
1687 p += cp_validate_operator (p - 8) - 8;
1690 /* Keep any important naming information. */
1691 p = keep_name_info (p, 1);
1694 /* Allocate our own copy of the substring between argptr and
1696 copy = (char *) alloca (p - *argptr + 1);
1697 memcpy (copy, *argptr, p - *argptr);
1698 copy[p - *argptr] = '\0';
1700 && copy[p - *argptr - 1]
1701 && strchr (get_gdb_completer_quote_characters (),
1702 copy[p - *argptr - 1]) != NULL)
1703 copy[p - *argptr - 1] = '\0';
1705 /* At this point copy->"fun", p->"". */
1707 /* No line number may be specified. */
1708 *argptr = skip_spaces (p);
1709 /* At this point arptr->"". */
1711 /* Look for copy as a method of sym_class. */
1712 /* At this point copy->"fun", sym_class is "AAA:inA",
1713 saved_arg->"AAA::inA::fun". This concludes the scanning of
1714 the string for possible components matches. If we find it
1715 here, we return. If not, and we are at the and of the string,
1716 we'll lookup the whole string in the symbol tables. */
1718 values = find_method (self, saved_arg, copy, class_name, sym_classes);
1720 do_cleanups (cleanup);
1722 } /* End if symbol found. */
1725 /* We couldn't find a class, so we're in case 2 above. We check the
1726 entire name as a symbol instead. The simplest way to do this is
1727 to just throw an exception and let our caller fall through to
1730 throw_error (NOT_FOUND_ERROR, _("see caller, this text doesn't matter"));
1733 /* An instance of this type is used when collecting prefix symbols for
1736 struct decode_compound_collector
1738 /* The result vector. */
1739 VEC (symbolp) *symbols;
1741 /* A hash table of all symbols we found. We use this to avoid
1742 adding any symbol more than once. */
1746 /* A callback for iterate_over_symbols that is used by
1747 lookup_prefix_sym to collect type symbols. */
1750 collect_one_symbol (struct symbol *sym, void *d)
1752 struct decode_compound_collector *collector = d;
1756 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1759 t = SYMBOL_TYPE (sym);
1761 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1762 && TYPE_CODE (t) != TYPE_CODE_UNION
1763 && TYPE_CODE (t) != TYPE_CODE_NAMESPACE)
1766 slot = htab_find_slot (collector->unique_syms, sym, INSERT);
1770 VEC_safe_push (symbolp, collector->symbols, sym);
1776 /* Return the symbol corresponding to the substring of *ARGPTR ending
1777 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1778 name in question, the compound object separator ("::" or "."), and
1779 whitespace. Note that *ARGPTR is changed whether or not the
1780 this call finds anything (i.e we return NULL). As an
1781 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
1783 static VEC (symbolp) *
1784 lookup_prefix_sym (char **argptr, char *p, VEC (symtab_p) *file_symtabs,
1791 struct decode_compound_collector collector;
1792 struct cleanup *outer;
1793 struct cleanup *cleanup;
1794 struct block *search_block;
1796 /* Extract the class name. */
1798 while (p != *argptr && p[-1] == ' ')
1800 copy = (char *) xmalloc (p - *argptr + 1);
1801 memcpy (copy, *argptr, p - *argptr);
1802 copy[p - *argptr] = 0;
1804 outer = make_cleanup (xfree, copy);
1806 /* Discard the class name from the argptr. */
1807 p = p1 + (p1[0] == ':' ? 2 : 1);
1808 p = skip_spaces (p);
1811 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1812 argptr->"inA::fun". */
1814 collector.symbols = NULL;
1815 make_cleanup (VEC_cleanup (symbolp), &collector.symbols);
1817 collector.unique_syms = htab_create_alloc (1, htab_hash_pointer,
1818 htab_eq_pointer, NULL,
1820 cleanup = make_cleanup_htab_delete (collector.unique_syms);
1822 for (ix = 0; VEC_iterate (symtab_p, file_symtabs, ix, elt); ++ix)
1826 iterate_over_all_matching_symtabs (copy, STRUCT_DOMAIN,
1827 collect_one_symbol, &collector,
1829 iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
1830 collect_one_symbol, &collector,
1835 struct block *search_block;
1837 /* Program spaces that are executing startup should have
1838 been filtered out earlier. */
1839 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
1840 set_current_program_space (SYMTAB_PSPACE (elt));
1841 search_block = get_search_block (elt);
1842 LA_ITERATE_OVER_SYMBOLS (search_block, copy, STRUCT_DOMAIN,
1843 collect_one_symbol, &collector);
1844 LA_ITERATE_OVER_SYMBOLS (search_block, copy, VAR_DOMAIN,
1845 collect_one_symbol, &collector);
1849 do_cleanups (cleanup);
1850 discard_cleanups (outer);
1851 return collector.symbols;
1854 /* A qsort comparison function for symbols. The resulting order does
1855 not actually matter; we just need to be able to sort them so that
1856 symbols with the same program space end up next to each other. */
1859 compare_symbols (const void *a, const void *b)
1861 struct symbol * const *sa = a;
1862 struct symbol * const *sb = b;
1865 uia = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa));
1866 uib = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb));
1873 uia = (uintptr_t) *sa;
1874 uib = (uintptr_t) *sb;
1884 /* Look for all the matching instances of each symbol in NAMES. Only
1885 instances from PSPACE are considered; other program spaces are
1886 handled by our caller. If PSPACE is NULL, then all program spaces
1887 are considered. Results are stored into INFO. */
1890 add_all_symbol_names_from_pspace (struct collect_info *info,
1891 struct program_space *pspace,
1892 VEC (const_char_ptr) *names)
1897 for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix)
1898 add_matching_symbols_to_info (iter, info, pspace);
1902 find_superclass_methods (VEC (typep) *superclasses,
1904 VEC (const_char_ptr) **result_names)
1906 int old_len = VEC_length (const_char_ptr, *result_names);
1907 VEC (typep) *iter_classes;
1908 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1910 iter_classes = superclasses;
1913 VEC (typep) *new_supers = NULL;
1917 make_cleanup (VEC_cleanup (typep), &new_supers);
1918 for (ix = 0; VEC_iterate (typep, iter_classes, ix, t); ++ix)
1919 find_methods (t, name, result_names, &new_supers);
1921 if (VEC_length (const_char_ptr, *result_names) != old_len
1922 || VEC_empty (typep, new_supers))
1925 iter_classes = new_supers;
1928 do_cleanups (cleanup);
1931 /* This finds the method COPY in the class whose type is given by one
1932 of the symbols in SYM_CLASSES. */
1934 static struct symtabs_and_lines
1935 find_method (struct linespec_state *self, char *saved_arg,
1936 char *copy, const char *class_name, VEC (symbolp) *sym_classes)
1940 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1942 int last_result_len;
1943 VEC (typep) *superclass_vec;
1944 VEC (const_char_ptr) *result_names;
1945 struct collect_info info;
1948 /* NAME is typed by the user: it needs to be canonicalized before
1949 searching the symbol tables. */
1950 canon = cp_canonicalize_string_no_typedefs (copy);
1954 make_cleanup (xfree, copy);
1957 /* Sort symbols so that symbols with the same program space are next
1959 qsort (VEC_address (symbolp, sym_classes),
1960 VEC_length (symbolp, sym_classes),
1965 info.result.sals = NULL;
1966 info.result.nelts = 0;
1967 info.objfile = NULL;
1969 /* Iterate over all the types, looking for the names of existing
1970 methods matching COPY. If we cannot find a direct method in a
1971 given program space, then we consider inherited methods; this is
1972 not ideal (ideal would be to respect C++ hiding rules), but it
1973 seems good enough and is what GDB has historically done. We only
1974 need to collect the names because later we find all symbols with
1975 those names. This loop is written in a somewhat funny way
1976 because we collect data across the program space before deciding
1978 superclass_vec = NULL;
1979 make_cleanup (VEC_cleanup (typep), &superclass_vec);
1980 result_names = NULL;
1981 make_cleanup (VEC_cleanup (const_char_ptr), &result_names);
1982 last_result_len = 0;
1983 for (ix = 0; VEC_iterate (symbolp, sym_classes, ix, sym); ++ix)
1986 struct program_space *pspace;
1988 /* Program spaces that are executing startup should have
1989 been filtered out earlier. */
1990 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym))->executing_startup);
1991 pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
1992 set_current_program_space (pspace);
1993 t = check_typedef (SYMBOL_TYPE (sym));
1994 find_methods (t, copy, &result_names, &superclass_vec);
1996 /* Handle all items from a single program space at once; and be
1997 sure not to miss the last batch. */
1998 if (ix == VEC_length (symbolp, sym_classes) - 1
2000 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp, sym_classes,
2003 /* If we did not find a direct implementation anywhere in
2004 this program space, consider superclasses. */
2005 if (VEC_length (const_char_ptr, result_names) == last_result_len)
2006 find_superclass_methods (superclass_vec, copy, &result_names);
2008 /* We have a list of candidate symbol names, so now we
2009 iterate over the symbol tables looking for all
2010 matches in this pspace. */
2011 add_all_symbol_names_from_pspace (&info, pspace, result_names);
2013 VEC_truncate (typep, superclass_vec, 0);
2014 last_result_len = VEC_length (const_char_ptr, result_names);
2018 if (info.result.nelts > 0)
2020 if (self->canonical)
2022 self->canonical->pre_expanded = 1;
2023 if (self->user_filename)
2024 self->canonical->addr_string
2025 = xstrprintf ("%s:%s", self->user_filename, saved_arg);
2027 self->canonical->addr_string = xstrdup (saved_arg);
2030 do_cleanups (cleanup);
2036 cplusplus_error (saved_arg,
2037 "the class `%s' does not have destructor defined\n",
2040 cplusplus_error (saved_arg,
2041 "the class %s does not have any method named %s\n",
2047 /* This object is used when collecting all matching symtabs. */
2049 struct symtab_collector
2051 /* The result vector of symtabs. */
2052 VEC (symtab_p) *symtabs;
2054 /* This is used to ensure the symtabs are unique. */
2055 htab_t symtab_table;
2058 /* Callback for iterate_over_symtabs. */
2061 add_symtabs_to_list (struct symtab *symtab, void *d)
2063 struct symtab_collector *data = d;
2066 slot = htab_find_slot (data->symtab_table, symtab, INSERT);
2070 VEC_safe_push (symtab_p, data->symtabs, symtab);
2076 /* Given a file name, return a VEC of all matching symtabs. */
2078 static VEC (symtab_p) *
2079 collect_symtabs_from_filename (const char *file)
2081 struct symtab_collector collector;
2082 struct cleanup *cleanups;
2083 struct program_space *pspace;
2085 collector.symtabs = NULL;
2086 collector.symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer,
2088 cleanups = make_cleanup_htab_delete (collector.symtab_table);
2090 /* Find that file's data. */
2091 ALL_PSPACES (pspace)
2093 if (pspace->executing_startup)
2096 set_current_program_space (pspace);
2097 iterate_over_symtabs (file, add_symtabs_to_list, &collector);
2100 do_cleanups (cleanups);
2101 return collector.symtabs;
2104 /* Return all the symtabs associated to the filename given by the
2105 substring of *ARGPTR ending at P, and advance ARGPTR past that
2108 static VEC (symtab_p) *
2109 symtabs_from_filename (char **argptr, char *p, int is_quote_enclosed,
2110 char **user_filename)
2114 struct cleanup *outer;
2115 VEC (symtab_p) *result;
2118 while (p != *argptr && p[-1] == ' ')
2120 if ((*p == '"') && is_quote_enclosed)
2122 copy = xmalloc (p - *argptr + 1);
2123 outer = make_cleanup (xfree, copy);
2124 memcpy (copy, *argptr, p - *argptr);
2125 /* It may have the ending quote right after the file name. */
2126 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
2127 || copy[p - *argptr - 1] == '\'')
2128 copy[p - *argptr - 1] = 0;
2130 copy[p - *argptr] = 0;
2132 result = collect_symtabs_from_filename (copy);
2134 if (VEC_empty (symtab_p, result))
2136 if (!have_full_symbols () && !have_partial_symbols ())
2137 throw_error (NOT_FOUND_ERROR,
2138 _("No symbol table is loaded. "
2139 "Use the \"file\" command."));
2140 throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy);
2143 /* Discard the file name from the arg. */
2147 *argptr = skip_spaces (p1 + 1);
2149 discard_cleanups (outer);
2150 *user_filename = copy;
2154 /* A callback used by iterate_over_all_matching_symtabs that collects
2155 symbols for find_function_symbols. */
2158 collect_function_symbols (struct symbol *sym, void *arg)
2160 VEC (symbolp) **syms = arg;
2162 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2163 VEC_safe_push (symbolp, *syms, sym);
2168 /* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR
2169 and return the symbol. If not found, return NULL. */
2171 static VEC (symbolp) *
2172 find_function_symbols (char **argptr, char *p, int is_quote_enclosed,
2173 char **user_function)
2177 VEC (symbolp) *result = NULL;
2180 while (p != *argptr && p[-1] == ' ')
2182 if ((*p == '"') && is_quote_enclosed)
2184 copy = (char *) xmalloc (p - *argptr + 1);
2185 *user_function = copy;
2186 memcpy (copy, *argptr, p - *argptr);
2187 /* It may have the ending quote right after the file name. */
2188 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
2189 || copy[p - *argptr - 1] == '\'')
2190 copy[p - *argptr - 1] = 0;
2192 copy[p - *argptr] = 0;
2194 iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
2195 collect_function_symbols, &result, NULL);
2197 if (VEC_empty (symbolp, result))
2198 VEC_free (symbolp, result);
2201 /* Discard the file name from the arg. */
2202 *argptr = skip_spaces (p1 + 1);
2210 /* A helper for decode_all_digits that handles the 'list_mode' case. */
2213 decode_digits_list_mode (struct linespec_state *self,
2214 struct symtabs_and_lines *values,
2215 struct symtab_and_line val)
2220 gdb_assert (self->list_mode);
2222 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2224 /* The logic above should ensure this. */
2225 gdb_assert (elt != NULL);
2227 set_current_program_space (SYMTAB_PSPACE (elt));
2229 /* Simplistic search just for the list command. */
2230 val.symtab = find_line_symtab (elt, val.line, NULL, NULL);
2231 if (val.symtab == NULL)
2233 val.pspace = SYMTAB_PSPACE (elt);
2235 val.explicit_line = 1;
2237 add_sal_to_sals (self, values, &val, NULL);
2241 /* A helper for decode_all_digits that iterates over the symtabs,
2242 adding lines to the VEC. */
2245 decode_digits_ordinary (struct linespec_state *self,
2247 struct symtabs_and_lines *sals,
2248 struct linetable_entry **best_entry)
2253 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2256 VEC (CORE_ADDR) *pcs;
2259 /* The logic above should ensure this. */
2260 gdb_assert (elt != NULL);
2262 set_current_program_space (SYMTAB_PSPACE (elt));
2264 pcs = find_pcs_for_symtab_line (elt, line, best_entry);
2265 for (i = 0; VEC_iterate (CORE_ADDR, pcs, i, pc); ++i)
2267 struct symtab_and_line sal;
2270 sal.pspace = SYMTAB_PSPACE (elt);
2274 add_sal_to_sals_basic (sals, &sal);
2277 VEC_free (CORE_ADDR, pcs);
2281 /* This decodes a line where the argument is all digits (possibly
2282 preceded by a sign). Q should point to the end of those digits;
2283 the other arguments are as usual. */
2285 static struct symtabs_and_lines
2286 decode_all_digits (struct linespec_state *self,
2290 struct symtabs_and_lines values;
2291 struct symtab_and_line val;
2292 int use_default = 0;
2293 char *saved_arg = *argptr;
2305 /* This is where we need to make sure that we have good defaults.
2306 We must guarantee that this section of code is never executed
2307 when we are called with just a function name, since
2308 set_default_source_symtab_and_line uses
2309 select_source_symtab that calls us with such an argument. */
2311 if (VEC_length (symtab_p, self->file_symtabs) == 1
2312 && VEC_index (symtab_p, self->file_symtabs, 0) == NULL)
2314 set_current_program_space (self->program_space);
2316 /* Make sure we have at least a default source file. */
2317 set_default_source_symtab_and_line ();
2318 initialize_defaults (&self->default_symtab, &self->default_line);
2319 VEC_pop (symtab_p, self->file_symtabs);
2320 VEC_free (symtab_p, self->file_symtabs);
2322 = collect_symtabs_from_filename (self->default_symtab->filename);
2326 if (**argptr == '+')
2327 sign = plus, (*argptr)++;
2328 else if (**argptr == '-')
2329 sign = minus, (*argptr)++;
2330 val.line = atoi (*argptr);
2337 val.line = self->default_line + val.line;
2343 val.line = self->default_line - val.line;
2348 break; /* No need to adjust val.line. */
2351 *argptr = skip_spaces (q);
2353 if (self->list_mode)
2354 decode_digits_list_mode (self, &values, val);
2357 struct linetable_entry *best_entry = NULL;
2359 struct block **blocks;
2360 struct cleanup *cleanup;
2361 struct symtabs_and_lines intermediate_results;
2364 intermediate_results.sals = NULL;
2365 intermediate_results.nelts = 0;
2367 decode_digits_ordinary (self, val.line, &intermediate_results,
2369 if (intermediate_results.nelts == 0 && best_entry != NULL)
2370 decode_digits_ordinary (self, best_entry->line, &intermediate_results,
2373 cleanup = make_cleanup (xfree, intermediate_results.sals);
2375 /* For optimized code, compiler can scatter one source line
2376 accross disjoint ranges of PC values, even when no duplicate
2377 functions or inline functions are involved. For example,
2378 'for (;;)' inside non-template non-inline non-ctor-or-dtor
2379 function can result in two PC ranges. In this case, we don't
2380 want to set breakpoint on first PC of each range. To filter
2381 such cases, we use containing blocks -- for each PC found
2382 above we see if there are other PCs that are in the same
2383 block. If yes, the other PCs are filtered out. */
2385 filter = xmalloc (intermediate_results.nelts * sizeof (int));
2386 make_cleanup (xfree, filter);
2387 blocks = xmalloc (intermediate_results.nelts * sizeof (struct block *));
2388 make_cleanup (xfree, blocks);
2390 for (i = 0; i < intermediate_results.nelts; ++i)
2392 set_current_program_space (intermediate_results.sals[i].pspace);
2395 blocks[i] = block_for_pc_sect (intermediate_results.sals[i].pc,
2396 intermediate_results.sals[i].section);
2399 for (i = 0; i < intermediate_results.nelts; ++i)
2401 if (blocks[i] != NULL)
2402 for (j = i + 1; j < intermediate_results.nelts; ++j)
2404 if (blocks[j] == blocks[i])
2412 for (i = 0; i < intermediate_results.nelts; ++i)
2415 struct symbol *sym = (blocks[i]
2416 ? block_containing_function (blocks[i])
2419 if (self->funfirstline)
2420 skip_prologue_sal (&intermediate_results.sals[i]);
2421 /* Make sure the line matches the request, not what was
2423 intermediate_results.sals[i].line = val.line;
2424 add_sal_to_sals (self, &values, &intermediate_results.sals[i],
2425 sym ? SYMBOL_NATURAL_NAME (sym) : NULL);
2428 do_cleanups (cleanup);
2431 if (values.nelts == 0)
2433 if (self->user_filename)
2434 throw_error (NOT_FOUND_ERROR, _("No line %d in file \"%s\"."),
2435 val.line, self->user_filename);
2437 throw_error (NOT_FOUND_ERROR, _("No line %d in the current file."),
2441 if (self->canonical)
2443 char *copy = savestring (saved_arg, q - saved_arg);
2445 self->canonical->pre_expanded = 1;
2446 gdb_assert (self->user_filename || use_default);
2447 self->canonical->addr_string
2448 = xstrprintf ("%s:%s", (self->user_filename
2449 ? self->user_filename
2450 : self->default_symtab->filename),
2460 /* Decode a linespec starting with a dollar sign. */
2462 static struct symtabs_and_lines
2463 decode_dollar (struct linespec_state *self, char *copy)
2467 struct symtabs_and_lines values;
2468 struct symtab_and_line val;
2471 struct minimal_symbol *msymbol;
2475 p = (copy[1] == '$') ? copy + 2 : copy + 1;
2476 while (*p >= '0' && *p <= '9')
2478 if (!*p) /* Reached end of token without hitting non-digit. */
2480 /* We have a value history reference. */
2481 struct value *val_history;
2483 sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index);
2484 val_history = access_value_history ((copy[1] == '$') ? -index : index);
2485 if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
2486 error (_("History values used in line "
2487 "specs must have integer values."));
2488 valx = value_as_long (val_history);
2492 /* Not all digits -- may be user variable/function or a
2493 convenience variable. */
2495 volatile struct gdb_exception exc;
2497 TRY_CATCH (exc, RETURN_MASK_ERROR)
2499 values = decode_variable (self, copy);
2502 if (exc.reason == 0)
2505 if (exc.error != NOT_FOUND_ERROR)
2506 throw_exception (exc);
2508 /* Not a user variable or function -- must be convenience variable. */
2509 if (!get_internalvar_integer (lookup_internalvar (copy + 1), &valx))
2510 error (_("Convenience variables used in line "
2511 "specs must have integer values."));
2519 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2523 elt = self->default_symtab;
2524 set_current_program_space (self->program_space);
2527 set_current_program_space (SYMTAB_PSPACE (elt));
2529 /* Either history value or convenience value from above, in valx. */
2533 val.pspace = elt ? SYMTAB_PSPACE (elt) : current_program_space;
2535 add_sal_to_sals (self, &values, &val, NULL);
2538 if (self->canonical)
2540 self->canonical->pre_expanded = 1;
2541 if (self->user_filename)
2542 self->canonical->addr_string = xstrprintf ("%s:%s",
2543 self->user_filename, copy);
2545 self->canonical->addr_string = xstrdup (copy);
2553 /* A helper for decode_line_1 that tries to find a label. The label
2554 is searched for in the current block.
2555 FUNCTION_SYMBOLS is a list of the enclosing functions; or NULL if none
2557 COPY is the name of the label to find.
2558 CANONICAL is the same as the "canonical" argument to decode_line_1.
2559 RESULT is a pointer to a symtabs_and_lines structure which will be
2560 filled in on success.
2561 This function returns 1 if a label was found, 0 otherwise. */
2564 decode_label (struct linespec_state *self,
2565 VEC (symbolp) *function_symbols, char *copy,
2566 struct symtabs_and_lines *result)
2568 struct symbol *fn_sym;
2571 if (function_symbols == NULL)
2573 struct block *block;
2575 struct symtab_and_line sal;
2576 struct symtabs_and_lines values;
2581 set_current_program_space (self->program_space);
2582 block = get_search_block (NULL);
2585 block && !BLOCK_FUNCTION (block);
2586 block = BLOCK_SUPERBLOCK (block))
2590 fn_sym = BLOCK_FUNCTION (block);
2592 sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0);
2597 symbol_to_sal (&sal, self->funfirstline, sym);
2598 add_sal_to_sals (self, &values, &sal,
2599 SYMBOL_NATURAL_NAME (fn_sym));
2601 if (self->canonical)
2603 self->canonical->special_display = 1;
2604 self->canonical->addr_string
2605 = xstrprintf ("%s:%s", SYMBOL_NATURAL_NAME (fn_sym),
2614 result->sals = NULL;
2617 for (ix = 0; VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix)
2619 struct block *block;
2622 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym)));
2623 block = SYMBOL_BLOCK_VALUE (fn_sym);
2624 sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0);
2628 struct symtab_and_line sal;
2631 symbol_to_sal (&sal, self->funfirstline, sym);
2632 symname = xstrprintf ("%s:%s",
2633 SYMBOL_NATURAL_NAME (fn_sym),
2634 SYMBOL_NATURAL_NAME (sym));
2635 add_sal_to_sals (self, result, &sal, symname);
2640 if (self->canonical && result->nelts > 0)
2642 self->canonical->pre_expanded = 1;
2643 self->canonical->special_display = 1;
2645 gdb_assert (self->user_function);
2646 self->canonical->addr_string
2647 = xstrprintf ("%s:%s", self->user_function, copy);
2650 return result->nelts > 0;
2653 /* A callback used to possibly add a symbol to the results. */
2656 collect_symbols (struct symbol *sym, void *data)
2658 struct collect_info *info = data;
2659 struct symtab_and_line sal;
2661 if ((SYMBOL_CLASS (sym) == LOC_STATIC
2662 && !info->state->funfirstline
2663 && !maybe_add_address (info->state->addr_set,
2664 SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)),
2665 SYMBOL_VALUE_ADDRESS (sym)))
2666 || (SYMBOL_CLASS (sym) == LOC_BLOCK
2667 && !maybe_add_address (info->state->addr_set,
2668 SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)),
2669 BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))))
2673 else if (symbol_to_sal (&sal, info->state->funfirstline, sym))
2674 add_sal_to_sals (info->state, &info->result, &sal,
2675 SYMBOL_NATURAL_NAME (sym));
2680 /* We've found a minimal symbol MSYMBOL to associate with our
2681 linespec; add it to the result symtabs_and_lines. */
2684 minsym_found (struct linespec_state *self, struct objfile *objfile,
2685 struct minimal_symbol *msymbol,
2686 struct symtabs_and_lines *result)
2688 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2690 struct symtab_and_line sal;
2692 sal = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol),
2693 (struct obj_section *) 0, 0);
2694 sal.section = SYMBOL_OBJ_SECTION (msymbol);
2696 /* The minimal symbol might point to a function descriptor;
2697 resolve it to the actual code address instead. */
2698 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, ¤t_target);
2700 sal = find_pc_sect_line (pc, NULL, 0);
2702 if (self->funfirstline)
2703 skip_prologue_sal (&sal);
2705 add_sal_to_sals (self, result, &sal, SYMBOL_NATURAL_NAME (msymbol));
2708 /* Callback for iterate_over_minimal_symbols that may add the symbol
2712 check_minsym (struct minimal_symbol *minsym, void *d)
2714 struct collect_info *info = d;
2716 if (MSYMBOL_TYPE (minsym) == mst_unknown
2717 || MSYMBOL_TYPE (minsym) == mst_slot_got_plt
2718 || MSYMBOL_TYPE (minsym) == mst_solib_trampoline)
2720 /* Reject some odd ones. */
2722 else if (info->state->funfirstline
2723 && MSYMBOL_TYPE (minsym) != mst_text
2724 && MSYMBOL_TYPE (minsym) != mst_text_gnu_ifunc
2725 && MSYMBOL_TYPE (minsym) != mst_file_text)
2727 /* When FUNFIRSTLINE, only allow text symbols. */
2729 else if (maybe_add_address (info->state->addr_set, info->objfile->pspace,
2730 SYMBOL_VALUE_ADDRESS (minsym)))
2731 minsym_found (info->state, info->objfile, minsym, &info->result);
2734 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
2735 is not NULL, the search is restricted to just that program
2739 search_minsyms_for_name (struct collect_info *info, const char *name,
2740 struct program_space *search_pspace)
2742 struct objfile *objfile;
2743 struct program_space *pspace;
2745 ALL_PSPACES (pspace)
2747 if (search_pspace != NULL && search_pspace != pspace)
2749 if (pspace->executing_startup)
2752 set_current_program_space (pspace);
2754 ALL_OBJFILES (objfile)
2756 info->objfile = objfile;
2757 iterate_over_minimal_symbols (objfile, name, check_minsym, info);
2762 /* A helper function to add all symbols matching NAME to INFO. If
2763 PSPACE is not NULL, the search is restricted to just that program
2767 add_matching_symbols_to_info (const char *name,
2768 struct collect_info *info,
2769 struct program_space *pspace)
2774 for (ix = 0; VEC_iterate (symtab_p, info->state->file_symtabs, ix, elt); ++ix)
2780 iterate_over_all_matching_symtabs (name, VAR_DOMAIN,
2781 collect_symbols, info,
2783 search_minsyms_for_name (info, name, pspace);
2785 else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))
2787 /* Program spaces that are executing startup should have
2788 been filtered out earlier. */
2789 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
2790 set_current_program_space (SYMTAB_PSPACE (elt));
2791 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt), name,
2792 VAR_DOMAIN, collect_symbols,
2798 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
2799 look in that symtab's static variables first. */
2801 static struct symtabs_and_lines
2802 decode_variable (struct linespec_state *self, char *copy)
2804 struct collect_info info;
2805 const char *lookup_name;
2807 struct cleanup *cleanup;
2810 info.result.sals = NULL;
2811 info.result.nelts = 0;
2812 info.objfile = NULL;
2814 cleanup = demangle_for_lookup (copy, current_language->la_language,
2816 if (current_language->la_language == language_ada)
2818 /* In Ada, the symbol lookups are performed using the encoded
2819 name rather than the demangled name. */
2820 lookup_name = ada_name_for_lookup (copy);
2821 make_cleanup (xfree, (void *) lookup_name);
2824 canon = cp_canonicalize_string_no_typedefs (lookup_name);
2827 make_cleanup (xfree, canon);
2828 lookup_name = canon;
2831 add_matching_symbols_to_info (lookup_name, &info, NULL);
2833 if (info.result.nelts > 0)
2835 if (self->canonical)
2837 self->canonical->pre_expanded = 1;
2838 if (self->user_filename)
2839 self->canonical->addr_string
2840 = xstrprintf ("%s:%s", self->user_filename, copy);
2842 self->canonical->addr_string = xstrdup (copy);
2847 if (!have_full_symbols ()
2848 && !have_partial_symbols ()
2849 && !have_minimal_symbols ())
2850 throw_error (NOT_FOUND_ERROR,
2851 _("No symbol table is loaded. Use the \"file\" command."));
2852 if (self->user_filename)
2853 throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined in \"%s\"."),
2854 copy, self->user_filename);
2856 throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined."), copy);
2862 /* Now come some functions that are called from multiple places within
2866 symbol_to_sal (struct symtab_and_line *result,
2867 int funfirstline, struct symbol *sym)
2869 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2871 *result = find_function_start_sal (sym, funfirstline);
2876 if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
2879 result->symtab = SYMBOL_SYMTAB (sym);
2880 result->line = SYMBOL_LINE (sym);
2881 result->pc = SYMBOL_VALUE_ADDRESS (sym);
2882 result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2883 result->explicit_pc = 1;
2886 else if (funfirstline)
2890 else if (SYMBOL_LINE (sym) != 0)
2892 /* We know its line number. */
2894 result->symtab = SYMBOL_SYMTAB (sym);
2895 result->line = SYMBOL_LINE (sym);
2896 result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2904 /* See the comment in linespec.h. */
2907 init_linespec_result (struct linespec_result *lr)
2909 memset (lr, 0, sizeof (*lr));
2912 /* See the comment in linespec.h. */
2915 destroy_linespec_result (struct linespec_result *ls)
2918 struct linespec_sals *lsal;
2920 xfree (ls->addr_string);
2921 for (i = 0; VEC_iterate (linespec_sals, ls->sals, i, lsal); ++i)
2923 xfree (lsal->canonical);
2924 xfree (lsal->sals.sals);
2926 VEC_free (linespec_sals, ls->sals);
2929 /* Cleanup function for a linespec_result. */
2932 cleanup_linespec_result (void *a)
2934 destroy_linespec_result (a);
2937 /* See the comment in linespec.h. */
2940 make_cleanup_destroy_linespec_result (struct linespec_result *ls)
2942 return make_cleanup (cleanup_linespec_result, ls);