1 /* Parser for linespec for the GNU debugger, GDB.
3 Copyright (C) 1986-2013 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 /* A canonical linespec represented as a symtab-related string.
162 Each entry represents the "SYMTAB:SUFFIX" linespec string.
163 SYMTAB can be converted for example by symtab_to_fullname or
164 symtab_to_filename_for_display as needed. */
166 struct linespec_canonical_name
168 /* Remaining text part of the linespec string. */
171 /* If NULL then SUFFIX is the whole linespec string. */
172 struct symtab
*symtab
;
175 /* An instance of this is used to keep all state while linespec
176 operates. This instance is passed around as a 'this' pointer to
177 the various implementation methods. */
179 struct linespec_state
181 /* The language in use during linespec processing. */
182 const struct language_defn
*language
;
184 /* The program space as seen when the module was entered. */
185 struct program_space
*program_space
;
187 /* The default symtab to use, if no other symtab is specified. */
188 struct symtab
*default_symtab
;
190 /* The default line to use. */
193 /* The 'funfirstline' value that was passed in to decode_line_1 or
197 /* Nonzero if we are running in 'list' mode; see decode_line_list. */
200 /* The 'canonical' value passed to decode_line_full, or NULL. */
201 struct linespec_result
*canonical
;
203 /* Canonical strings that mirror the symtabs_and_lines result. */
204 struct linespec_canonical_name
*canonical_names
;
206 /* This is a set of address_entry objects which is used to prevent
207 duplicate symbols from being entered into the result. */
211 /* This is a helper object that is used when collecting symbols into a
216 /* The linespec object in use. */
217 struct linespec_state
*state
;
219 /* A list of symtabs to which to restrict matches. */
220 VEC (symtab_p
) *file_symtabs
;
222 /* The result being accumulated. */
225 VEC (symbolp
) *symbols
;
226 VEC (minsym_and_objfile_d
) *minimal_symbols
;
237 /* A colon "separator" */
249 /* EOI (end of input) */
255 typedef enum ls_token_type linespec_token_type
;
257 /* List of keywords */
259 static const char * const linespec_keywords
[] = { "if", "thread", "task" };
261 /* A token of the linespec lexer */
265 /* The type of the token */
266 linespec_token_type type
;
268 /* Data for the token */
271 /* A string, given as a stoken */
272 struct stoken string
;
278 typedef struct ls_token linespec_token
;
280 #define LS_TOKEN_STOKEN(TOK) (TOK).data.string
281 #define LS_TOKEN_KEYWORD(TOK) (TOK).data.keyword
283 /* An instance of the linespec parser. */
287 /* Lexer internal data */
290 /* Save head of input stream. */
293 /* Head of the input stream. */
295 #define PARSER_STREAM(P) (*(P)->lexer.stream)
297 /* The current token. */
298 linespec_token current
;
301 /* Is the entire linespec quote-enclosed? */
302 int is_quote_enclosed
;
304 /* Is a keyword syntactically valid at this point?
305 In, e.g., "break thread thread 1", the leading "keyword" must not
306 be interpreted as such. */
309 /* The state of the parse. */
310 struct linespec_state state
;
311 #define PARSER_STATE(PPTR) (&(PPTR)->state)
313 /* The result of the parse. */
314 struct linespec result
;
315 #define PARSER_RESULT(PPTR) (&(PPTR)->result)
317 typedef struct ls_parser linespec_parser
;
319 /* Prototypes for local functions. */
321 static void initialize_defaults (struct symtab
**default_symtab
,
324 static CORE_ADDR
linespec_expression_to_pc (char **exp_ptr
);
326 static struct symtabs_and_lines
decode_objc (struct linespec_state
*self
,
330 static VEC (symtab_p
) *symtabs_from_filename (const char *);
332 static VEC (symbolp
) *find_label_symbols (struct linespec_state
*self
,
333 VEC (symbolp
) *function_symbols
,
334 VEC (symbolp
) **label_funcs_ret
,
337 static void find_linespec_symbols (struct linespec_state
*self
,
338 VEC (symtab_p
) *file_symtabs
,
340 VEC (symbolp
) **symbols
,
341 VEC (minsym_and_objfile_d
) **minsyms
);
343 static struct line_offset
344 linespec_parse_variable (struct linespec_state
*self
,
345 const char *variable
);
347 static int symbol_to_sal (struct symtab_and_line
*result
,
348 int funfirstline
, struct symbol
*sym
);
350 static void add_matching_symbols_to_info (const char *name
,
351 struct collect_info
*info
,
352 struct program_space
*pspace
);
354 static void add_all_symbol_names_from_pspace (struct collect_info
*info
,
355 struct program_space
*pspace
,
356 VEC (const_char_ptr
) *names
);
358 static VEC (symtab_p
) *collect_symtabs_from_filename (const char *file
);
360 static void decode_digits_ordinary (struct linespec_state
*self
,
363 struct symtabs_and_lines
*sals
,
364 struct linetable_entry
**best_entry
);
366 static void decode_digits_list_mode (struct linespec_state
*self
,
368 struct symtabs_and_lines
*values
,
369 struct symtab_and_line val
);
371 static void minsym_found (struct linespec_state
*self
, struct objfile
*objfile
,
372 struct minimal_symbol
*msymbol
,
373 struct symtabs_and_lines
*result
);
375 static int compare_symbols (const void *a
, const void *b
);
377 static int compare_msymbols (const void *a
, const void *b
);
379 static const char *find_toplevel_char (const char *s
, char c
);
381 /* Permitted quote characters for the parser. This is different from the
382 completer's quote characters to allow backward compatibility with the
384 static const char *const linespec_quote_characters
= "\"\'";
386 /* Lexer functions. */
388 /* Lex a number from the input in PARSER. This only supports
391 Return true if input is decimal numbers. Return false if not. */
394 linespec_lexer_lex_number (linespec_parser
*parser
, linespec_token
*tokenp
)
396 tokenp
->type
= LSTOKEN_NUMBER
;
397 LS_TOKEN_STOKEN (*tokenp
).length
= 0;
398 LS_TOKEN_STOKEN (*tokenp
).ptr
= PARSER_STREAM (parser
);
400 /* Keep any sign at the start of the stream. */
401 if (*PARSER_STREAM (parser
) == '+' || *PARSER_STREAM (parser
) == '-')
403 ++LS_TOKEN_STOKEN (*tokenp
).length
;
404 ++(PARSER_STREAM (parser
));
407 while (isdigit (*PARSER_STREAM (parser
)))
409 ++LS_TOKEN_STOKEN (*tokenp
).length
;
410 ++(PARSER_STREAM (parser
));
413 /* If the next character in the input buffer is not a space, comma,
414 quote, or colon, this input does not represent a number. */
415 if (*PARSER_STREAM (parser
) != '\0'
416 && !isspace (*PARSER_STREAM (parser
)) && *PARSER_STREAM (parser
) != ','
417 && *PARSER_STREAM (parser
) != ':'
418 && !strchr (linespec_quote_characters
, *PARSER_STREAM (parser
)))
420 PARSER_STREAM (parser
) = LS_TOKEN_STOKEN (*tokenp
).ptr
;
427 /* Does P represent one of the keywords? If so, return
428 the keyword. If not, return NULL. */
431 linespec_lexer_lex_keyword (const char *p
)
437 for (i
= 0; i
< ARRAY_SIZE (linespec_keywords
); ++i
)
439 int len
= strlen (linespec_keywords
[i
]);
441 /* If P begins with one of the keywords and the next
442 character is not a valid identifier character,
443 we have found a keyword. */
444 if (strncmp (p
, linespec_keywords
[i
], len
) == 0
445 && !(isalnum (p
[len
]) || p
[len
] == '_'))
446 return linespec_keywords
[i
];
453 /* Does STRING represent an Ada operator? If so, return the length
454 of the decoded operator name. If not, return 0. */
457 is_ada_operator (const char *string
)
459 const struct ada_opname_map
*mapping
;
461 for (mapping
= ada_opname_table
;
462 mapping
->encoded
!= NULL
463 && strncmp (mapping
->decoded
, string
,
464 strlen (mapping
->decoded
)) != 0; ++mapping
)
467 return mapping
->decoded
== NULL
? 0 : strlen (mapping
->decoded
);
470 /* Find QUOTE_CHAR in STRING, accounting for the ':' terminal. Return
471 the location of QUOTE_CHAR, or NULL if not found. */
474 skip_quote_char (const char *string
, char quote_char
)
476 const char *p
, *last
;
478 p
= last
= find_toplevel_char (string
, quote_char
);
479 while (p
&& *p
!= '\0' && *p
!= ':')
481 p
= find_toplevel_char (p
, quote_char
);
489 /* Make a writable copy of the string given in TOKEN, trimming
490 any trailing whitespace. */
493 copy_token_string (linespec_token token
)
497 if (token
.type
== LSTOKEN_KEYWORD
)
498 return xstrdup (LS_TOKEN_KEYWORD (token
));
500 str
= savestring (LS_TOKEN_STOKEN (token
).ptr
,
501 LS_TOKEN_STOKEN (token
).length
);
502 s
= remove_trailing_whitespace (str
, str
+ LS_TOKEN_STOKEN (token
).length
);
508 /* Does P represent the end of a quote-enclosed linespec? */
511 is_closing_quote_enclosed (const char *p
)
513 if (strchr (linespec_quote_characters
, *p
))
515 p
= skip_spaces ((char *) p
);
516 return (*p
== '\0' || linespec_lexer_lex_keyword (p
));
519 /* Find the end of the parameter list that starts with *INPUT.
520 This helper function assists with lexing string segments
521 which might contain valid (non-terminating) commas. */
524 find_parameter_list_end (char *input
)
526 char end_char
, start_char
;
531 if (start_char
== '(')
533 else if (start_char
== '<')
542 if (*p
== start_char
)
544 else if (*p
== end_char
)
559 /* Lex a string from the input in PARSER. */
561 static linespec_token
562 linespec_lexer_lex_string (linespec_parser
*parser
)
564 linespec_token token
;
565 char *start
= PARSER_STREAM (parser
);
567 token
.type
= LSTOKEN_STRING
;
569 /* If the input stream starts with a quote character, skip to the next
570 quote character, regardless of the content. */
571 if (strchr (linespec_quote_characters
, *PARSER_STREAM (parser
)))
574 char quote_char
= *PARSER_STREAM (parser
);
576 /* Special case: Ada operators. */
577 if (PARSER_STATE (parser
)->language
->la_language
== language_ada
578 && quote_char
== '\"')
580 int len
= is_ada_operator (PARSER_STREAM (parser
));
584 /* The input is an Ada operator. Return the quoted string
586 LS_TOKEN_STOKEN (token
).ptr
= PARSER_STREAM (parser
);
587 LS_TOKEN_STOKEN (token
).length
= len
;
588 PARSER_STREAM (parser
) += len
;
592 /* The input does not represent an Ada operator -- fall through
593 to normal quoted string handling. */
596 /* Skip past the beginning quote. */
597 ++(PARSER_STREAM (parser
));
599 /* Mark the start of the string. */
600 LS_TOKEN_STOKEN (token
).ptr
= PARSER_STREAM (parser
);
602 /* Skip to the ending quote. */
603 end
= skip_quote_char (PARSER_STREAM (parser
), quote_char
);
605 /* Error if the input did not terminate properly. */
607 error (_("unmatched quote"));
609 /* Skip over the ending quote and mark the length of the string. */
610 PARSER_STREAM (parser
) = (char *) ++end
;
611 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - 2 - start
;
617 /* Otherwise, only identifier characters are permitted.
618 Spaces are the exception. In general, we keep spaces,
619 but only if the next characters in the input do not resolve
620 to one of the keywords.
622 This allows users to forgo quoting CV-qualifiers, template arguments,
623 and similar common language constructs. */
627 if (isspace (*PARSER_STREAM (parser
)))
629 p
= skip_spaces (PARSER_STREAM (parser
));
630 /* When we get here we know we've found something followed by
631 a space (we skip over parens and templates below).
632 So if we find a keyword now, we know it is a keyword and not,
633 say, a function name. */
634 if (linespec_lexer_lex_keyword (p
) != NULL
)
636 LS_TOKEN_STOKEN (token
).ptr
= start
;
637 LS_TOKEN_STOKEN (token
).length
638 = PARSER_STREAM (parser
) - start
;
642 /* Advance past the whitespace. */
643 PARSER_STREAM (parser
) = p
;
646 /* If the next character is EOI or (single) ':', the
647 string is complete; return the token. */
648 if (*PARSER_STREAM (parser
) == 0)
650 LS_TOKEN_STOKEN (token
).ptr
= start
;
651 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - start
;
654 else if (PARSER_STREAM (parser
)[0] == ':')
656 /* Do not tokenize the C++ scope operator. */
657 if (PARSER_STREAM (parser
)[1] == ':')
658 ++(PARSER_STREAM (parser
));
660 /* Do not tokenify if the input length so far is one
661 (i.e, a single-letter drive name) and the next character
662 is a directory separator. This allows Windows-style
663 paths to be recognized as filenames without quoting it. */
664 else if ((PARSER_STREAM (parser
) - start
) != 1
665 || !IS_DIR_SEPARATOR (PARSER_STREAM (parser
)[1]))
667 LS_TOKEN_STOKEN (token
).ptr
= start
;
668 LS_TOKEN_STOKEN (token
).length
669 = PARSER_STREAM (parser
) - start
;
673 /* Special case: permit quote-enclosed linespecs. */
674 else if (parser
->is_quote_enclosed
675 && strchr (linespec_quote_characters
,
676 *PARSER_STREAM (parser
))
677 && is_closing_quote_enclosed (PARSER_STREAM (parser
)))
679 LS_TOKEN_STOKEN (token
).ptr
= start
;
680 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - start
;
683 /* Because commas may terminate a linespec and appear in
684 the middle of valid string input, special cases for
685 '<' and '(' are necessary. */
686 else if (*PARSER_STREAM (parser
) == '<'
687 || *PARSER_STREAM (parser
) == '(')
691 p
= find_parameter_list_end (PARSER_STREAM (parser
));
694 PARSER_STREAM (parser
) = p
;
698 /* Commas are terminators, but not if they are part of an
700 else if (*PARSER_STREAM (parser
) == ',')
702 if ((PARSER_STATE (parser
)->language
->la_language
704 && (PARSER_STREAM (parser
) - start
) > 8
705 /* strlen ("operator") */)
707 char *p
= strstr (start
, "operator");
709 if (p
!= NULL
&& is_operator_name (p
))
711 /* This is an operator name. Keep going. */
712 ++(PARSER_STREAM (parser
));
717 /* Comma terminates the string. */
718 LS_TOKEN_STOKEN (token
).ptr
= start
;
719 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - start
;
723 /* Advance the stream. */
724 ++(PARSER_STREAM (parser
));
731 /* Lex a single linespec token from PARSER. */
733 static linespec_token
734 linespec_lexer_lex_one (linespec_parser
*parser
)
738 if (parser
->lexer
.current
.type
== LSTOKEN_CONSUMED
)
740 /* Skip any whitespace. */
741 PARSER_STREAM (parser
) = skip_spaces (PARSER_STREAM (parser
));
743 /* Check for a keyword, they end the linespec. */
745 if (parser
->keyword_ok
)
746 keyword
= linespec_lexer_lex_keyword (PARSER_STREAM (parser
));
749 parser
->lexer
.current
.type
= LSTOKEN_KEYWORD
;
750 LS_TOKEN_KEYWORD (parser
->lexer
.current
) = keyword
;
751 return parser
->lexer
.current
;
754 /* Handle other tokens. */
755 switch (*PARSER_STREAM (parser
))
758 parser
->lexer
.current
.type
= LSTOKEN_EOI
;
762 case '0': case '1': case '2': case '3': case '4':
763 case '5': case '6': case '7': case '8': case '9':
764 if (!linespec_lexer_lex_number (parser
, &(parser
->lexer
.current
)))
765 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
769 /* If we have a scope operator, lex the input as a string.
770 Otherwise, return LSTOKEN_COLON. */
771 if (PARSER_STREAM (parser
)[1] == ':')
772 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
775 parser
->lexer
.current
.type
= LSTOKEN_COLON
;
776 ++(PARSER_STREAM (parser
));
780 case '\'': case '\"':
781 /* Special case: permit quote-enclosed linespecs. */
782 if (parser
->is_quote_enclosed
783 && is_closing_quote_enclosed (PARSER_STREAM (parser
)))
785 ++(PARSER_STREAM (parser
));
786 parser
->lexer
.current
.type
= LSTOKEN_EOI
;
789 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
793 parser
->lexer
.current
.type
= LSTOKEN_COMMA
;
794 LS_TOKEN_STOKEN (parser
->lexer
.current
).ptr
795 = PARSER_STREAM (parser
);
796 LS_TOKEN_STOKEN (parser
->lexer
.current
).length
= 1;
797 ++(PARSER_STREAM (parser
));
801 /* If the input is not a number, it must be a string.
802 [Keywords were already considered above.] */
803 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
808 return parser
->lexer
.current
;
811 /* Consume the current token and return the next token in PARSER's
814 static linespec_token
815 linespec_lexer_consume_token (linespec_parser
*parser
)
817 parser
->lexer
.current
.type
= LSTOKEN_CONSUMED
;
818 return linespec_lexer_lex_one (parser
);
821 /* Return the next token without consuming the current token. */
823 static linespec_token
824 linespec_lexer_peek_token (linespec_parser
*parser
)
827 char *saved_stream
= PARSER_STREAM (parser
);
828 linespec_token saved_token
= parser
->lexer
.current
;
830 next
= linespec_lexer_consume_token (parser
);
831 PARSER_STREAM (parser
) = saved_stream
;
832 parser
->lexer
.current
= saved_token
;
836 /* Helper functions. */
838 /* Add SAL to SALS. */
841 add_sal_to_sals_basic (struct symtabs_and_lines
*sals
,
842 struct symtab_and_line
*sal
)
845 sals
->sals
= xrealloc (sals
->sals
, sals
->nelts
* sizeof (sals
->sals
[0]));
846 sals
->sals
[sals
->nelts
- 1] = *sal
;
849 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
850 the new sal, if needed. If not NULL, SYMNAME is the name of the
851 symbol to use when constructing the new canonical name.
853 If LITERAL_CANONICAL is non-zero, SYMNAME will be used as the
854 canonical name for the SAL. */
857 add_sal_to_sals (struct linespec_state
*self
,
858 struct symtabs_and_lines
*sals
,
859 struct symtab_and_line
*sal
,
860 const char *symname
, int literal_canonical
)
862 add_sal_to_sals_basic (sals
, sal
);
866 struct linespec_canonical_name
*canonical
;
868 self
->canonical_names
= xrealloc (self
->canonical_names
,
870 * sizeof (*self
->canonical_names
)));
871 canonical
= &self
->canonical_names
[sals
->nelts
- 1];
872 if (!literal_canonical
&& sal
->symtab
)
874 const char *fullname
= symtab_to_fullname (sal
->symtab
);
876 /* Note that the filter doesn't have to be a valid linespec
877 input. We only apply the ":LINE" treatment to Ada for
879 if (symname
!= NULL
&& sal
->line
!= 0
880 && self
->language
->la_language
== language_ada
)
881 canonical
->suffix
= xstrprintf ("%s:%d", symname
, sal
->line
);
882 else if (symname
!= NULL
)
883 canonical
->suffix
= xstrdup (symname
);
885 canonical
->suffix
= xstrprintf ("%d", sal
->line
);
886 canonical
->symtab
= sal
->symtab
;
891 canonical
->suffix
= xstrdup (symname
);
893 canonical
->suffix
= NULL
;
894 canonical
->symtab
= NULL
;
899 /* A hash function for address_entry. */
902 hash_address_entry (const void *p
)
904 const struct address_entry
*aep
= p
;
907 hash
= iterative_hash_object (aep
->pspace
, 0);
908 return iterative_hash_object (aep
->addr
, hash
);
911 /* An equality function for address_entry. */
914 eq_address_entry (const void *a
, const void *b
)
916 const struct address_entry
*aea
= a
;
917 const struct address_entry
*aeb
= b
;
919 return aea
->pspace
== aeb
->pspace
&& aea
->addr
== aeb
->addr
;
922 /* Check whether the address, represented by PSPACE and ADDR, is
923 already in the set. If so, return 0. Otherwise, add it and return
927 maybe_add_address (htab_t set
, struct program_space
*pspace
, CORE_ADDR addr
)
929 struct address_entry e
, *p
;
934 slot
= htab_find_slot (set
, &e
, INSERT
);
938 p
= XNEW (struct address_entry
);
939 memcpy (p
, &e
, sizeof (struct address_entry
));
945 /* A callback function and the additional data to call it with. */
947 struct symbol_and_data_callback
949 /* The callback to use. */
950 symbol_found_callback_ftype
*callback
;
952 /* Data to be passed to the callback. */
956 /* A helper for iterate_over_all_matching_symtabs that is used to
957 restrict calls to another callback to symbols representing inline
961 iterate_inline_only (struct symbol
*sym
, void *d
)
963 if (SYMBOL_INLINED (sym
))
965 struct symbol_and_data_callback
*cad
= d
;
967 return cad
->callback (sym
, cad
->data
);
969 return 1; /* Continue iterating. */
972 /* Some data for the expand_symtabs_matching callback. */
974 struct symbol_matcher_data
976 /* The lookup name against which symbol name should be compared. */
977 const char *lookup_name
;
979 /* The routine to be used for comparison. */
980 symbol_name_cmp_ftype symbol_name_cmp
;
983 /* A helper for iterate_over_all_matching_symtabs that is passed as a
984 callback to the expand_symtabs_matching method. */
987 iterate_name_matcher (const char *name
, void *d
)
989 const struct symbol_matcher_data
*data
= d
;
991 if (data
->symbol_name_cmp (name
, data
->lookup_name
) == 0)
992 return 1; /* Expand this symbol's symbol table. */
993 return 0; /* Skip this symbol. */
996 /* A helper that walks over all matching symtabs in all objfiles and
997 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
998 not NULL, then the search is restricted to just that program
999 space. If INCLUDE_INLINE is nonzero then symbols representing
1000 inlined instances of functions will be included in the result. */
1003 iterate_over_all_matching_symtabs (struct linespec_state
*state
,
1005 const domain_enum domain
,
1006 symbol_found_callback_ftype
*callback
,
1008 struct program_space
*search_pspace
,
1011 struct objfile
*objfile
;
1012 struct program_space
*pspace
;
1013 struct symbol_matcher_data matcher_data
;
1015 matcher_data
.lookup_name
= name
;
1016 matcher_data
.symbol_name_cmp
=
1017 state
->language
->la_get_symbol_name_cmp
!= NULL
1018 ? state
->language
->la_get_symbol_name_cmp (name
)
1021 ALL_PSPACES (pspace
)
1023 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
1025 if (pspace
->executing_startup
)
1028 set_current_program_space (pspace
);
1030 ALL_OBJFILES (objfile
)
1032 struct symtab
*symtab
;
1035 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, NULL
,
1036 iterate_name_matcher
,
1040 ALL_OBJFILE_PRIMARY_SYMTABS (objfile
, symtab
)
1042 struct block
*block
;
1044 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1045 state
->language
->la_iterate_over_symbols (block
, name
, domain
,
1050 struct symbol_and_data_callback cad
= { callback
, data
};
1053 for (i
= FIRST_LOCAL_BLOCK
;
1054 i
< BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (symtab
)); i
++)
1056 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), i
);
1057 state
->language
->la_iterate_over_symbols
1058 (block
, name
, domain
, iterate_inline_only
, &cad
);
1066 /* Returns the block to be used for symbol searches for the given SYMTAB,
1067 which may be NULL. */
1069 static struct block
*
1070 get_search_block (struct symtab
*symtab
)
1072 struct block
*block
;
1075 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1078 enum language save_language
;
1080 /* get_selected_block can change the current language when there is
1081 no selected frame yet. */
1082 save_language
= current_language
->la_language
;
1083 block
= get_selected_block (0);
1084 set_language (save_language
);
1090 /* A helper for find_method. This finds all methods in type T which
1091 match NAME. It adds matching symbol names to RESULT_NAMES, and
1092 adds T's direct superclasses to SUPERCLASSES. */
1095 find_methods (struct type
*t
, const char *name
,
1096 VEC (const_char_ptr
) **result_names
,
1097 VEC (typep
) **superclasses
)
1100 const char *class_name
= type_name_no_tag (t
);
1102 /* Ignore this class if it doesn't have a name. This is ugly, but
1103 unless we figure out how to get the physname without the name of
1104 the class, then the loop can't do any good. */
1111 /* Loop over each method name. At this level, all overloads of a name
1112 are counted as a single name. There is an inner loop which loops over
1115 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1116 method_counter
>= 0;
1119 const char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1120 char dem_opname
[64];
1122 if (strncmp (method_name
, "__", 2) == 0 ||
1123 strncmp (method_name
, "op", 2) == 0 ||
1124 strncmp (method_name
, "type", 4) == 0)
1126 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
1127 method_name
= dem_opname
;
1128 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
1129 method_name
= dem_opname
;
1132 if (strcmp_iw (method_name
, name
) == 0)
1136 for (field_counter
= (TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
)
1142 const char *phys_name
;
1144 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1145 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1147 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1148 VEC_safe_push (const_char_ptr
, *result_names
, phys_name
);
1154 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1155 VEC_safe_push (typep
, *superclasses
, TYPE_BASECLASS (t
, ibase
));
1158 /* Find an instance of the character C in the string S that is outside
1159 of all parenthesis pairs, single-quoted strings, and double-quoted
1160 strings. Also, ignore the char within a template name, like a ','
1161 within foo<int, int>. */
1164 find_toplevel_char (const char *s
, char c
)
1166 int quoted
= 0; /* zero if we're not in quotes;
1167 '"' if we're in a double-quoted string;
1168 '\'' if we're in a single-quoted string. */
1169 int depth
= 0; /* Number of unclosed parens we've seen. */
1172 for (scan
= s
; *scan
; scan
++)
1176 if (*scan
== quoted
)
1178 else if (*scan
== '\\' && *(scan
+ 1))
1181 else if (*scan
== c
&& ! quoted
&& depth
== 0)
1183 else if (*scan
== '"' || *scan
== '\'')
1185 else if (*scan
== '(' || *scan
== '<')
1187 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
1194 /* The string equivalent of find_toplevel_char. Returns a pointer
1195 to the location of NEEDLE in HAYSTACK, ignoring any occurrences
1196 inside "()" and "<>". Returns NULL if NEEDLE was not found. */
1199 find_toplevel_string (const char *haystack
, const char *needle
)
1201 const char *s
= haystack
;
1205 s
= find_toplevel_char (s
, *needle
);
1209 /* Found first char in HAYSTACK; check rest of string. */
1210 if (strncmp (s
, needle
, strlen (needle
)) == 0)
1213 /* Didn't find it; loop over HAYSTACK, looking for the next
1214 instance of the first character of NEEDLE. */
1218 while (s
!= NULL
&& *s
!= '\0');
1220 /* NEEDLE was not found in HAYSTACK. */
1224 /* Convert CANONICAL to its string representation using
1225 symtab_to_fullname for SYMTAB. The caller must xfree the result. */
1228 canonical_to_fullform (const struct linespec_canonical_name
*canonical
)
1230 if (canonical
->symtab
== NULL
)
1231 return xstrdup (canonical
->suffix
);
1233 return xstrprintf ("%s:%s", symtab_to_fullname (canonical
->symtab
),
1237 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
1238 and store the result in SELF->CANONICAL. */
1241 filter_results (struct linespec_state
*self
,
1242 struct symtabs_and_lines
*result
,
1243 VEC (const_char_ptr
) *filters
)
1248 for (i
= 0; VEC_iterate (const_char_ptr
, filters
, i
, name
); ++i
)
1250 struct linespec_sals lsal
;
1253 memset (&lsal
, 0, sizeof (lsal
));
1255 for (j
= 0; j
< result
->nelts
; ++j
)
1257 const struct linespec_canonical_name
*canonical
;
1259 struct cleanup
*cleanup
;
1261 canonical
= &self
->canonical_names
[j
];
1262 fullform
= canonical_to_fullform (canonical
);
1263 cleanup
= make_cleanup (xfree
, fullform
);
1265 if (strcmp (name
, fullform
) == 0)
1266 add_sal_to_sals_basic (&lsal
.sals
, &result
->sals
[j
]);
1268 do_cleanups (cleanup
);
1271 if (lsal
.sals
.nelts
> 0)
1273 lsal
.canonical
= xstrdup (name
);
1274 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
1278 self
->canonical
->pre_expanded
= 0;
1281 /* Store RESULT into SELF->CANONICAL. */
1284 convert_results_to_lsals (struct linespec_state
*self
,
1285 struct symtabs_and_lines
*result
)
1287 struct linespec_sals lsal
;
1289 lsal
.canonical
= NULL
;
1290 lsal
.sals
= *result
;
1291 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
1294 /* A structure that contains two string representations of a struct
1295 linespec_canonical_name:
1296 - one where the the symtab's fullname is used;
1297 - one where the filename followed the "set filename-display"
1300 struct decode_line_2_item
1302 /* The form using symtab_to_fullname.
1303 It must be xfree'ed after use. */
1306 /* The form using symtab_to_filename_for_display.
1307 It must be xfree'ed after use. */
1310 /* Field is initialized to zero and it is set to one if the user
1311 requested breakpoint for this entry. */
1312 unsigned int selected
: 1;
1315 /* Helper for qsort to sort decode_line_2_item entries by DISPLAYFORM and
1316 secondarily by FULLFORM. */
1319 decode_line_2_compare_items (const void *ap
, const void *bp
)
1321 const struct decode_line_2_item
*a
= ap
;
1322 const struct decode_line_2_item
*b
= bp
;
1325 retval
= strcmp (a
->displayform
, b
->displayform
);
1329 return strcmp (a
->fullform
, b
->fullform
);
1332 /* Handle multiple results in RESULT depending on SELECT_MODE. This
1333 will either return normally, throw an exception on multiple
1334 results, or present a menu to the user. On return, the SALS vector
1335 in SELF->CANONICAL is set up properly. */
1338 decode_line_2 (struct linespec_state
*self
,
1339 struct symtabs_and_lines
*result
,
1340 const char *select_mode
)
1342 char *args
, *prompt
;
1344 struct cleanup
*old_chain
;
1345 VEC (const_char_ptr
) *filters
= NULL
;
1346 struct get_number_or_range_state state
;
1347 struct decode_line_2_item
*items
;
1350 gdb_assert (select_mode
!= multiple_symbols_all
);
1351 gdb_assert (self
->canonical
!= NULL
);
1352 gdb_assert (result
->nelts
>= 1);
1354 old_chain
= make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
1356 /* Prepare ITEMS array. */
1357 items_count
= result
->nelts
;
1358 items
= xmalloc (sizeof (*items
) * items_count
);
1359 make_cleanup (xfree
, items
);
1360 for (i
= 0; i
< items_count
; ++i
)
1362 const struct linespec_canonical_name
*canonical
;
1363 struct decode_line_2_item
*item
;
1365 canonical
= &self
->canonical_names
[i
];
1366 gdb_assert (canonical
->suffix
!= NULL
);
1369 item
->fullform
= canonical_to_fullform (canonical
);
1370 make_cleanup (xfree
, item
->fullform
);
1372 if (canonical
->symtab
== NULL
)
1373 item
->displayform
= canonical
->suffix
;
1376 const char *fn_for_display
;
1378 fn_for_display
= symtab_to_filename_for_display (canonical
->symtab
);
1379 item
->displayform
= xstrprintf ("%s:%s", fn_for_display
,
1381 make_cleanup (xfree
, item
->displayform
);
1387 /* Sort the list of method names. */
1388 qsort (items
, items_count
, sizeof (*items
), decode_line_2_compare_items
);
1390 /* Remove entries with the same FULLFORM. */
1391 if (items_count
>= 2)
1393 struct decode_line_2_item
*dst
, *src
;
1396 for (src
= &items
[1]; src
< &items
[items_count
]; src
++)
1397 if (strcmp (src
->fullform
, dst
->fullform
) != 0)
1399 items_count
= dst
+ 1 - items
;
1402 if (select_mode
== multiple_symbols_cancel
&& items_count
> 1)
1403 error (_("canceled because the command is ambiguous\n"
1404 "See set/show multiple-symbol."));
1406 if (select_mode
== multiple_symbols_all
|| items_count
== 1)
1408 do_cleanups (old_chain
);
1409 convert_results_to_lsals (self
, result
);
1413 printf_unfiltered (_("[0] cancel\n[1] all\n"));
1414 for (i
= 0; i
< items_count
; i
++)
1415 printf_unfiltered ("[%d] %s\n", i
+ 2, items
[i
].displayform
);
1417 prompt
= getenv ("PS2");
1422 args
= command_line_input (prompt
, 0, "overload-choice");
1424 if (args
== 0 || *args
== 0)
1425 error_no_arg (_("one or more choice numbers"));
1427 init_number_or_range (&state
, args
);
1428 while (!state
.finished
)
1432 num
= get_number_or_range (&state
);
1435 error (_("canceled"));
1438 /* We intentionally make this result in a single breakpoint,
1439 contrary to what older versions of gdb did. The
1440 rationale is that this lets a user get the
1441 multiple_symbols_all behavior even with the 'ask'
1442 setting; and he can get separate breakpoints by entering
1443 "2-57" at the query. */
1444 do_cleanups (old_chain
);
1445 convert_results_to_lsals (self
, result
);
1450 if (num
>= items_count
)
1451 printf_unfiltered (_("No choice number %d.\n"), num
);
1454 struct decode_line_2_item
*item
= &items
[num
];
1456 if (!item
->selected
)
1458 VEC_safe_push (const_char_ptr
, filters
, item
->fullform
);
1463 printf_unfiltered (_("duplicate request for %d ignored.\n"),
1469 filter_results (self
, result
, filters
);
1470 do_cleanups (old_chain
);
1475 /* The parser of linespec itself. */
1477 /* Throw an appropriate error when SYMBOL is not found (optionally in
1480 static void ATTRIBUTE_NORETURN
1481 symbol_not_found_error (const char *symbol
, const char *filename
)
1486 if (!have_full_symbols ()
1487 && !have_partial_symbols ()
1488 && !have_minimal_symbols ())
1489 throw_error (NOT_FOUND_ERROR
,
1490 _("No symbol table is loaded. Use the \"file\" command."));
1492 /* If SYMBOL starts with '$', the user attempted to either lookup
1493 a function/variable in his code starting with '$' or an internal
1494 variable of that name. Since we do not know which, be concise and
1495 explain both possibilities. */
1499 throw_error (NOT_FOUND_ERROR
,
1500 _("Undefined convenience variable or function \"%s\" "
1501 "not defined in \"%s\"."), symbol
, filename
);
1503 throw_error (NOT_FOUND_ERROR
,
1504 _("Undefined convenience variable or function \"%s\" "
1505 "not defined."), symbol
);
1510 throw_error (NOT_FOUND_ERROR
,
1511 _("Function \"%s\" not defined in \"%s\"."),
1514 throw_error (NOT_FOUND_ERROR
,
1515 _("Function \"%s\" not defined."), symbol
);
1519 /* Throw an appropriate error when an unexpected token is encountered
1522 static void ATTRIBUTE_NORETURN
1523 unexpected_linespec_error (linespec_parser
*parser
)
1525 linespec_token token
;
1526 static const char * token_type_strings
[]
1527 = {"keyword", "colon", "string", "number", "comma", "end of input"};
1529 /* Get the token that generated the error. */
1530 token
= linespec_lexer_lex_one (parser
);
1532 /* Finally, throw the error. */
1533 if (token
.type
== LSTOKEN_STRING
|| token
.type
== LSTOKEN_NUMBER
1534 || token
.type
== LSTOKEN_KEYWORD
)
1537 struct cleanup
*cleanup
;
1539 string
= copy_token_string (token
);
1540 cleanup
= make_cleanup (xfree
, string
);
1541 throw_error (GENERIC_ERROR
,
1542 _("malformed linespec error: unexpected %s, \"%s\""),
1543 token_type_strings
[token
.type
], string
);
1546 throw_error (GENERIC_ERROR
,
1547 _("malformed linespec error: unexpected %s"),
1548 token_type_strings
[token
.type
]);
1551 /* Parse and return a line offset in STRING. */
1553 static struct line_offset
1554 linespec_parse_line_offset (const char *string
)
1556 struct line_offset line_offset
= {0, LINE_OFFSET_NONE
};
1560 line_offset
.sign
= LINE_OFFSET_PLUS
;
1563 else if (*string
== '-')
1565 line_offset
.sign
= LINE_OFFSET_MINUS
;
1569 /* Right now, we only allow base 10 for offsets. */
1570 line_offset
.offset
= atoi (string
);
1574 /* Parse the basic_spec in PARSER's input. */
1577 linespec_parse_basic (linespec_parser
*parser
)
1580 linespec_token token
;
1581 VEC (symbolp
) *symbols
, *labels
;
1582 VEC (minsym_and_objfile_d
) *minimal_symbols
;
1583 struct cleanup
*cleanup
;
1585 /* Get the next token. */
1586 token
= linespec_lexer_lex_one (parser
);
1588 /* If it is EOI or KEYWORD, issue an error. */
1589 if (token
.type
== LSTOKEN_KEYWORD
|| token
.type
== LSTOKEN_EOI
)
1590 unexpected_linespec_error (parser
);
1591 /* If it is a LSTOKEN_NUMBER, we have an offset. */
1592 else if (token
.type
== LSTOKEN_NUMBER
)
1594 /* Record the line offset and get the next token. */
1595 name
= copy_token_string (token
);
1596 cleanup
= make_cleanup (xfree
, name
);
1597 PARSER_RESULT (parser
)->line_offset
= linespec_parse_line_offset (name
);
1598 do_cleanups (cleanup
);
1600 /* Get the next token. */
1601 token
= linespec_lexer_consume_token (parser
);
1603 /* If the next token is a comma, stop parsing and return. */
1604 if (token
.type
== LSTOKEN_COMMA
)
1607 /* If the next token is anything but EOI or KEYWORD, issue
1609 if (token
.type
!= LSTOKEN_KEYWORD
&& token
.type
!= LSTOKEN_EOI
)
1610 unexpected_linespec_error (parser
);
1613 if (token
.type
== LSTOKEN_KEYWORD
|| token
.type
== LSTOKEN_EOI
)
1616 /* Next token must be LSTOKEN_STRING. */
1617 if (token
.type
!= LSTOKEN_STRING
)
1618 unexpected_linespec_error (parser
);
1620 /* The current token will contain the name of a function, method,
1622 name
= copy_token_string (token
);
1623 cleanup
= make_cleanup (xfree
, name
);
1625 /* Try looking it up as a function/method. */
1626 find_linespec_symbols (PARSER_STATE (parser
),
1627 PARSER_RESULT (parser
)->file_symtabs
, name
,
1628 &symbols
, &minimal_symbols
);
1630 if (symbols
!= NULL
|| minimal_symbols
!= NULL
)
1632 PARSER_RESULT (parser
)->function_symbols
= symbols
;
1633 PARSER_RESULT (parser
)->minimal_symbols
= minimal_symbols
;
1634 PARSER_RESULT (parser
)->function_name
= name
;
1636 discard_cleanups (cleanup
);
1640 /* NAME was not a function or a method. So it must be a label
1642 labels
= find_label_symbols (PARSER_STATE (parser
), NULL
,
1646 PARSER_RESULT (parser
)->labels
.label_symbols
= labels
;
1647 PARSER_RESULT (parser
)->labels
.function_symbols
= symbols
;
1648 PARSER_RESULT (parser
)->label_name
= name
;
1650 discard_cleanups (cleanup
);
1654 /* The name is also not a label. Abort parsing. Do not throw
1655 an error here. parse_linespec will do it for us. */
1657 /* Save a copy of the name we were trying to lookup. */
1658 PARSER_RESULT (parser
)->function_name
= name
;
1659 discard_cleanups (cleanup
);
1664 /* Get the next token. */
1665 token
= linespec_lexer_consume_token (parser
);
1667 if (token
.type
== LSTOKEN_COLON
)
1669 /* User specified a label or a lineno. */
1670 token
= linespec_lexer_consume_token (parser
);
1672 if (token
.type
== LSTOKEN_NUMBER
)
1674 /* User specified an offset. Record the line offset and
1675 get the next token. */
1676 name
= copy_token_string (token
);
1677 cleanup
= make_cleanup (xfree
, name
);
1678 PARSER_RESULT (parser
)->line_offset
1679 = linespec_parse_line_offset (name
);
1680 do_cleanups (cleanup
);
1682 /* Ge the next token. */
1683 token
= linespec_lexer_consume_token (parser
);
1685 else if (token
.type
== LSTOKEN_STRING
)
1687 /* Grab a copy of the label's name and look it up. */
1688 name
= copy_token_string (token
);
1689 cleanup
= make_cleanup (xfree
, name
);
1690 labels
= find_label_symbols (PARSER_STATE (parser
),
1691 PARSER_RESULT (parser
)->function_symbols
,
1696 PARSER_RESULT (parser
)->labels
.label_symbols
= labels
;
1697 PARSER_RESULT (parser
)->labels
.function_symbols
= symbols
;
1698 PARSER_RESULT (parser
)->label_name
= name
;
1700 discard_cleanups (cleanup
);
1704 /* We don't know what it was, but it isn't a label. */
1705 throw_error (NOT_FOUND_ERROR
,
1706 _("No label \"%s\" defined in function \"%s\"."),
1707 name
, PARSER_RESULT (parser
)->function_name
);
1710 /* Check for a line offset. */
1711 token
= linespec_lexer_consume_token (parser
);
1712 if (token
.type
== LSTOKEN_COLON
)
1714 /* Get the next token. */
1715 token
= linespec_lexer_consume_token (parser
);
1717 /* It must be a line offset. */
1718 if (token
.type
!= LSTOKEN_NUMBER
)
1719 unexpected_linespec_error (parser
);
1721 /* Record the lione offset and get the next token. */
1722 name
= copy_token_string (token
);
1723 cleanup
= make_cleanup (xfree
, name
);
1725 PARSER_RESULT (parser
)->line_offset
1726 = linespec_parse_line_offset (name
);
1727 do_cleanups (cleanup
);
1729 /* Get the next token. */
1730 token
= linespec_lexer_consume_token (parser
);
1735 /* Trailing ':' in the input. Issue an error. */
1736 unexpected_linespec_error (parser
);
1741 /* Canonicalize the linespec contained in LS. The result is saved into
1742 STATE->canonical. */
1745 canonicalize_linespec (struct linespec_state
*state
, linespec_p ls
)
1747 /* If canonicalization was not requested, no need to do anything. */
1748 if (!state
->canonical
)
1751 /* Shortcut expressions, which can only appear by themselves. */
1752 if (ls
->expression
!= NULL
)
1753 state
->canonical
->addr_string
= xstrdup (ls
->expression
);
1756 struct ui_file
*buf
;
1759 buf
= mem_fileopen ();
1760 if (ls
->source_filename
)
1762 fputs_unfiltered (ls
->source_filename
, buf
);
1766 if (ls
->function_name
)
1769 fputc_unfiltered (':', buf
);
1770 fputs_unfiltered (ls
->function_name
, buf
);
1777 fputc_unfiltered (':', buf
);
1779 if (ls
->function_name
== NULL
)
1783 /* No function was specified, so add the symbol name. */
1784 gdb_assert (ls
->labels
.function_symbols
!= NULL
1785 && (VEC_length (symbolp
, ls
->labels
.function_symbols
)
1787 s
= VEC_index (symbolp
, ls
->labels
.function_symbols
, 0);
1788 fputs_unfiltered (SYMBOL_NATURAL_NAME (s
), buf
);
1789 fputc_unfiltered (':', buf
);
1792 fputs_unfiltered (ls
->label_name
, buf
);
1794 state
->canonical
->special_display
= 1;
1797 if (ls
->line_offset
.sign
!= LINE_OFFSET_UNKNOWN
)
1800 fputc_unfiltered (':', buf
);
1801 fprintf_filtered (buf
, "%s%d",
1802 (ls
->line_offset
.sign
== LINE_OFFSET_NONE
? ""
1803 : (ls
->line_offset
.sign
1804 == LINE_OFFSET_PLUS
? "+" : "-")),
1805 ls
->line_offset
.offset
);
1808 state
->canonical
->addr_string
= ui_file_xstrdup (buf
, NULL
);
1809 ui_file_delete (buf
);
1813 /* Given a line offset in LS, construct the relevant SALs. */
1815 static struct symtabs_and_lines
1816 create_sals_line_offset (struct linespec_state
*self
,
1819 struct symtabs_and_lines values
;
1820 struct symtab_and_line val
;
1821 int use_default
= 0;
1827 /* This is where we need to make sure we have good defaults.
1828 We must guarantee that this section of code is never executed
1829 when we are called with just a function name, since
1830 set_default_source_symtab_and_line uses
1831 select_source_symtab that calls us with such an argument. */
1833 if (VEC_length (symtab_p
, ls
->file_symtabs
) == 1
1834 && VEC_index (symtab_p
, ls
->file_symtabs
, 0) == NULL
)
1836 const char *fullname
;
1838 set_current_program_space (self
->program_space
);
1840 /* Make sure we have at least a default source line. */
1841 set_default_source_symtab_and_line ();
1842 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
1843 fullname
= symtab_to_fullname (self
->default_symtab
);
1844 VEC_pop (symtab_p
, ls
->file_symtabs
);
1845 VEC_free (symtab_p
, ls
->file_symtabs
);
1846 ls
->file_symtabs
= collect_symtabs_from_filename (fullname
);
1850 val
.line
= ls
->line_offset
.offset
;
1851 switch (ls
->line_offset
.sign
)
1853 case LINE_OFFSET_PLUS
:
1854 if (ls
->line_offset
.offset
== 0)
1857 val
.line
= self
->default_line
+ val
.line
;
1860 case LINE_OFFSET_MINUS
:
1861 if (ls
->line_offset
.offset
== 0)
1864 val
.line
= self
->default_line
- val
.line
;
1866 val
.line
= -val
.line
;
1869 case LINE_OFFSET_NONE
:
1870 break; /* No need to adjust val.line. */
1873 if (self
->list_mode
)
1874 decode_digits_list_mode (self
, ls
, &values
, val
);
1877 struct linetable_entry
*best_entry
= NULL
;
1879 struct block
**blocks
;
1880 struct cleanup
*cleanup
;
1881 struct symtabs_and_lines intermediate_results
;
1884 intermediate_results
.sals
= NULL
;
1885 intermediate_results
.nelts
= 0;
1887 decode_digits_ordinary (self
, ls
, val
.line
, &intermediate_results
,
1889 if (intermediate_results
.nelts
== 0 && best_entry
!= NULL
)
1890 decode_digits_ordinary (self
, ls
, best_entry
->line
,
1891 &intermediate_results
, &best_entry
);
1893 cleanup
= make_cleanup (xfree
, intermediate_results
.sals
);
1895 /* For optimized code, the compiler can scatter one source line
1896 across disjoint ranges of PC values, even when no duplicate
1897 functions or inline functions are involved. For example,
1898 'for (;;)' inside a non-template, non-inline, and non-ctor-or-dtor
1899 function can result in two PC ranges. In this case, we don't
1900 want to set a breakpoint on the first PC of each range. To filter
1901 such cases, we use containing blocks -- for each PC found
1902 above, we see if there are other PCs that are in the same
1903 block. If yes, the other PCs are filtered out. */
1905 filter
= XNEWVEC (int, intermediate_results
.nelts
);
1906 make_cleanup (xfree
, filter
);
1907 blocks
= XNEWVEC (struct block
*, intermediate_results
.nelts
);
1908 make_cleanup (xfree
, blocks
);
1910 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
1912 set_current_program_space (intermediate_results
.sals
[i
].pspace
);
1915 blocks
[i
] = block_for_pc_sect (intermediate_results
.sals
[i
].pc
,
1916 intermediate_results
.sals
[i
].section
);
1919 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
1921 if (blocks
[i
] != NULL
)
1922 for (j
= i
+ 1; j
< intermediate_results
.nelts
; ++j
)
1924 if (blocks
[j
] == blocks
[i
])
1932 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
1935 struct symbol
*sym
= (blocks
[i
]
1936 ? block_containing_function (blocks
[i
])
1939 if (self
->funfirstline
)
1940 skip_prologue_sal (&intermediate_results
.sals
[i
]);
1941 /* Make sure the line matches the request, not what was
1943 intermediate_results
.sals
[i
].line
= val
.line
;
1944 add_sal_to_sals (self
, &values
, &intermediate_results
.sals
[i
],
1945 sym
? SYMBOL_NATURAL_NAME (sym
) : NULL
, 0);
1948 do_cleanups (cleanup
);
1951 if (values
.nelts
== 0)
1953 if (ls
->source_filename
)
1954 throw_error (NOT_FOUND_ERROR
, _("No line %d in file \"%s\"."),
1955 val
.line
, ls
->source_filename
);
1957 throw_error (NOT_FOUND_ERROR
, _("No line %d in the current file."),
1964 /* Create and return SALs from the linespec LS. */
1966 static struct symtabs_and_lines
1967 convert_linespec_to_sals (struct linespec_state
*state
, linespec_p ls
)
1969 struct symtabs_and_lines sals
= {NULL
, 0};
1971 if (ls
->expression
!= NULL
)
1973 struct symtab_and_line sal
;
1975 /* We have an expression. No other attribute is allowed. */
1976 sal
= find_pc_line (ls
->expr_pc
, 0);
1977 sal
.pc
= ls
->expr_pc
;
1978 sal
.section
= find_pc_overlay (ls
->expr_pc
);
1979 sal
.explicit_pc
= 1;
1980 add_sal_to_sals (state
, &sals
, &sal
, ls
->expression
, 1);
1982 else if (ls
->labels
.label_symbols
!= NULL
)
1984 /* We have just a bunch of functions/methods or labels. */
1986 struct symtab_and_line sal
;
1989 for (i
= 0; VEC_iterate (symbolp
, ls
->labels
.label_symbols
, i
, sym
); ++i
)
1991 if (symbol_to_sal (&sal
, state
->funfirstline
, sym
))
1992 add_sal_to_sals (state
, &sals
, &sal
,
1993 SYMBOL_NATURAL_NAME (sym
), 0);
1996 else if (ls
->function_symbols
!= NULL
|| ls
->minimal_symbols
!= NULL
)
1998 /* We have just a bunch of functions and/or methods. */
2000 struct symtab_and_line sal
;
2002 minsym_and_objfile_d
*elem
;
2003 struct program_space
*pspace
;
2005 if (ls
->function_symbols
!= NULL
)
2007 /* Sort symbols so that symbols with the same program space are next
2009 qsort (VEC_address (symbolp
, ls
->function_symbols
),
2010 VEC_length (symbolp
, ls
->function_symbols
),
2011 sizeof (symbolp
), compare_symbols
);
2013 for (i
= 0; VEC_iterate (symbolp
, ls
->function_symbols
, i
, sym
); ++i
)
2015 pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2016 set_current_program_space (pspace
);
2017 if (symbol_to_sal (&sal
, state
->funfirstline
, sym
)
2018 && maybe_add_address (state
->addr_set
, pspace
, sal
.pc
))
2019 add_sal_to_sals (state
, &sals
, &sal
,
2020 SYMBOL_NATURAL_NAME (sym
), 0);
2024 if (ls
->minimal_symbols
!= NULL
)
2026 /* Sort minimal symbols by program space, too. */
2027 qsort (VEC_address (minsym_and_objfile_d
, ls
->minimal_symbols
),
2028 VEC_length (minsym_and_objfile_d
, ls
->minimal_symbols
),
2029 sizeof (minsym_and_objfile_d
), compare_msymbols
);
2032 VEC_iterate (minsym_and_objfile_d
, ls
->minimal_symbols
, i
, elem
);
2035 pspace
= elem
->objfile
->pspace
;
2036 set_current_program_space (pspace
);
2037 minsym_found (state
, elem
->objfile
, elem
->minsym
, &sals
);
2041 else if (ls
->line_offset
.sign
!= LINE_OFFSET_UNKNOWN
)
2043 /* Only an offset was specified. */
2044 sals
= create_sals_line_offset (state
, ls
);
2046 /* Make sure we have a filename for canonicalization. */
2047 if (ls
->source_filename
== NULL
)
2049 const char *fullname
= symtab_to_fullname (state
->default_symtab
);
2051 ls
->source_filename
= xstrdup (fullname
);
2056 /* We haven't found any results... */
2060 canonicalize_linespec (state
, ls
);
2062 if (sals
.nelts
> 0 && state
->canonical
!= NULL
)
2063 state
->canonical
->pre_expanded
= 1;
2068 /* Parse a string that specifies a linespec.
2069 Pass the address of a char * variable; that variable will be
2070 advanced over the characters actually parsed.
2072 The basic grammar of linespecs:
2074 linespec -> expr_spec | var_spec | basic_spec
2075 expr_spec -> '*' STRING
2076 var_spec -> '$' (STRING | NUMBER)
2078 basic_spec -> file_offset_spec | function_spec | label_spec
2079 file_offset_spec -> opt_file_spec offset_spec
2080 function_spec -> opt_file_spec function_name_spec opt_label_spec
2081 label_spec -> label_name_spec
2083 opt_file_spec -> "" | file_name_spec ':'
2084 opt_label_spec -> "" | ':' label_name_spec
2086 file_name_spec -> STRING
2087 function_name_spec -> STRING
2088 label_name_spec -> STRING
2089 function_name_spec -> STRING
2090 offset_spec -> NUMBER
2094 This may all be followed by several keywords such as "if EXPR",
2097 A comma will terminate parsing.
2099 The function may be an undebuggable function found in minimal symbol table.
2101 If the argument FUNFIRSTLINE is nonzero, we want the first line
2102 of real code inside a function when a function is specified, and it is
2103 not OK to specify a variable or type to get its line number.
2105 DEFAULT_SYMTAB specifies the file to use if none is specified.
2106 It defaults to current_source_symtab.
2107 DEFAULT_LINE specifies the line number to use for relative
2108 line numbers (that start with signs). Defaults to current_source_line.
2109 If CANONICAL is non-NULL, store an array of strings containing the canonical
2110 line specs there if necessary. Currently overloaded member functions and
2111 line numbers or static functions without a filename yield a canonical
2112 line spec. The array and the line spec strings are allocated on the heap,
2113 it is the callers responsibility to free them.
2115 Note that it is possible to return zero for the symtab
2116 if no file is validly specified. Callers must check that.
2117 Also, the line number returned may be invalid. */
2119 /* Parse the linespec in ARGPTR. */
2121 static struct symtabs_and_lines
2122 parse_linespec (linespec_parser
*parser
, char **argptr
)
2124 linespec_token token
;
2125 struct symtabs_and_lines values
;
2126 volatile struct gdb_exception file_exception
;
2127 struct cleanup
*cleanup
;
2129 /* A special case to start. It has become quite popular for
2130 IDEs to work around bugs in the previous parser by quoting
2131 the entire linespec, so we attempt to deal with this nicely. */
2132 parser
->is_quote_enclosed
= 0;
2133 if (!is_ada_operator (*argptr
)
2134 && strchr (linespec_quote_characters
, **argptr
) != NULL
)
2138 end
= skip_quote_char (*argptr
+ 1, **argptr
);
2139 if (end
!= NULL
&& is_closing_quote_enclosed (end
))
2141 /* Here's the special case. Skip ARGPTR past the initial
2144 parser
->is_quote_enclosed
= 1;
2148 /* A keyword at the start cannot be interpreted as such.
2149 Consider "b thread thread 42". */
2150 parser
->keyword_ok
= 0;
2152 parser
->lexer
.saved_arg
= *argptr
;
2153 parser
->lexer
.stream
= argptr
;
2154 file_exception
.reason
= 0;
2156 /* Initialize the default symtab and line offset. */
2157 initialize_defaults (&PARSER_STATE (parser
)->default_symtab
,
2158 &PARSER_STATE (parser
)->default_line
);
2160 /* Objective-C shortcut. */
2161 values
= decode_objc (PARSER_STATE (parser
), PARSER_RESULT (parser
), argptr
);
2162 if (values
.sals
!= NULL
)
2165 /* Start parsing. */
2167 /* Get the first token. */
2168 token
= linespec_lexer_lex_one (parser
);
2170 /* It must be either LSTOKEN_STRING or LSTOKEN_NUMBER. */
2171 if (token
.type
== LSTOKEN_STRING
&& *LS_TOKEN_STOKEN (token
).ptr
== '*')
2175 /* User specified an expression, *EXPR. */
2176 copy
= expr
= copy_token_string (token
);
2177 cleanup
= make_cleanup (xfree
, expr
);
2178 PARSER_RESULT (parser
)->expr_pc
= linespec_expression_to_pc (©
);
2179 discard_cleanups (cleanup
);
2180 PARSER_RESULT (parser
)->expression
= expr
;
2182 /* This is a little hacky/tricky. If linespec_expression_to_pc
2183 did not evaluate the entire token, then we must find the
2184 string COPY inside the original token buffer. */
2187 PARSER_STREAM (parser
) = strstr (parser
->lexer
.saved_arg
, copy
);
2188 gdb_assert (PARSER_STREAM (parser
) != NULL
);
2191 /* Consume the token. */
2192 linespec_lexer_consume_token (parser
);
2194 goto convert_to_sals
;
2196 else if (token
.type
== LSTOKEN_STRING
&& *LS_TOKEN_STOKEN (token
).ptr
== '$')
2200 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2201 VEC_safe_push (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
, NULL
);
2203 /* User specified a convenience variable or history value. */
2204 var
= copy_token_string (token
);
2205 cleanup
= make_cleanup (xfree
, var
);
2206 PARSER_RESULT (parser
)->line_offset
2207 = linespec_parse_variable (PARSER_STATE (parser
), var
);
2208 do_cleanups (cleanup
);
2210 /* If a line_offset wasn't found (VAR is the name of a user
2211 variable/function), then skip to normal symbol processing. */
2212 if (PARSER_RESULT (parser
)->line_offset
.sign
!= LINE_OFFSET_UNKNOWN
)
2214 /* Consume this token. */
2215 linespec_lexer_consume_token (parser
);
2217 goto convert_to_sals
;
2220 else if (token
.type
!= LSTOKEN_STRING
&& token
.type
!= LSTOKEN_NUMBER
)
2221 unexpected_linespec_error (parser
);
2223 /* Now we can recognize keywords. */
2224 parser
->keyword_ok
= 1;
2226 /* Shortcut: If the next token is not LSTOKEN_COLON, we know that
2227 this token cannot represent a filename. */
2228 token
= linespec_lexer_peek_token (parser
);
2230 if (token
.type
== LSTOKEN_COLON
)
2232 char *user_filename
;
2234 /* Get the current token again and extract the filename. */
2235 token
= linespec_lexer_lex_one (parser
);
2236 user_filename
= copy_token_string (token
);
2238 /* Check if the input is a filename. */
2239 TRY_CATCH (file_exception
, RETURN_MASK_ERROR
)
2241 PARSER_RESULT (parser
)->file_symtabs
2242 = symtabs_from_filename (user_filename
);
2245 if (file_exception
.reason
>= 0)
2247 /* Symtabs were found for the file. Record the filename. */
2248 PARSER_RESULT (parser
)->source_filename
= user_filename
;
2250 /* Get the next token. */
2251 token
= linespec_lexer_consume_token (parser
);
2253 /* This is LSTOKEN_COLON; consume it. */
2254 linespec_lexer_consume_token (parser
);
2258 /* No symtabs found -- discard user_filename. */
2259 xfree (user_filename
);
2261 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2262 VEC_safe_push (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
, NULL
);
2265 /* If the next token is not EOI, KEYWORD, or COMMA, issue an error. */
2266 else if (token
.type
!= LSTOKEN_EOI
&& token
.type
!= LSTOKEN_KEYWORD
2267 && token
.type
!= LSTOKEN_COMMA
)
2269 /* TOKEN is the _next_ token, not the one currently in the parser.
2270 Consuming the token will give the correct error message. */
2271 linespec_lexer_consume_token (parser
);
2272 unexpected_linespec_error (parser
);
2276 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2277 VEC_safe_push (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
, NULL
);
2280 /* Parse the rest of the linespec. */
2281 linespec_parse_basic (parser
);
2283 if (PARSER_RESULT (parser
)->function_symbols
== NULL
2284 && PARSER_RESULT (parser
)->labels
.label_symbols
== NULL
2285 && PARSER_RESULT (parser
)->line_offset
.sign
== LINE_OFFSET_UNKNOWN
2286 && PARSER_RESULT (parser
)->minimal_symbols
== NULL
)
2288 /* The linespec didn't parse. Re-throw the file exception if
2290 if (file_exception
.reason
< 0)
2291 throw_exception (file_exception
);
2293 /* Otherwise, the symbol is not found. */
2294 symbol_not_found_error (PARSER_RESULT (parser
)->function_name
,
2295 PARSER_RESULT (parser
)->source_filename
);
2300 /* Get the last token and record how much of the input was parsed,
2302 token
= linespec_lexer_lex_one (parser
);
2303 if (token
.type
!= LSTOKEN_EOI
&& token
.type
!= LSTOKEN_KEYWORD
)
2304 PARSER_STREAM (parser
) = LS_TOKEN_STOKEN (token
).ptr
;
2306 /* Convert the data in PARSER_RESULT to SALs. */
2307 values
= convert_linespec_to_sals (PARSER_STATE (parser
),
2308 PARSER_RESULT (parser
));
2314 /* A constructor for linespec_state. */
2317 linespec_state_constructor (struct linespec_state
*self
,
2318 int flags
, const struct language_defn
*language
,
2319 struct symtab
*default_symtab
,
2321 struct linespec_result
*canonical
)
2323 memset (self
, 0, sizeof (*self
));
2324 self
->language
= language
;
2325 self
->funfirstline
= (flags
& DECODE_LINE_FUNFIRSTLINE
) ? 1 : 0;
2326 self
->list_mode
= (flags
& DECODE_LINE_LIST_MODE
) ? 1 : 0;
2327 self
->default_symtab
= default_symtab
;
2328 self
->default_line
= default_line
;
2329 self
->canonical
= canonical
;
2330 self
->program_space
= current_program_space
;
2331 self
->addr_set
= htab_create_alloc (10, hash_address_entry
, eq_address_entry
,
2332 xfree
, xcalloc
, xfree
);
2335 /* Initialize a new linespec parser. */
2338 linespec_parser_new (linespec_parser
*parser
,
2339 int flags
, const struct language_defn
*language
,
2340 struct symtab
*default_symtab
,
2342 struct linespec_result
*canonical
)
2344 parser
->lexer
.current
.type
= LSTOKEN_CONSUMED
;
2345 memset (PARSER_RESULT (parser
), 0, sizeof (struct linespec
));
2346 PARSER_RESULT (parser
)->line_offset
.sign
= LINE_OFFSET_UNKNOWN
;
2347 linespec_state_constructor (PARSER_STATE (parser
), flags
, language
,
2348 default_symtab
, default_line
, canonical
);
2351 /* A destructor for linespec_state. */
2354 linespec_state_destructor (struct linespec_state
*self
)
2356 htab_delete (self
->addr_set
);
2359 /* Delete a linespec parser. */
2362 linespec_parser_delete (void *arg
)
2364 linespec_parser
*parser
= (linespec_parser
*) arg
;
2366 xfree ((char *) PARSER_RESULT (parser
)->expression
);
2367 xfree ((char *) PARSER_RESULT (parser
)->source_filename
);
2368 xfree ((char *) PARSER_RESULT (parser
)->label_name
);
2369 xfree ((char *) PARSER_RESULT (parser
)->function_name
);
2371 if (PARSER_RESULT (parser
)->file_symtabs
!= NULL
)
2372 VEC_free (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
);
2374 if (PARSER_RESULT (parser
)->function_symbols
!= NULL
)
2375 VEC_free (symbolp
, PARSER_RESULT (parser
)->function_symbols
);
2377 if (PARSER_RESULT (parser
)->minimal_symbols
!= NULL
)
2378 VEC_free (minsym_and_objfile_d
, PARSER_RESULT (parser
)->minimal_symbols
);
2380 if (PARSER_RESULT (parser
)->labels
.label_symbols
!= NULL
)
2381 VEC_free (symbolp
, PARSER_RESULT (parser
)->labels
.label_symbols
);
2383 if (PARSER_RESULT (parser
)->labels
.function_symbols
!= NULL
)
2384 VEC_free (symbolp
, PARSER_RESULT (parser
)->labels
.function_symbols
);
2386 linespec_state_destructor (PARSER_STATE (parser
));
2389 /* See linespec.h. */
2392 decode_line_full (char **argptr
, int flags
,
2393 struct symtab
*default_symtab
,
2394 int default_line
, struct linespec_result
*canonical
,
2395 const char *select_mode
,
2398 struct symtabs_and_lines result
;
2399 struct cleanup
*cleanups
;
2400 VEC (const_char_ptr
) *filters
= NULL
;
2401 linespec_parser parser
;
2402 struct linespec_state
*state
;
2404 gdb_assert (canonical
!= NULL
);
2405 /* The filter only makes sense for 'all'. */
2406 gdb_assert (filter
== NULL
|| select_mode
== multiple_symbols_all
);
2407 gdb_assert (select_mode
== NULL
2408 || select_mode
== multiple_symbols_all
2409 || select_mode
== multiple_symbols_ask
2410 || select_mode
== multiple_symbols_cancel
);
2411 gdb_assert ((flags
& DECODE_LINE_LIST_MODE
) == 0);
2413 linespec_parser_new (&parser
, flags
, current_language
, default_symtab
,
2414 default_line
, canonical
);
2415 cleanups
= make_cleanup (linespec_parser_delete
, &parser
);
2416 save_current_program_space ();
2418 result
= parse_linespec (&parser
, argptr
);
2419 state
= PARSER_STATE (&parser
);
2421 gdb_assert (result
.nelts
== 1 || canonical
->pre_expanded
);
2422 gdb_assert (canonical
->addr_string
!= NULL
);
2423 canonical
->pre_expanded
= 1;
2425 /* Arrange for allocated canonical names to be freed. */
2426 if (result
.nelts
> 0)
2430 make_cleanup (xfree
, state
->canonical_names
);
2431 for (i
= 0; i
< result
.nelts
; ++i
)
2433 gdb_assert (state
->canonical_names
[i
].suffix
!= NULL
);
2434 make_cleanup (xfree
, state
->canonical_names
[i
].suffix
);
2438 if (select_mode
== NULL
)
2440 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2441 select_mode
= multiple_symbols_all
;
2443 select_mode
= multiple_symbols_select_mode ();
2446 if (select_mode
== multiple_symbols_all
)
2450 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
2451 VEC_safe_push (const_char_ptr
, filters
, filter
);
2452 filter_results (state
, &result
, filters
);
2455 convert_results_to_lsals (state
, &result
);
2458 decode_line_2 (state
, &result
, select_mode
);
2460 do_cleanups (cleanups
);
2463 /* See linespec.h. */
2465 struct symtabs_and_lines
2466 decode_line_1 (char **argptr
, int flags
,
2467 struct symtab
*default_symtab
,
2470 struct symtabs_and_lines result
;
2471 linespec_parser parser
;
2472 struct cleanup
*cleanups
;
2474 linespec_parser_new (&parser
, flags
, current_language
, default_symtab
,
2475 default_line
, NULL
);
2476 cleanups
= make_cleanup (linespec_parser_delete
, &parser
);
2477 save_current_program_space ();
2479 result
= parse_linespec (&parser
, argptr
);
2481 do_cleanups (cleanups
);
2485 /* See linespec.h. */
2487 struct symtabs_and_lines
2488 decode_line_with_current_source (char *string
, int flags
)
2490 struct symtabs_and_lines sals
;
2491 struct symtab_and_line cursal
;
2494 error (_("Empty line specification."));
2496 /* We use whatever is set as the current source line. We do not try
2497 and get a default source symtab+line or it will recursively call us! */
2498 cursal
= get_current_source_symtab_and_line ();
2500 sals
= decode_line_1 (&string
, flags
,
2501 cursal
.symtab
, cursal
.line
);
2504 error (_("Junk at end of line specification: %s"), string
);
2508 /* See linespec.h. */
2510 struct symtabs_and_lines
2511 decode_line_with_last_displayed (char *string
, int flags
)
2513 struct symtabs_and_lines sals
;
2516 error (_("Empty line specification."));
2518 if (last_displayed_sal_is_valid ())
2519 sals
= decode_line_1 (&string
, flags
,
2520 get_last_displayed_symtab (),
2521 get_last_displayed_line ());
2523 sals
= decode_line_1 (&string
, flags
, (struct symtab
*) NULL
, 0);
2526 error (_("Junk at end of line specification: %s"), string
);
2532 /* First, some functions to initialize stuff at the beggining of the
2536 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
2538 if (*default_symtab
== 0)
2540 /* Use whatever we have for the default source line. We don't use
2541 get_current_or_default_symtab_and_line as it can recurse and call
2543 struct symtab_and_line cursal
=
2544 get_current_source_symtab_and_line ();
2546 *default_symtab
= cursal
.symtab
;
2547 *default_line
= cursal
.line
;
2553 /* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR,
2554 advancing EXP_PTR past any parsed text. */
2557 linespec_expression_to_pc (char **exp_ptr
)
2559 if (current_program_space
->executing_startup
)
2560 /* The error message doesn't really matter, because this case
2561 should only hit during breakpoint reset. */
2562 throw_error (NOT_FOUND_ERROR
, _("cannot evaluate expressions while "
2563 "program space is in startup"));
2566 return value_as_address (parse_to_comma_and_eval (exp_ptr
));
2571 /* Here's where we recognise an Objective-C Selector. An Objective C
2572 selector may be implemented by more than one class, therefore it
2573 may represent more than one method/function. This gives us a
2574 situation somewhat analogous to C++ overloading. If there's more
2575 than one method that could represent the selector, then use some of
2576 the existing C++ code to let the user choose one. */
2578 static struct symtabs_and_lines
2579 decode_objc (struct linespec_state
*self
, linespec_p ls
, char **argptr
)
2581 struct collect_info info
;
2582 VEC (const_char_ptr
) *symbol_names
= NULL
;
2583 struct symtabs_and_lines values
;
2585 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (const_char_ptr
),
2589 info
.file_symtabs
= NULL
;
2590 VEC_safe_push (symtab_p
, info
.file_symtabs
, NULL
);
2591 make_cleanup (VEC_cleanup (symtab_p
), &info
.file_symtabs
);
2592 info
.result
.symbols
= NULL
;
2593 info
.result
.minimal_symbols
= NULL
;
2597 new_argptr
= find_imps (*argptr
, &symbol_names
);
2598 if (VEC_empty (const_char_ptr
, symbol_names
))
2600 do_cleanups (cleanup
);
2604 add_all_symbol_names_from_pspace (&info
, NULL
, symbol_names
);
2606 if (!VEC_empty (symbolp
, info
.result
.symbols
)
2607 || !VEC_empty (minsym_and_objfile_d
, info
.result
.minimal_symbols
))
2611 saved_arg
= alloca (new_argptr
- *argptr
+ 1);
2612 memcpy (saved_arg
, *argptr
, new_argptr
- *argptr
);
2613 saved_arg
[new_argptr
- *argptr
] = '\0';
2615 ls
->function_name
= xstrdup (saved_arg
);
2616 ls
->function_symbols
= info
.result
.symbols
;
2617 ls
->minimal_symbols
= info
.result
.minimal_symbols
;
2618 values
= convert_linespec_to_sals (self
, ls
);
2620 if (self
->canonical
)
2622 self
->canonical
->pre_expanded
= 1;
2623 if (ls
->source_filename
)
2624 self
->canonical
->addr_string
2625 = xstrprintf ("%s:%s", ls
->source_filename
, saved_arg
);
2627 self
->canonical
->addr_string
= xstrdup (saved_arg
);
2631 *argptr
= new_argptr
;
2633 do_cleanups (cleanup
);
2638 /* An instance of this type is used when collecting prefix symbols for
2641 struct decode_compound_collector
2643 /* The result vector. */
2644 VEC (symbolp
) *symbols
;
2646 /* A hash table of all symbols we found. We use this to avoid
2647 adding any symbol more than once. */
2651 /* A callback for iterate_over_symbols that is used by
2652 lookup_prefix_sym to collect type symbols. */
2655 collect_one_symbol (struct symbol
*sym
, void *d
)
2657 struct decode_compound_collector
*collector
= d
;
2661 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
2662 return 1; /* Continue iterating. */
2664 t
= SYMBOL_TYPE (sym
);
2666 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2667 && TYPE_CODE (t
) != TYPE_CODE_UNION
2668 && TYPE_CODE (t
) != TYPE_CODE_NAMESPACE
)
2669 return 1; /* Continue iterating. */
2671 slot
= htab_find_slot (collector
->unique_syms
, sym
, INSERT
);
2675 VEC_safe_push (symbolp
, collector
->symbols
, sym
);
2678 return 1; /* Continue iterating. */
2681 /* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */
2683 static VEC (symbolp
) *
2684 lookup_prefix_sym (struct linespec_state
*state
, VEC (symtab_p
) *file_symtabs
,
2685 const char *class_name
)
2689 struct decode_compound_collector collector
;
2690 struct cleanup
*outer
;
2691 struct cleanup
*cleanup
;
2693 collector
.symbols
= NULL
;
2694 outer
= make_cleanup (VEC_cleanup (symbolp
), &collector
.symbols
);
2696 collector
.unique_syms
= htab_create_alloc (1, htab_hash_pointer
,
2697 htab_eq_pointer
, NULL
,
2699 cleanup
= make_cleanup_htab_delete (collector
.unique_syms
);
2701 for (ix
= 0; VEC_iterate (symtab_p
, file_symtabs
, ix
, elt
); ++ix
)
2705 iterate_over_all_matching_symtabs (state
, class_name
, STRUCT_DOMAIN
,
2706 collect_one_symbol
, &collector
,
2708 iterate_over_all_matching_symtabs (state
, class_name
, VAR_DOMAIN
,
2709 collect_one_symbol
, &collector
,
2714 struct block
*search_block
;
2716 /* Program spaces that are executing startup should have
2717 been filtered out earlier. */
2718 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
2719 set_current_program_space (SYMTAB_PSPACE (elt
));
2720 search_block
= get_search_block (elt
);
2721 LA_ITERATE_OVER_SYMBOLS (search_block
, class_name
, STRUCT_DOMAIN
,
2722 collect_one_symbol
, &collector
);
2723 LA_ITERATE_OVER_SYMBOLS (search_block
, class_name
, VAR_DOMAIN
,
2724 collect_one_symbol
, &collector
);
2728 do_cleanups (cleanup
);
2729 discard_cleanups (outer
);
2730 return collector
.symbols
;
2733 /* A qsort comparison function for symbols. The resulting order does
2734 not actually matter; we just need to be able to sort them so that
2735 symbols with the same program space end up next to each other. */
2738 compare_symbols (const void *a
, const void *b
)
2740 struct symbol
* const *sa
= a
;
2741 struct symbol
* const *sb
= b
;
2744 uia
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa
));
2745 uib
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb
));
2752 uia
= (uintptr_t) *sa
;
2753 uib
= (uintptr_t) *sb
;
2763 /* Like compare_symbols but for minimal symbols. */
2766 compare_msymbols (const void *a
, const void *b
)
2768 const struct minsym_and_objfile
*sa
= a
;
2769 const struct minsym_and_objfile
*sb
= b
;
2772 uia
= (uintptr_t) sa
->objfile
->pspace
;
2773 uib
= (uintptr_t) sa
->objfile
->pspace
;
2780 uia
= (uintptr_t) sa
->minsym
;
2781 uib
= (uintptr_t) sb
->minsym
;
2791 /* Look for all the matching instances of each symbol in NAMES. Only
2792 instances from PSPACE are considered; other program spaces are
2793 handled by our caller. If PSPACE is NULL, then all program spaces
2794 are considered. Results are stored into INFO. */
2797 add_all_symbol_names_from_pspace (struct collect_info
*info
,
2798 struct program_space
*pspace
,
2799 VEC (const_char_ptr
) *names
)
2804 for (ix
= 0; VEC_iterate (const_char_ptr
, names
, ix
, iter
); ++ix
)
2805 add_matching_symbols_to_info (iter
, info
, pspace
);
2809 find_superclass_methods (VEC (typep
) *superclasses
,
2811 VEC (const_char_ptr
) **result_names
)
2813 int old_len
= VEC_length (const_char_ptr
, *result_names
);
2814 VEC (typep
) *iter_classes
;
2815 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
2817 iter_classes
= superclasses
;
2820 VEC (typep
) *new_supers
= NULL
;
2824 make_cleanup (VEC_cleanup (typep
), &new_supers
);
2825 for (ix
= 0; VEC_iterate (typep
, iter_classes
, ix
, t
); ++ix
)
2826 find_methods (t
, name
, result_names
, &new_supers
);
2828 if (VEC_length (const_char_ptr
, *result_names
) != old_len
2829 || VEC_empty (typep
, new_supers
))
2832 iter_classes
= new_supers
;
2835 do_cleanups (cleanup
);
2838 /* This finds the method METHOD_NAME in the class CLASS_NAME whose type is
2839 given by one of the symbols in SYM_CLASSES. Matches are returned
2840 in SYMBOLS (for debug symbols) and MINSYMS (for minimal symbols). */
2843 find_method (struct linespec_state
*self
, VEC (symtab_p
) *file_symtabs
,
2844 const char *class_name
, const char *method_name
,
2845 VEC (symbolp
) *sym_classes
, VEC (symbolp
) **symbols
,
2846 VEC (minsym_and_objfile_d
) **minsyms
)
2849 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
2851 int last_result_len
;
2852 VEC (typep
) *superclass_vec
;
2853 VEC (const_char_ptr
) *result_names
;
2854 struct collect_info info
;
2856 /* Sort symbols so that symbols with the same program space are next
2858 qsort (VEC_address (symbolp
, sym_classes
),
2859 VEC_length (symbolp
, sym_classes
),
2864 info
.file_symtabs
= file_symtabs
;
2865 info
.result
.symbols
= NULL
;
2866 info
.result
.minimal_symbols
= NULL
;
2868 /* Iterate over all the types, looking for the names of existing
2869 methods matching METHOD_NAME. If we cannot find a direct method in a
2870 given program space, then we consider inherited methods; this is
2871 not ideal (ideal would be to respect C++ hiding rules), but it
2872 seems good enough and is what GDB has historically done. We only
2873 need to collect the names because later we find all symbols with
2874 those names. This loop is written in a somewhat funny way
2875 because we collect data across the program space before deciding
2877 superclass_vec
= NULL
;
2878 make_cleanup (VEC_cleanup (typep
), &superclass_vec
);
2879 result_names
= NULL
;
2880 make_cleanup (VEC_cleanup (const_char_ptr
), &result_names
);
2881 last_result_len
= 0;
2882 for (ix
= 0; VEC_iterate (symbolp
, sym_classes
, ix
, sym
); ++ix
)
2885 struct program_space
*pspace
;
2887 /* Program spaces that are executing startup should have
2888 been filtered out earlier. */
2889 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
))->executing_startup
);
2890 pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2891 set_current_program_space (pspace
);
2892 t
= check_typedef (SYMBOL_TYPE (sym
));
2893 find_methods (t
, method_name
, &result_names
, &superclass_vec
);
2895 /* Handle all items from a single program space at once; and be
2896 sure not to miss the last batch. */
2897 if (ix
== VEC_length (symbolp
, sym_classes
) - 1
2899 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp
, sym_classes
,
2902 /* If we did not find a direct implementation anywhere in
2903 this program space, consider superclasses. */
2904 if (VEC_length (const_char_ptr
, result_names
) == last_result_len
)
2905 find_superclass_methods (superclass_vec
, method_name
,
2908 /* We have a list of candidate symbol names, so now we
2909 iterate over the symbol tables looking for all
2910 matches in this pspace. */
2911 add_all_symbol_names_from_pspace (&info
, pspace
, result_names
);
2913 VEC_truncate (typep
, superclass_vec
, 0);
2914 last_result_len
= VEC_length (const_char_ptr
, result_names
);
2918 if (!VEC_empty (symbolp
, info
.result
.symbols
)
2919 || !VEC_empty (minsym_and_objfile_d
, info
.result
.minimal_symbols
))
2921 *symbols
= info
.result
.symbols
;
2922 *minsyms
= info
.result
.minimal_symbols
;
2923 do_cleanups (cleanup
);
2927 /* Throw an NOT_FOUND_ERROR. This will be caught by the caller
2928 and other attempts to locate the symbol will be made. */
2929 throw_error (NOT_FOUND_ERROR
, _("see caller, this text doesn't matter"));
2934 /* This object is used when collecting all matching symtabs. */
2936 struct symtab_collector
2938 /* The result vector of symtabs. */
2939 VEC (symtab_p
) *symtabs
;
2941 /* This is used to ensure the symtabs are unique. */
2942 htab_t symtab_table
;
2945 /* Callback for iterate_over_symtabs. */
2948 add_symtabs_to_list (struct symtab
*symtab
, void *d
)
2950 struct symtab_collector
*data
= d
;
2953 slot
= htab_find_slot (data
->symtab_table
, symtab
, INSERT
);
2957 VEC_safe_push (symtab_p
, data
->symtabs
, symtab
);
2963 /* Given a file name, return a VEC of all matching symtabs. */
2965 static VEC (symtab_p
) *
2966 collect_symtabs_from_filename (const char *file
)
2968 struct symtab_collector collector
;
2969 struct cleanup
*cleanups
;
2970 struct program_space
*pspace
;
2972 collector
.symtabs
= NULL
;
2973 collector
.symtab_table
= htab_create (1, htab_hash_pointer
, htab_eq_pointer
,
2975 cleanups
= make_cleanup_htab_delete (collector
.symtab_table
);
2977 /* Find that file's data. */
2978 ALL_PSPACES (pspace
)
2980 if (pspace
->executing_startup
)
2983 set_current_program_space (pspace
);
2984 iterate_over_symtabs (file
, add_symtabs_to_list
, &collector
);
2987 do_cleanups (cleanups
);
2988 return collector
.symtabs
;
2991 /* Return all the symtabs associated to the FILENAME. */
2993 static VEC (symtab_p
) *
2994 symtabs_from_filename (const char *filename
)
2996 VEC (symtab_p
) *result
;
2998 result
= collect_symtabs_from_filename (filename
);
3000 if (VEC_empty (symtab_p
, result
))
3002 if (!have_full_symbols () && !have_partial_symbols ())
3003 throw_error (NOT_FOUND_ERROR
,
3004 _("No symbol table is loaded. "
3005 "Use the \"file\" command."));
3006 throw_error (NOT_FOUND_ERROR
, _("No source file named %s."), filename
);
3012 /* Look up a function symbol named NAME in symtabs FILE_SYMTABS. Matching
3013 debug symbols are returned in SYMBOLS. Matching minimal symbols are
3014 returned in MINSYMS. */
3017 find_function_symbols (struct linespec_state
*state
,
3018 VEC (symtab_p
) *file_symtabs
, const char *name
,
3019 VEC (symbolp
) **symbols
,
3020 VEC (minsym_and_objfile_d
) **minsyms
)
3022 struct collect_info info
;
3023 VEC (const_char_ptr
) *symbol_names
= NULL
;
3024 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (const_char_ptr
),
3028 info
.result
.symbols
= NULL
;
3029 info
.result
.minimal_symbols
= NULL
;
3030 info
.file_symtabs
= file_symtabs
;
3032 /* Try NAME as an Objective-C selector. */
3033 find_imps ((char *) name
, &symbol_names
);
3034 if (!VEC_empty (const_char_ptr
, symbol_names
))
3035 add_all_symbol_names_from_pspace (&info
, NULL
, symbol_names
);
3037 add_matching_symbols_to_info (name
, &info
, NULL
);
3039 do_cleanups (cleanup
);
3041 if (VEC_empty (symbolp
, info
.result
.symbols
))
3043 VEC_free (symbolp
, info
.result
.symbols
);
3047 *symbols
= info
.result
.symbols
;
3049 if (VEC_empty (minsym_and_objfile_d
, info
.result
.minimal_symbols
))
3051 VEC_free (minsym_and_objfile_d
, info
.result
.minimal_symbols
);
3055 *minsyms
= info
.result
.minimal_symbols
;
3058 /* Find all symbols named NAME in FILE_SYMTABS, returning debug symbols
3059 in SYMBOLS and minimal symbols in MINSYMS. */
3062 find_linespec_symbols (struct linespec_state
*state
,
3063 VEC (symtab_p
) *file_symtabs
,
3065 VEC (symbolp
) **symbols
,
3066 VEC (minsym_and_objfile_d
) **minsyms
)
3068 char *klass
, *method
, *canon
;
3069 const char *lookup_name
, *last
, *p
, *scope_op
;
3070 struct cleanup
*cleanup
;
3071 VEC (symbolp
) *classes
;
3072 volatile struct gdb_exception except
;
3074 cleanup
= demangle_for_lookup (name
, state
->language
->la_language
,
3076 if (state
->language
->la_language
== language_ada
)
3078 /* In Ada, the symbol lookups are performed using the encoded
3079 name rather than the demangled name. */
3080 lookup_name
= ada_name_for_lookup (name
);
3081 make_cleanup (xfree
, (void *) lookup_name
);
3084 canon
= cp_canonicalize_string_no_typedefs (lookup_name
);
3087 lookup_name
= canon
;
3088 cleanup
= make_cleanup (xfree
, canon
);
3091 /* See if we can find a scope operator and break this symbol
3092 name into namespaces${SCOPE_OPERATOR}class_name and method_name. */
3094 p
= find_toplevel_string (lookup_name
, scope_op
);
3097 /* No C++ scope operator. Try Java. */
3099 p
= find_toplevel_string (lookup_name
, scope_op
);
3106 p
= find_toplevel_string (p
+ strlen (scope_op
), scope_op
);
3109 /* If no scope operator was found, lookup the name as a symbol. */
3112 find_function_symbols (state
, file_symtabs
, lookup_name
,
3114 do_cleanups (cleanup
);
3118 /* NAME points to the class name.
3119 LAST points to the method name. */
3120 klass
= xmalloc ((last
- lookup_name
+ 1) * sizeof (char));
3121 make_cleanup (xfree
, klass
);
3122 strncpy (klass
, lookup_name
, last
- lookup_name
);
3123 klass
[last
- lookup_name
] = '\0';
3125 /* Skip past the scope operator. */
3126 last
+= strlen (scope_op
);
3127 method
= xmalloc ((strlen (last
) + 1) * sizeof (char));
3128 make_cleanup (xfree
, method
);
3129 strcpy (method
, last
);
3131 /* Find a list of classes named KLASS. */
3132 classes
= lookup_prefix_sym (state
, file_symtabs
, klass
);
3133 make_cleanup (VEC_cleanup (symbolp
), &classes
);
3134 if (!VEC_empty (symbolp
, classes
))
3136 /* Now locate a list of suitable methods named METHOD. */
3137 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3139 find_method (state
, file_symtabs
, klass
, method
, classes
,
3143 /* If successful, we're done. If NOT_FOUND_ERROR
3144 was not thrown, rethrow the exception that we did get.
3145 Otherwise, fall back to looking up the entire name as a symbol.
3146 This can happen with namespace::function. */
3147 if (except
.reason
>= 0)
3149 do_cleanups (cleanup
);
3152 else if (except
.error
!= NOT_FOUND_ERROR
)
3153 throw_exception (except
);
3156 /* We couldn't find a class, so we check the entire name as a symbol
3158 find_function_symbols (state
, file_symtabs
, lookup_name
, symbols
, minsyms
);
3159 do_cleanups (cleanup
);
3162 /* Return all labels named NAME in FUNCTION_SYMBOLS. Return the
3163 actual function symbol in which the label was found in LABEL_FUNC_RET. */
3165 static VEC (symbolp
) *
3166 find_label_symbols (struct linespec_state
*self
,
3167 VEC (symbolp
) *function_symbols
,
3168 VEC (symbolp
) **label_funcs_ret
, const char *name
)
3171 struct block
*block
;
3173 struct symbol
*fn_sym
;
3174 VEC (symbolp
) *result
= NULL
;
3176 if (function_symbols
== NULL
)
3178 set_current_program_space (self
->program_space
);
3179 block
= get_search_block (NULL
);
3182 block
&& !BLOCK_FUNCTION (block
);
3183 block
= BLOCK_SUPERBLOCK (block
))
3187 fn_sym
= BLOCK_FUNCTION (block
);
3189 sym
= lookup_symbol (name
, block
, LABEL_DOMAIN
, 0);
3193 VEC_safe_push (symbolp
, result
, sym
);
3194 VEC_safe_push (symbolp
, *label_funcs_ret
, fn_sym
);
3200 VEC_iterate (symbolp
, function_symbols
, ix
, fn_sym
); ++ix
)
3202 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym
)));
3203 block
= SYMBOL_BLOCK_VALUE (fn_sym
);
3204 sym
= lookup_symbol (name
, block
, LABEL_DOMAIN
, 0);
3208 VEC_safe_push (symbolp
, result
, sym
);
3209 VEC_safe_push (symbolp
, *label_funcs_ret
, fn_sym
);
3219 /* A helper for create_sals_line_offset that handles the 'list_mode' case. */
3222 decode_digits_list_mode (struct linespec_state
*self
,
3224 struct symtabs_and_lines
*values
,
3225 struct symtab_and_line val
)
3230 gdb_assert (self
->list_mode
);
3232 for (ix
= 0; VEC_iterate (symtab_p
, ls
->file_symtabs
, ix
, elt
);
3235 /* The logic above should ensure this. */
3236 gdb_assert (elt
!= NULL
);
3238 set_current_program_space (SYMTAB_PSPACE (elt
));
3240 /* Simplistic search just for the list command. */
3241 val
.symtab
= find_line_symtab (elt
, val
.line
, NULL
, NULL
);
3242 if (val
.symtab
== NULL
)
3244 val
.pspace
= SYMTAB_PSPACE (elt
);
3246 val
.explicit_line
= 1;
3248 add_sal_to_sals (self
, values
, &val
, NULL
, 0);
3252 /* A helper for create_sals_line_offset that iterates over the symtabs,
3253 adding lines to the VEC. */
3256 decode_digits_ordinary (struct linespec_state
*self
,
3259 struct symtabs_and_lines
*sals
,
3260 struct linetable_entry
**best_entry
)
3265 for (ix
= 0; VEC_iterate (symtab_p
, ls
->file_symtabs
, ix
, elt
); ++ix
)
3268 VEC (CORE_ADDR
) *pcs
;
3271 /* The logic above should ensure this. */
3272 gdb_assert (elt
!= NULL
);
3274 set_current_program_space (SYMTAB_PSPACE (elt
));
3276 pcs
= find_pcs_for_symtab_line (elt
, line
, best_entry
);
3277 for (i
= 0; VEC_iterate (CORE_ADDR
, pcs
, i
, pc
); ++i
)
3279 struct symtab_and_line sal
;
3282 sal
.pspace
= SYMTAB_PSPACE (elt
);
3286 add_sal_to_sals_basic (sals
, &sal
);
3289 VEC_free (CORE_ADDR
, pcs
);
3295 /* Return the line offset represented by VARIABLE. */
3297 static struct line_offset
3298 linespec_parse_variable (struct linespec_state
*self
, const char *variable
)
3302 struct line_offset offset
= {0, LINE_OFFSET_NONE
};
3304 p
= (variable
[1] == '$') ? variable
+ 2 : variable
+ 1;
3307 while (*p
>= '0' && *p
<= '9')
3309 if (!*p
) /* Reached end of token without hitting non-digit. */
3311 /* We have a value history reference. */
3312 struct value
*val_history
;
3314 sscanf ((variable
[1] == '$') ? variable
+ 2 : variable
+ 1, "%d", &index
);
3316 = access_value_history ((variable
[1] == '$') ? -index
: index
);
3317 if (TYPE_CODE (value_type (val_history
)) != TYPE_CODE_INT
)
3318 error (_("History values used in line "
3319 "specs must have integer values."));
3320 offset
.offset
= value_as_long (val_history
);
3324 /* Not all digits -- may be user variable/function or a
3325 convenience variable. */
3327 struct internalvar
*ivar
;
3329 /* Try it as a convenience variable. If it is not a convenience
3330 variable, return and allow normal symbol lookup to occur. */
3331 ivar
= lookup_only_internalvar (variable
+ 1);
3333 /* No internal variable with that name. Mark the offset
3334 as unknown to allow the name to be looked up as a symbol. */
3335 offset
.sign
= LINE_OFFSET_UNKNOWN
;
3338 /* We found a valid variable name. If it is not an integer,
3340 if (!get_internalvar_integer (ivar
, &valx
))
3341 error (_("Convenience variables used in line "
3342 "specs must have integer values."));
3344 offset
.offset
= valx
;
3352 /* A callback used to possibly add a symbol to the results. */
3355 collect_symbols (struct symbol
*sym
, void *data
)
3357 struct collect_info
*info
= data
;
3359 /* In list mode, add all matching symbols, regardless of class.
3360 This allows the user to type "list a_global_variable". */
3361 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
|| info
->state
->list_mode
)
3362 VEC_safe_push (symbolp
, info
->result
.symbols
, sym
);
3363 return 1; /* Continue iterating. */
3366 /* We've found a minimal symbol MSYMBOL in OBJFILE to associate with our
3367 linespec; return the SAL in RESULT. */
3370 minsym_found (struct linespec_state
*self
, struct objfile
*objfile
,
3371 struct minimal_symbol
*msymbol
,
3372 struct symtabs_and_lines
*result
)
3374 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3376 struct symtab_and_line sal
;
3378 sal
= find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
3379 (struct obj_section
*) 0, 0);
3380 sal
.section
= SYMBOL_OBJ_SECTION (msymbol
);
3382 /* The minimal symbol might point to a function descriptor;
3383 resolve it to the actual code address instead. */
3384 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, sal
.pc
, ¤t_target
);
3386 sal
= find_pc_sect_line (pc
, NULL
, 0);
3388 if (self
->funfirstline
)
3389 skip_prologue_sal (&sal
);
3391 if (maybe_add_address (self
->addr_set
, objfile
->pspace
, sal
.pc
))
3392 add_sal_to_sals (self
, result
, &sal
, SYMBOL_NATURAL_NAME (msymbol
), 0);
3395 /* A helper struct to pass some data through
3396 iterate_over_minimal_symbols. */
3398 struct collect_minsyms
3400 /* The objfile we're examining. */
3401 struct objfile
*objfile
;
3403 /* The funfirstline setting from the initial call. */
3406 /* The list_mode setting from the initial call. */
3409 /* The resulting symbols. */
3410 VEC (minsym_and_objfile_d
) *msyms
;
3413 /* A helper function to classify a minimal_symbol_type according to
3417 classify_mtype (enum minimal_symbol_type t
)
3424 /* Intermediate priority. */
3427 case mst_solib_trampoline
:
3428 /* Lowest priority. */
3432 /* Highest priority. */
3437 /* Callback for qsort that sorts symbols by priority. */
3440 compare_msyms (const void *a
, const void *b
)
3442 const minsym_and_objfile_d
*moa
= a
;
3443 const minsym_and_objfile_d
*mob
= b
;
3444 enum minimal_symbol_type ta
= MSYMBOL_TYPE (moa
->minsym
);
3445 enum minimal_symbol_type tb
= MSYMBOL_TYPE (mob
->minsym
);
3447 return classify_mtype (ta
) - classify_mtype (tb
);
3450 /* Callback for iterate_over_minimal_symbols that adds the symbol to
3454 add_minsym (struct minimal_symbol
*minsym
, void *d
)
3456 struct collect_minsyms
*info
= d
;
3457 minsym_and_objfile_d mo
;
3459 /* Exclude data symbols when looking for breakpoint locations. */
3460 if (!info
->list_mode
)
3461 switch (minsym
->type
)
3463 case mst_slot_got_plt
:
3470 /* Make sure this minsym is not a function descriptor
3471 before we decide to discard it. */
3472 struct gdbarch
*gdbarch
= info
->objfile
->gdbarch
;
3473 CORE_ADDR addr
= gdbarch_convert_from_func_ptr_addr
3474 (gdbarch
, SYMBOL_VALUE_ADDRESS (minsym
),
3477 if (addr
== SYMBOL_VALUE_ADDRESS (minsym
))
3483 mo
.objfile
= info
->objfile
;
3484 VEC_safe_push (minsym_and_objfile_d
, info
->msyms
, &mo
);
3487 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
3488 is not NULL, the search is restricted to just that program
3492 search_minsyms_for_name (struct collect_info
*info
, const char *name
,
3493 struct program_space
*search_pspace
)
3495 struct objfile
*objfile
;
3496 struct program_space
*pspace
;
3498 ALL_PSPACES (pspace
)
3500 struct collect_minsyms local
;
3501 struct cleanup
*cleanup
;
3503 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
3505 if (pspace
->executing_startup
)
3508 set_current_program_space (pspace
);
3510 memset (&local
, 0, sizeof (local
));
3511 local
.funfirstline
= info
->state
->funfirstline
;
3512 local
.list_mode
= info
->state
->list_mode
;
3514 cleanup
= make_cleanup (VEC_cleanup (minsym_and_objfile_d
),
3517 ALL_OBJFILES (objfile
)
3519 local
.objfile
= objfile
;
3520 iterate_over_minimal_symbols (objfile
, name
, add_minsym
, &local
);
3523 if (!VEC_empty (minsym_and_objfile_d
, local
.msyms
))
3527 minsym_and_objfile_d
*item
;
3529 qsort (VEC_address (minsym_and_objfile_d
, local
.msyms
),
3530 VEC_length (minsym_and_objfile_d
, local
.msyms
),
3531 sizeof (minsym_and_objfile_d
),
3534 /* Now the minsyms are in classification order. So, we walk
3535 over them and process just the minsyms with the same
3536 classification as the very first minsym in the list. */
3537 item
= VEC_index (minsym_and_objfile_d
, local
.msyms
, 0);
3538 classification
= classify_mtype (MSYMBOL_TYPE (item
->minsym
));
3541 VEC_iterate (minsym_and_objfile_d
, local
.msyms
, ix
, item
);
3544 if (classify_mtype (MSYMBOL_TYPE (item
->minsym
)) != classification
)
3547 VEC_safe_push (minsym_and_objfile_d
,
3548 info
->result
.minimal_symbols
, item
);
3552 do_cleanups (cleanup
);
3556 /* A helper function to add all symbols matching NAME to INFO. If
3557 PSPACE is not NULL, the search is restricted to just that program
3561 add_matching_symbols_to_info (const char *name
,
3562 struct collect_info
*info
,
3563 struct program_space
*pspace
)
3568 for (ix
= 0; VEC_iterate (symtab_p
, info
->file_symtabs
, ix
, elt
); ++ix
)
3572 iterate_over_all_matching_symtabs (info
->state
, name
, VAR_DOMAIN
,
3573 collect_symbols
, info
,
3575 search_minsyms_for_name (info
, name
, pspace
);
3577 else if (pspace
== NULL
|| pspace
== SYMTAB_PSPACE (elt
))
3579 /* Program spaces that are executing startup should have
3580 been filtered out earlier. */
3581 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
3582 set_current_program_space (SYMTAB_PSPACE (elt
));
3583 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt
), name
,
3584 VAR_DOMAIN
, collect_symbols
,
3592 /* Now come some functions that are called from multiple places within
3596 symbol_to_sal (struct symtab_and_line
*result
,
3597 int funfirstline
, struct symbol
*sym
)
3599 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3601 *result
= find_function_start_sal (sym
, funfirstline
);
3606 if (SYMBOL_CLASS (sym
) == LOC_LABEL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
3609 result
->symtab
= SYMBOL_SYMTAB (sym
);
3610 result
->line
= SYMBOL_LINE (sym
);
3611 result
->pc
= SYMBOL_VALUE_ADDRESS (sym
);
3612 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3613 result
->explicit_pc
= 1;
3616 else if (funfirstline
)
3620 else if (SYMBOL_LINE (sym
) != 0)
3622 /* We know its line number. */
3624 result
->symtab
= SYMBOL_SYMTAB (sym
);
3625 result
->line
= SYMBOL_LINE (sym
);
3626 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3634 /* See the comment in linespec.h. */
3637 init_linespec_result (struct linespec_result
*lr
)
3639 memset (lr
, 0, sizeof (*lr
));
3642 /* See the comment in linespec.h. */
3645 destroy_linespec_result (struct linespec_result
*ls
)
3648 struct linespec_sals
*lsal
;
3650 xfree (ls
->addr_string
);
3651 for (i
= 0; VEC_iterate (linespec_sals
, ls
->sals
, i
, lsal
); ++i
)
3653 xfree (lsal
->canonical
);
3654 xfree (lsal
->sals
.sals
);
3656 VEC_free (linespec_sals
, ls
->sals
);
3659 /* Cleanup function for a linespec_result. */
3662 cleanup_linespec_result (void *a
)
3664 destroy_linespec_result (a
);
3667 /* See the comment in linespec.h. */
3670 make_cleanup_destroy_linespec_result (struct linespec_result
*ls
)
3672 return make_cleanup (cleanup_linespec_result
, ls
);