1 /* Parse expressions for GDB.
3 Copyright (C) 1986-2019 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"
43 #include "parser-defs.h"
45 #include "symfile.h" /* for overlay functions */
47 #include "target-float.h"
51 #include "user-regs.h"
53 #include "common/gdb_optional.h"
55 /* Standard set of definitions for printing, dumping, prefixifying,
56 * and evaluating expressions. */
58 const struct exp_descriptor exp_descriptor_standard
=
60 print_subexp_standard
,
61 operator_length_standard
,
62 operator_check_standard
,
64 dump_subexp_body_standard
,
65 evaluate_subexp_standard
68 static unsigned int expressiondebug
= 0;
70 show_expressiondebug (struct ui_file
*file
, int from_tty
,
71 struct cmd_list_element
*c
, const char *value
)
73 fprintf_filtered (file
, _("Expression debugging is %s.\n"), value
);
77 /* Non-zero if an expression parser should set yydebug. */
81 show_parserdebug (struct ui_file
*file
, int from_tty
,
82 struct cmd_list_element
*c
, const char *value
)
84 fprintf_filtered (file
, _("Parser debugging is %s.\n"), value
);
88 static int prefixify_subexp (struct expression
*, struct expression
*, int,
91 static expression_up
parse_exp_in_context (const char **, CORE_ADDR
,
92 const struct block
*, int,
94 innermost_block_tracker
*,
95 expr_completion_state
*);
97 static void increase_expout_size (struct expr_builder
*ps
, size_t lenelt
);
100 /* Documented at it's declaration. */
103 innermost_block_tracker::update (const struct block
*b
,
104 innermost_block_tracker_types t
)
106 if ((m_types
& t
) != 0
107 && (m_innermost_block
== NULL
108 || contained_in (b
, m_innermost_block
)))
109 m_innermost_block
= b
;
114 /* See definition in parser-defs.h. */
116 expr_builder::expr_builder (const struct language_defn
*lang
,
117 struct gdbarch
*gdbarch
)
119 expout (XNEWVAR (expression
,
121 + EXP_ELEM_TO_BYTES (expout_size
)))),
124 expout
->language_defn
= lang
;
125 expout
->gdbarch
= gdbarch
;
129 expr_builder::release ()
131 /* Record the actual number of expression elements, and then
132 reallocate the expression memory so that we free up any
135 expout
->nelts
= expout_ptr
;
136 expout
.reset (XRESIZEVAR (expression
, expout
.release (),
138 + EXP_ELEM_TO_BYTES (expout_ptr
))));
140 return std::move (expout
);
143 /* This page contains the functions for adding data to the struct expression
144 being constructed. */
146 /* Add one element to the end of the expression. */
148 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
149 a register through here. */
152 write_exp_elt (struct expr_builder
*ps
, const union exp_element
*expelt
)
154 if (ps
->expout_ptr
>= ps
->expout_size
)
156 ps
->expout_size
*= 2;
157 ps
->expout
.reset (XRESIZEVAR (expression
, ps
->expout
.release (),
159 + EXP_ELEM_TO_BYTES (ps
->expout_size
))));
161 ps
->expout
->elts
[ps
->expout_ptr
++] = *expelt
;
165 write_exp_elt_opcode (struct expr_builder
*ps
, enum exp_opcode expelt
)
167 union exp_element tmp
;
169 memset (&tmp
, 0, sizeof (union exp_element
));
171 write_exp_elt (ps
, &tmp
);
175 write_exp_elt_sym (struct expr_builder
*ps
, struct symbol
*expelt
)
177 union exp_element tmp
;
179 memset (&tmp
, 0, sizeof (union exp_element
));
181 write_exp_elt (ps
, &tmp
);
185 write_exp_elt_msym (struct expr_builder
*ps
, minimal_symbol
*expelt
)
187 union exp_element tmp
;
189 memset (&tmp
, 0, sizeof (union exp_element
));
190 tmp
.msymbol
= expelt
;
191 write_exp_elt (ps
, &tmp
);
195 write_exp_elt_block (struct expr_builder
*ps
, const struct block
*b
)
197 union exp_element tmp
;
199 memset (&tmp
, 0, sizeof (union exp_element
));
201 write_exp_elt (ps
, &tmp
);
205 write_exp_elt_objfile (struct expr_builder
*ps
, struct objfile
*objfile
)
207 union exp_element tmp
;
209 memset (&tmp
, 0, sizeof (union exp_element
));
210 tmp
.objfile
= objfile
;
211 write_exp_elt (ps
, &tmp
);
215 write_exp_elt_longcst (struct expr_builder
*ps
, LONGEST expelt
)
217 union exp_element tmp
;
219 memset (&tmp
, 0, sizeof (union exp_element
));
220 tmp
.longconst
= expelt
;
221 write_exp_elt (ps
, &tmp
);
225 write_exp_elt_floatcst (struct expr_builder
*ps
, const gdb_byte expelt
[16])
227 union exp_element tmp
;
230 for (index
= 0; index
< 16; index
++)
231 tmp
.floatconst
[index
] = expelt
[index
];
233 write_exp_elt (ps
, &tmp
);
237 write_exp_elt_type (struct expr_builder
*ps
, struct type
*expelt
)
239 union exp_element tmp
;
241 memset (&tmp
, 0, sizeof (union exp_element
));
243 write_exp_elt (ps
, &tmp
);
247 write_exp_elt_intern (struct expr_builder
*ps
, struct internalvar
*expelt
)
249 union exp_element tmp
;
251 memset (&tmp
, 0, sizeof (union exp_element
));
252 tmp
.internalvar
= expelt
;
253 write_exp_elt (ps
, &tmp
);
256 /* Add a string constant to the end of the expression.
258 String constants are stored by first writing an expression element
259 that contains the length of the string, then stuffing the string
260 constant itself into however many expression elements are needed
261 to hold it, and then writing another expression element that contains
262 the length of the string. I.e. an expression element at each end of
263 the string records the string length, so you can skip over the
264 expression elements containing the actual string bytes from either
265 end of the string. Note that this also allows gdb to handle
266 strings with embedded null bytes, as is required for some languages.
268 Don't be fooled by the fact that the string is null byte terminated,
269 this is strictly for the convenience of debugging gdb itself.
270 Gdb does not depend up the string being null terminated, since the
271 actual length is recorded in expression elements at each end of the
272 string. The null byte is taken into consideration when computing how
273 many expression elements are required to hold the string constant, of
278 write_exp_string (struct expr_builder
*ps
, struct stoken str
)
280 int len
= str
.length
;
284 /* Compute the number of expression elements required to hold the string
285 (including a null byte terminator), along with one expression element
286 at each end to record the actual string length (not including the
287 null byte terminator). */
289 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
291 increase_expout_size (ps
, lenelt
);
293 /* Write the leading length expression element (which advances the current
294 expression element index), then write the string constant followed by a
295 terminating null byte, and then write the trailing length expression
298 write_exp_elt_longcst (ps
, (LONGEST
) len
);
299 strdata
= (char *) &ps
->expout
->elts
[ps
->expout_ptr
];
300 memcpy (strdata
, str
.ptr
, len
);
301 *(strdata
+ len
) = '\0';
302 ps
->expout_ptr
+= lenelt
- 2;
303 write_exp_elt_longcst (ps
, (LONGEST
) len
);
306 /* Add a vector of string constants to the end of the expression.
308 This adds an OP_STRING operation, but encodes the contents
309 differently from write_exp_string. The language is expected to
310 handle evaluation of this expression itself.
312 After the usual OP_STRING header, TYPE is written into the
313 expression as a long constant. The interpretation of this field is
314 up to the language evaluator.
316 Next, each string in VEC is written. The length is written as a
317 long constant, followed by the contents of the string. */
320 write_exp_string_vector (struct expr_builder
*ps
, int type
,
321 struct stoken_vector
*vec
)
326 /* Compute the size. We compute the size in number of slots to
327 avoid issues with string padding. */
329 for (i
= 0; i
< vec
->len
; ++i
)
331 /* One slot for the length of this element, plus the number of
332 slots needed for this string. */
333 n_slots
+= 1 + BYTES_TO_EXP_ELEM (vec
->tokens
[i
].length
);
336 /* One more slot for the type of the string. */
339 /* Now compute a phony string length. */
340 len
= EXP_ELEM_TO_BYTES (n_slots
) - 1;
343 increase_expout_size (ps
, n_slots
);
345 write_exp_elt_opcode (ps
, OP_STRING
);
346 write_exp_elt_longcst (ps
, len
);
347 write_exp_elt_longcst (ps
, type
);
349 for (i
= 0; i
< vec
->len
; ++i
)
351 write_exp_elt_longcst (ps
, vec
->tokens
[i
].length
);
352 memcpy (&ps
->expout
->elts
[ps
->expout_ptr
], vec
->tokens
[i
].ptr
,
353 vec
->tokens
[i
].length
);
354 ps
->expout_ptr
+= BYTES_TO_EXP_ELEM (vec
->tokens
[i
].length
);
357 write_exp_elt_longcst (ps
, len
);
358 write_exp_elt_opcode (ps
, OP_STRING
);
361 /* Add a bitstring constant to the end of the expression.
363 Bitstring constants are stored by first writing an expression element
364 that contains the length of the bitstring (in bits), then stuffing the
365 bitstring constant itself into however many expression elements are
366 needed to hold it, and then writing another expression element that
367 contains the length of the bitstring. I.e. an expression element at
368 each end of the bitstring records the bitstring length, so you can skip
369 over the expression elements containing the actual bitstring bytes from
370 either end of the bitstring. */
373 write_exp_bitstring (struct expr_builder
*ps
, struct stoken str
)
375 int bits
= str
.length
; /* length in bits */
376 int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
380 /* Compute the number of expression elements required to hold the bitstring,
381 along with one expression element at each end to record the actual
382 bitstring length in bits. */
384 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
386 increase_expout_size (ps
, lenelt
);
388 /* Write the leading length expression element (which advances the current
389 expression element index), then write the bitstring constant, and then
390 write the trailing length expression element. */
392 write_exp_elt_longcst (ps
, (LONGEST
) bits
);
393 strdata
= (char *) &ps
->expout
->elts
[ps
->expout_ptr
];
394 memcpy (strdata
, str
.ptr
, len
);
395 ps
->expout_ptr
+= lenelt
- 2;
396 write_exp_elt_longcst (ps
, (LONGEST
) bits
);
399 /* Return the type of MSYMBOL, a minimal symbol of OBJFILE. If
400 ADDRESS_P is not NULL, set it to the MSYMBOL's resolved
404 find_minsym_type_and_address (minimal_symbol
*msymbol
,
405 struct objfile
*objfile
,
406 CORE_ADDR
*address_p
)
408 bound_minimal_symbol bound_msym
= {msymbol
, objfile
};
409 struct obj_section
*section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
);
410 enum minimal_symbol_type type
= MSYMBOL_TYPE (msymbol
);
412 bool is_tls
= (section
!= NULL
413 && section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
);
415 /* The minimal symbol might point to a function descriptor;
416 resolve it to the actual code address instead. */
420 /* Addresses of TLS symbols are really offsets into a
421 per-objfile/per-thread storage block. */
422 addr
= MSYMBOL_VALUE_RAW_ADDRESS (bound_msym
.minsym
);
424 else if (msymbol_is_function (objfile
, msymbol
, &addr
))
426 if (addr
!= BMSYMBOL_VALUE_ADDRESS (bound_msym
))
428 /* This means we resolved a function descriptor, and we now
429 have an address for a code/text symbol instead of a data
431 if (MSYMBOL_TYPE (msymbol
) == mst_data_gnu_ifunc
)
432 type
= mst_text_gnu_ifunc
;
439 addr
= BMSYMBOL_VALUE_ADDRESS (bound_msym
);
441 if (overlay_debugging
)
442 addr
= symbol_overlayed_address (addr
, section
);
446 /* Skip translation if caller does not need the address. */
447 if (address_p
!= NULL
)
448 *address_p
= target_translate_tls_address (objfile
, addr
);
449 return objfile_type (objfile
)->nodebug_tls_symbol
;
452 if (address_p
!= NULL
)
459 case mst_solib_trampoline
:
460 return objfile_type (objfile
)->nodebug_text_symbol
;
462 case mst_text_gnu_ifunc
:
463 return objfile_type (objfile
)->nodebug_text_gnu_ifunc_symbol
;
469 return objfile_type (objfile
)->nodebug_data_symbol
;
471 case mst_slot_got_plt
:
472 return objfile_type (objfile
)->nodebug_got_plt_symbol
;
475 return objfile_type (objfile
)->nodebug_unknown_symbol
;
479 /* Add the appropriate elements for a minimal symbol to the end of
483 write_exp_msymbol (struct expr_builder
*ps
,
484 struct bound_minimal_symbol bound_msym
)
486 write_exp_elt_opcode (ps
, OP_VAR_MSYM_VALUE
);
487 write_exp_elt_objfile (ps
, bound_msym
.objfile
);
488 write_exp_elt_msym (ps
, bound_msym
.minsym
);
489 write_exp_elt_opcode (ps
, OP_VAR_MSYM_VALUE
);
492 /* See parser-defs.h. */
495 parser_state::mark_struct_expression ()
497 gdb_assert (parse_completion
498 && (m_completion_state
.expout_tag_completion_type
499 == TYPE_CODE_UNDEF
));
500 m_completion_state
.expout_last_struct
= expout_ptr
;
503 /* Indicate that the current parser invocation is completing a tag.
504 TAG is the type code of the tag, and PTR and LENGTH represent the
505 start of the tag name. */
508 parser_state::mark_completion_tag (enum type_code tag
, const char *ptr
,
511 gdb_assert (parse_completion
512 && (m_completion_state
.expout_tag_completion_type
514 && m_completion_state
.expout_completion_name
== NULL
515 && m_completion_state
.expout_last_struct
== -1);
516 gdb_assert (tag
== TYPE_CODE_UNION
517 || tag
== TYPE_CODE_STRUCT
518 || tag
== TYPE_CODE_ENUM
);
519 m_completion_state
.expout_tag_completion_type
= tag
;
520 m_completion_state
.expout_completion_name
.reset (xstrndup (ptr
, length
));
524 /* Recognize tokens that start with '$'. These include:
526 $regname A native register name or a "standard
529 $variable A convenience variable with a name chosen
532 $digits Value history with index <digits>, starting
533 from the first value which has index 1.
535 $$digits Value history with index <digits> relative
536 to the last value. I.e. $$0 is the last
537 value, $$1 is the one previous to that, $$2
538 is the one previous to $$1, etc.
540 $ | $0 | $$0 The last value in the value history.
542 $$ An abbreviation for the second to the last
543 value in the value history, I.e. $$1 */
546 write_dollar_variable (struct parser_state
*ps
, struct stoken str
)
548 struct block_symbol sym
;
549 struct bound_minimal_symbol msym
;
550 struct internalvar
*isym
= NULL
;
552 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
553 and $$digits (equivalent to $<-digits> if you could type that). */
557 /* Double dollar means negate the number and add -1 as well.
558 Thus $$ alone means -1. */
559 if (str
.length
>= 2 && str
.ptr
[1] == '$')
566 /* Just dollars (one or two). */
570 /* Is the rest of the token digits? */
571 for (; i
< str
.length
; i
++)
572 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
576 i
= atoi (str
.ptr
+ 1 + negate
);
582 /* Handle tokens that refer to machine registers:
583 $ followed by a register name. */
584 i
= user_reg_map_name_to_regnum (ps
->gdbarch (),
585 str
.ptr
+ 1, str
.length
- 1);
587 goto handle_register
;
589 /* Any names starting with $ are probably debugger internal variables. */
591 isym
= lookup_only_internalvar (copy_name (str
) + 1);
594 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
595 write_exp_elt_intern (ps
, isym
);
596 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
600 /* On some systems, such as HP-UX and hppa-linux, certain system routines
601 have names beginning with $ or $$. Check for those, first. */
603 sym
= lookup_symbol (copy_name (str
), NULL
, VAR_DOMAIN
, NULL
);
606 write_exp_elt_opcode (ps
, OP_VAR_VALUE
);
607 write_exp_elt_block (ps
, sym
.block
);
608 write_exp_elt_sym (ps
, sym
.symbol
);
609 write_exp_elt_opcode (ps
, OP_VAR_VALUE
);
612 msym
= lookup_bound_minimal_symbol (copy_name (str
));
615 write_exp_msymbol (ps
, msym
);
619 /* Any other names are assumed to be debugger internal variables. */
621 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
622 write_exp_elt_intern (ps
, create_internalvar (copy_name (str
) + 1));
623 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
626 write_exp_elt_opcode (ps
, OP_LAST
);
627 write_exp_elt_longcst (ps
, (LONGEST
) i
);
628 write_exp_elt_opcode (ps
, OP_LAST
);
631 write_exp_elt_opcode (ps
, OP_REGISTER
);
634 write_exp_string (ps
, str
);
635 write_exp_elt_opcode (ps
, OP_REGISTER
);
636 ps
->block_tracker
->update (ps
->expression_context_block
,
637 INNERMOST_BLOCK_FOR_REGISTERS
);
643 find_template_name_end (const char *p
)
646 int just_seen_right
= 0;
647 int just_seen_colon
= 0;
648 int just_seen_space
= 0;
650 if (!p
|| (*p
!= '<'))
661 /* In future, may want to allow these?? */
664 depth
++; /* start nested template */
665 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
666 return 0; /* but not after : or :: or > or space */
669 if (just_seen_colon
|| just_seen_right
)
670 return 0; /* end a (nested?) template */
671 just_seen_right
= 1; /* but not after : or :: */
672 if (--depth
== 0) /* also disallow >>, insist on > > */
673 return ++p
; /* if outermost ended, return */
676 if (just_seen_space
|| (just_seen_colon
> 1))
677 return 0; /* nested class spec coming up */
678 just_seen_colon
++; /* we allow :: but not :::: */
683 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
684 (*p
>= 'A' && *p
<= 'Z') ||
685 (*p
>= '0' && *p
<= '9') ||
686 (*p
== '_') || (*p
== ',') || /* commas for template args */
687 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
688 (*p
== '(') || (*p
== ')') || /* function types */
689 (*p
== '[') || (*p
== ']'))) /* array types */
703 /* Return a null-terminated temporary copy of the name of a string token.
705 Tokens that refer to names do so with explicit pointer and length,
706 so they can share the storage that lexptr is parsing.
707 When it is necessary to pass a name to a function that expects
708 a null-terminated string, the substring is copied out
709 into a separate block of storage.
711 N.B. A single buffer is reused on each call. */
714 copy_name (struct stoken token
)
716 /* A temporary buffer for identifiers, so we can null-terminate them.
717 We allocate this with xrealloc. parse_exp_1 used to allocate with
718 alloca, using the size of the whole expression as a conservative
719 estimate of the space needed. However, macro expansion can
720 introduce names longer than the original expression; there's no
721 practical way to know beforehand how large that might be. */
722 static char *namecopy
;
723 static size_t namecopy_size
;
725 /* Make sure there's enough space for the token. */
726 if (namecopy_size
< token
.length
+ 1)
728 namecopy_size
= token
.length
+ 1;
729 namecopy
= (char *) xrealloc (namecopy
, token
.length
+ 1);
732 memcpy (namecopy
, token
.ptr
, token
.length
);
733 namecopy
[token
.length
] = 0;
739 /* See comments on parser-defs.h. */
742 prefixify_expression (struct expression
*expr
, int last_struct
)
744 gdb_assert (expr
->nelts
> 0);
745 int len
= sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
746 struct expression
*temp
;
747 int inpos
= expr
->nelts
, outpos
= 0;
749 temp
= (struct expression
*) alloca (len
);
751 /* Copy the original expression into temp. */
752 memcpy (temp
, expr
, len
);
754 return prefixify_subexp (temp
, expr
, inpos
, outpos
, last_struct
);
757 /* Return the number of exp_elements in the postfix subexpression
758 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
761 length_of_subexp (struct expression
*expr
, int endpos
)
765 operator_length (expr
, endpos
, &oplen
, &args
);
769 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
776 /* Sets *OPLENP to the length of the operator whose (last) index is
777 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
781 operator_length (const struct expression
*expr
, int endpos
, int *oplenp
,
784 expr
->language_defn
->la_exp_desc
->operator_length (expr
, endpos
,
788 /* Default value for operator_length in exp_descriptor vectors. */
791 operator_length_standard (const struct expression
*expr
, int endpos
,
792 int *oplenp
, int *argsp
)
796 enum range_type range_type
;
800 error (_("?error in operator_length_standard"));
802 i
= (int) expr
->elts
[endpos
- 1].opcode
;
808 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
809 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
815 case OP_VAR_MSYM_VALUE
:
819 case OP_FUNC_STATIC_VAR
:
820 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
821 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
829 case OP_VAR_ENTRY_VALUE
:
839 case OP_F77_UNDETERMINED_ARGLIST
:
841 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
845 oplen
= 5 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
849 case OP_OBJC_MSGCALL
: /* Objective C message (method) call. */
851 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
860 case UNOP_DYNAMIC_CAST
:
861 case UNOP_REINTERPRET_CAST
:
862 case UNOP_MEMVAL_TYPE
:
891 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
892 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
897 case STRUCTOP_STRUCT
:
904 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
905 NSString constant. */
906 case OP_OBJC_SELECTOR
: /* Objective C "@selector" pseudo-op. */
908 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
909 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
914 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
915 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
925 case MULTI_SUBSCRIPT
:
927 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
930 case BINOP_ASSIGN_MODIFY
:
942 range_type
= (enum range_type
)
943 longest_to_int (expr
->elts
[endpos
- 2].longconst
);
947 case LOW_BOUND_DEFAULT
:
948 case LOW_BOUND_DEFAULT_EXCLUSIVE
:
949 case HIGH_BOUND_DEFAULT
:
952 case BOTH_BOUND_DEFAULT
:
955 case NONE_BOUND_DEFAULT
:
956 case NONE_BOUND_DEFAULT_EXCLUSIVE
:
964 args
= 1 + (i
< (int) BINOP_END
);
971 /* Copy the subexpression ending just before index INEND in INEXPR
972 into OUTEXPR, starting at index OUTBEG.
973 In the process, convert it from suffix to prefix form.
974 If LAST_STRUCT is -1, then this function always returns -1.
975 Otherwise, it returns the index of the subexpression which is the
976 left-hand-side of the expression at LAST_STRUCT. */
979 prefixify_subexp (struct expression
*inexpr
,
980 struct expression
*outexpr
, int inend
, int outbeg
,
989 operator_length (inexpr
, inend
, &oplen
, &args
);
991 /* Copy the final operator itself, from the end of the input
992 to the beginning of the output. */
994 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
995 EXP_ELEM_TO_BYTES (oplen
));
998 if (last_struct
== inend
)
999 result
= outbeg
- oplen
;
1001 /* Find the lengths of the arg subexpressions. */
1002 arglens
= (int *) alloca (args
* sizeof (int));
1003 for (i
= args
- 1; i
>= 0; i
--)
1005 oplen
= length_of_subexp (inexpr
, inend
);
1010 /* Now copy each subexpression, preserving the order of
1011 the subexpressions, but prefixifying each one.
1012 In this loop, inend starts at the beginning of
1013 the expression this level is working on
1014 and marches forward over the arguments.
1015 outbeg does similarly in the output. */
1016 for (i
= 0; i
< args
; i
++)
1022 r
= prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
, last_struct
);
1025 /* Return immediately. We probably have only parsed a
1026 partial expression, so we don't want to try to reverse
1027 the other operands. */
1036 /* Read an expression from the string *STRINGPTR points to,
1037 parse it, and return a pointer to a struct expression that we malloc.
1038 Use block BLOCK as the lexical context for variable names;
1039 if BLOCK is zero, use the block of the selected stack frame.
1040 Meanwhile, advance *STRINGPTR to point after the expression,
1041 at the first nonwhite character that is not part of the expression
1042 (possibly a null character).
1044 If COMMA is nonzero, stop if a comma is reached. */
1047 parse_exp_1 (const char **stringptr
, CORE_ADDR pc
, const struct block
*block
,
1048 int comma
, innermost_block_tracker
*tracker
)
1050 return parse_exp_in_context (stringptr
, pc
, block
, comma
, 0, NULL
,
1054 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1055 no value is expected from the expression.
1056 OUT_SUBEXP is set when attempting to complete a field name; in this
1057 case it is set to the index of the subexpression on the
1058 left-hand-side of the struct op. If not doing such completion, it
1059 is left untouched. */
1061 static expression_up
1062 parse_exp_in_context (const char **stringptr
, CORE_ADDR pc
,
1063 const struct block
*block
,
1064 int comma
, int void_context_p
, int *out_subexp
,
1065 innermost_block_tracker
*tracker
,
1066 expr_completion_state
*cstate
)
1068 const struct language_defn
*lang
= NULL
;
1071 if (*stringptr
== 0 || **stringptr
== 0)
1072 error_no_arg (_("expression to compute"));
1074 const struct block
*expression_context_block
= block
;
1075 CORE_ADDR expression_context_pc
= 0;
1077 innermost_block_tracker local_tracker
;
1078 if (tracker
== nullptr)
1079 tracker
= &local_tracker
;
1081 /* If no context specified, try using the current frame, if any. */
1082 if (!expression_context_block
)
1083 expression_context_block
= get_selected_block (&expression_context_pc
);
1085 expression_context_pc
= BLOCK_ENTRY_PC (expression_context_block
);
1087 expression_context_pc
= pc
;
1089 /* Fall back to using the current source static context, if any. */
1091 if (!expression_context_block
)
1093 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
1095 expression_context_block
1096 = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal
.symtab
),
1098 if (expression_context_block
)
1099 expression_context_pc
= BLOCK_ENTRY_PC (expression_context_block
);
1102 if (language_mode
== language_mode_auto
&& block
!= NULL
)
1104 /* Find the language associated to the given context block.
1105 Default to the current language if it can not be determined.
1107 Note that using the language corresponding to the current frame
1108 can sometimes give unexpected results. For instance, this
1109 routine is often called several times during the inferior
1110 startup phase to re-parse breakpoint expressions after
1111 a new shared library has been loaded. The language associated
1112 to the current frame at this moment is not relevant for
1113 the breakpoint. Using it would therefore be silly, so it seems
1114 better to rely on the current language rather than relying on
1115 the current frame language to parse the expression. That's why
1116 we do the following language detection only if the context block
1117 has been specifically provided. */
1118 struct symbol
*func
= block_linkage_function (block
);
1121 lang
= language_def (SYMBOL_LANGUAGE (func
));
1122 if (lang
== NULL
|| lang
->la_language
== language_unknown
)
1123 lang
= current_language
;
1126 lang
= current_language
;
1128 /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
1129 While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
1130 and others called from *.y) ensure CURRENT_LANGUAGE gets restored
1131 to the value matching SELECTED_FRAME as set by get_current_arch. */
1133 parser_state
ps (lang
, get_current_arch (), expression_context_block
,
1134 expression_context_pc
, comma
, *stringptr
,
1135 cstate
!= nullptr, tracker
);
1137 scoped_restore_current_language lang_saver
;
1138 set_language (lang
->la_language
);
1142 lang
->la_parser (&ps
);
1144 CATCH (except
, RETURN_MASK_ALL
)
1146 /* If parsing for completion, allow this to succeed; but if no
1147 expression elements have been written, then there's nothing
1149 if (! ps
.parse_completion
|| ps
.expout_ptr
== 0)
1150 throw_exception (except
);
1154 /* We have to operate on an "expression *", due to la_post_parser,
1155 which explains this funny-looking double release. */
1156 expression_up result
= ps
.release ();
1158 /* Convert expression from postfix form as generated by yacc
1159 parser, to a prefix form. */
1161 if (expressiondebug
)
1162 dump_raw_expression (result
.get (), gdb_stdlog
,
1163 "before conversion to prefix form");
1165 subexp
= prefixify_expression (result
.get (),
1166 ps
.m_completion_state
.expout_last_struct
);
1168 *out_subexp
= subexp
;
1170 lang
->la_post_parser (&result
, void_context_p
, ps
.parse_completion
,
1173 if (expressiondebug
)
1174 dump_prefix_expression (result
.get (), gdb_stdlog
);
1176 if (cstate
!= nullptr)
1177 *cstate
= std::move (ps
.m_completion_state
);
1178 *stringptr
= ps
.lexptr
;
1182 /* Parse STRING as an expression, and complain if this fails
1183 to use up all of the contents of STRING. */
1186 parse_expression (const char *string
, innermost_block_tracker
*tracker
)
1188 expression_up exp
= parse_exp_1 (&string
, 0, 0, 0, tracker
);
1190 error (_("Junk after end of expression."));
1194 /* Same as parse_expression, but using the given language (LANG)
1195 to parse the expression. */
1198 parse_expression_with_language (const char *string
, enum language lang
)
1200 gdb::optional
<scoped_restore_current_language
> lang_saver
;
1201 if (current_language
->la_language
!= lang
)
1203 lang_saver
.emplace ();
1204 set_language (lang
);
1207 return parse_expression (string
);
1210 /* Parse STRING as an expression. If parsing ends in the middle of a
1211 field reference, return the type of the left-hand-side of the
1212 reference; furthermore, if the parsing ends in the field name,
1213 return the field name in *NAME. If the parsing ends in the middle
1214 of a field reference, but the reference is somehow invalid, throw
1215 an exception. In all other cases, return NULL. */
1218 parse_expression_for_completion (const char *string
,
1219 gdb::unique_xmalloc_ptr
<char> *name
,
1220 enum type_code
*code
)
1225 expr_completion_state cstate
;
1229 exp
= parse_exp_in_context (&string
, 0, 0, 0, 0, &subexp
,
1232 CATCH (except
, RETURN_MASK_ERROR
)
1234 /* Nothing, EXP remains NULL. */
1241 if (cstate
.expout_tag_completion_type
!= TYPE_CODE_UNDEF
)
1243 *code
= cstate
.expout_tag_completion_type
;
1244 *name
= std::move (cstate
.expout_completion_name
);
1248 if (cstate
.expout_last_struct
== -1)
1251 const char *fieldname
= extract_field_op (exp
.get (), &subexp
);
1252 if (fieldname
== NULL
)
1258 name
->reset (xstrdup (fieldname
));
1259 /* This might throw an exception. If so, we want to let it
1261 val
= evaluate_subexpression_type (exp
.get (), subexp
);
1263 return value_type (val
);
1266 /* A post-parser that does nothing. */
1269 null_post_parser (expression_up
*exp
, int void_context_p
, int completin
,
1270 innermost_block_tracker
*tracker
)
1274 /* Parse floating point value P of length LEN.
1275 Return false if invalid, true if valid.
1276 The successfully parsed number is stored in DATA in
1277 target format for floating-point type TYPE.
1279 NOTE: This accepts the floating point syntax that sscanf accepts. */
1282 parse_float (const char *p
, int len
,
1283 const struct type
*type
, gdb_byte
*data
)
1285 return target_float_from_string (data
, type
, std::string (p
, len
));
1288 /* This function avoids direct calls to fprintf
1289 in the parser generated debug code. */
1291 parser_fprintf (FILE *x
, const char *y
, ...)
1297 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1300 fprintf_unfiltered (gdb_stderr
, " Unknown FILE used.\n");
1301 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1306 /* Implementation of the exp_descriptor method operator_check. */
1309 operator_check_standard (struct expression
*exp
, int pos
,
1310 int (*objfile_func
) (struct objfile
*objfile
,
1314 const union exp_element
*const elts
= exp
->elts
;
1315 struct type
*type
= NULL
;
1316 struct objfile
*objfile
= NULL
;
1318 /* Extended operators should have been already handled by exp_descriptor
1319 iterate method of its specific language. */
1320 gdb_assert (elts
[pos
].opcode
< OP_EXTENDED0
);
1322 /* Track the callers of write_exp_elt_type for this table. */
1324 switch (elts
[pos
].opcode
)
1336 type
= elts
[pos
+ 1].type
;
1341 LONGEST arg
, nargs
= elts
[pos
+ 2].longconst
;
1343 for (arg
= 0; arg
< nargs
; arg
++)
1345 struct type
*inst_type
= elts
[pos
+ 3 + arg
].type
;
1346 struct objfile
*inst_objfile
= TYPE_OBJFILE (inst_type
);
1348 if (inst_objfile
&& (*objfile_func
) (inst_objfile
, data
))
1356 const struct block
*const block
= elts
[pos
+ 1].block
;
1357 const struct symbol
*const symbol
= elts
[pos
+ 2].symbol
;
1359 /* Check objfile where the variable itself is placed.
1360 SYMBOL_OBJ_SECTION (symbol) may be NULL. */
1361 if ((*objfile_func
) (symbol_objfile (symbol
), data
))
1364 /* Check objfile where is placed the code touching the variable. */
1365 objfile
= lookup_objfile_from_block (block
);
1367 type
= SYMBOL_TYPE (symbol
);
1370 case OP_VAR_MSYM_VALUE
:
1371 objfile
= elts
[pos
+ 1].objfile
;
1375 /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
1377 if (type
&& TYPE_OBJFILE (type
)
1378 && (*objfile_func
) (TYPE_OBJFILE (type
), data
))
1380 if (objfile
&& (*objfile_func
) (objfile
, data
))
1386 /* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1387 OBJFILE_FUNC is never called with NULL OBJFILE. OBJFILE_FUNC get
1388 passed an arbitrary caller supplied DATA pointer. If OBJFILE_FUNC
1389 returns non-zero value then (any other) non-zero value is immediately
1390 returned to the caller. Otherwise zero is returned after iterating
1391 through whole EXP. */
1394 exp_iterate (struct expression
*exp
,
1395 int (*objfile_func
) (struct objfile
*objfile
, void *data
),
1400 for (endpos
= exp
->nelts
; endpos
> 0; )
1402 int pos
, args
, oplen
= 0;
1404 operator_length (exp
, endpos
, &oplen
, &args
);
1405 gdb_assert (oplen
> 0);
1407 pos
= endpos
- oplen
;
1408 if (exp
->language_defn
->la_exp_desc
->operator_check (exp
, pos
,
1409 objfile_func
, data
))
1418 /* Helper for exp_uses_objfile. */
1421 exp_uses_objfile_iter (struct objfile
*exp_objfile
, void *objfile_voidp
)
1423 struct objfile
*objfile
= (struct objfile
*) objfile_voidp
;
1425 if (exp_objfile
->separate_debug_objfile_backlink
)
1426 exp_objfile
= exp_objfile
->separate_debug_objfile_backlink
;
1428 return exp_objfile
== objfile
;
1431 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1432 is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
1436 exp_uses_objfile (struct expression
*exp
, struct objfile
*objfile
)
1438 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
1440 return exp_iterate (exp
, exp_uses_objfile_iter
, objfile
);
1443 /* Reallocate the `expout' pointer inside PS so that it can accommodate
1444 at least LENELT expression elements. This function does nothing if
1445 there is enough room for the elements. */
1448 increase_expout_size (struct expr_builder
*ps
, size_t lenelt
)
1450 if ((ps
->expout_ptr
+ lenelt
) >= ps
->expout_size
)
1452 ps
->expout_size
= std::max (ps
->expout_size
* 2,
1453 ps
->expout_ptr
+ lenelt
+ 10);
1454 ps
->expout
.reset (XRESIZEVAR (expression
,
1455 ps
->expout
.release (),
1456 (sizeof (struct expression
)
1457 + EXP_ELEM_TO_BYTES (ps
->expout_size
))));
1462 _initialize_parse (void)
1464 add_setshow_zuinteger_cmd ("expression", class_maintenance
,
1466 _("Set expression debugging."),
1467 _("Show expression debugging."),
1468 _("When non-zero, the internal representation "
1469 "of expressions will be printed."),
1471 show_expressiondebug
,
1472 &setdebuglist
, &showdebuglist
);
1473 add_setshow_boolean_cmd ("parser", class_maintenance
,
1475 _("Set parser debugging."),
1476 _("Show parser debugging."),
1477 _("When non-zero, expression parser "
1478 "tracing will be enabled."),
1481 &setdebuglist
, &showdebuglist
);