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 /* Global variables declared in parser-defs.h (and commented there). */
69 innermost_block_tracker innermost_block;
70 static struct type_stack type_stack;
73 static unsigned int expressiondebug = 0;
75 show_expressiondebug (struct ui_file *file, int from_tty,
76 struct cmd_list_element *c, const char *value)
78 fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
82 /* Non-zero if an expression parser should set yydebug. */
86 show_parserdebug (struct ui_file *file, int from_tty,
87 struct cmd_list_element *c, const char *value)
89 fprintf_filtered (file, _("Parser debugging is %s.\n"), value);
93 static int prefixify_subexp (struct expression *, struct expression *, int,
96 static expression_up parse_exp_in_context (const char **, CORE_ADDR,
97 const struct block *, int,
99 innermost_block_tracker_types,
100 expr_completion_state *);
102 static void increase_expout_size (struct expr_builder *ps, size_t lenelt);
105 /* Documented at it's declaration. */
108 innermost_block_tracker::update (const struct block *b,
109 innermost_block_tracker_types t)
111 if ((m_types & t) != 0
112 && (m_innermost_block == NULL
113 || contained_in (b, m_innermost_block)))
114 m_innermost_block = b;
119 /* See definition in parser-defs.h. */
121 expr_builder::expr_builder (const struct language_defn *lang,
122 struct gdbarch *gdbarch)
124 expout (XNEWVAR (expression,
126 + EXP_ELEM_TO_BYTES (expout_size)))),
129 expout->language_defn = lang;
130 expout->gdbarch = gdbarch;
134 expr_builder::release ()
136 /* Record the actual number of expression elements, and then
137 reallocate the expression memory so that we free up any
140 expout->nelts = expout_ptr;
141 expout.reset (XRESIZEVAR (expression, expout.release (),
143 + EXP_ELEM_TO_BYTES (expout_ptr))));
145 return std::move (expout);
148 /* This page contains the functions for adding data to the struct expression
149 being constructed. */
151 /* Add one element to the end of the expression. */
153 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
154 a register through here. */
157 write_exp_elt (struct expr_builder *ps, const union exp_element *expelt)
159 if (ps->expout_ptr >= ps->expout_size)
161 ps->expout_size *= 2;
162 ps->expout.reset (XRESIZEVAR (expression, ps->expout.release (),
164 + EXP_ELEM_TO_BYTES (ps->expout_size))));
166 ps->expout->elts[ps->expout_ptr++] = *expelt;
170 write_exp_elt_opcode (struct expr_builder *ps, enum exp_opcode expelt)
172 union exp_element tmp;
174 memset (&tmp, 0, sizeof (union exp_element));
176 write_exp_elt (ps, &tmp);
180 write_exp_elt_sym (struct expr_builder *ps, struct symbol *expelt)
182 union exp_element tmp;
184 memset (&tmp, 0, sizeof (union exp_element));
186 write_exp_elt (ps, &tmp);
190 write_exp_elt_msym (struct expr_builder *ps, minimal_symbol *expelt)
192 union exp_element tmp;
194 memset (&tmp, 0, sizeof (union exp_element));
195 tmp.msymbol = expelt;
196 write_exp_elt (ps, &tmp);
200 write_exp_elt_block (struct expr_builder *ps, const struct block *b)
202 union exp_element tmp;
204 memset (&tmp, 0, sizeof (union exp_element));
206 write_exp_elt (ps, &tmp);
210 write_exp_elt_objfile (struct expr_builder *ps, struct objfile *objfile)
212 union exp_element tmp;
214 memset (&tmp, 0, sizeof (union exp_element));
215 tmp.objfile = objfile;
216 write_exp_elt (ps, &tmp);
220 write_exp_elt_longcst (struct expr_builder *ps, LONGEST expelt)
222 union exp_element tmp;
224 memset (&tmp, 0, sizeof (union exp_element));
225 tmp.longconst = expelt;
226 write_exp_elt (ps, &tmp);
230 write_exp_elt_floatcst (struct expr_builder *ps, const gdb_byte expelt[16])
232 union exp_element tmp;
235 for (index = 0; index < 16; index++)
236 tmp.floatconst[index] = expelt[index];
238 write_exp_elt (ps, &tmp);
242 write_exp_elt_type (struct expr_builder *ps, struct type *expelt)
244 union exp_element tmp;
246 memset (&tmp, 0, sizeof (union exp_element));
248 write_exp_elt (ps, &tmp);
252 write_exp_elt_intern (struct expr_builder *ps, struct internalvar *expelt)
254 union exp_element tmp;
256 memset (&tmp, 0, sizeof (union exp_element));
257 tmp.internalvar = expelt;
258 write_exp_elt (ps, &tmp);
261 /* Add a string constant to the end of the expression.
263 String constants are stored by first writing an expression element
264 that contains the length of the string, then stuffing the string
265 constant itself into however many expression elements are needed
266 to hold it, and then writing another expression element that contains
267 the length of the string. I.e. an expression element at each end of
268 the string records the string length, so you can skip over the
269 expression elements containing the actual string bytes from either
270 end of the string. Note that this also allows gdb to handle
271 strings with embedded null bytes, as is required for some languages.
273 Don't be fooled by the fact that the string is null byte terminated,
274 this is strictly for the convenience of debugging gdb itself.
275 Gdb does not depend up the string being null terminated, since the
276 actual length is recorded in expression elements at each end of the
277 string. The null byte is taken into consideration when computing how
278 many expression elements are required to hold the string constant, of
283 write_exp_string (struct expr_builder *ps, struct stoken str)
285 int len = str.length;
289 /* Compute the number of expression elements required to hold the string
290 (including a null byte terminator), along with one expression element
291 at each end to record the actual string length (not including the
292 null byte terminator). */
294 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
296 increase_expout_size (ps, lenelt);
298 /* Write the leading length expression element (which advances the current
299 expression element index), then write the string constant followed by a
300 terminating null byte, and then write the trailing length expression
303 write_exp_elt_longcst (ps, (LONGEST) len);
304 strdata = (char *) &ps->expout->elts[ps->expout_ptr];
305 memcpy (strdata, str.ptr, len);
306 *(strdata + len) = '\0';
307 ps->expout_ptr += lenelt - 2;
308 write_exp_elt_longcst (ps, (LONGEST) len);
311 /* Add a vector of string constants to the end of the expression.
313 This adds an OP_STRING operation, but encodes the contents
314 differently from write_exp_string. The language is expected to
315 handle evaluation of this expression itself.
317 After the usual OP_STRING header, TYPE is written into the
318 expression as a long constant. The interpretation of this field is
319 up to the language evaluator.
321 Next, each string in VEC is written. The length is written as a
322 long constant, followed by the contents of the string. */
325 write_exp_string_vector (struct expr_builder *ps, int type,
326 struct stoken_vector *vec)
331 /* Compute the size. We compute the size in number of slots to
332 avoid issues with string padding. */
334 for (i = 0; i < vec->len; ++i)
336 /* One slot for the length of this element, plus the number of
337 slots needed for this string. */
338 n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
341 /* One more slot for the type of the string. */
344 /* Now compute a phony string length. */
345 len = EXP_ELEM_TO_BYTES (n_slots) - 1;
348 increase_expout_size (ps, n_slots);
350 write_exp_elt_opcode (ps, OP_STRING);
351 write_exp_elt_longcst (ps, len);
352 write_exp_elt_longcst (ps, type);
354 for (i = 0; i < vec->len; ++i)
356 write_exp_elt_longcst (ps, vec->tokens[i].length);
357 memcpy (&ps->expout->elts[ps->expout_ptr], vec->tokens[i].ptr,
358 vec->tokens[i].length);
359 ps->expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
362 write_exp_elt_longcst (ps, len);
363 write_exp_elt_opcode (ps, OP_STRING);
366 /* Add a bitstring constant to the end of the expression.
368 Bitstring constants are stored by first writing an expression element
369 that contains the length of the bitstring (in bits), then stuffing the
370 bitstring constant itself into however many expression elements are
371 needed to hold it, and then writing another expression element that
372 contains the length of the bitstring. I.e. an expression element at
373 each end of the bitstring records the bitstring length, so you can skip
374 over the expression elements containing the actual bitstring bytes from
375 either end of the bitstring. */
378 write_exp_bitstring (struct expr_builder *ps, struct stoken str)
380 int bits = str.length; /* length in bits */
381 int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
385 /* Compute the number of expression elements required to hold the bitstring,
386 along with one expression element at each end to record the actual
387 bitstring length in bits. */
389 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
391 increase_expout_size (ps, lenelt);
393 /* Write the leading length expression element (which advances the current
394 expression element index), then write the bitstring constant, and then
395 write the trailing length expression element. */
397 write_exp_elt_longcst (ps, (LONGEST) bits);
398 strdata = (char *) &ps->expout->elts[ps->expout_ptr];
399 memcpy (strdata, str.ptr, len);
400 ps->expout_ptr += lenelt - 2;
401 write_exp_elt_longcst (ps, (LONGEST) bits);
404 /* Return the type of MSYMBOL, a minimal symbol of OBJFILE. If
405 ADDRESS_P is not NULL, set it to the MSYMBOL's resolved
409 find_minsym_type_and_address (minimal_symbol *msymbol,
410 struct objfile *objfile,
411 CORE_ADDR *address_p)
413 bound_minimal_symbol bound_msym = {msymbol, objfile};
414 struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
415 enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
417 bool is_tls = (section != NULL
418 && section->the_bfd_section->flags & SEC_THREAD_LOCAL);
420 /* The minimal symbol might point to a function descriptor;
421 resolve it to the actual code address instead. */
425 /* Addresses of TLS symbols are really offsets into a
426 per-objfile/per-thread storage block. */
427 addr = MSYMBOL_VALUE_RAW_ADDRESS (bound_msym.minsym);
429 else if (msymbol_is_function (objfile, msymbol, &addr))
431 if (addr != BMSYMBOL_VALUE_ADDRESS (bound_msym))
433 /* This means we resolved a function descriptor, and we now
434 have an address for a code/text symbol instead of a data
436 if (MSYMBOL_TYPE (msymbol) == mst_data_gnu_ifunc)
437 type = mst_text_gnu_ifunc;
444 addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);
446 if (overlay_debugging)
447 addr = symbol_overlayed_address (addr, section);
451 /* Skip translation if caller does not need the address. */
452 if (address_p != NULL)
453 *address_p = target_translate_tls_address (objfile, addr);
454 return objfile_type (objfile)->nodebug_tls_symbol;
457 if (address_p != NULL)
464 case mst_solib_trampoline:
465 return objfile_type (objfile)->nodebug_text_symbol;
467 case mst_text_gnu_ifunc:
468 return objfile_type (objfile)->nodebug_text_gnu_ifunc_symbol;
474 return objfile_type (objfile)->nodebug_data_symbol;
476 case mst_slot_got_plt:
477 return objfile_type (objfile)->nodebug_got_plt_symbol;
480 return objfile_type (objfile)->nodebug_unknown_symbol;
484 /* Add the appropriate elements for a minimal symbol to the end of
488 write_exp_msymbol (struct expr_builder *ps,
489 struct bound_minimal_symbol bound_msym)
491 write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
492 write_exp_elt_objfile (ps, bound_msym.objfile);
493 write_exp_elt_msym (ps, bound_msym.minsym);
494 write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
497 /* See parser-defs.h. */
500 parser_state::mark_struct_expression ()
502 gdb_assert (parse_completion
503 && (m_completion_state.expout_tag_completion_type
504 == TYPE_CODE_UNDEF));
505 m_completion_state.expout_last_struct = expout_ptr;
508 /* Indicate that the current parser invocation is completing a tag.
509 TAG is the type code of the tag, and PTR and LENGTH represent the
510 start of the tag name. */
513 parser_state::mark_completion_tag (enum type_code tag, const char *ptr,
516 gdb_assert (parse_completion
517 && (m_completion_state.expout_tag_completion_type
519 && m_completion_state.expout_completion_name == NULL
520 && m_completion_state.expout_last_struct == -1);
521 gdb_assert (tag == TYPE_CODE_UNION
522 || tag == TYPE_CODE_STRUCT
523 || tag == TYPE_CODE_ENUM);
524 m_completion_state.expout_tag_completion_type = tag;
525 m_completion_state.expout_completion_name.reset (xstrndup (ptr, length));
529 /* Recognize tokens that start with '$'. These include:
531 $regname A native register name or a "standard
534 $variable A convenience variable with a name chosen
537 $digits Value history with index <digits>, starting
538 from the first value which has index 1.
540 $$digits Value history with index <digits> relative
541 to the last value. I.e. $$0 is the last
542 value, $$1 is the one previous to that, $$2
543 is the one previous to $$1, etc.
545 $ | $0 | $$0 The last value in the value history.
547 $$ An abbreviation for the second to the last
548 value in the value history, I.e. $$1 */
551 write_dollar_variable (struct parser_state *ps, struct stoken str)
553 struct block_symbol sym;
554 struct bound_minimal_symbol msym;
555 struct internalvar *isym = NULL;
557 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
558 and $$digits (equivalent to $<-digits> if you could type that). */
562 /* Double dollar means negate the number and add -1 as well.
563 Thus $$ alone means -1. */
564 if (str.length >= 2 && str.ptr[1] == '$')
571 /* Just dollars (one or two). */
575 /* Is the rest of the token digits? */
576 for (; i < str.length; i++)
577 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
581 i = atoi (str.ptr + 1 + negate);
587 /* Handle tokens that refer to machine registers:
588 $ followed by a register name. */
589 i = user_reg_map_name_to_regnum (ps->gdbarch (),
590 str.ptr + 1, str.length - 1);
592 goto handle_register;
594 /* Any names starting with $ are probably debugger internal variables. */
596 isym = lookup_only_internalvar (copy_name (str) + 1);
599 write_exp_elt_opcode (ps, OP_INTERNALVAR);
600 write_exp_elt_intern (ps, isym);
601 write_exp_elt_opcode (ps, OP_INTERNALVAR);
605 /* On some systems, such as HP-UX and hppa-linux, certain system routines
606 have names beginning with $ or $$. Check for those, first. */
608 sym = lookup_symbol (copy_name (str), NULL, VAR_DOMAIN, NULL);
611 write_exp_elt_opcode (ps, OP_VAR_VALUE);
612 write_exp_elt_block (ps, sym.block);
613 write_exp_elt_sym (ps, sym.symbol);
614 write_exp_elt_opcode (ps, OP_VAR_VALUE);
617 msym = lookup_bound_minimal_symbol (copy_name (str));
620 write_exp_msymbol (ps, msym);
624 /* Any other names are assumed to be debugger internal variables. */
626 write_exp_elt_opcode (ps, OP_INTERNALVAR);
627 write_exp_elt_intern (ps, create_internalvar (copy_name (str) + 1));
628 write_exp_elt_opcode (ps, OP_INTERNALVAR);
631 write_exp_elt_opcode (ps, OP_LAST);
632 write_exp_elt_longcst (ps, (LONGEST) i);
633 write_exp_elt_opcode (ps, OP_LAST);
636 write_exp_elt_opcode (ps, OP_REGISTER);
639 write_exp_string (ps, str);
640 write_exp_elt_opcode (ps, OP_REGISTER);
641 innermost_block.update (ps->expression_context_block,
642 INNERMOST_BLOCK_FOR_REGISTERS);
648 find_template_name_end (const char *p)
651 int just_seen_right = 0;
652 int just_seen_colon = 0;
653 int just_seen_space = 0;
655 if (!p || (*p != '<'))
666 /* In future, may want to allow these?? */
669 depth++; /* start nested template */
670 if (just_seen_colon || just_seen_right || just_seen_space)
671 return 0; /* but not after : or :: or > or space */
674 if (just_seen_colon || just_seen_right)
675 return 0; /* end a (nested?) template */
676 just_seen_right = 1; /* but not after : or :: */
677 if (--depth == 0) /* also disallow >>, insist on > > */
678 return ++p; /* if outermost ended, return */
681 if (just_seen_space || (just_seen_colon > 1))
682 return 0; /* nested class spec coming up */
683 just_seen_colon++; /* we allow :: but not :::: */
688 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
689 (*p >= 'A' && *p <= 'Z') ||
690 (*p >= '0' && *p <= '9') ||
691 (*p == '_') || (*p == ',') || /* commas for template args */
692 (*p == '&') || (*p == '*') || /* pointer and ref types */
693 (*p == '(') || (*p == ')') || /* function types */
694 (*p == '[') || (*p == ']'))) /* array types */
708 /* Return a null-terminated temporary copy of the name of a string token.
710 Tokens that refer to names do so with explicit pointer and length,
711 so they can share the storage that lexptr is parsing.
712 When it is necessary to pass a name to a function that expects
713 a null-terminated string, the substring is copied out
714 into a separate block of storage.
716 N.B. A single buffer is reused on each call. */
719 copy_name (struct stoken token)
721 /* A temporary buffer for identifiers, so we can null-terminate them.
722 We allocate this with xrealloc. parse_exp_1 used to allocate with
723 alloca, using the size of the whole expression as a conservative
724 estimate of the space needed. However, macro expansion can
725 introduce names longer than the original expression; there's no
726 practical way to know beforehand how large that might be. */
727 static char *namecopy;
728 static size_t namecopy_size;
730 /* Make sure there's enough space for the token. */
731 if (namecopy_size < token.length + 1)
733 namecopy_size = token.length + 1;
734 namecopy = (char *) xrealloc (namecopy, token.length + 1);
737 memcpy (namecopy, token.ptr, token.length);
738 namecopy[token.length] = 0;
744 /* See comments on parser-defs.h. */
747 prefixify_expression (struct expression *expr, int last_struct)
749 gdb_assert (expr->nelts > 0);
750 int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
751 struct expression *temp;
752 int inpos = expr->nelts, outpos = 0;
754 temp = (struct expression *) alloca (len);
756 /* Copy the original expression into temp. */
757 memcpy (temp, expr, len);
759 return prefixify_subexp (temp, expr, inpos, outpos, last_struct);
762 /* Return the number of exp_elements in the postfix subexpression
763 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
766 length_of_subexp (struct expression *expr, int endpos)
770 operator_length (expr, endpos, &oplen, &args);
774 oplen += length_of_subexp (expr, endpos - oplen);
781 /* Sets *OPLENP to the length of the operator whose (last) index is
782 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
786 operator_length (const struct expression *expr, int endpos, int *oplenp,
789 expr->language_defn->la_exp_desc->operator_length (expr, endpos,
793 /* Default value for operator_length in exp_descriptor vectors. */
796 operator_length_standard (const struct expression *expr, int endpos,
797 int *oplenp, int *argsp)
801 enum range_type range_type;
805 error (_("?error in operator_length_standard"));
807 i = (int) expr->elts[endpos - 1].opcode;
813 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
814 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
820 case OP_VAR_MSYM_VALUE:
824 case OP_FUNC_STATIC_VAR:
825 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
826 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
834 case OP_VAR_ENTRY_VALUE:
844 case OP_F77_UNDETERMINED_ARGLIST:
846 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
850 oplen = 5 + longest_to_int (expr->elts[endpos - 2].longconst);
854 case OP_OBJC_MSGCALL: /* Objective C message (method) call. */
856 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
865 case UNOP_DYNAMIC_CAST:
866 case UNOP_REINTERPRET_CAST:
867 case UNOP_MEMVAL_TYPE:
896 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
897 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
902 case STRUCTOP_STRUCT:
909 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
910 NSString constant. */
911 case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op. */
913 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
914 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
919 args = longest_to_int (expr->elts[endpos - 2].longconst);
920 args -= longest_to_int (expr->elts[endpos - 3].longconst);
930 case MULTI_SUBSCRIPT:
932 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
935 case BINOP_ASSIGN_MODIFY:
947 range_type = (enum range_type)
948 longest_to_int (expr->elts[endpos - 2].longconst);
952 case LOW_BOUND_DEFAULT:
953 case LOW_BOUND_DEFAULT_EXCLUSIVE:
954 case HIGH_BOUND_DEFAULT:
957 case BOTH_BOUND_DEFAULT:
960 case NONE_BOUND_DEFAULT:
961 case NONE_BOUND_DEFAULT_EXCLUSIVE:
969 args = 1 + (i < (int) BINOP_END);
976 /* Copy the subexpression ending just before index INEND in INEXPR
977 into OUTEXPR, starting at index OUTBEG.
978 In the process, convert it from suffix to prefix form.
979 If LAST_STRUCT is -1, then this function always returns -1.
980 Otherwise, it returns the index of the subexpression which is the
981 left-hand-side of the expression at LAST_STRUCT. */
984 prefixify_subexp (struct expression *inexpr,
985 struct expression *outexpr, int inend, int outbeg,
994 operator_length (inexpr, inend, &oplen, &args);
996 /* Copy the final operator itself, from the end of the input
997 to the beginning of the output. */
999 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1000 EXP_ELEM_TO_BYTES (oplen));
1003 if (last_struct == inend)
1004 result = outbeg - oplen;
1006 /* Find the lengths of the arg subexpressions. */
1007 arglens = (int *) alloca (args * sizeof (int));
1008 for (i = args - 1; i >= 0; i--)
1010 oplen = length_of_subexp (inexpr, inend);
1015 /* Now copy each subexpression, preserving the order of
1016 the subexpressions, but prefixifying each one.
1017 In this loop, inend starts at the beginning of
1018 the expression this level is working on
1019 and marches forward over the arguments.
1020 outbeg does similarly in the output. */
1021 for (i = 0; i < args; i++)
1027 r = prefixify_subexp (inexpr, outexpr, inend, outbeg, last_struct);
1030 /* Return immediately. We probably have only parsed a
1031 partial expression, so we don't want to try to reverse
1032 the other operands. */
1041 /* Read an expression from the string *STRINGPTR points to,
1042 parse it, and return a pointer to a struct expression that we malloc.
1043 Use block BLOCK as the lexical context for variable names;
1044 if BLOCK is zero, use the block of the selected stack frame.
1045 Meanwhile, advance *STRINGPTR to point after the expression,
1046 at the first nonwhite character that is not part of the expression
1047 (possibly a null character).
1049 If COMMA is nonzero, stop if a comma is reached. */
1052 parse_exp_1 (const char **stringptr, CORE_ADDR pc, const struct block *block,
1053 int comma, innermost_block_tracker_types tracker_types)
1055 return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL,
1056 tracker_types, nullptr);
1059 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1060 no value is expected from the expression.
1061 OUT_SUBEXP is set when attempting to complete a field name; in this
1062 case it is set to the index of the subexpression on the
1063 left-hand-side of the struct op. If not doing such completion, it
1064 is left untouched. */
1066 static expression_up
1067 parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
1068 const struct block *block,
1069 int comma, int void_context_p, int *out_subexp,
1070 innermost_block_tracker_types tracker_types,
1071 expr_completion_state *cstate)
1073 const struct language_defn *lang = NULL;
1076 type_stack.elements.clear ();
1077 innermost_block.reset (tracker_types);
1079 if (*stringptr == 0 || **stringptr == 0)
1080 error_no_arg (_("expression to compute"));
1082 const struct block *expression_context_block = block;
1083 CORE_ADDR expression_context_pc = 0;
1085 /* If no context specified, try using the current frame, if any. */
1086 if (!expression_context_block)
1087 expression_context_block = get_selected_block (&expression_context_pc);
1089 expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);
1091 expression_context_pc = pc;
1093 /* Fall back to using the current source static context, if any. */
1095 if (!expression_context_block)
1097 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1099 expression_context_block
1100 = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
1102 if (expression_context_block)
1103 expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);
1106 if (language_mode == language_mode_auto && block != NULL)
1108 /* Find the language associated to the given context block.
1109 Default to the current language if it can not be determined.
1111 Note that using the language corresponding to the current frame
1112 can sometimes give unexpected results. For instance, this
1113 routine is often called several times during the inferior
1114 startup phase to re-parse breakpoint expressions after
1115 a new shared library has been loaded. The language associated
1116 to the current frame at this moment is not relevant for
1117 the breakpoint. Using it would therefore be silly, so it seems
1118 better to rely on the current language rather than relying on
1119 the current frame language to parse the expression. That's why
1120 we do the following language detection only if the context block
1121 has been specifically provided. */
1122 struct symbol *func = block_linkage_function (block);
1125 lang = language_def (SYMBOL_LANGUAGE (func));
1126 if (lang == NULL || lang->la_language == language_unknown)
1127 lang = current_language;
1130 lang = current_language;
1132 /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
1133 While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
1134 and others called from *.y) ensure CURRENT_LANGUAGE gets restored
1135 to the value matching SELECTED_FRAME as set by get_current_arch. */
1137 parser_state ps (lang, get_current_arch (), expression_context_block,
1138 expression_context_pc, comma, *stringptr,
1141 scoped_restore_current_language lang_saver;
1142 set_language (lang->la_language);
1146 lang->la_parser (&ps);
1148 CATCH (except, RETURN_MASK_ALL)
1150 /* If parsing for completion, allow this to succeed; but if no
1151 expression elements have been written, then there's nothing
1153 if (! ps.parse_completion || ps.expout_ptr == 0)
1154 throw_exception (except);
1158 /* We have to operate on an "expression *", due to la_post_parser,
1159 which explains this funny-looking double release. */
1160 expression_up result = ps.release ();
1162 /* Convert expression from postfix form as generated by yacc
1163 parser, to a prefix form. */
1165 if (expressiondebug)
1166 dump_raw_expression (result.get (), gdb_stdlog,
1167 "before conversion to prefix form");
1169 subexp = prefixify_expression (result.get (),
1170 ps.m_completion_state.expout_last_struct);
1172 *out_subexp = subexp;
1174 lang->la_post_parser (&result, void_context_p, ps.parse_completion);
1176 if (expressiondebug)
1177 dump_prefix_expression (result.get (), gdb_stdlog);
1179 if (cstate != nullptr)
1180 *cstate = std::move (ps.m_completion_state);
1181 *stringptr = ps.lexptr;
1185 /* Parse STRING as an expression, and complain if this fails
1186 to use up all of the contents of STRING. */
1189 parse_expression (const char *string)
1191 expression_up exp = parse_exp_1 (&string, 0, 0, 0);
1193 error (_("Junk after end of expression."));
1197 /* Same as parse_expression, but using the given language (LANG)
1198 to parse the expression. */
1201 parse_expression_with_language (const char *string, enum language lang)
1203 gdb::optional<scoped_restore_current_language> lang_saver;
1204 if (current_language->la_language != lang)
1206 lang_saver.emplace ();
1207 set_language (lang);
1210 return parse_expression (string);
1213 /* Parse STRING as an expression. If parsing ends in the middle of a
1214 field reference, return the type of the left-hand-side of the
1215 reference; furthermore, if the parsing ends in the field name,
1216 return the field name in *NAME. If the parsing ends in the middle
1217 of a field reference, but the reference is somehow invalid, throw
1218 an exception. In all other cases, return NULL. */
1221 parse_expression_for_completion (const char *string,
1222 gdb::unique_xmalloc_ptr<char> *name,
1223 enum type_code *code)
1228 expr_completion_state cstate;
1232 exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp,
1233 INNERMOST_BLOCK_FOR_SYMBOLS, &cstate);
1235 CATCH (except, RETURN_MASK_ERROR)
1237 /* Nothing, EXP remains NULL. */
1244 if (cstate.expout_tag_completion_type != TYPE_CODE_UNDEF)
1246 *code = cstate.expout_tag_completion_type;
1247 *name = std::move (cstate.expout_completion_name);
1251 if (cstate.expout_last_struct == -1)
1254 const char *fieldname = extract_field_op (exp.get (), &subexp);
1255 if (fieldname == NULL)
1261 name->reset (xstrdup (fieldname));
1262 /* This might throw an exception. If so, we want to let it
1264 val = evaluate_subexpression_type (exp.get (), subexp);
1266 return value_type (val);
1269 /* A post-parser that does nothing. */
1272 null_post_parser (expression_up *exp, int void_context_p, int completin)
1276 /* Parse floating point value P of length LEN.
1277 Return false if invalid, true if valid.
1278 The successfully parsed number is stored in DATA in
1279 target format for floating-point type TYPE.
1281 NOTE: This accepts the floating point syntax that sscanf accepts. */
1284 parse_float (const char *p, int len,
1285 const struct type *type, gdb_byte *data)
1287 return target_float_from_string (data, type, std::string (p, len));
1290 /* Stuff for maintaining a stack of types. Currently just used by C, but
1291 probably useful for any language which declares its types "backwards". */
1293 /* A helper function for insert_type and insert_type_address_space.
1294 This does work of expanding the type stack and inserting the new
1295 element, ELEMENT, into the stack at location SLOT. */
1298 insert_into_type_stack (int slot, union type_stack_elt element)
1300 gdb_assert (slot <= type_stack.elements.size ());
1301 type_stack.elements.insert (type_stack.elements.begin () + slot, element);
1304 /* Insert a new type, TP, at the bottom of the type stack. If TP is
1305 tp_pointer, tp_reference or tp_rvalue_reference, it is inserted at the
1306 bottom. If TP is a qualifier, it is inserted at slot 1 (just above a
1307 previous tp_pointer) if there is anything on the stack, or simply pushed
1308 if the stack is empty. Other values for TP are invalid. */
1311 insert_type (enum type_pieces tp)
1313 union type_stack_elt element;
1316 gdb_assert (tp == tp_pointer || tp == tp_reference
1317 || tp == tp_rvalue_reference || tp == tp_const
1318 || tp == tp_volatile);
1320 /* If there is anything on the stack (we know it will be a
1321 tp_pointer), insert the qualifier above it. Otherwise, simply
1322 push this on the top of the stack. */
1323 if (!type_stack.elements.empty () && (tp == tp_const || tp == tp_volatile))
1329 insert_into_type_stack (slot, element);
1333 push_type (enum type_pieces tp)
1337 type_stack.elements.push_back (elt);
1341 push_type_int (int n)
1345 type_stack.elements.push_back (elt);
1348 /* Insert a tp_space_identifier and the corresponding address space
1349 value into the stack. STRING is the name of an address space, as
1350 recognized by address_space_name_to_int. If the stack is empty,
1351 the new elements are simply pushed. If the stack is not empty,
1352 this function assumes that the first item on the stack is a
1353 tp_pointer, and the new values are inserted above the first
1357 insert_type_address_space (struct expr_builder *pstate, char *string)
1359 union type_stack_elt element;
1362 /* If there is anything on the stack (we know it will be a
1363 tp_pointer), insert the address space qualifier above it.
1364 Otherwise, simply push this on the top of the stack. */
1365 if (!type_stack.elements.empty ())
1370 element.piece = tp_space_identifier;
1371 insert_into_type_stack (slot, element);
1372 element.int_val = address_space_name_to_int (pstate->gdbarch (),
1374 insert_into_type_stack (slot, element);
1380 if (!type_stack.elements.empty ())
1382 type_stack_elt elt = type_stack.elements.back ();
1383 type_stack.elements.pop_back ();
1392 if (!type_stack.elements.empty ())
1394 type_stack_elt elt = type_stack.elements.back ();
1395 type_stack.elements.pop_back ();
1398 /* "Can't happen". */
1402 /* Pop a type list element from the global type stack. */
1404 static std::vector<struct type *> *
1407 gdb_assert (!type_stack.elements.empty ());
1408 type_stack_elt elt = type_stack.elements.back ();
1409 type_stack.elements.pop_back ();
1410 return elt.typelist_val;
1413 /* Pop a type_stack element from the global type stack. */
1415 static struct type_stack *
1416 pop_type_stack (void)
1418 gdb_assert (!type_stack.elements.empty ());
1419 type_stack_elt elt = type_stack.elements.back ();
1420 type_stack.elements.pop_back ();
1421 return elt.stack_val;
1424 /* Append the elements of the type stack FROM to the type stack TO.
1425 Always returns TO. */
1428 append_type_stack (struct type_stack *to, struct type_stack *from)
1430 to->elements.insert (to->elements.end (), from->elements.begin (),
1431 from->elements.end ());
1435 /* Push the type stack STACK as an element on the global type stack. */
1438 push_type_stack (struct type_stack *stack)
1441 elt.stack_val = stack;
1442 type_stack.elements.push_back (elt);
1443 push_type (tp_type_stack);
1446 /* Copy the global type stack into a newly allocated type stack and
1447 return it. The global stack is cleared. The returned type stack
1448 must be freed with delete. */
1451 get_type_stack (void)
1453 struct type_stack *result = new struct type_stack (std::move (type_stack));
1454 type_stack.elements.clear ();
1458 /* Push a function type with arguments onto the global type stack.
1459 LIST holds the argument types. If the final item in LIST is NULL,
1460 then the function will be varargs. */
1463 push_typelist (std::vector<struct type *> *list)
1466 elt.typelist_val = list;
1467 type_stack.elements.push_back (elt);
1468 push_type (tp_function_with_arguments);
1471 /* Pop the type stack and return a type_instance_flags that
1472 corresponds the const/volatile qualifiers on the stack. This is
1473 called by the C++ parser when parsing methods types, and as such no
1474 other kind of type in the type stack is expected. */
1477 follow_type_instance_flags ()
1479 type_instance_flags flags = 0;
1482 switch (pop_type ())
1487 flags |= TYPE_INSTANCE_FLAG_CONST;
1490 flags |= TYPE_INSTANCE_FLAG_VOLATILE;
1493 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1498 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1499 as modified by all the stuff on the stack. */
1501 follow_types (struct type *follow_type)
1505 int make_volatile = 0;
1506 int make_addr_space = 0;
1510 switch (pop_type ())
1515 follow_type = make_cv_type (make_const,
1516 TYPE_VOLATILE (follow_type),
1519 follow_type = make_cv_type (TYPE_CONST (follow_type),
1522 if (make_addr_space)
1523 follow_type = make_type_with_address_space (follow_type,
1525 make_const = make_volatile = 0;
1526 make_addr_space = 0;
1534 case tp_space_identifier:
1535 make_addr_space = pop_type_int ();
1538 follow_type = lookup_pointer_type (follow_type);
1540 follow_type = make_cv_type (make_const,
1541 TYPE_VOLATILE (follow_type),
1544 follow_type = make_cv_type (TYPE_CONST (follow_type),
1547 if (make_addr_space)
1548 follow_type = make_type_with_address_space (follow_type,
1550 make_const = make_volatile = 0;
1551 make_addr_space = 0;
1554 follow_type = lookup_lvalue_reference_type (follow_type);
1555 goto process_reference;
1556 case tp_rvalue_reference:
1557 follow_type = lookup_rvalue_reference_type (follow_type);
1560 follow_type = make_cv_type (make_const,
1561 TYPE_VOLATILE (follow_type),
1564 follow_type = make_cv_type (TYPE_CONST (follow_type),
1567 if (make_addr_space)
1568 follow_type = make_type_with_address_space (follow_type,
1570 make_const = make_volatile = 0;
1571 make_addr_space = 0;
1574 array_size = pop_type_int ();
1575 /* FIXME-type-allocation: need a way to free this type when we are
1578 lookup_array_range_type (follow_type,
1579 0, array_size >= 0 ? array_size - 1 : 0);
1581 TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (follow_type))
1585 /* FIXME-type-allocation: need a way to free this type when we are
1587 follow_type = lookup_function_type (follow_type);
1590 case tp_function_with_arguments:
1592 std::vector<struct type *> *args = pop_typelist ();
1595 = lookup_function_type_with_arguments (follow_type,
1603 struct type_stack *stack = pop_type_stack ();
1604 /* Sort of ugly, but not really much worse than the
1606 struct type_stack save = type_stack;
1608 type_stack = *stack;
1609 follow_type = follow_types (follow_type);
1610 gdb_assert (type_stack.elements.empty ());
1616 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1621 /* This function avoids direct calls to fprintf
1622 in the parser generated debug code. */
1624 parser_fprintf (FILE *x, const char *y, ...)
1630 vfprintf_unfiltered (gdb_stderr, y, args);
1633 fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1634 vfprintf_unfiltered (gdb_stderr, y, args);
1639 /* Implementation of the exp_descriptor method operator_check. */
1642 operator_check_standard (struct expression *exp, int pos,
1643 int (*objfile_func) (struct objfile *objfile,
1647 const union exp_element *const elts = exp->elts;
1648 struct type *type = NULL;
1649 struct objfile *objfile = NULL;
1651 /* Extended operators should have been already handled by exp_descriptor
1652 iterate method of its specific language. */
1653 gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1655 /* Track the callers of write_exp_elt_type for this table. */
1657 switch (elts[pos].opcode)
1669 type = elts[pos + 1].type;
1674 LONGEST arg, nargs = elts[pos + 2].longconst;
1676 for (arg = 0; arg < nargs; arg++)
1678 struct type *inst_type = elts[pos + 3 + arg].type;
1679 struct objfile *inst_objfile = TYPE_OBJFILE (inst_type);
1681 if (inst_objfile && (*objfile_func) (inst_objfile, data))
1689 const struct block *const block = elts[pos + 1].block;
1690 const struct symbol *const symbol = elts[pos + 2].symbol;
1692 /* Check objfile where the variable itself is placed.
1693 SYMBOL_OBJ_SECTION (symbol) may be NULL. */
1694 if ((*objfile_func) (symbol_objfile (symbol), data))
1697 /* Check objfile where is placed the code touching the variable. */
1698 objfile = lookup_objfile_from_block (block);
1700 type = SYMBOL_TYPE (symbol);
1703 case OP_VAR_MSYM_VALUE:
1704 objfile = elts[pos + 1].objfile;
1708 /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
1710 if (type && TYPE_OBJFILE (type)
1711 && (*objfile_func) (TYPE_OBJFILE (type), data))
1713 if (objfile && (*objfile_func) (objfile, data))
1719 /* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1720 OBJFILE_FUNC is never called with NULL OBJFILE. OBJFILE_FUNC get
1721 passed an arbitrary caller supplied DATA pointer. If OBJFILE_FUNC
1722 returns non-zero value then (any other) non-zero value is immediately
1723 returned to the caller. Otherwise zero is returned after iterating
1724 through whole EXP. */
1727 exp_iterate (struct expression *exp,
1728 int (*objfile_func) (struct objfile *objfile, void *data),
1733 for (endpos = exp->nelts; endpos > 0; )
1735 int pos, args, oplen = 0;
1737 operator_length (exp, endpos, &oplen, &args);
1738 gdb_assert (oplen > 0);
1740 pos = endpos - oplen;
1741 if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1742 objfile_func, data))
1751 /* Helper for exp_uses_objfile. */
1754 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1756 struct objfile *objfile = (struct objfile *) objfile_voidp;
1758 if (exp_objfile->separate_debug_objfile_backlink)
1759 exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1761 return exp_objfile == objfile;
1764 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1765 is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
1769 exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1771 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1773 return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1776 /* Reallocate the `expout' pointer inside PS so that it can accommodate
1777 at least LENELT expression elements. This function does nothing if
1778 there is enough room for the elements. */
1781 increase_expout_size (struct expr_builder *ps, size_t lenelt)
1783 if ((ps->expout_ptr + lenelt) >= ps->expout_size)
1785 ps->expout_size = std::max (ps->expout_size * 2,
1786 ps->expout_ptr + lenelt + 10);
1787 ps->expout.reset (XRESIZEVAR (expression,
1788 ps->expout.release (),
1789 (sizeof (struct expression)
1790 + EXP_ELEM_TO_BYTES (ps->expout_size))));
1795 _initialize_parse (void)
1797 add_setshow_zuinteger_cmd ("expression", class_maintenance,
1799 _("Set expression debugging."),
1800 _("Show expression debugging."),
1801 _("When non-zero, the internal representation "
1802 "of expressions will be printed."),
1804 show_expressiondebug,
1805 &setdebuglist, &showdebuglist);
1806 add_setshow_boolean_cmd ("parser", class_maintenance,
1808 _("Set parser debugging."),
1809 _("Show parser debugging."),
1810 _("When non-zero, expression parser "
1811 "tracing will be enabled."),
1814 &setdebuglist, &showdebuglist);