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
);
914 case UNOP_DYNAMIC_CAST
:
915 case UNOP_REINTERPRET_CAST
:
916 case UNOP_MEMVAL_TYPE
:
928 case UNOP_MEMVAL_TLS
:
946 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
947 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
953 case STRUCTOP_STRUCT
:
960 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
961 NSString constant. */
962 case OP_OBJC_SELECTOR
: /* Objective C "@selector" pseudo-op. */
964 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
965 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
969 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
970 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
971 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
976 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
977 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
983 case TERNOP_SLICE_COUNT
:
988 case MULTI_SUBSCRIPT
:
990 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
993 case BINOP_ASSIGN_MODIFY
:
1006 range_type
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
1009 case LOW_BOUND_DEFAULT
:
1010 case HIGH_BOUND_DEFAULT
:
1013 case BOTH_BOUND_DEFAULT
:
1016 case NONE_BOUND_DEFAULT
:
1024 args
= 1 + (i
< (int) BINOP_END
);
1031 /* Copy the subexpression ending just before index INEND in INEXPR
1032 into OUTEXPR, starting at index OUTBEG.
1033 In the process, convert it from suffix to prefix form.
1034 If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1035 Otherwise, it returns the index of the subexpression which is the
1036 left-hand-side of the expression at EXPOUT_LAST_STRUCT. */
1039 prefixify_subexp (struct expression
*inexpr
,
1040 struct expression
*outexpr
, int inend
, int outbeg
)
1048 operator_length (inexpr
, inend
, &oplen
, &args
);
1050 /* Copy the final operator itself, from the end of the input
1051 to the beginning of the output. */
1053 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
1054 EXP_ELEM_TO_BYTES (oplen
));
1057 if (expout_last_struct
== inend
)
1058 result
= outbeg
- oplen
;
1060 /* Find the lengths of the arg subexpressions. */
1061 arglens
= (int *) alloca (args
* sizeof (int));
1062 for (i
= args
- 1; i
>= 0; i
--)
1064 oplen
= length_of_subexp (inexpr
, inend
);
1069 /* Now copy each subexpression, preserving the order of
1070 the subexpressions, but prefixifying each one.
1071 In this loop, inend starts at the beginning of
1072 the expression this level is working on
1073 and marches forward over the arguments.
1074 outbeg does similarly in the output. */
1075 for (i
= 0; i
< args
; i
++)
1081 r
= prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
1084 /* Return immediately. We probably have only parsed a
1085 partial expression, so we don't want to try to reverse
1086 the other operands. */
1095 /* Read an expression from the string *STRINGPTR points to,
1096 parse it, and return a pointer to a struct expression that we malloc.
1097 Use block BLOCK as the lexical context for variable names;
1098 if BLOCK is zero, use the block of the selected stack frame.
1099 Meanwhile, advance *STRINGPTR to point after the expression,
1100 at the first nonwhite character that is not part of the expression
1101 (possibly a null character).
1103 If COMMA is nonzero, stop if a comma is reached. */
1106 parse_exp_1 (char **stringptr
, CORE_ADDR pc
, struct block
*block
, int comma
)
1108 return parse_exp_in_context (stringptr
, pc
, block
, comma
, 0, NULL
);
1111 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1112 no value is expected from the expression.
1113 OUT_SUBEXP is set when attempting to complete a field name; in this
1114 case it is set to the index of the subexpression on the
1115 left-hand-side of the struct op. If not doing such completion, it
1116 is left untouched. */
1118 static struct expression
*
1119 parse_exp_in_context (char **stringptr
, CORE_ADDR pc
, struct block
*block
,
1120 int comma
, int void_context_p
, int *out_subexp
)
1122 volatile struct gdb_exception except
;
1123 struct cleanup
*old_chain
;
1124 const struct language_defn
*lang
= NULL
;
1127 lexptr
= *stringptr
;
1131 type_stack
.depth
= 0;
1132 expout_last_struct
= -1;
1134 comma_terminates
= comma
;
1136 if (lexptr
== 0 || *lexptr
== 0)
1137 error_no_arg (_("expression to compute"));
1139 old_chain
= make_cleanup (free_funcalls
, 0 /*ignore*/);
1142 expression_context_block
= block
;
1144 /* If no context specified, try using the current frame, if any. */
1145 if (!expression_context_block
)
1146 expression_context_block
= get_selected_block (&expression_context_pc
);
1148 expression_context_pc
= BLOCK_START (expression_context_block
);
1150 expression_context_pc
= pc
;
1152 /* Fall back to using the current source static context, if any. */
1154 if (!expression_context_block
)
1156 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
1158 expression_context_block
1159 = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal
.symtab
), STATIC_BLOCK
);
1160 if (expression_context_block
)
1161 expression_context_pc
= BLOCK_START (expression_context_block
);
1164 if (language_mode
== language_mode_auto
&& block
!= NULL
)
1166 /* Find the language associated to the given context block.
1167 Default to the current language if it can not be determined.
1169 Note that using the language corresponding to the current frame
1170 can sometimes give unexpected results. For instance, this
1171 routine is often called several times during the inferior
1172 startup phase to re-parse breakpoint expressions after
1173 a new shared library has been loaded. The language associated
1174 to the current frame at this moment is not relevant for
1175 the breakpoint. Using it would therefore be silly, so it seems
1176 better to rely on the current language rather than relying on
1177 the current frame language to parse the expression. That's why
1178 we do the following language detection only if the context block
1179 has been specifically provided. */
1180 struct symbol
*func
= block_linkage_function (block
);
1183 lang
= language_def (SYMBOL_LANGUAGE (func
));
1184 if (lang
== NULL
|| lang
->la_language
== language_unknown
)
1185 lang
= current_language
;
1188 lang
= current_language
;
1190 initialize_expout (10, lang
, get_current_arch ());
1192 TRY_CATCH (except
, RETURN_MASK_ALL
)
1194 if (lang
->la_parser ())
1195 lang
->la_error (NULL
);
1197 if (except
.reason
< 0)
1199 if (! in_parse_field
)
1202 throw_exception (except
);
1206 discard_cleanups (old_chain
);
1208 reallocate_expout ();
1210 /* Convert expression from postfix form as generated by yacc
1211 parser, to a prefix form. */
1213 if (expressiondebug
)
1214 dump_raw_expression (expout
, gdb_stdlog
,
1215 "before conversion to prefix form");
1217 subexp
= prefixify_expression (expout
);
1219 *out_subexp
= subexp
;
1221 lang
->la_post_parser (&expout
, void_context_p
);
1223 if (expressiondebug
)
1224 dump_prefix_expression (expout
, gdb_stdlog
);
1226 *stringptr
= lexptr
;
1230 /* Parse STRING as an expression, and complain if this fails
1231 to use up all of the contents of STRING. */
1234 parse_expression (char *string
)
1236 struct expression
*exp
;
1238 exp
= parse_exp_1 (&string
, 0, 0, 0);
1240 error (_("Junk after end of expression."));
1244 /* Parse STRING as an expression. If parsing ends in the middle of a
1245 field reference, return the type of the left-hand-side of the
1246 reference; furthermore, if the parsing ends in the field name,
1247 return the field name in *NAME. If the parsing ends in the middle
1248 of a field reference, but the reference is somehow invalid, throw
1249 an exception. In all other cases, return NULL. Returned non-NULL
1250 *NAME must be freed by the caller. */
1253 parse_field_expression (char *string
, char **name
)
1255 struct expression
*exp
= NULL
;
1258 volatile struct gdb_exception except
;
1260 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1263 exp
= parse_exp_in_context (&string
, 0, 0, 0, 0, &subexp
);
1266 if (except
.reason
< 0 || ! exp
)
1268 if (expout_last_struct
== -1)
1274 *name
= extract_field_op (exp
, &subexp
);
1281 /* This might throw an exception. If so, we want to let it
1283 val
= evaluate_subexpression_type (exp
, subexp
);
1284 /* (*NAME) is a part of the EXP memory block freed below. */
1285 *name
= xstrdup (*name
);
1288 return value_type (val
);
1291 /* A post-parser that does nothing. */
1294 null_post_parser (struct expression
**exp
, int void_context_p
)
1298 /* Parse floating point value P of length LEN.
1299 Return 0 (false) if invalid, 1 (true) if valid.
1300 The successfully parsed number is stored in D.
1301 *SUFFIX points to the suffix of the number in P.
1303 NOTE: This accepts the floating point syntax that sscanf accepts. */
1306 parse_float (const char *p
, int len
, DOUBLEST
*d
, const char **suffix
)
1311 copy
= xmalloc (len
+ 1);
1312 memcpy (copy
, p
, len
);
1315 num
= sscanf (copy
, "%" DOUBLEST_SCAN_FORMAT
"%n", d
, &n
);
1318 /* The sscanf man page suggests not making any assumptions on the effect
1319 of %n on the result, so we don't.
1320 That is why we simply test num == 0. */
1328 /* Parse floating point value P of length LEN, using the C syntax for floats.
1329 Return 0 (false) if invalid, 1 (true) if valid.
1330 The successfully parsed number is stored in *D.
1331 Its type is taken from builtin_type (gdbarch) and is stored in *T. */
1334 parse_c_float (struct gdbarch
*gdbarch
, const char *p
, int len
,
1335 DOUBLEST
*d
, struct type
**t
)
1339 const struct builtin_type
*builtin_types
= builtin_type (gdbarch
);
1341 if (! parse_float (p
, len
, d
, &suffix
))
1344 suffix_len
= p
+ len
- suffix
;
1346 if (suffix_len
== 0)
1347 *t
= builtin_types
->builtin_double
;
1348 else if (suffix_len
== 1)
1350 /* Handle suffixes: 'f' for float, 'l' for long double. */
1351 if (tolower (*suffix
) == 'f')
1352 *t
= builtin_types
->builtin_float
;
1353 else if (tolower (*suffix
) == 'l')
1354 *t
= builtin_types
->builtin_long_double
;
1364 /* Stuff for maintaining a stack of types. Currently just used by C, but
1365 probably useful for any language which declares its types "backwards". */
1367 /* Ensure that there are HOWMUCH open slots on the type stack STACK. */
1370 type_stack_reserve (struct type_stack
*stack
, int howmuch
)
1372 if (stack
->depth
+ howmuch
>= stack
->size
)
1375 if (stack
->size
< howmuch
)
1376 stack
->size
= howmuch
;
1377 stack
->elements
= xrealloc (stack
->elements
,
1378 stack
->size
* sizeof (union type_stack_elt
));
1382 /* Ensure that there is a single open slot in the global type stack. */
1385 check_type_stack_depth (void)
1387 type_stack_reserve (&type_stack
, 1);
1390 /* A helper function for insert_type and insert_type_address_space.
1391 This does work of expanding the type stack and inserting the new
1392 element, ELEMENT, into the stack at location SLOT. */
1395 insert_into_type_stack (int slot
, union type_stack_elt element
)
1397 check_type_stack_depth ();
1399 if (slot
< type_stack
.depth
)
1400 memmove (&type_stack
.elements
[slot
+ 1], &type_stack
.elements
[slot
],
1401 (type_stack
.depth
- slot
) * sizeof (union type_stack_elt
));
1402 type_stack
.elements
[slot
] = element
;
1406 /* Insert a new type, TP, at the bottom of the type stack. If TP is
1407 tp_pointer or tp_reference, it is inserted at the bottom. If TP is
1408 a qualifier, it is inserted at slot 1 (just above a previous
1409 tp_pointer) if there is anything on the stack, or simply pushed if
1410 the stack is empty. Other values for TP are invalid. */
1413 insert_type (enum type_pieces tp
)
1415 union type_stack_elt element
;
1418 gdb_assert (tp
== tp_pointer
|| tp
== tp_reference
1419 || tp
== tp_const
|| tp
== tp_volatile
);
1421 /* If there is anything on the stack (we know it will be a
1422 tp_pointer), insert the qualifier above it. Otherwise, simply
1423 push this on the top of the stack. */
1424 if (type_stack
.depth
&& (tp
== tp_const
|| tp
== tp_volatile
))
1430 insert_into_type_stack (slot
, element
);
1434 push_type (enum type_pieces tp
)
1436 check_type_stack_depth ();
1437 type_stack
.elements
[type_stack
.depth
++].piece
= tp
;
1441 push_type_int (int n
)
1443 check_type_stack_depth ();
1444 type_stack
.elements
[type_stack
.depth
++].int_val
= n
;
1447 /* Insert a tp_space_identifier and the corresponding address space
1448 value into the stack. STRING is the name of an address space, as
1449 recognized by address_space_name_to_int. If the stack is empty,
1450 the new elements are simply pushed. If the stack is not empty,
1451 this function assumes that the first item on the stack is a
1452 tp_pointer, and the new values are inserted above the first
1456 insert_type_address_space (char *string
)
1458 union type_stack_elt element
;
1461 /* If there is anything on the stack (we know it will be a
1462 tp_pointer), insert the address space qualifier above it.
1463 Otherwise, simply push this on the top of the stack. */
1464 if (type_stack
.depth
)
1469 element
.piece
= tp_space_identifier
;
1470 insert_into_type_stack (slot
, element
);
1471 element
.int_val
= address_space_name_to_int (parse_gdbarch
, string
);
1472 insert_into_type_stack (slot
, element
);
1478 if (type_stack
.depth
)
1479 return type_stack
.elements
[--type_stack
.depth
].piece
;
1486 if (type_stack
.depth
)
1487 return type_stack
.elements
[--type_stack
.depth
].int_val
;
1488 /* "Can't happen". */
1492 /* Pop a type list element from the global type stack. */
1494 static VEC (type_ptr
) *
1497 gdb_assert (type_stack
.depth
);
1498 return type_stack
.elements
[--type_stack
.depth
].typelist_val
;
1501 /* Pop a type_stack element from the global type stack. */
1503 static struct type_stack
*
1504 pop_type_stack (void)
1506 gdb_assert (type_stack
.depth
);
1507 return type_stack
.elements
[--type_stack
.depth
].stack_val
;
1510 /* Append the elements of the type stack FROM to the type stack TO.
1511 Always returns TO. */
1514 append_type_stack (struct type_stack
*to
, struct type_stack
*from
)
1516 type_stack_reserve (to
, from
->depth
);
1518 memcpy (&to
->elements
[to
->depth
], &from
->elements
[0],
1519 from
->depth
* sizeof (union type_stack_elt
));
1520 to
->depth
+= from
->depth
;
1525 /* Push the type stack STACK as an element on the global type stack. */
1528 push_type_stack (struct type_stack
*stack
)
1530 check_type_stack_depth ();
1531 type_stack
.elements
[type_stack
.depth
++].stack_val
= stack
;
1532 push_type (tp_type_stack
);
1535 /* Copy the global type stack into a newly allocated type stack and
1536 return it. The global stack is cleared. The returned type stack
1537 must be freed with type_stack_cleanup. */
1540 get_type_stack (void)
1542 struct type_stack
*result
= XNEW (struct type_stack
);
1544 *result
= type_stack
;
1545 type_stack
.depth
= 0;
1546 type_stack
.size
= 0;
1547 type_stack
.elements
= NULL
;
1552 /* A cleanup function that destroys a single type stack. */
1555 type_stack_cleanup (void *arg
)
1557 struct type_stack
*stack
= arg
;
1559 xfree (stack
->elements
);
1563 /* Push a function type with arguments onto the global type stack.
1564 LIST holds the argument types. If the final item in LIST is NULL,
1565 then the function will be varargs. */
1568 push_typelist (VEC (type_ptr
) *list
)
1570 check_type_stack_depth ();
1571 type_stack
.elements
[type_stack
.depth
++].typelist_val
= list
;
1572 push_type (tp_function_with_arguments
);
1575 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1576 as modified by all the stuff on the stack. */
1578 follow_types (struct type
*follow_type
)
1582 int make_volatile
= 0;
1583 int make_addr_space
= 0;
1587 switch (pop_type ())
1592 follow_type
= make_cv_type (make_const
,
1593 TYPE_VOLATILE (follow_type
),
1596 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1599 if (make_addr_space
)
1600 follow_type
= make_type_with_address_space (follow_type
,
1602 make_const
= make_volatile
= 0;
1603 make_addr_space
= 0;
1611 case tp_space_identifier
:
1612 make_addr_space
= pop_type_int ();
1615 follow_type
= lookup_pointer_type (follow_type
);
1617 follow_type
= make_cv_type (make_const
,
1618 TYPE_VOLATILE (follow_type
),
1621 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1624 if (make_addr_space
)
1625 follow_type
= make_type_with_address_space (follow_type
,
1627 make_const
= make_volatile
= 0;
1628 make_addr_space
= 0;
1631 follow_type
= lookup_reference_type (follow_type
);
1633 follow_type
= make_cv_type (make_const
,
1634 TYPE_VOLATILE (follow_type
),
1637 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1640 if (make_addr_space
)
1641 follow_type
= make_type_with_address_space (follow_type
,
1643 make_const
= make_volatile
= 0;
1644 make_addr_space
= 0;
1647 array_size
= pop_type_int ();
1648 /* FIXME-type-allocation: need a way to free this type when we are
1651 lookup_array_range_type (follow_type
,
1652 0, array_size
>= 0 ? array_size
- 1 : 0);
1654 TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type
) = 1;
1657 /* FIXME-type-allocation: need a way to free this type when we are
1659 follow_type
= lookup_function_type (follow_type
);
1662 case tp_function_with_arguments
:
1664 VEC (type_ptr
) *args
= pop_typelist ();
1667 = lookup_function_type_with_arguments (follow_type
,
1668 VEC_length (type_ptr
, args
),
1669 VEC_address (type_ptr
,
1671 VEC_free (type_ptr
, args
);
1677 struct type_stack
*stack
= pop_type_stack ();
1678 /* Sort of ugly, but not really much worse than the
1680 struct type_stack save
= type_stack
;
1682 type_stack
= *stack
;
1683 follow_type
= follow_types (follow_type
);
1684 gdb_assert (type_stack
.depth
== 0);
1690 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1695 /* This function avoids direct calls to fprintf
1696 in the parser generated debug code. */
1698 parser_fprintf (FILE *x
, const char *y
, ...)
1704 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1707 fprintf_unfiltered (gdb_stderr
, " Unknown FILE used.\n");
1708 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1713 /* Implementation of the exp_descriptor method operator_check. */
1716 operator_check_standard (struct expression
*exp
, int pos
,
1717 int (*objfile_func
) (struct objfile
*objfile
,
1721 const union exp_element
*const elts
= exp
->elts
;
1722 struct type
*type
= NULL
;
1723 struct objfile
*objfile
= NULL
;
1725 /* Extended operators should have been already handled by exp_descriptor
1726 iterate method of its specific language. */
1727 gdb_assert (elts
[pos
].opcode
< OP_EXTENDED0
);
1729 /* Track the callers of write_exp_elt_type for this table. */
1731 switch (elts
[pos
].opcode
)
1744 type
= elts
[pos
+ 1].type
;
1749 LONGEST arg
, nargs
= elts
[pos
+ 1].longconst
;
1751 for (arg
= 0; arg
< nargs
; arg
++)
1753 struct type
*type
= elts
[pos
+ 2 + arg
].type
;
1754 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1756 if (objfile
&& (*objfile_func
) (objfile
, data
))
1762 case UNOP_MEMVAL_TLS
:
1763 objfile
= elts
[pos
+ 1].objfile
;
1764 type
= elts
[pos
+ 2].type
;
1769 const struct block
*const block
= elts
[pos
+ 1].block
;
1770 const struct symbol
*const symbol
= elts
[pos
+ 2].symbol
;
1772 /* Check objfile where the variable itself is placed.
1773 SYMBOL_OBJ_SECTION (symbol) may be NULL. */
1774 if ((*objfile_func
) (SYMBOL_SYMTAB (symbol
)->objfile
, data
))
1777 /* Check objfile where is placed the code touching the variable. */
1778 objfile
= lookup_objfile_from_block (block
);
1780 type
= SYMBOL_TYPE (symbol
);
1785 /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
1787 if (type
&& TYPE_OBJFILE (type
)
1788 && (*objfile_func
) (TYPE_OBJFILE (type
), data
))
1790 if (objfile
&& (*objfile_func
) (objfile
, data
))
1796 /* Call OBJFILE_FUNC for any TYPE and OBJFILE found being referenced by EXP.
1797 The functions are never called with NULL OBJFILE. Functions get passed an
1798 arbitrary caller supplied DATA pointer. If any of the functions returns
1799 non-zero value then (any other) non-zero value is immediately returned to
1800 the caller. Otherwise zero is returned after iterating through whole EXP.
1804 exp_iterate (struct expression
*exp
,
1805 int (*objfile_func
) (struct objfile
*objfile
, void *data
),
1810 for (endpos
= exp
->nelts
; endpos
> 0; )
1812 int pos
, args
, oplen
= 0;
1814 operator_length (exp
, endpos
, &oplen
, &args
);
1815 gdb_assert (oplen
> 0);
1817 pos
= endpos
- oplen
;
1818 if (exp
->language_defn
->la_exp_desc
->operator_check (exp
, pos
,
1819 objfile_func
, data
))
1828 /* Helper for exp_uses_objfile. */
1831 exp_uses_objfile_iter (struct objfile
*exp_objfile
, void *objfile_voidp
)
1833 struct objfile
*objfile
= objfile_voidp
;
1835 if (exp_objfile
->separate_debug_objfile_backlink
)
1836 exp_objfile
= exp_objfile
->separate_debug_objfile_backlink
;
1838 return exp_objfile
== objfile
;
1841 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1842 is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
1846 exp_uses_objfile (struct expression
*exp
, struct objfile
*objfile
)
1848 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
1850 return exp_iterate (exp
, exp_uses_objfile_iter
, objfile
);
1854 _initialize_parse (void)
1856 type_stack
.size
= 0;
1857 type_stack
.depth
= 0;
1858 type_stack
.elements
= NULL
;
1860 add_setshow_zinteger_cmd ("expression", class_maintenance
,
1862 _("Set expression debugging."),
1863 _("Show expression debugging."),
1864 _("When non-zero, the internal representation "
1865 "of expressions will be printed."),
1867 show_expressiondebug
,
1868 &setdebuglist
, &showdebuglist
);
1869 add_setshow_boolean_cmd ("parser", class_maintenance
,
1871 _("Set parser debugging."),
1872 _("Show parser debugging."),
1873 _("When non-zero, expression parser "
1874 "tracing will be enabled."),
1877 &setdebuglist
, &showdebuglist
);