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;
71 static struct type_stack type_stack;
73 /* True if parsing an expression to attempt completion. */
76 /* The index of the last struct expression directly before a '.' or
77 '->'. This is set when parsing and is only used when completing a
78 field name. It is -1 if no dereference operation was found. */
79 static int expout_last_struct = -1;
81 /* If we are completing a tagged type name, this will be nonzero. */
82 static enum type_code expout_tag_completion_type = TYPE_CODE_UNDEF;
84 /* The token for tagged type name completion. */
85 static gdb::unique_xmalloc_ptr<char> expout_completion_name;
88 static unsigned int expressiondebug = 0;
90 show_expressiondebug (struct ui_file *file, int from_tty,
91 struct cmd_list_element *c, const char *value)
93 fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
97 /* Non-zero if an expression parser should set yydebug. */
101 show_parserdebug (struct ui_file *file, int from_tty,
102 struct cmd_list_element *c, const char *value)
104 fprintf_filtered (file, _("Parser debugging is %s.\n"), value);
108 static int prefixify_subexp (struct expression *, struct expression *, int,
111 static expression_up parse_exp_in_context (const char **, CORE_ADDR,
112 const struct block *, int,
114 innermost_block_tracker_types);
116 static void increase_expout_size (struct expr_builder *ps, size_t lenelt);
119 /* Documented at it's declaration. */
122 innermost_block_tracker::update (const struct block *b,
123 innermost_block_tracker_types t)
125 if ((m_types & t) != 0
126 && (m_innermost_block == NULL
127 || contained_in (b, m_innermost_block)))
128 m_innermost_block = b;
131 /* Data structure for saving values of arglist_len for function calls whose
132 arguments contain other function calls. */
134 static std::vector<int> *funcall_chain;
136 /* Begin counting arguments for a function call,
137 saving the data about any containing call. */
142 funcall_chain->push_back (arglist_len);
146 /* Return the number of arguments in a function call just terminated,
147 and restore the data for the containing function call. */
152 int val = arglist_len;
153 arglist_len = funcall_chain->back ();
154 funcall_chain->pop_back ();
160 /* See definition in parser-defs.h. */
162 expr_builder::expr_builder (const struct language_defn *lang,
163 struct gdbarch *gdbarch)
165 expout (XNEWVAR (expression,
167 + EXP_ELEM_TO_BYTES (expout_size)))),
170 expout->language_defn = lang;
171 expout->gdbarch = gdbarch;
175 expr_builder::release ()
177 /* Record the actual number of expression elements, and then
178 reallocate the expression memory so that we free up any
181 expout->nelts = expout_ptr;
182 expout.reset (XRESIZEVAR (expression, expout.release (),
184 + EXP_ELEM_TO_BYTES (expout_ptr))));
186 return std::move (expout);
189 /* This page contains the functions for adding data to the struct expression
190 being constructed. */
192 /* Add one element to the end of the expression. */
194 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
195 a register through here. */
198 write_exp_elt (struct expr_builder *ps, const union exp_element *expelt)
200 if (ps->expout_ptr >= ps->expout_size)
202 ps->expout_size *= 2;
203 ps->expout.reset (XRESIZEVAR (expression, ps->expout.release (),
205 + EXP_ELEM_TO_BYTES (ps->expout_size))));
207 ps->expout->elts[ps->expout_ptr++] = *expelt;
211 write_exp_elt_opcode (struct expr_builder *ps, enum exp_opcode expelt)
213 union exp_element tmp;
215 memset (&tmp, 0, sizeof (union exp_element));
217 write_exp_elt (ps, &tmp);
221 write_exp_elt_sym (struct expr_builder *ps, struct symbol *expelt)
223 union exp_element tmp;
225 memset (&tmp, 0, sizeof (union exp_element));
227 write_exp_elt (ps, &tmp);
231 write_exp_elt_msym (struct expr_builder *ps, minimal_symbol *expelt)
233 union exp_element tmp;
235 memset (&tmp, 0, sizeof (union exp_element));
236 tmp.msymbol = expelt;
237 write_exp_elt (ps, &tmp);
241 write_exp_elt_block (struct expr_builder *ps, const struct block *b)
243 union exp_element tmp;
245 memset (&tmp, 0, sizeof (union exp_element));
247 write_exp_elt (ps, &tmp);
251 write_exp_elt_objfile (struct expr_builder *ps, struct objfile *objfile)
253 union exp_element tmp;
255 memset (&tmp, 0, sizeof (union exp_element));
256 tmp.objfile = objfile;
257 write_exp_elt (ps, &tmp);
261 write_exp_elt_longcst (struct expr_builder *ps, LONGEST expelt)
263 union exp_element tmp;
265 memset (&tmp, 0, sizeof (union exp_element));
266 tmp.longconst = expelt;
267 write_exp_elt (ps, &tmp);
271 write_exp_elt_floatcst (struct expr_builder *ps, const gdb_byte expelt[16])
273 union exp_element tmp;
276 for (index = 0; index < 16; index++)
277 tmp.floatconst[index] = expelt[index];
279 write_exp_elt (ps, &tmp);
283 write_exp_elt_type (struct expr_builder *ps, struct type *expelt)
285 union exp_element tmp;
287 memset (&tmp, 0, sizeof (union exp_element));
289 write_exp_elt (ps, &tmp);
293 write_exp_elt_intern (struct expr_builder *ps, struct internalvar *expelt)
295 union exp_element tmp;
297 memset (&tmp, 0, sizeof (union exp_element));
298 tmp.internalvar = expelt;
299 write_exp_elt (ps, &tmp);
302 /* Add a string constant to the end of the expression.
304 String constants are stored by first writing an expression element
305 that contains the length of the string, then stuffing the string
306 constant itself into however many expression elements are needed
307 to hold it, and then writing another expression element that contains
308 the length of the string. I.e. an expression element at each end of
309 the string records the string length, so you can skip over the
310 expression elements containing the actual string bytes from either
311 end of the string. Note that this also allows gdb to handle
312 strings with embedded null bytes, as is required for some languages.
314 Don't be fooled by the fact that the string is null byte terminated,
315 this is strictly for the convenience of debugging gdb itself.
316 Gdb does not depend up the string being null terminated, since the
317 actual length is recorded in expression elements at each end of the
318 string. The null byte is taken into consideration when computing how
319 many expression elements are required to hold the string constant, of
324 write_exp_string (struct expr_builder *ps, struct stoken str)
326 int len = str.length;
330 /* Compute the number of expression elements required to hold the string
331 (including a null byte terminator), along with one expression element
332 at each end to record the actual string length (not including the
333 null byte terminator). */
335 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
337 increase_expout_size (ps, lenelt);
339 /* Write the leading length expression element (which advances the current
340 expression element index), then write the string constant followed by a
341 terminating null byte, and then write the trailing length expression
344 write_exp_elt_longcst (ps, (LONGEST) len);
345 strdata = (char *) &ps->expout->elts[ps->expout_ptr];
346 memcpy (strdata, str.ptr, len);
347 *(strdata + len) = '\0';
348 ps->expout_ptr += lenelt - 2;
349 write_exp_elt_longcst (ps, (LONGEST) len);
352 /* Add a vector of string constants to the end of the expression.
354 This adds an OP_STRING operation, but encodes the contents
355 differently from write_exp_string. The language is expected to
356 handle evaluation of this expression itself.
358 After the usual OP_STRING header, TYPE is written into the
359 expression as a long constant. The interpretation of this field is
360 up to the language evaluator.
362 Next, each string in VEC is written. The length is written as a
363 long constant, followed by the contents of the string. */
366 write_exp_string_vector (struct expr_builder *ps, int type,
367 struct stoken_vector *vec)
372 /* Compute the size. We compute the size in number of slots to
373 avoid issues with string padding. */
375 for (i = 0; i < vec->len; ++i)
377 /* One slot for the length of this element, plus the number of
378 slots needed for this string. */
379 n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
382 /* One more slot for the type of the string. */
385 /* Now compute a phony string length. */
386 len = EXP_ELEM_TO_BYTES (n_slots) - 1;
389 increase_expout_size (ps, n_slots);
391 write_exp_elt_opcode (ps, OP_STRING);
392 write_exp_elt_longcst (ps, len);
393 write_exp_elt_longcst (ps, type);
395 for (i = 0; i < vec->len; ++i)
397 write_exp_elt_longcst (ps, vec->tokens[i].length);
398 memcpy (&ps->expout->elts[ps->expout_ptr], vec->tokens[i].ptr,
399 vec->tokens[i].length);
400 ps->expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
403 write_exp_elt_longcst (ps, len);
404 write_exp_elt_opcode (ps, OP_STRING);
407 /* Add a bitstring constant to the end of the expression.
409 Bitstring constants are stored by first writing an expression element
410 that contains the length of the bitstring (in bits), then stuffing the
411 bitstring constant itself into however many expression elements are
412 needed to hold it, and then writing another expression element that
413 contains the length of the bitstring. I.e. an expression element at
414 each end of the bitstring records the bitstring length, so you can skip
415 over the expression elements containing the actual bitstring bytes from
416 either end of the bitstring. */
419 write_exp_bitstring (struct expr_builder *ps, struct stoken str)
421 int bits = str.length; /* length in bits */
422 int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
426 /* Compute the number of expression elements required to hold the bitstring,
427 along with one expression element at each end to record the actual
428 bitstring length in bits. */
430 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
432 increase_expout_size (ps, lenelt);
434 /* Write the leading length expression element (which advances the current
435 expression element index), then write the bitstring constant, and then
436 write the trailing length expression element. */
438 write_exp_elt_longcst (ps, (LONGEST) bits);
439 strdata = (char *) &ps->expout->elts[ps->expout_ptr];
440 memcpy (strdata, str.ptr, len);
441 ps->expout_ptr += lenelt - 2;
442 write_exp_elt_longcst (ps, (LONGEST) bits);
445 /* Return the type of MSYMBOL, a minimal symbol of OBJFILE. If
446 ADDRESS_P is not NULL, set it to the MSYMBOL's resolved
450 find_minsym_type_and_address (minimal_symbol *msymbol,
451 struct objfile *objfile,
452 CORE_ADDR *address_p)
454 bound_minimal_symbol bound_msym = {msymbol, objfile};
455 struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
456 enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
458 bool is_tls = (section != NULL
459 && section->the_bfd_section->flags & SEC_THREAD_LOCAL);
461 /* The minimal symbol might point to a function descriptor;
462 resolve it to the actual code address instead. */
466 /* Addresses of TLS symbols are really offsets into a
467 per-objfile/per-thread storage block. */
468 addr = MSYMBOL_VALUE_RAW_ADDRESS (bound_msym.minsym);
470 else if (msymbol_is_function (objfile, msymbol, &addr))
472 if (addr != BMSYMBOL_VALUE_ADDRESS (bound_msym))
474 /* This means we resolved a function descriptor, and we now
475 have an address for a code/text symbol instead of a data
477 if (MSYMBOL_TYPE (msymbol) == mst_data_gnu_ifunc)
478 type = mst_text_gnu_ifunc;
485 addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);
487 if (overlay_debugging)
488 addr = symbol_overlayed_address (addr, section);
492 /* Skip translation if caller does not need the address. */
493 if (address_p != NULL)
494 *address_p = target_translate_tls_address (objfile, addr);
495 return objfile_type (objfile)->nodebug_tls_symbol;
498 if (address_p != NULL)
505 case mst_solib_trampoline:
506 return objfile_type (objfile)->nodebug_text_symbol;
508 case mst_text_gnu_ifunc:
509 return objfile_type (objfile)->nodebug_text_gnu_ifunc_symbol;
515 return objfile_type (objfile)->nodebug_data_symbol;
517 case mst_slot_got_plt:
518 return objfile_type (objfile)->nodebug_got_plt_symbol;
521 return objfile_type (objfile)->nodebug_unknown_symbol;
525 /* Add the appropriate elements for a minimal symbol to the end of
529 write_exp_msymbol (struct expr_builder *ps,
530 struct bound_minimal_symbol bound_msym)
532 write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
533 write_exp_elt_objfile (ps, bound_msym.objfile);
534 write_exp_elt_msym (ps, bound_msym.minsym);
535 write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
538 /* Mark the current index as the starting location of a structure
539 expression. This is used when completing on field names. */
542 mark_struct_expression (struct expr_builder *ps)
544 gdb_assert (parse_completion
545 && expout_tag_completion_type == TYPE_CODE_UNDEF);
546 expout_last_struct = ps->expout_ptr;
549 /* Indicate that the current parser invocation is completing a tag.
550 TAG is the type code of the tag, and PTR and LENGTH represent the
551 start of the tag name. */
554 mark_completion_tag (enum type_code tag, const char *ptr, int length)
556 gdb_assert (parse_completion
557 && expout_tag_completion_type == TYPE_CODE_UNDEF
558 && expout_completion_name == NULL
559 && expout_last_struct == -1);
560 gdb_assert (tag == TYPE_CODE_UNION
561 || tag == TYPE_CODE_STRUCT
562 || tag == TYPE_CODE_ENUM);
563 expout_tag_completion_type = tag;
564 expout_completion_name.reset (xstrndup (ptr, length));
568 /* Recognize tokens that start with '$'. These include:
570 $regname A native register name or a "standard
573 $variable A convenience variable with a name chosen
576 $digits Value history with index <digits>, starting
577 from the first value which has index 1.
579 $$digits Value history with index <digits> relative
580 to the last value. I.e. $$0 is the last
581 value, $$1 is the one previous to that, $$2
582 is the one previous to $$1, etc.
584 $ | $0 | $$0 The last value in the value history.
586 $$ An abbreviation for the second to the last
587 value in the value history, I.e. $$1 */
590 write_dollar_variable (struct parser_state *ps, struct stoken str)
592 struct block_symbol sym;
593 struct bound_minimal_symbol msym;
594 struct internalvar *isym = NULL;
596 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
597 and $$digits (equivalent to $<-digits> if you could type that). */
601 /* Double dollar means negate the number and add -1 as well.
602 Thus $$ alone means -1. */
603 if (str.length >= 2 && str.ptr[1] == '$')
610 /* Just dollars (one or two). */
614 /* Is the rest of the token digits? */
615 for (; i < str.length; i++)
616 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
620 i = atoi (str.ptr + 1 + negate);
626 /* Handle tokens that refer to machine registers:
627 $ followed by a register name. */
628 i = user_reg_map_name_to_regnum (ps->gdbarch (),
629 str.ptr + 1, str.length - 1);
631 goto handle_register;
633 /* Any names starting with $ are probably debugger internal variables. */
635 isym = lookup_only_internalvar (copy_name (str) + 1);
638 write_exp_elt_opcode (ps, OP_INTERNALVAR);
639 write_exp_elt_intern (ps, isym);
640 write_exp_elt_opcode (ps, OP_INTERNALVAR);
644 /* On some systems, such as HP-UX and hppa-linux, certain system routines
645 have names beginning with $ or $$. Check for those, first. */
647 sym = lookup_symbol (copy_name (str), NULL, VAR_DOMAIN, NULL);
650 write_exp_elt_opcode (ps, OP_VAR_VALUE);
651 write_exp_elt_block (ps, sym.block);
652 write_exp_elt_sym (ps, sym.symbol);
653 write_exp_elt_opcode (ps, OP_VAR_VALUE);
656 msym = lookup_bound_minimal_symbol (copy_name (str));
659 write_exp_msymbol (ps, msym);
663 /* Any other names are assumed to be debugger internal variables. */
665 write_exp_elt_opcode (ps, OP_INTERNALVAR);
666 write_exp_elt_intern (ps, create_internalvar (copy_name (str) + 1));
667 write_exp_elt_opcode (ps, OP_INTERNALVAR);
670 write_exp_elt_opcode (ps, OP_LAST);
671 write_exp_elt_longcst (ps, (LONGEST) i);
672 write_exp_elt_opcode (ps, OP_LAST);
675 write_exp_elt_opcode (ps, OP_REGISTER);
678 write_exp_string (ps, str);
679 write_exp_elt_opcode (ps, OP_REGISTER);
680 innermost_block.update (ps->expression_context_block,
681 INNERMOST_BLOCK_FOR_REGISTERS);
687 find_template_name_end (const char *p)
690 int just_seen_right = 0;
691 int just_seen_colon = 0;
692 int just_seen_space = 0;
694 if (!p || (*p != '<'))
705 /* In future, may want to allow these?? */
708 depth++; /* start nested template */
709 if (just_seen_colon || just_seen_right || just_seen_space)
710 return 0; /* but not after : or :: or > or space */
713 if (just_seen_colon || just_seen_right)
714 return 0; /* end a (nested?) template */
715 just_seen_right = 1; /* but not after : or :: */
716 if (--depth == 0) /* also disallow >>, insist on > > */
717 return ++p; /* if outermost ended, return */
720 if (just_seen_space || (just_seen_colon > 1))
721 return 0; /* nested class spec coming up */
722 just_seen_colon++; /* we allow :: but not :::: */
727 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
728 (*p >= 'A' && *p <= 'Z') ||
729 (*p >= '0' && *p <= '9') ||
730 (*p == '_') || (*p == ',') || /* commas for template args */
731 (*p == '&') || (*p == '*') || /* pointer and ref types */
732 (*p == '(') || (*p == ')') || /* function types */
733 (*p == '[') || (*p == ']'))) /* array types */
747 /* Return a null-terminated temporary copy of the name of a string token.
749 Tokens that refer to names do so with explicit pointer and length,
750 so they can share the storage that lexptr is parsing.
751 When it is necessary to pass a name to a function that expects
752 a null-terminated string, the substring is copied out
753 into a separate block of storage.
755 N.B. A single buffer is reused on each call. */
758 copy_name (struct stoken token)
760 /* A temporary buffer for identifiers, so we can null-terminate them.
761 We allocate this with xrealloc. parse_exp_1 used to allocate with
762 alloca, using the size of the whole expression as a conservative
763 estimate of the space needed. However, macro expansion can
764 introduce names longer than the original expression; there's no
765 practical way to know beforehand how large that might be. */
766 static char *namecopy;
767 static size_t namecopy_size;
769 /* Make sure there's enough space for the token. */
770 if (namecopy_size < token.length + 1)
772 namecopy_size = token.length + 1;
773 namecopy = (char *) xrealloc (namecopy, token.length + 1);
776 memcpy (namecopy, token.ptr, token.length);
777 namecopy[token.length] = 0;
783 /* See comments on parser-defs.h. */
786 prefixify_expression (struct expression *expr)
788 gdb_assert (expr->nelts > 0);
789 int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
790 struct expression *temp;
791 int inpos = expr->nelts, outpos = 0;
793 temp = (struct expression *) alloca (len);
795 /* Copy the original expression into temp. */
796 memcpy (temp, expr, len);
798 return prefixify_subexp (temp, expr, inpos, outpos);
801 /* Return the number of exp_elements in the postfix subexpression
802 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
805 length_of_subexp (struct expression *expr, int endpos)
809 operator_length (expr, endpos, &oplen, &args);
813 oplen += length_of_subexp (expr, endpos - oplen);
820 /* Sets *OPLENP to the length of the operator whose (last) index is
821 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
825 operator_length (const struct expression *expr, int endpos, int *oplenp,
828 expr->language_defn->la_exp_desc->operator_length (expr, endpos,
832 /* Default value for operator_length in exp_descriptor vectors. */
835 operator_length_standard (const struct expression *expr, int endpos,
836 int *oplenp, int *argsp)
840 enum range_type range_type;
844 error (_("?error in operator_length_standard"));
846 i = (int) expr->elts[endpos - 1].opcode;
852 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
853 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
859 case OP_VAR_MSYM_VALUE:
863 case OP_FUNC_STATIC_VAR:
864 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
865 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
873 case OP_VAR_ENTRY_VALUE:
883 case OP_F77_UNDETERMINED_ARGLIST:
885 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
889 oplen = 5 + longest_to_int (expr->elts[endpos - 2].longconst);
893 case OP_OBJC_MSGCALL: /* Objective C message (method) call. */
895 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
904 case UNOP_DYNAMIC_CAST:
905 case UNOP_REINTERPRET_CAST:
906 case UNOP_MEMVAL_TYPE:
935 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
936 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
941 case STRUCTOP_STRUCT:
948 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
949 NSString constant. */
950 case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op. */
952 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
953 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
958 args = longest_to_int (expr->elts[endpos - 2].longconst);
959 args -= longest_to_int (expr->elts[endpos - 3].longconst);
969 case MULTI_SUBSCRIPT:
971 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
974 case BINOP_ASSIGN_MODIFY:
986 range_type = (enum range_type)
987 longest_to_int (expr->elts[endpos - 2].longconst);
991 case LOW_BOUND_DEFAULT:
992 case LOW_BOUND_DEFAULT_EXCLUSIVE:
993 case HIGH_BOUND_DEFAULT:
996 case BOTH_BOUND_DEFAULT:
999 case NONE_BOUND_DEFAULT:
1000 case NONE_BOUND_DEFAULT_EXCLUSIVE:
1008 args = 1 + (i < (int) BINOP_END);
1015 /* Copy the subexpression ending just before index INEND in INEXPR
1016 into OUTEXPR, starting at index OUTBEG.
1017 In the process, convert it from suffix to prefix form.
1018 If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1019 Otherwise, it returns the index of the subexpression which is the
1020 left-hand-side of the expression at EXPOUT_LAST_STRUCT. */
1023 prefixify_subexp (struct expression *inexpr,
1024 struct expression *outexpr, int inend, int outbeg)
1032 operator_length (inexpr, inend, &oplen, &args);
1034 /* Copy the final operator itself, from the end of the input
1035 to the beginning of the output. */
1037 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1038 EXP_ELEM_TO_BYTES (oplen));
1041 if (expout_last_struct == inend)
1042 result = outbeg - oplen;
1044 /* Find the lengths of the arg subexpressions. */
1045 arglens = (int *) alloca (args * sizeof (int));
1046 for (i = args - 1; i >= 0; i--)
1048 oplen = length_of_subexp (inexpr, inend);
1053 /* Now copy each subexpression, preserving the order of
1054 the subexpressions, but prefixifying each one.
1055 In this loop, inend starts at the beginning of
1056 the expression this level is working on
1057 and marches forward over the arguments.
1058 outbeg does similarly in the output. */
1059 for (i = 0; i < args; i++)
1065 r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1068 /* Return immediately. We probably have only parsed a
1069 partial expression, so we don't want to try to reverse
1070 the other operands. */
1079 /* Read an expression from the string *STRINGPTR points to,
1080 parse it, and return a pointer to a struct expression that we malloc.
1081 Use block BLOCK as the lexical context for variable names;
1082 if BLOCK is zero, use the block of the selected stack frame.
1083 Meanwhile, advance *STRINGPTR to point after the expression,
1084 at the first nonwhite character that is not part of the expression
1085 (possibly a null character).
1087 If COMMA is nonzero, stop if a comma is reached. */
1090 parse_exp_1 (const char **stringptr, CORE_ADDR pc, const struct block *block,
1091 int comma, innermost_block_tracker_types tracker_types)
1093 return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL,
1097 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1098 no value is expected from the expression.
1099 OUT_SUBEXP is set when attempting to complete a field name; in this
1100 case it is set to the index of the subexpression on the
1101 left-hand-side of the struct op. If not doing such completion, it
1102 is left untouched. */
1104 static expression_up
1105 parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
1106 const struct block *block,
1107 int comma, int void_context_p, int *out_subexp,
1108 innermost_block_tracker_types tracker_types)
1110 const struct language_defn *lang = NULL;
1113 type_stack.elements.clear ();
1114 expout_last_struct = -1;
1115 expout_tag_completion_type = TYPE_CODE_UNDEF;
1116 expout_completion_name.reset ();
1117 innermost_block.reset (tracker_types);
1119 if (*stringptr == 0 || **stringptr == 0)
1120 error_no_arg (_("expression to compute"));
1122 std::vector<int> funcalls;
1123 scoped_restore save_funcall_chain = make_scoped_restore (&funcall_chain,
1126 const struct block *expression_context_block = block;
1127 CORE_ADDR expression_context_pc = 0;
1129 /* If no context specified, try using the current frame, if any. */
1130 if (!expression_context_block)
1131 expression_context_block = get_selected_block (&expression_context_pc);
1133 expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);
1135 expression_context_pc = pc;
1137 /* Fall back to using the current source static context, if any. */
1139 if (!expression_context_block)
1141 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1143 expression_context_block
1144 = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
1146 if (expression_context_block)
1147 expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);
1150 if (language_mode == language_mode_auto && block != NULL)
1152 /* Find the language associated to the given context block.
1153 Default to the current language if it can not be determined.
1155 Note that using the language corresponding to the current frame
1156 can sometimes give unexpected results. For instance, this
1157 routine is often called several times during the inferior
1158 startup phase to re-parse breakpoint expressions after
1159 a new shared library has been loaded. The language associated
1160 to the current frame at this moment is not relevant for
1161 the breakpoint. Using it would therefore be silly, so it seems
1162 better to rely on the current language rather than relying on
1163 the current frame language to parse the expression. That's why
1164 we do the following language detection only if the context block
1165 has been specifically provided. */
1166 struct symbol *func = block_linkage_function (block);
1169 lang = language_def (SYMBOL_LANGUAGE (func));
1170 if (lang == NULL || lang->la_language == language_unknown)
1171 lang = current_language;
1174 lang = current_language;
1176 /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
1177 While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
1178 and others called from *.y) ensure CURRENT_LANGUAGE gets restored
1179 to the value matching SELECTED_FRAME as set by get_current_arch. */
1181 parser_state ps (lang, get_current_arch (), expression_context_block,
1182 expression_context_pc, comma, *stringptr);
1184 scoped_restore_current_language lang_saver;
1185 set_language (lang->la_language);
1189 lang->la_parser (&ps);
1191 CATCH (except, RETURN_MASK_ALL)
1193 /* If parsing for completion, allow this to succeed; but if no
1194 expression elements have been written, then there's nothing
1196 if (! parse_completion || ps.expout_ptr == 0)
1197 throw_exception (except);
1201 /* We have to operate on an "expression *", due to la_post_parser,
1202 which explains this funny-looking double release. */
1203 expression_up result = ps.release ();
1205 /* Convert expression from postfix form as generated by yacc
1206 parser, to a prefix form. */
1208 if (expressiondebug)
1209 dump_raw_expression (result.get (), gdb_stdlog,
1210 "before conversion to prefix form");
1212 subexp = prefixify_expression (result.get ());
1214 *out_subexp = subexp;
1216 lang->la_post_parser (&result, void_context_p);
1218 if (expressiondebug)
1219 dump_prefix_expression (result.get (), gdb_stdlog);
1221 *stringptr = ps.lexptr;
1225 /* Parse STRING as an expression, and complain if this fails
1226 to use up all of the contents of STRING. */
1229 parse_expression (const char *string)
1231 expression_up exp = parse_exp_1 (&string, 0, 0, 0);
1233 error (_("Junk after end of expression."));
1237 /* Same as parse_expression, but using the given language (LANG)
1238 to parse the expression. */
1241 parse_expression_with_language (const char *string, enum language lang)
1243 gdb::optional<scoped_restore_current_language> lang_saver;
1244 if (current_language->la_language != lang)
1246 lang_saver.emplace ();
1247 set_language (lang);
1250 return parse_expression (string);
1253 /* Parse STRING as an expression. If parsing ends in the middle of a
1254 field reference, return the type of the left-hand-side of the
1255 reference; furthermore, if the parsing ends in the field name,
1256 return the field name in *NAME. If the parsing ends in the middle
1257 of a field reference, but the reference is somehow invalid, throw
1258 an exception. In all other cases, return NULL. */
1261 parse_expression_for_completion (const char *string,
1262 gdb::unique_xmalloc_ptr<char> *name,
1263 enum type_code *code)
1271 parse_completion = 1;
1272 exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp,
1273 INNERMOST_BLOCK_FOR_SYMBOLS);
1275 CATCH (except, RETURN_MASK_ERROR)
1277 /* Nothing, EXP remains NULL. */
1281 parse_completion = 0;
1285 if (expout_tag_completion_type != TYPE_CODE_UNDEF)
1287 *code = expout_tag_completion_type;
1288 *name = std::move (expout_completion_name);
1292 if (expout_last_struct == -1)
1295 const char *fieldname = extract_field_op (exp.get (), &subexp);
1296 if (fieldname == NULL)
1302 name->reset (xstrdup (fieldname));
1303 /* This might throw an exception. If so, we want to let it
1305 val = evaluate_subexpression_type (exp.get (), subexp);
1307 return value_type (val);
1310 /* A post-parser that does nothing. */
1313 null_post_parser (expression_up *exp, int void_context_p)
1317 /* Parse floating point value P of length LEN.
1318 Return false if invalid, true if valid.
1319 The successfully parsed number is stored in DATA in
1320 target format for floating-point type TYPE.
1322 NOTE: This accepts the floating point syntax that sscanf accepts. */
1325 parse_float (const char *p, int len,
1326 const struct type *type, gdb_byte *data)
1328 return target_float_from_string (data, type, std::string (p, len));
1331 /* Stuff for maintaining a stack of types. Currently just used by C, but
1332 probably useful for any language which declares its types "backwards". */
1334 /* A helper function for insert_type and insert_type_address_space.
1335 This does work of expanding the type stack and inserting the new
1336 element, ELEMENT, into the stack at location SLOT. */
1339 insert_into_type_stack (int slot, union type_stack_elt element)
1341 gdb_assert (slot <= type_stack.elements.size ());
1342 type_stack.elements.insert (type_stack.elements.begin () + slot, element);
1345 /* Insert a new type, TP, at the bottom of the type stack. If TP is
1346 tp_pointer, tp_reference or tp_rvalue_reference, it is inserted at the
1347 bottom. If TP is a qualifier, it is inserted at slot 1 (just above a
1348 previous tp_pointer) if there is anything on the stack, or simply pushed
1349 if the stack is empty. Other values for TP are invalid. */
1352 insert_type (enum type_pieces tp)
1354 union type_stack_elt element;
1357 gdb_assert (tp == tp_pointer || tp == tp_reference
1358 || tp == tp_rvalue_reference || tp == tp_const
1359 || tp == tp_volatile);
1361 /* If there is anything on the stack (we know it will be a
1362 tp_pointer), insert the qualifier above it. Otherwise, simply
1363 push this on the top of the stack. */
1364 if (!type_stack.elements.empty () && (tp == tp_const || tp == tp_volatile))
1370 insert_into_type_stack (slot, element);
1374 push_type (enum type_pieces tp)
1378 type_stack.elements.push_back (elt);
1382 push_type_int (int n)
1386 type_stack.elements.push_back (elt);
1389 /* Insert a tp_space_identifier and the corresponding address space
1390 value into the stack. STRING is the name of an address space, as
1391 recognized by address_space_name_to_int. If the stack is empty,
1392 the new elements are simply pushed. If the stack is not empty,
1393 this function assumes that the first item on the stack is a
1394 tp_pointer, and the new values are inserted above the first
1398 insert_type_address_space (struct expr_builder *pstate, char *string)
1400 union type_stack_elt element;
1403 /* If there is anything on the stack (we know it will be a
1404 tp_pointer), insert the address space qualifier above it.
1405 Otherwise, simply push this on the top of the stack. */
1406 if (!type_stack.elements.empty ())
1411 element.piece = tp_space_identifier;
1412 insert_into_type_stack (slot, element);
1413 element.int_val = address_space_name_to_int (pstate->gdbarch (),
1415 insert_into_type_stack (slot, element);
1421 if (!type_stack.elements.empty ())
1423 type_stack_elt elt = type_stack.elements.back ();
1424 type_stack.elements.pop_back ();
1433 if (!type_stack.elements.empty ())
1435 type_stack_elt elt = type_stack.elements.back ();
1436 type_stack.elements.pop_back ();
1439 /* "Can't happen". */
1443 /* Pop a type list element from the global type stack. */
1445 static std::vector<struct type *> *
1448 gdb_assert (!type_stack.elements.empty ());
1449 type_stack_elt elt = type_stack.elements.back ();
1450 type_stack.elements.pop_back ();
1451 return elt.typelist_val;
1454 /* Pop a type_stack element from the global type stack. */
1456 static struct type_stack *
1457 pop_type_stack (void)
1459 gdb_assert (!type_stack.elements.empty ());
1460 type_stack_elt elt = type_stack.elements.back ();
1461 type_stack.elements.pop_back ();
1462 return elt.stack_val;
1465 /* Append the elements of the type stack FROM to the type stack TO.
1466 Always returns TO. */
1469 append_type_stack (struct type_stack *to, struct type_stack *from)
1471 to->elements.insert (to->elements.end (), from->elements.begin (),
1472 from->elements.end ());
1476 /* Push the type stack STACK as an element on the global type stack. */
1479 push_type_stack (struct type_stack *stack)
1482 elt.stack_val = stack;
1483 type_stack.elements.push_back (elt);
1484 push_type (tp_type_stack);
1487 /* Copy the global type stack into a newly allocated type stack and
1488 return it. The global stack is cleared. The returned type stack
1489 must be freed with delete. */
1492 get_type_stack (void)
1494 struct type_stack *result = new struct type_stack (std::move (type_stack));
1495 type_stack.elements.clear ();
1499 /* Push a function type with arguments onto the global type stack.
1500 LIST holds the argument types. If the final item in LIST is NULL,
1501 then the function will be varargs. */
1504 push_typelist (std::vector<struct type *> *list)
1507 elt.typelist_val = list;
1508 type_stack.elements.push_back (elt);
1509 push_type (tp_function_with_arguments);
1512 /* Pop the type stack and return a type_instance_flags that
1513 corresponds the const/volatile qualifiers on the stack. This is
1514 called by the C++ parser when parsing methods types, and as such no
1515 other kind of type in the type stack is expected. */
1518 follow_type_instance_flags ()
1520 type_instance_flags flags = 0;
1523 switch (pop_type ())
1528 flags |= TYPE_INSTANCE_FLAG_CONST;
1531 flags |= TYPE_INSTANCE_FLAG_VOLATILE;
1534 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1539 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1540 as modified by all the stuff on the stack. */
1542 follow_types (struct type *follow_type)
1546 int make_volatile = 0;
1547 int make_addr_space = 0;
1551 switch (pop_type ())
1556 follow_type = make_cv_type (make_const,
1557 TYPE_VOLATILE (follow_type),
1560 follow_type = make_cv_type (TYPE_CONST (follow_type),
1563 if (make_addr_space)
1564 follow_type = make_type_with_address_space (follow_type,
1566 make_const = make_volatile = 0;
1567 make_addr_space = 0;
1575 case tp_space_identifier:
1576 make_addr_space = pop_type_int ();
1579 follow_type = lookup_pointer_type (follow_type);
1581 follow_type = make_cv_type (make_const,
1582 TYPE_VOLATILE (follow_type),
1585 follow_type = make_cv_type (TYPE_CONST (follow_type),
1588 if (make_addr_space)
1589 follow_type = make_type_with_address_space (follow_type,
1591 make_const = make_volatile = 0;
1592 make_addr_space = 0;
1595 follow_type = lookup_lvalue_reference_type (follow_type);
1596 goto process_reference;
1597 case tp_rvalue_reference:
1598 follow_type = lookup_rvalue_reference_type (follow_type);
1601 follow_type = make_cv_type (make_const,
1602 TYPE_VOLATILE (follow_type),
1605 follow_type = make_cv_type (TYPE_CONST (follow_type),
1608 if (make_addr_space)
1609 follow_type = make_type_with_address_space (follow_type,
1611 make_const = make_volatile = 0;
1612 make_addr_space = 0;
1615 array_size = pop_type_int ();
1616 /* FIXME-type-allocation: need a way to free this type when we are
1619 lookup_array_range_type (follow_type,
1620 0, array_size >= 0 ? array_size - 1 : 0);
1622 TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (follow_type))
1626 /* FIXME-type-allocation: need a way to free this type when we are
1628 follow_type = lookup_function_type (follow_type);
1631 case tp_function_with_arguments:
1633 std::vector<struct type *> *args = pop_typelist ();
1636 = lookup_function_type_with_arguments (follow_type,
1644 struct type_stack *stack = pop_type_stack ();
1645 /* Sort of ugly, but not really much worse than the
1647 struct type_stack save = type_stack;
1649 type_stack = *stack;
1650 follow_type = follow_types (follow_type);
1651 gdb_assert (type_stack.elements.empty ());
1657 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1662 /* This function avoids direct calls to fprintf
1663 in the parser generated debug code. */
1665 parser_fprintf (FILE *x, const char *y, ...)
1671 vfprintf_unfiltered (gdb_stderr, y, args);
1674 fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1675 vfprintf_unfiltered (gdb_stderr, y, args);
1680 /* Implementation of the exp_descriptor method operator_check. */
1683 operator_check_standard (struct expression *exp, int pos,
1684 int (*objfile_func) (struct objfile *objfile,
1688 const union exp_element *const elts = exp->elts;
1689 struct type *type = NULL;
1690 struct objfile *objfile = NULL;
1692 /* Extended operators should have been already handled by exp_descriptor
1693 iterate method of its specific language. */
1694 gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1696 /* Track the callers of write_exp_elt_type for this table. */
1698 switch (elts[pos].opcode)
1710 type = elts[pos + 1].type;
1715 LONGEST arg, nargs = elts[pos + 2].longconst;
1717 for (arg = 0; arg < nargs; arg++)
1719 struct type *inst_type = elts[pos + 3 + arg].type;
1720 struct objfile *inst_objfile = TYPE_OBJFILE (inst_type);
1722 if (inst_objfile && (*objfile_func) (inst_objfile, data))
1730 const struct block *const block = elts[pos + 1].block;
1731 const struct symbol *const symbol = elts[pos + 2].symbol;
1733 /* Check objfile where the variable itself is placed.
1734 SYMBOL_OBJ_SECTION (symbol) may be NULL. */
1735 if ((*objfile_func) (symbol_objfile (symbol), data))
1738 /* Check objfile where is placed the code touching the variable. */
1739 objfile = lookup_objfile_from_block (block);
1741 type = SYMBOL_TYPE (symbol);
1744 case OP_VAR_MSYM_VALUE:
1745 objfile = elts[pos + 1].objfile;
1749 /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
1751 if (type && TYPE_OBJFILE (type)
1752 && (*objfile_func) (TYPE_OBJFILE (type), data))
1754 if (objfile && (*objfile_func) (objfile, data))
1760 /* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1761 OBJFILE_FUNC is never called with NULL OBJFILE. OBJFILE_FUNC get
1762 passed an arbitrary caller supplied DATA pointer. If OBJFILE_FUNC
1763 returns non-zero value then (any other) non-zero value is immediately
1764 returned to the caller. Otherwise zero is returned after iterating
1765 through whole EXP. */
1768 exp_iterate (struct expression *exp,
1769 int (*objfile_func) (struct objfile *objfile, void *data),
1774 for (endpos = exp->nelts; endpos > 0; )
1776 int pos, args, oplen = 0;
1778 operator_length (exp, endpos, &oplen, &args);
1779 gdb_assert (oplen > 0);
1781 pos = endpos - oplen;
1782 if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1783 objfile_func, data))
1792 /* Helper for exp_uses_objfile. */
1795 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1797 struct objfile *objfile = (struct objfile *) objfile_voidp;
1799 if (exp_objfile->separate_debug_objfile_backlink)
1800 exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1802 return exp_objfile == objfile;
1805 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1806 is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
1810 exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1812 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1814 return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1817 /* Reallocate the `expout' pointer inside PS so that it can accommodate
1818 at least LENELT expression elements. This function does nothing if
1819 there is enough room for the elements. */
1822 increase_expout_size (struct expr_builder *ps, size_t lenelt)
1824 if ((ps->expout_ptr + lenelt) >= ps->expout_size)
1826 ps->expout_size = std::max (ps->expout_size * 2,
1827 ps->expout_ptr + lenelt + 10);
1828 ps->expout.reset (XRESIZEVAR (expression,
1829 ps->expout.release (),
1830 (sizeof (struct expression)
1831 + EXP_ELEM_TO_BYTES (ps->expout_size))));
1836 _initialize_parse (void)
1838 add_setshow_zuinteger_cmd ("expression", class_maintenance,
1840 _("Set expression debugging."),
1841 _("Show expression debugging."),
1842 _("When non-zero, the internal representation "
1843 "of expressions will be printed."),
1845 show_expressiondebug,
1846 &setdebuglist, &showdebuglist);
1847 add_setshow_boolean_cmd ("parser", class_maintenance,
1849 _("Set parser debugging."),
1850 _("Show parser debugging."),
1851 _("When non-zero, expression parser "
1852 "tracing will be enabled."),
1855 &setdebuglist, &showdebuglist);