ld: fix regressions with rett instructions in sparc tests.
[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. */
8e9e35b1
TT
1753 state->canonical->location
1754 = new_explicit_location (&ls->explicit_loc);
1755 canon = state->canonical->location.get ();
67994074 1756 explicit_loc = get_explicit_location (canon);
40e084e1 1757
67994074 1758 if (explicit_loc->label_name != NULL)
a06efdd6 1759 {
00e52e53 1760 state->canonical->special_display = 1;
40e084e1 1761
67994074 1762 if (explicit_loc->function_name == NULL)
40e084e1 1763 {
a06efdd6
KS
1764 struct symbol *s;
1765
1766 /* No function was specified, so add the symbol name. */
1767 gdb_assert (ls->labels.function_symbols != NULL
1768 && (VEC_length (symbolp, ls->labels.function_symbols)
1769 == 1));
1770 s = VEC_index (symbolp, ls->labels.function_symbols, 0);
67994074 1771 explicit_loc->function_name = xstrdup (SYMBOL_NATURAL_NAME (s));
40e084e1 1772 }
a06efdd6 1773 }
40e084e1 1774
00e52e53
KS
1775 /* If this location originally came from a linespec, save a string
1776 representation of it for display and saving to file. */
1777 if (state->is_linespec)
a06efdd6 1778 {
67994074 1779 char *linespec = explicit_location_to_linespec (explicit_loc);
a06efdd6 1780
00e52e53
KS
1781 set_event_location_string (canon, linespec);
1782 xfree (linespec);
1783 }
94af9270 1784}
c00f8484 1785
40e084e1 1786/* Given a line offset in LS, construct the relevant SALs. */
c00f8484 1787
40e084e1
KS
1788static struct symtabs_and_lines
1789create_sals_line_offset (struct linespec_state *self,
1790 linespec_p ls)
c00f8484 1791{
40e084e1
KS
1792 struct symtabs_and_lines values;
1793 struct symtab_and_line val;
1794 int use_default = 0;
c00f8484 1795
40e084e1
KS
1796 init_sal (&val);
1797 values.sals = NULL;
1798 values.nelts = 0;
1799
1800 /* This is where we need to make sure we have good defaults.
1801 We must guarantee that this section of code is never executed
2e47c6ca 1802 when we are called with just a function name, since
40e084e1
KS
1803 set_default_source_symtab_and_line uses
1804 select_source_symtab that calls us with such an argument. */
1805
ec94af83
DE
1806 if (VEC_length (symtab_ptr, ls->file_symtabs) == 1
1807 && VEC_index (symtab_ptr, ls->file_symtabs, 0) == NULL)
3d50dd94 1808 {
05cba821
JK
1809 const char *fullname;
1810
40e084e1 1811 set_current_program_space (self->program_space);
c00f8484 1812
40e084e1
KS
1813 /* Make sure we have at least a default source line. */
1814 set_default_source_symtab_and_line ();
1815 initialize_defaults (&self->default_symtab, &self->default_line);
05cba821 1816 fullname = symtab_to_fullname (self->default_symtab);
ec94af83
DE
1817 VEC_pop (symtab_ptr, ls->file_symtabs);
1818 VEC_free (symtab_ptr, ls->file_symtabs);
c2f4122d
PA
1819 ls->file_symtabs = collect_symtabs_from_filename (fullname,
1820 self->search_pspace);
40e084e1
KS
1821 use_default = 1;
1822 }
c00f8484 1823
67994074
KS
1824 val.line = ls->explicit_loc.line_offset.offset;
1825 switch (ls->explicit_loc.line_offset.sign)
40e084e1
KS
1826 {
1827 case LINE_OFFSET_PLUS:
67994074 1828 if (ls->explicit_loc.line_offset.offset == 0)
40e084e1
KS
1829 val.line = 5;
1830 if (use_default)
1831 val.line = self->default_line + val.line;
1832 break;
1833
1834 case LINE_OFFSET_MINUS:
67994074 1835 if (ls->explicit_loc.line_offset.offset == 0)
40e084e1
KS
1836 val.line = 15;
1837 if (use_default)
1838 val.line = self->default_line - val.line;
1839 else
1840 val.line = -val.line;
1841 break;
1842
1843 case LINE_OFFSET_NONE:
1844 break; /* No need to adjust val.line. */
1845 }
1846
1847 if (self->list_mode)
1848 decode_digits_list_mode (self, ls, &values, val);
1849 else
1850 {
1851 struct linetable_entry *best_entry = NULL;
1852 int *filter;
3977b71f 1853 const struct block **blocks;
40e084e1
KS
1854 struct cleanup *cleanup;
1855 struct symtabs_and_lines intermediate_results;
1856 int i, j;
1857
1858 intermediate_results.sals = NULL;
1859 intermediate_results.nelts = 0;
1860
1861 decode_digits_ordinary (self, ls, val.line, &intermediate_results,
1862 &best_entry);
1863 if (intermediate_results.nelts == 0 && best_entry != NULL)
1864 decode_digits_ordinary (self, ls, best_entry->line,
1865 &intermediate_results, &best_entry);
1866
1867 cleanup = make_cleanup (xfree, intermediate_results.sals);
1868
1869 /* For optimized code, the compiler can scatter one source line
1870 across disjoint ranges of PC values, even when no duplicate
1871 functions or inline functions are involved. For example,
1872 'for (;;)' inside a non-template, non-inline, and non-ctor-or-dtor
1873 function can result in two PC ranges. In this case, we don't
1874 want to set a breakpoint on the first PC of each range. To filter
1875 such cases, we use containing blocks -- for each PC found
1876 above, we see if there are other PCs that are in the same
1877 block. If yes, the other PCs are filtered out. */
1878
1879 filter = XNEWVEC (int, intermediate_results.nelts);
1880 make_cleanup (xfree, filter);
3977b71f 1881 blocks = XNEWVEC (const struct block *, intermediate_results.nelts);
40e084e1
KS
1882 make_cleanup (xfree, blocks);
1883
1884 for (i = 0; i < intermediate_results.nelts; ++i)
3d50dd94 1885 {
40e084e1 1886 set_current_program_space (intermediate_results.sals[i].pspace);
c00f8484 1887
40e084e1
KS
1888 filter[i] = 1;
1889 blocks[i] = block_for_pc_sect (intermediate_results.sals[i].pc,
1890 intermediate_results.sals[i].section);
3d50dd94 1891 }
c00f8484 1892
40e084e1
KS
1893 for (i = 0; i < intermediate_results.nelts; ++i)
1894 {
1895 if (blocks[i] != NULL)
1896 for (j = i + 1; j < intermediate_results.nelts; ++j)
1897 {
1898 if (blocks[j] == blocks[i])
1899 {
1900 filter[j] = 0;
1901 break;
1902 }
1903 }
1904 }
c00f8484 1905
40e084e1
KS
1906 for (i = 0; i < intermediate_results.nelts; ++i)
1907 if (filter[i])
1908 {
1909 struct symbol *sym = (blocks[i]
1910 ? block_containing_function (blocks[i])
1911 : NULL);
3d50dd94 1912
40e084e1
KS
1913 if (self->funfirstline)
1914 skip_prologue_sal (&intermediate_results.sals[i]);
1915 /* Make sure the line matches the request, not what was
1916 found. */
1917 intermediate_results.sals[i].line = val.line;
1918 add_sal_to_sals (self, &values, &intermediate_results.sals[i],
66f1999b 1919 sym ? SYMBOL_NATURAL_NAME (sym) : NULL, 0);
40e084e1 1920 }
3d50dd94 1921
40e084e1 1922 do_cleanups (cleanup);
f17170e5 1923 }
c00f8484 1924
40e084e1
KS
1925 if (values.nelts == 0)
1926 {
67994074 1927 if (ls->explicit_loc.source_filename)
40e084e1 1928 throw_error (NOT_FOUND_ERROR, _("No line %d in file \"%s\"."),
67994074 1929 val.line, ls->explicit_loc.source_filename);
40e084e1
KS
1930 else
1931 throw_error (NOT_FOUND_ERROR, _("No line %d in the current file."),
1932 val.line);
1933 }
3d50dd94 1934
40e084e1 1935 return values;
c00f8484
KS
1936}
1937
a06efdd6
KS
1938/* Convert the given ADDRESS into SaLs. */
1939
1940static struct symtabs_and_lines
1941convert_address_location_to_sals (struct linespec_state *self,
1942 CORE_ADDR address)
1943{
1944 struct symtab_and_line sal;
1945 struct symtabs_and_lines sals = {NULL, 0};
1946
1947 sal = find_pc_line (address, 0);
1948 sal.pc = address;
1949 sal.section = find_pc_overlay (address);
1950 sal.explicit_pc = 1;
1951 add_sal_to_sals (self, &sals, &sal, core_addr_to_string (address), 1);
1952
1953 return sals;
1954}
1955
40e084e1
KS
1956/* Create and return SALs from the linespec LS. */
1957
1958static struct symtabs_and_lines
1959convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)
1960{
1961 struct symtabs_and_lines sals = {NULL, 0};
1962
a06efdd6 1963 if (ls->labels.label_symbols != NULL)
40e084e1
KS
1964 {
1965 /* We have just a bunch of functions/methods or labels. */
1966 int i;
1967 struct symtab_and_line sal;
1968 struct symbol *sym;
1969
1970 for (i = 0; VEC_iterate (symbolp, ls->labels.label_symbols, i, sym); ++i)
1971 {
08be3fe3 1972 struct program_space *pspace = SYMTAB_PSPACE (symbol_symtab (sym));
fdbb204b
TT
1973
1974 if (symbol_to_sal (&sal, state->funfirstline, sym)
1975 && maybe_add_address (state->addr_set, pspace, sal.pc))
64b92e45
KS
1976 add_sal_to_sals (state, &sals, &sal,
1977 SYMBOL_NATURAL_NAME (sym), 0);
40e084e1
KS
1978 }
1979 }
1980 else if (ls->function_symbols != NULL || ls->minimal_symbols != NULL)
1981 {
1982 /* We have just a bunch of functions and/or methods. */
1983 int i;
1984 struct symtab_and_line sal;
1985 struct symbol *sym;
f60e2d5c 1986 bound_minimal_symbol_d *elem;
40e084e1
KS
1987 struct program_space *pspace;
1988
1989 if (ls->function_symbols != NULL)
1990 {
1991 /* Sort symbols so that symbols with the same program space are next
1992 to each other. */
1993 qsort (VEC_address (symbolp, ls->function_symbols),
1994 VEC_length (symbolp, ls->function_symbols),
1995 sizeof (symbolp), compare_symbols);
1996
1997 for (i = 0; VEC_iterate (symbolp, ls->function_symbols, i, sym); ++i)
1998 {
08be3fe3 1999 pspace = SYMTAB_PSPACE (symbol_symtab (sym));
40e084e1 2000 set_current_program_space (pspace);
64b92e45
KS
2001 if (symbol_to_sal (&sal, state->funfirstline, sym)
2002 && maybe_add_address (state->addr_set, pspace, sal.pc))
66f1999b
KS
2003 add_sal_to_sals (state, &sals, &sal,
2004 SYMBOL_NATURAL_NAME (sym), 0);
40e084e1
KS
2005 }
2006 }
2007
2008 if (ls->minimal_symbols != NULL)
2009 {
2010 /* Sort minimal symbols by program space, too. */
f60e2d5c
TT
2011 qsort (VEC_address (bound_minimal_symbol_d, ls->minimal_symbols),
2012 VEC_length (bound_minimal_symbol_d, ls->minimal_symbols),
2013 sizeof (bound_minimal_symbol_d), compare_msymbols);
40e084e1
KS
2014
2015 for (i = 0;
f60e2d5c
TT
2016 VEC_iterate (bound_minimal_symbol_d, ls->minimal_symbols,
2017 i, elem);
40e084e1
KS
2018 ++i)
2019 {
001822aa 2020 pspace = elem->objfile->pspace;
40e084e1
KS
2021 set_current_program_space (pspace);
2022 minsym_found (state, elem->objfile, elem->minsym, &sals);
2023 }
2024 }
2025 }
67994074 2026 else if (ls->explicit_loc.line_offset.sign != LINE_OFFSET_UNKNOWN)
40e084e1
KS
2027 {
2028 /* Only an offset was specified. */
2029 sals = create_sals_line_offset (state, ls);
2030
2031 /* Make sure we have a filename for canonicalization. */
67994074 2032 if (ls->explicit_loc.source_filename == NULL)
05cba821
JK
2033 {
2034 const char *fullname = symtab_to_fullname (state->default_symtab);
2035
e93ba630
JK
2036 /* It may be more appropriate to keep DEFAULT_SYMTAB in its symtab
2037 form so that displaying SOURCE_FILENAME can follow the current
2038 FILENAME_DISPLAY_STRING setting. But as it is used only rarely
2039 it has been kept for code simplicity only in absolute form. */
67994074 2040 ls->explicit_loc.source_filename = xstrdup (fullname);
05cba821 2041 }
40e084e1
KS
2042 }
2043 else
2044 {
2045 /* We haven't found any results... */
2046 return sals;
2047 }
2048
2049 canonicalize_linespec (state, ls);
2050
2051 if (sals.nelts > 0 && state->canonical != NULL)
2052 state->canonical->pre_expanded = 1;
2053
2054 return sals;
2055}
50641945 2056
67994074 2057/* Convert the explicit location EXPLICIT_LOC into SaLs. */
00e52e53
KS
2058
2059static struct symtabs_and_lines
2060convert_explicit_location_to_sals (struct linespec_state *self,
2061 linespec_p result,
67994074 2062 const struct explicit_location *explicit_loc)
00e52e53
KS
2063{
2064 VEC (symbolp) *symbols, *labels;
2065 VEC (bound_minimal_symbol_d) *minimal_symbols;
2066
67994074 2067 if (explicit_loc->source_filename != NULL)
00e52e53
KS
2068 {
2069 TRY
2070 {
2071 result->file_symtabs
c2f4122d
PA
2072 = symtabs_from_filename (explicit_loc->source_filename,
2073 self->search_pspace);
00e52e53
KS
2074 }
2075 CATCH (except, RETURN_MASK_ERROR)
2076 {
67994074 2077 source_file_not_found_error (explicit_loc->source_filename);
00e52e53
KS
2078 }
2079 END_CATCH
67994074
KS
2080 result->explicit_loc.source_filename
2081 = xstrdup (explicit_loc->source_filename);
00e52e53
KS
2082 }
2083 else
2084 {
2085 /* A NULL entry means to use the default symtab. */
2086 VEC_safe_push (symtab_ptr, result->file_symtabs, NULL);
2087 }
2088
67994074 2089 if (explicit_loc->function_name != NULL)
00e52e53
KS
2090 {
2091 find_linespec_symbols (self, result->file_symtabs,
67994074 2092 explicit_loc->function_name, &symbols,
00e52e53
KS
2093 &minimal_symbols);
2094
2095 if (symbols == NULL && minimal_symbols == NULL)
67994074
KS
2096 symbol_not_found_error (explicit_loc->function_name,
2097 result->explicit_loc.source_filename);
00e52e53 2098
67994074
KS
2099 result->explicit_loc.function_name
2100 = xstrdup (explicit_loc->function_name);
00e52e53
KS
2101 result->function_symbols = symbols;
2102 result->minimal_symbols = minimal_symbols;
2103 }
2104
67994074 2105 if (explicit_loc->label_name != NULL)
00e52e53
KS
2106 {
2107 symbols = NULL;
2108 labels = find_label_symbols (self, result->function_symbols,
67994074 2109 &symbols, explicit_loc->label_name);
00e52e53
KS
2110
2111 if (labels == NULL)
67994074
KS
2112 undefined_label_error (result->explicit_loc.function_name,
2113 explicit_loc->label_name);
00e52e53 2114
67994074 2115 result->explicit_loc.label_name = xstrdup (explicit_loc->label_name);
00e52e53
KS
2116 result->labels.label_symbols = labels;
2117 result->labels.function_symbols = symbols;
2118 }
2119
67994074
KS
2120 if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
2121 result->explicit_loc.line_offset = explicit_loc->line_offset;
00e52e53
KS
2122
2123 return convert_linespec_to_sals (self, result);
2124}
2125
40e084e1 2126/* Parse a string that specifies a linespec.
50641945 2127
40e084e1 2128 The basic grammar of linespecs:
50641945 2129
a06efdd6 2130 linespec -> var_spec | basic_spec
40e084e1 2131 var_spec -> '$' (STRING | NUMBER)
50641945 2132
40e084e1
KS
2133 basic_spec -> file_offset_spec | function_spec | label_spec
2134 file_offset_spec -> opt_file_spec offset_spec
2135 function_spec -> opt_file_spec function_name_spec opt_label_spec
2136 label_spec -> label_name_spec
50641945 2137
40e084e1
KS
2138 opt_file_spec -> "" | file_name_spec ':'
2139 opt_label_spec -> "" | ':' label_name_spec
2140
2141 file_name_spec -> STRING
2142 function_name_spec -> STRING
2143 label_name_spec -> STRING
2144 function_name_spec -> STRING
2145 offset_spec -> NUMBER
2146 -> '+' NUMBER
2147 -> '-' NUMBER
2148
2149 This may all be followed by several keywords such as "if EXPR",
2150 which we ignore.
2151
2152 A comma will terminate parsing.
2153
2154 The function may be an undebuggable function found in minimal symbol table.
50641945
FN
2155
2156 If the argument FUNFIRSTLINE is nonzero, we want the first line
2157 of real code inside a function when a function is specified, and it is
2158 not OK to specify a variable or type to get its line number.
2159
2160 DEFAULT_SYMTAB specifies the file to use if none is specified.
2161 It defaults to current_source_symtab.
2162 DEFAULT_LINE specifies the line number to use for relative
2163 line numbers (that start with signs). Defaults to current_source_line.
2164 If CANONICAL is non-NULL, store an array of strings containing the canonical
1777feb0 2165 line specs there if necessary. Currently overloaded member functions and
50641945 2166 line numbers or static functions without a filename yield a canonical
1777feb0 2167 line spec. The array and the line spec strings are allocated on the heap,
50641945
FN
2168 it is the callers responsibility to free them.
2169
2170 Note that it is possible to return zero for the symtab
2171 if no file is validly specified. Callers must check that.
58438ac1 2172 Also, the line number returned may be invalid. */
50641945 2173
f00aae0f 2174/* Parse the linespec in ARG. */
50641945 2175
ad32032e 2176static struct symtabs_and_lines
f00aae0f 2177parse_linespec (linespec_parser *parser, const char *arg)
50641945 2178{
40e084e1
KS
2179 linespec_token token;
2180 struct symtabs_and_lines values;
7556d4a4 2181 struct gdb_exception file_exception = exception_none;
40e084e1
KS
2182 struct cleanup *cleanup;
2183
2184 /* A special case to start. It has become quite popular for
2185 IDEs to work around bugs in the previous parser by quoting
2186 the entire linespec, so we attempt to deal with this nicely. */
2187 parser->is_quote_enclosed = 0;
f00aae0f
KS
2188 if (!is_ada_operator (arg)
2189 && strchr (linespec_quote_characters, *arg) != NULL)
40e084e1
KS
2190 {
2191 const char *end;
9ef07c8c 2192
f00aae0f 2193 end = skip_quote_char (arg + 1, *arg);
40e084e1 2194 if (end != NULL && is_closing_quote_enclosed (end))
136e1c30 2195 {
f00aae0f 2196 /* Here's the special case. Skip ARG past the initial
40e084e1 2197 quote. */
f00aae0f 2198 ++arg;
40e084e1 2199 parser->is_quote_enclosed = 1;
136e1c30
DE
2200 }
2201 }
e8eb7bc5 2202
f00aae0f
KS
2203 parser->lexer.saved_arg = arg;
2204 parser->lexer.stream = arg;
d2630e69 2205
40e084e1
KS
2206 /* Initialize the default symtab and line offset. */
2207 initialize_defaults (&PARSER_STATE (parser)->default_symtab,
2208 &PARSER_STATE (parser)->default_line);
d2630e69 2209
40e084e1 2210 /* Objective-C shortcut. */
f00aae0f 2211 values = decode_objc (PARSER_STATE (parser), PARSER_RESULT (parser), arg);
40e084e1
KS
2212 if (values.sals != NULL)
2213 return values;
e0881a8e 2214
40e084e1 2215 /* Start parsing. */
d2630e69 2216
40e084e1
KS
2217 /* Get the first token. */
2218 token = linespec_lexer_lex_one (parser);
50641945 2219
40e084e1 2220 /* It must be either LSTOKEN_STRING or LSTOKEN_NUMBER. */
a06efdd6 2221 if (token.type == LSTOKEN_STRING && *LS_TOKEN_STOKEN (token).ptr == '$')
40e084e1
KS
2222 {
2223 char *var;
50641945 2224
40e084e1 2225 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
ec94af83 2226 VEC_safe_push (symtab_ptr, PARSER_RESULT (parser)->file_symtabs, NULL);
dcf9f4ab 2227
40e084e1
KS
2228 /* User specified a convenience variable or history value. */
2229 var = copy_token_string (token);
2230 cleanup = make_cleanup (xfree, var);
00e52e53 2231 PARSER_EXPLICIT (parser)->line_offset
40e084e1 2232 = linespec_parse_variable (PARSER_STATE (parser), var);
cf4ded82 2233 do_cleanups (cleanup);
f8eba3c6 2234
40e084e1
KS
2235 /* If a line_offset wasn't found (VAR is the name of a user
2236 variable/function), then skip to normal symbol processing. */
00e52e53 2237 if (PARSER_EXPLICIT (parser)->line_offset.sign != LINE_OFFSET_UNKNOWN)
40e084e1 2238 {
40e084e1
KS
2239 /* Consume this token. */
2240 linespec_lexer_consume_token (parser);
dcf9f4ab 2241
40e084e1 2242 goto convert_to_sals;
50641945 2243 }
40e084e1
KS
2244 }
2245 else if (token.type != LSTOKEN_STRING && token.type != LSTOKEN_NUMBER)
2246 unexpected_linespec_error (parser);
50641945 2247
40e084e1
KS
2248 /* Shortcut: If the next token is not LSTOKEN_COLON, we know that
2249 this token cannot represent a filename. */
2250 token = linespec_lexer_peek_token (parser);
0e0b460e 2251
40e084e1 2252 if (token.type == LSTOKEN_COLON)
0e0b460e 2253 {
40e084e1 2254 char *user_filename;
0e0b460e 2255
40e084e1
KS
2256 /* Get the current token again and extract the filename. */
2257 token = linespec_lexer_lex_one (parser);
2258 user_filename = copy_token_string (token);
50641945 2259
40e084e1 2260 /* Check if the input is a filename. */
492d29ea 2261 TRY
40e084e1
KS
2262 {
2263 PARSER_RESULT (parser)->file_symtabs
c2f4122d
PA
2264 = symtabs_from_filename (user_filename,
2265 PARSER_STATE (parser)->search_pspace);
40e084e1 2266 }
492d29ea 2267 CATCH (ex, RETURN_MASK_ERROR)
7556d4a4
PA
2268 {
2269 file_exception = ex;
2270 }
492d29ea 2271 END_CATCH
50641945 2272
40e084e1
KS
2273 if (file_exception.reason >= 0)
2274 {
2275 /* Symtabs were found for the file. Record the filename. */
00e52e53 2276 PARSER_EXPLICIT (parser)->source_filename = user_filename;
f8eba3c6 2277
40e084e1
KS
2278 /* Get the next token. */
2279 token = linespec_lexer_consume_token (parser);
50641945 2280
40e084e1
KS
2281 /* This is LSTOKEN_COLON; consume it. */
2282 linespec_lexer_consume_token (parser);
2283 }
2284 else
2285 {
2286 /* No symtabs found -- discard user_filename. */
2287 xfree (user_filename);
50641945 2288
40e084e1 2289 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
ec94af83 2290 VEC_safe_push (symtab_ptr, PARSER_RESULT (parser)->file_symtabs, NULL);
40e084e1 2291 }
50641945 2292 }
40e084e1
KS
2293 /* If the next token is not EOI, KEYWORD, or COMMA, issue an error. */
2294 else if (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD
2295 && token.type != LSTOKEN_COMMA)
d2630e69 2296 {
40e084e1
KS
2297 /* TOKEN is the _next_ token, not the one currently in the parser.
2298 Consuming the token will give the correct error message. */
2299 linespec_lexer_consume_token (parser);
2300 unexpected_linespec_error (parser);
d2630e69 2301 }
50641945
FN
2302 else
2303 {
40e084e1 2304 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
ec94af83 2305 VEC_safe_push (symtab_ptr, PARSER_RESULT (parser)->file_symtabs, NULL);
50641945 2306 }
50641945 2307
40e084e1
KS
2308 /* Parse the rest of the linespec. */
2309 linespec_parse_basic (parser);
50641945 2310
40e084e1
KS
2311 if (PARSER_RESULT (parser)->function_symbols == NULL
2312 && PARSER_RESULT (parser)->labels.label_symbols == NULL
00e52e53 2313 && PARSER_EXPLICIT (parser)->line_offset.sign == LINE_OFFSET_UNKNOWN
40e084e1 2314 && PARSER_RESULT (parser)->minimal_symbols == NULL)
f8eba3c6 2315 {
40e084e1
KS
2316 /* The linespec didn't parse. Re-throw the file exception if
2317 there was one. */
2318 if (file_exception.reason < 0)
2319 throw_exception (file_exception);
0f5238ed 2320
40e084e1 2321 /* Otherwise, the symbol is not found. */
00e52e53
KS
2322 symbol_not_found_error (PARSER_EXPLICIT (parser)->function_name,
2323 PARSER_EXPLICIT (parser)->source_filename);
0f5238ed
TT
2324 }
2325
40e084e1 2326 convert_to_sals:
9ef07c8c 2327
40e084e1
KS
2328 /* Get the last token and record how much of the input was parsed,
2329 if necessary. */
2330 token = linespec_lexer_lex_one (parser);
2331 if (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD)
2332 PARSER_STREAM (parser) = LS_TOKEN_STOKEN (token).ptr;
50641945 2333
40e084e1
KS
2334 /* Convert the data in PARSER_RESULT to SALs. */
2335 values = convert_linespec_to_sals (PARSER_STATE (parser),
2336 PARSER_RESULT (parser));
f8eba3c6 2337
40e084e1 2338 return values;
413dad4d 2339}
50641945 2340
40e084e1 2341
f8eba3c6 2342/* A constructor for linespec_state. */
44fe14ab 2343
f8eba3c6
TT
2344static void
2345linespec_state_constructor (struct linespec_state *self,
40e084e1 2346 int flags, const struct language_defn *language,
c2f4122d 2347 struct program_space *search_pspace,
f8eba3c6
TT
2348 struct symtab *default_symtab,
2349 int default_line,
2350 struct linespec_result *canonical)
2351{
2352 memset (self, 0, sizeof (*self));
40e084e1 2353 self->language = language;
f8eba3c6
TT
2354 self->funfirstline = (flags & DECODE_LINE_FUNFIRSTLINE) ? 1 : 0;
2355 self->list_mode = (flags & DECODE_LINE_LIST_MODE) ? 1 : 0;
c2f4122d 2356 self->search_pspace = search_pspace;
f8eba3c6
TT
2357 self->default_symtab = default_symtab;
2358 self->default_line = default_line;
2359 self->canonical = canonical;
2360 self->program_space = current_program_space;
2361 self->addr_set = htab_create_alloc (10, hash_address_entry, eq_address_entry,
2362 xfree, xcalloc, xfree);
00e52e53 2363 self->is_linespec = 0;
f8eba3c6 2364}
44fe14ab 2365
40e084e1 2366/* Initialize a new linespec parser. */
44fe14ab
DC
2367
2368static void
40e084e1
KS
2369linespec_parser_new (linespec_parser *parser,
2370 int flags, const struct language_defn *language,
c2f4122d 2371 struct program_space *search_pspace,
40e084e1
KS
2372 struct symtab *default_symtab,
2373 int default_line,
2374 struct linespec_result *canonical)
44fe14ab 2375{
f00aae0f 2376 memset (parser, 0, sizeof (linespec_parser));
40e084e1
KS
2377 parser->lexer.current.type = LSTOKEN_CONSUMED;
2378 memset (PARSER_RESULT (parser), 0, sizeof (struct linespec));
00e52e53 2379 PARSER_EXPLICIT (parser)->line_offset.sign = LINE_OFFSET_UNKNOWN;
40e084e1 2380 linespec_state_constructor (PARSER_STATE (parser), flags, language,
c2f4122d 2381 search_pspace,
40e084e1
KS
2382 default_symtab, default_line, canonical);
2383}
2384
2385/* A destructor for linespec_state. */
44fe14ab 2386
40e084e1
KS
2387static void
2388linespec_state_destructor (struct linespec_state *self)
2389{
f8eba3c6
TT
2390 htab_delete (self->addr_set);
2391}
44fe14ab 2392
40e084e1
KS
2393/* Delete a linespec parser. */
2394
2395static void
2396linespec_parser_delete (void *arg)
2397{
2398 linespec_parser *parser = (linespec_parser *) arg;
2399
00e52e53
KS
2400 xfree (PARSER_EXPLICIT (parser)->source_filename);
2401 xfree (PARSER_EXPLICIT (parser)->label_name);
2402 xfree (PARSER_EXPLICIT (parser)->function_name);
40e084e1
KS
2403
2404 if (PARSER_RESULT (parser)->file_symtabs != NULL)
ec94af83 2405 VEC_free (symtab_ptr, PARSER_RESULT (parser)->file_symtabs);
40e084e1
KS
2406
2407 if (PARSER_RESULT (parser)->function_symbols != NULL)
2408 VEC_free (symbolp, PARSER_RESULT (parser)->function_symbols);
2409
2410 if (PARSER_RESULT (parser)->minimal_symbols != NULL)
f60e2d5c 2411 VEC_free (bound_minimal_symbol_d, PARSER_RESULT (parser)->minimal_symbols);
40e084e1
KS
2412
2413 if (PARSER_RESULT (parser)->labels.label_symbols != NULL)
2414 VEC_free (symbolp, PARSER_RESULT (parser)->labels.label_symbols);
2415
2416 if (PARSER_RESULT (parser)->labels.function_symbols != NULL)
2417 VEC_free (symbolp, PARSER_RESULT (parser)->labels.function_symbols);
2418
2419 linespec_state_destructor (PARSER_STATE (parser));
2420}
2421
c7c1b3e9
KS
2422/* See description in linespec.h. */
2423
2424void
2425linespec_lex_to_end (char **stringp)
2426{
2427 linespec_parser parser;
2428 struct cleanup *cleanup;
2429 linespec_token token;
c7c1b3e9
KS
2430 const char *orig;
2431
2432 if (stringp == NULL || *stringp == NULL)
2433 return;
2434
c2f4122d 2435 linespec_parser_new (&parser, 0, current_language, NULL, NULL, 0, NULL);
c7c1b3e9
KS
2436 cleanup = make_cleanup (linespec_parser_delete, &parser);
2437 parser.lexer.saved_arg = *stringp;
2438 PARSER_STREAM (&parser) = orig = *stringp;
2439
2440 do
2441 {
2442 /* Stop before any comma tokens; we need it to keep it
2443 as the next token in the string. */
2444 token = linespec_lexer_peek_token (&parser);
2445 if (token.type == LSTOKEN_COMMA)
2446 break;
c7c1b3e9
KS
2447 token = linespec_lexer_consume_token (&parser);
2448 }
2449 while (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD);
2450
2451 *stringp += PARSER_STREAM (&parser) - orig;
2452 do_cleanups (cleanup);
2453}
2454
f00aae0f
KS
2455/* A helper function for decode_line_full and decode_line_1 to
2456 turn LOCATION into symtabs_and_lines. */
2457
2458static struct symtabs_and_lines
2459event_location_to_sals (linespec_parser *parser,
2460 const struct event_location *location)
2461{
2462 struct symtabs_and_lines result = {NULL, 0};
2463
2464 switch (event_location_type (location))
2465 {
2466 case LINESPEC_LOCATION:
2467 {
00e52e53 2468 PARSER_STATE (parser)->is_linespec = 1;
f00aae0f
KS
2469 TRY
2470 {
2471 result = parse_linespec (parser, get_linespec_location (location));
2472 }
2473 CATCH (except, RETURN_MASK_ERROR)
2474 {
2475 throw_exception (except);
2476 }
2477 END_CATCH
2478 }
2479 break;
2480
a06efdd6 2481 case ADDRESS_LOCATION:
305e13e6
JB
2482 {
2483 const char *addr_string = get_address_string_location (location);
2484 CORE_ADDR addr = get_address_location (location);
2485
2486 if (addr_string != NULL)
2487 {
2488 char *expr = xstrdup (addr_string);
2489 const char *const_expr = expr;
2490 struct cleanup *cleanup = make_cleanup (xfree, expr);
2491
2492 addr = linespec_expression_to_pc (&const_expr);
2493 if (PARSER_STATE (parser)->canonical != NULL)
2494 PARSER_STATE (parser)->canonical->location
8e9e35b1 2495 = copy_event_location (location);
305e13e6
JB
2496
2497 do_cleanups (cleanup);
2498 }
2499
2500 result = convert_address_location_to_sals (PARSER_STATE (parser),
2501 addr);
2502 }
a06efdd6
KS
2503 break;
2504
00e52e53
KS
2505 case EXPLICIT_LOCATION:
2506 {
67994074 2507 const struct explicit_location *explicit_loc;
00e52e53 2508
67994074 2509 explicit_loc = get_explicit_location_const (location);
00e52e53
KS
2510 result = convert_explicit_location_to_sals (PARSER_STATE (parser),
2511 PARSER_RESULT (parser),
67994074 2512 explicit_loc);
00e52e53
KS
2513 }
2514 break;
2515
5b56227b
KS
2516 case PROBE_LOCATION:
2517 /* Probes are handled by their own decoders. */
2518 gdb_assert_not_reached ("attempt to decode probe location");
2519 break;
2520
f00aae0f
KS
2521 default:
2522 gdb_assert_not_reached ("unhandled event location type");
2523 }
2524
2525 return result;
2526}
2527
f8eba3c6 2528/* See linespec.h. */
44fe14ab 2529
f8eba3c6 2530void
f00aae0f 2531decode_line_full (const struct event_location *location, int flags,
c2f4122d 2532 struct program_space *search_pspace,
f8eba3c6
TT
2533 struct symtab *default_symtab,
2534 int default_line, struct linespec_result *canonical,
2535 const char *select_mode,
2536 const char *filter)
44fe14ab 2537{
f8eba3c6 2538 struct symtabs_and_lines result;
f8eba3c6 2539 struct cleanup *cleanups;
f8eba3c6 2540 VEC (const_char_ptr) *filters = NULL;
40e084e1
KS
2541 linespec_parser parser;
2542 struct linespec_state *state;
f8eba3c6
TT
2543
2544 gdb_assert (canonical != NULL);
2545 /* The filter only makes sense for 'all'. */
2546 gdb_assert (filter == NULL || select_mode == multiple_symbols_all);
2547 gdb_assert (select_mode == NULL
2548 || select_mode == multiple_symbols_all
2549 || select_mode == multiple_symbols_ask
2550 || select_mode == multiple_symbols_cancel);
2551 gdb_assert ((flags & DECODE_LINE_LIST_MODE) == 0);
2552
c2f4122d
PA
2553 linespec_parser_new (&parser, flags, current_language,
2554 search_pspace, default_symtab,
40e084e1
KS
2555 default_line, canonical);
2556 cleanups = make_cleanup (linespec_parser_delete, &parser);
f8eba3c6
TT
2557 save_current_program_space ();
2558
f00aae0f 2559 result = event_location_to_sals (&parser, location);
40e084e1 2560 state = PARSER_STATE (&parser);
f8eba3c6
TT
2561
2562 gdb_assert (result.nelts == 1 || canonical->pre_expanded);
f8eba3c6
TT
2563 canonical->pre_expanded = 1;
2564
66f1999b 2565 /* Arrange for allocated canonical names to be freed. */
f8eba3c6
TT
2566 if (result.nelts > 0)
2567 {
2568 int i;
2569
40e084e1 2570 make_cleanup (xfree, state->canonical_names);
f8eba3c6
TT
2571 for (i = 0; i < result.nelts; ++i)
2572 {
33f448b1
JK
2573 gdb_assert (state->canonical_names[i].suffix != NULL);
2574 make_cleanup (xfree, state->canonical_names[i].suffix);
f8eba3c6
TT
2575 }
2576 }
2577
2578 if (select_mode == NULL)
2579 {
112e8700 2580 if (interp_ui_out (top_level_interpreter ())->is_mi_like_p ())
f8eba3c6
TT
2581 select_mode = multiple_symbols_all;
2582 else
2583 select_mode = multiple_symbols_select_mode ();
2584 }
2585
2586 if (select_mode == multiple_symbols_all)
2587 {
2588 if (filter != NULL)
2589 {
2590 make_cleanup (VEC_cleanup (const_char_ptr), &filters);
2591 VEC_safe_push (const_char_ptr, filters, filter);
40e084e1 2592 filter_results (state, &result, filters);
f8eba3c6
TT
2593 }
2594 else
40e084e1 2595 convert_results_to_lsals (state, &result);
f8eba3c6
TT
2596 }
2597 else
40e084e1 2598 decode_line_2 (state, &result, select_mode);
f8eba3c6
TT
2599
2600 do_cleanups (cleanups);
2601}
2602
39cf75f7
DE
2603/* See linespec.h. */
2604
f8eba3c6 2605struct symtabs_and_lines
f00aae0f 2606decode_line_1 (const struct event_location *location, int flags,
c2f4122d 2607 struct program_space *search_pspace,
f8eba3c6
TT
2608 struct symtab *default_symtab,
2609 int default_line)
2610{
2611 struct symtabs_and_lines result;
40e084e1 2612 linespec_parser parser;
f8eba3c6
TT
2613 struct cleanup *cleanups;
2614
c2f4122d
PA
2615 linespec_parser_new (&parser, flags, current_language,
2616 search_pspace, default_symtab,
40e084e1
KS
2617 default_line, NULL);
2618 cleanups = make_cleanup (linespec_parser_delete, &parser);
f8eba3c6
TT
2619 save_current_program_space ();
2620
f00aae0f 2621 result = event_location_to_sals (&parser, location);
40e084e1 2622
f8eba3c6
TT
2623 do_cleanups (cleanups);
2624 return result;
2625}
2626
39cf75f7
DE
2627/* See linespec.h. */
2628
2629struct symtabs_and_lines
2630decode_line_with_current_source (char *string, int flags)
2631{
2632 struct symtabs_and_lines sals;
2633 struct symtab_and_line cursal;
2634
2635 if (string == 0)
2636 error (_("Empty line specification."));
2637
2638 /* We use whatever is set as the current source line. We do not try
2639 and get a default source symtab+line or it will recursively call us! */
2640 cursal = get_current_source_symtab_and_line ();
2641
ffc2605c
TT
2642 event_location_up location = string_to_event_location (&string,
2643 current_language);
2644 sals = decode_line_1 (location.get (), flags, NULL,
39cf75f7
DE
2645 cursal.symtab, cursal.line);
2646
2647 if (*string)
2648 error (_("Junk at end of line specification: %s"), string);
f00aae0f 2649
39cf75f7
DE
2650 return sals;
2651}
2652
2653/* See linespec.h. */
2654
2655struct symtabs_and_lines
2656decode_line_with_last_displayed (char *string, int flags)
2657{
2658 struct symtabs_and_lines sals;
2659
2660 if (string == 0)
2661 error (_("Empty line specification."));
2662
ffc2605c
TT
2663 event_location_up location = string_to_event_location (&string,
2664 current_language);
39cf75f7 2665 if (last_displayed_sal_is_valid ())
ffc2605c 2666 sals = decode_line_1 (location.get (), flags, NULL,
39cf75f7
DE
2667 get_last_displayed_symtab (),
2668 get_last_displayed_line ());
2669 else
ffc2605c
TT
2670 sals = decode_line_1 (location.get (), flags, NULL,
2671 (struct symtab *) NULL, 0);
39cf75f7
DE
2672
2673 if (*string)
2674 error (_("Junk at end of line specification: %s"), string);
f00aae0f 2675
39cf75f7
DE
2676 return sals;
2677}
2678
f8eba3c6
TT
2679\f
2680
2681/* First, some functions to initialize stuff at the beggining of the
2682 function. */
2683
2684static void
2685initialize_defaults (struct symtab **default_symtab, int *default_line)
2686{
2687 if (*default_symtab == 0)
2688 {
2689 /* Use whatever we have for the default source line. We don't use
2690 get_current_or_default_symtab_and_line as it can recurse and call
2691 us back! */
2692 struct symtab_and_line cursal =
2693 get_current_source_symtab_and_line ();
2694
2695 *default_symtab = cursal.symtab;
2696 *default_line = cursal.line;
2697 }
2698}
2699
2700\f
2701
40e084e1
KS
2702/* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR,
2703 advancing EXP_PTR past any parsed text. */
f8eba3c6 2704
a06efdd6 2705CORE_ADDR
bbc13ae3 2706linespec_expression_to_pc (const char **exp_ptr)
f8eba3c6 2707{
f8eba3c6
TT
2708 if (current_program_space->executing_startup)
2709 /* The error message doesn't really matter, because this case
2710 should only hit during breakpoint reset. */
2711 throw_error (NOT_FOUND_ERROR, _("cannot evaluate expressions while "
2712 "program space is in startup"));
2713
40e084e1
KS
2714 (*exp_ptr)++;
2715 return value_as_address (parse_to_comma_and_eval (exp_ptr));
0960f083
DC
2716}
2717
2718\f
2719
d2630e69
AF
2720/* Here's where we recognise an Objective-C Selector. An Objective C
2721 selector may be implemented by more than one class, therefore it
2722 may represent more than one method/function. This gives us a
2723 situation somewhat analogous to C++ overloading. If there's more
2724 than one method that could represent the selector, then use some of
2725 the existing C++ code to let the user choose one. */
2726
f8eba3c6 2727static struct symtabs_and_lines
f00aae0f 2728decode_objc (struct linespec_state *self, linespec_p ls, const char *arg)
d2630e69 2729{
f8eba3c6
TT
2730 struct collect_info info;
2731 VEC (const_char_ptr) *symbol_names = NULL;
40e084e1 2732 struct symtabs_and_lines values;
d7561cbb 2733 const char *new_argptr;
f8eba3c6
TT
2734 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
2735 &symbol_names);
2736
2737 info.state = self;
40e084e1 2738 info.file_symtabs = NULL;
ec94af83
DE
2739 VEC_safe_push (symtab_ptr, info.file_symtabs, NULL);
2740 make_cleanup (VEC_cleanup (symtab_ptr), &info.file_symtabs);
40e084e1
KS
2741 info.result.symbols = NULL;
2742 info.result.minimal_symbols = NULL;
2743 values.nelts = 0;
2744 values.sals = NULL;
f8eba3c6 2745
f00aae0f 2746 new_argptr = find_imps (arg, &symbol_names);
f8eba3c6
TT
2747 if (VEC_empty (const_char_ptr, symbol_names))
2748 {
2749 do_cleanups (cleanup);
40e084e1 2750 return values;
f8eba3c6 2751 }
d2630e69 2752
f8eba3c6 2753 add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
d2630e69 2754
40e084e1 2755 if (!VEC_empty (symbolp, info.result.symbols)
f60e2d5c 2756 || !VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols))
d2630e69 2757 {
f8eba3c6 2758 char *saved_arg;
d2630e69 2759
224c3ddb 2760 saved_arg = (char *) alloca (new_argptr - arg + 1);
f00aae0f
KS
2761 memcpy (saved_arg, arg, new_argptr - arg);
2762 saved_arg[new_argptr - arg] = '\0';
d2630e69 2763
67994074 2764 ls->explicit_loc.function_name = xstrdup (saved_arg);
40e084e1
KS
2765 ls->function_symbols = info.result.symbols;
2766 ls->minimal_symbols = info.result.minimal_symbols;
2767 values = convert_linespec_to_sals (self, ls);
2768
f8eba3c6 2769 if (self->canonical)
d2630e69 2770 {
f00aae0f
KS
2771 char *str;
2772
f8eba3c6 2773 self->canonical->pre_expanded = 1;
f00aae0f 2774
67994074 2775 if (ls->explicit_loc.source_filename)
f00aae0f
KS
2776 {
2777 str = xstrprintf ("%s:%s",
67994074 2778 ls->explicit_loc.source_filename, saved_arg);
f00aae0f 2779 }
f8eba3c6 2780 else
f00aae0f
KS
2781 str = xstrdup (saved_arg);
2782
2783 make_cleanup (xfree, str);
8e9e35b1 2784 self->canonical->location = new_linespec_location (&str);
d2630e69 2785 }
d2630e69
AF
2786 }
2787
f8eba3c6 2788 do_cleanups (cleanup);
c00f8484 2789
40e084e1 2790 return values;
f8eba3c6 2791}
c00f8484 2792
ffdbe864
YQ
2793namespace {
2794
14bc53a8
PA
2795/* A function object that serves as symbol_found_callback_ftype
2796 callback for iterate_over_symbols. This is used by
2797 lookup_prefix_sym to collect type symbols. */
2798class decode_compound_collector
f8eba3c6 2799{
14bc53a8 2800public:
fc4007c9 2801 decode_compound_collector ()
14bc53a8 2802 : m_symbols (NULL)
fc4007c9 2803 {
14bc53a8
PA
2804 m_unique_syms = htab_create_alloc (1, htab_hash_pointer,
2805 htab_eq_pointer, NULL,
2806 xcalloc, xfree);
fc4007c9
TT
2807 }
2808
2809 ~decode_compound_collector ()
2810 {
14bc53a8
PA
2811 if (m_unique_syms != NULL)
2812 htab_delete (m_unique_syms);
fc4007c9 2813 }
3a93a0c2 2814
14bc53a8
PA
2815 /* Releases ownership of the collected symbols and returns them. */
2816 VEC (symbolp) *release_symbols ()
2817 {
2818 VEC (symbolp) *res = m_symbols;
2819 m_symbols = NULL;
2820 return res;
2821 }
c00f8484 2822
14bc53a8
PA
2823 /* Callable as a symbol_found_callback_ftype callback. */
2824 bool operator () (symbol *sym);
2825
2826private:
2827 /* A hash table of all symbols we found. We use this to avoid
2828 adding any symbol more than once. */
2829 htab_t m_unique_syms;
2830
2831 /* The result vector. */
2832 VEC (symbolp) *m_symbols;
2833};
2834
2835bool
2836decode_compound_collector::operator () (symbol *sym)
f8eba3c6 2837{
f8eba3c6
TT
2838 void **slot;
2839 struct type *t;
614b3b14 2840
f8eba3c6 2841 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
14bc53a8 2842 return true; /* Continue iterating. */
f8eba3c6
TT
2843
2844 t = SYMBOL_TYPE (sym);
f168693b 2845 t = check_typedef (t);
f8eba3c6
TT
2846 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2847 && TYPE_CODE (t) != TYPE_CODE_UNION
2848 && TYPE_CODE (t) != TYPE_CODE_NAMESPACE)
14bc53a8 2849 return true; /* Continue iterating. */
614b3b14 2850
14bc53a8 2851 slot = htab_find_slot (m_unique_syms, sym, INSERT);
f8eba3c6
TT
2852 if (!*slot)
2853 {
2854 *slot = sym;
14bc53a8 2855 VEC_safe_push (symbolp, m_symbols, sym);
f8eba3c6
TT
2856 }
2857
14bc53a8 2858 return true; /* Continue iterating. */
f8eba3c6 2859}
93d91629 2860
ffdbe864
YQ
2861} // namespace
2862
40e084e1 2863/* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */
93d91629 2864
f8eba3c6 2865static VEC (symbolp) *
ec94af83 2866lookup_prefix_sym (struct linespec_state *state, VEC (symtab_ptr) *file_symtabs,
40e084e1 2867 const char *class_name)
93d91629 2868{
f8eba3c6
TT
2869 int ix;
2870 struct symtab *elt;
14bc53a8 2871 decode_compound_collector collector;
e0881a8e 2872
ec94af83 2873 for (ix = 0; VEC_iterate (symtab_ptr, file_symtabs, ix, elt); ++ix)
f8eba3c6
TT
2874 {
2875 if (elt == NULL)
2876 {
40e084e1 2877 iterate_over_all_matching_symtabs (state, class_name, STRUCT_DOMAIN,
14bc53a8 2878 NULL, false, collector);
40e084e1 2879 iterate_over_all_matching_symtabs (state, class_name, VAR_DOMAIN,
14bc53a8 2880 NULL, false, collector);
f8eba3c6
TT
2881 }
2882 else
2883 {
f8eba3c6
TT
2884 /* Program spaces that are executing startup should have
2885 been filtered out earlier. */
2886 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
2887 set_current_program_space (SYMTAB_PSPACE (elt));
14bc53a8
PA
2888 iterate_over_file_blocks (elt, class_name, STRUCT_DOMAIN, collector);
2889 iterate_over_file_blocks (elt, class_name, VAR_DOMAIN, collector);
1e5a1abc
KS
2890 }
2891 }
2892
14bc53a8 2893 return collector.release_symbols ();
93d91629
DC
2894}
2895
40e084e1
KS
2896/* A qsort comparison function for symbols. The resulting order does
2897 not actually matter; we just need to be able to sort them so that
2898 symbols with the same program space end up next to each other. */
2899
2900static int
2901compare_symbols (const void *a, const void *b)
2902{
9a3c8263
SM
2903 struct symbol * const *sa = (struct symbol * const*) a;
2904 struct symbol * const *sb = (struct symbol * const*) b;
40e084e1
KS
2905 uintptr_t uia, uib;
2906
08be3fe3
DE
2907 uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sa));
2908 uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sb));
40e084e1
KS
2909
2910 if (uia < uib)
2911 return -1;
2912 if (uia > uib)
2913 return 1;
2914
2915 uia = (uintptr_t) *sa;
2916 uib = (uintptr_t) *sb;
2917
2918 if (uia < uib)
2919 return -1;
2920 if (uia > uib)
2921 return 1;
2922
2923 return 0;
2924}
2925
2926/* Like compare_symbols but for minimal symbols. */
4224873a 2927
f8eba3c6 2928static int
40e084e1 2929compare_msymbols (const void *a, const void *b)
4224873a 2930{
9a3c8263
SM
2931 const struct bound_minimal_symbol *sa
2932 = (const struct bound_minimal_symbol *) a;
2933 const struct bound_minimal_symbol *sb
2934 = (const struct bound_minimal_symbol *) b;
f8eba3c6
TT
2935 uintptr_t uia, uib;
2936
001822aa
TT
2937 uia = (uintptr_t) sa->objfile->pspace;
2938 uib = (uintptr_t) sa->objfile->pspace;
f8eba3c6
TT
2939
2940 if (uia < uib)
2941 return -1;
2942 if (uia > uib)
2943 return 1;
2944
001822aa
TT
2945 uia = (uintptr_t) sa->minsym;
2946 uib = (uintptr_t) sb->minsym;
f8eba3c6
TT
2947
2948 if (uia < uib)
2949 return -1;
2950 if (uia > uib)
2951 return 1;
2952
2953 return 0;
2954}
2955
2956/* Look for all the matching instances of each symbol in NAMES. Only
2957 instances from PSPACE are considered; other program spaces are
2958 handled by our caller. If PSPACE is NULL, then all program spaces
2959 are considered. Results are stored into INFO. */
2960
2961static void
2962add_all_symbol_names_from_pspace (struct collect_info *info,
2963 struct program_space *pspace,
2964 VEC (const_char_ptr) *names)
2965{
2966 int ix;
2967 const char *iter;
2968
2969 for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix)
2970 add_matching_symbols_to_info (iter, info, pspace);
2971}
2972
2973static void
2974find_superclass_methods (VEC (typep) *superclasses,
2975 const char *name,
2976 VEC (const_char_ptr) **result_names)
2977{
2978 int old_len = VEC_length (const_char_ptr, *result_names);
2979 VEC (typep) *iter_classes;
2980 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
2981
2982 iter_classes = superclasses;
2983 while (1)
2984 {
2985 VEC (typep) *new_supers = NULL;
2986 int ix;
2987 struct type *t;
2988
2989 make_cleanup (VEC_cleanup (typep), &new_supers);
2990 for (ix = 0; VEC_iterate (typep, iter_classes, ix, t); ++ix)
2991 find_methods (t, name, result_names, &new_supers);
2992
2993 if (VEC_length (const_char_ptr, *result_names) != old_len
2994 || VEC_empty (typep, new_supers))
2995 break;
4224873a 2996
f8eba3c6
TT
2997 iter_classes = new_supers;
2998 }
4224873a 2999
f8eba3c6
TT
3000 do_cleanups (cleanup);
3001}
3002
40e084e1
KS
3003/* This finds the method METHOD_NAME in the class CLASS_NAME whose type is
3004 given by one of the symbols in SYM_CLASSES. Matches are returned
3005 in SYMBOLS (for debug symbols) and MINSYMS (for minimal symbols). */
f8eba3c6 3006
40e084e1 3007static void
ec94af83 3008find_method (struct linespec_state *self, VEC (symtab_ptr) *file_symtabs,
40e084e1
KS
3009 const char *class_name, const char *method_name,
3010 VEC (symbolp) *sym_classes, VEC (symbolp) **symbols,
f60e2d5c 3011 VEC (bound_minimal_symbol_d) **minsyms)
f8eba3c6 3012{
f8eba3c6
TT
3013 struct symbol *sym;
3014 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
3015 int ix;
3016 int last_result_len;
3017 VEC (typep) *superclass_vec;
3018 VEC (const_char_ptr) *result_names;
3019 struct collect_info info;
4224873a 3020
f8eba3c6
TT
3021 /* Sort symbols so that symbols with the same program space are next
3022 to each other. */
3023 qsort (VEC_address (symbolp, sym_classes),
3024 VEC_length (symbolp, sym_classes),
3025 sizeof (symbolp),
3026 compare_symbols);
3027
3028 info.state = self;
40e084e1
KS
3029 info.file_symtabs = file_symtabs;
3030 info.result.symbols = NULL;
3031 info.result.minimal_symbols = NULL;
f8eba3c6
TT
3032
3033 /* Iterate over all the types, looking for the names of existing
40e084e1 3034 methods matching METHOD_NAME. If we cannot find a direct method in a
f8eba3c6
TT
3035 given program space, then we consider inherited methods; this is
3036 not ideal (ideal would be to respect C++ hiding rules), but it
3037 seems good enough and is what GDB has historically done. We only
3038 need to collect the names because later we find all symbols with
3039 those names. This loop is written in a somewhat funny way
3040 because we collect data across the program space before deciding
3041 what to do. */
3042 superclass_vec = NULL;
3043 make_cleanup (VEC_cleanup (typep), &superclass_vec);
3044 result_names = NULL;
3045 make_cleanup (VEC_cleanup (const_char_ptr), &result_names);
3046 last_result_len = 0;
3047 for (ix = 0; VEC_iterate (symbolp, sym_classes, ix, sym); ++ix)
3048 {
3049 struct type *t;
3050 struct program_space *pspace;
3051
3052 /* Program spaces that are executing startup should have
3053 been filtered out earlier. */
08be3fe3
DE
3054 pspace = SYMTAB_PSPACE (symbol_symtab (sym));
3055 gdb_assert (!pspace->executing_startup);
f8eba3c6
TT
3056 set_current_program_space (pspace);
3057 t = check_typedef (SYMBOL_TYPE (sym));
40e084e1 3058 find_methods (t, method_name, &result_names, &superclass_vec);
f8eba3c6
TT
3059
3060 /* Handle all items from a single program space at once; and be
3061 sure not to miss the last batch. */
3062 if (ix == VEC_length (symbolp, sym_classes) - 1
3063 || (pspace
08be3fe3 3064 != SYMTAB_PSPACE (symbol_symtab (VEC_index (symbolp, sym_classes,
f8eba3c6 3065 ix + 1)))))
4224873a 3066 {
f8eba3c6
TT
3067 /* If we did not find a direct implementation anywhere in
3068 this program space, consider superclasses. */
3069 if (VEC_length (const_char_ptr, result_names) == last_result_len)
40e084e1
KS
3070 find_superclass_methods (superclass_vec, method_name,
3071 &result_names);
f8eba3c6
TT
3072
3073 /* We have a list of candidate symbol names, so now we
3074 iterate over the symbol tables looking for all
3075 matches in this pspace. */
3076 add_all_symbol_names_from_pspace (&info, pspace, result_names);
3077
3078 VEC_truncate (typep, superclass_vec, 0);
3079 last_result_len = VEC_length (const_char_ptr, result_names);
4224873a 3080 }
4224873a 3081 }
f8eba3c6 3082
40e084e1 3083 if (!VEC_empty (symbolp, info.result.symbols)
f60e2d5c 3084 || !VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols))
4224873a 3085 {
40e084e1
KS
3086 *symbols = info.result.symbols;
3087 *minsyms = info.result.minimal_symbols;
f8eba3c6 3088 do_cleanups (cleanup);
40e084e1 3089 return;
4224873a 3090 }
f8eba3c6 3091
40e084e1
KS
3092 /* Throw an NOT_FOUND_ERROR. This will be caught by the caller
3093 and other attempts to locate the symbol will be made. */
3094 throw_error (NOT_FOUND_ERROR, _("see caller, this text doesn't matter"));
f8eba3c6
TT
3095}
3096
3097\f
3098
ffdbe864
YQ
3099namespace {
3100
14bc53a8
PA
3101/* This function object is a callback for iterate_over_symtabs, used
3102 when collecting all matching symtabs. */
f8eba3c6 3103
14bc53a8 3104class symtab_collector
f8eba3c6 3105{
14bc53a8 3106public:
fc4007c9 3107 symtab_collector ()
fc4007c9 3108 {
14bc53a8
PA
3109 m_symtabs = NULL;
3110 m_symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer,
3111 NULL);
fc4007c9
TT
3112 }
3113
3114 ~symtab_collector ()
3115 {
14bc53a8
PA
3116 if (m_symtab_table != NULL)
3117 htab_delete (m_symtab_table);
fc4007c9 3118 }
f8eba3c6 3119
14bc53a8
PA
3120 /* Callable as a symbol_found_callback_ftype callback. */
3121 bool operator () (symtab *sym);
f8eba3c6 3122
14bc53a8
PA
3123 /* Releases ownership of the collected symtabs and returns them. */
3124 VEC (symtab_ptr) *release_symtabs ()
3125 {
3126 VEC (symtab_ptr) *res = m_symtabs;
3127 m_symtabs = NULL;
3128 return res;
3129 }
3130
3131private:
3132 /* The result vector of symtabs. */
3133 VEC (symtab_ptr) *m_symtabs;
3134
3135 /* This is used to ensure the symtabs are unique. */
3136 htab_t m_symtab_table;
3137};
3138
3139bool
3140symtab_collector::operator () (struct symtab *symtab)
f8eba3c6 3141{
f8eba3c6
TT
3142 void **slot;
3143
14bc53a8 3144 slot = htab_find_slot (m_symtab_table, symtab, INSERT);
f8eba3c6 3145 if (!*slot)
4224873a 3146 {
f8eba3c6 3147 *slot = symtab;
14bc53a8 3148 VEC_safe_push (symtab_ptr, m_symtabs, symtab);
4224873a 3149 }
f8eba3c6 3150
14bc53a8 3151 return false;
4224873a
DC
3152}
3153
ffdbe864
YQ
3154} // namespace
3155
c2f4122d
PA
3156/* Given a file name, return a VEC of all matching symtabs. If
3157 SEARCH_PSPACE is not NULL, the search is restricted to just that
3158 program space. */
f8eba3c6 3159
ec94af83 3160static VEC (symtab_ptr) *
c2f4122d
PA
3161collect_symtabs_from_filename (const char *file,
3162 struct program_space *search_pspace)
f8eba3c6 3163{
14bc53a8 3164 symtab_collector collector;
f8eba3c6
TT
3165
3166 /* Find that file's data. */
c2f4122d
PA
3167 if (search_pspace == NULL)
3168 {
14bc53a8
PA
3169 struct program_space *pspace;
3170
c2f4122d
PA
3171 ALL_PSPACES (pspace)
3172 {
3173 if (pspace->executing_startup)
3174 continue;
f8eba3c6 3175
c2f4122d 3176 set_current_program_space (pspace);
14bc53a8 3177 iterate_over_symtabs (file, collector);
c2f4122d
PA
3178 }
3179 }
3180 else
3181 {
3182 set_current_program_space (search_pspace);
14bc53a8 3183 iterate_over_symtabs (file, collector);
c2f4122d 3184 }
f3c39e76 3185
14bc53a8 3186 return collector.release_symtabs ();
f8eba3c6
TT
3187}
3188
c2f4122d
PA
3189/* Return all the symtabs associated to the FILENAME. If SEARCH_PSPACE is
3190 not NULL, the search is restricted to just that program space. */
f8eba3c6 3191
ec94af83 3192static VEC (symtab_ptr) *
c2f4122d
PA
3193symtabs_from_filename (const char *filename,
3194 struct program_space *search_pspace)
40e084e1 3195{
ec94af83 3196 VEC (symtab_ptr) *result;
40e084e1 3197
c2f4122d 3198 result = collect_symtabs_from_filename (filename, search_pspace);
f8eba3c6 3199
ec94af83 3200 if (VEC_empty (symtab_ptr, result))
f8eba3c6 3201 {
40e084e1
KS
3202 if (!have_full_symbols () && !have_partial_symbols ())
3203 throw_error (NOT_FOUND_ERROR,
3204 _("No symbol table is loaded. "
3205 "Use the \"file\" command."));
00e52e53 3206 source_file_not_found_error (filename);
f8eba3c6
TT
3207 }
3208
40e084e1 3209 return result;
84fba31b 3210}
f3c39e76 3211
40e084e1
KS
3212/* Look up a function symbol named NAME in symtabs FILE_SYMTABS. Matching
3213 debug symbols are returned in SYMBOLS. Matching minimal symbols are
3214 returned in MINSYMS. */
14e91ac5 3215
40e084e1
KS
3216static void
3217find_function_symbols (struct linespec_state *state,
ec94af83 3218 VEC (symtab_ptr) *file_symtabs, const char *name,
40e084e1 3219 VEC (symbolp) **symbols,
f60e2d5c 3220 VEC (bound_minimal_symbol_d) **minsyms)
14e91ac5 3221{
40e084e1
KS
3222 struct collect_info info;
3223 VEC (const_char_ptr) *symbol_names = NULL;
3224 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
3225 &symbol_names);
14e91ac5 3226
40e084e1
KS
3227 info.state = state;
3228 info.result.symbols = NULL;
3229 info.result.minimal_symbols = NULL;
3230 info.file_symtabs = file_symtabs;
e0881a8e 3231
40e084e1 3232 /* Try NAME as an Objective-C selector. */
d7561cbb 3233 find_imps (name, &symbol_names);
40e084e1 3234 if (!VEC_empty (const_char_ptr, symbol_names))
c2f4122d
PA
3235 add_all_symbol_names_from_pspace (&info, state->search_pspace,
3236 symbol_names);
40e084e1 3237 else
c2f4122d 3238 add_matching_symbols_to_info (name, &info, state->search_pspace);
40e084e1
KS
3239
3240 do_cleanups (cleanup);
3241
3242 if (VEC_empty (symbolp, info.result.symbols))
3243 {
3244 VEC_free (symbolp, info.result.symbols);
3245 *symbols = NULL;
14e91ac5
DC
3246 }
3247 else
40e084e1
KS
3248 *symbols = info.result.symbols;
3249
f60e2d5c 3250 if (VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols))
14e91ac5 3251 {
f60e2d5c 3252 VEC_free (bound_minimal_symbol_d, info.result.minimal_symbols);
40e084e1
KS
3253 *minsyms = NULL;
3254 }
3255 else
3256 *minsyms = info.result.minimal_symbols;
3257}
3258
3259/* Find all symbols named NAME in FILE_SYMTABS, returning debug symbols
3260 in SYMBOLS and minimal symbols in MINSYMS. */
14e91ac5 3261
b1ae631a 3262static void
40e084e1 3263find_linespec_symbols (struct linespec_state *state,
ec94af83 3264 VEC (symtab_ptr) *file_symtabs,
40e084e1
KS
3265 const char *name,
3266 VEC (symbolp) **symbols,
f60e2d5c 3267 VEC (bound_minimal_symbol_d) **minsyms)
40e084e1 3268{
2f408ecb
PA
3269 demangle_result_storage demangle_storage;
3270 std::string ada_lookup_storage;
cc81e1c6 3271 const char *lookup_name;
f8eba3c6 3272
40e084e1
KS
3273 if (state->language->la_language == language_ada)
3274 {
3275 /* In Ada, the symbol lookups are performed using the encoded
3276 name rather than the demangled name. */
2f408ecb
PA
3277 ada_lookup_storage = ada_name_for_lookup (name);
3278 lookup_name = ada_lookup_storage.c_str ();
40e084e1 3279 }
2f408ecb 3280 else
40e084e1 3281 {
2f408ecb
PA
3282 lookup_name = demangle_for_lookup (name,
3283 state->language->la_language,
3284 demangle_storage);
40e084e1 3285 }
f8eba3c6 3286
2f408ecb
PA
3287 std::string canon = cp_canonicalize_string_no_typedefs (lookup_name);
3288 if (!canon.empty ())
3289 lookup_name = canon.c_str ();
3290
cc81e1c6
DE
3291 /* It's important to not call expand_symtabs_matching unnecessarily
3292 as it can really slow things down (by unnecessarily expanding
3293 potentially 1000s of symtabs, which when debugging some apps can
3294 cost 100s of seconds). Avoid this to some extent by *first* calling
3295 find_function_symbols, and only if that doesn't find anything
3296 *then* call find_method. This handles two important cases:
3297 1) break (anonymous namespace)::foo
3298 2) break class::method where method is in class (and not a baseclass) */
14e91ac5 3299
cc81e1c6
DE
3300 find_function_symbols (state, file_symtabs, lookup_name,
3301 symbols, minsyms);
14e91ac5 3302
cc81e1c6
DE
3303 /* If we were unable to locate a symbol of the same name, try dividing
3304 the name into class and method names and searching the class and its
3305 baseclasses. */
3306 if (VEC_empty (symbolp, *symbols)
f60e2d5c 3307 && VEC_empty (bound_minimal_symbol_d, *minsyms))
40e084e1 3308 {
2f408ecb 3309 std::string klass, method;
cc81e1c6
DE
3310 const char *last, *p, *scope_op;
3311 VEC (symbolp) *classes;
14e91ac5 3312
cc81e1c6
DE
3313 /* See if we can find a scope operator and break this symbol
3314 name into namespaces${SCOPE_OPERATOR}class_name and method_name. */
3315 scope_op = "::";
3316 p = find_toplevel_string (lookup_name, scope_op);
14e91ac5 3317
cc81e1c6
DE
3318 last = NULL;
3319 while (p != NULL)
f8eba3c6 3320 {
cc81e1c6
DE
3321 last = p;
3322 p = find_toplevel_string (p + strlen (scope_op), scope_op);
f8eba3c6 3323 }
14e91ac5 3324
cc81e1c6
DE
3325 /* If no scope operator was found, there is nothing more we can do;
3326 we already attempted to lookup the entire name as a symbol
3327 and failed. */
3328 if (last == NULL)
2f408ecb 3329 return;
cc81e1c6
DE
3330
3331 /* LOOKUP_NAME points to the class name.
3332 LAST points to the method name. */
2f408ecb 3333 klass = std::string (lookup_name, last - lookup_name);
cc81e1c6
DE
3334
3335 /* Skip past the scope operator. */
3336 last += strlen (scope_op);
2f408ecb 3337 method = last;
cc81e1c6
DE
3338
3339 /* Find a list of classes named KLASS. */
2f408ecb
PA
3340 classes = lookup_prefix_sym (state, file_symtabs, klass.c_str ());
3341 struct cleanup *old_chain
3342 = make_cleanup (VEC_cleanup (symbolp), &classes);
cc81e1c6
DE
3343
3344 if (!VEC_empty (symbolp, classes))
3345 {
3346 /* Now locate a list of suitable methods named METHOD. */
492d29ea 3347 TRY
cc81e1c6 3348 {
2f408ecb
PA
3349 find_method (state, file_symtabs,
3350 klass.c_str (), method.c_str (),
3351 classes, symbols, minsyms);
cc81e1c6
DE
3352 }
3353
3354 /* If successful, we're done. If NOT_FOUND_ERROR
3355 was not thrown, rethrow the exception that we did get. */
492d29ea 3356 CATCH (except, RETURN_MASK_ERROR)
7556d4a4
PA
3357 {
3358 if (except.error != NOT_FOUND_ERROR)
3359 throw_exception (except);
3360 }
492d29ea 3361 END_CATCH
cc81e1c6 3362 }
14e91ac5 3363
2f408ecb
PA
3364 do_cleanups (old_chain);
3365 }
14e91ac5
DC
3366}
3367
40e084e1
KS
3368/* Return all labels named NAME in FUNCTION_SYMBOLS. Return the
3369 actual function symbol in which the label was found in LABEL_FUNC_RET. */
0f5238ed 3370
40e084e1
KS
3371static VEC (symbolp) *
3372find_label_symbols (struct linespec_state *self,
3373 VEC (symbolp) *function_symbols,
3374 VEC (symbolp) **label_funcs_ret, const char *name)
0f5238ed 3375{
f8eba3c6 3376 int ix;
3977b71f 3377 const struct block *block;
40e084e1
KS
3378 struct symbol *sym;
3379 struct symbol *fn_sym;
3380 VEC (symbolp) *result = NULL;
9ef07c8c 3381
f8eba3c6 3382 if (function_symbols == NULL)
9ef07c8c 3383 {
f8eba3c6 3384 set_current_program_space (self->program_space);
4eeaa230 3385 block = get_current_search_block ();
f8eba3c6 3386
9ef07c8c
TT
3387 for (;
3388 block && !BLOCK_FUNCTION (block);
3389 block = BLOCK_SUPERBLOCK (block))
3390 ;
3391 if (!block)
40e084e1 3392 return NULL;
f8eba3c6
TT
3393 fn_sym = BLOCK_FUNCTION (block);
3394
d12307c1 3395 sym = lookup_symbol (name, block, LABEL_DOMAIN, 0).symbol;
f8eba3c6 3396
40e084e1
KS
3397 if (sym != NULL)
3398 {
3399 VEC_safe_push (symbolp, result, sym);
3400 VEC_safe_push (symbolp, *label_funcs_ret, fn_sym);
3401 }
3402 }
3403 else
3404 {
3405 for (ix = 0;
3406 VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix)
f8eba3c6 3407 {
08be3fe3 3408 set_current_program_space (SYMTAB_PSPACE (symbol_symtab (fn_sym)));
40e084e1 3409 block = SYMBOL_BLOCK_VALUE (fn_sym);
d12307c1 3410 sym = lookup_symbol (name, block, LABEL_DOMAIN, 0).symbol;
40e084e1
KS
3411
3412 if (sym != NULL)
3413 {
3414 VEC_safe_push (symbolp, result, sym);
3415 VEC_safe_push (symbolp, *label_funcs_ret, fn_sym);
3416 }
f8eba3c6 3417 }
40e084e1 3418 }
f8eba3c6 3419
40e084e1
KS
3420 return result;
3421}
f8eba3c6 3422
40e084e1
KS
3423\f
3424
3425/* A helper for create_sals_line_offset that handles the 'list_mode' case. */
3426
3427static void
3428decode_digits_list_mode (struct linespec_state *self,
3429 linespec_p ls,
3430 struct symtabs_and_lines *values,
3431 struct symtab_and_line val)
3432{
3433 int ix;
3434 struct symtab *elt;
3435
3436 gdb_assert (self->list_mode);
3437
ec94af83 3438 for (ix = 0; VEC_iterate (symtab_ptr, ls->file_symtabs, ix, elt);
40e084e1
KS
3439 ++ix)
3440 {
3441 /* The logic above should ensure this. */
3442 gdb_assert (elt != NULL);
3443
3444 set_current_program_space (SYMTAB_PSPACE (elt));
3445
3446 /* Simplistic search just for the list command. */
3447 val.symtab = find_line_symtab (elt, val.line, NULL, NULL);
3448 if (val.symtab == NULL)
3449 val.symtab = elt;
3450 val.pspace = SYMTAB_PSPACE (elt);
3451 val.pc = 0;
3452 val.explicit_line = 1;
3453
66f1999b 3454 add_sal_to_sals (self, values, &val, NULL, 0);
f8eba3c6 3455 }
40e084e1 3456}
f8eba3c6 3457
40e084e1
KS
3458/* A helper for create_sals_line_offset that iterates over the symtabs,
3459 adding lines to the VEC. */
3460
3461static void
3462decode_digits_ordinary (struct linespec_state *self,
3463 linespec_p ls,
3464 int line,
3465 struct symtabs_and_lines *sals,
3466 struct linetable_entry **best_entry)
3467{
3468 int ix;
3469 struct symtab *elt;
f8eba3c6 3470
ec94af83 3471 for (ix = 0; VEC_iterate (symtab_ptr, ls->file_symtabs, ix, elt); ++ix)
f8eba3c6 3472 {
67d89901 3473 std::vector<CORE_ADDR> pcs;
40e084e1
KS
3474
3475 /* The logic above should ensure this. */
3476 gdb_assert (elt != NULL);
f8eba3c6 3477
40e084e1 3478 set_current_program_space (SYMTAB_PSPACE (elt));
f8eba3c6 3479
40e084e1 3480 pcs = find_pcs_for_symtab_line (elt, line, best_entry);
67d89901 3481 for (CORE_ADDR pc : pcs)
f8eba3c6
TT
3482 {
3483 struct symtab_and_line sal;
40e084e1
KS
3484
3485 init_sal (&sal);
3486 sal.pspace = SYMTAB_PSPACE (elt);
3487 sal.symtab = elt;
3488 sal.line = line;
3489 sal.pc = pc;
3490 add_sal_to_sals_basic (sals, &sal);
f8eba3c6
TT
3491 }
3492 }
40e084e1
KS
3493}
3494
3495\f
3496
3497/* Return the line offset represented by VARIABLE. */
3498
3499static struct line_offset
3500linespec_parse_variable (struct linespec_state *self, const char *variable)
3501{
3502 int index = 0;
3503 const char *p;
3504 struct line_offset offset = {0, LINE_OFFSET_NONE};
f8eba3c6 3505
40e084e1
KS
3506 p = (variable[1] == '$') ? variable + 2 : variable + 1;
3507 if (*p == '$')
3508 ++p;
3509 while (*p >= '0' && *p <= '9')
3510 ++p;
3511 if (!*p) /* Reached end of token without hitting non-digit. */
f8eba3c6 3512 {
40e084e1
KS
3513 /* We have a value history reference. */
3514 struct value *val_history;
f8eba3c6 3515
40e084e1
KS
3516 sscanf ((variable[1] == '$') ? variable + 2 : variable + 1, "%d", &index);
3517 val_history
3518 = access_value_history ((variable[1] == '$') ? -index : index);
3519 if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
3520 error (_("History values used in line "
3521 "specs must have integer values."));
3522 offset.offset = value_as_long (val_history);
3523 }
3524 else
3525 {
3526 /* Not all digits -- may be user variable/function or a
3527 convenience variable. */
3528 LONGEST valx;
3529 struct internalvar *ivar;
3530
3531 /* Try it as a convenience variable. If it is not a convenience
3532 variable, return and allow normal symbol lookup to occur. */
3533 ivar = lookup_only_internalvar (variable + 1);
3534 if (ivar == NULL)
3535 /* No internal variable with that name. Mark the offset
3536 as unknown to allow the name to be looked up as a symbol. */
3537 offset.sign = LINE_OFFSET_UNKNOWN;
3538 else
3539 {
3540 /* We found a valid variable name. If it is not an integer,
3541 throw an error. */
3542 if (!get_internalvar_integer (ivar, &valx))
3543 error (_("Convenience variables used in line "
3544 "specs must have integer values."));
3545 else
3546 offset.offset = valx;
3547 }
f8eba3c6
TT
3548 }
3549
40e084e1 3550 return offset;
f8eba3c6 3551}
40e084e1 3552\f
f8eba3c6 3553
40e084e1 3554/* We've found a minimal symbol MSYMBOL in OBJFILE to associate with our
6e22494e
JK
3555 linespec; return the SAL in RESULT. This function should return SALs
3556 matching those from find_function_start_sal, otherwise false
3557 multiple-locations breakpoints could be placed. */
f8eba3c6
TT
3558
3559static void
3560minsym_found (struct linespec_state *self, struct objfile *objfile,
3561 struct minimal_symbol *msymbol,
3562 struct symtabs_and_lines *result)
3563{
3564 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3565 CORE_ADDR pc;
3566 struct symtab_and_line sal;
3567
77e371c0 3568 sal = find_pc_sect_line (MSYMBOL_VALUE_ADDRESS (objfile, msymbol),
f8eba3c6 3569 (struct obj_section *) 0, 0);
efd66ac6 3570 sal.section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
f8eba3c6
TT
3571
3572 /* The minimal symbol might point to a function descriptor;
3573 resolve it to the actual code address instead. */
3574 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, &current_target);
3575 if (pc != sal.pc)
3576 sal = find_pc_sect_line (pc, NULL, 0);
3577
3578 if (self->funfirstline)
6e22494e
JK
3579 {
3580 if (sal.symtab != NULL
3581 && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
3582 || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
3583 {
3584 /* If gdbarch_convert_from_func_ptr_addr does not apply then
3585 sal.SECTION, sal.LINE&co. will stay correct from above.
3586 If gdbarch_convert_from_func_ptr_addr applies then
3587 sal.SECTION is cleared from above and sal.LINE&co. will
3588 stay correct from the last find_pc_sect_line above. */
3589 sal.pc = MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
3590 sal.pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc,
3591 &current_target);
141c5cc4
JK
3592 if (gdbarch_skip_entrypoint_p (gdbarch))
3593 sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc);
6e22494e
JK
3594 }
3595 else
3596 skip_prologue_sal (&sal);
3597 }
f8eba3c6 3598
07fea4b4 3599 if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc))
efd66ac6 3600 add_sal_to_sals (self, result, &sal, MSYMBOL_NATURAL_NAME (msymbol), 0);
f8eba3c6
TT
3601}
3602
39b856a4
TT
3603/* A helper struct to pass some data through
3604 iterate_over_minimal_symbols. */
3605
3606struct collect_minsyms
3607{
3608 /* The objfile we're examining. */
3609 struct objfile *objfile;
3610
87186c6a
MMN
3611 /* Only search the given symtab, or NULL to search for all symbols. */
3612 struct symtab *symtab;
3613
39b856a4
TT
3614 /* The funfirstline setting from the initial call. */
3615 int funfirstline;
3616
095bcf5e
JB
3617 /* The list_mode setting from the initial call. */
3618 int list_mode;
3619
39b856a4 3620 /* The resulting symbols. */
f60e2d5c 3621 VEC (bound_minimal_symbol_d) *msyms;
39b856a4
TT
3622};
3623
3624/* A helper function to classify a minimal_symbol_type according to
3625 priority. */
3626
3627static int
3628classify_mtype (enum minimal_symbol_type t)
3629{
3630 switch (t)
f8eba3c6 3631 {
39b856a4
TT
3632 case mst_file_text:
3633 case mst_file_data:
3634 case mst_file_bss:
3635 /* Intermediate priority. */
3636 return 1;
3637
3638 case mst_solib_trampoline:
3639 /* Lowest priority. */
3640 return 2;
3641
3642 default:
3643 /* Highest priority. */
3644 return 0;
f8eba3c6 3645 }
39b856a4
TT
3646}
3647
3648/* Callback for qsort that sorts symbols by priority. */
3649
3650static int
3651compare_msyms (const void *a, const void *b)
3652{
9a3c8263
SM
3653 const bound_minimal_symbol_d *moa = (const bound_minimal_symbol_d *) a;
3654 const bound_minimal_symbol_d *mob = (const bound_minimal_symbol_d *) b;
39b856a4
TT
3655 enum minimal_symbol_type ta = MSYMBOL_TYPE (moa->minsym);
3656 enum minimal_symbol_type tb = MSYMBOL_TYPE (mob->minsym);
3657
3658 return classify_mtype (ta) - classify_mtype (tb);
3659}
3660
3661/* Callback for iterate_over_minimal_symbols that adds the symbol to
3662 the result. */
3663
3664static void
3665add_minsym (struct minimal_symbol *minsym, void *d)
3666{
9a3c8263 3667 struct collect_minsyms *info = (struct collect_minsyms *) d;
f60e2d5c 3668 bound_minimal_symbol_d mo;
39b856a4 3669
77e371c0
TT
3670 mo.minsym = minsym;
3671 mo.objfile = info->objfile;
3672
87186c6a
MMN
3673 if (info->symtab != NULL)
3674 {
3675 CORE_ADDR pc;
3676 struct symtab_and_line sal;
3677 struct gdbarch *gdbarch = get_objfile_arch (info->objfile);
3678
3679 sal = find_pc_sect_line (MSYMBOL_VALUE_ADDRESS (info->objfile, minsym),
3680 NULL, 0);
3681 sal.section = MSYMBOL_OBJ_SECTION (info->objfile, minsym);
3682 pc
3683 = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, &current_target);
3684 if (pc != sal.pc)
3685 sal = find_pc_sect_line (pc, NULL, 0);
3686
3687 if (info->symtab != sal.symtab)
3688 return;
3689 }
3690
095bcf5e
JB
3691 /* Exclude data symbols when looking for breakpoint locations. */
3692 if (!info->list_mode)
3693 switch (minsym->type)
3694 {
3695 case mst_slot_got_plt:
3696 case mst_data:
3697 case mst_bss:
3698 case mst_abs:
3699 case mst_file_data:
3700 case mst_file_bss:
1a2da5ee
JB
3701 {
3702 /* Make sure this minsym is not a function descriptor
3703 before we decide to discard it. */
df6d5441 3704 struct gdbarch *gdbarch = get_objfile_arch (info->objfile);
1a2da5ee 3705 CORE_ADDR addr = gdbarch_convert_from_func_ptr_addr
77e371c0 3706 (gdbarch, BMSYMBOL_VALUE_ADDRESS (mo),
1a2da5ee
JB
3707 &current_target);
3708
77e371c0 3709 if (addr == BMSYMBOL_VALUE_ADDRESS (mo))
1a2da5ee
JB
3710 return;
3711 }
095bcf5e
JB
3712 }
3713
f60e2d5c 3714 VEC_safe_push (bound_minimal_symbol_d, info->msyms, &mo);
f8eba3c6
TT
3715}
3716
87186c6a 3717/* Search for minimal symbols called NAME. If SEARCH_PSPACE
f8eba3c6 3718 is not NULL, the search is restricted to just that program
87186c6a
MMN
3719 space.
3720
3721 If SYMTAB is NULL, search all objfiles, otherwise
3722 restrict results to the given SYMTAB. */
f8eba3c6
TT
3723
3724static void
3725search_minsyms_for_name (struct collect_info *info, const char *name,
87186c6a
MMN
3726 struct program_space *search_pspace,
3727 struct symtab *symtab)
f8eba3c6 3728{
87186c6a
MMN
3729 struct collect_minsyms local;
3730 struct cleanup *cleanup;
f8eba3c6 3731
87186c6a
MMN
3732 memset (&local, 0, sizeof (local));
3733 local.funfirstline = info->state->funfirstline;
3734 local.list_mode = info->state->list_mode;
3735 local.symtab = symtab;
39b856a4 3736
87186c6a 3737 cleanup = make_cleanup (VEC_cleanup (bound_minimal_symbol_d), &local.msyms);
f8eba3c6 3738
87186c6a
MMN
3739 if (symtab == NULL)
3740 {
3741 struct program_space *pspace;
f8eba3c6 3742
87186c6a
MMN
3743 ALL_PSPACES (pspace)
3744 {
3745 struct objfile *objfile;
39b856a4 3746
87186c6a
MMN
3747 if (search_pspace != NULL && search_pspace != pspace)
3748 continue;
3749 if (pspace->executing_startup)
3750 continue;
39b856a4 3751
87186c6a
MMN
3752 set_current_program_space (pspace);
3753
3754 ALL_OBJFILES (objfile)
3755 {
3756 local.objfile = objfile;
3757 iterate_over_minimal_symbols (objfile, name, add_minsym, &local);
3758 }
3759 }
3760 }
3761 else
f8eba3c6 3762 {
87186c6a
MMN
3763 if (search_pspace == NULL || SYMTAB_PSPACE (symtab) == search_pspace)
3764 {
3765 set_current_program_space (SYMTAB_PSPACE (symtab));
3766 local.objfile = SYMTAB_OBJFILE(symtab);
3767 iterate_over_minimal_symbols (local.objfile, name, add_minsym,
3768 &local);
3769 }
9ef07c8c 3770 }
39b856a4 3771
f60e2d5c 3772 if (!VEC_empty (bound_minimal_symbol_d, local.msyms))
39b856a4
TT
3773 {
3774 int classification;
3775 int ix;
f60e2d5c 3776 bound_minimal_symbol_d *item;
39b856a4 3777
f60e2d5c
TT
3778 qsort (VEC_address (bound_minimal_symbol_d, local.msyms),
3779 VEC_length (bound_minimal_symbol_d, local.msyms),
3780 sizeof (bound_minimal_symbol_d),
39b856a4
TT
3781 compare_msyms);
3782
3783 /* Now the minsyms are in classification order. So, we walk
3784 over them and process just the minsyms with the same
3785 classification as the very first minsym in the list. */
f60e2d5c 3786 item = VEC_index (bound_minimal_symbol_d, local.msyms, 0);
39b856a4
TT
3787 classification = classify_mtype (MSYMBOL_TYPE (item->minsym));
3788
3789 for (ix = 0;
f60e2d5c 3790 VEC_iterate (bound_minimal_symbol_d, local.msyms, ix, item);
39b856a4
TT
3791 ++ix)
3792 {
3793 if (classify_mtype (MSYMBOL_TYPE (item->minsym)) != classification)
3794 break;
3795
f60e2d5c 3796 VEC_safe_push (bound_minimal_symbol_d,
40e084e1 3797 info->result.minimal_symbols, item);
39b856a4
TT
3798 }
3799 }
3800
3801 do_cleanups (cleanup);
f8eba3c6
TT
3802}
3803
3804/* A helper function to add all symbols matching NAME to INFO. If
3805 PSPACE is not NULL, the search is restricted to just that program
3806 space. */
0f5238ed 3807
f8eba3c6
TT
3808static void
3809add_matching_symbols_to_info (const char *name,
3810 struct collect_info *info,
3811 struct program_space *pspace)
3812{
3813 int ix;
3814 struct symtab *elt;
0f5238ed 3815
ec94af83 3816 for (ix = 0; VEC_iterate (symtab_ptr, info->file_symtabs, ix, elt); ++ix)
f8eba3c6 3817 {
f8eba3c6
TT
3818 if (elt == NULL)
3819 {
40e084e1 3820 iterate_over_all_matching_symtabs (info->state, name, VAR_DOMAIN,
14bc53a8
PA
3821 pspace, true, [&] (symbol *sym)
3822 { return info->add_symbol (sym); });
87186c6a 3823 search_minsyms_for_name (info, name, pspace, NULL);
f8eba3c6
TT
3824 }
3825 else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))
3826 {
87186c6a
MMN
3827 int prev_len = VEC_length (symbolp, info->result.symbols);
3828
f8eba3c6
TT
3829 /* Program spaces that are executing startup should have
3830 been filtered out earlier. */
3831 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
3832 set_current_program_space (SYMTAB_PSPACE (elt));
14bc53a8
PA
3833 iterate_over_file_blocks (elt, name, VAR_DOMAIN, [&] (symbol *sym)
3834 { return info->add_symbol (sym); });
87186c6a
MMN
3835
3836 /* If no new symbols were found in this iteration and this symtab
3837 is in assembler, we might actually be looking for a label for
3838 which we don't have debug info. Check for a minimal symbol in
3839 this case. */
3840 if (prev_len == VEC_length (symbolp, info->result.symbols)
3841 && elt->language == language_asm)
3842 search_minsyms_for_name (info, name, pspace, elt);
f8eba3c6
TT
3843 }
3844 }
0f5238ed
TT
3845}
3846
14e91ac5
DC
3847\f
3848
413dad4d
DC
3849/* Now come some functions that are called from multiple places within
3850 decode_line_1. */
3851
f8eba3c6
TT
3852static int
3853symbol_to_sal (struct symtab_and_line *result,
3854 int funfirstline, struct symbol *sym)
413dad4d 3855{
413dad4d 3856 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
50641945 3857 {
f8eba3c6
TT
3858 *result = find_function_start_sal (sym, funfirstline);
3859 return 1;
50641945 3860 }
413dad4d
DC
3861 else
3862 {
62853458 3863 if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
413dad4d 3864 {
f8eba3c6 3865 init_sal (result);
08be3fe3 3866 result->symtab = symbol_symtab (sym);
f8eba3c6
TT
3867 result->line = SYMBOL_LINE (sym);
3868 result->pc = SYMBOL_VALUE_ADDRESS (sym);
08be3fe3 3869 result->pspace = SYMTAB_PSPACE (result->symtab);
f8eba3c6
TT
3870 result->explicit_pc = 1;
3871 return 1;
413dad4d 3872 }
62853458 3873 else if (funfirstline)
dcf9f4ab 3874 {
f8eba3c6 3875 /* Nothing. */
dcf9f4ab 3876 }
62853458
TT
3877 else if (SYMBOL_LINE (sym) != 0)
3878 {
3879 /* We know its line number. */
f8eba3c6 3880 init_sal (result);
08be3fe3 3881 result->symtab = symbol_symtab (sym);
f8eba3c6 3882 result->line = SYMBOL_LINE (sym);
08be3fe3 3883 result->pspace = SYMTAB_PSPACE (result->symtab);
f8eba3c6 3884 return 1;
62853458 3885 }
413dad4d 3886 }
f8eba3c6
TT
3887
3888 return 0;
413dad4d 3889}
50641945 3890
16e802b9 3891linespec_result::~linespec_result ()
f8eba3c6
TT
3892{
3893 int i;
3894 struct linespec_sals *lsal;
bccdca4a 3895
16e802b9 3896 for (i = 0; VEC_iterate (linespec_sals, sals, i, lsal); ++i)
f8eba3c6
TT
3897 {
3898 xfree (lsal->canonical);
3899 xfree (lsal->sals.sals);
3900 }
16e802b9 3901 VEC_free (linespec_sals, sals);
7efd8fc2 3902}
87f0e720
KS
3903
3904/* Return the quote characters permitted by the linespec parser. */
3905
3906const char *
3907get_gdb_linespec_parser_quote_characters (void)
3908{
3909 return linespec_quote_characters;
3910}
This page took 2.397826 seconds and 4 git commands to generate.