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"
48 typedef struct symtab
*symtab_p
;
51 typedef struct symbol
*symbolp
;
54 typedef struct type
*typep
;
57 /* An address entry is used to ensure that any given location is only
58 added to the result a single time. It holds an address and the
59 program space from which the address came. */
63 struct program_space
*pspace
;
67 /* A helper struct which just holds a minimal symbol and the object
68 file from which it came. */
70 typedef struct minsym_and_objfile
72 struct minimal_symbol
*minsym
;
73 struct objfile
*objfile
;
74 } minsym_and_objfile_d
;
76 DEF_VEC_O (minsym_and_objfile_d
);
78 /* An enumeration of possible signs for a line offset. */
79 enum offset_relative_sign
84 /* A plus sign ("+") */
87 /* A minus sign ("-") */
90 /* A special "sign" for unspecified offset. */
94 /* A line offset in a linespec. */
98 /* Line offset and any specified sign. */
100 enum offset_relative_sign sign
;
103 /* A linespec. Elements of this structure are filled in by a parser
104 (either parse_linespec or some other function). The structure is
105 then converted into SALs by convert_linespec_to_sals. */
109 /* An expression and the resulting PC. Specifying an expression
110 currently precludes the use of other members. */
112 /* The expression entered by the user. */
113 const char *expression
;
115 /* The resulting PC expression derived from evaluating EXPRESSION. */
118 /* Any specified file symtabs. */
120 /* The user-supplied source filename or NULL if none was specified. */
121 const char *source_filename
;
123 /* The list of symtabs to search to which to limit the search. May not
124 be NULL. If SOURCE_FILENAME is NULL (no user-specified filename),
125 FILE_SYMTABS should contain one single NULL member. This will
126 cause the code to use the default symtab. */
127 VEC (symtab_p
) *file_symtabs
;
129 /* The name of a function or method and any matching symbols. */
131 /* The user-specified function name. If no function name was
132 supplied, this may be NULL. */
133 const char *function_name
;
135 /* A list of matching function symbols and minimal symbols. Both lists
136 may be NULL if no matching symbols were found. */
137 VEC (symbolp
) *function_symbols
;
138 VEC (minsym_and_objfile_d
) *minimal_symbols
;
140 /* The name of a label and matching symbols. */
142 /* The user-specified label name. */
143 const char *label_name
;
145 /* A structure of matching label symbols and the corresponding
146 function symbol in which the label was found. Both may be NULL
147 or both must be non-NULL. */
150 VEC (symbolp
) *label_symbols
;
151 VEC (symbolp
) *function_symbols
;
154 /* Line offset. It may be LINE_OFFSET_UNKNOWN, meaning that no
155 offset was specified. */
156 struct line_offset line_offset
;
158 typedef struct linespec
*linespec_p
;
160 /* An instance of this is used to keep all state while linespec
161 operates. This instance is passed around as a 'this' pointer to
162 the various implementation methods. */
164 struct linespec_state
166 /* The language in use during linespec processing. */
167 const struct language_defn
*language
;
169 /* The program space as seen when the module was entered. */
170 struct program_space
*program_space
;
172 /* The default symtab to use, if no other symtab is specified. */
173 struct symtab
*default_symtab
;
175 /* The default line to use. */
178 /* The 'funfirstline' value that was passed in to decode_line_1 or
182 /* Nonzero if we are running in 'list' mode; see decode_line_list. */
185 /* The 'canonical' value passed to decode_line_full, or NULL. */
186 struct linespec_result
*canonical
;
188 /* Canonical strings that mirror the symtabs_and_lines result. */
189 char **canonical_names
;
191 /* This is a set of address_entry objects which is used to prevent
192 duplicate symbols from being entered into the result. */
196 /* This is a helper object that is used when collecting symbols into a
201 /* The linespec object in use. */
202 struct linespec_state
*state
;
204 /* A list of symtabs to which to restrict matches. */
205 VEC (symtab_p
) *file_symtabs
;
207 /* The result being accumulated. */
210 VEC (symbolp
) *symbols
;
211 VEC (minsym_and_objfile_d
) *minimal_symbols
;
222 /* A colon "separator" */
234 /* EOI (end of input) */
240 typedef enum ls_token_type linespec_token_type
;
242 /* List of keywords */
244 static const char * const linespec_keywords
[] = { "if", "thread", "task" };
246 /* A token of the linespec lexer */
250 /* The type of the token */
251 linespec_token_type type
;
253 /* Data for the token */
256 /* A string, given as a stoken */
257 struct stoken string
;
263 typedef struct ls_token linespec_token
;
265 #define LS_TOKEN_STOKEN(TOK) (TOK).data.string
266 #define LS_TOKEN_KEYWORD(TOK) (TOK).data.keyword
268 /* An instance of the linespec parser. */
272 /* Lexer internal data */
275 /* Save head of input stream. */
278 /* Head of the input stream. */
280 #define PARSER_STREAM(P) (*(P)->lexer.stream)
282 /* The current token. */
283 linespec_token current
;
286 /* Is the entire linespec quote-enclosed? */
287 int is_quote_enclosed
;
289 /* The state of the parse. */
290 struct linespec_state state
;
291 #define PARSER_STATE(PPTR) (&(PPTR)->state)
293 /* The result of the parse. */
294 struct linespec result
;
295 #define PARSER_RESULT(PPTR) (&(PPTR)->result)
297 typedef struct ls_parser linespec_parser
;
299 /* Prototypes for local functions. */
301 static void initialize_defaults (struct symtab
**default_symtab
,
304 static CORE_ADDR
linespec_expression_to_pc (char **exp_ptr
);
306 static struct symtabs_and_lines
decode_objc (struct linespec_state
*self
,
310 static VEC (symtab_p
) *symtabs_from_filename (const char *);
312 static VEC (symbolp
) *find_label_symbols (struct linespec_state
*self
,
313 VEC (symbolp
) *function_symbols
,
314 VEC (symbolp
) **label_funcs_ret
,
317 void find_linespec_symbols (struct linespec_state
*self
,
318 VEC (symtab_p
) *file_symtabs
,
320 VEC (symbolp
) **symbols
,
321 VEC (minsym_and_objfile_d
) **minsyms
);
323 static struct line_offset
324 linespec_parse_variable (struct linespec_state
*self
,
325 const char *variable
);
327 static int symbol_to_sal (struct symtab_and_line
*result
,
328 int funfirstline
, struct symbol
*sym
);
330 static void add_matching_symbols_to_info (const char *name
,
331 struct collect_info
*info
,
332 struct program_space
*pspace
);
334 static void add_all_symbol_names_from_pspace (struct collect_info
*info
,
335 struct program_space
*pspace
,
336 VEC (const_char_ptr
) *names
);
338 static VEC (symtab_p
) *collect_symtabs_from_filename (const char *file
);
340 static void decode_digits_ordinary (struct linespec_state
*self
,
343 struct symtabs_and_lines
*sals
,
344 struct linetable_entry
**best_entry
);
346 static void decode_digits_list_mode (struct linespec_state
*self
,
348 struct symtabs_and_lines
*values
,
349 struct symtab_and_line val
);
351 static void minsym_found (struct linespec_state
*self
, struct objfile
*objfile
,
352 struct minimal_symbol
*msymbol
,
353 struct symtabs_and_lines
*result
);
355 static int compare_symbols (const void *a
, const void *b
);
357 static int compare_msymbols (const void *a
, const void *b
);
359 static const char *find_toplevel_char (const char *s
, char c
);
361 /* Permitted quote characters for the parser. This is different from the
362 completer's quote characters to allow backward compatibility with the
364 static const char *const linespec_quote_characters
= "\"\'";
366 /* Lexer functions. */
368 /* Lex a number from the input in PARSER. This only supports
371 Return true if input is decimal numbers. Return false if not. */
374 linespec_lexer_lex_number (linespec_parser
*parser
, linespec_token
*tokenp
)
376 tokenp
->type
= LSTOKEN_NUMBER
;
377 LS_TOKEN_STOKEN (*tokenp
).length
= 0;
378 LS_TOKEN_STOKEN (*tokenp
).ptr
= PARSER_STREAM (parser
);
380 /* Keep any sign at the start of the stream. */
381 if (*PARSER_STREAM (parser
) == '+' || *PARSER_STREAM (parser
) == '-')
383 ++LS_TOKEN_STOKEN (*tokenp
).length
;
384 ++(PARSER_STREAM (parser
));
387 while (isdigit (*PARSER_STREAM (parser
)))
389 ++LS_TOKEN_STOKEN (*tokenp
).length
;
390 ++(PARSER_STREAM (parser
));
393 /* If the next character in the input buffer is not a space, comma,
394 quote, or colon, this input does not represent a number. */
395 if (*PARSER_STREAM (parser
) != '\0'
396 && !isspace (*PARSER_STREAM (parser
)) && *PARSER_STREAM (parser
) != ','
397 && *PARSER_STREAM (parser
) != ':'
398 && !strchr (linespec_quote_characters
, *PARSER_STREAM (parser
)))
400 PARSER_STREAM (parser
) = LS_TOKEN_STOKEN (*tokenp
).ptr
;
407 /* Does P represent one of the keywords? If so, return
408 the keyword. If not, return NULL. */
411 linespec_lexer_lex_keyword (const char *p
)
417 for (i
= 0; i
< ARRAY_SIZE (linespec_keywords
); ++i
)
419 int len
= strlen (linespec_keywords
[i
]);
421 /* If P begins with one of the keywords and the next
422 character is not a valid identifier character,
423 we have found a keyword. */
424 if (strncmp (p
, linespec_keywords
[i
], len
) == 0
425 && !(isalnum (p
[len
]) || p
[len
] == '_'))
426 return linespec_keywords
[i
];
433 /* Does STRING represent an Ada operator? If so, return the length
434 of the decoded operator name. If not, return 0. */
437 is_ada_operator (const char *string
)
439 const struct ada_opname_map
*mapping
;
441 for (mapping
= ada_opname_table
;
442 mapping
->encoded
!= NULL
443 && strncmp (mapping
->decoded
, string
,
444 strlen (mapping
->decoded
)) != 0; ++mapping
)
447 return mapping
->decoded
== NULL
? 0 : strlen (mapping
->decoded
);
450 /* Find QUOTE_CHAR in STRING, accounting for the ':' terminal. Return
451 the location of QUOTE_CHAR, or NULL if not found. */
454 skip_quote_char (const char *string
, char quote_char
)
456 const char *p
, *last
;
458 p
= last
= find_toplevel_char (string
, quote_char
);
459 while (p
&& *p
!= '\0' && *p
!= ':')
461 p
= find_toplevel_char (p
, quote_char
);
469 /* Make a writable copy of the string given in TOKEN, trimming
470 any trailing whitespace. */
473 copy_token_string (linespec_token token
)
477 if (token
.type
== LSTOKEN_KEYWORD
)
478 return xstrdup (LS_TOKEN_KEYWORD (token
));
480 str
= savestring (LS_TOKEN_STOKEN (token
).ptr
,
481 LS_TOKEN_STOKEN (token
).length
);
482 s
= remove_trailing_whitespace (str
, str
+ LS_TOKEN_STOKEN (token
).length
);
488 /* Does P represent the end of a quote-enclosed linespec? */
491 is_closing_quote_enclosed (const char *p
)
493 if (strchr (linespec_quote_characters
, *p
))
495 p
= skip_spaces ((char *) p
);
496 return (*p
== '\0' || linespec_lexer_lex_keyword (p
));
499 /* Find the end of the parameter list that starts with *INPUT.
500 This helper function assists with lexing string segments
501 which might contain valid (non-terminating) commas. */
504 find_parameter_list_end (char *input
)
506 char end_char
, start_char
;
511 if (start_char
== '(')
513 else if (start_char
== '<')
522 if (*p
== start_char
)
524 else if (*p
== end_char
)
539 /* Lex a string from the input in PARSER. */
541 static linespec_token
542 linespec_lexer_lex_string (linespec_parser
*parser
)
544 linespec_token token
;
545 char *start
= PARSER_STREAM (parser
);
547 token
.type
= LSTOKEN_STRING
;
549 /* If the input stream starts with a quote character, skip to the next
550 quote character, regardless of the content. */
551 if (strchr (linespec_quote_characters
, *PARSER_STREAM (parser
)))
554 char quote_char
= *PARSER_STREAM (parser
);
556 /* Special case: Ada operators. */
557 if (PARSER_STATE (parser
)->language
->la_language
== language_ada
558 && quote_char
== '\"')
560 int len
= is_ada_operator (PARSER_STREAM (parser
));
564 /* The input is an Ada operator. Return the quoted string
566 LS_TOKEN_STOKEN (token
).ptr
= PARSER_STREAM (parser
);
567 LS_TOKEN_STOKEN (token
).length
= len
;
568 PARSER_STREAM (parser
) += len
;
572 /* The input does not represent an Ada operator -- fall through
573 to normal quoted string handling. */
576 /* Skip past the beginning quote. */
577 ++(PARSER_STREAM (parser
));
579 /* Mark the start of the string. */
580 LS_TOKEN_STOKEN (token
).ptr
= PARSER_STREAM (parser
);
582 /* Skip to the ending quote. */
583 end
= skip_quote_char (PARSER_STREAM (parser
), quote_char
);
585 /* Error if the input did not terminate properly. */
587 error (_("unmatched quote"));
589 /* Skip over the ending quote and mark the length of the string. */
590 PARSER_STREAM (parser
) = (char *) ++end
;
591 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - 2 - start
;
597 /* Otherwise, only identifier characters are permitted.
598 Spaces are the exception. In general, we keep spaces,
599 but only if the next characters in the input do not resolve
600 to one of the keywords.
602 This allows users to forgo quoting CV-qualifiers, template arguments,
603 and similar common language constructs. */
607 if (isspace (*PARSER_STREAM (parser
)))
609 p
= skip_spaces (PARSER_STREAM (parser
));
610 if (linespec_lexer_lex_keyword (p
) != NULL
)
612 LS_TOKEN_STOKEN (token
).ptr
= start
;
613 LS_TOKEN_STOKEN (token
).length
614 = PARSER_STREAM (parser
) - start
;
618 /* Advance past the whitespace. */
619 PARSER_STREAM (parser
) = p
;
622 /* If the next character is EOI or (single) ':', the
623 string is complete; return the token. */
624 if (*PARSER_STREAM (parser
) == 0)
626 LS_TOKEN_STOKEN (token
).ptr
= start
;
627 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - start
;
630 else if (PARSER_STREAM (parser
)[0] == ':')
632 /* Do not tokenize the C++ scope operator. */
633 if (PARSER_STREAM (parser
)[1] == ':')
634 ++(PARSER_STREAM (parser
));
636 /* Do not tokenify if the input length so far is one
637 (i.e, a single-letter drive name) and the next character
638 is a directory separator. This allows Windows-style
639 paths to be recognized as filenames without quoting it. */
640 else if ((PARSER_STREAM (parser
) - start
) != 1
641 || !IS_DIR_SEPARATOR (PARSER_STREAM (parser
)[1]))
643 LS_TOKEN_STOKEN (token
).ptr
= start
;
644 LS_TOKEN_STOKEN (token
).length
645 = PARSER_STREAM (parser
) - start
;
649 /* Special case: permit quote-enclosed linespecs. */
650 else if (parser
->is_quote_enclosed
651 && strchr (linespec_quote_characters
,
652 *PARSER_STREAM (parser
))
653 && is_closing_quote_enclosed (PARSER_STREAM (parser
)))
655 LS_TOKEN_STOKEN (token
).ptr
= start
;
656 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - start
;
659 /* Because commas may terminate a linespec and appear in
660 the middle of valid string input, special cases for
661 '<' and '(' are necessary. */
662 else if (*PARSER_STREAM (parser
) == '<'
663 || *PARSER_STREAM (parser
) == '(')
667 p
= find_parameter_list_end (PARSER_STREAM (parser
));
670 PARSER_STREAM (parser
) = p
;
674 /* Commas are terminators, but not if they are part of an
676 else if (*PARSER_STREAM (parser
) == ',')
678 if ((PARSER_STATE (parser
)->language
->la_language
680 && (PARSER_STREAM (parser
) - start
) > 8
681 /* strlen ("operator") */)
683 char *p
= strstr (start
, "operator");
685 if (p
!= NULL
&& is_operator_name (p
))
687 /* This is an operator name. Keep going. */
688 ++(PARSER_STREAM (parser
));
693 /* Comma terminates the string. */
694 LS_TOKEN_STOKEN (token
).ptr
= start
;
695 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - start
;
699 /* Advance the stream. */
700 ++(PARSER_STREAM (parser
));
707 /* Lex a single linespec token from PARSER. */
709 static linespec_token
710 linespec_lexer_lex_one (linespec_parser
*parser
)
714 if (parser
->lexer
.current
.type
== LSTOKEN_CONSUMED
)
716 /* Skip any whitespace. */
717 PARSER_STREAM (parser
) = skip_spaces (PARSER_STREAM (parser
));
719 /* Check for a keyword. */
720 keyword
= linespec_lexer_lex_keyword (PARSER_STREAM (parser
));
723 parser
->lexer
.current
.type
= LSTOKEN_KEYWORD
;
724 LS_TOKEN_KEYWORD (parser
->lexer
.current
) = keyword
;
725 return parser
->lexer
.current
;
728 /* Handle other tokens. */
729 switch (*PARSER_STREAM (parser
))
732 parser
->lexer
.current
.type
= LSTOKEN_EOI
;
736 case '0': case '1': case '2': case '3': case '4':
737 case '5': case '6': case '7': case '8': case '9':
738 if (!linespec_lexer_lex_number (parser
, &(parser
->lexer
.current
)))
739 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
743 /* If we have a scope operator, lex the input as a string.
744 Otherwise, return LSTOKEN_COLON. */
745 if (PARSER_STREAM (parser
)[1] == ':')
746 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
749 parser
->lexer
.current
.type
= LSTOKEN_COLON
;
750 ++(PARSER_STREAM (parser
));
754 case '\'': case '\"':
755 /* Special case: permit quote-enclosed linespecs. */
756 if (parser
->is_quote_enclosed
757 && is_closing_quote_enclosed (PARSER_STREAM (parser
)))
759 ++(PARSER_STREAM (parser
));
760 parser
->lexer
.current
.type
= LSTOKEN_EOI
;
763 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
767 parser
->lexer
.current
.type
= LSTOKEN_COMMA
;
768 LS_TOKEN_STOKEN (parser
->lexer
.current
).ptr
769 = PARSER_STREAM (parser
);
770 LS_TOKEN_STOKEN (parser
->lexer
.current
).length
= 1;
771 ++(PARSER_STREAM (parser
));
775 /* If the input is not a number, it must be a string.
776 [Keywords were already considered above.] */
777 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
782 return parser
->lexer
.current
;
785 /* Consume the current token and return the next token in PARSER's
788 static linespec_token
789 linespec_lexer_consume_token (linespec_parser
*parser
)
791 parser
->lexer
.current
.type
= LSTOKEN_CONSUMED
;
792 return linespec_lexer_lex_one (parser
);
795 /* Return the next token without consuming the current token. */
797 static linespec_token
798 linespec_lexer_peek_token (linespec_parser
*parser
)
801 char *saved_stream
= PARSER_STREAM (parser
);
802 linespec_token saved_token
= parser
->lexer
.current
;
804 next
= linespec_lexer_consume_token (parser
);
805 PARSER_STREAM (parser
) = saved_stream
;
806 parser
->lexer
.current
= saved_token
;
810 /* Helper functions. */
812 /* Add SAL to SALS. */
815 add_sal_to_sals_basic (struct symtabs_and_lines
*sals
,
816 struct symtab_and_line
*sal
)
819 sals
->sals
= xrealloc (sals
->sals
, sals
->nelts
* sizeof (sals
->sals
[0]));
820 sals
->sals
[sals
->nelts
- 1] = *sal
;
823 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
824 the new sal, if needed. If not NULL, SYMNAME is the name of the
825 symbol to use when constructing the new canonical name.
827 If LITERAL_CANONICAL is non-zero, SYMNAME will be used as the
828 canonical name for the SAL. */
831 add_sal_to_sals (struct linespec_state
*self
,
832 struct symtabs_and_lines
*sals
,
833 struct symtab_and_line
*sal
,
834 const char *symname
, int literal_canonical
)
836 add_sal_to_sals_basic (sals
, sal
);
840 char *canonical_name
= NULL
;
842 self
->canonical_names
= xrealloc (self
->canonical_names
,
843 sals
->nelts
* sizeof (char *));
844 if (!literal_canonical
&& sal
->symtab
&& sal
->symtab
->filename
)
846 char *filename
= sal
->symtab
->filename
;
848 /* Note that the filter doesn't have to be a valid linespec
849 input. We only apply the ":LINE" treatment to Ada for
851 if (symname
!= NULL
&& sal
->line
!= 0
852 && self
->language
->la_language
== language_ada
)
853 canonical_name
= xstrprintf ("%s:%s:%d", filename
, symname
,
855 else if (symname
!= NULL
)
856 canonical_name
= xstrprintf ("%s:%s", filename
, symname
);
858 canonical_name
= xstrprintf ("%s:%d", filename
, sal
->line
);
860 else if (symname
!= NULL
)
861 canonical_name
= xstrdup (symname
);
863 self
->canonical_names
[sals
->nelts
- 1] = canonical_name
;
867 /* A hash function for address_entry. */
870 hash_address_entry (const void *p
)
872 const struct address_entry
*aep
= p
;
875 hash
= iterative_hash_object (aep
->pspace
, 0);
876 return iterative_hash_object (aep
->addr
, hash
);
879 /* An equality function for address_entry. */
882 eq_address_entry (const void *a
, const void *b
)
884 const struct address_entry
*aea
= a
;
885 const struct address_entry
*aeb
= b
;
887 return aea
->pspace
== aeb
->pspace
&& aea
->addr
== aeb
->addr
;
890 /* Check whether the address, represented by PSPACE and ADDR, is
891 already in the set. If so, return 0. Otherwise, add it and return
895 maybe_add_address (htab_t set
, struct program_space
*pspace
, CORE_ADDR addr
)
897 struct address_entry e
, *p
;
902 slot
= htab_find_slot (set
, &e
, INSERT
);
906 p
= XNEW (struct address_entry
);
907 memcpy (p
, &e
, sizeof (struct address_entry
));
913 /* A callback function and the additional data to call it with. */
915 struct symbol_and_data_callback
917 /* The callback to use. */
918 symbol_found_callback_ftype
*callback
;
920 /* Data to be passed to the callback. */
924 /* A helper for iterate_over_all_matching_symtabs that is used to
925 restrict calls to another callback to symbols representing inline
929 iterate_inline_only (struct symbol
*sym
, void *d
)
931 if (SYMBOL_INLINED (sym
))
933 struct symbol_and_data_callback
*cad
= d
;
935 return cad
->callback (sym
, cad
->data
);
937 return 1; /* Continue iterating. */
940 /* Some data for the expand_symtabs_matching callback. */
942 struct symbol_matcher_data
944 /* The lookup name against which symbol name should be compared. */
945 const char *lookup_name
;
947 /* The routine to be used for comparison. */
948 symbol_name_cmp_ftype symbol_name_cmp
;
951 /* A helper for iterate_over_all_matching_symtabs that is passed as a
952 callback to the expand_symtabs_matching method. */
955 iterate_name_matcher (const char *name
, void *d
)
957 const struct symbol_matcher_data
*data
= d
;
959 if (data
->symbol_name_cmp (name
, data
->lookup_name
) == 0)
960 return 1; /* Expand this symbol's symbol table. */
961 return 0; /* Skip this symbol. */
964 /* A helper that walks over all matching symtabs in all objfiles and
965 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
966 not NULL, then the search is restricted to just that program
967 space. If INCLUDE_INLINE is nonzero then symbols representing
968 inlined instances of functions will be included in the result. */
971 iterate_over_all_matching_symtabs (struct linespec_state
*state
,
973 const domain_enum domain
,
974 symbol_found_callback_ftype
*callback
,
976 struct program_space
*search_pspace
,
979 struct objfile
*objfile
;
980 struct program_space
*pspace
;
981 struct symbol_matcher_data matcher_data
;
983 matcher_data
.lookup_name
= name
;
984 matcher_data
.symbol_name_cmp
=
985 state
->language
->la_get_symbol_name_cmp
!= NULL
986 ? state
->language
->la_get_symbol_name_cmp (name
)
991 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
993 if (pspace
->executing_startup
)
996 set_current_program_space (pspace
);
998 ALL_OBJFILES (objfile
)
1000 struct symtab
*symtab
;
1003 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, NULL
,
1004 iterate_name_matcher
,
1008 ALL_OBJFILE_PRIMARY_SYMTABS (objfile
, symtab
)
1010 struct block
*block
;
1012 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1013 LA_ITERATE_OVER_SYMBOLS (block
, name
, domain
, callback
, data
);
1017 struct symbol_and_data_callback cad
= { callback
, data
};
1020 for (i
= FIRST_LOCAL_BLOCK
;
1021 i
< BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (symtab
)); i
++)
1023 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), i
);
1024 LA_ITERATE_OVER_SYMBOLS (block
, name
, domain
,
1025 iterate_inline_only
, &cad
);
1033 /* Returns the block to be used for symbol searches for the given SYMTAB,
1034 which may be NULL. */
1036 static struct block
*
1037 get_search_block (struct symtab
*symtab
)
1039 struct block
*block
;
1042 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1045 enum language save_language
;
1047 /* get_selected_block can change the current language when there is
1048 no selected frame yet. */
1049 save_language
= current_language
->la_language
;
1050 block
= get_selected_block (0);
1051 set_language (save_language
);
1057 /* A helper for find_method. This finds all methods in type T which
1058 match NAME. It adds matching symbol names to RESULT_NAMES, and
1059 adds T's direct superclasses to SUPERCLASSES. */
1062 find_methods (struct type
*t
, const char *name
,
1063 VEC (const_char_ptr
) **result_names
,
1064 VEC (typep
) **superclasses
)
1068 const char *class_name
= type_name_no_tag (t
);
1070 /* Ignore this class if it doesn't have a name. This is ugly, but
1071 unless we figure out how to get the physname without the name of
1072 the class, then the loop can't do any good. */
1076 int name_len
= strlen (name
);
1080 /* Loop over each method name. At this level, all overloads of a name
1081 are counted as a single name. There is an inner loop which loops over
1084 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1085 method_counter
>= 0;
1088 const char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1089 char dem_opname
[64];
1091 if (strncmp (method_name
, "__", 2) == 0 ||
1092 strncmp (method_name
, "op", 2) == 0 ||
1093 strncmp (method_name
, "type", 4) == 0)
1095 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
1096 method_name
= dem_opname
;
1097 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
1098 method_name
= dem_opname
;
1101 if (strcmp_iw (method_name
, name
) == 0)
1105 for (field_counter
= (TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
)
1111 const char *phys_name
;
1113 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1114 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1116 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1117 VEC_safe_push (const_char_ptr
, *result_names
, phys_name
);
1123 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1124 VEC_safe_push (typep
, *superclasses
, TYPE_BASECLASS (t
, ibase
));
1127 /* Find an instance of the character C in the string S that is outside
1128 of all parenthesis pairs, single-quoted strings, and double-quoted
1129 strings. Also, ignore the char within a template name, like a ','
1130 within foo<int, int>. */
1133 find_toplevel_char (const char *s
, char c
)
1135 int quoted
= 0; /* zero if we're not in quotes;
1136 '"' if we're in a double-quoted string;
1137 '\'' if we're in a single-quoted string. */
1138 int depth
= 0; /* Number of unclosed parens we've seen. */
1141 for (scan
= s
; *scan
; scan
++)
1145 if (*scan
== quoted
)
1147 else if (*scan
== '\\' && *(scan
+ 1))
1150 else if (*scan
== c
&& ! quoted
&& depth
== 0)
1152 else if (*scan
== '"' || *scan
== '\'')
1154 else if (*scan
== '(' || *scan
== '<')
1156 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
1163 /* The string equivalent of find_toplevel_char. Returns a pointer
1164 to the location of NEEDLE in HAYSTACK, ignoring any occurrences
1165 inside "()" and "<>". Returns NULL if NEEDLE was not found. */
1168 find_toplevel_string (const char *haystack
, const char *needle
)
1170 const char *s
= haystack
;
1174 s
= find_toplevel_char (s
, *needle
);
1178 /* Found first char in HAYSTACK; check rest of string. */
1179 if (strncmp (s
, needle
, strlen (needle
)) == 0)
1182 /* Didn't find it; loop over HAYSTACK, looking for the next
1183 instance of the first character of NEEDLE. */
1187 while (s
!= NULL
&& *s
!= '\0');
1189 /* NEEDLE was not found in HAYSTACK. */
1193 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
1194 and store the result in SELF->CANONICAL. */
1197 filter_results (struct linespec_state
*self
,
1198 struct symtabs_and_lines
*result
,
1199 VEC (const_char_ptr
) *filters
)
1204 for (i
= 0; VEC_iterate (const_char_ptr
, filters
, i
, name
); ++i
)
1206 struct linespec_sals lsal
;
1209 memset (&lsal
, 0, sizeof (lsal
));
1211 for (j
= 0; j
< result
->nelts
; ++j
)
1213 if (strcmp (name
, self
->canonical_names
[j
]) == 0)
1214 add_sal_to_sals_basic (&lsal
.sals
, &result
->sals
[j
]);
1217 if (lsal
.sals
.nelts
> 0)
1219 lsal
.canonical
= xstrdup (name
);
1220 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
1224 self
->canonical
->pre_expanded
= 0;
1227 /* Store RESULT into SELF->CANONICAL. */
1230 convert_results_to_lsals (struct linespec_state
*self
,
1231 struct symtabs_and_lines
*result
)
1233 struct linespec_sals lsal
;
1235 lsal
.canonical
= NULL
;
1236 lsal
.sals
= *result
;
1237 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
1240 /* Handle multiple results in RESULT depending on SELECT_MODE. This
1241 will either return normally, throw an exception on multiple
1242 results, or present a menu to the user. On return, the SALS vector
1243 in SELF->CANONICAL is set up properly. */
1246 decode_line_2 (struct linespec_state
*self
,
1247 struct symtabs_and_lines
*result
,
1248 const char *select_mode
)
1251 char *args
, *prompt
;
1253 struct cleanup
*old_chain
;
1254 VEC (const_char_ptr
) *item_names
= NULL
, *filters
= NULL
;
1255 struct get_number_or_range_state state
;
1257 gdb_assert (select_mode
!= multiple_symbols_all
);
1258 gdb_assert (self
->canonical
!= NULL
);
1260 old_chain
= make_cleanup (VEC_cleanup (const_char_ptr
), &item_names
);
1261 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
1262 for (i
= 0; i
< result
->nelts
; ++i
)
1267 gdb_assert (self
->canonical_names
[i
] != NULL
);
1268 for (j
= 0; VEC_iterate (const_char_ptr
, item_names
, j
, iter
); ++j
)
1270 if (strcmp (iter
, self
->canonical_names
[i
]) == 0)
1278 VEC_safe_push (const_char_ptr
, item_names
, self
->canonical_names
[i
]);
1281 if (select_mode
== multiple_symbols_cancel
1282 && VEC_length (const_char_ptr
, item_names
) > 1)
1283 error (_("canceled because the command is ambiguous\n"
1284 "See set/show multiple-symbol."));
1286 if (select_mode
== multiple_symbols_all
1287 || VEC_length (const_char_ptr
, item_names
) == 1)
1289 do_cleanups (old_chain
);
1290 convert_results_to_lsals (self
, result
);
1294 /* Sort the list of method names alphabetically. */
1295 qsort (VEC_address (const_char_ptr
, item_names
),
1296 VEC_length (const_char_ptr
, item_names
),
1297 sizeof (const_char_ptr
), compare_strings
);
1299 printf_unfiltered (_("[0] cancel\n[1] all\n"));
1300 for (i
= 0; VEC_iterate (const_char_ptr
, item_names
, i
, iter
); ++i
)
1301 printf_unfiltered ("[%d] %s\n", i
+ 2, iter
);
1303 prompt
= getenv ("PS2");
1308 args
= command_line_input (prompt
, 0, "overload-choice");
1310 if (args
== 0 || *args
== 0)
1311 error_no_arg (_("one or more choice numbers"));
1313 init_number_or_range (&state
, args
);
1314 while (!state
.finished
)
1318 num
= get_number_or_range (&state
);
1321 error (_("canceled"));
1324 /* We intentionally make this result in a single breakpoint,
1325 contrary to what older versions of gdb did. The
1326 rationale is that this lets a user get the
1327 multiple_symbols_all behavior even with the 'ask'
1328 setting; and he can get separate breakpoints by entering
1329 "2-57" at the query. */
1330 do_cleanups (old_chain
);
1331 convert_results_to_lsals (self
, result
);
1336 if (num
>= VEC_length (const_char_ptr
, item_names
))
1337 printf_unfiltered (_("No choice number %d.\n"), num
);
1340 const char *elt
= VEC_index (const_char_ptr
, item_names
, num
);
1344 VEC_safe_push (const_char_ptr
, filters
, elt
);
1345 VEC_replace (const_char_ptr
, item_names
, num
, NULL
);
1349 printf_unfiltered (_("duplicate request for %d ignored.\n"),
1355 filter_results (self
, result
, filters
);
1356 do_cleanups (old_chain
);
1361 /* The parser of linespec itself. */
1363 /* Throw an appropriate error when SYMBOL is not found (optionally in
1366 static void ATTRIBUTE_NORETURN
1367 symbol_not_found_error (const char *symbol
, const char *filename
)
1372 if (!have_full_symbols ()
1373 && !have_partial_symbols ()
1374 && !have_minimal_symbols ())
1375 throw_error (NOT_FOUND_ERROR
,
1376 _("No symbol table is loaded. Use the \"file\" command."));
1378 /* If SYMBOL starts with '$', the user attempted to either lookup
1379 a function/variable in his code starting with '$' or an internal
1380 variable of that name. Since we do not know which, be concise and
1381 explain both possibilities. */
1385 throw_error (NOT_FOUND_ERROR
,
1386 _("Undefined convenience variable or function \"%s\" "
1387 "not defined in \"%s\"."), symbol
, filename
);
1389 throw_error (NOT_FOUND_ERROR
,
1390 _("Undefined convenience variable or function \"%s\" "
1391 "not defined."), symbol
);
1396 throw_error (NOT_FOUND_ERROR
,
1397 _("Function \"%s\" not defined in \"%s\"."),
1400 throw_error (NOT_FOUND_ERROR
,
1401 _("Function \"%s\" not defined."), symbol
);
1405 /* Throw an appropriate error when an unexpected token is encountered
1408 static void ATTRIBUTE_NORETURN
1409 unexpected_linespec_error (linespec_parser
*parser
)
1411 linespec_token token
;
1412 static const char * token_type_strings
[]
1413 = {"keyword", "colon", "string", "number", "comma", "end of input"};
1415 /* Get the token that generated the error. */
1416 token
= linespec_lexer_lex_one (parser
);
1418 /* Finally, throw the error. */
1419 if (token
.type
== LSTOKEN_STRING
|| token
.type
== LSTOKEN_NUMBER
1420 || token
.type
== LSTOKEN_KEYWORD
)
1423 struct cleanup
*cleanup
;
1425 string
= copy_token_string (token
);
1426 cleanup
= make_cleanup (xfree
, string
);
1427 throw_error (GENERIC_ERROR
,
1428 _("malformed linespec error: unexpected %s, \"%s\""),
1429 token_type_strings
[token
.type
], string
);
1432 throw_error (GENERIC_ERROR
,
1433 _("malformed linespec error: unexpected %s"),
1434 token_type_strings
[token
.type
]);
1437 /* Parse and return a line offset in STRING. */
1439 static struct line_offset
1440 linespec_parse_line_offset (const char *string
)
1442 struct line_offset line_offset
= {0, LINE_OFFSET_NONE
};
1446 line_offset
.sign
= LINE_OFFSET_PLUS
;
1449 else if (*string
== '-')
1451 line_offset
.sign
= LINE_OFFSET_MINUS
;
1455 /* Right now, we only allow base 10 for offsets. */
1456 line_offset
.offset
= atoi (string
);
1460 /* Parse the basic_spec in PARSER's input. */
1463 linespec_parse_basic (linespec_parser
*parser
)
1466 linespec_token token
;
1467 VEC (symbolp
) *symbols
, *labels
;
1468 VEC (minsym_and_objfile_d
) *minimal_symbols
;
1469 struct cleanup
*cleanup
;
1471 /* Get the next token. */
1472 token
= linespec_lexer_lex_one (parser
);
1474 /* If it is EOI or KEYWORD, issue an error. */
1475 if (token
.type
== LSTOKEN_KEYWORD
|| token
.type
== LSTOKEN_EOI
)
1476 unexpected_linespec_error (parser
);
1477 /* If it is a LSTOKEN_NUMBER, we have an offset. */
1478 else if (token
.type
== LSTOKEN_NUMBER
)
1480 /* Record the line offset and get the next token. */
1481 name
= copy_token_string (token
);
1482 cleanup
= make_cleanup (xfree
, name
);
1483 PARSER_RESULT (parser
)->line_offset
= linespec_parse_line_offset (name
);
1484 do_cleanups (cleanup
);
1486 /* Get the next token. */
1487 token
= linespec_lexer_consume_token (parser
);
1489 /* If the next token is a comma, stop parsing and return. */
1490 if (token
.type
== LSTOKEN_COMMA
)
1493 /* If the next token is anything but EOI or KEYWORD, issue
1495 if (token
.type
!= LSTOKEN_KEYWORD
&& token
.type
!= LSTOKEN_EOI
)
1496 unexpected_linespec_error (parser
);
1499 if (token
.type
== LSTOKEN_KEYWORD
|| token
.type
== LSTOKEN_EOI
)
1502 /* Next token must be LSTOKEN_STRING. */
1503 if (token
.type
!= LSTOKEN_STRING
)
1504 unexpected_linespec_error (parser
);
1506 /* The current token will contain the name of a function, method,
1508 name
= copy_token_string (token
);
1509 cleanup
= make_cleanup (xfree
, name
);
1511 /* Try looking it up as a function/method. */
1512 find_linespec_symbols (PARSER_STATE (parser
),
1513 PARSER_RESULT (parser
)->file_symtabs
, name
,
1514 &symbols
, &minimal_symbols
);
1516 if (symbols
!= NULL
|| minimal_symbols
!= NULL
)
1518 PARSER_RESULT (parser
)->function_symbols
= symbols
;
1519 PARSER_RESULT (parser
)->minimal_symbols
= minimal_symbols
;
1520 PARSER_RESULT (parser
)->function_name
= name
;
1522 discard_cleanups (cleanup
);
1526 /* NAME was not a function or a method. So it must be a label
1528 labels
= find_label_symbols (PARSER_STATE (parser
), NULL
,
1532 PARSER_RESULT (parser
)->labels
.label_symbols
= labels
;
1533 PARSER_RESULT (parser
)->labels
.function_symbols
= symbols
;
1534 PARSER_RESULT (parser
)->label_name
= name
;
1536 discard_cleanups (cleanup
);
1540 /* The name is also not a label. Abort parsing. Do not throw
1541 an error here. parse_linespec will do it for us. */
1543 /* Save a copy of the name we were trying to lookup. */
1544 PARSER_RESULT (parser
)->function_name
= name
;
1545 discard_cleanups (cleanup
);
1550 /* Get the next token. */
1551 token
= linespec_lexer_consume_token (parser
);
1553 if (token
.type
== LSTOKEN_COLON
)
1555 /* User specified a label or a lineno. */
1556 token
= linespec_lexer_consume_token (parser
);
1558 if (token
.type
== LSTOKEN_NUMBER
)
1560 /* User specified an offset. Record the line offset and
1561 get the next token. */
1562 name
= copy_token_string (token
);
1563 cleanup
= make_cleanup (xfree
, name
);
1564 PARSER_RESULT (parser
)->line_offset
1565 = linespec_parse_line_offset (name
);
1566 do_cleanups (cleanup
);
1568 /* Ge the next token. */
1569 token
= linespec_lexer_consume_token (parser
);
1571 else if (token
.type
== LSTOKEN_STRING
)
1573 /* Grab a copy of the label's name and look it up. */
1574 name
= copy_token_string (token
);
1575 cleanup
= make_cleanup (xfree
, name
);
1576 labels
= find_label_symbols (PARSER_STATE (parser
),
1577 PARSER_RESULT (parser
)->function_symbols
,
1582 PARSER_RESULT (parser
)->labels
.label_symbols
= labels
;
1583 PARSER_RESULT (parser
)->labels
.function_symbols
= symbols
;
1584 PARSER_RESULT (parser
)->label_name
= name
;
1586 discard_cleanups (cleanup
);
1590 /* We don't know what it was, but it isn't a label. */
1591 throw_error (NOT_FOUND_ERROR
,
1592 _("No label \"%s\" defined in function \"%s\"."),
1593 name
, PARSER_RESULT (parser
)->function_name
);
1596 /* Check for a line offset. */
1597 token
= linespec_lexer_consume_token (parser
);
1598 if (token
.type
== LSTOKEN_COLON
)
1600 /* Get the next token. */
1601 token
= linespec_lexer_consume_token (parser
);
1603 /* It must be a line offset. */
1604 if (token
.type
!= LSTOKEN_NUMBER
)
1605 unexpected_linespec_error (parser
);
1607 /* Record the lione offset and get the next token. */
1608 name
= copy_token_string (token
);
1609 cleanup
= make_cleanup (xfree
, name
);
1611 PARSER_RESULT (parser
)->line_offset
1612 = linespec_parse_line_offset (name
);
1613 do_cleanups (cleanup
);
1615 /* Get the next token. */
1616 token
= linespec_lexer_consume_token (parser
);
1621 /* Trailing ':' in the input. Issue an error. */
1622 unexpected_linespec_error (parser
);
1627 /* Canonicalize the linespec contained in LS. The result is saved into
1628 STATE->canonical. */
1631 canonicalize_linespec (struct linespec_state
*state
, linespec_p ls
)
1633 /* If canonicalization was not requested, no need to do anything. */
1634 if (!state
->canonical
)
1637 /* Shortcut expressions, which can only appear by themselves. */
1638 if (ls
->expression
!= NULL
)
1639 state
->canonical
->addr_string
= xstrdup (ls
->expression
);
1642 struct ui_file
*buf
;
1645 buf
= mem_fileopen ();
1646 if (ls
->source_filename
)
1648 fputs_unfiltered (ls
->source_filename
, buf
);
1652 if (ls
->function_name
)
1655 fputc_unfiltered (':', buf
);
1656 fputs_unfiltered (ls
->function_name
, buf
);
1663 fputc_unfiltered (':', buf
);
1665 if (ls
->function_name
== NULL
)
1669 /* No function was specified, so add the symbol name. */
1670 gdb_assert (ls
->labels
.function_symbols
!= NULL
1671 && (VEC_length (symbolp
, ls
->labels
.function_symbols
)
1673 s
= VEC_index (symbolp
, ls
->labels
.function_symbols
, 0);
1674 fputs_unfiltered (SYMBOL_NATURAL_NAME (s
), buf
);
1675 fputc_unfiltered (':', buf
);
1678 fputs_unfiltered (ls
->label_name
, buf
);
1680 state
->canonical
->special_display
= 1;
1683 if (ls
->line_offset
.sign
!= LINE_OFFSET_UNKNOWN
)
1686 fputc_unfiltered (':', buf
);
1687 fprintf_filtered (buf
, "%s%d",
1688 (ls
->line_offset
.sign
== LINE_OFFSET_NONE
? ""
1689 : (ls
->line_offset
.sign
1690 == LINE_OFFSET_PLUS
? "+" : "-")),
1691 ls
->line_offset
.offset
);
1694 state
->canonical
->addr_string
= ui_file_xstrdup (buf
, NULL
);
1695 ui_file_delete (buf
);
1699 /* Given a line offset in LS, construct the relevant SALs. */
1701 static struct symtabs_and_lines
1702 create_sals_line_offset (struct linespec_state
*self
,
1705 struct symtabs_and_lines values
;
1706 struct symtab_and_line val
;
1707 int use_default
= 0;
1713 /* This is where we need to make sure we have good defaults.
1714 We must guarantee that this section of code is never executed
1715 when we are called with just a function anme, since
1716 set_default_source_symtab_and_line uses
1717 select_source_symtab that calls us with such an argument. */
1719 if (VEC_length (symtab_p
, ls
->file_symtabs
) == 1
1720 && VEC_index (symtab_p
, ls
->file_symtabs
, 0) == NULL
)
1722 set_current_program_space (self
->program_space
);
1724 /* Make sure we have at least a default source line. */
1725 set_default_source_symtab_and_line ();
1726 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
1727 VEC_pop (symtab_p
, ls
->file_symtabs
);
1728 VEC_free (symtab_p
, ls
->file_symtabs
);
1730 = collect_symtabs_from_filename (self
->default_symtab
->filename
);
1734 val
.line
= ls
->line_offset
.offset
;
1735 switch (ls
->line_offset
.sign
)
1737 case LINE_OFFSET_PLUS
:
1738 if (ls
->line_offset
.offset
== 0)
1741 val
.line
= self
->default_line
+ val
.line
;
1744 case LINE_OFFSET_MINUS
:
1745 if (ls
->line_offset
.offset
== 0)
1748 val
.line
= self
->default_line
- val
.line
;
1750 val
.line
= -val
.line
;
1753 case LINE_OFFSET_NONE
:
1754 break; /* No need to adjust val.line. */
1757 if (self
->list_mode
)
1758 decode_digits_list_mode (self
, ls
, &values
, val
);
1761 struct linetable_entry
*best_entry
= NULL
;
1763 struct block
**blocks
;
1764 struct cleanup
*cleanup
;
1765 struct symtabs_and_lines intermediate_results
;
1768 intermediate_results
.sals
= NULL
;
1769 intermediate_results
.nelts
= 0;
1771 decode_digits_ordinary (self
, ls
, val
.line
, &intermediate_results
,
1773 if (intermediate_results
.nelts
== 0 && best_entry
!= NULL
)
1774 decode_digits_ordinary (self
, ls
, best_entry
->line
,
1775 &intermediate_results
, &best_entry
);
1777 cleanup
= make_cleanup (xfree
, intermediate_results
.sals
);
1779 /* For optimized code, the compiler can scatter one source line
1780 across disjoint ranges of PC values, even when no duplicate
1781 functions or inline functions are involved. For example,
1782 'for (;;)' inside a non-template, non-inline, and non-ctor-or-dtor
1783 function can result in two PC ranges. In this case, we don't
1784 want to set a breakpoint on the first PC of each range. To filter
1785 such cases, we use containing blocks -- for each PC found
1786 above, we see if there are other PCs that are in the same
1787 block. If yes, the other PCs are filtered out. */
1789 filter
= XNEWVEC (int, intermediate_results
.nelts
);
1790 make_cleanup (xfree
, filter
);
1791 blocks
= XNEWVEC (struct block
*, intermediate_results
.nelts
);
1792 make_cleanup (xfree
, blocks
);
1794 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
1796 set_current_program_space (intermediate_results
.sals
[i
].pspace
);
1799 blocks
[i
] = block_for_pc_sect (intermediate_results
.sals
[i
].pc
,
1800 intermediate_results
.sals
[i
].section
);
1803 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
1805 if (blocks
[i
] != NULL
)
1806 for (j
= i
+ 1; j
< intermediate_results
.nelts
; ++j
)
1808 if (blocks
[j
] == blocks
[i
])
1816 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
1819 struct symbol
*sym
= (blocks
[i
]
1820 ? block_containing_function (blocks
[i
])
1823 if (self
->funfirstline
)
1824 skip_prologue_sal (&intermediate_results
.sals
[i
]);
1825 /* Make sure the line matches the request, not what was
1827 intermediate_results
.sals
[i
].line
= val
.line
;
1828 add_sal_to_sals (self
, &values
, &intermediate_results
.sals
[i
],
1829 sym
? SYMBOL_NATURAL_NAME (sym
) : NULL
, 0);
1832 do_cleanups (cleanup
);
1835 if (values
.nelts
== 0)
1837 if (ls
->source_filename
)
1838 throw_error (NOT_FOUND_ERROR
, _("No line %d in file \"%s\"."),
1839 val
.line
, ls
->source_filename
);
1841 throw_error (NOT_FOUND_ERROR
, _("No line %d in the current file."),
1848 /* Create and return SALs from the linespec LS. */
1850 static struct symtabs_and_lines
1851 convert_linespec_to_sals (struct linespec_state
*state
, linespec_p ls
)
1853 struct symtabs_and_lines sals
= {NULL
, 0};
1855 if (ls
->expression
!= NULL
)
1857 struct symtab_and_line sal
;
1859 /* We have an expression. No other attribute is allowed. */
1860 sal
= find_pc_line (ls
->expr_pc
, 0);
1861 sal
.pc
= ls
->expr_pc
;
1862 sal
.section
= find_pc_overlay (ls
->expr_pc
);
1863 sal
.explicit_pc
= 1;
1864 add_sal_to_sals (state
, &sals
, &sal
, ls
->expression
, 1);
1866 else if (ls
->labels
.label_symbols
!= NULL
)
1868 /* We have just a bunch of functions/methods or labels. */
1870 struct symtab_and_line sal
;
1873 for (i
= 0; VEC_iterate (symbolp
, ls
->labels
.label_symbols
, i
, sym
); ++i
)
1875 if (symbol_to_sal (&sal
, state
->funfirstline
, sym
))
1876 add_sal_to_sals (state
, &sals
, &sal
,
1877 SYMBOL_NATURAL_NAME (sym
), 0);
1880 else if (ls
->function_symbols
!= NULL
|| ls
->minimal_symbols
!= NULL
)
1882 /* We have just a bunch of functions and/or methods. */
1884 struct symtab_and_line sal
;
1886 minsym_and_objfile_d
*elem
;
1887 struct program_space
*pspace
;
1889 if (ls
->function_symbols
!= NULL
)
1891 /* Sort symbols so that symbols with the same program space are next
1893 qsort (VEC_address (symbolp
, ls
->function_symbols
),
1894 VEC_length (symbolp
, ls
->function_symbols
),
1895 sizeof (symbolp
), compare_symbols
);
1897 for (i
= 0; VEC_iterate (symbolp
, ls
->function_symbols
, i
, sym
); ++i
)
1899 pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
1900 set_current_program_space (pspace
);
1901 if (symbol_to_sal (&sal
, state
->funfirstline
, sym
)
1902 && maybe_add_address (state
->addr_set
, pspace
, sal
.pc
))
1903 add_sal_to_sals (state
, &sals
, &sal
,
1904 SYMBOL_NATURAL_NAME (sym
), 0);
1908 if (ls
->minimal_symbols
!= NULL
)
1910 /* Sort minimal symbols by program space, too. */
1911 qsort (VEC_address (minsym_and_objfile_d
, ls
->minimal_symbols
),
1912 VEC_length (minsym_and_objfile_d
, ls
->minimal_symbols
),
1913 sizeof (minsym_and_objfile_d
), compare_msymbols
);
1916 VEC_iterate (minsym_and_objfile_d
, ls
->minimal_symbols
, i
, elem
);
1919 pspace
= elem
->objfile
->pspace
;
1920 set_current_program_space (pspace
);
1921 minsym_found (state
, elem
->objfile
, elem
->minsym
, &sals
);
1925 else if (ls
->line_offset
.sign
!= LINE_OFFSET_UNKNOWN
)
1927 /* Only an offset was specified. */
1928 sals
= create_sals_line_offset (state
, ls
);
1930 /* Make sure we have a filename for canonicalization. */
1931 if (ls
->source_filename
== NULL
)
1932 ls
->source_filename
= xstrdup (state
->default_symtab
->filename
);
1936 /* We haven't found any results... */
1940 canonicalize_linespec (state
, ls
);
1942 if (sals
.nelts
> 0 && state
->canonical
!= NULL
)
1943 state
->canonical
->pre_expanded
= 1;
1948 /* Parse a string that specifies a linespec.
1949 Pass the address of a char * variable; that variable will be
1950 advanced over the characters actually parsed.
1952 The basic grammar of linespecs:
1954 linespec -> expr_spec | var_spec | basic_spec
1955 expr_spec -> '*' STRING
1956 var_spec -> '$' (STRING | NUMBER)
1958 basic_spec -> file_offset_spec | function_spec | label_spec
1959 file_offset_spec -> opt_file_spec offset_spec
1960 function_spec -> opt_file_spec function_name_spec opt_label_spec
1961 label_spec -> label_name_spec
1963 opt_file_spec -> "" | file_name_spec ':'
1964 opt_label_spec -> "" | ':' label_name_spec
1966 file_name_spec -> STRING
1967 function_name_spec -> STRING
1968 label_name_spec -> STRING
1969 function_name_spec -> STRING
1970 offset_spec -> NUMBER
1974 This may all be followed by several keywords such as "if EXPR",
1977 A comma will terminate parsing.
1979 The function may be an undebuggable function found in minimal symbol table.
1981 If the argument FUNFIRSTLINE is nonzero, we want the first line
1982 of real code inside a function when a function is specified, and it is
1983 not OK to specify a variable or type to get its line number.
1985 DEFAULT_SYMTAB specifies the file to use if none is specified.
1986 It defaults to current_source_symtab.
1987 DEFAULT_LINE specifies the line number to use for relative
1988 line numbers (that start with signs). Defaults to current_source_line.
1989 If CANONICAL is non-NULL, store an array of strings containing the canonical
1990 line specs there if necessary. Currently overloaded member functions and
1991 line numbers or static functions without a filename yield a canonical
1992 line spec. The array and the line spec strings are allocated on the heap,
1993 it is the callers responsibility to free them.
1995 Note that it is possible to return zero for the symtab
1996 if no file is validly specified. Callers must check that.
1997 Also, the line number returned may be invalid. */
1999 /* Parse the linespec in ARGPTR. */
2001 static struct symtabs_and_lines
2002 parse_linespec (linespec_parser
*parser
, char **argptr
)
2004 linespec_token token
;
2005 struct symtabs_and_lines values
;
2006 volatile struct gdb_exception file_exception
;
2007 struct cleanup
*cleanup
;
2009 /* A special case to start. It has become quite popular for
2010 IDEs to work around bugs in the previous parser by quoting
2011 the entire linespec, so we attempt to deal with this nicely. */
2012 parser
->is_quote_enclosed
= 0;
2013 if (!is_ada_operator (*argptr
)
2014 && strchr (linespec_quote_characters
, **argptr
) != NULL
)
2018 end
= skip_quote_char (*argptr
+ 1, **argptr
);
2019 if (end
!= NULL
&& is_closing_quote_enclosed (end
))
2021 /* Here's the special case. Skip ARGPTR past the initial
2024 parser
->is_quote_enclosed
= 1;
2028 parser
->lexer
.saved_arg
= *argptr
;
2029 parser
->lexer
.stream
= argptr
;
2030 file_exception
.reason
= 0;
2032 /* Initialize the default symtab and line offset. */
2033 initialize_defaults (&PARSER_STATE (parser
)->default_symtab
,
2034 &PARSER_STATE (parser
)->default_line
);
2036 /* Objective-C shortcut. */
2037 values
= decode_objc (PARSER_STATE (parser
), PARSER_RESULT (parser
), argptr
);
2038 if (values
.sals
!= NULL
)
2041 /* Start parsing. */
2043 /* Get the first token. */
2044 token
= linespec_lexer_lex_one (parser
);
2046 /* It must be either LSTOKEN_STRING or LSTOKEN_NUMBER. */
2047 if (token
.type
== LSTOKEN_STRING
&& *LS_TOKEN_STOKEN (token
).ptr
== '*')
2051 /* User specified an expression, *EXPR. */
2052 copy
= expr
= copy_token_string (token
);
2053 cleanup
= make_cleanup (xfree
, expr
);
2054 PARSER_RESULT (parser
)->expr_pc
= linespec_expression_to_pc (©
);
2055 discard_cleanups (cleanup
);
2056 PARSER_RESULT (parser
)->expression
= expr
;
2058 /* This is a little hacky/tricky. If linespec_expression_to_pc
2059 did not evaluate the entire token, then we must find the
2060 string COPY inside the original token buffer. */
2063 PARSER_STREAM (parser
) = strstr (parser
->lexer
.saved_arg
, copy
);
2064 gdb_assert (PARSER_STREAM (parser
) != NULL
);
2067 /* Consume the token. */
2068 linespec_lexer_consume_token (parser
);
2070 goto convert_to_sals
;
2072 else if (token
.type
== LSTOKEN_STRING
&& *LS_TOKEN_STOKEN (token
).ptr
== '$')
2076 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2077 VEC_safe_push (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
, NULL
);
2079 /* User specified a convenience variable or history value. */
2080 var
= copy_token_string (token
);
2081 cleanup
= make_cleanup (xfree
, var
);
2082 PARSER_RESULT (parser
)->line_offset
2083 = linespec_parse_variable (PARSER_STATE (parser
), var
);
2085 /* If a line_offset wasn't found (VAR is the name of a user
2086 variable/function), then skip to normal symbol processing. */
2087 if (PARSER_RESULT (parser
)->line_offset
.sign
!= LINE_OFFSET_UNKNOWN
)
2089 discard_cleanups (cleanup
);
2091 /* Consume this token. */
2092 linespec_lexer_consume_token (parser
);
2094 goto convert_to_sals
;
2097 do_cleanups (cleanup
);
2099 else if (token
.type
!= LSTOKEN_STRING
&& token
.type
!= LSTOKEN_NUMBER
)
2100 unexpected_linespec_error (parser
);
2102 /* Shortcut: If the next token is not LSTOKEN_COLON, we know that
2103 this token cannot represent a filename. */
2104 token
= linespec_lexer_peek_token (parser
);
2106 if (token
.type
== LSTOKEN_COLON
)
2108 char *user_filename
;
2110 /* Get the current token again and extract the filename. */
2111 token
= linespec_lexer_lex_one (parser
);
2112 user_filename
= copy_token_string (token
);
2114 /* Check if the input is a filename. */
2115 TRY_CATCH (file_exception
, RETURN_MASK_ERROR
)
2117 PARSER_RESULT (parser
)->file_symtabs
2118 = symtabs_from_filename (user_filename
);
2121 if (file_exception
.reason
>= 0)
2123 /* Symtabs were found for the file. Record the filename. */
2124 PARSER_RESULT (parser
)->source_filename
= user_filename
;
2126 /* Get the next token. */
2127 token
= linespec_lexer_consume_token (parser
);
2129 /* This is LSTOKEN_COLON; consume it. */
2130 linespec_lexer_consume_token (parser
);
2134 /* No symtabs found -- discard user_filename. */
2135 xfree (user_filename
);
2137 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2138 VEC_safe_push (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
, NULL
);
2141 /* If the next token is not EOI, KEYWORD, or COMMA, issue an error. */
2142 else if (token
.type
!= LSTOKEN_EOI
&& token
.type
!= LSTOKEN_KEYWORD
2143 && token
.type
!= LSTOKEN_COMMA
)
2145 /* TOKEN is the _next_ token, not the one currently in the parser.
2146 Consuming the token will give the correct error message. */
2147 linespec_lexer_consume_token (parser
);
2148 unexpected_linespec_error (parser
);
2152 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2153 VEC_safe_push (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
, NULL
);
2156 /* Parse the rest of the linespec. */
2157 linespec_parse_basic (parser
);
2159 if (PARSER_RESULT (parser
)->function_symbols
== NULL
2160 && PARSER_RESULT (parser
)->labels
.label_symbols
== NULL
2161 && PARSER_RESULT (parser
)->line_offset
.sign
== LINE_OFFSET_UNKNOWN
2162 && PARSER_RESULT (parser
)->minimal_symbols
== NULL
)
2164 /* The linespec didn't parse. Re-throw the file exception if
2166 if (file_exception
.reason
< 0)
2167 throw_exception (file_exception
);
2169 /* Otherwise, the symbol is not found. */
2170 symbol_not_found_error (PARSER_RESULT (parser
)->function_name
,
2171 PARSER_RESULT (parser
)->source_filename
);
2176 /* Get the last token and record how much of the input was parsed,
2178 token
= linespec_lexer_lex_one (parser
);
2179 if (token
.type
!= LSTOKEN_EOI
&& token
.type
!= LSTOKEN_KEYWORD
)
2180 PARSER_STREAM (parser
) = LS_TOKEN_STOKEN (token
).ptr
;
2182 /* Convert the data in PARSER_RESULT to SALs. */
2183 values
= convert_linespec_to_sals (PARSER_STATE (parser
),
2184 PARSER_RESULT (parser
));
2190 /* A constructor for linespec_state. */
2193 linespec_state_constructor (struct linespec_state
*self
,
2194 int flags
, const struct language_defn
*language
,
2195 struct symtab
*default_symtab
,
2197 struct linespec_result
*canonical
)
2199 memset (self
, 0, sizeof (*self
));
2200 self
->language
= language
;
2201 self
->funfirstline
= (flags
& DECODE_LINE_FUNFIRSTLINE
) ? 1 : 0;
2202 self
->list_mode
= (flags
& DECODE_LINE_LIST_MODE
) ? 1 : 0;
2203 self
->default_symtab
= default_symtab
;
2204 self
->default_line
= default_line
;
2205 self
->canonical
= canonical
;
2206 self
->program_space
= current_program_space
;
2207 self
->addr_set
= htab_create_alloc (10, hash_address_entry
, eq_address_entry
,
2208 xfree
, xcalloc
, xfree
);
2211 /* Initialize a new linespec parser. */
2214 linespec_parser_new (linespec_parser
*parser
,
2215 int flags
, const struct language_defn
*language
,
2216 struct symtab
*default_symtab
,
2218 struct linespec_result
*canonical
)
2220 parser
->lexer
.current
.type
= LSTOKEN_CONSUMED
;
2221 memset (PARSER_RESULT (parser
), 0, sizeof (struct linespec
));
2222 PARSER_RESULT (parser
)->line_offset
.sign
= LINE_OFFSET_UNKNOWN
;
2223 linespec_state_constructor (PARSER_STATE (parser
), flags
, language
,
2224 default_symtab
, default_line
, canonical
);
2227 /* A destructor for linespec_state. */
2230 linespec_state_destructor (struct linespec_state
*self
)
2232 htab_delete (self
->addr_set
);
2235 /* Delete a linespec parser. */
2238 linespec_parser_delete (void *arg
)
2240 linespec_parser
*parser
= (linespec_parser
*) arg
;
2242 xfree ((char *) PARSER_RESULT (parser
)->expression
);
2243 xfree ((char *) PARSER_RESULT (parser
)->source_filename
);
2244 xfree ((char *) PARSER_RESULT (parser
)->label_name
);
2245 xfree ((char *) PARSER_RESULT (parser
)->function_name
);
2247 if (PARSER_RESULT (parser
)->file_symtabs
!= NULL
)
2248 VEC_free (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
);
2250 if (PARSER_RESULT (parser
)->function_symbols
!= NULL
)
2251 VEC_free (symbolp
, PARSER_RESULT (parser
)->function_symbols
);
2253 if (PARSER_RESULT (parser
)->minimal_symbols
!= NULL
)
2254 VEC_free (minsym_and_objfile_d
, PARSER_RESULT (parser
)->minimal_symbols
);
2256 if (PARSER_RESULT (parser
)->labels
.label_symbols
!= NULL
)
2257 VEC_free (symbolp
, PARSER_RESULT (parser
)->labels
.label_symbols
);
2259 if (PARSER_RESULT (parser
)->labels
.function_symbols
!= NULL
)
2260 VEC_free (symbolp
, PARSER_RESULT (parser
)->labels
.function_symbols
);
2262 linespec_state_destructor (PARSER_STATE (parser
));
2265 /* See linespec.h. */
2268 decode_line_full (char **argptr
, int flags
,
2269 struct symtab
*default_symtab
,
2270 int default_line
, struct linespec_result
*canonical
,
2271 const char *select_mode
,
2274 struct symtabs_and_lines result
;
2275 struct cleanup
*cleanups
;
2276 char *arg_start
= *argptr
;
2277 VEC (const_char_ptr
) *filters
= NULL
;
2278 linespec_parser parser
;
2279 struct linespec_state
*state
;
2281 gdb_assert (canonical
!= NULL
);
2282 /* The filter only makes sense for 'all'. */
2283 gdb_assert (filter
== NULL
|| select_mode
== multiple_symbols_all
);
2284 gdb_assert (select_mode
== NULL
2285 || select_mode
== multiple_symbols_all
2286 || select_mode
== multiple_symbols_ask
2287 || select_mode
== multiple_symbols_cancel
);
2288 gdb_assert ((flags
& DECODE_LINE_LIST_MODE
) == 0);
2290 linespec_parser_new (&parser
, flags
, current_language
, default_symtab
,
2291 default_line
, canonical
);
2292 cleanups
= make_cleanup (linespec_parser_delete
, &parser
);
2293 save_current_program_space ();
2295 result
= parse_linespec (&parser
, argptr
);
2296 state
= PARSER_STATE (&parser
);
2298 gdb_assert (result
.nelts
== 1 || canonical
->pre_expanded
);
2299 gdb_assert (canonical
->addr_string
!= NULL
);
2300 canonical
->pre_expanded
= 1;
2302 /* Arrange for allocated canonical names to be freed. */
2303 if (result
.nelts
> 0)
2307 make_cleanup (xfree
, state
->canonical_names
);
2308 for (i
= 0; i
< result
.nelts
; ++i
)
2310 gdb_assert (state
->canonical_names
[i
] != NULL
);
2311 make_cleanup (xfree
, state
->canonical_names
[i
]);
2315 if (select_mode
== NULL
)
2317 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2318 select_mode
= multiple_symbols_all
;
2320 select_mode
= multiple_symbols_select_mode ();
2323 if (select_mode
== multiple_symbols_all
)
2327 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
2328 VEC_safe_push (const_char_ptr
, filters
, filter
);
2329 filter_results (state
, &result
, filters
);
2332 convert_results_to_lsals (state
, &result
);
2335 decode_line_2 (state
, &result
, select_mode
);
2337 do_cleanups (cleanups
);
2340 /* See linespec.h. */
2342 struct symtabs_and_lines
2343 decode_line_1 (char **argptr
, int flags
,
2344 struct symtab
*default_symtab
,
2347 struct symtabs_and_lines result
;
2348 linespec_parser parser
;
2349 struct cleanup
*cleanups
;
2351 linespec_parser_new (&parser
, flags
, current_language
, default_symtab
,
2352 default_line
, NULL
);
2353 cleanups
= make_cleanup (linespec_parser_delete
, &parser
);
2354 save_current_program_space ();
2356 result
= parse_linespec (&parser
, argptr
);
2358 do_cleanups (cleanups
);
2362 /* See linespec.h. */
2364 struct symtabs_and_lines
2365 decode_line_with_current_source (char *string
, int flags
)
2367 struct symtabs_and_lines sals
;
2368 struct symtab_and_line cursal
;
2371 error (_("Empty line specification."));
2373 /* We use whatever is set as the current source line. We do not try
2374 and get a default source symtab+line or it will recursively call us! */
2375 cursal
= get_current_source_symtab_and_line ();
2377 sals
= decode_line_1 (&string
, flags
,
2378 cursal
.symtab
, cursal
.line
);
2381 error (_("Junk at end of line specification: %s"), string
);
2385 /* See linespec.h. */
2387 struct symtabs_and_lines
2388 decode_line_with_last_displayed (char *string
, int flags
)
2390 struct symtabs_and_lines sals
;
2393 error (_("Empty line specification."));
2395 if (last_displayed_sal_is_valid ())
2396 sals
= decode_line_1 (&string
, flags
,
2397 get_last_displayed_symtab (),
2398 get_last_displayed_line ());
2400 sals
= decode_line_1 (&string
, flags
, (struct symtab
*) NULL
, 0);
2403 error (_("Junk at end of line specification: %s"), string
);
2409 /* First, some functions to initialize stuff at the beggining of the
2413 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
2415 if (*default_symtab
== 0)
2417 /* Use whatever we have for the default source line. We don't use
2418 get_current_or_default_symtab_and_line as it can recurse and call
2420 struct symtab_and_line cursal
=
2421 get_current_source_symtab_and_line ();
2423 *default_symtab
= cursal
.symtab
;
2424 *default_line
= cursal
.line
;
2430 /* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR,
2431 advancing EXP_PTR past any parsed text. */
2434 linespec_expression_to_pc (char **exp_ptr
)
2436 if (current_program_space
->executing_startup
)
2437 /* The error message doesn't really matter, because this case
2438 should only hit during breakpoint reset. */
2439 throw_error (NOT_FOUND_ERROR
, _("cannot evaluate expressions while "
2440 "program space is in startup"));
2443 return value_as_address (parse_to_comma_and_eval (exp_ptr
));
2448 /* Here's where we recognise an Objective-C Selector. An Objective C
2449 selector may be implemented by more than one class, therefore it
2450 may represent more than one method/function. This gives us a
2451 situation somewhat analogous to C++ overloading. If there's more
2452 than one method that could represent the selector, then use some of
2453 the existing C++ code to let the user choose one. */
2455 static struct symtabs_and_lines
2456 decode_objc (struct linespec_state
*self
, linespec_p ls
, char **argptr
)
2458 struct collect_info info
;
2459 VEC (const_char_ptr
) *symbol_names
= NULL
;
2460 struct symtabs_and_lines values
;
2462 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (const_char_ptr
),
2466 info
.file_symtabs
= NULL
;
2467 VEC_safe_push (symtab_p
, info
.file_symtabs
, NULL
);
2468 make_cleanup (VEC_cleanup (symtab_p
), &info
.file_symtabs
);
2469 info
.result
.symbols
= NULL
;
2470 info
.result
.minimal_symbols
= NULL
;
2474 new_argptr
= find_imps (*argptr
, &symbol_names
);
2475 if (VEC_empty (const_char_ptr
, symbol_names
))
2477 do_cleanups (cleanup
);
2481 add_all_symbol_names_from_pspace (&info
, NULL
, symbol_names
);
2483 if (!VEC_empty (symbolp
, info
.result
.symbols
)
2484 || !VEC_empty (minsym_and_objfile_d
, info
.result
.minimal_symbols
))
2488 saved_arg
= alloca (new_argptr
- *argptr
+ 1);
2489 memcpy (saved_arg
, *argptr
, new_argptr
- *argptr
);
2490 saved_arg
[new_argptr
- *argptr
] = '\0';
2492 ls
->function_name
= xstrdup (saved_arg
);
2493 ls
->function_symbols
= info
.result
.symbols
;
2494 ls
->minimal_symbols
= info
.result
.minimal_symbols
;
2495 values
= convert_linespec_to_sals (self
, ls
);
2497 if (self
->canonical
)
2499 self
->canonical
->pre_expanded
= 1;
2500 if (ls
->source_filename
)
2501 self
->canonical
->addr_string
2502 = xstrprintf ("%s:%s", ls
->source_filename
, saved_arg
);
2504 self
->canonical
->addr_string
= xstrdup (saved_arg
);
2508 *argptr
= new_argptr
;
2510 do_cleanups (cleanup
);
2515 /* An instance of this type is used when collecting prefix symbols for
2518 struct decode_compound_collector
2520 /* The result vector. */
2521 VEC (symbolp
) *symbols
;
2523 /* A hash table of all symbols we found. We use this to avoid
2524 adding any symbol more than once. */
2528 /* A callback for iterate_over_symbols that is used by
2529 lookup_prefix_sym to collect type symbols. */
2532 collect_one_symbol (struct symbol
*sym
, void *d
)
2534 struct decode_compound_collector
*collector
= d
;
2538 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
2539 return 1; /* Continue iterating. */
2541 t
= SYMBOL_TYPE (sym
);
2543 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2544 && TYPE_CODE (t
) != TYPE_CODE_UNION
2545 && TYPE_CODE (t
) != TYPE_CODE_NAMESPACE
)
2546 return 1; /* Continue iterating. */
2548 slot
= htab_find_slot (collector
->unique_syms
, sym
, INSERT
);
2552 VEC_safe_push (symbolp
, collector
->symbols
, sym
);
2555 return 1; /* Continue iterating. */
2558 /* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */
2560 static VEC (symbolp
) *
2561 lookup_prefix_sym (struct linespec_state
*state
, VEC (symtab_p
) *file_symtabs
,
2562 const char *class_name
)
2566 struct decode_compound_collector collector
;
2567 struct cleanup
*outer
;
2568 struct cleanup
*cleanup
;
2570 collector
.symbols
= NULL
;
2571 outer
= make_cleanup (VEC_cleanup (symbolp
), &collector
.symbols
);
2573 collector
.unique_syms
= htab_create_alloc (1, htab_hash_pointer
,
2574 htab_eq_pointer
, NULL
,
2576 cleanup
= make_cleanup_htab_delete (collector
.unique_syms
);
2578 for (ix
= 0; VEC_iterate (symtab_p
, file_symtabs
, ix
, elt
); ++ix
)
2582 iterate_over_all_matching_symtabs (state
, class_name
, STRUCT_DOMAIN
,
2583 collect_one_symbol
, &collector
,
2585 iterate_over_all_matching_symtabs (state
, class_name
, VAR_DOMAIN
,
2586 collect_one_symbol
, &collector
,
2591 struct block
*search_block
;
2593 /* Program spaces that are executing startup should have
2594 been filtered out earlier. */
2595 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
2596 set_current_program_space (SYMTAB_PSPACE (elt
));
2597 search_block
= get_search_block (elt
);
2598 LA_ITERATE_OVER_SYMBOLS (search_block
, class_name
, STRUCT_DOMAIN
,
2599 collect_one_symbol
, &collector
);
2600 LA_ITERATE_OVER_SYMBOLS (search_block
, class_name
, VAR_DOMAIN
,
2601 collect_one_symbol
, &collector
);
2605 do_cleanups (cleanup
);
2606 discard_cleanups (outer
);
2607 return collector
.symbols
;
2610 /* A qsort comparison function for symbols. The resulting order does
2611 not actually matter; we just need to be able to sort them so that
2612 symbols with the same program space end up next to each other. */
2615 compare_symbols (const void *a
, const void *b
)
2617 struct symbol
* const *sa
= a
;
2618 struct symbol
* const *sb
= b
;
2621 uia
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa
));
2622 uib
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb
));
2629 uia
= (uintptr_t) *sa
;
2630 uib
= (uintptr_t) *sb
;
2640 /* Like compare_symbols but for minimal symbols. */
2643 compare_msymbols (const void *a
, const void *b
)
2645 const struct minsym_and_objfile
*sa
= a
;
2646 const struct minsym_and_objfile
*sb
= b
;
2649 uia
= (uintptr_t) sa
->objfile
->pspace
;
2650 uib
= (uintptr_t) sa
->objfile
->pspace
;
2657 uia
= (uintptr_t) sa
->minsym
;
2658 uib
= (uintptr_t) sb
->minsym
;
2668 /* Look for all the matching instances of each symbol in NAMES. Only
2669 instances from PSPACE are considered; other program spaces are
2670 handled by our caller. If PSPACE is NULL, then all program spaces
2671 are considered. Results are stored into INFO. */
2674 add_all_symbol_names_from_pspace (struct collect_info
*info
,
2675 struct program_space
*pspace
,
2676 VEC (const_char_ptr
) *names
)
2681 for (ix
= 0; VEC_iterate (const_char_ptr
, names
, ix
, iter
); ++ix
)
2682 add_matching_symbols_to_info (iter
, info
, pspace
);
2686 find_superclass_methods (VEC (typep
) *superclasses
,
2688 VEC (const_char_ptr
) **result_names
)
2690 int old_len
= VEC_length (const_char_ptr
, *result_names
);
2691 VEC (typep
) *iter_classes
;
2692 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
2694 iter_classes
= superclasses
;
2697 VEC (typep
) *new_supers
= NULL
;
2701 make_cleanup (VEC_cleanup (typep
), &new_supers
);
2702 for (ix
= 0; VEC_iterate (typep
, iter_classes
, ix
, t
); ++ix
)
2703 find_methods (t
, name
, result_names
, &new_supers
);
2705 if (VEC_length (const_char_ptr
, *result_names
) != old_len
2706 || VEC_empty (typep
, new_supers
))
2709 iter_classes
= new_supers
;
2712 do_cleanups (cleanup
);
2715 /* This finds the method METHOD_NAME in the class CLASS_NAME whose type is
2716 given by one of the symbols in SYM_CLASSES. Matches are returned
2717 in SYMBOLS (for debug symbols) and MINSYMS (for minimal symbols). */
2720 find_method (struct linespec_state
*self
, VEC (symtab_p
) *file_symtabs
,
2721 const char *class_name
, const char *method_name
,
2722 VEC (symbolp
) *sym_classes
, VEC (symbolp
) **symbols
,
2723 VEC (minsym_and_objfile_d
) **minsyms
)
2726 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
2728 int last_result_len
;
2729 VEC (typep
) *superclass_vec
;
2730 VEC (const_char_ptr
) *result_names
;
2731 struct collect_info info
;
2733 /* Sort symbols so that symbols with the same program space are next
2735 qsort (VEC_address (symbolp
, sym_classes
),
2736 VEC_length (symbolp
, sym_classes
),
2741 info
.file_symtabs
= file_symtabs
;
2742 info
.result
.symbols
= NULL
;
2743 info
.result
.minimal_symbols
= NULL
;
2745 /* Iterate over all the types, looking for the names of existing
2746 methods matching METHOD_NAME. If we cannot find a direct method in a
2747 given program space, then we consider inherited methods; this is
2748 not ideal (ideal would be to respect C++ hiding rules), but it
2749 seems good enough and is what GDB has historically done. We only
2750 need to collect the names because later we find all symbols with
2751 those names. This loop is written in a somewhat funny way
2752 because we collect data across the program space before deciding
2754 superclass_vec
= NULL
;
2755 make_cleanup (VEC_cleanup (typep
), &superclass_vec
);
2756 result_names
= NULL
;
2757 make_cleanup (VEC_cleanup (const_char_ptr
), &result_names
);
2758 last_result_len
= 0;
2759 for (ix
= 0; VEC_iterate (symbolp
, sym_classes
, ix
, sym
); ++ix
)
2762 struct program_space
*pspace
;
2764 /* Program spaces that are executing startup should have
2765 been filtered out earlier. */
2766 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
))->executing_startup
);
2767 pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2768 set_current_program_space (pspace
);
2769 t
= check_typedef (SYMBOL_TYPE (sym
));
2770 find_methods (t
, method_name
, &result_names
, &superclass_vec
);
2772 /* Handle all items from a single program space at once; and be
2773 sure not to miss the last batch. */
2774 if (ix
== VEC_length (symbolp
, sym_classes
) - 1
2776 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp
, sym_classes
,
2779 /* If we did not find a direct implementation anywhere in
2780 this program space, consider superclasses. */
2781 if (VEC_length (const_char_ptr
, result_names
) == last_result_len
)
2782 find_superclass_methods (superclass_vec
, method_name
,
2785 /* We have a list of candidate symbol names, so now we
2786 iterate over the symbol tables looking for all
2787 matches in this pspace. */
2788 add_all_symbol_names_from_pspace (&info
, pspace
, result_names
);
2790 VEC_truncate (typep
, superclass_vec
, 0);
2791 last_result_len
= VEC_length (const_char_ptr
, result_names
);
2795 if (!VEC_empty (symbolp
, info
.result
.symbols
)
2796 || !VEC_empty (minsym_and_objfile_d
, info
.result
.minimal_symbols
))
2798 *symbols
= info
.result
.symbols
;
2799 *minsyms
= info
.result
.minimal_symbols
;
2800 do_cleanups (cleanup
);
2804 /* Throw an NOT_FOUND_ERROR. This will be caught by the caller
2805 and other attempts to locate the symbol will be made. */
2806 throw_error (NOT_FOUND_ERROR
, _("see caller, this text doesn't matter"));
2811 /* This object is used when collecting all matching symtabs. */
2813 struct symtab_collector
2815 /* The result vector of symtabs. */
2816 VEC (symtab_p
) *symtabs
;
2818 /* This is used to ensure the symtabs are unique. */
2819 htab_t symtab_table
;
2822 /* Callback for iterate_over_symtabs. */
2825 add_symtabs_to_list (struct symtab
*symtab
, void *d
)
2827 struct symtab_collector
*data
= d
;
2830 slot
= htab_find_slot (data
->symtab_table
, symtab
, INSERT
);
2834 VEC_safe_push (symtab_p
, data
->symtabs
, symtab
);
2840 /* Given a file name, return a VEC of all matching symtabs. */
2842 static VEC (symtab_p
) *
2843 collect_symtabs_from_filename (const char *file
)
2845 struct symtab_collector collector
;
2846 struct cleanup
*cleanups
;
2847 struct program_space
*pspace
;
2849 collector
.symtabs
= NULL
;
2850 collector
.symtab_table
= htab_create (1, htab_hash_pointer
, htab_eq_pointer
,
2852 cleanups
= make_cleanup_htab_delete (collector
.symtab_table
);
2854 /* Find that file's data. */
2855 ALL_PSPACES (pspace
)
2857 if (pspace
->executing_startup
)
2860 set_current_program_space (pspace
);
2861 iterate_over_symtabs (file
, add_symtabs_to_list
, &collector
);
2864 do_cleanups (cleanups
);
2865 return collector
.symtabs
;
2868 /* Return all the symtabs associated to the FILENAME. */
2870 static VEC (symtab_p
) *
2871 symtabs_from_filename (const char *filename
)
2873 VEC (symtab_p
) *result
;
2875 result
= collect_symtabs_from_filename (filename
);
2877 if (VEC_empty (symtab_p
, result
))
2879 if (!have_full_symbols () && !have_partial_symbols ())
2880 throw_error (NOT_FOUND_ERROR
,
2881 _("No symbol table is loaded. "
2882 "Use the \"file\" command."));
2883 throw_error (NOT_FOUND_ERROR
, _("No source file named %s."), filename
);
2889 /* Look up a function symbol named NAME in symtabs FILE_SYMTABS. Matching
2890 debug symbols are returned in SYMBOLS. Matching minimal symbols are
2891 returned in MINSYMS. */
2894 find_function_symbols (struct linespec_state
*state
,
2895 VEC (symtab_p
) *file_symtabs
, const char *name
,
2896 VEC (symbolp
) **symbols
,
2897 VEC (minsym_and_objfile_d
) **minsyms
)
2899 struct collect_info info
;
2900 VEC (const_char_ptr
) *symbol_names
= NULL
;
2901 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (const_char_ptr
),
2905 info
.result
.symbols
= NULL
;
2906 info
.result
.minimal_symbols
= NULL
;
2907 info
.file_symtabs
= file_symtabs
;
2909 /* Try NAME as an Objective-C selector. */
2910 find_imps ((char *) name
, &symbol_names
);
2911 if (!VEC_empty (const_char_ptr
, symbol_names
))
2912 add_all_symbol_names_from_pspace (&info
, NULL
, symbol_names
);
2914 add_matching_symbols_to_info (name
, &info
, NULL
);
2916 do_cleanups (cleanup
);
2918 if (VEC_empty (symbolp
, info
.result
.symbols
))
2920 VEC_free (symbolp
, info
.result
.symbols
);
2924 *symbols
= info
.result
.symbols
;
2926 if (VEC_empty (minsym_and_objfile_d
, info
.result
.minimal_symbols
))
2928 VEC_free (minsym_and_objfile_d
, info
.result
.minimal_symbols
);
2932 *minsyms
= info
.result
.minimal_symbols
;
2935 /* Find all symbols named NAME in FILE_SYMTABS, returning debug symbols
2936 in SYMBOLS and minimal symbols in MINSYMS. */
2939 find_linespec_symbols (struct linespec_state
*state
,
2940 VEC (symtab_p
) *file_symtabs
,
2942 VEC (symbolp
) **symbols
,
2943 VEC (minsym_and_objfile_d
) **minsyms
)
2945 char *klass
, *method
, *canon
;
2946 const char *lookup_name
, *last
, *p
, *scope_op
;
2947 struct cleanup
*cleanup
;
2948 VEC (symbolp
) *classes
;
2949 volatile struct gdb_exception except
;
2951 cleanup
= demangle_for_lookup (name
, state
->language
->la_language
,
2953 if (state
->language
->la_language
== language_ada
)
2955 /* In Ada, the symbol lookups are performed using the encoded
2956 name rather than the demangled name. */
2957 lookup_name
= ada_name_for_lookup (name
);
2958 make_cleanup (xfree
, (void *) lookup_name
);
2961 canon
= cp_canonicalize_string_no_typedefs (lookup_name
);
2964 lookup_name
= canon
;
2965 cleanup
= make_cleanup (xfree
, canon
);
2968 /* See if we can find a scope operator and break this symbol
2969 name into namespaces${SCOPE_OPERATOR}class_name and method_name. */
2971 p
= find_toplevel_string (lookup_name
, scope_op
);
2974 /* No C++ scope operator. Try Java. */
2976 p
= find_toplevel_string (lookup_name
, scope_op
);
2983 p
= find_toplevel_string (p
+ strlen (scope_op
), scope_op
);
2986 /* If no scope operator was found, lookup the name as a symbol. */
2989 find_function_symbols (state
, file_symtabs
, lookup_name
,
2991 do_cleanups (cleanup
);
2995 /* NAME points to the class name.
2996 LAST points to the method name. */
2997 klass
= xmalloc ((last
- lookup_name
+ 1) * sizeof (char));
2998 make_cleanup (xfree
, klass
);
2999 strncpy (klass
, lookup_name
, last
- lookup_name
);
3000 klass
[last
- lookup_name
] = '\0';
3002 /* Skip past the scope operator. */
3003 last
+= strlen (scope_op
);
3004 method
= xmalloc ((strlen (last
) + 1) * sizeof (char));
3005 make_cleanup (xfree
, method
);
3006 strcpy (method
, last
);
3008 /* Find a list of classes named KLASS. */
3009 classes
= lookup_prefix_sym (state
, file_symtabs
, klass
);
3010 make_cleanup (VEC_cleanup (symbolp
), &classes
);
3011 if (!VEC_empty (symbolp
, classes
))
3013 /* Now locate a list of suitable methods named METHOD. */
3014 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3016 find_method (state
, file_symtabs
, klass
, method
, classes
,
3020 /* If successful, we're done. If NOT_FOUND_ERROR
3021 was not thrown, rethrow the exception that we did get.
3022 Otherwise, fall back to looking up the entire name as a symbol.
3023 This can happen with namespace::function. */
3024 if (except
.reason
>= 0)
3026 do_cleanups (cleanup
);
3029 else if (except
.error
!= NOT_FOUND_ERROR
)
3030 throw_exception (except
);
3033 /* We couldn't find a class, so we check the entire name as a symbol
3035 find_function_symbols (state
, file_symtabs
, lookup_name
, symbols
, minsyms
);
3036 do_cleanups (cleanup
);
3039 /* Return all labels named NAME in FUNCTION_SYMBOLS. Return the
3040 actual function symbol in which the label was found in LABEL_FUNC_RET. */
3042 static VEC (symbolp
) *
3043 find_label_symbols (struct linespec_state
*self
,
3044 VEC (symbolp
) *function_symbols
,
3045 VEC (symbolp
) **label_funcs_ret
, const char *name
)
3048 struct block
*block
;
3050 struct symbol
*fn_sym
;
3051 VEC (symbolp
) *result
= NULL
;
3053 if (function_symbols
== NULL
)
3055 set_current_program_space (self
->program_space
);
3056 block
= get_search_block (NULL
);
3059 block
&& !BLOCK_FUNCTION (block
);
3060 block
= BLOCK_SUPERBLOCK (block
))
3064 fn_sym
= BLOCK_FUNCTION (block
);
3066 sym
= lookup_symbol (name
, block
, LABEL_DOMAIN
, 0);
3070 VEC_safe_push (symbolp
, result
, sym
);
3071 VEC_safe_push (symbolp
, *label_funcs_ret
, fn_sym
);
3077 VEC_iterate (symbolp
, function_symbols
, ix
, fn_sym
); ++ix
)
3079 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym
)));
3080 block
= SYMBOL_BLOCK_VALUE (fn_sym
);
3081 sym
= lookup_symbol (name
, block
, LABEL_DOMAIN
, 0);
3085 VEC_safe_push (symbolp
, result
, sym
);
3086 VEC_safe_push (symbolp
, *label_funcs_ret
, fn_sym
);
3096 /* A helper for create_sals_line_offset that handles the 'list_mode' case. */
3099 decode_digits_list_mode (struct linespec_state
*self
,
3101 struct symtabs_and_lines
*values
,
3102 struct symtab_and_line val
)
3107 gdb_assert (self
->list_mode
);
3109 for (ix
= 0; VEC_iterate (symtab_p
, ls
->file_symtabs
, ix
, elt
);
3112 /* The logic above should ensure this. */
3113 gdb_assert (elt
!= NULL
);
3115 set_current_program_space (SYMTAB_PSPACE (elt
));
3117 /* Simplistic search just for the list command. */
3118 val
.symtab
= find_line_symtab (elt
, val
.line
, NULL
, NULL
);
3119 if (val
.symtab
== NULL
)
3121 val
.pspace
= SYMTAB_PSPACE (elt
);
3123 val
.explicit_line
= 1;
3125 add_sal_to_sals (self
, values
, &val
, NULL
, 0);
3129 /* A helper for create_sals_line_offset that iterates over the symtabs,
3130 adding lines to the VEC. */
3133 decode_digits_ordinary (struct linespec_state
*self
,
3136 struct symtabs_and_lines
*sals
,
3137 struct linetable_entry
**best_entry
)
3142 for (ix
= 0; VEC_iterate (symtab_p
, ls
->file_symtabs
, ix
, elt
); ++ix
)
3145 VEC (CORE_ADDR
) *pcs
;
3148 /* The logic above should ensure this. */
3149 gdb_assert (elt
!= NULL
);
3151 set_current_program_space (SYMTAB_PSPACE (elt
));
3153 pcs
= find_pcs_for_symtab_line (elt
, line
, best_entry
);
3154 for (i
= 0; VEC_iterate (CORE_ADDR
, pcs
, i
, pc
); ++i
)
3156 struct symtab_and_line sal
;
3159 sal
.pspace
= SYMTAB_PSPACE (elt
);
3163 add_sal_to_sals_basic (sals
, &sal
);
3166 VEC_free (CORE_ADDR
, pcs
);
3172 /* Return the line offset represented by VARIABLE. */
3174 static struct line_offset
3175 linespec_parse_variable (struct linespec_state
*self
, const char *variable
)
3179 struct line_offset offset
= {0, LINE_OFFSET_NONE
};
3181 p
= (variable
[1] == '$') ? variable
+ 2 : variable
+ 1;
3184 while (*p
>= '0' && *p
<= '9')
3186 if (!*p
) /* Reached end of token without hitting non-digit. */
3188 /* We have a value history reference. */
3189 struct value
*val_history
;
3191 sscanf ((variable
[1] == '$') ? variable
+ 2 : variable
+ 1, "%d", &index
);
3193 = access_value_history ((variable
[1] == '$') ? -index
: index
);
3194 if (TYPE_CODE (value_type (val_history
)) != TYPE_CODE_INT
)
3195 error (_("History values used in line "
3196 "specs must have integer values."));
3197 offset
.offset
= value_as_long (val_history
);
3201 /* Not all digits -- may be user variable/function or a
3202 convenience variable. */
3204 struct internalvar
*ivar
;
3206 /* Try it as a convenience variable. If it is not a convenience
3207 variable, return and allow normal symbol lookup to occur. */
3208 ivar
= lookup_only_internalvar (variable
+ 1);
3210 /* No internal variable with that name. Mark the offset
3211 as unknown to allow the name to be looked up as a symbol. */
3212 offset
.sign
= LINE_OFFSET_UNKNOWN
;
3215 /* We found a valid variable name. If it is not an integer,
3217 if (!get_internalvar_integer (ivar
, &valx
))
3218 error (_("Convenience variables used in line "
3219 "specs must have integer values."));
3221 offset
.offset
= valx
;
3229 /* A callback used to possibly add a symbol to the results. */
3232 collect_symbols (struct symbol
*sym
, void *data
)
3234 struct collect_info
*info
= data
;
3236 /* In list mode, add all matching symbols, regardless of class.
3237 This allows the user to type "list a_global_variable". */
3238 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
|| info
->state
->list_mode
)
3239 VEC_safe_push (symbolp
, info
->result
.symbols
, sym
);
3240 return 1; /* Continue iterating. */
3243 /* We've found a minimal symbol MSYMBOL in OBJFILE to associate with our
3244 linespec; return the SAL in RESULT. */
3247 minsym_found (struct linespec_state
*self
, struct objfile
*objfile
,
3248 struct minimal_symbol
*msymbol
,
3249 struct symtabs_and_lines
*result
)
3251 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3253 struct symtab_and_line sal
;
3255 sal
= find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
3256 (struct obj_section
*) 0, 0);
3257 sal
.section
= SYMBOL_OBJ_SECTION (msymbol
);
3259 /* The minimal symbol might point to a function descriptor;
3260 resolve it to the actual code address instead. */
3261 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, sal
.pc
, ¤t_target
);
3263 sal
= find_pc_sect_line (pc
, NULL
, 0);
3265 if (self
->funfirstline
)
3266 skip_prologue_sal (&sal
);
3268 if (maybe_add_address (self
->addr_set
, objfile
->pspace
, sal
.pc
))
3269 add_sal_to_sals (self
, result
, &sal
, SYMBOL_NATURAL_NAME (msymbol
), 0);
3272 /* A helper struct to pass some data through
3273 iterate_over_minimal_symbols. */
3275 struct collect_minsyms
3277 /* The objfile we're examining. */
3278 struct objfile
*objfile
;
3280 /* The funfirstline setting from the initial call. */
3283 /* The list_mode setting from the initial call. */
3286 /* The resulting symbols. */
3287 VEC (minsym_and_objfile_d
) *msyms
;
3290 /* A helper function to classify a minimal_symbol_type according to
3294 classify_mtype (enum minimal_symbol_type t
)
3301 /* Intermediate priority. */
3304 case mst_solib_trampoline
:
3305 /* Lowest priority. */
3309 /* Highest priority. */
3314 /* Callback for qsort that sorts symbols by priority. */
3317 compare_msyms (const void *a
, const void *b
)
3319 const minsym_and_objfile_d
*moa
= a
;
3320 const minsym_and_objfile_d
*mob
= b
;
3321 enum minimal_symbol_type ta
= MSYMBOL_TYPE (moa
->minsym
);
3322 enum minimal_symbol_type tb
= MSYMBOL_TYPE (mob
->minsym
);
3324 return classify_mtype (ta
) - classify_mtype (tb
);
3327 /* Callback for iterate_over_minimal_symbols that adds the symbol to
3331 add_minsym (struct minimal_symbol
*minsym
, void *d
)
3333 struct collect_minsyms
*info
= d
;
3334 minsym_and_objfile_d mo
;
3336 /* Exclude data symbols when looking for breakpoint locations. */
3337 if (!info
->list_mode
)
3338 switch (minsym
->type
)
3340 case mst_slot_got_plt
:
3347 /* Make sure this minsym is not a function descriptor
3348 before we decide to discard it. */
3349 struct gdbarch
*gdbarch
= info
->objfile
->gdbarch
;
3350 CORE_ADDR addr
= gdbarch_convert_from_func_ptr_addr
3351 (gdbarch
, SYMBOL_VALUE_ADDRESS (minsym
),
3354 if (addr
== SYMBOL_VALUE_ADDRESS (minsym
))
3360 mo
.objfile
= info
->objfile
;
3361 VEC_safe_push (minsym_and_objfile_d
, info
->msyms
, &mo
);
3364 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
3365 is not NULL, the search is restricted to just that program
3369 search_minsyms_for_name (struct collect_info
*info
, const char *name
,
3370 struct program_space
*search_pspace
)
3372 struct objfile
*objfile
;
3373 struct program_space
*pspace
;
3375 ALL_PSPACES (pspace
)
3377 struct collect_minsyms local
;
3378 struct cleanup
*cleanup
;
3380 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
3382 if (pspace
->executing_startup
)
3385 set_current_program_space (pspace
);
3387 memset (&local
, 0, sizeof (local
));
3388 local
.funfirstline
= info
->state
->funfirstline
;
3389 local
.list_mode
= info
->state
->list_mode
;
3391 cleanup
= make_cleanup (VEC_cleanup (minsym_and_objfile_d
),
3394 ALL_OBJFILES (objfile
)
3396 local
.objfile
= objfile
;
3397 iterate_over_minimal_symbols (objfile
, name
, add_minsym
, &local
);
3400 if (!VEC_empty (minsym_and_objfile_d
, local
.msyms
))
3404 minsym_and_objfile_d
*item
;
3406 qsort (VEC_address (minsym_and_objfile_d
, local
.msyms
),
3407 VEC_length (minsym_and_objfile_d
, local
.msyms
),
3408 sizeof (minsym_and_objfile_d
),
3411 /* Now the minsyms are in classification order. So, we walk
3412 over them and process just the minsyms with the same
3413 classification as the very first minsym in the list. */
3414 item
= VEC_index (minsym_and_objfile_d
, local
.msyms
, 0);
3415 classification
= classify_mtype (MSYMBOL_TYPE (item
->minsym
));
3418 VEC_iterate (minsym_and_objfile_d
, local
.msyms
, ix
, item
);
3421 if (classify_mtype (MSYMBOL_TYPE (item
->minsym
)) != classification
)
3424 VEC_safe_push (minsym_and_objfile_d
,
3425 info
->result
.minimal_symbols
, item
);
3429 do_cleanups (cleanup
);
3433 /* A helper function to add all symbols matching NAME to INFO. If
3434 PSPACE is not NULL, the search is restricted to just that program
3438 add_matching_symbols_to_info (const char *name
,
3439 struct collect_info
*info
,
3440 struct program_space
*pspace
)
3445 for (ix
= 0; VEC_iterate (symtab_p
, info
->file_symtabs
, ix
, elt
); ++ix
)
3449 iterate_over_all_matching_symtabs (info
->state
, name
, VAR_DOMAIN
,
3450 collect_symbols
, info
,
3452 search_minsyms_for_name (info
, name
, pspace
);
3454 else if (pspace
== NULL
|| pspace
== SYMTAB_PSPACE (elt
))
3456 /* Program spaces that are executing startup should have
3457 been filtered out earlier. */
3458 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
3459 set_current_program_space (SYMTAB_PSPACE (elt
));
3460 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt
), name
,
3461 VAR_DOMAIN
, collect_symbols
,
3469 /* Now come some functions that are called from multiple places within
3473 symbol_to_sal (struct symtab_and_line
*result
,
3474 int funfirstline
, struct symbol
*sym
)
3476 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3478 *result
= find_function_start_sal (sym
, funfirstline
);
3483 if (SYMBOL_CLASS (sym
) == LOC_LABEL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
3486 result
->symtab
= SYMBOL_SYMTAB (sym
);
3487 result
->line
= SYMBOL_LINE (sym
);
3488 result
->pc
= SYMBOL_VALUE_ADDRESS (sym
);
3489 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3490 result
->explicit_pc
= 1;
3493 else if (funfirstline
)
3497 else if (SYMBOL_LINE (sym
) != 0)
3499 /* We know its line number. */
3501 result
->symtab
= SYMBOL_SYMTAB (sym
);
3502 result
->line
= SYMBOL_LINE (sym
);
3503 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3511 /* See the comment in linespec.h. */
3514 init_linespec_result (struct linespec_result
*lr
)
3516 memset (lr
, 0, sizeof (*lr
));
3519 /* See the comment in linespec.h. */
3522 destroy_linespec_result (struct linespec_result
*ls
)
3525 struct linespec_sals
*lsal
;
3527 xfree (ls
->addr_string
);
3528 for (i
= 0; VEC_iterate (linespec_sals
, ls
->sals
, i
, lsal
); ++i
)
3530 xfree (lsal
->canonical
);
3531 xfree (lsal
->sals
.sals
);
3533 VEC_free (linespec_sals
, ls
->sals
);
3536 /* Cleanup function for a linespec_result. */
3539 cleanup_linespec_result (void *a
)
3541 destroy_linespec_result (a
);
3544 /* See the comment in linespec.h. */
3547 make_cleanup_destroy_linespec_result (struct linespec_result
*ls
)
3549 return make_cleanup (cleanup_linespec_result
, ls
);