1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2020 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"
44 /* Prototypes for local functions. */
46 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
49 static struct value
*evaluate_subexp_for_address (struct expression
*,
52 static value
*evaluate_subexp_for_cast (expression
*exp
, int *pos
,
56 static struct value
*evaluate_struct_tuple (struct value
*,
57 struct expression
*, int *,
60 static LONGEST
init_array_element (struct value
*, struct value
*,
61 struct expression
*, int *, enum noside
,
65 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
66 int *pos
, enum noside noside
)
70 gdb::optional
<enable_thread_stack_temporaries
> stack_temporaries
;
71 if (*pos
== 0 && target_has_execution
72 && exp
->language_defn
->la_language
== language_cplus
73 && !thread_stack_temporaries_enabled_p (inferior_thread ()))
74 stack_temporaries
.emplace (inferior_thread ());
76 retval
= (*exp
->language_defn
->expression_ops ()->evaluate_exp
)
77 (expect_type
, exp
, pos
, noside
);
79 if (stack_temporaries
.has_value ()
80 && value_in_thread_stack_temporaries (retval
, inferior_thread ()))
81 retval
= value_non_lval (retval
);
86 /* Parse the string EXP as a C expression, evaluate it,
87 and return the result as a number. */
90 parse_and_eval_address (const char *exp
)
92 expression_up expr
= parse_expression (exp
);
94 return value_as_address (evaluate_expression (expr
.get ()));
97 /* Like parse_and_eval_address, but treats the value of the expression
98 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
100 parse_and_eval_long (const char *exp
)
102 expression_up expr
= parse_expression (exp
);
104 return value_as_long (evaluate_expression (expr
.get ()));
108 parse_and_eval (const char *exp
)
110 expression_up expr
= parse_expression (exp
);
112 return evaluate_expression (expr
.get ());
115 /* Parse up to a comma (or to a closeparen)
116 in the string EXPP as an expression, evaluate it, and return the value.
117 EXPP is advanced to point to the comma. */
120 parse_to_comma_and_eval (const char **expp
)
122 expression_up expr
= parse_exp_1 (expp
, 0, nullptr, 1);
124 return evaluate_expression (expr
.get ());
127 /* Evaluate an expression in internal prefix form
128 such as is constructed by parse.y.
130 See expression.h for info on the format of an expression. */
133 evaluate_expression (struct expression
*exp
)
137 return evaluate_subexp (nullptr, exp
, &pc
, EVAL_NORMAL
);
140 /* Evaluate an expression, avoiding all memory references
141 and getting a value whose type alone is correct. */
144 evaluate_type (struct expression
*exp
)
148 return evaluate_subexp (nullptr, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
151 /* Evaluate a subexpression, avoiding all memory references and
152 getting a value whose type alone is correct. */
155 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
157 return evaluate_subexp (nullptr, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
160 /* Find the current value of a watchpoint on EXP. Return the value in
161 *VALP and *RESULTP and the chain of intermediate and final values
162 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
165 If PRESERVE_ERRORS is true, then exceptions are passed through.
166 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
167 occurs while evaluating the expression, *RESULTP will be set to
168 NULL. *RESULTP may be a lazy value, if the result could not be
169 read from memory. It is used to determine whether a value is
170 user-specified (we should watch the whole value) or intermediate
171 (we should watch only the bit used to locate the final value).
173 If the final value, or any intermediate value, could not be read
174 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
175 set to any referenced values. *VALP will never be a lazy value.
176 This is the value which we store in struct breakpoint.
178 If VAL_CHAIN is non-NULL, the values put into *VAL_CHAIN will be
179 released from the value chain. If VAL_CHAIN is NULL, all generated
180 values will be left on the value chain. */
183 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
184 struct value
**resultp
,
185 std::vector
<value_ref_ptr
> *val_chain
,
188 struct value
*mark
, *new_mark
, *result
;
196 /* Evaluate the expression. */
197 mark
= value_mark ();
202 result
= evaluate_subexp (nullptr, exp
, pc
, EVAL_NORMAL
);
204 catch (const gdb_exception
&ex
)
206 /* Ignore memory errors if we want watchpoints pointing at
207 inaccessible memory to still be created; otherwise, throw the
208 error to some higher catcher. */
212 if (!preserve_errors
)
221 new_mark
= value_mark ();
222 if (mark
== new_mark
)
227 /* Make sure it's not lazy, so that after the target stops again we
228 have a non-lazy previous value to compare with. */
231 if (!value_lazy (result
))
238 value_fetch_lazy (result
);
241 catch (const gdb_exception_error
&except
)
249 /* Return the chain of intermediate values. We use this to
250 decide which addresses to watch. */
251 *val_chain
= value_release_to_mark (mark
);
255 /* Extract a field operation from an expression. If the subexpression
256 of EXP starting at *SUBEXP is not a structure dereference
257 operation, return NULL. Otherwise, return the name of the
258 dereferenced field, and advance *SUBEXP to point to the
259 subexpression of the left-hand-side of the dereference. This is
260 used when completing field names. */
263 extract_field_op (struct expression
*exp
, int *subexp
)
268 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
269 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
271 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
272 result
= &exp
->elts
[*subexp
+ 2].string
;
273 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
277 /* This function evaluates brace-initializers (in C/C++) for
280 static struct value
*
281 evaluate_struct_tuple (struct value
*struct_val
,
282 struct expression
*exp
,
283 int *pos
, enum noside noside
, int nargs
)
285 struct type
*struct_type
= check_typedef (value_type (struct_val
));
286 struct type
*field_type
;
291 struct value
*val
= NULL
;
296 /* Skip static fields. */
297 while (fieldno
< struct_type
->num_fields ()
298 && field_is_static (&struct_type
->field (fieldno
)))
300 if (fieldno
>= struct_type
->num_fields ())
301 error (_("too many initializers"));
302 field_type
= struct_type
->field (fieldno
).type ();
303 if (field_type
->code () == TYPE_CODE_UNION
304 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
305 error (_("don't know which variant you want to set"));
307 /* Here, struct_type is the type of the inner struct,
308 while substruct_type is the type of the inner struct.
309 These are the same for normal structures, but a variant struct
310 contains anonymous union fields that contain substruct fields.
311 The value fieldno is the index of the top-level (normal or
312 anonymous union) field in struct_field, while the value
313 subfieldno is the index of the actual real (named inner) field
314 in substruct_type. */
316 field_type
= struct_type
->field (fieldno
).type ();
318 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
320 /* Now actually set the field in struct_val. */
322 /* Assign val to field fieldno. */
323 if (value_type (val
) != field_type
)
324 val
= value_cast (field_type
, val
);
326 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
327 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
328 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
330 modify_field (struct_type
, addr
,
331 value_as_long (val
), bitpos
% 8, bitsize
);
333 memcpy (addr
, value_contents (val
),
334 TYPE_LENGTH (value_type (val
)));
340 /* Recursive helper function for setting elements of array tuples.
341 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
342 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
343 Evaluates index expressions and sets the specified element(s) of
344 ARRAY to ELEMENT. Returns last index value. */
347 init_array_element (struct value
*array
, struct value
*element
,
348 struct expression
*exp
, int *pos
,
349 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
352 int element_size
= TYPE_LENGTH (value_type (element
));
354 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
357 init_array_element (array
, element
, exp
, pos
, noside
,
358 low_bound
, high_bound
);
359 return init_array_element (array
, element
,
360 exp
, pos
, noside
, low_bound
, high_bound
);
364 index
= value_as_long (evaluate_subexp (nullptr, exp
, pos
, noside
));
365 if (index
< low_bound
|| index
> high_bound
)
366 error (_("tuple index out of range"));
367 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
368 value_contents (element
), element_size
);
373 /* Promote value ARG1 as appropriate before performing a unary operation
375 If the result is not appropriate for any particular language then it
376 needs to patch this function. */
379 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
384 *arg1
= coerce_ref (*arg1
);
385 type1
= check_typedef (value_type (*arg1
));
387 if (is_integral_type (type1
))
389 switch (language
->la_language
)
392 /* Perform integral promotion for ANSI C/C++.
393 If not appropriate for any particular language
394 it needs to modify this function. */
396 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
398 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
399 *arg1
= value_cast (builtin_int
, *arg1
);
406 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
407 operation on those two operands.
408 If the result is not appropriate for any particular language then it
409 needs to patch this function. */
412 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
413 struct value
**arg1
, struct value
**arg2
)
415 struct type
*promoted_type
= NULL
;
419 *arg1
= coerce_ref (*arg1
);
420 *arg2
= coerce_ref (*arg2
);
422 type1
= check_typedef (value_type (*arg1
));
423 type2
= check_typedef (value_type (*arg2
));
425 if ((type1
->code () != TYPE_CODE_FLT
426 && type1
->code () != TYPE_CODE_DECFLOAT
427 && !is_integral_type (type1
))
428 || (type2
->code () != TYPE_CODE_FLT
429 && type2
->code () != TYPE_CODE_DECFLOAT
430 && !is_integral_type (type2
)))
433 if (type1
->code () == TYPE_CODE_DECFLOAT
434 || type2
->code () == TYPE_CODE_DECFLOAT
)
436 /* No promotion required. */
438 else if (type1
->code () == TYPE_CODE_FLT
439 || type2
->code () == TYPE_CODE_FLT
)
441 switch (language
->la_language
)
447 case language_opencl
:
448 /* No promotion required. */
452 /* For other languages the result type is unchanged from gdb
453 version 6.7 for backward compatibility.
454 If either arg was long double, make sure that value is also long
455 double. Otherwise use double. */
456 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
457 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
458 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
460 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
464 else if (type1
->code () == TYPE_CODE_BOOL
465 && type2
->code () == TYPE_CODE_BOOL
)
467 /* No promotion required. */
470 /* Integral operations here. */
471 /* FIXME: Also mixed integral/booleans, with result an integer. */
473 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
474 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
475 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
476 int is_unsigned1
= type1
->is_unsigned ();
477 int is_unsigned2
= type2
->is_unsigned ();
478 unsigned int result_len
;
479 int unsigned_operation
;
481 /* Determine type length and signedness after promotion for
483 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
486 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
488 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
491 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
494 if (promoted_len1
> promoted_len2
)
496 unsigned_operation
= is_unsigned1
;
497 result_len
= promoted_len1
;
499 else if (promoted_len2
> promoted_len1
)
501 unsigned_operation
= is_unsigned2
;
502 result_len
= promoted_len2
;
506 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
507 result_len
= promoted_len1
;
510 switch (language
->la_language
)
516 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
518 promoted_type
= (unsigned_operation
519 ? builtin
->builtin_unsigned_int
520 : builtin
->builtin_int
);
522 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
524 promoted_type
= (unsigned_operation
525 ? builtin
->builtin_unsigned_long
526 : builtin
->builtin_long
);
530 promoted_type
= (unsigned_operation
531 ? builtin
->builtin_unsigned_long_long
532 : builtin
->builtin_long_long
);
535 case language_opencl
:
536 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
541 ? lookup_unsigned_typename (language
, "int")
542 : lookup_signed_typename (language
, "int"));
544 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
549 ? lookup_unsigned_typename (language
, "long")
550 : lookup_signed_typename (language
,"long"));
554 /* For other languages the result type is unchanged from gdb
555 version 6.7 for backward compatibility.
556 If either arg was long long, make sure that value is also long
557 long. Otherwise use long. */
558 if (unsigned_operation
)
560 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
561 promoted_type
= builtin
->builtin_unsigned_long_long
;
563 promoted_type
= builtin
->builtin_unsigned_long
;
567 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
568 promoted_type
= builtin
->builtin_long_long
;
570 promoted_type
= builtin
->builtin_long
;
578 /* Promote both operands to common type. */
579 *arg1
= value_cast (promoted_type
, *arg1
);
580 *arg2
= value_cast (promoted_type
, *arg2
);
585 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
587 type
= check_typedef (type
);
588 if (TYPE_IS_REFERENCE (type
))
589 type
= TYPE_TARGET_TYPE (type
);
591 switch (type
->code ())
597 case TYPE_CODE_ARRAY
:
598 return type
->is_vector () ? 0 : lang
->c_style_arrays_p ();
605 /* Represents a fake method with the given parameter types. This is
606 used by the parser to construct a temporary "expected" type for
607 method overload resolution. FLAGS is used as instance flags of the
608 new type, in order to be able to make the new type represent a
609 const/volatile overload. */
614 fake_method (type_instance_flags flags
,
615 int num_types
, struct type
**param_types
);
618 /* The constructed type. */
619 struct type
*type () { return &m_type
; }
622 struct type m_type
{};
623 main_type m_main_type
{};
626 fake_method::fake_method (type_instance_flags flags
,
627 int num_types
, struct type
**param_types
)
629 struct type
*type
= &m_type
;
631 TYPE_MAIN_TYPE (type
) = &m_main_type
;
632 TYPE_LENGTH (type
) = 1;
633 type
->set_code (TYPE_CODE_METHOD
);
634 TYPE_CHAIN (type
) = type
;
635 type
->set_instance_flags (flags
);
638 if (param_types
[num_types
- 1] == NULL
)
641 type
->set_has_varargs (true);
643 else if (check_typedef (param_types
[num_types
- 1])->code ()
647 /* Caller should have ensured this. */
648 gdb_assert (num_types
== 0);
649 type
->set_is_prototyped (true);
653 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
654 neither an objfile nor a gdbarch. As a result we must manually
655 allocate memory for auxiliary fields, and free the memory ourselves
656 when we are done with it. */
657 type
->set_num_fields (num_types
);
659 ((struct field
*) xzalloc (sizeof (struct field
) * num_types
));
661 while (num_types
-- > 0)
662 type
->field (num_types
).set_type (param_types
[num_types
]);
665 fake_method::~fake_method ()
667 xfree (m_type
.fields ());
670 /* Helper for evaluating an OP_VAR_VALUE. */
673 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
675 /* JYG: We used to just return value_zero of the symbol type if
676 we're asked to avoid side effects. Otherwise we return
677 value_of_variable (...). However I'm not sure if
678 value_of_variable () has any side effect. We need a full value
679 object returned here for whatis_exp () to call evaluate_type ()
680 and then pass the full value to value_rtti_target_type () if we
681 are dealing with a pointer or reference to a base class and print
684 struct value
*ret
= NULL
;
688 ret
= value_of_variable (var
, blk
);
691 catch (const gdb_exception_error
&except
)
693 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
696 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
702 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
705 evaluate_var_msym_value (enum noside noside
,
706 struct objfile
*objfile
, minimal_symbol
*msymbol
)
709 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
711 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !the_type
->is_gnu_ifunc ())
712 return value_zero (the_type
, not_lval
);
714 return value_at_lazy (the_type
, address
);
717 /* Helper for returning a value when handling EVAL_SKIP. */
720 eval_skip_value (expression
*exp
)
722 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
725 /* See expression.h. */
728 evaluate_subexp_do_call (expression
*exp
, enum noside noside
,
729 int nargs
, value
**argvec
,
730 const char *function_name
,
731 type
*default_return_type
)
733 if (argvec
[0] == NULL
)
734 error (_("Cannot evaluate function -- may be inlined"));
735 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
737 /* If the return type doesn't look like a function type,
738 call an error. This can happen if somebody tries to turn
739 a variable into a function call. */
741 type
*ftype
= value_type (argvec
[0]);
743 if (ftype
->code () == TYPE_CODE_INTERNAL_FUNCTION
)
745 /* We don't know anything about what the internal
746 function might return, but we have to return
748 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
751 else if (ftype
->code () == TYPE_CODE_XMETHOD
)
754 = result_type_of_xmethod (argvec
[0],
755 gdb::make_array_view (argvec
+ 1,
758 if (return_type
== NULL
)
759 error (_("Xmethod is missing return type."));
760 return value_zero (return_type
, not_lval
);
762 else if (ftype
->code () == TYPE_CODE_FUNC
763 || ftype
->code () == TYPE_CODE_METHOD
)
765 if (ftype
->is_gnu_ifunc ())
767 CORE_ADDR address
= value_address (argvec
[0]);
768 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
770 if (resolved_type
!= NULL
)
771 ftype
= resolved_type
;
774 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
776 if (return_type
== NULL
)
777 return_type
= default_return_type
;
779 if (return_type
== NULL
)
780 error_call_unknown_return_type (function_name
);
782 return allocate_value (return_type
);
785 error (_("Expression of type other than "
786 "\"Function returning ...\" used as function"));
788 switch (value_type (argvec
[0])->code ())
790 case TYPE_CODE_INTERNAL_FUNCTION
:
791 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
792 argvec
[0], nargs
, argvec
+ 1);
793 case TYPE_CODE_XMETHOD
:
794 return call_xmethod (argvec
[0], gdb::make_array_view (argvec
+ 1, nargs
));
796 return call_function_by_hand (argvec
[0], default_return_type
,
797 gdb::make_array_view (argvec
+ 1, nargs
));
801 /* Helper for evaluating an OP_FUNCALL. */
804 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
812 symbol
*function
= NULL
;
813 char *function_name
= NULL
;
814 const char *var_func_name
= NULL
;
819 exp_opcode op
= exp
->elts
[*pos
].opcode
;
820 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
821 /* Allocate arg vector, including space for the function to be
822 called in argvec[0], a potential `this', and a terminating
824 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
825 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
827 /* First, evaluate the structure into arg2. */
830 if (op
== STRUCTOP_MEMBER
)
832 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
836 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
839 /* If the function is a virtual function, then the aggregate
840 value (providing the structure) plays its part by providing
841 the vtable. Otherwise, it is just along for the ride: call
842 the function directly. */
844 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
846 type
*a1_type
= check_typedef (value_type (arg1
));
847 if (noside
== EVAL_SKIP
)
848 tem
= 1; /* Set it to the right arg index so that all
849 arguments can also be skipped. */
850 else if (a1_type
->code () == TYPE_CODE_METHODPTR
)
852 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
853 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
855 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
857 /* Now, say which argument to start evaluating from. */
862 else if (a1_type
->code () == TYPE_CODE_MEMBERPTR
)
864 struct type
*type_ptr
865 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
866 struct type
*target_type_ptr
867 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
869 /* Now, convert these values to an address. */
870 arg2
= value_cast (type_ptr
, arg2
);
872 long mem_offset
= value_as_long (arg1
);
874 arg1
= value_from_pointer (target_type_ptr
,
875 value_as_long (arg2
) + mem_offset
);
876 arg1
= value_ind (arg1
);
880 error (_("Non-pointer-to-member value used in pointer-to-member "
883 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
885 /* Hair for method invocations. */
889 /* First, evaluate the structure into arg2. */
891 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
892 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
894 if (op
== STRUCTOP_STRUCT
)
896 /* If v is a variable in a register, and the user types
897 v.method (), this will produce an error, because v has no
900 A possible way around this would be to allocate a copy of
901 the variable on the stack, copy in the contents, call the
902 function, and copy out the contents. I.e. convert this
903 from call by reference to call by copy-return (or
904 whatever it's called). However, this does not work
905 because it is not the same: the method being called could
906 stash a copy of the address, and then future uses through
907 that address (after the method returns) would be expected
908 to use the variable itself, not some copy of it. */
909 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
913 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
915 /* Check to see if the operator '->' has been overloaded.
916 If the operator has been overloaded replace arg2 with the
917 value returned by the custom operator and continue
919 while (unop_user_defined_p (op
, arg2
))
921 struct value
*value
= NULL
;
924 value
= value_x_unop (arg2
, op
, noside
);
927 catch (const gdb_exception_error
&except
)
929 if (except
.error
== NOT_FOUND_ERROR
)
938 /* Now, say which argument to start evaluating from. */
941 else if (op
== OP_SCOPE
942 && overload_resolution
943 && (exp
->language_defn
->la_language
== language_cplus
))
945 /* Unpack it locally so we can properly handle overload
951 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
952 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
953 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
954 name
= &exp
->elts
[pc2
+ 3].string
;
957 function_name
= NULL
;
958 if (type
->code () == TYPE_CODE_NAMESPACE
)
960 function
= cp_lookup_symbol_namespace (type
->name (),
962 get_selected_block (0),
964 if (function
== NULL
)
965 error (_("No symbol \"%s\" in namespace \"%s\"."),
966 name
, type
->name ());
969 /* arg2 is left as NULL on purpose. */
973 gdb_assert (type
->code () == TYPE_CODE_STRUCT
974 || type
->code () == TYPE_CODE_UNION
);
975 function_name
= name
;
977 /* We need a properly typed value for method lookup. For
978 static methods arg2 is otherwise unused. */
979 arg2
= value_zero (type
, lval_memory
);
984 else if (op
== OP_ADL_FUNC
)
986 /* Save the function position and move pos so that the arguments
993 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
994 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
998 /* Non-method function call. */
1002 /* If this is a C++ function wait until overload resolution. */
1003 if (op
== OP_VAR_VALUE
1004 && overload_resolution
1005 && (exp
->language_defn
->la_language
== language_cplus
))
1007 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1012 if (op
== OP_VAR_MSYM_VALUE
)
1014 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1015 var_func_name
= msym
->print_name ();
1017 else if (op
== OP_VAR_VALUE
)
1019 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1020 var_func_name
= sym
->print_name ();
1023 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1024 type
*type
= value_type (argvec
[0]);
1025 if (type
&& type
->code () == TYPE_CODE_PTR
)
1026 type
= TYPE_TARGET_TYPE (type
);
1027 if (type
&& type
->code () == TYPE_CODE_FUNC
)
1029 for (; tem
<= nargs
&& tem
<= type
->num_fields (); tem
++)
1031 argvec
[tem
] = evaluate_subexp (type
->field (tem
- 1).type (),
1038 /* Evaluate arguments (if not already done, e.g., namespace::func()
1039 and overload-resolution is off). */
1040 for (; tem
<= nargs
; tem
++)
1042 /* Ensure that array expressions are coerced into pointer
1044 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1047 /* Signal end of arglist. */
1050 if (noside
== EVAL_SKIP
)
1051 return eval_skip_value (exp
);
1053 if (op
== OP_ADL_FUNC
)
1055 struct symbol
*symp
;
1058 int string_pc
= save_pos1
+ 3;
1060 /* Extract the function name. */
1061 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1062 func_name
= (char *) alloca (name_len
+ 1);
1063 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1065 find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1067 NON_METHOD
, /* not method */
1068 NULL
, NULL
, /* pass NULL symbol since
1069 symbol is unknown */
1070 NULL
, &symp
, NULL
, 0, noside
);
1072 /* Now fix the expression being evaluated. */
1073 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1074 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1077 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1078 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1080 int static_memfuncp
;
1083 /* Method invocation: stuff "this" as first parameter. If the
1084 method turns out to be static we undo this below. */
1089 /* Name of method from expression. */
1090 tstr
= &exp
->elts
[pc2
+ 2].string
;
1093 tstr
= function_name
;
1095 if (overload_resolution
&& (exp
->language_defn
->la_language
1098 /* Language is C++, do some overload resolution before
1100 struct value
*valp
= NULL
;
1102 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1104 METHOD
, /* method */
1105 &arg2
, /* the object */
1107 &static_memfuncp
, 0, noside
);
1109 if (op
== OP_SCOPE
&& !static_memfuncp
)
1111 /* For the time being, we don't handle this. */
1112 error (_("Call to overloaded function %s requires "
1116 argvec
[1] = arg2
; /* the ``this'' pointer */
1117 argvec
[0] = valp
; /* Use the method found after overload
1121 /* Non-C++ case -- or no overload resolution. */
1123 struct value
*temp
= arg2
;
1125 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1127 op
== STRUCTOP_STRUCT
1128 ? "structure" : "structure pointer");
1129 /* value_struct_elt updates temp with the correct value of
1130 the ``this'' pointer if necessary, so modify argvec[1] to
1131 reflect any ``this'' changes. */
1133 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1134 value_address (temp
)
1135 + value_embedded_offset (temp
));
1136 argvec
[1] = arg2
; /* the ``this'' pointer */
1139 /* Take out `this' if needed. */
1140 if (static_memfuncp
)
1142 argvec
[1] = argvec
[0];
1147 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1149 /* Pointer to member. argvec[1] is already set up. */
1152 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1154 /* Non-member function being called. */
1155 /* fn: This can only be done for C++ functions. A C-style
1156 function in a C++ program, for instance, does not have the
1157 fields that are expected here. */
1159 if (overload_resolution
&& (exp
->language_defn
->la_language
1162 /* Language is C++, do some overload resolution before
1164 struct symbol
*symp
;
1167 /* If a scope has been specified disable ADL. */
1171 if (op
== OP_VAR_VALUE
)
1172 function
= exp
->elts
[save_pos1
+2].symbol
;
1174 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1175 NULL
, /* no need for name */
1176 NON_METHOD
, /* not method */
1177 NULL
, function
, /* the function */
1178 NULL
, &symp
, NULL
, no_adl
, noside
);
1180 if (op
== OP_VAR_VALUE
)
1182 /* Now fix the expression being evaluated. */
1183 exp
->elts
[save_pos1
+2].symbol
= symp
;
1184 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1188 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1192 /* Not C++, or no overload resolution allowed. */
1193 /* Nothing to be done; argvec already correctly set up. */
1198 /* It is probably a C-style function. */
1199 /* Nothing to be done; argvec already correctly set up. */
1202 return evaluate_subexp_do_call (exp
, noside
, nargs
, argvec
,
1203 var_func_name
, expect_type
);
1206 /* Return true if type is integral or reference to integral */
1209 is_integral_or_integral_reference (struct type
*type
)
1211 if (is_integral_type (type
))
1214 type
= check_typedef (type
);
1215 return (type
!= nullptr
1216 && TYPE_IS_REFERENCE (type
)
1217 && is_integral_type (TYPE_TARGET_TYPE (type
)));
1221 evaluate_subexp_standard (struct type
*expect_type
,
1222 struct expression
*exp
, int *pos
,
1226 int tem
, tem2
, tem3
;
1228 struct value
*arg1
= NULL
;
1229 struct value
*arg2
= NULL
;
1233 struct value
**argvec
;
1236 struct type
**arg_types
;
1239 op
= exp
->elts
[pc
].opcode
;
1244 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1245 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1246 if (noside
== EVAL_SKIP
)
1247 return eval_skip_value (exp
);
1248 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
1249 &exp
->elts
[pc
+ 3].string
,
1250 expect_type
, 0, noside
);
1252 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
1257 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1258 exp
->elts
[pc
+ 2].longconst
);
1262 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1263 exp
->elts
[pc
+ 2].floatconst
);
1269 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1270 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
1271 error_unknown_type (var
->print_name ());
1272 if (noside
!= EVAL_SKIP
)
1273 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1276 /* Return a dummy value of the correct type when skipping, so
1277 that parent functions know what is to be skipped. */
1278 return allocate_value (SYMBOL_TYPE (var
));
1282 case OP_VAR_MSYM_VALUE
:
1286 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1287 value
*val
= evaluate_var_msym_value (noside
,
1288 exp
->elts
[pc
+ 1].objfile
,
1291 type
= value_type (val
);
1292 if (type
->code () == TYPE_CODE_ERROR
1293 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| pc
!= 0))
1294 error_unknown_type (msymbol
->print_name ());
1298 case OP_VAR_ENTRY_VALUE
:
1300 if (noside
== EVAL_SKIP
)
1301 return eval_skip_value (exp
);
1304 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1305 struct frame_info
*frame
;
1307 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1308 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1310 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1311 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1312 error (_("Symbol \"%s\" does not have any specific entry value"),
1313 sym
->print_name ());
1315 frame
= get_selected_frame (NULL
);
1316 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1319 case OP_FUNC_STATIC_VAR
:
1320 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1321 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1322 if (noside
== EVAL_SKIP
)
1323 return eval_skip_value (exp
);
1326 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1327 CORE_ADDR addr
= value_address (func
);
1329 const block
*blk
= block_for_pc (addr
);
1330 const char *var
= &exp
->elts
[pc
+ 2].string
;
1332 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1334 if (sym
.symbol
== NULL
)
1335 error (_("No symbol \"%s\" in specified context."), var
);
1337 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1343 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1347 const char *name
= &exp
->elts
[pc
+ 2].string
;
1351 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1352 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1353 name
, strlen (name
));
1355 error (_("Register $%s not available."), name
);
1357 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1358 a value with the appropriate register type. Unfortunately,
1359 we don't have easy access to the type of user registers.
1360 So for these registers, we fetch the register value regardless
1361 of the evaluation mode. */
1362 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1363 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1364 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1366 val
= value_of_register (regno
, get_selected_frame (NULL
));
1368 error (_("Value of register %s not available."), name
);
1374 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1375 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1377 case OP_INTERNALVAR
:
1379 return value_of_internalvar (exp
->gdbarch
,
1380 exp
->elts
[pc
+ 1].internalvar
);
1383 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1384 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1385 if (noside
== EVAL_SKIP
)
1386 return eval_skip_value (exp
);
1387 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1388 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1390 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1391 NSString constant. */
1392 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1393 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1394 if (noside
== EVAL_SKIP
)
1395 return eval_skip_value (exp
);
1396 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1400 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1401 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1402 nargs
= tem3
- tem2
+ 1;
1403 type
= expect_type
? check_typedef (expect_type
) : nullptr;
1405 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1406 && type
->code () == TYPE_CODE_STRUCT
)
1408 struct value
*rec
= allocate_value (expect_type
);
1410 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1411 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1414 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1415 && type
->code () == TYPE_CODE_ARRAY
)
1417 struct type
*range_type
= type
->index_type ();
1418 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1419 struct value
*array
= allocate_value (expect_type
);
1420 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1421 LONGEST low_bound
, high_bound
, index
;
1423 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1426 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1429 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1430 for (tem
= nargs
; --nargs
>= 0;)
1432 struct value
*element
;
1435 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1436 if (value_type (element
) != element_type
)
1437 element
= value_cast (element_type
, element
);
1440 int continue_pc
= *pos
;
1443 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1444 low_bound
, high_bound
);
1449 if (index
> high_bound
)
1450 /* To avoid memory corruption. */
1451 error (_("Too many array elements"));
1452 memcpy (value_contents_raw (array
)
1453 + (index
- low_bound
) * element_size
,
1454 value_contents (element
),
1462 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1463 && type
->code () == TYPE_CODE_SET
)
1465 struct value
*set
= allocate_value (expect_type
);
1466 gdb_byte
*valaddr
= value_contents_raw (set
);
1467 struct type
*element_type
= type
->index_type ();
1468 struct type
*check_type
= element_type
;
1469 LONGEST low_bound
, high_bound
;
1471 /* Get targettype of elementtype. */
1472 while (check_type
->code () == TYPE_CODE_RANGE
1473 || check_type
->code () == TYPE_CODE_TYPEDEF
)
1474 check_type
= TYPE_TARGET_TYPE (check_type
);
1476 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1477 error (_("(power)set type with unknown size"));
1478 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1479 for (tem
= 0; tem
< nargs
; tem
++)
1481 LONGEST range_low
, range_high
;
1482 struct type
*range_low_type
, *range_high_type
;
1483 struct value
*elem_val
;
1485 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1486 range_low_type
= range_high_type
= value_type (elem_val
);
1487 range_low
= range_high
= value_as_long (elem_val
);
1489 /* Check types of elements to avoid mixture of elements from
1490 different types. Also check if type of element is "compatible"
1491 with element type of powerset. */
1492 if (range_low_type
->code () == TYPE_CODE_RANGE
)
1493 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1494 if (range_high_type
->code () == TYPE_CODE_RANGE
)
1495 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1496 if ((range_low_type
->code () != range_high_type
->code ())
1497 || (range_low_type
->code () == TYPE_CODE_ENUM
1498 && (range_low_type
!= range_high_type
)))
1499 /* different element modes. */
1500 error (_("POWERSET tuple elements of different mode"));
1501 if ((check_type
->code () != range_low_type
->code ())
1502 || (check_type
->code () == TYPE_CODE_ENUM
1503 && range_low_type
!= check_type
))
1504 error (_("incompatible POWERSET tuple elements"));
1505 if (range_low
> range_high
)
1507 warning (_("empty POWERSET tuple range"));
1510 if (range_low
< low_bound
|| range_high
> high_bound
)
1511 error (_("POWERSET tuple element out of range"));
1512 range_low
-= low_bound
;
1513 range_high
-= low_bound
;
1514 for (; range_low
<= range_high
; range_low
++)
1516 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1518 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1519 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1520 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1527 argvec
= XALLOCAVEC (struct value
*, nargs
);
1528 for (tem
= 0; tem
< nargs
; tem
++)
1530 /* Ensure that array expressions are coerced into pointer
1532 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1534 if (noside
== EVAL_SKIP
)
1535 return eval_skip_value (exp
);
1536 return value_array (tem2
, tem3
, argvec
);
1540 struct value
*array
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1542 = value_as_long (evaluate_subexp (nullptr, exp
, pos
, noside
));
1543 int upper
= value_as_long (evaluate_subexp (nullptr, exp
, pos
, noside
));
1545 if (noside
== EVAL_SKIP
)
1546 return eval_skip_value (exp
);
1547 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1551 /* Skip third and second args to evaluate the first one. */
1552 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1553 if (value_logical_not (arg1
))
1555 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
1556 return evaluate_subexp (nullptr, exp
, pos
, noside
);
1560 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1561 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
1565 case OP_OBJC_SELECTOR
:
1566 { /* Objective C @selector operator. */
1567 char *sel
= &exp
->elts
[pc
+ 2].string
;
1568 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1569 struct type
*selector_type
;
1571 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1572 if (noside
== EVAL_SKIP
)
1573 return eval_skip_value (exp
);
1576 sel
[len
] = 0; /* Make sure it's terminated. */
1578 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1579 return value_from_longest (selector_type
,
1580 lookup_child_selector (exp
->gdbarch
, sel
));
1583 case OP_OBJC_MSGCALL
:
1584 { /* Objective C message (method) call. */
1586 CORE_ADDR responds_selector
= 0;
1587 CORE_ADDR method_selector
= 0;
1589 CORE_ADDR selector
= 0;
1591 int struct_return
= 0;
1592 enum noside sub_no_side
= EVAL_NORMAL
;
1594 struct value
*msg_send
= NULL
;
1595 struct value
*msg_send_stret
= NULL
;
1596 int gnu_runtime
= 0;
1598 struct value
*target
= NULL
;
1599 struct value
*method
= NULL
;
1600 struct value
*called_method
= NULL
;
1602 struct type
*selector_type
= NULL
;
1603 struct type
*long_type
;
1605 struct value
*ret
= NULL
;
1608 selector
= exp
->elts
[pc
+ 1].longconst
;
1609 nargs
= exp
->elts
[pc
+ 2].longconst
;
1610 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1614 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1615 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1617 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1618 sub_no_side
= EVAL_NORMAL
;
1620 sub_no_side
= noside
;
1622 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1624 if (value_as_long (target
) == 0)
1625 return value_from_longest (long_type
, 0);
1627 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1630 /* Find the method dispatch (Apple runtime) or method lookup
1631 (GNU runtime) function for Objective-C. These will be used
1632 to lookup the symbol information for the method. If we
1633 can't find any symbol information, then we'll use these to
1634 call the method, otherwise we can call the method
1635 directly. The msg_send_stret function is used in the special
1636 case of a method that returns a structure (Apple runtime
1640 type
= selector_type
;
1642 type
= lookup_function_type (type
);
1643 type
= lookup_pointer_type (type
);
1644 type
= lookup_function_type (type
);
1645 type
= lookup_pointer_type (type
);
1647 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1649 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1651 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1652 msg_send_stret
= value_from_pointer (type
,
1653 value_as_address (msg_send_stret
));
1657 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1658 /* Special dispatcher for methods returning structs. */
1660 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1663 /* Verify the target object responds to this method. The
1664 standard top-level 'Object' class uses a different name for
1665 the verification method than the non-standard, but more
1666 often used, 'NSObject' class. Make sure we check for both. */
1669 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1670 if (responds_selector
== 0)
1672 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1674 if (responds_selector
== 0)
1675 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1678 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1679 if (method_selector
== 0)
1681 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1683 if (method_selector
== 0)
1684 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1686 /* Call the verification method, to make sure that the target
1687 class implements the desired method. */
1689 argvec
[0] = msg_send
;
1691 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1692 argvec
[3] = value_from_longest (long_type
, selector
);
1695 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1698 /* Function objc_msg_lookup returns a pointer. */
1700 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1702 if (value_as_long (ret
) == 0)
1703 error (_("Target does not respond to this message selector."));
1705 /* Call "methodForSelector:" method, to get the address of a
1706 function method that implements this selector for this
1707 class. If we can find a symbol at that address, then we
1708 know the return type, parameter types etc. (that's a good
1711 argvec
[0] = msg_send
;
1713 argvec
[2] = value_from_longest (long_type
, method_selector
);
1714 argvec
[3] = value_from_longest (long_type
, selector
);
1717 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1721 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1724 /* ret should now be the selector. */
1726 addr
= value_as_long (ret
);
1729 struct symbol
*sym
= NULL
;
1731 /* The address might point to a function descriptor;
1732 resolve it to the actual code address instead. */
1733 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1734 current_top_target ());
1736 /* Is it a high_level symbol? */
1737 sym
= find_pc_function (addr
);
1739 method
= value_of_variable (sym
, 0);
1742 /* If we found a method with symbol information, check to see
1743 if it returns a struct. Otherwise assume it doesn't. */
1748 struct type
*val_type
;
1750 funaddr
= find_function_addr (method
, &val_type
);
1752 block_for_pc (funaddr
);
1754 val_type
= check_typedef (val_type
);
1756 if ((val_type
== NULL
)
1757 || (val_type
->code () == TYPE_CODE_ERROR
))
1759 if (expect_type
!= NULL
)
1760 val_type
= expect_type
;
1763 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1766 else if (expect_type
!= NULL
)
1768 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1769 check_typedef (expect_type
));
1772 /* Found a function symbol. Now we will substitute its
1773 value in place of the message dispatcher (obj_msgSend),
1774 so that we call the method directly instead of thru
1775 the dispatcher. The main reason for doing this is that
1776 we can now evaluate the return value and parameter values
1777 according to their known data types, in case we need to
1778 do things like promotion, dereferencing, special handling
1779 of structs and doubles, etc.
1781 We want to use the type signature of 'method', but still
1782 jump to objc_msgSend() or objc_msgSend_stret() to better
1783 mimic the behavior of the runtime. */
1787 if (value_type (method
)->code () != TYPE_CODE_FUNC
)
1788 error (_("method address has symbol information "
1789 "with non-function type; skipping"));
1791 /* Create a function pointer of the appropriate type, and
1792 replace its value with the value of msg_send or
1793 msg_send_stret. We must use a pointer here, as
1794 msg_send and msg_send_stret are of pointer type, and
1795 the representation may be different on systems that use
1796 function descriptors. */
1799 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1800 value_as_address (msg_send_stret
));
1803 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1804 value_as_address (msg_send
));
1809 called_method
= msg_send_stret
;
1811 called_method
= msg_send
;
1814 if (noside
== EVAL_SKIP
)
1815 return eval_skip_value (exp
);
1817 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1819 /* If the return type doesn't look like a function type,
1820 call an error. This can happen if somebody tries to
1821 turn a variable into a function call. This is here
1822 because people often want to call, eg, strcmp, which
1823 gdb doesn't know is a function. If gdb isn't asked for
1824 it's opinion (ie. through "whatis"), it won't offer
1827 struct type
*callee_type
= value_type (called_method
);
1829 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
1830 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1831 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1835 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
1836 return allocate_value (expect_type
);
1838 return allocate_value (callee_type
);
1841 error (_("Expression of type other than "
1842 "\"method returning ...\" used as a method"));
1845 /* Now depending on whether we found a symbol for the method,
1846 we will either call the runtime dispatcher or the method
1849 argvec
[0] = called_method
;
1851 argvec
[2] = value_from_longest (long_type
, selector
);
1852 /* User-supplied arguments. */
1853 for (tem
= 0; tem
< nargs
; tem
++)
1854 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1855 argvec
[tem
+ 3] = 0;
1857 auto call_args
= gdb::make_array_view (argvec
+ 1, nargs
+ 2);
1859 if (gnu_runtime
&& (method
!= NULL
))
1861 /* Function objc_msg_lookup returns a pointer. */
1862 deprecated_set_value_type (argvec
[0],
1863 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1864 argvec
[0] = call_function_by_hand (argvec
[0], NULL
, call_args
);
1867 return call_function_by_hand (argvec
[0], NULL
, call_args
);
1872 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1875 /* We have a complex number, There should be 2 floating
1876 point numbers that compose it. */
1878 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1879 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1881 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1883 case STRUCTOP_STRUCT
:
1884 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1885 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1886 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1887 if (noside
== EVAL_SKIP
)
1888 return eval_skip_value (exp
);
1889 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1891 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1892 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1896 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1897 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1898 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1899 if (noside
== EVAL_SKIP
)
1900 return eval_skip_value (exp
);
1902 /* Check to see if operator '->' has been overloaded. If so replace
1903 arg1 with the value returned by evaluating operator->(). */
1904 while (unop_user_defined_p (op
, arg1
))
1906 struct value
*value
= NULL
;
1909 value
= value_x_unop (arg1
, op
, noside
);
1912 catch (const gdb_exception_error
&except
)
1914 if (except
.error
== NOT_FOUND_ERROR
)
1923 /* JYG: if print object is on we need to replace the base type
1924 with rtti type in order to continue on with successful
1925 lookup of member / method only available in the rtti type. */
1927 struct type
*arg_type
= value_type (arg1
);
1928 struct type
*real_type
;
1929 int full
, using_enc
;
1931 struct value_print_options opts
;
1933 get_user_print_options (&opts
);
1934 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
1935 && (TYPE_TARGET_TYPE (arg_type
)->code () == TYPE_CODE_STRUCT
))
1937 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1940 arg1
= value_cast (real_type
, arg1
);
1944 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1945 NULL
, "structure pointer");
1946 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1947 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1950 case STRUCTOP_MEMBER
:
1952 if (op
== STRUCTOP_MEMBER
)
1953 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1955 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1957 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1959 if (noside
== EVAL_SKIP
)
1960 return eval_skip_value (exp
);
1962 type
= check_typedef (value_type (arg2
));
1963 switch (type
->code ())
1965 case TYPE_CODE_METHODPTR
:
1966 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1967 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1970 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1971 gdb_assert (value_type (arg2
)->code () == TYPE_CODE_PTR
);
1972 return value_ind (arg2
);
1975 case TYPE_CODE_MEMBERPTR
:
1976 /* Now, convert these values to an address. */
1977 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1980 mem_offset
= value_as_long (arg2
);
1982 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1983 value_as_long (arg1
) + mem_offset
);
1984 return value_ind (arg3
);
1987 error (_("non-pointer-to-member value used "
1988 "in pointer-to-member construct"));
1993 type_instance_flags flags
1994 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1995 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1996 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1997 for (ix
= 0; ix
< nargs
; ++ix
)
1998 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2000 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
2001 *(pos
) += 4 + nargs
;
2002 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
2007 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2008 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2009 if (noside
== EVAL_SKIP
)
2010 return eval_skip_value (exp
);
2011 if (binop_user_defined_p (op
, arg1
, arg2
))
2012 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2014 return value_concat (arg1
, arg2
);
2017 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2018 /* Special-case assignments where the left-hand-side is a
2019 convenience variable -- in these, don't bother setting an
2020 expected type. This avoids a weird case where re-assigning a
2021 string or array to an internal variable could error with "Too
2022 many array elements". */
2023 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
2025 : value_type (arg1
),
2028 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2030 if (binop_user_defined_p (op
, arg1
, arg2
))
2031 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2033 return value_assign (arg1
, arg2
);
2035 case BINOP_ASSIGN_MODIFY
:
2037 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2038 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2039 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2041 op
= exp
->elts
[pc
+ 1].opcode
;
2042 if (binop_user_defined_p (op
, arg1
, arg2
))
2043 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2044 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2046 && is_integral_type (value_type (arg2
)))
2047 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2048 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2050 && is_integral_type (value_type (arg2
)))
2051 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2054 struct value
*tmp
= arg1
;
2056 /* For shift and integer exponentiation operations,
2057 only promote the first argument. */
2058 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2059 && is_integral_type (value_type (arg2
)))
2060 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2062 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2064 arg2
= value_binop (tmp
, arg2
, op
);
2066 return value_assign (arg1
, arg2
);
2069 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2070 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2071 if (noside
== EVAL_SKIP
)
2072 return eval_skip_value (exp
);
2073 if (binop_user_defined_p (op
, arg1
, arg2
))
2074 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2075 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2076 && is_integral_or_integral_reference (value_type (arg2
)))
2077 return value_ptradd (arg1
, value_as_long (arg2
));
2078 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2079 && is_integral_or_integral_reference (value_type (arg1
)))
2080 return value_ptradd (arg2
, value_as_long (arg1
));
2083 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2084 return value_binop (arg1
, arg2
, BINOP_ADD
);
2088 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2089 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2090 if (noside
== EVAL_SKIP
)
2091 return eval_skip_value (exp
);
2092 if (binop_user_defined_p (op
, arg1
, arg2
))
2093 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2094 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2095 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2097 /* FIXME -- should be ptrdiff_t */
2098 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2099 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2101 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2102 && is_integral_or_integral_reference (value_type (arg2
)))
2103 return value_ptradd (arg1
, - value_as_long (arg2
));
2106 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2107 return value_binop (arg1
, arg2
, BINOP_SUB
);
2118 case BINOP_BITWISE_AND
:
2119 case BINOP_BITWISE_IOR
:
2120 case BINOP_BITWISE_XOR
:
2121 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2122 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2123 if (noside
== EVAL_SKIP
)
2124 return eval_skip_value (exp
);
2125 if (binop_user_defined_p (op
, arg1
, arg2
))
2126 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2129 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2130 fudge arg2 to avoid division-by-zero, the caller is
2131 (theoretically) only looking for the type of the result. */
2132 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2133 /* ??? Do we really want to test for BINOP_MOD here?
2134 The implementation of value_binop gives it a well-defined
2137 || op
== BINOP_INTDIV
2140 && value_logical_not (arg2
))
2142 struct value
*v_one
, *retval
;
2144 v_one
= value_one (value_type (arg2
));
2145 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2146 retval
= value_binop (arg1
, v_one
, op
);
2151 /* For shift and integer exponentiation operations,
2152 only promote the first argument. */
2153 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2154 && is_integral_type (value_type (arg2
)))
2155 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2157 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2159 return value_binop (arg1
, arg2
, op
);
2163 case BINOP_SUBSCRIPT
:
2164 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2165 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2166 if (noside
== EVAL_SKIP
)
2167 return eval_skip_value (exp
);
2168 if (binop_user_defined_p (op
, arg1
, arg2
))
2169 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2172 /* If the user attempts to subscript something that is not an
2173 array or pointer type (like a plain int variable for example),
2174 then report this as an error. */
2176 arg1
= coerce_ref (arg1
);
2177 type
= check_typedef (value_type (arg1
));
2178 if (type
->code () != TYPE_CODE_ARRAY
2179 && type
->code () != TYPE_CODE_PTR
)
2182 error (_("cannot subscript something of type `%s'"),
2185 error (_("cannot subscript requested type"));
2188 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2189 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2191 return value_subscript (arg1
, value_as_long (arg2
));
2193 case MULTI_SUBSCRIPT
:
2195 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2196 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2199 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2200 /* FIXME: EVAL_SKIP handling may not be correct. */
2201 if (noside
== EVAL_SKIP
)
2205 return eval_skip_value (exp
);
2207 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2208 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2210 /* If the user attempts to subscript something that has no target
2211 type (like a plain int variable for example), then report this
2214 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2217 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2223 error (_("cannot subscript something of type `%s'"),
2224 value_type (arg1
)->name ());
2228 if (binop_user_defined_p (op
, arg1
, arg2
))
2230 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2234 arg1
= coerce_ref (arg1
);
2235 type
= check_typedef (value_type (arg1
));
2237 switch (type
->code ())
2240 case TYPE_CODE_ARRAY
:
2241 case TYPE_CODE_STRING
:
2242 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2247 error (_("cannot subscript something of type `%s'"),
2250 error (_("cannot subscript requested type"));
2256 case BINOP_LOGICAL_AND
:
2257 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2258 if (noside
== EVAL_SKIP
)
2260 evaluate_subexp (nullptr, exp
, pos
, noside
);
2261 return eval_skip_value (exp
);
2265 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2268 if (binop_user_defined_p (op
, arg1
, arg2
))
2270 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2271 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2275 tem
= value_logical_not (arg1
);
2277 = evaluate_subexp (nullptr, exp
, pos
, (tem
? EVAL_SKIP
: noside
));
2278 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2279 return value_from_longest (type
,
2280 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2283 case BINOP_LOGICAL_OR
:
2284 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2285 if (noside
== EVAL_SKIP
)
2287 evaluate_subexp (nullptr, exp
, pos
, noside
);
2288 return eval_skip_value (exp
);
2292 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2295 if (binop_user_defined_p (op
, arg1
, arg2
))
2297 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2298 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2302 tem
= value_logical_not (arg1
);
2304 = evaluate_subexp (nullptr, exp
, pos
, (!tem
? EVAL_SKIP
: noside
));
2305 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2306 return value_from_longest (type
,
2307 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2311 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2312 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2313 if (noside
== EVAL_SKIP
)
2314 return eval_skip_value (exp
);
2315 if (binop_user_defined_p (op
, arg1
, arg2
))
2317 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2321 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2322 tem
= value_equal (arg1
, arg2
);
2323 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2324 return value_from_longest (type
, (LONGEST
) tem
);
2327 case BINOP_NOTEQUAL
:
2328 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2329 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2330 if (noside
== EVAL_SKIP
)
2331 return eval_skip_value (exp
);
2332 if (binop_user_defined_p (op
, arg1
, arg2
))
2334 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2338 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2339 tem
= value_equal (arg1
, arg2
);
2340 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2341 return value_from_longest (type
, (LONGEST
) ! tem
);
2345 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2346 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2347 if (noside
== EVAL_SKIP
)
2348 return eval_skip_value (exp
);
2349 if (binop_user_defined_p (op
, arg1
, arg2
))
2351 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2355 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2356 tem
= value_less (arg1
, arg2
);
2357 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2358 return value_from_longest (type
, (LONGEST
) tem
);
2362 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2363 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2364 if (noside
== EVAL_SKIP
)
2365 return eval_skip_value (exp
);
2366 if (binop_user_defined_p (op
, arg1
, arg2
))
2368 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2372 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2373 tem
= value_less (arg2
, arg1
);
2374 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2375 return value_from_longest (type
, (LONGEST
) tem
);
2379 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2380 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2381 if (noside
== EVAL_SKIP
)
2382 return eval_skip_value (exp
);
2383 if (binop_user_defined_p (op
, arg1
, arg2
))
2385 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2389 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2390 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2391 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2392 return value_from_longest (type
, (LONGEST
) tem
);
2396 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2397 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2398 if (noside
== EVAL_SKIP
)
2399 return eval_skip_value (exp
);
2400 if (binop_user_defined_p (op
, arg1
, arg2
))
2402 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2406 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2407 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2408 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2409 return value_from_longest (type
, (LONGEST
) tem
);
2413 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2414 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2415 if (noside
== EVAL_SKIP
)
2416 return eval_skip_value (exp
);
2417 type
= check_typedef (value_type (arg2
));
2418 if (type
->code () != TYPE_CODE_INT
2419 && type
->code () != TYPE_CODE_ENUM
)
2420 error (_("Non-integral right operand for \"@\" operator."));
2421 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2423 return allocate_repeat_value (value_type (arg1
),
2424 longest_to_int (value_as_long (arg2
)));
2427 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2430 evaluate_subexp (nullptr, exp
, pos
, noside
);
2431 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2434 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2435 if (noside
== EVAL_SKIP
)
2436 return eval_skip_value (exp
);
2437 if (unop_user_defined_p (op
, arg1
))
2438 return value_x_unop (arg1
, op
, noside
);
2441 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2442 return value_pos (arg1
);
2446 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2447 if (noside
== EVAL_SKIP
)
2448 return eval_skip_value (exp
);
2449 if (unop_user_defined_p (op
, arg1
))
2450 return value_x_unop (arg1
, op
, noside
);
2453 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2454 return value_neg (arg1
);
2457 case UNOP_COMPLEMENT
:
2458 /* C++: check for and handle destructor names. */
2460 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2461 if (noside
== EVAL_SKIP
)
2462 return eval_skip_value (exp
);
2463 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2464 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2467 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2468 return value_complement (arg1
);
2471 case UNOP_LOGICAL_NOT
:
2472 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2473 if (noside
== EVAL_SKIP
)
2474 return eval_skip_value (exp
);
2475 if (unop_user_defined_p (op
, arg1
))
2476 return value_x_unop (arg1
, op
, noside
);
2479 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2480 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2484 if (expect_type
&& expect_type
->code () == TYPE_CODE_PTR
)
2485 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2486 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2487 type
= check_typedef (value_type (arg1
));
2488 if (type
->code () == TYPE_CODE_METHODPTR
2489 || type
->code () == TYPE_CODE_MEMBERPTR
)
2490 error (_("Attempt to dereference pointer "
2491 "to member without an object"));
2492 if (noside
== EVAL_SKIP
)
2493 return eval_skip_value (exp
);
2494 if (unop_user_defined_p (op
, arg1
))
2495 return value_x_unop (arg1
, op
, noside
);
2496 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2498 type
= check_typedef (value_type (arg1
));
2499 if (type
->code () == TYPE_CODE_PTR
2500 || TYPE_IS_REFERENCE (type
)
2501 /* In C you can dereference an array to get the 1st elt. */
2502 || type
->code () == TYPE_CODE_ARRAY
2504 return value_zero (TYPE_TARGET_TYPE (type
),
2506 else if (type
->code () == TYPE_CODE_INT
)
2507 /* GDB allows dereferencing an int. */
2508 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2511 error (_("Attempt to take contents of a non-pointer value."));
2514 /* Allow * on an integer so we can cast it to whatever we want.
2515 This returns an int, which seems like the most C-like thing to
2516 do. "long long" variables are rare enough that
2517 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2518 if (type
->code () == TYPE_CODE_INT
)
2519 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2520 (CORE_ADDR
) value_as_address (arg1
));
2521 return value_ind (arg1
);
2524 /* C++: check for and handle pointer to members. */
2526 if (noside
== EVAL_SKIP
)
2528 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2529 return eval_skip_value (exp
);
2533 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2540 if (noside
== EVAL_SKIP
)
2542 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2543 return eval_skip_value (exp
);
2545 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2550 evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
));
2551 /* FIXME: This should be size_t. */
2552 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2553 ULONGEST align
= type_align (type
);
2555 error (_("could not determine alignment of type"));
2556 return value_from_longest (size_type
, align
);
2561 type
= exp
->elts
[pc
+ 1].type
;
2562 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2564 case UNOP_CAST_TYPE
:
2565 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2566 type
= value_type (arg1
);
2567 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2569 case UNOP_DYNAMIC_CAST
:
2570 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2571 type
= value_type (arg1
);
2572 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2573 if (noside
== EVAL_SKIP
)
2574 return eval_skip_value (exp
);
2575 return value_dynamic_cast (type
, arg1
);
2577 case UNOP_REINTERPRET_CAST
:
2578 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2579 type
= value_type (arg1
);
2580 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2581 if (noside
== EVAL_SKIP
)
2582 return eval_skip_value (exp
);
2583 return value_reinterpret_cast (type
, arg1
);
2587 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2588 if (noside
== EVAL_SKIP
)
2589 return eval_skip_value (exp
);
2590 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2591 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2593 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2594 value_as_address (arg1
));
2596 case UNOP_MEMVAL_TYPE
:
2597 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2598 type
= value_type (arg1
);
2599 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2600 if (noside
== EVAL_SKIP
)
2601 return eval_skip_value (exp
);
2602 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2603 return value_zero (type
, lval_memory
);
2605 return value_at_lazy (type
, value_as_address (arg1
));
2607 case UNOP_PREINCREMENT
:
2608 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2609 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2611 else if (unop_user_defined_p (op
, arg1
))
2613 return value_x_unop (arg1
, op
, noside
);
2617 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2618 arg2
= value_ptradd (arg1
, 1);
2621 struct value
*tmp
= arg1
;
2623 arg2
= value_one (value_type (arg1
));
2624 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2625 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2628 return value_assign (arg1
, arg2
);
2631 case UNOP_PREDECREMENT
:
2632 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2633 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2635 else if (unop_user_defined_p (op
, arg1
))
2637 return value_x_unop (arg1
, op
, noside
);
2641 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2642 arg2
= value_ptradd (arg1
, -1);
2645 struct value
*tmp
= arg1
;
2647 arg2
= value_one (value_type (arg1
));
2648 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2649 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2652 return value_assign (arg1
, arg2
);
2655 case UNOP_POSTINCREMENT
:
2656 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2657 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2659 else if (unop_user_defined_p (op
, arg1
))
2661 return value_x_unop (arg1
, op
, noside
);
2665 arg3
= value_non_lval (arg1
);
2667 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2668 arg2
= value_ptradd (arg1
, 1);
2671 struct value
*tmp
= arg1
;
2673 arg2
= value_one (value_type (arg1
));
2674 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2675 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2678 value_assign (arg1
, arg2
);
2682 case UNOP_POSTDECREMENT
:
2683 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2684 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2686 else if (unop_user_defined_p (op
, arg1
))
2688 return value_x_unop (arg1
, op
, noside
);
2692 arg3
= value_non_lval (arg1
);
2694 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2695 arg2
= value_ptradd (arg1
, -1);
2698 struct value
*tmp
= arg1
;
2700 arg2
= value_one (value_type (arg1
));
2701 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2702 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2705 value_assign (arg1
, arg2
);
2711 return value_of_this (exp
->language_defn
);
2714 /* The value is not supposed to be used. This is here to make it
2715 easier to accommodate expressions that contain types. */
2717 if (noside
== EVAL_SKIP
)
2718 return eval_skip_value (exp
);
2719 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2720 return allocate_value (exp
->elts
[pc
+ 1].type
);
2722 error (_("Attempt to use a type name as an expression"));
2726 if (noside
== EVAL_SKIP
)
2728 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2729 return eval_skip_value (exp
);
2731 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2733 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2734 struct value
*result
;
2736 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2738 /* 'decltype' has special semantics for lvalues. */
2739 if (op
== OP_DECLTYPE
2740 && (sub_op
== BINOP_SUBSCRIPT
2741 || sub_op
== STRUCTOP_MEMBER
2742 || sub_op
== STRUCTOP_MPTR
2743 || sub_op
== UNOP_IND
2744 || sub_op
== STRUCTOP_STRUCT
2745 || sub_op
== STRUCTOP_PTR
2746 || sub_op
== OP_SCOPE
))
2748 type
= value_type (result
);
2750 if (!TYPE_IS_REFERENCE (type
))
2752 type
= lookup_lvalue_reference_type (type
);
2753 result
= allocate_value (type
);
2760 error (_("Attempt to use a type as an expression"));
2764 struct value
*result
;
2765 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2767 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2768 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2770 result
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2772 if (noside
!= EVAL_NORMAL
)
2773 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2775 return cplus_typeid (result
);
2779 /* Removing this case and compiling with gcc -Wall reveals that
2780 a lot of cases are hitting this case. Some of these should
2781 probably be removed from expression.h; others are legitimate
2782 expressions which are (apparently) not fully implemented.
2784 If there are any cases landing here which mean a user error,
2785 then they should be separate cases, with more descriptive
2788 error (_("GDB does not (yet) know how to "
2789 "evaluate that kind of expression"));
2792 gdb_assert_not_reached ("missed return?");
2795 /* Evaluate a subexpression of EXP, at index *POS,
2796 and return the address of that subexpression.
2797 Advance *POS over the subexpression.
2798 If the subexpression isn't an lvalue, get an error.
2799 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2800 then only the type of the result need be correct. */
2802 static struct value
*
2803 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2813 op
= exp
->elts
[pc
].opcode
;
2819 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2821 /* We can't optimize out "&*" if there's a user-defined operator*. */
2822 if (unop_user_defined_p (op
, x
))
2824 x
= value_x_unop (x
, op
, noside
);
2825 goto default_case_after_eval
;
2828 return coerce_array (x
);
2832 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2833 evaluate_subexp (nullptr, exp
, pos
, noside
));
2835 case UNOP_MEMVAL_TYPE
:
2840 x
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2841 type
= value_type (x
);
2842 return value_cast (lookup_pointer_type (type
),
2843 evaluate_subexp (nullptr, exp
, pos
, noside
));
2847 var
= exp
->elts
[pc
+ 2].symbol
;
2849 /* C++: The "address" of a reference should yield the address
2850 * of the object pointed to. Let value_addr() deal with it. */
2851 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
2855 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2858 lookup_pointer_type (SYMBOL_TYPE (var
));
2859 enum address_class sym_class
= SYMBOL_CLASS (var
);
2861 if (sym_class
== LOC_CONST
2862 || sym_class
== LOC_CONST_BYTES
2863 || sym_class
== LOC_REGISTER
)
2864 error (_("Attempt to take address of register or constant."));
2867 value_zero (type
, not_lval
);
2870 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2872 case OP_VAR_MSYM_VALUE
:
2876 value
*val
= evaluate_var_msym_value (noside
,
2877 exp
->elts
[pc
+ 1].objfile
,
2878 exp
->elts
[pc
+ 2].msymbol
);
2879 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2881 struct type
*type
= lookup_pointer_type (value_type (val
));
2882 return value_zero (type
, not_lval
);
2885 return value_addr (val
);
2889 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2890 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2891 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2892 &exp
->elts
[pc
+ 3].string
,
2895 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2900 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2901 default_case_after_eval
:
2902 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2904 struct type
*type
= check_typedef (value_type (x
));
2906 if (TYPE_IS_REFERENCE (type
))
2907 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2909 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2910 return value_zero (lookup_pointer_type (value_type (x
)),
2913 error (_("Attempt to take address of "
2914 "value not located in memory."));
2916 return value_addr (x
);
2920 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2921 When used in contexts where arrays will be coerced anyway, this is
2922 equivalent to `evaluate_subexp' but much faster because it avoids
2923 actually fetching array contents (perhaps obsolete now that we have
2926 Note that we currently only do the coercion for C expressions, where
2927 arrays are zero based and the coercion is correct. For other languages,
2928 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2929 to decide if coercion is appropriate. */
2932 evaluate_subexp_with_coercion (struct expression
*exp
,
2933 int *pos
, enum noside noside
)
2942 op
= exp
->elts
[pc
].opcode
;
2947 var
= exp
->elts
[pc
+ 2].symbol
;
2948 type
= check_typedef (SYMBOL_TYPE (var
));
2949 if (type
->code () == TYPE_CODE_ARRAY
2950 && !type
->is_vector ()
2951 && CAST_IS_CONVERSION (exp
->language_defn
))
2954 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2955 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2961 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2965 /* Evaluate a subexpression of EXP, at index *POS,
2966 and return a value for the size of that subexpression.
2967 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2968 we allow side-effects on the operand if its type is a variable
2971 static struct value
*
2972 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
2975 /* FIXME: This should be size_t. */
2976 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2983 op
= exp
->elts
[pc
].opcode
;
2987 /* This case is handled specially
2988 so that we avoid creating a value for the result type.
2989 If the result type is very big, it's desirable not to
2990 create a value unnecessarily. */
2993 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2994 type
= check_typedef (value_type (val
));
2995 if (type
->code () != TYPE_CODE_PTR
2996 && !TYPE_IS_REFERENCE (type
)
2997 && type
->code () != TYPE_CODE_ARRAY
)
2998 error (_("Attempt to take contents of a non-pointer value."));
2999 type
= TYPE_TARGET_TYPE (type
);
3000 if (is_dynamic_type (type
))
3001 type
= value_type (value_ind (val
));
3002 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3006 type
= exp
->elts
[pc
+ 1].type
;
3009 case UNOP_MEMVAL_TYPE
:
3011 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3012 type
= value_type (val
);
3016 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3017 if (is_dynamic_type (type
))
3019 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3020 type
= value_type (val
);
3021 if (type
->code () == TYPE_CODE_ARRAY
3022 && is_dynamic_type (type
->index_type ())
3023 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
3024 return allocate_optimized_out_value (size_type
);
3030 case OP_VAR_MSYM_VALUE
:
3034 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3035 value
*mval
= evaluate_var_msym_value (noside
,
3036 exp
->elts
[pc
+ 1].objfile
,
3039 type
= value_type (mval
);
3040 if (type
->code () == TYPE_CODE_ERROR
)
3041 error_unknown_type (msymbol
->print_name ());
3043 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3047 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3048 type of the subscript is a variable length array type. In this case we
3049 must re-evaluate the right hand side of the subscription to allow
3051 case BINOP_SUBSCRIPT
:
3052 if (noside
== EVAL_NORMAL
)
3054 int npc
= (*pos
) + 1;
3056 val
= evaluate_subexp (nullptr, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3057 type
= check_typedef (value_type (val
));
3058 if (type
->code () == TYPE_CODE_ARRAY
)
3060 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3061 if (type
->code () == TYPE_CODE_ARRAY
)
3063 type
= type
->index_type ();
3064 /* Only re-evaluate the right hand side if the resulting type
3065 is a variable length type. */
3066 if (type
->bounds ()->flag_bound_evaluated
)
3068 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3069 return value_from_longest
3070 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3079 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3080 type
= value_type (val
);
3084 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3085 "When applied to a reference or a reference type, the result is
3086 the size of the referenced type." */
3087 type
= check_typedef (type
);
3088 if (exp
->language_defn
->la_language
== language_cplus
3089 && (TYPE_IS_REFERENCE (type
)))
3090 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3091 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3094 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3095 for that subexpression cast to TO_TYPE. Advance *POS over the
3099 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3101 struct type
*to_type
)
3105 /* Don't let symbols be evaluated with evaluate_subexp because that
3106 throws an "unknown type" error for no-debug data symbols.
3107 Instead, we want the cast to reinterpret the symbol. */
3108 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3109 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3114 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3116 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3117 return value_zero (to_type
, not_lval
);
3119 val
= evaluate_var_msym_value (noside
,
3120 exp
->elts
[pc
+ 1].objfile
,
3121 exp
->elts
[pc
+ 2].msymbol
);
3124 val
= evaluate_var_value (noside
,
3125 exp
->elts
[pc
+ 1].block
,
3126 exp
->elts
[pc
+ 2].symbol
);
3128 if (noside
== EVAL_SKIP
)
3129 return eval_skip_value (exp
);
3131 val
= value_cast (to_type
, val
);
3133 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3134 if (VALUE_LVAL (val
) == lval_memory
)
3136 if (value_lazy (val
))
3137 value_fetch_lazy (val
);
3138 VALUE_LVAL (val
) = not_lval
;
3143 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3144 if (noside
== EVAL_SKIP
)
3145 return eval_skip_value (exp
);
3146 return value_cast (to_type
, val
);
3149 /* Parse a type expression in the string [P..P+LENGTH). */
3152 parse_and_eval_type (char *p
, int length
)
3154 char *tmp
= (char *) alloca (length
+ 4);
3157 memcpy (tmp
+ 1, p
, length
);
3158 tmp
[length
+ 1] = ')';
3159 tmp
[length
+ 2] = '0';
3160 tmp
[length
+ 3] = '\0';
3161 expression_up expr
= parse_expression (tmp
);
3162 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3163 error (_("Internal error in eval_type."));
3164 return expr
->elts
[1].type
;