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;
126 /* Prototypes for local functions. */
128 static void initialize_defaults (struct symtab **default_symtab,
131 static struct symtabs_and_lines decode_indirect (struct linespec_state *self,
134 static char *locate_first_half (char **argptr, int *is_quote_enclosed);
136 static struct symtabs_and_lines decode_objc (struct linespec_state *self,
139 static struct symtabs_and_lines decode_compound (struct linespec_state *self,
144 static VEC (symbolp) *lookup_prefix_sym (char **argptr, char *p,
148 static struct symtabs_and_lines find_method (struct linespec_state *self,
151 const char *class_name,
152 VEC (symbolp) *sym_classes);
154 static void cplusplus_error (const char *name, const char *fmt, ...)
155 ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 3);
157 static char *find_toplevel_char (char *s, char c);
159 static int is_objc_method_format (const char *s);
161 static VEC (symtab_p) *symtabs_from_filename (char **argptr,
162 char *p, int is_quote_enclosed,
163 char **user_filename);
165 static VEC (symbolp) *find_function_symbols (char **argptr, char *p,
166 int is_quote_enclosed,
167 char **user_function);
169 static struct symtabs_and_lines decode_all_digits (struct linespec_state *self,
173 static struct symtabs_and_lines decode_dollar (struct linespec_state *self,
176 static int decode_label (struct linespec_state *self,
177 VEC (symbolp) *function_symbols,
179 struct symtabs_and_lines *result);
181 static struct symtabs_and_lines decode_variable (struct linespec_state *self,
184 static int symbol_to_sal (struct symtab_and_line *result,
185 int funfirstline, struct symbol *sym);
187 static void add_matching_symbols_to_info (const char *name,
188 struct collect_info *info,
189 struct program_space *pspace);
191 static void add_all_symbol_names_from_pspace (struct collect_info *info,
192 struct program_space *pspace,
193 VEC (const_char_ptr) *names);
195 /* Helper functions. */
197 /* Add SAL to SALS. */
200 add_sal_to_sals_basic (struct symtabs_and_lines *sals,
201 struct symtab_and_line *sal)
204 sals->sals = xrealloc (sals->sals, sals->nelts * sizeof (sals->sals[0]));
205 sals->sals[sals->nelts - 1] = *sal;
208 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
209 the new sal, if needed. If not NULL, SYMNAME is the name of the
210 symbol to use when constructing the new canonical name. */
213 add_sal_to_sals (struct linespec_state *self,
214 struct symtabs_and_lines *sals,
215 struct symtab_and_line *sal,
218 add_sal_to_sals_basic (sals, sal);
222 char *canonical_name = NULL;
224 self->canonical_names = xrealloc (self->canonical_names,
225 sals->nelts * sizeof (char *));
226 if (sal->symtab && sal->symtab->filename)
228 char *filename = sal->symtab->filename;
230 /* Note that the filter doesn't have to be a valid linespec
231 input. We only apply the ":LINE" treatment to Ada for
233 if (symname != NULL && sal->line != 0
234 && current_language->la_language == language_ada)
235 canonical_name = xstrprintf ("%s:%s:%d", filename, symname,
237 else if (symname != NULL)
238 canonical_name = xstrprintf ("%s:%s", filename, symname);
240 canonical_name = xstrprintf ("%s:%d", filename, sal->line);
243 self->canonical_names[sals->nelts - 1] = canonical_name;
247 /* A hash function for address_entry. */
250 hash_address_entry (const void *p)
252 const struct address_entry *aep = p;
255 hash = iterative_hash_object (aep->pspace, 0);
256 return iterative_hash_object (aep->addr, hash);
259 /* An equality function for address_entry. */
262 eq_address_entry (const void *a, const void *b)
264 const struct address_entry *aea = a;
265 const struct address_entry *aeb = b;
267 return aea->pspace == aeb->pspace && aea->addr == aeb->addr;
270 /* Check whether the address, represented by PSPACE and ADDR, is
271 already in the set. If so, return 0. Otherwise, add it and return
275 maybe_add_address (htab_t set, struct program_space *pspace, CORE_ADDR addr)
277 struct address_entry e, *p;
282 slot = htab_find_slot (set, &e, INSERT);
286 p = XNEW (struct address_entry);
287 memcpy (p, &e, sizeof (struct address_entry));
293 /* Issue a helpful hint on using the command completion feature on
294 single quoted demangled C++ symbols as part of the completion
298 cplusplus_error (const char *name, const char *fmt, ...)
300 struct ui_file *tmp_stream;
303 tmp_stream = mem_fileopen ();
304 make_cleanup_ui_file_delete (tmp_stream);
309 va_start (args, fmt);
310 vfprintf_unfiltered (tmp_stream, fmt, args);
314 while (*name == '\'')
316 fprintf_unfiltered (tmp_stream,
317 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
318 "(Note leading single quote.)"),
321 message = ui_file_xstrdup (tmp_stream, NULL);
322 make_cleanup (xfree, message);
323 throw_error (NOT_FOUND_ERROR, "%s", message);
326 /* A helper for iterate_over_all_matching_symtabs that is passed as a
327 callback to the expand_symtabs_matching method. */
330 iterate_name_matcher (const struct language_defn *language,
331 const char *name, void *d)
333 const char **dname = d;
335 if (language->la_symbol_name_compare (name, *dname) == 0)
340 /* A helper that walks over all matching symtabs in all objfiles and
341 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
342 not NULL, then the search is restricted to just that program
346 iterate_over_all_matching_symtabs (const char *name,
347 const domain_enum domain,
348 int (*callback) (struct symbol *, void *),
350 struct program_space *search_pspace)
352 struct objfile *objfile;
353 struct program_space *pspace;
357 if (search_pspace != NULL && search_pspace != pspace)
359 if (pspace->executing_startup)
362 set_current_program_space (pspace);
364 ALL_OBJFILES (objfile)
366 struct symtab *symtab;
369 objfile->sf->qf->expand_symtabs_matching (objfile, NULL,
370 iterate_name_matcher,
374 ALL_OBJFILE_SYMTABS (objfile, symtab)
380 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
381 LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data);
388 /* Returns the block to be used for symbol searches for the given SYMTAB,
389 which may be NULL. */
391 static struct block *
392 get_search_block (struct symtab *symtab)
397 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
400 enum language save_language;
402 /* get_selected_block can change the current language when there is
403 no selected frame yet. */
404 save_language = current_language->la_language;
405 block = get_selected_block (0);
406 set_language (save_language);
412 /* A helper for find_method. This finds all methods in type T which
413 match NAME. It adds resulting symbol names to RESULT_NAMES, and
414 adds T's direct superclasses to SUPERCLASSES. */
417 find_methods (struct type *t, const char *name,
418 VEC (const_char_ptr) **result_names,
419 VEC (typep) **superclasses)
423 char *class_name = type_name_no_tag (t);
426 /* Ignore this class if it doesn't have a name. This is ugly, but
427 unless we figure out how to get the physname without the name of
428 the class, then the loop can't do any good. */
432 int name_len = strlen (name);
436 /* Loop over each method name. At this level, all overloads of a name
437 are counted as a single name. There is an inner loop which loops over
440 for (method_counter = TYPE_NFN_FIELDS (t) - 1;
444 char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
447 if (strncmp (method_name, "__", 2) == 0 ||
448 strncmp (method_name, "op", 2) == 0 ||
449 strncmp (method_name, "type", 4) == 0)
451 if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI))
452 method_name = dem_opname;
453 else if (cplus_demangle_opname (method_name, dem_opname, 0))
454 method_name = dem_opname;
457 if (strcmp_iw (method_name, name) == 0)
461 for (field_counter = (TYPE_FN_FIELDLIST_LENGTH (t, method_counter)
467 const char *phys_name;
469 f = TYPE_FN_FIELDLIST1 (t, method_counter);
470 if (TYPE_FN_FIELD_STUB (f, field_counter))
472 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
473 VEC_safe_push (const_char_ptr, *result_names, phys_name);
479 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
480 VEC_safe_push (typep, *superclasses, TYPE_BASECLASS (t, ibase));
483 /* Find an instance of the character C in the string S that is outside
484 of all parenthesis pairs, single-quoted strings, and double-quoted
485 strings. Also, ignore the char within a template name, like a ','
486 within foo<int, int>. */
489 find_toplevel_char (char *s, char c)
491 int quoted = 0; /* zero if we're not in quotes;
492 '"' if we're in a double-quoted string;
493 '\'' if we're in a single-quoted string. */
494 int depth = 0; /* Number of unclosed parens we've seen. */
497 for (scan = s; *scan; scan++)
503 else if (*scan == '\\' && *(scan + 1))
506 else if (*scan == c && ! quoted && depth == 0)
508 else if (*scan == '"' || *scan == '\'')
510 else if (*scan == '(' || *scan == '<')
512 else if ((*scan == ')' || *scan == '>') && depth > 0)
519 /* Determines if the gives string corresponds to an Objective-C method
520 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
521 are allowed to have spaces and parentheses in them. */
524 is_objc_method_format (const char *s)
526 if (s == NULL || *s == '\0')
528 /* Handle arguments with the format FILENAME:SYMBOL. */
529 if ((s[0] == ':') && (strchr ("+-", s[1]) != NULL)
530 && (s[2] == '[') && strchr(s, ']'))
532 /* Handle arguments that are just SYMBOL. */
533 else if ((strchr ("+-", s[0]) != NULL) && (s[1] == '[') && strchr(s, ']'))
538 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
539 and store the result in SELF->CANONICAL. */
542 filter_results (struct linespec_state *self,
543 struct symtabs_and_lines *result,
544 VEC (const_char_ptr) *filters)
549 for (i = 0; VEC_iterate (const_char_ptr, filters, i, name); ++i)
551 struct linespec_sals lsal;
554 memset (&lsal, 0, sizeof (lsal));
556 for (j = 0; j < result->nelts; ++j)
558 if (strcmp (name, self->canonical_names[j]) == 0)
559 add_sal_to_sals_basic (&lsal.sals, &result->sals[j]);
562 if (lsal.sals.nelts > 0)
564 lsal.canonical = xstrdup (name);
565 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
569 self->canonical->pre_expanded = 0;
572 /* Store RESULT into SELF->CANONICAL. */
575 convert_results_to_lsals (struct linespec_state *self,
576 struct symtabs_and_lines *result)
578 struct linespec_sals lsal;
580 lsal.canonical = NULL;
582 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
585 /* Handle multiple results in RESULT depending on SELECT_MODE. This
586 will either return normally, throw an exception on multiple
587 results, or present a menu to the user. On return, the SALS vector
588 in SELF->CANONICAL is set up properly. */
591 decode_line_2 (struct linespec_state *self,
592 struct symtabs_and_lines *result,
593 const char *select_mode)
598 struct cleanup *old_chain;
599 VEC (const_char_ptr) *item_names = NULL, *filters = NULL;
600 struct get_number_or_range_state state;
602 gdb_assert (select_mode != multiple_symbols_all);
603 gdb_assert (self->canonical != NULL);
605 old_chain = make_cleanup (VEC_cleanup (const_char_ptr), &item_names);
606 make_cleanup (VEC_cleanup (const_char_ptr), &filters);
607 for (i = 0; i < result->nelts; ++i)
612 gdb_assert (self->canonical_names[i] != NULL);
613 for (j = 0; VEC_iterate (const_char_ptr, item_names, j, iter); ++j)
615 if (strcmp (iter, self->canonical_names[i]) == 0)
623 VEC_safe_push (const_char_ptr, item_names, self->canonical_names[i]);
626 if (select_mode == multiple_symbols_cancel
627 && VEC_length (const_char_ptr, item_names) > 1)
628 error (_("canceled because the command is ambiguous\n"
629 "See set/show multiple-symbol."));
631 if (select_mode == multiple_symbols_all
632 || VEC_length (const_char_ptr, item_names) == 1)
634 do_cleanups (old_chain);
635 convert_results_to_lsals (self, result);
639 printf_unfiltered (_("[0] cancel\n[1] all\n"));
640 for (i = 0; VEC_iterate (const_char_ptr, item_names, i, iter); ++i)
641 printf_unfiltered ("[%d] %s\n", i + 2, iter);
643 prompt = getenv ("PS2");
648 args = command_line_input (prompt, 0, "overload-choice");
650 if (args == 0 || *args == 0)
651 error_no_arg (_("one or more choice numbers"));
653 init_number_or_range (&state, args);
654 while (!state.finished)
658 num = get_number_or_range (&state);
661 error (_("canceled"));
664 /* We intentionally make this result in a single breakpoint,
665 contrary to what older versions of gdb did. The
666 rationale is that this lets a user get the
667 multiple_symbols_all behavior even with the 'ask'
668 setting; and he can get separate breakpoints by entering
669 "2-57" at the query. */
670 do_cleanups (old_chain);
671 convert_results_to_lsals (self, result);
676 if (num >= VEC_length (const_char_ptr, item_names))
677 printf_unfiltered (_("No choice number %d.\n"), num);
680 const char *elt = VEC_index (const_char_ptr, item_names, num);
684 VEC_safe_push (const_char_ptr, filters, elt);
685 VEC_replace (const_char_ptr, item_names, num, NULL);
689 printf_unfiltered (_("duplicate request for %d ignored.\n"),
695 filter_results (self, result, filters);
696 do_cleanups (old_chain);
699 /* Valid delimiters for linespec keywords "if", "thread" or "task". */
702 is_linespec_boundary (char c)
704 return c == ' ' || c == '\t' || c == '\0' || c == ',';
707 /* A helper function for decode_line_1 and friends which skips P
708 past any method overload information at the beginning of P, e.g.,
709 "(const struct foo *)".
711 This function assumes that P has already been validated to contain
712 overload information, and it will assert if *P != '('. */
714 find_method_overload_end (char *p)
718 gdb_assert (*p == '(');
738 /* Keep important information used when looking up a name. This includes
739 template parameters, overload information, and important keywords, including
740 the possible Java trailing type. */
743 keep_name_info (char *p, int on_boundary)
745 const char *quotes = get_gdb_completer_quote_characters ();
751 if (strchr (quotes, *p))
754 if (*p == ',' && !nest)
757 if (on_boundary && !nest)
759 const char *const words[] = { "if", "thread", "task" };
762 for (wordi = 0; wordi < ARRAY_SIZE (words); wordi++)
763 if (strncmp (p, words[wordi], strlen (words[wordi])) == 0
764 && is_linespec_boundary (p[strlen (words[wordi])]))
766 if (wordi < ARRAY_SIZE (words))
770 if (*p == '(' || *p == '<' || *p == '[')
772 else if ((*p == ')' || *p == '>' || *p == ']') && nest > 0)
777 /* The ',' check could fail on "operator ,". */
778 p += cp_validate_operator (p);
780 on_boundary = is_linespec_boundary (p[-1]);
783 while (p > saved_p && is_linespec_boundary (p[-1]))
790 /* The parser of linespec itself. */
792 /* Parse a string that specifies a line number.
793 Pass the address of a char * variable; that variable will be
794 advanced over the characters actually parsed.
798 LINENUM -- that line number in current file. PC returned is 0.
799 FILE:LINENUM -- that line in that file. PC returned is 0.
800 FUNCTION -- line number of openbrace of that function.
801 PC returned is the start of the function.
802 LABEL -- a label in the current scope
803 VARIABLE -- line number of definition of that variable.
805 FILE:FUNCTION -- likewise, but prefer functions in that file.
806 *EXPR -- line in which address EXPR appears.
808 This may all be followed by an "if EXPR", which we ignore.
810 FUNCTION may be an undebuggable function found in minimal symbol table.
812 If the argument FUNFIRSTLINE is nonzero, we want the first line
813 of real code inside a function when a function is specified, and it is
814 not OK to specify a variable or type to get its line number.
816 DEFAULT_SYMTAB specifies the file to use if none is specified.
817 It defaults to current_source_symtab.
818 DEFAULT_LINE specifies the line number to use for relative
819 line numbers (that start with signs). Defaults to current_source_line.
820 If CANONICAL is non-NULL, store an array of strings containing the canonical
821 line specs there if necessary. Currently overloaded member functions and
822 line numbers or static functions without a filename yield a canonical
823 line spec. The array and the line spec strings are allocated on the heap,
824 it is the callers responsibility to free them.
826 Note that it is possible to return zero for the symtab
827 if no file is validly specified. Callers must check that.
828 Also, the line number returned may be invalid. */
830 /* We allow single quotes in various places. This is a hideous
831 kludge, which exists because the completer can't yet deal with the
832 lack of single quotes. FIXME: write a linespec_completer which we
833 can use as appropriate instead of make_symbol_completion_list. */
835 static struct symtabs_and_lines
836 decode_line_internal (struct linespec_state *self, char **argptr)
842 /* This says whether or not something in *ARGPTR is quoted with
843 completer_quotes (i.e. with single quotes). */
845 /* Is *ARGPTR enclosed in double quotes? */
846 int is_quote_enclosed;
847 int is_objc_method = 0;
848 char *saved_arg = *argptr;
849 /* If IS_QUOTED, the end of the quoted bit. */
850 char *end_quote = NULL;
851 /* Is *ARGPTR enclosed in single quotes? */
852 int is_squote_enclosed = 0;
853 /* The "first half" of the linespec. */
856 /* If we are parsing `function:label', this holds the symbols
857 matching the function name. */
858 VEC (symbolp) *function_symbols = NULL;
859 /* If FUNCTION_SYMBOLS is not NULL, then this is the exception that
860 was thrown when trying to parse a filename. */
861 volatile struct gdb_exception file_exception;
863 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
865 /* Defaults have defaults. */
867 initialize_defaults (&self->default_symtab, &self->default_line);
869 /* See if arg is *PC. */
873 do_cleanups (cleanup);
874 return decode_indirect (self, argptr);
877 is_quoted = (strchr (get_gdb_completer_quote_characters (),
882 end_quote = skip_quoted (*argptr);
883 if (*end_quote == '\0')
884 is_squote_enclosed = 1;
887 /* Check to see if it's a multipart linespec (with colons or
890 /* Locate the end of the first half of the linespec.
891 After the call, for instance, if the argptr string is "foo.c:123"
892 p will point at "123". If there is only one part, like "foo", p
893 will point to "". If this is a C++ name, like "A::B::foo", p will
894 point to "::B::foo". Argptr is not changed by this call. */
896 first_half = p = locate_first_half (argptr, &is_quote_enclosed);
898 /* First things first: if ARGPTR starts with a filename, get its
899 symtab and strip the filename from ARGPTR. */
900 TRY_CATCH (file_exception, RETURN_MASK_ERROR)
902 self->file_symtabs = symtabs_from_filename (argptr, p, is_quote_enclosed,
903 &self->user_filename);
906 if (VEC_empty (symtab_p, self->file_symtabs))
908 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
909 VEC_safe_push (symtab_p, self->file_symtabs, NULL);
912 if (file_exception.reason >= 0)
914 /* Check for single quotes on the non-filename part. */
915 is_quoted = (**argptr
916 && strchr (get_gdb_completer_quote_characters (),
919 end_quote = skip_quoted (*argptr);
921 /* Locate the next "half" of the linespec. */
922 first_half = p = locate_first_half (argptr, &is_quote_enclosed);
925 /* Check if this is an Objective-C method (anything that starts with
926 a '+' or '-' and a '['). */
927 if (is_objc_method_format (p))
930 /* Check if the symbol could be an Objective-C selector. */
933 struct symtabs_and_lines values;
935 values = decode_objc (self, argptr);
936 if (values.sals != NULL)
938 do_cleanups (cleanup);
943 /* Does it look like there actually were two parts? */
945 if (p[0] == ':' || p[0] == '.')
947 /* Is it a C++ or Java compound data structure?
948 The check on p[1] == ':' is capturing the case of "::",
949 since p[0]==':' was checked above.
950 Note that the call to decode_compound does everything
951 for us, including the lookup on the symbol table, so we
954 if (p[0] == '.' || p[1] == ':')
956 struct symtabs_and_lines values;
957 volatile struct gdb_exception ex;
958 char *saved_argptr = *argptr;
960 if (is_quote_enclosed)
963 /* Initialize it just to avoid a GCC false warning. */
964 memset (&values, 0, sizeof (values));
966 TRY_CATCH (ex, RETURN_MASK_ERROR)
968 values = decode_compound (self, argptr, saved_arg, p);
970 if ((is_quoted || is_squote_enclosed) && **argptr == '\'')
971 *argptr = *argptr + 1;
975 do_cleanups (cleanup);
979 if (ex.error != NOT_FOUND_ERROR)
980 throw_exception (ex);
982 *argptr = saved_argptr;
986 /* If there was an exception looking up a specified filename earlier,
987 then check whether we were really given `function:label'. */
988 if (file_exception.reason < 0)
990 function_symbols = find_function_symbols (argptr, p,
992 &self->user_function);
994 /* If we did not find a function, re-throw the original
996 if (!function_symbols)
997 throw_exception (file_exception);
999 make_cleanup (VEC_cleanup (symbolp), &function_symbols);
1002 /* Check for single quotes on the non-filename part. */
1005 is_quoted = (**argptr
1006 && strchr (get_gdb_completer_quote_characters (),
1009 end_quote = skip_quoted (*argptr);
1014 /* self->file_symtabs holds the specified file symtabs, or 0 if no file
1016 If we are parsing `function:symbol', then FUNCTION_SYMBOLS holds the
1017 functions before the `:'.
1018 arg no longer contains the file name. */
1020 /* If the filename was quoted, we must re-check the quotation. */
1022 if (end_quote == first_half && *end_quote!= '\0')
1024 is_quoted = (**argptr
1025 && strchr (get_gdb_completer_quote_characters (),
1028 end_quote = skip_quoted (*argptr);
1031 /* Check whether arg is all digits (and sign). */
1034 if (*q == '-' || *q == '+')
1036 while (*q >= '0' && *q <= '9')
1039 if (q != *argptr && (*q == 0 || *q == ' ' || *q == '\t' || *q == ',')
1040 && function_symbols == NULL)
1042 struct symtabs_and_lines values;
1044 /* We found a token consisting of all digits -- at least one digit. */
1045 values = decode_all_digits (self, argptr, q);
1046 do_cleanups (cleanup);
1050 /* Arg token is not digits => try it as a variable name
1051 Find the next token (everything up to end or next whitespace). */
1053 if (**argptr == '$') /* May be a convenience variable. */
1054 /* One or two $ chars possible. */
1055 p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1));
1056 else if (is_quoted || is_squote_enclosed)
1060 error (_("Unmatched single quote."));
1062 else if (is_objc_method)
1064 /* allow word separators in method names for Obj-C. */
1065 p = skip_quoted_chars (*argptr, NULL, "");
1069 p = skip_quoted (*argptr);
1072 /* Keep any important naming information. */
1073 p = keep_name_info (p, p == saved_arg || is_linespec_boundary (p[-1]));
1075 copy = (char *) alloca (p - *argptr + 1);
1076 memcpy (copy, *argptr, p - *argptr);
1077 copy[p - *argptr] = '\0';
1080 && copy[0] == copy[p - *argptr - 1]
1081 && strchr (get_gdb_completer_quote_characters (), copy[0]) != NULL)
1083 copy[p - *argptr - 1] = '\0';
1086 else if (is_quoted || is_squote_enclosed)
1087 copy[p - *argptr - 1] = '\0';
1089 *argptr = skip_spaces (p);
1091 /* If it starts with $: may be a legitimate variable or routine name
1092 (e.g. HP-UX millicode routines such as $$dyncall), or it may
1093 be history value, or it may be a convenience variable. */
1095 if (*copy == '$' && function_symbols == NULL)
1097 struct symtabs_and_lines values;
1099 values = decode_dollar (self, copy);
1100 do_cleanups (cleanup);
1104 /* Try the token as a label, but only if no file was specified,
1105 because we can only really find labels in the current scope. */
1107 if (VEC_length (symtab_p, self->file_symtabs) == 1
1108 && VEC_index (symtab_p, self->file_symtabs, 0) == NULL)
1110 struct symtabs_and_lines label_result;
1111 if (decode_label (self, function_symbols, copy, &label_result))
1113 do_cleanups (cleanup);
1114 return label_result;
1118 if (function_symbols)
1119 throw_exception (file_exception);
1121 /* Look up that token as a variable.
1122 If file specified, use that file's per-file block to start with. */
1125 struct symtabs_and_lines values;
1127 values = decode_variable (self, copy);
1128 do_cleanups (cleanup);
1133 /* A constructor for linespec_state. */
1136 linespec_state_constructor (struct linespec_state *self,
1138 struct symtab *default_symtab,
1140 struct linespec_result *canonical)
1142 memset (self, 0, sizeof (*self));
1143 self->funfirstline = (flags & DECODE_LINE_FUNFIRSTLINE) ? 1 : 0;
1144 self->list_mode = (flags & DECODE_LINE_LIST_MODE) ? 1 : 0;
1145 self->default_symtab = default_symtab;
1146 self->default_line = default_line;
1147 self->canonical = canonical;
1148 self->program_space = current_program_space;
1149 self->addr_set = htab_create_alloc (10, hash_address_entry, eq_address_entry,
1150 xfree, xcalloc, xfree);
1153 /* A destructor for linespec_state. */
1156 linespec_state_destructor (void *arg)
1158 struct linespec_state *self = arg;
1160 xfree (self->user_filename);
1161 xfree (self->user_function);
1162 VEC_free (symtab_p, self->file_symtabs);
1163 htab_delete (self->addr_set);
1166 /* See linespec.h. */
1169 decode_line_full (char **argptr, int flags,
1170 struct symtab *default_symtab,
1171 int default_line, struct linespec_result *canonical,
1172 const char *select_mode,
1175 struct symtabs_and_lines result;
1176 struct linespec_state state;
1177 struct cleanup *cleanups;
1178 char *arg_start = *argptr;
1179 VEC (const_char_ptr) *filters = NULL;
1181 gdb_assert (canonical != NULL);
1182 /* The filter only makes sense for 'all'. */
1183 gdb_assert (filter == NULL || select_mode == multiple_symbols_all);
1184 gdb_assert (select_mode == NULL
1185 || select_mode == multiple_symbols_all
1186 || select_mode == multiple_symbols_ask
1187 || select_mode == multiple_symbols_cancel);
1188 gdb_assert ((flags & DECODE_LINE_LIST_MODE) == 0);
1190 linespec_state_constructor (&state, flags,
1191 default_symtab, default_line, canonical);
1192 cleanups = make_cleanup (linespec_state_destructor, &state);
1193 save_current_program_space ();
1195 result = decode_line_internal (&state, argptr);
1197 gdb_assert (result.nelts == 1 || canonical->pre_expanded);
1198 gdb_assert (canonical->addr_string != NULL);
1199 canonical->pre_expanded = 1;
1201 /* Fill in the missing canonical names. */
1202 if (result.nelts > 0)
1206 if (state.canonical_names == NULL)
1207 state.canonical_names = xcalloc (result.nelts, sizeof (char *));
1208 make_cleanup (xfree, state.canonical_names);
1209 for (i = 0; i < result.nelts; ++i)
1211 if (state.canonical_names[i] == NULL)
1212 state.canonical_names[i] = savestring (arg_start,
1213 *argptr - arg_start);
1214 make_cleanup (xfree, state.canonical_names[i]);
1218 if (select_mode == NULL)
1220 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
1221 select_mode = multiple_symbols_all;
1223 select_mode = multiple_symbols_select_mode ();
1226 if (select_mode == multiple_symbols_all)
1230 make_cleanup (VEC_cleanup (const_char_ptr), &filters);
1231 VEC_safe_push (const_char_ptr, filters, filter);
1232 filter_results (&state, &result, filters);
1235 convert_results_to_lsals (&state, &result);
1238 decode_line_2 (&state, &result, select_mode);
1240 do_cleanups (cleanups);
1243 struct symtabs_and_lines
1244 decode_line_1 (char **argptr, int flags,
1245 struct symtab *default_symtab,
1248 struct symtabs_and_lines result;
1249 struct linespec_state state;
1250 struct cleanup *cleanups;
1252 linespec_state_constructor (&state, flags,
1253 default_symtab, default_line, NULL);
1254 cleanups = make_cleanup (linespec_state_destructor, &state);
1255 save_current_program_space ();
1257 result = decode_line_internal (&state, argptr);
1258 do_cleanups (cleanups);
1264 /* First, some functions to initialize stuff at the beggining of the
1268 initialize_defaults (struct symtab **default_symtab, int *default_line)
1270 if (*default_symtab == 0)
1272 /* Use whatever we have for the default source line. We don't use
1273 get_current_or_default_symtab_and_line as it can recurse and call
1275 struct symtab_and_line cursal =
1276 get_current_source_symtab_and_line ();
1278 *default_symtab = cursal.symtab;
1279 *default_line = cursal.line;
1285 /* Decode arg of the form *PC. */
1287 static struct symtabs_and_lines
1288 decode_indirect (struct linespec_state *self, char **argptr)
1290 struct symtabs_and_lines values;
1292 char *initial = *argptr;
1294 if (current_program_space->executing_startup)
1295 /* The error message doesn't really matter, because this case
1296 should only hit during breakpoint reset. */
1297 throw_error (NOT_FOUND_ERROR, _("cannot evaluate expressions while "
1298 "program space is in startup"));
1301 pc = value_as_address (parse_to_comma_and_eval (argptr));
1303 values.sals = (struct symtab_and_line *)
1304 xmalloc (sizeof (struct symtab_and_line));
1307 values.sals[0] = find_pc_line (pc, 0);
1308 values.sals[0].pc = pc;
1309 values.sals[0].section = find_pc_overlay (pc);
1310 values.sals[0].explicit_pc = 1;
1312 if (self->canonical)
1313 self->canonical->addr_string = savestring (initial, *argptr - initial);
1320 /* Locate the first half of the linespec, ending in a colon, period,
1321 or whitespace. (More or less.) Also, check to see if *ARGPTR is
1322 enclosed in double quotes; if so, set is_quote_enclosed, advance
1323 ARGPTR past that and zero out the trailing double quote.
1324 If ARGPTR is just a simple name like "main", p will point to ""
1328 locate_first_half (char **argptr, int *is_quote_enclosed)
1334 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1335 and we must isolate the first half. Outer layers will call again later
1336 for the second half.
1338 Don't count commas that appear in argument lists of overloaded
1339 functions, or in quoted strings. It's stupid to go to this much
1340 trouble when the rest of the function is such an obvious roach hotel. */
1341 ii = find_toplevel_char (*argptr, ',');
1342 has_comma = (ii != 0);
1344 /* Temporarily zap out second half to not confuse the code below.
1345 This is undone below. Do not change ii!! */
1351 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
1352 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
1358 *is_quote_enclosed = 1;
1364 *is_quote_enclosed = 0;
1365 if (strchr (get_gdb_completer_quote_characters (), *p))
1373 /* Check for a drive letter in the filename. This is done on all hosts
1374 to capture cross-compilation environments. On Unixen, directory
1375 separators are illegal in filenames, so if the user enters "e:/foo.c",
1376 he is referring to a directory named "e:" and a source file named
1377 "foo.c", and we still want to keep these two pieces together. */
1378 if (isalpha (p[0]) && p[1] == ':' && IS_DIR_SEPARATOR (p[2]))
1385 char *temp_end = find_template_name_end (p);
1388 error (_("malformed template specification in command"));
1393 p = find_method_overload_end (p);
1395 /* Check for a colon and a plus or minus and a [ (which
1396 indicates an Objective-C method). */
1397 if (is_objc_method_format (p))
1401 /* Check for the end of the first half of the linespec. End of
1402 line, a tab, a colon or a space. But if enclosed in double
1403 quotes we do not break on enclosed spaces. */
1407 || ((p[0] == ' ') && !*is_quote_enclosed))
1409 if (p[0] == '.' && strchr (p, ':') == NULL)
1411 /* Java qualified method. Find the *last* '.', since the
1412 others are package qualifiers. Stop at any open parenthesis
1413 which might provide overload information. */
1414 for (p1 = p; *p1 && *p1 != '('; p1++)
1422 p = skip_spaces (p);
1424 /* If the closing double quote was left at the end, remove it. */
1425 if (*is_quote_enclosed)
1427 char *closing_quote = strchr (p - 1, '"');
1429 if (closing_quote && closing_quote[1] == '\0')
1430 *closing_quote = '\0';
1433 /* Now that we've safely parsed the first half, put back ',' so
1434 outer layers can see it. */
1443 /* Here's where we recognise an Objective-C Selector. An Objective C
1444 selector may be implemented by more than one class, therefore it
1445 may represent more than one method/function. This gives us a
1446 situation somewhat analogous to C++ overloading. If there's more
1447 than one method that could represent the selector, then use some of
1448 the existing C++ code to let the user choose one. */
1450 static struct symtabs_and_lines
1451 decode_objc (struct linespec_state *self, char **argptr)
1453 struct collect_info info;
1454 VEC (const_char_ptr) *symbol_names = NULL;
1456 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
1460 info.result.sals = NULL;
1461 info.result.nelts = 0;
1463 new_argptr = find_imps (*argptr, &symbol_names);
1464 if (VEC_empty (const_char_ptr, symbol_names))
1466 do_cleanups (cleanup);
1470 add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
1472 if (info.result.nelts > 0)
1476 saved_arg = alloca (new_argptr - *argptr + 1);
1477 memcpy (saved_arg, *argptr, new_argptr - *argptr);
1478 saved_arg[new_argptr - *argptr] = '\0';
1480 if (self->canonical)
1482 self->canonical->pre_expanded = 1;
1483 if (self->user_filename)
1484 self->canonical->addr_string
1485 = xstrprintf ("%s:%s", self->user_filename, saved_arg);
1487 self->canonical->addr_string = xstrdup (saved_arg);
1491 *argptr = new_argptr;
1493 do_cleanups (cleanup);
1497 /* This handles C++ and Java compound data structures. P should point
1498 at the first component separator, i.e. double-colon or period. As
1499 an example, on entrance to this function we could have ARGPTR
1500 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
1502 static struct symtabs_and_lines
1503 decode_compound (struct linespec_state *self,
1504 char **argptr, char *the_real_saved_arg, char *p)
1506 struct symtabs_and_lines values;
1508 char *saved_arg2 = *argptr;
1512 VEC (symbolp) *sym_classes;
1513 char *saved_arg, *class_name;
1514 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1516 /* If the user specified any completer quote characters in the input,
1517 strip them. They are superfluous. */
1518 saved_arg = alloca (strlen (the_real_saved_arg) + 1);
1520 char *dst = saved_arg;
1521 char *src = the_real_saved_arg;
1522 char *quotes = get_gdb_completer_quote_characters ();
1523 while (*src != '\0')
1525 if (strchr (quotes, *src) == NULL)
1532 /* First check for "global" namespace specification, of the form
1533 "::foo". If found, skip over the colons and jump to normal
1534 symbol processing. I.e. the whole line specification starts with
1535 "::" (note the condition that *argptr == p). */
1537 && ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t')))
1540 /* Given our example "AAA::inA::fun", we have two cases to consider:
1542 1) AAA::inA is the name of a class. In that case, presumably it
1543 has a method called "fun"; we then look up that method using
1546 2) AAA::inA isn't the name of a class. In that case, either the
1547 user made a typo, AAA::inA is the name of a namespace, or it is
1548 the name of a minimal symbol.
1549 In this case we just delegate to decode_variable.
1551 Thus, our first task is to find everything before the last set of
1552 double-colons and figure out if it's the name of a class. So we
1553 first loop through all of the double-colons. */
1555 p2 = p; /* Save for restart. */
1557 /* This is very messy. Following the example above we have now the
1560 argptr -> "AAA::inA::fun
1561 saved_arg -> "AAA::inA::fun
1562 saved_arg2 -> "AAA::inA::fun
1563 p2 -> "::inA::fun". */
1565 /* In the loop below, with these strings, we'll make 2 passes, each
1566 is marked in comments. */
1570 static char *break_characters = " \t(";
1572 /* Move pointer up to next possible class/namespace token. */
1574 p = p2 + 1; /* Restart with old value +1. */
1576 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1577 i.e. if there is a double-colon, p will now point to the
1579 /* PASS2: p2->"::fun", p->":fun" */
1581 /* Move pointer ahead to next double-colon. */
1583 && strchr (break_characters, *p) == NULL
1584 && strchr (get_gdb_completer_quote_characters (), *p) == NULL)
1586 if (current_language->la_language == language_cplus)
1587 p += cp_validate_operator (p);
1591 temp_end = find_template_name_end (p);
1593 error (_("malformed template specification in command"));
1596 /* Note that, since, at the start of this loop, p would be
1597 pointing to the second colon in a double-colon, we only
1598 satisfy the condition below if there is another
1599 double-colon to the right (after). I.e. there is another
1600 component that can be a class or a namespace. I.e, if at
1601 the beginning of this loop (PASS1), we had
1602 p->":inA::fun", we'll trigger this when p has been
1603 advanced to point to "::fun". */
1604 /* PASS2: we will not trigger this. */
1605 else if ((p[0] == ':') && (p[1] == ':'))
1606 break; /* Found double-colon. */
1609 /* PASS2: We'll keep getting here, until P points to one of the
1610 break characters, at which point we exit this loop. */
1614 && strncmp (&p[1], CP_ANONYMOUS_NAMESPACE_STR,
1615 CP_ANONYMOUS_NAMESPACE_LEN) == 0)
1616 p += CP_ANONYMOUS_NAMESPACE_LEN;
1617 else if (strchr (break_characters, *p) == NULL)
1624 break; /* Out of the while (1). This would happen
1625 for instance if we have looked up
1626 unsuccessfully all the components of the
1627 string, and p->""(PASS2). */
1629 /* We get here if p points to one of the break characters or "" (i.e.,
1631 /* Save restart for next time around. */
1633 /* Restore argptr as it was on entry to this function. */
1634 *argptr = saved_arg2;
1635 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1638 /* All ready for next pass through the loop. */
1642 /* Start of lookup in the symbol tables. */
1644 /* Lookup in the symbol table the substring between argptr and
1645 p. Note, this call changes the value of argptr. */
1646 /* Before the call, argptr->"AAA::inA::fun",
1647 p->"", p2->"::fun". After the call: argptr->"fun", p, p2
1649 sym_classes = lookup_prefix_sym (argptr, p2, self->file_symtabs,
1651 make_cleanup (VEC_cleanup (symbolp), &sym_classes);
1652 make_cleanup (xfree, class_name);
1654 /* If a class has been found, then we're in case 1 above. So we
1655 look up "fun" as a method of those classes. */
1656 if (!VEC_empty (symbolp, sym_classes))
1658 /* Arg token is not digits => try it as a function name.
1659 Find the next token (everything up to end or next
1662 && strchr (get_gdb_completer_quote_characters (),
1665 p = skip_quoted (*argptr);
1666 *argptr = *argptr + 1;
1670 /* At this point argptr->"fun". */
1674 while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':'
1677 /* At this point p->"". String ended. */
1678 /* Nope, C++ operators could have spaces in them
1679 ("foo::operator <" or "foo::operator delete []").
1680 I apologize, this is a bit hacky... */
1681 if (current_language->la_language == language_cplus
1682 && *p == ' ' && p - 8 - *argptr + 1 > 0)
1684 /* The above loop has already swallowed "operator". */
1685 p += cp_validate_operator (p - 8) - 8;
1688 /* Keep any important naming information. */
1689 p = keep_name_info (p, 1);
1692 /* Allocate our own copy of the substring between argptr and
1694 copy = (char *) alloca (p - *argptr + 1);
1695 memcpy (copy, *argptr, p - *argptr);
1696 copy[p - *argptr] = '\0';
1698 && copy[p - *argptr - 1]
1699 && strchr (get_gdb_completer_quote_characters (),
1700 copy[p - *argptr - 1]) != NULL)
1701 copy[p - *argptr - 1] = '\0';
1703 /* At this point copy->"fun", p->"". */
1705 /* No line number may be specified. */
1706 *argptr = skip_spaces (p);
1707 /* At this point arptr->"". */
1709 /* Look for copy as a method of sym_class. */
1710 /* At this point copy->"fun", sym_class is "AAA:inA",
1711 saved_arg->"AAA::inA::fun". This concludes the scanning of
1712 the string for possible components matches. If we find it
1713 here, we return. If not, and we are at the and of the string,
1714 we'll lookup the whole string in the symbol tables. */
1716 values = find_method (self, saved_arg, copy, class_name, sym_classes);
1718 do_cleanups (cleanup);
1720 } /* End if symbol found. */
1723 /* We couldn't find a class, so we're in case 2 above. We check the
1724 entire name as a symbol instead. The simplest way to do this is
1725 to just throw an exception and let our caller fall through to
1728 throw_error (NOT_FOUND_ERROR, _("see caller, this text doesn't matter"));
1731 /* An instance of this type is used when collecting prefix symbols for
1734 struct decode_compound_collector
1736 /* The result vector. */
1737 VEC (symbolp) *symbols;
1739 /* A hash table of all symbols we found. We use this to avoid
1740 adding any symbol more than once. */
1744 /* A callback for iterate_over_symbols that is used by
1745 lookup_prefix_sym to collect type symbols. */
1748 collect_one_symbol (struct symbol *sym, void *d)
1750 struct decode_compound_collector *collector = d;
1754 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1757 t = SYMBOL_TYPE (sym);
1759 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1760 && TYPE_CODE (t) != TYPE_CODE_UNION
1761 && TYPE_CODE (t) != TYPE_CODE_NAMESPACE)
1764 slot = htab_find_slot (collector->unique_syms, sym, INSERT);
1768 VEC_safe_push (symbolp, collector->symbols, sym);
1774 /* Return the symbol corresponding to the substring of *ARGPTR ending
1775 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1776 name in question, the compound object separator ("::" or "."), and
1777 whitespace. Note that *ARGPTR is changed whether or not the
1778 this call finds anything (i.e we return NULL). As an
1779 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
1781 static VEC (symbolp) *
1782 lookup_prefix_sym (char **argptr, char *p, VEC (symtab_p) *file_symtabs,
1789 struct decode_compound_collector collector;
1790 struct cleanup *outer;
1791 struct cleanup *cleanup;
1792 struct block *search_block;
1794 /* Extract the class name. */
1796 while (p != *argptr && p[-1] == ' ')
1798 copy = (char *) xmalloc (p - *argptr + 1);
1799 memcpy (copy, *argptr, p - *argptr);
1800 copy[p - *argptr] = 0;
1802 outer = make_cleanup (xfree, copy);
1804 /* Discard the class name from the argptr. */
1805 p = p1 + (p1[0] == ':' ? 2 : 1);
1806 p = skip_spaces (p);
1809 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1810 argptr->"inA::fun". */
1812 collector.symbols = NULL;
1813 make_cleanup (VEC_cleanup (symbolp), &collector.symbols);
1815 collector.unique_syms = htab_create_alloc (1, htab_hash_pointer,
1816 htab_eq_pointer, NULL,
1818 cleanup = make_cleanup_htab_delete (collector.unique_syms);
1820 for (ix = 0; VEC_iterate (symtab_p, file_symtabs, ix, elt); ++ix)
1824 iterate_over_all_matching_symtabs (copy, STRUCT_DOMAIN,
1825 collect_one_symbol, &collector,
1827 iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
1828 collect_one_symbol, &collector,
1833 struct block *search_block;
1835 /* Program spaces that are executing startup should have
1836 been filtered out earlier. */
1837 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
1838 set_current_program_space (SYMTAB_PSPACE (elt));
1839 search_block = get_search_block (elt);
1840 LA_ITERATE_OVER_SYMBOLS (search_block, copy, STRUCT_DOMAIN,
1841 collect_one_symbol, &collector);
1842 LA_ITERATE_OVER_SYMBOLS (search_block, copy, VAR_DOMAIN,
1843 collect_one_symbol, &collector);
1847 do_cleanups (cleanup);
1848 discard_cleanups (outer);
1849 return collector.symbols;
1852 /* A qsort comparison function for symbols. The resulting order does
1853 not actually matter; we just need to be able to sort them so that
1854 symbols with the same program space end up next to each other. */
1857 compare_symbols (const void *a, const void *b)
1859 struct symbol * const *sa = a;
1860 struct symbol * const *sb = b;
1863 uia = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa));
1864 uib = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb));
1871 uia = (uintptr_t) *sa;
1872 uib = (uintptr_t) *sb;
1882 /* Look for all the matching instances of each symbol in NAMES. Only
1883 instances from PSPACE are considered; other program spaces are
1884 handled by our caller. If PSPACE is NULL, then all program spaces
1885 are considered. Results are stored into INFO. */
1888 add_all_symbol_names_from_pspace (struct collect_info *info,
1889 struct program_space *pspace,
1890 VEC (const_char_ptr) *names)
1895 for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix)
1896 add_matching_symbols_to_info (iter, info, pspace);
1900 find_superclass_methods (VEC (typep) *superclasses,
1902 VEC (const_char_ptr) **result_names)
1904 int old_len = VEC_length (const_char_ptr, *result_names);
1905 VEC (typep) *iter_classes;
1906 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1908 iter_classes = superclasses;
1911 VEC (typep) *new_supers = NULL;
1915 make_cleanup (VEC_cleanup (typep), &new_supers);
1916 for (ix = 0; VEC_iterate (typep, iter_classes, ix, t); ++ix)
1917 find_methods (t, name, result_names, &new_supers);
1919 if (VEC_length (const_char_ptr, *result_names) != old_len
1920 || VEC_empty (typep, new_supers))
1923 iter_classes = new_supers;
1926 do_cleanups (cleanup);
1929 /* This finds the method COPY in the class whose type is given by one
1930 of the symbols in SYM_CLASSES. */
1932 static struct symtabs_and_lines
1933 find_method (struct linespec_state *self, char *saved_arg,
1934 char *copy, const char *class_name, VEC (symbolp) *sym_classes)
1938 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1940 int last_result_len;
1941 VEC (typep) *superclass_vec;
1942 VEC (const_char_ptr) *result_names;
1943 struct collect_info info;
1946 /* NAME is typed by the user: it needs to be canonicalized before
1947 searching the symbol tables. */
1948 canon = cp_canonicalize_string_no_typedefs (copy);
1952 make_cleanup (xfree, copy);
1955 /* Sort symbols so that symbols with the same program space are next
1957 qsort (VEC_address (symbolp, sym_classes),
1958 VEC_length (symbolp, sym_classes),
1963 info.result.sals = NULL;
1964 info.result.nelts = 0;
1966 /* Iterate over all the types, looking for the names of existing
1967 methods matching COPY. If we cannot find a direct method in a
1968 given program space, then we consider inherited methods; this is
1969 not ideal (ideal would be to respect C++ hiding rules), but it
1970 seems good enough and is what GDB has historically done. We only
1971 need to collect the names because later we find all symbols with
1972 those names. This loop is written in a somewhat funny way
1973 because we collect data across the program space before deciding
1975 superclass_vec = NULL;
1976 make_cleanup (VEC_cleanup (typep), &superclass_vec);
1977 result_names = NULL;
1978 make_cleanup (VEC_cleanup (const_char_ptr), &result_names);
1979 last_result_len = 0;
1980 for (ix = 0; VEC_iterate (symbolp, sym_classes, ix, sym); ++ix)
1983 struct program_space *pspace;
1985 /* Program spaces that are executing startup should have
1986 been filtered out earlier. */
1987 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym))->executing_startup);
1988 pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
1989 set_current_program_space (pspace);
1990 t = check_typedef (SYMBOL_TYPE (sym));
1991 find_methods (t, copy, &result_names, &superclass_vec);
1993 /* Handle all items from a single program space at once; and be
1994 sure not to miss the last batch. */
1995 if (ix == VEC_length (symbolp, sym_classes) - 1
1997 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp, sym_classes,
2000 /* If we did not find a direct implementation anywhere in
2001 this program space, consider superclasses. */
2002 if (VEC_length (const_char_ptr, result_names) == last_result_len)
2003 find_superclass_methods (superclass_vec, copy, &result_names);
2005 /* We have a list of candidate symbol names, so now we
2006 iterate over the symbol tables looking for all
2007 matches in this pspace. */
2008 add_all_symbol_names_from_pspace (&info, pspace, result_names);
2010 VEC_truncate (typep, superclass_vec, 0);
2011 last_result_len = VEC_length (const_char_ptr, result_names);
2015 if (info.result.nelts > 0)
2017 if (self->canonical)
2019 self->canonical->pre_expanded = 1;
2020 if (self->user_filename)
2021 self->canonical->addr_string
2022 = xstrprintf ("%s:%s", self->user_filename, saved_arg);
2024 self->canonical->addr_string = xstrdup (saved_arg);
2027 do_cleanups (cleanup);
2033 cplusplus_error (saved_arg,
2034 "the class `%s' does not have destructor defined\n",
2037 cplusplus_error (saved_arg,
2038 "the class %s does not have any method named %s\n",
2044 /* This object is used when collecting all matching symtabs. */
2046 struct symtab_collector
2048 /* The result vector of symtabs. */
2049 VEC (symtab_p) *symtabs;
2051 /* This is used to ensure the symtabs are unique. */
2052 htab_t symtab_table;
2055 /* Callback for iterate_over_symtabs. */
2058 add_symtabs_to_list (struct symtab *symtab, void *d)
2060 struct symtab_collector *data = d;
2063 slot = htab_find_slot (data->symtab_table, symtab, INSERT);
2067 VEC_safe_push (symtab_p, data->symtabs, symtab);
2073 /* Given a file name, return a VEC of all matching symtabs. */
2075 static VEC (symtab_p) *
2076 collect_symtabs_from_filename (const char *file)
2078 struct symtab_collector collector;
2079 struct cleanup *cleanups;
2080 struct program_space *pspace;
2082 collector.symtabs = NULL;
2083 collector.symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer,
2085 cleanups = make_cleanup_htab_delete (collector.symtab_table);
2087 /* Find that file's data. */
2088 ALL_PSPACES (pspace)
2090 if (pspace->executing_startup)
2093 set_current_program_space (pspace);
2094 iterate_over_symtabs (file, add_symtabs_to_list, &collector);
2097 do_cleanups (cleanups);
2098 return collector.symtabs;
2101 /* Return all the symtabs associated to the filename given by the
2102 substring of *ARGPTR ending at P, and advance ARGPTR past that
2105 static VEC (symtab_p) *
2106 symtabs_from_filename (char **argptr, char *p, int is_quote_enclosed,
2107 char **user_filename)
2111 struct cleanup *outer;
2112 VEC (symtab_p) *result;
2115 while (p != *argptr && p[-1] == ' ')
2117 if ((*p == '"') && is_quote_enclosed)
2119 copy = xmalloc (p - *argptr + 1);
2120 outer = make_cleanup (xfree, copy);
2121 memcpy (copy, *argptr, p - *argptr);
2122 /* It may have the ending quote right after the file name. */
2123 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
2124 || copy[p - *argptr - 1] == '\'')
2125 copy[p - *argptr - 1] = 0;
2127 copy[p - *argptr] = 0;
2129 result = collect_symtabs_from_filename (copy);
2131 if (VEC_empty (symtab_p, result))
2133 if (!have_full_symbols () && !have_partial_symbols ())
2134 throw_error (NOT_FOUND_ERROR,
2135 _("No symbol table is loaded. "
2136 "Use the \"file\" command."));
2137 throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy);
2140 /* Discard the file name from the arg. */
2144 *argptr = skip_spaces (p1 + 1);
2146 discard_cleanups (outer);
2147 *user_filename = copy;
2151 /* A callback used by iterate_over_all_matching_symtabs that collects
2152 symbols for find_function_symbols. */
2155 collect_function_symbols (struct symbol *sym, void *arg)
2157 VEC (symbolp) **syms = arg;
2159 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2160 VEC_safe_push (symbolp, *syms, sym);
2165 /* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR
2166 and return the symbol. If not found, return NULL. */
2168 static VEC (symbolp) *
2169 find_function_symbols (char **argptr, char *p, int is_quote_enclosed,
2170 char **user_function)
2174 VEC (symbolp) *result = NULL;
2177 while (p != *argptr && p[-1] == ' ')
2179 if ((*p == '"') && is_quote_enclosed)
2181 copy = (char *) xmalloc (p - *argptr + 1);
2182 *user_function = copy;
2183 memcpy (copy, *argptr, p - *argptr);
2184 /* It may have the ending quote right after the file name. */
2185 if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
2186 || copy[p - *argptr - 1] == '\'')
2187 copy[p - *argptr - 1] = 0;
2189 copy[p - *argptr] = 0;
2191 iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
2192 collect_function_symbols, &result, NULL);
2194 if (VEC_empty (symbolp, result))
2195 VEC_free (symbolp, result);
2198 /* Discard the file name from the arg. */
2199 *argptr = skip_spaces (p1 + 1);
2207 /* A helper for decode_all_digits that handles the 'list_mode' case. */
2210 decode_digits_list_mode (struct linespec_state *self,
2211 struct symtabs_and_lines *values,
2212 struct symtab_and_line val)
2217 gdb_assert (self->list_mode);
2219 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2221 /* The logic above should ensure this. */
2222 gdb_assert (elt != NULL);
2224 set_current_program_space (SYMTAB_PSPACE (elt));
2226 /* Simplistic search just for the list command. */
2227 val.symtab = find_line_symtab (elt, val.line, NULL, NULL);
2228 if (val.symtab == NULL)
2230 val.pspace = SYMTAB_PSPACE (elt);
2232 val.explicit_line = 1;
2234 add_sal_to_sals (self, values, &val, NULL);
2238 /* A helper for decode_all_digits that iterates over the symtabs,
2239 adding lines to the VEC. */
2242 decode_digits_ordinary (struct linespec_state *self,
2244 struct symtabs_and_lines *sals,
2245 struct linetable_entry **best_entry)
2250 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2253 VEC (CORE_ADDR) *pcs;
2256 /* The logic above should ensure this. */
2257 gdb_assert (elt != NULL);
2259 set_current_program_space (SYMTAB_PSPACE (elt));
2261 pcs = find_pcs_for_symtab_line (elt, line, best_entry);
2262 for (i = 0; VEC_iterate (CORE_ADDR, pcs, i, pc); ++i)
2264 struct symtab_and_line sal;
2267 sal.pspace = SYMTAB_PSPACE (elt);
2271 add_sal_to_sals_basic (sals, &sal);
2274 VEC_free (CORE_ADDR, pcs);
2278 /* This decodes a line where the argument is all digits (possibly
2279 preceded by a sign). Q should point to the end of those digits;
2280 the other arguments are as usual. */
2282 static struct symtabs_and_lines
2283 decode_all_digits (struct linespec_state *self,
2287 struct symtabs_and_lines values;
2288 struct symtab_and_line val;
2289 int use_default = 0;
2290 char *saved_arg = *argptr;
2302 /* This is where we need to make sure that we have good defaults.
2303 We must guarantee that this section of code is never executed
2304 when we are called with just a function name, since
2305 set_default_source_symtab_and_line uses
2306 select_source_symtab that calls us with such an argument. */
2308 if (VEC_length (symtab_p, self->file_symtabs) == 1
2309 && VEC_index (symtab_p, self->file_symtabs, 0) == NULL)
2311 set_current_program_space (self->program_space);
2313 /* Make sure we have at least a default source file. */
2314 set_default_source_symtab_and_line ();
2315 initialize_defaults (&self->default_symtab, &self->default_line);
2316 VEC_pop (symtab_p, self->file_symtabs);
2317 VEC_free (symtab_p, self->file_symtabs);
2319 = collect_symtabs_from_filename (self->default_symtab->filename);
2323 if (**argptr == '+')
2324 sign = plus, (*argptr)++;
2325 else if (**argptr == '-')
2326 sign = minus, (*argptr)++;
2327 val.line = atoi (*argptr);
2334 val.line = self->default_line + val.line;
2340 val.line = self->default_line - val.line;
2345 break; /* No need to adjust val.line. */
2348 *argptr = skip_spaces (q);
2350 if (self->list_mode)
2351 decode_digits_list_mode (self, &values, val);
2354 struct linetable_entry *best_entry = NULL;
2356 struct block **blocks;
2357 struct cleanup *cleanup;
2358 struct symtabs_and_lines intermediate_results;
2361 intermediate_results.sals = NULL;
2362 intermediate_results.nelts = 0;
2364 decode_digits_ordinary (self, val.line, &intermediate_results,
2366 if (intermediate_results.nelts == 0 && best_entry != NULL)
2367 decode_digits_ordinary (self, best_entry->line, &intermediate_results,
2370 cleanup = make_cleanup (xfree, intermediate_results.sals);
2372 /* For optimized code, compiler can scatter one source line
2373 accross disjoint ranges of PC values, even when no duplicate
2374 functions or inline functions are involved. For example,
2375 'for (;;)' inside non-template non-inline non-ctor-or-dtor
2376 function can result in two PC ranges. In this case, we don't
2377 want to set breakpoint on first PC of each range. To filter
2378 such cases, we use containing blocks -- for each PC found
2379 above we see if there are other PCs that are in the same
2380 block. If yes, the other PCs are filtered out. */
2382 filter = xmalloc (intermediate_results.nelts * sizeof (int));
2383 make_cleanup (xfree, filter);
2384 blocks = xmalloc (intermediate_results.nelts * sizeof (struct block *));
2385 make_cleanup (xfree, blocks);
2387 for (i = 0; i < intermediate_results.nelts; ++i)
2389 set_current_program_space (intermediate_results.sals[i].pspace);
2392 blocks[i] = block_for_pc_sect (intermediate_results.sals[i].pc,
2393 intermediate_results.sals[i].section);
2396 for (i = 0; i < intermediate_results.nelts; ++i)
2398 if (blocks[i] != NULL)
2399 for (j = i + 1; j < intermediate_results.nelts; ++j)
2401 if (blocks[j] == blocks[i])
2409 for (i = 0; i < intermediate_results.nelts; ++i)
2412 struct symbol *sym = (blocks[i]
2413 ? block_containing_function (blocks[i])
2416 if (self->funfirstline)
2417 skip_prologue_sal (&intermediate_results.sals[i]);
2418 /* Make sure the line matches the request, not what was
2420 intermediate_results.sals[i].line = val.line;
2421 add_sal_to_sals (self, &values, &intermediate_results.sals[i],
2422 sym ? SYMBOL_NATURAL_NAME (sym) : NULL);
2425 do_cleanups (cleanup);
2428 if (values.nelts == 0)
2430 if (self->user_filename)
2431 throw_error (NOT_FOUND_ERROR, _("No line %d in file \"%s\"."),
2432 val.line, self->user_filename);
2434 throw_error (NOT_FOUND_ERROR, _("No line %d in the current file."),
2438 if (self->canonical)
2440 char *copy = savestring (saved_arg, q - saved_arg);
2442 self->canonical->pre_expanded = 1;
2443 gdb_assert (self->user_filename || use_default);
2444 self->canonical->addr_string
2445 = xstrprintf ("%s:%s", (self->user_filename
2446 ? self->user_filename
2447 : self->default_symtab->filename),
2457 /* Decode a linespec starting with a dollar sign. */
2459 static struct symtabs_and_lines
2460 decode_dollar (struct linespec_state *self, char *copy)
2464 struct symtabs_and_lines values;
2465 struct symtab_and_line val;
2468 struct minimal_symbol *msymbol;
2472 p = (copy[1] == '$') ? copy + 2 : copy + 1;
2473 while (*p >= '0' && *p <= '9')
2475 if (!*p) /* Reached end of token without hitting non-digit. */
2477 /* We have a value history reference. */
2478 struct value *val_history;
2480 sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index);
2481 val_history = access_value_history ((copy[1] == '$') ? -index : index);
2482 if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
2483 error (_("History values used in line "
2484 "specs must have integer values."));
2485 valx = value_as_long (val_history);
2489 /* Not all digits -- may be user variable/function or a
2490 convenience variable. */
2492 volatile struct gdb_exception exc;
2494 /* Avoid "may be used uninitialized" warning. */
2498 TRY_CATCH (exc, RETURN_MASK_ERROR)
2500 values = decode_variable (self, copy);
2503 if (exc.reason == 0)
2506 if (exc.error != NOT_FOUND_ERROR)
2507 throw_exception (exc);
2509 /* Not a user variable or function -- must be convenience variable. */
2510 if (!get_internalvar_integer (lookup_internalvar (copy + 1), &valx))
2511 error (_("Convenience variables used in line "
2512 "specs must have integer values."));
2520 for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2524 elt = self->default_symtab;
2525 set_current_program_space (self->program_space);
2528 set_current_program_space (SYMTAB_PSPACE (elt));
2530 /* Either history value or convenience value from above, in valx. */
2534 val.pspace = elt ? SYMTAB_PSPACE (elt) : current_program_space;
2536 add_sal_to_sals (self, &values, &val, NULL);
2539 if (self->canonical)
2541 self->canonical->pre_expanded = 1;
2542 if (self->user_filename)
2543 self->canonical->addr_string = xstrprintf ("%s:%s",
2544 self->user_filename, copy);
2546 self->canonical->addr_string = xstrdup (copy);
2554 /* A helper for decode_line_1 that tries to find a label. The label
2555 is searched for in the current block.
2556 FUNCTION_SYMBOLS is a list of the enclosing functions; or NULL if none
2558 COPY is the name of the label to find.
2559 CANONICAL is the same as the "canonical" argument to decode_line_1.
2560 RESULT is a pointer to a symtabs_and_lines structure which will be
2561 filled in on success.
2562 This function returns 1 if a label was found, 0 otherwise. */
2565 decode_label (struct linespec_state *self,
2566 VEC (symbolp) *function_symbols, char *copy,
2567 struct symtabs_and_lines *result)
2569 struct symbol *fn_sym;
2572 if (function_symbols == NULL)
2574 struct block *block;
2576 struct symtab_and_line sal;
2577 struct symtabs_and_lines values;
2582 set_current_program_space (self->program_space);
2583 block = get_search_block (NULL);
2586 block && !BLOCK_FUNCTION (block);
2587 block = BLOCK_SUPERBLOCK (block))
2591 fn_sym = BLOCK_FUNCTION (block);
2593 sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0);
2598 symbol_to_sal (&sal, self->funfirstline, sym);
2599 add_sal_to_sals (self, &values, &sal,
2600 SYMBOL_NATURAL_NAME (fn_sym));
2602 if (self->canonical)
2604 self->canonical->special_display = 1;
2605 self->canonical->addr_string
2606 = xstrprintf ("%s:%s", SYMBOL_NATURAL_NAME (fn_sym),
2615 result->sals = NULL;
2618 for (ix = 0; VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix)
2620 struct block *block;
2623 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym)));
2624 block = SYMBOL_BLOCK_VALUE (fn_sym);
2625 sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0);
2629 struct symtab_and_line sal;
2632 symbol_to_sal (&sal, self->funfirstline, sym);
2633 symname = xstrprintf ("%s:%s",
2634 SYMBOL_NATURAL_NAME (fn_sym),
2635 SYMBOL_NATURAL_NAME (sym));
2636 add_sal_to_sals (self, result, &sal, symname);
2641 if (self->canonical && result->nelts > 0)
2643 self->canonical->pre_expanded = 1;
2644 self->canonical->special_display = 1;
2646 gdb_assert (self->user_function);
2647 self->canonical->addr_string
2648 = xstrprintf ("%s:%s", self->user_function, copy);
2651 return result->nelts > 0;
2654 /* A callback used to possibly add a symbol to the results. */
2657 collect_symbols (struct symbol *sym, void *data)
2659 struct collect_info *info = data;
2660 struct symtab_and_line sal;
2662 if ((SYMBOL_CLASS (sym) == LOC_STATIC
2663 && !info->state->funfirstline
2664 && !maybe_add_address (info->state->addr_set,
2665 SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)),
2666 SYMBOL_VALUE_ADDRESS (sym)))
2667 || (SYMBOL_CLASS (sym) == LOC_BLOCK
2668 && !maybe_add_address (info->state->addr_set,
2669 SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)),
2670 BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))))
2674 else if (symbol_to_sal (&sal, info->state->funfirstline, sym))
2675 add_sal_to_sals (info->state, &info->result, &sal,
2676 SYMBOL_NATURAL_NAME (sym));
2681 /* We've found a minimal symbol MSYMBOL to associate with our
2682 linespec; add it to the result symtabs_and_lines. */
2685 minsym_found (struct linespec_state *self, struct objfile *objfile,
2686 struct minimal_symbol *msymbol,
2687 struct symtabs_and_lines *result)
2689 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2691 struct symtab_and_line sal;
2693 sal = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol),
2694 (struct obj_section *) 0, 0);
2695 sal.section = SYMBOL_OBJ_SECTION (msymbol);
2697 /* The minimal symbol might point to a function descriptor;
2698 resolve it to the actual code address instead. */
2699 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, ¤t_target);
2701 sal = find_pc_sect_line (pc, NULL, 0);
2703 if (self->funfirstline)
2704 skip_prologue_sal (&sal);
2706 add_sal_to_sals (self, result, &sal, SYMBOL_NATURAL_NAME (msymbol));
2709 /* A helper struct which just holds a minimal symbol and the object
2710 file from which it came. */
2712 typedef struct minsym_and_objfile
2714 struct minimal_symbol *minsym;
2715 struct objfile *objfile;
2716 } minsym_and_objfile_d;
2718 DEF_VEC_O (minsym_and_objfile_d);
2720 /* A helper struct to pass some data through
2721 iterate_over_minimal_symbols. */
2723 struct collect_minsyms
2725 /* The objfile we're examining. */
2726 struct objfile *objfile;
2728 /* The funfirstline setting from the initial call. */
2731 /* The resulting symbols. */
2732 VEC (minsym_and_objfile_d) *msyms;
2735 /* A helper function to classify a minimal_symbol_type according to
2739 classify_mtype (enum minimal_symbol_type t)
2746 /* Intermediate priority. */
2749 case mst_solib_trampoline:
2750 /* Lowest priority. */
2754 /* Highest priority. */
2759 /* Callback for qsort that sorts symbols by priority. */
2762 compare_msyms (const void *a, const void *b)
2764 const minsym_and_objfile_d *moa = a;
2765 const minsym_and_objfile_d *mob = b;
2766 enum minimal_symbol_type ta = MSYMBOL_TYPE (moa->minsym);
2767 enum minimal_symbol_type tb = MSYMBOL_TYPE (mob->minsym);
2769 return classify_mtype (ta) - classify_mtype (tb);
2772 /* Callback for iterate_over_minimal_symbols that adds the symbol to
2776 add_minsym (struct minimal_symbol *minsym, void *d)
2778 struct collect_minsyms *info = d;
2779 minsym_and_objfile_d mo;
2782 mo.objfile = info->objfile;
2783 VEC_safe_push (minsym_and_objfile_d, info->msyms, &mo);
2786 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
2787 is not NULL, the search is restricted to just that program
2791 search_minsyms_for_name (struct collect_info *info, const char *name,
2792 struct program_space *search_pspace)
2794 struct objfile *objfile;
2795 struct program_space *pspace;
2797 ALL_PSPACES (pspace)
2799 struct collect_minsyms local;
2800 struct cleanup *cleanup;
2802 if (search_pspace != NULL && search_pspace != pspace)
2804 if (pspace->executing_startup)
2807 set_current_program_space (pspace);
2809 memset (&local, 0, sizeof (local));
2810 local.funfirstline = info->state->funfirstline;
2812 cleanup = make_cleanup (VEC_cleanup (minsym_and_objfile_d),
2815 ALL_OBJFILES (objfile)
2817 local.objfile = objfile;
2818 iterate_over_minimal_symbols (objfile, name, add_minsym, &local);
2821 if (!VEC_empty (minsym_and_objfile_d, local.msyms))
2825 minsym_and_objfile_d *item;
2827 qsort (VEC_address (minsym_and_objfile_d, local.msyms),
2828 VEC_length (minsym_and_objfile_d, local.msyms),
2829 sizeof (minsym_and_objfile_d),
2832 /* Now the minsyms are in classification order. So, we walk
2833 over them and process just the minsyms with the same
2834 classification as the very first minsym in the list. */
2835 item = VEC_index (minsym_and_objfile_d, local.msyms, 0);
2836 classification = classify_mtype (MSYMBOL_TYPE (item->minsym));
2839 VEC_iterate (minsym_and_objfile_d, local.msyms, ix, item);
2842 if (classify_mtype (MSYMBOL_TYPE (item->minsym)) != classification)
2845 if (maybe_add_address (info->state->addr_set,
2846 item->objfile->pspace,
2847 SYMBOL_VALUE_ADDRESS (item->minsym)))
2848 minsym_found (info->state, item->objfile, item->minsym,
2853 do_cleanups (cleanup);
2857 /* A helper function to add all symbols matching NAME to INFO. If
2858 PSPACE is not NULL, the search is restricted to just that program
2862 add_matching_symbols_to_info (const char *name,
2863 struct collect_info *info,
2864 struct program_space *pspace)
2869 for (ix = 0; VEC_iterate (symtab_p, info->state->file_symtabs, ix, elt); ++ix)
2875 iterate_over_all_matching_symtabs (name, VAR_DOMAIN,
2876 collect_symbols, info,
2878 search_minsyms_for_name (info, name, pspace);
2880 else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))
2882 /* Program spaces that are executing startup should have
2883 been filtered out earlier. */
2884 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
2885 set_current_program_space (SYMTAB_PSPACE (elt));
2886 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt), name,
2887 VAR_DOMAIN, collect_symbols,
2893 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
2894 look in that symtab's static variables first. */
2896 static struct symtabs_and_lines
2897 decode_variable (struct linespec_state *self, char *copy)
2899 struct collect_info info;
2900 const char *lookup_name;
2902 struct cleanup *cleanup;
2905 info.result.sals = NULL;
2906 info.result.nelts = 0;
2908 cleanup = demangle_for_lookup (copy, current_language->la_language,
2910 if (current_language->la_language == language_ada)
2912 /* In Ada, the symbol lookups are performed using the encoded
2913 name rather than the demangled name. */
2914 lookup_name = ada_name_for_lookup (copy);
2915 make_cleanup (xfree, (void *) lookup_name);
2918 canon = cp_canonicalize_string_no_typedefs (lookup_name);
2921 make_cleanup (xfree, canon);
2922 lookup_name = canon;
2925 add_matching_symbols_to_info (lookup_name, &info, NULL);
2927 if (info.result.nelts > 0)
2929 if (self->canonical)
2931 self->canonical->pre_expanded = 1;
2932 if (self->user_filename)
2933 self->canonical->addr_string
2934 = xstrprintf ("%s:%s", self->user_filename, copy);
2936 self->canonical->addr_string = xstrdup (copy);
2941 if (!have_full_symbols ()
2942 && !have_partial_symbols ()
2943 && !have_minimal_symbols ())
2944 throw_error (NOT_FOUND_ERROR,
2945 _("No symbol table is loaded. Use the \"file\" command."));
2946 if (self->user_filename)
2947 throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined in \"%s\"."),
2948 copy, self->user_filename);
2950 throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined."), copy);
2956 /* Now come some functions that are called from multiple places within
2960 symbol_to_sal (struct symtab_and_line *result,
2961 int funfirstline, struct symbol *sym)
2963 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2965 *result = find_function_start_sal (sym, funfirstline);
2970 if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
2973 result->symtab = SYMBOL_SYMTAB (sym);
2974 result->line = SYMBOL_LINE (sym);
2975 result->pc = SYMBOL_VALUE_ADDRESS (sym);
2976 result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2977 result->explicit_pc = 1;
2980 else if (funfirstline)
2984 else if (SYMBOL_LINE (sym) != 0)
2986 /* We know its line number. */
2988 result->symtab = SYMBOL_SYMTAB (sym);
2989 result->line = SYMBOL_LINE (sym);
2990 result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2998 /* See the comment in linespec.h. */
3001 init_linespec_result (struct linespec_result *lr)
3003 memset (lr, 0, sizeof (*lr));
3006 /* See the comment in linespec.h. */
3009 destroy_linespec_result (struct linespec_result *ls)
3012 struct linespec_sals *lsal;
3014 xfree (ls->addr_string);
3015 for (i = 0; VEC_iterate (linespec_sals, ls->sals, i, lsal); ++i)
3017 xfree (lsal->canonical);
3018 xfree (lsal->sals.sals);
3020 VEC_free (linespec_sals, ls->sals);
3023 /* Cleanup function for a linespec_result. */
3026 cleanup_linespec_result (void *a)
3028 destroy_linespec_result (a);
3031 /* See the comment in linespec.h. */
3034 make_cleanup_destroy_linespec_result (struct linespec_result *ls)
3036 return make_cleanup (cleanup_linespec_result, ls);