1 /* Parser for linespec for the GNU debugger, GDB.
3 Copyright (C) 1986-2005, 2007-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
29 #include "completer.h"
31 #include "cp-support.h"
32 #include "parser-defs.h"
34 #include "objc-lang.h"
36 #include "exceptions.h"
39 #include "mi/mi-cmds.h"
41 #include "arch-utils.h"
43 #include "cli/cli-utils.h"
44 #include "filenames.h"
48 typedef struct symtab
*symtab_p
;
51 typedef struct symbol
*symbolp
;
54 typedef struct type
*typep
;
57 /* An address entry is used to ensure that any given location is only
58 added to the result a single time. It holds an address and the
59 program space from which the address came. */
63 struct program_space
*pspace
;
67 /* A helper struct which just holds a minimal symbol and the object
68 file from which it came. */
70 typedef struct minsym_and_objfile
72 struct minimal_symbol
*minsym
;
73 struct objfile
*objfile
;
74 } minsym_and_objfile_d
;
76 DEF_VEC_O (minsym_and_objfile_d
);
78 /* An enumeration of possible signs for a line offset. */
79 enum offset_relative_sign
84 /* A plus sign ("+") */
87 /* A minus sign ("-") */
90 /* A special "sign" for unspecified offset. */
94 /* A line offset in a linespec. */
98 /* Line offset and any specified sign. */
100 enum offset_relative_sign sign
;
103 /* A linespec. Elements of this structure are filled in by a parser
104 (either parse_linespec or some other function). The structure is
105 then converted into SALs by convert_linespec_to_sals. */
109 /* An expression and the resulting PC. Specifying an expression
110 currently precludes the use of other members. */
112 /* The expression entered by the user. */
113 const char *expression
;
115 /* The resulting PC expression derived from evaluating EXPRESSION. */
118 /* Any specified file symtabs. */
120 /* The user-supplied source filename or NULL if none was specified. */
121 const char *source_filename
;
123 /* The list of symtabs to search to which to limit the search. May not
124 be NULL. If SOURCE_FILENAME is NULL (no user-specified filename),
125 FILE_SYMTABS should contain one single NULL member. This will
126 cause the code to use the default symtab. */
127 VEC (symtab_p
) *file_symtabs
;
129 /* The name of a function or method and any matching symbols. */
131 /* The user-specified function name. If no function name was
132 supplied, this may be NULL. */
133 const char *function_name
;
135 /* A list of matching function symbols and minimal symbols. Both lists
136 may be NULL if no matching symbols were found. */
137 VEC (symbolp
) *function_symbols
;
138 VEC (minsym_and_objfile_d
) *minimal_symbols
;
140 /* The name of a label and matching symbols. */
142 /* The user-specified label name. */
143 const char *label_name
;
145 /* A structure of matching label symbols and the corresponding
146 function symbol in which the label was found. Both may be NULL
147 or both must be non-NULL. */
150 VEC (symbolp
) *label_symbols
;
151 VEC (symbolp
) *function_symbols
;
154 /* Line offset. It may be LINE_OFFSET_UNKNOWN, meaning that no
155 offset was specified. */
156 struct line_offset line_offset
;
158 typedef struct linespec
*linespec_p
;
160 /* An instance of this is used to keep all state while linespec
161 operates. This instance is passed around as a 'this' pointer to
162 the various implementation methods. */
164 struct linespec_state
166 /* The language in use during linespec processing. */
167 const struct language_defn
*language
;
169 /* The program space as seen when the module was entered. */
170 struct program_space
*program_space
;
172 /* The default symtab to use, if no other symtab is specified. */
173 struct symtab
*default_symtab
;
175 /* The default line to use. */
178 /* The 'funfirstline' value that was passed in to decode_line_1 or
182 /* Nonzero if we are running in 'list' mode; see decode_line_list. */
185 /* The 'canonical' value passed to decode_line_full, or NULL. */
186 struct linespec_result
*canonical
;
188 /* Canonical strings that mirror the symtabs_and_lines result. */
189 char **canonical_names
;
191 /* This is a set of address_entry objects which is used to prevent
192 duplicate symbols from being entered into the result. */
196 /* This is a helper object that is used when collecting symbols into a
201 /* The linespec object in use. */
202 struct linespec_state
*state
;
204 /* A list of symtabs to which to restrict matches. */
205 VEC (symtab_p
) *file_symtabs
;
207 /* The result being accumulated. */
210 VEC (symbolp
) *symbols
;
211 VEC (minsym_and_objfile_d
) *minimal_symbols
;
222 /* A colon "separator" */
234 /* EOI (end of input) */
240 typedef enum ls_token_type linespec_token_type
;
242 /* List of keywords */
244 static const char * const linespec_keywords
[] = { "if", "thread", "task" };
246 /* A token of the linespec lexer */
250 /* The type of the token */
251 linespec_token_type type
;
253 /* Data for the token */
256 /* A string, given as a stoken */
257 struct stoken string
;
263 typedef struct ls_token linespec_token
;
265 #define LS_TOKEN_STOKEN(TOK) (TOK).data.string
266 #define LS_TOKEN_KEYWORD(TOK) (TOK).data.keyword
268 /* An instance of the linespec parser. */
272 /* Lexer internal data */
275 /* Save head of input stream. */
278 /* Head of the input stream. */
280 #define PARSER_STREAM(P) (*(P)->lexer.stream)
282 /* The current token. */
283 linespec_token current
;
286 /* Is the entire linespec quote-enclosed? */
287 int is_quote_enclosed
;
289 /* The state of the parse. */
290 struct linespec_state state
;
291 #define PARSER_STATE(PPTR) (&(PPTR)->state)
293 /* The result of the parse. */
294 struct linespec result
;
295 #define PARSER_RESULT(PPTR) (&(PPTR)->result)
297 typedef struct ls_parser linespec_parser
;
299 /* Prototypes for local functions. */
301 static void initialize_defaults (struct symtab
**default_symtab
,
304 static CORE_ADDR
linespec_expression_to_pc (char **exp_ptr
);
306 static struct symtabs_and_lines
decode_objc (struct linespec_state
*self
,
310 static VEC (symtab_p
) *symtabs_from_filename (const char *);
312 static VEC (symbolp
) *find_label_symbols (struct linespec_state
*self
,
313 VEC (symbolp
) *function_symbols
,
314 VEC (symbolp
) **label_funcs_ret
,
317 void find_linespec_symbols (struct linespec_state
*self
,
318 VEC (symtab_p
) *file_symtabs
,
320 VEC (symbolp
) **symbols
,
321 VEC (minsym_and_objfile_d
) **minsyms
);
323 static struct line_offset
324 linespec_parse_variable (struct linespec_state
*self
,
325 const char *variable
);
327 static int symbol_to_sal (struct symtab_and_line
*result
,
328 int funfirstline
, struct symbol
*sym
);
330 static void add_matching_symbols_to_info (const char *name
,
331 struct collect_info
*info
,
332 struct program_space
*pspace
);
334 static void add_all_symbol_names_from_pspace (struct collect_info
*info
,
335 struct program_space
*pspace
,
336 VEC (const_char_ptr
) *names
);
338 static VEC (symtab_p
) *collect_symtabs_from_filename (const char *file
);
340 static void decode_digits_ordinary (struct linespec_state
*self
,
343 struct symtabs_and_lines
*sals
,
344 struct linetable_entry
**best_entry
);
346 static void decode_digits_list_mode (struct linespec_state
*self
,
348 struct symtabs_and_lines
*values
,
349 struct symtab_and_line val
);
351 static void minsym_found (struct linespec_state
*self
, struct objfile
*objfile
,
352 struct minimal_symbol
*msymbol
,
353 struct symtabs_and_lines
*result
);
355 static int compare_symbols (const void *a
, const void *b
);
357 static int compare_msymbols (const void *a
, const void *b
);
359 static const char *find_toplevel_char (const char *s
, char c
);
361 /* Permitted quote characters for the parser. This is different from the
362 completer's quote characters to allow backward compatibility with the
364 static const char *const linespec_quote_characters
= "\"\'";
366 /* Lexer functions. */
368 /* Lex a number from the input in PARSER. This only supports
371 static linespec_token
372 linespec_lexer_lex_number (linespec_parser
*parser
)
374 linespec_token token
;
376 token
.type
= LSTOKEN_NUMBER
;
377 LS_TOKEN_STOKEN (token
).length
= 0;
378 LS_TOKEN_STOKEN (token
).ptr
= PARSER_STREAM (parser
);
380 /* Keep any sign at the start of the stream. */
381 if (*PARSER_STREAM (parser
) == '+' || *PARSER_STREAM (parser
) == '-')
383 ++LS_TOKEN_STOKEN (token
).length
;
384 ++(PARSER_STREAM (parser
));
387 while (isdigit (*PARSER_STREAM (parser
)))
389 ++LS_TOKEN_STOKEN (token
).length
;
390 ++(PARSER_STREAM (parser
));
396 /* Does P represent one of the keywords? If so, return
397 the keyword. If not, return NULL. */
400 linespec_lexer_lex_keyword (const char *p
)
406 for (i
= 0; i
< ARRAY_SIZE (linespec_keywords
); ++i
)
408 int len
= strlen (linespec_keywords
[i
]);
410 /* If P begins with one of the keywords and the next
411 character is not a valid identifier character,
412 we have found a keyword. */
413 if (strncmp (p
, linespec_keywords
[i
], len
) == 0
414 && !(isalnum (p
[len
]) || p
[len
] == '_'))
415 return linespec_keywords
[i
];
422 /* Does STRING represent an Ada operator? If so, return the length
423 of the decoded operator name. If not, return 0. */
426 is_ada_operator (const char *string
)
428 const struct ada_opname_map
*mapping
;
430 for (mapping
= ada_opname_table
;
431 mapping
->encoded
!= NULL
432 && strncmp (mapping
->decoded
, string
,
433 strlen (mapping
->decoded
)) != 0; ++mapping
)
436 return mapping
->decoded
== NULL
? 0 : strlen (mapping
->decoded
);
439 /* Find QUOTE_CHAR in STRING, accounting for the ':' terminal. Return
440 the location of QUOTE_CHAR, or NULL if not found. */
443 skip_quote_char (const char *string
, char quote_char
)
445 const char *p
, *last
;
447 p
= last
= find_toplevel_char (string
, quote_char
);
448 while (p
&& *p
!= '\0' && *p
!= ':')
450 p
= find_toplevel_char (p
, quote_char
);
458 /* Make a writable copy of the string given in TOKEN, trimming
459 any trailing whitespace. */
462 copy_token_string (linespec_token token
)
466 if (token
.type
== LSTOKEN_KEYWORD
)
467 return xstrdup (LS_TOKEN_KEYWORD (token
));
469 str
= savestring (LS_TOKEN_STOKEN (token
).ptr
,
470 LS_TOKEN_STOKEN (token
).length
);
471 s
= remove_trailing_whitespace (str
, str
+ LS_TOKEN_STOKEN (token
).length
);
477 /* Does P represent the end of a quote-enclosed linespec? */
480 is_closing_quote_enclosed (const char *p
)
482 if (strchr (linespec_quote_characters
, *p
))
484 p
= skip_spaces ((char *) p
);
485 return (*p
== '\0' || linespec_lexer_lex_keyword (p
));
488 /* Find the end of the parameter list that starts with *INPUT.
489 This helper function assists with lexing string segments
490 which might contain valid (non-terminating) commas. */
493 find_parameter_list_end (char *input
)
495 char end_char
, start_char
;
500 if (start_char
== '(')
502 else if (start_char
== '<')
511 if (*p
== start_char
)
513 else if (*p
== end_char
)
528 /* Lex a string from the input in PARSER. */
530 static linespec_token
531 linespec_lexer_lex_string (linespec_parser
*parser
)
533 linespec_token token
;
534 char *start
= PARSER_STREAM (parser
);
536 token
.type
= LSTOKEN_STRING
;
538 /* If the input stream starts with a quote character, skip to the next
539 quote character, regardless of the content. */
540 if (strchr (linespec_quote_characters
, *PARSER_STREAM (parser
)))
543 char quote_char
= *PARSER_STREAM (parser
);
545 /* Special case: Ada operators. */
546 if (PARSER_STATE (parser
)->language
->la_language
== language_ada
547 && quote_char
== '\"')
549 int len
= is_ada_operator (PARSER_STREAM (parser
));
553 /* The input is an Ada operator. Return the quoted string
555 LS_TOKEN_STOKEN (token
).ptr
= PARSER_STREAM (parser
);
556 LS_TOKEN_STOKEN (token
).length
= len
;
557 PARSER_STREAM (parser
) += len
;
561 /* The input does not represent an Ada operator -- fall through
562 to normal quoted string handling. */
565 /* Skip past the beginning quote. */
566 ++(PARSER_STREAM (parser
));
568 /* Mark the start of the string. */
569 LS_TOKEN_STOKEN (token
).ptr
= PARSER_STREAM (parser
);
571 /* Skip to the ending quote. */
572 end
= skip_quote_char (PARSER_STREAM (parser
), quote_char
);
574 /* Error if the input did not terminate properly. */
576 error (_("unmatched quote"));
578 /* Skip over the ending quote and mark the length of the string. */
579 PARSER_STREAM (parser
) = (char *) ++end
;
580 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - 2 - start
;
586 /* Otherwise, only identifier characters are permitted.
587 Spaces are the exception. In general, we keep spaces,
588 but only if the next characters in the input do not resolve
589 to one of the keywords.
591 This allows users to forgo quoting CV-qualifiers, template arguments,
592 and similar common language constructs. */
596 if (isspace (*PARSER_STREAM (parser
)))
598 p
= skip_spaces (PARSER_STREAM (parser
));
599 if (linespec_lexer_lex_keyword (p
) != NULL
)
601 LS_TOKEN_STOKEN (token
).ptr
= start
;
602 LS_TOKEN_STOKEN (token
).length
603 = PARSER_STREAM (parser
) - start
;
607 /* Advance past the whitespace. */
608 PARSER_STREAM (parser
) = p
;
611 /* If the next character is EOI or (single) ':', the
612 string is complete; return the token. */
613 if (*PARSER_STREAM (parser
) == 0)
615 LS_TOKEN_STOKEN (token
).ptr
= start
;
616 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - start
;
619 else if (PARSER_STREAM (parser
)[0] == ':')
621 /* Do not tokenize the C++ scope operator. */
622 if (PARSER_STREAM (parser
)[1] == ':')
623 ++(PARSER_STREAM (parser
));
625 /* Do not tokenify if the input length so far is one
626 (i.e, a single-letter drive name) and the next character
627 is a directory separator. This allows Windows-style
628 paths to be recognized as filenames without quoting it. */
629 else if ((PARSER_STREAM (parser
) - start
) != 1
630 || !IS_DIR_SEPARATOR (PARSER_STREAM (parser
)[1]))
632 LS_TOKEN_STOKEN (token
).ptr
= start
;
633 LS_TOKEN_STOKEN (token
).length
634 = PARSER_STREAM (parser
) - start
;
638 /* Special case: permit quote-enclosed linespecs. */
639 else if (parser
->is_quote_enclosed
640 && strchr (linespec_quote_characters
,
641 *PARSER_STREAM (parser
))
642 && is_closing_quote_enclosed (PARSER_STREAM (parser
)))
644 LS_TOKEN_STOKEN (token
).ptr
= start
;
645 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - start
;
648 /* Because commas may terminate a linespec and appear in
649 the middle of valid string input, special cases for
650 '<' and '(' are necessary. */
651 else if (*PARSER_STREAM (parser
) == '<'
652 || *PARSER_STREAM (parser
) == '(')
656 p
= find_parameter_list_end (PARSER_STREAM (parser
));
659 PARSER_STREAM (parser
) = p
;
663 /* Commas are terminators, but not if they are part of an
665 else if (*PARSER_STREAM (parser
) == ',')
667 if ((PARSER_STATE (parser
)->language
->la_language
669 && (PARSER_STREAM (parser
) - start
) > 8
670 /* strlen ("operator") */)
672 char *p
= strstr (start
, "operator");
674 if (p
!= NULL
&& is_operator_name (p
))
676 /* This is an operator name. Keep going. */
677 ++(PARSER_STREAM (parser
));
682 /* Comma terminates the string. */
683 LS_TOKEN_STOKEN (token
).ptr
= start
;
684 LS_TOKEN_STOKEN (token
).length
= PARSER_STREAM (parser
) - start
;
688 /* Advance the stream. */
689 ++(PARSER_STREAM (parser
));
696 /* Lex a single linespec token from PARSER. */
698 static linespec_token
699 linespec_lexer_lex_one (linespec_parser
*parser
)
703 if (parser
->lexer
.current
.type
== LSTOKEN_CONSUMED
)
705 /* Skip any whitespace. */
706 PARSER_STREAM (parser
) = skip_spaces (PARSER_STREAM (parser
));
708 /* Check for a keyword. */
709 keyword
= linespec_lexer_lex_keyword (PARSER_STREAM (parser
));
712 parser
->lexer
.current
.type
= LSTOKEN_KEYWORD
;
713 LS_TOKEN_KEYWORD (parser
->lexer
.current
) = keyword
;
714 return parser
->lexer
.current
;
717 /* Handle other tokens. */
718 switch (*PARSER_STREAM (parser
))
721 parser
->lexer
.current
.type
= LSTOKEN_EOI
;
725 case '0': case '1': case '2': case '3': case '4':
726 case '5': case '6': case '7': case '8': case '9':
727 parser
->lexer
.current
= linespec_lexer_lex_number (parser
);
731 /* If we have a scope operator, lex the input as a string.
732 Otherwise, return LSTOKEN_COLON. */
733 if (PARSER_STREAM (parser
)[1] == ':')
734 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
737 parser
->lexer
.current
.type
= LSTOKEN_COLON
;
738 ++(PARSER_STREAM (parser
));
742 case '\'': case '\"':
743 /* Special case: permit quote-enclosed linespecs. */
744 if (parser
->is_quote_enclosed
745 && is_closing_quote_enclosed (PARSER_STREAM (parser
)))
747 ++(PARSER_STREAM (parser
));
748 parser
->lexer
.current
.type
= LSTOKEN_EOI
;
751 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
755 parser
->lexer
.current
.type
= LSTOKEN_COMMA
;
756 LS_TOKEN_STOKEN (parser
->lexer
.current
).ptr
757 = PARSER_STREAM (parser
);
758 LS_TOKEN_STOKEN (parser
->lexer
.current
).length
= 1;
759 ++(PARSER_STREAM (parser
));
763 /* If the input is not a number, it must be a string.
764 [Keywords were already considered above.] */
765 parser
->lexer
.current
= linespec_lexer_lex_string (parser
);
770 return parser
->lexer
.current
;
773 /* Consume the current token and return the next token in PARSER's
776 static linespec_token
777 linespec_lexer_consume_token (linespec_parser
*parser
)
779 parser
->lexer
.current
.type
= LSTOKEN_CONSUMED
;
780 return linespec_lexer_lex_one (parser
);
783 /* Return the next token without consuming the current token. */
785 static linespec_token
786 linespec_lexer_peek_token (linespec_parser
*parser
)
789 char *saved_stream
= PARSER_STREAM (parser
);
790 linespec_token saved_token
= parser
->lexer
.current
;
792 next
= linespec_lexer_consume_token (parser
);
793 PARSER_STREAM (parser
) = saved_stream
;
794 parser
->lexer
.current
= saved_token
;
798 /* Helper functions. */
800 /* Add SAL to SALS. */
803 add_sal_to_sals_basic (struct symtabs_and_lines
*sals
,
804 struct symtab_and_line
*sal
)
807 sals
->sals
= xrealloc (sals
->sals
, sals
->nelts
* sizeof (sals
->sals
[0]));
808 sals
->sals
[sals
->nelts
- 1] = *sal
;
811 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
812 the new sal, if needed. If not NULL, SYMNAME is the name of the
813 symbol to use when constructing the new canonical name. */
816 add_sal_to_sals (struct linespec_state
*self
,
817 struct symtabs_and_lines
*sals
,
818 struct symtab_and_line
*sal
,
821 add_sal_to_sals_basic (sals
, sal
);
825 char *canonical_name
= NULL
;
827 self
->canonical_names
= xrealloc (self
->canonical_names
,
828 sals
->nelts
* sizeof (char *));
829 if (sal
->symtab
&& sal
->symtab
->filename
)
831 char *filename
= sal
->symtab
->filename
;
833 /* Note that the filter doesn't have to be a valid linespec
834 input. We only apply the ":LINE" treatment to Ada for
836 if (symname
!= NULL
&& sal
->line
!= 0
837 && self
->language
->la_language
== language_ada
)
838 canonical_name
= xstrprintf ("%s:%s:%d", filename
, symname
,
840 else if (symname
!= NULL
)
841 canonical_name
= xstrprintf ("%s:%s", filename
, symname
);
843 canonical_name
= xstrprintf ("%s:%d", filename
, sal
->line
);
846 self
->canonical_names
[sals
->nelts
- 1] = canonical_name
;
850 /* A hash function for address_entry. */
853 hash_address_entry (const void *p
)
855 const struct address_entry
*aep
= p
;
858 hash
= iterative_hash_object (aep
->pspace
, 0);
859 return iterative_hash_object (aep
->addr
, hash
);
862 /* An equality function for address_entry. */
865 eq_address_entry (const void *a
, const void *b
)
867 const struct address_entry
*aea
= a
;
868 const struct address_entry
*aeb
= b
;
870 return aea
->pspace
== aeb
->pspace
&& aea
->addr
== aeb
->addr
;
873 /* Check whether the address, represented by PSPACE and ADDR, is
874 already in the set. If so, return 0. Otherwise, add it and return
878 maybe_add_address (htab_t set
, struct program_space
*pspace
, CORE_ADDR addr
)
880 struct address_entry e
, *p
;
885 slot
= htab_find_slot (set
, &e
, INSERT
);
889 p
= XNEW (struct address_entry
);
890 memcpy (p
, &e
, sizeof (struct address_entry
));
896 /* A callback function and the additional data to call it with. */
898 struct symbol_and_data_callback
900 /* The callback to use. */
901 symbol_found_callback_ftype
*callback
;
903 /* Data to be passed to the callback. */
907 /* A helper for iterate_over_all_matching_symtabs that is used to
908 restrict calls to another callback to symbols representing inline
912 iterate_inline_only (struct symbol
*sym
, void *d
)
914 if (SYMBOL_INLINED (sym
))
916 struct symbol_and_data_callback
*cad
= d
;
918 return cad
->callback (sym
, cad
->data
);
920 return 1; /* Continue iterating. */
923 /* Some data for the expand_symtabs_matching callback. */
925 struct symbol_matcher_data
927 /* The lookup name against which symbol name should be compared. */
928 const char *lookup_name
;
930 /* The routine to be used for comparison. */
931 symbol_name_cmp_ftype symbol_name_cmp
;
934 /* A helper for iterate_over_all_matching_symtabs that is passed as a
935 callback to the expand_symtabs_matching method. */
938 iterate_name_matcher (const char *name
, void *d
)
940 const struct symbol_matcher_data
*data
= d
;
942 if (data
->symbol_name_cmp (name
, data
->lookup_name
) == 0)
943 return 1; /* Expand this symbol's symbol table. */
944 return 0; /* Skip this symbol. */
947 /* A helper that walks over all matching symtabs in all objfiles and
948 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
949 not NULL, then the search is restricted to just that program
950 space. If INCLUDE_INLINE is nonzero then symbols representing
951 inlined instances of functions will be included in the result. */
954 iterate_over_all_matching_symtabs (struct linespec_state
*state
,
956 const domain_enum domain
,
957 symbol_found_callback_ftype
*callback
,
959 struct program_space
*search_pspace
,
962 struct objfile
*objfile
;
963 struct program_space
*pspace
;
964 struct symbol_matcher_data matcher_data
;
966 matcher_data
.lookup_name
= name
;
967 matcher_data
.symbol_name_cmp
=
968 state
->language
->la_get_symbol_name_cmp
!= NULL
969 ? state
->language
->la_get_symbol_name_cmp (name
)
974 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
976 if (pspace
->executing_startup
)
979 set_current_program_space (pspace
);
981 ALL_OBJFILES (objfile
)
983 struct symtab
*symtab
;
986 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, NULL
,
987 iterate_name_matcher
,
991 ALL_OBJFILE_PRIMARY_SYMTABS (objfile
, symtab
)
995 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
996 LA_ITERATE_OVER_SYMBOLS (block
, name
, domain
, callback
, data
);
1000 struct symbol_and_data_callback cad
= { callback
, data
};
1003 for (i
= FIRST_LOCAL_BLOCK
;
1004 i
< BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (symtab
)); i
++)
1006 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), i
);
1007 LA_ITERATE_OVER_SYMBOLS (block
, name
, domain
,
1008 iterate_inline_only
, &cad
);
1016 /* Returns the block to be used for symbol searches for the given SYMTAB,
1017 which may be NULL. */
1019 static struct block
*
1020 get_search_block (struct symtab
*symtab
)
1022 struct block
*block
;
1025 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1028 enum language save_language
;
1030 /* get_selected_block can change the current language when there is
1031 no selected frame yet. */
1032 save_language
= current_language
->la_language
;
1033 block
= get_selected_block (0);
1034 set_language (save_language
);
1040 /* A helper for find_method. This finds all methods in type T which
1041 match NAME. It adds matching symbol names to RESULT_NAMES, and
1042 adds T's direct superclasses to SUPERCLASSES. */
1045 find_methods (struct type
*t
, const char *name
,
1046 VEC (const_char_ptr
) **result_names
,
1047 VEC (typep
) **superclasses
)
1051 const char *class_name
= type_name_no_tag (t
);
1053 /* Ignore this class if it doesn't have a name. This is ugly, but
1054 unless we figure out how to get the physname without the name of
1055 the class, then the loop can't do any good. */
1059 int name_len
= strlen (name
);
1063 /* Loop over each method name. At this level, all overloads of a name
1064 are counted as a single name. There is an inner loop which loops over
1067 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1068 method_counter
>= 0;
1071 const char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1072 char dem_opname
[64];
1074 if (strncmp (method_name
, "__", 2) == 0 ||
1075 strncmp (method_name
, "op", 2) == 0 ||
1076 strncmp (method_name
, "type", 4) == 0)
1078 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
1079 method_name
= dem_opname
;
1080 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
1081 method_name
= dem_opname
;
1084 if (strcmp_iw (method_name
, name
) == 0)
1088 for (field_counter
= (TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
)
1094 const char *phys_name
;
1096 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1097 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1099 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1100 VEC_safe_push (const_char_ptr
, *result_names
, phys_name
);
1106 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1107 VEC_safe_push (typep
, *superclasses
, TYPE_BASECLASS (t
, ibase
));
1110 /* Find an instance of the character C in the string S that is outside
1111 of all parenthesis pairs, single-quoted strings, and double-quoted
1112 strings. Also, ignore the char within a template name, like a ','
1113 within foo<int, int>. */
1116 find_toplevel_char (const char *s
, char c
)
1118 int quoted
= 0; /* zero if we're not in quotes;
1119 '"' if we're in a double-quoted string;
1120 '\'' if we're in a single-quoted string. */
1121 int depth
= 0; /* Number of unclosed parens we've seen. */
1124 for (scan
= s
; *scan
; scan
++)
1128 if (*scan
== quoted
)
1130 else if (*scan
== '\\' && *(scan
+ 1))
1133 else if (*scan
== c
&& ! quoted
&& depth
== 0)
1135 else if (*scan
== '"' || *scan
== '\'')
1137 else if (*scan
== '(' || *scan
== '<')
1139 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
1146 /* The string equivalent of find_toplevel_char. Returns a pointer
1147 to the location of NEEDLE in HAYSTACK, ignoring any occurrences
1148 inside "()" and "<>". Returns NULL if NEEDLE was not found. */
1151 find_toplevel_string (const char *haystack
, const char *needle
)
1153 const char *s
= haystack
;
1157 s
= find_toplevel_char (s
, *needle
);
1161 /* Found first char in HAYSTACK; check rest of string. */
1162 if (strncmp (s
, needle
, strlen (needle
)) == 0)
1165 /* Didn't find it; loop over HAYSTACK, looking for the next
1166 instance of the first character of NEEDLE. */
1170 while (s
!= NULL
&& *s
!= '\0');
1172 /* NEEDLE was not found in HAYSTACK. */
1176 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
1177 and store the result in SELF->CANONICAL. */
1180 filter_results (struct linespec_state
*self
,
1181 struct symtabs_and_lines
*result
,
1182 VEC (const_char_ptr
) *filters
)
1187 for (i
= 0; VEC_iterate (const_char_ptr
, filters
, i
, name
); ++i
)
1189 struct linespec_sals lsal
;
1192 memset (&lsal
, 0, sizeof (lsal
));
1194 for (j
= 0; j
< result
->nelts
; ++j
)
1196 if (strcmp (name
, self
->canonical_names
[j
]) == 0)
1197 add_sal_to_sals_basic (&lsal
.sals
, &result
->sals
[j
]);
1200 if (lsal
.sals
.nelts
> 0)
1202 lsal
.canonical
= xstrdup (name
);
1203 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
1207 self
->canonical
->pre_expanded
= 0;
1210 /* Store RESULT into SELF->CANONICAL. */
1213 convert_results_to_lsals (struct linespec_state
*self
,
1214 struct symtabs_and_lines
*result
)
1216 struct linespec_sals lsal
;
1218 lsal
.canonical
= NULL
;
1219 lsal
.sals
= *result
;
1220 VEC_safe_push (linespec_sals
, self
->canonical
->sals
, &lsal
);
1223 /* Handle multiple results in RESULT depending on SELECT_MODE. This
1224 will either return normally, throw an exception on multiple
1225 results, or present a menu to the user. On return, the SALS vector
1226 in SELF->CANONICAL is set up properly. */
1229 decode_line_2 (struct linespec_state
*self
,
1230 struct symtabs_and_lines
*result
,
1231 const char *select_mode
)
1234 char *args
, *prompt
;
1236 struct cleanup
*old_chain
;
1237 VEC (const_char_ptr
) *item_names
= NULL
, *filters
= NULL
;
1238 struct get_number_or_range_state state
;
1240 gdb_assert (select_mode
!= multiple_symbols_all
);
1241 gdb_assert (self
->canonical
!= NULL
);
1243 old_chain
= make_cleanup (VEC_cleanup (const_char_ptr
), &item_names
);
1244 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
1245 for (i
= 0; i
< result
->nelts
; ++i
)
1250 gdb_assert (self
->canonical_names
[i
] != NULL
);
1251 for (j
= 0; VEC_iterate (const_char_ptr
, item_names
, j
, iter
); ++j
)
1253 if (strcmp (iter
, self
->canonical_names
[i
]) == 0)
1261 VEC_safe_push (const_char_ptr
, item_names
, self
->canonical_names
[i
]);
1264 if (select_mode
== multiple_symbols_cancel
1265 && VEC_length (const_char_ptr
, item_names
) > 1)
1266 error (_("canceled because the command is ambiguous\n"
1267 "See set/show multiple-symbol."));
1269 if (select_mode
== multiple_symbols_all
1270 || VEC_length (const_char_ptr
, item_names
) == 1)
1272 do_cleanups (old_chain
);
1273 convert_results_to_lsals (self
, result
);
1277 /* Sort the list of method names alphabetically. */
1278 qsort (VEC_address (const_char_ptr
, item_names
),
1279 VEC_length (const_char_ptr
, item_names
),
1280 sizeof (const_char_ptr
), compare_strings
);
1282 printf_unfiltered (_("[0] cancel\n[1] all\n"));
1283 for (i
= 0; VEC_iterate (const_char_ptr
, item_names
, i
, iter
); ++i
)
1284 printf_unfiltered ("[%d] %s\n", i
+ 2, iter
);
1286 prompt
= getenv ("PS2");
1291 args
= command_line_input (prompt
, 0, "overload-choice");
1293 if (args
== 0 || *args
== 0)
1294 error_no_arg (_("one or more choice numbers"));
1296 init_number_or_range (&state
, args
);
1297 while (!state
.finished
)
1301 num
= get_number_or_range (&state
);
1304 error (_("canceled"));
1307 /* We intentionally make this result in a single breakpoint,
1308 contrary to what older versions of gdb did. The
1309 rationale is that this lets a user get the
1310 multiple_symbols_all behavior even with the 'ask'
1311 setting; and he can get separate breakpoints by entering
1312 "2-57" at the query. */
1313 do_cleanups (old_chain
);
1314 convert_results_to_lsals (self
, result
);
1319 if (num
>= VEC_length (const_char_ptr
, item_names
))
1320 printf_unfiltered (_("No choice number %d.\n"), num
);
1323 const char *elt
= VEC_index (const_char_ptr
, item_names
, num
);
1327 VEC_safe_push (const_char_ptr
, filters
, elt
);
1328 VEC_replace (const_char_ptr
, item_names
, num
, NULL
);
1332 printf_unfiltered (_("duplicate request for %d ignored.\n"),
1338 filter_results (self
, result
, filters
);
1339 do_cleanups (old_chain
);
1344 /* The parser of linespec itself. */
1346 /* Throw an appropriate error when SYMBOL is not found (optionally in
1349 static void ATTRIBUTE_NORETURN
1350 symbol_not_found_error (const char *symbol
, const char *filename
)
1355 if (!have_full_symbols ()
1356 && !have_partial_symbols ()
1357 && !have_minimal_symbols ())
1358 throw_error (NOT_FOUND_ERROR
,
1359 _("No symbol table is loaded. Use the \"file\" command."));
1361 /* If SYMBOL starts with '$', the user attempted to either lookup
1362 a function/variable in his code starting with '$' or an internal
1363 variable of that name. Since we do not know which, be concise and
1364 explain both possibilities. */
1368 throw_error (NOT_FOUND_ERROR
,
1369 _("Undefined convenience variable or function \"%s\" "
1370 "not defined in \"%s\"."), symbol
, filename
);
1372 throw_error (NOT_FOUND_ERROR
,
1373 _("Undefined convenience variable or function \"%s\" "
1374 "not defined."), symbol
);
1379 throw_error (NOT_FOUND_ERROR
,
1380 _("Function \"%s\" not defined in \"%s\"."),
1383 throw_error (NOT_FOUND_ERROR
,
1384 _("Function \"%s\" not defined."), symbol
);
1388 /* Throw an appropriate error when an unexpected token is encountered
1391 static void ATTRIBUTE_NORETURN
1392 unexpected_linespec_error (linespec_parser
*parser
)
1394 linespec_token token
;
1395 static const char * token_type_strings
[]
1396 = {"keyword", "colon", "string", "number", "comma", "end of input"};
1398 /* Get the token that generated the error. */
1399 token
= linespec_lexer_lex_one (parser
);
1401 /* Finally, throw the error. */
1402 if (token
.type
== LSTOKEN_STRING
|| token
.type
== LSTOKEN_NUMBER
1403 || token
.type
== LSTOKEN_KEYWORD
)
1406 struct cleanup
*cleanup
;
1408 string
= copy_token_string (token
);
1409 cleanup
= make_cleanup (xfree
, string
);
1410 throw_error (GENERIC_ERROR
,
1411 _("malformed linespec error: unexpected %s, \"%s\""),
1412 token_type_strings
[token
.type
], string
);
1415 throw_error (GENERIC_ERROR
,
1416 _("malformed linespec error: unexpected %s"),
1417 token_type_strings
[token
.type
]);
1420 /* Parse and return a line offset in STRING. */
1422 static struct line_offset
1423 linespec_parse_line_offset (const char *string
)
1425 struct line_offset line_offset
= {0, LINE_OFFSET_NONE
};
1429 line_offset
.sign
= LINE_OFFSET_PLUS
;
1432 else if (*string
== '-')
1434 line_offset
.sign
= LINE_OFFSET_MINUS
;
1438 /* Right now, we only allow base 10 for offsets. */
1439 line_offset
.offset
= atoi (string
);
1443 /* Parse the basic_spec in PARSER's input. */
1446 linespec_parse_basic (linespec_parser
*parser
)
1449 linespec_token token
;
1450 VEC (symbolp
) *symbols
, *labels
;
1451 VEC (minsym_and_objfile_d
) *minimal_symbols
;
1452 struct cleanup
*cleanup
;
1454 /* Get the next token. */
1455 token
= linespec_lexer_lex_one (parser
);
1457 /* If it is EOI or KEYWORD, issue an error. */
1458 if (token
.type
== LSTOKEN_KEYWORD
|| token
.type
== LSTOKEN_EOI
)
1459 unexpected_linespec_error (parser
);
1460 /* If it is a LSTOKEN_NUMBER, we have an offset. */
1461 else if (token
.type
== LSTOKEN_NUMBER
)
1463 /* Record the line offset and get the next token. */
1464 name
= copy_token_string (token
);
1465 cleanup
= make_cleanup (xfree
, name
);
1466 PARSER_RESULT (parser
)->line_offset
= linespec_parse_line_offset (name
);
1467 do_cleanups (cleanup
);
1469 /* Get the next token. */
1470 token
= linespec_lexer_consume_token (parser
);
1472 /* If the next token is a comma, stop parsing and return. */
1473 if (token
.type
== LSTOKEN_COMMA
)
1476 /* If the next token is anything but EOI or KEYWORD, issue
1478 if (token
.type
!= LSTOKEN_KEYWORD
&& token
.type
!= LSTOKEN_EOI
)
1479 unexpected_linespec_error (parser
);
1482 if (token
.type
== LSTOKEN_KEYWORD
|| token
.type
== LSTOKEN_EOI
)
1485 /* Next token must be LSTOKEN_STRING. */
1486 if (token
.type
!= LSTOKEN_STRING
)
1487 unexpected_linespec_error (parser
);
1489 /* The current token will contain the name of a function, method,
1491 name
= copy_token_string (token
);
1492 cleanup
= make_cleanup (xfree
, name
);
1494 /* Try looking it up as a function/method. */
1495 find_linespec_symbols (PARSER_STATE (parser
),
1496 PARSER_RESULT (parser
)->file_symtabs
, name
,
1497 &symbols
, &minimal_symbols
);
1499 if (symbols
!= NULL
|| minimal_symbols
!= NULL
)
1501 PARSER_RESULT (parser
)->function_symbols
= symbols
;
1502 PARSER_RESULT (parser
)->minimal_symbols
= minimal_symbols
;
1503 PARSER_RESULT (parser
)->function_name
= name
;
1505 discard_cleanups (cleanup
);
1509 /* NAME was not a function or a method. So it must be a label
1511 labels
= find_label_symbols (PARSER_STATE (parser
), NULL
,
1515 PARSER_RESULT (parser
)->labels
.label_symbols
= labels
;
1516 PARSER_RESULT (parser
)->labels
.function_symbols
= symbols
;
1517 PARSER_RESULT (parser
)->label_name
= name
;
1519 discard_cleanups (cleanup
);
1523 /* The name is also not a label. Abort parsing. Do not throw
1524 an error here. parse_linespec will do it for us. */
1526 /* Save a copy of the name we were trying to lookup. */
1527 PARSER_RESULT (parser
)->function_name
= name
;
1528 discard_cleanups (cleanup
);
1533 /* Get the next token. */
1534 token
= linespec_lexer_consume_token (parser
);
1536 if (token
.type
== LSTOKEN_COLON
)
1538 /* User specified a label or a lineno. */
1539 token
= linespec_lexer_consume_token (parser
);
1541 if (token
.type
== LSTOKEN_NUMBER
)
1543 /* User specified an offset. Record the line offset and
1544 get the next token. */
1545 name
= copy_token_string (token
);
1546 cleanup
= make_cleanup (xfree
, name
);
1547 PARSER_RESULT (parser
)->line_offset
1548 = linespec_parse_line_offset (name
);
1549 do_cleanups (cleanup
);
1551 /* Ge the next token. */
1552 token
= linespec_lexer_consume_token (parser
);
1554 else if (token
.type
== LSTOKEN_STRING
)
1556 /* Grab a copy of the label's name and look it up. */
1557 name
= copy_token_string (token
);
1558 cleanup
= make_cleanup (xfree
, name
);
1559 labels
= find_label_symbols (PARSER_STATE (parser
),
1560 PARSER_RESULT (parser
)->function_symbols
,
1565 PARSER_RESULT (parser
)->labels
.label_symbols
= labels
;
1566 PARSER_RESULT (parser
)->labels
.function_symbols
= symbols
;
1567 PARSER_RESULT (parser
)->label_name
= name
;
1569 discard_cleanups (cleanup
);
1573 /* We don't know what it was, but it isn't a label. */
1574 throw_error (NOT_FOUND_ERROR
,
1575 _("No label \"%s\" defined in function \"%s\"."),
1576 name
, PARSER_RESULT (parser
)->function_name
);
1579 /* Check for a line offset. */
1580 token
= linespec_lexer_consume_token (parser
);
1581 if (token
.type
== LSTOKEN_COLON
)
1583 /* Get the next token. */
1584 token
= linespec_lexer_consume_token (parser
);
1586 /* It must be a line offset. */
1587 if (token
.type
!= LSTOKEN_NUMBER
)
1588 unexpected_linespec_error (parser
);
1590 /* Record the lione offset and get the next token. */
1591 name
= copy_token_string (token
);
1592 cleanup
= make_cleanup (xfree
, name
);
1594 PARSER_RESULT (parser
)->line_offset
1595 = linespec_parse_line_offset (name
);
1596 do_cleanups (cleanup
);
1598 /* Get the next token. */
1599 token
= linespec_lexer_consume_token (parser
);
1604 /* Trailing ':' in the input. Issue an error. */
1605 unexpected_linespec_error (parser
);
1610 /* Canonicalize the linespec contained in LS. The result is saved into
1611 STATE->canonical. */
1614 canonicalize_linespec (struct linespec_state
*state
, linespec_p ls
)
1616 /* If canonicalization was not requested, no need to do anything. */
1617 if (!state
->canonical
)
1620 /* Shortcut expressions, which can only appear by themselves. */
1621 if (ls
->expression
!= NULL
)
1622 state
->canonical
->addr_string
= xstrdup (ls
->expression
);
1625 struct ui_file
*buf
;
1628 buf
= mem_fileopen ();
1629 if (ls
->source_filename
)
1631 fputs_unfiltered (ls
->source_filename
, buf
);
1635 if (ls
->function_name
)
1638 fputc_unfiltered (':', buf
);
1639 fputs_unfiltered (ls
->function_name
, buf
);
1646 fputc_unfiltered (':', buf
);
1648 if (ls
->function_name
== NULL
)
1652 /* No function was specified, so add the symbol name. */
1653 gdb_assert (ls
->labels
.function_symbols
!= NULL
1654 && (VEC_length (symbolp
, ls
->labels
.function_symbols
)
1656 s
= VEC_index (symbolp
, ls
->labels
.function_symbols
, 0);
1657 fputs_unfiltered (SYMBOL_NATURAL_NAME (s
), buf
);
1658 fputc_unfiltered (':', buf
);
1661 fputs_unfiltered (ls
->label_name
, buf
);
1663 state
->canonical
->special_display
= 1;
1666 if (ls
->line_offset
.sign
!= LINE_OFFSET_UNKNOWN
)
1669 fputc_unfiltered (':', buf
);
1670 fprintf_filtered (buf
, "%s%d",
1671 (ls
->line_offset
.sign
== LINE_OFFSET_NONE
? ""
1672 : (ls
->line_offset
.sign
1673 == LINE_OFFSET_PLUS
? "+" : "-")),
1674 ls
->line_offset
.offset
);
1677 state
->canonical
->addr_string
= ui_file_xstrdup (buf
, NULL
);
1678 ui_file_delete (buf
);
1682 /* Given a line offset in LS, construct the relevant SALs. */
1684 static struct symtabs_and_lines
1685 create_sals_line_offset (struct linespec_state
*self
,
1688 struct symtabs_and_lines values
;
1689 struct symtab_and_line val
;
1690 int use_default
= 0;
1696 /* This is where we need to make sure we have good defaults.
1697 We must guarantee that this section of code is never executed
1698 when we are called with just a function anme, since
1699 set_default_source_symtab_and_line uses
1700 select_source_symtab that calls us with such an argument. */
1702 if (VEC_length (symtab_p
, ls
->file_symtabs
) == 1
1703 && VEC_index (symtab_p
, ls
->file_symtabs
, 0) == NULL
)
1705 set_current_program_space (self
->program_space
);
1707 /* Make sure we have at least a default source line. */
1708 set_default_source_symtab_and_line ();
1709 initialize_defaults (&self
->default_symtab
, &self
->default_line
);
1710 VEC_pop (symtab_p
, ls
->file_symtabs
);
1711 VEC_free (symtab_p
, ls
->file_symtabs
);
1713 = collect_symtabs_from_filename (self
->default_symtab
->filename
);
1717 val
.line
= ls
->line_offset
.offset
;
1718 switch (ls
->line_offset
.sign
)
1720 case LINE_OFFSET_PLUS
:
1721 if (ls
->line_offset
.offset
== 0)
1724 val
.line
= self
->default_line
+ val
.line
;
1727 case LINE_OFFSET_MINUS
:
1728 if (ls
->line_offset
.offset
== 0)
1731 val
.line
= self
->default_line
- val
.line
;
1733 val
.line
= -val
.line
;
1736 case LINE_OFFSET_NONE
:
1737 break; /* No need to adjust val.line. */
1740 if (self
->list_mode
)
1741 decode_digits_list_mode (self
, ls
, &values
, val
);
1744 struct linetable_entry
*best_entry
= NULL
;
1746 struct block
**blocks
;
1747 struct cleanup
*cleanup
;
1748 struct symtabs_and_lines intermediate_results
;
1751 intermediate_results
.sals
= NULL
;
1752 intermediate_results
.nelts
= 0;
1754 decode_digits_ordinary (self
, ls
, val
.line
, &intermediate_results
,
1756 if (intermediate_results
.nelts
== 0 && best_entry
!= NULL
)
1757 decode_digits_ordinary (self
, ls
, best_entry
->line
,
1758 &intermediate_results
, &best_entry
);
1760 cleanup
= make_cleanup (xfree
, intermediate_results
.sals
);
1762 /* For optimized code, the compiler can scatter one source line
1763 across disjoint ranges of PC values, even when no duplicate
1764 functions or inline functions are involved. For example,
1765 'for (;;)' inside a non-template, non-inline, and non-ctor-or-dtor
1766 function can result in two PC ranges. In this case, we don't
1767 want to set a breakpoint on the first PC of each range. To filter
1768 such cases, we use containing blocks -- for each PC found
1769 above, we see if there are other PCs that are in the same
1770 block. If yes, the other PCs are filtered out. */
1772 filter
= XNEWVEC (int, intermediate_results
.nelts
);
1773 make_cleanup (xfree
, filter
);
1774 blocks
= XNEWVEC (struct block
*, intermediate_results
.nelts
);
1775 make_cleanup (xfree
, blocks
);
1777 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
1779 set_current_program_space (intermediate_results
.sals
[i
].pspace
);
1782 blocks
[i
] = block_for_pc_sect (intermediate_results
.sals
[i
].pc
,
1783 intermediate_results
.sals
[i
].section
);
1786 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
1788 if (blocks
[i
] != NULL
)
1789 for (j
= i
+ 1; j
< intermediate_results
.nelts
; ++j
)
1791 if (blocks
[j
] == blocks
[i
])
1799 for (i
= 0; i
< intermediate_results
.nelts
; ++i
)
1802 struct symbol
*sym
= (blocks
[i
]
1803 ? block_containing_function (blocks
[i
])
1806 if (self
->funfirstline
)
1807 skip_prologue_sal (&intermediate_results
.sals
[i
]);
1808 /* Make sure the line matches the request, not what was
1810 intermediate_results
.sals
[i
].line
= val
.line
;
1811 add_sal_to_sals (self
, &values
, &intermediate_results
.sals
[i
],
1812 sym
? SYMBOL_NATURAL_NAME (sym
) : NULL
);
1815 do_cleanups (cleanup
);
1818 if (values
.nelts
== 0)
1820 if (ls
->source_filename
)
1821 throw_error (NOT_FOUND_ERROR
, _("No line %d in file \"%s\"."),
1822 val
.line
, ls
->source_filename
);
1824 throw_error (NOT_FOUND_ERROR
, _("No line %d in the current file."),
1831 /* Create and return SALs from the linespec LS. */
1833 static struct symtabs_and_lines
1834 convert_linespec_to_sals (struct linespec_state
*state
, linespec_p ls
)
1836 struct symtabs_and_lines sals
= {NULL
, 0};
1838 if (ls
->expression
!= NULL
)
1840 /* We have an expression. No other attribute is allowed. */
1841 sals
.sals
= XMALLOC (struct symtab_and_line
);
1843 sals
.sals
[0] = find_pc_line (ls
->expr_pc
, 0);
1844 sals
.sals
[0].pc
= ls
->expr_pc
;
1845 sals
.sals
[0].section
= find_pc_overlay (ls
->expr_pc
);
1846 sals
.sals
[0].explicit_pc
= 1;
1848 else if (ls
->labels
.label_symbols
!= NULL
)
1850 /* We have just a bunch of functions/methods or labels. */
1852 struct symtab_and_line sal
;
1855 for (i
= 0; VEC_iterate (symbolp
, ls
->labels
.label_symbols
, i
, sym
); ++i
)
1857 symbol_to_sal (&sal
, state
->funfirstline
, sym
);
1858 add_sal_to_sals (state
, &sals
, &sal
,
1859 SYMBOL_NATURAL_NAME (sym
));
1862 else if (ls
->function_symbols
!= NULL
|| ls
->minimal_symbols
!= NULL
)
1864 /* We have just a bunch of functions and/or methods. */
1866 struct symtab_and_line sal
;
1868 minsym_and_objfile_d
*elem
;
1869 struct program_space
*pspace
;
1871 if (ls
->function_symbols
!= NULL
)
1873 /* Sort symbols so that symbols with the same program space are next
1875 qsort (VEC_address (symbolp
, ls
->function_symbols
),
1876 VEC_length (symbolp
, ls
->function_symbols
),
1877 sizeof (symbolp
), compare_symbols
);
1879 for (i
= 0; VEC_iterate (symbolp
, ls
->function_symbols
, i
, sym
); ++i
)
1881 pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
1882 set_current_program_space (pspace
);
1883 symbol_to_sal (&sal
, state
->funfirstline
, sym
);
1884 if (maybe_add_address (state
->addr_set
, pspace
, sal
.pc
))
1885 add_sal_to_sals (state
, &sals
, &sal
, SYMBOL_NATURAL_NAME (sym
));
1889 if (ls
->minimal_symbols
!= NULL
)
1891 /* Sort minimal symbols by program space, too. */
1892 qsort (VEC_address (minsym_and_objfile_d
, ls
->minimal_symbols
),
1893 VEC_length (minsym_and_objfile_d
, ls
->minimal_symbols
),
1894 sizeof (minsym_and_objfile_d
), compare_msymbols
);
1897 VEC_iterate (minsym_and_objfile_d
, ls
->minimal_symbols
, i
, elem
);
1900 pspace
= elem
->objfile
->pspace
;
1901 set_current_program_space (pspace
);
1902 minsym_found (state
, elem
->objfile
, elem
->minsym
, &sals
);
1906 else if (ls
->line_offset
.sign
!= LINE_OFFSET_UNKNOWN
)
1908 /* Only an offset was specified. */
1909 sals
= create_sals_line_offset (state
, ls
);
1911 /* Make sure we have a filename for canonicalization. */
1912 if (ls
->source_filename
== NULL
)
1913 ls
->source_filename
= xstrdup (state
->default_symtab
->filename
);
1917 /* We haven't found any results... */
1921 canonicalize_linespec (state
, ls
);
1923 if (sals
.nelts
> 0 && state
->canonical
!= NULL
)
1924 state
->canonical
->pre_expanded
= 1;
1929 /* Parse a string that specifies a linespec.
1930 Pass the address of a char * variable; that variable will be
1931 advanced over the characters actually parsed.
1933 The basic grammar of linespecs:
1935 linespec -> expr_spec | var_spec | basic_spec
1936 expr_spec -> '*' STRING
1937 var_spec -> '$' (STRING | NUMBER)
1939 basic_spec -> file_offset_spec | function_spec | label_spec
1940 file_offset_spec -> opt_file_spec offset_spec
1941 function_spec -> opt_file_spec function_name_spec opt_label_spec
1942 label_spec -> label_name_spec
1944 opt_file_spec -> "" | file_name_spec ':'
1945 opt_label_spec -> "" | ':' label_name_spec
1947 file_name_spec -> STRING
1948 function_name_spec -> STRING
1949 label_name_spec -> STRING
1950 function_name_spec -> STRING
1951 offset_spec -> NUMBER
1955 This may all be followed by several keywords such as "if EXPR",
1958 A comma will terminate parsing.
1960 The function may be an undebuggable function found in minimal symbol table.
1962 If the argument FUNFIRSTLINE is nonzero, we want the first line
1963 of real code inside a function when a function is specified, and it is
1964 not OK to specify a variable or type to get its line number.
1966 DEFAULT_SYMTAB specifies the file to use if none is specified.
1967 It defaults to current_source_symtab.
1968 DEFAULT_LINE specifies the line number to use for relative
1969 line numbers (that start with signs). Defaults to current_source_line.
1970 If CANONICAL is non-NULL, store an array of strings containing the canonical
1971 line specs there if necessary. Currently overloaded member functions and
1972 line numbers or static functions without a filename yield a canonical
1973 line spec. The array and the line spec strings are allocated on the heap,
1974 it is the callers responsibility to free them.
1976 Note that it is possible to return zero for the symtab
1977 if no file is validly specified. Callers must check that.
1978 Also, the line number returned may be invalid. */
1980 /* Parse the linespec in ARGPTR. */
1982 static struct symtabs_and_lines
1983 parse_linespec (linespec_parser
*parser
, char **argptr
)
1985 linespec_token token
;
1986 struct symtabs_and_lines values
;
1987 volatile struct gdb_exception file_exception
;
1988 struct cleanup
*cleanup
;
1990 /* A special case to start. It has become quite popular for
1991 IDEs to work around bugs in the previous parser by quoting
1992 the entire linespec, so we attempt to deal with this nicely. */
1993 parser
->is_quote_enclosed
= 0;
1994 if (!is_ada_operator (*argptr
)
1995 && strchr (linespec_quote_characters
, **argptr
) != NULL
)
1999 end
= skip_quote_char (*argptr
+ 1, **argptr
);
2000 if (end
!= NULL
&& is_closing_quote_enclosed (end
))
2002 /* Here's the special case. Skip ARGPTR past the initial
2005 parser
->is_quote_enclosed
= 1;
2009 parser
->lexer
.saved_arg
= *argptr
;
2010 parser
->lexer
.stream
= argptr
;
2011 file_exception
.reason
= 0;
2013 /* Initialize the default symtab and line offset. */
2014 initialize_defaults (&PARSER_STATE (parser
)->default_symtab
,
2015 &PARSER_STATE (parser
)->default_line
);
2017 /* Objective-C shortcut. */
2018 values
= decode_objc (PARSER_STATE (parser
), PARSER_RESULT (parser
), argptr
);
2019 if (values
.sals
!= NULL
)
2022 /* Start parsing. */
2024 /* Get the first token. */
2025 token
= linespec_lexer_lex_one (parser
);
2027 /* It must be either LSTOKEN_STRING or LSTOKEN_NUMBER. */
2028 if (token
.type
== LSTOKEN_STRING
&& *LS_TOKEN_STOKEN (token
).ptr
== '*')
2032 /* User specified an expression, *EXPR. */
2033 copy
= expr
= copy_token_string (token
);
2034 cleanup
= make_cleanup (xfree
, expr
);
2035 PARSER_RESULT (parser
)->expr_pc
= linespec_expression_to_pc (©
);
2036 discard_cleanups (cleanup
);
2037 PARSER_RESULT (parser
)->expression
= expr
;
2039 /* This is a little hacky/tricky. If linespec_expression_to_pc
2040 did not evaluate the entire token, then we must find the
2041 string COPY inside the original token buffer. */
2044 PARSER_STREAM (parser
) = strstr (parser
->lexer
.saved_arg
, copy
);
2045 gdb_assert (PARSER_STREAM (parser
) != NULL
);
2048 /* Consume the token. */
2049 linespec_lexer_consume_token (parser
);
2051 goto convert_to_sals
;
2053 else if (token
.type
== LSTOKEN_STRING
&& *LS_TOKEN_STOKEN (token
).ptr
== '$')
2057 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2058 VEC_safe_push (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
, NULL
);
2060 /* User specified a convenience variable or history value. */
2061 var
= copy_token_string (token
);
2062 cleanup
= make_cleanup (xfree
, var
);
2063 PARSER_RESULT (parser
)->line_offset
2064 = linespec_parse_variable (PARSER_STATE (parser
), var
);
2066 /* If a line_offset wasn't found (VAR is the name of a user
2067 variable/function), then skip to normal symbol processing. */
2068 if (PARSER_RESULT (parser
)->line_offset
.sign
!= LINE_OFFSET_UNKNOWN
)
2070 discard_cleanups (cleanup
);
2072 /* Consume this token. */
2073 linespec_lexer_consume_token (parser
);
2075 goto convert_to_sals
;
2078 do_cleanups (cleanup
);
2080 else if (token
.type
!= LSTOKEN_STRING
&& token
.type
!= LSTOKEN_NUMBER
)
2081 unexpected_linespec_error (parser
);
2083 /* Shortcut: If the next token is not LSTOKEN_COLON, we know that
2084 this token cannot represent a filename. */
2085 token
= linespec_lexer_peek_token (parser
);
2087 if (token
.type
== LSTOKEN_COLON
)
2089 char *user_filename
;
2091 /* Get the current token again and extract the filename. */
2092 token
= linespec_lexer_lex_one (parser
);
2093 user_filename
= copy_token_string (token
);
2095 /* Check if the input is a filename. */
2096 TRY_CATCH (file_exception
, RETURN_MASK_ERROR
)
2098 PARSER_RESULT (parser
)->file_symtabs
2099 = symtabs_from_filename (user_filename
);
2102 if (file_exception
.reason
>= 0)
2104 /* Symtabs were found for the file. Record the filename. */
2105 PARSER_RESULT (parser
)->source_filename
= user_filename
;
2107 /* Get the next token. */
2108 token
= linespec_lexer_consume_token (parser
);
2110 /* This is LSTOKEN_COLON; consume it. */
2111 linespec_lexer_consume_token (parser
);
2115 /* No symtabs found -- discard user_filename. */
2116 xfree (user_filename
);
2118 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2119 VEC_safe_push (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
, NULL
);
2122 /* If the next token is not EOI, KEYWORD, or COMMA, issue an error. */
2123 else if (token
.type
!= LSTOKEN_EOI
&& token
.type
!= LSTOKEN_KEYWORD
2124 && token
.type
!= LSTOKEN_COMMA
)
2126 /* TOKEN is the _next_ token, not the one currently in the parser.
2127 Consuming the token will give the correct error message. */
2128 linespec_lexer_consume_token (parser
);
2129 unexpected_linespec_error (parser
);
2133 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2134 VEC_safe_push (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
, NULL
);
2137 /* Parse the rest of the linespec. */
2138 linespec_parse_basic (parser
);
2140 if (PARSER_RESULT (parser
)->function_symbols
== NULL
2141 && PARSER_RESULT (parser
)->labels
.label_symbols
== NULL
2142 && PARSER_RESULT (parser
)->line_offset
.sign
== LINE_OFFSET_UNKNOWN
2143 && PARSER_RESULT (parser
)->minimal_symbols
== NULL
)
2145 /* The linespec didn't parse. Re-throw the file exception if
2147 if (file_exception
.reason
< 0)
2148 throw_exception (file_exception
);
2150 /* Otherwise, the symbol is not found. */
2151 symbol_not_found_error (PARSER_RESULT (parser
)->function_name
,
2152 PARSER_RESULT (parser
)->source_filename
);
2157 /* Get the last token and record how much of the input was parsed,
2159 token
= linespec_lexer_lex_one (parser
);
2160 if (token
.type
!= LSTOKEN_EOI
&& token
.type
!= LSTOKEN_KEYWORD
)
2161 PARSER_STREAM (parser
) = LS_TOKEN_STOKEN (token
).ptr
;
2163 /* Convert the data in PARSER_RESULT to SALs. */
2164 values
= convert_linespec_to_sals (PARSER_STATE (parser
),
2165 PARSER_RESULT (parser
));
2171 /* A constructor for linespec_state. */
2174 linespec_state_constructor (struct linespec_state
*self
,
2175 int flags
, const struct language_defn
*language
,
2176 struct symtab
*default_symtab
,
2178 struct linespec_result
*canonical
)
2180 memset (self
, 0, sizeof (*self
));
2181 self
->language
= language
;
2182 self
->funfirstline
= (flags
& DECODE_LINE_FUNFIRSTLINE
) ? 1 : 0;
2183 self
->list_mode
= (flags
& DECODE_LINE_LIST_MODE
) ? 1 : 0;
2184 self
->default_symtab
= default_symtab
;
2185 self
->default_line
= default_line
;
2186 self
->canonical
= canonical
;
2187 self
->program_space
= current_program_space
;
2188 self
->addr_set
= htab_create_alloc (10, hash_address_entry
, eq_address_entry
,
2189 xfree
, xcalloc
, xfree
);
2192 /* Initialize a new linespec parser. */
2195 linespec_parser_new (linespec_parser
*parser
,
2196 int flags
, const struct language_defn
*language
,
2197 struct symtab
*default_symtab
,
2199 struct linespec_result
*canonical
)
2201 parser
->lexer
.current
.type
= LSTOKEN_CONSUMED
;
2202 memset (PARSER_RESULT (parser
), 0, sizeof (struct linespec
));
2203 PARSER_RESULT (parser
)->line_offset
.sign
= LINE_OFFSET_UNKNOWN
;
2204 linespec_state_constructor (PARSER_STATE (parser
), flags
, language
,
2205 default_symtab
, default_line
, canonical
);
2208 /* A destructor for linespec_state. */
2211 linespec_state_destructor (struct linespec_state
*self
)
2213 htab_delete (self
->addr_set
);
2216 /* Delete a linespec parser. */
2219 linespec_parser_delete (void *arg
)
2221 linespec_parser
*parser
= (linespec_parser
*) arg
;
2223 xfree ((char *) PARSER_RESULT (parser
)->expression
);
2224 xfree ((char *) PARSER_RESULT (parser
)->source_filename
);
2225 xfree ((char *) PARSER_RESULT (parser
)->label_name
);
2226 xfree ((char *) PARSER_RESULT (parser
)->function_name
);
2228 if (PARSER_RESULT (parser
)->file_symtabs
!= NULL
)
2229 VEC_free (symtab_p
, PARSER_RESULT (parser
)->file_symtabs
);
2231 if (PARSER_RESULT (parser
)->function_symbols
!= NULL
)
2232 VEC_free (symbolp
, PARSER_RESULT (parser
)->function_symbols
);
2234 if (PARSER_RESULT (parser
)->minimal_symbols
!= NULL
)
2235 VEC_free (minsym_and_objfile_d
, PARSER_RESULT (parser
)->minimal_symbols
);
2237 if (PARSER_RESULT (parser
)->labels
.label_symbols
!= NULL
)
2238 VEC_free (symbolp
, PARSER_RESULT (parser
)->labels
.label_symbols
);
2240 if (PARSER_RESULT (parser
)->labels
.function_symbols
!= NULL
)
2241 VEC_free (symbolp
, PARSER_RESULT (parser
)->labels
.function_symbols
);
2243 linespec_state_destructor (PARSER_STATE (parser
));
2246 /* See linespec.h. */
2249 decode_line_full (char **argptr
, int flags
,
2250 struct symtab
*default_symtab
,
2251 int default_line
, struct linespec_result
*canonical
,
2252 const char *select_mode
,
2255 struct symtabs_and_lines result
;
2256 struct cleanup
*cleanups
;
2257 char *arg_start
= *argptr
;
2258 VEC (const_char_ptr
) *filters
= NULL
;
2259 linespec_parser parser
;
2260 struct linespec_state
*state
;
2262 gdb_assert (canonical
!= NULL
);
2263 /* The filter only makes sense for 'all'. */
2264 gdb_assert (filter
== NULL
|| select_mode
== multiple_symbols_all
);
2265 gdb_assert (select_mode
== NULL
2266 || select_mode
== multiple_symbols_all
2267 || select_mode
== multiple_symbols_ask
2268 || select_mode
== multiple_symbols_cancel
);
2269 gdb_assert ((flags
& DECODE_LINE_LIST_MODE
) == 0);
2271 linespec_parser_new (&parser
, flags
, current_language
, default_symtab
,
2272 default_line
, canonical
);
2273 cleanups
= make_cleanup (linespec_parser_delete
, &parser
);
2274 save_current_program_space ();
2276 result
= parse_linespec (&parser
, argptr
);
2277 state
= PARSER_STATE (&parser
);
2279 gdb_assert (result
.nelts
== 1 || canonical
->pre_expanded
);
2280 gdb_assert (canonical
->addr_string
!= NULL
);
2281 canonical
->pre_expanded
= 1;
2283 /* Fill in the missing canonical names. */
2284 if (result
.nelts
> 0)
2288 if (state
->canonical_names
== NULL
)
2289 state
->canonical_names
= xcalloc (result
.nelts
, sizeof (char *));
2290 make_cleanup (xfree
, state
->canonical_names
);
2291 for (i
= 0; i
< result
.nelts
; ++i
)
2293 if (state
->canonical_names
[i
] == NULL
)
2294 state
->canonical_names
[i
] = savestring (arg_start
,
2295 *argptr
- arg_start
);
2296 make_cleanup (xfree
, state
->canonical_names
[i
]);
2300 if (select_mode
== NULL
)
2302 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2303 select_mode
= multiple_symbols_all
;
2305 select_mode
= multiple_symbols_select_mode ();
2308 if (select_mode
== multiple_symbols_all
)
2312 make_cleanup (VEC_cleanup (const_char_ptr
), &filters
);
2313 VEC_safe_push (const_char_ptr
, filters
, filter
);
2314 filter_results (state
, &result
, filters
);
2317 convert_results_to_lsals (state
, &result
);
2320 decode_line_2 (state
, &result
, select_mode
);
2322 do_cleanups (cleanups
);
2325 /* See linespec.h. */
2327 struct symtabs_and_lines
2328 decode_line_1 (char **argptr
, int flags
,
2329 struct symtab
*default_symtab
,
2332 struct symtabs_and_lines result
;
2333 linespec_parser parser
;
2334 struct cleanup
*cleanups
;
2336 linespec_parser_new (&parser
, flags
, current_language
, default_symtab
,
2337 default_line
, NULL
);
2338 cleanups
= make_cleanup (linespec_parser_delete
, &parser
);
2339 save_current_program_space ();
2341 result
= parse_linespec (&parser
, argptr
);
2343 do_cleanups (cleanups
);
2347 /* See linespec.h. */
2349 struct symtabs_and_lines
2350 decode_line_with_current_source (char *string
, int flags
)
2352 struct symtabs_and_lines sals
;
2353 struct symtab_and_line cursal
;
2356 error (_("Empty line specification."));
2358 /* We use whatever is set as the current source line. We do not try
2359 and get a default source symtab+line or it will recursively call us! */
2360 cursal
= get_current_source_symtab_and_line ();
2362 sals
= decode_line_1 (&string
, flags
,
2363 cursal
.symtab
, cursal
.line
);
2366 error (_("Junk at end of line specification: %s"), string
);
2370 /* See linespec.h. */
2372 struct symtabs_and_lines
2373 decode_line_with_last_displayed (char *string
, int flags
)
2375 struct symtabs_and_lines sals
;
2378 error (_("Empty line specification."));
2380 if (last_displayed_sal_is_valid ())
2381 sals
= decode_line_1 (&string
, flags
,
2382 get_last_displayed_symtab (),
2383 get_last_displayed_line ());
2385 sals
= decode_line_1 (&string
, flags
, (struct symtab
*) NULL
, 0);
2388 error (_("Junk at end of line specification: %s"), string
);
2394 /* First, some functions to initialize stuff at the beggining of the
2398 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
2400 if (*default_symtab
== 0)
2402 /* Use whatever we have for the default source line. We don't use
2403 get_current_or_default_symtab_and_line as it can recurse and call
2405 struct symtab_and_line cursal
=
2406 get_current_source_symtab_and_line ();
2408 *default_symtab
= cursal
.symtab
;
2409 *default_line
= cursal
.line
;
2415 /* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR,
2416 advancing EXP_PTR past any parsed text. */
2419 linespec_expression_to_pc (char **exp_ptr
)
2421 if (current_program_space
->executing_startup
)
2422 /* The error message doesn't really matter, because this case
2423 should only hit during breakpoint reset. */
2424 throw_error (NOT_FOUND_ERROR
, _("cannot evaluate expressions while "
2425 "program space is in startup"));
2428 return value_as_address (parse_to_comma_and_eval (exp_ptr
));
2433 /* Here's where we recognise an Objective-C Selector. An Objective C
2434 selector may be implemented by more than one class, therefore it
2435 may represent more than one method/function. This gives us a
2436 situation somewhat analogous to C++ overloading. If there's more
2437 than one method that could represent the selector, then use some of
2438 the existing C++ code to let the user choose one. */
2440 static struct symtabs_and_lines
2441 decode_objc (struct linespec_state
*self
, linespec_p ls
, char **argptr
)
2443 struct collect_info info
;
2444 VEC (const_char_ptr
) *symbol_names
= NULL
;
2445 struct symtabs_and_lines values
;
2447 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (const_char_ptr
),
2451 info
.file_symtabs
= NULL
;
2452 VEC_safe_push (symtab_p
, info
.file_symtabs
, NULL
);
2453 make_cleanup (VEC_cleanup (symtab_p
), &info
.file_symtabs
);
2454 info
.result
.symbols
= NULL
;
2455 info
.result
.minimal_symbols
= NULL
;
2459 new_argptr
= find_imps (*argptr
, &symbol_names
);
2460 if (VEC_empty (const_char_ptr
, symbol_names
))
2462 do_cleanups (cleanup
);
2466 add_all_symbol_names_from_pspace (&info
, NULL
, symbol_names
);
2468 if (!VEC_empty (symbolp
, info
.result
.symbols
)
2469 || !VEC_empty (minsym_and_objfile_d
, info
.result
.minimal_symbols
))
2473 saved_arg
= alloca (new_argptr
- *argptr
+ 1);
2474 memcpy (saved_arg
, *argptr
, new_argptr
- *argptr
);
2475 saved_arg
[new_argptr
- *argptr
] = '\0';
2477 ls
->function_symbols
= info
.result
.symbols
;
2478 ls
->minimal_symbols
= info
.result
.minimal_symbols
;
2479 values
= convert_linespec_to_sals (self
, ls
);
2481 if (self
->canonical
)
2483 self
->canonical
->pre_expanded
= 1;
2484 if (ls
->source_filename
)
2485 self
->canonical
->addr_string
2486 = xstrprintf ("%s:%s", ls
->source_filename
, saved_arg
);
2488 self
->canonical
->addr_string
= xstrdup (saved_arg
);
2492 *argptr
= new_argptr
;
2494 do_cleanups (cleanup
);
2499 /* An instance of this type is used when collecting prefix symbols for
2502 struct decode_compound_collector
2504 /* The result vector. */
2505 VEC (symbolp
) *symbols
;
2507 /* A hash table of all symbols we found. We use this to avoid
2508 adding any symbol more than once. */
2512 /* A callback for iterate_over_symbols that is used by
2513 lookup_prefix_sym to collect type symbols. */
2516 collect_one_symbol (struct symbol
*sym
, void *d
)
2518 struct decode_compound_collector
*collector
= d
;
2522 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
2523 return 1; /* Continue iterating. */
2525 t
= SYMBOL_TYPE (sym
);
2527 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2528 && TYPE_CODE (t
) != TYPE_CODE_UNION
2529 && TYPE_CODE (t
) != TYPE_CODE_NAMESPACE
)
2530 return 1; /* Continue iterating. */
2532 slot
= htab_find_slot (collector
->unique_syms
, sym
, INSERT
);
2536 VEC_safe_push (symbolp
, collector
->symbols
, sym
);
2539 return 1; /* Continue iterating. */
2542 /* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */
2544 static VEC (symbolp
) *
2545 lookup_prefix_sym (struct linespec_state
*state
, VEC (symtab_p
) *file_symtabs
,
2546 const char *class_name
)
2550 struct decode_compound_collector collector
;
2551 struct cleanup
*outer
;
2552 struct cleanup
*cleanup
;
2554 collector
.symbols
= NULL
;
2555 outer
= make_cleanup (VEC_cleanup (symbolp
), &collector
.symbols
);
2557 collector
.unique_syms
= htab_create_alloc (1, htab_hash_pointer
,
2558 htab_eq_pointer
, NULL
,
2560 cleanup
= make_cleanup_htab_delete (collector
.unique_syms
);
2562 for (ix
= 0; VEC_iterate (symtab_p
, file_symtabs
, ix
, elt
); ++ix
)
2566 iterate_over_all_matching_symtabs (state
, class_name
, STRUCT_DOMAIN
,
2567 collect_one_symbol
, &collector
,
2569 iterate_over_all_matching_symtabs (state
, class_name
, VAR_DOMAIN
,
2570 collect_one_symbol
, &collector
,
2575 struct block
*search_block
;
2577 /* Program spaces that are executing startup should have
2578 been filtered out earlier. */
2579 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
2580 set_current_program_space (SYMTAB_PSPACE (elt
));
2581 search_block
= get_search_block (elt
);
2582 LA_ITERATE_OVER_SYMBOLS (search_block
, class_name
, STRUCT_DOMAIN
,
2583 collect_one_symbol
, &collector
);
2584 LA_ITERATE_OVER_SYMBOLS (search_block
, class_name
, VAR_DOMAIN
,
2585 collect_one_symbol
, &collector
);
2589 do_cleanups (cleanup
);
2590 discard_cleanups (outer
);
2591 return collector
.symbols
;
2594 /* A qsort comparison function for symbols. The resulting order does
2595 not actually matter; we just need to be able to sort them so that
2596 symbols with the same program space end up next to each other. */
2599 compare_symbols (const void *a
, const void *b
)
2601 struct symbol
* const *sa
= a
;
2602 struct symbol
* const *sb
= b
;
2605 uia
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa
));
2606 uib
= (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb
));
2613 uia
= (uintptr_t) *sa
;
2614 uib
= (uintptr_t) *sb
;
2624 /* Like compare_symbols but for minimal symbols. */
2627 compare_msymbols (const void *a
, const void *b
)
2629 const struct minsym_and_objfile
*sa
= a
;
2630 const struct minsym_and_objfile
*sb
= b
;
2633 uia
= (uintptr_t) sa
->objfile
->pspace
;
2634 uib
= (uintptr_t) sa
->objfile
->pspace
;
2641 uia
= (uintptr_t) sa
->minsym
;
2642 uib
= (uintptr_t) sb
->minsym
;
2652 /* Look for all the matching instances of each symbol in NAMES. Only
2653 instances from PSPACE are considered; other program spaces are
2654 handled by our caller. If PSPACE is NULL, then all program spaces
2655 are considered. Results are stored into INFO. */
2658 add_all_symbol_names_from_pspace (struct collect_info
*info
,
2659 struct program_space
*pspace
,
2660 VEC (const_char_ptr
) *names
)
2665 for (ix
= 0; VEC_iterate (const_char_ptr
, names
, ix
, iter
); ++ix
)
2666 add_matching_symbols_to_info (iter
, info
, pspace
);
2670 find_superclass_methods (VEC (typep
) *superclasses
,
2672 VEC (const_char_ptr
) **result_names
)
2674 int old_len
= VEC_length (const_char_ptr
, *result_names
);
2675 VEC (typep
) *iter_classes
;
2676 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
2678 iter_classes
= superclasses
;
2681 VEC (typep
) *new_supers
= NULL
;
2685 make_cleanup (VEC_cleanup (typep
), &new_supers
);
2686 for (ix
= 0; VEC_iterate (typep
, iter_classes
, ix
, t
); ++ix
)
2687 find_methods (t
, name
, result_names
, &new_supers
);
2689 if (VEC_length (const_char_ptr
, *result_names
) != old_len
2690 || VEC_empty (typep
, new_supers
))
2693 iter_classes
= new_supers
;
2696 do_cleanups (cleanup
);
2699 /* This finds the method METHOD_NAME in the class CLASS_NAME whose type is
2700 given by one of the symbols in SYM_CLASSES. Matches are returned
2701 in SYMBOLS (for debug symbols) and MINSYMS (for minimal symbols). */
2704 find_method (struct linespec_state
*self
, VEC (symtab_p
) *file_symtabs
,
2705 const char *class_name
, const char *method_name
,
2706 VEC (symbolp
) *sym_classes
, VEC (symbolp
) **symbols
,
2707 VEC (minsym_and_objfile_d
) **minsyms
)
2710 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
2712 int last_result_len
;
2713 VEC (typep
) *superclass_vec
;
2714 VEC (const_char_ptr
) *result_names
;
2715 struct collect_info info
;
2717 /* Sort symbols so that symbols with the same program space are next
2719 qsort (VEC_address (symbolp
, sym_classes
),
2720 VEC_length (symbolp
, sym_classes
),
2725 info
.file_symtabs
= file_symtabs
;
2726 info
.result
.symbols
= NULL
;
2727 info
.result
.minimal_symbols
= NULL
;
2729 /* Iterate over all the types, looking for the names of existing
2730 methods matching METHOD_NAME. If we cannot find a direct method in a
2731 given program space, then we consider inherited methods; this is
2732 not ideal (ideal would be to respect C++ hiding rules), but it
2733 seems good enough and is what GDB has historically done. We only
2734 need to collect the names because later we find all symbols with
2735 those names. This loop is written in a somewhat funny way
2736 because we collect data across the program space before deciding
2738 superclass_vec
= NULL
;
2739 make_cleanup (VEC_cleanup (typep
), &superclass_vec
);
2740 result_names
= NULL
;
2741 make_cleanup (VEC_cleanup (const_char_ptr
), &result_names
);
2742 last_result_len
= 0;
2743 for (ix
= 0; VEC_iterate (symbolp
, sym_classes
, ix
, sym
); ++ix
)
2746 struct program_space
*pspace
;
2748 /* Program spaces that are executing startup should have
2749 been filtered out earlier. */
2750 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
))->executing_startup
);
2751 pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2752 set_current_program_space (pspace
);
2753 t
= check_typedef (SYMBOL_TYPE (sym
));
2754 find_methods (t
, method_name
, &result_names
, &superclass_vec
);
2756 /* Handle all items from a single program space at once; and be
2757 sure not to miss the last batch. */
2758 if (ix
== VEC_length (symbolp
, sym_classes
) - 1
2760 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp
, sym_classes
,
2763 /* If we did not find a direct implementation anywhere in
2764 this program space, consider superclasses. */
2765 if (VEC_length (const_char_ptr
, result_names
) == last_result_len
)
2766 find_superclass_methods (superclass_vec
, method_name
,
2769 /* We have a list of candidate symbol names, so now we
2770 iterate over the symbol tables looking for all
2771 matches in this pspace. */
2772 add_all_symbol_names_from_pspace (&info
, pspace
, result_names
);
2774 VEC_truncate (typep
, superclass_vec
, 0);
2775 last_result_len
= VEC_length (const_char_ptr
, result_names
);
2779 if (!VEC_empty (symbolp
, info
.result
.symbols
)
2780 || !VEC_empty (minsym_and_objfile_d
, info
.result
.minimal_symbols
))
2782 *symbols
= info
.result
.symbols
;
2783 *minsyms
= info
.result
.minimal_symbols
;
2784 do_cleanups (cleanup
);
2788 /* Throw an NOT_FOUND_ERROR. This will be caught by the caller
2789 and other attempts to locate the symbol will be made. */
2790 throw_error (NOT_FOUND_ERROR
, _("see caller, this text doesn't matter"));
2795 /* This object is used when collecting all matching symtabs. */
2797 struct symtab_collector
2799 /* The result vector of symtabs. */
2800 VEC (symtab_p
) *symtabs
;
2802 /* This is used to ensure the symtabs are unique. */
2803 htab_t symtab_table
;
2806 /* Callback for iterate_over_symtabs. */
2809 add_symtabs_to_list (struct symtab
*symtab
, void *d
)
2811 struct symtab_collector
*data
= d
;
2814 slot
= htab_find_slot (data
->symtab_table
, symtab
, INSERT
);
2818 VEC_safe_push (symtab_p
, data
->symtabs
, symtab
);
2824 /* Given a file name, return a VEC of all matching symtabs. */
2826 static VEC (symtab_p
) *
2827 collect_symtabs_from_filename (const char *file
)
2829 struct symtab_collector collector
;
2830 struct cleanup
*cleanups
;
2831 struct program_space
*pspace
;
2833 collector
.symtabs
= NULL
;
2834 collector
.symtab_table
= htab_create (1, htab_hash_pointer
, htab_eq_pointer
,
2836 cleanups
= make_cleanup_htab_delete (collector
.symtab_table
);
2838 /* Find that file's data. */
2839 ALL_PSPACES (pspace
)
2841 if (pspace
->executing_startup
)
2844 set_current_program_space (pspace
);
2845 iterate_over_symtabs (file
, add_symtabs_to_list
, &collector
);
2848 do_cleanups (cleanups
);
2849 return collector
.symtabs
;
2852 /* Return all the symtabs associated to the FILENAME. */
2854 static VEC (symtab_p
) *
2855 symtabs_from_filename (const char *filename
)
2857 VEC (symtab_p
) *result
;
2859 result
= collect_symtabs_from_filename (filename
);
2861 if (VEC_empty (symtab_p
, result
))
2863 if (!have_full_symbols () && !have_partial_symbols ())
2864 throw_error (NOT_FOUND_ERROR
,
2865 _("No symbol table is loaded. "
2866 "Use the \"file\" command."));
2867 throw_error (NOT_FOUND_ERROR
, _("No source file named %s."), filename
);
2873 /* Look up a function symbol named NAME in symtabs FILE_SYMTABS. Matching
2874 debug symbols are returned in SYMBOLS. Matching minimal symbols are
2875 returned in MINSYMS. */
2878 find_function_symbols (struct linespec_state
*state
,
2879 VEC (symtab_p
) *file_symtabs
, const char *name
,
2880 VEC (symbolp
) **symbols
,
2881 VEC (minsym_and_objfile_d
) **minsyms
)
2883 struct collect_info info
;
2884 VEC (const_char_ptr
) *symbol_names
= NULL
;
2885 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (const_char_ptr
),
2889 info
.result
.symbols
= NULL
;
2890 info
.result
.minimal_symbols
= NULL
;
2891 info
.file_symtabs
= file_symtabs
;
2893 /* Try NAME as an Objective-C selector. */
2894 find_imps ((char *) name
, &symbol_names
);
2895 if (!VEC_empty (const_char_ptr
, symbol_names
))
2896 add_all_symbol_names_from_pspace (&info
, NULL
, symbol_names
);
2898 add_matching_symbols_to_info (name
, &info
, NULL
);
2900 do_cleanups (cleanup
);
2902 if (VEC_empty (symbolp
, info
.result
.symbols
))
2904 VEC_free (symbolp
, info
.result
.symbols
);
2908 *symbols
= info
.result
.symbols
;
2910 if (VEC_empty (minsym_and_objfile_d
, info
.result
.minimal_symbols
))
2912 VEC_free (minsym_and_objfile_d
, info
.result
.minimal_symbols
);
2916 *minsyms
= info
.result
.minimal_symbols
;
2919 /* Find all symbols named NAME in FILE_SYMTABS, returning debug symbols
2920 in SYMBOLS and minimal symbols in MINSYMS. */
2923 find_linespec_symbols (struct linespec_state
*state
,
2924 VEC (symtab_p
) *file_symtabs
,
2926 VEC (symbolp
) **symbols
,
2927 VEC (minsym_and_objfile_d
) **minsyms
)
2929 char *klass
, *method
, *canon
;
2930 const char *lookup_name
, *last
, *p
, *scope_op
;
2931 struct cleanup
*cleanup
;
2932 VEC (symbolp
) *classes
;
2933 volatile struct gdb_exception except
;
2935 cleanup
= demangle_for_lookup (name
, state
->language
->la_language
,
2937 if (state
->language
->la_language
== language_ada
)
2939 /* In Ada, the symbol lookups are performed using the encoded
2940 name rather than the demangled name. */
2941 lookup_name
= ada_name_for_lookup (name
);
2942 make_cleanup (xfree
, (void *) lookup_name
);
2945 canon
= cp_canonicalize_string_no_typedefs (lookup_name
);
2948 lookup_name
= canon
;
2949 cleanup
= make_cleanup (xfree
, canon
);
2952 /* See if we can find a scope operator and break this symbol
2953 name into namespaces${SCOPE_OPERATOR}class_name and method_name. */
2955 p
= find_toplevel_string (lookup_name
, scope_op
);
2958 /* No C++ scope operator. Try Java. */
2960 p
= find_toplevel_string (lookup_name
, scope_op
);
2967 p
= find_toplevel_string (p
+ strlen (scope_op
), scope_op
);
2970 /* If no scope operator was found, lookup the name as a symbol. */
2973 find_function_symbols (state
, file_symtabs
, lookup_name
,
2975 do_cleanups (cleanup
);
2979 /* NAME points to the class name.
2980 LAST points to the method name. */
2981 klass
= xmalloc ((last
- lookup_name
+ 1) * sizeof (char));
2982 make_cleanup (xfree
, klass
);
2983 strncpy (klass
, lookup_name
, last
- lookup_name
);
2984 klass
[last
- lookup_name
] = '\0';
2986 /* Skip past the scope operator. */
2987 last
+= strlen (scope_op
);
2988 method
= xmalloc ((strlen (last
) + 1) * sizeof (char));
2989 make_cleanup (xfree
, method
);
2990 strcpy (method
, last
);
2992 /* Find a list of classes named KLASS. */
2993 classes
= lookup_prefix_sym (state
, file_symtabs
, klass
);
2994 make_cleanup (VEC_cleanup (symbolp
), &classes
);
2995 if (!VEC_empty (symbolp
, classes
))
2997 /* Now locate a list of suitable methods named METHOD. */
2998 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3000 find_method (state
, file_symtabs
, klass
, method
, classes
,
3004 /* If successful, we're done. If NOT_FOUND_ERROR
3005 was not thrown, rethrow the exception that we did get.
3006 Otherwise, fall back to looking up the entire name as a symbol.
3007 This can happen with namespace::function. */
3008 if (except
.reason
>= 0)
3010 do_cleanups (cleanup
);
3013 else if (except
.error
!= NOT_FOUND_ERROR
)
3014 throw_exception (except
);
3017 /* We couldn't find a class, so we check the entire name as a symbol
3019 find_function_symbols (state
, file_symtabs
, lookup_name
, symbols
, minsyms
);
3020 do_cleanups (cleanup
);
3023 /* Return all labels named NAME in FUNCTION_SYMBOLS. Return the
3024 actual function symbol in which the label was found in LABEL_FUNC_RET. */
3026 static VEC (symbolp
) *
3027 find_label_symbols (struct linespec_state
*self
,
3028 VEC (symbolp
) *function_symbols
,
3029 VEC (symbolp
) **label_funcs_ret
, const char *name
)
3032 struct block
*block
;
3034 struct symbol
*fn_sym
;
3035 VEC (symbolp
) *result
= NULL
;
3037 if (function_symbols
== NULL
)
3039 set_current_program_space (self
->program_space
);
3040 block
= get_search_block (NULL
);
3043 block
&& !BLOCK_FUNCTION (block
);
3044 block
= BLOCK_SUPERBLOCK (block
))
3048 fn_sym
= BLOCK_FUNCTION (block
);
3050 sym
= lookup_symbol (name
, block
, LABEL_DOMAIN
, 0);
3054 VEC_safe_push (symbolp
, result
, sym
);
3055 VEC_safe_push (symbolp
, *label_funcs_ret
, fn_sym
);
3061 VEC_iterate (symbolp
, function_symbols
, ix
, fn_sym
); ++ix
)
3063 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym
)));
3064 block
= SYMBOL_BLOCK_VALUE (fn_sym
);
3065 sym
= lookup_symbol (name
, block
, LABEL_DOMAIN
, 0);
3069 VEC_safe_push (symbolp
, result
, sym
);
3070 VEC_safe_push (symbolp
, *label_funcs_ret
, fn_sym
);
3080 /* A helper for create_sals_line_offset that handles the 'list_mode' case. */
3083 decode_digits_list_mode (struct linespec_state
*self
,
3085 struct symtabs_and_lines
*values
,
3086 struct symtab_and_line val
)
3091 gdb_assert (self
->list_mode
);
3093 for (ix
= 0; VEC_iterate (symtab_p
, ls
->file_symtabs
, ix
, elt
);
3096 /* The logic above should ensure this. */
3097 gdb_assert (elt
!= NULL
);
3099 set_current_program_space (SYMTAB_PSPACE (elt
));
3101 /* Simplistic search just for the list command. */
3102 val
.symtab
= find_line_symtab (elt
, val
.line
, NULL
, NULL
);
3103 if (val
.symtab
== NULL
)
3105 val
.pspace
= SYMTAB_PSPACE (elt
);
3107 val
.explicit_line
= 1;
3109 add_sal_to_sals (self
, values
, &val
, NULL
);
3113 /* A helper for create_sals_line_offset that iterates over the symtabs,
3114 adding lines to the VEC. */
3117 decode_digits_ordinary (struct linespec_state
*self
,
3120 struct symtabs_and_lines
*sals
,
3121 struct linetable_entry
**best_entry
)
3126 for (ix
= 0; VEC_iterate (symtab_p
, ls
->file_symtabs
, ix
, elt
); ++ix
)
3129 VEC (CORE_ADDR
) *pcs
;
3132 /* The logic above should ensure this. */
3133 gdb_assert (elt
!= NULL
);
3135 set_current_program_space (SYMTAB_PSPACE (elt
));
3137 pcs
= find_pcs_for_symtab_line (elt
, line
, best_entry
);
3138 for (i
= 0; VEC_iterate (CORE_ADDR
, pcs
, i
, pc
); ++i
)
3140 struct symtab_and_line sal
;
3143 sal
.pspace
= SYMTAB_PSPACE (elt
);
3147 add_sal_to_sals_basic (sals
, &sal
);
3150 VEC_free (CORE_ADDR
, pcs
);
3156 /* Return the line offset represented by VARIABLE. */
3158 static struct line_offset
3159 linespec_parse_variable (struct linespec_state
*self
, const char *variable
)
3163 struct line_offset offset
= {0, LINE_OFFSET_NONE
};
3165 p
= (variable
[1] == '$') ? variable
+ 2 : variable
+ 1;
3168 while (*p
>= '0' && *p
<= '9')
3170 if (!*p
) /* Reached end of token without hitting non-digit. */
3172 /* We have a value history reference. */
3173 struct value
*val_history
;
3175 sscanf ((variable
[1] == '$') ? variable
+ 2 : variable
+ 1, "%d", &index
);
3177 = access_value_history ((variable
[1] == '$') ? -index
: index
);
3178 if (TYPE_CODE (value_type (val_history
)) != TYPE_CODE_INT
)
3179 error (_("History values used in line "
3180 "specs must have integer values."));
3181 offset
.offset
= value_as_long (val_history
);
3185 /* Not all digits -- may be user variable/function or a
3186 convenience variable. */
3188 struct internalvar
*ivar
;
3190 /* Try it as a convenience variable. If it is not a convenience
3191 variable, return and allow normal symbol lookup to occur. */
3192 ivar
= lookup_only_internalvar (variable
+ 1);
3194 /* No internal variable with that name. Mark the offset
3195 as unknown to allow the name to be looked up as a symbol. */
3196 offset
.sign
= LINE_OFFSET_UNKNOWN
;
3199 /* We found a valid variable name. If it is not an integer,
3201 if (!get_internalvar_integer (ivar
, &valx
))
3202 error (_("Convenience variables used in line "
3203 "specs must have integer values."));
3205 offset
.offset
= valx
;
3213 /* A callback used to possibly add a symbol to the results. */
3216 collect_symbols (struct symbol
*sym
, void *data
)
3218 struct collect_info
*info
= data
;
3220 /* In list mode, add all matching symbols, regardless of class.
3221 This allows the user to type "list a_global_variable". */
3222 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
|| info
->state
->list_mode
)
3223 VEC_safe_push (symbolp
, info
->result
.symbols
, sym
);
3224 return 1; /* Continue iterating. */
3227 /* We've found a minimal symbol MSYMBOL in OBJFILE to associate with our
3228 linespec; return the SAL in RESULT. */
3231 minsym_found (struct linespec_state
*self
, struct objfile
*objfile
,
3232 struct minimal_symbol
*msymbol
,
3233 struct symtabs_and_lines
*result
)
3235 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3237 struct symtab_and_line sal
;
3239 sal
= find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
3240 (struct obj_section
*) 0, 0);
3241 sal
.section
= SYMBOL_OBJ_SECTION (msymbol
);
3243 /* The minimal symbol might point to a function descriptor;
3244 resolve it to the actual code address instead. */
3245 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, sal
.pc
, ¤t_target
);
3247 sal
= find_pc_sect_line (pc
, NULL
, 0);
3249 if (self
->funfirstline
)
3250 skip_prologue_sal (&sal
);
3252 if (maybe_add_address (self
->addr_set
, objfile
->pspace
, sal
.pc
))
3253 add_sal_to_sals (self
, result
, &sal
, SYMBOL_NATURAL_NAME (msymbol
));
3256 /* A helper struct to pass some data through
3257 iterate_over_minimal_symbols. */
3259 struct collect_minsyms
3261 /* The objfile we're examining. */
3262 struct objfile
*objfile
;
3264 /* The funfirstline setting from the initial call. */
3267 /* The list_mode setting from the initial call. */
3270 /* The resulting symbols. */
3271 VEC (minsym_and_objfile_d
) *msyms
;
3274 /* A helper function to classify a minimal_symbol_type according to
3278 classify_mtype (enum minimal_symbol_type t
)
3285 /* Intermediate priority. */
3288 case mst_solib_trampoline
:
3289 /* Lowest priority. */
3293 /* Highest priority. */
3298 /* Callback for qsort that sorts symbols by priority. */
3301 compare_msyms (const void *a
, const void *b
)
3303 const minsym_and_objfile_d
*moa
= a
;
3304 const minsym_and_objfile_d
*mob
= b
;
3305 enum minimal_symbol_type ta
= MSYMBOL_TYPE (moa
->minsym
);
3306 enum minimal_symbol_type tb
= MSYMBOL_TYPE (mob
->minsym
);
3308 return classify_mtype (ta
) - classify_mtype (tb
);
3311 /* Callback for iterate_over_minimal_symbols that adds the symbol to
3315 add_minsym (struct minimal_symbol
*minsym
, void *d
)
3317 struct collect_minsyms
*info
= d
;
3318 minsym_and_objfile_d mo
;
3320 /* Exclude data symbols when looking for breakpoint locations. */
3321 if (!info
->list_mode
)
3322 switch (minsym
->type
)
3324 case mst_slot_got_plt
:
3331 /* Make sure this minsym is not a function descriptor
3332 before we decide to discard it. */
3333 struct gdbarch
*gdbarch
= info
->objfile
->gdbarch
;
3334 CORE_ADDR addr
= gdbarch_convert_from_func_ptr_addr
3335 (gdbarch
, SYMBOL_VALUE_ADDRESS (minsym
),
3338 if (addr
== SYMBOL_VALUE_ADDRESS (minsym
))
3344 mo
.objfile
= info
->objfile
;
3345 VEC_safe_push (minsym_and_objfile_d
, info
->msyms
, &mo
);
3348 /* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
3349 is not NULL, the search is restricted to just that program
3353 search_minsyms_for_name (struct collect_info
*info
, const char *name
,
3354 struct program_space
*search_pspace
)
3356 struct objfile
*objfile
;
3357 struct program_space
*pspace
;
3359 ALL_PSPACES (pspace
)
3361 struct collect_minsyms local
;
3362 struct cleanup
*cleanup
;
3364 if (search_pspace
!= NULL
&& search_pspace
!= pspace
)
3366 if (pspace
->executing_startup
)
3369 set_current_program_space (pspace
);
3371 memset (&local
, 0, sizeof (local
));
3372 local
.funfirstline
= info
->state
->funfirstline
;
3373 local
.list_mode
= info
->state
->list_mode
;
3375 cleanup
= make_cleanup (VEC_cleanup (minsym_and_objfile_d
),
3378 ALL_OBJFILES (objfile
)
3380 local
.objfile
= objfile
;
3381 iterate_over_minimal_symbols (objfile
, name
, add_minsym
, &local
);
3384 if (!VEC_empty (minsym_and_objfile_d
, local
.msyms
))
3388 minsym_and_objfile_d
*item
;
3390 qsort (VEC_address (minsym_and_objfile_d
, local
.msyms
),
3391 VEC_length (minsym_and_objfile_d
, local
.msyms
),
3392 sizeof (minsym_and_objfile_d
),
3395 /* Now the minsyms are in classification order. So, we walk
3396 over them and process just the minsyms with the same
3397 classification as the very first minsym in the list. */
3398 item
= VEC_index (minsym_and_objfile_d
, local
.msyms
, 0);
3399 classification
= classify_mtype (MSYMBOL_TYPE (item
->minsym
));
3402 VEC_iterate (minsym_and_objfile_d
, local
.msyms
, ix
, item
);
3405 if (classify_mtype (MSYMBOL_TYPE (item
->minsym
)) != classification
)
3408 VEC_safe_push (minsym_and_objfile_d
,
3409 info
->result
.minimal_symbols
, item
);
3413 do_cleanups (cleanup
);
3417 /* A helper function to add all symbols matching NAME to INFO. If
3418 PSPACE is not NULL, the search is restricted to just that program
3422 add_matching_symbols_to_info (const char *name
,
3423 struct collect_info
*info
,
3424 struct program_space
*pspace
)
3429 for (ix
= 0; VEC_iterate (symtab_p
, info
->file_symtabs
, ix
, elt
); ++ix
)
3433 iterate_over_all_matching_symtabs (info
->state
, name
, VAR_DOMAIN
,
3434 collect_symbols
, info
,
3436 search_minsyms_for_name (info
, name
, pspace
);
3438 else if (pspace
== NULL
|| pspace
== SYMTAB_PSPACE (elt
))
3440 /* Program spaces that are executing startup should have
3441 been filtered out earlier. */
3442 gdb_assert (!SYMTAB_PSPACE (elt
)->executing_startup
);
3443 set_current_program_space (SYMTAB_PSPACE (elt
));
3444 LA_ITERATE_OVER_SYMBOLS (get_search_block (elt
), name
,
3445 VAR_DOMAIN
, collect_symbols
,
3453 /* Now come some functions that are called from multiple places within
3457 symbol_to_sal (struct symtab_and_line
*result
,
3458 int funfirstline
, struct symbol
*sym
)
3460 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3462 *result
= find_function_start_sal (sym
, funfirstline
);
3467 if (SYMBOL_CLASS (sym
) == LOC_LABEL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
3470 result
->symtab
= SYMBOL_SYMTAB (sym
);
3471 result
->line
= SYMBOL_LINE (sym
);
3472 result
->pc
= SYMBOL_VALUE_ADDRESS (sym
);
3473 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3474 result
->explicit_pc
= 1;
3477 else if (funfirstline
)
3481 else if (SYMBOL_LINE (sym
) != 0)
3483 /* We know its line number. */
3485 result
->symtab
= SYMBOL_SYMTAB (sym
);
3486 result
->line
= SYMBOL_LINE (sym
);
3487 result
->pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
3495 /* See the comment in linespec.h. */
3498 init_linespec_result (struct linespec_result
*lr
)
3500 memset (lr
, 0, sizeof (*lr
));
3503 /* See the comment in linespec.h. */
3506 destroy_linespec_result (struct linespec_result
*ls
)
3509 struct linespec_sals
*lsal
;
3511 xfree (ls
->addr_string
);
3512 for (i
= 0; VEC_iterate (linespec_sals
, ls
->sals
, i
, lsal
); ++i
)
3514 xfree (lsal
->canonical
);
3515 xfree (lsal
->sals
.sals
);
3517 VEC_free (linespec_sals
, ls
->sals
);
3520 /* Cleanup function for a linespec_result. */
3523 cleanup_linespec_result (void *a
)
3525 destroy_linespec_result (a
);
3528 /* See the comment in linespec.h. */
3531 make_cleanup_destroy_linespec_result (struct linespec_result
*ls
)
3533 return make_cleanup (cleanup_linespec_result
, ls
);