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 char *name
, void *d
)
341 const struct symbol_matcher_data
*data
= d
;
343 if (data
->symbol_name_match_p (name
, data
->lookup_name
))
348 /* A helper that walks over all matching symtabs in all objfiles and
349 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
350 not NULL, then the search is restricted to just that program
354 iterate_over_all_matching_symtabs (const char *name
,
355 const domain_enum domain
,
356 int (*callback
) (struct symbol
*, void *),
358 struct program_space
*search_pspace
)
360 struct objfile
*objfile
;
361 struct program_space
*pspace
;
362 struct symbol_matcher_data matcher_data
;
364 matcher_data
.lookup_name
= name
;
365 matcher_data
.symbol_name_match_p
=
366 current_language
->la_get_symbol_name_match_p
!= NULL
367 ? current_language
->la_get_symbol_name_match_p (name
)
372 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
374 if (pspace
->executing_startup
)
377 set_current_program_space (pspace
);
379 ALL_OBJFILES (objfile
)
381 struct symtab
*symtab
;
384 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, NULL
,
385 iterate_name_matcher
,
389 ALL_OBJFILE_SYMTABS (objfile
, symtab
)
395 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
396 LA_ITERATE_OVER_SYMBOLS (block
, name
, domain
, callback
, data
);
403 /* Returns the block to be used for symbol searches for the given SYMTAB,
404 which may be NULL. */
406 static struct block
*
407 get_search_block (struct symtab
*symtab
)
412 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
415 enum language save_language
;
417 /* get_selected_block can change the current language when there is
418 no selected frame yet. */
419 save_language
= current_language
->la_language
;
420 block
= get_selected_block (0);
421 set_language (save_language
);
427 /* A helper for find_method. This finds all methods in type T which
428 match NAME. It adds resulting symbol names to RESULT_NAMES, and
429 adds T's direct superclasses to SUPERCLASSES. */
432 find_methods (struct type
*t
, const char *name
,
433 VEC (const_char_ptr
) **result_names
,
434 VEC (typep
) **superclasses
)
438 char *class_name
= type_name_no_tag (t
);
441 /* Ignore this class if it doesn't have a name. This is ugly, but
442 unless we figure out how to get the physname without the name of
443 the class, then the loop can't do any good. */
447 int name_len
= strlen (name
);
451 /* Loop over each method name. At this level, all overloads of a name
452 are counted as a single name. There is an inner loop which loops over
455 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
459 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
462 if (strncmp (method_name
, "__", 2) == 0 ||
463 strncmp (method_name
, "op", 2) == 0 ||
464 strncmp (method_name
, "type", 4) == 0)
466 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
467 method_name
= dem_opname
;
468 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
469 method_name
= dem_opname
;
472 if (strcmp_iw (method_name
, name
) == 0)
476 for (field_counter
= (TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
)
482 const char *phys_name
;
484 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
485 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
487 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
488 VEC_safe_push (const_char_ptr
, *result_names
, phys_name
);
494 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
495 VEC_safe_push (typep
, *superclasses
, TYPE_BASECLASS (t
, ibase
));
498 /* Find an instance of the character C in the string S that is outside
499 of all parenthesis pairs, single-quoted strings, and double-quoted
500 strings. Also, ignore the char within a template name, like a ','
501 within foo<int, int>. */
504 find_toplevel_char (char *s
, char c
)
506 int quoted
= 0; /* zero if we're not in quotes;
507 '"' if we're in a double-quoted string;
508 '\'' if we're in a single-quoted string. */
509 int depth
= 0; /* Number of unclosed parens we've seen. */
512 for (scan
= s
; *scan
; scan
++)
518 else if (*scan
== '\\' && *(scan
+ 1))
521 else if (*scan
== c
&& ! quoted
&& depth
== 0)
523 else if (*scan
== '"' || *scan
== '\'')
525 else if (*scan
== '(' || *scan
== '<')
527 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
534 /* Determines if the gives string corresponds to an Objective-C method
535 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
536 are allowed to have spaces and parentheses in them. */
539 is_objc_method_format (const char *s
)
541 if (s
== NULL
|| *s
== '\0')
543 /* Handle arguments with the format FILENAME:SYMBOL. */
544 if ((s
[0] == ':') && (strchr ("+-", s
[1]) != NULL
)
545 && (s
[2] == '[') && strchr(s
, ']'))
547 /* Handle arguments that are just SYMBOL. */
548 else if ((strchr ("+-", s
[0]) != NULL
) && (s
[1] == '[') && strchr(s
, ']'))
553 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
554 and store the result in SELF->CANONICAL. */
557 filter_results (struct linespec_state
*self
,
558 struct symtabs_and_lines
*result
,
559 VEC (const_char_ptr
) *filters
)
564 for (i
= 0; VEC_iterate (const_char_ptr
, filters
, i
, name
); ++i
)
566 struct linespec_sals lsal
;
569 memset (&lsal
, 0, sizeof (lsal
));
571 for (j
= 0; j
< result
->nelts
; ++j
)
573 if (strcmp (name
, self
->canonical_names
[j
]) == 0)
574 add_sal_to_sals_basic (&lsal
.sals
, &result
->sals
[j
]);
577 if (lsal
.sals
.nelts
> 0)
579 lsal
.canonical
= xstrdup (name
);
580 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
584 self
->canonical
->pre_expanded
= 0;
587 /* Store RESULT into SELF->CANONICAL. */
590 convert_results_to_lsals (struct linespec_state
*self
,
591 struct symtabs_and_lines
*result
)
593 struct linespec_sals lsal
;
595 lsal
.canonical
= NULL
;
597 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
600 /* Handle multiple results in RESULT depending on SELECT_MODE. This
601 will either return normally, throw an exception on multiple
602 results, or present a menu to the user. On return, the SALS vector
603 in SELF->CANONICAL is set up properly. */
606 decode_line_2 (struct linespec_state
*self
,
607 struct symtabs_and_lines
*result
,
608 const char *select_mode
)
613 struct cleanup
*old_chain
;
614 VEC (const_char_ptr
) *item_names
= NULL
, *filters
= NULL
;
615 struct get_number_or_range_state state
;
617 gdb_assert (select_mode
!= multiple_symbols_all
);
618 gdb_assert (self
->canonical
!= NULL
);
620 old_chain
= make_cleanup (VEC_cleanup (const_char_ptr
), &item_names
);
621 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
622 for (i
= 0; i
< result
->nelts
; ++i
)
627 gdb_assert (self
->canonical_names
[i
] != NULL
);
628 for (j
= 0; VEC_iterate (const_char_ptr
, item_names
, j
, iter
); ++j
)
630 if (strcmp (iter
, self
->canonical_names
[i
]) == 0)
638 VEC_safe_push (const_char_ptr
, item_names
, self
->canonical_names
[i
]);
641 if (select_mode
== multiple_symbols_cancel
642 && VEC_length (const_char_ptr
, item_names
) > 1)
643 error (_("canceled because the command is ambiguous\n"
644 "See set/show multiple-symbol."));
646 if (select_mode
== multiple_symbols_all
647 || VEC_length (const_char_ptr
, item_names
) == 1)
649 do_cleanups (old_chain
);
650 convert_results_to_lsals (self
, result
);
654 printf_unfiltered (_("[0] cancel\n[1] all\n"));
655 for (i
= 0; VEC_iterate (const_char_ptr
, item_names
, i
, iter
); ++i
)
656 printf_unfiltered ("[%d] %s\n", i
+ 2, iter
);
658 prompt
= getenv ("PS2");
663 args
= command_line_input (prompt
, 0, "overload-choice");
665 if (args
== 0 || *args
== 0)
666 error_no_arg (_("one or more choice numbers"));
668 init_number_or_range (&state
, args
);
669 while (!state
.finished
)
673 num
= get_number_or_range (&state
);
676 error (_("canceled"));
679 /* We intentionally make this result in a single breakpoint,
680 contrary to what older versions of gdb did. The
681 rationale is that this lets a user get the
682 multiple_symbols_all behavior even with the 'ask'
683 setting; and he can get separate breakpoints by entering
684 "2-57" at the query. */
685 do_cleanups (old_chain
);
686 convert_results_to_lsals (self
, result
);
691 if (num
>= VEC_length (const_char_ptr
, item_names
))
692 printf_unfiltered (_("No choice number %d.\n"), num
);
695 const char *elt
= VEC_index (const_char_ptr
, item_names
, num
);
699 VEC_safe_push (const_char_ptr
, filters
, elt
);
700 VEC_replace (const_char_ptr
, item_names
, num
, NULL
);
704 printf_unfiltered (_("duplicate request for %d ignored.\n"),
710 filter_results (self
, result
, filters
);
711 do_cleanups (old_chain
);
714 /* Valid delimiters for linespec keywords "if", "thread" or "task". */
717 is_linespec_boundary (char c
)
719 return c
== ' ' || c
== '\t' || c
== '\0' || c
== ',';
722 /* A helper function for decode_line_1 and friends which skips P
723 past any method overload information at the beginning of P, e.g.,
724 "(const struct foo *)".
726 This function assumes that P has already been validated to contain
727 overload information, and it will assert if *P != '('. */
729 find_method_overload_end (char *p
)
733 gdb_assert (*p
== '(');
753 /* Keep important information used when looking up a name. This includes
754 template parameters, overload information, and important keywords, including
755 the possible Java trailing type. */
758 keep_name_info (char *p
, int on_boundary
)
760 const char *quotes
= get_gdb_completer_quote_characters ();
766 if (strchr (quotes
, *p
))
769 if (*p
== ',' && !nest
)
772 if (on_boundary
&& !nest
)
774 const char *const words
[] = { "if", "thread", "task" };
777 for (wordi
= 0; wordi
< ARRAY_SIZE (words
); wordi
++)
778 if (strncmp (p
, words
[wordi
], strlen (words
[wordi
])) == 0
779 && is_linespec_boundary (p
[strlen (words
[wordi
])]))
781 if (wordi
< ARRAY_SIZE (words
))
785 if (*p
== '(' || *p
== '<' || *p
== '[')
787 else if ((*p
== ')' || *p
== '>' || *p
== ']') && nest
> 0)
792 /* The ',' check could fail on "operator ,". */
793 p
+= cp_validate_operator (p
);
795 on_boundary
= is_linespec_boundary (p
[-1]);
798 while (p
> saved_p
&& is_linespec_boundary (p
[-1]))
805 /* The parser of linespec itself. */
807 /* Parse a string that specifies a line number.
808 Pass the address of a char * variable; that variable will be
809 advanced over the characters actually parsed.
813 LINENUM -- that line number in current file. PC returned is 0.
814 FILE:LINENUM -- that line in that file. PC returned is 0.
815 FUNCTION -- line number of openbrace of that function.
816 PC returned is the start of the function.
817 LABEL -- a label in the current scope
818 VARIABLE -- line number of definition of that variable.
820 FILE:FUNCTION -- likewise, but prefer functions in that file.
821 *EXPR -- line in which address EXPR appears.
823 This may all be followed by an "if EXPR", which we ignore.
825 FUNCTION may be an undebuggable function found in minimal symbol table.
827 If the argument FUNFIRSTLINE is nonzero, we want the first line
828 of real code inside a function when a function is specified, and it is
829 not OK to specify a variable or type to get its line number.
831 DEFAULT_SYMTAB specifies the file to use if none is specified.
832 It defaults to current_source_symtab.
833 DEFAULT_LINE specifies the line number to use for relative
834 line numbers (that start with signs). Defaults to current_source_line.
835 If CANONICAL is non-NULL, store an array of strings containing the canonical
836 line specs there if necessary. Currently overloaded member functions and
837 line numbers or static functions without a filename yield a canonical
838 line spec. The array and the line spec strings are allocated on the heap,
839 it is the callers responsibility to free them.
841 Note that it is possible to return zero for the symtab
842 if no file is validly specified. Callers must check that.
843 Also, the line number returned may be invalid. */
845 /* We allow single quotes in various places. This is a hideous
846 kludge, which exists because the completer can't yet deal with the
847 lack of single quotes. FIXME: write a linespec_completer which we
848 can use as appropriate instead of make_symbol_completion_list. */
850 static struct symtabs_and_lines
851 decode_line_internal (struct linespec_state
*self
, char **argptr
)
857 /* This says whether or not something in *ARGPTR is quoted with
858 completer_quotes (i.e. with single quotes). */
860 /* Is *ARGPTR enclosed in double quotes? */
861 int is_quote_enclosed
;
862 int is_objc_method
= 0;
863 char *saved_arg
= *argptr
;
864 /* If IS_QUOTED, the end of the quoted bit. */
865 char *end_quote
= NULL
;
866 /* Is *ARGPTR enclosed in single quotes? */
867 int is_squote_enclosed
= 0;
868 /* The "first half" of the linespec. */
871 /* If we are parsing `function:label', this holds the symbols
872 matching the function name. */
873 VEC (symbolp
) *function_symbols
= NULL
;
874 /* If FUNCTION_SYMBOLS is not NULL, then this is the exception that
875 was thrown when trying to parse a filename. */
876 volatile struct gdb_exception file_exception
;
878 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
880 /* Defaults have defaults. */
882 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
884 /* See if arg is *PC. */
888 do_cleanups (cleanup
);
889 return decode_indirect (self
, argptr
);
892 is_quoted
= (strchr (get_gdb_completer_quote_characters (),
897 end_quote
= skip_quoted (*argptr
);
898 if (*end_quote
== '\0')
899 is_squote_enclosed
= 1;
902 /* Check to see if it's a multipart linespec (with colons or
905 /* Locate the end of the first half of the linespec.
906 After the call, for instance, if the argptr string is "foo.c:123"
907 p will point at "123". If there is only one part, like "foo", p
908 will point to "". If this is a C++ name, like "A::B::foo", p will
909 point to "::B::foo". Argptr is not changed by this call. */
911 first_half
= p
= locate_first_half (argptr
, &is_quote_enclosed
);
913 /* First things first: if ARGPTR starts with a filename, get its
914 symtab and strip the filename from ARGPTR.
915 Avoid calling symtab_from_filename if we know can,
916 it can be expensive. */
920 TRY_CATCH (file_exception
, RETURN_MASK_ERROR
)
922 self
->file_symtabs
= symtabs_from_filename (argptr
, p
,
924 &self
->user_filename
);
927 if (file_exception
.reason
>= 0)
929 /* Check for single quotes on the non-filename part. */
930 is_quoted
= (**argptr
931 && strchr (get_gdb_completer_quote_characters (),
934 end_quote
= skip_quoted (*argptr
);
936 /* Locate the next "half" of the linespec. */
937 first_half
= p
= locate_first_half (argptr
, &is_quote_enclosed
);
940 if (VEC_empty (symtab_p
, self
->file_symtabs
))
942 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
943 VEC_safe_push (symtab_p
, self
->file_symtabs
, NULL
);
948 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
949 VEC_safe_push (symtab_p
, self
->file_symtabs
, NULL
);
952 /* Check if this is an Objective-C method (anything that starts with
953 a '+' or '-' and a '['). */
954 if (is_objc_method_format (p
))
957 /* Check if the symbol could be an Objective-C selector. */
960 struct symtabs_and_lines values
;
962 values
= decode_objc (self
, argptr
);
963 if (values
.sals
!= NULL
)
965 do_cleanups (cleanup
);
970 /* Does it look like there actually were two parts? */
972 if (p
[0] == ':' || p
[0] == '.')
974 /* Is it a C++ or Java compound data structure?
975 The check on p[1] == ':' is capturing the case of "::",
976 since p[0]==':' was checked above.
977 Note that the call to decode_compound does everything
978 for us, including the lookup on the symbol table, so we
981 if (p
[0] == '.' || p
[1] == ':')
983 /* We only perform this check for the languages where it might
984 make sense. For instance, Ada does not use this type of
985 syntax, and trying to apply this logic on an Ada linespec
986 may trigger a spurious error (for instance, decode_compound
987 does not like expressions such as `ops."<"', which is a
988 valid function name in Ada). */
989 if (current_language
->la_language
== language_c
990 || current_language
->la_language
== language_cplus
991 || current_language
->la_language
== language_java
)
993 struct symtabs_and_lines values
;
994 volatile struct gdb_exception ex
;
995 char *saved_argptr
= *argptr
;
997 if (is_quote_enclosed
)
1000 /* Initialize it just to avoid a GCC false warning. */
1001 memset (&values
, 0, sizeof (values
));
1003 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1005 values
= decode_compound (self
, argptr
, saved_arg
, p
);
1007 if ((is_quoted
|| is_squote_enclosed
) && **argptr
== '\'')
1008 *argptr
= *argptr
+ 1;
1012 do_cleanups (cleanup
);
1016 if (ex
.error
!= NOT_FOUND_ERROR
)
1017 throw_exception (ex
);
1019 *argptr
= saved_argptr
;
1024 /* If there was an exception looking up a specified filename earlier,
1025 then check whether we were really given `function:label'. */
1026 if (file_exception
.reason
< 0)
1028 function_symbols
= find_function_symbols (argptr
, p
,
1030 &self
->user_function
);
1032 /* If we did not find a function, re-throw the original
1034 if (!function_symbols
)
1035 throw_exception (file_exception
);
1037 make_cleanup (VEC_cleanup (symbolp
), &function_symbols
);
1040 /* Check for single quotes on the non-filename part. */
1043 is_quoted
= (**argptr
1044 && strchr (get_gdb_completer_quote_characters (),
1047 end_quote
= skip_quoted (*argptr
);
1052 /* self->file_symtabs holds the specified file symtabs, or 0 if no file
1054 If we are parsing `function:symbol', then FUNCTION_SYMBOLS holds the
1055 functions before the `:'.
1056 arg no longer contains the file name. */
1058 /* If the filename was quoted, we must re-check the quotation. */
1060 if (end_quote
== first_half
&& *end_quote
!= '\0')
1062 is_quoted
= (**argptr
1063 && strchr (get_gdb_completer_quote_characters (),
1066 end_quote
= skip_quoted (*argptr
);
1069 /* Check whether arg is all digits (and sign). */
1072 if (*q
== '-' || *q
== '+')
1074 while (*q
>= '0' && *q
<= '9')
1077 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ',')
1078 && function_symbols
== NULL
)
1080 struct symtabs_and_lines values
;
1082 /* We found a token consisting of all digits -- at least one digit. */
1083 values
= decode_all_digits (self
, argptr
, q
);
1084 do_cleanups (cleanup
);
1088 /* Arg token is not digits => try it as a variable name
1089 Find the next token (everything up to end or next whitespace). */
1091 if (**argptr
== '$') /* May be a convenience variable. */
1092 /* One or two $ chars possible. */
1093 p
= skip_quoted (*argptr
+ (((*argptr
)[1] == '$') ? 2 : 1));
1094 else if (is_quoted
|| is_squote_enclosed
)
1098 error (_("Unmatched single quote."));
1100 else if (is_objc_method
)
1102 /* allow word separators in method names for Obj-C. */
1103 p
= skip_quoted_chars (*argptr
, NULL
, "");
1107 p
= skip_quoted (*argptr
);
1110 /* Keep any important naming information. */
1111 p
= keep_name_info (p
, p
== saved_arg
|| is_linespec_boundary (p
[-1]));
1113 copy
= (char *) alloca (p
- *argptr
+ 1);
1114 memcpy (copy
, *argptr
, p
- *argptr
);
1115 copy
[p
- *argptr
] = '\0';
1118 && copy
[0] == copy
[p
- *argptr
- 1]
1119 && strchr (get_gdb_completer_quote_characters (), copy
[0]) != NULL
)
1121 copy
[p
- *argptr
- 1] = '\0';
1124 else if (is_quoted
|| is_squote_enclosed
)
1125 copy
[p
- *argptr
- 1] = '\0';
1127 *argptr
= skip_spaces (p
);
1129 /* If it starts with $: may be a legitimate variable or routine name
1130 (e.g. HP-UX millicode routines such as $$dyncall), or it may
1131 be history value, or it may be a convenience variable. */
1133 if (*copy
== '$' && function_symbols
== NULL
)
1135 struct symtabs_and_lines values
;
1137 values
= decode_dollar (self
, copy
);
1138 do_cleanups (cleanup
);
1142 /* Try the token as a label, but only if no file was specified,
1143 because we can only really find labels in the current scope. */
1145 if (VEC_length (symtab_p
, self
->file_symtabs
) == 1
1146 && VEC_index (symtab_p
, self
->file_symtabs
, 0) == NULL
)
1148 struct symtabs_and_lines label_result
;
1149 if (decode_label (self
, function_symbols
, copy
, &label_result
))
1151 do_cleanups (cleanup
);
1152 return label_result
;
1156 if (function_symbols
)
1157 throw_exception (file_exception
);
1159 /* Look up that token as a variable.
1160 If file specified, use that file's per-file block to start with. */
1163 struct symtabs_and_lines values
;
1165 values
= decode_variable (self
, copy
);
1166 do_cleanups (cleanup
);
1171 /* A constructor for linespec_state. */
1174 linespec_state_constructor (struct linespec_state
*self
,
1176 struct symtab
*default_symtab
,
1178 struct linespec_result
*canonical
)
1180 memset (self
, 0, sizeof (*self
));
1181 self
->funfirstline
= (flags
& DECODE_LINE_FUNFIRSTLINE
) ? 1 : 0;
1182 self
->list_mode
= (flags
& DECODE_LINE_LIST_MODE
) ? 1 : 0;
1183 self
->default_symtab
= default_symtab
;
1184 self
->default_line
= default_line
;
1185 self
->canonical
= canonical
;
1186 self
->program_space
= current_program_space
;
1187 self
->addr_set
= htab_create_alloc (10, hash_address_entry
, eq_address_entry
,
1188 xfree
, xcalloc
, xfree
);
1191 /* A destructor for linespec_state. */
1194 linespec_state_destructor (void *arg
)
1196 struct linespec_state
*self
= arg
;
1198 xfree (self
->user_filename
);
1199 xfree (self
->user_function
);
1200 VEC_free (symtab_p
, self
->file_symtabs
);
1201 htab_delete (self
->addr_set
);
1204 /* See linespec.h. */
1207 decode_line_full (char **argptr
, int flags
,
1208 struct symtab
*default_symtab
,
1209 int default_line
, struct linespec_result
*canonical
,
1210 const char *select_mode
,
1213 struct symtabs_and_lines result
;
1214 struct linespec_state state
;
1215 struct cleanup
*cleanups
;
1216 char *arg_start
= *argptr
;
1217 VEC (const_char_ptr
) *filters
= NULL
;
1219 gdb_assert (canonical
!= NULL
);
1220 /* The filter only makes sense for 'all'. */
1221 gdb_assert (filter
== NULL
|| select_mode
== multiple_symbols_all
);
1222 gdb_assert (select_mode
== NULL
1223 || select_mode
== multiple_symbols_all
1224 || select_mode
== multiple_symbols_ask
1225 || select_mode
== multiple_symbols_cancel
);
1226 gdb_assert ((flags
& DECODE_LINE_LIST_MODE
) == 0);
1228 linespec_state_constructor (&state
, flags
,
1229 default_symtab
, default_line
, canonical
);
1230 cleanups
= make_cleanup (linespec_state_destructor
, &state
);
1231 save_current_program_space ();
1233 result
= decode_line_internal (&state
, argptr
);
1235 gdb_assert (result
.nelts
== 1 || canonical
->pre_expanded
);
1236 gdb_assert (canonical
->addr_string
!= NULL
);
1237 canonical
->pre_expanded
= 1;
1239 /* Fill in the missing canonical names. */
1240 if (result
.nelts
> 0)
1244 if (state
.canonical_names
== NULL
)
1245 state
.canonical_names
= xcalloc (result
.nelts
, sizeof (char *));
1246 make_cleanup (xfree
, state
.canonical_names
);
1247 for (i
= 0; i
< result
.nelts
; ++i
)
1249 if (state
.canonical_names
[i
] == NULL
)
1250 state
.canonical_names
[i
] = savestring (arg_start
,
1251 *argptr
- arg_start
);
1252 make_cleanup (xfree
, state
.canonical_names
[i
]);
1256 if (select_mode
== NULL
)
1258 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
1259 select_mode
= multiple_symbols_all
;
1261 select_mode
= multiple_symbols_select_mode ();
1264 if (select_mode
== multiple_symbols_all
)
1268 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
1269 VEC_safe_push (const_char_ptr
, filters
, filter
);
1270 filter_results (&state
, &result
, filters
);
1273 convert_results_to_lsals (&state
, &result
);
1276 decode_line_2 (&state
, &result
, select_mode
);
1278 do_cleanups (cleanups
);
1281 struct symtabs_and_lines
1282 decode_line_1 (char **argptr
, int flags
,
1283 struct symtab
*default_symtab
,
1286 struct symtabs_and_lines result
;
1287 struct linespec_state state
;
1288 struct cleanup
*cleanups
;
1290 linespec_state_constructor (&state
, flags
,
1291 default_symtab
, default_line
, NULL
);
1292 cleanups
= make_cleanup (linespec_state_destructor
, &state
);
1293 save_current_program_space ();
1295 result
= decode_line_internal (&state
, argptr
);
1296 do_cleanups (cleanups
);
1302 /* First, some functions to initialize stuff at the beggining of the
1306 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
1308 if (*default_symtab
== 0)
1310 /* Use whatever we have for the default source line. We don't use
1311 get_current_or_default_symtab_and_line as it can recurse and call
1313 struct symtab_and_line cursal
=
1314 get_current_source_symtab_and_line ();
1316 *default_symtab
= cursal
.symtab
;
1317 *default_line
= cursal
.line
;
1323 /* Decode arg of the form *PC. */
1325 static struct symtabs_and_lines
1326 decode_indirect (struct linespec_state
*self
, char **argptr
)
1328 struct symtabs_and_lines values
;
1330 char *initial
= *argptr
;
1332 if (current_program_space
->executing_startup
)
1333 /* The error message doesn't really matter, because this case
1334 should only hit during breakpoint reset. */
1335 throw_error (NOT_FOUND_ERROR
, _("cannot evaluate expressions while "
1336 "program space is in startup"));
1339 pc
= value_as_address (parse_to_comma_and_eval (argptr
));
1341 values
.sals
= (struct symtab_and_line
*)
1342 xmalloc (sizeof (struct symtab_and_line
));
1345 values
.sals
[0] = find_pc_line (pc
, 0);
1346 values
.sals
[0].pc
= pc
;
1347 values
.sals
[0].section
= find_pc_overlay (pc
);
1348 values
.sals
[0].explicit_pc
= 1;
1350 if (self
->canonical
)
1351 self
->canonical
->addr_string
= savestring (initial
, *argptr
- initial
);
1358 /* Locate the first half of the linespec, ending in a colon, period,
1359 or whitespace. (More or less.) Also, check to see if *ARGPTR is
1360 enclosed in double quotes; if so, set is_quote_enclosed, advance
1361 ARGPTR past that and zero out the trailing double quote.
1362 If ARGPTR is just a simple name like "main", p will point to ""
1366 locate_first_half (char **argptr
, int *is_quote_enclosed
)
1372 /* Check if the linespec starts with an Ada operator (such as "+",
1373 or ">", for instance). */
1376 && current_language
->la_language
== language_ada
)
1378 const struct ada_opname_map
*op
;
1380 for (op
= ada_opname_table
; op
->encoded
!= NULL
; op
++)
1381 if (strncmp (op
->decoded
, p
, strlen (op
->decoded
)) == 0)
1383 if (op
->encoded
!= NULL
)
1385 *is_quote_enclosed
= 0;
1386 return p
+ strlen (op
->decoded
);
1390 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1391 and we must isolate the first half. Outer layers will call again later
1392 for the second half.
1394 Don't count commas that appear in argument lists of overloaded
1395 functions, or in quoted strings. It's stupid to go to this much
1396 trouble when the rest of the function is such an obvious roach hotel. */
1397 ii
= find_toplevel_char (*argptr
, ',');
1398 has_comma
= (ii
!= 0);
1400 /* Temporarily zap out second half to not confuse the code below.
1401 This is undone below. Do not change ii!! */
1407 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
1408 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
1414 *is_quote_enclosed
= 1;
1420 *is_quote_enclosed
= 0;
1421 if (strchr (get_gdb_completer_quote_characters (), *p
))
1429 /* Check for a drive letter in the filename. This is done on all hosts
1430 to capture cross-compilation environments. On Unixen, directory
1431 separators are illegal in filenames, so if the user enters "e:/foo.c",
1432 he is referring to a directory named "e:" and a source file named
1433 "foo.c", and we still want to keep these two pieces together. */
1434 if (isalpha (p
[0]) && p
[1] == ':' && IS_DIR_SEPARATOR (p
[2]))
1441 char *temp_end
= find_template_name_end (p
);
1444 error (_("malformed template specification in command"));
1449 p
= find_method_overload_end (p
);
1451 /* Check for a colon and a plus or minus and a [ (which
1452 indicates an Objective-C method). */
1453 if (is_objc_method_format (p
))
1457 /* Check for the end of the first half of the linespec. End of
1458 line, a tab, a colon or a space. But if enclosed in double
1459 quotes we do not break on enclosed spaces. */
1463 || ((p
[0] == ' ') && !*is_quote_enclosed
))
1465 if (p
[0] == '.' && strchr (p
, ':') == NULL
)
1467 /* Java qualified method. Find the *last* '.', since the
1468 others are package qualifiers. Stop at any open parenthesis
1469 which might provide overload information. */
1470 for (p1
= p
; *p1
&& *p1
!= '('; p1
++)
1478 p
= skip_spaces (p
);
1480 /* If the closing double quote was left at the end, remove it. */
1481 if (*is_quote_enclosed
)
1483 char *closing_quote
= strchr (p
- 1, '"');
1485 if (closing_quote
&& closing_quote
[1] == '\0')
1486 *closing_quote
= '\0';
1489 /* Now that we've safely parsed the first half, put back ',' so
1490 outer layers can see it. */
1499 /* Here's where we recognise an Objective-C Selector. An Objective C
1500 selector may be implemented by more than one class, therefore it
1501 may represent more than one method/function. This gives us a
1502 situation somewhat analogous to C++ overloading. If there's more
1503 than one method that could represent the selector, then use some of
1504 the existing C++ code to let the user choose one. */
1506 static struct symtabs_and_lines
1507 decode_objc (struct linespec_state
*self
, char **argptr
)
1509 struct collect_info info
;
1510 VEC (const_char_ptr
) *symbol_names
= NULL
;
1512 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (const_char_ptr
),
1516 info
.result
.sals
= NULL
;
1517 info
.result
.nelts
= 0;
1519 new_argptr
= find_imps (*argptr
, &symbol_names
);
1520 if (VEC_empty (const_char_ptr
, symbol_names
))
1522 do_cleanups (cleanup
);
1526 add_all_symbol_names_from_pspace (&info
, NULL
, symbol_names
);
1528 if (info
.result
.nelts
> 0)
1532 saved_arg
= alloca (new_argptr
- *argptr
+ 1);
1533 memcpy (saved_arg
, *argptr
, new_argptr
- *argptr
);
1534 saved_arg
[new_argptr
- *argptr
] = '\0';
1536 if (self
->canonical
)
1538 self
->canonical
->pre_expanded
= 1;
1539 if (self
->user_filename
)
1540 self
->canonical
->addr_string
1541 = xstrprintf ("%s:%s", self
->user_filename
, saved_arg
);
1543 self
->canonical
->addr_string
= xstrdup (saved_arg
);
1547 *argptr
= new_argptr
;
1549 do_cleanups (cleanup
);
1553 /* This handles C++ and Java compound data structures. P should point
1554 at the first component separator, i.e. double-colon or period. As
1555 an example, on entrance to this function we could have ARGPTR
1556 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
1558 static struct symtabs_and_lines
1559 decode_compound (struct linespec_state
*self
,
1560 char **argptr
, char *the_real_saved_arg
, char *p
)
1562 struct symtabs_and_lines values
;
1564 char *saved_arg2
= *argptr
;
1568 VEC (symbolp
) *sym_classes
;
1569 char *saved_arg
, *class_name
;
1570 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1572 /* If the user specified any completer quote characters in the input,
1573 strip them. They are superfluous. */
1574 saved_arg
= alloca (strlen (the_real_saved_arg
) + 1);
1576 char *dst
= saved_arg
;
1577 char *src
= the_real_saved_arg
;
1578 char *quotes
= get_gdb_completer_quote_characters ();
1579 while (*src
!= '\0')
1581 if (strchr (quotes
, *src
) == NULL
)
1588 /* First check for "global" namespace specification, of the form
1589 "::foo". If found, skip over the colons and jump to normal
1590 symbol processing. I.e. the whole line specification starts with
1591 "::" (note the condition that *argptr == p). */
1593 && ((*argptr
== p
) || (p
[-1] == ' ') || (p
[-1] == '\t')))
1596 /* Given our example "AAA::inA::fun", we have two cases to consider:
1598 1) AAA::inA is the name of a class. In that case, presumably it
1599 has a method called "fun"; we then look up that method using
1602 2) AAA::inA isn't the name of a class. In that case, either the
1603 user made a typo, AAA::inA is the name of a namespace, or it is
1604 the name of a minimal symbol.
1605 In this case we just delegate to decode_variable.
1607 Thus, our first task is to find everything before the last set of
1608 double-colons and figure out if it's the name of a class. So we
1609 first loop through all of the double-colons. */
1611 p2
= p
; /* Save for restart. */
1613 /* This is very messy. Following the example above we have now the
1616 argptr -> "AAA::inA::fun
1617 saved_arg -> "AAA::inA::fun
1618 saved_arg2 -> "AAA::inA::fun
1619 p2 -> "::inA::fun". */
1621 /* In the loop below, with these strings, we'll make 2 passes, each
1622 is marked in comments. */
1626 static char *break_characters
= " \t(";
1628 /* Move pointer up to next possible class/namespace token. */
1630 p
= p2
+ 1; /* Restart with old value +1. */
1632 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1633 i.e. if there is a double-colon, p will now point to the
1635 /* PASS2: p2->"::fun", p->":fun" */
1637 /* Move pointer ahead to next double-colon. */
1639 && strchr (break_characters
, *p
) == NULL
1640 && strchr (get_gdb_completer_quote_characters (), *p
) == NULL
)
1642 if (current_language
->la_language
== language_cplus
)
1643 p
+= cp_validate_operator (p
);
1647 temp_end
= find_template_name_end (p
);
1649 error (_("malformed template specification in command"));
1652 /* Note that, since, at the start of this loop, p would be
1653 pointing to the second colon in a double-colon, we only
1654 satisfy the condition below if there is another
1655 double-colon to the right (after). I.e. there is another
1656 component that can be a class or a namespace. I.e, if at
1657 the beginning of this loop (PASS1), we had
1658 p->":inA::fun", we'll trigger this when p has been
1659 advanced to point to "::fun". */
1660 /* PASS2: we will not trigger this. */
1661 else if ((p
[0] == ':') && (p
[1] == ':'))
1662 break; /* Found double-colon. */
1665 /* PASS2: We'll keep getting here, until P points to one of the
1666 break characters, at which point we exit this loop. */
1670 && strncmp (&p
[1], CP_ANONYMOUS_NAMESPACE_STR
,
1671 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
1672 p
+= CP_ANONYMOUS_NAMESPACE_LEN
;
1673 else if (strchr (break_characters
, *p
) == NULL
)
1680 break; /* Out of the while (1). This would happen
1681 for instance if we have looked up
1682 unsuccessfully all the components of the
1683 string, and p->""(PASS2). */
1685 /* We get here if p points to one of the break characters or "" (i.e.,
1687 /* Save restart for next time around. */
1689 /* Restore argptr as it was on entry to this function. */
1690 *argptr
= saved_arg2
;
1691 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1694 /* All ready for next pass through the loop. */
1698 /* Start of lookup in the symbol tables. */
1700 /* Lookup in the symbol table the substring between argptr and
1701 p. Note, this call changes the value of argptr. */
1702 /* Before the call, argptr->"AAA::inA::fun",
1703 p->"", p2->"::fun". After the call: argptr->"fun", p, p2
1705 sym_classes
= lookup_prefix_sym (argptr
, p2
, self
->file_symtabs
,
1707 make_cleanup (VEC_cleanup (symbolp
), &sym_classes
);
1708 make_cleanup (xfree
, class_name
);
1710 /* If a class has been found, then we're in case 1 above. So we
1711 look up "fun" as a method of those classes. */
1712 if (!VEC_empty (symbolp
, sym_classes
))
1714 /* Arg token is not digits => try it as a function name.
1715 Find the next token (everything up to end or next
1718 && strchr (get_gdb_completer_quote_characters (),
1721 p
= skip_quoted (*argptr
);
1722 *argptr
= *argptr
+ 1;
1726 /* At this point argptr->"fun". */
1730 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!= ':'
1733 /* At this point p->"". String ended. */
1734 /* Nope, C++ operators could have spaces in them
1735 ("foo::operator <" or "foo::operator delete []").
1736 I apologize, this is a bit hacky... */
1737 if (current_language
->la_language
== language_cplus
1738 && *p
== ' ' && p
- 8 - *argptr
+ 1 > 0)
1740 /* The above loop has already swallowed "operator". */
1741 p
+= cp_validate_operator (p
- 8) - 8;
1744 /* Keep any important naming information. */
1745 p
= keep_name_info (p
, 1);
1748 /* Allocate our own copy of the substring between argptr and
1750 copy
= (char *) alloca (p
- *argptr
+ 1);
1751 memcpy (copy
, *argptr
, p
- *argptr
);
1752 copy
[p
- *argptr
] = '\0';
1754 && copy
[p
- *argptr
- 1]
1755 && strchr (get_gdb_completer_quote_characters (),
1756 copy
[p
- *argptr
- 1]) != NULL
)
1757 copy
[p
- *argptr
- 1] = '\0';
1759 /* At this point copy->"fun", p->"". */
1761 /* No line number may be specified. */
1762 *argptr
= skip_spaces (p
);
1763 /* At this point arptr->"". */
1765 /* Look for copy as a method of sym_class. */
1766 /* At this point copy->"fun", sym_class is "AAA:inA",
1767 saved_arg->"AAA::inA::fun". This concludes the scanning of
1768 the string for possible components matches. If we find it
1769 here, we return. If not, and we are at the and of the string,
1770 we'll lookup the whole string in the symbol tables. */
1772 values
= find_method (self
, saved_arg
, copy
, class_name
, sym_classes
);
1774 do_cleanups (cleanup
);
1776 } /* End if symbol found. */
1779 /* We couldn't find a class, so we're in case 2 above. We check the
1780 entire name as a symbol instead. The simplest way to do this is
1781 to just throw an exception and let our caller fall through to
1784 throw_error (NOT_FOUND_ERROR
, _("see caller, this text doesn't matter"));
1787 /* An instance of this type is used when collecting prefix symbols for
1790 struct decode_compound_collector
1792 /* The result vector. */
1793 VEC (symbolp
) *symbols
;
1795 /* A hash table of all symbols we found. We use this to avoid
1796 adding any symbol more than once. */
1800 /* A callback for iterate_over_symbols that is used by
1801 lookup_prefix_sym to collect type symbols. */
1804 collect_one_symbol (struct symbol
*sym
, void *d
)
1806 struct decode_compound_collector
*collector
= d
;
1810 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1813 t
= SYMBOL_TYPE (sym
);
1815 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1816 && TYPE_CODE (t
) != TYPE_CODE_UNION
1817 && TYPE_CODE (t
) != TYPE_CODE_NAMESPACE
)
1820 slot
= htab_find_slot (collector
->unique_syms
, sym
, INSERT
);
1824 VEC_safe_push (symbolp
, collector
->symbols
, sym
);
1830 /* Return the symbol corresponding to the substring of *ARGPTR ending
1831 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1832 name in question, the compound object separator ("::" or "."), and
1833 whitespace. Note that *ARGPTR is changed whether or not the
1834 this call finds anything (i.e we return NULL). As an
1835 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
1837 static VEC (symbolp
) *
1838 lookup_prefix_sym (char **argptr
, char *p
, VEC (symtab_p
) *file_symtabs
,
1845 struct decode_compound_collector collector
;
1846 struct cleanup
*outer
;
1847 struct cleanup
*cleanup
;
1848 struct block
*search_block
;
1850 /* Extract the class name. */
1852 while (p
!= *argptr
&& p
[-1] == ' ')
1854 copy
= (char *) xmalloc (p
- *argptr
+ 1);
1855 memcpy (copy
, *argptr
, p
- *argptr
);
1856 copy
[p
- *argptr
] = 0;
1858 outer
= make_cleanup (xfree
, copy
);
1860 /* Discard the class name from the argptr. */
1861 p
= p1
+ (p1
[0] == ':' ? 2 : 1);
1862 p
= skip_spaces (p
);
1865 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1866 argptr->"inA::fun". */
1868 collector
.symbols
= NULL
;
1869 make_cleanup (VEC_cleanup (symbolp
), &collector
.symbols
);
1871 collector
.unique_syms
= htab_create_alloc (1, htab_hash_pointer
,
1872 htab_eq_pointer
, NULL
,
1874 cleanup
= make_cleanup_htab_delete (collector
.unique_syms
);
1876 for (ix
= 0; VEC_iterate (symtab_p
, file_symtabs
, ix
, elt
); ++ix
)
1880 iterate_over_all_matching_symtabs (copy
, STRUCT_DOMAIN
,
1881 collect_one_symbol
, &collector
,
1883 iterate_over_all_matching_symtabs (copy
, VAR_DOMAIN
,
1884 collect_one_symbol
, &collector
,
1889 struct block
*search_block
;
1891 /* Program spaces that are executing startup should have
1892 been filtered out earlier. */
1893 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
1894 set_current_program_space (SYMTAB_PSPACE (elt
));
1895 search_block
= get_search_block (elt
);
1896 LA_ITERATE_OVER_SYMBOLS (search_block
, copy
, STRUCT_DOMAIN
,
1897 collect_one_symbol
, &collector
);
1898 LA_ITERATE_OVER_SYMBOLS (search_block
, copy
, VAR_DOMAIN
,
1899 collect_one_symbol
, &collector
);
1903 do_cleanups (cleanup
);
1904 discard_cleanups (outer
);
1905 return collector
.symbols
;
1908 /* A qsort comparison function for symbols. The resulting order does
1909 not actually matter; we just need to be able to sort them so that
1910 symbols with the same program space end up next to each other. */
1913 compare_symbols (const void *a
, const void *b
)
1915 struct symbol
* const *sa
= a
;
1916 struct symbol
* const *sb
= b
;
1919 uia
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa
));
1920 uib
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb
));
1927 uia
= (uintptr_t) *sa
;
1928 uib
= (uintptr_t) *sb
;
1938 /* Look for all the matching instances of each symbol in NAMES. Only
1939 instances from PSPACE are considered; other program spaces are
1940 handled by our caller. If PSPACE is NULL, then all program spaces
1941 are considered. Results are stored into INFO. */
1944 add_all_symbol_names_from_pspace (struct collect_info
*info
,
1945 struct program_space
*pspace
,
1946 VEC (const_char_ptr
) *names
)
1951 for (ix
= 0; VEC_iterate (const_char_ptr
, names
, ix
, iter
); ++ix
)
1952 add_matching_symbols_to_info (iter
, info
, pspace
);
1956 find_superclass_methods (VEC (typep
) *superclasses
,
1958 VEC (const_char_ptr
) **result_names
)
1960 int old_len
= VEC_length (const_char_ptr
, *result_names
);
1961 VEC (typep
) *iter_classes
;
1962 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1964 iter_classes
= superclasses
;
1967 VEC (typep
) *new_supers
= NULL
;
1971 make_cleanup (VEC_cleanup (typep
), &new_supers
);
1972 for (ix
= 0; VEC_iterate (typep
, iter_classes
, ix
, t
); ++ix
)
1973 find_methods (t
, name
, result_names
, &new_supers
);
1975 if (VEC_length (const_char_ptr
, *result_names
) != old_len
1976 || VEC_empty (typep
, new_supers
))
1979 iter_classes
= new_supers
;
1982 do_cleanups (cleanup
);
1985 /* This finds the method COPY in the class whose type is given by one
1986 of the symbols in SYM_CLASSES. */
1988 static struct symtabs_and_lines
1989 find_method (struct linespec_state
*self
, char *saved_arg
,
1990 char *copy
, const char *class_name
, VEC (symbolp
) *sym_classes
)
1994 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1996 int last_result_len
;
1997 VEC (typep
) *superclass_vec
;
1998 VEC (const_char_ptr
) *result_names
;
1999 struct collect_info info
;
2002 /* NAME is typed by the user: it needs to be canonicalized before
2003 searching the symbol tables. */
2004 canon
= cp_canonicalize_string_no_typedefs (copy
);
2008 make_cleanup (xfree
, copy
);
2011 /* Sort symbols so that symbols with the same program space are next
2013 qsort (VEC_address (symbolp
, sym_classes
),
2014 VEC_length (symbolp
, sym_classes
),
2019 info
.result
.sals
= NULL
;
2020 info
.result
.nelts
= 0;
2022 /* Iterate over all the types, looking for the names of existing
2023 methods matching COPY. If we cannot find a direct method in a
2024 given program space, then we consider inherited methods; this is
2025 not ideal (ideal would be to respect C++ hiding rules), but it
2026 seems good enough and is what GDB has historically done. We only
2027 need to collect the names because later we find all symbols with
2028 those names. This loop is written in a somewhat funny way
2029 because we collect data across the program space before deciding
2031 superclass_vec
= NULL
;
2032 make_cleanup (VEC_cleanup (typep
), &superclass_vec
);
2033 result_names
= NULL
;
2034 make_cleanup (VEC_cleanup (const_char_ptr
), &result_names
);
2035 last_result_len
= 0;
2036 for (ix
= 0; VEC_iterate (symbolp
, sym_classes
, ix
, sym
); ++ix
)
2039 struct program_space
*pspace
;
2041 /* Program spaces that are executing startup should have
2042 been filtered out earlier. */
2043 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
))->executing_startup
);
2044 pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2045 set_current_program_space (pspace
);
2046 t
= check_typedef (SYMBOL_TYPE (sym
));
2047 find_methods (t
, copy
, &result_names
, &superclass_vec
);
2049 /* Handle all items from a single program space at once; and be
2050 sure not to miss the last batch. */
2051 if (ix
== VEC_length (symbolp
, sym_classes
) - 1
2053 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp
, sym_classes
,
2056 /* If we did not find a direct implementation anywhere in
2057 this program space, consider superclasses. */
2058 if (VEC_length (const_char_ptr
, result_names
) == last_result_len
)
2059 find_superclass_methods (superclass_vec
, copy
, &result_names
);
2061 /* We have a list of candidate symbol names, so now we
2062 iterate over the symbol tables looking for all
2063 matches in this pspace. */
2064 add_all_symbol_names_from_pspace (&info
, pspace
, result_names
);
2066 VEC_truncate (typep
, superclass_vec
, 0);
2067 last_result_len
= VEC_length (const_char_ptr
, result_names
);
2071 if (info
.result
.nelts
> 0)
2073 if (self
->canonical
)
2075 self
->canonical
->pre_expanded
= 1;
2076 if (self
->user_filename
)
2077 self
->canonical
->addr_string
2078 = xstrprintf ("%s:%s", self
->user_filename
, saved_arg
);
2080 self
->canonical
->addr_string
= xstrdup (saved_arg
);
2083 do_cleanups (cleanup
);
2089 cplusplus_error (saved_arg
,
2090 "the class `%s' does not have destructor defined\n",
2093 cplusplus_error (saved_arg
,
2094 "the class %s does not have any method named %s\n",
2100 /* This object is used when collecting all matching symtabs. */
2102 struct symtab_collector
2104 /* The result vector of symtabs. */
2105 VEC (symtab_p
) *symtabs
;
2107 /* This is used to ensure the symtabs are unique. */
2108 htab_t symtab_table
;
2111 /* Callback for iterate_over_symtabs. */
2114 add_symtabs_to_list (struct symtab
*symtab
, void *d
)
2116 struct symtab_collector
*data
= d
;
2119 slot
= htab_find_slot (data
->symtab_table
, symtab
, INSERT
);
2123 VEC_safe_push (symtab_p
, data
->symtabs
, symtab
);
2129 /* Given a file name, return a VEC of all matching symtabs. */
2131 static VEC (symtab_p
) *
2132 collect_symtabs_from_filename (const char *file
)
2134 struct symtab_collector collector
;
2135 struct cleanup
*cleanups
;
2136 struct program_space
*pspace
;
2138 collector
.symtabs
= NULL
;
2139 collector
.symtab_table
= htab_create (1, htab_hash_pointer
, htab_eq_pointer
,
2141 cleanups
= make_cleanup_htab_delete (collector
.symtab_table
);
2143 /* Find that file's data. */
2144 ALL_PSPACES (pspace
)
2146 if (pspace
->executing_startup
)
2149 set_current_program_space (pspace
);
2150 iterate_over_symtabs (file
, add_symtabs_to_list
, &collector
);
2153 do_cleanups (cleanups
);
2154 return collector
.symtabs
;
2157 /* Return all the symtabs associated to the filename given by the
2158 substring of *ARGPTR ending at P, and advance ARGPTR past that
2161 static VEC (symtab_p
) *
2162 symtabs_from_filename (char **argptr
, char *p
, int is_quote_enclosed
,
2163 char **user_filename
)
2167 struct cleanup
*outer
;
2168 VEC (symtab_p
) *result
;
2171 while (p
!= *argptr
&& p
[-1] == ' ')
2173 if ((*p
== '"') && is_quote_enclosed
)
2175 copy
= xmalloc (p
- *argptr
+ 1);
2176 outer
= make_cleanup (xfree
, copy
);
2177 memcpy (copy
, *argptr
, p
- *argptr
);
2178 /* It may have the ending quote right after the file name. */
2179 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
2180 || copy
[p
- *argptr
- 1] == '\'')
2181 copy
[p
- *argptr
- 1] = 0;
2183 copy
[p
- *argptr
] = 0;
2185 result
= collect_symtabs_from_filename (copy
);
2187 if (VEC_empty (symtab_p
, result
))
2189 if (!have_full_symbols () && !have_partial_symbols ())
2190 throw_error (NOT_FOUND_ERROR
,
2191 _("No symbol table is loaded. "
2192 "Use the \"file\" command."));
2193 throw_error (NOT_FOUND_ERROR
, _("No source file named %s."), copy
);
2196 /* Discard the file name from the arg. */
2200 *argptr
= skip_spaces (p1
+ 1);
2202 discard_cleanups (outer
);
2203 *user_filename
= copy
;
2207 /* A callback used by iterate_over_all_matching_symtabs that collects
2208 symbols for find_function_symbols. */
2211 collect_function_symbols (struct symbol
*sym
, void *arg
)
2213 VEC (symbolp
) **syms
= arg
;
2215 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2216 VEC_safe_push (symbolp
, *syms
, sym
);
2221 /* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR
2222 and return the symbol. If not found, return NULL. */
2224 static VEC (symbolp
) *
2225 find_function_symbols (char **argptr
, char *p
, int is_quote_enclosed
,
2226 char **user_function
)
2230 VEC (symbolp
) *result
= NULL
;
2233 while (p
!= *argptr
&& p
[-1] == ' ')
2235 if ((*p
== '"') && is_quote_enclosed
)
2237 copy
= (char *) xmalloc (p
- *argptr
+ 1);
2238 *user_function
= copy
;
2239 memcpy (copy
, *argptr
, p
- *argptr
);
2240 /* It may have the ending quote right after the file name. */
2241 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
2242 || copy
[p
- *argptr
- 1] == '\'')
2243 copy
[p
- *argptr
- 1] = 0;
2245 copy
[p
- *argptr
] = 0;
2247 iterate_over_all_matching_symtabs (copy
, VAR_DOMAIN
,
2248 collect_function_symbols
, &result
, NULL
);
2250 if (VEC_empty (symbolp
, result
))
2251 VEC_free (symbolp
, result
);
2254 /* Discard the file name from the arg. */
2255 *argptr
= skip_spaces (p1
+ 1);
2263 /* A helper for decode_all_digits that handles the 'list_mode' case. */
2266 decode_digits_list_mode (struct linespec_state
*self
,
2267 struct symtabs_and_lines
*values
,
2268 struct symtab_and_line val
)
2273 gdb_assert (self
->list_mode
);
2275 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2277 /* The logic above should ensure this. */
2278 gdb_assert (elt
!= NULL
);
2280 set_current_program_space (SYMTAB_PSPACE (elt
));
2282 /* Simplistic search just for the list command. */
2283 val
.symtab
= find_line_symtab (elt
, val
.line
, NULL
, NULL
);
2284 if (val
.symtab
== NULL
)
2286 val
.pspace
= SYMTAB_PSPACE (elt
);
2288 val
.explicit_line
= 1;
2290 add_sal_to_sals (self
, values
, &val
, NULL
);
2294 /* A helper for decode_all_digits that iterates over the symtabs,
2295 adding lines to the VEC. */
2298 decode_digits_ordinary (struct linespec_state
*self
,
2300 struct symtabs_and_lines
*sals
,
2301 struct linetable_entry
**best_entry
)
2306 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2309 VEC (CORE_ADDR
) *pcs
;
2312 /* The logic above should ensure this. */
2313 gdb_assert (elt
!= NULL
);
2315 set_current_program_space (SYMTAB_PSPACE (elt
));
2317 pcs
= find_pcs_for_symtab_line (elt
, line
, best_entry
);
2318 for (i
= 0; VEC_iterate (CORE_ADDR
, pcs
, i
, pc
); ++i
)
2320 struct symtab_and_line sal
;
2323 sal
.pspace
= SYMTAB_PSPACE (elt
);
2327 add_sal_to_sals_basic (sals
, &sal
);
2330 VEC_free (CORE_ADDR
, pcs
);
2334 /* This decodes a line where the argument is all digits (possibly
2335 preceded by a sign). Q should point to the end of those digits;
2336 the other arguments are as usual. */
2338 static struct symtabs_and_lines
2339 decode_all_digits (struct linespec_state
*self
,
2343 struct symtabs_and_lines values
;
2344 struct symtab_and_line val
;
2345 int use_default
= 0;
2346 char *saved_arg
= *argptr
;
2358 /* This is where we need to make sure that we have good defaults.
2359 We must guarantee that this section of code is never executed
2360 when we are called with just a function name, since
2361 set_default_source_symtab_and_line uses
2362 select_source_symtab that calls us with such an argument. */
2364 if (VEC_length (symtab_p
, self
->file_symtabs
) == 1
2365 && VEC_index (symtab_p
, self
->file_symtabs
, 0) == NULL
)
2367 set_current_program_space (self
->program_space
);
2369 /* Make sure we have at least a default source file. */
2370 set_default_source_symtab_and_line ();
2371 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
2372 VEC_pop (symtab_p
, self
->file_symtabs
);
2373 VEC_free (symtab_p
, self
->file_symtabs
);
2375 = collect_symtabs_from_filename (self
->default_symtab
->filename
);
2379 if (**argptr
== '+')
2380 sign
= plus
, (*argptr
)++;
2381 else if (**argptr
== '-')
2382 sign
= minus
, (*argptr
)++;
2383 val
.line
= atoi (*argptr
);
2390 val
.line
= self
->default_line
+ val
.line
;
2396 val
.line
= self
->default_line
- val
.line
;
2401 break; /* No need to adjust val.line. */
2404 *argptr
= skip_spaces (q
);
2406 if (self
->list_mode
)
2407 decode_digits_list_mode (self
, &values
, val
);
2410 struct linetable_entry
*best_entry
= NULL
;
2412 struct block
**blocks
;
2413 struct cleanup
*cleanup
;
2414 struct symtabs_and_lines intermediate_results
;
2417 intermediate_results
.sals
= NULL
;
2418 intermediate_results
.nelts
= 0;
2420 decode_digits_ordinary (self
, val
.line
, &intermediate_results
,
2422 if (intermediate_results
.nelts
== 0 && best_entry
!= NULL
)
2423 decode_digits_ordinary (self
, best_entry
->line
, &intermediate_results
,
2426 cleanup
= make_cleanup (xfree
, intermediate_results
.sals
);
2428 /* For optimized code, compiler can scatter one source line
2429 accross disjoint ranges of PC values, even when no duplicate
2430 functions or inline functions are involved. For example,
2431 'for (;;)' inside non-template non-inline non-ctor-or-dtor
2432 function can result in two PC ranges. In this case, we don't
2433 want to set breakpoint on first PC of each range. To filter
2434 such cases, we use containing blocks -- for each PC found
2435 above we see if there are other PCs that are in the same
2436 block. If yes, the other PCs are filtered out. */
2438 filter
= xmalloc (intermediate_results
.nelts
* sizeof (int));
2439 make_cleanup (xfree
, filter
);
2440 blocks
= xmalloc (intermediate_results
.nelts
* sizeof (struct block
*));
2441 make_cleanup (xfree
, blocks
);
2443 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2445 set_current_program_space (intermediate_results
.sals
[i
].pspace
);
2448 blocks
[i
] = block_for_pc_sect (intermediate_results
.sals
[i
].pc
,
2449 intermediate_results
.sals
[i
].section
);
2452 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2454 if (blocks
[i
] != NULL
)
2455 for (j
= i
+ 1; j
< intermediate_results
.nelts
; ++j
)
2457 if (blocks
[j
] == blocks
[i
])
2465 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2468 struct symbol
*sym
= (blocks
[i
]
2469 ? block_containing_function (blocks
[i
])
2472 if (self
->funfirstline
)
2473 skip_prologue_sal (&intermediate_results
.sals
[i
]);
2474 /* Make sure the line matches the request, not what was
2476 intermediate_results
.sals
[i
].line
= val
.line
;
2477 add_sal_to_sals (self
, &values
, &intermediate_results
.sals
[i
],
2478 sym
? SYMBOL_NATURAL_NAME (sym
) : NULL
);
2481 do_cleanups (cleanup
);
2484 if (values
.nelts
== 0)
2486 if (self
->user_filename
)
2487 throw_error (NOT_FOUND_ERROR
, _("No line %d in file \"%s\"."),
2488 val
.line
, self
->user_filename
);
2490 throw_error (NOT_FOUND_ERROR
, _("No line %d in the current file."),
2494 if (self
->canonical
)
2496 char *copy
= savestring (saved_arg
, q
- saved_arg
);
2498 self
->canonical
->pre_expanded
= 1;
2499 gdb_assert (self
->user_filename
|| use_default
);
2500 self
->canonical
->addr_string
2501 = xstrprintf ("%s:%s", (self
->user_filename
2502 ? self
->user_filename
2503 : self
->default_symtab
->filename
),
2513 /* Decode a linespec starting with a dollar sign. */
2515 static struct symtabs_and_lines
2516 decode_dollar (struct linespec_state
*self
, char *copy
)
2520 struct symtabs_and_lines values
;
2521 struct symtab_and_line val
;
2524 struct minimal_symbol
*msymbol
;
2528 p
= (copy
[1] == '$') ? copy
+ 2 : copy
+ 1;
2529 while (*p
>= '0' && *p
<= '9')
2531 if (!*p
) /* Reached end of token without hitting non-digit. */
2533 /* We have a value history reference. */
2534 struct value
*val_history
;
2536 sscanf ((copy
[1] == '$') ? copy
+ 2 : copy
+ 1, "%d", &index
);
2537 val_history
= access_value_history ((copy
[1] == '$') ? -index
: index
);
2538 if (TYPE_CODE (value_type (val_history
)) != TYPE_CODE_INT
)
2539 error (_("History values used in line "
2540 "specs must have integer values."));
2541 valx
= value_as_long (val_history
);
2545 /* Not all digits -- may be user variable/function or a
2546 convenience variable. */
2548 volatile struct gdb_exception exc
;
2550 /* Avoid "may be used uninitialized" warning. */
2554 TRY_CATCH (exc
, RETURN_MASK_ERROR
)
2556 values
= decode_variable (self
, copy
);
2559 if (exc
.reason
== 0)
2562 if (exc
.error
!= NOT_FOUND_ERROR
)
2563 throw_exception (exc
);
2565 /* Not a user variable or function -- must be convenience variable. */
2566 if (!get_internalvar_integer (lookup_internalvar (copy
+ 1), &valx
))
2567 error (_("Convenience variables used in line "
2568 "specs must have integer values."));
2576 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2580 elt
= self
->default_symtab
;
2581 set_current_program_space (self
->program_space
);
2584 set_current_program_space (SYMTAB_PSPACE (elt
));
2586 /* Either history value or convenience value from above, in valx. */
2590 val
.pspace
= elt
? SYMTAB_PSPACE (elt
) : current_program_space
;
2592 add_sal_to_sals (self
, &values
, &val
, NULL
);
2595 if (self
->canonical
)
2597 self
->canonical
->pre_expanded
= 1;
2598 if (self
->user_filename
)
2599 self
->canonical
->addr_string
= xstrprintf ("%s:%s",
2600 self
->user_filename
, copy
);
2602 self
->canonical
->addr_string
= xstrdup (copy
);
2610 /* A helper for decode_line_1 that tries to find a label. The label
2611 is searched for in the current block.
2612 FUNCTION_SYMBOLS is a list of the enclosing functions; or NULL if none
2614 COPY is the name of the label to find.
2615 CANONICAL is the same as the "canonical" argument to decode_line_1.
2616 RESULT is a pointer to a symtabs_and_lines structure which will be
2617 filled in on success.
2618 This function returns 1 if a label was found, 0 otherwise. */
2621 decode_label (struct linespec_state
*self
,
2622 VEC (symbolp
) *function_symbols
, char *copy
,
2623 struct symtabs_and_lines
*result
)
2625 struct symbol
*fn_sym
;
2628 if (function_symbols
== NULL
)
2630 struct block
*block
;
2632 struct symtab_and_line sal
;
2633 struct symtabs_and_lines values
;
2638 set_current_program_space (self
->program_space
);
2639 block
= get_search_block (NULL
);
2642 block
&& !BLOCK_FUNCTION (block
);
2643 block
= BLOCK_SUPERBLOCK (block
))
2647 fn_sym
= BLOCK_FUNCTION (block
);
2649 sym
= lookup_symbol (copy
, block
, LABEL_DOMAIN
, 0);
2654 symbol_to_sal (&sal
, self
->funfirstline
, sym
);
2655 add_sal_to_sals (self
, &values
, &sal
,
2656 SYMBOL_NATURAL_NAME (fn_sym
));
2658 if (self
->canonical
)
2660 self
->canonical
->special_display
= 1;
2661 self
->canonical
->addr_string
2662 = xstrprintf ("%s:%s", SYMBOL_NATURAL_NAME (fn_sym
),
2671 result
->sals
= NULL
;
2674 for (ix
= 0; VEC_iterate (symbolp
, function_symbols
, ix
, fn_sym
); ++ix
)
2676 struct block
*block
;
2679 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym
)));
2680 block
= SYMBOL_BLOCK_VALUE (fn_sym
);
2681 sym
= lookup_symbol (copy
, block
, LABEL_DOMAIN
, 0);
2685 struct symtab_and_line sal
;
2688 symbol_to_sal (&sal
, self
->funfirstline
, sym
);
2689 symname
= xstrprintf ("%s:%s",
2690 SYMBOL_NATURAL_NAME (fn_sym
),
2691 SYMBOL_NATURAL_NAME (sym
));
2692 add_sal_to_sals (self
, result
, &sal
, symname
);
2697 if (self
->canonical
&& result
->nelts
> 0)
2699 self
->canonical
->pre_expanded
= 1;
2700 self
->canonical
->special_display
= 1;
2702 gdb_assert (self
->user_function
);
2703 self
->canonical
->addr_string
2704 = xstrprintf ("%s:%s", self
->user_function
, copy
);
2707 return result
->nelts
> 0;
2710 /* A callback used to possibly add a symbol to the results. */
2713 collect_symbols (struct symbol
*sym
, void *data
)
2715 struct collect_info
*info
= data
;
2716 struct symtab_and_line sal
;
2718 if (symbol_to_sal (&sal
, info
->state
->funfirstline
, sym
)
2719 && maybe_add_address (info
->state
->addr_set
,
2720 SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
)),
2722 add_sal_to_sals (info
->state
, &info
->result
, &sal
,
2723 SYMBOL_NATURAL_NAME (sym
));
2728 /* We've found a minimal symbol MSYMBOL to associate with our
2729 linespec; add it to the result symtabs_and_lines. */
2732 minsym_found (struct linespec_state
*self
, struct objfile
*objfile
,
2733 struct minimal_symbol
*msymbol
,
2734 struct symtabs_and_lines
*result
)
2736 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2738 struct symtab_and_line sal
;
2740 sal
= find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
2741 (struct obj_section
*) 0, 0);
2742 sal
.section
= SYMBOL_OBJ_SECTION (msymbol
);
2744 /* The minimal symbol might point to a function descriptor;
2745 resolve it to the actual code address instead. */
2746 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, sal
.pc
, ¤t_target
);
2748 sal
= find_pc_sect_line (pc
, NULL
, 0);
2750 if (self
->funfirstline
)
2751 skip_prologue_sal (&sal
);
2753 if (maybe_add_address (self
->addr_set
, objfile
->pspace
, sal
.pc
))
2754 add_sal_to_sals (self
, result
, &sal
, SYMBOL_NATURAL_NAME (msymbol
));
2757 /* A helper struct which just holds a minimal symbol and the object
2758 file from which it came. */
2760 typedef struct minsym_and_objfile
2762 struct minimal_symbol
*minsym
;
2763 struct objfile
*objfile
;
2764 } minsym_and_objfile_d
;
2766 DEF_VEC_O (minsym_and_objfile_d
);
2768 /* A helper struct to pass some data through
2769 iterate_over_minimal_symbols. */
2771 struct collect_minsyms
2773 /* The objfile we're examining. */
2774 struct objfile
*objfile
;
2776 /* The funfirstline setting from the initial call. */
2779 /* The list_mode setting from the initial call. */
2782 /* The resulting symbols. */
2783 VEC (minsym_and_objfile_d
) *msyms
;
2786 /* A helper function to classify a minimal_symbol_type according to
2790 classify_mtype (enum minimal_symbol_type t
)
2797 /* Intermediate priority. */
2800 case mst_solib_trampoline
:
2801 /* Lowest priority. */
2805 /* Highest priority. */
2810 /* Callback for qsort that sorts symbols by priority. */
2813 compare_msyms (const void *a
, const void *b
)
2815 const minsym_and_objfile_d
*moa
= a
;
2816 const minsym_and_objfile_d
*mob
= b
;
2817 enum minimal_symbol_type ta
= MSYMBOL_TYPE (moa
->minsym
);
2818 enum minimal_symbol_type tb
= MSYMBOL_TYPE (mob
->minsym
);
2820 return classify_mtype (ta
) - classify_mtype (tb
);
2823 /* Callback for iterate_over_minimal_symbols that adds the symbol to
2827 add_minsym (struct minimal_symbol
*minsym
, void *d
)
2829 struct collect_minsyms
*info
= d
;
2830 minsym_and_objfile_d mo
;
2832 /* Exclude data symbols when looking for breakpoint locations. */
2833 if (!info
->list_mode
)
2834 switch (minsym
->type
)
2836 case mst_slot_got_plt
:
2843 /* Make sure this minsym is not a function descriptor
2844 before we decide to discard it. */
2845 struct gdbarch
*gdbarch
= info
->objfile
->gdbarch
;
2846 CORE_ADDR addr
= gdbarch_convert_from_func_ptr_addr
2847 (gdbarch
, SYMBOL_VALUE_ADDRESS (minsym
),
2850 if (addr
== SYMBOL_VALUE_ADDRESS (minsym
))
2856 mo
.objfile
= info
->objfile
;
2857 VEC_safe_push (minsym_and_objfile_d
, info
->msyms
, &mo
);
2860 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
2861 is not NULL, the search is restricted to just that program
2865 search_minsyms_for_name (struct collect_info
*info
, const char *name
,
2866 struct program_space
*search_pspace
)
2868 struct objfile
*objfile
;
2869 struct program_space
*pspace
;
2871 ALL_PSPACES (pspace
)
2873 struct collect_minsyms local
;
2874 struct cleanup
*cleanup
;
2876 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
2878 if (pspace
->executing_startup
)
2881 set_current_program_space (pspace
);
2883 memset (&local
, 0, sizeof (local
));
2884 local
.funfirstline
= info
->state
->funfirstline
;
2885 local
.list_mode
= info
->state
->list_mode
;
2887 cleanup
= make_cleanup (VEC_cleanup (minsym_and_objfile_d
),
2890 ALL_OBJFILES (objfile
)
2892 local
.objfile
= objfile
;
2893 iterate_over_minimal_symbols (objfile
, name
, add_minsym
, &local
);
2896 if (!VEC_empty (minsym_and_objfile_d
, local
.msyms
))
2900 minsym_and_objfile_d
*item
;
2902 qsort (VEC_address (minsym_and_objfile_d
, local
.msyms
),
2903 VEC_length (minsym_and_objfile_d
, local
.msyms
),
2904 sizeof (minsym_and_objfile_d
),
2907 /* Now the minsyms are in classification order. So, we walk
2908 over them and process just the minsyms with the same
2909 classification as the very first minsym in the list. */
2910 item
= VEC_index (minsym_and_objfile_d
, local
.msyms
, 0);
2911 classification
= classify_mtype (MSYMBOL_TYPE (item
->minsym
));
2914 VEC_iterate (minsym_and_objfile_d
, local
.msyms
, ix
, item
);
2917 if (classify_mtype (MSYMBOL_TYPE (item
->minsym
)) != classification
)
2920 minsym_found (info
->state
, item
->objfile
, item
->minsym
,
2925 do_cleanups (cleanup
);
2929 /* A helper function to add all symbols matching NAME to INFO. If
2930 PSPACE is not NULL, the search is restricted to just that program
2934 add_matching_symbols_to_info (const char *name
,
2935 struct collect_info
*info
,
2936 struct program_space
*pspace
)
2941 for (ix
= 0; VEC_iterate (symtab_p
, info
->state
->file_symtabs
, ix
, elt
); ++ix
)
2947 iterate_over_all_matching_symtabs (name
, VAR_DOMAIN
,
2948 collect_symbols
, info
,
2950 search_minsyms_for_name (info
, name
, pspace
);
2952 else if (pspace
== NULL
|| pspace
== SYMTAB_PSPACE (elt
))
2954 /* Program spaces that are executing startup should have
2955 been filtered out earlier. */
2956 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
2957 set_current_program_space (SYMTAB_PSPACE (elt
));
2958 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt
), name
,
2959 VAR_DOMAIN
, collect_symbols
,
2965 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
2966 look in that symtab's static variables first. */
2968 static struct symtabs_and_lines
2969 decode_variable (struct linespec_state
*self
, char *copy
)
2971 struct collect_info info
;
2972 const char *lookup_name
;
2974 struct cleanup
*cleanup
;
2977 info
.result
.sals
= NULL
;
2978 info
.result
.nelts
= 0;
2980 cleanup
= demangle_for_lookup (copy
, current_language
->la_language
,
2982 if (current_language
->la_language
== language_ada
)
2984 /* In Ada, the symbol lookups are performed using the encoded
2985 name rather than the demangled name. */
2986 lookup_name
= ada_name_for_lookup (copy
);
2987 make_cleanup (xfree
, (void *) lookup_name
);
2990 canon
= cp_canonicalize_string_no_typedefs (lookup_name
);
2993 make_cleanup (xfree
, canon
);
2994 lookup_name
= canon
;
2997 add_matching_symbols_to_info (lookup_name
, &info
, NULL
);
2999 if (info
.result
.nelts
> 0)
3001 if (self
->canonical
)
3003 self
->canonical
->pre_expanded
= 1;
3004 if (self
->user_filename
)
3005 self
->canonical
->addr_string
3006 = xstrprintf ("%s:%s", self
->user_filename
, copy
);
3008 self
->canonical
->addr_string
= xstrdup (copy
);
3013 if (!have_full_symbols ()
3014 && !have_partial_symbols ()
3015 && !have_minimal_symbols ())
3016 throw_error (NOT_FOUND_ERROR
,
3017 _("No symbol table is loaded. Use the \"file\" command."));
3018 if (self
->user_filename
)
3019 throw_error (NOT_FOUND_ERROR
, _("Function \"%s\" not defined in \"%s\"."),
3020 copy
, self
->user_filename
);
3022 throw_error (NOT_FOUND_ERROR
, _("Function \"%s\" not defined."), copy
);
3028 /* Now come some functions that are called from multiple places within
3032 symbol_to_sal (struct symtab_and_line
*result
,
3033 int funfirstline
, struct symbol
*sym
)
3035 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3037 *result
= find_function_start_sal (sym
, funfirstline
);
3042 if (SYMBOL_CLASS (sym
) == LOC_LABEL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
3045 result
->symtab
= SYMBOL_SYMTAB (sym
);
3046 result
->line
= SYMBOL_LINE (sym
);
3047 result
->pc
= SYMBOL_VALUE_ADDRESS (sym
);
3048 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3049 result
->explicit_pc
= 1;
3052 else if (funfirstline
)
3056 else if (SYMBOL_LINE (sym
) != 0)
3058 /* We know its line number. */
3060 result
->symtab
= SYMBOL_SYMTAB (sym
);
3061 result
->line
= SYMBOL_LINE (sym
);
3062 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3070 /* See the comment in linespec.h. */
3073 init_linespec_result (struct linespec_result
*lr
)
3075 memset (lr
, 0, sizeof (*lr
));
3078 /* See the comment in linespec.h. */
3081 destroy_linespec_result (struct linespec_result
*ls
)
3084 struct linespec_sals
*lsal
;
3086 xfree (ls
->addr_string
);
3087 for (i
= 0; VEC_iterate (linespec_sals
, ls
->sals
, i
, lsal
); ++i
)
3089 xfree (lsal
->canonical
);
3090 xfree (lsal
->sals
.sals
);
3092 VEC_free (linespec_sals
, ls
->sals
);
3095 /* Cleanup function for a linespec_result. */
3098 cleanup_linespec_result (void *a
)
3100 destroy_linespec_result (a
);
3103 /* See the comment in linespec.h. */
3106 make_cleanup_destroy_linespec_result (struct linespec_result
*ls
)
3108 return make_cleanup (cleanup_linespec_result
, ls
);