1 /* Parser for linespec for the GNU debugger, GDB.
3 Copyright (C) 1986-2005, 2007-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
29 #include "completer.h"
31 #include "cp-support.h"
32 #include "parser-defs.h"
34 #include "objc-lang.h"
36 #include "exceptions.h"
39 #include "mi/mi-cmds.h"
41 #include "arch-utils.h"
43 #include "cli/cli-utils.h"
44 #include "filenames.h"
47 typedef struct symtab
*symtab_p
;
50 typedef struct symbol
*symbolp
;
53 typedef struct type
*typep
;
56 /* An address entry is used to ensure that any given location is only
57 added to the result a single time. It holds an address and the
58 program space from which the address came. */
62 struct program_space
*pspace
;
66 /* An instance of this is used to keep all state while linespec
67 operates. This instance is passed around as a 'this' pointer to
68 the various implementation methods. */
72 /* The program space as seen when the module was entered. */
73 struct program_space
*program_space
;
75 /* The default symtab to use, if no other symtab is specified. */
76 struct symtab
*default_symtab
;
78 /* The default line to use. */
81 /* If the linespec started with "FILE:", this holds all the matching
82 symtabs. Otherwise, it will hold a single NULL entry, meaning
83 that the default symtab should be used. */
84 VEC (symtab_p
) *file_symtabs
;
86 /* If the linespec started with "FILE:", this holds an xmalloc'd
90 /* If the linespec is "FUNCTION:LABEL", this holds an xmalloc'd copy
94 /* The 'funfirstline' value that was passed in to decode_line_1 or
98 /* Nonzero if we are running in 'list' mode; see decode_line_list. */
101 /* The 'canonical' value passed to decode_line_full, or NULL. */
102 struct linespec_result
*canonical
;
104 /* Canonical strings that mirror the symtabs_and_lines result. */
105 char **canonical_names
;
107 /* This is a set of address_entry objects which is used to prevent
108 duplicate symbols from being entered into the result. */
112 /* This is a helper object that is used when collecting symbols into a
117 /* The linespec object in use. */
118 struct linespec_state
*state
;
120 /* The result being accumulated. */
121 struct symtabs_and_lines result
;
124 /* Prototypes for local functions. */
126 static void initialize_defaults (struct symtab
**default_symtab
,
129 static struct symtabs_and_lines
decode_indirect (struct linespec_state
*self
,
132 static char *locate_first_half (char **argptr
, int *is_quote_enclosed
);
134 static struct symtabs_and_lines
decode_objc (struct linespec_state
*self
,
137 static struct symtabs_and_lines
decode_compound (struct linespec_state
*self
,
142 static VEC (symbolp
) *lookup_prefix_sym (char **argptr
, char *p
,
146 static struct symtabs_and_lines
find_method (struct linespec_state
*self
,
149 const char *class_name
,
150 VEC (symbolp
) *sym_classes
);
152 static void cplusplus_error (const char *name
, const char *fmt
, ...)
153 ATTRIBUTE_NORETURN
ATTRIBUTE_PRINTF (2, 3);
155 static char *find_toplevel_char (char *s
, char c
);
157 static int is_objc_method_format (const char *s
);
159 static VEC (symtab_p
) *symtabs_from_filename (char **argptr
,
160 char *p
, int is_quote_enclosed
,
161 char **user_filename
);
163 static VEC (symbolp
) *find_function_symbols (char **argptr
, char *p
,
164 int is_quote_enclosed
,
165 char **user_function
);
167 static struct symtabs_and_lines
decode_all_digits (struct linespec_state
*self
,
171 static struct symtabs_and_lines
decode_dollar (struct linespec_state
*self
,
174 static int decode_label (struct linespec_state
*self
,
175 VEC (symbolp
) *function_symbols
,
177 struct symtabs_and_lines
*result
);
179 static struct symtabs_and_lines
decode_variable (struct linespec_state
*self
,
182 static int symbol_to_sal (struct symtab_and_line
*result
,
183 int funfirstline
, struct symbol
*sym
);
185 static void add_matching_symbols_to_info (const char *name
,
186 struct collect_info
*info
,
187 struct program_space
*pspace
);
189 static void add_all_symbol_names_from_pspace (struct collect_info
*info
,
190 struct program_space
*pspace
,
191 VEC (const_char_ptr
) *names
);
193 /* Helper functions. */
195 /* Add SAL to SALS. */
198 add_sal_to_sals_basic (struct symtabs_and_lines
*sals
,
199 struct symtab_and_line
*sal
)
202 sals
->sals
= xrealloc (sals
->sals
, sals
->nelts
* sizeof (sals
->sals
[0]));
203 sals
->sals
[sals
->nelts
- 1] = *sal
;
206 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
207 the new sal, if needed. If not NULL, SYMNAME is the name of the
208 symbol to use when constructing the new canonical name. */
211 add_sal_to_sals (struct linespec_state
*self
,
212 struct symtabs_and_lines
*sals
,
213 struct symtab_and_line
*sal
,
216 add_sal_to_sals_basic (sals
, sal
);
220 char *canonical_name
= NULL
;
222 self
->canonical_names
= xrealloc (self
->canonical_names
,
223 sals
->nelts
* sizeof (char *));
224 if (sal
->symtab
&& sal
->symtab
->filename
)
226 char *filename
= sal
->symtab
->filename
;
228 /* Note that the filter doesn't have to be a valid linespec
229 input. We only apply the ":LINE" treatment to Ada for
231 if (symname
!= NULL
&& sal
->line
!= 0
232 && current_language
->la_language
== language_ada
)
233 canonical_name
= xstrprintf ("%s:%s:%d", filename
, symname
,
235 else if (symname
!= NULL
)
236 canonical_name
= xstrprintf ("%s:%s", filename
, symname
);
238 canonical_name
= xstrprintf ("%s:%d", filename
, sal
->line
);
241 self
->canonical_names
[sals
->nelts
- 1] = canonical_name
;
245 /* A hash function for address_entry. */
248 hash_address_entry (const void *p
)
250 const struct address_entry
*aep
= p
;
253 hash
= iterative_hash_object (aep
->pspace
, 0);
254 return iterative_hash_object (aep
->addr
, hash
);
257 /* An equality function for address_entry. */
260 eq_address_entry (const void *a
, const void *b
)
262 const struct address_entry
*aea
= a
;
263 const struct address_entry
*aeb
= b
;
265 return aea
->pspace
== aeb
->pspace
&& aea
->addr
== aeb
->addr
;
268 /* Check whether the address, represented by PSPACE and ADDR, is
269 already in the set. If so, return 0. Otherwise, add it and return
273 maybe_add_address (htab_t set
, struct program_space
*pspace
, CORE_ADDR addr
)
275 struct address_entry e
, *p
;
280 slot
= htab_find_slot (set
, &e
, INSERT
);
284 p
= XNEW (struct address_entry
);
285 memcpy (p
, &e
, sizeof (struct address_entry
));
291 /* Issue a helpful hint on using the command completion feature on
292 single quoted demangled C++ symbols as part of the completion
296 cplusplus_error (const char *name
, const char *fmt
, ...)
298 struct ui_file
*tmp_stream
;
301 tmp_stream
= mem_fileopen ();
302 make_cleanup_ui_file_delete (tmp_stream
);
307 va_start (args
, fmt
);
308 vfprintf_unfiltered (tmp_stream
, fmt
, args
);
312 while (*name
== '\'')
314 fprintf_unfiltered (tmp_stream
,
315 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
316 "(Note leading single quote.)"),
319 message
= ui_file_xstrdup (tmp_stream
, NULL
);
320 make_cleanup (xfree
, message
);
321 throw_error (NOT_FOUND_ERROR
, "%s", message
);
324 /* A helper for iterate_over_all_matching_symtabs that is passed as a
325 callback to the expand_symtabs_matching method. */
328 iterate_name_matcher (const struct language_defn
*language
,
329 const char *name
, void *d
)
331 const char **dname
= d
;
333 if (language
->la_symbol_name_compare (name
, *dname
) == 0)
338 /* A helper that walks over all matching symtabs in all objfiles and
339 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
340 not NULL, then the search is restricted to just that program
344 iterate_over_all_matching_symtabs (const char *name
,
345 const domain_enum domain
,
346 int (*callback
) (struct symbol
*, void *),
348 struct program_space
*search_pspace
)
350 struct objfile
*objfile
;
351 struct program_space
*pspace
;
355 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
357 if (pspace
->executing_startup
)
360 set_current_program_space (pspace
);
362 ALL_OBJFILES (objfile
)
364 struct symtab
*symtab
;
367 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, NULL
,
368 iterate_name_matcher
,
372 ALL_OBJFILE_SYMTABS (objfile
, symtab
)
378 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
379 LA_ITERATE_OVER_SYMBOLS (block
, name
, domain
, callback
, data
);
386 /* Returns the block to be used for symbol searches for the given SYMTAB,
387 which may be NULL. */
389 static struct block
*
390 get_search_block (struct symtab
*symtab
)
395 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
398 enum language save_language
;
400 /* get_selected_block can change the current language when there is
401 no selected frame yet. */
402 save_language
= current_language
->la_language
;
403 block
= get_selected_block (0);
404 set_language (save_language
);
410 /* A helper for find_method. This finds all methods in type T which
411 match NAME. It adds resulting symbol names to RESULT_NAMES, and
412 adds T's direct superclasses to SUPERCLASSES. */
415 find_methods (struct type
*t
, const char *name
,
416 VEC (const_char_ptr
) **result_names
,
417 VEC (typep
) **superclasses
)
421 char *class_name
= type_name_no_tag (t
);
424 /* Ignore this class if it doesn't have a name. This is ugly, but
425 unless we figure out how to get the physname without the name of
426 the class, then the loop can't do any good. */
430 int name_len
= strlen (name
);
434 /* Loop over each method name. At this level, all overloads of a name
435 are counted as a single name. There is an inner loop which loops over
438 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
442 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
445 if (strncmp (method_name
, "__", 2) == 0 ||
446 strncmp (method_name
, "op", 2) == 0 ||
447 strncmp (method_name
, "type", 4) == 0)
449 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
450 method_name
= dem_opname
;
451 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
452 method_name
= dem_opname
;
455 if (strcmp_iw (method_name
, name
) == 0)
459 for (field_counter
= (TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
)
465 const char *phys_name
;
467 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
468 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
470 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
471 VEC_safe_push (const_char_ptr
, *result_names
, phys_name
);
477 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
478 VEC_safe_push (typep
, *superclasses
, TYPE_BASECLASS (t
, ibase
));
481 /* Find an instance of the character C in the string S that is outside
482 of all parenthesis pairs, single-quoted strings, and double-quoted
483 strings. Also, ignore the char within a template name, like a ','
484 within foo<int, int>. */
487 find_toplevel_char (char *s
, char c
)
489 int quoted
= 0; /* zero if we're not in quotes;
490 '"' if we're in a double-quoted string;
491 '\'' if we're in a single-quoted string. */
492 int depth
= 0; /* Number of unclosed parens we've seen. */
495 for (scan
= s
; *scan
; scan
++)
501 else if (*scan
== '\\' && *(scan
+ 1))
504 else if (*scan
== c
&& ! quoted
&& depth
== 0)
506 else if (*scan
== '"' || *scan
== '\'')
508 else if (*scan
== '(' || *scan
== '<')
510 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
517 /* Determines if the gives string corresponds to an Objective-C method
518 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
519 are allowed to have spaces and parentheses in them. */
522 is_objc_method_format (const char *s
)
524 if (s
== NULL
|| *s
== '\0')
526 /* Handle arguments with the format FILENAME:SYMBOL. */
527 if ((s
[0] == ':') && (strchr ("+-", s
[1]) != NULL
)
528 && (s
[2] == '[') && strchr(s
, ']'))
530 /* Handle arguments that are just SYMBOL. */
531 else if ((strchr ("+-", s
[0]) != NULL
) && (s
[1] == '[') && strchr(s
, ']'))
536 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
537 and store the result in SELF->CANONICAL. */
540 filter_results (struct linespec_state
*self
,
541 struct symtabs_and_lines
*result
,
542 VEC (const_char_ptr
) *filters
)
547 for (i
= 0; VEC_iterate (const_char_ptr
, filters
, i
, name
); ++i
)
549 struct linespec_sals lsal
;
552 memset (&lsal
, 0, sizeof (lsal
));
554 for (j
= 0; j
< result
->nelts
; ++j
)
556 if (strcmp (name
, self
->canonical_names
[j
]) == 0)
557 add_sal_to_sals_basic (&lsal
.sals
, &result
->sals
[j
]);
560 if (lsal
.sals
.nelts
> 0)
562 lsal
.canonical
= xstrdup (name
);
563 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
567 self
->canonical
->pre_expanded
= 0;
570 /* Store RESULT into SELF->CANONICAL. */
573 convert_results_to_lsals (struct linespec_state
*self
,
574 struct symtabs_and_lines
*result
)
576 struct linespec_sals lsal
;
578 lsal
.canonical
= NULL
;
580 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
583 /* Handle multiple results in RESULT depending on SELECT_MODE. This
584 will either return normally, throw an exception on multiple
585 results, or present a menu to the user. On return, the SALS vector
586 in SELF->CANONICAL is set up properly. */
589 decode_line_2 (struct linespec_state
*self
,
590 struct symtabs_and_lines
*result
,
591 const char *select_mode
)
596 struct cleanup
*old_chain
;
597 VEC (const_char_ptr
) *item_names
= NULL
, *filters
= NULL
;
598 struct get_number_or_range_state state
;
600 gdb_assert (select_mode
!= multiple_symbols_all
);
601 gdb_assert (self
->canonical
!= NULL
);
603 old_chain
= make_cleanup (VEC_cleanup (const_char_ptr
), &item_names
);
604 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
605 for (i
= 0; i
< result
->nelts
; ++i
)
610 gdb_assert (self
->canonical_names
[i
] != NULL
);
611 for (j
= 0; VEC_iterate (const_char_ptr
, item_names
, j
, iter
); ++j
)
613 if (strcmp (iter
, self
->canonical_names
[i
]) == 0)
621 VEC_safe_push (const_char_ptr
, item_names
, self
->canonical_names
[i
]);
624 if (select_mode
== multiple_symbols_cancel
625 && VEC_length (const_char_ptr
, item_names
) > 1)
626 error (_("canceled because the command is ambiguous\n"
627 "See set/show multiple-symbol."));
629 if (select_mode
== multiple_symbols_all
630 || VEC_length (const_char_ptr
, item_names
) == 1)
632 do_cleanups (old_chain
);
633 convert_results_to_lsals (self
, result
);
637 printf_unfiltered (_("[0] cancel\n[1] all\n"));
638 for (i
= 0; VEC_iterate (const_char_ptr
, item_names
, i
, iter
); ++i
)
639 printf_unfiltered ("[%d] %s\n", i
+ 2, iter
);
641 prompt
= getenv ("PS2");
646 args
= command_line_input (prompt
, 0, "overload-choice");
648 if (args
== 0 || *args
== 0)
649 error_no_arg (_("one or more choice numbers"));
651 init_number_or_range (&state
, args
);
652 while (!state
.finished
)
656 num
= get_number_or_range (&state
);
659 error (_("canceled"));
662 /* We intentionally make this result in a single breakpoint,
663 contrary to what older versions of gdb did. The
664 rationale is that this lets a user get the
665 multiple_symbols_all behavior even with the 'ask'
666 setting; and he can get separate breakpoints by entering
667 "2-57" at the query. */
668 do_cleanups (old_chain
);
669 convert_results_to_lsals (self
, result
);
674 if (num
>= VEC_length (const_char_ptr
, item_names
))
675 printf_unfiltered (_("No choice number %d.\n"), num
);
678 const char *elt
= VEC_index (const_char_ptr
, item_names
, num
);
682 VEC_safe_push (const_char_ptr
, filters
, elt
);
683 VEC_replace (const_char_ptr
, item_names
, num
, NULL
);
687 printf_unfiltered (_("duplicate request for %d ignored.\n"),
693 filter_results (self
, result
, filters
);
694 do_cleanups (old_chain
);
697 /* Valid delimiters for linespec keywords "if", "thread" or "task". */
700 is_linespec_boundary (char c
)
702 return c
== ' ' || c
== '\t' || c
== '\0' || c
== ',';
705 /* A helper function for decode_line_1 and friends which skips P
706 past any method overload information at the beginning of P, e.g.,
707 "(const struct foo *)".
709 This function assumes that P has already been validated to contain
710 overload information, and it will assert if *P != '('. */
712 find_method_overload_end (char *p
)
716 gdb_assert (*p
== '(');
736 /* Keep important information used when looking up a name. This includes
737 template parameters, overload information, and important keywords, including
738 the possible Java trailing type. */
741 keep_name_info (char *p
, int on_boundary
)
743 const char *quotes
= get_gdb_completer_quote_characters ();
749 if (strchr (quotes
, *p
))
752 if (*p
== ',' && !nest
)
755 if (on_boundary
&& !nest
)
757 const char *const words
[] = { "if", "thread", "task" };
760 for (wordi
= 0; wordi
< ARRAY_SIZE (words
); wordi
++)
761 if (strncmp (p
, words
[wordi
], strlen (words
[wordi
])) == 0
762 && is_linespec_boundary (p
[strlen (words
[wordi
])]))
764 if (wordi
< ARRAY_SIZE (words
))
768 if (*p
== '(' || *p
== '<' || *p
== '[')
770 else if ((*p
== ')' || *p
== '>' || *p
== ']') && nest
> 0)
775 /* The ',' check could fail on "operator ,". */
776 p
+= cp_validate_operator (p
);
778 on_boundary
= is_linespec_boundary (p
[-1]);
781 while (p
> saved_p
&& is_linespec_boundary (p
[-1]))
788 /* The parser of linespec itself. */
790 /* Parse a string that specifies a line number.
791 Pass the address of a char * variable; that variable will be
792 advanced over the characters actually parsed.
796 LINENUM -- that line number in current file. PC returned is 0.
797 FILE:LINENUM -- that line in that file. PC returned is 0.
798 FUNCTION -- line number of openbrace of that function.
799 PC returned is the start of the function.
800 LABEL -- a label in the current scope
801 VARIABLE -- line number of definition of that variable.
803 FILE:FUNCTION -- likewise, but prefer functions in that file.
804 *EXPR -- line in which address EXPR appears.
806 This may all be followed by an "if EXPR", which we ignore.
808 FUNCTION may be an undebuggable function found in minimal symbol table.
810 If the argument FUNFIRSTLINE is nonzero, we want the first line
811 of real code inside a function when a function is specified, and it is
812 not OK to specify a variable or type to get its line number.
814 DEFAULT_SYMTAB specifies the file to use if none is specified.
815 It defaults to current_source_symtab.
816 DEFAULT_LINE specifies the line number to use for relative
817 line numbers (that start with signs). Defaults to current_source_line.
818 If CANONICAL is non-NULL, store an array of strings containing the canonical
819 line specs there if necessary. Currently overloaded member functions and
820 line numbers or static functions without a filename yield a canonical
821 line spec. The array and the line spec strings are allocated on the heap,
822 it is the callers responsibility to free them.
824 Note that it is possible to return zero for the symtab
825 if no file is validly specified. Callers must check that.
826 Also, the line number returned may be invalid. */
828 /* We allow single quotes in various places. This is a hideous
829 kludge, which exists because the completer can't yet deal with the
830 lack of single quotes. FIXME: write a linespec_completer which we
831 can use as appropriate instead of make_symbol_completion_list. */
833 static struct symtabs_and_lines
834 decode_line_internal (struct linespec_state
*self
, char **argptr
)
840 /* This says whether or not something in *ARGPTR is quoted with
841 completer_quotes (i.e. with single quotes). */
843 /* Is *ARGPTR enclosed in double quotes? */
844 int is_quote_enclosed
;
845 int is_objc_method
= 0;
846 char *saved_arg
= *argptr
;
847 /* If IS_QUOTED, the end of the quoted bit. */
848 char *end_quote
= NULL
;
849 /* Is *ARGPTR enclosed in single quotes? */
850 int is_squote_enclosed
= 0;
851 /* The "first half" of the linespec. */
854 /* If we are parsing `function:label', this holds the symbols
855 matching the function name. */
856 VEC (symbolp
) *function_symbols
= NULL
;
857 /* If FUNCTION_SYMBOLS is not NULL, then this is the exception that
858 was thrown when trying to parse a filename. */
859 volatile struct gdb_exception file_exception
;
861 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
863 /* Defaults have defaults. */
865 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
867 /* See if arg is *PC. */
871 do_cleanups (cleanup
);
872 return decode_indirect (self
, argptr
);
875 is_quoted
= (strchr (get_gdb_completer_quote_characters (),
880 end_quote
= skip_quoted (*argptr
);
881 if (*end_quote
== '\0')
882 is_squote_enclosed
= 1;
885 /* Check to see if it's a multipart linespec (with colons or
888 /* Locate the end of the first half of the linespec.
889 After the call, for instance, if the argptr string is "foo.c:123"
890 p will point at "123". If there is only one part, like "foo", p
891 will point to "". If this is a C++ name, like "A::B::foo", p will
892 point to "::B::foo". Argptr is not changed by this call. */
894 first_half
= p
= locate_first_half (argptr
, &is_quote_enclosed
);
896 /* First things first: if ARGPTR starts with a filename, get its
897 symtab and strip the filename from ARGPTR.
898 Avoid calling symtab_from_filename if we know can,
899 it can be expensive. */
903 TRY_CATCH (file_exception
, RETURN_MASK_ERROR
)
905 self
->file_symtabs
= symtabs_from_filename (argptr
, p
,
907 &self
->user_filename
);
910 if (file_exception
.reason
>= 0)
912 /* Check for single quotes on the non-filename part. */
913 is_quoted
= (**argptr
914 && strchr (get_gdb_completer_quote_characters (),
917 end_quote
= skip_quoted (*argptr
);
919 /* Locate the next "half" of the linespec. */
920 first_half
= p
= locate_first_half (argptr
, &is_quote_enclosed
);
923 if (VEC_empty (symtab_p
, self
->file_symtabs
))
925 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
926 VEC_safe_push (symtab_p
, self
->file_symtabs
, NULL
);
931 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
932 VEC_safe_push (symtab_p
, self
->file_symtabs
, NULL
);
935 /* Check if this is an Objective-C method (anything that starts with
936 a '+' or '-' and a '['). */
937 if (is_objc_method_format (p
))
940 /* Check if the symbol could be an Objective-C selector. */
943 struct symtabs_and_lines values
;
945 values
= decode_objc (self
, argptr
);
946 if (values
.sals
!= NULL
)
948 do_cleanups (cleanup
);
953 /* Does it look like there actually were two parts? */
955 if (p
[0] == ':' || p
[0] == '.')
957 /* Is it a C++ or Java compound data structure?
958 The check on p[1] == ':' is capturing the case of "::",
959 since p[0]==':' was checked above.
960 Note that the call to decode_compound does everything
961 for us, including the lookup on the symbol table, so we
964 if (p
[0] == '.' || p
[1] == ':')
966 /* We only perform this check for the languages where it might
967 make sense. For instance, Ada does not use this type of
968 syntax, and trying to apply this logic on an Ada linespec
969 may trigger a spurious error (for instance, decode_compound
970 does not like expressions such as `ops."<"', which is a
971 valid function name in Ada). */
972 if (current_language
->la_language
== language_c
973 || current_language
->la_language
== language_cplus
974 || current_language
->la_language
== language_java
)
976 struct symtabs_and_lines values
;
977 volatile struct gdb_exception ex
;
978 char *saved_argptr
= *argptr
;
980 if (is_quote_enclosed
)
983 /* Initialize it just to avoid a GCC false warning. */
984 memset (&values
, 0, sizeof (values
));
986 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
988 values
= decode_compound (self
, argptr
, saved_arg
, p
);
990 if ((is_quoted
|| is_squote_enclosed
) && **argptr
== '\'')
991 *argptr
= *argptr
+ 1;
995 do_cleanups (cleanup
);
999 if (ex
.error
!= NOT_FOUND_ERROR
)
1000 throw_exception (ex
);
1002 *argptr
= saved_argptr
;
1007 /* If there was an exception looking up a specified filename earlier,
1008 then check whether we were really given `function:label'. */
1009 if (file_exception
.reason
< 0)
1011 function_symbols
= find_function_symbols (argptr
, p
,
1013 &self
->user_function
);
1015 /* If we did not find a function, re-throw the original
1017 if (!function_symbols
)
1018 throw_exception (file_exception
);
1020 make_cleanup (VEC_cleanup (symbolp
), &function_symbols
);
1023 /* Check for single quotes on the non-filename part. */
1026 is_quoted
= (**argptr
1027 && strchr (get_gdb_completer_quote_characters (),
1030 end_quote
= skip_quoted (*argptr
);
1035 /* self->file_symtabs holds the specified file symtabs, or 0 if no file
1037 If we are parsing `function:symbol', then FUNCTION_SYMBOLS holds the
1038 functions before the `:'.
1039 arg no longer contains the file name. */
1041 /* If the filename was quoted, we must re-check the quotation. */
1043 if (end_quote
== first_half
&& *end_quote
!= '\0')
1045 is_quoted
= (**argptr
1046 && strchr (get_gdb_completer_quote_characters (),
1049 end_quote
= skip_quoted (*argptr
);
1052 /* Check whether arg is all digits (and sign). */
1055 if (*q
== '-' || *q
== '+')
1057 while (*q
>= '0' && *q
<= '9')
1060 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ',')
1061 && function_symbols
== NULL
)
1063 struct symtabs_and_lines values
;
1065 /* We found a token consisting of all digits -- at least one digit. */
1066 values
= decode_all_digits (self
, argptr
, q
);
1067 do_cleanups (cleanup
);
1071 /* Arg token is not digits => try it as a variable name
1072 Find the next token (everything up to end or next whitespace). */
1074 if (**argptr
== '$') /* May be a convenience variable. */
1075 /* One or two $ chars possible. */
1076 p
= skip_quoted (*argptr
+ (((*argptr
)[1] == '$') ? 2 : 1));
1077 else if (is_quoted
|| is_squote_enclosed
)
1081 error (_("Unmatched single quote."));
1083 else if (is_objc_method
)
1085 /* allow word separators in method names for Obj-C. */
1086 p
= skip_quoted_chars (*argptr
, NULL
, "");
1090 p
= skip_quoted (*argptr
);
1093 /* Keep any important naming information. */
1094 p
= keep_name_info (p
, p
== saved_arg
|| is_linespec_boundary (p
[-1]));
1096 copy
= (char *) alloca (p
- *argptr
+ 1);
1097 memcpy (copy
, *argptr
, p
- *argptr
);
1098 copy
[p
- *argptr
] = '\0';
1101 && copy
[0] == copy
[p
- *argptr
- 1]
1102 && strchr (get_gdb_completer_quote_characters (), copy
[0]) != NULL
)
1104 copy
[p
- *argptr
- 1] = '\0';
1107 else if (is_quoted
|| is_squote_enclosed
)
1108 copy
[p
- *argptr
- 1] = '\0';
1110 *argptr
= skip_spaces (p
);
1112 /* If it starts with $: may be a legitimate variable or routine name
1113 (e.g. HP-UX millicode routines such as $$dyncall), or it may
1114 be history value, or it may be a convenience variable. */
1116 if (*copy
== '$' && function_symbols
== NULL
)
1118 struct symtabs_and_lines values
;
1120 values
= decode_dollar (self
, copy
);
1121 do_cleanups (cleanup
);
1125 /* Try the token as a label, but only if no file was specified,
1126 because we can only really find labels in the current scope. */
1128 if (VEC_length (symtab_p
, self
->file_symtabs
) == 1
1129 && VEC_index (symtab_p
, self
->file_symtabs
, 0) == NULL
)
1131 struct symtabs_and_lines label_result
;
1132 if (decode_label (self
, function_symbols
, copy
, &label_result
))
1134 do_cleanups (cleanup
);
1135 return label_result
;
1139 if (function_symbols
)
1140 throw_exception (file_exception
);
1142 /* Look up that token as a variable.
1143 If file specified, use that file's per-file block to start with. */
1146 struct symtabs_and_lines values
;
1148 values
= decode_variable (self
, copy
);
1149 do_cleanups (cleanup
);
1154 /* A constructor for linespec_state. */
1157 linespec_state_constructor (struct linespec_state
*self
,
1159 struct symtab
*default_symtab
,
1161 struct linespec_result
*canonical
)
1163 memset (self
, 0, sizeof (*self
));
1164 self
->funfirstline
= (flags
& DECODE_LINE_FUNFIRSTLINE
) ? 1 : 0;
1165 self
->list_mode
= (flags
& DECODE_LINE_LIST_MODE
) ? 1 : 0;
1166 self
->default_symtab
= default_symtab
;
1167 self
->default_line
= default_line
;
1168 self
->canonical
= canonical
;
1169 self
->program_space
= current_program_space
;
1170 self
->addr_set
= htab_create_alloc (10, hash_address_entry
, eq_address_entry
,
1171 xfree
, xcalloc
, xfree
);
1174 /* A destructor for linespec_state. */
1177 linespec_state_destructor (void *arg
)
1179 struct linespec_state
*self
= arg
;
1181 xfree (self
->user_filename
);
1182 xfree (self
->user_function
);
1183 VEC_free (symtab_p
, self
->file_symtabs
);
1184 htab_delete (self
->addr_set
);
1187 /* See linespec.h. */
1190 decode_line_full (char **argptr
, int flags
,
1191 struct symtab
*default_symtab
,
1192 int default_line
, struct linespec_result
*canonical
,
1193 const char *select_mode
,
1196 struct symtabs_and_lines result
;
1197 struct linespec_state state
;
1198 struct cleanup
*cleanups
;
1199 char *arg_start
= *argptr
;
1200 VEC (const_char_ptr
) *filters
= NULL
;
1202 gdb_assert (canonical
!= NULL
);
1203 /* The filter only makes sense for 'all'. */
1204 gdb_assert (filter
== NULL
|| select_mode
== multiple_symbols_all
);
1205 gdb_assert (select_mode
== NULL
1206 || select_mode
== multiple_symbols_all
1207 || select_mode
== multiple_symbols_ask
1208 || select_mode
== multiple_symbols_cancel
);
1209 gdb_assert ((flags
& DECODE_LINE_LIST_MODE
) == 0);
1211 linespec_state_constructor (&state
, flags
,
1212 default_symtab
, default_line
, canonical
);
1213 cleanups
= make_cleanup (linespec_state_destructor
, &state
);
1214 save_current_program_space ();
1216 result
= decode_line_internal (&state
, argptr
);
1218 gdb_assert (result
.nelts
== 1 || canonical
->pre_expanded
);
1219 gdb_assert (canonical
->addr_string
!= NULL
);
1220 canonical
->pre_expanded
= 1;
1222 /* Fill in the missing canonical names. */
1223 if (result
.nelts
> 0)
1227 if (state
.canonical_names
== NULL
)
1228 state
.canonical_names
= xcalloc (result
.nelts
, sizeof (char *));
1229 make_cleanup (xfree
, state
.canonical_names
);
1230 for (i
= 0; i
< result
.nelts
; ++i
)
1232 if (state
.canonical_names
[i
] == NULL
)
1233 state
.canonical_names
[i
] = savestring (arg_start
,
1234 *argptr
- arg_start
);
1235 make_cleanup (xfree
, state
.canonical_names
[i
]);
1239 if (select_mode
== NULL
)
1241 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
1242 select_mode
= multiple_symbols_all
;
1244 select_mode
= multiple_symbols_select_mode ();
1247 if (select_mode
== multiple_symbols_all
)
1251 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
1252 VEC_safe_push (const_char_ptr
, filters
, filter
);
1253 filter_results (&state
, &result
, filters
);
1256 convert_results_to_lsals (&state
, &result
);
1259 decode_line_2 (&state
, &result
, select_mode
);
1261 do_cleanups (cleanups
);
1264 struct symtabs_and_lines
1265 decode_line_1 (char **argptr
, int flags
,
1266 struct symtab
*default_symtab
,
1269 struct symtabs_and_lines result
;
1270 struct linespec_state state
;
1271 struct cleanup
*cleanups
;
1273 linespec_state_constructor (&state
, flags
,
1274 default_symtab
, default_line
, NULL
);
1275 cleanups
= make_cleanup (linespec_state_destructor
, &state
);
1276 save_current_program_space ();
1278 result
= decode_line_internal (&state
, argptr
);
1279 do_cleanups (cleanups
);
1285 /* First, some functions to initialize stuff at the beggining of the
1289 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
1291 if (*default_symtab
== 0)
1293 /* Use whatever we have for the default source line. We don't use
1294 get_current_or_default_symtab_and_line as it can recurse and call
1296 struct symtab_and_line cursal
=
1297 get_current_source_symtab_and_line ();
1299 *default_symtab
= cursal
.symtab
;
1300 *default_line
= cursal
.line
;
1306 /* Decode arg of the form *PC. */
1308 static struct symtabs_and_lines
1309 decode_indirect (struct linespec_state
*self
, char **argptr
)
1311 struct symtabs_and_lines values
;
1313 char *initial
= *argptr
;
1315 if (current_program_space
->executing_startup
)
1316 /* The error message doesn't really matter, because this case
1317 should only hit during breakpoint reset. */
1318 throw_error (NOT_FOUND_ERROR
, _("cannot evaluate expressions while "
1319 "program space is in startup"));
1322 pc
= value_as_address (parse_to_comma_and_eval (argptr
));
1324 values
.sals
= (struct symtab_and_line
*)
1325 xmalloc (sizeof (struct symtab_and_line
));
1328 values
.sals
[0] = find_pc_line (pc
, 0);
1329 values
.sals
[0].pc
= pc
;
1330 values
.sals
[0].section
= find_pc_overlay (pc
);
1331 values
.sals
[0].explicit_pc
= 1;
1333 if (self
->canonical
)
1334 self
->canonical
->addr_string
= savestring (initial
, *argptr
- initial
);
1341 /* Locate the first half of the linespec, ending in a colon, period,
1342 or whitespace. (More or less.) Also, check to see if *ARGPTR is
1343 enclosed in double quotes; if so, set is_quote_enclosed, advance
1344 ARGPTR past that and zero out the trailing double quote.
1345 If ARGPTR is just a simple name like "main", p will point to ""
1349 locate_first_half (char **argptr
, int *is_quote_enclosed
)
1355 /* Check if the linespec starts with an Ada operator (such as "+",
1356 or ">", for instance). */
1359 && current_language
->la_language
== language_ada
)
1361 const struct ada_opname_map
*op
;
1363 for (op
= ada_opname_table
; op
->encoded
!= NULL
; op
++)
1364 if (strncmp (op
->decoded
, p
, strlen (op
->decoded
)) == 0)
1366 if (op
->encoded
!= NULL
)
1368 *is_quote_enclosed
= 0;
1369 return p
+ strlen (op
->decoded
);
1373 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1374 and we must isolate the first half. Outer layers will call again later
1375 for the second half.
1377 Don't count commas that appear in argument lists of overloaded
1378 functions, or in quoted strings. It's stupid to go to this much
1379 trouble when the rest of the function is such an obvious roach hotel. */
1380 ii
= find_toplevel_char (*argptr
, ',');
1381 has_comma
= (ii
!= 0);
1383 /* Temporarily zap out second half to not confuse the code below.
1384 This is undone below. Do not change ii!! */
1390 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
1391 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
1397 *is_quote_enclosed
= 1;
1403 *is_quote_enclosed
= 0;
1404 if (strchr (get_gdb_completer_quote_characters (), *p
))
1412 /* Check for a drive letter in the filename. This is done on all hosts
1413 to capture cross-compilation environments. On Unixen, directory
1414 separators are illegal in filenames, so if the user enters "e:/foo.c",
1415 he is referring to a directory named "e:" and a source file named
1416 "foo.c", and we still want to keep these two pieces together. */
1417 if (isalpha (p
[0]) && p
[1] == ':' && IS_DIR_SEPARATOR (p
[2]))
1424 char *temp_end
= find_template_name_end (p
);
1427 error (_("malformed template specification in command"));
1432 p
= find_method_overload_end (p
);
1434 /* Check for a colon and a plus or minus and a [ (which
1435 indicates an Objective-C method). */
1436 if (is_objc_method_format (p
))
1440 /* Check for the end of the first half of the linespec. End of
1441 line, a tab, a colon or a space. But if enclosed in double
1442 quotes we do not break on enclosed spaces. */
1446 || ((p
[0] == ' ') && !*is_quote_enclosed
))
1448 if (p
[0] == '.' && strchr (p
, ':') == NULL
)
1450 /* Java qualified method. Find the *last* '.', since the
1451 others are package qualifiers. Stop at any open parenthesis
1452 which might provide overload information. */
1453 for (p1
= p
; *p1
&& *p1
!= '('; p1
++)
1461 p
= skip_spaces (p
);
1463 /* If the closing double quote was left at the end, remove it. */
1464 if (*is_quote_enclosed
)
1466 char *closing_quote
= strchr (p
- 1, '"');
1468 if (closing_quote
&& closing_quote
[1] == '\0')
1469 *closing_quote
= '\0';
1472 /* Now that we've safely parsed the first half, put back ',' so
1473 outer layers can see it. */
1482 /* Here's where we recognise an Objective-C Selector. An Objective C
1483 selector may be implemented by more than one class, therefore it
1484 may represent more than one method/function. This gives us a
1485 situation somewhat analogous to C++ overloading. If there's more
1486 than one method that could represent the selector, then use some of
1487 the existing C++ code to let the user choose one. */
1489 static struct symtabs_and_lines
1490 decode_objc (struct linespec_state
*self
, char **argptr
)
1492 struct collect_info info
;
1493 VEC (const_char_ptr
) *symbol_names
= NULL
;
1495 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (const_char_ptr
),
1499 info
.result
.sals
= NULL
;
1500 info
.result
.nelts
= 0;
1502 new_argptr
= find_imps (*argptr
, &symbol_names
);
1503 if (VEC_empty (const_char_ptr
, symbol_names
))
1505 do_cleanups (cleanup
);
1509 add_all_symbol_names_from_pspace (&info
, NULL
, symbol_names
);
1511 if (info
.result
.nelts
> 0)
1515 saved_arg
= alloca (new_argptr
- *argptr
+ 1);
1516 memcpy (saved_arg
, *argptr
, new_argptr
- *argptr
);
1517 saved_arg
[new_argptr
- *argptr
] = '\0';
1519 if (self
->canonical
)
1521 self
->canonical
->pre_expanded
= 1;
1522 if (self
->user_filename
)
1523 self
->canonical
->addr_string
1524 = xstrprintf ("%s:%s", self
->user_filename
, saved_arg
);
1526 self
->canonical
->addr_string
= xstrdup (saved_arg
);
1530 *argptr
= new_argptr
;
1532 do_cleanups (cleanup
);
1536 /* This handles C++ and Java compound data structures. P should point
1537 at the first component separator, i.e. double-colon or period. As
1538 an example, on entrance to this function we could have ARGPTR
1539 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
1541 static struct symtabs_and_lines
1542 decode_compound (struct linespec_state
*self
,
1543 char **argptr
, char *the_real_saved_arg
, char *p
)
1545 struct symtabs_and_lines values
;
1547 char *saved_arg2
= *argptr
;
1551 VEC (symbolp
) *sym_classes
;
1552 char *saved_arg
, *class_name
;
1553 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1555 /* If the user specified any completer quote characters in the input,
1556 strip them. They are superfluous. */
1557 saved_arg
= alloca (strlen (the_real_saved_arg
) + 1);
1559 char *dst
= saved_arg
;
1560 char *src
= the_real_saved_arg
;
1561 char *quotes
= get_gdb_completer_quote_characters ();
1562 while (*src
!= '\0')
1564 if (strchr (quotes
, *src
) == NULL
)
1571 /* First check for "global" namespace specification, of the form
1572 "::foo". If found, skip over the colons and jump to normal
1573 symbol processing. I.e. the whole line specification starts with
1574 "::" (note the condition that *argptr == p). */
1576 && ((*argptr
== p
) || (p
[-1] == ' ') || (p
[-1] == '\t')))
1579 /* Given our example "AAA::inA::fun", we have two cases to consider:
1581 1) AAA::inA is the name of a class. In that case, presumably it
1582 has a method called "fun"; we then look up that method using
1585 2) AAA::inA isn't the name of a class. In that case, either the
1586 user made a typo, AAA::inA is the name of a namespace, or it is
1587 the name of a minimal symbol.
1588 In this case we just delegate to decode_variable.
1590 Thus, our first task is to find everything before the last set of
1591 double-colons and figure out if it's the name of a class. So we
1592 first loop through all of the double-colons. */
1594 p2
= p
; /* Save for restart. */
1596 /* This is very messy. Following the example above we have now the
1599 argptr -> "AAA::inA::fun
1600 saved_arg -> "AAA::inA::fun
1601 saved_arg2 -> "AAA::inA::fun
1602 p2 -> "::inA::fun". */
1604 /* In the loop below, with these strings, we'll make 2 passes, each
1605 is marked in comments. */
1609 static char *break_characters
= " \t(";
1611 /* Move pointer up to next possible class/namespace token. */
1613 p
= p2
+ 1; /* Restart with old value +1. */
1615 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1616 i.e. if there is a double-colon, p will now point to the
1618 /* PASS2: p2->"::fun", p->":fun" */
1620 /* Move pointer ahead to next double-colon. */
1622 && strchr (break_characters
, *p
) == NULL
1623 && strchr (get_gdb_completer_quote_characters (), *p
) == NULL
)
1625 if (current_language
->la_language
== language_cplus
)
1626 p
+= cp_validate_operator (p
);
1630 temp_end
= find_template_name_end (p
);
1632 error (_("malformed template specification in command"));
1635 /* Note that, since, at the start of this loop, p would be
1636 pointing to the second colon in a double-colon, we only
1637 satisfy the condition below if there is another
1638 double-colon to the right (after). I.e. there is another
1639 component that can be a class or a namespace. I.e, if at
1640 the beginning of this loop (PASS1), we had
1641 p->":inA::fun", we'll trigger this when p has been
1642 advanced to point to "::fun". */
1643 /* PASS2: we will not trigger this. */
1644 else if ((p
[0] == ':') && (p
[1] == ':'))
1645 break; /* Found double-colon. */
1648 /* PASS2: We'll keep getting here, until P points to one of the
1649 break characters, at which point we exit this loop. */
1653 && strncmp (&p
[1], CP_ANONYMOUS_NAMESPACE_STR
,
1654 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
1655 p
+= CP_ANONYMOUS_NAMESPACE_LEN
;
1656 else if (strchr (break_characters
, *p
) == NULL
)
1663 break; /* Out of the while (1). This would happen
1664 for instance if we have looked up
1665 unsuccessfully all the components of the
1666 string, and p->""(PASS2). */
1668 /* We get here if p points to one of the break characters or "" (i.e.,
1670 /* Save restart for next time around. */
1672 /* Restore argptr as it was on entry to this function. */
1673 *argptr
= saved_arg2
;
1674 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1677 /* All ready for next pass through the loop. */
1681 /* Start of lookup in the symbol tables. */
1683 /* Lookup in the symbol table the substring between argptr and
1684 p. Note, this call changes the value of argptr. */
1685 /* Before the call, argptr->"AAA::inA::fun",
1686 p->"", p2->"::fun". After the call: argptr->"fun", p, p2
1688 sym_classes
= lookup_prefix_sym (argptr
, p2
, self
->file_symtabs
,
1690 make_cleanup (VEC_cleanup (symbolp
), &sym_classes
);
1691 make_cleanup (xfree
, class_name
);
1693 /* If a class has been found, then we're in case 1 above. So we
1694 look up "fun" as a method of those classes. */
1695 if (!VEC_empty (symbolp
, sym_classes
))
1697 /* Arg token is not digits => try it as a function name.
1698 Find the next token (everything up to end or next
1701 && strchr (get_gdb_completer_quote_characters (),
1704 p
= skip_quoted (*argptr
);
1705 *argptr
= *argptr
+ 1;
1709 /* At this point argptr->"fun". */
1713 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!= ':'
1716 /* At this point p->"". String ended. */
1717 /* Nope, C++ operators could have spaces in them
1718 ("foo::operator <" or "foo::operator delete []").
1719 I apologize, this is a bit hacky... */
1720 if (current_language
->la_language
== language_cplus
1721 && *p
== ' ' && p
- 8 - *argptr
+ 1 > 0)
1723 /* The above loop has already swallowed "operator". */
1724 p
+= cp_validate_operator (p
- 8) - 8;
1727 /* Keep any important naming information. */
1728 p
= keep_name_info (p
, 1);
1731 /* Allocate our own copy of the substring between argptr and
1733 copy
= (char *) alloca (p
- *argptr
+ 1);
1734 memcpy (copy
, *argptr
, p
- *argptr
);
1735 copy
[p
- *argptr
] = '\0';
1737 && copy
[p
- *argptr
- 1]
1738 && strchr (get_gdb_completer_quote_characters (),
1739 copy
[p
- *argptr
- 1]) != NULL
)
1740 copy
[p
- *argptr
- 1] = '\0';
1742 /* At this point copy->"fun", p->"". */
1744 /* No line number may be specified. */
1745 *argptr
= skip_spaces (p
);
1746 /* At this point arptr->"". */
1748 /* Look for copy as a method of sym_class. */
1749 /* At this point copy->"fun", sym_class is "AAA:inA",
1750 saved_arg->"AAA::inA::fun". This concludes the scanning of
1751 the string for possible components matches. If we find it
1752 here, we return. If not, and we are at the and of the string,
1753 we'll lookup the whole string in the symbol tables. */
1755 values
= find_method (self
, saved_arg
, copy
, class_name
, sym_classes
);
1757 do_cleanups (cleanup
);
1759 } /* End if symbol found. */
1762 /* We couldn't find a class, so we're in case 2 above. We check the
1763 entire name as a symbol instead. The simplest way to do this is
1764 to just throw an exception and let our caller fall through to
1767 throw_error (NOT_FOUND_ERROR
, _("see caller, this text doesn't matter"));
1770 /* An instance of this type is used when collecting prefix symbols for
1773 struct decode_compound_collector
1775 /* The result vector. */
1776 VEC (symbolp
) *symbols
;
1778 /* A hash table of all symbols we found. We use this to avoid
1779 adding any symbol more than once. */
1783 /* A callback for iterate_over_symbols that is used by
1784 lookup_prefix_sym to collect type symbols. */
1787 collect_one_symbol (struct symbol
*sym
, void *d
)
1789 struct decode_compound_collector
*collector
= d
;
1793 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1796 t
= SYMBOL_TYPE (sym
);
1798 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1799 && TYPE_CODE (t
) != TYPE_CODE_UNION
1800 && TYPE_CODE (t
) != TYPE_CODE_NAMESPACE
)
1803 slot
= htab_find_slot (collector
->unique_syms
, sym
, INSERT
);
1807 VEC_safe_push (symbolp
, collector
->symbols
, sym
);
1813 /* Return the symbol corresponding to the substring of *ARGPTR ending
1814 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1815 name in question, the compound object separator ("::" or "."), and
1816 whitespace. Note that *ARGPTR is changed whether or not the
1817 this call finds anything (i.e we return NULL). As an
1818 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
1820 static VEC (symbolp
) *
1821 lookup_prefix_sym (char **argptr
, char *p
, VEC (symtab_p
) *file_symtabs
,
1828 struct decode_compound_collector collector
;
1829 struct cleanup
*outer
;
1830 struct cleanup
*cleanup
;
1831 struct block
*search_block
;
1833 /* Extract the class name. */
1835 while (p
!= *argptr
&& p
[-1] == ' ')
1837 copy
= (char *) xmalloc (p
- *argptr
+ 1);
1838 memcpy (copy
, *argptr
, p
- *argptr
);
1839 copy
[p
- *argptr
] = 0;
1841 outer
= make_cleanup (xfree
, copy
);
1843 /* Discard the class name from the argptr. */
1844 p
= p1
+ (p1
[0] == ':' ? 2 : 1);
1845 p
= skip_spaces (p
);
1848 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1849 argptr->"inA::fun". */
1851 collector
.symbols
= NULL
;
1852 make_cleanup (VEC_cleanup (symbolp
), &collector
.symbols
);
1854 collector
.unique_syms
= htab_create_alloc (1, htab_hash_pointer
,
1855 htab_eq_pointer
, NULL
,
1857 cleanup
= make_cleanup_htab_delete (collector
.unique_syms
);
1859 for (ix
= 0; VEC_iterate (symtab_p
, file_symtabs
, ix
, elt
); ++ix
)
1863 iterate_over_all_matching_symtabs (copy
, STRUCT_DOMAIN
,
1864 collect_one_symbol
, &collector
,
1866 iterate_over_all_matching_symtabs (copy
, VAR_DOMAIN
,
1867 collect_one_symbol
, &collector
,
1872 struct block
*search_block
;
1874 /* Program spaces that are executing startup should have
1875 been filtered out earlier. */
1876 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
1877 set_current_program_space (SYMTAB_PSPACE (elt
));
1878 search_block
= get_search_block (elt
);
1879 LA_ITERATE_OVER_SYMBOLS (search_block
, copy
, STRUCT_DOMAIN
,
1880 collect_one_symbol
, &collector
);
1881 LA_ITERATE_OVER_SYMBOLS (search_block
, copy
, VAR_DOMAIN
,
1882 collect_one_symbol
, &collector
);
1886 do_cleanups (cleanup
);
1887 discard_cleanups (outer
);
1888 return collector
.symbols
;
1891 /* A qsort comparison function for symbols. The resulting order does
1892 not actually matter; we just need to be able to sort them so that
1893 symbols with the same program space end up next to each other. */
1896 compare_symbols (const void *a
, const void *b
)
1898 struct symbol
* const *sa
= a
;
1899 struct symbol
* const *sb
= b
;
1902 uia
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa
));
1903 uib
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb
));
1910 uia
= (uintptr_t) *sa
;
1911 uib
= (uintptr_t) *sb
;
1921 /* Look for all the matching instances of each symbol in NAMES. Only
1922 instances from PSPACE are considered; other program spaces are
1923 handled by our caller. If PSPACE is NULL, then all program spaces
1924 are considered. Results are stored into INFO. */
1927 add_all_symbol_names_from_pspace (struct collect_info
*info
,
1928 struct program_space
*pspace
,
1929 VEC (const_char_ptr
) *names
)
1934 for (ix
= 0; VEC_iterate (const_char_ptr
, names
, ix
, iter
); ++ix
)
1935 add_matching_symbols_to_info (iter
, info
, pspace
);
1939 find_superclass_methods (VEC (typep
) *superclasses
,
1941 VEC (const_char_ptr
) **result_names
)
1943 int old_len
= VEC_length (const_char_ptr
, *result_names
);
1944 VEC (typep
) *iter_classes
;
1945 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1947 iter_classes
= superclasses
;
1950 VEC (typep
) *new_supers
= NULL
;
1954 make_cleanup (VEC_cleanup (typep
), &new_supers
);
1955 for (ix
= 0; VEC_iterate (typep
, iter_classes
, ix
, t
); ++ix
)
1956 find_methods (t
, name
, result_names
, &new_supers
);
1958 if (VEC_length (const_char_ptr
, *result_names
) != old_len
1959 || VEC_empty (typep
, new_supers
))
1962 iter_classes
= new_supers
;
1965 do_cleanups (cleanup
);
1968 /* This finds the method COPY in the class whose type is given by one
1969 of the symbols in SYM_CLASSES. */
1971 static struct symtabs_and_lines
1972 find_method (struct linespec_state
*self
, char *saved_arg
,
1973 char *copy
, const char *class_name
, VEC (symbolp
) *sym_classes
)
1977 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1979 int last_result_len
;
1980 VEC (typep
) *superclass_vec
;
1981 VEC (const_char_ptr
) *result_names
;
1982 struct collect_info info
;
1985 /* NAME is typed by the user: it needs to be canonicalized before
1986 searching the symbol tables. */
1987 canon
= cp_canonicalize_string_no_typedefs (copy
);
1991 make_cleanup (xfree
, copy
);
1994 /* Sort symbols so that symbols with the same program space are next
1996 qsort (VEC_address (symbolp
, sym_classes
),
1997 VEC_length (symbolp
, sym_classes
),
2002 info
.result
.sals
= NULL
;
2003 info
.result
.nelts
= 0;
2005 /* Iterate over all the types, looking for the names of existing
2006 methods matching COPY. If we cannot find a direct method in a
2007 given program space, then we consider inherited methods; this is
2008 not ideal (ideal would be to respect C++ hiding rules), but it
2009 seems good enough and is what GDB has historically done. We only
2010 need to collect the names because later we find all symbols with
2011 those names. This loop is written in a somewhat funny way
2012 because we collect data across the program space before deciding
2014 superclass_vec
= NULL
;
2015 make_cleanup (VEC_cleanup (typep
), &superclass_vec
);
2016 result_names
= NULL
;
2017 make_cleanup (VEC_cleanup (const_char_ptr
), &result_names
);
2018 last_result_len
= 0;
2019 for (ix
= 0; VEC_iterate (symbolp
, sym_classes
, ix
, sym
); ++ix
)
2022 struct program_space
*pspace
;
2024 /* Program spaces that are executing startup should have
2025 been filtered out earlier. */
2026 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
))->executing_startup
);
2027 pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2028 set_current_program_space (pspace
);
2029 t
= check_typedef (SYMBOL_TYPE (sym
));
2030 find_methods (t
, copy
, &result_names
, &superclass_vec
);
2032 /* Handle all items from a single program space at once; and be
2033 sure not to miss the last batch. */
2034 if (ix
== VEC_length (symbolp
, sym_classes
) - 1
2036 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp
, sym_classes
,
2039 /* If we did not find a direct implementation anywhere in
2040 this program space, consider superclasses. */
2041 if (VEC_length (const_char_ptr
, result_names
) == last_result_len
)
2042 find_superclass_methods (superclass_vec
, copy
, &result_names
);
2044 /* We have a list of candidate symbol names, so now we
2045 iterate over the symbol tables looking for all
2046 matches in this pspace. */
2047 add_all_symbol_names_from_pspace (&info
, pspace
, result_names
);
2049 VEC_truncate (typep
, superclass_vec
, 0);
2050 last_result_len
= VEC_length (const_char_ptr
, result_names
);
2054 if (info
.result
.nelts
> 0)
2056 if (self
->canonical
)
2058 self
->canonical
->pre_expanded
= 1;
2059 if (self
->user_filename
)
2060 self
->canonical
->addr_string
2061 = xstrprintf ("%s:%s", self
->user_filename
, saved_arg
);
2063 self
->canonical
->addr_string
= xstrdup (saved_arg
);
2066 do_cleanups (cleanup
);
2072 cplusplus_error (saved_arg
,
2073 "the class `%s' does not have destructor defined\n",
2076 cplusplus_error (saved_arg
,
2077 "the class %s does not have any method named %s\n",
2083 /* This object is used when collecting all matching symtabs. */
2085 struct symtab_collector
2087 /* The result vector of symtabs. */
2088 VEC (symtab_p
) *symtabs
;
2090 /* This is used to ensure the symtabs are unique. */
2091 htab_t symtab_table
;
2094 /* Callback for iterate_over_symtabs. */
2097 add_symtabs_to_list (struct symtab
*symtab
, void *d
)
2099 struct symtab_collector
*data
= d
;
2102 slot
= htab_find_slot (data
->symtab_table
, symtab
, INSERT
);
2106 VEC_safe_push (symtab_p
, data
->symtabs
, symtab
);
2112 /* Given a file name, return a VEC of all matching symtabs. */
2114 static VEC (symtab_p
) *
2115 collect_symtabs_from_filename (const char *file
)
2117 struct symtab_collector collector
;
2118 struct cleanup
*cleanups
;
2119 struct program_space
*pspace
;
2121 collector
.symtabs
= NULL
;
2122 collector
.symtab_table
= htab_create (1, htab_hash_pointer
, htab_eq_pointer
,
2124 cleanups
= make_cleanup_htab_delete (collector
.symtab_table
);
2126 /* Find that file's data. */
2127 ALL_PSPACES (pspace
)
2129 if (pspace
->executing_startup
)
2132 set_current_program_space (pspace
);
2133 iterate_over_symtabs (file
, add_symtabs_to_list
, &collector
);
2136 do_cleanups (cleanups
);
2137 return collector
.symtabs
;
2140 /* Return all the symtabs associated to the filename given by the
2141 substring of *ARGPTR ending at P, and advance ARGPTR past that
2144 static VEC (symtab_p
) *
2145 symtabs_from_filename (char **argptr
, char *p
, int is_quote_enclosed
,
2146 char **user_filename
)
2150 struct cleanup
*outer
;
2151 VEC (symtab_p
) *result
;
2154 while (p
!= *argptr
&& p
[-1] == ' ')
2156 if ((*p
== '"') && is_quote_enclosed
)
2158 copy
= xmalloc (p
- *argptr
+ 1);
2159 outer
= make_cleanup (xfree
, copy
);
2160 memcpy (copy
, *argptr
, p
- *argptr
);
2161 /* It may have the ending quote right after the file name. */
2162 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
2163 || copy
[p
- *argptr
- 1] == '\'')
2164 copy
[p
- *argptr
- 1] = 0;
2166 copy
[p
- *argptr
] = 0;
2168 result
= collect_symtabs_from_filename (copy
);
2170 if (VEC_empty (symtab_p
, result
))
2172 if (!have_full_symbols () && !have_partial_symbols ())
2173 throw_error (NOT_FOUND_ERROR
,
2174 _("No symbol table is loaded. "
2175 "Use the \"file\" command."));
2176 throw_error (NOT_FOUND_ERROR
, _("No source file named %s."), copy
);
2179 /* Discard the file name from the arg. */
2183 *argptr
= skip_spaces (p1
+ 1);
2185 discard_cleanups (outer
);
2186 *user_filename
= copy
;
2190 /* A callback used by iterate_over_all_matching_symtabs that collects
2191 symbols for find_function_symbols. */
2194 collect_function_symbols (struct symbol
*sym
, void *arg
)
2196 VEC (symbolp
) **syms
= arg
;
2198 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2199 VEC_safe_push (symbolp
, *syms
, sym
);
2204 /* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR
2205 and return the symbol. If not found, return NULL. */
2207 static VEC (symbolp
) *
2208 find_function_symbols (char **argptr
, char *p
, int is_quote_enclosed
,
2209 char **user_function
)
2213 VEC (symbolp
) *result
= NULL
;
2216 while (p
!= *argptr
&& p
[-1] == ' ')
2218 if ((*p
== '"') && is_quote_enclosed
)
2220 copy
= (char *) xmalloc (p
- *argptr
+ 1);
2221 *user_function
= copy
;
2222 memcpy (copy
, *argptr
, p
- *argptr
);
2223 /* It may have the ending quote right after the file name. */
2224 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
2225 || copy
[p
- *argptr
- 1] == '\'')
2226 copy
[p
- *argptr
- 1] = 0;
2228 copy
[p
- *argptr
] = 0;
2230 iterate_over_all_matching_symtabs (copy
, VAR_DOMAIN
,
2231 collect_function_symbols
, &result
, NULL
);
2233 if (VEC_empty (symbolp
, result
))
2234 VEC_free (symbolp
, result
);
2237 /* Discard the file name from the arg. */
2238 *argptr
= skip_spaces (p1
+ 1);
2246 /* A helper for decode_all_digits that handles the 'list_mode' case. */
2249 decode_digits_list_mode (struct linespec_state
*self
,
2250 struct symtabs_and_lines
*values
,
2251 struct symtab_and_line val
)
2256 gdb_assert (self
->list_mode
);
2258 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2260 /* The logic above should ensure this. */
2261 gdb_assert (elt
!= NULL
);
2263 set_current_program_space (SYMTAB_PSPACE (elt
));
2265 /* Simplistic search just for the list command. */
2266 val
.symtab
= find_line_symtab (elt
, val
.line
, NULL
, NULL
);
2267 if (val
.symtab
== NULL
)
2269 val
.pspace
= SYMTAB_PSPACE (elt
);
2271 val
.explicit_line
= 1;
2273 add_sal_to_sals (self
, values
, &val
, NULL
);
2277 /* A helper for decode_all_digits that iterates over the symtabs,
2278 adding lines to the VEC. */
2281 decode_digits_ordinary (struct linespec_state
*self
,
2283 struct symtabs_and_lines
*sals
,
2284 struct linetable_entry
**best_entry
)
2289 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2292 VEC (CORE_ADDR
) *pcs
;
2295 /* The logic above should ensure this. */
2296 gdb_assert (elt
!= NULL
);
2298 set_current_program_space (SYMTAB_PSPACE (elt
));
2300 pcs
= find_pcs_for_symtab_line (elt
, line
, best_entry
);
2301 for (i
= 0; VEC_iterate (CORE_ADDR
, pcs
, i
, pc
); ++i
)
2303 struct symtab_and_line sal
;
2306 sal
.pspace
= SYMTAB_PSPACE (elt
);
2310 add_sal_to_sals_basic (sals
, &sal
);
2313 VEC_free (CORE_ADDR
, pcs
);
2317 /* This decodes a line where the argument is all digits (possibly
2318 preceded by a sign). Q should point to the end of those digits;
2319 the other arguments are as usual. */
2321 static struct symtabs_and_lines
2322 decode_all_digits (struct linespec_state
*self
,
2326 struct symtabs_and_lines values
;
2327 struct symtab_and_line val
;
2328 int use_default
= 0;
2329 char *saved_arg
= *argptr
;
2341 /* This is where we need to make sure that we have good defaults.
2342 We must guarantee that this section of code is never executed
2343 when we are called with just a function name, since
2344 set_default_source_symtab_and_line uses
2345 select_source_symtab that calls us with such an argument. */
2347 if (VEC_length (symtab_p
, self
->file_symtabs
) == 1
2348 && VEC_index (symtab_p
, self
->file_symtabs
, 0) == NULL
)
2350 set_current_program_space (self
->program_space
);
2352 /* Make sure we have at least a default source file. */
2353 set_default_source_symtab_and_line ();
2354 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
2355 VEC_pop (symtab_p
, self
->file_symtabs
);
2356 VEC_free (symtab_p
, self
->file_symtabs
);
2358 = collect_symtabs_from_filename (self
->default_symtab
->filename
);
2362 if (**argptr
== '+')
2363 sign
= plus
, (*argptr
)++;
2364 else if (**argptr
== '-')
2365 sign
= minus
, (*argptr
)++;
2366 val
.line
= atoi (*argptr
);
2373 val
.line
= self
->default_line
+ val
.line
;
2379 val
.line
= self
->default_line
- val
.line
;
2384 break; /* No need to adjust val.line. */
2387 *argptr
= skip_spaces (q
);
2389 if (self
->list_mode
)
2390 decode_digits_list_mode (self
, &values
, val
);
2393 struct linetable_entry
*best_entry
= NULL
;
2395 struct block
**blocks
;
2396 struct cleanup
*cleanup
;
2397 struct symtabs_and_lines intermediate_results
;
2400 intermediate_results
.sals
= NULL
;
2401 intermediate_results
.nelts
= 0;
2403 decode_digits_ordinary (self
, val
.line
, &intermediate_results
,
2405 if (intermediate_results
.nelts
== 0 && best_entry
!= NULL
)
2406 decode_digits_ordinary (self
, best_entry
->line
, &intermediate_results
,
2409 cleanup
= make_cleanup (xfree
, intermediate_results
.sals
);
2411 /* For optimized code, compiler can scatter one source line
2412 accross disjoint ranges of PC values, even when no duplicate
2413 functions or inline functions are involved. For example,
2414 'for (;;)' inside non-template non-inline non-ctor-or-dtor
2415 function can result in two PC ranges. In this case, we don't
2416 want to set breakpoint on first PC of each range. To filter
2417 such cases, we use containing blocks -- for each PC found
2418 above we see if there are other PCs that are in the same
2419 block. If yes, the other PCs are filtered out. */
2421 filter
= xmalloc (intermediate_results
.nelts
* sizeof (int));
2422 make_cleanup (xfree
, filter
);
2423 blocks
= xmalloc (intermediate_results
.nelts
* sizeof (struct block
*));
2424 make_cleanup (xfree
, blocks
);
2426 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2428 set_current_program_space (intermediate_results
.sals
[i
].pspace
);
2431 blocks
[i
] = block_for_pc_sect (intermediate_results
.sals
[i
].pc
,
2432 intermediate_results
.sals
[i
].section
);
2435 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2437 if (blocks
[i
] != NULL
)
2438 for (j
= i
+ 1; j
< intermediate_results
.nelts
; ++j
)
2440 if (blocks
[j
] == blocks
[i
])
2448 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2451 struct symbol
*sym
= (blocks
[i
]
2452 ? block_containing_function (blocks
[i
])
2455 if (self
->funfirstline
)
2456 skip_prologue_sal (&intermediate_results
.sals
[i
]);
2457 /* Make sure the line matches the request, not what was
2459 intermediate_results
.sals
[i
].line
= val
.line
;
2460 add_sal_to_sals (self
, &values
, &intermediate_results
.sals
[i
],
2461 sym
? SYMBOL_NATURAL_NAME (sym
) : NULL
);
2464 do_cleanups (cleanup
);
2467 if (values
.nelts
== 0)
2469 if (self
->user_filename
)
2470 throw_error (NOT_FOUND_ERROR
, _("No line %d in file \"%s\"."),
2471 val
.line
, self
->user_filename
);
2473 throw_error (NOT_FOUND_ERROR
, _("No line %d in the current file."),
2477 if (self
->canonical
)
2479 char *copy
= savestring (saved_arg
, q
- saved_arg
);
2481 self
->canonical
->pre_expanded
= 1;
2482 gdb_assert (self
->user_filename
|| use_default
);
2483 self
->canonical
->addr_string
2484 = xstrprintf ("%s:%s", (self
->user_filename
2485 ? self
->user_filename
2486 : self
->default_symtab
->filename
),
2496 /* Decode a linespec starting with a dollar sign. */
2498 static struct symtabs_and_lines
2499 decode_dollar (struct linespec_state
*self
, char *copy
)
2503 struct symtabs_and_lines values
;
2504 struct symtab_and_line val
;
2507 struct minimal_symbol
*msymbol
;
2511 p
= (copy
[1] == '$') ? copy
+ 2 : copy
+ 1;
2512 while (*p
>= '0' && *p
<= '9')
2514 if (!*p
) /* Reached end of token without hitting non-digit. */
2516 /* We have a value history reference. */
2517 struct value
*val_history
;
2519 sscanf ((copy
[1] == '$') ? copy
+ 2 : copy
+ 1, "%d", &index
);
2520 val_history
= access_value_history ((copy
[1] == '$') ? -index
: index
);
2521 if (TYPE_CODE (value_type (val_history
)) != TYPE_CODE_INT
)
2522 error (_("History values used in line "
2523 "specs must have integer values."));
2524 valx
= value_as_long (val_history
);
2528 /* Not all digits -- may be user variable/function or a
2529 convenience variable. */
2531 volatile struct gdb_exception exc
;
2533 /* Avoid "may be used uninitialized" warning. */
2537 TRY_CATCH (exc
, RETURN_MASK_ERROR
)
2539 values
= decode_variable (self
, copy
);
2542 if (exc
.reason
== 0)
2545 if (exc
.error
!= NOT_FOUND_ERROR
)
2546 throw_exception (exc
);
2548 /* Not a user variable or function -- must be convenience variable. */
2549 if (!get_internalvar_integer (lookup_internalvar (copy
+ 1), &valx
))
2550 error (_("Convenience variables used in line "
2551 "specs must have integer values."));
2559 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2563 elt
= self
->default_symtab
;
2564 set_current_program_space (self
->program_space
);
2567 set_current_program_space (SYMTAB_PSPACE (elt
));
2569 /* Either history value or convenience value from above, in valx. */
2573 val
.pspace
= elt
? SYMTAB_PSPACE (elt
) : current_program_space
;
2575 add_sal_to_sals (self
, &values
, &val
, NULL
);
2578 if (self
->canonical
)
2580 self
->canonical
->pre_expanded
= 1;
2581 if (self
->user_filename
)
2582 self
->canonical
->addr_string
= xstrprintf ("%s:%s",
2583 self
->user_filename
, copy
);
2585 self
->canonical
->addr_string
= xstrdup (copy
);
2593 /* A helper for decode_line_1 that tries to find a label. The label
2594 is searched for in the current block.
2595 FUNCTION_SYMBOLS is a list of the enclosing functions; or NULL if none
2597 COPY is the name of the label to find.
2598 CANONICAL is the same as the "canonical" argument to decode_line_1.
2599 RESULT is a pointer to a symtabs_and_lines structure which will be
2600 filled in on success.
2601 This function returns 1 if a label was found, 0 otherwise. */
2604 decode_label (struct linespec_state
*self
,
2605 VEC (symbolp
) *function_symbols
, char *copy
,
2606 struct symtabs_and_lines
*result
)
2608 struct symbol
*fn_sym
;
2611 if (function_symbols
== NULL
)
2613 struct block
*block
;
2615 struct symtab_and_line sal
;
2616 struct symtabs_and_lines values
;
2621 set_current_program_space (self
->program_space
);
2622 block
= get_search_block (NULL
);
2625 block
&& !BLOCK_FUNCTION (block
);
2626 block
= BLOCK_SUPERBLOCK (block
))
2630 fn_sym
= BLOCK_FUNCTION (block
);
2632 sym
= lookup_symbol (copy
, block
, LABEL_DOMAIN
, 0);
2637 symbol_to_sal (&sal
, self
->funfirstline
, sym
);
2638 add_sal_to_sals (self
, &values
, &sal
,
2639 SYMBOL_NATURAL_NAME (fn_sym
));
2641 if (self
->canonical
)
2643 self
->canonical
->special_display
= 1;
2644 self
->canonical
->addr_string
2645 = xstrprintf ("%s:%s", SYMBOL_NATURAL_NAME (fn_sym
),
2654 result
->sals
= NULL
;
2657 for (ix
= 0; VEC_iterate (symbolp
, function_symbols
, ix
, fn_sym
); ++ix
)
2659 struct block
*block
;
2662 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym
)));
2663 block
= SYMBOL_BLOCK_VALUE (fn_sym
);
2664 sym
= lookup_symbol (copy
, block
, LABEL_DOMAIN
, 0);
2668 struct symtab_and_line sal
;
2671 symbol_to_sal (&sal
, self
->funfirstline
, sym
);
2672 symname
= xstrprintf ("%s:%s",
2673 SYMBOL_NATURAL_NAME (fn_sym
),
2674 SYMBOL_NATURAL_NAME (sym
));
2675 add_sal_to_sals (self
, result
, &sal
, symname
);
2680 if (self
->canonical
&& result
->nelts
> 0)
2682 self
->canonical
->pre_expanded
= 1;
2683 self
->canonical
->special_display
= 1;
2685 gdb_assert (self
->user_function
);
2686 self
->canonical
->addr_string
2687 = xstrprintf ("%s:%s", self
->user_function
, copy
);
2690 return result
->nelts
> 0;
2693 /* A callback used to possibly add a symbol to the results. */
2696 collect_symbols (struct symbol
*sym
, void *data
)
2698 struct collect_info
*info
= data
;
2699 struct symtab_and_line sal
;
2701 if (symbol_to_sal (&sal
, info
->state
->funfirstline
, sym
)
2702 && maybe_add_address (info
->state
->addr_set
,
2703 SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
)),
2705 add_sal_to_sals (info
->state
, &info
->result
, &sal
,
2706 SYMBOL_NATURAL_NAME (sym
));
2711 /* We've found a minimal symbol MSYMBOL to associate with our
2712 linespec; add it to the result symtabs_and_lines. */
2715 minsym_found (struct linespec_state
*self
, struct objfile
*objfile
,
2716 struct minimal_symbol
*msymbol
,
2717 struct symtabs_and_lines
*result
)
2719 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2721 struct symtab_and_line sal
;
2723 sal
= find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
2724 (struct obj_section
*) 0, 0);
2725 sal
.section
= SYMBOL_OBJ_SECTION (msymbol
);
2727 /* The minimal symbol might point to a function descriptor;
2728 resolve it to the actual code address instead. */
2729 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, sal
.pc
, ¤t_target
);
2731 sal
= find_pc_sect_line (pc
, NULL
, 0);
2733 if (self
->funfirstline
)
2734 skip_prologue_sal (&sal
);
2736 if (maybe_add_address (self
->addr_set
, objfile
->pspace
, sal
.pc
))
2737 add_sal_to_sals (self
, result
, &sal
, SYMBOL_NATURAL_NAME (msymbol
));
2740 /* A helper struct which just holds a minimal symbol and the object
2741 file from which it came. */
2743 typedef struct minsym_and_objfile
2745 struct minimal_symbol
*minsym
;
2746 struct objfile
*objfile
;
2747 } minsym_and_objfile_d
;
2749 DEF_VEC_O (minsym_and_objfile_d
);
2751 /* A helper struct to pass some data through
2752 iterate_over_minimal_symbols. */
2754 struct collect_minsyms
2756 /* The objfile we're examining. */
2757 struct objfile
*objfile
;
2759 /* The funfirstline setting from the initial call. */
2762 /* The list_mode setting from the initial call. */
2765 /* The resulting symbols. */
2766 VEC (minsym_and_objfile_d
) *msyms
;
2769 /* A helper function to classify a minimal_symbol_type according to
2773 classify_mtype (enum minimal_symbol_type t
)
2780 /* Intermediate priority. */
2783 case mst_solib_trampoline
:
2784 /* Lowest priority. */
2788 /* Highest priority. */
2793 /* Callback for qsort that sorts symbols by priority. */
2796 compare_msyms (const void *a
, const void *b
)
2798 const minsym_and_objfile_d
*moa
= a
;
2799 const minsym_and_objfile_d
*mob
= b
;
2800 enum minimal_symbol_type ta
= MSYMBOL_TYPE (moa
->minsym
);
2801 enum minimal_symbol_type tb
= MSYMBOL_TYPE (mob
->minsym
);
2803 return classify_mtype (ta
) - classify_mtype (tb
);
2806 /* Callback for iterate_over_minimal_symbols that adds the symbol to
2810 add_minsym (struct minimal_symbol
*minsym
, void *d
)
2812 struct collect_minsyms
*info
= d
;
2813 minsym_and_objfile_d mo
;
2815 /* Exclude data symbols when looking for breakpoint locations. */
2816 if (!info
->list_mode
)
2817 switch (minsym
->type
)
2819 case mst_slot_got_plt
:
2826 /* Make sure this minsym is not a function descriptor
2827 before we decide to discard it. */
2828 struct gdbarch
*gdbarch
= info
->objfile
->gdbarch
;
2829 CORE_ADDR addr
= gdbarch_convert_from_func_ptr_addr
2830 (gdbarch
, SYMBOL_VALUE_ADDRESS (minsym
),
2833 if (addr
== SYMBOL_VALUE_ADDRESS (minsym
))
2839 mo
.objfile
= info
->objfile
;
2840 VEC_safe_push (minsym_and_objfile_d
, info
->msyms
, &mo
);
2843 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
2844 is not NULL, the search is restricted to just that program
2848 search_minsyms_for_name (struct collect_info
*info
, const char *name
,
2849 struct program_space
*search_pspace
)
2851 struct objfile
*objfile
;
2852 struct program_space
*pspace
;
2854 ALL_PSPACES (pspace
)
2856 struct collect_minsyms local
;
2857 struct cleanup
*cleanup
;
2859 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
2861 if (pspace
->executing_startup
)
2864 set_current_program_space (pspace
);
2866 memset (&local
, 0, sizeof (local
));
2867 local
.funfirstline
= info
->state
->funfirstline
;
2868 local
.list_mode
= info
->state
->list_mode
;
2870 cleanup
= make_cleanup (VEC_cleanup (minsym_and_objfile_d
),
2873 ALL_OBJFILES (objfile
)
2875 local
.objfile
= objfile
;
2876 iterate_over_minimal_symbols (objfile
, name
, add_minsym
, &local
);
2879 if (!VEC_empty (minsym_and_objfile_d
, local
.msyms
))
2883 minsym_and_objfile_d
*item
;
2885 qsort (VEC_address (minsym_and_objfile_d
, local
.msyms
),
2886 VEC_length (minsym_and_objfile_d
, local
.msyms
),
2887 sizeof (minsym_and_objfile_d
),
2890 /* Now the minsyms are in classification order. So, we walk
2891 over them and process just the minsyms with the same
2892 classification as the very first minsym in the list. */
2893 item
= VEC_index (minsym_and_objfile_d
, local
.msyms
, 0);
2894 classification
= classify_mtype (MSYMBOL_TYPE (item
->minsym
));
2897 VEC_iterate (minsym_and_objfile_d
, local
.msyms
, ix
, item
);
2900 if (classify_mtype (MSYMBOL_TYPE (item
->minsym
)) != classification
)
2903 minsym_found (info
->state
, item
->objfile
, item
->minsym
,
2908 do_cleanups (cleanup
);
2912 /* A helper function to add all symbols matching NAME to INFO. If
2913 PSPACE is not NULL, the search is restricted to just that program
2917 add_matching_symbols_to_info (const char *name
,
2918 struct collect_info
*info
,
2919 struct program_space
*pspace
)
2924 for (ix
= 0; VEC_iterate (symtab_p
, info
->state
->file_symtabs
, ix
, elt
); ++ix
)
2930 iterate_over_all_matching_symtabs (name
, VAR_DOMAIN
,
2931 collect_symbols
, info
,
2933 search_minsyms_for_name (info
, name
, pspace
);
2935 else if (pspace
== NULL
|| pspace
== SYMTAB_PSPACE (elt
))
2937 /* Program spaces that are executing startup should have
2938 been filtered out earlier. */
2939 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
2940 set_current_program_space (SYMTAB_PSPACE (elt
));
2941 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt
), name
,
2942 VAR_DOMAIN
, collect_symbols
,
2948 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
2949 look in that symtab's static variables first. */
2951 static struct symtabs_and_lines
2952 decode_variable (struct linespec_state
*self
, char *copy
)
2954 struct collect_info info
;
2955 const char *lookup_name
;
2957 struct cleanup
*cleanup
;
2960 info
.result
.sals
= NULL
;
2961 info
.result
.nelts
= 0;
2963 cleanup
= demangle_for_lookup (copy
, current_language
->la_language
,
2965 if (current_language
->la_language
== language_ada
)
2967 /* In Ada, the symbol lookups are performed using the encoded
2968 name rather than the demangled name. */
2969 lookup_name
= ada_name_for_lookup (copy
);
2970 make_cleanup (xfree
, (void *) lookup_name
);
2973 canon
= cp_canonicalize_string_no_typedefs (lookup_name
);
2976 make_cleanup (xfree
, canon
);
2977 lookup_name
= canon
;
2980 add_matching_symbols_to_info (lookup_name
, &info
, NULL
);
2982 if (info
.result
.nelts
> 0)
2984 if (self
->canonical
)
2986 self
->canonical
->pre_expanded
= 1;
2987 if (self
->user_filename
)
2988 self
->canonical
->addr_string
2989 = xstrprintf ("%s:%s", self
->user_filename
, copy
);
2991 self
->canonical
->addr_string
= xstrdup (copy
);
2996 if (!have_full_symbols ()
2997 && !have_partial_symbols ()
2998 && !have_minimal_symbols ())
2999 throw_error (NOT_FOUND_ERROR
,
3000 _("No symbol table is loaded. Use the \"file\" command."));
3001 if (self
->user_filename
)
3002 throw_error (NOT_FOUND_ERROR
, _("Function \"%s\" not defined in \"%s\"."),
3003 copy
, self
->user_filename
);
3005 throw_error (NOT_FOUND_ERROR
, _("Function \"%s\" not defined."), copy
);
3011 /* Now come some functions that are called from multiple places within
3015 symbol_to_sal (struct symtab_and_line
*result
,
3016 int funfirstline
, struct symbol
*sym
)
3018 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3020 *result
= find_function_start_sal (sym
, funfirstline
);
3025 if (SYMBOL_CLASS (sym
) == LOC_LABEL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
3028 result
->symtab
= SYMBOL_SYMTAB (sym
);
3029 result
->line
= SYMBOL_LINE (sym
);
3030 result
->pc
= SYMBOL_VALUE_ADDRESS (sym
);
3031 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3032 result
->explicit_pc
= 1;
3035 else if (funfirstline
)
3039 else if (SYMBOL_LINE (sym
) != 0)
3041 /* We know its line number. */
3043 result
->symtab
= SYMBOL_SYMTAB (sym
);
3044 result
->line
= SYMBOL_LINE (sym
);
3045 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3053 /* See the comment in linespec.h. */
3056 init_linespec_result (struct linespec_result
*lr
)
3058 memset (lr
, 0, sizeof (*lr
));
3061 /* See the comment in linespec.h. */
3064 destroy_linespec_result (struct linespec_result
*ls
)
3067 struct linespec_sals
*lsal
;
3069 xfree (ls
->addr_string
);
3070 for (i
= 0; VEC_iterate (linespec_sals
, ls
->sals
, i
, lsal
); ++i
)
3072 xfree (lsal
->canonical
);
3073 xfree (lsal
->sals
.sals
);
3075 VEC_free (linespec_sals
, ls
->sals
);
3078 /* Cleanup function for a linespec_result. */
3081 cleanup_linespec_result (void *a
)
3083 destroy_linespec_result (a
);
3086 /* See the comment in linespec.h. */
3089 make_cleanup_destroy_linespec_result (struct linespec_result
*ls
)
3091 return make_cleanup (cleanup_linespec_result
, ls
);