1 /* Parse expressions for GDB.
3 Copyright (C) 1986-2018 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 const struct block
*expression_context_block
;
70 CORE_ADDR expression_context_pc
;
71 innermost_block_tracker innermost_block
;
73 static struct type_stack type_stack
;
75 const char *prev_lexptr
;
79 /* True if parsing an expression to attempt completion. */
82 /* The index of the last struct expression directly before a '.' or
83 '->'. This is set when parsing and is only used when completing a
84 field name. It is -1 if no dereference operation was found. */
85 static int expout_last_struct
= -1;
87 /* If we are completing a tagged type name, this will be nonzero. */
88 static enum type_code expout_tag_completion_type
= TYPE_CODE_UNDEF
;
90 /* The token for tagged type name completion. */
91 static char *expout_completion_name
;
94 static unsigned int expressiondebug
= 0;
96 show_expressiondebug (struct ui_file
*file
, int from_tty
,
97 struct cmd_list_element
*c
, const char *value
)
99 fprintf_filtered (file
, _("Expression debugging is %s.\n"), value
);
103 /* Non-zero if an expression parser should set yydebug. */
107 show_parserdebug (struct ui_file
*file
, int from_tty
,
108 struct cmd_list_element
*c
, const char *value
)
110 fprintf_filtered (file
, _("Parser debugging is %s.\n"), value
);
114 static int prefixify_subexp (struct expression
*, struct expression
*, int,
117 static expression_up
parse_exp_in_context (const char **, CORE_ADDR
,
118 const struct block
*, int,
120 static expression_up
parse_exp_in_context_1 (const char **, CORE_ADDR
,
121 const struct block
*, int,
124 /* Documented at it's declaration. */
127 innermost_block_tracker::update (const struct block
*b
)
129 if (m_innermost_block
== NULL
|| contained_in (b
, m_innermost_block
))
130 m_innermost_block
= b
;
133 /* Data structure for saving values of arglist_len for function calls whose
134 arguments contain other function calls. */
136 static std::vector
<int> *funcall_chain
;
138 /* Begin counting arguments for a function call,
139 saving the data about any containing call. */
144 funcall_chain
->push_back (arglist_len
);
148 /* Return the number of arguments in a function call just terminated,
149 and restore the data for the containing function call. */
154 int val
= arglist_len
;
155 arglist_len
= funcall_chain
->back ();
156 funcall_chain
->pop_back ();
162 /* See definition in parser-defs.h. */
164 parser_state::parser_state (size_t initial_size
,
165 const struct language_defn
*lang
,
166 struct gdbarch
*gdbarch
)
167 : expout_size (initial_size
),
168 expout (XNEWVAR (expression
,
170 + EXP_ELEM_TO_BYTES (expout_size
)))),
173 expout
->language_defn
= lang
;
174 expout
->gdbarch
= gdbarch
;
178 parser_state::release ()
180 /* Record the actual number of expression elements, and then
181 reallocate the expression memory so that we free up any
184 expout
->nelts
= expout_ptr
;
185 expout
.reset (XRESIZEVAR (expression
, expout
.release (),
187 + EXP_ELEM_TO_BYTES (expout_ptr
))));
189 return std::move (expout
);
192 /* This page contains the functions for adding data to the struct expression
193 being constructed. */
195 /* Add one element to the end of the expression. */
197 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
198 a register through here. */
201 write_exp_elt (struct parser_state
*ps
, const union exp_element
*expelt
)
203 if (ps
->expout_ptr
>= ps
->expout_size
)
205 ps
->expout_size
*= 2;
206 ps
->expout
.reset (XRESIZEVAR (expression
, ps
->expout
.release (),
208 + EXP_ELEM_TO_BYTES (ps
->expout_size
))));
210 ps
->expout
->elts
[ps
->expout_ptr
++] = *expelt
;
214 write_exp_elt_opcode (struct parser_state
*ps
, enum exp_opcode expelt
)
216 union exp_element tmp
;
218 memset (&tmp
, 0, sizeof (union exp_element
));
220 write_exp_elt (ps
, &tmp
);
224 write_exp_elt_sym (struct parser_state
*ps
, struct symbol
*expelt
)
226 union exp_element tmp
;
228 memset (&tmp
, 0, sizeof (union exp_element
));
230 write_exp_elt (ps
, &tmp
);
234 write_exp_elt_msym (struct parser_state
*ps
, minimal_symbol
*expelt
)
236 union exp_element tmp
;
238 memset (&tmp
, 0, sizeof (union exp_element
));
239 tmp
.msymbol
= expelt
;
240 write_exp_elt (ps
, &tmp
);
244 write_exp_elt_block (struct parser_state
*ps
, const struct block
*b
)
246 union exp_element tmp
;
248 memset (&tmp
, 0, sizeof (union exp_element
));
250 write_exp_elt (ps
, &tmp
);
254 write_exp_elt_objfile (struct parser_state
*ps
, struct objfile
*objfile
)
256 union exp_element tmp
;
258 memset (&tmp
, 0, sizeof (union exp_element
));
259 tmp
.objfile
= objfile
;
260 write_exp_elt (ps
, &tmp
);
264 write_exp_elt_longcst (struct parser_state
*ps
, LONGEST expelt
)
266 union exp_element tmp
;
268 memset (&tmp
, 0, sizeof (union exp_element
));
269 tmp
.longconst
= expelt
;
270 write_exp_elt (ps
, &tmp
);
274 write_exp_elt_floatcst (struct parser_state
*ps
, const gdb_byte expelt
[16])
276 union exp_element tmp
;
279 for (index
= 0; index
< 16; index
++)
280 tmp
.floatconst
[index
] = expelt
[index
];
282 write_exp_elt (ps
, &tmp
);
286 write_exp_elt_type (struct parser_state
*ps
, struct type
*expelt
)
288 union exp_element tmp
;
290 memset (&tmp
, 0, sizeof (union exp_element
));
292 write_exp_elt (ps
, &tmp
);
296 write_exp_elt_intern (struct parser_state
*ps
, struct internalvar
*expelt
)
298 union exp_element tmp
;
300 memset (&tmp
, 0, sizeof (union exp_element
));
301 tmp
.internalvar
= expelt
;
302 write_exp_elt (ps
, &tmp
);
305 /* Add a string constant to the end of the expression.
307 String constants are stored by first writing an expression element
308 that contains the length of the string, then stuffing the string
309 constant itself into however many expression elements are needed
310 to hold it, and then writing another expression element that contains
311 the length of the string. I.e. an expression element at each end of
312 the string records the string length, so you can skip over the
313 expression elements containing the actual string bytes from either
314 end of the string. Note that this also allows gdb to handle
315 strings with embedded null bytes, as is required for some languages.
317 Don't be fooled by the fact that the string is null byte terminated,
318 this is strictly for the convenience of debugging gdb itself.
319 Gdb does not depend up the string being null terminated, since the
320 actual length is recorded in expression elements at each end of the
321 string. The null byte is taken into consideration when computing how
322 many expression elements are required to hold the string constant, of
327 write_exp_string (struct parser_state
*ps
, struct stoken str
)
329 int len
= str
.length
;
333 /* Compute the number of expression elements required to hold the string
334 (including a null byte terminator), along with one expression element
335 at each end to record the actual string length (not including the
336 null byte terminator). */
338 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
340 increase_expout_size (ps
, lenelt
);
342 /* Write the leading length expression element (which advances the current
343 expression element index), then write the string constant followed by a
344 terminating null byte, and then write the trailing length expression
347 write_exp_elt_longcst (ps
, (LONGEST
) len
);
348 strdata
= (char *) &ps
->expout
->elts
[ps
->expout_ptr
];
349 memcpy (strdata
, str
.ptr
, len
);
350 *(strdata
+ len
) = '\0';
351 ps
->expout_ptr
+= lenelt
- 2;
352 write_exp_elt_longcst (ps
, (LONGEST
) len
);
355 /* Add a vector of string constants to the end of the expression.
357 This adds an OP_STRING operation, but encodes the contents
358 differently from write_exp_string. The language is expected to
359 handle evaluation of this expression itself.
361 After the usual OP_STRING header, TYPE is written into the
362 expression as a long constant. The interpretation of this field is
363 up to the language evaluator.
365 Next, each string in VEC is written. The length is written as a
366 long constant, followed by the contents of the string. */
369 write_exp_string_vector (struct parser_state
*ps
, int type
,
370 struct stoken_vector
*vec
)
375 /* Compute the size. We compute the size in number of slots to
376 avoid issues with string padding. */
378 for (i
= 0; i
< vec
->len
; ++i
)
380 /* One slot for the length of this element, plus the number of
381 slots needed for this string. */
382 n_slots
+= 1 + BYTES_TO_EXP_ELEM (vec
->tokens
[i
].length
);
385 /* One more slot for the type of the string. */
388 /* Now compute a phony string length. */
389 len
= EXP_ELEM_TO_BYTES (n_slots
) - 1;
392 increase_expout_size (ps
, n_slots
);
394 write_exp_elt_opcode (ps
, OP_STRING
);
395 write_exp_elt_longcst (ps
, len
);
396 write_exp_elt_longcst (ps
, type
);
398 for (i
= 0; i
< vec
->len
; ++i
)
400 write_exp_elt_longcst (ps
, vec
->tokens
[i
].length
);
401 memcpy (&ps
->expout
->elts
[ps
->expout_ptr
], vec
->tokens
[i
].ptr
,
402 vec
->tokens
[i
].length
);
403 ps
->expout_ptr
+= BYTES_TO_EXP_ELEM (vec
->tokens
[i
].length
);
406 write_exp_elt_longcst (ps
, len
);
407 write_exp_elt_opcode (ps
, OP_STRING
);
410 /* Add a bitstring constant to the end of the expression.
412 Bitstring constants are stored by first writing an expression element
413 that contains the length of the bitstring (in bits), then stuffing the
414 bitstring constant itself into however many expression elements are
415 needed to hold it, and then writing another expression element that
416 contains the length of the bitstring. I.e. an expression element at
417 each end of the bitstring records the bitstring length, so you can skip
418 over the expression elements containing the actual bitstring bytes from
419 either end of the bitstring. */
422 write_exp_bitstring (struct parser_state
*ps
, struct stoken str
)
424 int bits
= str
.length
; /* length in bits */
425 int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
429 /* Compute the number of expression elements required to hold the bitstring,
430 along with one expression element at each end to record the actual
431 bitstring length in bits. */
433 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
435 increase_expout_size (ps
, lenelt
);
437 /* Write the leading length expression element (which advances the current
438 expression element index), then write the bitstring constant, and then
439 write the trailing length expression element. */
441 write_exp_elt_longcst (ps
, (LONGEST
) bits
);
442 strdata
= (char *) &ps
->expout
->elts
[ps
->expout_ptr
];
443 memcpy (strdata
, str
.ptr
, len
);
444 ps
->expout_ptr
+= lenelt
- 2;
445 write_exp_elt_longcst (ps
, (LONGEST
) bits
);
448 /* Return the type of MSYMBOL, a minimal symbol of OBJFILE. If
449 ADDRESS_P is not NULL, set it to the MSYMBOL's resolved
453 find_minsym_type_and_address (minimal_symbol
*msymbol
,
454 struct objfile
*objfile
,
455 CORE_ADDR
*address_p
)
457 bound_minimal_symbol bound_msym
= {msymbol
, objfile
};
458 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
459 struct obj_section
*section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
);
460 enum minimal_symbol_type type
= MSYMBOL_TYPE (msymbol
);
463 bool is_tls
= (section
!= NULL
464 && section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
);
466 /* Addresses of TLS symbols are really offsets into a
467 per-objfile/per-thread storage block. */
468 CORE_ADDR addr
= (is_tls
469 ? MSYMBOL_VALUE_RAW_ADDRESS (bound_msym
.minsym
)
470 : BMSYMBOL_VALUE_ADDRESS (bound_msym
));
472 /* The minimal symbol might point to a function descriptor;
473 resolve it to the actual code address instead. */
474 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
, ¤t_target
);
477 struct bound_minimal_symbol ifunc_msym
= lookup_minimal_symbol_by_pc (pc
);
479 /* In this case, assume we have a code symbol instead of
482 if (ifunc_msym
.minsym
!= NULL
483 && MSYMBOL_TYPE (ifunc_msym
.minsym
) == mst_text_gnu_ifunc
484 && BMSYMBOL_VALUE_ADDRESS (ifunc_msym
) == pc
)
486 /* A function descriptor has been resolved but PC is still in the
487 STT_GNU_IFUNC resolver body (such as because inferior does not
488 run to be able to call it). */
490 type
= mst_text_gnu_ifunc
;
498 if (overlay_debugging
)
499 addr
= symbol_overlayed_address (addr
, section
);
503 /* Skip translation if caller does not need the address. */
504 if (address_p
!= NULL
)
505 *address_p
= target_translate_tls_address (objfile
, addr
);
506 return objfile_type (objfile
)->nodebug_tls_symbol
;
509 if (address_p
!= NULL
)
516 case mst_solib_trampoline
:
517 return objfile_type (objfile
)->nodebug_text_symbol
;
519 case mst_text_gnu_ifunc
:
520 return objfile_type (objfile
)->nodebug_text_gnu_ifunc_symbol
;
526 return objfile_type (objfile
)->nodebug_data_symbol
;
528 case mst_slot_got_plt
:
529 return objfile_type (objfile
)->nodebug_got_plt_symbol
;
532 return objfile_type (objfile
)->nodebug_unknown_symbol
;
536 /* Add the appropriate elements for a minimal symbol to the end of
540 write_exp_msymbol (struct parser_state
*ps
,
541 struct bound_minimal_symbol bound_msym
)
543 write_exp_elt_opcode (ps
, OP_VAR_MSYM_VALUE
);
544 write_exp_elt_objfile (ps
, bound_msym
.objfile
);
545 write_exp_elt_msym (ps
, bound_msym
.minsym
);
546 write_exp_elt_opcode (ps
, OP_VAR_MSYM_VALUE
);
549 /* Mark the current index as the starting location of a structure
550 expression. This is used when completing on field names. */
553 mark_struct_expression (struct parser_state
*ps
)
555 gdb_assert (parse_completion
556 && expout_tag_completion_type
== TYPE_CODE_UNDEF
);
557 expout_last_struct
= ps
->expout_ptr
;
560 /* Indicate that the current parser invocation is completing a tag.
561 TAG is the type code of the tag, and PTR and LENGTH represent the
562 start of the tag name. */
565 mark_completion_tag (enum type_code tag
, const char *ptr
, int length
)
567 gdb_assert (parse_completion
568 && expout_tag_completion_type
== TYPE_CODE_UNDEF
569 && expout_completion_name
== NULL
570 && expout_last_struct
== -1);
571 gdb_assert (tag
== TYPE_CODE_UNION
572 || tag
== TYPE_CODE_STRUCT
573 || tag
== TYPE_CODE_ENUM
);
574 expout_tag_completion_type
= tag
;
575 expout_completion_name
= (char *) xmalloc (length
+ 1);
576 memcpy (expout_completion_name
, ptr
, length
);
577 expout_completion_name
[length
] = '\0';
581 /* Recognize tokens that start with '$'. These include:
583 $regname A native register name or a "standard
586 $variable A convenience variable with a name chosen
589 $digits Value history with index <digits>, starting
590 from the first value which has index 1.
592 $$digits Value history with index <digits> relative
593 to the last value. I.e. $$0 is the last
594 value, $$1 is the one previous to that, $$2
595 is the one previous to $$1, etc.
597 $ | $0 | $$0 The last value in the value history.
599 $$ An abbreviation for the second to the last
600 value in the value history, I.e. $$1 */
603 write_dollar_variable (struct parser_state
*ps
, struct stoken str
)
605 struct block_symbol sym
;
606 struct bound_minimal_symbol msym
;
607 struct internalvar
*isym
= NULL
;
609 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
610 and $$digits (equivalent to $<-digits> if you could type that). */
614 /* Double dollar means negate the number and add -1 as well.
615 Thus $$ alone means -1. */
616 if (str
.length
>= 2 && str
.ptr
[1] == '$')
623 /* Just dollars (one or two). */
627 /* Is the rest of the token digits? */
628 for (; i
< str
.length
; i
++)
629 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
633 i
= atoi (str
.ptr
+ 1 + negate
);
639 /* Handle tokens that refer to machine registers:
640 $ followed by a register name. */
641 i
= user_reg_map_name_to_regnum (parse_gdbarch (ps
),
642 str
.ptr
+ 1, str
.length
- 1);
644 goto handle_register
;
646 /* Any names starting with $ are probably debugger internal variables. */
648 isym
= lookup_only_internalvar (copy_name (str
) + 1);
651 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
652 write_exp_elt_intern (ps
, isym
);
653 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
657 /* On some systems, such as HP-UX and hppa-linux, certain system routines
658 have names beginning with $ or $$. Check for those, first. */
660 sym
= lookup_symbol (copy_name (str
), (struct block
*) NULL
,
664 write_exp_elt_opcode (ps
, OP_VAR_VALUE
);
665 write_exp_elt_block (ps
, sym
.block
);
666 write_exp_elt_sym (ps
, sym
.symbol
);
667 write_exp_elt_opcode (ps
, OP_VAR_VALUE
);
670 msym
= lookup_bound_minimal_symbol (copy_name (str
));
673 write_exp_msymbol (ps
, msym
);
677 /* Any other names are assumed to be debugger internal variables. */
679 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
680 write_exp_elt_intern (ps
, create_internalvar (copy_name (str
) + 1));
681 write_exp_elt_opcode (ps
, OP_INTERNALVAR
);
684 write_exp_elt_opcode (ps
, OP_LAST
);
685 write_exp_elt_longcst (ps
, (LONGEST
) i
);
686 write_exp_elt_opcode (ps
, OP_LAST
);
689 write_exp_elt_opcode (ps
, OP_REGISTER
);
692 write_exp_string (ps
, str
);
693 write_exp_elt_opcode (ps
, OP_REGISTER
);
699 find_template_name_end (const char *p
)
702 int just_seen_right
= 0;
703 int just_seen_colon
= 0;
704 int just_seen_space
= 0;
706 if (!p
|| (*p
!= '<'))
717 /* In future, may want to allow these?? */
720 depth
++; /* start nested template */
721 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
722 return 0; /* but not after : or :: or > or space */
725 if (just_seen_colon
|| just_seen_right
)
726 return 0; /* end a (nested?) template */
727 just_seen_right
= 1; /* but not after : or :: */
728 if (--depth
== 0) /* also disallow >>, insist on > > */
729 return ++p
; /* if outermost ended, return */
732 if (just_seen_space
|| (just_seen_colon
> 1))
733 return 0; /* nested class spec coming up */
734 just_seen_colon
++; /* we allow :: but not :::: */
739 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
740 (*p
>= 'A' && *p
<= 'Z') ||
741 (*p
>= '0' && *p
<= '9') ||
742 (*p
== '_') || (*p
== ',') || /* commas for template args */
743 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
744 (*p
== '(') || (*p
== ')') || /* function types */
745 (*p
== '[') || (*p
== ']'))) /* array types */
759 /* Return a null-terminated temporary copy of the name of a string token.
761 Tokens that refer to names do so with explicit pointer and length,
762 so they can share the storage that lexptr is parsing.
763 When it is necessary to pass a name to a function that expects
764 a null-terminated string, the substring is copied out
765 into a separate block of storage.
767 N.B. A single buffer is reused on each call. */
770 copy_name (struct stoken token
)
772 /* A temporary buffer for identifiers, so we can null-terminate them.
773 We allocate this with xrealloc. parse_exp_1 used to allocate with
774 alloca, using the size of the whole expression as a conservative
775 estimate of the space needed. However, macro expansion can
776 introduce names longer than the original expression; there's no
777 practical way to know beforehand how large that might be. */
778 static char *namecopy
;
779 static size_t namecopy_size
;
781 /* Make sure there's enough space for the token. */
782 if (namecopy_size
< token
.length
+ 1)
784 namecopy_size
= token
.length
+ 1;
785 namecopy
= (char *) xrealloc (namecopy
, token
.length
+ 1);
788 memcpy (namecopy
, token
.ptr
, token
.length
);
789 namecopy
[token
.length
] = 0;
795 /* See comments on parser-defs.h. */
798 prefixify_expression (struct expression
*expr
)
800 int len
= sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
801 struct expression
*temp
;
802 int inpos
= expr
->nelts
, outpos
= 0;
804 temp
= (struct expression
*) alloca (len
);
806 /* Copy the original expression into temp. */
807 memcpy (temp
, expr
, len
);
809 return prefixify_subexp (temp
, expr
, inpos
, outpos
);
812 /* Return the number of exp_elements in the postfix subexpression
813 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
816 length_of_subexp (struct expression
*expr
, int endpos
)
820 operator_length (expr
, endpos
, &oplen
, &args
);
824 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
831 /* Sets *OPLENP to the length of the operator whose (last) index is
832 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
836 operator_length (const struct expression
*expr
, int endpos
, int *oplenp
,
839 expr
->language_defn
->la_exp_desc
->operator_length (expr
, endpos
,
843 /* Default value for operator_length in exp_descriptor vectors. */
846 operator_length_standard (const struct expression
*expr
, int endpos
,
847 int *oplenp
, int *argsp
)
851 enum range_type range_type
;
855 error (_("?error in operator_length_standard"));
857 i
= (int) expr
->elts
[endpos
- 1].opcode
;
863 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
864 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
870 case OP_VAR_MSYM_VALUE
:
874 case OP_FUNC_STATIC_VAR
:
875 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
876 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
884 case OP_VAR_ENTRY_VALUE
:
894 case OP_F77_UNDETERMINED_ARGLIST
:
896 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
900 oplen
= 5 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
904 case OP_OBJC_MSGCALL
: /* Objective C message (method) call. */
906 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
915 case UNOP_DYNAMIC_CAST
:
916 case UNOP_REINTERPRET_CAST
:
917 case UNOP_MEMVAL_TYPE
:
945 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
946 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
951 case STRUCTOP_STRUCT
:
958 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
959 NSString constant. */
960 case OP_OBJC_SELECTOR
: /* Objective C "@selector" pseudo-op. */
962 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
963 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
968 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
969 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
979 case MULTI_SUBSCRIPT
:
981 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
984 case BINOP_ASSIGN_MODIFY
:
996 range_type
= (enum range_type
)
997 longest_to_int (expr
->elts
[endpos
- 2].longconst
);
1001 case LOW_BOUND_DEFAULT
:
1002 case HIGH_BOUND_DEFAULT
:
1005 case BOTH_BOUND_DEFAULT
:
1008 case NONE_BOUND_DEFAULT
:
1016 args
= 1 + (i
< (int) BINOP_END
);
1023 /* Copy the subexpression ending just before index INEND in INEXPR
1024 into OUTEXPR, starting at index OUTBEG.
1025 In the process, convert it from suffix to prefix form.
1026 If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1027 Otherwise, it returns the index of the subexpression which is the
1028 left-hand-side of the expression at EXPOUT_LAST_STRUCT. */
1031 prefixify_subexp (struct expression
*inexpr
,
1032 struct expression
*outexpr
, int inend
, int outbeg
)
1040 operator_length (inexpr
, inend
, &oplen
, &args
);
1042 /* Copy the final operator itself, from the end of the input
1043 to the beginning of the output. */
1045 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
1046 EXP_ELEM_TO_BYTES (oplen
));
1049 if (expout_last_struct
== inend
)
1050 result
= outbeg
- oplen
;
1052 /* Find the lengths of the arg subexpressions. */
1053 arglens
= (int *) alloca (args
* sizeof (int));
1054 for (i
= args
- 1; i
>= 0; i
--)
1056 oplen
= length_of_subexp (inexpr
, inend
);
1061 /* Now copy each subexpression, preserving the order of
1062 the subexpressions, but prefixifying each one.
1063 In this loop, inend starts at the beginning of
1064 the expression this level is working on
1065 and marches forward over the arguments.
1066 outbeg does similarly in the output. */
1067 for (i
= 0; i
< args
; i
++)
1073 r
= prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
1076 /* Return immediately. We probably have only parsed a
1077 partial expression, so we don't want to try to reverse
1078 the other operands. */
1087 /* Read an expression from the string *STRINGPTR points to,
1088 parse it, and return a pointer to a struct expression that we malloc.
1089 Use block BLOCK as the lexical context for variable names;
1090 if BLOCK is zero, use the block of the selected stack frame.
1091 Meanwhile, advance *STRINGPTR to point after the expression,
1092 at the first nonwhite character that is not part of the expression
1093 (possibly a null character).
1095 If COMMA is nonzero, stop if a comma is reached. */
1098 parse_exp_1 (const char **stringptr
, CORE_ADDR pc
, const struct block
*block
,
1101 return parse_exp_in_context (stringptr
, pc
, block
, comma
, 0, NULL
);
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
)
1109 return parse_exp_in_context_1 (stringptr
, pc
, block
, comma
,
1110 void_context_p
, out_subexp
);
1113 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1114 no value is expected from the expression.
1115 OUT_SUBEXP is set when attempting to complete a field name; in this
1116 case it is set to the index of the subexpression on the
1117 left-hand-side of the struct op. If not doing such completion, it
1118 is left untouched. */
1120 static expression_up
1121 parse_exp_in_context_1 (const char **stringptr
, CORE_ADDR pc
,
1122 const struct block
*block
,
1123 int comma
, int void_context_p
, int *out_subexp
)
1125 const struct language_defn
*lang
= NULL
;
1128 lexptr
= *stringptr
;
1132 type_stack
.depth
= 0;
1133 expout_last_struct
= -1;
1134 expout_tag_completion_type
= TYPE_CODE_UNDEF
;
1135 xfree (expout_completion_name
);
1136 expout_completion_name
= NULL
;
1138 comma_terminates
= comma
;
1140 if (lexptr
== 0 || *lexptr
== 0)
1141 error_no_arg (_("expression to compute"));
1143 std::vector
<int> funcalls
;
1144 scoped_restore save_funcall_chain
= make_scoped_restore (&funcall_chain
,
1147 expression_context_block
= block
;
1149 /* If no context specified, try using the current frame, if any. */
1150 if (!expression_context_block
)
1151 expression_context_block
= get_selected_block (&expression_context_pc
);
1153 expression_context_pc
= BLOCK_START (expression_context_block
);
1155 expression_context_pc
= pc
;
1157 /* Fall back to using the current source static context, if any. */
1159 if (!expression_context_block
)
1161 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
1163 expression_context_block
1164 = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal
.symtab
),
1166 if (expression_context_block
)
1167 expression_context_pc
= BLOCK_START (expression_context_block
);
1170 if (language_mode
== language_mode_auto
&& block
!= NULL
)
1172 /* Find the language associated to the given context block.
1173 Default to the current language if it can not be determined.
1175 Note that using the language corresponding to the current frame
1176 can sometimes give unexpected results. For instance, this
1177 routine is often called several times during the inferior
1178 startup phase to re-parse breakpoint expressions after
1179 a new shared library has been loaded. The language associated
1180 to the current frame at this moment is not relevant for
1181 the breakpoint. Using it would therefore be silly, so it seems
1182 better to rely on the current language rather than relying on
1183 the current frame language to parse the expression. That's why
1184 we do the following language detection only if the context block
1185 has been specifically provided. */
1186 struct symbol
*func
= block_linkage_function (block
);
1189 lang
= language_def (SYMBOL_LANGUAGE (func
));
1190 if (lang
== NULL
|| lang
->la_language
== language_unknown
)
1191 lang
= current_language
;
1194 lang
= current_language
;
1196 /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
1197 While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
1198 and others called from *.y) ensure CURRENT_LANGUAGE gets restored
1199 to the value matching SELECTED_FRAME as set by get_current_arch. */
1201 parser_state
ps (10, lang
, get_current_arch ());
1203 scoped_restore_current_language lang_saver
;
1204 set_language (lang
->la_language
);
1208 if (lang
->la_parser (&ps
))
1209 lang
->la_error (NULL
);
1211 CATCH (except
, RETURN_MASK_ALL
)
1213 if (! parse_completion
)
1214 throw_exception (except
);
1218 /* We have to operate on an "expression *", due to la_post_parser,
1219 which explains this funny-looking double release. */
1220 expression_up result
= ps
.release ();
1222 /* Convert expression from postfix form as generated by yacc
1223 parser, to a prefix form. */
1225 if (expressiondebug
)
1226 dump_raw_expression (result
.get (), gdb_stdlog
,
1227 "before conversion to prefix form");
1229 subexp
= prefixify_expression (result
.get ());
1231 *out_subexp
= subexp
;
1233 lang
->la_post_parser (&result
, void_context_p
);
1235 if (expressiondebug
)
1236 dump_prefix_expression (result
.get (), gdb_stdlog
);
1238 *stringptr
= lexptr
;
1242 /* Parse STRING as an expression, and complain if this fails
1243 to use up all of the contents of STRING. */
1246 parse_expression (const char *string
)
1248 expression_up exp
= parse_exp_1 (&string
, 0, 0, 0);
1250 error (_("Junk after end of expression."));
1254 /* Same as parse_expression, but using the given language (LANG)
1255 to parse the expression. */
1258 parse_expression_with_language (const char *string
, enum language lang
)
1260 gdb::optional
<scoped_restore_current_language
> lang_saver
;
1261 if (current_language
->la_language
!= lang
)
1263 lang_saver
.emplace ();
1264 set_language (lang
);
1267 return parse_expression (string
);
1270 /* Parse STRING as an expression. If parsing ends in the middle of a
1271 field reference, return the type of the left-hand-side of the
1272 reference; furthermore, if the parsing ends in the field name,
1273 return the field name in *NAME. If the parsing ends in the middle
1274 of a field reference, but the reference is somehow invalid, throw
1275 an exception. In all other cases, return NULL. Returned non-NULL
1276 *NAME must be freed by the caller. */
1279 parse_expression_for_completion (const char *string
, char **name
,
1280 enum type_code
*code
)
1288 parse_completion
= 1;
1289 exp
= parse_exp_in_context (&string
, 0, 0, 0, 0, &subexp
);
1291 CATCH (except
, RETURN_MASK_ERROR
)
1293 /* Nothing, EXP remains NULL. */
1297 parse_completion
= 0;
1301 if (expout_tag_completion_type
!= TYPE_CODE_UNDEF
)
1303 *code
= expout_tag_completion_type
;
1304 *name
= expout_completion_name
;
1305 expout_completion_name
= NULL
;
1309 if (expout_last_struct
== -1)
1312 *name
= extract_field_op (exp
.get (), &subexp
);
1316 /* This might throw an exception. If so, we want to let it
1318 val
= evaluate_subexpression_type (exp
.get (), subexp
);
1319 /* (*NAME) is a part of the EXP memory block freed below. */
1320 *name
= xstrdup (*name
);
1322 return value_type (val
);
1325 /* A post-parser that does nothing. */
1328 null_post_parser (expression_up
*exp
, int void_context_p
)
1332 /* Parse floating point value P of length LEN.
1333 Return false if invalid, true if valid.
1334 The successfully parsed number is stored in DATA in
1335 target format for floating-point type TYPE.
1337 NOTE: This accepts the floating point syntax that sscanf accepts. */
1340 parse_float (const char *p
, int len
,
1341 const struct type
*type
, gdb_byte
*data
)
1343 return target_float_from_string (data
, type
, std::string (p
, len
));
1346 /* Stuff for maintaining a stack of types. Currently just used by C, but
1347 probably useful for any language which declares its types "backwards". */
1349 /* Ensure that there are HOWMUCH open slots on the type stack STACK. */
1352 type_stack_reserve (struct type_stack
*stack
, int howmuch
)
1354 if (stack
->depth
+ howmuch
>= stack
->size
)
1357 if (stack
->size
< howmuch
)
1358 stack
->size
= howmuch
;
1359 stack
->elements
= XRESIZEVEC (union type_stack_elt
, stack
->elements
,
1364 /* Ensure that there is a single open slot in the global type stack. */
1367 check_type_stack_depth (void)
1369 type_stack_reserve (&type_stack
, 1);
1372 /* A helper function for insert_type and insert_type_address_space.
1373 This does work of expanding the type stack and inserting the new
1374 element, ELEMENT, into the stack at location SLOT. */
1377 insert_into_type_stack (int slot
, union type_stack_elt element
)
1379 check_type_stack_depth ();
1381 if (slot
< type_stack
.depth
)
1382 memmove (&type_stack
.elements
[slot
+ 1], &type_stack
.elements
[slot
],
1383 (type_stack
.depth
- slot
) * sizeof (union type_stack_elt
));
1384 type_stack
.elements
[slot
] = element
;
1388 /* Insert a new type, TP, at the bottom of the type stack. If TP is
1389 tp_pointer, tp_reference or tp_rvalue_reference, it is inserted at the
1390 bottom. If TP is a qualifier, it is inserted at slot 1 (just above a
1391 previous tp_pointer) if there is anything on the stack, or simply pushed
1392 if the stack is empty. Other values for TP are invalid. */
1395 insert_type (enum type_pieces tp
)
1397 union type_stack_elt element
;
1400 gdb_assert (tp
== tp_pointer
|| tp
== tp_reference
1401 || tp
== tp_rvalue_reference
|| tp
== tp_const
1402 || tp
== tp_volatile
);
1404 /* If there is anything on the stack (we know it will be a
1405 tp_pointer), insert the qualifier above it. Otherwise, simply
1406 push this on the top of the stack. */
1407 if (type_stack
.depth
&& (tp
== tp_const
|| tp
== tp_volatile
))
1413 insert_into_type_stack (slot
, element
);
1417 push_type (enum type_pieces tp
)
1419 check_type_stack_depth ();
1420 type_stack
.elements
[type_stack
.depth
++].piece
= tp
;
1424 push_type_int (int n
)
1426 check_type_stack_depth ();
1427 type_stack
.elements
[type_stack
.depth
++].int_val
= n
;
1430 /* Insert a tp_space_identifier and the corresponding address space
1431 value into the stack. STRING is the name of an address space, as
1432 recognized by address_space_name_to_int. If the stack is empty,
1433 the new elements are simply pushed. If the stack is not empty,
1434 this function assumes that the first item on the stack is a
1435 tp_pointer, and the new values are inserted above the first
1439 insert_type_address_space (struct parser_state
*pstate
, char *string
)
1441 union type_stack_elt element
;
1444 /* If there is anything on the stack (we know it will be a
1445 tp_pointer), insert the address space qualifier above it.
1446 Otherwise, simply push this on the top of the stack. */
1447 if (type_stack
.depth
)
1452 element
.piece
= tp_space_identifier
;
1453 insert_into_type_stack (slot
, element
);
1454 element
.int_val
= address_space_name_to_int (parse_gdbarch (pstate
),
1456 insert_into_type_stack (slot
, element
);
1462 if (type_stack
.depth
)
1463 return type_stack
.elements
[--type_stack
.depth
].piece
;
1470 if (type_stack
.depth
)
1471 return type_stack
.elements
[--type_stack
.depth
].int_val
;
1472 /* "Can't happen". */
1476 /* Pop a type list element from the global type stack. */
1478 static VEC (type_ptr
) *
1481 gdb_assert (type_stack
.depth
);
1482 return type_stack
.elements
[--type_stack
.depth
].typelist_val
;
1485 /* Pop a type_stack element from the global type stack. */
1487 static struct type_stack
*
1488 pop_type_stack (void)
1490 gdb_assert (type_stack
.depth
);
1491 return type_stack
.elements
[--type_stack
.depth
].stack_val
;
1494 /* Append the elements of the type stack FROM to the type stack TO.
1495 Always returns TO. */
1498 append_type_stack (struct type_stack
*to
, struct type_stack
*from
)
1500 type_stack_reserve (to
, from
->depth
);
1502 memcpy (&to
->elements
[to
->depth
], &from
->elements
[0],
1503 from
->depth
* sizeof (union type_stack_elt
));
1504 to
->depth
+= from
->depth
;
1509 /* Push the type stack STACK as an element on the global type stack. */
1512 push_type_stack (struct type_stack
*stack
)
1514 check_type_stack_depth ();
1515 type_stack
.elements
[type_stack
.depth
++].stack_val
= stack
;
1516 push_type (tp_type_stack
);
1519 /* Copy the global type stack into a newly allocated type stack and
1520 return it. The global stack is cleared. The returned type stack
1521 must be freed with type_stack_cleanup. */
1524 get_type_stack (void)
1526 struct type_stack
*result
= XNEW (struct type_stack
);
1528 *result
= type_stack
;
1529 type_stack
.depth
= 0;
1530 type_stack
.size
= 0;
1531 type_stack
.elements
= NULL
;
1536 /* A cleanup function that destroys a single type stack. */
1539 type_stack_cleanup (void *arg
)
1541 struct type_stack
*stack
= (struct type_stack
*) arg
;
1543 xfree (stack
->elements
);
1547 /* Push a function type with arguments onto the global type stack.
1548 LIST holds the argument types. If the final item in LIST is NULL,
1549 then the function will be varargs. */
1552 push_typelist (VEC (type_ptr
) *list
)
1554 check_type_stack_depth ();
1555 type_stack
.elements
[type_stack
.depth
++].typelist_val
= list
;
1556 push_type (tp_function_with_arguments
);
1559 /* Pop the type stack and return a type_instance_flags that
1560 corresponds the const/volatile qualifiers on the stack. This is
1561 called by the C++ parser when parsing methods types, and as such no
1562 other kind of type in the type stack is expected. */
1565 follow_type_instance_flags ()
1567 type_instance_flags flags
= 0;
1570 switch (pop_type ())
1575 flags
|= TYPE_INSTANCE_FLAG_CONST
;
1578 flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
1581 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1586 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1587 as modified by all the stuff on the stack. */
1589 follow_types (struct type
*follow_type
)
1593 int make_volatile
= 0;
1594 int make_addr_space
= 0;
1598 switch (pop_type ())
1603 follow_type
= make_cv_type (make_const
,
1604 TYPE_VOLATILE (follow_type
),
1607 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1610 if (make_addr_space
)
1611 follow_type
= make_type_with_address_space (follow_type
,
1613 make_const
= make_volatile
= 0;
1614 make_addr_space
= 0;
1622 case tp_space_identifier
:
1623 make_addr_space
= pop_type_int ();
1626 follow_type
= lookup_pointer_type (follow_type
);
1628 follow_type
= make_cv_type (make_const
,
1629 TYPE_VOLATILE (follow_type
),
1632 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1635 if (make_addr_space
)
1636 follow_type
= make_type_with_address_space (follow_type
,
1638 make_const
= make_volatile
= 0;
1639 make_addr_space
= 0;
1642 follow_type
= lookup_lvalue_reference_type (follow_type
);
1643 goto process_reference
;
1644 case tp_rvalue_reference
:
1645 follow_type
= lookup_rvalue_reference_type (follow_type
);
1648 follow_type
= make_cv_type (make_const
,
1649 TYPE_VOLATILE (follow_type
),
1652 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1655 if (make_addr_space
)
1656 follow_type
= make_type_with_address_space (follow_type
,
1658 make_const
= make_volatile
= 0;
1659 make_addr_space
= 0;
1662 array_size
= pop_type_int ();
1663 /* FIXME-type-allocation: need a way to free this type when we are
1666 lookup_array_range_type (follow_type
,
1667 0, array_size
>= 0 ? array_size
- 1 : 0);
1669 TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (follow_type
))
1673 /* FIXME-type-allocation: need a way to free this type when we are
1675 follow_type
= lookup_function_type (follow_type
);
1678 case tp_function_with_arguments
:
1680 VEC (type_ptr
) *args
= pop_typelist ();
1683 = lookup_function_type_with_arguments (follow_type
,
1684 VEC_length (type_ptr
, args
),
1685 VEC_address (type_ptr
,
1687 VEC_free (type_ptr
, args
);
1693 struct type_stack
*stack
= pop_type_stack ();
1694 /* Sort of ugly, but not really much worse than the
1696 struct type_stack save
= type_stack
;
1698 type_stack
= *stack
;
1699 follow_type
= follow_types (follow_type
);
1700 gdb_assert (type_stack
.depth
== 0);
1706 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1711 /* This function avoids direct calls to fprintf
1712 in the parser generated debug code. */
1714 parser_fprintf (FILE *x
, const char *y
, ...)
1720 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1723 fprintf_unfiltered (gdb_stderr
, " Unknown FILE used.\n");
1724 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1729 /* Implementation of the exp_descriptor method operator_check. */
1732 operator_check_standard (struct expression
*exp
, int pos
,
1733 int (*objfile_func
) (struct objfile
*objfile
,
1737 const union exp_element
*const elts
= exp
->elts
;
1738 struct type
*type
= NULL
;
1739 struct objfile
*objfile
= NULL
;
1741 /* Extended operators should have been already handled by exp_descriptor
1742 iterate method of its specific language. */
1743 gdb_assert (elts
[pos
].opcode
< OP_EXTENDED0
);
1745 /* Track the callers of write_exp_elt_type for this table. */
1747 switch (elts
[pos
].opcode
)
1759 type
= elts
[pos
+ 1].type
;
1764 LONGEST arg
, nargs
= elts
[pos
+ 2].longconst
;
1766 for (arg
= 0; arg
< nargs
; arg
++)
1768 struct type
*type
= elts
[pos
+ 3 + arg
].type
;
1769 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1771 if (objfile
&& (*objfile_func
) (objfile
, data
))
1779 const struct block
*const block
= elts
[pos
+ 1].block
;
1780 const struct symbol
*const symbol
= elts
[pos
+ 2].symbol
;
1782 /* Check objfile where the variable itself is placed.
1783 SYMBOL_OBJ_SECTION (symbol) may be NULL. */
1784 if ((*objfile_func
) (symbol_objfile (symbol
), data
))
1787 /* Check objfile where is placed the code touching the variable. */
1788 objfile
= lookup_objfile_from_block (block
);
1790 type
= SYMBOL_TYPE (symbol
);
1793 case OP_VAR_MSYM_VALUE
:
1794 objfile
= elts
[pos
+ 1].objfile
;
1798 /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
1800 if (type
&& TYPE_OBJFILE (type
)
1801 && (*objfile_func
) (TYPE_OBJFILE (type
), data
))
1803 if (objfile
&& (*objfile_func
) (objfile
, data
))
1809 /* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1810 OBJFILE_FUNC is never called with NULL OBJFILE. OBJFILE_FUNC get
1811 passed an arbitrary caller supplied DATA pointer. If OBJFILE_FUNC
1812 returns non-zero value then (any other) non-zero value is immediately
1813 returned to the caller. Otherwise zero is returned after iterating
1814 through whole EXP. */
1817 exp_iterate (struct expression
*exp
,
1818 int (*objfile_func
) (struct objfile
*objfile
, void *data
),
1823 for (endpos
= exp
->nelts
; endpos
> 0; )
1825 int pos
, args
, oplen
= 0;
1827 operator_length (exp
, endpos
, &oplen
, &args
);
1828 gdb_assert (oplen
> 0);
1830 pos
= endpos
- oplen
;
1831 if (exp
->language_defn
->la_exp_desc
->operator_check (exp
, pos
,
1832 objfile_func
, data
))
1841 /* Helper for exp_uses_objfile. */
1844 exp_uses_objfile_iter (struct objfile
*exp_objfile
, void *objfile_voidp
)
1846 struct objfile
*objfile
= (struct objfile
*) objfile_voidp
;
1848 if (exp_objfile
->separate_debug_objfile_backlink
)
1849 exp_objfile
= exp_objfile
->separate_debug_objfile_backlink
;
1851 return exp_objfile
== objfile
;
1854 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1855 is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
1859 exp_uses_objfile (struct expression
*exp
, struct objfile
*objfile
)
1861 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
1863 return exp_iterate (exp
, exp_uses_objfile_iter
, objfile
);
1866 /* See definition in parser-defs.h. */
1869 increase_expout_size (struct parser_state
*ps
, size_t lenelt
)
1871 if ((ps
->expout_ptr
+ lenelt
) >= ps
->expout_size
)
1873 ps
->expout_size
= std::max (ps
->expout_size
* 2,
1874 ps
->expout_ptr
+ lenelt
+ 10);
1875 ps
->expout
.reset (XRESIZEVAR (expression
,
1876 ps
->expout
.release (),
1877 (sizeof (struct expression
)
1878 + EXP_ELEM_TO_BYTES (ps
->expout_size
))));
1883 _initialize_parse (void)
1885 type_stack
.size
= 0;
1886 type_stack
.depth
= 0;
1887 type_stack
.elements
= NULL
;
1889 add_setshow_zuinteger_cmd ("expression", class_maintenance
,
1891 _("Set expression debugging."),
1892 _("Show expression debugging."),
1893 _("When non-zero, the internal representation "
1894 "of expressions will be printed."),
1896 show_expressiondebug
,
1897 &setdebuglist
, &showdebuglist
);
1898 add_setshow_boolean_cmd ("parser", class_maintenance
,
1900 _("Set parser debugging."),
1901 _("Show parser debugging."),
1902 _("When non-zero, expression parser "
1903 "tracing will be enabled."),
1906 &setdebuglist
, &showdebuglist
);