1 /* Parser for linespec for the GNU debugger, GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
5 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
31 #include "completer.h"
33 #include "cp-support.h"
34 #include "parser-defs.h"
36 #include "objc-lang.h"
38 #include "exceptions.h"
41 #include "mi/mi-cmds.h"
43 #include "arch-utils.h"
45 #include "cli/cli-utils.h"
46 #include "filenames.h"
49 typedef struct symtab
*symtab_p
;
52 typedef struct symbol
*symbolp
;
55 typedef struct type
*typep
;
58 /* An address entry is used to ensure that any given location is only
59 added to the result a single time. It holds an address and the
60 program space from which the address came. */
64 struct program_space
*pspace
;
68 /* An instance of this is used to keep all state while linespec
69 operates. This instance is passed around as a 'this' pointer to
70 the various implementation methods. */
74 /* The program space as seen when the module was entered. */
75 struct program_space
*program_space
;
77 /* The default symtab to use, if no other symtab is specified. */
78 struct symtab
*default_symtab
;
80 /* The default line to use. */
83 /* If the linespec started with "FILE:", this holds all the matching
84 symtabs. Otherwise, it will hold a single NULL entry, meaning
85 that the default symtab should be used. */
86 VEC (symtab_p
) *file_symtabs
;
88 /* If the linespec started with "FILE:", this holds an xmalloc'd
92 /* If the linespec is "FUNCTION:LABEL", this holds an xmalloc'd copy
96 /* The 'funfirstline' value that was passed in to decode_line_1 or
100 /* Nonzero if we are running in 'list' mode; see decode_line_list. */
103 /* The 'canonical' value passed to decode_line_full, or NULL. */
104 struct linespec_result
*canonical
;
106 /* Canonical strings that mirror the symtabs_and_lines result. */
107 char **canonical_names
;
109 /* This is a set of address_entry objects which is used to prevent
110 duplicate symbols from being entered into the result. */
114 /* This is a helper object that is used when collecting symbols into a
119 /* The linespec object in use. */
120 struct linespec_state
*state
;
122 /* The result being accumulated. */
123 struct symtabs_and_lines result
;
126 /* Prototypes for local functions. */
128 static void initialize_defaults (struct symtab
**default_symtab
,
131 static struct symtabs_and_lines
decode_indirect (struct linespec_state
*self
,
134 static char *locate_first_half (char **argptr
, int *is_quote_enclosed
);
136 static struct symtabs_and_lines
decode_objc (struct linespec_state
*self
,
139 static struct symtabs_and_lines
decode_compound (struct linespec_state
*self
,
144 static VEC (symbolp
) *lookup_prefix_sym (char **argptr
, char *p
,
148 static struct symtabs_and_lines
find_method (struct linespec_state
*self
,
151 const char *class_name
,
152 VEC (symbolp
) *sym_classes
);
154 static void cplusplus_error (const char *name
, const char *fmt
, ...)
155 ATTRIBUTE_NORETURN
ATTRIBUTE_PRINTF (2, 3);
157 static char *find_toplevel_char (char *s
, char c
);
159 static int is_objc_method_format (const char *s
);
161 static VEC (symtab_p
) *symtabs_from_filename (char **argptr
,
162 char *p
, int is_quote_enclosed
,
163 char **user_filename
);
165 static VEC (symbolp
) *find_function_symbols (char **argptr
, char *p
,
166 int is_quote_enclosed
,
167 char **user_function
);
169 static struct symtabs_and_lines
decode_all_digits (struct linespec_state
*self
,
173 static struct symtabs_and_lines
decode_dollar (struct linespec_state
*self
,
176 static int decode_label (struct linespec_state
*self
,
177 VEC (symbolp
) *function_symbols
,
179 struct symtabs_and_lines
*result
);
181 static struct symtabs_and_lines
decode_variable (struct linespec_state
*self
,
184 static int symbol_to_sal (struct symtab_and_line
*result
,
185 int funfirstline
, struct symbol
*sym
);
187 static void add_matching_symbols_to_info (const char *name
,
188 struct collect_info
*info
,
189 struct program_space
*pspace
);
191 static void add_all_symbol_names_from_pspace (struct collect_info
*info
,
192 struct program_space
*pspace
,
193 VEC (const_char_ptr
) *names
);
195 /* Helper functions. */
197 /* Add SAL to SALS. */
200 add_sal_to_sals_basic (struct symtabs_and_lines
*sals
,
201 struct symtab_and_line
*sal
)
204 sals
->sals
= xrealloc (sals
->sals
, sals
->nelts
* sizeof (sals
->sals
[0]));
205 sals
->sals
[sals
->nelts
- 1] = *sal
;
208 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
209 the new sal, if needed. If not NULL, SYMNAME is the name of the
210 symbol to use when constructing the new canonical name. */
213 add_sal_to_sals (struct linespec_state
*self
,
214 struct symtabs_and_lines
*sals
,
215 struct symtab_and_line
*sal
,
218 add_sal_to_sals_basic (sals
, sal
);
222 char *canonical_name
= NULL
;
224 self
->canonical_names
= xrealloc (self
->canonical_names
,
225 sals
->nelts
* sizeof (char *));
226 if (sal
->symtab
&& sal
->symtab
->filename
)
228 char *filename
= sal
->symtab
->filename
;
230 /* Note that the filter doesn't have to be a valid linespec
231 input. We only apply the ":LINE" treatment to Ada for
233 if (symname
!= NULL
&& sal
->line
!= 0
234 && current_language
->la_language
== language_ada
)
235 canonical_name
= xstrprintf ("%s:%s:%d", filename
, symname
,
237 else if (symname
!= NULL
)
238 canonical_name
= xstrprintf ("%s:%s", filename
, symname
);
240 canonical_name
= xstrprintf ("%s:%d", filename
, sal
->line
);
243 self
->canonical_names
[sals
->nelts
- 1] = canonical_name
;
247 /* A hash function for address_entry. */
250 hash_address_entry (const void *p
)
252 const struct address_entry
*aep
= p
;
255 hash
= iterative_hash_object (aep
->pspace
, 0);
256 return iterative_hash_object (aep
->addr
, hash
);
259 /* An equality function for address_entry. */
262 eq_address_entry (const void *a
, const void *b
)
264 const struct address_entry
*aea
= a
;
265 const struct address_entry
*aeb
= b
;
267 return aea
->pspace
== aeb
->pspace
&& aea
->addr
== aeb
->addr
;
270 /* Check whether the address, represented by PSPACE and ADDR, is
271 already in the set. If so, return 0. Otherwise, add it and return
275 maybe_add_address (htab_t set
, struct program_space
*pspace
, CORE_ADDR addr
)
277 struct address_entry e
, *p
;
282 slot
= htab_find_slot (set
, &e
, INSERT
);
286 p
= XNEW (struct address_entry
);
287 memcpy (p
, &e
, sizeof (struct address_entry
));
293 /* Issue a helpful hint on using the command completion feature on
294 single quoted demangled C++ symbols as part of the completion
298 cplusplus_error (const char *name
, const char *fmt
, ...)
300 struct ui_file
*tmp_stream
;
303 tmp_stream
= mem_fileopen ();
304 make_cleanup_ui_file_delete (tmp_stream
);
309 va_start (args
, fmt
);
310 vfprintf_unfiltered (tmp_stream
, fmt
, args
);
314 while (*name
== '\'')
316 fprintf_unfiltered (tmp_stream
,
317 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
318 "(Note leading single quote.)"),
321 message
= ui_file_xstrdup (tmp_stream
, NULL
);
322 make_cleanup (xfree
, message
);
323 throw_error (NOT_FOUND_ERROR
, "%s", message
);
326 /* A helper for iterate_over_all_matching_symtabs that is passed as a
327 callback to the expand_symtabs_matching method. */
330 iterate_name_matcher (const struct language_defn
*language
,
331 const char *name
, void *d
)
333 const char **dname
= d
;
335 if (language
->la_symbol_name_compare (name
, *dname
) == 0)
340 /* A helper that walks over all matching symtabs in all objfiles and
341 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
342 not NULL, then the search is restricted to just that program
346 iterate_over_all_matching_symtabs (const char *name
,
347 const domain_enum domain
,
348 int (*callback
) (struct symbol
*, void *),
350 struct program_space
*search_pspace
)
352 struct objfile
*objfile
;
353 struct program_space
*pspace
;
357 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
359 if (pspace
->executing_startup
)
362 set_current_program_space (pspace
);
364 ALL_OBJFILES (objfile
)
366 struct symtab
*symtab
;
369 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, NULL
,
370 iterate_name_matcher
,
374 ALL_OBJFILE_SYMTABS (objfile
, symtab
)
380 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
381 LA_ITERATE_OVER_SYMBOLS (block
, name
, domain
, callback
, data
);
388 /* Returns the block to be used for symbol searches for the given SYMTAB,
389 which may be NULL. */
391 static struct block
*
392 get_search_block (struct symtab
*symtab
)
397 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
400 enum language save_language
;
402 /* get_selected_block can change the current language when there is
403 no selected frame yet. */
404 save_language
= current_language
->la_language
;
405 block
= get_selected_block (0);
406 set_language (save_language
);
412 /* A helper for find_method. This finds all methods in type T which
413 match NAME. It adds resulting symbol names to RESULT_NAMES, and
414 adds T's direct superclasses to SUPERCLASSES. */
417 find_methods (struct type
*t
, const char *name
,
418 VEC (const_char_ptr
) **result_names
,
419 VEC (typep
) **superclasses
)
423 char *class_name
= type_name_no_tag (t
);
426 /* Ignore this class if it doesn't have a name. This is ugly, but
427 unless we figure out how to get the physname without the name of
428 the class, then the loop can't do any good. */
432 int name_len
= strlen (name
);
436 /* Loop over each method name. At this level, all overloads of a name
437 are counted as a single name. There is an inner loop which loops over
440 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
444 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
447 if (strncmp (method_name
, "__", 2) == 0 ||
448 strncmp (method_name
, "op", 2) == 0 ||
449 strncmp (method_name
, "type", 4) == 0)
451 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
452 method_name
= dem_opname
;
453 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
454 method_name
= dem_opname
;
457 if (strcmp_iw (method_name
, name
) == 0)
461 for (field_counter
= (TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
)
467 const char *phys_name
;
469 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
470 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
472 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
473 VEC_safe_push (const_char_ptr
, *result_names
, phys_name
);
479 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
480 VEC_safe_push (typep
, *superclasses
, TYPE_BASECLASS (t
, ibase
));
483 /* Find an instance of the character C in the string S that is outside
484 of all parenthesis pairs, single-quoted strings, and double-quoted
485 strings. Also, ignore the char within a template name, like a ','
486 within foo<int, int>. */
489 find_toplevel_char (char *s
, char c
)
491 int quoted
= 0; /* zero if we're not in quotes;
492 '"' if we're in a double-quoted string;
493 '\'' if we're in a single-quoted string. */
494 int depth
= 0; /* Number of unclosed parens we've seen. */
497 for (scan
= s
; *scan
; scan
++)
503 else if (*scan
== '\\' && *(scan
+ 1))
506 else if (*scan
== c
&& ! quoted
&& depth
== 0)
508 else if (*scan
== '"' || *scan
== '\'')
510 else if (*scan
== '(' || *scan
== '<')
512 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
519 /* Determines if the gives string corresponds to an Objective-C method
520 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
521 are allowed to have spaces and parentheses in them. */
524 is_objc_method_format (const char *s
)
526 if (s
== NULL
|| *s
== '\0')
528 /* Handle arguments with the format FILENAME:SYMBOL. */
529 if ((s
[0] == ':') && (strchr ("+-", s
[1]) != NULL
)
530 && (s
[2] == '[') && strchr(s
, ']'))
532 /* Handle arguments that are just SYMBOL. */
533 else if ((strchr ("+-", s
[0]) != NULL
) && (s
[1] == '[') && strchr(s
, ']'))
538 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
539 and store the result in SELF->CANONICAL. */
542 filter_results (struct linespec_state
*self
,
543 struct symtabs_and_lines
*result
,
544 VEC (const_char_ptr
) *filters
)
549 for (i
= 0; VEC_iterate (const_char_ptr
, filters
, i
, name
); ++i
)
551 struct linespec_sals lsal
;
554 memset (&lsal
, 0, sizeof (lsal
));
556 for (j
= 0; j
< result
->nelts
; ++j
)
558 if (strcmp (name
, self
->canonical_names
[j
]) == 0)
559 add_sal_to_sals_basic (&lsal
.sals
, &result
->sals
[j
]);
562 if (lsal
.sals
.nelts
> 0)
564 lsal
.canonical
= xstrdup (name
);
565 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
569 self
->canonical
->pre_expanded
= 0;
572 /* Store RESULT into SELF->CANONICAL. */
575 convert_results_to_lsals (struct linespec_state
*self
,
576 struct symtabs_and_lines
*result
)
578 struct linespec_sals lsal
;
580 lsal
.canonical
= NULL
;
582 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
585 /* Handle multiple results in RESULT depending on SELECT_MODE. This
586 will either return normally, throw an exception on multiple
587 results, or present a menu to the user. On return, the SALS vector
588 in SELF->CANONICAL is set up properly. */
591 decode_line_2 (struct linespec_state
*self
,
592 struct symtabs_and_lines
*result
,
593 const char *select_mode
)
598 struct cleanup
*old_chain
;
599 VEC (const_char_ptr
) *item_names
= NULL
, *filters
= NULL
;
600 struct get_number_or_range_state state
;
602 gdb_assert (select_mode
!= multiple_symbols_all
);
603 gdb_assert (self
->canonical
!= NULL
);
605 old_chain
= make_cleanup (VEC_cleanup (const_char_ptr
), &item_names
);
606 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
607 for (i
= 0; i
< result
->nelts
; ++i
)
612 gdb_assert (self
->canonical_names
[i
] != NULL
);
613 for (j
= 0; VEC_iterate (const_char_ptr
, item_names
, j
, iter
); ++j
)
615 if (strcmp (iter
, self
->canonical_names
[i
]) == 0)
623 VEC_safe_push (const_char_ptr
, item_names
, self
->canonical_names
[i
]);
626 if (select_mode
== multiple_symbols_cancel
627 && VEC_length (const_char_ptr
, item_names
) > 1)
628 error (_("canceled because the command is ambiguous\n"
629 "See set/show multiple-symbol."));
631 if (select_mode
== multiple_symbols_all
632 || VEC_length (const_char_ptr
, item_names
) == 1)
634 do_cleanups (old_chain
);
635 convert_results_to_lsals (self
, result
);
639 printf_unfiltered (_("[0] cancel\n[1] all\n"));
640 for (i
= 0; VEC_iterate (const_char_ptr
, item_names
, i
, iter
); ++i
)
641 printf_unfiltered ("[%d] %s\n", i
+ 2, iter
);
643 prompt
= getenv ("PS2");
648 args
= command_line_input (prompt
, 0, "overload-choice");
650 if (args
== 0 || *args
== 0)
651 error_no_arg (_("one or more choice numbers"));
653 init_number_or_range (&state
, args
);
654 while (!state
.finished
)
658 num
= get_number_or_range (&state
);
661 error (_("canceled"));
664 /* We intentionally make this result in a single breakpoint,
665 contrary to what older versions of gdb did. The
666 rationale is that this lets a user get the
667 multiple_symbols_all behavior even with the 'ask'
668 setting; and he can get separate breakpoints by entering
669 "2-57" at the query. */
670 do_cleanups (old_chain
);
671 convert_results_to_lsals (self
, result
);
676 if (num
>= VEC_length (const_char_ptr
, item_names
))
677 printf_unfiltered (_("No choice number %d.\n"), num
);
680 const char *elt
= VEC_index (const_char_ptr
, item_names
, num
);
684 VEC_safe_push (const_char_ptr
, filters
, elt
);
685 VEC_replace (const_char_ptr
, item_names
, num
, NULL
);
689 printf_unfiltered (_("duplicate request for %d ignored.\n"),
695 filter_results (self
, result
, filters
);
696 do_cleanups (old_chain
);
699 /* Valid delimiters for linespec keywords "if", "thread" or "task". */
702 is_linespec_boundary (char c
)
704 return c
== ' ' || c
== '\t' || c
== '\0' || c
== ',';
707 /* A helper function for decode_line_1 and friends which skips P
708 past any method overload information at the beginning of P, e.g.,
709 "(const struct foo *)".
711 This function assumes that P has already been validated to contain
712 overload information, and it will assert if *P != '('. */
714 find_method_overload_end (char *p
)
718 gdb_assert (*p
== '(');
738 /* Keep important information used when looking up a name. This includes
739 template parameters, overload information, and important keywords, including
740 the possible Java trailing type. */
743 keep_name_info (char *p
, int on_boundary
)
745 const char *quotes
= get_gdb_completer_quote_characters ();
751 if (strchr (quotes
, *p
))
754 if (*p
== ',' && !nest
)
757 if (on_boundary
&& !nest
)
759 const char *const words
[] = { "if", "thread", "task" };
762 for (wordi
= 0; wordi
< ARRAY_SIZE (words
); wordi
++)
763 if (strncmp (p
, words
[wordi
], strlen (words
[wordi
])) == 0
764 && is_linespec_boundary (p
[strlen (words
[wordi
])]))
766 if (wordi
< ARRAY_SIZE (words
))
770 if (*p
== '(' || *p
== '<' || *p
== '[')
772 else if ((*p
== ')' || *p
== '>' || *p
== ']') && nest
> 0)
777 /* The ',' check could fail on "operator ,". */
778 p
+= cp_validate_operator (p
);
780 on_boundary
= is_linespec_boundary (p
[-1]);
783 while (p
> saved_p
&& is_linespec_boundary (p
[-1]))
790 /* The parser of linespec itself. */
792 /* Parse a string that specifies a line number.
793 Pass the address of a char * variable; that variable will be
794 advanced over the characters actually parsed.
798 LINENUM -- that line number in current file. PC returned is 0.
799 FILE:LINENUM -- that line in that file. PC returned is 0.
800 FUNCTION -- line number of openbrace of that function.
801 PC returned is the start of the function.
802 LABEL -- a label in the current scope
803 VARIABLE -- line number of definition of that variable.
805 FILE:FUNCTION -- likewise, but prefer functions in that file.
806 *EXPR -- line in which address EXPR appears.
808 This may all be followed by an "if EXPR", which we ignore.
810 FUNCTION may be an undebuggable function found in minimal symbol table.
812 If the argument FUNFIRSTLINE is nonzero, we want the first line
813 of real code inside a function when a function is specified, and it is
814 not OK to specify a variable or type to get its line number.
816 DEFAULT_SYMTAB specifies the file to use if none is specified.
817 It defaults to current_source_symtab.
818 DEFAULT_LINE specifies the line number to use for relative
819 line numbers (that start with signs). Defaults to current_source_line.
820 If CANONICAL is non-NULL, store an array of strings containing the canonical
821 line specs there if necessary. Currently overloaded member functions and
822 line numbers or static functions without a filename yield a canonical
823 line spec. The array and the line spec strings are allocated on the heap,
824 it is the callers responsibility to free them.
826 Note that it is possible to return zero for the symtab
827 if no file is validly specified. Callers must check that.
828 Also, the line number returned may be invalid. */
830 /* We allow single quotes in various places. This is a hideous
831 kludge, which exists because the completer can't yet deal with the
832 lack of single quotes. FIXME: write a linespec_completer which we
833 can use as appropriate instead of make_symbol_completion_list. */
835 static struct symtabs_and_lines
836 decode_line_internal (struct linespec_state
*self
, char **argptr
)
842 /* This says whether or not something in *ARGPTR is quoted with
843 completer_quotes (i.e. with single quotes). */
845 /* Is *ARGPTR enclosed in double quotes? */
846 int is_quote_enclosed
;
847 int is_objc_method
= 0;
848 char *saved_arg
= *argptr
;
849 /* If IS_QUOTED, the end of the quoted bit. */
850 char *end_quote
= NULL
;
851 /* Is *ARGPTR enclosed in single quotes? */
852 int is_squote_enclosed
= 0;
853 /* The "first half" of the linespec. */
856 /* If we are parsing `function:label', this holds the symbols
857 matching the function name. */
858 VEC (symbolp
) *function_symbols
= NULL
;
859 /* If FUNCTION_SYMBOLS is not NULL, then this is the exception that
860 was thrown when trying to parse a filename. */
861 volatile struct gdb_exception file_exception
;
863 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
865 /* Defaults have defaults. */
867 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
869 /* See if arg is *PC. */
873 do_cleanups (cleanup
);
874 return decode_indirect (self
, argptr
);
877 is_quoted
= (strchr (get_gdb_completer_quote_characters (),
882 end_quote
= skip_quoted (*argptr
);
883 if (*end_quote
== '\0')
884 is_squote_enclosed
= 1;
887 /* Check to see if it's a multipart linespec (with colons or
890 /* Locate the end of the first half of the linespec.
891 After the call, for instance, if the argptr string is "foo.c:123"
892 p will point at "123". If there is only one part, like "foo", p
893 will point to "". If this is a C++ name, like "A::B::foo", p will
894 point to "::B::foo". Argptr is not changed by this call. */
896 first_half
= p
= locate_first_half (argptr
, &is_quote_enclosed
);
898 /* First things first: if ARGPTR starts with a filename, get its
899 symtab and strip the filename from ARGPTR. */
900 TRY_CATCH (file_exception
, RETURN_MASK_ERROR
)
902 self
->file_symtabs
= symtabs_from_filename (argptr
, p
, is_quote_enclosed
,
903 &self
->user_filename
);
906 if (VEC_empty (symtab_p
, self
->file_symtabs
))
908 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
909 VEC_safe_push (symtab_p
, self
->file_symtabs
, NULL
);
912 if (file_exception
.reason
>= 0)
914 /* Check for single quotes on the non-filename part. */
915 is_quoted
= (**argptr
916 && strchr (get_gdb_completer_quote_characters (),
919 end_quote
= skip_quoted (*argptr
);
921 /* Locate the next "half" of the linespec. */
922 first_half
= p
= locate_first_half (argptr
, &is_quote_enclosed
);
925 /* Check if this is an Objective-C method (anything that starts with
926 a '+' or '-' and a '['). */
927 if (is_objc_method_format (p
))
930 /* Check if the symbol could be an Objective-C selector. */
933 struct symtabs_and_lines values
;
935 values
= decode_objc (self
, argptr
);
936 if (values
.sals
!= NULL
)
938 do_cleanups (cleanup
);
943 /* Does it look like there actually were two parts? */
945 if (p
[0] == ':' || p
[0] == '.')
947 /* Is it a C++ or Java compound data structure?
948 The check on p[1] == ':' is capturing the case of "::",
949 since p[0]==':' was checked above.
950 Note that the call to decode_compound does everything
951 for us, including the lookup on the symbol table, so we
954 if (p
[0] == '.' || p
[1] == ':')
956 struct symtabs_and_lines values
;
957 volatile struct gdb_exception ex
;
958 char *saved_argptr
= *argptr
;
960 if (is_quote_enclosed
)
963 /* Initialize it just to avoid a GCC false warning. */
964 memset (&values
, 0, sizeof (values
));
966 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
968 values
= decode_compound (self
, argptr
, saved_arg
, p
);
970 if ((is_quoted
|| is_squote_enclosed
) && **argptr
== '\'')
971 *argptr
= *argptr
+ 1;
975 do_cleanups (cleanup
);
979 if (ex
.error
!= NOT_FOUND_ERROR
)
980 throw_exception (ex
);
982 *argptr
= saved_argptr
;
986 /* If there was an exception looking up a specified filename earlier,
987 then check whether we were really given `function:label'. */
988 if (file_exception
.reason
< 0)
990 function_symbols
= find_function_symbols (argptr
, p
,
992 &self
->user_function
);
994 /* If we did not find a function, re-throw the original
996 if (!function_symbols
)
997 throw_exception (file_exception
);
999 make_cleanup (VEC_cleanup (symbolp
), &function_symbols
);
1002 /* Check for single quotes on the non-filename part. */
1005 is_quoted
= (**argptr
1006 && strchr (get_gdb_completer_quote_characters (),
1009 end_quote
= skip_quoted (*argptr
);
1014 /* self->file_symtabs holds the specified file symtabs, or 0 if no file
1016 If we are parsing `function:symbol', then FUNCTION_SYMBOLS holds the
1017 functions before the `:'.
1018 arg no longer contains the file name. */
1020 /* If the filename was quoted, we must re-check the quotation. */
1022 if (end_quote
== first_half
&& *end_quote
!= '\0')
1024 is_quoted
= (**argptr
1025 && strchr (get_gdb_completer_quote_characters (),
1028 end_quote
= skip_quoted (*argptr
);
1031 /* Check whether arg is all digits (and sign). */
1034 if (*q
== '-' || *q
== '+')
1036 while (*q
>= '0' && *q
<= '9')
1039 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ',')
1040 && function_symbols
== NULL
)
1042 struct symtabs_and_lines values
;
1044 /* We found a token consisting of all digits -- at least one digit. */
1045 values
= decode_all_digits (self
, argptr
, q
);
1046 do_cleanups (cleanup
);
1050 /* Arg token is not digits => try it as a variable name
1051 Find the next token (everything up to end or next whitespace). */
1053 if (**argptr
== '$') /* May be a convenience variable. */
1054 /* One or two $ chars possible. */
1055 p
= skip_quoted (*argptr
+ (((*argptr
)[1] == '$') ? 2 : 1));
1056 else if (is_quoted
|| is_squote_enclosed
)
1060 error (_("Unmatched single quote."));
1062 else if (is_objc_method
)
1064 /* allow word separators in method names for Obj-C. */
1065 p
= skip_quoted_chars (*argptr
, NULL
, "");
1069 p
= skip_quoted (*argptr
);
1072 /* Keep any important naming information. */
1073 p
= keep_name_info (p
, p
== saved_arg
|| is_linespec_boundary (p
[-1]));
1075 copy
= (char *) alloca (p
- *argptr
+ 1);
1076 memcpy (copy
, *argptr
, p
- *argptr
);
1077 copy
[p
- *argptr
] = '\0';
1080 && copy
[0] == copy
[p
- *argptr
- 1]
1081 && strchr (get_gdb_completer_quote_characters (), copy
[0]) != NULL
)
1083 copy
[p
- *argptr
- 1] = '\0';
1086 else if (is_quoted
|| is_squote_enclosed
)
1087 copy
[p
- *argptr
- 1] = '\0';
1089 *argptr
= skip_spaces (p
);
1091 /* If it starts with $: may be a legitimate variable or routine name
1092 (e.g. HP-UX millicode routines such as $$dyncall), or it may
1093 be history value, or it may be a convenience variable. */
1095 if (*copy
== '$' && function_symbols
== NULL
)
1097 struct symtabs_and_lines values
;
1099 values
= decode_dollar (self
, copy
);
1100 do_cleanups (cleanup
);
1104 /* Try the token as a label, but only if no file was specified,
1105 because we can only really find labels in the current scope. */
1107 if (VEC_length (symtab_p
, self
->file_symtabs
) == 1
1108 && VEC_index (symtab_p
, self
->file_symtabs
, 0) == NULL
)
1110 struct symtabs_and_lines label_result
;
1111 if (decode_label (self
, function_symbols
, copy
, &label_result
))
1113 do_cleanups (cleanup
);
1114 return label_result
;
1118 if (function_symbols
)
1119 throw_exception (file_exception
);
1121 /* Look up that token as a variable.
1122 If file specified, use that file's per-file block to start with. */
1125 struct symtabs_and_lines values
;
1127 values
= decode_variable (self
, copy
);
1128 do_cleanups (cleanup
);
1133 /* A constructor for linespec_state. */
1136 linespec_state_constructor (struct linespec_state
*self
,
1138 struct symtab
*default_symtab
,
1140 struct linespec_result
*canonical
)
1142 memset (self
, 0, sizeof (*self
));
1143 self
->funfirstline
= (flags
& DECODE_LINE_FUNFIRSTLINE
) ? 1 : 0;
1144 self
->list_mode
= (flags
& DECODE_LINE_LIST_MODE
) ? 1 : 0;
1145 self
->default_symtab
= default_symtab
;
1146 self
->default_line
= default_line
;
1147 self
->canonical
= canonical
;
1148 self
->program_space
= current_program_space
;
1149 self
->addr_set
= htab_create_alloc (10, hash_address_entry
, eq_address_entry
,
1150 xfree
, xcalloc
, xfree
);
1153 /* A destructor for linespec_state. */
1156 linespec_state_destructor (void *arg
)
1158 struct linespec_state
*self
= arg
;
1160 xfree (self
->user_filename
);
1161 xfree (self
->user_function
);
1162 VEC_free (symtab_p
, self
->file_symtabs
);
1163 htab_delete (self
->addr_set
);
1166 /* See linespec.h. */
1169 decode_line_full (char **argptr
, int flags
,
1170 struct symtab
*default_symtab
,
1171 int default_line
, struct linespec_result
*canonical
,
1172 const char *select_mode
,
1175 struct symtabs_and_lines result
;
1176 struct linespec_state state
;
1177 struct cleanup
*cleanups
;
1178 char *arg_start
= *argptr
;
1179 VEC (const_char_ptr
) *filters
= NULL
;
1181 gdb_assert (canonical
!= NULL
);
1182 /* The filter only makes sense for 'all'. */
1183 gdb_assert (filter
== NULL
|| select_mode
== multiple_symbols_all
);
1184 gdb_assert (select_mode
== NULL
1185 || select_mode
== multiple_symbols_all
1186 || select_mode
== multiple_symbols_ask
1187 || select_mode
== multiple_symbols_cancel
);
1188 gdb_assert ((flags
& DECODE_LINE_LIST_MODE
) == 0);
1190 linespec_state_constructor (&state
, flags
,
1191 default_symtab
, default_line
, canonical
);
1192 cleanups
= make_cleanup (linespec_state_destructor
, &state
);
1193 save_current_program_space ();
1195 result
= decode_line_internal (&state
, argptr
);
1197 gdb_assert (result
.nelts
== 1 || canonical
->pre_expanded
);
1198 gdb_assert (canonical
->addr_string
!= NULL
);
1199 canonical
->pre_expanded
= 1;
1201 /* Fill in the missing canonical names. */
1202 if (result
.nelts
> 0)
1206 if (state
.canonical_names
== NULL
)
1207 state
.canonical_names
= xcalloc (result
.nelts
, sizeof (char *));
1208 make_cleanup (xfree
, state
.canonical_names
);
1209 for (i
= 0; i
< result
.nelts
; ++i
)
1211 if (state
.canonical_names
[i
] == NULL
)
1212 state
.canonical_names
[i
] = savestring (arg_start
,
1213 *argptr
- arg_start
);
1214 make_cleanup (xfree
, state
.canonical_names
[i
]);
1218 if (select_mode
== NULL
)
1220 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
1221 select_mode
= multiple_symbols_all
;
1223 select_mode
= multiple_symbols_select_mode ();
1226 if (select_mode
== multiple_symbols_all
)
1230 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
1231 VEC_safe_push (const_char_ptr
, filters
, filter
);
1232 filter_results (&state
, &result
, filters
);
1235 convert_results_to_lsals (&state
, &result
);
1238 decode_line_2 (&state
, &result
, select_mode
);
1240 do_cleanups (cleanups
);
1243 struct symtabs_and_lines
1244 decode_line_1 (char **argptr
, int flags
,
1245 struct symtab
*default_symtab
,
1248 struct symtabs_and_lines result
;
1249 struct linespec_state state
;
1250 struct cleanup
*cleanups
;
1252 linespec_state_constructor (&state
, flags
,
1253 default_symtab
, default_line
, NULL
);
1254 cleanups
= make_cleanup (linespec_state_destructor
, &state
);
1255 save_current_program_space ();
1257 result
= decode_line_internal (&state
, argptr
);
1258 do_cleanups (cleanups
);
1264 /* First, some functions to initialize stuff at the beggining of the
1268 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
1270 if (*default_symtab
== 0)
1272 /* Use whatever we have for the default source line. We don't use
1273 get_current_or_default_symtab_and_line as it can recurse and call
1275 struct symtab_and_line cursal
=
1276 get_current_source_symtab_and_line ();
1278 *default_symtab
= cursal
.symtab
;
1279 *default_line
= cursal
.line
;
1285 /* Decode arg of the form *PC. */
1287 static struct symtabs_and_lines
1288 decode_indirect (struct linespec_state
*self
, char **argptr
)
1290 struct symtabs_and_lines values
;
1292 char *initial
= *argptr
;
1294 if (current_program_space
->executing_startup
)
1295 /* The error message doesn't really matter, because this case
1296 should only hit during breakpoint reset. */
1297 throw_error (NOT_FOUND_ERROR
, _("cannot evaluate expressions while "
1298 "program space is in startup"));
1301 pc
= value_as_address (parse_to_comma_and_eval (argptr
));
1303 values
.sals
= (struct symtab_and_line
*)
1304 xmalloc (sizeof (struct symtab_and_line
));
1307 values
.sals
[0] = find_pc_line (pc
, 0);
1308 values
.sals
[0].pc
= pc
;
1309 values
.sals
[0].section
= find_pc_overlay (pc
);
1310 values
.sals
[0].explicit_pc
= 1;
1312 if (self
->canonical
)
1313 self
->canonical
->addr_string
= savestring (initial
, *argptr
- initial
);
1320 /* Locate the first half of the linespec, ending in a colon, period,
1321 or whitespace. (More or less.) Also, check to see if *ARGPTR is
1322 enclosed in double quotes; if so, set is_quote_enclosed, advance
1323 ARGPTR past that and zero out the trailing double quote.
1324 If ARGPTR is just a simple name like "main", p will point to ""
1328 locate_first_half (char **argptr
, int *is_quote_enclosed
)
1334 /* Check if the linespec starts with an Ada operator (such as "+",
1335 or ">", for instance). */
1338 && current_language
->la_language
== language_ada
)
1340 const struct ada_opname_map
*op
;
1342 for (op
= ada_opname_table
; op
->encoded
!= NULL
; op
++)
1343 if (strncmp (op
->decoded
, p
, strlen (op
->decoded
)) == 0)
1345 if (op
->encoded
!= NULL
)
1347 *is_quote_enclosed
= 0;
1348 return p
+ strlen (op
->decoded
);
1352 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1353 and we must isolate the first half. Outer layers will call again later
1354 for the second half.
1356 Don't count commas that appear in argument lists of overloaded
1357 functions, or in quoted strings. It's stupid to go to this much
1358 trouble when the rest of the function is such an obvious roach hotel. */
1359 ii
= find_toplevel_char (*argptr
, ',');
1360 has_comma
= (ii
!= 0);
1362 /* Temporarily zap out second half to not confuse the code below.
1363 This is undone below. Do not change ii!! */
1369 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
1370 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
1376 *is_quote_enclosed
= 1;
1382 *is_quote_enclosed
= 0;
1383 if (strchr (get_gdb_completer_quote_characters (), *p
))
1391 /* Check for a drive letter in the filename. This is done on all hosts
1392 to capture cross-compilation environments. On Unixen, directory
1393 separators are illegal in filenames, so if the user enters "e:/foo.c",
1394 he is referring to a directory named "e:" and a source file named
1395 "foo.c", and we still want to keep these two pieces together. */
1396 if (isalpha (p
[0]) && p
[1] == ':' && IS_DIR_SEPARATOR (p
[2]))
1403 char *temp_end
= find_template_name_end (p
);
1406 error (_("malformed template specification in command"));
1411 p
= find_method_overload_end (p
);
1413 /* Check for a colon and a plus or minus and a [ (which
1414 indicates an Objective-C method). */
1415 if (is_objc_method_format (p
))
1419 /* Check for the end of the first half of the linespec. End of
1420 line, a tab, a colon or a space. But if enclosed in double
1421 quotes we do not break on enclosed spaces. */
1425 || ((p
[0] == ' ') && !*is_quote_enclosed
))
1427 if (p
[0] == '.' && strchr (p
, ':') == NULL
)
1429 /* Java qualified method. Find the *last* '.', since the
1430 others are package qualifiers. Stop at any open parenthesis
1431 which might provide overload information. */
1432 for (p1
= p
; *p1
&& *p1
!= '('; p1
++)
1440 p
= skip_spaces (p
);
1442 /* If the closing double quote was left at the end, remove it. */
1443 if (*is_quote_enclosed
)
1445 char *closing_quote
= strchr (p
- 1, '"');
1447 if (closing_quote
&& closing_quote
[1] == '\0')
1448 *closing_quote
= '\0';
1451 /* Now that we've safely parsed the first half, put back ',' so
1452 outer layers can see it. */
1461 /* Here's where we recognise an Objective-C Selector. An Objective C
1462 selector may be implemented by more than one class, therefore it
1463 may represent more than one method/function. This gives us a
1464 situation somewhat analogous to C++ overloading. If there's more
1465 than one method that could represent the selector, then use some of
1466 the existing C++ code to let the user choose one. */
1468 static struct symtabs_and_lines
1469 decode_objc (struct linespec_state
*self
, char **argptr
)
1471 struct collect_info info
;
1472 VEC (const_char_ptr
) *symbol_names
= NULL
;
1474 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (const_char_ptr
),
1478 info
.result
.sals
= NULL
;
1479 info
.result
.nelts
= 0;
1481 new_argptr
= find_imps (*argptr
, &symbol_names
);
1482 if (VEC_empty (const_char_ptr
, symbol_names
))
1484 do_cleanups (cleanup
);
1488 add_all_symbol_names_from_pspace (&info
, NULL
, symbol_names
);
1490 if (info
.result
.nelts
> 0)
1494 saved_arg
= alloca (new_argptr
- *argptr
+ 1);
1495 memcpy (saved_arg
, *argptr
, new_argptr
- *argptr
);
1496 saved_arg
[new_argptr
- *argptr
] = '\0';
1498 if (self
->canonical
)
1500 self
->canonical
->pre_expanded
= 1;
1501 if (self
->user_filename
)
1502 self
->canonical
->addr_string
1503 = xstrprintf ("%s:%s", self
->user_filename
, saved_arg
);
1505 self
->canonical
->addr_string
= xstrdup (saved_arg
);
1509 *argptr
= new_argptr
;
1511 do_cleanups (cleanup
);
1515 /* This handles C++ and Java compound data structures. P should point
1516 at the first component separator, i.e. double-colon or period. As
1517 an example, on entrance to this function we could have ARGPTR
1518 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
1520 static struct symtabs_and_lines
1521 decode_compound (struct linespec_state
*self
,
1522 char **argptr
, char *the_real_saved_arg
, char *p
)
1524 struct symtabs_and_lines values
;
1526 char *saved_arg2
= *argptr
;
1530 VEC (symbolp
) *sym_classes
;
1531 char *saved_arg
, *class_name
;
1532 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1534 /* If the user specified any completer quote characters in the input,
1535 strip them. They are superfluous. */
1536 saved_arg
= alloca (strlen (the_real_saved_arg
) + 1);
1538 char *dst
= saved_arg
;
1539 char *src
= the_real_saved_arg
;
1540 char *quotes
= get_gdb_completer_quote_characters ();
1541 while (*src
!= '\0')
1543 if (strchr (quotes
, *src
) == NULL
)
1550 /* First check for "global" namespace specification, of the form
1551 "::foo". If found, skip over the colons and jump to normal
1552 symbol processing. I.e. the whole line specification starts with
1553 "::" (note the condition that *argptr == p). */
1555 && ((*argptr
== p
) || (p
[-1] == ' ') || (p
[-1] == '\t')))
1558 /* Given our example "AAA::inA::fun", we have two cases to consider:
1560 1) AAA::inA is the name of a class. In that case, presumably it
1561 has a method called "fun"; we then look up that method using
1564 2) AAA::inA isn't the name of a class. In that case, either the
1565 user made a typo, AAA::inA is the name of a namespace, or it is
1566 the name of a minimal symbol.
1567 In this case we just delegate to decode_variable.
1569 Thus, our first task is to find everything before the last set of
1570 double-colons and figure out if it's the name of a class. So we
1571 first loop through all of the double-colons. */
1573 p2
= p
; /* Save for restart. */
1575 /* This is very messy. Following the example above we have now the
1578 argptr -> "AAA::inA::fun
1579 saved_arg -> "AAA::inA::fun
1580 saved_arg2 -> "AAA::inA::fun
1581 p2 -> "::inA::fun". */
1583 /* In the loop below, with these strings, we'll make 2 passes, each
1584 is marked in comments. */
1588 static char *break_characters
= " \t(";
1590 /* Move pointer up to next possible class/namespace token. */
1592 p
= p2
+ 1; /* Restart with old value +1. */
1594 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1595 i.e. if there is a double-colon, p will now point to the
1597 /* PASS2: p2->"::fun", p->":fun" */
1599 /* Move pointer ahead to next double-colon. */
1601 && strchr (break_characters
, *p
) == NULL
1602 && strchr (get_gdb_completer_quote_characters (), *p
) == NULL
)
1604 if (current_language
->la_language
== language_cplus
)
1605 p
+= cp_validate_operator (p
);
1609 temp_end
= find_template_name_end (p
);
1611 error (_("malformed template specification in command"));
1614 /* Note that, since, at the start of this loop, p would be
1615 pointing to the second colon in a double-colon, we only
1616 satisfy the condition below if there is another
1617 double-colon to the right (after). I.e. there is another
1618 component that can be a class or a namespace. I.e, if at
1619 the beginning of this loop (PASS1), we had
1620 p->":inA::fun", we'll trigger this when p has been
1621 advanced to point to "::fun". */
1622 /* PASS2: we will not trigger this. */
1623 else if ((p
[0] == ':') && (p
[1] == ':'))
1624 break; /* Found double-colon. */
1627 /* PASS2: We'll keep getting here, until P points to one of the
1628 break characters, at which point we exit this loop. */
1632 && strncmp (&p
[1], CP_ANONYMOUS_NAMESPACE_STR
,
1633 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
1634 p
+= CP_ANONYMOUS_NAMESPACE_LEN
;
1635 else if (strchr (break_characters
, *p
) == NULL
)
1642 break; /* Out of the while (1). This would happen
1643 for instance if we have looked up
1644 unsuccessfully all the components of the
1645 string, and p->""(PASS2). */
1647 /* We get here if p points to one of the break characters or "" (i.e.,
1649 /* Save restart for next time around. */
1651 /* Restore argptr as it was on entry to this function. */
1652 *argptr
= saved_arg2
;
1653 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1656 /* All ready for next pass through the loop. */
1660 /* Start of lookup in the symbol tables. */
1662 /* Lookup in the symbol table the substring between argptr and
1663 p. Note, this call changes the value of argptr. */
1664 /* Before the call, argptr->"AAA::inA::fun",
1665 p->"", p2->"::fun". After the call: argptr->"fun", p, p2
1667 sym_classes
= lookup_prefix_sym (argptr
, p2
, self
->file_symtabs
,
1669 make_cleanup (VEC_cleanup (symbolp
), &sym_classes
);
1670 make_cleanup (xfree
, class_name
);
1672 /* If a class has been found, then we're in case 1 above. So we
1673 look up "fun" as a method of those classes. */
1674 if (!VEC_empty (symbolp
, sym_classes
))
1676 /* Arg token is not digits => try it as a function name.
1677 Find the next token (everything up to end or next
1680 && strchr (get_gdb_completer_quote_characters (),
1683 p
= skip_quoted (*argptr
);
1684 *argptr
= *argptr
+ 1;
1688 /* At this point argptr->"fun". */
1692 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!= ':'
1695 /* At this point p->"". String ended. */
1696 /* Nope, C++ operators could have spaces in them
1697 ("foo::operator <" or "foo::operator delete []").
1698 I apologize, this is a bit hacky... */
1699 if (current_language
->la_language
== language_cplus
1700 && *p
== ' ' && p
- 8 - *argptr
+ 1 > 0)
1702 /* The above loop has already swallowed "operator". */
1703 p
+= cp_validate_operator (p
- 8) - 8;
1706 /* Keep any important naming information. */
1707 p
= keep_name_info (p
, 1);
1710 /* Allocate our own copy of the substring between argptr and
1712 copy
= (char *) alloca (p
- *argptr
+ 1);
1713 memcpy (copy
, *argptr
, p
- *argptr
);
1714 copy
[p
- *argptr
] = '\0';
1716 && copy
[p
- *argptr
- 1]
1717 && strchr (get_gdb_completer_quote_characters (),
1718 copy
[p
- *argptr
- 1]) != NULL
)
1719 copy
[p
- *argptr
- 1] = '\0';
1721 /* At this point copy->"fun", p->"". */
1723 /* No line number may be specified. */
1724 *argptr
= skip_spaces (p
);
1725 /* At this point arptr->"". */
1727 /* Look for copy as a method of sym_class. */
1728 /* At this point copy->"fun", sym_class is "AAA:inA",
1729 saved_arg->"AAA::inA::fun". This concludes the scanning of
1730 the string for possible components matches. If we find it
1731 here, we return. If not, and we are at the and of the string,
1732 we'll lookup the whole string in the symbol tables. */
1734 values
= find_method (self
, saved_arg
, copy
, class_name
, sym_classes
);
1736 do_cleanups (cleanup
);
1738 } /* End if symbol found. */
1741 /* We couldn't find a class, so we're in case 2 above. We check the
1742 entire name as a symbol instead. The simplest way to do this is
1743 to just throw an exception and let our caller fall through to
1746 throw_error (NOT_FOUND_ERROR
, _("see caller, this text doesn't matter"));
1749 /* An instance of this type is used when collecting prefix symbols for
1752 struct decode_compound_collector
1754 /* The result vector. */
1755 VEC (symbolp
) *symbols
;
1757 /* A hash table of all symbols we found. We use this to avoid
1758 adding any symbol more than once. */
1762 /* A callback for iterate_over_symbols that is used by
1763 lookup_prefix_sym to collect type symbols. */
1766 collect_one_symbol (struct symbol
*sym
, void *d
)
1768 struct decode_compound_collector
*collector
= d
;
1772 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1775 t
= SYMBOL_TYPE (sym
);
1777 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1778 && TYPE_CODE (t
) != TYPE_CODE_UNION
1779 && TYPE_CODE (t
) != TYPE_CODE_NAMESPACE
)
1782 slot
= htab_find_slot (collector
->unique_syms
, sym
, INSERT
);
1786 VEC_safe_push (symbolp
, collector
->symbols
, sym
);
1792 /* Return the symbol corresponding to the substring of *ARGPTR ending
1793 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1794 name in question, the compound object separator ("::" or "."), and
1795 whitespace. Note that *ARGPTR is changed whether or not the
1796 this call finds anything (i.e we return NULL). As an
1797 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
1799 static VEC (symbolp
) *
1800 lookup_prefix_sym (char **argptr
, char *p
, VEC (symtab_p
) *file_symtabs
,
1807 struct decode_compound_collector collector
;
1808 struct cleanup
*outer
;
1809 struct cleanup
*cleanup
;
1810 struct block
*search_block
;
1812 /* Extract the class name. */
1814 while (p
!= *argptr
&& p
[-1] == ' ')
1816 copy
= (char *) xmalloc (p
- *argptr
+ 1);
1817 memcpy (copy
, *argptr
, p
- *argptr
);
1818 copy
[p
- *argptr
] = 0;
1820 outer
= make_cleanup (xfree
, copy
);
1822 /* Discard the class name from the argptr. */
1823 p
= p1
+ (p1
[0] == ':' ? 2 : 1);
1824 p
= skip_spaces (p
);
1827 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1828 argptr->"inA::fun". */
1830 collector
.symbols
= NULL
;
1831 make_cleanup (VEC_cleanup (symbolp
), &collector
.symbols
);
1833 collector
.unique_syms
= htab_create_alloc (1, htab_hash_pointer
,
1834 htab_eq_pointer
, NULL
,
1836 cleanup
= make_cleanup_htab_delete (collector
.unique_syms
);
1838 for (ix
= 0; VEC_iterate (symtab_p
, file_symtabs
, ix
, elt
); ++ix
)
1842 iterate_over_all_matching_symtabs (copy
, STRUCT_DOMAIN
,
1843 collect_one_symbol
, &collector
,
1845 iterate_over_all_matching_symtabs (copy
, VAR_DOMAIN
,
1846 collect_one_symbol
, &collector
,
1851 struct block
*search_block
;
1853 /* Program spaces that are executing startup should have
1854 been filtered out earlier. */
1855 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
1856 set_current_program_space (SYMTAB_PSPACE (elt
));
1857 search_block
= get_search_block (elt
);
1858 LA_ITERATE_OVER_SYMBOLS (search_block
, copy
, STRUCT_DOMAIN
,
1859 collect_one_symbol
, &collector
);
1860 LA_ITERATE_OVER_SYMBOLS (search_block
, copy
, VAR_DOMAIN
,
1861 collect_one_symbol
, &collector
);
1865 do_cleanups (cleanup
);
1866 discard_cleanups (outer
);
1867 return collector
.symbols
;
1870 /* A qsort comparison function for symbols. The resulting order does
1871 not actually matter; we just need to be able to sort them so that
1872 symbols with the same program space end up next to each other. */
1875 compare_symbols (const void *a
, const void *b
)
1877 struct symbol
* const *sa
= a
;
1878 struct symbol
* const *sb
= b
;
1881 uia
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa
));
1882 uib
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb
));
1889 uia
= (uintptr_t) *sa
;
1890 uib
= (uintptr_t) *sb
;
1900 /* Look for all the matching instances of each symbol in NAMES. Only
1901 instances from PSPACE are considered; other program spaces are
1902 handled by our caller. If PSPACE is NULL, then all program spaces
1903 are considered. Results are stored into INFO. */
1906 add_all_symbol_names_from_pspace (struct collect_info
*info
,
1907 struct program_space
*pspace
,
1908 VEC (const_char_ptr
) *names
)
1913 for (ix
= 0; VEC_iterate (const_char_ptr
, names
, ix
, iter
); ++ix
)
1914 add_matching_symbols_to_info (iter
, info
, pspace
);
1918 find_superclass_methods (VEC (typep
) *superclasses
,
1920 VEC (const_char_ptr
) **result_names
)
1922 int old_len
= VEC_length (const_char_ptr
, *result_names
);
1923 VEC (typep
) *iter_classes
;
1924 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1926 iter_classes
= superclasses
;
1929 VEC (typep
) *new_supers
= NULL
;
1933 make_cleanup (VEC_cleanup (typep
), &new_supers
);
1934 for (ix
= 0; VEC_iterate (typep
, iter_classes
, ix
, t
); ++ix
)
1935 find_methods (t
, name
, result_names
, &new_supers
);
1937 if (VEC_length (const_char_ptr
, *result_names
) != old_len
1938 || VEC_empty (typep
, new_supers
))
1941 iter_classes
= new_supers
;
1944 do_cleanups (cleanup
);
1947 /* This finds the method COPY in the class whose type is given by one
1948 of the symbols in SYM_CLASSES. */
1950 static struct symtabs_and_lines
1951 find_method (struct linespec_state
*self
, char *saved_arg
,
1952 char *copy
, const char *class_name
, VEC (symbolp
) *sym_classes
)
1956 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1958 int last_result_len
;
1959 VEC (typep
) *superclass_vec
;
1960 VEC (const_char_ptr
) *result_names
;
1961 struct collect_info info
;
1964 /* NAME is typed by the user: it needs to be canonicalized before
1965 searching the symbol tables. */
1966 canon
= cp_canonicalize_string_no_typedefs (copy
);
1970 make_cleanup (xfree
, copy
);
1973 /* Sort symbols so that symbols with the same program space are next
1975 qsort (VEC_address (symbolp
, sym_classes
),
1976 VEC_length (symbolp
, sym_classes
),
1981 info
.result
.sals
= NULL
;
1982 info
.result
.nelts
= 0;
1984 /* Iterate over all the types, looking for the names of existing
1985 methods matching COPY. If we cannot find a direct method in a
1986 given program space, then we consider inherited methods; this is
1987 not ideal (ideal would be to respect C++ hiding rules), but it
1988 seems good enough and is what GDB has historically done. We only
1989 need to collect the names because later we find all symbols with
1990 those names. This loop is written in a somewhat funny way
1991 because we collect data across the program space before deciding
1993 superclass_vec
= NULL
;
1994 make_cleanup (VEC_cleanup (typep
), &superclass_vec
);
1995 result_names
= NULL
;
1996 make_cleanup (VEC_cleanup (const_char_ptr
), &result_names
);
1997 last_result_len
= 0;
1998 for (ix
= 0; VEC_iterate (symbolp
, sym_classes
, ix
, sym
); ++ix
)
2001 struct program_space
*pspace
;
2003 /* Program spaces that are executing startup should have
2004 been filtered out earlier. */
2005 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
))->executing_startup
);
2006 pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2007 set_current_program_space (pspace
);
2008 t
= check_typedef (SYMBOL_TYPE (sym
));
2009 find_methods (t
, copy
, &result_names
, &superclass_vec
);
2011 /* Handle all items from a single program space at once; and be
2012 sure not to miss the last batch. */
2013 if (ix
== VEC_length (symbolp
, sym_classes
) - 1
2015 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp
, sym_classes
,
2018 /* If we did not find a direct implementation anywhere in
2019 this program space, consider superclasses. */
2020 if (VEC_length (const_char_ptr
, result_names
) == last_result_len
)
2021 find_superclass_methods (superclass_vec
, copy
, &result_names
);
2023 /* We have a list of candidate symbol names, so now we
2024 iterate over the symbol tables looking for all
2025 matches in this pspace. */
2026 add_all_symbol_names_from_pspace (&info
, pspace
, result_names
);
2028 VEC_truncate (typep
, superclass_vec
, 0);
2029 last_result_len
= VEC_length (const_char_ptr
, result_names
);
2033 if (info
.result
.nelts
> 0)
2035 if (self
->canonical
)
2037 self
->canonical
->pre_expanded
= 1;
2038 if (self
->user_filename
)
2039 self
->canonical
->addr_string
2040 = xstrprintf ("%s:%s", self
->user_filename
, saved_arg
);
2042 self
->canonical
->addr_string
= xstrdup (saved_arg
);
2045 do_cleanups (cleanup
);
2051 cplusplus_error (saved_arg
,
2052 "the class `%s' does not have destructor defined\n",
2055 cplusplus_error (saved_arg
,
2056 "the class %s does not have any method named %s\n",
2062 /* This object is used when collecting all matching symtabs. */
2064 struct symtab_collector
2066 /* The result vector of symtabs. */
2067 VEC (symtab_p
) *symtabs
;
2069 /* This is used to ensure the symtabs are unique. */
2070 htab_t symtab_table
;
2073 /* Callback for iterate_over_symtabs. */
2076 add_symtabs_to_list (struct symtab
*symtab
, void *d
)
2078 struct symtab_collector
*data
= d
;
2081 slot
= htab_find_slot (data
->symtab_table
, symtab
, INSERT
);
2085 VEC_safe_push (symtab_p
, data
->symtabs
, symtab
);
2091 /* Given a file name, return a VEC of all matching symtabs. */
2093 static VEC (symtab_p
) *
2094 collect_symtabs_from_filename (const char *file
)
2096 struct symtab_collector collector
;
2097 struct cleanup
*cleanups
;
2098 struct program_space
*pspace
;
2100 collector
.symtabs
= NULL
;
2101 collector
.symtab_table
= htab_create (1, htab_hash_pointer
, htab_eq_pointer
,
2103 cleanups
= make_cleanup_htab_delete (collector
.symtab_table
);
2105 /* Find that file's data. */
2106 ALL_PSPACES (pspace
)
2108 if (pspace
->executing_startup
)
2111 set_current_program_space (pspace
);
2112 iterate_over_symtabs (file
, add_symtabs_to_list
, &collector
);
2115 do_cleanups (cleanups
);
2116 return collector
.symtabs
;
2119 /* Return all the symtabs associated to the filename given by the
2120 substring of *ARGPTR ending at P, and advance ARGPTR past that
2123 static VEC (symtab_p
) *
2124 symtabs_from_filename (char **argptr
, char *p
, int is_quote_enclosed
,
2125 char **user_filename
)
2129 struct cleanup
*outer
;
2130 VEC (symtab_p
) *result
;
2133 while (p
!= *argptr
&& p
[-1] == ' ')
2135 if ((*p
== '"') && is_quote_enclosed
)
2137 copy
= xmalloc (p
- *argptr
+ 1);
2138 outer
= make_cleanup (xfree
, copy
);
2139 memcpy (copy
, *argptr
, p
- *argptr
);
2140 /* It may have the ending quote right after the file name. */
2141 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
2142 || copy
[p
- *argptr
- 1] == '\'')
2143 copy
[p
- *argptr
- 1] = 0;
2145 copy
[p
- *argptr
] = 0;
2147 result
= collect_symtabs_from_filename (copy
);
2149 if (VEC_empty (symtab_p
, result
))
2151 if (!have_full_symbols () && !have_partial_symbols ())
2152 throw_error (NOT_FOUND_ERROR
,
2153 _("No symbol table is loaded. "
2154 "Use the \"file\" command."));
2155 throw_error (NOT_FOUND_ERROR
, _("No source file named %s."), copy
);
2158 /* Discard the file name from the arg. */
2162 *argptr
= skip_spaces (p1
+ 1);
2164 discard_cleanups (outer
);
2165 *user_filename
= copy
;
2169 /* A callback used by iterate_over_all_matching_symtabs that collects
2170 symbols for find_function_symbols. */
2173 collect_function_symbols (struct symbol
*sym
, void *arg
)
2175 VEC (symbolp
) **syms
= arg
;
2177 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2178 VEC_safe_push (symbolp
, *syms
, sym
);
2183 /* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR
2184 and return the symbol. If not found, return NULL. */
2186 static VEC (symbolp
) *
2187 find_function_symbols (char **argptr
, char *p
, int is_quote_enclosed
,
2188 char **user_function
)
2192 VEC (symbolp
) *result
= NULL
;
2195 while (p
!= *argptr
&& p
[-1] == ' ')
2197 if ((*p
== '"') && is_quote_enclosed
)
2199 copy
= (char *) xmalloc (p
- *argptr
+ 1);
2200 *user_function
= copy
;
2201 memcpy (copy
, *argptr
, p
- *argptr
);
2202 /* It may have the ending quote right after the file name. */
2203 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
2204 || copy
[p
- *argptr
- 1] == '\'')
2205 copy
[p
- *argptr
- 1] = 0;
2207 copy
[p
- *argptr
] = 0;
2209 iterate_over_all_matching_symtabs (copy
, VAR_DOMAIN
,
2210 collect_function_symbols
, &result
, NULL
);
2212 if (VEC_empty (symbolp
, result
))
2213 VEC_free (symbolp
, result
);
2216 /* Discard the file name from the arg. */
2217 *argptr
= skip_spaces (p1
+ 1);
2225 /* A helper for decode_all_digits that handles the 'list_mode' case. */
2228 decode_digits_list_mode (struct linespec_state
*self
,
2229 struct symtabs_and_lines
*values
,
2230 struct symtab_and_line val
)
2235 gdb_assert (self
->list_mode
);
2237 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2239 /* The logic above should ensure this. */
2240 gdb_assert (elt
!= NULL
);
2242 set_current_program_space (SYMTAB_PSPACE (elt
));
2244 /* Simplistic search just for the list command. */
2245 val
.symtab
= find_line_symtab (elt
, val
.line
, NULL
, NULL
);
2246 if (val
.symtab
== NULL
)
2248 val
.pspace
= SYMTAB_PSPACE (elt
);
2250 val
.explicit_line
= 1;
2252 add_sal_to_sals (self
, values
, &val
, NULL
);
2256 /* A helper for decode_all_digits that iterates over the symtabs,
2257 adding lines to the VEC. */
2260 decode_digits_ordinary (struct linespec_state
*self
,
2262 struct symtabs_and_lines
*sals
,
2263 struct linetable_entry
**best_entry
)
2268 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2271 VEC (CORE_ADDR
) *pcs
;
2274 /* The logic above should ensure this. */
2275 gdb_assert (elt
!= NULL
);
2277 set_current_program_space (SYMTAB_PSPACE (elt
));
2279 pcs
= find_pcs_for_symtab_line (elt
, line
, best_entry
);
2280 for (i
= 0; VEC_iterate (CORE_ADDR
, pcs
, i
, pc
); ++i
)
2282 struct symtab_and_line sal
;
2285 sal
.pspace
= SYMTAB_PSPACE (elt
);
2289 add_sal_to_sals_basic (sals
, &sal
);
2292 VEC_free (CORE_ADDR
, pcs
);
2296 /* This decodes a line where the argument is all digits (possibly
2297 preceded by a sign). Q should point to the end of those digits;
2298 the other arguments are as usual. */
2300 static struct symtabs_and_lines
2301 decode_all_digits (struct linespec_state
*self
,
2305 struct symtabs_and_lines values
;
2306 struct symtab_and_line val
;
2307 int use_default
= 0;
2308 char *saved_arg
= *argptr
;
2320 /* This is where we need to make sure that we have good defaults.
2321 We must guarantee that this section of code is never executed
2322 when we are called with just a function name, since
2323 set_default_source_symtab_and_line uses
2324 select_source_symtab that calls us with such an argument. */
2326 if (VEC_length (symtab_p
, self
->file_symtabs
) == 1
2327 && VEC_index (symtab_p
, self
->file_symtabs
, 0) == NULL
)
2329 set_current_program_space (self
->program_space
);
2331 /* Make sure we have at least a default source file. */
2332 set_default_source_symtab_and_line ();
2333 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
2334 VEC_pop (symtab_p
, self
->file_symtabs
);
2335 VEC_free (symtab_p
, self
->file_symtabs
);
2337 = collect_symtabs_from_filename (self
->default_symtab
->filename
);
2341 if (**argptr
== '+')
2342 sign
= plus
, (*argptr
)++;
2343 else if (**argptr
== '-')
2344 sign
= minus
, (*argptr
)++;
2345 val
.line
= atoi (*argptr
);
2352 val
.line
= self
->default_line
+ val
.line
;
2358 val
.line
= self
->default_line
- val
.line
;
2363 break; /* No need to adjust val.line. */
2366 *argptr
= skip_spaces (q
);
2368 if (self
->list_mode
)
2369 decode_digits_list_mode (self
, &values
, val
);
2372 struct linetable_entry
*best_entry
= NULL
;
2374 struct block
**blocks
;
2375 struct cleanup
*cleanup
;
2376 struct symtabs_and_lines intermediate_results
;
2379 intermediate_results
.sals
= NULL
;
2380 intermediate_results
.nelts
= 0;
2382 decode_digits_ordinary (self
, val
.line
, &intermediate_results
,
2384 if (intermediate_results
.nelts
== 0 && best_entry
!= NULL
)
2385 decode_digits_ordinary (self
, best_entry
->line
, &intermediate_results
,
2388 cleanup
= make_cleanup (xfree
, intermediate_results
.sals
);
2390 /* For optimized code, compiler can scatter one source line
2391 accross disjoint ranges of PC values, even when no duplicate
2392 functions or inline functions are involved. For example,
2393 'for (;;)' inside non-template non-inline non-ctor-or-dtor
2394 function can result in two PC ranges. In this case, we don't
2395 want to set breakpoint on first PC of each range. To filter
2396 such cases, we use containing blocks -- for each PC found
2397 above we see if there are other PCs that are in the same
2398 block. If yes, the other PCs are filtered out. */
2400 filter
= xmalloc (intermediate_results
.nelts
* sizeof (int));
2401 make_cleanup (xfree
, filter
);
2402 blocks
= xmalloc (intermediate_results
.nelts
* sizeof (struct block
*));
2403 make_cleanup (xfree
, blocks
);
2405 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2407 set_current_program_space (intermediate_results
.sals
[i
].pspace
);
2410 blocks
[i
] = block_for_pc_sect (intermediate_results
.sals
[i
].pc
,
2411 intermediate_results
.sals
[i
].section
);
2414 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2416 if (blocks
[i
] != NULL
)
2417 for (j
= i
+ 1; j
< intermediate_results
.nelts
; ++j
)
2419 if (blocks
[j
] == blocks
[i
])
2427 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
2430 struct symbol
*sym
= (blocks
[i
]
2431 ? block_containing_function (blocks
[i
])
2434 if (self
->funfirstline
)
2435 skip_prologue_sal (&intermediate_results
.sals
[i
]);
2436 /* Make sure the line matches the request, not what was
2438 intermediate_results
.sals
[i
].line
= val
.line
;
2439 add_sal_to_sals (self
, &values
, &intermediate_results
.sals
[i
],
2440 sym
? SYMBOL_NATURAL_NAME (sym
) : NULL
);
2443 do_cleanups (cleanup
);
2446 if (values
.nelts
== 0)
2448 if (self
->user_filename
)
2449 throw_error (NOT_FOUND_ERROR
, _("No line %d in file \"%s\"."),
2450 val
.line
, self
->user_filename
);
2452 throw_error (NOT_FOUND_ERROR
, _("No line %d in the current file."),
2456 if (self
->canonical
)
2458 char *copy
= savestring (saved_arg
, q
- saved_arg
);
2460 self
->canonical
->pre_expanded
= 1;
2461 gdb_assert (self
->user_filename
|| use_default
);
2462 self
->canonical
->addr_string
2463 = xstrprintf ("%s:%s", (self
->user_filename
2464 ? self
->user_filename
2465 : self
->default_symtab
->filename
),
2475 /* Decode a linespec starting with a dollar sign. */
2477 static struct symtabs_and_lines
2478 decode_dollar (struct linespec_state
*self
, char *copy
)
2482 struct symtabs_and_lines values
;
2483 struct symtab_and_line val
;
2486 struct minimal_symbol
*msymbol
;
2490 p
= (copy
[1] == '$') ? copy
+ 2 : copy
+ 1;
2491 while (*p
>= '0' && *p
<= '9')
2493 if (!*p
) /* Reached end of token without hitting non-digit. */
2495 /* We have a value history reference. */
2496 struct value
*val_history
;
2498 sscanf ((copy
[1] == '$') ? copy
+ 2 : copy
+ 1, "%d", &index
);
2499 val_history
= access_value_history ((copy
[1] == '$') ? -index
: index
);
2500 if (TYPE_CODE (value_type (val_history
)) != TYPE_CODE_INT
)
2501 error (_("History values used in line "
2502 "specs must have integer values."));
2503 valx
= value_as_long (val_history
);
2507 /* Not all digits -- may be user variable/function or a
2508 convenience variable. */
2510 volatile struct gdb_exception exc
;
2512 /* Avoid "may be used uninitialized" warning. */
2516 TRY_CATCH (exc
, RETURN_MASK_ERROR
)
2518 values
= decode_variable (self
, copy
);
2521 if (exc
.reason
== 0)
2524 if (exc
.error
!= NOT_FOUND_ERROR
)
2525 throw_exception (exc
);
2527 /* Not a user variable or function -- must be convenience variable. */
2528 if (!get_internalvar_integer (lookup_internalvar (copy
+ 1), &valx
))
2529 error (_("Convenience variables used in line "
2530 "specs must have integer values."));
2538 for (ix
= 0; VEC_iterate (symtab_p
, self
->file_symtabs
, ix
, elt
); ++ix
)
2542 elt
= self
->default_symtab
;
2543 set_current_program_space (self
->program_space
);
2546 set_current_program_space (SYMTAB_PSPACE (elt
));
2548 /* Either history value or convenience value from above, in valx. */
2552 val
.pspace
= elt
? SYMTAB_PSPACE (elt
) : current_program_space
;
2554 add_sal_to_sals (self
, &values
, &val
, NULL
);
2557 if (self
->canonical
)
2559 self
->canonical
->pre_expanded
= 1;
2560 if (self
->user_filename
)
2561 self
->canonical
->addr_string
= xstrprintf ("%s:%s",
2562 self
->user_filename
, copy
);
2564 self
->canonical
->addr_string
= xstrdup (copy
);
2572 /* A helper for decode_line_1 that tries to find a label. The label
2573 is searched for in the current block.
2574 FUNCTION_SYMBOLS is a list of the enclosing functions; or NULL if none
2576 COPY is the name of the label to find.
2577 CANONICAL is the same as the "canonical" argument to decode_line_1.
2578 RESULT is a pointer to a symtabs_and_lines structure which will be
2579 filled in on success.
2580 This function returns 1 if a label was found, 0 otherwise. */
2583 decode_label (struct linespec_state
*self
,
2584 VEC (symbolp
) *function_symbols
, char *copy
,
2585 struct symtabs_and_lines
*result
)
2587 struct symbol
*fn_sym
;
2590 if (function_symbols
== NULL
)
2592 struct block
*block
;
2594 struct symtab_and_line sal
;
2595 struct symtabs_and_lines values
;
2600 set_current_program_space (self
->program_space
);
2601 block
= get_search_block (NULL
);
2604 block
&& !BLOCK_FUNCTION (block
);
2605 block
= BLOCK_SUPERBLOCK (block
))
2609 fn_sym
= BLOCK_FUNCTION (block
);
2611 sym
= lookup_symbol (copy
, block
, LABEL_DOMAIN
, 0);
2616 symbol_to_sal (&sal
, self
->funfirstline
, sym
);
2617 add_sal_to_sals (self
, &values
, &sal
,
2618 SYMBOL_NATURAL_NAME (fn_sym
));
2620 if (self
->canonical
)
2622 self
->canonical
->special_display
= 1;
2623 self
->canonical
->addr_string
2624 = xstrprintf ("%s:%s", SYMBOL_NATURAL_NAME (fn_sym
),
2633 result
->sals
= NULL
;
2636 for (ix
= 0; VEC_iterate (symbolp
, function_symbols
, ix
, fn_sym
); ++ix
)
2638 struct block
*block
;
2641 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym
)));
2642 block
= SYMBOL_BLOCK_VALUE (fn_sym
);
2643 sym
= lookup_symbol (copy
, block
, LABEL_DOMAIN
, 0);
2647 struct symtab_and_line sal
;
2650 symbol_to_sal (&sal
, self
->funfirstline
, sym
);
2651 symname
= xstrprintf ("%s:%s",
2652 SYMBOL_NATURAL_NAME (fn_sym
),
2653 SYMBOL_NATURAL_NAME (sym
));
2654 add_sal_to_sals (self
, result
, &sal
, symname
);
2659 if (self
->canonical
&& result
->nelts
> 0)
2661 self
->canonical
->pre_expanded
= 1;
2662 self
->canonical
->special_display
= 1;
2664 gdb_assert (self
->user_function
);
2665 self
->canonical
->addr_string
2666 = xstrprintf ("%s:%s", self
->user_function
, copy
);
2669 return result
->nelts
> 0;
2672 /* A callback used to possibly add a symbol to the results. */
2675 collect_symbols (struct symbol
*sym
, void *data
)
2677 struct collect_info
*info
= data
;
2678 struct symtab_and_line sal
;
2680 if (symbol_to_sal (&sal
, info
->state
->funfirstline
, sym
)
2681 && maybe_add_address (info
->state
->addr_set
,
2682 SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
)),
2684 add_sal_to_sals (info
->state
, &info
->result
, &sal
,
2685 SYMBOL_NATURAL_NAME (sym
));
2690 /* We've found a minimal symbol MSYMBOL to associate with our
2691 linespec; add it to the result symtabs_and_lines. */
2694 minsym_found (struct linespec_state
*self
, struct objfile
*objfile
,
2695 struct minimal_symbol
*msymbol
,
2696 struct symtabs_and_lines
*result
)
2698 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2700 struct symtab_and_line sal
;
2702 sal
= find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
2703 (struct obj_section
*) 0, 0);
2704 sal
.section
= SYMBOL_OBJ_SECTION (msymbol
);
2706 /* The minimal symbol might point to a function descriptor;
2707 resolve it to the actual code address instead. */
2708 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, sal
.pc
, ¤t_target
);
2710 sal
= find_pc_sect_line (pc
, NULL
, 0);
2712 if (self
->funfirstline
)
2713 skip_prologue_sal (&sal
);
2715 if (maybe_add_address (self
->addr_set
, objfile
->pspace
, sal
.pc
))
2716 add_sal_to_sals (self
, result
, &sal
, SYMBOL_NATURAL_NAME (msymbol
));
2719 /* A helper struct which just holds a minimal symbol and the object
2720 file from which it came. */
2722 typedef struct minsym_and_objfile
2724 struct minimal_symbol
*minsym
;
2725 struct objfile
*objfile
;
2726 } minsym_and_objfile_d
;
2728 DEF_VEC_O (minsym_and_objfile_d
);
2730 /* A helper struct to pass some data through
2731 iterate_over_minimal_symbols. */
2733 struct collect_minsyms
2735 /* The objfile we're examining. */
2736 struct objfile
*objfile
;
2738 /* The funfirstline setting from the initial call. */
2741 /* The list_mode setting from the initial call. */
2744 /* The resulting symbols. */
2745 VEC (minsym_and_objfile_d
) *msyms
;
2748 /* A helper function to classify a minimal_symbol_type according to
2752 classify_mtype (enum minimal_symbol_type t
)
2759 /* Intermediate priority. */
2762 case mst_solib_trampoline
:
2763 /* Lowest priority. */
2767 /* Highest priority. */
2772 /* Callback for qsort that sorts symbols by priority. */
2775 compare_msyms (const void *a
, const void *b
)
2777 const minsym_and_objfile_d
*moa
= a
;
2778 const minsym_and_objfile_d
*mob
= b
;
2779 enum minimal_symbol_type ta
= MSYMBOL_TYPE (moa
->minsym
);
2780 enum minimal_symbol_type tb
= MSYMBOL_TYPE (mob
->minsym
);
2782 return classify_mtype (ta
) - classify_mtype (tb
);
2785 /* Callback for iterate_over_minimal_symbols that adds the symbol to
2789 add_minsym (struct minimal_symbol
*minsym
, void *d
)
2791 struct collect_minsyms
*info
= d
;
2792 minsym_and_objfile_d mo
;
2794 /* Exclude data symbols when looking for breakpoint locations. */
2795 if (!info
->list_mode
)
2796 switch (minsym
->type
)
2798 case mst_slot_got_plt
:
2808 mo
.objfile
= info
->objfile
;
2809 VEC_safe_push (minsym_and_objfile_d
, info
->msyms
, &mo
);
2812 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
2813 is not NULL, the search is restricted to just that program
2817 search_minsyms_for_name (struct collect_info
*info
, const char *name
,
2818 struct program_space
*search_pspace
)
2820 struct objfile
*objfile
;
2821 struct program_space
*pspace
;
2823 ALL_PSPACES (pspace
)
2825 struct collect_minsyms local
;
2826 struct cleanup
*cleanup
;
2828 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
2830 if (pspace
->executing_startup
)
2833 set_current_program_space (pspace
);
2835 memset (&local
, 0, sizeof (local
));
2836 local
.funfirstline
= info
->state
->funfirstline
;
2837 local
.list_mode
= info
->state
->list_mode
;
2839 cleanup
= make_cleanup (VEC_cleanup (minsym_and_objfile_d
),
2842 ALL_OBJFILES (objfile
)
2844 local
.objfile
= objfile
;
2845 iterate_over_minimal_symbols (objfile
, name
, add_minsym
, &local
);
2848 if (!VEC_empty (minsym_and_objfile_d
, local
.msyms
))
2852 minsym_and_objfile_d
*item
;
2854 qsort (VEC_address (minsym_and_objfile_d
, local
.msyms
),
2855 VEC_length (minsym_and_objfile_d
, local
.msyms
),
2856 sizeof (minsym_and_objfile_d
),
2859 /* Now the minsyms are in classification order. So, we walk
2860 over them and process just the minsyms with the same
2861 classification as the very first minsym in the list. */
2862 item
= VEC_index (minsym_and_objfile_d
, local
.msyms
, 0);
2863 classification
= classify_mtype (MSYMBOL_TYPE (item
->minsym
));
2866 VEC_iterate (minsym_and_objfile_d
, local
.msyms
, ix
, item
);
2869 if (classify_mtype (MSYMBOL_TYPE (item
->minsym
)) != classification
)
2872 minsym_found (info
->state
, item
->objfile
, item
->minsym
,
2877 do_cleanups (cleanup
);
2881 /* A helper function to add all symbols matching NAME to INFO. If
2882 PSPACE is not NULL, the search is restricted to just that program
2886 add_matching_symbols_to_info (const char *name
,
2887 struct collect_info
*info
,
2888 struct program_space
*pspace
)
2893 for (ix
= 0; VEC_iterate (symtab_p
, info
->state
->file_symtabs
, ix
, elt
); ++ix
)
2899 iterate_over_all_matching_symtabs (name
, VAR_DOMAIN
,
2900 collect_symbols
, info
,
2902 search_minsyms_for_name (info
, name
, pspace
);
2904 else if (pspace
== NULL
|| pspace
== SYMTAB_PSPACE (elt
))
2906 /* Program spaces that are executing startup should have
2907 been filtered out earlier. */
2908 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
2909 set_current_program_space (SYMTAB_PSPACE (elt
));
2910 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt
), name
,
2911 VAR_DOMAIN
, collect_symbols
,
2917 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
2918 look in that symtab's static variables first. */
2920 static struct symtabs_and_lines
2921 decode_variable (struct linespec_state
*self
, char *copy
)
2923 struct collect_info info
;
2924 const char *lookup_name
;
2926 struct cleanup
*cleanup
;
2929 info
.result
.sals
= NULL
;
2930 info
.result
.nelts
= 0;
2932 cleanup
= demangle_for_lookup (copy
, current_language
->la_language
,
2934 if (current_language
->la_language
== language_ada
)
2936 /* In Ada, the symbol lookups are performed using the encoded
2937 name rather than the demangled name. */
2938 lookup_name
= ada_name_for_lookup (copy
);
2939 make_cleanup (xfree
, (void *) lookup_name
);
2942 canon
= cp_canonicalize_string_no_typedefs (lookup_name
);
2945 make_cleanup (xfree
, canon
);
2946 lookup_name
= canon
;
2949 add_matching_symbols_to_info (lookup_name
, &info
, NULL
);
2951 if (info
.result
.nelts
> 0)
2953 if (self
->canonical
)
2955 self
->canonical
->pre_expanded
= 1;
2956 if (self
->user_filename
)
2957 self
->canonical
->addr_string
2958 = xstrprintf ("%s:%s", self
->user_filename
, copy
);
2960 self
->canonical
->addr_string
= xstrdup (copy
);
2965 if (!have_full_symbols ()
2966 && !have_partial_symbols ()
2967 && !have_minimal_symbols ())
2968 throw_error (NOT_FOUND_ERROR
,
2969 _("No symbol table is loaded. Use the \"file\" command."));
2970 if (self
->user_filename
)
2971 throw_error (NOT_FOUND_ERROR
, _("Function \"%s\" not defined in \"%s\"."),
2972 copy
, self
->user_filename
);
2974 throw_error (NOT_FOUND_ERROR
, _("Function \"%s\" not defined."), copy
);
2980 /* Now come some functions that are called from multiple places within
2984 symbol_to_sal (struct symtab_and_line
*result
,
2985 int funfirstline
, struct symbol
*sym
)
2987 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2989 *result
= find_function_start_sal (sym
, funfirstline
);
2994 if (SYMBOL_CLASS (sym
) == LOC_LABEL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
2997 result
->symtab
= SYMBOL_SYMTAB (sym
);
2998 result
->line
= SYMBOL_LINE (sym
);
2999 result
->pc
= SYMBOL_VALUE_ADDRESS (sym
);
3000 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3001 result
->explicit_pc
= 1;
3004 else if (funfirstline
)
3008 else if (SYMBOL_LINE (sym
) != 0)
3010 /* We know its line number. */
3012 result
->symtab
= SYMBOL_SYMTAB (sym
);
3013 result
->line
= SYMBOL_LINE (sym
);
3014 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3022 /* See the comment in linespec.h. */
3025 init_linespec_result (struct linespec_result
*lr
)
3027 memset (lr
, 0, sizeof (*lr
));
3030 /* See the comment in linespec.h. */
3033 destroy_linespec_result (struct linespec_result
*ls
)
3036 struct linespec_sals
*lsal
;
3038 xfree (ls
->addr_string
);
3039 for (i
= 0; VEC_iterate (linespec_sals
, ls
->sals
, i
, lsal
); ++i
)
3041 xfree (lsal
->canonical
);
3042 xfree (lsal
->sals
.sals
);
3044 VEC_free (linespec_sals
, ls
->sals
);
3047 /* Cleanup function for a linespec_result. */
3050 cleanup_linespec_result (void *a
)
3052 destroy_linespec_result (a
);
3055 /* See the comment in linespec.h. */
3058 make_cleanup_destroy_linespec_result (struct linespec_result
*ls
)
3060 return make_cleanup (cleanup_linespec_result
, ls
);