1 /* Parse expressions for GDB.
3 Copyright (C) 1986-2021 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 /* 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
,
63 dump_subexp_body_standard
,
64 evaluate_subexp_standard
67 static unsigned int expressiondebug
= 0;
69 show_expressiondebug (struct ui_file
*file
, int from_tty
,
70 struct cmd_list_element
*c
, const char *value
)
72 fprintf_filtered (file
, _("Expression debugging is %s.\n"), value
);
76 /* True if an expression parser should set yydebug. */
80 show_parserdebug (struct ui_file
*file
, int from_tty
,
81 struct cmd_list_element
*c
, const char *value
)
83 fprintf_filtered (file
, _("Parser debugging is %s.\n"), value
);
87 static int prefixify_subexp (struct expression
*, struct expression
*, int,
90 static expression_up
parse_exp_in_context (const char **, CORE_ADDR
,
91 const struct block
*, int,
93 innermost_block_tracker
*,
94 expr_completion_state
*);
96 static void increase_expout_size (struct expr_builder
*ps
, size_t lenelt
);
99 /* Documented at it's declaration. */
102 innermost_block_tracker::update (const struct block
*b
,
103 innermost_block_tracker_types t
)
105 if ((m_types
& t
) != 0
106 && (m_innermost_block
== NULL
107 || contained_in (b
, m_innermost_block
)))
108 m_innermost_block
= b
;
113 /* See definition in parser-defs.h. */
115 expr_builder::expr_builder (const struct language_defn
*lang
,
116 struct gdbarch
*gdbarch
)
118 expout (new expression (lang
, gdbarch
, expout_size
)),
124 expr_builder::release ()
126 /* Record the actual number of expression elements, and then
127 reallocate the expression memory so that we free up any
130 expout
->nelts
= expout_ptr
;
131 expout
->resize (expout_ptr
);
133 return std::move (expout
);
136 expression::expression (const struct language_defn
*lang
, struct gdbarch
*arch
,
138 : language_defn (lang
),
145 expression::~expression ()
151 expression::resize (size_t n
)
153 elts
= XRESIZEVAR (union exp_element
, elts
, EXP_ELEM_TO_BYTES (n
));
156 /* This page contains the functions for adding data to the struct expression
157 being constructed. */
159 /* Add one element to the end of the expression. */
161 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
162 a register through here. */
165 write_exp_elt (struct expr_builder
*ps
, const union exp_element
*expelt
)
167 if (ps
->expout_ptr
>= ps
->expout_size
)
169 ps
->expout_size
*= 2;
170 ps
->expout
->resize (ps
->expout_size
);
172 ps
->expout
->elts
[ps
->expout_ptr
++] = *expelt
;
176 write_exp_elt_opcode (struct expr_builder
*ps
, enum exp_opcode expelt
)
178 union exp_element tmp
;
180 memset (&tmp
, 0, sizeof (union exp_element
));
182 write_exp_elt (ps
, &tmp
);
186 write_exp_elt_sym (struct expr_builder
*ps
, struct symbol
*expelt
)
188 union exp_element tmp
;
190 memset (&tmp
, 0, sizeof (union exp_element
));
192 write_exp_elt (ps
, &tmp
);
196 write_exp_elt_msym (struct expr_builder
*ps
, minimal_symbol
*expelt
)
198 union exp_element tmp
;
200 memset (&tmp
, 0, sizeof (union exp_element
));
201 tmp
.msymbol
= expelt
;
202 write_exp_elt (ps
, &tmp
);
206 write_exp_elt_block (struct expr_builder
*ps
, const struct block
*b
)
208 union exp_element tmp
;
210 memset (&tmp
, 0, sizeof (union exp_element
));
212 write_exp_elt (ps
, &tmp
);
216 write_exp_elt_objfile (struct expr_builder
*ps
, struct objfile
*objfile
)
218 union exp_element tmp
;
220 memset (&tmp
, 0, sizeof (union exp_element
));
221 tmp
.objfile
= objfile
;
222 write_exp_elt (ps
, &tmp
);
226 write_exp_elt_longcst (struct expr_builder
*ps
, LONGEST expelt
)
228 union exp_element tmp
;
230 memset (&tmp
, 0, sizeof (union exp_element
));
231 tmp
.longconst
= expelt
;
232 write_exp_elt (ps
, &tmp
);
236 write_exp_elt_floatcst (struct expr_builder
*ps
, const gdb_byte expelt
[16])
238 union exp_element tmp
;
241 for (index
= 0; index
< 16; index
++)
242 tmp
.floatconst
[index
] = expelt
[index
];
244 write_exp_elt (ps
, &tmp
);
248 write_exp_elt_type (struct expr_builder
*ps
, struct type
*expelt
)
250 union exp_element tmp
;
252 memset (&tmp
, 0, sizeof (union exp_element
));
254 write_exp_elt (ps
, &tmp
);
258 write_exp_elt_intern (struct expr_builder
*ps
, struct internalvar
*expelt
)
260 union exp_element tmp
;
262 memset (&tmp
, 0, sizeof (union exp_element
));
263 tmp
.internalvar
= expelt
;
264 write_exp_elt (ps
, &tmp
);
267 /* Add a string constant to the end of the expression.
269 String constants are stored by first writing an expression element
270 that contains the length of the string, then stuffing the string
271 constant itself into however many expression elements are needed
272 to hold it, and then writing another expression element that contains
273 the length of the string. I.e. an expression element at each end of
274 the string records the string length, so you can skip over the
275 expression elements containing the actual string bytes from either
276 end of the string. Note that this also allows gdb to handle
277 strings with embedded null bytes, as is required for some languages.
279 Don't be fooled by the fact that the string is null byte terminated,
280 this is strictly for the convenience of debugging gdb itself.
281 Gdb does not depend up the string being null terminated, since the
282 actual length is recorded in expression elements at each end of the
283 string. The null byte is taken into consideration when computing how
284 many expression elements are required to hold the string constant, of
289 write_exp_string (struct expr_builder
*ps
, struct stoken str
)
291 int len
= str
.length
;
295 /* Compute the number of expression elements required to hold the string
296 (including a null byte terminator), along with one expression element
297 at each end to record the actual string length (not including the
298 null byte terminator). */
300 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
302 increase_expout_size (ps
, lenelt
);
304 /* Write the leading length expression element (which advances the current
305 expression element index), then write the string constant followed by a
306 terminating null byte, and then write the trailing length expression
309 write_exp_elt_longcst (ps
, (LONGEST
) len
);
310 strdata
= (char *) &ps
->expout
->elts
[ps
->expout_ptr
];
311 memcpy (strdata
, str
.ptr
, len
);
312 *(strdata
+ len
) = '\0';
313 ps
->expout_ptr
+= lenelt
- 2;
314 write_exp_elt_longcst (ps
, (LONGEST
) len
);
317 /* Add a vector of string constants to the end of the expression.
319 This adds an OP_STRING operation, but encodes the contents
320 differently from write_exp_string. The language is expected to
321 handle evaluation of this expression itself.
323 After the usual OP_STRING header, TYPE is written into the
324 expression as a long constant. The interpretation of this field is
325 up to the language evaluator.
327 Next, each string in VEC is written. The length is written as a
328 long constant, followed by the contents of the string. */
331 write_exp_string_vector (struct expr_builder
*ps
, int type
,
332 struct stoken_vector
*vec
)
337 /* Compute the size. We compute the size in number of slots to
338 avoid issues with string padding. */
340 for (i
= 0; i
< vec
->len
; ++i
)
342 /* One slot for the length of this element, plus the number of
343 slots needed for this string. */
344 n_slots
+= 1 + BYTES_TO_EXP_ELEM (vec
->tokens
[i
].length
);
347 /* One more slot for the type of the string. */
350 /* Now compute a phony string length. */
351 len
= EXP_ELEM_TO_BYTES (n_slots
) - 1;
354 increase_expout_size (ps
, n_slots
);
356 write_exp_elt_opcode (ps
, OP_STRING
);
357 write_exp_elt_longcst (ps
, len
);
358 write_exp_elt_longcst (ps
, type
);
360 for (i
= 0; i
< vec
->len
; ++i
)
362 write_exp_elt_longcst (ps
, vec
->tokens
[i
].length
);
363 memcpy (&ps
->expout
->elts
[ps
->expout_ptr
], vec
->tokens
[i
].ptr
,
364 vec
->tokens
[i
].length
);
365 ps
->expout_ptr
+= BYTES_TO_EXP_ELEM (vec
->tokens
[i
].length
);
368 write_exp_elt_longcst (ps
, len
);
369 write_exp_elt_opcode (ps
, OP_STRING
);
372 /* Add a bitstring constant to the end of the expression.
374 Bitstring constants are stored by first writing an expression element
375 that contains the length of the bitstring (in bits), then stuffing the
376 bitstring constant itself into however many expression elements are
377 needed to hold it, and then writing another expression element that
378 contains the length of the bitstring. I.e. an expression element at
379 each end of the bitstring records the bitstring length, so you can skip
380 over the expression elements containing the actual bitstring bytes from
381 either end of the bitstring. */
384 write_exp_bitstring (struct expr_builder
*ps
, struct stoken str
)
386 int bits
= str
.length
; /* length in bits */
387 int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
391 /* Compute the number of expression elements required to hold the bitstring,
392 along with one expression element at each end to record the actual
393 bitstring length in bits. */
395 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
397 increase_expout_size (ps
, lenelt
);
399 /* Write the leading length expression element (which advances the current
400 expression element index), then write the bitstring constant, and then
401 write the trailing length expression element. */
403 write_exp_elt_longcst (ps
, (LONGEST
) bits
);
404 strdata
= (char *) &ps
->expout
->elts
[ps
->expout_ptr
];
405 memcpy (strdata
, str
.ptr
, len
);
406 ps
->expout_ptr
+= lenelt
- 2;
407 write_exp_elt_longcst (ps
, (LONGEST
) bits
);
410 /* Return the type of MSYMBOL, a minimal symbol of OBJFILE. If
411 ADDRESS_P is not NULL, set it to the MSYMBOL's resolved
415 find_minsym_type_and_address (minimal_symbol
*msymbol
,
416 struct objfile
*objfile
,
417 CORE_ADDR
*address_p
)
419 bound_minimal_symbol bound_msym
= {msymbol
, objfile
};
420 struct obj_section
*section
= msymbol
->obj_section (objfile
);
421 enum minimal_symbol_type type
= MSYMBOL_TYPE (msymbol
);
423 bool is_tls
= (section
!= NULL
424 && section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
);
426 /* The minimal symbol might point to a function descriptor;
427 resolve it to the actual code address instead. */
431 /* Addresses of TLS symbols are really offsets into a
432 per-objfile/per-thread storage block. */
433 addr
= MSYMBOL_VALUE_RAW_ADDRESS (bound_msym
.minsym
);
435 else if (msymbol_is_function (objfile
, msymbol
, &addr
))
437 if (addr
!= BMSYMBOL_VALUE_ADDRESS (bound_msym
))
439 /* This means we resolved a function descriptor, and we now
440 have an address for a code/text symbol instead of a data
442 if (MSYMBOL_TYPE (msymbol
) == mst_data_gnu_ifunc
)
443 type
= mst_text_gnu_ifunc
;
450 addr
= BMSYMBOL_VALUE_ADDRESS (bound_msym
);
452 if (overlay_debugging
)
453 addr
= symbol_overlayed_address (addr
, section
);
457 /* Skip translation if caller does not need the address. */
458 if (address_p
!= NULL
)
459 *address_p
= target_translate_tls_address (objfile
, addr
);
460 return objfile_type (objfile
)->nodebug_tls_symbol
;
463 if (address_p
!= NULL
)
470 case mst_solib_trampoline
:
471 return objfile_type (objfile
)->nodebug_text_symbol
;
473 case mst_text_gnu_ifunc
:
474 return objfile_type (objfile
)->nodebug_text_gnu_ifunc_symbol
;
480 return objfile_type (objfile
)->nodebug_data_symbol
;
482 case mst_slot_got_plt
:
483 return objfile_type (objfile
)->nodebug_got_plt_symbol
;
486 return objfile_type (objfile
)->nodebug_unknown_symbol
;
490 /* Add the appropriate elements for a minimal symbol to the end of
494 write_exp_msymbol (struct expr_builder
*ps
,
495 struct bound_minimal_symbol bound_msym
)
497 write_exp_elt_opcode (ps
, OP_VAR_MSYM_VALUE
);
498 write_exp_elt_objfile (ps
, bound_msym
.objfile
);
499 write_exp_elt_msym (ps
, bound_msym
.minsym
);
500 write_exp_elt_opcode (ps
, OP_VAR_MSYM_VALUE
);
503 /* See parser-defs.h. */
506 parser_state::mark_struct_expression ()
508 gdb_assert (parse_completion
509 && (m_completion_state
.expout_tag_completion_type
511 && m_completion_state
.expout_last_op
== nullptr);
512 m_completion_state
.expout_last_struct
= expout_ptr
;
515 /* See parser-defs.h. */
518 parser_state::mark_struct_expression (expr::structop_base_operation
*op
)
520 gdb_assert (parse_completion
521 && (m_completion_state
.expout_tag_completion_type
523 && m_completion_state
.expout_last_struct
== -1);
524 m_completion_state
.expout_last_op
= op
;
527 /* Indicate that the current parser invocation is completing a tag.
528 TAG is the type code of the tag, and PTR and LENGTH represent the
529 start of the tag name. */
532 parser_state::mark_completion_tag (enum type_code tag
, const char *ptr
,
535 gdb_assert (parse_completion
536 && (m_completion_state
.expout_tag_completion_type
538 && m_completion_state
.expout_completion_name
== NULL
539 && m_completion_state
.expout_last_struct
== -1
540 && m_completion_state
.expout_last_op
== nullptr);
541 gdb_assert (tag
== TYPE_CODE_UNION
542 || tag
== TYPE_CODE_STRUCT
543 || tag
== TYPE_CODE_ENUM
);
544 m_completion_state
.expout_tag_completion_type
= tag
;
545 m_completion_state
.expout_completion_name
.reset (xstrndup (ptr
, length
));
549 /* Recognize tokens that start with '$'. These include:
551 $regname A native register name or a "standard
554 $variable A convenience variable with a name chosen
557 $digits Value history with index <digits>, starting
558 from the first value which has index 1.
560 $$digits Value history with index <digits> relative
561 to the last value. I.e. $$0 is the last
562 value, $$1 is the one previous to that, $$2
563 is the one previous to $$1, etc.
565 $ | $0 | $$0 The last value in the value history.
567 $$ An abbreviation for the second to the last
568 value in the value history, I.e. $$1 */
571 write_dollar_variable (struct parser_state
*ps
, struct stoken str
)
573 struct block_symbol sym
;
574 struct bound_minimal_symbol msym
;
575 struct internalvar
*isym
= NULL
;
578 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
579 and $$digits (equivalent to $<-digits> if you could type that). */
583 /* Double dollar means negate the number and add -1 as well.
584 Thus $$ alone means -1. */
585 if (str
.length
>= 2 && str
.ptr
[1] == '$')
592 /* Just dollars (one or two). */
596 /* Is the rest of the token digits? */
597 for (; i
< str
.length
; i
++)
598 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
602 i
= atoi (str
.ptr
+ 1 + negate
);
608 /* Handle tokens that refer to machine registers:
609 $ followed by a register name. */
610 i
= user_reg_map_name_to_regnum (ps
->gdbarch (),
611 str
.ptr
+ 1, str
.length
- 1);
613 goto handle_register
;
615 /* Any names starting with $ are probably debugger internal variables. */
617 copy
= copy_name (str
);
618 isym
= lookup_only_internalvar (copy
.c_str () + 1);
621 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
622 write_exp_elt_intern (ps
, isym
);
623 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
627 /* On some systems, such as HP-UX and hppa-linux, certain system routines
628 have names beginning with $ or $$. Check for those, first. */
630 sym
= lookup_symbol (copy
.c_str (), NULL
, VAR_DOMAIN
, NULL
);
633 write_exp_elt_opcode (ps
, OP_VAR_VALUE
);
634 write_exp_elt_block (ps
, sym
.block
);
635 write_exp_elt_sym (ps
, sym
.symbol
);
636 write_exp_elt_opcode (ps
, OP_VAR_VALUE
);
639 msym
= lookup_bound_minimal_symbol (copy
.c_str ());
642 write_exp_msymbol (ps
, msym
);
646 /* Any other names are assumed to be debugger internal variables. */
648 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
649 write_exp_elt_intern (ps
, create_internalvar (copy
.c_str () + 1));
650 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
653 write_exp_elt_opcode (ps
, OP_LAST
);
654 write_exp_elt_longcst (ps
, (LONGEST
) i
);
655 write_exp_elt_opcode (ps
, OP_LAST
);
658 write_exp_elt_opcode (ps
, OP_REGISTER
);
661 write_exp_string (ps
, str
);
662 write_exp_elt_opcode (ps
, OP_REGISTER
);
663 ps
->block_tracker
->update (ps
->expression_context_block
,
664 INNERMOST_BLOCK_FOR_REGISTERS
);
668 /* See parser-defs.h. */
671 write_exp_symbol_reference (struct parser_state
*pstate
, const char *name
,
672 struct block_symbol sym
)
674 if (sym
.symbol
!= nullptr)
676 if (symbol_read_needs_frame (sym
.symbol
))
677 pstate
->block_tracker
->update (sym
);
678 write_exp_elt_opcode (pstate
, OP_VAR_VALUE
);
679 write_exp_elt_block (pstate
, sym
.block
);
680 write_exp_elt_sym (pstate
, sym
.symbol
);
681 write_exp_elt_opcode (pstate
, OP_VAR_VALUE
);
685 struct bound_minimal_symbol msymbol
= lookup_bound_minimal_symbol (name
);
686 if (msymbol
.minsym
!= NULL
)
687 write_exp_msymbol (pstate
, msymbol
);
688 else if (!have_full_symbols () && !have_partial_symbols ())
689 error (_("No symbol table is loaded. Use the \"file\" command."));
691 error (_("No symbol \"%s\" in current context."), name
);
696 find_template_name_end (const char *p
)
699 int just_seen_right
= 0;
700 int just_seen_colon
= 0;
701 int just_seen_space
= 0;
703 if (!p
|| (*p
!= '<'))
714 /* In future, may want to allow these?? */
717 depth
++; /* start nested template */
718 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
719 return 0; /* but not after : or :: or > or space */
722 if (just_seen_colon
|| just_seen_right
)
723 return 0; /* end a (nested?) template */
724 just_seen_right
= 1; /* but not after : or :: */
725 if (--depth
== 0) /* also disallow >>, insist on > > */
726 return ++p
; /* if outermost ended, return */
729 if (just_seen_space
|| (just_seen_colon
> 1))
730 return 0; /* nested class spec coming up */
731 just_seen_colon
++; /* we allow :: but not :::: */
736 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
737 (*p
>= 'A' && *p
<= 'Z') ||
738 (*p
>= '0' && *p
<= '9') ||
739 (*p
== '_') || (*p
== ',') || /* commas for template args */
740 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
741 (*p
== '(') || (*p
== ')') || /* function types */
742 (*p
== '[') || (*p
== ']'))) /* array types */
756 /* Return a null-terminated temporary copy of the name of a string token.
758 Tokens that refer to names do so with explicit pointer and length,
759 so they can share the storage that lexptr is parsing.
760 When it is necessary to pass a name to a function that expects
761 a null-terminated string, the substring is copied out
762 into a separate block of storage. */
765 copy_name (struct stoken token
)
767 return std::string (token
.ptr
, token
.length
);
771 /* See comments on parser-defs.h. */
774 prefixify_expression (struct expression
*expr
, int last_struct
)
776 gdb_assert (expr
->nelts
> 0);
777 int len
= EXP_ELEM_TO_BYTES (expr
->nelts
);
778 struct expression
temp (expr
->language_defn
, expr
->gdbarch
, expr
->nelts
);
779 int inpos
= expr
->nelts
, outpos
= 0;
781 /* Copy the original expression into temp. */
782 memcpy (temp
.elts
, expr
->elts
, len
);
784 return prefixify_subexp (&temp
, expr
, inpos
, outpos
, last_struct
);
787 /* Return the number of exp_elements in the postfix subexpression
788 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
791 length_of_subexp (struct expression
*expr
, int endpos
)
795 operator_length (expr
, endpos
, &oplen
, &args
);
799 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
806 /* Sets *OPLENP to the length of the operator whose (last) index is
807 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
811 operator_length (const struct expression
*expr
, int endpos
, int *oplenp
,
814 expr
->language_defn
->expression_ops ()->operator_length (expr
, endpos
,
818 /* Default value for operator_length in exp_descriptor vectors. */
821 operator_length_standard (const struct expression
*expr
, int endpos
,
822 int *oplenp
, int *argsp
)
826 enum range_flag range_flag
;
830 error (_("?error in operator_length_standard"));
832 i
= (int) expr
->elts
[endpos
- 1].opcode
;
838 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
839 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
845 case OP_VAR_MSYM_VALUE
:
849 case OP_FUNC_STATIC_VAR
:
850 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
851 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
859 case OP_VAR_ENTRY_VALUE
:
870 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
874 oplen
= 5 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
878 case OP_OBJC_MSGCALL
: /* Objective C message (method) call. */
880 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
889 case UNOP_DYNAMIC_CAST
:
890 case UNOP_REINTERPRET_CAST
:
891 case UNOP_MEMVAL_TYPE
:
919 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
920 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
925 case STRUCTOP_STRUCT
:
932 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
933 NSString constant. */
934 case OP_OBJC_SELECTOR
: /* Objective C "@selector" pseudo-op. */
936 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
937 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
942 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
943 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
953 case MULTI_SUBSCRIPT
:
955 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
958 case BINOP_ASSIGN_MODIFY
:
970 range_flag
= (enum range_flag
)
971 longest_to_int (expr
->elts
[endpos
- 2].longconst
);
973 /* Assume the range has 2 arguments (low bound and high bound), then
974 reduce the argument count if any bounds are set to default. */
976 if (range_flag
& RANGE_HAS_STRIDE
)
978 if (range_flag
& RANGE_LOW_BOUND_DEFAULT
)
980 if (range_flag
& RANGE_HIGH_BOUND_DEFAULT
)
986 args
= 1 + (i
< (int) BINOP_END
);
993 /* Copy the subexpression ending just before index INEND in INEXPR
994 into OUTEXPR, starting at index OUTBEG.
995 In the process, convert it from suffix to prefix form.
996 If LAST_STRUCT is -1, then this function always returns -1.
997 Otherwise, it returns the index of the subexpression which is the
998 left-hand-side of the expression at LAST_STRUCT. */
1001 prefixify_subexp (struct expression
*inexpr
,
1002 struct expression
*outexpr
, int inend
, int outbeg
,
1011 operator_length (inexpr
, inend
, &oplen
, &args
);
1013 /* Copy the final operator itself, from the end of the input
1014 to the beginning of the output. */
1016 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
1017 EXP_ELEM_TO_BYTES (oplen
));
1020 if (last_struct
== inend
)
1021 result
= outbeg
- oplen
;
1023 /* Find the lengths of the arg subexpressions. */
1024 arglens
= (int *) alloca (args
* sizeof (int));
1025 for (i
= args
- 1; i
>= 0; i
--)
1027 oplen
= length_of_subexp (inexpr
, inend
);
1032 /* Now copy each subexpression, preserving the order of
1033 the subexpressions, but prefixifying each one.
1034 In this loop, inend starts at the beginning of
1035 the expression this level is working on
1036 and marches forward over the arguments.
1037 outbeg does similarly in the output. */
1038 for (i
= 0; i
< args
; i
++)
1044 r
= prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
, last_struct
);
1047 /* Return immediately. We probably have only parsed a
1048 partial expression, so we don't want to try to reverse
1049 the other operands. */
1058 /* Read an expression from the string *STRINGPTR points to,
1059 parse it, and return a pointer to a struct expression that we malloc.
1060 Use block BLOCK as the lexical context for variable names;
1061 if BLOCK is zero, use the block of the selected stack frame.
1062 Meanwhile, advance *STRINGPTR to point after the expression,
1063 at the first nonwhite character that is not part of the expression
1064 (possibly a null character).
1066 If COMMA is nonzero, stop if a comma is reached. */
1069 parse_exp_1 (const char **stringptr
, CORE_ADDR pc
, const struct block
*block
,
1070 int comma
, innermost_block_tracker
*tracker
)
1072 return parse_exp_in_context (stringptr
, pc
, block
, comma
, false, NULL
,
1076 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1077 no value is expected from the expression.
1078 OUT_SUBEXP is set when attempting to complete a field name; in this
1079 case it is set to the index of the subexpression on the
1080 left-hand-side of the struct op. If not doing such completion, it
1081 is left untouched. */
1083 static expression_up
1084 parse_exp_in_context (const char **stringptr
, CORE_ADDR pc
,
1085 const struct block
*block
,
1086 int comma
, bool void_context_p
, int *out_subexp
,
1087 innermost_block_tracker
*tracker
,
1088 expr_completion_state
*cstate
)
1090 const struct language_defn
*lang
= NULL
;
1092 if (*stringptr
== 0 || **stringptr
== 0)
1093 error_no_arg (_("expression to compute"));
1095 const struct block
*expression_context_block
= block
;
1096 CORE_ADDR expression_context_pc
= 0;
1098 innermost_block_tracker local_tracker
;
1099 if (tracker
== nullptr)
1100 tracker
= &local_tracker
;
1102 /* If no context specified, try using the current frame, if any. */
1103 if (!expression_context_block
)
1104 expression_context_block
= get_selected_block (&expression_context_pc
);
1106 expression_context_pc
= BLOCK_ENTRY_PC (expression_context_block
);
1108 expression_context_pc
= pc
;
1110 /* Fall back to using the current source static context, if any. */
1112 if (!expression_context_block
)
1114 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
1116 expression_context_block
1117 = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal
.symtab
),
1119 if (expression_context_block
)
1120 expression_context_pc
= BLOCK_ENTRY_PC (expression_context_block
);
1123 if (language_mode
== language_mode_auto
&& block
!= NULL
)
1125 /* Find the language associated to the given context block.
1126 Default to the current language if it can not be determined.
1128 Note that using the language corresponding to the current frame
1129 can sometimes give unexpected results. For instance, this
1130 routine is often called several times during the inferior
1131 startup phase to re-parse breakpoint expressions after
1132 a new shared library has been loaded. The language associated
1133 to the current frame at this moment is not relevant for
1134 the breakpoint. Using it would therefore be silly, so it seems
1135 better to rely on the current language rather than relying on
1136 the current frame language to parse the expression. That's why
1137 we do the following language detection only if the context block
1138 has been specifically provided. */
1139 struct symbol
*func
= block_linkage_function (block
);
1142 lang
= language_def (func
->language ());
1143 if (lang
== NULL
|| lang
->la_language
== language_unknown
)
1144 lang
= current_language
;
1147 lang
= current_language
;
1149 /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
1150 While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
1151 and others called from *.y) ensure CURRENT_LANGUAGE gets restored
1152 to the value matching SELECTED_FRAME as set by get_current_arch. */
1154 parser_state
ps (lang
, get_current_arch (), expression_context_block
,
1155 expression_context_pc
, comma
, *stringptr
,
1156 cstate
!= nullptr, tracker
, void_context_p
);
1158 scoped_restore_current_language lang_saver
;
1159 set_language (lang
->la_language
);
1165 catch (const gdb_exception
&except
)
1167 /* If parsing for completion, allow this to succeed; but if no
1168 expression elements have been written, then there's nothing
1170 if (! ps
.parse_completion
1171 || (ps
.expout
->op
== nullptr && ps
.expout_ptr
== 0))
1175 /* We have to operate on an "expression *", due to la_post_parser,
1176 which explains this funny-looking double release. */
1177 expression_up result
= ps
.release ();
1179 /* Convert expression from postfix form as generated by yacc
1180 parser, to a prefix form. */
1182 if (expressiondebug
)
1183 dump_raw_expression (result
.get (), gdb_stdlog
,
1184 "before conversion to prefix form");
1186 if (result
->op
== nullptr)
1188 int subexp
= prefixify_expression (result
.get (),
1189 ps
.m_completion_state
.expout_last_struct
);
1191 *out_subexp
= subexp
;
1193 lang
->post_parser (&result
, &ps
);
1196 result
->op
->set_outermost ();
1198 if (expressiondebug
)
1199 dump_prefix_expression (result
.get (), gdb_stdlog
);
1201 if (cstate
!= nullptr)
1202 *cstate
= std::move (ps
.m_completion_state
);
1203 *stringptr
= ps
.lexptr
;
1207 /* Parse STRING as an expression, and complain if this fails to use up
1208 all of the contents of STRING. TRACKER, if non-null, will be
1209 updated by the parser. VOID_CONTEXT_P should be true to indicate
1210 that the expression may be expected to return a value with void
1211 type. Parsers are free to ignore this, or to use it to help with
1212 overload resolution decisions. */
1215 parse_expression (const char *string
, innermost_block_tracker
*tracker
,
1216 bool void_context_p
)
1218 expression_up exp
= parse_exp_in_context (&string
, 0, nullptr, 0,
1219 void_context_p
, nullptr,
1222 error (_("Junk after end of expression."));
1226 /* Same as parse_expression, but using the given language (LANG)
1227 to parse the expression. */
1230 parse_expression_with_language (const char *string
, enum language lang
)
1232 gdb::optional
<scoped_restore_current_language
> lang_saver
;
1233 if (current_language
->la_language
!= lang
)
1235 lang_saver
.emplace ();
1236 set_language (lang
);
1239 return parse_expression (string
);
1242 /* Parse STRING as an expression. If parsing ends in the middle of a
1243 field reference, return the type of the left-hand-side of the
1244 reference; furthermore, if the parsing ends in the field name,
1245 return the field name in *NAME. If the parsing ends in the middle
1246 of a field reference, but the reference is somehow invalid, throw
1247 an exception. In all other cases, return NULL. */
1250 parse_expression_for_completion (const char *string
,
1251 gdb::unique_xmalloc_ptr
<char> *name
,
1252 enum type_code
*code
)
1257 expr_completion_state cstate
;
1261 exp
= parse_exp_in_context (&string
, 0, 0, 0, false, &subexp
,
1264 catch (const gdb_exception_error
&except
)
1266 /* Nothing, EXP remains NULL. */
1272 if (cstate
.expout_tag_completion_type
!= TYPE_CODE_UNDEF
)
1274 *code
= cstate
.expout_tag_completion_type
;
1275 *name
= std::move (cstate
.expout_completion_name
);
1279 if (cstate
.expout_last_op
!= nullptr)
1281 expr::structop_base_operation
*op
= cstate
.expout_last_op
;
1282 const std::string
&fld
= op
->get_string ();
1283 *name
= make_unique_xstrdup (fld
.c_str ());
1284 return value_type (op
->evaluate_lhs (exp
.get ()));
1287 if (cstate
.expout_last_struct
== -1)
1290 const char *fieldname
= extract_field_op (exp
.get (), &subexp
);
1291 if (fieldname
== NULL
)
1297 name
->reset (xstrdup (fieldname
));
1298 /* This might throw an exception. If so, we want to let it
1300 val
= evaluate_subexpression_type (exp
.get (), subexp
);
1302 return value_type (val
);
1305 /* Parse floating point value P of length LEN.
1306 Return false if invalid, true if valid.
1307 The successfully parsed number is stored in DATA in
1308 target format for floating-point type TYPE.
1310 NOTE: This accepts the floating point syntax that sscanf accepts. */
1313 parse_float (const char *p
, int len
,
1314 const struct type
*type
, gdb_byte
*data
)
1316 return target_float_from_string (data
, type
, std::string (p
, len
));
1319 /* This function avoids direct calls to fprintf
1320 in the parser generated debug code. */
1322 parser_fprintf (FILE *x
, const char *y
, ...)
1328 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1331 fprintf_unfiltered (gdb_stderr
, " Unknown FILE used.\n");
1332 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1337 /* Implementation of the exp_descriptor method operator_check. */
1340 operator_check_standard (struct expression
*exp
, int pos
,
1341 int (*objfile_func
) (struct objfile
*objfile
,
1345 const union exp_element
*const elts
= exp
->elts
;
1346 struct type
*type
= NULL
;
1347 struct objfile
*objfile
= NULL
;
1349 /* Extended operators should have been already handled by exp_descriptor
1350 iterate method of its specific language. */
1351 gdb_assert (elts
[pos
].opcode
< OP_EXTENDED0
);
1353 /* Track the callers of write_exp_elt_type for this table. */
1355 switch (elts
[pos
].opcode
)
1367 type
= elts
[pos
+ 1].type
;
1372 LONGEST arg
, nargs
= elts
[pos
+ 2].longconst
;
1374 for (arg
= 0; arg
< nargs
; arg
++)
1376 struct type
*inst_type
= elts
[pos
+ 3 + arg
].type
;
1377 struct objfile
*inst_objfile
= inst_type
->objfile_owner ();
1379 if (inst_objfile
&& (*objfile_func
) (inst_objfile
, data
))
1387 const struct block
*const block
= elts
[pos
+ 1].block
;
1388 const struct symbol
*const symbol
= elts
[pos
+ 2].symbol
;
1390 /* Check objfile where the variable itself is placed. */
1391 if ((*objfile_func
) (symbol_objfile (symbol
), data
))
1394 /* Check objfile where is placed the code touching the variable. */
1395 objfile
= block_objfile (block
);
1397 type
= SYMBOL_TYPE (symbol
);
1400 case OP_VAR_MSYM_VALUE
:
1401 objfile
= elts
[pos
+ 1].objfile
;
1405 /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
1407 if (type
!= nullptr && type
->objfile_owner () != nullptr
1408 && objfile_func (type
->objfile_owner (), data
))
1411 if (objfile
&& (*objfile_func
) (objfile
, data
))
1417 /* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1418 OBJFILE_FUNC is never called with NULL OBJFILE. OBJFILE_FUNC get
1419 passed an arbitrary caller supplied DATA pointer. If OBJFILE_FUNC
1420 returns non-zero value then (any other) non-zero value is immediately
1421 returned to the caller. Otherwise zero is returned after iterating
1422 through whole EXP. */
1425 exp_iterate (struct expression
*exp
,
1426 int (*objfile_func
) (struct objfile
*objfile
, void *data
),
1431 for (endpos
= exp
->nelts
; endpos
> 0; )
1433 int pos
, args
, oplen
= 0;
1435 operator_length (exp
, endpos
, &oplen
, &args
);
1436 gdb_assert (oplen
> 0);
1438 pos
= endpos
- oplen
;
1439 if (exp
->language_defn
->expression_ops ()->operator_check (exp
, pos
,
1450 /* Helper for exp_uses_objfile. */
1453 exp_uses_objfile_iter (struct objfile
*exp_objfile
, void *objfile_voidp
)
1455 struct objfile
*objfile
= (struct objfile
*) objfile_voidp
;
1457 if (exp_objfile
->separate_debug_objfile_backlink
)
1458 exp_objfile
= exp_objfile
->separate_debug_objfile_backlink
;
1460 return exp_objfile
== objfile
;
1463 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1464 is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
1468 exp_uses_objfile (struct expression
*exp
, struct objfile
*objfile
)
1470 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
1472 if (exp
->op
!= nullptr)
1473 return exp
->op
->uses_objfile (objfile
);
1475 return exp_iterate (exp
, exp_uses_objfile_iter
, objfile
);
1478 /* Reallocate the `expout' pointer inside PS so that it can accommodate
1479 at least LENELT expression elements. This function does nothing if
1480 there is enough room for the elements. */
1483 increase_expout_size (struct expr_builder
*ps
, size_t lenelt
)
1485 if ((ps
->expout_ptr
+ lenelt
) >= ps
->expout_size
)
1487 ps
->expout_size
= std::max (ps
->expout_size
* 2,
1488 ps
->expout_ptr
+ lenelt
+ 10);
1489 ps
->expout
->resize (ps
->expout_size
);
1493 void _initialize_parse ();
1495 _initialize_parse ()
1497 add_setshow_zuinteger_cmd ("expression", class_maintenance
,
1499 _("Set expression debugging."),
1500 _("Show expression debugging."),
1501 _("When non-zero, the internal representation "
1502 "of expressions will be printed."),
1504 show_expressiondebug
,
1505 &setdebuglist
, &showdebuglist
);
1506 add_setshow_boolean_cmd ("parser", class_maintenance
,
1508 _("Set parser debugging."),
1509 _("Show parser debugging."),
1510 _("When non-zero, expression parser "
1511 "tracing will be enabled."),
1514 &setdebuglist
, &showdebuglist
);