1 /* Parse expressions for GDB.
3 Copyright (C) 1986, 1989-2001, 2004-2005, 2007-2012 Free Software
6 Modified from expread.y by the Department of Computer Science at the
7 State University of New York at Buffalo, 1991.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 /* Parse an expression from text in a string,
25 and return the result as a struct expression pointer.
26 That structure contains arithmetic operations in reverse polish,
27 with constants represented by operations that are followed by special data.
28 See expression.h for the details of the format.
29 What is important here is that it can be built up sequentially
30 during the process of parsing; the lower levels of the tree always
31 come first in the result. */
35 #include "arch-utils.h"
36 #include "gdb_string.h"
40 #include "expression.h"
45 #include "parser-defs.h"
47 #include "symfile.h" /* for overlay functions */
50 #include "gdb_assert.h"
54 #include "exceptions.h"
55 #include "user-regs.h"
57 /* Standard set of definitions for printing, dumping, prefixifying,
58 * and evaluating expressions. */
60 const struct exp_descriptor exp_descriptor_standard =
62 print_subexp_standard,
63 operator_length_standard,
64 operator_check_standard,
66 dump_subexp_body_standard,
67 evaluate_subexp_standard
70 /* Global variables declared in parser-defs.h (and commented there). */
71 struct expression *expout;
74 struct block *expression_context_block;
75 CORE_ADDR expression_context_pc;
76 struct block *innermost_block;
78 static struct type_stack type_stack;
84 /* True if parsing an expression to find a field reference. This is
85 only used by completion. */
88 /* The index of the last struct expression directly before a '.' or
89 '->'. This is set when parsing and is only used when completing a
90 field name. It is -1 if no dereference operation was found. */
91 static int expout_last_struct = -1;
93 static int expressiondebug = 0;
95 show_expressiondebug (struct ui_file *file, int from_tty,
96 struct cmd_list_element *c, const char *value)
98 fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
102 /* Non-zero if an expression parser should set yydebug. */
106 show_parserdebug (struct ui_file *file, int from_tty,
107 struct cmd_list_element *c, const char *value)
109 fprintf_filtered (file, _("Parser debugging is %s.\n"), value);
113 static void free_funcalls (void *ignore);
115 static int prefixify_subexp (struct expression *, struct expression *, int,
118 static struct expression *parse_exp_in_context (char **, CORE_ADDR,
122 void _initialize_parse (void);
124 /* Data structure for saving values of arglist_len for function calls whose
125 arguments contain other function calls. */
129 struct funcall *next;
133 static struct funcall *funcall_chain;
135 /* Begin counting arguments for a function call,
136 saving the data about any containing call. */
143 new = (struct funcall *) xmalloc (sizeof (struct funcall));
144 new->next = funcall_chain;
145 new->arglist_len = arglist_len;
150 /* Return the number of arguments in a function call just terminated,
151 and restore the data for the containing function call. */
156 int val = arglist_len;
157 struct funcall *call = funcall_chain;
159 funcall_chain = call->next;
160 arglist_len = call->arglist_len;
165 /* Free everything in the funcall chain.
166 Used when there is an error inside parsing. */
169 free_funcalls (void *ignore)
171 struct funcall *call, *next;
173 for (call = funcall_chain; call; call = next)
180 /* This page contains the functions for adding data to the struct expression
181 being constructed. */
183 /* See definition in parser-defs.h. */
186 initialize_expout (int initial_size, const struct language_defn *lang,
187 struct gdbarch *gdbarch)
189 expout_size = initial_size;
191 expout = xmalloc (sizeof (struct expression)
192 + EXP_ELEM_TO_BYTES (expout_size));
193 expout->language_defn = lang;
194 expout->gdbarch = gdbarch;
197 /* See definition in parser-defs.h. */
200 reallocate_expout (void)
202 /* Record the actual number of expression elements, and then
203 reallocate the expression memory so that we free up any
206 expout->nelts = expout_ptr;
207 expout = xrealloc ((char *) expout,
208 sizeof (struct expression)
209 + EXP_ELEM_TO_BYTES (expout_ptr));
212 /* Add one element to the end of the expression. */
214 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
215 a register through here. */
218 write_exp_elt (const union exp_element *expelt)
220 if (expout_ptr >= expout_size)
223 expout = (struct expression *)
224 xrealloc ((char *) expout, sizeof (struct expression)
225 + EXP_ELEM_TO_BYTES (expout_size));
227 expout->elts[expout_ptr++] = *expelt;
231 write_exp_elt_opcode (enum exp_opcode expelt)
233 union exp_element tmp;
235 memset (&tmp, 0, sizeof (union exp_element));
237 write_exp_elt (&tmp);
241 write_exp_elt_sym (struct symbol *expelt)
243 union exp_element tmp;
245 memset (&tmp, 0, sizeof (union exp_element));
247 write_exp_elt (&tmp);
251 write_exp_elt_block (struct block *b)
253 union exp_element tmp;
255 memset (&tmp, 0, sizeof (union exp_element));
257 write_exp_elt (&tmp);
261 write_exp_elt_objfile (struct objfile *objfile)
263 union exp_element tmp;
265 memset (&tmp, 0, sizeof (union exp_element));
266 tmp.objfile = objfile;
267 write_exp_elt (&tmp);
271 write_exp_elt_longcst (LONGEST expelt)
273 union exp_element tmp;
275 memset (&tmp, 0, sizeof (union exp_element));
276 tmp.longconst = expelt;
277 write_exp_elt (&tmp);
281 write_exp_elt_dblcst (DOUBLEST expelt)
283 union exp_element tmp;
285 memset (&tmp, 0, sizeof (union exp_element));
286 tmp.doubleconst = expelt;
287 write_exp_elt (&tmp);
291 write_exp_elt_decfloatcst (gdb_byte expelt[16])
293 union exp_element tmp;
296 for (index = 0; index < 16; index++)
297 tmp.decfloatconst[index] = expelt[index];
299 write_exp_elt (&tmp);
303 write_exp_elt_type (struct type *expelt)
305 union exp_element tmp;
307 memset (&tmp, 0, sizeof (union exp_element));
309 write_exp_elt (&tmp);
313 write_exp_elt_intern (struct internalvar *expelt)
315 union exp_element tmp;
317 memset (&tmp, 0, sizeof (union exp_element));
318 tmp.internalvar = expelt;
319 write_exp_elt (&tmp);
322 /* Add a string constant to the end of the expression.
324 String constants are stored by first writing an expression element
325 that contains the length of the string, then stuffing the string
326 constant itself into however many expression elements are needed
327 to hold it, and then writing another expression element that contains
328 the length of the string. I.e. an expression element at each end of
329 the string records the string length, so you can skip over the
330 expression elements containing the actual string bytes from either
331 end of the string. Note that this also allows gdb to handle
332 strings with embedded null bytes, as is required for some languages.
334 Don't be fooled by the fact that the string is null byte terminated,
335 this is strictly for the convenience of debugging gdb itself.
336 Gdb does not depend up the string being null terminated, since the
337 actual length is recorded in expression elements at each end of the
338 string. The null byte is taken into consideration when computing how
339 many expression elements are required to hold the string constant, of
344 write_exp_string (struct stoken str)
346 int len = str.length;
350 /* Compute the number of expression elements required to hold the string
351 (including a null byte terminator), along with one expression element
352 at each end to record the actual string length (not including the
353 null byte terminator). */
355 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
357 /* Ensure that we have enough available expression elements to store
360 if ((expout_ptr + lenelt) >= expout_size)
362 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
363 expout = (struct expression *)
364 xrealloc ((char *) expout, (sizeof (struct expression)
365 + EXP_ELEM_TO_BYTES (expout_size)));
368 /* Write the leading length expression element (which advances the current
369 expression element index), then write the string constant followed by a
370 terminating null byte, and then write the trailing length expression
373 write_exp_elt_longcst ((LONGEST) len);
374 strdata = (char *) &expout->elts[expout_ptr];
375 memcpy (strdata, str.ptr, len);
376 *(strdata + len) = '\0';
377 expout_ptr += lenelt - 2;
378 write_exp_elt_longcst ((LONGEST) len);
381 /* Add a vector of string constants to the end of the expression.
383 This adds an OP_STRING operation, but encodes the contents
384 differently from write_exp_string. The language is expected to
385 handle evaluation of this expression itself.
387 After the usual OP_STRING header, TYPE is written into the
388 expression as a long constant. The interpretation of this field is
389 up to the language evaluator.
391 Next, each string in VEC is written. The length is written as a
392 long constant, followed by the contents of the string. */
395 write_exp_string_vector (int type, struct stoken_vector *vec)
399 /* Compute the size. We compute the size in number of slots to
400 avoid issues with string padding. */
402 for (i = 0; i < vec->len; ++i)
404 /* One slot for the length of this element, plus the number of
405 slots needed for this string. */
406 n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
409 /* One more slot for the type of the string. */
412 /* Now compute a phony string length. */
413 len = EXP_ELEM_TO_BYTES (n_slots) - 1;
416 if ((expout_ptr + n_slots) >= expout_size)
418 expout_size = max (expout_size * 2, expout_ptr + n_slots + 10);
419 expout = (struct expression *)
420 xrealloc ((char *) expout, (sizeof (struct expression)
421 + EXP_ELEM_TO_BYTES (expout_size)));
424 write_exp_elt_opcode (OP_STRING);
425 write_exp_elt_longcst (len);
426 write_exp_elt_longcst (type);
428 for (i = 0; i < vec->len; ++i)
430 write_exp_elt_longcst (vec->tokens[i].length);
431 memcpy (&expout->elts[expout_ptr], vec->tokens[i].ptr,
432 vec->tokens[i].length);
433 expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
436 write_exp_elt_longcst (len);
437 write_exp_elt_opcode (OP_STRING);
440 /* Add a bitstring constant to the end of the expression.
442 Bitstring constants are stored by first writing an expression element
443 that contains the length of the bitstring (in bits), then stuffing the
444 bitstring constant itself into however many expression elements are
445 needed to hold it, and then writing another expression element that
446 contains the length of the bitstring. I.e. an expression element at
447 each end of the bitstring records the bitstring length, so you can skip
448 over the expression elements containing the actual bitstring bytes from
449 either end of the bitstring. */
452 write_exp_bitstring (struct stoken str)
454 int bits = str.length; /* length in bits */
455 int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
459 /* Compute the number of expression elements required to hold the bitstring,
460 along with one expression element at each end to record the actual
461 bitstring length in bits. */
463 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
465 /* Ensure that we have enough available expression elements to store
468 if ((expout_ptr + lenelt) >= expout_size)
470 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
471 expout = (struct expression *)
472 xrealloc ((char *) expout, (sizeof (struct expression)
473 + EXP_ELEM_TO_BYTES (expout_size)));
476 /* Write the leading length expression element (which advances the current
477 expression element index), then write the bitstring constant, and then
478 write the trailing length expression element. */
480 write_exp_elt_longcst ((LONGEST) bits);
481 strdata = (char *) &expout->elts[expout_ptr];
482 memcpy (strdata, str.ptr, len);
483 expout_ptr += lenelt - 2;
484 write_exp_elt_longcst ((LONGEST) bits);
487 /* Add the appropriate elements for a minimal symbol to the end of
491 write_exp_msymbol (struct minimal_symbol *msymbol)
493 struct objfile *objfile = msymbol_objfile (msymbol);
494 struct gdbarch *gdbarch = get_objfile_arch (objfile);
496 CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
497 struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol);
498 enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
501 /* The minimal symbol might point to a function descriptor;
502 resolve it to the actual code address instead. */
503 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, ¤t_target);
506 struct minimal_symbol *ifunc_msym = lookup_minimal_symbol_by_pc (pc);
508 /* In this case, assume we have a code symbol instead of
511 if (ifunc_msym != NULL && MSYMBOL_TYPE (ifunc_msym) == mst_text_gnu_ifunc
512 && SYMBOL_VALUE_ADDRESS (ifunc_msym) == pc)
514 /* A function descriptor has been resolved but PC is still in the
515 STT_GNU_IFUNC resolver body (such as because inferior does not
516 run to be able to call it). */
518 type = mst_text_gnu_ifunc;
526 if (overlay_debugging)
527 addr = symbol_overlayed_address (addr, section);
529 write_exp_elt_opcode (OP_LONG);
530 /* Let's make the type big enough to hold a 64-bit address. */
531 write_exp_elt_type (objfile_type (objfile)->builtin_core_addr);
532 write_exp_elt_longcst ((LONGEST) addr);
533 write_exp_elt_opcode (OP_LONG);
535 if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
537 write_exp_elt_opcode (UNOP_MEMVAL_TLS);
538 write_exp_elt_objfile (objfile);
539 write_exp_elt_type (objfile_type (objfile)->nodebug_tls_symbol);
540 write_exp_elt_opcode (UNOP_MEMVAL_TLS);
544 write_exp_elt_opcode (UNOP_MEMVAL);
549 case mst_solib_trampoline:
550 write_exp_elt_type (objfile_type (objfile)->nodebug_text_symbol);
553 case mst_text_gnu_ifunc:
554 write_exp_elt_type (objfile_type (objfile)
555 ->nodebug_text_gnu_ifunc_symbol);
562 write_exp_elt_type (objfile_type (objfile)->nodebug_data_symbol);
565 case mst_slot_got_plt:
566 write_exp_elt_type (objfile_type (objfile)->nodebug_got_plt_symbol);
570 write_exp_elt_type (objfile_type (objfile)->nodebug_unknown_symbol);
573 write_exp_elt_opcode (UNOP_MEMVAL);
576 /* Mark the current index as the starting location of a structure
577 expression. This is used when completing on field names. */
580 mark_struct_expression (void)
582 expout_last_struct = expout_ptr;
586 /* Recognize tokens that start with '$'. These include:
588 $regname A native register name or a "standard
591 $variable A convenience variable with a name chosen
594 $digits Value history with index <digits>, starting
595 from the first value which has index 1.
597 $$digits Value history with index <digits> relative
598 to the last value. I.e. $$0 is the last
599 value, $$1 is the one previous to that, $$2
600 is the one previous to $$1, etc.
602 $ | $0 | $$0 The last value in the value history.
604 $$ An abbreviation for the second to the last
605 value in the value history, I.e. $$1 */
608 write_dollar_variable (struct stoken str)
610 struct symbol *sym = NULL;
611 struct minimal_symbol *msym = NULL;
612 struct internalvar *isym = NULL;
614 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
615 and $$digits (equivalent to $<-digits> if you could type that). */
619 /* Double dollar means negate the number and add -1 as well.
620 Thus $$ alone means -1. */
621 if (str.length >= 2 && str.ptr[1] == '$')
628 /* Just dollars (one or two). */
632 /* Is the rest of the token digits? */
633 for (; i < str.length; i++)
634 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
638 i = atoi (str.ptr + 1 + negate);
644 /* Handle tokens that refer to machine registers:
645 $ followed by a register name. */
646 i = user_reg_map_name_to_regnum (parse_gdbarch,
647 str.ptr + 1, str.length - 1);
649 goto handle_register;
651 /* Any names starting with $ are probably debugger internal variables. */
653 isym = lookup_only_internalvar (copy_name (str) + 1);
656 write_exp_elt_opcode (OP_INTERNALVAR);
657 write_exp_elt_intern (isym);
658 write_exp_elt_opcode (OP_INTERNALVAR);
662 /* On some systems, such as HP-UX and hppa-linux, certain system routines
663 have names beginning with $ or $$. Check for those, first. */
665 sym = lookup_symbol (copy_name (str), (struct block *) NULL,
666 VAR_DOMAIN, (int *) NULL);
669 write_exp_elt_opcode (OP_VAR_VALUE);
670 write_exp_elt_block (block_found); /* set by lookup_symbol */
671 write_exp_elt_sym (sym);
672 write_exp_elt_opcode (OP_VAR_VALUE);
675 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
678 write_exp_msymbol (msym);
682 /* Any other names are assumed to be debugger internal variables. */
684 write_exp_elt_opcode (OP_INTERNALVAR);
685 write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
686 write_exp_elt_opcode (OP_INTERNALVAR);
689 write_exp_elt_opcode (OP_LAST);
690 write_exp_elt_longcst ((LONGEST) i);
691 write_exp_elt_opcode (OP_LAST);
694 write_exp_elt_opcode (OP_REGISTER);
697 write_exp_string (str);
698 write_exp_elt_opcode (OP_REGISTER);
704 find_template_name_end (char *p)
707 int just_seen_right = 0;
708 int just_seen_colon = 0;
709 int just_seen_space = 0;
711 if (!p || (*p != '<'))
722 /* In future, may want to allow these?? */
725 depth++; /* start nested template */
726 if (just_seen_colon || just_seen_right || just_seen_space)
727 return 0; /* but not after : or :: or > or space */
730 if (just_seen_colon || just_seen_right)
731 return 0; /* end a (nested?) template */
732 just_seen_right = 1; /* but not after : or :: */
733 if (--depth == 0) /* also disallow >>, insist on > > */
734 return ++p; /* if outermost ended, return */
737 if (just_seen_space || (just_seen_colon > 1))
738 return 0; /* nested class spec coming up */
739 just_seen_colon++; /* we allow :: but not :::: */
744 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
745 (*p >= 'A' && *p <= 'Z') ||
746 (*p >= '0' && *p <= '9') ||
747 (*p == '_') || (*p == ',') || /* commas for template args */
748 (*p == '&') || (*p == '*') || /* pointer and ref types */
749 (*p == '(') || (*p == ')') || /* function types */
750 (*p == '[') || (*p == ']'))) /* array types */
764 /* Return a null-terminated temporary copy of the name of a string token.
766 Tokens that refer to names do so with explicit pointer and length,
767 so they can share the storage that lexptr is parsing.
768 When it is necessary to pass a name to a function that expects
769 a null-terminated string, the substring is copied out
770 into a separate block of storage.
772 N.B. A single buffer is reused on each call. */
775 copy_name (struct stoken token)
777 /* A temporary buffer for identifiers, so we can null-terminate them.
778 We allocate this with xrealloc. parse_exp_1 used to allocate with
779 alloca, using the size of the whole expression as a conservative
780 estimate of the space needed. However, macro expansion can
781 introduce names longer than the original expression; there's no
782 practical way to know beforehand how large that might be. */
783 static char *namecopy;
784 static size_t namecopy_size;
786 /* Make sure there's enough space for the token. */
787 if (namecopy_size < token.length + 1)
789 namecopy_size = token.length + 1;
790 namecopy = xrealloc (namecopy, token.length + 1);
793 memcpy (namecopy, token.ptr, token.length);
794 namecopy[token.length] = 0;
800 /* See comments on parser-defs.h. */
803 prefixify_expression (struct expression *expr)
805 int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
806 struct expression *temp;
807 int inpos = expr->nelts, outpos = 0;
809 temp = (struct expression *) alloca (len);
811 /* Copy the original expression into temp. */
812 memcpy (temp, expr, len);
814 return prefixify_subexp (temp, expr, inpos, outpos);
817 /* Return the number of exp_elements in the postfix subexpression
818 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
821 length_of_subexp (struct expression *expr, int endpos)
825 operator_length (expr, endpos, &oplen, &args);
829 oplen += length_of_subexp (expr, endpos - oplen);
836 /* Sets *OPLENP to the length of the operator whose (last) index is
837 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
841 operator_length (const struct expression *expr, int endpos, int *oplenp,
844 expr->language_defn->la_exp_desc->operator_length (expr, endpos,
848 /* Default value for operator_length in exp_descriptor vectors. */
851 operator_length_standard (const struct expression *expr, int endpos,
852 int *oplenp, int *argsp)
856 enum f90_range_type range_type;
860 error (_("?error in operator_length_standard"));
862 i = (int) expr->elts[endpos - 1].opcode;
868 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
869 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
883 case OP_VAR_ENTRY_VALUE:
893 case OP_F77_UNDETERMINED_ARGLIST:
895 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
899 oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
903 case OP_OBJC_MSGCALL: /* Objective C message (method) call. */
905 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
915 case UNOP_DYNAMIC_CAST:
916 case UNOP_REINTERPRET_CAST:
922 case UNOP_MEMVAL_TLS:
940 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
941 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
947 case STRUCTOP_STRUCT:
954 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
955 NSString constant. */
956 case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op. */
958 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
959 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
963 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
964 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
965 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
970 args = longest_to_int (expr->elts[endpos - 2].longconst);
971 args -= longest_to_int (expr->elts[endpos - 3].longconst);
977 case TERNOP_SLICE_COUNT:
982 case MULTI_SUBSCRIPT:
984 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
987 case BINOP_ASSIGN_MODIFY:
1000 range_type = longest_to_int (expr->elts[endpos - 2].longconst);
1003 case LOW_BOUND_DEFAULT:
1004 case HIGH_BOUND_DEFAULT:
1007 case BOTH_BOUND_DEFAULT:
1010 case NONE_BOUND_DEFAULT:
1018 args = 1 + (i < (int) BINOP_END);
1025 /* Copy the subexpression ending just before index INEND in INEXPR
1026 into OUTEXPR, starting at index OUTBEG.
1027 In the process, convert it from suffix to prefix form.
1028 If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1029 Otherwise, it returns the index of the subexpression which is the
1030 left-hand-side of the expression at EXPOUT_LAST_STRUCT. */
1033 prefixify_subexp (struct expression *inexpr,
1034 struct expression *outexpr, int inend, int outbeg)
1042 operator_length (inexpr, inend, &oplen, &args);
1044 /* Copy the final operator itself, from the end of the input
1045 to the beginning of the output. */
1047 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1048 EXP_ELEM_TO_BYTES (oplen));
1051 if (expout_last_struct == inend)
1052 result = outbeg - oplen;
1054 /* Find the lengths of the arg subexpressions. */
1055 arglens = (int *) alloca (args * sizeof (int));
1056 for (i = args - 1; i >= 0; i--)
1058 oplen = length_of_subexp (inexpr, inend);
1063 /* Now copy each subexpression, preserving the order of
1064 the subexpressions, but prefixifying each one.
1065 In this loop, inend starts at the beginning of
1066 the expression this level is working on
1067 and marches forward over the arguments.
1068 outbeg does similarly in the output. */
1069 for (i = 0; i < args; i++)
1075 r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1078 /* Return immediately. We probably have only parsed a
1079 partial expression, so we don't want to try to reverse
1080 the other operands. */
1089 /* Read an expression from the string *STRINGPTR points to,
1090 parse it, and return a pointer to a struct expression that we malloc.
1091 Use block BLOCK as the lexical context for variable names;
1092 if BLOCK is zero, use the block of the selected stack frame.
1093 Meanwhile, advance *STRINGPTR to point after the expression,
1094 at the first nonwhite character that is not part of the expression
1095 (possibly a null character).
1097 If COMMA is nonzero, stop if a comma is reached. */
1100 parse_exp_1 (char **stringptr, CORE_ADDR pc, struct block *block, int comma)
1102 return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL);
1105 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1106 no value is expected from the expression.
1107 OUT_SUBEXP is set when attempting to complete a field name; in this
1108 case it is set to the index of the subexpression on the
1109 left-hand-side of the struct op. If not doing such completion, it
1110 is left untouched. */
1112 static struct expression *
1113 parse_exp_in_context (char **stringptr, CORE_ADDR pc, struct block *block,
1114 int comma, int void_context_p, int *out_subexp)
1116 volatile struct gdb_exception except;
1117 struct cleanup *old_chain;
1118 const struct language_defn *lang = NULL;
1121 lexptr = *stringptr;
1125 type_stack.depth = 0;
1126 expout_last_struct = -1;
1128 comma_terminates = comma;
1130 if (lexptr == 0 || *lexptr == 0)
1131 error_no_arg (_("expression to compute"));
1133 old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1136 expression_context_block = block;
1138 /* If no context specified, try using the current frame, if any. */
1139 if (!expression_context_block)
1140 expression_context_block = get_selected_block (&expression_context_pc);
1142 expression_context_pc = BLOCK_START (expression_context_block);
1144 expression_context_pc = pc;
1146 /* Fall back to using the current source static context, if any. */
1148 if (!expression_context_block)
1150 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1152 expression_context_block
1153 = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1154 if (expression_context_block)
1155 expression_context_pc = BLOCK_START (expression_context_block);
1158 if (language_mode == language_mode_auto && block != NULL)
1160 /* Find the language associated to the given context block.
1161 Default to the current language if it can not be determined.
1163 Note that using the language corresponding to the current frame
1164 can sometimes give unexpected results. For instance, this
1165 routine is often called several times during the inferior
1166 startup phase to re-parse breakpoint expressions after
1167 a new shared library has been loaded. The language associated
1168 to the current frame at this moment is not relevant for
1169 the breakpoint. Using it would therefore be silly, so it seems
1170 better to rely on the current language rather than relying on
1171 the current frame language to parse the expression. That's why
1172 we do the following language detection only if the context block
1173 has been specifically provided. */
1174 struct symbol *func = block_linkage_function (block);
1177 lang = language_def (SYMBOL_LANGUAGE (func));
1178 if (lang == NULL || lang->la_language == language_unknown)
1179 lang = current_language;
1182 lang = current_language;
1184 initialize_expout (10, lang, get_current_arch ());
1186 TRY_CATCH (except, RETURN_MASK_ALL)
1188 if (lang->la_parser ())
1189 lang->la_error (NULL);
1191 if (except.reason < 0)
1193 if (! in_parse_field)
1196 throw_exception (except);
1200 discard_cleanups (old_chain);
1202 reallocate_expout ();
1204 /* Convert expression from postfix form as generated by yacc
1205 parser, to a prefix form. */
1207 if (expressiondebug)
1208 dump_raw_expression (expout, gdb_stdlog,
1209 "before conversion to prefix form");
1211 subexp = prefixify_expression (expout);
1213 *out_subexp = subexp;
1215 lang->la_post_parser (&expout, void_context_p);
1217 if (expressiondebug)
1218 dump_prefix_expression (expout, gdb_stdlog);
1220 *stringptr = lexptr;
1224 /* Parse STRING as an expression, and complain if this fails
1225 to use up all of the contents of STRING. */
1228 parse_expression (char *string)
1230 struct expression *exp;
1232 exp = parse_exp_1 (&string, 0, 0, 0);
1234 error (_("Junk after end of expression."));
1238 /* Parse STRING as an expression. If parsing ends in the middle of a
1239 field reference, return the type of the left-hand-side of the
1240 reference; furthermore, if the parsing ends in the field name,
1241 return the field name in *NAME. If the parsing ends in the middle
1242 of a field reference, but the reference is somehow invalid, throw
1243 an exception. In all other cases, return NULL. Returned non-NULL
1244 *NAME must be freed by the caller. */
1247 parse_field_expression (char *string, char **name)
1249 struct expression *exp = NULL;
1252 volatile struct gdb_exception except;
1254 TRY_CATCH (except, RETURN_MASK_ERROR)
1257 exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp);
1260 if (except.reason < 0 || ! exp)
1262 if (expout_last_struct == -1)
1268 *name = extract_field_op (exp, &subexp);
1275 /* This might throw an exception. If so, we want to let it
1277 val = evaluate_subexpression_type (exp, subexp);
1278 /* (*NAME) is a part of the EXP memory block freed below. */
1279 *name = xstrdup (*name);
1282 return value_type (val);
1285 /* A post-parser that does nothing. */
1288 null_post_parser (struct expression **exp, int void_context_p)
1292 /* Parse floating point value P of length LEN.
1293 Return 0 (false) if invalid, 1 (true) if valid.
1294 The successfully parsed number is stored in D.
1295 *SUFFIX points to the suffix of the number in P.
1297 NOTE: This accepts the floating point syntax that sscanf accepts. */
1300 parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
1305 copy = xmalloc (len + 1);
1306 memcpy (copy, p, len);
1309 num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
1312 /* The sscanf man page suggests not making any assumptions on the effect
1313 of %n on the result, so we don't.
1314 That is why we simply test num == 0. */
1322 /* Parse floating point value P of length LEN, using the C syntax for floats.
1323 Return 0 (false) if invalid, 1 (true) if valid.
1324 The successfully parsed number is stored in *D.
1325 Its type is taken from builtin_type (gdbarch) and is stored in *T. */
1328 parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
1329 DOUBLEST *d, struct type **t)
1333 const struct builtin_type *builtin_types = builtin_type (gdbarch);
1335 if (! parse_float (p, len, d, &suffix))
1338 suffix_len = p + len - suffix;
1340 if (suffix_len == 0)
1341 *t = builtin_types->builtin_double;
1342 else if (suffix_len == 1)
1344 /* Handle suffixes: 'f' for float, 'l' for long double. */
1345 if (tolower (*suffix) == 'f')
1346 *t = builtin_types->builtin_float;
1347 else if (tolower (*suffix) == 'l')
1348 *t = builtin_types->builtin_long_double;
1358 /* Stuff for maintaining a stack of types. Currently just used by C, but
1359 probably useful for any language which declares its types "backwards". */
1361 /* Ensure that there are HOWMUCH open slots on the type stack STACK. */
1364 type_stack_reserve (struct type_stack *stack, int howmuch)
1366 if (stack->depth + howmuch >= stack->size)
1369 if (stack->size < howmuch)
1370 stack->size = howmuch;
1371 stack->elements = xrealloc (stack->elements,
1372 stack->size * sizeof (union type_stack_elt));
1376 /* Ensure that there is a single open slot in the global type stack. */
1379 check_type_stack_depth (void)
1381 type_stack_reserve (&type_stack, 1);
1384 /* A helper function for insert_type and insert_type_address_space.
1385 This does work of expanding the type stack and inserting the new
1386 element, ELEMENT, into the stack at location SLOT. */
1389 insert_into_type_stack (int slot, union type_stack_elt element)
1391 check_type_stack_depth ();
1393 if (slot < type_stack.depth)
1394 memmove (&type_stack.elements[slot + 1], &type_stack.elements[slot],
1395 (type_stack.depth - slot) * sizeof (union type_stack_elt));
1396 type_stack.elements[slot] = element;
1400 /* Insert a new type, TP, at the bottom of the type stack. If TP is
1401 tp_pointer or tp_reference, it is inserted at the bottom. If TP is
1402 a qualifier, it is inserted at slot 1 (just above a previous
1403 tp_pointer) if there is anything on the stack, or simply pushed if
1404 the stack is empty. Other values for TP are invalid. */
1407 insert_type (enum type_pieces tp)
1409 union type_stack_elt element;
1412 gdb_assert (tp == tp_pointer || tp == tp_reference
1413 || tp == tp_const || tp == tp_volatile);
1415 /* If there is anything on the stack (we know it will be a
1416 tp_pointer), insert the qualifier above it. Otherwise, simply
1417 push this on the top of the stack. */
1418 if (type_stack.depth && (tp == tp_const || tp == tp_volatile))
1424 insert_into_type_stack (slot, element);
1428 push_type (enum type_pieces tp)
1430 check_type_stack_depth ();
1431 type_stack.elements[type_stack.depth++].piece = tp;
1435 push_type_int (int n)
1437 check_type_stack_depth ();
1438 type_stack.elements[type_stack.depth++].int_val = n;
1441 /* Insert a tp_space_identifier and the corresponding address space
1442 value into the stack. STRING is the name of an address space, as
1443 recognized by address_space_name_to_int. If the stack is empty,
1444 the new elements are simply pushed. If the stack is not empty,
1445 this function assumes that the first item on the stack is a
1446 tp_pointer, and the new values are inserted above the first
1450 insert_type_address_space (char *string)
1452 union type_stack_elt element;
1455 /* If there is anything on the stack (we know it will be a
1456 tp_pointer), insert the address space qualifier above it.
1457 Otherwise, simply push this on the top of the stack. */
1458 if (type_stack.depth)
1463 element.piece = tp_space_identifier;
1464 insert_into_type_stack (slot, element);
1465 element.int_val = address_space_name_to_int (parse_gdbarch, string);
1466 insert_into_type_stack (slot, element);
1472 if (type_stack.depth)
1473 return type_stack.elements[--type_stack.depth].piece;
1480 if (type_stack.depth)
1481 return type_stack.elements[--type_stack.depth].int_val;
1482 /* "Can't happen". */
1486 /* Pop a type_stack element from the global type stack. */
1488 static struct type_stack *
1489 pop_type_stack (void)
1491 gdb_assert (type_stack.depth);
1492 return type_stack.elements[--type_stack.depth].stack_val;
1495 /* Append the elements of the type stack FROM to the type stack TO.
1496 Always returns TO. */
1499 append_type_stack (struct type_stack *to, struct type_stack *from)
1501 type_stack_reserve (to, from->depth);
1503 memcpy (&to->elements[to->depth], &from->elements[0],
1504 from->depth * sizeof (union type_stack_elt));
1505 to->depth += from->depth;
1510 /* Push the type stack STACK as an element on the global type stack. */
1513 push_type_stack (struct type_stack *stack)
1515 check_type_stack_depth ();
1516 type_stack.elements[type_stack.depth++].stack_val = stack;
1517 push_type (tp_type_stack);
1520 /* Copy the global type stack into a newly allocated type stack and
1521 return it. The global stack is cleared. The returned type stack
1522 must be freed with type_stack_cleanup. */
1525 get_type_stack (void)
1527 struct type_stack *result = XNEW (struct type_stack);
1529 *result = type_stack;
1530 type_stack.depth = 0;
1531 type_stack.size = 0;
1532 type_stack.elements = NULL;
1537 /* A cleanup function that destroys a single type stack. */
1540 type_stack_cleanup (void *arg)
1542 struct type_stack *stack = arg;
1544 xfree (stack->elements);
1548 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1549 as modified by all the stuff on the stack. */
1551 follow_types (struct type *follow_type)
1555 int make_volatile = 0;
1556 int make_addr_space = 0;
1560 switch (pop_type ())
1565 follow_type = make_cv_type (make_const,
1566 TYPE_VOLATILE (follow_type),
1569 follow_type = make_cv_type (TYPE_CONST (follow_type),
1572 if (make_addr_space)
1573 follow_type = make_type_with_address_space (follow_type,
1575 make_const = make_volatile = 0;
1576 make_addr_space = 0;
1584 case tp_space_identifier:
1585 make_addr_space = pop_type_int ();
1588 follow_type = lookup_pointer_type (follow_type);
1590 follow_type = make_cv_type (make_const,
1591 TYPE_VOLATILE (follow_type),
1594 follow_type = make_cv_type (TYPE_CONST (follow_type),
1597 if (make_addr_space)
1598 follow_type = make_type_with_address_space (follow_type,
1600 make_const = make_volatile = 0;
1601 make_addr_space = 0;
1604 follow_type = lookup_reference_type (follow_type);
1606 follow_type = make_cv_type (make_const,
1607 TYPE_VOLATILE (follow_type),
1610 follow_type = make_cv_type (TYPE_CONST (follow_type),
1613 if (make_addr_space)
1614 follow_type = make_type_with_address_space (follow_type,
1616 make_const = make_volatile = 0;
1617 make_addr_space = 0;
1620 array_size = pop_type_int ();
1621 /* FIXME-type-allocation: need a way to free this type when we are
1624 lookup_array_range_type (follow_type,
1625 0, array_size >= 0 ? array_size - 1 : 0);
1627 TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type) = 1;
1630 /* FIXME-type-allocation: need a way to free this type when we are
1632 follow_type = lookup_function_type (follow_type);
1637 struct type_stack *stack = pop_type_stack ();
1638 /* Sort of ugly, but not really much worse than the
1640 struct type_stack save = type_stack;
1642 type_stack = *stack;
1643 follow_type = follow_types (follow_type);
1644 gdb_assert (type_stack.depth == 0);
1650 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1655 /* This function avoids direct calls to fprintf
1656 in the parser generated debug code. */
1658 parser_fprintf (FILE *x, const char *y, ...)
1664 vfprintf_unfiltered (gdb_stderr, y, args);
1667 fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1668 vfprintf_unfiltered (gdb_stderr, y, args);
1673 /* Implementation of the exp_descriptor method operator_check. */
1676 operator_check_standard (struct expression *exp, int pos,
1677 int (*objfile_func) (struct objfile *objfile,
1681 const union exp_element *const elts = exp->elts;
1682 struct type *type = NULL;
1683 struct objfile *objfile = NULL;
1685 /* Extended operators should have been already handled by exp_descriptor
1686 iterate method of its specific language. */
1687 gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1689 /* Track the callers of write_exp_elt_type for this table. */
1691 switch (elts[pos].opcode)
1701 case UNOP_DYNAMIC_CAST:
1702 case UNOP_REINTERPRET_CAST:
1706 type = elts[pos + 1].type;
1711 LONGEST arg, nargs = elts[pos + 1].longconst;
1713 for (arg = 0; arg < nargs; arg++)
1715 struct type *type = elts[pos + 2 + arg].type;
1716 struct objfile *objfile = TYPE_OBJFILE (type);
1718 if (objfile && (*objfile_func) (objfile, data))
1724 case UNOP_MEMVAL_TLS:
1725 objfile = elts[pos + 1].objfile;
1726 type = elts[pos + 2].type;
1731 const struct block *const block = elts[pos + 1].block;
1732 const struct symbol *const symbol = elts[pos + 2].symbol;
1734 /* Check objfile where the variable itself is placed.
1735 SYMBOL_OBJ_SECTION (symbol) may be NULL. */
1736 if ((*objfile_func) (SYMBOL_SYMTAB (symbol)->objfile, data))
1739 /* Check objfile where is placed the code touching the variable. */
1740 objfile = lookup_objfile_from_block (block);
1742 type = SYMBOL_TYPE (symbol);
1747 /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
1749 if (type && TYPE_OBJFILE (type)
1750 && (*objfile_func) (TYPE_OBJFILE (type), data))
1752 if (objfile && (*objfile_func) (objfile, data))
1758 /* Call OBJFILE_FUNC for any TYPE and OBJFILE found being referenced by EXP.
1759 The functions are never called with NULL OBJFILE. Functions get passed an
1760 arbitrary caller supplied DATA pointer. If any of the functions returns
1761 non-zero value then (any other) non-zero value is immediately returned to
1762 the caller. Otherwise zero is returned after iterating through whole EXP.
1766 exp_iterate (struct expression *exp,
1767 int (*objfile_func) (struct objfile *objfile, void *data),
1772 for (endpos = exp->nelts; endpos > 0; )
1774 int pos, args, oplen = 0;
1776 operator_length (exp, endpos, &oplen, &args);
1777 gdb_assert (oplen > 0);
1779 pos = endpos - oplen;
1780 if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1781 objfile_func, data))
1790 /* Helper for exp_uses_objfile. */
1793 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1795 struct objfile *objfile = objfile_voidp;
1797 if (exp_objfile->separate_debug_objfile_backlink)
1798 exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1800 return exp_objfile == objfile;
1803 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1804 is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
1808 exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1810 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1812 return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1816 _initialize_parse (void)
1818 type_stack.size = 0;
1819 type_stack.depth = 0;
1820 type_stack.elements = NULL;
1822 add_setshow_zinteger_cmd ("expression", class_maintenance,
1824 _("Set expression debugging."),
1825 _("Show expression debugging."),
1826 _("When non-zero, the internal representation "
1827 "of expressions will be printed."),
1829 show_expressiondebug,
1830 &setdebuglist, &showdebuglist);
1831 add_setshow_boolean_cmd ("parser", class_maintenance,
1833 _("Set parser debugging."),
1834 _("Show parser debugging."),
1835 _("When non-zero, expression parser "
1836 "tracing will be enabled."),
1839 &setdebuglist, &showdebuglist);