1 /* Parser for linespec for the GNU debugger, GDB.
3 Copyright (C) 1986-2005, 2007-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
29 #include "completer.h"
31 #include "cp-support.h"
32 #include "parser-defs.h"
34 #include "objc-lang.h"
36 #include "exceptions.h"
39 #include "mi/mi-cmds.h"
41 #include "arch-utils.h"
43 #include "cli/cli-utils.h"
44 #include "filenames.h"
47 typedef struct symtab *symtab_p;
50 typedef struct symbol *symbolp;
53 typedef struct type *typep;
56 /* An address entry is used to ensure that any given location is only
57 added to the result a single time. It holds an address and the
58 program space from which the address came. */
62 struct program_space *pspace;
66 /* An instance of this is used to keep all state while linespec
67 operates. This instance is passed around as a 'this' pointer to
68 the various implementation methods. */
72 /* The program space as seen when the module was entered. */
73 struct program_space *program_space;
75 /* The default symtab to use, if no other symtab is specified. */
76 struct symtab *default_symtab;
78 /* The default line to use. */
81 /* If the linespec started with "FILE:", this holds all the matching
82 symtabs. Otherwise, it will hold a single NULL entry, meaning
83 that the default symtab should be used. */
84 VEC (symtab_p) *file_symtabs;
86 /* If the linespec started with "FILE:", this holds an xmalloc'd
90 /* If the linespec is "FUNCTION:LABEL", this holds an xmalloc'd copy
94 /* The 'funfirstline' value that was passed in to decode_line_1 or
98 /* Nonzero if we are running in 'list' mode; see decode_line_list. */
101 /* The 'canonical' value passed to decode_line_full, or NULL. */
102 struct linespec_result *canonical;
104 /* Canonical strings that mirror the symtabs_and_lines result. */
105 char **canonical_names;
107 /* This is a set of address_entry objects which is used to prevent
108 duplicate symbols from being entered into the result. */
112 /* This is a helper object that is used when collecting symbols into a
117 /* The linespec object in use. */
118 struct linespec_state *state;
120 /* The result being accumulated. */
121 struct symtabs_and_lines result;
124 /* Prototypes for local functions. */
126 static void initialize_defaults (struct symtab **default_symtab,
129 static struct symtabs_and_lines decode_indirect (struct linespec_state *self,
132 static char *locate_first_half (char **argptr, int *is_quote_enclosed);
134 static struct symtabs_and_lines decode_objc (struct linespec_state *self,
137 static struct symtabs_and_lines decode_compound (struct linespec_state *self,
142 static VEC (symbolp) *lookup_prefix_sym (char **argptr, char *p,
146 static struct symtabs_and_lines find_method (struct linespec_state *self,
149 const char *class_name,
150 VEC (symbolp) *sym_classes);
152 static void cplusplus_error (const char *name, const char *fmt, ...)
153 ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 3);
155 static char *find_toplevel_char (char *s, char c);
157 static int is_objc_method_format (const char *s);
159 static VEC (symtab_p) *symtabs_from_filename (char **argptr,
160 char *p, int is_quote_enclosed,
161 char **user_filename);
163 static VEC (symbolp) *find_function_symbols (char **argptr, char *p,
164 int is_quote_enclosed,
165 char **user_function);
167 static struct symtabs_and_lines decode_all_digits (struct linespec_state *self,
171 static struct symtabs_and_lines decode_dollar (struct linespec_state *self,
174 static int decode_label (struct linespec_state *self,
175 VEC (symbolp) *function_symbols,
177 struct symtabs_and_lines *result);
179 static struct symtabs_and_lines decode_variable (struct linespec_state *self,
182 static int symbol_to_sal (struct symtab_and_line *result,
183 int funfirstline, struct symbol *sym);
185 static void add_matching_symbols_to_info (const char *name,
186 struct collect_info *info,
187 struct program_space *pspace);
189 static void add_all_symbol_names_from_pspace (struct collect_info *info,
190 struct program_space *pspace,
191 VEC (const_char_ptr) *names);
193 /* Helper functions. */
195 /* Add SAL to SALS. */
198 add_sal_to_sals_basic (struct symtabs_and_lines *sals,
199 struct symtab_and_line *sal)
202 sals->sals = xrealloc (sals->sals, sals->nelts * sizeof (sals->sals[0]));
203 sals->sals[sals->nelts - 1] = *sal;
206 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
207 the new sal, if needed. If not NULL, SYMNAME is the name of the
208 symbol to use when constructing the new canonical name. */
211 add_sal_to_sals (struct linespec_state *self,
212 struct symtabs_and_lines *sals,
213 struct symtab_and_line *sal,
216 add_sal_to_sals_basic (sals, sal);
220 char *canonical_name = NULL;
222 self->canonical_names = xrealloc (self->canonical_names,
223 sals->nelts * sizeof (char *));
224 if (sal->symtab && sal->symtab->filename)
226 char *filename = sal->symtab->filename;
228 /* Note that the filter doesn't have to be a valid linespec
229 input. We only apply the ":LINE" treatment to Ada for
231 if (symname != NULL && sal->line != 0
232 && current_language->la_language == language_ada)
233 canonical_name = xstrprintf ("%s:%s:%d", filename, symname,
235 else if (symname != NULL)
236 canonical_name = xstrprintf ("%s:%s", filename, symname);
238 canonical_name = xstrprintf ("%s:%d", filename, sal->line);
241 self->canonical_names[sals->nelts - 1] = canonical_name;
245 /* A hash function for address_entry. */
248 hash_address_entry (const void *p)
250 const struct address_entry *aep = p;
253 hash = iterative_hash_object (aep->pspace, 0);
254 return iterative_hash_object (aep->addr, hash);
257 /* An equality function for address_entry. */
260 eq_address_entry (const void *a, const void *b)
262 const struct address_entry *aea = a;
263 const struct address_entry *aeb = b;
265 return aea->pspace == aeb->pspace && aea->addr == aeb->addr;
268 /* Check whether the address, represented by PSPACE and ADDR, is
269 already in the set. If so, return 0. Otherwise, add it and return
273 maybe_add_address (htab_t set, struct program_space *pspace, CORE_ADDR addr)
275 struct address_entry e, *p;
280 slot = htab_find_slot (set, &e, INSERT);
284 p = XNEW (struct address_entry);
285 memcpy (p, &e, sizeof (struct address_entry));
291 /* Issue a helpful hint on using the command completion feature on
292 single quoted demangled C++ symbols as part of the completion
296 cplusplus_error (const char *name, const char *fmt, ...)
298 struct ui_file *tmp_stream;
301 tmp_stream = mem_fileopen ();
302 make_cleanup_ui_file_delete (tmp_stream);
307 va_start (args, fmt);
308 vfprintf_unfiltered (tmp_stream, fmt, args);
312 while (*name == '\'')
314 fprintf_unfiltered (tmp_stream,
315 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
316 "(Note leading single quote.)"),
319 message = ui_file_xstrdup (tmp_stream, NULL);
320 make_cleanup (xfree, message);
321 throw_error (NOT_FOUND_ERROR, "%s", message);
324 /* A helper for iterate_over_all_matching_symtabs that is passed as a
325 callback to the expand_symtabs_matching method. */
328 iterate_name_matcher (const struct language_defn *language,
329 const char *name, void *d)
331 const char **dname = d;
333 if (language->la_symbol_name_compare (name, *dname) == 0)
338 /* A helper that walks over all matching symtabs in all objfiles and
339 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
340 not NULL, then the search is restricted to just that program
344 iterate_over_all_matching_symtabs (const char *name,
345 const domain_enum domain,
346 int (*callback) (struct symbol *, void *),
348 struct program_space *search_pspace)
350 struct objfile *objfile;
351 struct program_space *pspace;
355 if (search_pspace != NULL && search_pspace != pspace)
357 if (pspace->executing_startup)
360 set_current_program_space (pspace);
362 ALL_OBJFILES (objfile)
364 struct symtab *symtab;
367 objfile->sf->qf->expand_symtabs_matching (objfile, NULL,
368 iterate_name_matcher,
372 ALL_OBJFILE_SYMTABS (objfile, symtab)
378 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
379 LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data);
386 /* Returns the block to be used for symbol searches for the given SYMTAB,
387 which may be NULL. */
389 static struct block *
390 get_search_block (struct symtab *symtab)
395 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
398 enum language save_language;
400 /* get_selected_block can change the current language when there is
401 no selected frame yet. */
402 save_language = current_language->la_language;
403 block = get_selected_block (0);
404 set_language (save_language);
410 /* A helper for find_method. This finds all methods in type T which
411 match NAME. It adds resulting symbol names to RESULT_NAMES, and
412 adds T's direct superclasses to SUPERCLASSES. */
415 find_methods (struct type *t, const char *name,
416 VEC (const_char_ptr) **result_names,
417 VEC (typep) **superclasses)
421 char *class_name = type_name_no_tag (t);
424 /* Ignore this class if it doesn't have a name. This is ugly, but
425 unless we figure out how to get the physname without the name of
426 the class, then the loop can't do any good. */
430 int name_len = strlen (name);
434 /* Loop over each method name. At this level, all overloads of a name
435 are counted as a single name. There is an inner loop which loops over
438 for (method_counter = TYPE_NFN_FIELDS (t) - 1;
442 char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
445 if (strncmp (method_name, "__", 2) == 0 ||
446 strncmp (method_name, "op", 2) == 0 ||
447 strncmp (method_name, "type", 4) == 0)
449 if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI))
450 method_name = dem_opname;
451 else if (cplus_demangle_opname (method_name, dem_opname, 0))
452 method_name = dem_opname;
455 if (strcmp_iw (method_name, name) == 0)
459 for (field_counter = (TYPE_FN_FIELDLIST_LENGTH (t, method_counter)
465 const char *phys_name;
467 f = TYPE_FN_FIELDLIST1 (t, method_counter);
468 if (TYPE_FN_FIELD_STUB (f, field_counter))
470 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
471 VEC_safe_push (const_char_ptr, *result_names, phys_name);
477 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
478 VEC_safe_push (typep, *superclasses, TYPE_BASECLASS (t, ibase));
481 /* Find an instance of the character C in the string S that is outside
482 of all parenthesis pairs, single-quoted strings, and double-quoted
483 strings. Also, ignore the char within a template name, like a ','
484 within foo<int, int>. */
487 find_toplevel_char (char *s, char c)
489 int quoted = 0; /* zero if we're not in quotes;
490 '"' if we're in a double-quoted string;
491 '\'' if we're in a single-quoted string. */
492 int depth = 0; /* Number of unclosed parens we've seen. */
495 for (scan = s; *scan; scan++)
501 else if (*scan == '\\' && *(scan + 1))
504 else if (*scan == c && ! quoted && depth == 0)
506 else if (*scan == '"' || *scan == '\'')
508 else if (*scan == '(' || *scan == '<')
510 else if ((*scan == ')' || *scan == '>') && depth > 0)
517 /* Determines if the gives string corresponds to an Objective-C method
518 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
519 are allowed to have spaces and parentheses in them. */
522 is_objc_method_format (const char *s)
524 if (s == NULL || *s == '\0')
526 /* Handle arguments with the format FILENAME:SYMBOL. */
527 if ((s[0] == ':') && (strchr ("+-", s[1]) != NULL)
528 && (s[2] == '[') && strchr(s, ']'))
530 /* Handle arguments that are just SYMBOL. */
531 else if ((strchr ("+-", s[0]) != NULL) && (s[1] == '[') && strchr(s, ']'))
536 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
537 and store the result in SELF->CANONICAL. */
540 filter_results (struct linespec_state *self,
541 struct symtabs_and_lines *result,
542 VEC (const_char_ptr) *filters)
547 for (i = 0; VEC_iterate (const_char_ptr, filters, i, name); ++i)
549 struct linespec_sals lsal;
552 memset (&lsal, 0, sizeof (lsal));
554 for (j = 0; j < result->nelts; ++j)
556 if (strcmp (name, self->canonical_names[j]) == 0)
557 add_sal_to_sals_basic (&lsal.sals, &result->sals[j]);
560 if (lsal.sals.nelts > 0)
562 lsal.canonical = xstrdup (name);
563 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
567 self->canonical->pre_expanded = 0;
570 /* Store RESULT into SELF->CANONICAL. */
573 convert_results_to_lsals (struct linespec_state *self,
574 struct symtabs_and_lines *result)
576 struct linespec_sals lsal;
578 lsal.canonical = NULL;
580 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
583 /* Handle multiple results in RESULT depending on SELECT_MODE. This
584 will either return normally, throw an exception on multiple
585 results, or present a menu to the user. On return, the SALS vector
586 in SELF->CANONICAL is set up properly. */
589 decode_line_2 (struct linespec_state *self,
590 struct symtabs_and_lines *result,
591 const char *select_mode)
596 struct cleanup *old_chain;
597 VEC (const_char_ptr) *item_names = NULL, *filters = NULL;
598 struct get_number_or_range_state state;
600 gdb_assert (select_mode != multiple_symbols_all);
601 gdb_assert (self->canonical != NULL);
603 old_chain = make_cleanup (VEC_cleanup (const_char_ptr), &item_names);
604 make_cleanup (VEC_cleanup (const_char_ptr), &filters);
605 for (i = 0; i < result->nelts; ++i)
610 gdb_assert (self->canonical_names[i] != NULL);
611 for (j = 0; VEC_iterate (const_char_ptr, item_names, j, iter); ++j)
613 if (strcmp (iter, self->canonical_names[i]) == 0)
621 VEC_safe_push (const_char_ptr, item_names, self->canonical_names[i]);
624 if (select_mode == multiple_symbols_cancel
625 && VEC_length (const_char_ptr, item_names) > 1)
626 error (_("canceled because the command is ambiguous\n"
627 "See set/show multiple-symbol."));
629 if (select_mode == multiple_symbols_all
630 || VEC_length (const_char_ptr, item_names) == 1)
632 do_cleanups (old_chain);
633 convert_results_to_lsals (self, result);
637 printf_unfiltered (_("[0] cancel\n[1] all\n"));
638 for (i = 0; VEC_iterate (const_char_ptr, item_names, i, iter); ++i)
639 printf_unfiltered ("[%d] %s\n", i + 2, iter);
641 prompt = getenv ("PS2");
646 args = command_line_input (prompt, 0, "overload-choice");
648 if (args == 0 || *args == 0)
649 error_no_arg (_("one or more choice numbers"));
651 init_number_or_range (&state, args);
652 while (!state.finished)
656 num = get_number_or_range (&state);
659 error (_("canceled"));
662 /* We intentionally make this result in a single breakpoint,
663 contrary to what older versions of gdb did. The
664 rationale is that this lets a user get the
665 multiple_symbols_all behavior even with the 'ask'
666 setting; and he can get separate breakpoints by entering
667 "2-57" at the query. */
668 do_cleanups (old_chain);
669 convert_results_to_lsals (self, result);
674 if (num >= VEC_length (const_char_ptr, item_names))
675 printf_unfiltered (_("No choice number %d.\n"), num);
678 const char *elt = VEC_index (const_char_ptr, item_names, num);
682 VEC_safe_push (const_char_ptr, filters, elt);
683 VEC_replace (const_char_ptr, item_names, num, NULL);
687 printf_unfiltered (_("duplicate request for %d ignored.\n"),
693 filter_results (self, result, filters);
694 do_cleanups (old_chain);
697 /* Valid delimiters for linespec keywords "if", "thread" or "task". */
700 is_linespec_boundary (char c)
702 return c == ' ' || c == '\t' || c == '\0' || c == ',';
705 /* A helper function for decode_line_1 and friends which skips P
706 past any method overload information at the beginning of P, e.g.,
707 "(const struct foo *)".
709 This function assumes that P has already been validated to contain
710 overload information, and it will assert if *P != '('. */
712 find_method_overload_end (char *p)
716 gdb_assert (*p == '(');
736 /* Keep important information used when looking up a name. This includes
737 template parameters, overload information, and important keywords, including
738 the possible Java trailing type. */
741 keep_name_info (char *p, int on_boundary)
743 const char *quotes = get_gdb_completer_quote_characters ();
749 if (strchr (quotes, *p))
752 if (*p == ',' && !nest)
755 if (on_boundary && !nest)
757 const char *const words[] = { "if", "thread", "task" };
760 for (wordi = 0; wordi < ARRAY_SIZE (words); wordi++)
761 if (strncmp (p, words[wordi], strlen (words[wordi])) == 0
762 && is_linespec_boundary (p[strlen (words[wordi])]))
764 if (wordi < ARRAY_SIZE (words))
768 if (*p == '(' || *p == '<' || *p == '[')
770 else if ((*p == ')' || *p == '>' || *p == ']') && nest > 0)
775 /* The ',' check could fail on "operator ,". */
776 p += cp_validate_operator (p);
778 on_boundary = is_linespec_boundary (p[-1]);
781 while (p > saved_p && is_linespec_boundary (p[-1]))
788 /* The parser of linespec itself. */
790 /* Parse a string that specifies a line number.
791 Pass the address of a char * variable; that variable will be
792 advanced over the characters actually parsed.
796 LINENUM -- that line number in current file. PC returned is 0.
797 FILE:LINENUM -- that line in that file. PC returned is 0.
798 FUNCTION -- line number of openbrace of that function.
799 PC returned is the start of the function.
800 LABEL -- a label in the current scope
801 VARIABLE -- line number of definition of that variable.
803 FILE:FUNCTION -- likewise, but prefer functions in that file.
804 *EXPR -- line in which address EXPR appears.
806 This may all be followed by an "if EXPR", which we ignore.
808 FUNCTION may be an undebuggable function found in minimal symbol table.
810 If the argument FUNFIRSTLINE is nonzero, we want the first line
811 of real code inside a function when a function is specified, and it is
812 not OK to specify a variable or type to get its line number.
814 DEFAULT_SYMTAB specifies the file to use if none is specified.
815 It defaults to current_source_symtab.
816 DEFAULT_LINE specifies the line number to use for relative
817 line numbers (that start with signs). Defaults to current_source_line.
818 If CANONICAL is non-NULL, store an array of strings containing the canonical
819 line specs there if necessary. Currently overloaded member functions and
820 line numbers or static functions without a filename yield a canonical
821 line spec. The array and the line spec strings are allocated on the heap,
822 it is the callers responsibility to free them.
824 Note that it is possible to return zero for the symtab
825 if no file is validly specified. Callers must check that.
826 Also, the line number returned may be invalid. */
828 /* We allow single quotes in various places. This is a hideous
829 kludge, which exists because the completer can't yet deal with the
830 lack of single quotes. FIXME: write a linespec_completer which we
831 can use as appropriate instead of make_symbol_completion_list. */
833 static struct symtabs_and_lines
834 decode_line_internal (struct linespec_state *self, char **argptr)
840 /* This says whether or not something in *ARGPTR is quoted with
841 completer_quotes (i.e. with single quotes). */
843 /* Is *ARGPTR enclosed in double quotes? */
844 int is_quote_enclosed;
845 int is_objc_method = 0;
846 char *saved_arg = *argptr;
847 /* If IS_QUOTED, the end of the quoted bit. */
848 char *end_quote = NULL;
849 /* Is *ARGPTR enclosed in single quotes? */
850 int is_squote_enclosed = 0;
851 /* The "first half" of the linespec. */
854 /* If we are parsing `function:label', this holds the symbols
855 matching the function name. */
856 VEC (symbolp) *function_symbols = NULL;
857 /* If FUNCTION_SYMBOLS is not NULL, then this is the exception that
858 was thrown when trying to parse a filename. */
859 volatile struct gdb_exception file_exception;
861 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
863 /* Defaults have defaults. */
865 initialize_defaults (&self->default_symtab, &self->default_line);
867 /* See if arg is *PC. */
871 do_cleanups (cleanup);
872 return decode_indirect (self, argptr);
875 is_quoted = (strchr (get_gdb_completer_quote_characters (),
880 end_quote = skip_quoted (*argptr);
881 if (*end_quote == '\0')
882 is_squote_enclosed = 1;
885 /* Check to see if it's a multipart linespec (with colons or
888 /* Locate the end of the first half of the linespec.
889 After the call, for instance, if the argptr string is "foo.c:123"
890 p will point at "123". If there is only one part, like "foo", p
891 will point to "". If this is a C++ name, like "A::B::foo", p will
892 point to "::B::foo". Argptr is not changed by this call. */
894 first_half = p = locate_first_half (argptr, &is_quote_enclosed);
896 /* First things first: if ARGPTR starts with a filename, get its
897 symtab and strip the filename from ARGPTR. */
898 TRY_CATCH (file_exception, RETURN_MASK_ERROR)
900 self->file_symtabs = symtabs_from_filename (argptr, p, is_quote_enclosed,
901 &self->user_filename);
904 if (VEC_empty (symtab_p, self->file_symtabs))
906 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
907 VEC_safe_push (symtab_p, self->file_symtabs, NULL);
910 if (file_exception.reason >= 0)
912 /* Check for single quotes on the non-filename part. */
913 is_quoted = (**argptr
914 && strchr (get_gdb_completer_quote_characters (),
917 end_quote = skip_quoted (*argptr);
919 /* Locate the next "half" of the linespec. */
920 first_half = p = locate_first_half (argptr, &is_quote_enclosed);
923 /* Check if this is an Objective-C method (anything that starts with
924 a '+' or '-' and a '['). */
925 if (is_objc_method_format (p))
928 /* Check if the symbol could be an Objective-C selector. */
931 struct symtabs_and_lines values;
933 values = decode_objc (self, argptr);
934 if (values.sals != NULL)
936 do_cleanups (cleanup);
941 /* Does it look like there actually were two parts? */
943 if (p[0] == ':' || p[0] == '.')
945 /* Is it a C++ or Java compound data structure?
946 The check on p[1] == ':' is capturing the case of "::",
947 since p[0]==':' was checked above.
948 Note that the call to decode_compound does everything
949 for us, including the lookup on the symbol table, so we
952 if (p[0] == '.' || p[1] == ':')
954 struct symtabs_and_lines values;
955 volatile struct gdb_exception ex;
956 char *saved_argptr = *argptr;
958 if (is_quote_enclosed)
961 /* Initialize it just to avoid a GCC false warning. */
962 memset (&values, 0, sizeof (values));
964 TRY_CATCH (ex, RETURN_MASK_ERROR)
966 values = decode_compound (self, argptr, saved_arg, p);
968 if ((is_quoted || is_squote_enclosed) && **argptr == '\'')
969 *argptr = *argptr + 1;
973 do_cleanups (cleanup);
977 if (ex.error != NOT_FOUND_ERROR)
978 throw_exception (ex);
980 *argptr = saved_argptr;
984 /* If there was an exception looking up a specified filename earlier,
985 then check whether we were really given `function:label'. */
986 if (file_exception.reason < 0)
988 function_symbols = find_function_symbols (argptr, p,
990 &self->user_function);
992 /* If we did not find a function, re-throw the original
994 if (!function_symbols)
995 throw_exception (file_exception);
997 make_cleanup (VEC_cleanup (symbolp), &function_symbols);
1000 /* Check for single quotes on the non-filename part. */
1003 is_quoted = (**argptr
1004 && strchr (get_gdb_completer_quote_characters (),
1007 end_quote = skip_quoted (*argptr);
1012 /* self->file_symtabs holds the specified file symtabs, or 0 if no file
1014 If we are parsing `function:symbol', then FUNCTION_SYMBOLS holds the
1015 functions before the `:'.
1016 arg no longer contains the file name. */
1018 /* If the filename was quoted, we must re-check the quotation. */
1020 if (end_quote == first_half && *end_quote!= '\0')
1022 is_quoted = (**argptr
1023 && strchr (get_gdb_completer_quote_characters (),
1026 end_quote = skip_quoted (*argptr);
1029 /* Check whether arg is all digits (and sign). */
1032 if (*q == '-' || *q == '+')
1034 while (*q >= '0' && *q <= '9')
1037 if (q != *argptr && (*q == 0 || *q == ' ' || *q == '\t' || *q == ',')
1038 && function_symbols == NULL)
1040 struct symtabs_and_lines values;
1042 /* We found a token consisting of all digits -- at least one digit. */
1043 values = decode_all_digits (self, argptr, q);
1044 do_cleanups (cleanup);
1048 /* Arg token is not digits => try it as a variable name
1049 Find the next token (everything up to end or next whitespace). */
1051 if (**argptr == '$') /* May be a convenience variable. */
1052 /* One or two $ chars possible. */
1053 p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1));
1054 else if (is_quoted || is_squote_enclosed)
1058 error (_("Unmatched single quote."));
1060 else if (is_objc_method)
1062 /* allow word separators in method names for Obj-C. */
1063 p = skip_quoted_chars (*argptr, NULL, "");
1067 p = skip_quoted (*argptr);
1070 /* Keep any important naming information. */
1071 p = keep_name_info (p, p == saved_arg || is_linespec_boundary (p[-1]));
1073 copy = (char *) alloca (p - *argptr + 1);
1074 memcpy (copy, *argptr, p - *argptr);
1075 copy[p - *argptr] = '\0';
1078 && copy[0] == copy[p - *argptr - 1]
1079 && strchr (get_gdb_completer_quote_characters (), copy[0]) != NULL)
1081 copy[p - *argptr - 1] = '\0';
1084 else if (is_quoted || is_squote_enclosed)
1085 copy[p - *argptr - 1] = '\0';
1087 *argptr = skip_spaces (p);
1089 /* If it starts with $: may be a legitimate variable or routine name
1090 (e.g. HP-UX millicode routines such as $$dyncall), or it may
1091 be history value, or it may be a convenience variable. */
1093 if (*copy == '$' && function_symbols == NULL)
1095 struct symtabs_and_lines values;
1097 values = decode_dollar (self, copy);
1098 do_cleanups (cleanup);
1102 /* Try the token as a label, but only if no file was specified,
1103 because we can only really find labels in the current scope. */
1105 if (VEC_length (symtab_p, self->file_symtabs) == 1
1106 && VEC_index (symtab_p, self->file_symtabs, 0) == NULL)
1108 struct symtabs_and_lines label_result;
1109 if (decode_label (self, function_symbols, copy, &label_result))
1111 do_cleanups (cleanup);
1112 return label_result;
1116 if (function_symbols)
1117 throw_exception (file_exception);
1119 /* Look up that token as a variable.
1120 If file specified, use that file's per-file block to start with. */
1123 struct symtabs_and_lines values;
1125 values = decode_variable (self, copy);
1126 do_cleanups (cleanup);
1131 /* A constructor for linespec_state. */
1134 linespec_state_constructor (struct linespec_state *self,
1136 struct symtab *default_symtab,
1138 struct linespec_result *canonical)
1140 memset (self, 0, sizeof (*self));
1141 self->funfirstline = (flags & DECODE_LINE_FUNFIRSTLINE) ? 1 : 0;
1142 self->list_mode = (flags & DECODE_LINE_LIST_MODE) ? 1 : 0;
1143 self->default_symtab = default_symtab;
1144 self->default_line = default_line;
1145 self->canonical = canonical;
1146 self->program_space = current_program_space;
1147 self->addr_set = htab_create_alloc (10, hash_address_entry, eq_address_entry,
1148 xfree, xcalloc, xfree);
1151 /* A destructor for linespec_state. */
1154 linespec_state_destructor (void *arg)
1156 struct linespec_state *self = arg;
1158 xfree (self->user_filename);
1159 xfree (self->user_function);
1160 VEC_free (symtab_p, self->file_symtabs);
1161 htab_delete (self->addr_set);
1164 /* See linespec.h. */
1167 decode_line_full (char **argptr, int flags,
1168 struct symtab *default_symtab,
1169 int default_line, struct linespec_result *canonical,
1170 const char *select_mode,
1173 struct symtabs_and_lines result;
1174 struct linespec_state state;
1175 struct cleanup *cleanups;
1176 char *arg_start = *argptr;
1177 VEC (const_char_ptr) *filters = NULL;
1179 gdb_assert (canonical != NULL);
1180 /* The filter only makes sense for 'all'. */
1181 gdb_assert (filter == NULL || select_mode == multiple_symbols_all);
1182 gdb_assert (select_mode == NULL
1183 || select_mode == multiple_symbols_all
1184 || select_mode == multiple_symbols_ask
1185 || select_mode == multiple_symbols_cancel);
1186 gdb_assert ((flags & DECODE_LINE_LIST_MODE) == 0);
1188 linespec_state_constructor (&state, flags,
1189 default_symtab, default_line, canonical);
1190 cleanups = make_cleanup (linespec_state_destructor, &state);
1191 save_current_program_space ();
1193 result = decode_line_internal (&state, argptr);
1195 gdb_assert (result.nelts == 1 || canonical->pre_expanded);
1196 gdb_assert (canonical->addr_string != NULL);
1197 canonical->pre_expanded = 1;
1199 /* Fill in the missing canonical names. */
1200 if (result.nelts > 0)
1204 if (state.canonical_names == NULL)
1205 state.canonical_names = xcalloc (result.nelts, sizeof (char *));
1206 make_cleanup (xfree, state.canonical_names);
1207 for (i = 0; i < result.nelts; ++i)
1209 if (state.canonical_names[i] == NULL)
1210 state.canonical_names[i] = savestring (arg_start,
1211 *argptr - arg_start);
1212 make_cleanup (xfree, state.canonical_names[i]);
1216 if (select_mode == NULL)
1218 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
1219 select_mode = multiple_symbols_all;
1221 select_mode = multiple_symbols_select_mode ();
1224 if (select_mode == multiple_symbols_all)
1228 make_cleanup (VEC_cleanup (const_char_ptr), &filters);
1229 VEC_safe_push (const_char_ptr, filters, filter);
1230 filter_results (&state, &result, filters);
1233 convert_results_to_lsals (&state, &result);
1236 decode_line_2 (&state, &result, select_mode);
1238 do_cleanups (cleanups);
1241 struct symtabs_and_lines
1242 decode_line_1 (char **argptr, int flags,
1243 struct symtab *default_symtab,
1246 struct symtabs_and_lines result;
1247 struct linespec_state state;
1248 struct cleanup *cleanups;
1250 linespec_state_constructor (&state, flags,
1251 default_symtab, default_line, NULL);
1252 cleanups = make_cleanup (linespec_state_destructor, &state);
1253 save_current_program_space ();
1255 result = decode_line_internal (&state, argptr);
1256 do_cleanups (cleanups);
1262 /* First, some functions to initialize stuff at the beggining of the
1266 initialize_defaults (struct symtab **default_symtab, int *default_line)
1268 if (*default_symtab == 0)
1270 /* Use whatever we have for the default source line. We don't use
1271 get_current_or_default_symtab_and_line as it can recurse and call
1273 struct symtab_and_line cursal =
1274 get_current_source_symtab_and_line ();
1276 *default_symtab = cursal.symtab;
1277 *default_line = cursal.line;
1283 /* Decode arg of the form *PC. */
1285 static struct symtabs_and_lines
1286 decode_indirect (struct linespec_state *self, char **argptr)
1288 struct symtabs_and_lines values;
1290 char *initial = *argptr;
1292 if (current_program_space->executing_startup)
1293 /* The error message doesn't really matter, because this case
1294 should only hit during breakpoint reset. */
1295 throw_error (NOT_FOUND_ERROR, _("cannot evaluate expressions while "
1296 "program space is in startup"));
1299 pc = value_as_address (parse_to_comma_and_eval (argptr));
1301 values.sals = (struct symtab_and_line *)
1302 xmalloc (sizeof (struct symtab_and_line));
1305 values.sals[0] = find_pc_line (pc, 0);
1306 values.sals[0].pc = pc;
1307 values.sals[0].section = find_pc_overlay (pc);
1308 values.sals[0].explicit_pc = 1;
1310 if (self->canonical)
1311 self->canonical->addr_string = savestring (initial, *argptr - initial);
1318 /* Locate the first half of the linespec, ending in a colon, period,
1319 or whitespace. (More or less.) Also, check to see if *ARGPTR is
1320 enclosed in double quotes; if so, set is_quote_enclosed, advance
1321 ARGPTR past that and zero out the trailing double quote.
1322 If ARGPTR is just a simple name like "main", p will point to ""
1326 locate_first_half (char **argptr, int *is_quote_enclosed)
1332 /* Check if the linespec starts with an Ada operator (such as "+",
1333 or ">", for instance). */
1336 && current_language->la_language == language_ada)
1338 const struct ada_opname_map *op;
1340 for (op = ada_opname_table; op->encoded != NULL; op++)
1341 if (strncmp (op->decoded, p, strlen (op->decoded)) == 0)
1343 if (op->encoded != NULL)
1345 *is_quote_enclosed = 0;
1346 return p + strlen (op->decoded);
1350 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1351 and we must isolate the first half. Outer layers will call again later
1352 for the second half.
1354 Don't count commas that appear in argument lists of overloaded
1355 functions, or in quoted strings. It's stupid to go to this much
1356 trouble when the rest of the function is such an obvious roach hotel. */
1357 ii = find_toplevel_char (*argptr, ',');
1358 has_comma = (ii != 0);
1360 /* Temporarily zap out second half to not confuse the code below.
1361 This is undone below. Do not change ii!! */
1367 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
1368 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
1374 *is_quote_enclosed = 1;
1380 *is_quote_enclosed = 0;
1381 if (strchr (get_gdb_completer_quote_characters (), *p))
1389 /* Check for a drive letter in the filename. This is done on all hosts
1390 to capture cross-compilation environments. On Unixen, directory
1391 separators are illegal in filenames, so if the user enters "e:/foo.c",
1392 he is referring to a directory named "e:" and a source file named
1393 "foo.c", and we still want to keep these two pieces together. */
1394 if (isalpha (p[0]) && p[1] == ':' && IS_DIR_SEPARATOR (p[2]))
1401 char *temp_end = find_template_name_end (p);
1404 error (_("malformed template specification in command"));
1409 p = find_method_overload_end (p);
1411 /* Check for a colon and a plus or minus and a [ (which
1412 indicates an Objective-C method). */
1413 if (is_objc_method_format (p))
1417 /* Check for the end of the first half of the linespec. End of
1418 line, a tab, a colon or a space. But if enclosed in double
1419 quotes we do not break on enclosed spaces. */
1423 || ((p[0] == ' ') && !*is_quote_enclosed))
1425 if (p[0] == '.' && strchr (p, ':') == NULL)
1427 /* Java qualified method. Find the *last* '.', since the
1428 others are package qualifiers. Stop at any open parenthesis
1429 which might provide overload information. */
1430 for (p1 = p; *p1 && *p1 != '('; p1++)
1438 p = skip_spaces (p);
1440 /* If the closing double quote was left at the end, remove it. */
1441 if (*is_quote_enclosed)
1443 char *closing_quote = strchr (p - 1, '"');
1445 if (closing_quote && closing_quote[1] == '\0')
1446 *closing_quote = '\0';
1449 /* Now that we've safely parsed the first half, put back ',' so
1450 outer layers can see it. */
1459 /* Here's where we recognise an Objective-C Selector. An Objective C
1460 selector may be implemented by more than one class, therefore it
1461 may represent more than one method/function. This gives us a
1462 situation somewhat analogous to C++ overloading. If there's more
1463 than one method that could represent the selector, then use some of
1464 the existing C++ code to let the user choose one. */
1466 static struct symtabs_and_lines
1467 decode_objc (struct linespec_state *self, char **argptr)
1469 struct collect_info info;
1470 VEC (const_char_ptr) *symbol_names = NULL;
1472 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
1476 info.result.sals = NULL;
1477 info.result.nelts = 0;
1479 new_argptr = find_imps (*argptr, &symbol_names);
1480 if (VEC_empty (const_char_ptr, symbol_names))
1482 do_cleanups (cleanup);
1486 add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
1488 if (info.result.nelts > 0)
1492 saved_arg = alloca (new_argptr - *argptr + 1);
1493 memcpy (saved_arg, *argptr, new_argptr - *argptr);
1494 saved_arg[new_argptr - *argptr] = '\0';
1496 if (self->canonical)
1498 self->canonical->pre_expanded = 1;
1499 if (self->user_filename)
1500 self->canonical->addr_string
1501 = xstrprintf ("%s:%s", self->user_filename, saved_arg);
1503 self->canonical->addr_string = xstrdup (saved_arg);
1507 *argptr = new_argptr;
1509 do_cleanups (cleanup);
1513 /* This handles C++ and Java compound data structures. P should point
1514 at the first component separator, i.e. double-colon or period. As
1515 an example, on entrance to this function we could have ARGPTR
1516 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
1518 static struct symtabs_and_lines
1519 decode_compound (struct linespec_state *self,
1520 char **argptr, char *the_real_saved_arg, char *p)
1522 struct symtabs_and_lines values;
1524 char *saved_arg2 = *argptr;
1528 VEC (symbolp) *sym_classes;
1529 char *saved_arg, *class_name;
1530 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1532 /* If the user specified any completer quote characters in the input,
1533 strip them. They are superfluous. */
1534 saved_arg = alloca (strlen (the_real_saved_arg) + 1);
1536 char *dst = saved_arg;
1537 char *src = the_real_saved_arg;
1538 char *quotes = get_gdb_completer_quote_characters ();
1539 while (*src != '\0')
1541 if (strchr (quotes, *src) == NULL)
1548 /* First check for "global" namespace specification, of the form
1549 "::foo". If found, skip over the colons and jump to normal
1550 symbol processing. I.e. the whole line specification starts with
1551 "::" (note the condition that *argptr == p). */
1553 && ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t')))
1556 /* Given our example "AAA::inA::fun", we have two cases to consider:
1558 1) AAA::inA is the name of a class. In that case, presumably it
1559 has a method called "fun"; we then look up that method using
1562 2) AAA::inA isn't the name of a class. In that case, either the
1563 user made a typo, AAA::inA is the name of a namespace, or it is
1564 the name of a minimal symbol.
1565 In this case we just delegate to decode_variable.
1567 Thus, our first task is to find everything before the last set of
1568 double-colons and figure out if it's the name of a class. So we
1569 first loop through all of the double-colons. */
1571 p2 = p; /* Save for restart. */
1573 /* This is very messy. Following the example above we have now the
1576 argptr -> "AAA::inA::fun
1577 saved_arg -> "AAA::inA::fun
1578 saved_arg2 -> "AAA::inA::fun
1579 p2 -> "::inA::fun". */
1581 /* In the loop below, with these strings, we'll make 2 passes, each
1582 is marked in comments. */
1586 static char *break_characters = " \t(";
1588 /* Move pointer up to next possible class/namespace token. */
1590 p = p2 + 1; /* Restart with old value +1. */
1592 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1593 i.e. if there is a double-colon, p will now point to the
1595 /* PASS2: p2->"::fun", p->":fun" */
1597 /* Move pointer ahead to next double-colon. */
1599 && strchr (break_characters, *p) == NULL
1600 && strchr (get_gdb_completer_quote_characters (), *p) == NULL)
1602 if (current_language->la_language == language_cplus)
1603 p += cp_validate_operator (p);
1607 temp_end = find_template_name_end (p);
1609 error (_("malformed template specification in command"));
1612 /* Note that, since, at the start of this loop, p would be
1613 pointing to the second colon in a double-colon, we only
1614 satisfy the condition below if there is another
1615 double-colon to the right (after). I.e. there is another
1616 component that can be a class or a namespace. I.e, if at
1617 the beginning of this loop (PASS1), we had
1618 p->":inA::fun", we'll trigger this when p has been
1619 advanced to point to "::fun". */
1620 /* PASS2: we will not trigger this. */
1621 else if ((p[0] == ':') && (p[1] == ':'))
1622 break; /* Found double-colon. */
1625 /* PASS2: We'll keep getting here, until P points to one of the
1626 break characters, at which point we exit this loop. */
1630 && strncmp (&p[1], CP_ANONYMOUS_NAMESPACE_STR,
1631 CP_ANONYMOUS_NAMESPACE_LEN) == 0)
1632 p += CP_ANONYMOUS_NAMESPACE_LEN;
1633 else if (strchr (break_characters, *p) == NULL)
1640 break; /* Out of the while (1). This would happen
1641 for instance if we have looked up
1642 unsuccessfully all the components of the
1643 string, and p->""(PASS2). */
1645 /* We get here if p points to one of the break characters or "" (i.e.,
1647 /* Save restart for next time around. */
1649 /* Restore argptr as it was on entry to this function. */
1650 *argptr = saved_arg2;
1651 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1654 /* All ready for next pass through the loop. */
1658 /* Start of lookup in the symbol tables. */
1660 /* Lookup in the symbol table the substring between argptr and
1661 p. Note, this call changes the value of argptr. */
1662 /* Before the call, argptr->"AAA::inA::fun",
1663 p->"", p2->"::fun". After the call: argptr->"fun", p, p2
1665 sym_classes = lookup_prefix_sym (argptr, p2, self->file_symtabs,
1667 make_cleanup (VEC_cleanup (symbolp), &sym_classes);
1668 make_cleanup (xfree, class_name);
1670 /* If a class has been found, then we're in case 1 above. So we
1671 look up "fun" as a method of those classes. */
1672 if (!VEC_empty (symbolp, sym_classes))
1674 /* Arg token is not digits => try it as a function name.
1675 Find the next token (everything up to end or next
1678 && strchr (get_gdb_completer_quote_characters (),
1681 p = skip_quoted (*argptr);
1682 *argptr = *argptr + 1;
1686 /* At this point argptr->"fun". */
1690 while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':'
1693 /* At this point p->"". String ended. */
1694 /* Nope, C++ operators could have spaces in them
1695 ("foo::operator <" or "foo::operator delete []").
1696 I apologize, this is a bit hacky... */
1697 if (current_language->la_language == language_cplus
1698 && *p == ' ' && p - 8 - *argptr + 1 > 0)
1700 /* The above loop has already swallowed "operator". */
1701 p += cp_validate_operator (p - 8) - 8;
1704 /* Keep any important naming information. */
1705 p = keep_name_info (p, 1);
1708 /* Allocate our own copy of the substring between argptr and
1710 copy = (char *) alloca (p - *argptr + 1);
1711 memcpy (copy, *argptr, p - *argptr);
1712 copy[p - *argptr] = '\0';
1714 && copy[p - *argptr - 1]
1715 && strchr (get_gdb_completer_quote_characters (),
1716 copy[p - *argptr - 1]) != NULL)
1717 copy[p - *argptr - 1] = '\0';
1719 /* At this point copy->"fun", p->"". */
1721 /* No line number may be specified. */
1722 *argptr = skip_spaces (p);
1723 /* At this point arptr->"". */
1725 /* Look for copy as a method of sym_class. */
1726 /* At this point copy->"fun", sym_class is "AAA:inA",
1727 saved_arg->"AAA::inA::fun". This concludes the scanning of
1728 the string for possible components matches. If we find it
1729 here, we return. If not, and we are at the and of the string,
1730 we'll lookup the whole string in the symbol tables. */
1732 values = find_method (self, saved_arg, copy, class_name, sym_classes);
1734 do_cleanups (cleanup);
1736 } /* End if symbol found. */
1739 /* We couldn't find a class, so we're in case 2 above. We check the
1740 entire name as a symbol instead. The simplest way to do this is
1741 to just throw an exception and let our caller fall through to
1744 throw_error (NOT_FOUND_ERROR, _("see caller, this text doesn't matter"));
1747 /* An instance of this type is used when collecting prefix symbols for
1750 struct decode_compound_collector
1752 /* The result vector. */
1753 VEC (symbolp) *symbols;
1755 /* A hash table of all symbols we found. We use this to avoid
1756 adding any symbol more than once. */
1760 /* A callback for iterate_over_symbols that is used by
1761 lookup_prefix_sym to collect type symbols. */
1764 collect_one_symbol (struct symbol *sym, void *d)
1766 struct decode_compound_collector *collector = d;
1770 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1773 t = SYMBOL_TYPE (sym);
1775 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1776 && TYPE_CODE (t) != TYPE_CODE_UNION
1777 && TYPE_CODE (t) != TYPE_CODE_NAMESPACE)
1780 slot = htab_find_slot (collector->unique_syms, sym, INSERT);
1784 VEC_safe_push (symbolp, collector->symbols, sym);
1790 /* Return the symbol corresponding to the substring of *ARGPTR ending
1791 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1792 name in question, the compound object separator ("::" or "."), and
1793 whitespace. Note that *ARGPTR is changed whether or not the
1794 this call finds anything (i.e we return NULL). As an
1795 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
1797 static VEC (symbolp) *
1798 lookup_prefix_sym (char **argptr, char *p, VEC (symtab_p) *file_symtabs,
1805 struct decode_compound_collector collector;
1806 struct cleanup *outer;
1807 struct cleanup *cleanup;
1808 struct block *search_block;
1810 /* Extract the class name. */
1812 while (p != *argptr && p[-1] == ' ')
1814 copy = (char *) xmalloc (p - *argptr + 1);
1815 memcpy (copy, *argptr, p - *argptr);
1816 copy[p - *argptr] = 0;
1818 outer = make_cleanup (xfree, copy);
1820 /* Discard the class name from the argptr. */
1821 p = p1 + (p1[0] == ':' ? 2 : 1);
1822 p = skip_spaces (p);
1825 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1826 argptr->"inA::fun". */
1828 collector.symbols = NULL;
1829 make_cleanup (VEC_cleanup (symbolp), &collector.symbols);
1831 collector.unique_syms = htab_create_alloc (1, htab_hash_pointer,
1832 htab_eq_pointer, NULL,
1834 cleanup = make_cleanup_htab_delete (collector.unique_syms);
1836 for (ix = 0; VEC_iterate (symtab_p, file_symtabs, ix, elt); ++ix)
1840 iterate_over_all_matching_symtabs (copy, STRUCT_DOMAIN,
1841 collect_one_symbol, &collector,
1843 iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
1844 collect_one_symbol, &collector,
1849 struct block *search_block;
1851 /* Program spaces that are executing startup should have
1852 been filtered out earlier. */
1853 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
1854 set_current_program_space (SYMTAB_PSPACE (elt));
1855 search_block = get_search_block (elt);
1856 LA_ITERATE_OVER_SYMBOLS (search_block, copy, STRUCT_DOMAIN,
1857 collect_one_symbol, &collector);
1858 LA_ITERATE_OVER_SYMBOLS (search_block, copy, VAR_DOMAIN,
1859 collect_one_symbol, &collector);
1863 do_cleanups (cleanup);
1864 discard_cleanups (outer);
1865 return collector.symbols;
1868 /* A qsort comparison function for symbols. The resulting order does
1869 not actually matter; we just need to be able to sort them so that
1870 symbols with the same program space end up next to each other. */
1873 compare_symbols (const void *a, const void *b)
1875 struct symbol * const *sa = a;
1876 struct symbol * const *sb = b;
1879 uia = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa));
1880 uib = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb));
1887 uia = (uintptr_t) *sa;
1888 uib = (uintptr_t) *sb;
1898 /* Look for all the matching instances of each symbol in NAMES. Only
1899 instances from PSPACE are considered; other program spaces are
1900 handled by our caller. If PSPACE is NULL, then all program spaces
1901 are considered. Results are stored into INFO. */
1904 add_all_symbol_names_from_pspace (struct collect_info *info,
1905 struct program_space *pspace,
1906 VEC (const_char_ptr) *names)
1911 for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix)
1912 add_matching_symbols_to_info (iter, info, pspace);
1916 find_superclass_methods (VEC (typep) *superclasses,
1918 VEC (const_char_ptr) **result_names)
1920 int old_len = VEC_length (const_char_ptr, *result_names);
1921 VEC (typep) *iter_classes;
1922 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1924 iter_classes = superclasses;
1927 VEC (typep) *new_supers = NULL;
1931 make_cleanup (VEC_cleanup (typep), &new_supers);
1932 for (ix = 0; VEC_iterate (typep, iter_classes, ix, t); ++ix)
1933 find_methods (t, name, result_names, &new_supers);
1935 if (VEC_length (const_char_ptr, *result_names) != old_len
1936 || VEC_empty (typep, new_supers))
1939 iter_classes = new_supers;
1942 do_cleanups (cleanup);
1945 /* This finds the method COPY in the class whose type is given by one
1946 of the symbols in SYM_CLASSES. */
1948 static struct symtabs_and_lines
1949 find_method (struct linespec_state *self, char *saved_arg,
1950 char *copy, const char *class_name, VEC (symbolp) *sym_classes)
1954 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1956 int last_result_len;
1957 VEC (typep) *superclass_vec;
1958 VEC (const_char_ptr) *result_names;
1959 struct collect_info info;
1962 /* NAME is typed by the user: it needs to be canonicalized before
1963 searching the symbol tables. */
1964 canon = cp_canonicalize_string_no_typedefs (copy);
1968 make_cleanup (xfree, copy);
1971 /* Sort symbols so that symbols with the same program space are next
1973 qsort (VEC_address (symbolp, sym_classes),
1974 VEC_length (symbolp, sym_classes),
1979 info.result.sals = NULL;
1980 info.result.nelts = 0;
1982 /* Iterate over all the types, looking for the names of existing
1983 methods matching COPY. If we cannot find a direct method in a
1984 given program space, then we consider inherited methods; this is
1985 not ideal (ideal would be to respect C++ hiding rules), but it
1986 seems good enough and is what GDB has historically done. We only
1987 need to collect the names because later we find all symbols with
1988 those names. This loop is written in a somewhat funny way
1989 because we collect data across the program space before deciding
1991 superclass_vec = NULL;
1992 make_cleanup (VEC_cleanup (typep), &superclass_vec);
1993 result_names = NULL;
1994 make_cleanup (VEC_cleanup (const_char_ptr), &result_names);
1995 last_result_len = 0;
1996 for (ix = 0; VEC_iterate (symbolp, sym_classes, ix, sym); ++ix)
1999 struct program_space *pspace;
2001 /* Program spaces that are executing startup should have
2002 been filtered out earlier. */
2003 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym))->executing_startup);
2004 pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2005 set_current_program_space (pspace);
2006 t = check_typedef (SYMBOL_TYPE (sym));
2007 find_methods (t, copy, &result_names, &superclass_vec);
2009 /* Handle all items from a single program space at once; and be
2010 sure not to miss the last batch. */
2011 if (ix == VEC_length (symbolp, sym_classes) - 1
2013 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp, sym_classes,
2016 /* If we did not find a direct implementation anywhere in
2017 this program space, consider superclasses. */
2018 if (VEC_length (const_char_ptr, result_names) == last_result_len)
2019 find_superclass_methods (superclass_vec, copy, &result_names);
2021 /* We have a list of candidate symbol names, so now we
2022 iterate over the symbol tables looking for all
2023 matches in this pspace. */
2024 add_all_symbol_names_from_pspace (&info, pspace, result_names);
2026 VEC_truncate (typep, superclass_vec, 0);
2027 last_result_len = VEC_length (const_char_ptr, result_names);
2031 if (info.result.nelts > 0)
2033 if (self->canonical)
2035 self->canonical->pre_expanded = 1;
2036 if (self->user_filename)
2037 self->canonical->addr_string
2038 = xstrprintf ("%s:%s", self->user_filename, saved_arg);
2040 self->canonical->addr_string = xstrdup (saved_arg);
2043 do_cleanups (cleanup);
2049 cplusplus_error (saved_arg,
2050 "the class `%s' does not have destructor defined\n",
2053 cplusplus_error (saved_arg,
2054 "the class %s does not have any method named %s\n",
2060 /* This object is used when collecting all matching symtabs. */
2062 struct symtab_collector
2064 /* The result vector of symtabs. */
2065 VEC (symtab_p) *symtabs;
2067 /* This is used to ensure the symtabs are unique. */
2068 htab_t symtab_table;
2071 /* Callback for iterate_over_symtabs. */
2074 add_symtabs_to_list (struct symtab *symtab, void *d)
2076 struct symtab_collector *data = d;
2079 slot = htab_find_slot (data->symtab_table, symtab, INSERT);
2083 VEC_safe_push (symtab_p, data->symtabs, symtab);
2089 /* Given a file name, return a VEC of all matching symtabs. */
2091 static VEC (symtab_p) *
2092 collect_symtabs_from_filename (const char *file)
2094 struct symtab_collector collector;
2095 struct cleanup *cleanups;
2096 struct program_space *pspace;
2098 collector.symtabs = NULL;
2099 collector.symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer,
2101 cleanups = make_cleanup_htab_delete (collector.symtab_table);
2103 /* Find that file's data. */
2104 ALL_PSPACES (pspace)
2106 if (pspace->executing_startup)
2109 set_current_program_space (pspace);
2110 iterate_over_symtabs (file, add_symtabs_to_list, &collector);
2113 do_cleanups (cleanups);
2114 return collector.symtabs;
2117 /* Return all the symtabs associated to the filename given by the
2118 substring of *ARGPTR ending at P, and advance ARGPTR past that
2121 static VEC (symtab_p) *
2122 symtabs_from_filename (char **argptr, char *p, int is_quote_enclosed,
2123 char **user_filename)
2127 struct cleanup *outer;
2128 VEC (symtab_p) *result;
2131 while (p != *argptr && p[-1] == ' ')
2133 if ((*p == '"') && is_quote_enclosed)
2135 copy = xmalloc (p - *argptr + 1);
2136 outer = make_cleanup (xfree, copy);
2137 memcpy (copy, *argptr, p - *argptr);
2138 /* It may have the ending quote right after the file name. */
2139 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
2140 || copy[p - *argptr - 1] == '\'')
2141 copy[p - *argptr - 1] = 0;
2143 copy[p - *argptr] = 0;
2145 result = collect_symtabs_from_filename (copy);
2147 if (VEC_empty (symtab_p, result))
2149 if (!have_full_symbols () && !have_partial_symbols ())
2150 throw_error (NOT_FOUND_ERROR,
2151 _("No symbol table is loaded. "
2152 "Use the \"file\" command."));
2153 throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy);
2156 /* Discard the file name from the arg. */
2160 *argptr = skip_spaces (p1 + 1);
2162 discard_cleanups (outer);
2163 *user_filename = copy;
2167 /* A callback used by iterate_over_all_matching_symtabs that collects
2168 symbols for find_function_symbols. */
2171 collect_function_symbols (struct symbol *sym, void *arg)
2173 VEC (symbolp) **syms = arg;
2175 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2176 VEC_safe_push (symbolp, *syms, sym);
2181 /* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR
2182 and return the symbol. If not found, return NULL. */
2184 static VEC (symbolp) *
2185 find_function_symbols (char **argptr, char *p, int is_quote_enclosed,
2186 char **user_function)
2190 VEC (symbolp) *result = NULL;
2193 while (p != *argptr && p[-1] == ' ')
2195 if ((*p == '"') && is_quote_enclosed)
2197 copy = (char *) xmalloc (p - *argptr + 1);
2198 *user_function = copy;
2199 memcpy (copy, *argptr, p - *argptr);
2200 /* It may have the ending quote right after the file name. */
2201 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
2202 || copy[p - *argptr - 1] == '\'')
2203 copy[p - *argptr - 1] = 0;
2205 copy[p - *argptr] = 0;
2207 iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
2208 collect_function_symbols, &result, NULL);
2210 if (VEC_empty (symbolp, result))
2211 VEC_free (symbolp, result);
2214 /* Discard the file name from the arg. */
2215 *argptr = skip_spaces (p1 + 1);
2223 /* A helper for decode_all_digits that handles the 'list_mode' case. */
2226 decode_digits_list_mode (struct linespec_state *self,
2227 struct symtabs_and_lines *values,
2228 struct symtab_and_line val)
2233 gdb_assert (self->list_mode);
2235 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2237 /* The logic above should ensure this. */
2238 gdb_assert (elt != NULL);
2240 set_current_program_space (SYMTAB_PSPACE (elt));
2242 /* Simplistic search just for the list command. */
2243 val.symtab = find_line_symtab (elt, val.line, NULL, NULL);
2244 if (val.symtab == NULL)
2246 val.pspace = SYMTAB_PSPACE (elt);
2248 val.explicit_line = 1;
2250 add_sal_to_sals (self, values, &val, NULL);
2254 /* A helper for decode_all_digits that iterates over the symtabs,
2255 adding lines to the VEC. */
2258 decode_digits_ordinary (struct linespec_state *self,
2260 struct symtabs_and_lines *sals,
2261 struct linetable_entry **best_entry)
2266 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2269 VEC (CORE_ADDR) *pcs;
2272 /* The logic above should ensure this. */
2273 gdb_assert (elt != NULL);
2275 set_current_program_space (SYMTAB_PSPACE (elt));
2277 pcs = find_pcs_for_symtab_line (elt, line, best_entry);
2278 for (i = 0; VEC_iterate (CORE_ADDR, pcs, i, pc); ++i)
2280 struct symtab_and_line sal;
2283 sal.pspace = SYMTAB_PSPACE (elt);
2287 add_sal_to_sals_basic (sals, &sal);
2290 VEC_free (CORE_ADDR, pcs);
2294 /* This decodes a line where the argument is all digits (possibly
2295 preceded by a sign). Q should point to the end of those digits;
2296 the other arguments are as usual. */
2298 static struct symtabs_and_lines
2299 decode_all_digits (struct linespec_state *self,
2303 struct symtabs_and_lines values;
2304 struct symtab_and_line val;
2305 int use_default = 0;
2306 char *saved_arg = *argptr;
2318 /* This is where we need to make sure that we have good defaults.
2319 We must guarantee that this section of code is never executed
2320 when we are called with just a function name, since
2321 set_default_source_symtab_and_line uses
2322 select_source_symtab that calls us with such an argument. */
2324 if (VEC_length (symtab_p, self->file_symtabs) == 1
2325 && VEC_index (symtab_p, self->file_symtabs, 0) == NULL)
2327 set_current_program_space (self->program_space);
2329 /* Make sure we have at least a default source file. */
2330 set_default_source_symtab_and_line ();
2331 initialize_defaults (&self->default_symtab, &self->default_line);
2332 VEC_pop (symtab_p, self->file_symtabs);
2333 VEC_free (symtab_p, self->file_symtabs);
2335 = collect_symtabs_from_filename (self->default_symtab->filename);
2339 if (**argptr == '+')
2340 sign = plus, (*argptr)++;
2341 else if (**argptr == '-')
2342 sign = minus, (*argptr)++;
2343 val.line = atoi (*argptr);
2350 val.line = self->default_line + val.line;
2356 val.line = self->default_line - val.line;
2361 break; /* No need to adjust val.line. */
2364 *argptr = skip_spaces (q);
2366 if (self->list_mode)
2367 decode_digits_list_mode (self, &values, val);
2370 struct linetable_entry *best_entry = NULL;
2372 struct block **blocks;
2373 struct cleanup *cleanup;
2374 struct symtabs_and_lines intermediate_results;
2377 intermediate_results.sals = NULL;
2378 intermediate_results.nelts = 0;
2380 decode_digits_ordinary (self, val.line, &intermediate_results,
2382 if (intermediate_results.nelts == 0 && best_entry != NULL)
2383 decode_digits_ordinary (self, best_entry->line, &intermediate_results,
2386 cleanup = make_cleanup (xfree, intermediate_results.sals);
2388 /* For optimized code, compiler can scatter one source line
2389 accross disjoint ranges of PC values, even when no duplicate
2390 functions or inline functions are involved. For example,
2391 'for (;;)' inside non-template non-inline non-ctor-or-dtor
2392 function can result in two PC ranges. In this case, we don't
2393 want to set breakpoint on first PC of each range. To filter
2394 such cases, we use containing blocks -- for each PC found
2395 above we see if there are other PCs that are in the same
2396 block. If yes, the other PCs are filtered out. */
2398 filter = xmalloc (intermediate_results.nelts * sizeof (int));
2399 make_cleanup (xfree, filter);
2400 blocks = xmalloc (intermediate_results.nelts * sizeof (struct block *));
2401 make_cleanup (xfree, blocks);
2403 for (i = 0; i < intermediate_results.nelts; ++i)
2405 set_current_program_space (intermediate_results.sals[i].pspace);
2408 blocks[i] = block_for_pc_sect (intermediate_results.sals[i].pc,
2409 intermediate_results.sals[i].section);
2412 for (i = 0; i < intermediate_results.nelts; ++i)
2414 if (blocks[i] != NULL)
2415 for (j = i + 1; j < intermediate_results.nelts; ++j)
2417 if (blocks[j] == blocks[i])
2425 for (i = 0; i < intermediate_results.nelts; ++i)
2428 struct symbol *sym = (blocks[i]
2429 ? block_containing_function (blocks[i])
2432 if (self->funfirstline)
2433 skip_prologue_sal (&intermediate_results.sals[i]);
2434 /* Make sure the line matches the request, not what was
2436 intermediate_results.sals[i].line = val.line;
2437 add_sal_to_sals (self, &values, &intermediate_results.sals[i],
2438 sym ? SYMBOL_NATURAL_NAME (sym) : NULL);
2441 do_cleanups (cleanup);
2444 if (values.nelts == 0)
2446 if (self->user_filename)
2447 throw_error (NOT_FOUND_ERROR, _("No line %d in file \"%s\"."),
2448 val.line, self->user_filename);
2450 throw_error (NOT_FOUND_ERROR, _("No line %d in the current file."),
2454 if (self->canonical)
2456 char *copy = savestring (saved_arg, q - saved_arg);
2458 self->canonical->pre_expanded = 1;
2459 gdb_assert (self->user_filename || use_default);
2460 self->canonical->addr_string
2461 = xstrprintf ("%s:%s", (self->user_filename
2462 ? self->user_filename
2463 : self->default_symtab->filename),
2473 /* Decode a linespec starting with a dollar sign. */
2475 static struct symtabs_and_lines
2476 decode_dollar (struct linespec_state *self, char *copy)
2480 struct symtabs_and_lines values;
2481 struct symtab_and_line val;
2484 struct minimal_symbol *msymbol;
2488 p = (copy[1] == '$') ? copy + 2 : copy + 1;
2489 while (*p >= '0' && *p <= '9')
2491 if (!*p) /* Reached end of token without hitting non-digit. */
2493 /* We have a value history reference. */
2494 struct value *val_history;
2496 sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index);
2497 val_history = access_value_history ((copy[1] == '$') ? -index : index);
2498 if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
2499 error (_("History values used in line "
2500 "specs must have integer values."));
2501 valx = value_as_long (val_history);
2505 /* Not all digits -- may be user variable/function or a
2506 convenience variable. */
2508 volatile struct gdb_exception exc;
2510 /* Avoid "may be used uninitialized" warning. */
2514 TRY_CATCH (exc, RETURN_MASK_ERROR)
2516 values = decode_variable (self, copy);
2519 if (exc.reason == 0)
2522 if (exc.error != NOT_FOUND_ERROR)
2523 throw_exception (exc);
2525 /* Not a user variable or function -- must be convenience variable. */
2526 if (!get_internalvar_integer (lookup_internalvar (copy + 1), &valx))
2527 error (_("Convenience variables used in line "
2528 "specs must have integer values."));
2536 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2540 elt = self->default_symtab;
2541 set_current_program_space (self->program_space);
2544 set_current_program_space (SYMTAB_PSPACE (elt));
2546 /* Either history value or convenience value from above, in valx. */
2550 val.pspace = elt ? SYMTAB_PSPACE (elt) : current_program_space;
2552 add_sal_to_sals (self, &values, &val, NULL);
2555 if (self->canonical)
2557 self->canonical->pre_expanded = 1;
2558 if (self->user_filename)
2559 self->canonical->addr_string = xstrprintf ("%s:%s",
2560 self->user_filename, copy);
2562 self->canonical->addr_string = xstrdup (copy);
2570 /* A helper for decode_line_1 that tries to find a label. The label
2571 is searched for in the current block.
2572 FUNCTION_SYMBOLS is a list of the enclosing functions; or NULL if none
2574 COPY is the name of the label to find.
2575 CANONICAL is the same as the "canonical" argument to decode_line_1.
2576 RESULT is a pointer to a symtabs_and_lines structure which will be
2577 filled in on success.
2578 This function returns 1 if a label was found, 0 otherwise. */
2581 decode_label (struct linespec_state *self,
2582 VEC (symbolp) *function_symbols, char *copy,
2583 struct symtabs_and_lines *result)
2585 struct symbol *fn_sym;
2588 if (function_symbols == NULL)
2590 struct block *block;
2592 struct symtab_and_line sal;
2593 struct symtabs_and_lines values;
2598 set_current_program_space (self->program_space);
2599 block = get_search_block (NULL);
2602 block && !BLOCK_FUNCTION (block);
2603 block = BLOCK_SUPERBLOCK (block))
2607 fn_sym = BLOCK_FUNCTION (block);
2609 sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0);
2614 symbol_to_sal (&sal, self->funfirstline, sym);
2615 add_sal_to_sals (self, &values, &sal,
2616 SYMBOL_NATURAL_NAME (fn_sym));
2618 if (self->canonical)
2620 self->canonical->special_display = 1;
2621 self->canonical->addr_string
2622 = xstrprintf ("%s:%s", SYMBOL_NATURAL_NAME (fn_sym),
2631 result->sals = NULL;
2634 for (ix = 0; VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix)
2636 struct block *block;
2639 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym)));
2640 block = SYMBOL_BLOCK_VALUE (fn_sym);
2641 sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0);
2645 struct symtab_and_line sal;
2648 symbol_to_sal (&sal, self->funfirstline, sym);
2649 symname = xstrprintf ("%s:%s",
2650 SYMBOL_NATURAL_NAME (fn_sym),
2651 SYMBOL_NATURAL_NAME (sym));
2652 add_sal_to_sals (self, result, &sal, symname);
2657 if (self->canonical && result->nelts > 0)
2659 self->canonical->pre_expanded = 1;
2660 self->canonical->special_display = 1;
2662 gdb_assert (self->user_function);
2663 self->canonical->addr_string
2664 = xstrprintf ("%s:%s", self->user_function, copy);
2667 return result->nelts > 0;
2670 /* A callback used to possibly add a symbol to the results. */
2673 collect_symbols (struct symbol *sym, void *data)
2675 struct collect_info *info = data;
2676 struct symtab_and_line sal;
2678 if (symbol_to_sal (&sal, info->state->funfirstline, sym)
2679 && maybe_add_address (info->state->addr_set,
2680 SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)),
2682 add_sal_to_sals (info->state, &info->result, &sal,
2683 SYMBOL_NATURAL_NAME (sym));
2688 /* We've found a minimal symbol MSYMBOL to associate with our
2689 linespec; add it to the result symtabs_and_lines. */
2692 minsym_found (struct linespec_state *self, struct objfile *objfile,
2693 struct minimal_symbol *msymbol,
2694 struct symtabs_and_lines *result)
2696 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2698 struct symtab_and_line sal;
2700 sal = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol),
2701 (struct obj_section *) 0, 0);
2702 sal.section = SYMBOL_OBJ_SECTION (msymbol);
2704 /* The minimal symbol might point to a function descriptor;
2705 resolve it to the actual code address instead. */
2706 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, ¤t_target);
2708 sal = find_pc_sect_line (pc, NULL, 0);
2710 if (self->funfirstline)
2711 skip_prologue_sal (&sal);
2713 if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc))
2714 add_sal_to_sals (self, result, &sal, SYMBOL_NATURAL_NAME (msymbol));
2717 /* A helper struct which just holds a minimal symbol and the object
2718 file from which it came. */
2720 typedef struct minsym_and_objfile
2722 struct minimal_symbol *minsym;
2723 struct objfile *objfile;
2724 } minsym_and_objfile_d;
2726 DEF_VEC_O (minsym_and_objfile_d);
2728 /* A helper struct to pass some data through
2729 iterate_over_minimal_symbols. */
2731 struct collect_minsyms
2733 /* The objfile we're examining. */
2734 struct objfile *objfile;
2736 /* The funfirstline setting from the initial call. */
2739 /* The list_mode setting from the initial call. */
2742 /* The resulting symbols. */
2743 VEC (minsym_and_objfile_d) *msyms;
2746 /* A helper function to classify a minimal_symbol_type according to
2750 classify_mtype (enum minimal_symbol_type t)
2757 /* Intermediate priority. */
2760 case mst_solib_trampoline:
2761 /* Lowest priority. */
2765 /* Highest priority. */
2770 /* Callback for qsort that sorts symbols by priority. */
2773 compare_msyms (const void *a, const void *b)
2775 const minsym_and_objfile_d *moa = a;
2776 const minsym_and_objfile_d *mob = b;
2777 enum minimal_symbol_type ta = MSYMBOL_TYPE (moa->minsym);
2778 enum minimal_symbol_type tb = MSYMBOL_TYPE (mob->minsym);
2780 return classify_mtype (ta) - classify_mtype (tb);
2783 /* Callback for iterate_over_minimal_symbols that adds the symbol to
2787 add_minsym (struct minimal_symbol *minsym, void *d)
2789 struct collect_minsyms *info = d;
2790 minsym_and_objfile_d mo;
2792 /* Exclude data symbols when looking for breakpoint locations. */
2793 if (!info->list_mode)
2794 switch (minsym->type)
2796 case mst_slot_got_plt:
2806 mo.objfile = info->objfile;
2807 VEC_safe_push (minsym_and_objfile_d, info->msyms, &mo);
2810 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
2811 is not NULL, the search is restricted to just that program
2815 search_minsyms_for_name (struct collect_info *info, const char *name,
2816 struct program_space *search_pspace)
2818 struct objfile *objfile;
2819 struct program_space *pspace;
2821 ALL_PSPACES (pspace)
2823 struct collect_minsyms local;
2824 struct cleanup *cleanup;
2826 if (search_pspace != NULL && search_pspace != pspace)
2828 if (pspace->executing_startup)
2831 set_current_program_space (pspace);
2833 memset (&local, 0, sizeof (local));
2834 local.funfirstline = info->state->funfirstline;
2835 local.list_mode = info->state->list_mode;
2837 cleanup = make_cleanup (VEC_cleanup (minsym_and_objfile_d),
2840 ALL_OBJFILES (objfile)
2842 local.objfile = objfile;
2843 iterate_over_minimal_symbols (objfile, name, add_minsym, &local);
2846 if (!VEC_empty (minsym_and_objfile_d, local.msyms))
2850 minsym_and_objfile_d *item;
2852 qsort (VEC_address (minsym_and_objfile_d, local.msyms),
2853 VEC_length (minsym_and_objfile_d, local.msyms),
2854 sizeof (minsym_and_objfile_d),
2857 /* Now the minsyms are in classification order. So, we walk
2858 over them and process just the minsyms with the same
2859 classification as the very first minsym in the list. */
2860 item = VEC_index (minsym_and_objfile_d, local.msyms, 0);
2861 classification = classify_mtype (MSYMBOL_TYPE (item->minsym));
2864 VEC_iterate (minsym_and_objfile_d, local.msyms, ix, item);
2867 if (classify_mtype (MSYMBOL_TYPE (item->minsym)) != classification)
2870 minsym_found (info->state, item->objfile, item->minsym,
2875 do_cleanups (cleanup);
2879 /* A helper function to add all symbols matching NAME to INFO. If
2880 PSPACE is not NULL, the search is restricted to just that program
2884 add_matching_symbols_to_info (const char *name,
2885 struct collect_info *info,
2886 struct program_space *pspace)
2891 for (ix = 0; VEC_iterate (symtab_p, info->state->file_symtabs, ix, elt); ++ix)
2897 iterate_over_all_matching_symtabs (name, VAR_DOMAIN,
2898 collect_symbols, info,
2900 search_minsyms_for_name (info, name, pspace);
2902 else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))
2904 /* Program spaces that are executing startup should have
2905 been filtered out earlier. */
2906 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
2907 set_current_program_space (SYMTAB_PSPACE (elt));
2908 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt), name,
2909 VAR_DOMAIN, collect_symbols,
2915 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
2916 look in that symtab's static variables first. */
2918 static struct symtabs_and_lines
2919 decode_variable (struct linespec_state *self, char *copy)
2921 struct collect_info info;
2922 const char *lookup_name;
2924 struct cleanup *cleanup;
2927 info.result.sals = NULL;
2928 info.result.nelts = 0;
2930 cleanup = demangle_for_lookup (copy, current_language->la_language,
2932 if (current_language->la_language == language_ada)
2934 /* In Ada, the symbol lookups are performed using the encoded
2935 name rather than the demangled name. */
2936 lookup_name = ada_name_for_lookup (copy);
2937 make_cleanup (xfree, (void *) lookup_name);
2940 canon = cp_canonicalize_string_no_typedefs (lookup_name);
2943 make_cleanup (xfree, canon);
2944 lookup_name = canon;
2947 add_matching_symbols_to_info (lookup_name, &info, NULL);
2949 if (info.result.nelts > 0)
2951 if (self->canonical)
2953 self->canonical->pre_expanded = 1;
2954 if (self->user_filename)
2955 self->canonical->addr_string
2956 = xstrprintf ("%s:%s", self->user_filename, copy);
2958 self->canonical->addr_string = xstrdup (copy);
2963 if (!have_full_symbols ()
2964 && !have_partial_symbols ()
2965 && !have_minimal_symbols ())
2966 throw_error (NOT_FOUND_ERROR,
2967 _("No symbol table is loaded. Use the \"file\" command."));
2968 if (self->user_filename)
2969 throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined in \"%s\"."),
2970 copy, self->user_filename);
2972 throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined."), copy);
2978 /* Now come some functions that are called from multiple places within
2982 symbol_to_sal (struct symtab_and_line *result,
2983 int funfirstline, struct symbol *sym)
2985 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2987 *result = find_function_start_sal (sym, funfirstline);
2992 if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
2995 result->symtab = SYMBOL_SYMTAB (sym);
2996 result->line = SYMBOL_LINE (sym);
2997 result->pc = SYMBOL_VALUE_ADDRESS (sym);
2998 result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2999 result->explicit_pc = 1;
3002 else if (funfirstline)
3006 else if (SYMBOL_LINE (sym) != 0)
3008 /* We know its line number. */
3010 result->symtab = SYMBOL_SYMTAB (sym);
3011 result->line = SYMBOL_LINE (sym);
3012 result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
3020 /* See the comment in linespec.h. */
3023 init_linespec_result (struct linespec_result *lr)
3025 memset (lr, 0, sizeof (*lr));
3028 /* See the comment in linespec.h. */
3031 destroy_linespec_result (struct linespec_result *ls)
3034 struct linespec_sals *lsal;
3036 xfree (ls->addr_string);
3037 for (i = 0; VEC_iterate (linespec_sals, ls->sals, i, lsal); ++i)
3039 xfree (lsal->canonical);
3040 xfree (lsal->sals.sals);
3042 VEC_free (linespec_sals, ls->sals);
3045 /* Cleanup function for a linespec_result. */
3048 cleanup_linespec_result (void *a)
3050 destroy_linespec_result (a);
3053 /* See the comment in linespec.h. */
3056 make_cleanup_destroy_linespec_result (struct linespec_result *ls)
3058 return make_cleanup (cleanup_linespec_result, ls);