1 /* Parse expressions for GDB.
3 Copyright (C) 1986-2022 Free Software Foundation, Inc.
5 Modified from expread.y by the Department of Computer Science at the
6 State University of New York at Buffalo, 1991.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Parse an expression from text in a string,
24 and return the result as a struct expression pointer.
25 That structure contains arithmetic operations in reverse polish,
26 with constants represented by operations that are followed by special data.
27 See expression.h for the details of the format.
28 What is important here is that it can be built up sequentially
29 during the process of parsing; the lower levels of the tree always
30 come first in the result. */
34 #include "arch-utils.h"
38 #include "expression.h"
42 #include "parser-defs.h"
44 #include "symfile.h" /* for overlay functions */
46 #include "target-float.h"
50 #include "user-regs.h"
52 #include "gdbsupport/gdb_optional.h"
55 static unsigned int expressiondebug
= 0;
57 show_expressiondebug (struct ui_file
*file
, int from_tty
,
58 struct cmd_list_element
*c
, const char *value
)
60 gdb_printf (file
, _("Expression debugging is %s.\n"), value
);
64 /* True if an expression parser should set yydebug. */
68 show_parserdebug (struct ui_file
*file
, int from_tty
,
69 struct cmd_list_element
*c
, const char *value
)
71 gdb_printf (file
, _("Parser debugging is %s.\n"), value
);
75 static expression_up parse_exp_in_context
76 (const char **, CORE_ADDR
,
77 const struct block
*, int,
78 bool, innermost_block_tracker
*,
79 std::unique_ptr
<expr_completion_base
> *);
81 /* Documented at it's declaration. */
84 innermost_block_tracker::update (const struct block
*b
,
85 innermost_block_tracker_types t
)
87 if ((m_types
& t
) != 0
88 && (m_innermost_block
== NULL
89 || contained_in (b
, m_innermost_block
)))
90 m_innermost_block
= b
;
95 /* Return the type of MSYMBOL, a minimal symbol of OBJFILE. If
96 ADDRESS_P is not NULL, set it to the MSYMBOL's resolved
100 find_minsym_type_and_address (minimal_symbol
*msymbol
,
101 struct objfile
*objfile
,
102 CORE_ADDR
*address_p
)
104 bound_minimal_symbol bound_msym
= {msymbol
, objfile
};
105 struct obj_section
*section
= msymbol
->obj_section (objfile
);
106 enum minimal_symbol_type type
= MSYMBOL_TYPE (msymbol
);
108 bool is_tls
= (section
!= NULL
109 && section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
);
111 /* The minimal symbol might point to a function descriptor;
112 resolve it to the actual code address instead. */
116 /* Addresses of TLS symbols are really offsets into a
117 per-objfile/per-thread storage block. */
118 addr
= MSYMBOL_VALUE_RAW_ADDRESS (bound_msym
.minsym
);
120 else if (msymbol_is_function (objfile
, msymbol
, &addr
))
122 if (addr
!= BMSYMBOL_VALUE_ADDRESS (bound_msym
))
124 /* This means we resolved a function descriptor, and we now
125 have an address for a code/text symbol instead of a data
127 if (MSYMBOL_TYPE (msymbol
) == mst_data_gnu_ifunc
)
128 type
= mst_text_gnu_ifunc
;
135 addr
= BMSYMBOL_VALUE_ADDRESS (bound_msym
);
137 if (overlay_debugging
)
138 addr
= symbol_overlayed_address (addr
, section
);
142 /* Skip translation if caller does not need the address. */
143 if (address_p
!= NULL
)
144 *address_p
= target_translate_tls_address (objfile
, addr
);
145 return objfile_type (objfile
)->nodebug_tls_symbol
;
148 if (address_p
!= NULL
)
155 case mst_solib_trampoline
:
156 return objfile_type (objfile
)->nodebug_text_symbol
;
158 case mst_text_gnu_ifunc
:
159 return objfile_type (objfile
)->nodebug_text_gnu_ifunc_symbol
;
165 return objfile_type (objfile
)->nodebug_data_symbol
;
167 case mst_slot_got_plt
:
168 return objfile_type (objfile
)->nodebug_got_plt_symbol
;
171 return objfile_type (objfile
)->nodebug_unknown_symbol
;
176 expr_complete_tag::complete (struct expression
*exp
,
177 completion_tracker
&tracker
)
179 collect_symbol_completion_matches_type (tracker
, m_name
.get (),
180 m_name
.get (), m_code
);
184 /* See parser-defs.h. */
187 parser_state::mark_struct_expression (expr::structop_base_operation
*op
)
189 gdb_assert (parse_completion
&& m_completion_state
== nullptr);
190 m_completion_state
.reset (new expr_complete_structop (op
));
193 /* Indicate that the current parser invocation is completing a tag.
194 TAG is the type code of the tag, and PTR and LENGTH represent the
195 start of the tag name. */
198 parser_state::mark_completion_tag (enum type_code tag
, const char *ptr
,
201 gdb_assert (parse_completion
&& m_completion_state
== nullptr);
202 gdb_assert (tag
== TYPE_CODE_UNION
203 || tag
== TYPE_CODE_STRUCT
204 || tag
== TYPE_CODE_ENUM
);
205 m_completion_state
.reset
206 (new expr_complete_tag (tag
, make_unique_xstrndup (ptr
, length
)));
209 /* See parser-defs.h. */
212 parser_state::push_c_string (int kind
, struct stoken_vector
*vec
)
214 std::vector
<std::string
> data (vec
->len
);
215 for (int i
= 0; i
< vec
->len
; ++i
)
216 data
[i
] = std::string (vec
->tokens
[i
].ptr
, vec
->tokens
[i
].length
);
218 push_new
<expr::c_string_operation
> ((enum c_string_type_values
) kind
,
222 /* See parser-defs.h. */
225 parser_state::push_symbol (const char *name
, block_symbol sym
)
227 if (sym
.symbol
!= nullptr)
229 if (symbol_read_needs_frame (sym
.symbol
))
230 block_tracker
->update (sym
);
231 push_new
<expr::var_value_operation
> (sym
);
235 struct bound_minimal_symbol msymbol
= lookup_bound_minimal_symbol (name
);
236 if (msymbol
.minsym
!= NULL
)
237 push_new
<expr::var_msym_value_operation
> (msymbol
);
238 else if (!have_full_symbols () && !have_partial_symbols ())
239 error (_("No symbol table is loaded. Use the \"file\" command."));
241 error (_("No symbol \"%s\" in current context."), name
);
245 /* See parser-defs.h. */
248 parser_state::push_dollar (struct stoken str
)
250 struct block_symbol sym
;
251 struct bound_minimal_symbol msym
;
252 struct internalvar
*isym
= NULL
;
255 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
256 and $$digits (equivalent to $<-digits> if you could type that). */
260 /* Double dollar means negate the number and add -1 as well.
261 Thus $$ alone means -1. */
262 if (str
.length
>= 2 && str
.ptr
[1] == '$')
269 /* Just dollars (one or two). */
273 /* Is the rest of the token digits? */
274 for (; i
< str
.length
; i
++)
275 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
279 i
= atoi (str
.ptr
+ 1 + negate
);
285 /* Handle tokens that refer to machine registers:
286 $ followed by a register name. */
287 i
= user_reg_map_name_to_regnum (gdbarch (),
288 str
.ptr
+ 1, str
.length
- 1);
290 goto handle_register
;
292 /* Any names starting with $ are probably debugger internal variables. */
294 copy
= copy_name (str
);
295 isym
= lookup_only_internalvar (copy
.c_str () + 1);
298 push_new
<expr::internalvar_operation
> (isym
);
302 /* On some systems, such as HP-UX and hppa-linux, certain system routines
303 have names beginning with $ or $$. Check for those, first. */
305 sym
= lookup_symbol (copy
.c_str (), NULL
, VAR_DOMAIN
, NULL
);
308 push_new
<expr::var_value_operation
> (sym
);
311 msym
= lookup_bound_minimal_symbol (copy
.c_str ());
314 push_new
<expr::var_msym_value_operation
> (msym
);
318 /* Any other names are assumed to be debugger internal variables. */
320 push_new
<expr::internalvar_operation
>
321 (create_internalvar (copy
.c_str () + 1));
324 push_new
<expr::last_operation
> (i
);
329 push_new
<expr::register_operation
> (copy_name (str
));
330 block_tracker
->update (expression_context_block
,
331 INNERMOST_BLOCK_FOR_REGISTERS
);
338 find_template_name_end (const char *p
)
341 int just_seen_right
= 0;
342 int just_seen_colon
= 0;
343 int just_seen_space
= 0;
345 if (!p
|| (*p
!= '<'))
356 /* In future, may want to allow these?? */
359 depth
++; /* start nested template */
360 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
361 return 0; /* but not after : or :: or > or space */
364 if (just_seen_colon
|| just_seen_right
)
365 return 0; /* end a (nested?) template */
366 just_seen_right
= 1; /* but not after : or :: */
367 if (--depth
== 0) /* also disallow >>, insist on > > */
368 return ++p
; /* if outermost ended, return */
371 if (just_seen_space
|| (just_seen_colon
> 1))
372 return 0; /* nested class spec coming up */
373 just_seen_colon
++; /* we allow :: but not :::: */
378 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
379 (*p
>= 'A' && *p
<= 'Z') ||
380 (*p
>= '0' && *p
<= '9') ||
381 (*p
== '_') || (*p
== ',') || /* commas for template args */
382 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
383 (*p
== '(') || (*p
== ')') || /* function types */
384 (*p
== '[') || (*p
== ']'))) /* array types */
398 /* Return a null-terminated temporary copy of the name of a string token.
400 Tokens that refer to names do so with explicit pointer and length,
401 so they can share the storage that lexptr is parsing.
402 When it is necessary to pass a name to a function that expects
403 a null-terminated string, the substring is copied out
404 into a separate block of storage. */
407 copy_name (struct stoken token
)
409 return std::string (token
.ptr
, token
.length
);
413 /* Read an expression from the string *STRINGPTR points to,
414 parse it, and return a pointer to a struct expression that we malloc.
415 Use block BLOCK as the lexical context for variable names;
416 if BLOCK is zero, use the block of the selected stack frame.
417 Meanwhile, advance *STRINGPTR to point after the expression,
418 at the first nonwhite character that is not part of the expression
419 (possibly a null character).
421 If COMMA is nonzero, stop if a comma is reached. */
424 parse_exp_1 (const char **stringptr
, CORE_ADDR pc
, const struct block
*block
,
425 int comma
, innermost_block_tracker
*tracker
)
427 return parse_exp_in_context (stringptr
, pc
, block
, comma
, false,
431 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
432 no value is expected from the expression. */
435 parse_exp_in_context (const char **stringptr
, CORE_ADDR pc
,
436 const struct block
*block
,
437 int comma
, bool void_context_p
,
438 innermost_block_tracker
*tracker
,
439 std::unique_ptr
<expr_completion_base
> *completer
)
441 const struct language_defn
*lang
= NULL
;
443 if (*stringptr
== 0 || **stringptr
== 0)
444 error_no_arg (_("expression to compute"));
446 const struct block
*expression_context_block
= block
;
447 CORE_ADDR expression_context_pc
= 0;
449 innermost_block_tracker local_tracker
;
450 if (tracker
== nullptr)
451 tracker
= &local_tracker
;
453 /* If no context specified, try using the current frame, if any. */
454 if (!expression_context_block
)
455 expression_context_block
= get_selected_block (&expression_context_pc
);
457 expression_context_pc
= BLOCK_ENTRY_PC (expression_context_block
);
459 expression_context_pc
= pc
;
461 /* Fall back to using the current source static context, if any. */
463 if (!expression_context_block
)
465 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
467 expression_context_block
468 = BLOCKVECTOR_BLOCK (cursal
.symtab
->blockvector (),
470 if (expression_context_block
)
471 expression_context_pc
= BLOCK_ENTRY_PC (expression_context_block
);
474 if (language_mode
== language_mode_auto
&& block
!= NULL
)
476 /* Find the language associated to the given context block.
477 Default to the current language if it can not be determined.
479 Note that using the language corresponding to the current frame
480 can sometimes give unexpected results. For instance, this
481 routine is often called several times during the inferior
482 startup phase to re-parse breakpoint expressions after
483 a new shared library has been loaded. The language associated
484 to the current frame at this moment is not relevant for
485 the breakpoint. Using it would therefore be silly, so it seems
486 better to rely on the current language rather than relying on
487 the current frame language to parse the expression. That's why
488 we do the following language detection only if the context block
489 has been specifically provided. */
490 struct symbol
*func
= block_linkage_function (block
);
493 lang
= language_def (func
->language ());
494 if (lang
== NULL
|| lang
->la_language
== language_unknown
)
495 lang
= current_language
;
498 lang
= current_language
;
500 /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
501 While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
502 and others called from *.y) ensure CURRENT_LANGUAGE gets restored
503 to the value matching SELECTED_FRAME as set by get_current_arch. */
505 parser_state
ps (lang
, get_current_arch (), expression_context_block
,
506 expression_context_pc
, comma
, *stringptr
,
507 completer
!= nullptr, tracker
, void_context_p
);
509 scoped_restore_current_language lang_saver
;
510 set_language (lang
->la_language
);
516 catch (const gdb_exception
&except
)
518 /* If parsing for completion, allow this to succeed; but if no
519 expression elements have been written, then there's nothing
521 if (! ps
.parse_completion
|| ps
.expout
->op
== nullptr)
525 expression_up result
= ps
.release ();
526 result
->op
->set_outermost ();
529 dump_prefix_expression (result
.get (), gdb_stdlog
);
531 if (completer
!= nullptr)
532 *completer
= std::move (ps
.m_completion_state
);
533 *stringptr
= ps
.lexptr
;
537 /* Parse STRING as an expression, and complain if this fails to use up
538 all of the contents of STRING. TRACKER, if non-null, will be
539 updated by the parser. VOID_CONTEXT_P should be true to indicate
540 that the expression may be expected to return a value with void
541 type. Parsers are free to ignore this, or to use it to help with
542 overload resolution decisions. */
545 parse_expression (const char *string
, innermost_block_tracker
*tracker
,
548 expression_up exp
= parse_exp_in_context (&string
, 0, nullptr, 0,
552 error (_("Junk after end of expression."));
556 /* Same as parse_expression, but using the given language (LANG)
557 to parse the expression. */
560 parse_expression_with_language (const char *string
, enum language lang
)
562 gdb::optional
<scoped_restore_current_language
> lang_saver
;
563 if (current_language
->la_language
!= lang
)
565 lang_saver
.emplace ();
569 return parse_expression (string
);
572 /* Parse STRING as an expression. If the parse is marked for
573 completion, set COMPLETER and return the expression. In all other
574 cases, return NULL. */
577 parse_expression_for_completion
579 std::unique_ptr
<expr_completion_base
> *completer
)
585 exp
= parse_exp_in_context (&string
, 0, 0, 0, false, nullptr, completer
);
587 catch (const gdb_exception_error
&except
)
589 /* Nothing, EXP remains NULL. */
592 /* If we didn't get a completion result, be sure to also not return
593 an expression to our caller. */
594 if (*completer
== nullptr)
600 /* Parse floating point value P of length LEN.
601 Return false if invalid, true if valid.
602 The successfully parsed number is stored in DATA in
603 target format for floating-point type TYPE.
605 NOTE: This accepts the floating point syntax that sscanf accepts. */
608 parse_float (const char *p
, int len
,
609 const struct type
*type
, gdb_byte
*data
)
611 return target_float_from_string (data
, type
, std::string (p
, len
));
614 /* This function avoids direct calls to fprintf
615 in the parser generated debug code. */
617 parser_fprintf (FILE *x
, const char *y
, ...)
623 gdb_vprintf (gdb_stderr
, y
, args
);
626 gdb_printf (gdb_stderr
, " Unknown FILE used.\n");
627 gdb_vprintf (gdb_stderr
, y
, args
);
632 /* Return rue if EXP uses OBJFILE (and will become dangling when
633 OBJFILE is unloaded), otherwise return false. OBJFILE must not be
634 a separate debug info file. */
637 exp_uses_objfile (struct expression
*exp
, struct objfile
*objfile
)
639 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
641 return exp
->op
->uses_objfile (objfile
);
644 void _initialize_parse ();
648 add_setshow_zuinteger_cmd ("expression", class_maintenance
,
650 _("Set expression debugging."),
651 _("Show expression debugging."),
652 _("When non-zero, the internal representation "
653 "of expressions will be printed."),
655 show_expressiondebug
,
656 &setdebuglist
, &showdebuglist
);
657 add_setshow_boolean_cmd ("parser", class_maintenance
,
659 _("Set parser debugging."),
660 _("Show parser debugging."),
661 _("When non-zero, expression parser "
662 "tracing will be enabled."),
665 &setdebuglist
, &showdebuglist
);