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 /* Some data for the expand_symtabs_matching callback. */
326 struct symbol_matcher_data
328 /* The lookup name against which symbol name should be compared. */
329 const char *lookup_name
;
331 /* The routine to be used for comparison. */
332 symbol_name_match_p_ftype symbol_name_match_p
;
335 /* A helper for iterate_over_all_matching_symtabs that is passed as a
336 callback to the expand_symtabs_matching method. */
339 iterate_name_matcher (const struct language_defn
*language
,
340 const char *name
, void *d
)
342 const struct symbol_matcher_data
*data
= d
;
344 if (data
->symbol_name_match_p (name
, data
->lookup_name
))
349 /* A helper that walks over all matching symtabs in all objfiles and
350 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
351 not NULL, then the search is restricted to just that program
355 iterate_over_all_matching_symtabs (const char *name
,
356 const domain_enum domain
,
357 int (*callback
) (struct symbol
*, void *),
359 struct program_space
*search_pspace
)
361 struct objfile
*objfile
;
362 struct program_space
*pspace
;
363 struct symbol_matcher_data matcher_data
;
365 matcher_data
.lookup_name
= name
;
366 matcher_data
.symbol_name_match_p
=
367 current_language
->la_get_symbol_name_match_p
!= NULL
368 ? current_language
->la_get_symbol_name_match_p (name
)
373 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
375 if (pspace
->executing_startup
)
378 set_current_program_space (pspace
);
380 ALL_OBJFILES (objfile
)
382 struct symtab
*symtab
;
385 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, NULL
,
386 iterate_name_matcher
,
390 ALL_OBJFILE_SYMTABS (objfile
, symtab
)
396 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
397 LA_ITERATE_OVER_SYMBOLS (block
, name
, domain
, callback
, data
);
404 /* Returns the block to be used for symbol searches for the given SYMTAB,
405 which may be NULL. */
407 static struct block
*
408 get_search_block (struct symtab
*symtab
)
413 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
416 enum language save_language
;
418 /* get_selected_block can change the current language when there is
419 no selected frame yet. */
420 save_language
= current_language
->la_language
;
421 block
= get_selected_block (0);
422 set_language (save_language
);
428 /* A helper for find_method. This finds all methods in type T which
429 match NAME. It adds resulting symbol names to RESULT_NAMES, and
430 adds T's direct superclasses to SUPERCLASSES. */
433 find_methods (struct type
*t
, const char *name
,
434 VEC (const_char_ptr
) **result_names
,
435 VEC (typep
) **superclasses
)
439 char *class_name
= type_name_no_tag (t
);
442 /* Ignore this class if it doesn't have a name. This is ugly, but
443 unless we figure out how to get the physname without the name of
444 the class, then the loop can't do any good. */
448 int name_len
= strlen (name
);
452 /* Loop over each method name. At this level, all overloads of a name
453 are counted as a single name. There is an inner loop which loops over
456 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
460 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
463 if (strncmp (method_name
, "__", 2) == 0 ||
464 strncmp (method_name
, "op", 2) == 0 ||
465 strncmp (method_name
, "type", 4) == 0)
467 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
468 method_name
= dem_opname
;
469 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
470 method_name
= dem_opname
;
473 if (strcmp_iw (method_name
, name
) == 0)
477 for (field_counter
= (TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
)
483 const char *phys_name
;
485 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
486 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
488 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
489 VEC_safe_push (const_char_ptr
, *result_names
, phys_name
);
495 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
496 VEC_safe_push (typep
, *superclasses
, TYPE_BASECLASS (t
, ibase
));
499 /* Find an instance of the character C in the string S that is outside
500 of all parenthesis pairs, single-quoted strings, and double-quoted
501 strings. Also, ignore the char within a template name, like a ','
502 within foo<int, int>. */
505 find_toplevel_char (char *s
, char c
)
507 int quoted
= 0; /* zero if we're not in quotes;
508 '"' if we're in a double-quoted string;
509 '\'' if we're in a single-quoted string. */
510 int depth
= 0; /* Number of unclosed parens we've seen. */
513 for (scan
= s
; *scan
; scan
++)
519 else if (*scan
== '\\' && *(scan
+ 1))
522 else if (*scan
== c
&& ! quoted
&& depth
== 0)
524 else if (*scan
== '"' || *scan
== '\'')
526 else if (*scan
== '(' || *scan
== '<')
528 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
535 /* Determines if the gives string corresponds to an Objective-C method
536 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
537 are allowed to have spaces and parentheses in them. */
540 is_objc_method_format (const char *s
)
542 if (s
== NULL
|| *s
== '\0')
544 /* Handle arguments with the format FILENAME:SYMBOL. */
545 if ((s
[0] == ':') && (strchr ("+-", s
[1]) != NULL
)
546 && (s
[2] == '[') && strchr(s
, ']'))
548 /* Handle arguments that are just SYMBOL. */
549 else if ((strchr ("+-", s
[0]) != NULL
) && (s
[1] == '[') && strchr(s
, ']'))
554 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
555 and store the result in SELF->CANONICAL. */
558 filter_results (struct linespec_state
*self
,
559 struct symtabs_and_lines
*result
,
560 VEC (const_char_ptr
) *filters
)
565 for (i
= 0; VEC_iterate (const_char_ptr
, filters
, i
, name
); ++i
)
567 struct linespec_sals lsal
;
570 memset (&lsal
, 0, sizeof (lsal
));
572 for (j
= 0; j
< result
->nelts
; ++j
)
574 if (strcmp (name
, self
->canonical_names
[j
]) == 0)
575 add_sal_to_sals_basic (&lsal
.sals
, &result
->sals
[j
]);
578 if (lsal
.sals
.nelts
> 0)
580 lsal
.canonical
= xstrdup (name
);
581 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
585 self
->canonical
->pre_expanded
= 0;
588 /* Store RESULT into SELF->CANONICAL. */
591 convert_results_to_lsals (struct linespec_state
*self
,
592 struct symtabs_and_lines
*result
)
594 struct linespec_sals lsal
;
596 lsal
.canonical
= NULL
;
598 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
601 /* Handle multiple results in RESULT depending on SELECT_MODE. This
602 will either return normally, throw an exception on multiple
603 results, or present a menu to the user. On return, the SALS vector
604 in SELF->CANONICAL is set up properly. */
607 decode_line_2 (struct linespec_state
*self
,
608 struct symtabs_and_lines
*result
,
609 const char *select_mode
)
614 struct cleanup
*old_chain
;
615 VEC (const_char_ptr
) *item_names
= NULL
, *filters
= NULL
;
616 struct get_number_or_range_state state
;
618 gdb_assert (select_mode
!= multiple_symbols_all
);
619 gdb_assert (self
->canonical
!= NULL
);
621 old_chain
= make_cleanup (VEC_cleanup (const_char_ptr
), &item_names
);
622 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
623 for (i
= 0; i
< result
->nelts
; ++i
)
628 gdb_assert (self
->canonical_names
[i
] != NULL
);
629 for (j
= 0; VEC_iterate (const_char_ptr
, item_names
, j
, iter
); ++j
)
631 if (strcmp (iter
, self
->canonical_names
[i
]) == 0)
639 VEC_safe_push (const_char_ptr
, item_names
, self
->canonical_names
[i
]);
642 if (select_mode
== multiple_symbols_cancel
643 && VEC_length (const_char_ptr
, item_names
) > 1)
644 error (_("canceled because the command is ambiguous\n"
645 "See set/show multiple-symbol."));
647 if (select_mode
== multiple_symbols_all
648 || VEC_length (const_char_ptr
, item_names
) == 1)
650 do_cleanups (old_chain
);
651 convert_results_to_lsals (self
, result
);
655 printf_unfiltered (_("[0] cancel\n[1] all\n"));
656 for (i
= 0; VEC_iterate (const_char_ptr
, item_names
, i
, iter
); ++i
)
657 printf_unfiltered ("[%d] %s\n", i
+ 2, iter
);
659 prompt
= getenv ("PS2");
664 args
= command_line_input (prompt
, 0, "overload-choice");
666 if (args
== 0 || *args
== 0)
667 error_no_arg (_("one or more choice numbers"));
669 init_number_or_range (&state
, args
);
670 while (!state
.finished
)
674 num
= get_number_or_range (&state
);
677 error (_("canceled"));
680 /* We intentionally make this result in a single breakpoint,
681 contrary to what older versions of gdb did. The
682 rationale is that this lets a user get the
683 multiple_symbols_all behavior even with the 'ask'
684 setting; and he can get separate breakpoints by entering
685 "2-57" at the query. */
686 do_cleanups (old_chain
);
687 convert_results_to_lsals (self
, result
);
692 if (num
>= VEC_length (const_char_ptr
, item_names
))
693 printf_unfiltered (_("No choice number %d.\n"), num
);
696 const char *elt
= VEC_index (const_char_ptr
, item_names
, num
);
700 VEC_safe_push (const_char_ptr
, filters
, elt
);
701 VEC_replace (const_char_ptr
, item_names
, num
, NULL
);
705 printf_unfiltered (_("duplicate request for %d ignored.\n"),
711 filter_results (self
, result
, filters
);
712 do_cleanups (old_chain
);
715 /* Valid delimiters for linespec keywords "if", "thread" or "task". */
718 is_linespec_boundary (char c
)
720 return c
== ' ' || c
== '\t' || c
== '\0' || c
== ',';
723 /* A helper function for decode_line_1 and friends which skips P
724 past any method overload information at the beginning of P, e.g.,
725 "(const struct foo *)".
727 This function assumes that P has already been validated to contain
728 overload information, and it will assert if *P != '('. */
730 find_method_overload_end (char *p
)
734 gdb_assert (*p
== '(');
754 /* Keep important information used when looking up a name. This includes
755 template parameters, overload information, and important keywords, including
756 the possible Java trailing type. */
759 keep_name_info (char *p
, int on_boundary
)
761 const char *quotes
= get_gdb_completer_quote_characters ();
767 if (strchr (quotes
, *p
))
770 if (*p
== ',' && !nest
)
773 if (on_boundary
&& !nest
)
775 const char *const words
[] = { "if", "thread", "task" };
778 for (wordi
= 0; wordi
< ARRAY_SIZE (words
); wordi
++)
779 if (strncmp (p
, words
[wordi
], strlen (words
[wordi
])) == 0
780 && is_linespec_boundary (p
[strlen (words
[wordi
])]))
782 if (wordi
< ARRAY_SIZE (words
))
786 if (*p
== '(' || *p
== '<' || *p
== '[')
788 else if ((*p
== ')' || *p
== '>' || *p
== ']') && nest
> 0)
793 /* The ',' check could fail on "operator ,". */
794 p
+= cp_validate_operator (p
);
796 on_boundary
= is_linespec_boundary (p
[-1]);
799 while (p
> saved_p
&& is_linespec_boundary (p
[-1]))
806 /* The parser of linespec itself. */
808 /* Parse a string that specifies a line number.
809 Pass the address of a char * variable; that variable will be
810 advanced over the characters actually parsed.
814 LINENUM -- that line number in current file. PC returned is 0.
815 FILE:LINENUM -- that line in that file. PC returned is 0.
816 FUNCTION -- line number of openbrace of that function.
817 PC returned is the start of the function.
818 LABEL -- a label in the current scope
819 VARIABLE -- line number of definition of that variable.
821 FILE:FUNCTION -- likewise, but prefer functions in that file.
822 *EXPR -- line in which address EXPR appears.
824 This may all be followed by an "if EXPR", which we ignore.
826 FUNCTION may be an undebuggable function found in minimal symbol table.
828 If the argument FUNFIRSTLINE is nonzero, we want the first line
829 of real code inside a function when a function is specified, and it is
830 not OK to specify a variable or type to get its line number.
832 DEFAULT_SYMTAB specifies the file to use if none is specified.
833 It defaults to current_source_symtab.
834 DEFAULT_LINE specifies the line number to use for relative
835 line numbers (that start with signs). Defaults to current_source_line.
836 If CANONICAL is non-NULL, store an array of strings containing the canonical
837 line specs there if necessary. Currently overloaded member functions and
838 line numbers or static functions without a filename yield a canonical
839 line spec. The array and the line spec strings are allocated on the heap,
840 it is the callers responsibility to free them.
842 Note that it is possible to return zero for the symtab
843 if no file is validly specified. Callers must check that.
844 Also, the line number returned may be invalid. */
846 /* We allow single quotes in various places. This is a hideous
847 kludge, which exists because the completer can't yet deal with the
848 lack of single quotes. FIXME: write a linespec_completer which we
849 can use as appropriate instead of make_symbol_completion_list. */
851 static struct symtabs_and_lines
852 decode_line_internal (struct linespec_state
*self
, char **argptr
)
858 /* This says whether or not something in *ARGPTR is quoted with
859 completer_quotes (i.e. with single quotes). */
861 /* Is *ARGPTR enclosed in double quotes? */
862 int is_quote_enclosed
;
863 int is_objc_method
= 0;
864 char *saved_arg
= *argptr
;
865 /* If IS_QUOTED, the end of the quoted bit. */
866 char *end_quote
= NULL
;
867 /* Is *ARGPTR enclosed in single quotes? */
868 int is_squote_enclosed
= 0;
869 /* The "first half" of the linespec. */
872 /* If we are parsing `function:label', this holds the symbols
873 matching the function name. */
874 VEC (symbolp
) *function_symbols
= NULL
;
875 /* If FUNCTION_SYMBOLS is not NULL, then this is the exception that
876 was thrown when trying to parse a filename. */
877 volatile struct gdb_exception file_exception
;
879 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
881 /* Defaults have defaults. */
883 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
885 /* See if arg is *PC. */
889 do_cleanups (cleanup
);
890 return decode_indirect (self
, argptr
);
893 is_quoted
= (strchr (get_gdb_completer_quote_characters (),
898 end_quote
= skip_quoted (*argptr
);
899 if (*end_quote
== '\0')
900 is_squote_enclosed
= 1;
903 /* Check to see if it's a multipart linespec (with colons or
906 /* Locate the end of the first half of the linespec.
907 After the call, for instance, if the argptr string is "foo.c:123"
908 p will point at "123". If there is only one part, like "foo", p
909 will point to "". If this is a C++ name, like "A::B::foo", p will
910 point to "::B::foo". Argptr is not changed by this call. */
912 first_half
= p
= locate_first_half (argptr
, &is_quote_enclosed
);
914 /* First things first: if ARGPTR starts with a filename, get its
915 symtab and strip the filename from ARGPTR.
916 Avoid calling symtab_from_filename if we know can,
917 it can be expensive. */
921 TRY_CATCH (file_exception
, RETURN_MASK_ERROR
)
923 self
->file_symtabs
= symtabs_from_filename (argptr
, p
,
925 &self
->user_filename
);
928 if (file_exception
.reason
>= 0)
930 /* Check for single quotes on the non-filename part. */
931 is_quoted
= (**argptr
932 && strchr (get_gdb_completer_quote_characters (),
935 end_quote
= skip_quoted (*argptr
);
937 /* Locate the next "half" of the linespec. */
938 first_half
= p
= locate_first_half (argptr
, &is_quote_enclosed
);
941 if (VEC_empty (symtab_p
, self
->file_symtabs
))
943 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
944 VEC_safe_push (symtab_p
, self
->file_symtabs
, NULL
);
949 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
950 VEC_safe_push (symtab_p
, self
->file_symtabs
, NULL
);
953 /* Check if this is an Objective-C method (anything that starts with
954 a '+' or '-' and a '['). */
955 if (is_objc_method_format (p
))
958 /* Check if the symbol could be an Objective-C selector. */
961 struct symtabs_and_lines values
;
963 values
= decode_objc (self
, argptr
);
964 if (values
.sals
!= NULL
)
966 do_cleanups (cleanup
);
971 /* Does it look like there actually were two parts? */
973 if (p
[0] == ':' || p
[0] == '.')
975 /* Is it a C++ or Java compound data structure?
976 The check on p[1] == ':' is capturing the case of "::",
977 since p[0]==':' was checked above.
978 Note that the call to decode_compound does everything
979 for us, including the lookup on the symbol table, so we
982 if (p
[0] == '.' || p
[1] == ':')
984 /* We only perform this check for the languages where it might
985 make sense. For instance, Ada does not use this type of
986 syntax, and trying to apply this logic on an Ada linespec
987 may trigger a spurious error (for instance, decode_compound
988 does not like expressions such as `ops."<"', which is a
989 valid function name in Ada). */
990 if (current_language
->la_language
== language_c
991 || current_language
->la_language
== language_cplus
992 || current_language
->la_language
== language_java
)
994 struct symtabs_and_lines values
;
995 volatile struct gdb_exception ex
;
996 char *saved_argptr
= *argptr
;
998 if (is_quote_enclosed
)
1001 /* Initialize it just to avoid a GCC false warning. */
1002 memset (&values
, 0, sizeof (values
));
1004 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1006 values
= decode_compound (self
, argptr
, saved_arg
, p
);
1008 if ((is_quoted
|| is_squote_enclosed
) && **argptr
== '\'')
1009 *argptr
= *argptr
+ 1;
1013 do_cleanups (cleanup
);
1017 if (ex
.error
!= NOT_FOUND_ERROR
)
1018 throw_exception (ex
);
1020 *argptr
= saved_argptr
;
1025 /* If there was an exception looking up a specified filename earlier,
1026 then check whether we were really given `function:label'. */
1027 if (file_exception
.reason
< 0)
1029 function_symbols
= find_function_symbols (argptr
, p
,
1031 &self
->user_function
);
1033 /* If we did not find a function, re-throw the original
1035 if (!function_symbols
)
1036 throw_exception (file_exception
);
1038 make_cleanup (VEC_cleanup (symbolp
), &function_symbols
);
1041 /* Check for single quotes on the non-filename part. */
1044 is_quoted
= (**argptr
1045 && strchr (get_gdb_completer_quote_characters (),
1048 end_quote
= skip_quoted (*argptr
);
1053 /* self->file_symtabs holds the specified file symtabs, or 0 if no file
1055 If we are parsing `function:symbol', then FUNCTION_SYMBOLS holds the
1056 functions before the `:'.
1057 arg no longer contains the file name. */
1059 /* If the filename was quoted, we must re-check the quotation. */
1061 if (end_quote
== first_half
&& *end_quote
!= '\0')
1063 is_quoted
= (**argptr
1064 && strchr (get_gdb_completer_quote_characters (),
1067 end_quote
= skip_quoted (*argptr
);
1070 /* Check whether arg is all digits (and sign). */
1073 if (*q
== '-' || *q
== '+')
1075 while (*q
>= '0' && *q
<= '9')
1078 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ',')
1079 && function_symbols
== NULL
)
1081 struct symtabs_and_lines values
;
1083 /* We found a token consisting of all digits -- at least one digit. */
1084 values
= decode_all_digits (self
, argptr
, q
);
1085 do_cleanups (cleanup
);
1089 /* Arg token is not digits => try it as a variable name
1090 Find the next token (everything up to end or next whitespace). */
1092 if (**argptr
== '$') /* May be a convenience variable. */
1093 /* One or two $ chars possible. */
1094 p
= skip_quoted (*argptr
+ (((*argptr
)[1] == '$') ? 2 : 1));
1095 else if (is_quoted
|| is_squote_enclosed
)
1099 error (_("Unmatched single quote."));
1101 else if (is_objc_method
)
1103 /* allow word separators in method names for Obj-C. */
1104 p
= skip_quoted_chars (*argptr
, NULL
, "");
1108 p
= skip_quoted (*argptr
);
1111 /* Keep any important naming information. */
1112 p
= keep_name_info (p
, p
== saved_arg
|| is_linespec_boundary (p
[-1]));
1114 copy
= (char *) alloca (p
- *argptr
+ 1);
1115 memcpy (copy
, *argptr
, p
- *argptr
);
1116 copy
[p
- *argptr
] = '\0';
1119 && copy
[0] == copy
[p
- *argptr
- 1]
1120 && strchr (get_gdb_completer_quote_characters (), copy
[0]) != NULL
)
1122 copy
[p
- *argptr
- 1] = '\0';
1125 else if (is_quoted
|| is_squote_enclosed
)
1126 copy
[p
- *argptr
- 1] = '\0';
1128 *argptr
= skip_spaces (p
);
1130 /* If it starts with $: may be a legitimate variable or routine name
1131 (e.g. HP-UX millicode routines such as $$dyncall), or it may
1132 be history value, or it may be a convenience variable. */
1134 if (*copy
== '$' && function_symbols
== NULL
)
1136 struct symtabs_and_lines values
;
1138 values
= decode_dollar (self
, copy
);
1139 do_cleanups (cleanup
);
1143 /* Try the token as a label, but only if no file was specified,
1144 because we can only really find labels in the current scope. */
1146 if (VEC_length (symtab_p
, self
->file_symtabs
) == 1
1147 && VEC_index (symtab_p
, self
->file_symtabs
, 0) == NULL
)
1149 struct symtabs_and_lines label_result
;
1150 if (decode_label (self
, function_symbols
, copy
, &label_result
))
1152 do_cleanups (cleanup
);
1153 return label_result
;
1157 if (function_symbols
)
1158 throw_exception (file_exception
);
1160 /* Look up that token as a variable.
1161 If file specified, use that file's per-file block to start with. */
1164 struct symtabs_and_lines values
;
1166 values
= decode_variable (self
, copy
);
1167 do_cleanups (cleanup
);
1172 /* A constructor for linespec_state. */
1175 linespec_state_constructor (struct linespec_state
*self
,
1177 struct symtab
*default_symtab
,
1179 struct linespec_result
*canonical
)
1181 memset (self
, 0, sizeof (*self
));
1182 self
->funfirstline
= (flags
& DECODE_LINE_FUNFIRSTLINE
) ? 1 : 0;
1183 self
->list_mode
= (flags
& DECODE_LINE_LIST_MODE
) ? 1 : 0;
1184 self
->default_symtab
= default_symtab
;
1185 self
->default_line
= default_line
;
1186 self
->canonical
= canonical
;
1187 self
->program_space
= current_program_space
;
1188 self
->addr_set
= htab_create_alloc (10, hash_address_entry
, eq_address_entry
,
1189 xfree
, xcalloc
, xfree
);
1192 /* A destructor for linespec_state. */
1195 linespec_state_destructor (void *arg
)
1197 struct linespec_state
*self
= arg
;
1199 xfree (self
->user_filename
);
1200 xfree (self
->user_function
);
1201 VEC_free (symtab_p
, self
->file_symtabs
);
1202 htab_delete (self
->addr_set
);
1205 /* See linespec.h. */
1208 decode_line_full (char **argptr
, int flags
,
1209 struct symtab
*default_symtab
,
1210 int default_line
, struct linespec_result
*canonical
,
1211 const char *select_mode
,
1214 struct symtabs_and_lines result
;
1215 struct linespec_state state
;
1216 struct cleanup
*cleanups
;
1217 char *arg_start
= *argptr
;
1218 VEC (const_char_ptr
) *filters
= NULL
;
1220 gdb_assert (canonical
!= NULL
);
1221 /* The filter only makes sense for 'all'. */
1222 gdb_assert (filter
== NULL
|| select_mode
== multiple_symbols_all
);
1223 gdb_assert (select_mode
== NULL
1224 || select_mode
== multiple_symbols_all
1225 || select_mode
== multiple_symbols_ask
1226 || select_mode
== multiple_symbols_cancel
);
1227 gdb_assert ((flags
& DECODE_LINE_LIST_MODE
) == 0);
1229 linespec_state_constructor (&state
, flags
,
1230 default_symtab
, default_line
, canonical
);
1231 cleanups
= make_cleanup (linespec_state_destructor
, &state
);
1232 save_current_program_space ();
1234 result
= decode_line_internal (&state
, argptr
);
1236 gdb_assert (result
.nelts
== 1 || canonical
->pre_expanded
);
1237 gdb_assert (canonical
->addr_string
!= NULL
);
1238 canonical
->pre_expanded
= 1;
1240 /* Fill in the missing canonical names. */
1241 if (result
.nelts
> 0)
1245 if (state
.canonical_names
== NULL
)
1246 state
.canonical_names
= xcalloc (result
.nelts
, sizeof (char *));
1247 make_cleanup (xfree
, state
.canonical_names
);
1248 for (i
= 0; i
< result
.nelts
; ++i
)
1250 if (state
.canonical_names
[i
] == NULL
)
1251 state
.canonical_names
[i
] = savestring (arg_start
,
1252 *argptr
- arg_start
);
1253 make_cleanup (xfree
, state
.canonical_names
[i
]);
1257 if (select_mode
== NULL
)
1259 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
1260 select_mode
= multiple_symbols_all
;
1262 select_mode
= multiple_symbols_select_mode ();
1265 if (select_mode
== multiple_symbols_all
)
1269 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
1270 VEC_safe_push (const_char_ptr
, filters
, filter
);
1271 filter_results (&state
, &result
, filters
);
1274 convert_results_to_lsals (&state
, &result
);
1277 decode_line_2 (&state
, &result
, select_mode
);
1279 do_cleanups (cleanups
);
1282 struct symtabs_and_lines
1283 decode_line_1 (char **argptr
, int flags
,
1284 struct symtab
*default_symtab
,
1287 struct symtabs_and_lines result
;
1288 struct linespec_state state
;
1289 struct cleanup
*cleanups
;
1291 linespec_state_constructor (&state
, flags
,
1292 default_symtab
, default_line
, NULL
);
1293 cleanups
= make_cleanup (linespec_state_destructor
, &state
);
1294 save_current_program_space ();
1296 result
= decode_line_internal (&state
, argptr
);
1297 do_cleanups (cleanups
);
1303 /* First, some functions to initialize stuff at the beggining of the
1307 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
1309 if (*default_symtab
== 0)
1311 /* Use whatever we have for the default source line. We don't use
1312 get_current_or_default_symtab_and_line as it can recurse and call
1314 struct symtab_and_line cursal
=
1315 get_current_source_symtab_and_line ();
1317 *default_symtab
= cursal
.symtab
;
1318 *default_line
= cursal
.line
;
1324 /* Decode arg of the form *PC. */
1326 static struct symtabs_and_lines
1327 decode_indirect (struct linespec_state
*self
, char **argptr
)
1329 struct symtabs_and_lines values
;
1331 char *initial
= *argptr
;
1333 if (current_program_space
->executing_startup
)
1334 /* The error message doesn't really matter, because this case
1335 should only hit during breakpoint reset. */
1336 throw_error (NOT_FOUND_ERROR
, _("cannot evaluate expressions while "
1337 "program space is in startup"));
1340 pc
= value_as_address (parse_to_comma_and_eval (argptr
));
1342 values
.sals
= (struct symtab_and_line
*)
1343 xmalloc (sizeof (struct symtab_and_line
));
1346 values
.sals
[0] = find_pc_line (pc
, 0);
1347 values
.sals
[0].pc
= pc
;
1348 values
.sals
[0].section
= find_pc_overlay (pc
);
1349 values
.sals
[0].explicit_pc
= 1;
1351 if (self
->canonical
)
1352 self
->canonical
->addr_string
= savestring (initial
, *argptr
- initial
);
1359 /* Locate the first half of the linespec, ending in a colon, period,
1360 or whitespace. (More or less.) Also, check to see if *ARGPTR is
1361 enclosed in double quotes; if so, set is_quote_enclosed, advance
1362 ARGPTR past that and zero out the trailing double quote.
1363 If ARGPTR is just a simple name like "main", p will point to ""
1367 locate_first_half (char **argptr
, int *is_quote_enclosed
)
1373 /* Check if the linespec starts with an Ada operator (such as "+",
1374 or ">", for instance). */
1377 && current_language
->la_language
== language_ada
)
1379 const struct ada_opname_map
*op
;
1381 for (op
= ada_opname_table
; op
->encoded
!= NULL
; op
++)
1382 if (strncmp (op
->decoded
, p
, strlen (op
->decoded
)) == 0)
1384 if (op
->encoded
!= NULL
)
1386 *is_quote_enclosed
= 0;
1387 return p
+ strlen (op
->decoded
);
1391 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1392 and we must isolate the first half. Outer layers will call again later
1393 for the second half.
1395 Don't count commas that appear in argument lists of overloaded
1396 functions, or in quoted strings. It's stupid to go to this much
1397 trouble when the rest of the function is such an obvious roach hotel. */
1398 ii
= find_toplevel_char (*argptr
, ',');
1399 has_comma
= (ii
!= 0);
1401 /* Temporarily zap out second half to not confuse the code below.
1402 This is undone below. Do not change ii!! */
1408 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
1409 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
1415 *is_quote_enclosed
= 1;
1421 *is_quote_enclosed
= 0;
1422 if (strchr (get_gdb_completer_quote_characters (), *p
))
1430 /* Check for a drive letter in the filename. This is done on all hosts
1431 to capture cross-compilation environments. On Unixen, directory
1432 separators are illegal in filenames, so if the user enters "e:/foo.c",
1433 he is referring to a directory named "e:" and a source file named
1434 "foo.c", and we still want to keep these two pieces together. */
1435 if (isalpha (p
[0]) && p
[1] == ':' && IS_DIR_SEPARATOR (p
[2]))
1442 char *temp_end
= find_template_name_end (p
);
1445 error (_("malformed template specification in command"));
1450 p
= find_method_overload_end (p
);
1452 /* Check for a colon and a plus or minus and a [ (which
1453 indicates an Objective-C method). */
1454 if (is_objc_method_format (p
))
1458 /* Check for the end of the first half of the linespec. End of
1459 line, a tab, a colon or a space. But if enclosed in double
1460 quotes we do not break on enclosed spaces. */
1464 || ((p
[0] == ' ') && !*is_quote_enclosed
))
1466 if (p
[0] == '.' && strchr (p
, ':') == NULL
)
1468 /* Java qualified method. Find the *last* '.', since the
1469 others are package qualifiers. Stop at any open parenthesis
1470 which might provide overload information. */
1471 for (p1
= p
; *p1
&& *p1
!= '('; p1
++)
1479 p
= skip_spaces (p
);
1481 /* If the closing double quote was left at the end, remove it. */
1482 if (*is_quote_enclosed
)
1484 char *closing_quote
= strchr (p
- 1, '"');
1486 if (closing_quote
&& closing_quote
[1] == '\0')
1487 *closing_quote
= '\0';
1490 /* Now that we've safely parsed the first half, put back ',' so
1491 outer layers can see it. */
1500 /* Here's where we recognise an Objective-C Selector. An Objective C
1501 selector may be implemented by more than one class, therefore it
1502 may represent more than one method/function. This gives us a
1503 situation somewhat analogous to C++ overloading. If there's more
1504 than one method that could represent the selector, then use some of
1505 the existing C++ code to let the user choose one. */
1507 static struct symtabs_and_lines
1508 decode_objc (struct linespec_state
*self
, char **argptr
)
1510 struct collect_info info
;
1511 VEC (const_char_ptr
) *symbol_names
= NULL
;
1513 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (const_char_ptr
),
1517 info
.result
.sals
= NULL
;
1518 info
.result
.nelts
= 0;
1520 new_argptr
= find_imps (*argptr
, &symbol_names
);
1521 if (VEC_empty (const_char_ptr
, symbol_names
))
1523 do_cleanups (cleanup
);
1527 add_all_symbol_names_from_pspace (&info
, NULL
, symbol_names
);
1529 if (info
.result
.nelts
> 0)
1533 saved_arg
= alloca (new_argptr
- *argptr
+ 1);
1534 memcpy (saved_arg
, *argptr
, new_argptr
- *argptr
);
1535 saved_arg
[new_argptr
- *argptr
] = '\0';
1537 if (self
->canonical
)
1539 self
->canonical
->pre_expanded
= 1;
1540 if (self
->user_filename
)
1541 self
->canonical
->addr_string
1542 = xstrprintf ("%s:%s", self
->user_filename
, saved_arg
);
1544 self
->canonical
->addr_string
= xstrdup (saved_arg
);
1548 *argptr
= new_argptr
;
1550 do_cleanups (cleanup
);
1554 /* This handles C++ and Java compound data structures. P should point
1555 at the first component separator, i.e. double-colon or period. As
1556 an example, on entrance to this function we could have ARGPTR
1557 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
1559 static struct symtabs_and_lines
1560 decode_compound (struct linespec_state
*self
,
1561 char **argptr
, char *the_real_saved_arg
, char *p
)
1563 struct symtabs_and_lines values
;
1565 char *saved_arg2
= *argptr
;
1569 VEC (symbolp
) *sym_classes
;
1570 char *saved_arg
, *class_name
;
1571 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1573 /* If the user specified any completer quote characters in the input,
1574 strip them. They are superfluous. */
1575 saved_arg
= alloca (strlen (the_real_saved_arg
) + 1);
1577 char *dst
= saved_arg
;
1578 char *src
= the_real_saved_arg
;
1579 char *quotes
= get_gdb_completer_quote_characters ();
1580 while (*src
!= '\0')
1582 if (strchr (quotes
, *src
) == NULL
)
1589 /* First check for "global" namespace specification, of the form
1590 "::foo". If found, skip over the colons and jump to normal
1591 symbol processing. I.e. the whole line specification starts with
1592 "::" (note the condition that *argptr == p). */
1594 && ((*argptr
== p
) || (p
[-1] == ' ') || (p
[-1] == '\t')))
1597 /* Given our example "AAA::inA::fun", we have two cases to consider:
1599 1) AAA::inA is the name of a class. In that case, presumably it
1600 has a method called "fun"; we then look up that method using
1603 2) AAA::inA isn't the name of a class. In that case, either the
1604 user made a typo, AAA::inA is the name of a namespace, or it is
1605 the name of a minimal symbol.
1606 In this case we just delegate to decode_variable.
1608 Thus, our first task is to find everything before the last set of
1609 double-colons and figure out if it's the name of a class. So we
1610 first loop through all of the double-colons. */
1612 p2
= p
; /* Save for restart. */
1614 /* This is very messy. Following the example above we have now the
1617 argptr -> "AAA::inA::fun
1618 saved_arg -> "AAA::inA::fun
1619 saved_arg2 -> "AAA::inA::fun
1620 p2 -> "::inA::fun". */
1622 /* In the loop below, with these strings, we'll make 2 passes, each
1623 is marked in comments. */
1627 static char *break_characters
= " \t(";
1629 /* Move pointer up to next possible class/namespace token. */
1631 p
= p2
+ 1; /* Restart with old value +1. */
1633 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1634 i.e. if there is a double-colon, p will now point to the
1636 /* PASS2: p2->"::fun", p->":fun" */
1638 /* Move pointer ahead to next double-colon. */
1640 && strchr (break_characters
, *p
) == NULL
1641 && strchr (get_gdb_completer_quote_characters (), *p
) == NULL
)
1643 if (current_language
->la_language
== language_cplus
)
1644 p
+= cp_validate_operator (p
);
1648 temp_end
= find_template_name_end (p
);
1650 error (_("malformed template specification in command"));
1653 /* Note that, since, at the start of this loop, p would be
1654 pointing to the second colon in a double-colon, we only
1655 satisfy the condition below if there is another
1656 double-colon to the right (after). I.e. there is another
1657 component that can be a class or a namespace. I.e, if at
1658 the beginning of this loop (PASS1), we had
1659 p->":inA::fun", we'll trigger this when p has been
1660 advanced to point to "::fun". */
1661 /* PASS2: we will not trigger this. */
1662 else if ((p
[0] == ':') && (p
[1] == ':'))
1663 break; /* Found double-colon. */
1666 /* PASS2: We'll keep getting here, until P points to one of the
1667 break characters, at which point we exit this loop. */
1671 && strncmp (&p
[1], CP_ANONYMOUS_NAMESPACE_STR
,
1672 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
1673 p
+= CP_ANONYMOUS_NAMESPACE_LEN
;
1674 else if (strchr (break_characters
, *p
) == NULL
)
1681 break; /* Out of the while (1). This would happen
1682 for instance if we have looked up
1683 unsuccessfully all the components of the
1684 string, and p->""(PASS2). */
1686 /* We get here if p points to one of the break characters or "" (i.e.,
1688 /* Save restart for next time around. */
1690 /* Restore argptr as it was on entry to this function. */
1691 *argptr
= saved_arg2
;
1692 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1695 /* All ready for next pass through the loop. */
1699 /* Start of lookup in the symbol tables. */
1701 /* Lookup in the symbol table the substring between argptr and
1702 p. Note, this call changes the value of argptr. */
1703 /* Before the call, argptr->"AAA::inA::fun",
1704 p->"", p2->"::fun". After the call: argptr->"fun", p, p2
1706 sym_classes
= lookup_prefix_sym (argptr
, p2
, self
->file_symtabs
,
1708 make_cleanup (VEC_cleanup (symbolp
), &sym_classes
);
1709 make_cleanup (xfree
, class_name
);
1711 /* If a class has been found, then we're in case 1 above. So we
1712 look up "fun" as a method of those classes. */
1713 if (!VEC_empty (symbolp
, sym_classes
))
1715 /* Arg token is not digits => try it as a function name.
1716 Find the next token (everything up to end or next
1719 && strchr (get_gdb_completer_quote_characters (),
1722 p
= skip_quoted (*argptr
);
1723 *argptr
= *argptr
+ 1;
1727 /* At this point argptr->"fun". */
1731 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!= ':'
1734 /* At this point p->"". String ended. */
1735 /* Nope, C++ operators could have spaces in them
1736 ("foo::operator <" or "foo::operator delete []").
1737 I apologize, this is a bit hacky... */
1738 if (current_language
->la_language
== language_cplus
1739 && *p
== ' ' && p
- 8 - *argptr
+ 1 > 0)
1741 /* The above loop has already swallowed "operator". */
1742 p
+= cp_validate_operator (p
- 8) - 8;
1745 /* Keep any important naming information. */
1746 p
= keep_name_info (p
, 1);
1749 /* Allocate our own copy of the substring between argptr and
1751 copy
= (char *) alloca (p
- *argptr
+ 1);
1752 memcpy (copy
, *argptr
, p
- *argptr
);
1753 copy
[p
- *argptr
] = '\0';
1755 && copy
[p
- *argptr
- 1]
1756 && strchr (get_gdb_completer_quote_characters (),
1757 copy
[p
- *argptr
- 1]) != NULL
)
1758 copy
[p
- *argptr
- 1] = '\0';
1760 /* At this point copy->"fun", p->"". */
1762 /* No line number may be specified. */
1763 *argptr
= skip_spaces (p
);
1764 /* At this point arptr->"". */
1766 /* Look for copy as a method of sym_class. */
1767 /* At this point copy->"fun", sym_class is "AAA:inA",
1768 saved_arg->"AAA::inA::fun". This concludes the scanning of
1769 the string for possible components matches. If we find it
1770 here, we return. If not, and we are at the and of the string,
1771 we'll lookup the whole string in the symbol tables. */
1773 values
= find_method (self
, saved_arg
, copy
, class_name
, sym_classes
);
1775 do_cleanups (cleanup
);
1777 } /* End if symbol found. */
1780 /* We couldn't find a class, so we're in case 2 above. We check the
1781 entire name as a symbol instead. The simplest way to do this is
1782 to just throw an exception and let our caller fall through to
1785 throw_error (NOT_FOUND_ERROR
, _("see caller, this text doesn't matter"));
1788 /* An instance of this type is used when collecting prefix symbols for
1791 struct decode_compound_collector
1793 /* The result vector. */
1794 VEC (symbolp
) *symbols
;
1796 /* A hash table of all symbols we found. We use this to avoid
1797 adding any symbol more than once. */
1801 /* A callback for iterate_over_symbols that is used by
1802 lookup_prefix_sym to collect type symbols. */
1805 collect_one_symbol (struct symbol
*sym
, void *d
)
1807 struct decode_compound_collector
*collector
= d
;
1811 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1814 t
= SYMBOL_TYPE (sym
);
1816 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1817 && TYPE_CODE (t
) != TYPE_CODE_UNION
1818 && TYPE_CODE (t
) != TYPE_CODE_NAMESPACE
)
1821 slot
= htab_find_slot (collector
->unique_syms
, sym
, INSERT
);
1825 VEC_safe_push (symbolp
, collector
->symbols
, sym
);
1831 /* Return the symbol corresponding to the substring of *ARGPTR ending
1832 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1833 name in question, the compound object separator ("::" or "."), and
1834 whitespace. Note that *ARGPTR is changed whether or not the
1835 this call finds anything (i.e we return NULL). As an
1836 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
1838 static VEC (symbolp
) *
1839 lookup_prefix_sym (char **argptr
, char *p
, VEC (symtab_p
) *file_symtabs
,
1846 struct decode_compound_collector collector
;
1847 struct cleanup
*outer
;
1848 struct cleanup
*cleanup
;
1849 struct block
*search_block
;
1851 /* Extract the class name. */
1853 while (p
!= *argptr
&& p
[-1] == ' ')
1855 copy
= (char *) xmalloc (p
- *argptr
+ 1);
1856 memcpy (copy
, *argptr
, p
- *argptr
);
1857 copy
[p
- *argptr
] = 0;
1859 outer
= make_cleanup (xfree
, copy
);
1861 /* Discard the class name from the argptr. */
1862 p
= p1
+ (p1
[0] == ':' ? 2 : 1);
1863 p
= skip_spaces (p
);
1866 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1867 argptr->"inA::fun". */
1869 collector
.symbols
= NULL
;
1870 make_cleanup (VEC_cleanup (symbolp
), &collector
.symbols
);
1872 collector
.unique_syms
= htab_create_alloc (1, htab_hash_pointer
,
1873 htab_eq_pointer
, NULL
,
1875 cleanup
= make_cleanup_htab_delete (collector
.unique_syms
);
1877 for (ix
= 0; VEC_iterate (symtab_p
, file_symtabs
, ix
, elt
); ++ix
)
1881 iterate_over_all_matching_symtabs (copy
, STRUCT_DOMAIN
,
1882 collect_one_symbol
, &collector
,
1884 iterate_over_all_matching_symtabs (copy
, VAR_DOMAIN
,
1885 collect_one_symbol
, &collector
,
1890 struct block
*search_block
;
1892 /* Program spaces that are executing startup should have
1893 been filtered out earlier. */
1894 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
1895 set_current_program_space (SYMTAB_PSPACE (elt
));
1896 search_block
= get_search_block (elt
);
1897 LA_ITERATE_OVER_SYMBOLS (search_block
, copy
, STRUCT_DOMAIN
,
1898 collect_one_symbol
, &collector
);
1899 LA_ITERATE_OVER_SYMBOLS (search_block
, copy
, VAR_DOMAIN
,
1900 collect_one_symbol
, &collector
);
1904 do_cleanups (cleanup
);
1905 discard_cleanups (outer
);
1906 return collector
.symbols
;
1909 /* A qsort comparison function for symbols. The resulting order does
1910 not actually matter; we just need to be able to sort them so that
1911 symbols with the same program space end up next to each other. */
1914 compare_symbols (const void *a
, const void *b
)
1916 struct symbol
* const *sa
= a
;
1917 struct symbol
* const *sb
= b
;
1920 uia
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa
));
1921 uib
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb
));
1928 uia
= (uintptr_t) *sa
;
1929 uib
= (uintptr_t) *sb
;
1939 /* Look for all the matching instances of each symbol in NAMES. Only
1940 instances from PSPACE are considered; other program spaces are
1941 handled by our caller. If PSPACE is NULL, then all program spaces
1942 are considered. Results are stored into INFO. */
1945 add_all_symbol_names_from_pspace (struct collect_info
*info
,
1946 struct program_space
*pspace
,
1947 VEC (const_char_ptr
) *names
)
1952 for (ix
= 0; VEC_iterate (const_char_ptr
, names
, ix
, iter
); ++ix
)
1953 add_matching_symbols_to_info (iter
, info
, pspace
);
1957 find_superclass_methods (VEC (typep
) *superclasses
,
1959 VEC (const_char_ptr
) **result_names
)
1961 int old_len
= VEC_length (const_char_ptr
, *result_names
);
1962 VEC (typep
) *iter_classes
;
1963 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1965 iter_classes
= superclasses
;
1968 VEC (typep
) *new_supers
= NULL
;
1972 make_cleanup (VEC_cleanup (typep
), &new_supers
);
1973 for (ix
= 0; VEC_iterate (typep
, iter_classes
, ix
, t
); ++ix
)
1974 find_methods (t
, name
, result_names
, &new_supers
);
1976 if (VEC_length (const_char_ptr
, *result_names
) != old_len
1977 || VEC_empty (typep
, new_supers
))
1980 iter_classes
= new_supers
;
1983 do_cleanups (cleanup
);
1986 /* This finds the method COPY in the class whose type is given by one
1987 of the symbols in SYM_CLASSES. */
1989 static struct symtabs_and_lines
1990 find_method (struct linespec_state
*self
, char *saved_arg
,
1991 char *copy
, const char *class_name
, VEC (symbolp
) *sym_classes
)
1995 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1997 int last_result_len
;
1998 VEC (typep
) *superclass_vec
;
1999 VEC (const_char_ptr
) *result_names
;
2000 struct collect_info info
;
2003 /* NAME is typed by the user: it needs to be canonicalized before
2004 searching the symbol tables. */
2005 canon
= cp_canonicalize_string_no_typedefs (copy
);
2009 make_cleanup (xfree
, copy
);
2012 /* Sort symbols so that symbols with the same program space are next
2014 qsort (VEC_address (symbolp
, sym_classes
),
2015 VEC_length (symbolp
, sym_classes
),
2020 info
.result
.sals
= NULL
;
2021 info
.result
.nelts
= 0;
2023 /* Iterate over all the types, looking for the names of existing
2024 methods matching COPY. If we cannot find a direct method in a
2025 given program space, then we consider inherited methods; this is
2026 not ideal (ideal would be to respect C++ hiding rules), but it
2027 seems good enough and is what GDB has historically done. We only
2028 need to collect the names because later we find all symbols with
2029 those names. This loop is written in a somewhat funny way
2030 because we collect data across the program space before deciding
2032 superclass_vec
= NULL
;
2033 make_cleanup (VEC_cleanup (typep
), &superclass_vec
);
2034 result_names
= NULL
;
2035 make_cleanup (VEC_cleanup (const_char_ptr
), &result_names
);
2036 last_result_len
= 0;
2037 for (ix
= 0; VEC_iterate (symbolp
, sym_classes
, ix
, sym
); ++ix
)
2040 struct program_space
*pspace
;
2042 /* Program spaces that are executing startup should have
2043 been filtered out earlier. */
2044 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
))->executing_startup
);
2045 pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2046 set_current_program_space (pspace
);
2047 t
= check_typedef (SYMBOL_TYPE (sym
));
2048 find_methods (t
, copy
, &result_names
, &superclass_vec
);
2050 /* Handle all items from a single program space at once; and be
2051 sure not to miss the last batch. */
2052 if (ix
== VEC_length (symbolp
, sym_classes
) - 1
2054 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp
, sym_classes
,
2057 /* If we did not find a direct implementation anywhere in
2058 this program space, consider superclasses. */
2059 if (VEC_length (const_char_ptr
, result_names
) == last_result_len
)
2060 find_superclass_methods (superclass_vec
, copy
, &result_names
);
2062 /* We have a list of candidate symbol names, so now we
2063 iterate over the symbol tables looking for all
2064 matches in this pspace. */
2065 add_all_symbol_names_from_pspace (&info
, pspace
, result_names
);
2067 VEC_truncate (typep
, superclass_vec
, 0);
2068 last_result_len
= VEC_length (const_char_ptr
, result_names
);
2072 if (info
.result
.nelts
> 0)
2074 if (self
->canonical
)
2076 self
->canonical
->pre_expanded
= 1;
2077 if (self
->user_filename
)
2078 self
->canonical
->addr_string
2079 = xstrprintf ("%s:%s", self
->user_filename
, saved_arg
);
2081 self
->canonical
->addr_string
= xstrdup (saved_arg
);
2084 do_cleanups (cleanup
);
2090 cplusplus_error (saved_arg
,
2091 "the class `%s' does not have destructor defined\n",
2094 cplusplus_error (saved_arg
,
2095 "the class %s does not have any method named %s\n",
2101 /* This object is used when collecting all matching symtabs. */
2103 struct symtab_collector
2105 /* The result vector of symtabs. */
2106 VEC (symtab_p
) *symtabs
;
2108 /* This is used to ensure the symtabs are unique. */
2109 htab_t symtab_table
;
2112 /* Callback for iterate_over_symtabs. */
2115 add_symtabs_to_list (struct symtab
*symtab
, void *d
)
2117 struct symtab_collector
*data
= d
;
2120 slot
= htab_find_slot (data
->symtab_table
, symtab
, INSERT
);
2124 VEC_safe_push (symtab_p
, data
->symtabs
, symtab
);
2130 /* Given a file name, return a VEC of all matching symtabs. */
2132 static VEC (symtab_p
) *
2133 collect_symtabs_from_filename (const char *file
)
2135 struct symtab_collector collector
;
2136 struct cleanup
*cleanups
;
2137 struct program_space
*pspace
;
2139 collector
.symtabs
= NULL
;
2140 collector
.symtab_table
= htab_create (1, htab_hash_pointer
, htab_eq_pointer
,
2142 cleanups
= make_cleanup_htab_delete (collector
.symtab_table
);
2144 /* Find that file's data. */
2145 ALL_PSPACES (pspace
)
2147 if (pspace
->executing_startup
)
2150 set_current_program_space (pspace
);
2151 iterate_over_symtabs (file
, add_symtabs_to_list
, &collector
);
2154 do_cleanups (cleanups
);
2155 return collector
.symtabs
;
2158 /* Return all the symtabs associated to the filename given by the
2159 substring of *ARGPTR ending at P, and advance ARGPTR past that
2162 static VEC (symtab_p
) *
2163 symtabs_from_filename (char **argptr
, char *p
, int is_quote_enclosed
,
2164 char **user_filename
)
2168 struct cleanup
*outer
;
2169 VEC (symtab_p
) *result
;
2172 while (p
!= *argptr
&& p
[-1] == ' ')
2174 if ((*p
== '"') && is_quote_enclosed
)
2176 copy
= xmalloc (p
- *argptr
+ 1);
2177 outer
= make_cleanup (xfree
, copy
);
2178 memcpy (copy
, *argptr
, p
- *argptr
);
2179 /* It may have the ending quote right after the file name. */
2180 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
2181 || copy
[p
- *argptr
- 1] == '\'')
2182 copy
[p
- *argptr
- 1] = 0;
2184 copy
[p
- *argptr
] = 0;
2186 result
= collect_symtabs_from_filename (copy
);
2188 if (VEC_empty (symtab_p
, result
))
2190 if (!have_full_symbols () && !have_partial_symbols ())
2191 throw_error (NOT_FOUND_ERROR
,
2192 _("No symbol table is loaded. "
2193 "Use the \"file\" command."));
2194 throw_error (NOT_FOUND_ERROR
, _("No source file named %s."), copy
);
2197 /* Discard the file name from the arg. */
2201 *argptr
= skip_spaces (p1
+ 1);
2203 discard_cleanups (outer
);
2204 *user_filename
= copy
;
2208 /* A callback used by iterate_over_all_matching_symtabs that collects
2209 symbols for find_function_symbols. */
2212 collect_function_symbols (struct symbol
*sym
, void *arg
)
2214 VEC (symbolp
) **syms
= arg
;
2216 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2217 VEC_safe_push (symbolp
, *syms
, sym
);
2222 /* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR
2223 and return the symbol. If not found, return NULL. */
2225 static VEC (symbolp
) *
2226 find_function_symbols (char **argptr
, char *p
, int is_quote_enclosed
,
2227 char **user_function
)
2231 VEC (symbolp
) *result
= NULL
;
2234 while (p
!= *argptr
&& p
[-1] == ' ')
2236 if ((*p
== '"') && is_quote_enclosed
)
2238 copy
= (char *) xmalloc (p
- *argptr
+ 1);
2239 *user_function
= copy
;
2240 memcpy (copy
, *argptr
, p
- *argptr
);
2241 /* It may have the ending quote right after the file name. */
2242 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
2243 || copy
[p
- *argptr
- 1] == '\'')
2244 copy
[p
- *argptr
- 1] = 0;
2246 copy
[p
- *argptr
] = 0;
2248 iterate_over_all_matching_symtabs (copy
, VAR_DOMAIN
,
2249 collect_function_symbols
, &result
, NULL
);
2251 if (VEC_empty (symbolp
, result
))
2252 VEC_free (symbolp
, result
);
2255 /* Discard the file name from the arg. */
2256 *argptr
= skip_spaces (p1
+ 1);
2264 /* A helper for decode_all_digits that handles the 'list_mode' case. */
2267 decode_digits_list_mode (struct linespec_state
*self
,
2268 struct symtabs_and_lines
*values
,
2269 struct symtab_and_line val
)
2274 gdb_assert (self
->list_mode
);
2276 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2278 /* The logic above should ensure this. */
2279 gdb_assert (elt
!= NULL
);
2281 set_current_program_space (SYMTAB_PSPACE (elt
));
2283 /* Simplistic search just for the list command. */
2284 val
.symtab
= find_line_symtab (elt
, val
.line
, NULL
, NULL
);
2285 if (val
.symtab
== NULL
)
2287 val
.pspace
= SYMTAB_PSPACE (elt
);
2289 val
.explicit_line
= 1;
2291 add_sal_to_sals (self
, values
, &val
, NULL
);
2295 /* A helper for decode_all_digits that iterates over the symtabs,
2296 adding lines to the VEC. */
2299 decode_digits_ordinary (struct linespec_state
*self
,
2301 struct symtabs_and_lines
*sals
,
2302 struct linetable_entry
**best_entry
)
2307 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2310 VEC (CORE_ADDR
) *pcs
;
2313 /* The logic above should ensure this. */
2314 gdb_assert (elt
!= NULL
);
2316 set_current_program_space (SYMTAB_PSPACE (elt
));
2318 pcs
= find_pcs_for_symtab_line (elt
, line
, best_entry
);
2319 for (i
= 0; VEC_iterate (CORE_ADDR
, pcs
, i
, pc
); ++i
)
2321 struct symtab_and_line sal
;
2324 sal
.pspace
= SYMTAB_PSPACE (elt
);
2328 add_sal_to_sals_basic (sals
, &sal
);
2331 VEC_free (CORE_ADDR
, pcs
);
2335 /* This decodes a line where the argument is all digits (possibly
2336 preceded by a sign). Q should point to the end of those digits;
2337 the other arguments are as usual. */
2339 static struct symtabs_and_lines
2340 decode_all_digits (struct linespec_state
*self
,
2344 struct symtabs_and_lines values
;
2345 struct symtab_and_line val
;
2346 int use_default
= 0;
2347 char *saved_arg
= *argptr
;
2359 /* This is where we need to make sure that we have good defaults.
2360 We must guarantee that this section of code is never executed
2361 when we are called with just a function name, since
2362 set_default_source_symtab_and_line uses
2363 select_source_symtab that calls us with such an argument. */
2365 if (VEC_length (symtab_p
, self
->file_symtabs
) == 1
2366 && VEC_index (symtab_p
, self
->file_symtabs
, 0) == NULL
)
2368 set_current_program_space (self
->program_space
);
2370 /* Make sure we have at least a default source file. */
2371 set_default_source_symtab_and_line ();
2372 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
2373 VEC_pop (symtab_p
, self
->file_symtabs
);
2374 VEC_free (symtab_p
, self
->file_symtabs
);
2376 = collect_symtabs_from_filename (self
->default_symtab
->filename
);
2380 if (**argptr
== '+')
2381 sign
= plus
, (*argptr
)++;
2382 else if (**argptr
== '-')
2383 sign
= minus
, (*argptr
)++;
2384 val
.line
= atoi (*argptr
);
2391 val
.line
= self
->default_line
+ val
.line
;
2397 val
.line
= self
->default_line
- val
.line
;
2402 break; /* No need to adjust val.line. */
2405 *argptr
= skip_spaces (q
);
2407 if (self
->list_mode
)
2408 decode_digits_list_mode (self
, &values
, val
);
2411 struct linetable_entry
*best_entry
= NULL
;
2413 struct block
**blocks
;
2414 struct cleanup
*cleanup
;
2415 struct symtabs_and_lines intermediate_results
;
2418 intermediate_results
.sals
= NULL
;
2419 intermediate_results
.nelts
= 0;
2421 decode_digits_ordinary (self
, val
.line
, &intermediate_results
,
2423 if (intermediate_results
.nelts
== 0 && best_entry
!= NULL
)
2424 decode_digits_ordinary (self
, best_entry
->line
, &intermediate_results
,
2427 cleanup
= make_cleanup (xfree
, intermediate_results
.sals
);
2429 /* For optimized code, compiler can scatter one source line
2430 accross disjoint ranges of PC values, even when no duplicate
2431 functions or inline functions are involved. For example,
2432 'for (;;)' inside non-template non-inline non-ctor-or-dtor
2433 function can result in two PC ranges. In this case, we don't
2434 want to set breakpoint on first PC of each range. To filter
2435 such cases, we use containing blocks -- for each PC found
2436 above we see if there are other PCs that are in the same
2437 block. If yes, the other PCs are filtered out. */
2439 filter
= xmalloc (intermediate_results
.nelts
* sizeof (int));
2440 make_cleanup (xfree
, filter
);
2441 blocks
= xmalloc (intermediate_results
.nelts
* sizeof (struct block
*));
2442 make_cleanup (xfree
, blocks
);
2444 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2446 set_current_program_space (intermediate_results
.sals
[i
].pspace
);
2449 blocks
[i
] = block_for_pc_sect (intermediate_results
.sals
[i
].pc
,
2450 intermediate_results
.sals
[i
].section
);
2453 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2455 if (blocks
[i
] != NULL
)
2456 for (j
= i
+ 1; j
< intermediate_results
.nelts
; ++j
)
2458 if (blocks
[j
] == blocks
[i
])
2466 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2469 struct symbol
*sym
= (blocks
[i
]
2470 ? block_containing_function (blocks
[i
])
2473 if (self
->funfirstline
)
2474 skip_prologue_sal (&intermediate_results
.sals
[i
]);
2475 /* Make sure the line matches the request, not what was
2477 intermediate_results
.sals
[i
].line
= val
.line
;
2478 add_sal_to_sals (self
, &values
, &intermediate_results
.sals
[i
],
2479 sym
? SYMBOL_NATURAL_NAME (sym
) : NULL
);
2482 do_cleanups (cleanup
);
2485 if (values
.nelts
== 0)
2487 if (self
->user_filename
)
2488 throw_error (NOT_FOUND_ERROR
, _("No line %d in file \"%s\"."),
2489 val
.line
, self
->user_filename
);
2491 throw_error (NOT_FOUND_ERROR
, _("No line %d in the current file."),
2495 if (self
->canonical
)
2497 char *copy
= savestring (saved_arg
, q
- saved_arg
);
2499 self
->canonical
->pre_expanded
= 1;
2500 gdb_assert (self
->user_filename
|| use_default
);
2501 self
->canonical
->addr_string
2502 = xstrprintf ("%s:%s", (self
->user_filename
2503 ? self
->user_filename
2504 : self
->default_symtab
->filename
),
2514 /* Decode a linespec starting with a dollar sign. */
2516 static struct symtabs_and_lines
2517 decode_dollar (struct linespec_state
*self
, char *copy
)
2521 struct symtabs_and_lines values
;
2522 struct symtab_and_line val
;
2525 struct minimal_symbol
*msymbol
;
2529 p
= (copy
[1] == '$') ? copy
+ 2 : copy
+ 1;
2530 while (*p
>= '0' && *p
<= '9')
2532 if (!*p
) /* Reached end of token without hitting non-digit. */
2534 /* We have a value history reference. */
2535 struct value
*val_history
;
2537 sscanf ((copy
[1] == '$') ? copy
+ 2 : copy
+ 1, "%d", &index
);
2538 val_history
= access_value_history ((copy
[1] == '$') ? -index
: index
);
2539 if (TYPE_CODE (value_type (val_history
)) != TYPE_CODE_INT
)
2540 error (_("History values used in line "
2541 "specs must have integer values."));
2542 valx
= value_as_long (val_history
);
2546 /* Not all digits -- may be user variable/function or a
2547 convenience variable. */
2549 volatile struct gdb_exception exc
;
2551 /* Avoid "may be used uninitialized" warning. */
2555 TRY_CATCH (exc
, RETURN_MASK_ERROR
)
2557 values
= decode_variable (self
, copy
);
2560 if (exc
.reason
== 0)
2563 if (exc
.error
!= NOT_FOUND_ERROR
)
2564 throw_exception (exc
);
2566 /* Not a user variable or function -- must be convenience variable. */
2567 if (!get_internalvar_integer (lookup_internalvar (copy
+ 1), &valx
))
2568 error (_("Convenience variables used in line "
2569 "specs must have integer values."));
2577 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2581 elt
= self
->default_symtab
;
2582 set_current_program_space (self
->program_space
);
2585 set_current_program_space (SYMTAB_PSPACE (elt
));
2587 /* Either history value or convenience value from above, in valx. */
2591 val
.pspace
= elt
? SYMTAB_PSPACE (elt
) : current_program_space
;
2593 add_sal_to_sals (self
, &values
, &val
, NULL
);
2596 if (self
->canonical
)
2598 self
->canonical
->pre_expanded
= 1;
2599 if (self
->user_filename
)
2600 self
->canonical
->addr_string
= xstrprintf ("%s:%s",
2601 self
->user_filename
, copy
);
2603 self
->canonical
->addr_string
= xstrdup (copy
);
2611 /* A helper for decode_line_1 that tries to find a label. The label
2612 is searched for in the current block.
2613 FUNCTION_SYMBOLS is a list of the enclosing functions; or NULL if none
2615 COPY is the name of the label to find.
2616 CANONICAL is the same as the "canonical" argument to decode_line_1.
2617 RESULT is a pointer to a symtabs_and_lines structure which will be
2618 filled in on success.
2619 This function returns 1 if a label was found, 0 otherwise. */
2622 decode_label (struct linespec_state
*self
,
2623 VEC (symbolp
) *function_symbols
, char *copy
,
2624 struct symtabs_and_lines
*result
)
2626 struct symbol
*fn_sym
;
2629 if (function_symbols
== NULL
)
2631 struct block
*block
;
2633 struct symtab_and_line sal
;
2634 struct symtabs_and_lines values
;
2639 set_current_program_space (self
->program_space
);
2640 block
= get_search_block (NULL
);
2643 block
&& !BLOCK_FUNCTION (block
);
2644 block
= BLOCK_SUPERBLOCK (block
))
2648 fn_sym
= BLOCK_FUNCTION (block
);
2650 sym
= lookup_symbol (copy
, block
, LABEL_DOMAIN
, 0);
2655 symbol_to_sal (&sal
, self
->funfirstline
, sym
);
2656 add_sal_to_sals (self
, &values
, &sal
,
2657 SYMBOL_NATURAL_NAME (fn_sym
));
2659 if (self
->canonical
)
2661 self
->canonical
->special_display
= 1;
2662 self
->canonical
->addr_string
2663 = xstrprintf ("%s:%s", SYMBOL_NATURAL_NAME (fn_sym
),
2672 result
->sals
= NULL
;
2675 for (ix
= 0; VEC_iterate (symbolp
, function_symbols
, ix
, fn_sym
); ++ix
)
2677 struct block
*block
;
2680 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym
)));
2681 block
= SYMBOL_BLOCK_VALUE (fn_sym
);
2682 sym
= lookup_symbol (copy
, block
, LABEL_DOMAIN
, 0);
2686 struct symtab_and_line sal
;
2689 symbol_to_sal (&sal
, self
->funfirstline
, sym
);
2690 symname
= xstrprintf ("%s:%s",
2691 SYMBOL_NATURAL_NAME (fn_sym
),
2692 SYMBOL_NATURAL_NAME (sym
));
2693 add_sal_to_sals (self
, result
, &sal
, symname
);
2698 if (self
->canonical
&& result
->nelts
> 0)
2700 self
->canonical
->pre_expanded
= 1;
2701 self
->canonical
->special_display
= 1;
2703 gdb_assert (self
->user_function
);
2704 self
->canonical
->addr_string
2705 = xstrprintf ("%s:%s", self
->user_function
, copy
);
2708 return result
->nelts
> 0;
2711 /* A callback used to possibly add a symbol to the results. */
2714 collect_symbols (struct symbol
*sym
, void *data
)
2716 struct collect_info
*info
= data
;
2717 struct symtab_and_line sal
;
2719 if (symbol_to_sal (&sal
, info
->state
->funfirstline
, sym
)
2720 && maybe_add_address (info
->state
->addr_set
,
2721 SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
)),
2723 add_sal_to_sals (info
->state
, &info
->result
, &sal
,
2724 SYMBOL_NATURAL_NAME (sym
));
2729 /* We've found a minimal symbol MSYMBOL to associate with our
2730 linespec; add it to the result symtabs_and_lines. */
2733 minsym_found (struct linespec_state
*self
, struct objfile
*objfile
,
2734 struct minimal_symbol
*msymbol
,
2735 struct symtabs_and_lines
*result
)
2737 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2739 struct symtab_and_line sal
;
2741 sal
= find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
2742 (struct obj_section
*) 0, 0);
2743 sal
.section
= SYMBOL_OBJ_SECTION (msymbol
);
2745 /* The minimal symbol might point to a function descriptor;
2746 resolve it to the actual code address instead. */
2747 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, sal
.pc
, ¤t_target
);
2749 sal
= find_pc_sect_line (pc
, NULL
, 0);
2751 if (self
->funfirstline
)
2752 skip_prologue_sal (&sal
);
2754 if (maybe_add_address (self
->addr_set
, objfile
->pspace
, sal
.pc
))
2755 add_sal_to_sals (self
, result
, &sal
, SYMBOL_NATURAL_NAME (msymbol
));
2758 /* A helper struct which just holds a minimal symbol and the object
2759 file from which it came. */
2761 typedef struct minsym_and_objfile
2763 struct minimal_symbol
*minsym
;
2764 struct objfile
*objfile
;
2765 } minsym_and_objfile_d
;
2767 DEF_VEC_O (minsym_and_objfile_d
);
2769 /* A helper struct to pass some data through
2770 iterate_over_minimal_symbols. */
2772 struct collect_minsyms
2774 /* The objfile we're examining. */
2775 struct objfile
*objfile
;
2777 /* The funfirstline setting from the initial call. */
2780 /* The list_mode setting from the initial call. */
2783 /* The resulting symbols. */
2784 VEC (minsym_and_objfile_d
) *msyms
;
2787 /* A helper function to classify a minimal_symbol_type according to
2791 classify_mtype (enum minimal_symbol_type t
)
2798 /* Intermediate priority. */
2801 case mst_solib_trampoline
:
2802 /* Lowest priority. */
2806 /* Highest priority. */
2811 /* Callback for qsort that sorts symbols by priority. */
2814 compare_msyms (const void *a
, const void *b
)
2816 const minsym_and_objfile_d
*moa
= a
;
2817 const minsym_and_objfile_d
*mob
= b
;
2818 enum minimal_symbol_type ta
= MSYMBOL_TYPE (moa
->minsym
);
2819 enum minimal_symbol_type tb
= MSYMBOL_TYPE (mob
->minsym
);
2821 return classify_mtype (ta
) - classify_mtype (tb
);
2824 /* Callback for iterate_over_minimal_symbols that adds the symbol to
2828 add_minsym (struct minimal_symbol
*minsym
, void *d
)
2830 struct collect_minsyms
*info
= d
;
2831 minsym_and_objfile_d mo
;
2833 /* Exclude data symbols when looking for breakpoint locations. */
2834 if (!info
->list_mode
)
2835 switch (minsym
->type
)
2837 case mst_slot_got_plt
:
2844 /* Make sure this minsym is not a function descriptor
2845 before we decide to discard it. */
2846 struct gdbarch
*gdbarch
= info
->objfile
->gdbarch
;
2847 CORE_ADDR addr
= gdbarch_convert_from_func_ptr_addr
2848 (gdbarch
, SYMBOL_VALUE_ADDRESS (minsym
),
2851 if (addr
== SYMBOL_VALUE_ADDRESS (minsym
))
2857 mo
.objfile
= info
->objfile
;
2858 VEC_safe_push (minsym_and_objfile_d
, info
->msyms
, &mo
);
2861 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
2862 is not NULL, the search is restricted to just that program
2866 search_minsyms_for_name (struct collect_info
*info
, const char *name
,
2867 struct program_space
*search_pspace
)
2869 struct objfile
*objfile
;
2870 struct program_space
*pspace
;
2872 ALL_PSPACES (pspace
)
2874 struct collect_minsyms local
;
2875 struct cleanup
*cleanup
;
2877 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
2879 if (pspace
->executing_startup
)
2882 set_current_program_space (pspace
);
2884 memset (&local
, 0, sizeof (local
));
2885 local
.funfirstline
= info
->state
->funfirstline
;
2886 local
.list_mode
= info
->state
->list_mode
;
2888 cleanup
= make_cleanup (VEC_cleanup (minsym_and_objfile_d
),
2891 ALL_OBJFILES (objfile
)
2893 local
.objfile
= objfile
;
2894 iterate_over_minimal_symbols (objfile
, name
, add_minsym
, &local
);
2897 if (!VEC_empty (minsym_and_objfile_d
, local
.msyms
))
2901 minsym_and_objfile_d
*item
;
2903 qsort (VEC_address (minsym_and_objfile_d
, local
.msyms
),
2904 VEC_length (minsym_and_objfile_d
, local
.msyms
),
2905 sizeof (minsym_and_objfile_d
),
2908 /* Now the minsyms are in classification order. So, we walk
2909 over them and process just the minsyms with the same
2910 classification as the very first minsym in the list. */
2911 item
= VEC_index (minsym_and_objfile_d
, local
.msyms
, 0);
2912 classification
= classify_mtype (MSYMBOL_TYPE (item
->minsym
));
2915 VEC_iterate (minsym_and_objfile_d
, local
.msyms
, ix
, item
);
2918 if (classify_mtype (MSYMBOL_TYPE (item
->minsym
)) != classification
)
2921 minsym_found (info
->state
, item
->objfile
, item
->minsym
,
2926 do_cleanups (cleanup
);
2930 /* A helper function to add all symbols matching NAME to INFO. If
2931 PSPACE is not NULL, the search is restricted to just that program
2935 add_matching_symbols_to_info (const char *name
,
2936 struct collect_info
*info
,
2937 struct program_space
*pspace
)
2942 for (ix
= 0; VEC_iterate (symtab_p
, info
->state
->file_symtabs
, ix
, elt
); ++ix
)
2948 iterate_over_all_matching_symtabs (name
, VAR_DOMAIN
,
2949 collect_symbols
, info
,
2951 search_minsyms_for_name (info
, name
, pspace
);
2953 else if (pspace
== NULL
|| pspace
== SYMTAB_PSPACE (elt
))
2955 /* Program spaces that are executing startup should have
2956 been filtered out earlier. */
2957 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
2958 set_current_program_space (SYMTAB_PSPACE (elt
));
2959 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt
), name
,
2960 VAR_DOMAIN
, collect_symbols
,
2966 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
2967 look in that symtab's static variables first. */
2969 static struct symtabs_and_lines
2970 decode_variable (struct linespec_state
*self
, char *copy
)
2972 struct collect_info info
;
2973 const char *lookup_name
;
2975 struct cleanup
*cleanup
;
2978 info
.result
.sals
= NULL
;
2979 info
.result
.nelts
= 0;
2981 cleanup
= demangle_for_lookup (copy
, current_language
->la_language
,
2983 if (current_language
->la_language
== language_ada
)
2985 /* In Ada, the symbol lookups are performed using the encoded
2986 name rather than the demangled name. */
2987 lookup_name
= ada_name_for_lookup (copy
);
2988 make_cleanup (xfree
, (void *) lookup_name
);
2991 canon
= cp_canonicalize_string_no_typedefs (lookup_name
);
2994 make_cleanup (xfree
, canon
);
2995 lookup_name
= canon
;
2998 add_matching_symbols_to_info (lookup_name
, &info
, NULL
);
3000 if (info
.result
.nelts
> 0)
3002 if (self
->canonical
)
3004 self
->canonical
->pre_expanded
= 1;
3005 if (self
->user_filename
)
3006 self
->canonical
->addr_string
3007 = xstrprintf ("%s:%s", self
->user_filename
, copy
);
3009 self
->canonical
->addr_string
= xstrdup (copy
);
3014 if (!have_full_symbols ()
3015 && !have_partial_symbols ()
3016 && !have_minimal_symbols ())
3017 throw_error (NOT_FOUND_ERROR
,
3018 _("No symbol table is loaded. Use the \"file\" command."));
3019 if (self
->user_filename
)
3020 throw_error (NOT_FOUND_ERROR
, _("Function \"%s\" not defined in \"%s\"."),
3021 copy
, self
->user_filename
);
3023 throw_error (NOT_FOUND_ERROR
, _("Function \"%s\" not defined."), copy
);
3029 /* Now come some functions that are called from multiple places within
3033 symbol_to_sal (struct symtab_and_line
*result
,
3034 int funfirstline
, struct symbol
*sym
)
3036 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3038 *result
= find_function_start_sal (sym
, funfirstline
);
3043 if (SYMBOL_CLASS (sym
) == LOC_LABEL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
3046 result
->symtab
= SYMBOL_SYMTAB (sym
);
3047 result
->line
= SYMBOL_LINE (sym
);
3048 result
->pc
= SYMBOL_VALUE_ADDRESS (sym
);
3049 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3050 result
->explicit_pc
= 1;
3053 else if (funfirstline
)
3057 else if (SYMBOL_LINE (sym
) != 0)
3059 /* We know its line number. */
3061 result
->symtab
= SYMBOL_SYMTAB (sym
);
3062 result
->line
= SYMBOL_LINE (sym
);
3063 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3071 /* See the comment in linespec.h. */
3074 init_linespec_result (struct linespec_result
*lr
)
3076 memset (lr
, 0, sizeof (*lr
));
3079 /* See the comment in linespec.h. */
3082 destroy_linespec_result (struct linespec_result
*ls
)
3085 struct linespec_sals
*lsal
;
3087 xfree (ls
->addr_string
);
3088 for (i
= 0; VEC_iterate (linespec_sals
, ls
->sals
, i
, lsal
); ++i
)
3090 xfree (lsal
->canonical
);
3091 xfree (lsal
->sals
.sals
);
3093 VEC_free (linespec_sals
, ls
->sals
);
3096 /* Cleanup function for a linespec_result. */
3099 cleanup_linespec_result (void *a
)
3101 destroy_linespec_result (a
);
3104 /* See the comment in linespec.h. */
3107 make_cleanup_destroy_linespec_result (struct linespec_result
*ls
)
3109 return make_cleanup (cleanup_linespec_result
, ls
);