1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
27 #include "gdbthread.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
31 #include "objc-lang.h"
33 #include "parser-defs.h"
34 #include "cp-support.h"
37 #include "user-regs.h"
39 #include "gdb_obstack.h"
41 #include "typeprint.h"
46 /* Prototypes for local functions. */
48 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
51 static struct value
*evaluate_subexp_for_address (struct expression
*,
54 static value
*evaluate_subexp_for_cast (expression
*exp
, int *pos
,
58 static struct value
*evaluate_struct_tuple (struct value
*,
59 struct expression
*, int *,
63 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
64 int *pos
, enum noside noside
)
66 return ((*exp
->language_defn
->expression_ops ()->evaluate_exp
)
67 (expect_type
, exp
, pos
, noside
));
70 /* Parse the string EXP as a C expression, evaluate it,
71 and return the result as a number. */
74 parse_and_eval_address (const char *exp
)
76 expression_up expr
= parse_expression (exp
);
78 return value_as_address (evaluate_expression (expr
.get ()));
81 /* Like parse_and_eval_address, but treats the value of the expression
82 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
84 parse_and_eval_long (const char *exp
)
86 expression_up expr
= parse_expression (exp
);
88 return value_as_long (evaluate_expression (expr
.get ()));
92 parse_and_eval (const char *exp
)
94 expression_up expr
= parse_expression (exp
);
96 return evaluate_expression (expr
.get ());
99 /* Parse up to a comma (or to a closeparen)
100 in the string EXPP as an expression, evaluate it, and return the value.
101 EXPP is advanced to point to the comma. */
104 parse_to_comma_and_eval (const char **expp
)
106 expression_up expr
= parse_exp_1 (expp
, 0, nullptr, 1);
108 return evaluate_expression (expr
.get ());
112 /* See expression.h. */
115 expression::evaluate (struct type
*expect_type
, enum noside noside
)
117 gdb::optional
<enable_thread_stack_temporaries
> stack_temporaries
;
118 if (target_has_execution ()
119 && language_defn
->la_language
== language_cplus
120 && !thread_stack_temporaries_enabled_p (inferior_thread ()))
121 stack_temporaries
.emplace (inferior_thread ());
124 struct value
*retval
= evaluate_subexp (expect_type
, this, &pos
, noside
);
126 if (stack_temporaries
.has_value ()
127 && value_in_thread_stack_temporaries (retval
, inferior_thread ()))
128 retval
= value_non_lval (retval
);
136 evaluate_expression (struct expression
*exp
, struct type
*expect_type
)
138 return exp
->evaluate (expect_type
, EVAL_NORMAL
);
141 /* Evaluate an expression, avoiding all memory references
142 and getting a value whose type alone is correct. */
145 evaluate_type (struct expression
*exp
)
147 return exp
->evaluate (nullptr, EVAL_AVOID_SIDE_EFFECTS
);
150 /* Evaluate a subexpression, avoiding all memory references and
151 getting a value whose type alone is correct. */
154 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
156 return evaluate_subexp (nullptr, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
159 /* Find the current value of a watchpoint on EXP. Return the value in
160 *VALP and *RESULTP and the chain of intermediate and final values
161 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
164 If PRESERVE_ERRORS is true, then exceptions are passed through.
165 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
166 occurs while evaluating the expression, *RESULTP will be set to
167 NULL. *RESULTP may be a lazy value, if the result could not be
168 read from memory. It is used to determine whether a value is
169 user-specified (we should watch the whole value) or intermediate
170 (we should watch only the bit used to locate the final value).
172 If the final value, or any intermediate value, could not be read
173 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
174 set to any referenced values. *VALP will never be a lazy value.
175 This is the value which we store in struct breakpoint.
177 If VAL_CHAIN is non-NULL, the values put into *VAL_CHAIN will be
178 released from the value chain. If VAL_CHAIN is NULL, all generated
179 values will be left on the value chain. */
182 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
183 struct value
**resultp
,
184 std::vector
<value_ref_ptr
> *val_chain
,
185 bool preserve_errors
)
187 struct value
*mark
, *new_mark
, *result
;
195 /* Evaluate the expression. */
196 mark
= value_mark ();
201 result
= evaluate_subexp (nullptr, exp
, pc
, EVAL_NORMAL
);
203 catch (const gdb_exception
&ex
)
205 /* Ignore memory errors if we want watchpoints pointing at
206 inaccessible memory to still be created; otherwise, throw the
207 error to some higher catcher. */
211 if (!preserve_errors
)
220 new_mark
= value_mark ();
221 if (mark
== new_mark
)
226 /* Make sure it's not lazy, so that after the target stops again we
227 have a non-lazy previous value to compare with. */
230 if (!value_lazy (result
))
237 value_fetch_lazy (result
);
240 catch (const gdb_exception_error
&except
)
248 /* Return the chain of intermediate values. We use this to
249 decide which addresses to watch. */
250 *val_chain
= value_release_to_mark (mark
);
254 /* Extract a field operation from an expression. If the subexpression
255 of EXP starting at *SUBEXP is not a structure dereference
256 operation, return NULL. Otherwise, return the name of the
257 dereferenced field, and advance *SUBEXP to point to the
258 subexpression of the left-hand-side of the dereference. This is
259 used when completing field names. */
262 extract_field_op (struct expression
*exp
, int *subexp
)
267 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
268 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
270 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
271 result
= &exp
->elts
[*subexp
+ 2].string
;
272 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
276 /* This function evaluates brace-initializers (in C/C++) for
279 static struct value
*
280 evaluate_struct_tuple (struct value
*struct_val
,
281 struct expression
*exp
,
282 int *pos
, enum noside noside
, int nargs
)
284 struct type
*struct_type
= check_typedef (value_type (struct_val
));
285 struct type
*field_type
;
290 struct value
*val
= NULL
;
295 /* Skip static fields. */
296 while (fieldno
< struct_type
->num_fields ()
297 && field_is_static (&struct_type
->field (fieldno
)))
299 if (fieldno
>= struct_type
->num_fields ())
300 error (_("too many initializers"));
301 field_type
= struct_type
->field (fieldno
).type ();
302 if (field_type
->code () == TYPE_CODE_UNION
303 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
304 error (_("don't know which variant you want to set"));
306 /* Here, struct_type is the type of the inner struct,
307 while substruct_type is the type of the inner struct.
308 These are the same for normal structures, but a variant struct
309 contains anonymous union fields that contain substruct fields.
310 The value fieldno is the index of the top-level (normal or
311 anonymous union) field in struct_field, while the value
312 subfieldno is the index of the actual real (named inner) field
313 in substruct_type. */
315 field_type
= struct_type
->field (fieldno
).type ();
317 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
319 /* Now actually set the field in struct_val. */
321 /* Assign val to field fieldno. */
322 if (value_type (val
) != field_type
)
323 val
= value_cast (field_type
, val
);
325 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
326 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
327 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
329 modify_field (struct_type
, addr
,
330 value_as_long (val
), bitpos
% 8, bitsize
);
332 memcpy (addr
, value_contents (val
),
333 TYPE_LENGTH (value_type (val
)));
339 /* Promote value ARG1 as appropriate before performing a unary operation
341 If the result is not appropriate for any particular language then it
342 needs to patch this function. */
345 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
350 *arg1
= coerce_ref (*arg1
);
351 type1
= check_typedef (value_type (*arg1
));
353 if (is_integral_type (type1
))
355 switch (language
->la_language
)
358 /* Perform integral promotion for ANSI C/C++.
359 If not appropriate for any particular language
360 it needs to modify this function. */
362 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
364 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
365 *arg1
= value_cast (builtin_int
, *arg1
);
372 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
373 operation on those two operands.
374 If the result is not appropriate for any particular language then it
375 needs to patch this function. */
378 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
379 struct value
**arg1
, struct value
**arg2
)
381 struct type
*promoted_type
= NULL
;
385 *arg1
= coerce_ref (*arg1
);
386 *arg2
= coerce_ref (*arg2
);
388 type1
= check_typedef (value_type (*arg1
));
389 type2
= check_typedef (value_type (*arg2
));
391 if ((type1
->code () != TYPE_CODE_FLT
392 && type1
->code () != TYPE_CODE_DECFLOAT
393 && !is_integral_type (type1
))
394 || (type2
->code () != TYPE_CODE_FLT
395 && type2
->code () != TYPE_CODE_DECFLOAT
396 && !is_integral_type (type2
)))
399 if (is_fixed_point_type (type1
) || is_fixed_point_type (type2
))
402 if (type1
->code () == TYPE_CODE_DECFLOAT
403 || type2
->code () == TYPE_CODE_DECFLOAT
)
405 /* No promotion required. */
407 else if (type1
->code () == TYPE_CODE_FLT
408 || type2
->code () == TYPE_CODE_FLT
)
410 switch (language
->la_language
)
416 case language_opencl
:
417 /* No promotion required. */
421 /* For other languages the result type is unchanged from gdb
422 version 6.7 for backward compatibility.
423 If either arg was long double, make sure that value is also long
424 double. Otherwise use double. */
425 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
426 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
427 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
429 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
433 else if (type1
->code () == TYPE_CODE_BOOL
434 && type2
->code () == TYPE_CODE_BOOL
)
436 /* No promotion required. */
439 /* Integral operations here. */
440 /* FIXME: Also mixed integral/booleans, with result an integer. */
442 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
443 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
444 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
445 int is_unsigned1
= type1
->is_unsigned ();
446 int is_unsigned2
= type2
->is_unsigned ();
447 unsigned int result_len
;
448 int unsigned_operation
;
450 /* Determine type length and signedness after promotion for
452 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
455 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
457 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
460 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
463 if (promoted_len1
> promoted_len2
)
465 unsigned_operation
= is_unsigned1
;
466 result_len
= promoted_len1
;
468 else if (promoted_len2
> promoted_len1
)
470 unsigned_operation
= is_unsigned2
;
471 result_len
= promoted_len2
;
475 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
476 result_len
= promoted_len1
;
479 switch (language
->la_language
)
485 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
487 promoted_type
= (unsigned_operation
488 ? builtin
->builtin_unsigned_int
489 : builtin
->builtin_int
);
491 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
493 promoted_type
= (unsigned_operation
494 ? builtin
->builtin_unsigned_long
495 : builtin
->builtin_long
);
499 promoted_type
= (unsigned_operation
500 ? builtin
->builtin_unsigned_long_long
501 : builtin
->builtin_long_long
);
504 case language_opencl
:
505 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
510 ? lookup_unsigned_typename (language
, "int")
511 : lookup_signed_typename (language
, "int"));
513 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
518 ? lookup_unsigned_typename (language
, "long")
519 : lookup_signed_typename (language
,"long"));
523 /* For other languages the result type is unchanged from gdb
524 version 6.7 for backward compatibility.
525 If either arg was long long, make sure that value is also long
526 long. Otherwise use long. */
527 if (unsigned_operation
)
529 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
530 promoted_type
= builtin
->builtin_unsigned_long_long
;
532 promoted_type
= builtin
->builtin_unsigned_long
;
536 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
537 promoted_type
= builtin
->builtin_long_long
;
539 promoted_type
= builtin
->builtin_long
;
547 /* Promote both operands to common type. */
548 *arg1
= value_cast (promoted_type
, *arg1
);
549 *arg2
= value_cast (promoted_type
, *arg2
);
554 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
556 type
= check_typedef (type
);
557 if (TYPE_IS_REFERENCE (type
))
558 type
= TYPE_TARGET_TYPE (type
);
560 switch (type
->code ())
566 case TYPE_CODE_ARRAY
:
567 return type
->is_vector () ? 0 : lang
->c_style_arrays_p ();
574 /* Represents a fake method with the given parameter types. This is
575 used by the parser to construct a temporary "expected" type for
576 method overload resolution. FLAGS is used as instance flags of the
577 new type, in order to be able to make the new type represent a
578 const/volatile overload. */
583 fake_method (type_instance_flags flags
,
584 int num_types
, struct type
**param_types
);
587 /* The constructed type. */
588 struct type
*type () { return &m_type
; }
591 struct type m_type
{};
592 main_type m_main_type
{};
595 fake_method::fake_method (type_instance_flags flags
,
596 int num_types
, struct type
**param_types
)
598 struct type
*type
= &m_type
;
600 TYPE_MAIN_TYPE (type
) = &m_main_type
;
601 TYPE_LENGTH (type
) = 1;
602 type
->set_code (TYPE_CODE_METHOD
);
603 TYPE_CHAIN (type
) = type
;
604 type
->set_instance_flags (flags
);
607 if (param_types
[num_types
- 1] == NULL
)
610 type
->set_has_varargs (true);
612 else if (check_typedef (param_types
[num_types
- 1])->code ()
616 /* Caller should have ensured this. */
617 gdb_assert (num_types
== 0);
618 type
->set_is_prototyped (true);
622 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
623 neither an objfile nor a gdbarch. As a result we must manually
624 allocate memory for auxiliary fields, and free the memory ourselves
625 when we are done with it. */
626 type
->set_num_fields (num_types
);
628 ((struct field
*) xzalloc (sizeof (struct field
) * num_types
));
630 while (num_types
-- > 0)
631 type
->field (num_types
).set_type (param_types
[num_types
]);
634 fake_method::~fake_method ()
636 xfree (m_type
.fields ());
643 type_instance_operation::evaluate (struct type
*expect_type
,
644 struct expression
*exp
,
647 type_instance_flags flags
= std::get
<0> (m_storage
);
648 std::vector
<type
*> &types
= std::get
<1> (m_storage
);
650 fake_method
fake_expect_type (flags
, types
.size (), types
.data ());
651 return std::get
<2> (m_storage
)->evaluate (fake_expect_type
.type (),
657 /* Helper for evaluating an OP_VAR_VALUE. */
660 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
662 /* JYG: We used to just return value_zero of the symbol type if
663 we're asked to avoid side effects. Otherwise we return
664 value_of_variable (...). However I'm not sure if
665 value_of_variable () has any side effect. We need a full value
666 object returned here for whatis_exp () to call evaluate_type ()
667 and then pass the full value to value_rtti_target_type () if we
668 are dealing with a pointer or reference to a base class and print
671 struct value
*ret
= NULL
;
675 ret
= value_of_variable (var
, blk
);
678 catch (const gdb_exception_error
&except
)
680 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
683 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
694 var_value_operation::evaluate (struct type
*expect_type
,
695 struct expression
*exp
,
698 symbol
*var
= std::get
<0> (m_storage
);
699 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
700 error_unknown_type (var
->print_name ());
701 return evaluate_var_value (noside
, std::get
<1> (m_storage
), var
);
704 } /* namespace expr */
706 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
709 evaluate_var_msym_value (enum noside noside
,
710 struct objfile
*objfile
, minimal_symbol
*msymbol
)
713 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
715 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !the_type
->is_gnu_ifunc ())
716 return value_zero (the_type
, not_lval
);
718 return value_at_lazy (the_type
, address
);
721 /* Helper for returning a value when handling EVAL_SKIP. */
724 eval_skip_value (expression
*exp
)
726 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
729 /* See expression.h. */
732 evaluate_subexp_do_call (expression
*exp
, enum noside noside
,
734 gdb::array_view
<value
*> argvec
,
735 const char *function_name
,
736 type
*default_return_type
)
739 error (_("Cannot evaluate function -- may be inlined"));
740 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
742 /* If the return type doesn't look like a function type,
743 call an error. This can happen if somebody tries to turn
744 a variable into a function call. */
746 type
*ftype
= value_type (callee
);
748 if (ftype
->code () == TYPE_CODE_INTERNAL_FUNCTION
)
750 /* We don't know anything about what the internal
751 function might return, but we have to return
753 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
756 else if (ftype
->code () == TYPE_CODE_XMETHOD
)
758 type
*return_type
= result_type_of_xmethod (callee
, argvec
);
760 if (return_type
== NULL
)
761 error (_("Xmethod is missing return type."));
762 return value_zero (return_type
, not_lval
);
764 else if (ftype
->code () == TYPE_CODE_FUNC
765 || ftype
->code () == TYPE_CODE_METHOD
)
767 if (ftype
->is_gnu_ifunc ())
769 CORE_ADDR address
= value_address (callee
);
770 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
772 if (resolved_type
!= NULL
)
773 ftype
= resolved_type
;
776 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
778 if (return_type
== NULL
)
779 return_type
= default_return_type
;
781 if (return_type
== NULL
)
782 error_call_unknown_return_type (function_name
);
784 return allocate_value (return_type
);
787 error (_("Expression of type other than "
788 "\"Function returning ...\" used as function"));
790 switch (value_type (callee
)->code ())
792 case TYPE_CODE_INTERNAL_FUNCTION
:
793 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
794 callee
, argvec
.size (), argvec
.data ());
795 case TYPE_CODE_XMETHOD
:
796 return call_xmethod (callee
, argvec
);
798 return call_function_by_hand (callee
, default_return_type
, argvec
);
802 /* Helper for evaluating an OP_FUNCALL. */
805 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
813 symbol
*function
= NULL
;
814 char *function_name
= NULL
;
815 const char *var_func_name
= NULL
;
820 exp_opcode op
= exp
->elts
[*pos
].opcode
;
821 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
822 /* Allocate arg vector, including space for the function to be
823 called in argvec[0], a potential `this', and a terminating
825 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
826 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
828 /* First, evaluate the structure into arg2. */
831 if (op
== STRUCTOP_MEMBER
)
833 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
837 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
840 /* If the function is a virtual function, then the aggregate
841 value (providing the structure) plays its part by providing
842 the vtable. Otherwise, it is just along for the ride: call
843 the function directly. */
845 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
847 type
*a1_type
= check_typedef (value_type (arg1
));
848 if (noside
== EVAL_SKIP
)
849 tem
= 1; /* Set it to the right arg index so that all
850 arguments can also be skipped. */
851 else if (a1_type
->code () == TYPE_CODE_METHODPTR
)
853 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
854 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
856 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
858 /* Now, say which argument to start evaluating from. */
863 else if (a1_type
->code () == TYPE_CODE_MEMBERPTR
)
865 struct type
*type_ptr
866 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
867 struct type
*target_type_ptr
868 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
870 /* Now, convert these values to an address. */
871 arg2
= value_cast (type_ptr
, arg2
);
873 long mem_offset
= value_as_long (arg1
);
875 arg1
= value_from_pointer (target_type_ptr
,
876 value_as_long (arg2
) + mem_offset
);
877 arg1
= value_ind (arg1
);
881 error (_("Non-pointer-to-member value used in pointer-to-member "
884 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
886 /* Hair for method invocations. */
890 /* First, evaluate the structure into arg2. */
892 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
893 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
895 if (op
== STRUCTOP_STRUCT
)
897 /* If v is a variable in a register, and the user types
898 v.method (), this will produce an error, because v has no
901 A possible way around this would be to allocate a copy of
902 the variable on the stack, copy in the contents, call the
903 function, and copy out the contents. I.e. convert this
904 from call by reference to call by copy-return (or
905 whatever it's called). However, this does not work
906 because it is not the same: the method being called could
907 stash a copy of the address, and then future uses through
908 that address (after the method returns) would be expected
909 to use the variable itself, not some copy of it. */
910 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
914 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
916 /* Check to see if the operator '->' has been overloaded.
917 If the operator has been overloaded replace arg2 with the
918 value returned by the custom operator and continue
920 while (unop_user_defined_p (op
, arg2
))
922 struct value
*value
= NULL
;
925 value
= value_x_unop (arg2
, op
, noside
);
928 catch (const gdb_exception_error
&except
)
930 if (except
.error
== NOT_FOUND_ERROR
)
939 /* Now, say which argument to start evaluating from. */
942 else if (op
== OP_SCOPE
943 && overload_resolution
944 && (exp
->language_defn
->la_language
== language_cplus
))
946 /* Unpack it locally so we can properly handle overload
952 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
953 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
954 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
955 name
= &exp
->elts
[pc2
+ 3].string
;
958 function_name
= NULL
;
959 if (type
->code () == TYPE_CODE_NAMESPACE
)
961 function
= cp_lookup_symbol_namespace (type
->name (),
963 get_selected_block (0),
965 if (function
== NULL
)
966 error (_("No symbol \"%s\" in namespace \"%s\"."),
967 name
, type
->name ());
970 /* arg2 is left as NULL on purpose. */
974 gdb_assert (type
->code () == TYPE_CODE_STRUCT
975 || type
->code () == TYPE_CODE_UNION
);
976 function_name
= name
;
978 /* We need a properly typed value for method lookup. For
979 static methods arg2 is otherwise unused. */
980 arg2
= value_zero (type
, lval_memory
);
985 else if (op
== OP_ADL_FUNC
)
987 /* Save the function position and move pos so that the arguments
994 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
995 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
999 /* Non-method function call. */
1003 /* If this is a C++ function wait until overload resolution. */
1004 if (op
== OP_VAR_VALUE
1005 && overload_resolution
1006 && (exp
->language_defn
->la_language
== language_cplus
))
1008 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1013 if (op
== OP_VAR_MSYM_VALUE
)
1015 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1016 var_func_name
= msym
->print_name ();
1018 else if (op
== OP_VAR_VALUE
)
1020 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1021 var_func_name
= sym
->print_name ();
1024 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1025 type
*type
= value_type (argvec
[0]);
1026 if (type
&& type
->code () == TYPE_CODE_PTR
)
1027 type
= TYPE_TARGET_TYPE (type
);
1028 if (type
&& type
->code () == TYPE_CODE_FUNC
)
1030 for (; tem
<= nargs
&& tem
<= type
->num_fields (); tem
++)
1032 argvec
[tem
] = evaluate_subexp (type
->field (tem
- 1).type (),
1039 /* Evaluate arguments (if not already done, e.g., namespace::func()
1040 and overload-resolution is off). */
1041 for (; tem
<= nargs
; tem
++)
1043 /* Ensure that array expressions are coerced into pointer
1045 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1048 /* Signal end of arglist. */
1051 if (noside
== EVAL_SKIP
)
1052 return eval_skip_value (exp
);
1054 if (op
== OP_ADL_FUNC
)
1056 struct symbol
*symp
;
1059 int string_pc
= save_pos1
+ 3;
1061 /* Extract the function name. */
1062 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1063 func_name
= (char *) alloca (name_len
+ 1);
1064 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1066 find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1068 NON_METHOD
, /* not method */
1069 NULL
, NULL
, /* pass NULL symbol since
1070 symbol is unknown */
1071 NULL
, &symp
, NULL
, 0, noside
);
1073 /* Now fix the expression being evaluated. */
1074 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1075 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1078 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1079 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1081 int static_memfuncp
;
1084 /* Method invocation: stuff "this" as first parameter. If the
1085 method turns out to be static we undo this below. */
1090 /* Name of method from expression. */
1091 tstr
= &exp
->elts
[pc2
+ 2].string
;
1094 tstr
= function_name
;
1096 if (overload_resolution
&& (exp
->language_defn
->la_language
1099 /* Language is C++, do some overload resolution before
1101 struct value
*valp
= NULL
;
1103 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1105 METHOD
, /* method */
1106 &arg2
, /* the object */
1108 &static_memfuncp
, 0, noside
);
1110 if (op
== OP_SCOPE
&& !static_memfuncp
)
1112 /* For the time being, we don't handle this. */
1113 error (_("Call to overloaded function %s requires "
1117 argvec
[1] = arg2
; /* the ``this'' pointer */
1118 argvec
[0] = valp
; /* Use the method found after overload
1122 /* Non-C++ case -- or no overload resolution. */
1124 struct value
*temp
= arg2
;
1126 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1128 op
== STRUCTOP_STRUCT
1129 ? "structure" : "structure pointer");
1130 /* value_struct_elt updates temp with the correct value of
1131 the ``this'' pointer if necessary, so modify argvec[1] to
1132 reflect any ``this'' changes. */
1134 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1135 value_address (temp
)
1136 + value_embedded_offset (temp
));
1137 argvec
[1] = arg2
; /* the ``this'' pointer */
1140 /* Take out `this' if needed. */
1141 if (static_memfuncp
)
1143 argvec
[1] = argvec
[0];
1148 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1150 /* Pointer to member. argvec[1] is already set up. */
1153 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1155 /* Non-member function being called. */
1156 /* fn: This can only be done for C++ functions. A C-style
1157 function in a C++ program, for instance, does not have the
1158 fields that are expected here. */
1160 if (overload_resolution
&& (exp
->language_defn
->la_language
1163 /* Language is C++, do some overload resolution before
1165 struct symbol
*symp
;
1168 /* If a scope has been specified disable ADL. */
1172 if (op
== OP_VAR_VALUE
)
1173 function
= exp
->elts
[save_pos1
+2].symbol
;
1175 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1176 NULL
, /* no need for name */
1177 NON_METHOD
, /* not method */
1178 NULL
, function
, /* the function */
1179 NULL
, &symp
, NULL
, no_adl
, noside
);
1181 if (op
== OP_VAR_VALUE
)
1183 /* Now fix the expression being evaluated. */
1184 exp
->elts
[save_pos1
+2].symbol
= symp
;
1185 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1189 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1193 /* Not C++, or no overload resolution allowed. */
1194 /* Nothing to be done; argvec already correctly set up. */
1199 /* It is probably a C-style function. */
1200 /* Nothing to be done; argvec already correctly set up. */
1203 return evaluate_subexp_do_call (exp
, noside
, argvec
[0],
1204 gdb::make_array_view (argvec
+ 1, nargs
),
1205 var_func_name
, expect_type
);
1212 operation::evaluate_funcall (struct type
*expect_type
,
1213 struct expression
*exp
,
1215 const char *function_name
,
1216 const std::vector
<operation_up
> &args
)
1218 std::vector
<value
*> vals (args
.size ());
1220 value
*callee
= evaluate_with_coercion (exp
, noside
);
1221 for (int i
= 0; i
< args
.size (); ++i
)
1222 vals
[i
] = args
[i
]->evaluate_with_coercion (exp
, noside
);
1224 return evaluate_subexp_do_call (exp
, noside
, callee
, vals
,
1225 function_name
, expect_type
);
1229 var_value_operation::evaluate_funcall (struct type
*expect_type
,
1230 struct expression
*exp
,
1232 const std::vector
<operation_up
> &args
)
1234 if (!overload_resolution
1235 || exp
->language_defn
->la_language
!= language_cplus
)
1236 return operation::evaluate_funcall (expect_type
, exp
, noside
, args
);
1238 std::vector
<value
*> argvec (args
.size ());
1239 for (int i
= 0; i
< args
.size (); ++i
)
1240 argvec
[i
] = args
[i
]->evaluate_with_coercion (exp
, noside
);
1242 struct symbol
*symp
;
1243 find_overload_match (argvec
, NULL
, NON_METHOD
,
1244 NULL
, std::get
<0> (m_storage
),
1245 NULL
, &symp
, NULL
, 0, noside
);
1247 if (SYMBOL_TYPE (symp
)->code () == TYPE_CODE_ERROR
)
1248 error_unknown_type (symp
->print_name ());
1249 value
*callee
= evaluate_var_value (noside
, std::get
<1> (m_storage
), symp
);
1251 return evaluate_subexp_do_call (exp
, noside
, callee
, argvec
,
1252 nullptr, expect_type
);
1256 scope_operation::evaluate_funcall (struct type
*expect_type
,
1257 struct expression
*exp
,
1259 const std::vector
<operation_up
> &args
)
1261 if (!overload_resolution
1262 || exp
->language_defn
->la_language
!= language_cplus
)
1263 return operation::evaluate_funcall (expect_type
, exp
, noside
, args
);
1265 /* Unpack it locally so we can properly handle overload
1267 const std::string
&name
= std::get
<1> (m_storage
);
1268 struct type
*type
= std::get
<0> (m_storage
);
1270 symbol
*function
= NULL
;
1271 const char *function_name
= NULL
;
1272 std::vector
<value
*> argvec (1 + args
.size ());
1273 if (type
->code () == TYPE_CODE_NAMESPACE
)
1275 function
= cp_lookup_symbol_namespace (type
->name (),
1277 get_selected_block (0),
1279 if (function
== NULL
)
1280 error (_("No symbol \"%s\" in namespace \"%s\"."),
1281 name
.c_str (), type
->name ());
1285 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1286 || type
->code () == TYPE_CODE_UNION
);
1287 function_name
= name
.c_str ();
1289 /* We need a properly typed value for method lookup. */
1290 argvec
[0] = value_zero (type
, lval_memory
);
1293 for (int i
= 0; i
< args
.size (); ++i
)
1294 argvec
[i
+ 1] = args
[i
]->evaluate_with_coercion (exp
, noside
);
1295 gdb::array_view
<value
*> arg_view
= argvec
;
1297 value
*callee
= nullptr;
1298 if (function_name
!= nullptr)
1300 int static_memfuncp
;
1302 find_overload_match (arg_view
, function_name
, METHOD
,
1303 &argvec
[0], nullptr, &callee
, nullptr,
1304 &static_memfuncp
, 0, noside
);
1305 if (!static_memfuncp
)
1307 /* For the time being, we don't handle this. */
1308 error (_("Call to overloaded function %s requires "
1313 arg_view
= arg_view
.slice (1);
1318 arg_view
= arg_view
.slice (1);
1319 find_overload_match (arg_view
, nullptr,
1320 NON_METHOD
, nullptr, function
,
1321 nullptr, &symp
, nullptr, 1, noside
);
1322 callee
= value_of_variable (symp
, get_selected_block (0));
1325 return evaluate_subexp_do_call (exp
, noside
, callee
, arg_view
,
1326 nullptr, expect_type
);
1330 structop_member_base::evaluate_funcall (struct type
*expect_type
,
1331 struct expression
*exp
,
1333 const std::vector
<operation_up
> &args
)
1335 /* First, evaluate the structure into lhs. */
1337 if (opcode () == STRUCTOP_MEMBER
)
1338 lhs
= std::get
<0> (m_storage
)->evaluate_for_address (exp
, noside
);
1340 lhs
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
1342 std::vector
<value
*> vals (args
.size () + 1);
1343 gdb::array_view
<value
*> val_view
= vals
;
1344 /* If the function is a virtual function, then the aggregate
1345 value (providing the structure) plays its part by providing
1346 the vtable. Otherwise, it is just along for the ride: call
1347 the function directly. */
1348 value
*rhs
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
1351 type
*a1_type
= check_typedef (value_type (rhs
));
1352 if (a1_type
->code () == TYPE_CODE_METHODPTR
)
1354 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1355 callee
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
1357 callee
= cplus_method_ptr_to_value (&lhs
, rhs
);
1361 else if (a1_type
->code () == TYPE_CODE_MEMBERPTR
)
1363 struct type
*type_ptr
1364 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
1365 struct type
*target_type_ptr
1366 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
1368 /* Now, convert this value to an address. */
1369 lhs
= value_cast (type_ptr
, lhs
);
1371 long mem_offset
= value_as_long (rhs
);
1373 callee
= value_from_pointer (target_type_ptr
,
1374 value_as_long (lhs
) + mem_offset
);
1375 callee
= value_ind (callee
);
1377 val_view
= val_view
.slice (1);
1380 error (_("Non-pointer-to-member value used in pointer-to-member "
1383 for (int i
= 0; i
< args
.size (); ++i
)
1384 vals
[i
+ 1] = args
[i
]->evaluate_with_coercion (exp
, noside
);
1386 return evaluate_subexp_do_call (exp
, noside
, callee
, val_view
,
1387 nullptr, expect_type
);
1392 structop_base_operation::evaluate_funcall
1393 (struct type
*expect_type
, struct expression
*exp
, enum noside noside
,
1394 const std::vector
<operation_up
> &args
)
1396 std::vector
<value
*> vals (args
.size () + 1);
1397 /* First, evaluate the structure into vals[0]. */
1398 enum exp_opcode op
= opcode ();
1399 if (op
== STRUCTOP_STRUCT
)
1401 /* If v is a variable in a register, and the user types
1402 v.method (), this will produce an error, because v has no
1405 A possible way around this would be to allocate a copy of
1406 the variable on the stack, copy in the contents, call the
1407 function, and copy out the contents. I.e. convert this
1408 from call by reference to call by copy-return (or
1409 whatever it's called). However, this does not work
1410 because it is not the same: the method being called could
1411 stash a copy of the address, and then future uses through
1412 that address (after the method returns) would be expected
1413 to use the variable itself, not some copy of it. */
1414 vals
[0] = std::get
<0> (m_storage
)->evaluate_for_address (exp
, noside
);
1418 vals
[0] = std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
1419 /* Check to see if the operator '->' has been overloaded.
1420 If the operator has been overloaded replace vals[0] with the
1421 value returned by the custom operator and continue
1423 while (unop_user_defined_p (op
, vals
[0]))
1425 struct value
*value
= nullptr;
1428 value
= value_x_unop (vals
[0], op
, noside
);
1430 catch (const gdb_exception_error
&except
)
1432 if (except
.error
== NOT_FOUND_ERROR
)
1442 for (int i
= 0; i
< args
.size (); ++i
)
1443 vals
[i
+ 1] = args
[i
]->evaluate_with_coercion (exp
, noside
);
1444 gdb::array_view
<value
*> arg_view
= vals
;
1446 int static_memfuncp
;
1448 const char *tstr
= std::get
<1> (m_storage
).c_str ();
1449 if (overload_resolution
1450 && exp
->language_defn
->la_language
== language_cplus
)
1452 /* Language is C++, do some overload resolution before
1454 value
*val0
= vals
[0];
1455 find_overload_match (arg_view
, tstr
, METHOD
,
1456 &val0
, nullptr, &callee
, nullptr,
1457 &static_memfuncp
, 0, noside
);
1461 /* Non-C++ case -- or no overload resolution. */
1463 struct value
*temp
= vals
[0];
1465 callee
= value_struct_elt (&temp
, &vals
[1], tstr
,
1467 op
== STRUCTOP_STRUCT
1468 ? "structure" : "structure pointer");
1469 /* value_struct_elt updates temp with the correct value of the
1470 ``this'' pointer if necessary, so modify it to reflect any
1471 ``this'' changes. */
1472 vals
[0] = value_from_longest (lookup_pointer_type (value_type (temp
)),
1473 value_address (temp
)
1474 + value_embedded_offset (temp
));
1477 /* Take out `this' if needed. */
1478 if (static_memfuncp
)
1479 arg_view
= arg_view
.slice (1);
1481 return evaluate_subexp_do_call (exp
, noside
, callee
, arg_view
,
1482 nullptr, expect_type
);
1486 } /* namespace expr */
1488 /* Return true if type is integral or reference to integral */
1491 is_integral_or_integral_reference (struct type
*type
)
1493 if (is_integral_type (type
))
1496 type
= check_typedef (type
);
1497 return (type
!= nullptr
1498 && TYPE_IS_REFERENCE (type
)
1499 && is_integral_type (TYPE_TARGET_TYPE (type
)));
1502 /* Helper function that implements the body of OP_SCOPE. */
1505 eval_op_scope (struct type
*expect_type
, struct expression
*exp
,
1507 struct type
*type
, const char *string
)
1509 if (noside
== EVAL_SKIP
)
1510 return eval_skip_value (exp
);
1511 struct value
*arg1
= value_aggregate_elt (type
, string
, expect_type
,
1514 error (_("There is no field named %s"), string
);
1518 /* Helper function that implements the body of OP_VAR_ENTRY_VALUE. */
1521 eval_op_var_entry_value (struct type
*expect_type
, struct expression
*exp
,
1522 enum noside noside
, symbol
*sym
)
1524 if (noside
== EVAL_SKIP
)
1525 return eval_skip_value (exp
);
1526 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1527 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1529 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1530 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1531 error (_("Symbol \"%s\" does not have any specific entry value"),
1532 sym
->print_name ());
1534 struct frame_info
*frame
= get_selected_frame (NULL
);
1535 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1538 /* Helper function that implements the body of OP_VAR_MSYM_VALUE. */
1541 eval_op_var_msym_value (struct type
*expect_type
, struct expression
*exp
,
1542 enum noside noside
, bool outermost_p
,
1543 minimal_symbol
*msymbol
, struct objfile
*objfile
)
1545 value
*val
= evaluate_var_msym_value (noside
, objfile
, msymbol
);
1547 struct type
*type
= value_type (val
);
1548 if (type
->code () == TYPE_CODE_ERROR
1549 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| !outermost_p
))
1550 error_unknown_type (msymbol
->print_name ());
1554 /* Helper function that implements the body of OP_FUNC_STATIC_VAR. */
1557 eval_op_func_static_var (struct type
*expect_type
, struct expression
*exp
,
1559 value
*func
, const char *var
)
1561 if (noside
== EVAL_SKIP
)
1562 return eval_skip_value (exp
);
1563 CORE_ADDR addr
= value_address (func
);
1564 const block
*blk
= block_for_pc (addr
);
1565 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1566 if (sym
.symbol
== NULL
)
1567 error (_("No symbol \"%s\" in specified context."), var
);
1568 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1571 /* Helper function that implements the body of OP_REGISTER. */
1574 eval_op_register (struct type
*expect_type
, struct expression
*exp
,
1575 enum noside noside
, const char *name
)
1580 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1581 name
, strlen (name
));
1583 error (_("Register $%s not available."), name
);
1585 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1586 a value with the appropriate register type. Unfortunately,
1587 we don't have easy access to the type of user registers.
1588 So for these registers, we fetch the register value regardless
1589 of the evaluation mode. */
1590 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1591 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1592 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1594 val
= value_of_register (regno
, get_selected_frame (NULL
));
1596 error (_("Value of register %s not available."), name
);
1601 /* Helper function that implements the body of OP_STRING. */
1604 eval_op_string (struct type
*expect_type
, struct expression
*exp
,
1605 enum noside noside
, int len
, const char *string
)
1607 if (noside
== EVAL_SKIP
)
1608 return eval_skip_value (exp
);
1609 struct type
*type
= language_string_char_type (exp
->language_defn
,
1611 return value_string (string
, len
, type
);
1614 /* Helper function that implements the body of OP_OBJC_SELECTOR. */
1617 eval_op_objc_selector (struct type
*expect_type
, struct expression
*exp
,
1621 if (noside
== EVAL_SKIP
)
1622 return eval_skip_value (exp
);
1624 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1625 return value_from_longest (selector_type
,
1626 lookup_child_selector (exp
->gdbarch
, sel
));
1629 /* Helper function that implements the body of BINOP_CONCAT. */
1632 eval_op_concat (struct type
*expect_type
, struct expression
*exp
,
1633 enum noside noside
, struct value
*arg1
, struct value
*arg2
)
1635 if (noside
== EVAL_SKIP
)
1636 return eval_skip_value (exp
);
1637 if (binop_user_defined_p (BINOP_CONCAT
, arg1
, arg2
))
1638 return value_x_binop (arg1
, arg2
, BINOP_CONCAT
, OP_NULL
, noside
);
1640 return value_concat (arg1
, arg2
);
1643 /* A helper function for TERNOP_SLICE. */
1646 eval_op_ternop (struct type
*expect_type
, struct expression
*exp
,
1648 struct value
*array
, struct value
*low
, struct value
*upper
)
1650 if (noside
== EVAL_SKIP
)
1651 return eval_skip_value (exp
);
1652 int lowbound
= value_as_long (low
);
1653 int upperbound
= value_as_long (upper
);
1654 return value_slice (array
, lowbound
, upperbound
- lowbound
+ 1);
1657 /* A helper function for STRUCTOP_STRUCT. */
1660 eval_op_structop_struct (struct type
*expect_type
, struct expression
*exp
,
1662 struct value
*arg1
, const char *string
)
1664 if (noside
== EVAL_SKIP
)
1665 return eval_skip_value (exp
);
1666 struct value
*arg3
= value_struct_elt (&arg1
, NULL
, string
,
1668 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1669 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1673 /* A helper function for STRUCTOP_PTR. */
1676 eval_op_structop_ptr (struct type
*expect_type
, struct expression
*exp
,
1678 struct value
*arg1
, const char *string
)
1680 if (noside
== EVAL_SKIP
)
1681 return eval_skip_value (exp
);
1683 /* Check to see if operator '->' has been overloaded. If so replace
1684 arg1 with the value returned by evaluating operator->(). */
1685 while (unop_user_defined_p (STRUCTOP_PTR
, arg1
))
1687 struct value
*value
= NULL
;
1690 value
= value_x_unop (arg1
, STRUCTOP_PTR
, noside
);
1693 catch (const gdb_exception_error
&except
)
1695 if (except
.error
== NOT_FOUND_ERROR
)
1704 /* JYG: if print object is on we need to replace the base type
1705 with rtti type in order to continue on with successful
1706 lookup of member / method only available in the rtti type. */
1708 struct type
*arg_type
= value_type (arg1
);
1709 struct type
*real_type
;
1710 int full
, using_enc
;
1712 struct value_print_options opts
;
1714 get_user_print_options (&opts
);
1715 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
1716 && (TYPE_TARGET_TYPE (arg_type
)->code () == TYPE_CODE_STRUCT
))
1718 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1721 arg1
= value_cast (real_type
, arg1
);
1725 struct value
*arg3
= value_struct_elt (&arg1
, NULL
, string
,
1726 NULL
, "structure pointer");
1727 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1728 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1732 /* A helper function for STRUCTOP_MEMBER. */
1735 eval_op_member (struct type
*expect_type
, struct expression
*exp
,
1737 struct value
*arg1
, struct value
*arg2
)
1741 if (noside
== EVAL_SKIP
)
1742 return eval_skip_value (exp
);
1745 struct type
*type
= check_typedef (value_type (arg2
));
1746 switch (type
->code ())
1748 case TYPE_CODE_METHODPTR
:
1749 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1750 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1753 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1754 gdb_assert (value_type (arg2
)->code () == TYPE_CODE_PTR
);
1755 return value_ind (arg2
);
1758 case TYPE_CODE_MEMBERPTR
:
1759 /* Now, convert these values to an address. */
1760 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1763 mem_offset
= value_as_long (arg2
);
1765 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1766 value_as_long (arg1
) + mem_offset
);
1767 return value_ind (arg3
);
1770 error (_("non-pointer-to-member value used "
1771 "in pointer-to-member construct"));
1775 /* A helper function for BINOP_ADD. */
1778 eval_op_add (struct type
*expect_type
, struct expression
*exp
,
1780 struct value
*arg1
, struct value
*arg2
)
1782 if (noside
== EVAL_SKIP
)
1783 return eval_skip_value (exp
);
1784 if (binop_user_defined_p (BINOP_ADD
, arg1
, arg2
))
1785 return value_x_binop (arg1
, arg2
, BINOP_ADD
, OP_NULL
, noside
);
1786 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1787 && is_integral_or_integral_reference (value_type (arg2
)))
1788 return value_ptradd (arg1
, value_as_long (arg2
));
1789 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
1790 && is_integral_or_integral_reference (value_type (arg1
)))
1791 return value_ptradd (arg2
, value_as_long (arg1
));
1794 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1795 return value_binop (arg1
, arg2
, BINOP_ADD
);
1799 /* A helper function for BINOP_SUB. */
1802 eval_op_sub (struct type
*expect_type
, struct expression
*exp
,
1804 struct value
*arg1
, struct value
*arg2
)
1806 if (noside
== EVAL_SKIP
)
1807 return eval_skip_value (exp
);
1808 if (binop_user_defined_p (BINOP_SUB
, arg1
, arg2
))
1809 return value_x_binop (arg1
, arg2
, BINOP_SUB
, OP_NULL
, noside
);
1810 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1811 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
1813 /* FIXME -- should be ptrdiff_t */
1814 struct type
*type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1815 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1817 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1818 && is_integral_or_integral_reference (value_type (arg2
)))
1819 return value_ptradd (arg1
, - value_as_long (arg2
));
1822 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1823 return value_binop (arg1
, arg2
, BINOP_SUB
);
1827 /* Helper function for several different binary operations. */
1830 eval_op_binary (struct type
*expect_type
, struct expression
*exp
,
1831 enum noside noside
, enum exp_opcode op
,
1832 struct value
*arg1
, struct value
*arg2
)
1834 if (noside
== EVAL_SKIP
)
1835 return eval_skip_value (exp
);
1836 if (binop_user_defined_p (op
, arg1
, arg2
))
1837 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1840 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1841 fudge arg2 to avoid division-by-zero, the caller is
1842 (theoretically) only looking for the type of the result. */
1843 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1844 /* ??? Do we really want to test for BINOP_MOD here?
1845 The implementation of value_binop gives it a well-defined
1848 || op
== BINOP_INTDIV
1851 && value_logical_not (arg2
))
1853 struct value
*v_one
;
1855 v_one
= value_one (value_type (arg2
));
1856 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1857 return value_binop (arg1
, v_one
, op
);
1861 /* For shift and integer exponentiation operations,
1862 only promote the first argument. */
1863 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1864 && is_integral_type (value_type (arg2
)))
1865 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1867 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1869 return value_binop (arg1
, arg2
, op
);
1874 /* A helper function for BINOP_SUBSCRIPT. */
1877 eval_op_subscript (struct type
*expect_type
, struct expression
*exp
,
1878 enum noside noside
, enum exp_opcode op
,
1879 struct value
*arg1
, struct value
*arg2
)
1881 if (noside
== EVAL_SKIP
)
1882 return eval_skip_value (exp
);
1883 if (binop_user_defined_p (op
, arg1
, arg2
))
1884 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1887 /* If the user attempts to subscript something that is not an
1888 array or pointer type (like a plain int variable for example),
1889 then report this as an error. */
1891 arg1
= coerce_ref (arg1
);
1892 struct type
*type
= check_typedef (value_type (arg1
));
1893 if (type
->code () != TYPE_CODE_ARRAY
1894 && type
->code () != TYPE_CODE_PTR
)
1897 error (_("cannot subscript something of type `%s'"),
1900 error (_("cannot subscript requested type"));
1903 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1904 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1906 return value_subscript (arg1
, value_as_long (arg2
));
1910 /* A helper function for BINOP_EQUAL. */
1913 eval_op_equal (struct type
*expect_type
, struct expression
*exp
,
1914 enum noside noside
, enum exp_opcode op
,
1915 struct value
*arg1
, struct value
*arg2
)
1917 if (noside
== EVAL_SKIP
)
1918 return eval_skip_value (exp
);
1919 if (binop_user_defined_p (op
, arg1
, arg2
))
1921 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1925 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1926 int tem
= value_equal (arg1
, arg2
);
1927 struct type
*type
= language_bool_type (exp
->language_defn
,
1929 return value_from_longest (type
, (LONGEST
) tem
);
1933 /* A helper function for BINOP_NOTEQUAL. */
1936 eval_op_notequal (struct type
*expect_type
, struct expression
*exp
,
1937 enum noside noside
, enum exp_opcode op
,
1938 struct value
*arg1
, struct value
*arg2
)
1940 if (noside
== EVAL_SKIP
)
1941 return eval_skip_value (exp
);
1942 if (binop_user_defined_p (op
, arg1
, arg2
))
1944 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1948 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1949 int tem
= value_equal (arg1
, arg2
);
1950 struct type
*type
= language_bool_type (exp
->language_defn
,
1952 return value_from_longest (type
, (LONGEST
) ! tem
);
1956 /* A helper function for BINOP_LESS. */
1959 eval_op_less (struct type
*expect_type
, struct expression
*exp
,
1960 enum noside noside
, enum exp_opcode op
,
1961 struct value
*arg1
, struct value
*arg2
)
1963 if (noside
== EVAL_SKIP
)
1964 return eval_skip_value (exp
);
1965 if (binop_user_defined_p (op
, arg1
, arg2
))
1967 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1971 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1972 int tem
= value_less (arg1
, arg2
);
1973 struct type
*type
= language_bool_type (exp
->language_defn
,
1975 return value_from_longest (type
, (LONGEST
) tem
);
1979 /* A helper function for BINOP_GTR. */
1982 eval_op_gtr (struct type
*expect_type
, struct expression
*exp
,
1983 enum noside noside
, enum exp_opcode op
,
1984 struct value
*arg1
, struct value
*arg2
)
1986 if (noside
== EVAL_SKIP
)
1987 return eval_skip_value (exp
);
1988 if (binop_user_defined_p (op
, arg1
, arg2
))
1990 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1994 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1995 int tem
= value_less (arg2
, arg1
);
1996 struct type
*type
= language_bool_type (exp
->language_defn
,
1998 return value_from_longest (type
, (LONGEST
) tem
);
2002 /* A helper function for BINOP_GEQ. */
2005 eval_op_geq (struct type
*expect_type
, struct expression
*exp
,
2006 enum noside noside
, enum exp_opcode op
,
2007 struct value
*arg1
, struct value
*arg2
)
2009 if (noside
== EVAL_SKIP
)
2010 return eval_skip_value (exp
);
2011 if (binop_user_defined_p (op
, arg1
, arg2
))
2013 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2017 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2018 int tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2019 struct type
*type
= language_bool_type (exp
->language_defn
,
2021 return value_from_longest (type
, (LONGEST
) tem
);
2025 /* A helper function for BINOP_LEQ. */
2028 eval_op_leq (struct type
*expect_type
, struct expression
*exp
,
2029 enum noside noside
, enum exp_opcode op
,
2030 struct value
*arg1
, struct value
*arg2
)
2032 if (noside
== EVAL_SKIP
)
2033 return eval_skip_value (exp
);
2034 if (binop_user_defined_p (op
, arg1
, arg2
))
2036 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2040 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2041 int tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2042 struct type
*type
= language_bool_type (exp
->language_defn
,
2044 return value_from_longest (type
, (LONGEST
) tem
);
2048 /* A helper function for BINOP_REPEAT. */
2051 eval_op_repeat (struct type
*expect_type
, struct expression
*exp
,
2052 enum noside noside
, enum exp_opcode op
,
2053 struct value
*arg1
, struct value
*arg2
)
2055 if (noside
== EVAL_SKIP
)
2056 return eval_skip_value (exp
);
2057 struct type
*type
= check_typedef (value_type (arg2
));
2058 if (type
->code () != TYPE_CODE_INT
2059 && type
->code () != TYPE_CODE_ENUM
)
2060 error (_("Non-integral right operand for \"@\" operator."));
2061 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2063 return allocate_repeat_value (value_type (arg1
),
2064 longest_to_int (value_as_long (arg2
)));
2067 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2070 /* A helper function for UNOP_PLUS. */
2073 eval_op_plus (struct type
*expect_type
, struct expression
*exp
,
2074 enum noside noside
, enum exp_opcode op
,
2077 if (noside
== EVAL_SKIP
)
2078 return eval_skip_value (exp
);
2079 if (unop_user_defined_p (op
, arg1
))
2080 return value_x_unop (arg1
, op
, noside
);
2083 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2084 return value_pos (arg1
);
2088 /* A helper function for UNOP_NEG. */
2091 eval_op_neg (struct type
*expect_type
, struct expression
*exp
,
2092 enum noside noside
, enum exp_opcode op
,
2095 if (noside
== EVAL_SKIP
)
2096 return eval_skip_value (exp
);
2097 if (unop_user_defined_p (op
, arg1
))
2098 return value_x_unop (arg1
, op
, noside
);
2101 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2102 return value_neg (arg1
);
2106 /* A helper function for UNOP_COMPLEMENT. */
2109 eval_op_complement (struct type
*expect_type
, struct expression
*exp
,
2110 enum noside noside
, enum exp_opcode op
,
2113 if (noside
== EVAL_SKIP
)
2114 return eval_skip_value (exp
);
2115 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2116 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2119 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2120 return value_complement (arg1
);
2124 /* A helper function for UNOP_LOGICAL_NOT. */
2127 eval_op_lognot (struct type
*expect_type
, struct expression
*exp
,
2128 enum noside noside
, enum exp_opcode op
,
2131 if (noside
== EVAL_SKIP
)
2132 return eval_skip_value (exp
);
2133 if (unop_user_defined_p (op
, arg1
))
2134 return value_x_unop (arg1
, op
, noside
);
2137 struct type
*type
= language_bool_type (exp
->language_defn
,
2139 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2143 /* A helper function for UNOP_IND. */
2146 eval_op_ind (struct type
*expect_type
, struct expression
*exp
,
2150 struct type
*type
= check_typedef (value_type (arg1
));
2151 if (type
->code () == TYPE_CODE_METHODPTR
2152 || type
->code () == TYPE_CODE_MEMBERPTR
)
2153 error (_("Attempt to dereference pointer "
2154 "to member without an object"));
2155 if (noside
== EVAL_SKIP
)
2156 return eval_skip_value (exp
);
2157 if (unop_user_defined_p (UNOP_IND
, arg1
))
2158 return value_x_unop (arg1
, UNOP_IND
, noside
);
2159 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2161 type
= check_typedef (value_type (arg1
));
2163 /* If the type pointed to is dynamic then in order to resolve the
2164 dynamic properties we must actually dereference the pointer.
2165 There is a risk that this dereference will have side-effects
2166 in the inferior, but being able to print accurate type
2167 information seems worth the risk. */
2168 if ((type
->code () != TYPE_CODE_PTR
2169 && !TYPE_IS_REFERENCE (type
))
2170 || !is_dynamic_type (TYPE_TARGET_TYPE (type
)))
2172 if (type
->code () == TYPE_CODE_PTR
2173 || TYPE_IS_REFERENCE (type
)
2174 /* In C you can dereference an array to get the 1st elt. */
2175 || type
->code () == TYPE_CODE_ARRAY
)
2176 return value_zero (TYPE_TARGET_TYPE (type
),
2178 else if (type
->code () == TYPE_CODE_INT
)
2179 /* GDB allows dereferencing an int. */
2180 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2183 error (_("Attempt to take contents of a non-pointer value."));
2187 /* Allow * on an integer so we can cast it to whatever we want.
2188 This returns an int, which seems like the most C-like thing to
2189 do. "long long" variables are rare enough that
2190 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2191 if (type
->code () == TYPE_CODE_INT
)
2192 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2193 (CORE_ADDR
) value_as_address (arg1
));
2194 return value_ind (arg1
);
2197 /* A helper function for UNOP_ALIGNOF. */
2200 eval_op_alignof (struct type
*expect_type
, struct expression
*exp
,
2204 struct type
*type
= value_type (arg1
);
2205 /* FIXME: This should be size_t. */
2206 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2207 ULONGEST align
= type_align (type
);
2209 error (_("could not determine alignment of type"));
2210 return value_from_longest (size_type
, align
);
2213 /* A helper function for UNOP_MEMVAL. */
2216 eval_op_memval (struct type
*expect_type
, struct expression
*exp
,
2218 struct value
*arg1
, struct type
*type
)
2220 if (noside
== EVAL_SKIP
)
2221 return eval_skip_value (exp
);
2222 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2223 return value_zero (type
, lval_memory
);
2225 return value_at_lazy (type
, value_as_address (arg1
));
2228 /* A helper function for UNOP_PREINCREMENT. */
2231 eval_op_preinc (struct type
*expect_type
, struct expression
*exp
,
2232 enum noside noside
, enum exp_opcode op
,
2235 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2237 else if (unop_user_defined_p (op
, arg1
))
2239 return value_x_unop (arg1
, op
, noside
);
2244 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2245 arg2
= value_ptradd (arg1
, 1);
2248 struct value
*tmp
= arg1
;
2250 arg2
= value_one (value_type (arg1
));
2251 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2252 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2255 return value_assign (arg1
, arg2
);
2259 /* A helper function for UNOP_PREDECREMENT. */
2262 eval_op_predec (struct type
*expect_type
, struct expression
*exp
,
2263 enum noside noside
, enum exp_opcode op
,
2266 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2268 else if (unop_user_defined_p (op
, arg1
))
2270 return value_x_unop (arg1
, op
, noside
);
2275 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2276 arg2
= value_ptradd (arg1
, -1);
2279 struct value
*tmp
= arg1
;
2281 arg2
= value_one (value_type (arg1
));
2282 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2283 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2286 return value_assign (arg1
, arg2
);
2290 /* A helper function for UNOP_POSTINCREMENT. */
2293 eval_op_postinc (struct type
*expect_type
, struct expression
*exp
,
2294 enum noside noside
, enum exp_opcode op
,
2297 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2299 else if (unop_user_defined_p (op
, arg1
))
2301 return value_x_unop (arg1
, op
, noside
);
2305 struct value
*arg3
= value_non_lval (arg1
);
2308 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2309 arg2
= value_ptradd (arg1
, 1);
2312 struct value
*tmp
= arg1
;
2314 arg2
= value_one (value_type (arg1
));
2315 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2316 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2319 value_assign (arg1
, arg2
);
2324 /* A helper function for UNOP_POSTDECREMENT. */
2327 eval_op_postdec (struct type
*expect_type
, struct expression
*exp
,
2328 enum noside noside
, enum exp_opcode op
,
2331 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2333 else if (unop_user_defined_p (op
, arg1
))
2335 return value_x_unop (arg1
, op
, noside
);
2339 struct value
*arg3
= value_non_lval (arg1
);
2342 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2343 arg2
= value_ptradd (arg1
, -1);
2346 struct value
*tmp
= arg1
;
2348 arg2
= value_one (value_type (arg1
));
2349 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2350 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2353 value_assign (arg1
, arg2
);
2358 /* A helper function for OP_TYPE. */
2361 eval_op_type (struct type
*expect_type
, struct expression
*exp
,
2362 enum noside noside
, struct type
*type
)
2364 if (noside
== EVAL_SKIP
)
2365 return eval_skip_value (exp
);
2366 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2367 return allocate_value (type
);
2369 error (_("Attempt to use a type name as an expression"));
2372 /* A helper function for BINOP_ASSIGN_MODIFY. */
2375 eval_binop_assign_modify (struct type
*expect_type
, struct expression
*exp
,
2376 enum noside noside
, enum exp_opcode op
,
2377 struct value
*arg1
, struct value
*arg2
)
2379 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2381 if (binop_user_defined_p (op
, arg1
, arg2
))
2382 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2383 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2385 && is_integral_type (value_type (arg2
)))
2386 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2387 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2389 && is_integral_type (value_type (arg2
)))
2390 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2393 struct value
*tmp
= arg1
;
2395 /* For shift and integer exponentiation operations,
2396 only promote the first argument. */
2397 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2398 && is_integral_type (value_type (arg2
)))
2399 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2401 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2403 arg2
= value_binop (tmp
, arg2
, op
);
2405 return value_assign (arg1
, arg2
);
2408 /* Note that ARGS needs 2 empty slots up front and must end with a
2410 static struct value
*
2411 eval_op_objc_msgcall (struct type
*expect_type
, struct expression
*exp
,
2412 enum noside noside
, CORE_ADDR selector
,
2413 value
*target
, gdb::array_view
<value
*> args
)
2415 CORE_ADDR responds_selector
= 0;
2416 CORE_ADDR method_selector
= 0;
2418 int struct_return
= 0;
2420 struct value
*msg_send
= NULL
;
2421 struct value
*msg_send_stret
= NULL
;
2422 int gnu_runtime
= 0;
2424 struct value
*method
= NULL
;
2425 struct value
*called_method
= NULL
;
2427 struct type
*selector_type
= NULL
;
2428 struct type
*long_type
;
2431 struct value
*ret
= NULL
;
2436 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2437 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2439 if (value_as_long (target
) == 0)
2440 return value_from_longest (long_type
, 0);
2442 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
2445 /* Find the method dispatch (Apple runtime) or method lookup
2446 (GNU runtime) function for Objective-C. These will be used
2447 to lookup the symbol information for the method. If we
2448 can't find any symbol information, then we'll use these to
2449 call the method, otherwise we can call the method
2450 directly. The msg_send_stret function is used in the special
2451 case of a method that returns a structure (Apple runtime
2455 type
= selector_type
;
2457 type
= lookup_function_type (type
);
2458 type
= lookup_pointer_type (type
);
2459 type
= lookup_function_type (type
);
2460 type
= lookup_pointer_type (type
);
2462 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
2464 = find_function_in_inferior ("objc_msg_lookup", NULL
);
2466 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
2467 msg_send_stret
= value_from_pointer (type
,
2468 value_as_address (msg_send_stret
));
2472 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
2473 /* Special dispatcher for methods returning structs. */
2475 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
2478 /* Verify the target object responds to this method. The
2479 standard top-level 'Object' class uses a different name for
2480 the verification method than the non-standard, but more
2481 often used, 'NSObject' class. Make sure we check for both. */
2484 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
2485 if (responds_selector
== 0)
2487 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
2489 if (responds_selector
== 0)
2490 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
2493 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
2494 if (method_selector
== 0)
2496 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
2498 if (method_selector
== 0)
2499 error (_("no 'methodFor:' or 'methodForSelector:' method"));
2501 /* Call the verification method, to make sure that the target
2502 class implements the desired method. */
2504 argvec
[0] = msg_send
;
2506 argvec
[2] = value_from_longest (long_type
, responds_selector
);
2507 argvec
[3] = value_from_longest (long_type
, selector
);
2510 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2513 /* Function objc_msg_lookup returns a pointer. */
2515 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2517 if (value_as_long (ret
) == 0)
2518 error (_("Target does not respond to this message selector."));
2520 /* Call "methodForSelector:" method, to get the address of a
2521 function method that implements this selector for this
2522 class. If we can find a symbol at that address, then we
2523 know the return type, parameter types etc. (that's a good
2526 argvec
[0] = msg_send
;
2528 argvec
[2] = value_from_longest (long_type
, method_selector
);
2529 argvec
[3] = value_from_longest (long_type
, selector
);
2532 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2536 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2539 /* ret should now be the selector. */
2541 addr
= value_as_long (ret
);
2544 struct symbol
*sym
= NULL
;
2546 /* The address might point to a function descriptor;
2547 resolve it to the actual code address instead. */
2548 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
2549 current_top_target ());
2551 /* Is it a high_level symbol? */
2552 sym
= find_pc_function (addr
);
2554 method
= value_of_variable (sym
, 0);
2557 /* If we found a method with symbol information, check to see
2558 if it returns a struct. Otherwise assume it doesn't. */
2563 struct type
*val_type
;
2565 funaddr
= find_function_addr (method
, &val_type
);
2567 block_for_pc (funaddr
);
2569 val_type
= check_typedef (val_type
);
2571 if ((val_type
== NULL
)
2572 || (val_type
->code () == TYPE_CODE_ERROR
))
2574 if (expect_type
!= NULL
)
2575 val_type
= expect_type
;
2578 struct_return
= using_struct_return (exp
->gdbarch
, method
,
2581 else if (expect_type
!= NULL
)
2583 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
2584 check_typedef (expect_type
));
2587 /* Found a function symbol. Now we will substitute its
2588 value in place of the message dispatcher (obj_msgSend),
2589 so that we call the method directly instead of thru
2590 the dispatcher. The main reason for doing this is that
2591 we can now evaluate the return value and parameter values
2592 according to their known data types, in case we need to
2593 do things like promotion, dereferencing, special handling
2594 of structs and doubles, etc.
2596 We want to use the type signature of 'method', but still
2597 jump to objc_msgSend() or objc_msgSend_stret() to better
2598 mimic the behavior of the runtime. */
2602 if (value_type (method
)->code () != TYPE_CODE_FUNC
)
2603 error (_("method address has symbol information "
2604 "with non-function type; skipping"));
2606 /* Create a function pointer of the appropriate type, and
2607 replace its value with the value of msg_send or
2608 msg_send_stret. We must use a pointer here, as
2609 msg_send and msg_send_stret are of pointer type, and
2610 the representation may be different on systems that use
2611 function descriptors. */
2614 = value_from_pointer (lookup_pointer_type (value_type (method
)),
2615 value_as_address (msg_send_stret
));
2618 = value_from_pointer (lookup_pointer_type (value_type (method
)),
2619 value_as_address (msg_send
));
2624 called_method
= msg_send_stret
;
2626 called_method
= msg_send
;
2629 if (noside
== EVAL_SKIP
)
2630 return eval_skip_value (exp
);
2632 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2634 /* If the return type doesn't look like a function type,
2635 call an error. This can happen if somebody tries to
2636 turn a variable into a function call. This is here
2637 because people often want to call, eg, strcmp, which
2638 gdb doesn't know is a function. If gdb isn't asked for
2639 it's opinion (ie. through "whatis"), it won't offer
2642 struct type
*callee_type
= value_type (called_method
);
2644 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
2645 callee_type
= TYPE_TARGET_TYPE (callee_type
);
2646 callee_type
= TYPE_TARGET_TYPE (callee_type
);
2650 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
2651 return allocate_value (expect_type
);
2653 return allocate_value (callee_type
);
2656 error (_("Expression of type other than "
2657 "\"method returning ...\" used as a method"));
2660 /* Now depending on whether we found a symbol for the method,
2661 we will either call the runtime dispatcher or the method
2665 args
[1] = value_from_longest (long_type
, selector
);
2667 if (gnu_runtime
&& (method
!= NULL
))
2669 /* Function objc_msg_lookup returns a pointer. */
2670 struct type
*tem_type
= value_type (called_method
);
2671 tem_type
= lookup_pointer_type (lookup_function_type (tem_type
));
2672 deprecated_set_value_type (called_method
, tem_type
);
2673 called_method
= call_function_by_hand (called_method
, NULL
, args
);
2676 return call_function_by_hand (called_method
, NULL
, args
);
2679 /* Helper function for MULTI_SUBSCRIPT. */
2681 static struct value
*
2682 eval_multi_subscript (struct type
*expect_type
, struct expression
*exp
,
2683 enum noside noside
, value
*arg1
,
2684 gdb::array_view
<value
*> args
)
2686 if (noside
== EVAL_SKIP
)
2688 for (value
*arg2
: args
)
2690 if (binop_user_defined_p (MULTI_SUBSCRIPT
, arg1
, arg2
))
2692 arg1
= value_x_binop (arg1
, arg2
, MULTI_SUBSCRIPT
, OP_NULL
, noside
);
2696 arg1
= coerce_ref (arg1
);
2697 struct type
*type
= check_typedef (value_type (arg1
));
2699 switch (type
->code ())
2702 case TYPE_CODE_ARRAY
:
2703 case TYPE_CODE_STRING
:
2704 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2709 error (_("cannot subscript something of type `%s'"),
2712 error (_("cannot subscript requested type"));
2723 objc_msgcall_operation::evaluate (struct type
*expect_type
,
2724 struct expression
*exp
,
2727 enum noside sub_no_side
= EVAL_NORMAL
;
2728 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2730 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2731 sub_no_side
= EVAL_NORMAL
;
2733 sub_no_side
= noside
;
2735 = std::get
<1> (m_storage
)->evaluate (selector_type
, exp
, sub_no_side
);
2737 if (value_as_long (target
) == 0)
2738 sub_no_side
= EVAL_AVOID_SIDE_EFFECTS
;
2740 sub_no_side
= noside
;
2741 std::vector
<operation_up
> &args
= std::get
<2> (m_storage
);
2742 value
**argvec
= XALLOCAVEC (struct value
*, args
.size () + 3);
2743 argvec
[0] = nullptr;
2744 argvec
[1] = nullptr;
2745 for (int i
= 0; i
< args
.size (); ++i
)
2746 argvec
[i
+ 2] = args
[i
]->evaluate_with_coercion (exp
, sub_no_side
);
2747 argvec
[args
.size () + 2] = nullptr;
2749 return eval_op_objc_msgcall (expect_type
, exp
, noside
, std::
2750 get
<0> (m_storage
), target
,
2751 gdb::make_array_view (argvec
,
2756 multi_subscript_operation::evaluate (struct type
*expect_type
,
2757 struct expression
*exp
,
2760 value
*arg1
= std::get
<0> (m_storage
)->evaluate_with_coercion (exp
, noside
);
2761 std::vector
<operation_up
> &values
= std::get
<1> (m_storage
);
2762 value
**argvec
= XALLOCAVEC (struct value
*, values
.size ());
2763 for (int ix
= 0; ix
< values
.size (); ++ix
)
2764 argvec
[ix
] = values
[ix
]->evaluate_with_coercion (exp
, noside
);
2765 return eval_multi_subscript (expect_type
, exp
, noside
, arg1
,
2766 gdb::make_array_view (argvec
, values
.size ()));
2770 logical_and_operation::evaluate (struct type
*expect_type
,
2771 struct expression
*exp
,
2774 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2775 if (noside
== EVAL_SKIP
)
2776 return eval_skip_value (exp
);
2778 value
*arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
,
2779 EVAL_AVOID_SIDE_EFFECTS
);
2781 if (binop_user_defined_p (BINOP_LOGICAL_AND
, arg1
, arg2
))
2783 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2784 return value_x_binop (arg1
, arg2
, BINOP_LOGICAL_AND
, OP_NULL
, noside
);
2788 int tem
= value_logical_not (arg1
);
2791 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2792 tem
= value_logical_not (arg2
);
2794 struct type
*type
= language_bool_type (exp
->language_defn
,
2796 return value_from_longest (type
, !tem
);
2801 logical_or_operation::evaluate (struct type
*expect_type
,
2802 struct expression
*exp
,
2805 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2806 if (noside
== EVAL_SKIP
)
2807 return eval_skip_value (exp
);
2809 value
*arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
,
2810 EVAL_AVOID_SIDE_EFFECTS
);
2812 if (binop_user_defined_p (BINOP_LOGICAL_OR
, arg1
, arg2
))
2814 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2815 return value_x_binop (arg1
, arg2
, BINOP_LOGICAL_OR
, OP_NULL
, noside
);
2819 int tem
= value_logical_not (arg1
);
2822 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2823 tem
= value_logical_not (arg2
);
2826 struct type
*type
= language_bool_type (exp
->language_defn
,
2828 return value_from_longest (type
, !tem
);
2833 adl_func_operation::evaluate (struct type
*expect_type
,
2834 struct expression
*exp
,
2837 std::vector
<operation_up
> &arg_ops
= std::get
<2> (m_storage
);
2838 std::vector
<value
*> args (arg_ops
.size ());
2839 for (int i
= 0; i
< arg_ops
.size (); ++i
)
2840 args
[i
] = arg_ops
[i
]->evaluate_with_coercion (exp
, noside
);
2842 struct symbol
*symp
;
2843 find_overload_match (args
, std::get
<0> (m_storage
).c_str (),
2846 nullptr, &symp
, nullptr, 0, noside
);
2847 if (SYMBOL_TYPE (symp
)->code () == TYPE_CODE_ERROR
)
2848 error_unknown_type (symp
->print_name ());
2849 value
*callee
= evaluate_var_value (noside
, std::get
<1> (m_storage
), symp
);
2850 return evaluate_subexp_do_call (exp
, noside
, callee
, args
,
2851 nullptr, expect_type
);
2855 /* This function evaluates brace-initializers (in C/C++) for
2859 array_operation::evaluate_struct_tuple (struct value
*struct_val
,
2860 struct expression
*exp
,
2861 enum noside noside
, int nargs
)
2863 const std::vector
<operation_up
> &in_args
= std::get
<2> (m_storage
);
2864 struct type
*struct_type
= check_typedef (value_type (struct_val
));
2865 struct type
*field_type
;
2869 while (--nargs
>= 0)
2871 struct value
*val
= NULL
;
2872 int bitpos
, bitsize
;
2876 /* Skip static fields. */
2877 while (fieldno
< struct_type
->num_fields ()
2878 && field_is_static (&struct_type
->field (fieldno
)))
2880 if (fieldno
>= struct_type
->num_fields ())
2881 error (_("too many initializers"));
2882 field_type
= struct_type
->field (fieldno
).type ();
2883 if (field_type
->code () == TYPE_CODE_UNION
2884 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
2885 error (_("don't know which variant you want to set"));
2887 /* Here, struct_type is the type of the inner struct,
2888 while substruct_type is the type of the inner struct.
2889 These are the same for normal structures, but a variant struct
2890 contains anonymous union fields that contain substruct fields.
2891 The value fieldno is the index of the top-level (normal or
2892 anonymous union) field in struct_field, while the value
2893 subfieldno is the index of the actual real (named inner) field
2894 in substruct_type. */
2896 field_type
= struct_type
->field (fieldno
).type ();
2898 val
= in_args
[idx
++]->evaluate (field_type
, exp
, noside
);
2900 /* Now actually set the field in struct_val. */
2902 /* Assign val to field fieldno. */
2903 if (value_type (val
) != field_type
)
2904 val
= value_cast (field_type
, val
);
2906 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
2907 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
2908 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
2910 modify_field (struct_type
, addr
,
2911 value_as_long (val
), bitpos
% 8, bitsize
);
2913 memcpy (addr
, value_contents (val
),
2914 TYPE_LENGTH (value_type (val
)));
2921 array_operation::evaluate (struct type
*expect_type
,
2922 struct expression
*exp
,
2926 int tem2
= std::get
<0> (m_storage
);
2927 int tem3
= std::get
<1> (m_storage
);
2928 const std::vector
<operation_up
> &in_args
= std::get
<2> (m_storage
);
2929 int nargs
= tem3
- tem2
+ 1;
2930 struct type
*type
= expect_type
? check_typedef (expect_type
) : nullptr;
2932 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2933 && type
->code () == TYPE_CODE_STRUCT
)
2935 struct value
*rec
= allocate_value (expect_type
);
2937 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
2938 return evaluate_struct_tuple (rec
, exp
, noside
, nargs
);
2941 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2942 && type
->code () == TYPE_CODE_ARRAY
)
2944 struct type
*range_type
= type
->index_type ();
2945 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
2946 struct value
*array
= allocate_value (expect_type
);
2947 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
2948 LONGEST low_bound
, high_bound
, index
;
2950 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
2953 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
2956 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
2957 for (tem
= nargs
; --nargs
>= 0;)
2959 struct value
*element
;
2961 element
= in_args
[index
- low_bound
]->evaluate (element_type
,
2963 if (value_type (element
) != element_type
)
2964 element
= value_cast (element_type
, element
);
2965 if (index
> high_bound
)
2966 /* To avoid memory corruption. */
2967 error (_("Too many array elements"));
2968 memcpy (value_contents_raw (array
)
2969 + (index
- low_bound
) * element_size
,
2970 value_contents (element
),
2977 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2978 && type
->code () == TYPE_CODE_SET
)
2980 struct value
*set
= allocate_value (expect_type
);
2981 gdb_byte
*valaddr
= value_contents_raw (set
);
2982 struct type
*element_type
= type
->index_type ();
2983 struct type
*check_type
= element_type
;
2984 LONGEST low_bound
, high_bound
;
2986 /* Get targettype of elementtype. */
2987 while (check_type
->code () == TYPE_CODE_RANGE
2988 || check_type
->code () == TYPE_CODE_TYPEDEF
)
2989 check_type
= TYPE_TARGET_TYPE (check_type
);
2991 if (!get_discrete_bounds (element_type
, &low_bound
, &high_bound
))
2992 error (_("(power)set type with unknown size"));
2993 memset (valaddr
, '\0', TYPE_LENGTH (type
));
2995 for (tem
= 0; tem
< nargs
; tem
++)
2997 LONGEST range_low
, range_high
;
2998 struct type
*range_low_type
, *range_high_type
;
2999 struct value
*elem_val
;
3001 elem_val
= in_args
[idx
++]->evaluate (element_type
, exp
, noside
);
3002 range_low_type
= range_high_type
= value_type (elem_val
);
3003 range_low
= range_high
= value_as_long (elem_val
);
3005 /* Check types of elements to avoid mixture of elements from
3006 different types. Also check if type of element is "compatible"
3007 with element type of powerset. */
3008 if (range_low_type
->code () == TYPE_CODE_RANGE
)
3009 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
3010 if (range_high_type
->code () == TYPE_CODE_RANGE
)
3011 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
3012 if ((range_low_type
->code () != range_high_type
->code ())
3013 || (range_low_type
->code () == TYPE_CODE_ENUM
3014 && (range_low_type
!= range_high_type
)))
3015 /* different element modes. */
3016 error (_("POWERSET tuple elements of different mode"));
3017 if ((check_type
->code () != range_low_type
->code ())
3018 || (check_type
->code () == TYPE_CODE_ENUM
3019 && range_low_type
!= check_type
))
3020 error (_("incompatible POWERSET tuple elements"));
3021 if (range_low
> range_high
)
3023 warning (_("empty POWERSET tuple range"));
3026 if (range_low
< low_bound
|| range_high
> high_bound
)
3027 error (_("POWERSET tuple element out of range"));
3028 range_low
-= low_bound
;
3029 range_high
-= low_bound
;
3030 for (; range_low
<= range_high
; range_low
++)
3032 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
3034 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
3035 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
3036 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
3043 value
**argvec
= XALLOCAVEC (struct value
*, nargs
);
3044 for (tem
= 0; tem
< nargs
; tem
++)
3046 /* Ensure that array expressions are coerced into pointer
3048 argvec
[tem
] = in_args
[tem
]->evaluate_with_coercion (exp
, noside
);
3050 if (noside
== EVAL_SKIP
)
3051 return eval_skip_value (exp
);
3052 return value_array (tem2
, tem3
, argvec
);
3058 evaluate_subexp_standard (struct type
*expect_type
,
3059 struct expression
*exp
, int *pos
,
3063 int tem
, tem2
, tem3
;
3065 struct value
*arg1
= NULL
;
3066 struct value
*arg2
= NULL
;
3069 struct value
**argvec
;
3071 struct type
**arg_types
;
3074 op
= exp
->elts
[pc
].opcode
;
3079 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3080 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
3081 return eval_op_scope (expect_type
, exp
, noside
,
3082 exp
->elts
[pc
+ 1].type
,
3083 &exp
->elts
[pc
+ 3].string
);
3087 return value_from_longest (exp
->elts
[pc
+ 1].type
,
3088 exp
->elts
[pc
+ 2].longconst
);
3092 return value_from_contents (exp
->elts
[pc
+ 1].type
,
3093 exp
->elts
[pc
+ 2].floatconst
);
3099 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
3100 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
3101 error_unknown_type (var
->print_name ());
3102 if (noside
!= EVAL_SKIP
)
3103 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
3106 /* Return a dummy value of the correct type when skipping, so
3107 that parent functions know what is to be skipped. */
3108 return allocate_value (SYMBOL_TYPE (var
));
3112 case OP_VAR_MSYM_VALUE
:
3116 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3117 return eval_op_var_msym_value (expect_type
, exp
, noside
,
3119 exp
->elts
[pc
+ 1].objfile
);
3122 case OP_VAR_ENTRY_VALUE
:
3126 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
3128 return eval_op_var_entry_value (expect_type
, exp
, noside
, sym
);
3131 case OP_FUNC_STATIC_VAR
:
3132 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
3133 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
3134 if (noside
== EVAL_SKIP
)
3135 return eval_skip_value (exp
);
3138 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
3140 return eval_op_func_static_var (expect_type
, exp
, noside
, func
,
3141 &exp
->elts
[pc
+ 2].string
);
3147 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
3151 const char *name
= &exp
->elts
[pc
+ 2].string
;
3153 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
3154 return eval_op_register (expect_type
, exp
, noside
, name
);
3158 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
3159 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
3161 case OP_INTERNALVAR
:
3163 return value_of_internalvar (exp
->gdbarch
,
3164 exp
->elts
[pc
+ 1].internalvar
);
3167 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
3168 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
3169 return eval_op_string (expect_type
, exp
, noside
, tem
,
3170 &exp
->elts
[pc
+ 2].string
);
3172 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
3173 NSString constant. */
3174 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
3175 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
3176 if (noside
== EVAL_SKIP
)
3177 return eval_skip_value (exp
);
3178 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
3182 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
3183 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3184 nargs
= tem3
- tem2
+ 1;
3185 type
= expect_type
? check_typedef (expect_type
) : nullptr;
3187 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
3188 && type
->code () == TYPE_CODE_STRUCT
)
3190 struct value
*rec
= allocate_value (expect_type
);
3192 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
3193 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
3196 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
3197 && type
->code () == TYPE_CODE_ARRAY
)
3199 struct type
*range_type
= type
->index_type ();
3200 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
3201 struct value
*array
= allocate_value (expect_type
);
3202 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
3203 LONGEST low_bound
, high_bound
, index
;
3205 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
3208 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
3211 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
3212 for (tem
= nargs
; --nargs
>= 0;)
3214 struct value
*element
;
3216 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
3217 if (value_type (element
) != element_type
)
3218 element
= value_cast (element_type
, element
);
3219 if (index
> high_bound
)
3220 /* To avoid memory corruption. */
3221 error (_("Too many array elements"));
3222 memcpy (value_contents_raw (array
)
3223 + (index
- low_bound
) * element_size
,
3224 value_contents (element
),
3231 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
3232 && type
->code () == TYPE_CODE_SET
)
3234 struct value
*set
= allocate_value (expect_type
);
3235 gdb_byte
*valaddr
= value_contents_raw (set
);
3236 struct type
*element_type
= type
->index_type ();
3237 struct type
*check_type
= element_type
;
3238 LONGEST low_bound
, high_bound
;
3240 /* Get targettype of elementtype. */
3241 while (check_type
->code () == TYPE_CODE_RANGE
3242 || check_type
->code () == TYPE_CODE_TYPEDEF
)
3243 check_type
= TYPE_TARGET_TYPE (check_type
);
3245 if (!get_discrete_bounds (element_type
, &low_bound
, &high_bound
))
3246 error (_("(power)set type with unknown size"));
3247 memset (valaddr
, '\0', TYPE_LENGTH (type
));
3248 for (tem
= 0; tem
< nargs
; tem
++)
3250 LONGEST range_low
, range_high
;
3251 struct type
*range_low_type
, *range_high_type
;
3252 struct value
*elem_val
;
3254 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
3255 range_low_type
= range_high_type
= value_type (elem_val
);
3256 range_low
= range_high
= value_as_long (elem_val
);
3258 /* Check types of elements to avoid mixture of elements from
3259 different types. Also check if type of element is "compatible"
3260 with element type of powerset. */
3261 if (range_low_type
->code () == TYPE_CODE_RANGE
)
3262 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
3263 if (range_high_type
->code () == TYPE_CODE_RANGE
)
3264 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
3265 if ((range_low_type
->code () != range_high_type
->code ())
3266 || (range_low_type
->code () == TYPE_CODE_ENUM
3267 && (range_low_type
!= range_high_type
)))
3268 /* different element modes. */
3269 error (_("POWERSET tuple elements of different mode"));
3270 if ((check_type
->code () != range_low_type
->code ())
3271 || (check_type
->code () == TYPE_CODE_ENUM
3272 && range_low_type
!= check_type
))
3273 error (_("incompatible POWERSET tuple elements"));
3274 if (range_low
> range_high
)
3276 warning (_("empty POWERSET tuple range"));
3279 if (range_low
< low_bound
|| range_high
> high_bound
)
3280 error (_("POWERSET tuple element out of range"));
3281 range_low
-= low_bound
;
3282 range_high
-= low_bound
;
3283 for (; range_low
<= range_high
; range_low
++)
3285 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
3287 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
3288 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
3289 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
3296 argvec
= XALLOCAVEC (struct value
*, nargs
);
3297 for (tem
= 0; tem
< nargs
; tem
++)
3299 /* Ensure that array expressions are coerced into pointer
3301 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
3303 if (noside
== EVAL_SKIP
)
3304 return eval_skip_value (exp
);
3305 return value_array (tem2
, tem3
, argvec
);
3309 struct value
*array
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3310 struct value
*low
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3311 struct value
*upper
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3312 return eval_op_ternop (expect_type
, exp
, noside
, array
, low
, upper
);
3316 /* Skip third and second args to evaluate the first one. */
3317 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3318 if (value_logical_not (arg1
))
3320 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
3321 return evaluate_subexp (nullptr, exp
, pos
, noside
);
3325 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3326 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
3330 case OP_OBJC_SELECTOR
:
3331 { /* Objective C @selector operator. */
3332 char *sel
= &exp
->elts
[pc
+ 2].string
;
3333 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
3335 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
3337 sel
[len
] = 0; /* Make sure it's terminated. */
3339 return eval_op_objc_selector (expect_type
, exp
, noside
, sel
);
3342 case OP_OBJC_MSGCALL
:
3343 { /* Objective C message (method) call. */
3344 CORE_ADDR selector
= 0;
3346 enum noside sub_no_side
= EVAL_NORMAL
;
3348 struct value
*target
= NULL
;
3350 struct type
*selector_type
= NULL
;
3352 selector
= exp
->elts
[pc
+ 1].longconst
;
3353 nargs
= exp
->elts
[pc
+ 2].longconst
;
3354 argvec
= XALLOCAVEC (struct value
*, nargs
+ 3);
3358 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
3360 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3361 sub_no_side
= EVAL_NORMAL
;
3363 sub_no_side
= noside
;
3365 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
3367 if (value_as_long (target
) == 0)
3368 sub_no_side
= EVAL_SKIP
;
3370 sub_no_side
= noside
;
3372 /* Now depending on whether we found a symbol for the method,
3373 we will either call the runtime dispatcher or the method
3376 argvec
[0] = nullptr;
3377 argvec
[1] = nullptr;
3378 /* User-supplied arguments. */
3379 for (tem
= 0; tem
< nargs
; tem
++)
3380 argvec
[tem
+ 2] = evaluate_subexp_with_coercion (exp
, pos
,
3382 argvec
[tem
+ 3] = 0;
3384 auto call_args
= gdb::make_array_view (argvec
, nargs
+ 3);
3386 return eval_op_objc_msgcall (expect_type
, exp
, noside
, selector
,
3392 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
3395 /* We have a complex number, There should be 2 floating
3396 point numbers that compose it. */
3398 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3399 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3401 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
3403 case STRUCTOP_STRUCT
:
3404 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
3405 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
3406 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3407 return eval_op_structop_struct (expect_type
, exp
, noside
, arg1
,
3408 &exp
->elts
[pc
+ 2].string
);
3411 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
3412 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
3413 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3414 return eval_op_structop_ptr (expect_type
, exp
, noside
, arg1
,
3415 &exp
->elts
[pc
+ 2].string
);
3417 case STRUCTOP_MEMBER
:
3419 if (op
== STRUCTOP_MEMBER
)
3420 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
3422 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3424 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3426 return eval_op_member (expect_type
, exp
, noside
, arg1
, arg2
);
3430 type_instance_flags flags
3431 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
3432 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3433 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
3434 for (ix
= 0; ix
< nargs
; ++ix
)
3435 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
3437 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
3438 *(pos
) += 4 + nargs
;
3439 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
3444 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
3445 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
3446 return eval_op_concat (expect_type
, exp
, noside
, arg1
, arg2
);
3449 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3450 /* Special-case assignments where the left-hand-side is a
3451 convenience variable -- in these, don't bother setting an
3452 expected type. This avoids a weird case where re-assigning a
3453 string or array to an internal variable could error with "Too
3454 many array elements". */
3455 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
3457 : value_type (arg1
),
3460 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
3462 if (binop_user_defined_p (op
, arg1
, arg2
))
3463 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
3465 return value_assign (arg1
, arg2
);
3467 case BINOP_ASSIGN_MODIFY
:
3469 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3470 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3471 op
= exp
->elts
[pc
+ 1].opcode
;
3472 return eval_binop_assign_modify (expect_type
, exp
, noside
, op
,
3476 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
3477 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
3478 return eval_op_add (expect_type
, exp
, noside
, arg1
, arg2
);
3481 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
3482 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
3483 return eval_op_sub (expect_type
, exp
, noside
, arg1
, arg2
);
3493 case BINOP_BITWISE_AND
:
3494 case BINOP_BITWISE_IOR
:
3495 case BINOP_BITWISE_XOR
:
3496 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3497 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3498 return eval_op_binary (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3500 case BINOP_SUBSCRIPT
:
3501 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3502 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3503 return eval_op_subscript (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3505 case MULTI_SUBSCRIPT
:
3507 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
3508 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
3509 argvec
= XALLOCAVEC (struct value
*, nargs
);
3510 for (ix
= 0; ix
< nargs
; ++ix
)
3511 argvec
[ix
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
3512 return eval_multi_subscript (expect_type
, exp
, noside
, arg1
,
3513 gdb::make_array_view (argvec
, nargs
));
3515 case BINOP_LOGICAL_AND
:
3516 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3517 if (noside
== EVAL_SKIP
)
3519 evaluate_subexp (nullptr, exp
, pos
, noside
);
3520 return eval_skip_value (exp
);
3524 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3527 if (binop_user_defined_p (op
, arg1
, arg2
))
3529 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3530 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
3534 tem
= value_logical_not (arg1
);
3536 = evaluate_subexp (nullptr, exp
, pos
, (tem
? EVAL_SKIP
: noside
));
3537 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
3538 return value_from_longest (type
,
3539 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
3542 case BINOP_LOGICAL_OR
:
3543 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3544 if (noside
== EVAL_SKIP
)
3546 evaluate_subexp (nullptr, exp
, pos
, noside
);
3547 return eval_skip_value (exp
);
3551 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3554 if (binop_user_defined_p (op
, arg1
, arg2
))
3556 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3557 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
3561 tem
= value_logical_not (arg1
);
3563 = evaluate_subexp (nullptr, exp
, pos
, (!tem
? EVAL_SKIP
: noside
));
3564 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
3565 return value_from_longest (type
,
3566 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
3570 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3571 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3572 return eval_op_equal (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3574 case BINOP_NOTEQUAL
:
3575 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3576 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3577 return eval_op_notequal (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3580 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3581 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3582 return eval_op_less (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3585 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3586 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3587 return eval_op_gtr (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3590 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3591 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3592 return eval_op_geq (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3595 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3596 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3597 return eval_op_leq (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3600 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3601 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3602 return eval_op_repeat (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3605 evaluate_subexp (nullptr, exp
, pos
, noside
);
3606 return evaluate_subexp (nullptr, exp
, pos
, noside
);
3609 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3610 return eval_op_plus (expect_type
, exp
, noside
, op
, arg1
);
3613 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3614 return eval_op_neg (expect_type
, exp
, noside
, op
, arg1
);
3616 case UNOP_COMPLEMENT
:
3617 /* C++: check for and handle destructor names. */
3619 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3620 return eval_op_complement (expect_type
, exp
, noside
, op
, arg1
);
3622 case UNOP_LOGICAL_NOT
:
3623 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3624 return eval_op_lognot (expect_type
, exp
, noside
, op
, arg1
);
3627 if (expect_type
&& expect_type
->code () == TYPE_CODE_PTR
)
3628 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
3629 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3630 return eval_op_ind (expect_type
, exp
, noside
, arg1
);
3633 /* C++: check for and handle pointer to members. */
3635 if (noside
== EVAL_SKIP
)
3637 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
3638 return eval_skip_value (exp
);
3641 return evaluate_subexp_for_address (exp
, pos
, noside
);
3644 if (noside
== EVAL_SKIP
)
3646 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
3647 return eval_skip_value (exp
);
3649 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
3652 arg1
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3653 return eval_op_alignof (expect_type
, exp
, noside
, arg1
);
3657 type
= exp
->elts
[pc
+ 1].type
;
3658 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
3660 case UNOP_CAST_TYPE
:
3661 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3662 type
= value_type (arg1
);
3663 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
3665 case UNOP_DYNAMIC_CAST
:
3666 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3667 type
= value_type (arg1
);
3668 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
3669 if (noside
== EVAL_SKIP
)
3670 return eval_skip_value (exp
);
3671 return value_dynamic_cast (type
, arg1
);
3673 case UNOP_REINTERPRET_CAST
:
3674 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3675 type
= value_type (arg1
);
3676 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
3677 if (noside
== EVAL_SKIP
)
3678 return eval_skip_value (exp
);
3679 return value_reinterpret_cast (type
, arg1
);
3683 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3684 return eval_op_memval (expect_type
, exp
, noside
, arg1
,
3685 exp
->elts
[pc
+ 1].type
);
3687 case UNOP_MEMVAL_TYPE
:
3688 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3689 type
= value_type (arg1
);
3690 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3691 return eval_op_memval (expect_type
, exp
, noside
, arg1
, type
);
3693 case UNOP_PREINCREMENT
:
3694 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3695 return eval_op_preinc (expect_type
, exp
, noside
, op
, arg1
);
3697 case UNOP_PREDECREMENT
:
3698 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3699 return eval_op_predec (expect_type
, exp
, noside
, op
, arg1
);
3701 case UNOP_POSTINCREMENT
:
3702 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3703 return eval_op_postinc (expect_type
, exp
, noside
, op
, arg1
);
3705 case UNOP_POSTDECREMENT
:
3706 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3707 return eval_op_postdec (expect_type
, exp
, noside
, op
, arg1
);
3711 return value_of_this (exp
->language_defn
);
3714 /* The value is not supposed to be used. This is here to make it
3715 easier to accommodate expressions that contain types. */
3717 return eval_op_type (expect_type
, exp
, noside
, exp
->elts
[pc
+ 1].type
);
3721 if (noside
== EVAL_SKIP
)
3723 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
3724 return eval_skip_value (exp
);
3726 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3728 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
3729 struct value
*result
;
3731 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3733 /* 'decltype' has special semantics for lvalues. */
3734 if (op
== OP_DECLTYPE
3735 && (sub_op
== BINOP_SUBSCRIPT
3736 || sub_op
== STRUCTOP_MEMBER
3737 || sub_op
== STRUCTOP_MPTR
3738 || sub_op
== UNOP_IND
3739 || sub_op
== STRUCTOP_STRUCT
3740 || sub_op
== STRUCTOP_PTR
3741 || sub_op
== OP_SCOPE
))
3743 type
= value_type (result
);
3745 if (!TYPE_IS_REFERENCE (type
))
3747 type
= lookup_lvalue_reference_type (type
);
3748 result
= allocate_value (type
);
3755 error (_("Attempt to use a type as an expression"));
3759 struct value
*result
;
3760 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
3762 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
3763 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3765 result
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3767 if (noside
!= EVAL_NORMAL
)
3768 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
3770 return cplus_typeid (result
);
3774 /* Removing this case and compiling with gcc -Wall reveals that
3775 a lot of cases are hitting this case. Some of these should
3776 probably be removed from expression.h; others are legitimate
3777 expressions which are (apparently) not fully implemented.
3779 If there are any cases landing here which mean a user error,
3780 then they should be separate cases, with more descriptive
3783 error (_("GDB does not (yet) know how to "
3784 "evaluate that kind of expression"));
3787 gdb_assert_not_reached ("missed return?");
3790 /* Helper for evaluate_subexp_for_address. */
3793 evaluate_subexp_for_address_base (struct expression
*exp
, enum noside noside
,
3796 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3798 struct type
*type
= check_typedef (value_type (x
));
3800 if (TYPE_IS_REFERENCE (type
))
3801 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3803 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3804 return value_zero (lookup_pointer_type (value_type (x
)),
3807 error (_("Attempt to take address of "
3808 "value not located in memory."));
3810 return value_addr (x
);
3813 /* Evaluate a subexpression of EXP, at index *POS,
3814 and return the address of that subexpression.
3815 Advance *POS over the subexpression.
3816 If the subexpression isn't an lvalue, get an error.
3817 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
3818 then only the type of the result need be correct. */
3820 static struct value
*
3821 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
3831 op
= exp
->elts
[pc
].opcode
;
3837 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3839 /* We can't optimize out "&*" if there's a user-defined operator*. */
3840 if (unop_user_defined_p (op
, x
))
3842 x
= value_x_unop (x
, op
, noside
);
3843 goto default_case_after_eval
;
3846 return coerce_array (x
);
3850 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
3851 evaluate_subexp (nullptr, exp
, pos
, noside
));
3853 case UNOP_MEMVAL_TYPE
:
3858 x
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3859 type
= value_type (x
);
3860 return value_cast (lookup_pointer_type (type
),
3861 evaluate_subexp (nullptr, exp
, pos
, noside
));
3865 var
= exp
->elts
[pc
+ 2].symbol
;
3867 /* C++: The "address" of a reference should yield the address
3868 * of the object pointed to. Let value_addr() deal with it. */
3869 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
3873 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3876 lookup_pointer_type (SYMBOL_TYPE (var
));
3877 enum address_class sym_class
= SYMBOL_CLASS (var
);
3879 if (sym_class
== LOC_CONST
3880 || sym_class
== LOC_CONST_BYTES
3881 || sym_class
== LOC_REGISTER
)
3882 error (_("Attempt to take address of register or constant."));
3885 value_zero (type
, not_lval
);
3888 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3890 case OP_VAR_MSYM_VALUE
:
3894 value
*val
= evaluate_var_msym_value (noside
,
3895 exp
->elts
[pc
+ 1].objfile
,
3896 exp
->elts
[pc
+ 2].msymbol
);
3897 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3899 struct type
*type
= lookup_pointer_type (value_type (val
));
3900 return value_zero (type
, not_lval
);
3903 return value_addr (val
);
3907 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3908 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3909 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3910 &exp
->elts
[pc
+ 3].string
,
3913 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3918 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3919 default_case_after_eval
:
3920 return evaluate_subexp_for_address_base (exp
, noside
, x
);
3928 operation::evaluate_for_cast (struct type
*expect_type
,
3929 struct expression
*exp
,
3932 value
*val
= evaluate (expect_type
, exp
, noside
);
3933 if (noside
== EVAL_SKIP
)
3934 return eval_skip_value (exp
);
3935 return value_cast (expect_type
, val
);
3939 operation::evaluate_for_address (struct expression
*exp
, enum noside noside
)
3941 value
*val
= evaluate (nullptr, exp
, noside
);
3942 return evaluate_subexp_for_address_base (exp
, noside
, val
);
3946 scope_operation::evaluate_for_address (struct expression
*exp
,
3949 value
*x
= value_aggregate_elt (std::get
<0> (m_storage
),
3950 std::get
<1> (m_storage
).c_str (),
3953 error (_("There is no field named %s"), std::get
<1> (m_storage
).c_str ());
3958 unop_ind_base_operation::evaluate_for_address (struct expression
*exp
,
3961 value
*x
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
3963 /* We can't optimize out "&*" if there's a user-defined operator*. */
3964 if (unop_user_defined_p (UNOP_IND
, x
))
3966 x
= value_x_unop (x
, UNOP_IND
, noside
);
3967 return evaluate_subexp_for_address_base (exp
, noside
, x
);
3970 return coerce_array (x
);
3974 var_msym_value_operation::evaluate_for_address (struct expression
*exp
,
3977 value
*val
= evaluate_var_msym_value (noside
,
3978 std::get
<1> (m_storage
),
3979 std::get
<0> (m_storage
));
3980 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3982 struct type
*type
= lookup_pointer_type (value_type (val
));
3983 return value_zero (type
, not_lval
);
3986 return value_addr (val
);
3990 unop_memval_operation::evaluate_for_address (struct expression
*exp
,
3993 return value_cast (lookup_pointer_type (std::get
<1> (m_storage
)),
3994 std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
));
3998 unop_memval_type_operation::evaluate_for_address (struct expression
*exp
,
4001 value
*typeval
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
4002 EVAL_AVOID_SIDE_EFFECTS
);
4003 struct type
*type
= value_type (typeval
);
4004 return value_cast (lookup_pointer_type (type
),
4005 std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
));
4010 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
4011 When used in contexts where arrays will be coerced anyway, this is
4012 equivalent to `evaluate_subexp' but much faster because it avoids
4013 actually fetching array contents (perhaps obsolete now that we have
4016 Note that we currently only do the coercion for C expressions, where
4017 arrays are zero based and the coercion is correct. For other languages,
4018 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
4019 to decide if coercion is appropriate. */
4022 evaluate_subexp_with_coercion (struct expression
*exp
,
4023 int *pos
, enum noside noside
)
4032 op
= exp
->elts
[pc
].opcode
;
4037 var
= exp
->elts
[pc
+ 2].symbol
;
4038 type
= check_typedef (SYMBOL_TYPE (var
));
4039 if (type
->code () == TYPE_CODE_ARRAY
4040 && !type
->is_vector ()
4041 && CAST_IS_CONVERSION (exp
->language_defn
))
4044 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
4045 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
4051 return evaluate_subexp (nullptr, exp
, pos
, noside
);
4059 var_value_operation::evaluate_for_address (struct expression
*exp
,
4062 symbol
*var
= std::get
<0> (m_storage
);
4064 /* C++: The "address" of a reference should yield the address
4065 * of the object pointed to. Let value_addr() deal with it. */
4066 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
4067 return operation::evaluate_for_address (exp
, noside
);
4069 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
4071 struct type
*type
= lookup_pointer_type (SYMBOL_TYPE (var
));
4072 enum address_class sym_class
= SYMBOL_CLASS (var
);
4074 if (sym_class
== LOC_CONST
4075 || sym_class
== LOC_CONST_BYTES
4076 || sym_class
== LOC_REGISTER
)
4077 error (_("Attempt to take address of register or constant."));
4079 return value_zero (type
, not_lval
);
4082 return address_of_variable (var
, std::get
<1> (m_storage
));
4086 var_value_operation::evaluate_with_coercion (struct expression
*exp
,
4089 struct symbol
*var
= std::get
<0> (m_storage
);
4090 struct type
*type
= check_typedef (SYMBOL_TYPE (var
));
4091 if (type
->code () == TYPE_CODE_ARRAY
4092 && !type
->is_vector ()
4093 && CAST_IS_CONVERSION (exp
->language_defn
))
4095 struct value
*val
= address_of_variable (var
, std::get
<1> (m_storage
));
4096 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)), val
);
4098 return evaluate (nullptr, exp
, noside
);
4103 /* Helper function for evaluating the size of a type. */
4106 evaluate_subexp_for_sizeof_base (struct expression
*exp
, struct type
*type
)
4108 /* FIXME: This should be size_t. */
4109 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
4110 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
4111 "When applied to a reference or a reference type, the result is
4112 the size of the referenced type." */
4113 type
= check_typedef (type
);
4114 if (exp
->language_defn
->la_language
== language_cplus
4115 && (TYPE_IS_REFERENCE (type
)))
4116 type
= check_typedef (TYPE_TARGET_TYPE (type
));
4117 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
4120 /* Evaluate a subexpression of EXP, at index *POS,
4121 and return a value for the size of that subexpression.
4122 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
4123 we allow side-effects on the operand if its type is a variable
4126 static struct value
*
4127 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
4130 /* FIXME: This should be size_t. */
4131 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
4138 op
= exp
->elts
[pc
].opcode
;
4142 /* This case is handled specially
4143 so that we avoid creating a value for the result type.
4144 If the result type is very big, it's desirable not to
4145 create a value unnecessarily. */
4148 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
4149 type
= check_typedef (value_type (val
));
4150 if (type
->code () != TYPE_CODE_PTR
4151 && !TYPE_IS_REFERENCE (type
)
4152 && type
->code () != TYPE_CODE_ARRAY
)
4153 error (_("Attempt to take contents of a non-pointer value."));
4154 type
= TYPE_TARGET_TYPE (type
);
4155 if (is_dynamic_type (type
))
4156 type
= value_type (value_ind (val
));
4157 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
4161 type
= exp
->elts
[pc
+ 1].type
;
4164 case UNOP_MEMVAL_TYPE
:
4166 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
4167 type
= value_type (val
);
4171 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
4172 if (is_dynamic_type (type
))
4174 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
4175 type
= value_type (val
);
4176 if (type
->code () == TYPE_CODE_ARRAY
)
4178 if (type_not_allocated (type
) || type_not_associated (type
))
4179 return value_zero (size_type
, not_lval
);
4180 else if (is_dynamic_type (type
->index_type ())
4181 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
4182 return allocate_optimized_out_value (size_type
);
4189 case OP_VAR_MSYM_VALUE
:
4193 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
4194 value
*mval
= evaluate_var_msym_value (noside
,
4195 exp
->elts
[pc
+ 1].objfile
,
4198 type
= value_type (mval
);
4199 if (type
->code () == TYPE_CODE_ERROR
)
4200 error_unknown_type (msymbol
->print_name ());
4202 return value_from_longest (size_type
, TYPE_LENGTH (type
));
4206 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
4207 type of the subscript is a variable length array type. In this case we
4208 must re-evaluate the right hand side of the subscription to allow
4210 case BINOP_SUBSCRIPT
:
4211 if (noside
== EVAL_NORMAL
)
4213 int npc
= (*pos
) + 1;
4215 val
= evaluate_subexp (nullptr, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
4216 type
= check_typedef (value_type (val
));
4217 if (type
->code () == TYPE_CODE_ARRAY
)
4219 type
= check_typedef (TYPE_TARGET_TYPE (type
));
4220 if (type
->code () == TYPE_CODE_ARRAY
)
4222 type
= type
->index_type ();
4223 /* Only re-evaluate the right hand side if the resulting type
4224 is a variable length type. */
4225 if (type
->bounds ()->flag_bound_evaluated
)
4227 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
4228 return value_from_longest
4229 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
4238 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
4239 type
= value_type (val
);
4243 return evaluate_subexp_for_sizeof_base (exp
, type
);
4250 operation::evaluate_for_sizeof (struct expression
*exp
, enum noside noside
)
4252 value
*val
= evaluate (nullptr, exp
, EVAL_AVOID_SIDE_EFFECTS
);
4253 return evaluate_subexp_for_sizeof_base (exp
, value_type (val
));
4257 var_msym_value_operation::evaluate_for_sizeof (struct expression
*exp
,
4261 minimal_symbol
*msymbol
= std::get
<0> (m_storage
);
4262 value
*mval
= evaluate_var_msym_value (noside
,
4263 std::get
<1> (m_storage
),
4266 struct type
*type
= value_type (mval
);
4267 if (type
->code () == TYPE_CODE_ERROR
)
4268 error_unknown_type (msymbol
->print_name ());
4270 /* FIXME: This should be size_t. */
4271 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
4272 return value_from_longest (size_type
, TYPE_LENGTH (type
));
4276 subscript_operation::evaluate_for_sizeof (struct expression
*exp
,
4279 if (noside
== EVAL_NORMAL
)
4281 value
*val
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
4282 EVAL_AVOID_SIDE_EFFECTS
);
4283 struct type
*type
= check_typedef (value_type (val
));
4284 if (type
->code () == TYPE_CODE_ARRAY
)
4286 type
= check_typedef (TYPE_TARGET_TYPE (type
));
4287 if (type
->code () == TYPE_CODE_ARRAY
)
4289 type
= type
->index_type ();
4290 /* Only re-evaluate the right hand side if the resulting type
4291 is a variable length type. */
4292 if (type
->bounds ()->flag_bound_evaluated
)
4294 val
= evaluate (nullptr, exp
, EVAL_NORMAL
);
4295 /* FIXME: This should be size_t. */
4296 struct type
*size_type
4297 = builtin_type (exp
->gdbarch
)->builtin_int
;
4298 return value_from_longest
4299 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
4305 return operation::evaluate_for_sizeof (exp
, noside
);
4309 unop_ind_base_operation::evaluate_for_sizeof (struct expression
*exp
,
4312 value
*val
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
4313 EVAL_AVOID_SIDE_EFFECTS
);
4314 struct type
*type
= check_typedef (value_type (val
));
4315 if (type
->code () != TYPE_CODE_PTR
4316 && !TYPE_IS_REFERENCE (type
)
4317 && type
->code () != TYPE_CODE_ARRAY
)
4318 error (_("Attempt to take contents of a non-pointer value."));
4319 type
= TYPE_TARGET_TYPE (type
);
4320 if (is_dynamic_type (type
))
4321 type
= value_type (value_ind (val
));
4322 /* FIXME: This should be size_t. */
4323 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
4324 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
4328 unop_memval_operation::evaluate_for_sizeof (struct expression
*exp
,
4331 return evaluate_subexp_for_sizeof_base (exp
, std::get
<1> (m_storage
));
4335 unop_memval_type_operation::evaluate_for_sizeof (struct expression
*exp
,
4338 value
*typeval
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
4339 EVAL_AVOID_SIDE_EFFECTS
);
4340 return evaluate_subexp_for_sizeof_base (exp
, value_type (typeval
));
4344 var_value_operation::evaluate_for_sizeof (struct expression
*exp
,
4347 struct type
*type
= SYMBOL_TYPE (std::get
<0> (m_storage
));
4348 if (is_dynamic_type (type
))
4350 value
*val
= evaluate (nullptr, exp
, EVAL_NORMAL
);
4351 type
= value_type (val
);
4352 if (type
->code () == TYPE_CODE_ARRAY
)
4354 /* FIXME: This should be size_t. */
4355 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
4356 if (type_not_allocated (type
) || type_not_associated (type
))
4357 return value_zero (size_type
, not_lval
);
4358 else if (is_dynamic_type (type
->index_type ())
4359 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
4360 return allocate_optimized_out_value (size_type
);
4363 return evaluate_subexp_for_sizeof_base (exp
, type
);
4368 /* Evaluate a subexpression of EXP, at index *POS, and return a value
4369 for that subexpression cast to TO_TYPE. Advance *POS over the
4373 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
4375 struct type
*to_type
)
4379 /* Don't let symbols be evaluated with evaluate_subexp because that
4380 throws an "unknown type" error for no-debug data symbols.
4381 Instead, we want the cast to reinterpret the symbol. */
4382 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
4383 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
4388 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
4390 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
4391 return value_zero (to_type
, not_lval
);
4393 val
= evaluate_var_msym_value (noside
,
4394 exp
->elts
[pc
+ 1].objfile
,
4395 exp
->elts
[pc
+ 2].msymbol
);
4398 val
= evaluate_var_value (noside
,
4399 exp
->elts
[pc
+ 1].block
,
4400 exp
->elts
[pc
+ 2].symbol
);
4402 if (noside
== EVAL_SKIP
)
4403 return eval_skip_value (exp
);
4405 val
= value_cast (to_type
, val
);
4407 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
4408 if (VALUE_LVAL (val
) == lval_memory
)
4410 if (value_lazy (val
))
4411 value_fetch_lazy (val
);
4412 VALUE_LVAL (val
) = not_lval
;
4417 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
4418 if (noside
== EVAL_SKIP
)
4419 return eval_skip_value (exp
);
4420 return value_cast (to_type
, val
);
4427 var_msym_value_operation::evaluate_for_cast (struct type
*to_type
,
4428 struct expression
*exp
,
4431 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
4432 return value_zero (to_type
, not_lval
);
4434 value
*val
= evaluate_var_msym_value (noside
,
4435 std::get
<1> (m_storage
),
4436 std::get
<0> (m_storage
));
4438 if (noside
== EVAL_SKIP
)
4439 return eval_skip_value (exp
);
4441 val
= value_cast (to_type
, val
);
4443 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
4444 if (VALUE_LVAL (val
) == lval_memory
)
4446 if (value_lazy (val
))
4447 value_fetch_lazy (val
);
4448 VALUE_LVAL (val
) = not_lval
;
4454 var_value_operation::evaluate_for_cast (struct type
*to_type
,
4455 struct expression
*exp
,
4458 value
*val
= evaluate_var_value (noside
,
4459 std::get
<1> (m_storage
),
4460 std::get
<0> (m_storage
));
4462 if (noside
== EVAL_SKIP
)
4463 return eval_skip_value (exp
);
4465 val
= value_cast (to_type
, val
);
4467 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
4468 if (VALUE_LVAL (val
) == lval_memory
)
4470 if (value_lazy (val
))
4471 value_fetch_lazy (val
);
4472 VALUE_LVAL (val
) = not_lval
;
4479 /* Parse a type expression in the string [P..P+LENGTH). */
4482 parse_and_eval_type (const char *p
, int length
)
4484 char *tmp
= (char *) alloca (length
+ 4);
4487 memcpy (tmp
+ 1, p
, length
);
4488 tmp
[length
+ 1] = ')';
4489 tmp
[length
+ 2] = '0';
4490 tmp
[length
+ 3] = '\0';
4491 expression_up expr
= parse_expression (tmp
);
4492 if (expr
->first_opcode () != UNOP_CAST
)
4493 error (_("Internal error in eval_type."));
4494 return expr
->elts
[1].type
;