Change find_pcs_for_symtab_line to return a std::vector
[deliverable/binutils-gdb.git] / gdb / linespec.c
CommitLineData
50641945 1/* Parser for linespec for the GNU debugger, GDB.
05ff989b 2
61baf725 3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
50641945
FN
4
5 This file is part of GDB.
6
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
50641945
FN
10 (at your option) any later version.
11
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.
16
17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
50641945
FN
19
20#include "defs.h"
21#include "symtab.h"
c5f0f3d0
FN
22#include "frame.h"
23#include "command.h"
50641945
FN
24#include "symfile.h"
25#include "objfiles.h"
0378c332 26#include "source.h"
50641945 27#include "demangle.h"
c5f0f3d0
FN
28#include "value.h"
29#include "completer.h"
015a42b4 30#include "cp-abi.h"
12907978 31#include "cp-support.h"
c38da1af 32#include "parser-defs.h"
fe898f56 33#include "block.h"
d2630e69 34#include "objc-lang.h"
b9362cc7 35#include "linespec.h"
53c5240f 36#include "language.h"
dc67126b
NR
37#include "interps.h"
38#include "mi/mi-cmds.h"
bccdca4a 39#include "target.h"
94af9270 40#include "arch-utils.h"
c00f8484
KS
41#include <ctype.h>
42#include "cli/cli-utils.h"
731971ed 43#include "filenames.h"
f8eba3c6 44#include "ada-lang.h"
39cf75f7 45#include "stack.h"
f00aae0f 46#include "location.h"
14bc53a8 47#include "common/function-view.h"
f8eba3c6 48
f8eba3c6
TT
49typedef struct symbol *symbolp;
50DEF_VEC_P (symbolp);
51
52typedef struct type *typep;
53DEF_VEC_P (typep);
54
55/* An address entry is used to ensure that any given location is only
56 added to the result a single time. It holds an address and the
57 program space from which the address came. */
58
59struct address_entry
60{
61 struct program_space *pspace;
62 CORE_ADDR addr;
63};
64
f60e2d5c 65typedef struct bound_minimal_symbol bound_minimal_symbol_d;
40e084e1 66
f60e2d5c 67DEF_VEC_O (bound_minimal_symbol_d);
40e084e1 68
40e084e1
KS
69/* A linespec. Elements of this structure are filled in by a parser
70 (either parse_linespec or some other function). The structure is
71 then converted into SALs by convert_linespec_to_sals. */
72
73struct linespec
74{
00e52e53 75 /* An explicit location describing the SaLs. */
67994074 76 struct explicit_location explicit_loc;
40e084e1
KS
77
78 /* The list of symtabs to search to which to limit the search. May not
00e52e53
KS
79 be NULL. If explicit.SOURCE_FILENAME is NULL (no user-specified
80 filename), FILE_SYMTABS should contain one single NULL member. This
81 will cause the code to use the default symtab. */
ec94af83 82 VEC (symtab_ptr) *file_symtabs;
40e084e1 83
40e084e1
KS
84 /* A list of matching function symbols and minimal symbols. Both lists
85 may be NULL if no matching symbols were found. */
86 VEC (symbolp) *function_symbols;
f60e2d5c 87 VEC (bound_minimal_symbol_d) *minimal_symbols;
40e084e1 88
40e084e1
KS
89 /* A structure of matching label symbols and the corresponding
90 function symbol in which the label was found. Both may be NULL
91 or both must be non-NULL. */
92 struct
93 {
94 VEC (symbolp) *label_symbols;
95 VEC (symbolp) *function_symbols;
96 } labels;
40e084e1
KS
97};
98typedef struct linespec *linespec_p;
99
33f448b1
JK
100/* A canonical linespec represented as a symtab-related string.
101
102 Each entry represents the "SYMTAB:SUFFIX" linespec string.
103 SYMTAB can be converted for example by symtab_to_fullname or
104 symtab_to_filename_for_display as needed. */
105
106struct linespec_canonical_name
107{
108 /* Remaining text part of the linespec string. */
109 char *suffix;
110
111 /* If NULL then SUFFIX is the whole linespec string. */
112 struct symtab *symtab;
113};
114
f8eba3c6
TT
115/* An instance of this is used to keep all state while linespec
116 operates. This instance is passed around as a 'this' pointer to
117 the various implementation methods. */
118
119struct linespec_state
120{
40e084e1
KS
121 /* The language in use during linespec processing. */
122 const struct language_defn *language;
123
f8eba3c6
TT
124 /* The program space as seen when the module was entered. */
125 struct program_space *program_space;
126
c2f4122d
PA
127 /* If not NULL, the search is restricted to just this program
128 space. */
129 struct program_space *search_pspace;
130
f8eba3c6
TT
131 /* The default symtab to use, if no other symtab is specified. */
132 struct symtab *default_symtab;
133
134 /* The default line to use. */
135 int default_line;
136
f8eba3c6
TT
137 /* The 'funfirstline' value that was passed in to decode_line_1 or
138 decode_line_full. */
139 int funfirstline;
140
141 /* Nonzero if we are running in 'list' mode; see decode_line_list. */
142 int list_mode;
143
144 /* The 'canonical' value passed to decode_line_full, or NULL. */
145 struct linespec_result *canonical;
146
147 /* Canonical strings that mirror the symtabs_and_lines result. */
33f448b1 148 struct linespec_canonical_name *canonical_names;
f8eba3c6
TT
149
150 /* This is a set of address_entry objects which is used to prevent
151 duplicate symbols from being entered into the result. */
152 htab_t addr_set;
00e52e53
KS
153
154 /* Are we building a linespec? */
155 int is_linespec;
f8eba3c6
TT
156};
157
158/* This is a helper object that is used when collecting symbols into a
159 result. */
160
161struct collect_info
162{
163 /* The linespec object in use. */
164 struct linespec_state *state;
165
40e084e1 166 /* A list of symtabs to which to restrict matches. */
ec94af83 167 VEC (symtab_ptr) *file_symtabs;
40e084e1 168
f8eba3c6 169 /* The result being accumulated. */
40e084e1
KS
170 struct
171 {
172 VEC (symbolp) *symbols;
f60e2d5c 173 VEC (bound_minimal_symbol_d) *minimal_symbols;
40e084e1 174 } result;
14bc53a8
PA
175
176 /* Possibly add a symbol to the results. */
177 bool add_symbol (symbol *sym);
f8eba3c6 178};
50641945 179
14bc53a8
PA
180bool
181collect_info::add_symbol (symbol *sym)
182{
183 /* In list mode, add all matching symbols, regardless of class.
184 This allows the user to type "list a_global_variable". */
185 if (SYMBOL_CLASS (sym) == LOC_BLOCK || this->state->list_mode)
186 VEC_safe_push (symbolp, this->result.symbols, sym);
187
188 /* Continue iterating. */
189 return true;
190}
191
40e084e1 192/* Token types */
50641945 193
40e084e1
KS
194enum ls_token_type
195{
196 /* A keyword */
197 LSTOKEN_KEYWORD = 0,
44fe14ab 198
40e084e1
KS
199 /* A colon "separator" */
200 LSTOKEN_COLON,
44fe14ab 201
40e084e1
KS
202 /* A string */
203 LSTOKEN_STRING,
0960f083 204
40e084e1
KS
205 /* A number */
206 LSTOKEN_NUMBER,
207
208 /* A comma */
209 LSTOKEN_COMMA,
210
211 /* EOI (end of input) */
212 LSTOKEN_EOI,
213
214 /* Consumed token */
215 LSTOKEN_CONSUMED
216};
217typedef enum ls_token_type linespec_token_type;
218
219/* List of keywords */
220
221static const char * const linespec_keywords[] = { "if", "thread", "task" };
0578b14e 222#define IF_KEYWORD_INDEX 0
40e084e1
KS
223
224/* A token of the linespec lexer */
225
226struct ls_token
227{
228 /* The type of the token */
229 linespec_token_type type;
230
231 /* Data for the token */
232 union
233 {
234 /* A string, given as a stoken */
235 struct stoken string;
236
237 /* A keyword */
238 const char *keyword;
239 } data;
240};
241typedef struct ls_token linespec_token;
242
243#define LS_TOKEN_STOKEN(TOK) (TOK).data.string
244#define LS_TOKEN_KEYWORD(TOK) (TOK).data.keyword
245
246/* An instance of the linespec parser. */
247
248struct ls_parser
249{
250 /* Lexer internal data */
251 struct
252 {
253 /* Save head of input stream. */
d7561cbb 254 const char *saved_arg;
d2630e69 255
40e084e1 256 /* Head of the input stream. */
f00aae0f
KS
257 const char *stream;
258#define PARSER_STREAM(P) ((P)->lexer.stream)
614b3b14 259
40e084e1
KS
260 /* The current token. */
261 linespec_token current;
262 } lexer;
93d91629 263
40e084e1
KS
264 /* Is the entire linespec quote-enclosed? */
265 int is_quote_enclosed;
266
267 /* The state of the parse. */
268 struct linespec_state state;
269#define PARSER_STATE(PPTR) (&(PPTR)->state)
4224873a 270
40e084e1
KS
271 /* The result of the parse. */
272 struct linespec result;
273#define PARSER_RESULT(PPTR) (&(PPTR)->result)
274};
275typedef struct ls_parser linespec_parser;
50641945 276
00e52e53
KS
277/* A convenience macro for accessing the explicit location result of
278 the parser. */
67994074 279#define PARSER_EXPLICIT(PPTR) (&PARSER_RESULT ((PPTR))->explicit_loc)
00e52e53 280
40e084e1 281/* Prototypes for local functions. */
50641945 282
14bc53a8
PA
283static void iterate_over_file_blocks
284 (struct symtab *symtab, const char *name, domain_enum domain,
285 gdb::function_view<symbol_found_callback_ftype> callback);
4eeaa230 286
40e084e1
KS
287static void initialize_defaults (struct symtab **default_symtab,
288 int *default_line);
50641945 289
a06efdd6 290CORE_ADDR linespec_expression_to_pc (const char **exp_ptr);
aee8d8ba 291
40e084e1
KS
292static struct symtabs_and_lines decode_objc (struct linespec_state *self,
293 linespec_p ls,
f00aae0f 294 const char *arg);
aee8d8ba 295
c2f4122d
PA
296static VEC (symtab_ptr) *symtabs_from_filename (const char *,
297 struct program_space *pspace);
50641945 298
40e084e1
KS
299static VEC (symbolp) *find_label_symbols (struct linespec_state *self,
300 VEC (symbolp) *function_symbols,
301 VEC (symbolp) **label_funcs_ret,
302 const char *name);
50641945 303
b1ae631a 304static void find_linespec_symbols (struct linespec_state *self,
ec94af83 305 VEC (symtab_ptr) *file_symtabs,
b1ae631a
DE
306 const char *name,
307 VEC (symbolp) **symbols,
f60e2d5c 308 VEC (bound_minimal_symbol_d) **minsyms);
f8eba3c6 309
40e084e1
KS
310static struct line_offset
311 linespec_parse_variable (struct linespec_state *self,
312 const char *variable);
889f28e2 313
f8eba3c6
TT
314static int symbol_to_sal (struct symtab_and_line *result,
315 int funfirstline, struct symbol *sym);
50641945 316
f8eba3c6
TT
317static void add_matching_symbols_to_info (const char *name,
318 struct collect_info *info,
319 struct program_space *pspace);
f3c39e76 320
f8eba3c6
TT
321static void add_all_symbol_names_from_pspace (struct collect_info *info,
322 struct program_space *pspace,
323 VEC (const_char_ptr) *names);
9ef07c8c 324
c2f4122d
PA
325static VEC (symtab_ptr) *
326 collect_symtabs_from_filename (const char *file,
327 struct program_space *pspace);
84fba31b 328
40e084e1
KS
329static void decode_digits_ordinary (struct linespec_state *self,
330 linespec_p ls,
331 int line,
332 struct symtabs_and_lines *sals,
333 struct linetable_entry **best_entry);
14e91ac5 334
40e084e1
KS
335static void decode_digits_list_mode (struct linespec_state *self,
336 linespec_p ls,
337 struct symtabs_and_lines *values,
338 struct symtab_and_line val);
0f5238ed 339
40e084e1
KS
340static void minsym_found (struct linespec_state *self, struct objfile *objfile,
341 struct minimal_symbol *msymbol,
342 struct symtabs_and_lines *result);
bca02a8a 343
40e084e1 344static int compare_symbols (const void *a, const void *b);
413dad4d 345
40e084e1 346static int compare_msymbols (const void *a, const void *b);
413dad4d 347
40e084e1
KS
348/* Permitted quote characters for the parser. This is different from the
349 completer's quote characters to allow backward compatibility with the
350 previous parser. */
351static const char *const linespec_quote_characters = "\"\'";
f8eba3c6 352
40e084e1
KS
353/* Lexer functions. */
354
355/* Lex a number from the input in PARSER. This only supports
dd3818c8
KS
356 decimal numbers.
357
d7cbec71 358 Return true if input is decimal numbers. Return false if not. */
40e084e1 359
d7cbec71
HZ
360static int
361linespec_lexer_lex_number (linespec_parser *parser, linespec_token *tokenp)
40e084e1 362{
d7cbec71
HZ
363 tokenp->type = LSTOKEN_NUMBER;
364 LS_TOKEN_STOKEN (*tokenp).length = 0;
365 LS_TOKEN_STOKEN (*tokenp).ptr = PARSER_STREAM (parser);
40e084e1
KS
366
367 /* Keep any sign at the start of the stream. */
368 if (*PARSER_STREAM (parser) == '+' || *PARSER_STREAM (parser) == '-')
369 {
d7cbec71 370 ++LS_TOKEN_STOKEN (*tokenp).length;
40e084e1
KS
371 ++(PARSER_STREAM (parser));
372 }
373
374 while (isdigit (*PARSER_STREAM (parser)))
375 {
d7cbec71 376 ++LS_TOKEN_STOKEN (*tokenp).length;
40e084e1 377 ++(PARSER_STREAM (parser));
f8eba3c6 378 }
40e084e1 379
dd3818c8 380 /* If the next character in the input buffer is not a space, comma,
eff9c3e6 381 quote, or colon, this input does not represent a number. */
dd3818c8
KS
382 if (*PARSER_STREAM (parser) != '\0'
383 && !isspace (*PARSER_STREAM (parser)) && *PARSER_STREAM (parser) != ','
eff9c3e6
KS
384 && *PARSER_STREAM (parser) != ':'
385 && !strchr (linespec_quote_characters, *PARSER_STREAM (parser)))
d7cbec71
HZ
386 {
387 PARSER_STREAM (parser) = LS_TOKEN_STOKEN (*tokenp).ptr;
388 return 0;
389 }
390
391 return 1;
f8eba3c6
TT
392}
393
32b40af9 394/* See linespec.h. */
f8eba3c6 395
0578b14e 396const char *
40e084e1 397linespec_lexer_lex_keyword (const char *p)
f8eba3c6 398{
40e084e1 399 int i;
f8eba3c6 400
40e084e1
KS
401 if (p != NULL)
402 {
403 for (i = 0; i < ARRAY_SIZE (linespec_keywords); ++i)
404 {
405 int len = strlen (linespec_keywords[i]);
406
407 /* If P begins with one of the keywords and the next
0578b14e
KS
408 character is whitespace, we may have found a keyword.
409 It is only a keyword if it is not followed by another
410 keyword. */
40e084e1 411 if (strncmp (p, linespec_keywords[i], len) == 0
0578b14e
KS
412 && isspace (p[len]))
413 {
414 int j;
415
416 /* Special case: "if" ALWAYS stops the lexer, since it
417 is not possible to predict what is going to appear in
418 the condition, which can only be parsed after SaLs have
419 been found. */
420 if (i != IF_KEYWORD_INDEX)
421 {
422 p += len;
423 p = skip_spaces_const (p);
424 for (j = 0; j < ARRAY_SIZE (linespec_keywords); ++j)
425 {
426 int nextlen = strlen (linespec_keywords[j]);
427
428 if (strncmp (p, linespec_keywords[j], nextlen) == 0
429 && isspace (p[nextlen]))
430 return NULL;
431 }
432 }
433
434 return linespec_keywords[i];
435 }
40e084e1
KS
436 }
437 }
438
439 return NULL;
f8eba3c6
TT
440}
441
87f0e720 442/* See description in linespec.h. */
f8eba3c6 443
87f0e720 444int
40e084e1 445is_ada_operator (const char *string)
f8eba3c6 446{
40e084e1 447 const struct ada_opname_map *mapping;
f8eba3c6 448
40e084e1
KS
449 for (mapping = ada_opname_table;
450 mapping->encoded != NULL
61012eef 451 && !startswith (string, mapping->decoded); ++mapping)
40e084e1
KS
452 ;
453
454 return mapping->decoded == NULL ? 0 : strlen (mapping->decoded);
f8eba3c6
TT
455}
456
40e084e1
KS
457/* Find QUOTE_CHAR in STRING, accounting for the ':' terminal. Return
458 the location of QUOTE_CHAR, or NULL if not found. */
f8eba3c6 459
40e084e1
KS
460static const char *
461skip_quote_char (const char *string, char quote_char)
f8eba3c6 462{
40e084e1 463 const char *p, *last;
f8eba3c6 464
40e084e1
KS
465 p = last = find_toplevel_char (string, quote_char);
466 while (p && *p != '\0' && *p != ':')
467 {
468 p = find_toplevel_char (p, quote_char);
469 if (p != NULL)
470 last = p++;
471 }
f8eba3c6 472
40e084e1 473 return last;
f8eba3c6 474}
50641945 475
40e084e1
KS
476/* Make a writable copy of the string given in TOKEN, trimming
477 any trailing whitespace. */
50641945 478
40e084e1
KS
479static char *
480copy_token_string (linespec_token token)
50641945 481{
40e084e1 482 char *str, *s;
e0881a8e 483
40e084e1
KS
484 if (token.type == LSTOKEN_KEYWORD)
485 return xstrdup (LS_TOKEN_KEYWORD (token));
255e7dbf 486
40e084e1
KS
487 str = savestring (LS_TOKEN_STOKEN (token).ptr,
488 LS_TOKEN_STOKEN (token).length);
489 s = remove_trailing_whitespace (str, str + LS_TOKEN_STOKEN (token).length);
490 *s = '\0';
e0881a8e 491
40e084e1
KS
492 return str;
493}
255e7dbf 494
40e084e1 495/* Does P represent the end of a quote-enclosed linespec? */
f3a5f1de 496
40e084e1
KS
497static int
498is_closing_quote_enclosed (const char *p)
499{
500 if (strchr (linespec_quote_characters, *p))
501 ++p;
502 p = skip_spaces ((char *) p);
503 return (*p == '\0' || linespec_lexer_lex_keyword (p));
50641945
FN
504}
505
40e084e1
KS
506/* Find the end of the parameter list that starts with *INPUT.
507 This helper function assists with lexing string segments
508 which might contain valid (non-terminating) commas. */
481860b3 509
d7561cbb
KS
510static const char *
511find_parameter_list_end (const char *input)
481860b3 512{
40e084e1
KS
513 char end_char, start_char;
514 int depth;
d7561cbb 515 const char *p;
481860b3 516
40e084e1
KS
517 start_char = *input;
518 if (start_char == '(')
519 end_char = ')';
520 else if (start_char == '<')
521 end_char = '>';
522 else
523 return NULL;
481860b3 524
40e084e1
KS
525 p = input;
526 depth = 0;
527 while (*p)
481860b3 528 {
40e084e1
KS
529 if (*p == start_char)
530 ++depth;
531 else if (*p == end_char)
532 {
533 if (--depth == 0)
534 {
535 ++p;
536 break;
537 }
538 }
539 ++p;
481860b3 540 }
40e084e1
KS
541
542 return p;
481860b3
GB
543}
544
74ccd7f5 545
40e084e1
KS
546/* Lex a string from the input in PARSER. */
547
548static linespec_token
549linespec_lexer_lex_string (linespec_parser *parser)
74ccd7f5 550{
40e084e1 551 linespec_token token;
d7561cbb 552 const char *start = PARSER_STREAM (parser);
74ccd7f5 553
40e084e1 554 token.type = LSTOKEN_STRING;
74ccd7f5 555
40e084e1
KS
556 /* If the input stream starts with a quote character, skip to the next
557 quote character, regardless of the content. */
558 if (strchr (linespec_quote_characters, *PARSER_STREAM (parser)))
559 {
560 const char *end;
561 char quote_char = *PARSER_STREAM (parser);
50641945 562
40e084e1
KS
563 /* Special case: Ada operators. */
564 if (PARSER_STATE (parser)->language->la_language == language_ada
565 && quote_char == '\"')
566 {
567 int len = is_ada_operator (PARSER_STREAM (parser));
50641945 568
40e084e1
KS
569 if (len != 0)
570 {
571 /* The input is an Ada operator. Return the quoted string
572 as-is. */
573 LS_TOKEN_STOKEN (token).ptr = PARSER_STREAM (parser);
574 LS_TOKEN_STOKEN (token).length = len;
575 PARSER_STREAM (parser) += len;
576 return token;
577 }
f8eba3c6 578
40e084e1
KS
579 /* The input does not represent an Ada operator -- fall through
580 to normal quoted string handling. */
581 }
f8eba3c6 582
40e084e1
KS
583 /* Skip past the beginning quote. */
584 ++(PARSER_STREAM (parser));
74ccd7f5 585
40e084e1
KS
586 /* Mark the start of the string. */
587 LS_TOKEN_STOKEN (token).ptr = PARSER_STREAM (parser);
f8eba3c6 588
40e084e1
KS
589 /* Skip to the ending quote. */
590 end = skip_quote_char (PARSER_STREAM (parser), quote_char);
591
592 /* Error if the input did not terminate properly. */
593 if (end == NULL)
594 error (_("unmatched quote"));
595
596 /* Skip over the ending quote and mark the length of the string. */
597 PARSER_STREAM (parser) = (char *) ++end;
598 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - 2 - start;
599 }
600 else
601 {
d7561cbb 602 const char *p;
40e084e1
KS
603
604 /* Otherwise, only identifier characters are permitted.
605 Spaces are the exception. In general, we keep spaces,
606 but only if the next characters in the input do not resolve
607 to one of the keywords.
608
609 This allows users to forgo quoting CV-qualifiers, template arguments,
610 and similar common language constructs. */
611
612 while (1)
613 {
614 if (isspace (*PARSER_STREAM (parser)))
615 {
d7561cbb 616 p = skip_spaces_const (PARSER_STREAM (parser));
7c09e5a0
DE
617 /* When we get here we know we've found something followed by
618 a space (we skip over parens and templates below).
619 So if we find a keyword now, we know it is a keyword and not,
620 say, a function name. */
40e084e1
KS
621 if (linespec_lexer_lex_keyword (p) != NULL)
622 {
623 LS_TOKEN_STOKEN (token).ptr = start;
624 LS_TOKEN_STOKEN (token).length
625 = PARSER_STREAM (parser) - start;
626 return token;
627 }
628
629 /* Advance past the whitespace. */
630 PARSER_STREAM (parser) = p;
631 }
632
633 /* If the next character is EOI or (single) ':', the
634 string is complete; return the token. */
635 if (*PARSER_STREAM (parser) == 0)
636 {
637 LS_TOKEN_STOKEN (token).ptr = start;
638 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start;
639 return token;
640 }
641 else if (PARSER_STREAM (parser)[0] == ':')
642 {
643 /* Do not tokenize the C++ scope operator. */
644 if (PARSER_STREAM (parser)[1] == ':')
645 ++(PARSER_STREAM (parser));
646
647 /* Do not tokenify if the input length so far is one
648 (i.e, a single-letter drive name) and the next character
649 is a directory separator. This allows Windows-style
650 paths to be recognized as filenames without quoting it. */
651 else if ((PARSER_STREAM (parser) - start) != 1
652 || !IS_DIR_SEPARATOR (PARSER_STREAM (parser)[1]))
653 {
654 LS_TOKEN_STOKEN (token).ptr = start;
655 LS_TOKEN_STOKEN (token).length
656 = PARSER_STREAM (parser) - start;
657 return token;
658 }
659 }
660 /* Special case: permit quote-enclosed linespecs. */
661 else if (parser->is_quote_enclosed
662 && strchr (linespec_quote_characters,
663 *PARSER_STREAM (parser))
664 && is_closing_quote_enclosed (PARSER_STREAM (parser)))
665 {
666 LS_TOKEN_STOKEN (token).ptr = start;
667 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start;
668 return token;
669 }
670 /* Because commas may terminate a linespec and appear in
671 the middle of valid string input, special cases for
672 '<' and '(' are necessary. */
673 else if (*PARSER_STREAM (parser) == '<'
674 || *PARSER_STREAM (parser) == '(')
675 {
d7561cbb 676 const char *p;
40e084e1
KS
677
678 p = find_parameter_list_end (PARSER_STREAM (parser));
679 if (p != NULL)
680 {
681 PARSER_STREAM (parser) = p;
682 continue;
683 }
684 }
685 /* Commas are terminators, but not if they are part of an
686 operator name. */
687 else if (*PARSER_STREAM (parser) == ',')
688 {
689 if ((PARSER_STATE (parser)->language->la_language
690 == language_cplus)
691 && (PARSER_STREAM (parser) - start) > 8
692 /* strlen ("operator") */)
693 {
acaa662f 694 const char *p = strstr (start, "operator");
40e084e1
KS
695
696 if (p != NULL && is_operator_name (p))
697 {
698 /* This is an operator name. Keep going. */
699 ++(PARSER_STREAM (parser));
700 continue;
701 }
702 }
703
704 /* Comma terminates the string. */
705 LS_TOKEN_STOKEN (token).ptr = start;
706 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start;
707 return token;
708 }
709
710 /* Advance the stream. */
711 ++(PARSER_STREAM (parser));
712 }
713 }
714
715 return token;
716}
717
718/* Lex a single linespec token from PARSER. */
719
720static linespec_token
721linespec_lexer_lex_one (linespec_parser *parser)
722{
723 const char *keyword;
724
725 if (parser->lexer.current.type == LSTOKEN_CONSUMED)
726 {
727 /* Skip any whitespace. */
d7561cbb 728 PARSER_STREAM (parser) = skip_spaces_const (PARSER_STREAM (parser));
40e084e1 729
7c09e5a0 730 /* Check for a keyword, they end the linespec. */
0578b14e 731 keyword = linespec_lexer_lex_keyword (PARSER_STREAM (parser));
40e084e1
KS
732 if (keyword != NULL)
733 {
734 parser->lexer.current.type = LSTOKEN_KEYWORD;
735 LS_TOKEN_KEYWORD (parser->lexer.current) = keyword;
0578b14e
KS
736 /* We do not advance the stream here intentionally:
737 we would like lexing to stop when a keyword is seen.
738
739 PARSER_STREAM (parser) += strlen (keyword); */
740
40e084e1
KS
741 return parser->lexer.current;
742 }
743
744 /* Handle other tokens. */
745 switch (*PARSER_STREAM (parser))
746 {
747 case 0:
748 parser->lexer.current.type = LSTOKEN_EOI;
749 break;
750
751 case '+': case '-':
752 case '0': case '1': case '2': case '3': case '4':
753 case '5': case '6': case '7': case '8': case '9':
d7cbec71
HZ
754 if (!linespec_lexer_lex_number (parser, &(parser->lexer.current)))
755 parser->lexer.current = linespec_lexer_lex_string (parser);
40e084e1
KS
756 break;
757
758 case ':':
759 /* If we have a scope operator, lex the input as a string.
760 Otherwise, return LSTOKEN_COLON. */
761 if (PARSER_STREAM (parser)[1] == ':')
762 parser->lexer.current = linespec_lexer_lex_string (parser);
763 else
764 {
765 parser->lexer.current.type = LSTOKEN_COLON;
766 ++(PARSER_STREAM (parser));
767 }
768 break;
769
770 case '\'': case '\"':
771 /* Special case: permit quote-enclosed linespecs. */
772 if (parser->is_quote_enclosed
773 && is_closing_quote_enclosed (PARSER_STREAM (parser)))
774 {
775 ++(PARSER_STREAM (parser));
776 parser->lexer.current.type = LSTOKEN_EOI;
777 }
778 else
779 parser->lexer.current = linespec_lexer_lex_string (parser);
780 break;
781
782 case ',':
783 parser->lexer.current.type = LSTOKEN_COMMA;
784 LS_TOKEN_STOKEN (parser->lexer.current).ptr
785 = PARSER_STREAM (parser);
786 LS_TOKEN_STOKEN (parser->lexer.current).length = 1;
787 ++(PARSER_STREAM (parser));
788 break;
789
790 default:
791 /* If the input is not a number, it must be a string.
792 [Keywords were already considered above.] */
793 parser->lexer.current = linespec_lexer_lex_string (parser);
794 break;
795 }
796 }
797
798 return parser->lexer.current;
799}
800
801/* Consume the current token and return the next token in PARSER's
802 input stream. */
803
804static linespec_token
805linespec_lexer_consume_token (linespec_parser *parser)
806{
807 parser->lexer.current.type = LSTOKEN_CONSUMED;
808 return linespec_lexer_lex_one (parser);
809}
810
811/* Return the next token without consuming the current token. */
812
813static linespec_token
814linespec_lexer_peek_token (linespec_parser *parser)
815{
816 linespec_token next;
d7561cbb 817 const char *saved_stream = PARSER_STREAM (parser);
40e084e1
KS
818 linespec_token saved_token = parser->lexer.current;
819
820 next = linespec_lexer_consume_token (parser);
821 PARSER_STREAM (parser) = saved_stream;
822 parser->lexer.current = saved_token;
823 return next;
824}
825
826/* Helper functions. */
827
828/* Add SAL to SALS. */
829
830static void
831add_sal_to_sals_basic (struct symtabs_and_lines *sals,
832 struct symtab_and_line *sal)
833{
834 ++sals->nelts;
224c3ddb 835 sals->sals = XRESIZEVEC (struct symtab_and_line, sals->sals, sals->nelts);
40e084e1
KS
836 sals->sals[sals->nelts - 1] = *sal;
837}
838
839/* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
840 the new sal, if needed. If not NULL, SYMNAME is the name of the
66f1999b
KS
841 symbol to use when constructing the new canonical name.
842
843 If LITERAL_CANONICAL is non-zero, SYMNAME will be used as the
844 canonical name for the SAL. */
40e084e1
KS
845
846static void
847add_sal_to_sals (struct linespec_state *self,
848 struct symtabs_and_lines *sals,
849 struct symtab_and_line *sal,
66f1999b 850 const char *symname, int literal_canonical)
40e084e1
KS
851{
852 add_sal_to_sals_basic (sals, sal);
853
854 if (self->canonical)
855 {
33f448b1 856 struct linespec_canonical_name *canonical;
40e084e1 857
224c3ddb
SM
858 self->canonical_names = XRESIZEVEC (struct linespec_canonical_name,
859 self->canonical_names, sals->nelts);
33f448b1 860 canonical = &self->canonical_names[sals->nelts - 1];
4e04028d 861 if (!literal_canonical && sal->symtab)
40e084e1 862 {
df140a0b
TS
863 symtab_to_fullname (sal->symtab);
864
40e084e1
KS
865 /* Note that the filter doesn't have to be a valid linespec
866 input. We only apply the ":LINE" treatment to Ada for
867 the time being. */
868 if (symname != NULL && sal->line != 0
869 && self->language->la_language == language_ada)
33f448b1 870 canonical->suffix = xstrprintf ("%s:%d", symname, sal->line);
40e084e1 871 else if (symname != NULL)
33f448b1 872 canonical->suffix = xstrdup (symname);
40e084e1 873 else
33f448b1
JK
874 canonical->suffix = xstrprintf ("%d", sal->line);
875 canonical->symtab = sal->symtab;
876 }
877 else
878 {
879 if (symname != NULL)
880 canonical->suffix = xstrdup (symname);
881 else
e617b069 882 canonical->suffix = xstrdup ("<unknown>");
33f448b1 883 canonical->symtab = NULL;
40e084e1 884 }
40e084e1
KS
885 }
886}
887
888/* A hash function for address_entry. */
889
890static hashval_t
891hash_address_entry (const void *p)
892{
9a3c8263 893 const struct address_entry *aep = (const struct address_entry *) p;
40e084e1
KS
894 hashval_t hash;
895
896 hash = iterative_hash_object (aep->pspace, 0);
897 return iterative_hash_object (aep->addr, hash);
898}
899
900/* An equality function for address_entry. */
901
902static int
903eq_address_entry (const void *a, const void *b)
904{
9a3c8263
SM
905 const struct address_entry *aea = (const struct address_entry *) a;
906 const struct address_entry *aeb = (const struct address_entry *) b;
40e084e1
KS
907
908 return aea->pspace == aeb->pspace && aea->addr == aeb->addr;
909}
910
911/* Check whether the address, represented by PSPACE and ADDR, is
912 already in the set. If so, return 0. Otherwise, add it and return
913 1. */
914
915static int
916maybe_add_address (htab_t set, struct program_space *pspace, CORE_ADDR addr)
917{
918 struct address_entry e, *p;
919 void **slot;
920
921 e.pspace = pspace;
922 e.addr = addr;
923 slot = htab_find_slot (set, &e, INSERT);
924 if (*slot)
925 return 0;
926
927 p = XNEW (struct address_entry);
928 memcpy (p, &e, sizeof (struct address_entry));
929 *slot = p;
930
931 return 1;
932}
933
40e084e1
KS
934/* A helper that walks over all matching symtabs in all objfiles and
935 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
936 not NULL, then the search is restricted to just that program
14bc53a8 937 space. If INCLUDE_INLINE is true then symbols representing
40e084e1
KS
938 inlined instances of functions will be included in the result. */
939
940static void
14bc53a8
PA
941iterate_over_all_matching_symtabs
942 (struct linespec_state *state, const char *name, const domain_enum domain,
943 struct program_space *search_pspace, bool include_inline,
944 gdb::function_view<symbol_found_callback_ftype> callback)
40e084e1
KS
945{
946 struct objfile *objfile;
947 struct program_space *pspace;
40e084e1 948
14bc53a8
PA
949 /* The routine to be used for comparison. */
950 symbol_name_cmp_ftype symbol_name_cmp
951 = (state->language->la_get_symbol_name_cmp != NULL
952 ? state->language->la_get_symbol_name_cmp (name)
953 : strcmp_iw);
40e084e1
KS
954
955 ALL_PSPACES (pspace)
956 {
957 if (search_pspace != NULL && search_pspace != pspace)
958 continue;
959 if (pspace->executing_startup)
f8eba3c6
TT
960 continue;
961
962 set_current_program_space (pspace);
50641945 963
f8eba3c6
TT
964 ALL_OBJFILES (objfile)
965 {
43f3e411 966 struct compunit_symtab *cu;
f8eba3c6
TT
967
968 if (objfile->sf)
14bc53a8
PA
969 objfile->sf->qf->expand_symtabs_matching
970 (objfile,
971 NULL,
972 [&] (const char *symbol_name)
973 {
974 return symbol_name_cmp (symbol_name, name) == 0;
975 },
976 NULL,
977 ALL_DOMAIN);
f8eba3c6 978
43f3e411 979 ALL_OBJFILE_COMPUNITS (objfile, cu)
f8eba3c6 980 {
43f3e411
DE
981 struct symtab *symtab = COMPUNIT_FILETABS (cu);
982
14bc53a8 983 iterate_over_file_blocks (symtab, name, domain, callback);
481860b3 984
d790cf0a
DE
985 if (include_inline)
986 {
4eeaa230 987 struct block *block;
d790cf0a 988 int i;
481860b3 989
d790cf0a 990 for (i = FIRST_LOCAL_BLOCK;
439247b6
DE
991 i < BLOCKVECTOR_NBLOCKS (SYMTAB_BLOCKVECTOR (symtab));
992 i++)
d790cf0a 993 {
439247b6 994 block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), i);
4ae24af0 995 state->language->la_iterate_over_symbols
14bc53a8
PA
996 (block, name, domain, [&] (symbol *sym)
997 {
998 /* Restrict calls to CALLBACK to symbols
999 representing inline symbols only. */
1000 if (SYMBOL_INLINED (sym))
1001 return callback (sym);
1002 return true;
1003 });
481860b3 1004 }
f8eba3c6
TT
1005 }
1006 }
1007 }
1008 }
50641945
FN
1009}
1010
4eeaa230
DE
1011/* Returns the block to be used for symbol searches from
1012 the current location. */
e8eb7bc5 1013
3977b71f 1014static const struct block *
e482a1a7 1015get_current_search_block (void)
e8eb7bc5 1016{
3977b71f 1017 const struct block *block;
4eeaa230 1018 enum language save_language;
e8eb7bc5 1019
4eeaa230
DE
1020 /* get_selected_block can change the current language when there is
1021 no selected frame yet. */
1022 save_language = current_language->la_language;
1023 block = get_selected_block (0);
1024 set_language (save_language);
e8eb7bc5
KS
1025
1026 return block;
1027}
1028
4eeaa230
DE
1029/* Iterate over static and global blocks. */
1030
1031static void
14bc53a8
PA
1032iterate_over_file_blocks
1033 (struct symtab *symtab, const char *name, domain_enum domain,
1034 gdb::function_view<symbol_found_callback_ftype> callback)
4eeaa230
DE
1035{
1036 struct block *block;
1037
439247b6 1038 for (block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), STATIC_BLOCK);
4eeaa230
DE
1039 block != NULL;
1040 block = BLOCK_SUPERBLOCK (block))
14bc53a8 1041 LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback);
4eeaa230
DE
1042}
1043
f8eba3c6 1044/* A helper for find_method. This finds all methods in type T which
40e084e1 1045 match NAME. It adds matching symbol names to RESULT_NAMES, and
f8eba3c6 1046 adds T's direct superclasses to SUPERCLASSES. */
50641945 1047
f8eba3c6
TT
1048static void
1049find_methods (struct type *t, const char *name,
1050 VEC (const_char_ptr) **result_names,
1051 VEC (typep) **superclasses)
50641945 1052{
50641945 1053 int ibase;
0d5cff50 1054 const char *class_name = type_name_no_tag (t);
c00f8484 1055
50641945
FN
1056 /* Ignore this class if it doesn't have a name. This is ugly, but
1057 unless we figure out how to get the physname without the name of
1058 the class, then the loop can't do any good. */
f8eba3c6 1059 if (class_name)
50641945
FN
1060 {
1061 int method_counter;
1062
f168693b 1063 t = check_typedef (t);
50641945
FN
1064
1065 /* Loop over each method name. At this level, all overloads of a name
1066 are counted as a single name. There is an inner loop which loops over
1067 each overload. */
1068
1069 for (method_counter = TYPE_NFN_FIELDS (t) - 1;
1070 method_counter >= 0;
1071 --method_counter)
1072 {
0d5cff50 1073 const char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
50641945
FN
1074 char dem_opname[64];
1075
61012eef
GB
1076 if (startswith (method_name, "__") ||
1077 startswith (method_name, "op") ||
1078 startswith (method_name, "type"))
50641945
FN
1079 {
1080 if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI))
1081 method_name = dem_opname;
1082 else if (cplus_demangle_opname (method_name, dem_opname, 0))
1083 method_name = dem_opname;
1084 }
1085
f8eba3c6
TT
1086 if (strcmp_iw (method_name, name) == 0)
1087 {
1088 int field_counter;
aee8d8ba 1089
f8eba3c6
TT
1090 for (field_counter = (TYPE_FN_FIELDLIST_LENGTH (t, method_counter)
1091 - 1);
1092 field_counter >= 0;
1093 --field_counter)
1094 {
1095 struct fn_field *f;
1096 const char *phys_name;
1097
1098 f = TYPE_FN_FIELDLIST1 (t, method_counter);
1099 if (TYPE_FN_FIELD_STUB (f, field_counter))
1100 continue;
1101 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
1102 VEC_safe_push (const_char_ptr, *result_names, phys_name);
1103 }
1104 }
aee8d8ba
DC
1105 }
1106 }
1107
f8eba3c6
TT
1108 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
1109 VEC_safe_push (typep, *superclasses, TYPE_BASECLASS (t, ibase));
50641945
FN
1110}
1111
50641945
FN
1112/* Find an instance of the character C in the string S that is outside
1113 of all parenthesis pairs, single-quoted strings, and double-quoted
8120c9d5
EZ
1114 strings. Also, ignore the char within a template name, like a ','
1115 within foo<int, int>. */
1116
87f0e720 1117const char *
40e084e1 1118find_toplevel_char (const char *s, char c)
50641945
FN
1119{
1120 int quoted = 0; /* zero if we're not in quotes;
1121 '"' if we're in a double-quoted string;
1122 '\'' if we're in a single-quoted string. */
a04257e6 1123 int depth = 0; /* Number of unclosed parens we've seen. */
40e084e1 1124 const char *scan;
50641945
FN
1125
1126 for (scan = s; *scan; scan++)
1127 {
1128 if (quoted)
1129 {
1130 if (*scan == quoted)
1131 quoted = 0;
1132 else if (*scan == '\\' && *(scan + 1))
1133 scan++;
1134 }
1135 else if (*scan == c && ! quoted && depth == 0)
1136 return scan;
1137 else if (*scan == '"' || *scan == '\'')
1138 quoted = *scan;
8120c9d5 1139 else if (*scan == '(' || *scan == '<')
50641945 1140 depth++;
8120c9d5 1141 else if ((*scan == ')' || *scan == '>') && depth > 0)
50641945
FN
1142 depth--;
1143 }
1144
1145 return 0;
1146}
1147
40e084e1
KS
1148/* The string equivalent of find_toplevel_char. Returns a pointer
1149 to the location of NEEDLE in HAYSTACK, ignoring any occurrences
1150 inside "()" and "<>". Returns NULL if NEEDLE was not found. */
889f28e2 1151
40e084e1
KS
1152static const char *
1153find_toplevel_string (const char *haystack, const char *needle)
889f28e2 1154{
40e084e1
KS
1155 const char *s = haystack;
1156
1157 do
1158 {
1159 s = find_toplevel_char (s, *needle);
1160
1161 if (s != NULL)
1162 {
1163 /* Found first char in HAYSTACK; check rest of string. */
61012eef 1164 if (startswith (s, needle))
40e084e1
KS
1165 return s;
1166
1167 /* Didn't find it; loop over HAYSTACK, looking for the next
1168 instance of the first character of NEEDLE. */
1169 ++s;
1170 }
1171 }
1172 while (s != NULL && *s != '\0');
1173
1174 /* NEEDLE was not found in HAYSTACK. */
1175 return NULL;
889f28e2
AF
1176}
1177
33f448b1
JK
1178/* Convert CANONICAL to its string representation using
1179 symtab_to_fullname for SYMTAB. The caller must xfree the result. */
1180
1181static char *
1182canonical_to_fullform (const struct linespec_canonical_name *canonical)
1183{
1184 if (canonical->symtab == NULL)
1185 return xstrdup (canonical->suffix);
1186 else
1187 return xstrprintf ("%s:%s", symtab_to_fullname (canonical->symtab),
1188 canonical->suffix);
1189}
1190
f8eba3c6
TT
1191/* Given FILTERS, a list of canonical names, filter the sals in RESULT
1192 and store the result in SELF->CANONICAL. */
50641945 1193
f8eba3c6
TT
1194static void
1195filter_results (struct linespec_state *self,
1196 struct symtabs_and_lines *result,
1197 VEC (const_char_ptr) *filters)
1198{
1199 int i;
1200 const char *name;
1201
1202 for (i = 0; VEC_iterate (const_char_ptr, filters, i, name); ++i)
1203 {
1204 struct linespec_sals lsal;
1205 int j;
1206
1207 memset (&lsal, 0, sizeof (lsal));
1208
1209 for (j = 0; j < result->nelts; ++j)
1210 {
33f448b1
JK
1211 const struct linespec_canonical_name *canonical;
1212 char *fullform;
1213 struct cleanup *cleanup;
1214
1215 canonical = &self->canonical_names[j];
1216 fullform = canonical_to_fullform (canonical);
1217 cleanup = make_cleanup (xfree, fullform);
1218
1219 if (strcmp (name, fullform) == 0)
f8eba3c6 1220 add_sal_to_sals_basic (&lsal.sals, &result->sals[j]);
33f448b1
JK
1221
1222 do_cleanups (cleanup);
f8eba3c6
TT
1223 }
1224
1225 if (lsal.sals.nelts > 0)
1226 {
1227 lsal.canonical = xstrdup (name);
1228 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
1229 }
1230 }
1231
1232 self->canonical->pre_expanded = 0;
1233}
1234
1235/* Store RESULT into SELF->CANONICAL. */
1236
1237static void
1238convert_results_to_lsals (struct linespec_state *self,
1239 struct symtabs_and_lines *result)
50641945 1240{
f8eba3c6
TT
1241 struct linespec_sals lsal;
1242
1243 lsal.canonical = NULL;
1244 lsal.sals = *result;
1245 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
1246}
1247
33f448b1
JK
1248/* A structure that contains two string representations of a struct
1249 linespec_canonical_name:
1250 - one where the the symtab's fullname is used;
1251 - one where the filename followed the "set filename-display"
1252 setting. */
1253
1254struct decode_line_2_item
1255{
1256 /* The form using symtab_to_fullname.
1257 It must be xfree'ed after use. */
1258 char *fullform;
1259
1260 /* The form using symtab_to_filename_for_display.
1261 It must be xfree'ed after use. */
1262 char *displayform;
1263
1264 /* Field is initialized to zero and it is set to one if the user
1265 requested breakpoint for this entry. */
1266 unsigned int selected : 1;
1267};
1268
1269/* Helper for qsort to sort decode_line_2_item entries by DISPLAYFORM and
1270 secondarily by FULLFORM. */
1271
1272static int
1273decode_line_2_compare_items (const void *ap, const void *bp)
1274{
9a3c8263
SM
1275 const struct decode_line_2_item *a = (const struct decode_line_2_item *) ap;
1276 const struct decode_line_2_item *b = (const struct decode_line_2_item *) bp;
33f448b1
JK
1277 int retval;
1278
1279 retval = strcmp (a->displayform, b->displayform);
1280 if (retval != 0)
1281 return retval;
1282
1283 return strcmp (a->fullform, b->fullform);
1284}
1285
f8eba3c6
TT
1286/* Handle multiple results in RESULT depending on SELECT_MODE. This
1287 will either return normally, throw an exception on multiple
1288 results, or present a menu to the user. On return, the SALS vector
1289 in SELF->CANONICAL is set up properly. */
1290
1291static void
1292decode_line_2 (struct linespec_state *self,
1293 struct symtabs_and_lines *result,
1294 const char *select_mode)
1295{
a121b7c1
PA
1296 char *args;
1297 const char *prompt;
50641945 1298 int i;
50641945 1299 struct cleanup *old_chain;
33f448b1 1300 VEC (const_char_ptr) *filters = NULL;
33f448b1
JK
1301 struct decode_line_2_item *items;
1302 int items_count;
50641945 1303
f8eba3c6
TT
1304 gdb_assert (select_mode != multiple_symbols_all);
1305 gdb_assert (self->canonical != NULL);
33f448b1
JK
1306 gdb_assert (result->nelts >= 1);
1307
1308 old_chain = make_cleanup (VEC_cleanup (const_char_ptr), &filters);
50641945 1309
33f448b1
JK
1310 /* Prepare ITEMS array. */
1311 items_count = result->nelts;
8d749320 1312 items = XNEWVEC (struct decode_line_2_item, items_count);
33f448b1
JK
1313 make_cleanup (xfree, items);
1314 for (i = 0; i < items_count; ++i)
50641945 1315 {
33f448b1
JK
1316 const struct linespec_canonical_name *canonical;
1317 struct decode_line_2_item *item;
1318
1319 canonical = &self->canonical_names[i];
1320 gdb_assert (canonical->suffix != NULL);
1321 item = &items[i];
f8eba3c6 1322
33f448b1
JK
1323 item->fullform = canonical_to_fullform (canonical);
1324 make_cleanup (xfree, item->fullform);
1325
1326 if (canonical->symtab == NULL)
1327 item->displayform = canonical->suffix;
1328 else
f8eba3c6 1329 {
33f448b1
JK
1330 const char *fn_for_display;
1331
1332 fn_for_display = symtab_to_filename_for_display (canonical->symtab);
1333 item->displayform = xstrprintf ("%s:%s", fn_for_display,
1334 canonical->suffix);
1335 make_cleanup (xfree, item->displayform);
f8eba3c6
TT
1336 }
1337
33f448b1 1338 item->selected = 0;
50641945
FN
1339 }
1340
33f448b1
JK
1341 /* Sort the list of method names. */
1342 qsort (items, items_count, sizeof (*items), decode_line_2_compare_items);
1343
1344 /* Remove entries with the same FULLFORM. */
1345 if (items_count >= 2)
1346 {
1347 struct decode_line_2_item *dst, *src;
1348
1349 dst = items;
1350 for (src = &items[1]; src < &items[items_count]; src++)
1351 if (strcmp (src->fullform, dst->fullform) != 0)
1352 *++dst = *src;
1353 items_count = dst + 1 - items;
1354 }
1355
1356 if (select_mode == multiple_symbols_cancel && items_count > 1)
f8eba3c6
TT
1357 error (_("canceled because the command is ambiguous\n"
1358 "See set/show multiple-symbol."));
1359
33f448b1 1360 if (select_mode == multiple_symbols_all || items_count == 1)
50641945 1361 {
f8eba3c6
TT
1362 do_cleanups (old_chain);
1363 convert_results_to_lsals (self, result);
1364 return;
50641945
FN
1365 }
1366
f8eba3c6 1367 printf_unfiltered (_("[0] cancel\n[1] all\n"));
33f448b1
JK
1368 for (i = 0; i < items_count; i++)
1369 printf_unfiltered ("[%d] %s\n", i + 2, items[i].displayform);
f8eba3c6
TT
1370
1371 prompt = getenv ("PS2");
1372 if (prompt == NULL)
50641945 1373 {
f8eba3c6 1374 prompt = "> ";
50641945 1375 }
f8eba3c6 1376 args = command_line_input (prompt, 0, "overload-choice");
50641945
FN
1377
1378 if (args == 0 || *args == 0)
e2e0b3e5 1379 error_no_arg (_("one or more choice numbers"));
50641945 1380
bfd28288
PA
1381 number_or_range_parser parser (args);
1382 while (!parser.finished ())
50641945 1383 {
bfd28288 1384 int num = parser.get_number ();
50641945
FN
1385
1386 if (num == 0)
8a3fe4f8 1387 error (_("canceled"));
50641945
FN
1388 else if (num == 1)
1389 {
f8eba3c6
TT
1390 /* We intentionally make this result in a single breakpoint,
1391 contrary to what older versions of gdb did. The
1392 rationale is that this lets a user get the
1393 multiple_symbols_all behavior even with the 'ask'
1394 setting; and he can get separate breakpoints by entering
1395 "2-57" at the query. */
1396 do_cleanups (old_chain);
1397 convert_results_to_lsals (self, result);
1398 return;
50641945
FN
1399 }
1400
f8eba3c6 1401 num -= 2;
33f448b1 1402 if (num >= items_count)
f8eba3c6 1403 printf_unfiltered (_("No choice number %d.\n"), num);
50641945
FN
1404 else
1405 {
33f448b1 1406 struct decode_line_2_item *item = &items[num];
f8eba3c6 1407
33f448b1 1408 if (!item->selected)
50641945 1409 {
33f448b1
JK
1410 VEC_safe_push (const_char_ptr, filters, item->fullform);
1411 item->selected = 1;
50641945
FN
1412 }
1413 else
1414 {
3e43a32a 1415 printf_unfiltered (_("duplicate request for %d ignored.\n"),
f6f99966 1416 num + 2);
50641945
FN
1417 }
1418 }
50641945 1419 }
f8eba3c6
TT
1420
1421 filter_results (self, result, filters);
1422 do_cleanups (old_chain);
50641945 1423}
94af9270 1424
40e084e1 1425\f
3d50dd94 1426
40e084e1
KS
1427/* The parser of linespec itself. */
1428
1429/* Throw an appropriate error when SYMBOL is not found (optionally in
1430 FILENAME). */
1431
1432static void ATTRIBUTE_NORETURN
5d94e27b 1433symbol_not_found_error (const char *symbol, const char *filename)
3d50dd94 1434{
40e084e1
KS
1435 if (symbol == NULL)
1436 symbol = "";
1437
1438 if (!have_full_symbols ()
1439 && !have_partial_symbols ()
1440 && !have_minimal_symbols ())
1441 throw_error (NOT_FOUND_ERROR,
1442 _("No symbol table is loaded. Use the \"file\" command."));
1443
1444 /* If SYMBOL starts with '$', the user attempted to either lookup
1445 a function/variable in his code starting with '$' or an internal
1446 variable of that name. Since we do not know which, be concise and
1447 explain both possibilities. */
1448 if (*symbol == '$')
1449 {
1450 if (filename)
1451 throw_error (NOT_FOUND_ERROR,
1452 _("Undefined convenience variable or function \"%s\" "
1453 "not defined in \"%s\"."), symbol, filename);
1454 else
1455 throw_error (NOT_FOUND_ERROR,
1456 _("Undefined convenience variable or function \"%s\" "
1457 "not defined."), symbol);
1458 }
1459 else
1460 {
1461 if (filename)
1462 throw_error (NOT_FOUND_ERROR,
1463 _("Function \"%s\" not defined in \"%s\"."),
1464 symbol, filename);
1465 else
1466 throw_error (NOT_FOUND_ERROR,
1467 _("Function \"%s\" not defined."), symbol);
1468 }
3d50dd94
JK
1469}
1470
40e084e1
KS
1471/* Throw an appropriate error when an unexpected token is encountered
1472 in the input. */
94af9270 1473
40e084e1
KS
1474static void ATTRIBUTE_NORETURN
1475unexpected_linespec_error (linespec_parser *parser)
94af9270 1476{
40e084e1
KS
1477 linespec_token token;
1478 static const char * token_type_strings[]
1479 = {"keyword", "colon", "string", "number", "comma", "end of input"};
94af9270 1480
40e084e1
KS
1481 /* Get the token that generated the error. */
1482 token = linespec_lexer_lex_one (parser);
94af9270 1483
40e084e1
KS
1484 /* Finally, throw the error. */
1485 if (token.type == LSTOKEN_STRING || token.type == LSTOKEN_NUMBER
1486 || token.type == LSTOKEN_KEYWORD)
94af9270 1487 {
40e084e1 1488 char *string;
40e084e1
KS
1489
1490 string = copy_token_string (token);
78cc6c2d 1491 make_cleanup (xfree, string);
40e084e1
KS
1492 throw_error (GENERIC_ERROR,
1493 _("malformed linespec error: unexpected %s, \"%s\""),
1494 token_type_strings[token.type], string);
1495 }
1496 else
1497 throw_error (GENERIC_ERROR,
1498 _("malformed linespec error: unexpected %s"),
1499 token_type_strings[token.type]);
1500}
1501
00e52e53
KS
1502/* Throw an undefined label error. */
1503
1504static void ATTRIBUTE_NORETURN
1505undefined_label_error (const char *function, const char *label)
1506{
1507 if (function != NULL)
1508 throw_error (NOT_FOUND_ERROR,
1509 _("No label \"%s\" defined in function \"%s\"."),
1510 label, function);
1511 else
1512 throw_error (NOT_FOUND_ERROR,
1513 _("No label \"%s\" defined in current function."),
1514 label);
1515}
1516
1517/* Throw a source file not found error. */
1518
1519static void ATTRIBUTE_NORETURN
1520source_file_not_found_error (const char *name)
1521{
1522 throw_error (NOT_FOUND_ERROR, _("No source file named %s."), name);
1523}
1524
87f0e720 1525/* See description in linespec.h. */
40e084e1 1526
87f0e720 1527struct line_offset
09cf2b22 1528linespec_parse_line_offset (const char *string)
40e084e1 1529{
87f0e720 1530 const char *start = string;
40e084e1
KS
1531 struct line_offset line_offset = {0, LINE_OFFSET_NONE};
1532
1533 if (*string == '+')
1534 {
1535 line_offset.sign = LINE_OFFSET_PLUS;
1536 ++string;
1537 }
1538 else if (*string == '-')
1539 {
1540 line_offset.sign = LINE_OFFSET_MINUS;
1541 ++string;
1542 }
1543
87f0e720
KS
1544 if (*string != '\0' && !isdigit (*string))
1545 error (_("malformed line offset: \"%s\""), start);
1546
40e084e1
KS
1547 /* Right now, we only allow base 10 for offsets. */
1548 line_offset.offset = atoi (string);
1549 return line_offset;
1550}
1551
1552/* Parse the basic_spec in PARSER's input. */
1553
1554static void
1555linespec_parse_basic (linespec_parser *parser)
1556{
1557 char *name;
1558 linespec_token token;
1559 VEC (symbolp) *symbols, *labels;
f60e2d5c 1560 VEC (bound_minimal_symbol_d) *minimal_symbols;
40e084e1
KS
1561 struct cleanup *cleanup;
1562
1563 /* Get the next token. */
1564 token = linespec_lexer_lex_one (parser);
1565
1566 /* If it is EOI or KEYWORD, issue an error. */
1567 if (token.type == LSTOKEN_KEYWORD || token.type == LSTOKEN_EOI)
1568 unexpected_linespec_error (parser);
1569 /* If it is a LSTOKEN_NUMBER, we have an offset. */
1570 else if (token.type == LSTOKEN_NUMBER)
1571 {
1572 /* Record the line offset and get the next token. */
1573 name = copy_token_string (token);
1574 cleanup = make_cleanup (xfree, name);
00e52e53 1575 PARSER_EXPLICIT (parser)->line_offset = linespec_parse_line_offset (name);
40e084e1
KS
1576 do_cleanups (cleanup);
1577
1578 /* Get the next token. */
1579 token = linespec_lexer_consume_token (parser);
1580
1581 /* If the next token is a comma, stop parsing and return. */
1582 if (token.type == LSTOKEN_COMMA)
1583 return;
1584
1585 /* If the next token is anything but EOI or KEYWORD, issue
1586 an error. */
1587 if (token.type != LSTOKEN_KEYWORD && token.type != LSTOKEN_EOI)
1588 unexpected_linespec_error (parser);
1589 }
1590
1591 if (token.type == LSTOKEN_KEYWORD || token.type == LSTOKEN_EOI)
1592 return;
1593
1594 /* Next token must be LSTOKEN_STRING. */
1595 if (token.type != LSTOKEN_STRING)
1596 unexpected_linespec_error (parser);
1597
1598 /* The current token will contain the name of a function, method,
1599 or label. */
1600 name = copy_token_string (token);
1601 cleanup = make_cleanup (xfree, name);
1602
1603 /* Try looking it up as a function/method. */
1604 find_linespec_symbols (PARSER_STATE (parser),
1605 PARSER_RESULT (parser)->file_symtabs, name,
1606 &symbols, &minimal_symbols);
1607
1608 if (symbols != NULL || minimal_symbols != NULL)
1609 {
1610 PARSER_RESULT (parser)->function_symbols = symbols;
1611 PARSER_RESULT (parser)->minimal_symbols = minimal_symbols;
00e52e53 1612 PARSER_EXPLICIT (parser)->function_name = name;
40e084e1
KS
1613 symbols = NULL;
1614 discard_cleanups (cleanup);
1615 }
1616 else
1617 {
1618 /* NAME was not a function or a method. So it must be a label
b4013987 1619 name or user specified variable like "break foo.c:$zippo". */
40e084e1
KS
1620 labels = find_label_symbols (PARSER_STATE (parser), NULL,
1621 &symbols, name);
1622 if (labels != NULL)
94af9270 1623 {
40e084e1
KS
1624 PARSER_RESULT (parser)->labels.label_symbols = labels;
1625 PARSER_RESULT (parser)->labels.function_symbols = symbols;
00e52e53 1626 PARSER_EXPLICIT (parser)->label_name = name;
40e084e1
KS
1627 symbols = NULL;
1628 discard_cleanups (cleanup);
1629 }
b4013987
AA
1630 else if (token.type == LSTOKEN_STRING
1631 && *LS_TOKEN_STOKEN (token).ptr == '$')
1632 {
1633 /* User specified a convenience variable or history value. */
00e52e53 1634 PARSER_EXPLICIT (parser)->line_offset
b4013987
AA
1635 = linespec_parse_variable (PARSER_STATE (parser), name);
1636
00e52e53 1637 if (PARSER_EXPLICIT (parser)->line_offset.sign == LINE_OFFSET_UNKNOWN)
b4013987
AA
1638 {
1639 /* The user-specified variable was not valid. Do not
1640 throw an error here. parse_linespec will do it for us. */
00e52e53 1641 PARSER_EXPLICIT (parser)->function_name = name;
b4013987
AA
1642 discard_cleanups (cleanup);
1643 return;
1644 }
c888a17d
KS
1645
1646 /* The convenience variable/history value parsed correctly.
1647 NAME is no longer needed. */
1648 do_cleanups (cleanup);
b4013987 1649 }
40e084e1
KS
1650 else
1651 {
1652 /* The name is also not a label. Abort parsing. Do not throw
1653 an error here. parse_linespec will do it for us. */
1654
1655 /* Save a copy of the name we were trying to lookup. */
00e52e53 1656 PARSER_EXPLICIT (parser)->function_name = name;
40e084e1
KS
1657 discard_cleanups (cleanup);
1658 return;
1659 }
1660 }
1661
1662 /* Get the next token. */
1663 token = linespec_lexer_consume_token (parser);
1664
1665 if (token.type == LSTOKEN_COLON)
1666 {
1667 /* User specified a label or a lineno. */
1668 token = linespec_lexer_consume_token (parser);
1669
1670 if (token.type == LSTOKEN_NUMBER)
1671 {
1672 /* User specified an offset. Record the line offset and
1673 get the next token. */
1674 name = copy_token_string (token);
1675 cleanup = make_cleanup (xfree, name);
00e52e53 1676 PARSER_EXPLICIT (parser)->line_offset
40e084e1
KS
1677 = linespec_parse_line_offset (name);
1678 do_cleanups (cleanup);
1679
1680 /* Ge the next token. */
1681 token = linespec_lexer_consume_token (parser);
1682 }
1683 else if (token.type == LSTOKEN_STRING)
1684 {
1685 /* Grab a copy of the label's name and look it up. */
1686 name = copy_token_string (token);
1687 cleanup = make_cleanup (xfree, name);
1688 labels = find_label_symbols (PARSER_STATE (parser),
1689 PARSER_RESULT (parser)->function_symbols,
1690 &symbols, name);
1691
1692 if (labels != NULL)
94af9270 1693 {
40e084e1
KS
1694 PARSER_RESULT (parser)->labels.label_symbols = labels;
1695 PARSER_RESULT (parser)->labels.function_symbols = symbols;
00e52e53 1696 PARSER_EXPLICIT (parser)->label_name = name;
40e084e1
KS
1697 symbols = NULL;
1698 discard_cleanups (cleanup);
1699 }
1700 else
1701 {
1702 /* We don't know what it was, but it isn't a label. */
00e52e53
KS
1703 undefined_label_error (PARSER_EXPLICIT (parser)->function_name,
1704 name);
40e084e1
KS
1705 }
1706
1707 /* Check for a line offset. */
1708 token = linespec_lexer_consume_token (parser);
1709 if (token.type == LSTOKEN_COLON)
1710 {
1711 /* Get the next token. */
1712 token = linespec_lexer_consume_token (parser);
1713
1714 /* It must be a line offset. */
1715 if (token.type != LSTOKEN_NUMBER)
1716 unexpected_linespec_error (parser);
1717
1718 /* Record the lione offset and get the next token. */
1719 name = copy_token_string (token);
1720 cleanup = make_cleanup (xfree, name);
1721
00e52e53 1722 PARSER_EXPLICIT (parser)->line_offset
40e084e1
KS
1723 = linespec_parse_line_offset (name);
1724 do_cleanups (cleanup);
1725
1726 /* Get the next token. */
1727 token = linespec_lexer_consume_token (parser);
94af9270
KS
1728 }
1729 }
40e084e1
KS
1730 else
1731 {
1732 /* Trailing ':' in the input. Issue an error. */
1733 unexpected_linespec_error (parser);
1734 }
94af9270 1735 }
40e084e1 1736}
94af9270 1737
40e084e1 1738/* Canonicalize the linespec contained in LS. The result is saved into
00e52e53
KS
1739 STATE->canonical. This function handles both linespec and explicit
1740 locations. */
40e084e1
KS
1741
1742static void
f00aae0f 1743canonicalize_linespec (struct linespec_state *state, const linespec_p ls)
40e084e1 1744{
00e52e53 1745 struct event_location *canon;
67994074 1746 struct explicit_location *explicit_loc;
f00aae0f 1747
40e084e1
KS
1748 /* If canonicalization was not requested, no need to do anything. */
1749 if (!state->canonical)
1750 return;
1751
00e52e53 1752 /* Save everything as an explicit location. */
67994074 1753 canon = state->canonical->location
ffc2605c 1754 = new_explicit_location (&ls->explicit_loc).release ();
67994074 1755 explicit_loc = get_explicit_location (canon);
40e084e1 1756
67994074 1757 if (explicit_loc->label_name != NULL)
a06efdd6 1758 {
00e52e53 1759 state->canonical->special_display = 1;
40e084e1 1760
67994074 1761 if (explicit_loc->function_name == NULL)
40e084e1 1762 {
a06efdd6
KS
1763 struct symbol *s;
1764
1765 /* No function was specified, so add the symbol name. */
1766 gdb_assert (ls->labels.function_symbols != NULL
1767 && (VEC_length (symbolp, ls->labels.function_symbols)
1768 == 1));
1769 s = VEC_index (symbolp, ls->labels.function_symbols, 0);
67994074 1770 explicit_loc->function_name = xstrdup (SYMBOL_NATURAL_NAME (s));
40e084e1 1771 }
a06efdd6 1772 }
40e084e1 1773
00e52e53
KS
1774 /* If this location originally came from a linespec, save a string
1775 representation of it for display and saving to file. */
1776 if (state->is_linespec)
a06efdd6 1777 {
67994074 1778 char *linespec = explicit_location_to_linespec (explicit_loc);
a06efdd6 1779
00e52e53
KS
1780 set_event_location_string (canon, linespec);
1781 xfree (linespec);
1782 }
94af9270 1783}
c00f8484 1784
40e084e1 1785/* Given a line offset in LS, construct the relevant SALs. */
c00f8484 1786
40e084e1
KS
1787static struct symtabs_and_lines
1788create_sals_line_offset (struct linespec_state *self,
1789 linespec_p ls)
c00f8484 1790{
40e084e1
KS
1791 struct symtabs_and_lines values;
1792 struct symtab_and_line val;
1793 int use_default = 0;
c00f8484 1794
40e084e1
KS
1795 init_sal (&val);
1796 values.sals = NULL;
1797 values.nelts = 0;
1798
1799 /* This is where we need to make sure we have good defaults.
1800 We must guarantee that this section of code is never executed
2e47c6ca 1801 when we are called with just a function name, since
40e084e1
KS
1802 set_default_source_symtab_and_line uses
1803 select_source_symtab that calls us with such an argument. */
1804
ec94af83
DE
1805 if (VEC_length (symtab_ptr, ls->file_symtabs) == 1
1806 && VEC_index (symtab_ptr, ls->file_symtabs, 0) == NULL)
3d50dd94 1807 {
05cba821
JK
1808 const char *fullname;
1809
40e084e1 1810 set_current_program_space (self->program_space);
c00f8484 1811
40e084e1
KS
1812 /* Make sure we have at least a default source line. */
1813 set_default_source_symtab_and_line ();
1814 initialize_defaults (&self->default_symtab, &self->default_line);
05cba821 1815 fullname = symtab_to_fullname (self->default_symtab);
ec94af83
DE
1816 VEC_pop (symtab_ptr, ls->file_symtabs);
1817 VEC_free (symtab_ptr, ls->file_symtabs);
c2f4122d
PA
1818 ls->file_symtabs = collect_symtabs_from_filename (fullname,
1819 self->search_pspace);
40e084e1
KS
1820 use_default = 1;
1821 }
c00f8484 1822
67994074
KS
1823 val.line = ls->explicit_loc.line_offset.offset;
1824 switch (ls->explicit_loc.line_offset.sign)
40e084e1
KS
1825 {
1826 case LINE_OFFSET_PLUS:
67994074 1827 if (ls->explicit_loc.line_offset.offset == 0)
40e084e1
KS
1828 val.line = 5;
1829 if (use_default)
1830 val.line = self->default_line + val.line;
1831 break;
1832
1833 case LINE_OFFSET_MINUS:
67994074 1834 if (ls->explicit_loc.line_offset.offset == 0)
40e084e1
KS
1835 val.line = 15;
1836 if (use_default)
1837 val.line = self->default_line - val.line;
1838 else
1839 val.line = -val.line;
1840 break;
1841
1842 case LINE_OFFSET_NONE:
1843 break; /* No need to adjust val.line. */
1844 }
1845
1846 if (self->list_mode)
1847 decode_digits_list_mode (self, ls, &values, val);
1848 else
1849 {
1850 struct linetable_entry *best_entry = NULL;
1851 int *filter;
3977b71f 1852 const struct block **blocks;
40e084e1
KS
1853 struct cleanup *cleanup;
1854 struct symtabs_and_lines intermediate_results;
1855 int i, j;
1856
1857 intermediate_results.sals = NULL;
1858 intermediate_results.nelts = 0;
1859
1860 decode_digits_ordinary (self, ls, val.line, &intermediate_results,
1861 &best_entry);
1862 if (intermediate_results.nelts == 0 && best_entry != NULL)
1863 decode_digits_ordinary (self, ls, best_entry->line,
1864 &intermediate_results, &best_entry);
1865
1866 cleanup = make_cleanup (xfree, intermediate_results.sals);
1867
1868 /* For optimized code, the compiler can scatter one source line
1869 across disjoint ranges of PC values, even when no duplicate
1870 functions or inline functions are involved. For example,
1871 'for (;;)' inside a non-template, non-inline, and non-ctor-or-dtor
1872 function can result in two PC ranges. In this case, we don't
1873 want to set a breakpoint on the first PC of each range. To filter
1874 such cases, we use containing blocks -- for each PC found
1875 above, we see if there are other PCs that are in the same
1876 block. If yes, the other PCs are filtered out. */
1877
1878 filter = XNEWVEC (int, intermediate_results.nelts);
1879 make_cleanup (xfree, filter);
3977b71f 1880 blocks = XNEWVEC (const struct block *, intermediate_results.nelts);
40e084e1
KS
1881 make_cleanup (xfree, blocks);
1882
1883 for (i = 0; i < intermediate_results.nelts; ++i)
3d50dd94 1884 {
40e084e1 1885 set_current_program_space (intermediate_results.sals[i].pspace);
c00f8484 1886
40e084e1
KS
1887 filter[i] = 1;
1888 blocks[i] = block_for_pc_sect (intermediate_results.sals[i].pc,
1889 intermediate_results.sals[i].section);
3d50dd94 1890 }
c00f8484 1891
40e084e1
KS
1892 for (i = 0; i < intermediate_results.nelts; ++i)
1893 {
1894 if (blocks[i] != NULL)
1895 for (j = i + 1; j < intermediate_results.nelts; ++j)
1896 {
1897 if (blocks[j] == blocks[i])
1898 {
1899 filter[j] = 0;
1900 break;
1901 }
1902 }
1903 }
c00f8484 1904
40e084e1
KS
1905 for (i = 0; i < intermediate_results.nelts; ++i)
1906 if (filter[i])
1907 {
1908 struct symbol *sym = (blocks[i]
1909 ? block_containing_function (blocks[i])
1910 : NULL);
3d50dd94 1911
40e084e1
KS
1912 if (self->funfirstline)
1913 skip_prologue_sal (&intermediate_results.sals[i]);
1914 /* Make sure the line matches the request, not what was
1915 found. */
1916 intermediate_results.sals[i].line = val.line;
1917 add_sal_to_sals (self, &values, &intermediate_results.sals[i],
66f1999b 1918 sym ? SYMBOL_NATURAL_NAME (sym) : NULL, 0);
40e084e1 1919 }
3d50dd94 1920
40e084e1 1921 do_cleanups (cleanup);
f17170e5 1922 }
c00f8484 1923
40e084e1
KS
1924 if (values.nelts == 0)
1925 {
67994074 1926 if (ls->explicit_loc.source_filename)
40e084e1 1927 throw_error (NOT_FOUND_ERROR, _("No line %d in file \"%s\"."),
67994074 1928 val.line, ls->explicit_loc.source_filename);
40e084e1
KS
1929 else
1930 throw_error (NOT_FOUND_ERROR, _("No line %d in the current file."),
1931 val.line);
1932 }
3d50dd94 1933
40e084e1 1934 return values;
c00f8484
KS
1935}
1936
a06efdd6
KS
1937/* Convert the given ADDRESS into SaLs. */
1938
1939static struct symtabs_and_lines
1940convert_address_location_to_sals (struct linespec_state *self,
1941 CORE_ADDR address)
1942{
1943 struct symtab_and_line sal;
1944 struct symtabs_and_lines sals = {NULL, 0};
1945
1946 sal = find_pc_line (address, 0);
1947 sal.pc = address;
1948 sal.section = find_pc_overlay (address);
1949 sal.explicit_pc = 1;
1950 add_sal_to_sals (self, &sals, &sal, core_addr_to_string (address), 1);
1951
1952 return sals;
1953}
1954
40e084e1
KS
1955/* Create and return SALs from the linespec LS. */
1956
1957static struct symtabs_and_lines
1958convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)
1959{
1960 struct symtabs_and_lines sals = {NULL, 0};
1961
a06efdd6 1962 if (ls->labels.label_symbols != NULL)
40e084e1
KS
1963 {
1964 /* We have just a bunch of functions/methods or labels. */
1965 int i;
1966 struct symtab_and_line sal;
1967 struct symbol *sym;
1968
1969 for (i = 0; VEC_iterate (symbolp, ls->labels.label_symbols, i, sym); ++i)
1970 {
08be3fe3 1971 struct program_space *pspace = SYMTAB_PSPACE (symbol_symtab (sym));
fdbb204b
TT
1972
1973 if (symbol_to_sal (&sal, state->funfirstline, sym)
1974 && maybe_add_address (state->addr_set, pspace, sal.pc))
64b92e45
KS
1975 add_sal_to_sals (state, &sals, &sal,
1976 SYMBOL_NATURAL_NAME (sym), 0);
40e084e1
KS
1977 }
1978 }
1979 else if (ls->function_symbols != NULL || ls->minimal_symbols != NULL)
1980 {
1981 /* We have just a bunch of functions and/or methods. */
1982 int i;
1983 struct symtab_and_line sal;
1984 struct symbol *sym;
f60e2d5c 1985 bound_minimal_symbol_d *elem;
40e084e1
KS
1986 struct program_space *pspace;
1987
1988 if (ls->function_symbols != NULL)
1989 {
1990 /* Sort symbols so that symbols with the same program space are next
1991 to each other. */
1992 qsort (VEC_address (symbolp, ls->function_symbols),
1993 VEC_length (symbolp, ls->function_symbols),
1994 sizeof (symbolp), compare_symbols);
1995
1996 for (i = 0; VEC_iterate (symbolp, ls->function_symbols, i, sym); ++i)
1997 {
08be3fe3 1998 pspace = SYMTAB_PSPACE (symbol_symtab (sym));
40e084e1 1999 set_current_program_space (pspace);
64b92e45
KS
2000 if (symbol_to_sal (&sal, state->funfirstline, sym)
2001 && maybe_add_address (state->addr_set, pspace, sal.pc))
66f1999b
KS
2002 add_sal_to_sals (state, &sals, &sal,
2003 SYMBOL_NATURAL_NAME (sym), 0);
40e084e1
KS
2004 }
2005 }
2006
2007 if (ls->minimal_symbols != NULL)
2008 {
2009 /* Sort minimal symbols by program space, too. */
f60e2d5c
TT
2010 qsort (VEC_address (bound_minimal_symbol_d, ls->minimal_symbols),
2011 VEC_length (bound_minimal_symbol_d, ls->minimal_symbols),
2012 sizeof (bound_minimal_symbol_d), compare_msymbols);
40e084e1
KS
2013
2014 for (i = 0;
f60e2d5c
TT
2015 VEC_iterate (bound_minimal_symbol_d, ls->minimal_symbols,
2016 i, elem);
40e084e1
KS
2017 ++i)
2018 {
001822aa 2019 pspace = elem->objfile->pspace;
40e084e1
KS
2020 set_current_program_space (pspace);
2021 minsym_found (state, elem->objfile, elem->minsym, &sals);
2022 }
2023 }
2024 }
67994074 2025 else if (ls->explicit_loc.line_offset.sign != LINE_OFFSET_UNKNOWN)
40e084e1
KS
2026 {
2027 /* Only an offset was specified. */
2028 sals = create_sals_line_offset (state, ls);
2029
2030 /* Make sure we have a filename for canonicalization. */
67994074 2031 if (ls->explicit_loc.source_filename == NULL)
05cba821
JK
2032 {
2033 const char *fullname = symtab_to_fullname (state->default_symtab);
2034
e93ba630
JK
2035 /* It may be more appropriate to keep DEFAULT_SYMTAB in its symtab
2036 form so that displaying SOURCE_FILENAME can follow the current
2037 FILENAME_DISPLAY_STRING setting. But as it is used only rarely
2038 it has been kept for code simplicity only in absolute form. */
67994074 2039 ls->explicit_loc.source_filename = xstrdup (fullname);
05cba821 2040 }
40e084e1
KS
2041 }
2042 else
2043 {
2044 /* We haven't found any results... */
2045 return sals;
2046 }
2047
2048 canonicalize_linespec (state, ls);
2049
2050 if (sals.nelts > 0 && state->canonical != NULL)
2051 state->canonical->pre_expanded = 1;
2052
2053 return sals;
2054}
50641945 2055
67994074 2056/* Convert the explicit location EXPLICIT_LOC into SaLs. */
00e52e53
KS
2057
2058static struct symtabs_and_lines
2059convert_explicit_location_to_sals (struct linespec_state *self,
2060 linespec_p result,
67994074 2061 const struct explicit_location *explicit_loc)
00e52e53
KS
2062{
2063 VEC (symbolp) *symbols, *labels;
2064 VEC (bound_minimal_symbol_d) *minimal_symbols;
2065
67994074 2066 if (explicit_loc->source_filename != NULL)
00e52e53
KS
2067 {
2068 TRY
2069 {
2070 result->file_symtabs
c2f4122d
PA
2071 = symtabs_from_filename (explicit_loc->source_filename,
2072 self->search_pspace);
00e52e53
KS
2073 }
2074 CATCH (except, RETURN_MASK_ERROR)
2075 {
67994074 2076 source_file_not_found_error (explicit_loc->source_filename);
00e52e53
KS
2077 }
2078 END_CATCH
67994074
KS
2079 result->explicit_loc.source_filename
2080 = xstrdup (explicit_loc->source_filename);
00e52e53
KS
2081 }
2082 else
2083 {
2084 /* A NULL entry means to use the default symtab. */
2085 VEC_safe_push (symtab_ptr, result->file_symtabs, NULL);
2086 }
2087
67994074 2088 if (explicit_loc->function_name != NULL)
00e52e53
KS
2089 {
2090 find_linespec_symbols (self, result->file_symtabs,
67994074 2091 explicit_loc->function_name, &symbols,
00e52e53
KS
2092 &minimal_symbols);
2093
2094 if (symbols == NULL && minimal_symbols == NULL)
67994074
KS
2095 symbol_not_found_error (explicit_loc->function_name,
2096 result->explicit_loc.source_filename);
00e52e53 2097
67994074
KS
2098 result->explicit_loc.function_name
2099 = xstrdup (explicit_loc->function_name);
00e52e53
KS
2100 result->function_symbols = symbols;
2101 result->minimal_symbols = minimal_symbols;
2102 }
2103
67994074 2104 if (explicit_loc->label_name != NULL)
00e52e53
KS
2105 {
2106 symbols = NULL;
2107 labels = find_label_symbols (self, result->function_symbols,
67994074 2108 &symbols, explicit_loc->label_name);
00e52e53
KS
2109
2110 if (labels == NULL)
67994074
KS
2111 undefined_label_error (result->explicit_loc.function_name,
2112 explicit_loc->label_name);
00e52e53 2113
67994074 2114 result->explicit_loc.label_name = xstrdup (explicit_loc->label_name);
00e52e53
KS
2115 result->labels.label_symbols = labels;
2116 result->labels.function_symbols = symbols;
2117 }
2118
67994074
KS
2119 if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
2120 result->explicit_loc.line_offset = explicit_loc->line_offset;
00e52e53
KS
2121
2122 return convert_linespec_to_sals (self, result);
2123}
2124
40e084e1 2125/* Parse a string that specifies a linespec.
50641945 2126
40e084e1 2127 The basic grammar of linespecs:
50641945 2128
a06efdd6 2129 linespec -> var_spec | basic_spec
40e084e1 2130 var_spec -> '$' (STRING | NUMBER)
50641945 2131
40e084e1
KS
2132 basic_spec -> file_offset_spec | function_spec | label_spec
2133 file_offset_spec -> opt_file_spec offset_spec
2134 function_spec -> opt_file_spec function_name_spec opt_label_spec
2135 label_spec -> label_name_spec
50641945 2136
40e084e1
KS
2137 opt_file_spec -> "" | file_name_spec ':'
2138 opt_label_spec -> "" | ':' label_name_spec
2139
2140 file_name_spec -> STRING
2141 function_name_spec -> STRING
2142 label_name_spec -> STRING
2143 function_name_spec -> STRING
2144 offset_spec -> NUMBER
2145 -> '+' NUMBER
2146 -> '-' NUMBER
2147
2148 This may all be followed by several keywords such as "if EXPR",
2149 which we ignore.
2150
2151 A comma will terminate parsing.
2152
2153 The function may be an undebuggable function found in minimal symbol table.
50641945
FN
2154
2155 If the argument FUNFIRSTLINE is nonzero, we want the first line
2156 of real code inside a function when a function is specified, and it is
2157 not OK to specify a variable or type to get its line number.
2158
2159 DEFAULT_SYMTAB specifies the file to use if none is specified.
2160 It defaults to current_source_symtab.
2161 DEFAULT_LINE specifies the line number to use for relative
2162 line numbers (that start with signs). Defaults to current_source_line.
2163 If CANONICAL is non-NULL, store an array of strings containing the canonical
1777feb0 2164 line specs there if necessary. Currently overloaded member functions and
50641945 2165 line numbers or static functions without a filename yield a canonical
1777feb0 2166 line spec. The array and the line spec strings are allocated on the heap,
50641945
FN
2167 it is the callers responsibility to free them.
2168
2169 Note that it is possible to return zero for the symtab
2170 if no file is validly specified. Callers must check that.
58438ac1 2171 Also, the line number returned may be invalid. */
50641945 2172
f00aae0f 2173/* Parse the linespec in ARG. */
50641945 2174
ad32032e 2175static struct symtabs_and_lines
f00aae0f 2176parse_linespec (linespec_parser *parser, const char *arg)
50641945 2177{
40e084e1
KS
2178 linespec_token token;
2179 struct symtabs_and_lines values;
7556d4a4 2180 struct gdb_exception file_exception = exception_none;
40e084e1
KS
2181 struct cleanup *cleanup;
2182
2183 /* A special case to start. It has become quite popular for
2184 IDEs to work around bugs in the previous parser by quoting
2185 the entire linespec, so we attempt to deal with this nicely. */
2186 parser->is_quote_enclosed = 0;
f00aae0f
KS
2187 if (!is_ada_operator (arg)
2188 && strchr (linespec_quote_characters, *arg) != NULL)
40e084e1
KS
2189 {
2190 const char *end;
9ef07c8c 2191
f00aae0f 2192 end = skip_quote_char (arg + 1, *arg);
40e084e1 2193 if (end != NULL && is_closing_quote_enclosed (end))
136e1c30 2194 {
f00aae0f 2195 /* Here's the special case. Skip ARG past the initial
40e084e1 2196 quote. */
f00aae0f 2197 ++arg;
40e084e1 2198 parser->is_quote_enclosed = 1;
136e1c30
DE
2199 }
2200 }
e8eb7bc5 2201
f00aae0f
KS
2202 parser->lexer.saved_arg = arg;
2203 parser->lexer.stream = arg;
d2630e69 2204
40e084e1
KS
2205 /* Initialize the default symtab and line offset. */
2206 initialize_defaults (&PARSER_STATE (parser)->default_symtab,
2207 &PARSER_STATE (parser)->default_line);
d2630e69 2208
40e084e1 2209 /* Objective-C shortcut. */
f00aae0f 2210 values = decode_objc (PARSER_STATE (parser), PARSER_RESULT (parser), arg);
40e084e1
KS
2211 if (values.sals != NULL)
2212 return values;
e0881a8e 2213
40e084e1 2214 /* Start parsing. */
d2630e69 2215
40e084e1
KS
2216 /* Get the first token. */
2217 token = linespec_lexer_lex_one (parser);
50641945 2218
40e084e1 2219 /* It must be either LSTOKEN_STRING or LSTOKEN_NUMBER. */
a06efdd6 2220 if (token.type == LSTOKEN_STRING && *LS_TOKEN_STOKEN (token).ptr == '$')
40e084e1
KS
2221 {
2222 char *var;
50641945 2223
40e084e1 2224 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
ec94af83 2225 VEC_safe_push (symtab_ptr, PARSER_RESULT (parser)->file_symtabs, NULL);
dcf9f4ab 2226
40e084e1
KS
2227 /* User specified a convenience variable or history value. */
2228 var = copy_token_string (token);
2229 cleanup = make_cleanup (xfree, var);
00e52e53 2230 PARSER_EXPLICIT (parser)->line_offset
40e084e1 2231 = linespec_parse_variable (PARSER_STATE (parser), var);
cf4ded82 2232 do_cleanups (cleanup);
f8eba3c6 2233
40e084e1
KS
2234 /* If a line_offset wasn't found (VAR is the name of a user
2235 variable/function), then skip to normal symbol processing. */
00e52e53 2236 if (PARSER_EXPLICIT (parser)->line_offset.sign != LINE_OFFSET_UNKNOWN)
40e084e1 2237 {
40e084e1
KS
2238 /* Consume this token. */
2239 linespec_lexer_consume_token (parser);
dcf9f4ab 2240
40e084e1 2241 goto convert_to_sals;
50641945 2242 }
40e084e1
KS
2243 }
2244 else if (token.type != LSTOKEN_STRING && token.type != LSTOKEN_NUMBER)
2245 unexpected_linespec_error (parser);
50641945 2246
40e084e1
KS
2247 /* Shortcut: If the next token is not LSTOKEN_COLON, we know that
2248 this token cannot represent a filename. */
2249 token = linespec_lexer_peek_token (parser);
0e0b460e 2250
40e084e1 2251 if (token.type == LSTOKEN_COLON)
0e0b460e 2252 {
40e084e1 2253 char *user_filename;
0e0b460e 2254
40e084e1
KS
2255 /* Get the current token again and extract the filename. */
2256 token = linespec_lexer_lex_one (parser);
2257 user_filename = copy_token_string (token);
50641945 2258
40e084e1 2259 /* Check if the input is a filename. */
492d29ea 2260 TRY
40e084e1
KS
2261 {
2262 PARSER_RESULT (parser)->file_symtabs
c2f4122d
PA
2263 = symtabs_from_filename (user_filename,
2264 PARSER_STATE (parser)->search_pspace);
40e084e1 2265 }
492d29ea 2266 CATCH (ex, RETURN_MASK_ERROR)
7556d4a4
PA
2267 {
2268 file_exception = ex;
2269 }
492d29ea 2270 END_CATCH
50641945 2271
40e084e1
KS
2272 if (file_exception.reason >= 0)
2273 {
2274 /* Symtabs were found for the file. Record the filename. */
00e52e53 2275 PARSER_EXPLICIT (parser)->source_filename = user_filename;
f8eba3c6 2276
40e084e1
KS
2277 /* Get the next token. */
2278 token = linespec_lexer_consume_token (parser);
50641945 2279
40e084e1
KS
2280 /* This is LSTOKEN_COLON; consume it. */
2281 linespec_lexer_consume_token (parser);
2282 }
2283 else
2284 {
2285 /* No symtabs found -- discard user_filename. */
2286 xfree (user_filename);
50641945 2287
40e084e1 2288 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
ec94af83 2289 VEC_safe_push (symtab_ptr, PARSER_RESULT (parser)->file_symtabs, NULL);
40e084e1 2290 }
50641945 2291 }
40e084e1
KS
2292 /* If the next token is not EOI, KEYWORD, or COMMA, issue an error. */
2293 else if (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD
2294 && token.type != LSTOKEN_COMMA)
d2630e69 2295 {
40e084e1
KS
2296 /* TOKEN is the _next_ token, not the one currently in the parser.
2297 Consuming the token will give the correct error message. */
2298 linespec_lexer_consume_token (parser);
2299 unexpected_linespec_error (parser);
d2630e69 2300 }
50641945
FN
2301 else
2302 {
40e084e1 2303 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
ec94af83 2304 VEC_safe_push (symtab_ptr, PARSER_RESULT (parser)->file_symtabs, NULL);
50641945 2305 }
50641945 2306
40e084e1
KS
2307 /* Parse the rest of the linespec. */
2308 linespec_parse_basic (parser);
50641945 2309
40e084e1
KS
2310 if (PARSER_RESULT (parser)->function_symbols == NULL
2311 && PARSER_RESULT (parser)->labels.label_symbols == NULL
00e52e53 2312 && PARSER_EXPLICIT (parser)->line_offset.sign == LINE_OFFSET_UNKNOWN
40e084e1 2313 && PARSER_RESULT (parser)->minimal_symbols == NULL)
f8eba3c6 2314 {
40e084e1
KS
2315 /* The linespec didn't parse. Re-throw the file exception if
2316 there was one. */
2317 if (file_exception.reason < 0)
2318 throw_exception (file_exception);
0f5238ed 2319
40e084e1 2320 /* Otherwise, the symbol is not found. */
00e52e53
KS
2321 symbol_not_found_error (PARSER_EXPLICIT (parser)->function_name,
2322 PARSER_EXPLICIT (parser)->source_filename);
0f5238ed
TT
2323 }
2324
40e084e1 2325 convert_to_sals:
9ef07c8c 2326
40e084e1
KS
2327 /* Get the last token and record how much of the input was parsed,
2328 if necessary. */
2329 token = linespec_lexer_lex_one (parser);
2330 if (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD)
2331 PARSER_STREAM (parser) = LS_TOKEN_STOKEN (token).ptr;
50641945 2332
40e084e1
KS
2333 /* Convert the data in PARSER_RESULT to SALs. */
2334 values = convert_linespec_to_sals (PARSER_STATE (parser),
2335 PARSER_RESULT (parser));
f8eba3c6 2336
40e084e1 2337 return values;
413dad4d 2338}
50641945 2339
40e084e1 2340
f8eba3c6 2341/* A constructor for linespec_state. */
44fe14ab 2342
f8eba3c6
TT
2343static void
2344linespec_state_constructor (struct linespec_state *self,
40e084e1 2345 int flags, const struct language_defn *language,
c2f4122d 2346 struct program_space *search_pspace,
f8eba3c6
TT
2347 struct symtab *default_symtab,
2348 int default_line,
2349 struct linespec_result *canonical)
2350{
2351 memset (self, 0, sizeof (*self));
40e084e1 2352 self->language = language;
f8eba3c6
TT
2353 self->funfirstline = (flags & DECODE_LINE_FUNFIRSTLINE) ? 1 : 0;
2354 self->list_mode = (flags & DECODE_LINE_LIST_MODE) ? 1 : 0;
c2f4122d 2355 self->search_pspace = search_pspace;
f8eba3c6
TT
2356 self->default_symtab = default_symtab;
2357 self->default_line = default_line;
2358 self->canonical = canonical;
2359 self->program_space = current_program_space;
2360 self->addr_set = htab_create_alloc (10, hash_address_entry, eq_address_entry,
2361 xfree, xcalloc, xfree);
00e52e53 2362 self->is_linespec = 0;
f8eba3c6 2363}
44fe14ab 2364
40e084e1 2365/* Initialize a new linespec parser. */
44fe14ab
DC
2366
2367static void
40e084e1
KS
2368linespec_parser_new (linespec_parser *parser,
2369 int flags, const struct language_defn *language,
c2f4122d 2370 struct program_space *search_pspace,
40e084e1
KS
2371 struct symtab *default_symtab,
2372 int default_line,
2373 struct linespec_result *canonical)
44fe14ab 2374{
f00aae0f 2375 memset (parser, 0, sizeof (linespec_parser));
40e084e1
KS
2376 parser->lexer.current.type = LSTOKEN_CONSUMED;
2377 memset (PARSER_RESULT (parser), 0, sizeof (struct linespec));
00e52e53 2378 PARSER_EXPLICIT (parser)->line_offset.sign = LINE_OFFSET_UNKNOWN;
40e084e1 2379 linespec_state_constructor (PARSER_STATE (parser), flags, language,
c2f4122d 2380 search_pspace,
40e084e1
KS
2381 default_symtab, default_line, canonical);
2382}
2383
2384/* A destructor for linespec_state. */
44fe14ab 2385
40e084e1
KS
2386static void
2387linespec_state_destructor (struct linespec_state *self)
2388{
f8eba3c6
TT
2389 htab_delete (self->addr_set);
2390}
44fe14ab 2391
40e084e1
KS
2392/* Delete a linespec parser. */
2393
2394static void
2395linespec_parser_delete (void *arg)
2396{
2397 linespec_parser *parser = (linespec_parser *) arg;
2398
00e52e53
KS
2399 xfree (PARSER_EXPLICIT (parser)->source_filename);
2400 xfree (PARSER_EXPLICIT (parser)->label_name);
2401 xfree (PARSER_EXPLICIT (parser)->function_name);
40e084e1
KS
2402
2403 if (PARSER_RESULT (parser)->file_symtabs != NULL)
ec94af83 2404 VEC_free (symtab_ptr, PARSER_RESULT (parser)->file_symtabs);
40e084e1
KS
2405
2406 if (PARSER_RESULT (parser)->function_symbols != NULL)
2407 VEC_free (symbolp, PARSER_RESULT (parser)->function_symbols);
2408
2409 if (PARSER_RESULT (parser)->minimal_symbols != NULL)
f60e2d5c 2410 VEC_free (bound_minimal_symbol_d, PARSER_RESULT (parser)->minimal_symbols);
40e084e1
KS
2411
2412 if (PARSER_RESULT (parser)->labels.label_symbols != NULL)
2413 VEC_free (symbolp, PARSER_RESULT (parser)->labels.label_symbols);
2414
2415 if (PARSER_RESULT (parser)->labels.function_symbols != NULL)
2416 VEC_free (symbolp, PARSER_RESULT (parser)->labels.function_symbols);
2417
2418 linespec_state_destructor (PARSER_STATE (parser));
2419}
2420
c7c1b3e9
KS
2421/* See description in linespec.h. */
2422
2423void
2424linespec_lex_to_end (char **stringp)
2425{
2426 linespec_parser parser;
2427 struct cleanup *cleanup;
2428 linespec_token token;
c7c1b3e9
KS
2429 const char *orig;
2430
2431 if (stringp == NULL || *stringp == NULL)
2432 return;
2433
c2f4122d 2434 linespec_parser_new (&parser, 0, current_language, NULL, NULL, 0, NULL);
c7c1b3e9
KS
2435 cleanup = make_cleanup (linespec_parser_delete, &parser);
2436 parser.lexer.saved_arg = *stringp;
2437 PARSER_STREAM (&parser) = orig = *stringp;
2438
2439 do
2440 {
2441 /* Stop before any comma tokens; we need it to keep it
2442 as the next token in the string. */
2443 token = linespec_lexer_peek_token (&parser);
2444 if (token.type == LSTOKEN_COMMA)
2445 break;
c7c1b3e9
KS
2446 token = linespec_lexer_consume_token (&parser);
2447 }
2448 while (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD);
2449
2450 *stringp += PARSER_STREAM (&parser) - orig;
2451 do_cleanups (cleanup);
2452}
2453
f00aae0f
KS
2454/* A helper function for decode_line_full and decode_line_1 to
2455 turn LOCATION into symtabs_and_lines. */
2456
2457static struct symtabs_and_lines
2458event_location_to_sals (linespec_parser *parser,
2459 const struct event_location *location)
2460{
2461 struct symtabs_and_lines result = {NULL, 0};
2462
2463 switch (event_location_type (location))
2464 {
2465 case LINESPEC_LOCATION:
2466 {
00e52e53 2467 PARSER_STATE (parser)->is_linespec = 1;
f00aae0f
KS
2468 TRY
2469 {
2470 result = parse_linespec (parser, get_linespec_location (location));
2471 }
2472 CATCH (except, RETURN_MASK_ERROR)
2473 {
2474 throw_exception (except);
2475 }
2476 END_CATCH
2477 }
2478 break;
2479
a06efdd6 2480 case ADDRESS_LOCATION:
305e13e6
JB
2481 {
2482 const char *addr_string = get_address_string_location (location);
2483 CORE_ADDR addr = get_address_location (location);
2484
2485 if (addr_string != NULL)
2486 {
2487 char *expr = xstrdup (addr_string);
2488 const char *const_expr = expr;
2489 struct cleanup *cleanup = make_cleanup (xfree, expr);
2490
2491 addr = linespec_expression_to_pc (&const_expr);
2492 if (PARSER_STATE (parser)->canonical != NULL)
2493 PARSER_STATE (parser)->canonical->location
ffc2605c 2494 = copy_event_location (location).release ();
305e13e6
JB
2495
2496 do_cleanups (cleanup);
2497 }
2498
2499 result = convert_address_location_to_sals (PARSER_STATE (parser),
2500 addr);
2501 }
a06efdd6
KS
2502 break;
2503
00e52e53
KS
2504 case EXPLICIT_LOCATION:
2505 {
67994074 2506 const struct explicit_location *explicit_loc;
00e52e53 2507
67994074 2508 explicit_loc = get_explicit_location_const (location);
00e52e53
KS
2509 result = convert_explicit_location_to_sals (PARSER_STATE (parser),
2510 PARSER_RESULT (parser),
67994074 2511 explicit_loc);
00e52e53
KS
2512 }
2513 break;
2514
5b56227b
KS
2515 case PROBE_LOCATION:
2516 /* Probes are handled by their own decoders. */
2517 gdb_assert_not_reached ("attempt to decode probe location");
2518 break;
2519
f00aae0f
KS
2520 default:
2521 gdb_assert_not_reached ("unhandled event location type");
2522 }
2523
2524 return result;
2525}
2526
f8eba3c6 2527/* See linespec.h. */
44fe14ab 2528
f8eba3c6 2529void
f00aae0f 2530decode_line_full (const struct event_location *location, int flags,
c2f4122d 2531 struct program_space *search_pspace,
f8eba3c6
TT
2532 struct symtab *default_symtab,
2533 int default_line, struct linespec_result *canonical,
2534 const char *select_mode,
2535 const char *filter)
44fe14ab 2536{
f8eba3c6 2537 struct symtabs_and_lines result;
f8eba3c6 2538 struct cleanup *cleanups;
f8eba3c6 2539 VEC (const_char_ptr) *filters = NULL;
40e084e1
KS
2540 linespec_parser parser;
2541 struct linespec_state *state;
f8eba3c6
TT
2542
2543 gdb_assert (canonical != NULL);
2544 /* The filter only makes sense for 'all'. */
2545 gdb_assert (filter == NULL || select_mode == multiple_symbols_all);
2546 gdb_assert (select_mode == NULL
2547 || select_mode == multiple_symbols_all
2548 || select_mode == multiple_symbols_ask
2549 || select_mode == multiple_symbols_cancel);
2550 gdb_assert ((flags & DECODE_LINE_LIST_MODE) == 0);
2551
c2f4122d
PA
2552 linespec_parser_new (&parser, flags, current_language,
2553 search_pspace, default_symtab,
40e084e1
KS
2554 default_line, canonical);
2555 cleanups = make_cleanup (linespec_parser_delete, &parser);
f8eba3c6
TT
2556 save_current_program_space ();
2557
f00aae0f 2558 result = event_location_to_sals (&parser, location);
40e084e1 2559 state = PARSER_STATE (&parser);
f8eba3c6
TT
2560
2561 gdb_assert (result.nelts == 1 || canonical->pre_expanded);
f8eba3c6
TT
2562 canonical->pre_expanded = 1;
2563
66f1999b 2564 /* Arrange for allocated canonical names to be freed. */
f8eba3c6
TT
2565 if (result.nelts > 0)
2566 {
2567 int i;
2568
40e084e1 2569 make_cleanup (xfree, state->canonical_names);
f8eba3c6
TT
2570 for (i = 0; i < result.nelts; ++i)
2571 {
33f448b1
JK
2572 gdb_assert (state->canonical_names[i].suffix != NULL);
2573 make_cleanup (xfree, state->canonical_names[i].suffix);
f8eba3c6
TT
2574 }
2575 }
2576
2577 if (select_mode == NULL)
2578 {
112e8700 2579 if (interp_ui_out (top_level_interpreter ())->is_mi_like_p ())
f8eba3c6
TT
2580 select_mode = multiple_symbols_all;
2581 else
2582 select_mode = multiple_symbols_select_mode ();
2583 }
2584
2585 if (select_mode == multiple_symbols_all)
2586 {
2587 if (filter != NULL)
2588 {
2589 make_cleanup (VEC_cleanup (const_char_ptr), &filters);
2590 VEC_safe_push (const_char_ptr, filters, filter);
40e084e1 2591 filter_results (state, &result, filters);
f8eba3c6
TT
2592 }
2593 else
40e084e1 2594 convert_results_to_lsals (state, &result);
f8eba3c6
TT
2595 }
2596 else
40e084e1 2597 decode_line_2 (state, &result, select_mode);
f8eba3c6
TT
2598
2599 do_cleanups (cleanups);
2600}
2601
39cf75f7
DE
2602/* See linespec.h. */
2603
f8eba3c6 2604struct symtabs_and_lines
f00aae0f 2605decode_line_1 (const struct event_location *location, int flags,
c2f4122d 2606 struct program_space *search_pspace,
f8eba3c6
TT
2607 struct symtab *default_symtab,
2608 int default_line)
2609{
2610 struct symtabs_and_lines result;
40e084e1 2611 linespec_parser parser;
f8eba3c6
TT
2612 struct cleanup *cleanups;
2613
c2f4122d
PA
2614 linespec_parser_new (&parser, flags, current_language,
2615 search_pspace, default_symtab,
40e084e1
KS
2616 default_line, NULL);
2617 cleanups = make_cleanup (linespec_parser_delete, &parser);
f8eba3c6
TT
2618 save_current_program_space ();
2619
f00aae0f 2620 result = event_location_to_sals (&parser, location);
40e084e1 2621
f8eba3c6
TT
2622 do_cleanups (cleanups);
2623 return result;
2624}
2625
39cf75f7
DE
2626/* See linespec.h. */
2627
2628struct symtabs_and_lines
2629decode_line_with_current_source (char *string, int flags)
2630{
2631 struct symtabs_and_lines sals;
2632 struct symtab_and_line cursal;
2633
2634 if (string == 0)
2635 error (_("Empty line specification."));
2636
2637 /* We use whatever is set as the current source line. We do not try
2638 and get a default source symtab+line or it will recursively call us! */
2639 cursal = get_current_source_symtab_and_line ();
2640
ffc2605c
TT
2641 event_location_up location = string_to_event_location (&string,
2642 current_language);
2643 sals = decode_line_1 (location.get (), flags, NULL,
39cf75f7
DE
2644 cursal.symtab, cursal.line);
2645
2646 if (*string)
2647 error (_("Junk at end of line specification: %s"), string);
f00aae0f 2648
39cf75f7
DE
2649 return sals;
2650}
2651
2652/* See linespec.h. */
2653
2654struct symtabs_and_lines
2655decode_line_with_last_displayed (char *string, int flags)
2656{
2657 struct symtabs_and_lines sals;
2658
2659 if (string == 0)
2660 error (_("Empty line specification."));
2661
ffc2605c
TT
2662 event_location_up location = string_to_event_location (&string,
2663 current_language);
39cf75f7 2664 if (last_displayed_sal_is_valid ())
ffc2605c 2665 sals = decode_line_1 (location.get (), flags, NULL,
39cf75f7
DE
2666 get_last_displayed_symtab (),
2667 get_last_displayed_line ());
2668 else
ffc2605c
TT
2669 sals = decode_line_1 (location.get (), flags, NULL,
2670 (struct symtab *) NULL, 0);
39cf75f7
DE
2671
2672 if (*string)
2673 error (_("Junk at end of line specification: %s"), string);
f00aae0f 2674
39cf75f7
DE
2675 return sals;
2676}
2677
f8eba3c6
TT
2678\f
2679
2680/* First, some functions to initialize stuff at the beggining of the
2681 function. */
2682
2683static void
2684initialize_defaults (struct symtab **default_symtab, int *default_line)
2685{
2686 if (*default_symtab == 0)
2687 {
2688 /* Use whatever we have for the default source line. We don't use
2689 get_current_or_default_symtab_and_line as it can recurse and call
2690 us back! */
2691 struct symtab_and_line cursal =
2692 get_current_source_symtab_and_line ();
2693
2694 *default_symtab = cursal.symtab;
2695 *default_line = cursal.line;
2696 }
2697}
2698
2699\f
2700
40e084e1
KS
2701/* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR,
2702 advancing EXP_PTR past any parsed text. */
f8eba3c6 2703
a06efdd6 2704CORE_ADDR
bbc13ae3 2705linespec_expression_to_pc (const char **exp_ptr)
f8eba3c6 2706{
f8eba3c6
TT
2707 if (current_program_space->executing_startup)
2708 /* The error message doesn't really matter, because this case
2709 should only hit during breakpoint reset. */
2710 throw_error (NOT_FOUND_ERROR, _("cannot evaluate expressions while "
2711 "program space is in startup"));
2712
40e084e1
KS
2713 (*exp_ptr)++;
2714 return value_as_address (parse_to_comma_and_eval (exp_ptr));
0960f083
DC
2715}
2716
2717\f
2718
d2630e69
AF
2719/* Here's where we recognise an Objective-C Selector. An Objective C
2720 selector may be implemented by more than one class, therefore it
2721 may represent more than one method/function. This gives us a
2722 situation somewhat analogous to C++ overloading. If there's more
2723 than one method that could represent the selector, then use some of
2724 the existing C++ code to let the user choose one. */
2725
f8eba3c6 2726static struct symtabs_and_lines
f00aae0f 2727decode_objc (struct linespec_state *self, linespec_p ls, const char *arg)
d2630e69 2728{
f8eba3c6
TT
2729 struct collect_info info;
2730 VEC (const_char_ptr) *symbol_names = NULL;
40e084e1 2731 struct symtabs_and_lines values;
d7561cbb 2732 const char *new_argptr;
f8eba3c6
TT
2733 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
2734 &symbol_names);
2735
2736 info.state = self;
40e084e1 2737 info.file_symtabs = NULL;
ec94af83
DE
2738 VEC_safe_push (symtab_ptr, info.file_symtabs, NULL);
2739 make_cleanup (VEC_cleanup (symtab_ptr), &info.file_symtabs);
40e084e1
KS
2740 info.result.symbols = NULL;
2741 info.result.minimal_symbols = NULL;
2742 values.nelts = 0;
2743 values.sals = NULL;
f8eba3c6 2744
f00aae0f 2745 new_argptr = find_imps (arg, &symbol_names);
f8eba3c6
TT
2746 if (VEC_empty (const_char_ptr, symbol_names))
2747 {
2748 do_cleanups (cleanup);
40e084e1 2749 return values;
f8eba3c6 2750 }
d2630e69 2751
f8eba3c6 2752 add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
d2630e69 2753
40e084e1 2754 if (!VEC_empty (symbolp, info.result.symbols)
f60e2d5c 2755 || !VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols))
d2630e69 2756 {
f8eba3c6 2757 char *saved_arg;
d2630e69 2758
224c3ddb 2759 saved_arg = (char *) alloca (new_argptr - arg + 1);
f00aae0f
KS
2760 memcpy (saved_arg, arg, new_argptr - arg);
2761 saved_arg[new_argptr - arg] = '\0';
d2630e69 2762
67994074 2763 ls->explicit_loc.function_name = xstrdup (saved_arg);
40e084e1
KS
2764 ls->function_symbols = info.result.symbols;
2765 ls->minimal_symbols = info.result.minimal_symbols;
2766 values = convert_linespec_to_sals (self, ls);
2767
f8eba3c6 2768 if (self->canonical)
d2630e69 2769 {
f00aae0f
KS
2770 char *str;
2771
f8eba3c6 2772 self->canonical->pre_expanded = 1;
f00aae0f 2773
67994074 2774 if (ls->explicit_loc.source_filename)
f00aae0f
KS
2775 {
2776 str = xstrprintf ("%s:%s",
67994074 2777 ls->explicit_loc.source_filename, saved_arg);
f00aae0f 2778 }
f8eba3c6 2779 else
f00aae0f
KS
2780 str = xstrdup (saved_arg);
2781
2782 make_cleanup (xfree, str);
ffc2605c 2783 self->canonical->location = new_linespec_location (&str).release ();
d2630e69 2784 }
d2630e69
AF
2785 }
2786
f8eba3c6 2787 do_cleanups (cleanup);
c00f8484 2788
40e084e1 2789 return values;
f8eba3c6 2790}
c00f8484 2791
ffdbe864
YQ
2792namespace {
2793
14bc53a8
PA
2794/* A function object that serves as symbol_found_callback_ftype
2795 callback for iterate_over_symbols. This is used by
2796 lookup_prefix_sym to collect type symbols. */
2797class decode_compound_collector
f8eba3c6 2798{
14bc53a8 2799public:
fc4007c9 2800 decode_compound_collector ()
14bc53a8 2801 : m_symbols (NULL)
fc4007c9 2802 {
14bc53a8
PA
2803 m_unique_syms = htab_create_alloc (1, htab_hash_pointer,
2804 htab_eq_pointer, NULL,
2805 xcalloc, xfree);
fc4007c9
TT
2806 }
2807
2808 ~decode_compound_collector ()
2809 {
14bc53a8
PA
2810 if (m_unique_syms != NULL)
2811 htab_delete (m_unique_syms);
fc4007c9 2812 }
3a93a0c2 2813
14bc53a8
PA
2814 /* Releases ownership of the collected symbols and returns them. */
2815 VEC (symbolp) *release_symbols ()
2816 {
2817 VEC (symbolp) *res = m_symbols;
2818 m_symbols = NULL;
2819 return res;
2820 }
c00f8484 2821
14bc53a8
PA
2822 /* Callable as a symbol_found_callback_ftype callback. */
2823 bool operator () (symbol *sym);
2824
2825private:
2826 /* A hash table of all symbols we found. We use this to avoid
2827 adding any symbol more than once. */
2828 htab_t m_unique_syms;
2829
2830 /* The result vector. */
2831 VEC (symbolp) *m_symbols;
2832};
2833
2834bool
2835decode_compound_collector::operator () (symbol *sym)
f8eba3c6 2836{
f8eba3c6
TT
2837 void **slot;
2838 struct type *t;
614b3b14 2839
f8eba3c6 2840 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
14bc53a8 2841 return true; /* Continue iterating. */
f8eba3c6
TT
2842
2843 t = SYMBOL_TYPE (sym);
f168693b 2844 t = check_typedef (t);
f8eba3c6
TT
2845 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2846 && TYPE_CODE (t) != TYPE_CODE_UNION
2847 && TYPE_CODE (t) != TYPE_CODE_NAMESPACE)
14bc53a8 2848 return true; /* Continue iterating. */
614b3b14 2849
14bc53a8 2850 slot = htab_find_slot (m_unique_syms, sym, INSERT);
f8eba3c6
TT
2851 if (!*slot)
2852 {
2853 *slot = sym;
14bc53a8 2854 VEC_safe_push (symbolp, m_symbols, sym);
f8eba3c6
TT
2855 }
2856
14bc53a8 2857 return true; /* Continue iterating. */
f8eba3c6 2858}
93d91629 2859
ffdbe864
YQ
2860} // namespace
2861
40e084e1 2862/* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */
93d91629 2863
f8eba3c6 2864static VEC (symbolp) *
ec94af83 2865lookup_prefix_sym (struct linespec_state *state, VEC (symtab_ptr) *file_symtabs,
40e084e1 2866 const char *class_name)
93d91629 2867{
f8eba3c6
TT
2868 int ix;
2869 struct symtab *elt;
14bc53a8 2870 decode_compound_collector collector;
e0881a8e 2871
ec94af83 2872 for (ix = 0; VEC_iterate (symtab_ptr, file_symtabs, ix, elt); ++ix)
f8eba3c6
TT
2873 {
2874 if (elt == NULL)
2875 {
40e084e1 2876 iterate_over_all_matching_symtabs (state, class_name, STRUCT_DOMAIN,
14bc53a8 2877 NULL, false, collector);
40e084e1 2878 iterate_over_all_matching_symtabs (state, class_name, VAR_DOMAIN,
14bc53a8 2879 NULL, false, collector);
f8eba3c6
TT
2880 }
2881 else
2882 {
f8eba3c6
TT
2883 /* Program spaces that are executing startup should have
2884 been filtered out earlier. */
2885 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
2886 set_current_program_space (SYMTAB_PSPACE (elt));
14bc53a8
PA
2887 iterate_over_file_blocks (elt, class_name, STRUCT_DOMAIN, collector);
2888 iterate_over_file_blocks (elt, class_name, VAR_DOMAIN, collector);
1e5a1abc
KS
2889 }
2890 }
2891
14bc53a8 2892 return collector.release_symbols ();
93d91629
DC
2893}
2894
40e084e1
KS
2895/* A qsort comparison function for symbols. The resulting order does
2896 not actually matter; we just need to be able to sort them so that
2897 symbols with the same program space end up next to each other. */
2898
2899static int
2900compare_symbols (const void *a, const void *b)
2901{
9a3c8263
SM
2902 struct symbol * const *sa = (struct symbol * const*) a;
2903 struct symbol * const *sb = (struct symbol * const*) b;
40e084e1
KS
2904 uintptr_t uia, uib;
2905
08be3fe3
DE
2906 uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sa));
2907 uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sb));
40e084e1
KS
2908
2909 if (uia < uib)
2910 return -1;
2911 if (uia > uib)
2912 return 1;
2913
2914 uia = (uintptr_t) *sa;
2915 uib = (uintptr_t) *sb;
2916
2917 if (uia < uib)
2918 return -1;
2919 if (uia > uib)
2920 return 1;
2921
2922 return 0;
2923}
2924
2925/* Like compare_symbols but for minimal symbols. */
4224873a 2926
f8eba3c6 2927static int
40e084e1 2928compare_msymbols (const void *a, const void *b)
4224873a 2929{
9a3c8263
SM
2930 const struct bound_minimal_symbol *sa
2931 = (const struct bound_minimal_symbol *) a;
2932 const struct bound_minimal_symbol *sb
2933 = (const struct bound_minimal_symbol *) b;
f8eba3c6
TT
2934 uintptr_t uia, uib;
2935
001822aa
TT
2936 uia = (uintptr_t) sa->objfile->pspace;
2937 uib = (uintptr_t) sa->objfile->pspace;
f8eba3c6
TT
2938
2939 if (uia < uib)
2940 return -1;
2941 if (uia > uib)
2942 return 1;
2943
001822aa
TT
2944 uia = (uintptr_t) sa->minsym;
2945 uib = (uintptr_t) sb->minsym;
f8eba3c6
TT
2946
2947 if (uia < uib)
2948 return -1;
2949 if (uia > uib)
2950 return 1;
2951
2952 return 0;
2953}
2954
2955/* Look for all the matching instances of each symbol in NAMES. Only
2956 instances from PSPACE are considered; other program spaces are
2957 handled by our caller. If PSPACE is NULL, then all program spaces
2958 are considered. Results are stored into INFO. */
2959
2960static void
2961add_all_symbol_names_from_pspace (struct collect_info *info,
2962 struct program_space *pspace,
2963 VEC (const_char_ptr) *names)
2964{
2965 int ix;
2966 const char *iter;
2967
2968 for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix)
2969 add_matching_symbols_to_info (iter, info, pspace);
2970}
2971
2972static void
2973find_superclass_methods (VEC (typep) *superclasses,
2974 const char *name,
2975 VEC (const_char_ptr) **result_names)
2976{
2977 int old_len = VEC_length (const_char_ptr, *result_names);
2978 VEC (typep) *iter_classes;
2979 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
2980
2981 iter_classes = superclasses;
2982 while (1)
2983 {
2984 VEC (typep) *new_supers = NULL;
2985 int ix;
2986 struct type *t;
2987
2988 make_cleanup (VEC_cleanup (typep), &new_supers);
2989 for (ix = 0; VEC_iterate (typep, iter_classes, ix, t); ++ix)
2990 find_methods (t, name, result_names, &new_supers);
2991
2992 if (VEC_length (const_char_ptr, *result_names) != old_len
2993 || VEC_empty (typep, new_supers))
2994 break;
4224873a 2995
f8eba3c6
TT
2996 iter_classes = new_supers;
2997 }
4224873a 2998
f8eba3c6
TT
2999 do_cleanups (cleanup);
3000}
3001
40e084e1
KS
3002/* This finds the method METHOD_NAME in the class CLASS_NAME whose type is
3003 given by one of the symbols in SYM_CLASSES. Matches are returned
3004 in SYMBOLS (for debug symbols) and MINSYMS (for minimal symbols). */
f8eba3c6 3005
40e084e1 3006static void
ec94af83 3007find_method (struct linespec_state *self, VEC (symtab_ptr) *file_symtabs,
40e084e1
KS
3008 const char *class_name, const char *method_name,
3009 VEC (symbolp) *sym_classes, VEC (symbolp) **symbols,
f60e2d5c 3010 VEC (bound_minimal_symbol_d) **minsyms)
f8eba3c6 3011{
f8eba3c6
TT
3012 struct symbol *sym;
3013 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
3014 int ix;
3015 int last_result_len;
3016 VEC (typep) *superclass_vec;
3017 VEC (const_char_ptr) *result_names;
3018 struct collect_info info;
4224873a 3019
f8eba3c6
TT
3020 /* Sort symbols so that symbols with the same program space are next
3021 to each other. */
3022 qsort (VEC_address (symbolp, sym_classes),
3023 VEC_length (symbolp, sym_classes),
3024 sizeof (symbolp),
3025 compare_symbols);
3026
3027 info.state = self;
40e084e1
KS
3028 info.file_symtabs = file_symtabs;
3029 info.result.symbols = NULL;
3030 info.result.minimal_symbols = NULL;
f8eba3c6
TT
3031
3032 /* Iterate over all the types, looking for the names of existing
40e084e1 3033 methods matching METHOD_NAME. If we cannot find a direct method in a
f8eba3c6
TT
3034 given program space, then we consider inherited methods; this is
3035 not ideal (ideal would be to respect C++ hiding rules), but it
3036 seems good enough and is what GDB has historically done. We only
3037 need to collect the names because later we find all symbols with
3038 those names. This loop is written in a somewhat funny way
3039 because we collect data across the program space before deciding
3040 what to do. */
3041 superclass_vec = NULL;
3042 make_cleanup (VEC_cleanup (typep), &superclass_vec);
3043 result_names = NULL;
3044 make_cleanup (VEC_cleanup (const_char_ptr), &result_names);
3045 last_result_len = 0;
3046 for (ix = 0; VEC_iterate (symbolp, sym_classes, ix, sym); ++ix)
3047 {
3048 struct type *t;
3049 struct program_space *pspace;
3050
3051 /* Program spaces that are executing startup should have
3052 been filtered out earlier. */
08be3fe3
DE
3053 pspace = SYMTAB_PSPACE (symbol_symtab (sym));
3054 gdb_assert (!pspace->executing_startup);
f8eba3c6
TT
3055 set_current_program_space (pspace);
3056 t = check_typedef (SYMBOL_TYPE (sym));
40e084e1 3057 find_methods (t, method_name, &result_names, &superclass_vec);
f8eba3c6
TT
3058
3059 /* Handle all items from a single program space at once; and be
3060 sure not to miss the last batch. */
3061 if (ix == VEC_length (symbolp, sym_classes) - 1
3062 || (pspace
08be3fe3 3063 != SYMTAB_PSPACE (symbol_symtab (VEC_index (symbolp, sym_classes,
f8eba3c6 3064 ix + 1)))))
4224873a 3065 {
f8eba3c6
TT
3066 /* If we did not find a direct implementation anywhere in
3067 this program space, consider superclasses. */
3068 if (VEC_length (const_char_ptr, result_names) == last_result_len)
40e084e1
KS
3069 find_superclass_methods (superclass_vec, method_name,
3070 &result_names);
f8eba3c6
TT
3071
3072 /* We have a list of candidate symbol names, so now we
3073 iterate over the symbol tables looking for all
3074 matches in this pspace. */
3075 add_all_symbol_names_from_pspace (&info, pspace, result_names);
3076
3077 VEC_truncate (typep, superclass_vec, 0);
3078 last_result_len = VEC_length (const_char_ptr, result_names);
4224873a 3079 }
4224873a 3080 }
f8eba3c6 3081
40e084e1 3082 if (!VEC_empty (symbolp, info.result.symbols)
f60e2d5c 3083 || !VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols))
4224873a 3084 {
40e084e1
KS
3085 *symbols = info.result.symbols;
3086 *minsyms = info.result.minimal_symbols;
f8eba3c6 3087 do_cleanups (cleanup);
40e084e1 3088 return;
4224873a 3089 }
f8eba3c6 3090
40e084e1
KS
3091 /* Throw an NOT_FOUND_ERROR. This will be caught by the caller
3092 and other attempts to locate the symbol will be made. */
3093 throw_error (NOT_FOUND_ERROR, _("see caller, this text doesn't matter"));
f8eba3c6
TT
3094}
3095
3096\f
3097
ffdbe864
YQ
3098namespace {
3099
14bc53a8
PA
3100/* This function object is a callback for iterate_over_symtabs, used
3101 when collecting all matching symtabs. */
f8eba3c6 3102
14bc53a8 3103class symtab_collector
f8eba3c6 3104{
14bc53a8 3105public:
fc4007c9 3106 symtab_collector ()
fc4007c9 3107 {
14bc53a8
PA
3108 m_symtabs = NULL;
3109 m_symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer,
3110 NULL);
fc4007c9
TT
3111 }
3112
3113 ~symtab_collector ()
3114 {
14bc53a8
PA
3115 if (m_symtab_table != NULL)
3116 htab_delete (m_symtab_table);
fc4007c9 3117 }
f8eba3c6 3118
14bc53a8
PA
3119 /* Callable as a symbol_found_callback_ftype callback. */
3120 bool operator () (symtab *sym);
f8eba3c6 3121
14bc53a8
PA
3122 /* Releases ownership of the collected symtabs and returns them. */
3123 VEC (symtab_ptr) *release_symtabs ()
3124 {
3125 VEC (symtab_ptr) *res = m_symtabs;
3126 m_symtabs = NULL;
3127 return res;
3128 }
3129
3130private:
3131 /* The result vector of symtabs. */
3132 VEC (symtab_ptr) *m_symtabs;
3133
3134 /* This is used to ensure the symtabs are unique. */
3135 htab_t m_symtab_table;
3136};
3137
3138bool
3139symtab_collector::operator () (struct symtab *symtab)
f8eba3c6 3140{
f8eba3c6
TT
3141 void **slot;
3142
14bc53a8 3143 slot = htab_find_slot (m_symtab_table, symtab, INSERT);
f8eba3c6 3144 if (!*slot)
4224873a 3145 {
f8eba3c6 3146 *slot = symtab;
14bc53a8 3147 VEC_safe_push (symtab_ptr, m_symtabs, symtab);
4224873a 3148 }
f8eba3c6 3149
14bc53a8 3150 return false;
4224873a
DC
3151}
3152
ffdbe864
YQ
3153} // namespace
3154
c2f4122d
PA
3155/* Given a file name, return a VEC of all matching symtabs. If
3156 SEARCH_PSPACE is not NULL, the search is restricted to just that
3157 program space. */
f8eba3c6 3158
ec94af83 3159static VEC (symtab_ptr) *
c2f4122d
PA
3160collect_symtabs_from_filename (const char *file,
3161 struct program_space *search_pspace)
f8eba3c6 3162{
14bc53a8 3163 symtab_collector collector;
f8eba3c6
TT
3164
3165 /* Find that file's data. */
c2f4122d
PA
3166 if (search_pspace == NULL)
3167 {
14bc53a8
PA
3168 struct program_space *pspace;
3169
c2f4122d
PA
3170 ALL_PSPACES (pspace)
3171 {
3172 if (pspace->executing_startup)
3173 continue;
f8eba3c6 3174
c2f4122d 3175 set_current_program_space (pspace);
14bc53a8 3176 iterate_over_symtabs (file, collector);
c2f4122d
PA
3177 }
3178 }
3179 else
3180 {
3181 set_current_program_space (search_pspace);
14bc53a8 3182 iterate_over_symtabs (file, collector);
c2f4122d 3183 }
f3c39e76 3184
14bc53a8 3185 return collector.release_symtabs ();
f8eba3c6
TT
3186}
3187
c2f4122d
PA
3188/* Return all the symtabs associated to the FILENAME. If SEARCH_PSPACE is
3189 not NULL, the search is restricted to just that program space. */
f8eba3c6 3190
ec94af83 3191static VEC (symtab_ptr) *
c2f4122d
PA
3192symtabs_from_filename (const char *filename,
3193 struct program_space *search_pspace)
40e084e1 3194{
ec94af83 3195 VEC (symtab_ptr) *result;
40e084e1 3196
c2f4122d 3197 result = collect_symtabs_from_filename (filename, search_pspace);
f8eba3c6 3198
ec94af83 3199 if (VEC_empty (symtab_ptr, result))
f8eba3c6 3200 {
40e084e1
KS
3201 if (!have_full_symbols () && !have_partial_symbols ())
3202 throw_error (NOT_FOUND_ERROR,
3203 _("No symbol table is loaded. "
3204 "Use the \"file\" command."));
00e52e53 3205 source_file_not_found_error (filename);
f8eba3c6
TT
3206 }
3207
40e084e1 3208 return result;
84fba31b 3209}
f3c39e76 3210
40e084e1
KS
3211/* Look up a function symbol named NAME in symtabs FILE_SYMTABS. Matching
3212 debug symbols are returned in SYMBOLS. Matching minimal symbols are
3213 returned in MINSYMS. */
14e91ac5 3214
40e084e1
KS
3215static void
3216find_function_symbols (struct linespec_state *state,
ec94af83 3217 VEC (symtab_ptr) *file_symtabs, const char *name,
40e084e1 3218 VEC (symbolp) **symbols,
f60e2d5c 3219 VEC (bound_minimal_symbol_d) **minsyms)
14e91ac5 3220{
40e084e1
KS
3221 struct collect_info info;
3222 VEC (const_char_ptr) *symbol_names = NULL;
3223 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
3224 &symbol_names);
14e91ac5 3225
40e084e1
KS
3226 info.state = state;
3227 info.result.symbols = NULL;
3228 info.result.minimal_symbols = NULL;
3229 info.file_symtabs = file_symtabs;
e0881a8e 3230
40e084e1 3231 /* Try NAME as an Objective-C selector. */
d7561cbb 3232 find_imps (name, &symbol_names);
40e084e1 3233 if (!VEC_empty (const_char_ptr, symbol_names))
c2f4122d
PA
3234 add_all_symbol_names_from_pspace (&info, state->search_pspace,
3235 symbol_names);
40e084e1 3236 else
c2f4122d 3237 add_matching_symbols_to_info (name, &info, state->search_pspace);
40e084e1
KS
3238
3239 do_cleanups (cleanup);
3240
3241 if (VEC_empty (symbolp, info.result.symbols))
3242 {
3243 VEC_free (symbolp, info.result.symbols);
3244 *symbols = NULL;
14e91ac5
DC
3245 }
3246 else
40e084e1
KS
3247 *symbols = info.result.symbols;
3248
f60e2d5c 3249 if (VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols))
14e91ac5 3250 {
f60e2d5c 3251 VEC_free (bound_minimal_symbol_d, info.result.minimal_symbols);
40e084e1
KS
3252 *minsyms = NULL;
3253 }
3254 else
3255 *minsyms = info.result.minimal_symbols;
3256}
3257
3258/* Find all symbols named NAME in FILE_SYMTABS, returning debug symbols
3259 in SYMBOLS and minimal symbols in MINSYMS. */
14e91ac5 3260
b1ae631a 3261static void
40e084e1 3262find_linespec_symbols (struct linespec_state *state,
ec94af83 3263 VEC (symtab_ptr) *file_symtabs,
40e084e1
KS
3264 const char *name,
3265 VEC (symbolp) **symbols,
f60e2d5c 3266 VEC (bound_minimal_symbol_d) **minsyms)
40e084e1 3267{
2f408ecb
PA
3268 demangle_result_storage demangle_storage;
3269 std::string ada_lookup_storage;
cc81e1c6 3270 const char *lookup_name;
f8eba3c6 3271
40e084e1
KS
3272 if (state->language->la_language == language_ada)
3273 {
3274 /* In Ada, the symbol lookups are performed using the encoded
3275 name rather than the demangled name. */
2f408ecb
PA
3276 ada_lookup_storage = ada_name_for_lookup (name);
3277 lookup_name = ada_lookup_storage.c_str ();
40e084e1 3278 }
2f408ecb 3279 else
40e084e1 3280 {
2f408ecb
PA
3281 lookup_name = demangle_for_lookup (name,
3282 state->language->la_language,
3283 demangle_storage);
40e084e1 3284 }
f8eba3c6 3285
2f408ecb
PA
3286 std::string canon = cp_canonicalize_string_no_typedefs (lookup_name);
3287 if (!canon.empty ())
3288 lookup_name = canon.c_str ();
3289
cc81e1c6
DE
3290 /* It's important to not call expand_symtabs_matching unnecessarily
3291 as it can really slow things down (by unnecessarily expanding
3292 potentially 1000s of symtabs, which when debugging some apps can
3293 cost 100s of seconds). Avoid this to some extent by *first* calling
3294 find_function_symbols, and only if that doesn't find anything
3295 *then* call find_method. This handles two important cases:
3296 1) break (anonymous namespace)::foo
3297 2) break class::method where method is in class (and not a baseclass) */
14e91ac5 3298
cc81e1c6
DE
3299 find_function_symbols (state, file_symtabs, lookup_name,
3300 symbols, minsyms);
14e91ac5 3301
cc81e1c6
DE
3302 /* If we were unable to locate a symbol of the same name, try dividing
3303 the name into class and method names and searching the class and its
3304 baseclasses. */
3305 if (VEC_empty (symbolp, *symbols)
f60e2d5c 3306 && VEC_empty (bound_minimal_symbol_d, *minsyms))
40e084e1 3307 {
2f408ecb 3308 std::string klass, method;
cc81e1c6
DE
3309 const char *last, *p, *scope_op;
3310 VEC (symbolp) *classes;
14e91ac5 3311
cc81e1c6
DE
3312 /* See if we can find a scope operator and break this symbol
3313 name into namespaces${SCOPE_OPERATOR}class_name and method_name. */
3314 scope_op = "::";
3315 p = find_toplevel_string (lookup_name, scope_op);
14e91ac5 3316
cc81e1c6
DE
3317 last = NULL;
3318 while (p != NULL)
f8eba3c6 3319 {
cc81e1c6
DE
3320 last = p;
3321 p = find_toplevel_string (p + strlen (scope_op), scope_op);
f8eba3c6 3322 }
14e91ac5 3323
cc81e1c6
DE
3324 /* If no scope operator was found, there is nothing more we can do;
3325 we already attempted to lookup the entire name as a symbol
3326 and failed. */
3327 if (last == NULL)
2f408ecb 3328 return;
cc81e1c6
DE
3329
3330 /* LOOKUP_NAME points to the class name.
3331 LAST points to the method name. */
2f408ecb 3332 klass = std::string (lookup_name, last - lookup_name);
cc81e1c6
DE
3333
3334 /* Skip past the scope operator. */
3335 last += strlen (scope_op);
2f408ecb 3336 method = last;
cc81e1c6
DE
3337
3338 /* Find a list of classes named KLASS. */
2f408ecb
PA
3339 classes = lookup_prefix_sym (state, file_symtabs, klass.c_str ());
3340 struct cleanup *old_chain
3341 = make_cleanup (VEC_cleanup (symbolp), &classes);
cc81e1c6
DE
3342
3343 if (!VEC_empty (symbolp, classes))
3344 {
3345 /* Now locate a list of suitable methods named METHOD. */
492d29ea 3346 TRY
cc81e1c6 3347 {
2f408ecb
PA
3348 find_method (state, file_symtabs,
3349 klass.c_str (), method.c_str (),
3350 classes, symbols, minsyms);
cc81e1c6
DE
3351 }
3352
3353 /* If successful, we're done. If NOT_FOUND_ERROR
3354 was not thrown, rethrow the exception that we did get. */
492d29ea 3355 CATCH (except, RETURN_MASK_ERROR)
7556d4a4
PA
3356 {
3357 if (except.error != NOT_FOUND_ERROR)
3358 throw_exception (except);
3359 }
492d29ea 3360 END_CATCH
cc81e1c6 3361 }
14e91ac5 3362
2f408ecb
PA
3363 do_cleanups (old_chain);
3364 }
14e91ac5
DC
3365}
3366
40e084e1
KS
3367/* Return all labels named NAME in FUNCTION_SYMBOLS. Return the
3368 actual function symbol in which the label was found in LABEL_FUNC_RET. */
0f5238ed 3369
40e084e1
KS
3370static VEC (symbolp) *
3371find_label_symbols (struct linespec_state *self,
3372 VEC (symbolp) *function_symbols,
3373 VEC (symbolp) **label_funcs_ret, const char *name)
0f5238ed 3374{
f8eba3c6 3375 int ix;
3977b71f 3376 const struct block *block;
40e084e1
KS
3377 struct symbol *sym;
3378 struct symbol *fn_sym;
3379 VEC (symbolp) *result = NULL;
9ef07c8c 3380
f8eba3c6 3381 if (function_symbols == NULL)
9ef07c8c 3382 {
f8eba3c6 3383 set_current_program_space (self->program_space);
4eeaa230 3384 block = get_current_search_block ();
f8eba3c6 3385
9ef07c8c
TT
3386 for (;
3387 block && !BLOCK_FUNCTION (block);
3388 block = BLOCK_SUPERBLOCK (block))
3389 ;
3390 if (!block)
40e084e1 3391 return NULL;
f8eba3c6
TT
3392 fn_sym = BLOCK_FUNCTION (block);
3393
d12307c1 3394 sym = lookup_symbol (name, block, LABEL_DOMAIN, 0).symbol;
f8eba3c6 3395
40e084e1
KS
3396 if (sym != NULL)
3397 {
3398 VEC_safe_push (symbolp, result, sym);
3399 VEC_safe_push (symbolp, *label_funcs_ret, fn_sym);
3400 }
3401 }
3402 else
3403 {
3404 for (ix = 0;
3405 VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix)
f8eba3c6 3406 {
08be3fe3 3407 set_current_program_space (SYMTAB_PSPACE (symbol_symtab (fn_sym)));
40e084e1 3408 block = SYMBOL_BLOCK_VALUE (fn_sym);
d12307c1 3409 sym = lookup_symbol (name, block, LABEL_DOMAIN, 0).symbol;
40e084e1
KS
3410
3411 if (sym != NULL)
3412 {
3413 VEC_safe_push (symbolp, result, sym);
3414 VEC_safe_push (symbolp, *label_funcs_ret, fn_sym);
3415 }
f8eba3c6 3416 }
40e084e1 3417 }
f8eba3c6 3418
40e084e1
KS
3419 return result;
3420}
f8eba3c6 3421
40e084e1
KS
3422\f
3423
3424/* A helper for create_sals_line_offset that handles the 'list_mode' case. */
3425
3426static void
3427decode_digits_list_mode (struct linespec_state *self,
3428 linespec_p ls,
3429 struct symtabs_and_lines *values,
3430 struct symtab_and_line val)
3431{
3432 int ix;
3433 struct symtab *elt;
3434
3435 gdb_assert (self->list_mode);
3436
ec94af83 3437 for (ix = 0; VEC_iterate (symtab_ptr, ls->file_symtabs, ix, elt);
40e084e1
KS
3438 ++ix)
3439 {
3440 /* The logic above should ensure this. */
3441 gdb_assert (elt != NULL);
3442
3443 set_current_program_space (SYMTAB_PSPACE (elt));
3444
3445 /* Simplistic search just for the list command. */
3446 val.symtab = find_line_symtab (elt, val.line, NULL, NULL);
3447 if (val.symtab == NULL)
3448 val.symtab = elt;
3449 val.pspace = SYMTAB_PSPACE (elt);
3450 val.pc = 0;
3451 val.explicit_line = 1;
3452
66f1999b 3453 add_sal_to_sals (self, values, &val, NULL, 0);
f8eba3c6 3454 }
40e084e1 3455}
f8eba3c6 3456
40e084e1
KS
3457/* A helper for create_sals_line_offset that iterates over the symtabs,
3458 adding lines to the VEC. */
3459
3460static void
3461decode_digits_ordinary (struct linespec_state *self,
3462 linespec_p ls,
3463 int line,
3464 struct symtabs_and_lines *sals,
3465 struct linetable_entry **best_entry)
3466{
3467 int ix;
3468 struct symtab *elt;
f8eba3c6 3469
ec94af83 3470 for (ix = 0; VEC_iterate (symtab_ptr, ls->file_symtabs, ix, elt); ++ix)
f8eba3c6 3471 {
67d89901 3472 std::vector<CORE_ADDR> pcs;
40e084e1
KS
3473
3474 /* The logic above should ensure this. */
3475 gdb_assert (elt != NULL);
f8eba3c6 3476
40e084e1 3477 set_current_program_space (SYMTAB_PSPACE (elt));
f8eba3c6 3478
40e084e1 3479 pcs = find_pcs_for_symtab_line (elt, line, best_entry);
67d89901 3480 for (CORE_ADDR pc : pcs)
f8eba3c6
TT
3481 {
3482 struct symtab_and_line sal;
40e084e1
KS
3483
3484 init_sal (&sal);
3485 sal.pspace = SYMTAB_PSPACE (elt);
3486 sal.symtab = elt;
3487 sal.line = line;
3488 sal.pc = pc;
3489 add_sal_to_sals_basic (sals, &sal);
f8eba3c6
TT
3490 }
3491 }
40e084e1
KS
3492}
3493
3494\f
3495
3496/* Return the line offset represented by VARIABLE. */
3497
3498static struct line_offset
3499linespec_parse_variable (struct linespec_state *self, const char *variable)
3500{
3501 int index = 0;
3502 const char *p;
3503 struct line_offset offset = {0, LINE_OFFSET_NONE};
f8eba3c6 3504
40e084e1
KS
3505 p = (variable[1] == '$') ? variable + 2 : variable + 1;
3506 if (*p == '$')
3507 ++p;
3508 while (*p >= '0' && *p <= '9')
3509 ++p;
3510 if (!*p) /* Reached end of token without hitting non-digit. */
f8eba3c6 3511 {
40e084e1
KS
3512 /* We have a value history reference. */
3513 struct value *val_history;
f8eba3c6 3514
40e084e1
KS
3515 sscanf ((variable[1] == '$') ? variable + 2 : variable + 1, "%d", &index);
3516 val_history
3517 = access_value_history ((variable[1] == '$') ? -index : index);
3518 if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
3519 error (_("History values used in line "
3520 "specs must have integer values."));
3521 offset.offset = value_as_long (val_history);
3522 }
3523 else
3524 {
3525 /* Not all digits -- may be user variable/function or a
3526 convenience variable. */
3527 LONGEST valx;
3528 struct internalvar *ivar;
3529
3530 /* Try it as a convenience variable. If it is not a convenience
3531 variable, return and allow normal symbol lookup to occur. */
3532 ivar = lookup_only_internalvar (variable + 1);
3533 if (ivar == NULL)
3534 /* No internal variable with that name. Mark the offset
3535 as unknown to allow the name to be looked up as a symbol. */
3536 offset.sign = LINE_OFFSET_UNKNOWN;
3537 else
3538 {
3539 /* We found a valid variable name. If it is not an integer,
3540 throw an error. */
3541 if (!get_internalvar_integer (ivar, &valx))
3542 error (_("Convenience variables used in line "
3543 "specs must have integer values."));
3544 else
3545 offset.offset = valx;
3546 }
f8eba3c6
TT
3547 }
3548
40e084e1 3549 return offset;
f8eba3c6 3550}
40e084e1 3551\f
f8eba3c6 3552
40e084e1 3553/* We've found a minimal symbol MSYMBOL in OBJFILE to associate with our
6e22494e
JK
3554 linespec; return the SAL in RESULT. This function should return SALs
3555 matching those from find_function_start_sal, otherwise false
3556 multiple-locations breakpoints could be placed. */
f8eba3c6
TT
3557
3558static void
3559minsym_found (struct linespec_state *self, struct objfile *objfile,
3560 struct minimal_symbol *msymbol,
3561 struct symtabs_and_lines *result)
3562{
3563 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3564 CORE_ADDR pc;
3565 struct symtab_and_line sal;
3566
77e371c0 3567 sal = find_pc_sect_line (MSYMBOL_VALUE_ADDRESS (objfile, msymbol),
f8eba3c6 3568 (struct obj_section *) 0, 0);
efd66ac6 3569 sal.section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
f8eba3c6
TT
3570
3571 /* The minimal symbol might point to a function descriptor;
3572 resolve it to the actual code address instead. */
3573 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, &current_target);
3574 if (pc != sal.pc)
3575 sal = find_pc_sect_line (pc, NULL, 0);
3576
3577 if (self->funfirstline)
6e22494e
JK
3578 {
3579 if (sal.symtab != NULL
3580 && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
3581 || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
3582 {
3583 /* If gdbarch_convert_from_func_ptr_addr does not apply then
3584 sal.SECTION, sal.LINE&co. will stay correct from above.
3585 If gdbarch_convert_from_func_ptr_addr applies then
3586 sal.SECTION is cleared from above and sal.LINE&co. will
3587 stay correct from the last find_pc_sect_line above. */
3588 sal.pc = MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
3589 sal.pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc,
3590 &current_target);
141c5cc4
JK
3591 if (gdbarch_skip_entrypoint_p (gdbarch))
3592 sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc);
6e22494e
JK
3593 }
3594 else
3595 skip_prologue_sal (&sal);
3596 }
f8eba3c6 3597
07fea4b4 3598 if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc))
efd66ac6 3599 add_sal_to_sals (self, result, &sal, MSYMBOL_NATURAL_NAME (msymbol), 0);
f8eba3c6
TT
3600}
3601
39b856a4
TT
3602/* A helper struct to pass some data through
3603 iterate_over_minimal_symbols. */
3604
3605struct collect_minsyms
3606{
3607 /* The objfile we're examining. */
3608 struct objfile *objfile;
3609
87186c6a
MMN
3610 /* Only search the given symtab, or NULL to search for all symbols. */
3611 struct symtab *symtab;
3612
39b856a4
TT
3613 /* The funfirstline setting from the initial call. */
3614 int funfirstline;
3615
095bcf5e
JB
3616 /* The list_mode setting from the initial call. */
3617 int list_mode;
3618
39b856a4 3619 /* The resulting symbols. */
f60e2d5c 3620 VEC (bound_minimal_symbol_d) *msyms;
39b856a4
TT
3621};
3622
3623/* A helper function to classify a minimal_symbol_type according to
3624 priority. */
3625
3626static int
3627classify_mtype (enum minimal_symbol_type t)
3628{
3629 switch (t)
f8eba3c6 3630 {
39b856a4
TT
3631 case mst_file_text:
3632 case mst_file_data:
3633 case mst_file_bss:
3634 /* Intermediate priority. */
3635 return 1;
3636
3637 case mst_solib_trampoline:
3638 /* Lowest priority. */
3639 return 2;
3640
3641 default:
3642 /* Highest priority. */
3643 return 0;
f8eba3c6 3644 }
39b856a4
TT
3645}
3646
3647/* Callback for qsort that sorts symbols by priority. */
3648
3649static int
3650compare_msyms (const void *a, const void *b)
3651{
9a3c8263
SM
3652 const bound_minimal_symbol_d *moa = (const bound_minimal_symbol_d *) a;
3653 const bound_minimal_symbol_d *mob = (const bound_minimal_symbol_d *) b;
39b856a4
TT
3654 enum minimal_symbol_type ta = MSYMBOL_TYPE (moa->minsym);
3655 enum minimal_symbol_type tb = MSYMBOL_TYPE (mob->minsym);
3656
3657 return classify_mtype (ta) - classify_mtype (tb);
3658}
3659
3660/* Callback for iterate_over_minimal_symbols that adds the symbol to
3661 the result. */
3662
3663static void
3664add_minsym (struct minimal_symbol *minsym, void *d)
3665{
9a3c8263 3666 struct collect_minsyms *info = (struct collect_minsyms *) d;
f60e2d5c 3667 bound_minimal_symbol_d mo;
39b856a4 3668
77e371c0
TT
3669 mo.minsym = minsym;
3670 mo.objfile = info->objfile;
3671
87186c6a
MMN
3672 if (info->symtab != NULL)
3673 {
3674 CORE_ADDR pc;
3675 struct symtab_and_line sal;
3676 struct gdbarch *gdbarch = get_objfile_arch (info->objfile);
3677
3678 sal = find_pc_sect_line (MSYMBOL_VALUE_ADDRESS (info->objfile, minsym),
3679 NULL, 0);
3680 sal.section = MSYMBOL_OBJ_SECTION (info->objfile, minsym);
3681 pc
3682 = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, &current_target);
3683 if (pc != sal.pc)
3684 sal = find_pc_sect_line (pc, NULL, 0);
3685
3686 if (info->symtab != sal.symtab)
3687 return;
3688 }
3689
095bcf5e
JB
3690 /* Exclude data symbols when looking for breakpoint locations. */
3691 if (!info->list_mode)
3692 switch (minsym->type)
3693 {
3694 case mst_slot_got_plt:
3695 case mst_data:
3696 case mst_bss:
3697 case mst_abs:
3698 case mst_file_data:
3699 case mst_file_bss:
1a2da5ee
JB
3700 {
3701 /* Make sure this minsym is not a function descriptor
3702 before we decide to discard it. */
df6d5441 3703 struct gdbarch *gdbarch = get_objfile_arch (info->objfile);
1a2da5ee 3704 CORE_ADDR addr = gdbarch_convert_from_func_ptr_addr
77e371c0 3705 (gdbarch, BMSYMBOL_VALUE_ADDRESS (mo),
1a2da5ee
JB
3706 &current_target);
3707
77e371c0 3708 if (addr == BMSYMBOL_VALUE_ADDRESS (mo))
1a2da5ee
JB
3709 return;
3710 }
095bcf5e
JB
3711 }
3712
f60e2d5c 3713 VEC_safe_push (bound_minimal_symbol_d, info->msyms, &mo);
f8eba3c6
TT
3714}
3715
87186c6a 3716/* Search for minimal symbols called NAME. If SEARCH_PSPACE
f8eba3c6 3717 is not NULL, the search is restricted to just that program
87186c6a
MMN
3718 space.
3719
3720 If SYMTAB is NULL, search all objfiles, otherwise
3721 restrict results to the given SYMTAB. */
f8eba3c6
TT
3722
3723static void
3724search_minsyms_for_name (struct collect_info *info, const char *name,
87186c6a
MMN
3725 struct program_space *search_pspace,
3726 struct symtab *symtab)
f8eba3c6 3727{
87186c6a
MMN
3728 struct collect_minsyms local;
3729 struct cleanup *cleanup;
f8eba3c6 3730
87186c6a
MMN
3731 memset (&local, 0, sizeof (local));
3732 local.funfirstline = info->state->funfirstline;
3733 local.list_mode = info->state->list_mode;
3734 local.symtab = symtab;
39b856a4 3735
87186c6a 3736 cleanup = make_cleanup (VEC_cleanup (bound_minimal_symbol_d), &local.msyms);
f8eba3c6 3737
87186c6a
MMN
3738 if (symtab == NULL)
3739 {
3740 struct program_space *pspace;
f8eba3c6 3741
87186c6a
MMN
3742 ALL_PSPACES (pspace)
3743 {
3744 struct objfile *objfile;
39b856a4 3745
87186c6a
MMN
3746 if (search_pspace != NULL && search_pspace != pspace)
3747 continue;
3748 if (pspace->executing_startup)
3749 continue;
39b856a4 3750
87186c6a
MMN
3751 set_current_program_space (pspace);
3752
3753 ALL_OBJFILES (objfile)
3754 {
3755 local.objfile = objfile;
3756 iterate_over_minimal_symbols (objfile, name, add_minsym, &local);
3757 }
3758 }
3759 }
3760 else
f8eba3c6 3761 {
87186c6a
MMN
3762 if (search_pspace == NULL || SYMTAB_PSPACE (symtab) == search_pspace)
3763 {
3764 set_current_program_space (SYMTAB_PSPACE (symtab));
3765 local.objfile = SYMTAB_OBJFILE(symtab);
3766 iterate_over_minimal_symbols (local.objfile, name, add_minsym,
3767 &local);
3768 }
9ef07c8c 3769 }
39b856a4 3770
f60e2d5c 3771 if (!VEC_empty (bound_minimal_symbol_d, local.msyms))
39b856a4
TT
3772 {
3773 int classification;
3774 int ix;
f60e2d5c 3775 bound_minimal_symbol_d *item;
39b856a4 3776
f60e2d5c
TT
3777 qsort (VEC_address (bound_minimal_symbol_d, local.msyms),
3778 VEC_length (bound_minimal_symbol_d, local.msyms),
3779 sizeof (bound_minimal_symbol_d),
39b856a4
TT
3780 compare_msyms);
3781
3782 /* Now the minsyms are in classification order. So, we walk
3783 over them and process just the minsyms with the same
3784 classification as the very first minsym in the list. */
f60e2d5c 3785 item = VEC_index (bound_minimal_symbol_d, local.msyms, 0);
39b856a4
TT
3786 classification = classify_mtype (MSYMBOL_TYPE (item->minsym));
3787
3788 for (ix = 0;
f60e2d5c 3789 VEC_iterate (bound_minimal_symbol_d, local.msyms, ix, item);
39b856a4
TT
3790 ++ix)
3791 {
3792 if (classify_mtype (MSYMBOL_TYPE (item->minsym)) != classification)
3793 break;
3794
f60e2d5c 3795 VEC_safe_push (bound_minimal_symbol_d,
40e084e1 3796 info->result.minimal_symbols, item);
39b856a4
TT
3797 }
3798 }
3799
3800 do_cleanups (cleanup);
f8eba3c6
TT
3801}
3802
3803/* A helper function to add all symbols matching NAME to INFO. If
3804 PSPACE is not NULL, the search is restricted to just that program
3805 space. */
0f5238ed 3806
f8eba3c6
TT
3807static void
3808add_matching_symbols_to_info (const char *name,
3809 struct collect_info *info,
3810 struct program_space *pspace)
3811{
3812 int ix;
3813 struct symtab *elt;
0f5238ed 3814
ec94af83 3815 for (ix = 0; VEC_iterate (symtab_ptr, info->file_symtabs, ix, elt); ++ix)
f8eba3c6 3816 {
f8eba3c6
TT
3817 if (elt == NULL)
3818 {
40e084e1 3819 iterate_over_all_matching_symtabs (info->state, name, VAR_DOMAIN,
14bc53a8
PA
3820 pspace, true, [&] (symbol *sym)
3821 { return info->add_symbol (sym); });
87186c6a 3822 search_minsyms_for_name (info, name, pspace, NULL);
f8eba3c6
TT
3823 }
3824 else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))
3825 {
87186c6a
MMN
3826 int prev_len = VEC_length (symbolp, info->result.symbols);
3827
f8eba3c6
TT
3828 /* Program spaces that are executing startup should have
3829 been filtered out earlier. */
3830 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
3831 set_current_program_space (SYMTAB_PSPACE (elt));
14bc53a8
PA
3832 iterate_over_file_blocks (elt, name, VAR_DOMAIN, [&] (symbol *sym)
3833 { return info->add_symbol (sym); });
87186c6a
MMN
3834
3835 /* If no new symbols were found in this iteration and this symtab
3836 is in assembler, we might actually be looking for a label for
3837 which we don't have debug info. Check for a minimal symbol in
3838 this case. */
3839 if (prev_len == VEC_length (symbolp, info->result.symbols)
3840 && elt->language == language_asm)
3841 search_minsyms_for_name (info, name, pspace, elt);
f8eba3c6
TT
3842 }
3843 }
0f5238ed
TT
3844}
3845
14e91ac5
DC
3846\f
3847
413dad4d
DC
3848/* Now come some functions that are called from multiple places within
3849 decode_line_1. */
3850
f8eba3c6
TT
3851static int
3852symbol_to_sal (struct symtab_and_line *result,
3853 int funfirstline, struct symbol *sym)
413dad4d 3854{
413dad4d 3855 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
50641945 3856 {
f8eba3c6
TT
3857 *result = find_function_start_sal (sym, funfirstline);
3858 return 1;
50641945 3859 }
413dad4d
DC
3860 else
3861 {
62853458 3862 if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
413dad4d 3863 {
f8eba3c6 3864 init_sal (result);
08be3fe3 3865 result->symtab = symbol_symtab (sym);
f8eba3c6
TT
3866 result->line = SYMBOL_LINE (sym);
3867 result->pc = SYMBOL_VALUE_ADDRESS (sym);
08be3fe3 3868 result->pspace = SYMTAB_PSPACE (result->symtab);
f8eba3c6
TT
3869 result->explicit_pc = 1;
3870 return 1;
413dad4d 3871 }
62853458 3872 else if (funfirstline)
dcf9f4ab 3873 {
f8eba3c6 3874 /* Nothing. */
dcf9f4ab 3875 }
62853458
TT
3876 else if (SYMBOL_LINE (sym) != 0)
3877 {
3878 /* We know its line number. */
f8eba3c6 3879 init_sal (result);
08be3fe3 3880 result->symtab = symbol_symtab (sym);
f8eba3c6 3881 result->line = SYMBOL_LINE (sym);
08be3fe3 3882 result->pspace = SYMTAB_PSPACE (result->symtab);
f8eba3c6 3883 return 1;
62853458 3884 }
413dad4d 3885 }
f8eba3c6
TT
3886
3887 return 0;
413dad4d 3888}
50641945 3889
f8eba3c6 3890/* See the comment in linespec.h. */
50641945 3891
f8eba3c6
TT
3892void
3893init_linespec_result (struct linespec_result *lr)
413dad4d 3894{
f8eba3c6
TT
3895 memset (lr, 0, sizeof (*lr));
3896}
413dad4d 3897
f8eba3c6 3898/* See the comment in linespec.h. */
bccdca4a 3899
f8eba3c6
TT
3900void
3901destroy_linespec_result (struct linespec_result *ls)
3902{
3903 int i;
3904 struct linespec_sals *lsal;
bccdca4a 3905
f00aae0f 3906 delete_event_location (ls->location);
f8eba3c6
TT
3907 for (i = 0; VEC_iterate (linespec_sals, ls->sals, i, lsal); ++i)
3908 {
3909 xfree (lsal->canonical);
3910 xfree (lsal->sals.sals);
3911 }
3912 VEC_free (linespec_sals, ls->sals);
3913}
e48883f7 3914
f8eba3c6
TT
3915/* Cleanup function for a linespec_result. */
3916
3917static void
3918cleanup_linespec_result (void *a)
3919{
9a3c8263 3920 destroy_linespec_result ((struct linespec_result *) a);
50641945 3921}
7efd8fc2 3922
f8eba3c6
TT
3923/* See the comment in linespec.h. */
3924
3925struct cleanup *
3926make_cleanup_destroy_linespec_result (struct linespec_result *ls)
7efd8fc2 3927{
f8eba3c6 3928 return make_cleanup (cleanup_linespec_result, ls);
7efd8fc2 3929}
87f0e720
KS
3930
3931/* Return the quote characters permitted by the linespec parser. */
3932
3933const char *
3934get_gdb_linespec_parser_quote_characters (void)
3935{
3936 return linespec_quote_characters;
3937}
This page took 1.607405 seconds and 4 git commands to generate.