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"
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 *,
61 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
62 int *pos
, enum noside noside
)
64 return ((*exp
->language_defn
->expression_ops ()->evaluate_exp
)
65 (expect_type
, exp
, pos
, noside
));
68 /* Parse the string EXP as a C expression, evaluate it,
69 and return the result as a number. */
72 parse_and_eval_address (const char *exp
)
74 expression_up expr
= parse_expression (exp
);
76 return value_as_address (evaluate_expression (expr
.get ()));
79 /* Like parse_and_eval_address, but treats the value of the expression
80 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
82 parse_and_eval_long (const char *exp
)
84 expression_up expr
= parse_expression (exp
);
86 return value_as_long (evaluate_expression (expr
.get ()));
90 parse_and_eval (const char *exp
)
92 expression_up expr
= parse_expression (exp
);
94 return evaluate_expression (expr
.get ());
97 /* Parse up to a comma (or to a closeparen)
98 in the string EXPP as an expression, evaluate it, and return the value.
99 EXPP is advanced to point to the comma. */
102 parse_to_comma_and_eval (const char **expp
)
104 expression_up expr
= parse_exp_1 (expp
, 0, nullptr, 1);
106 return evaluate_expression (expr
.get ());
110 /* See expression.h. */
113 expression::evaluate (struct type
*expect_type
, enum noside noside
)
115 gdb::optional
<enable_thread_stack_temporaries
> stack_temporaries
;
116 if (target_has_execution ()
117 && language_defn
->la_language
== language_cplus
118 && !thread_stack_temporaries_enabled_p (inferior_thread ()))
119 stack_temporaries
.emplace (inferior_thread ());
122 struct value
*retval
= evaluate_subexp (expect_type
, this, &pos
, noside
);
124 if (stack_temporaries
.has_value ()
125 && value_in_thread_stack_temporaries (retval
, inferior_thread ()))
126 retval
= value_non_lval (retval
);
134 evaluate_expression (struct expression
*exp
, struct type
*expect_type
)
136 return exp
->evaluate (expect_type
, EVAL_NORMAL
);
139 /* Evaluate an expression, avoiding all memory references
140 and getting a value whose type alone is correct. */
143 evaluate_type (struct expression
*exp
)
145 return exp
->evaluate (nullptr, EVAL_AVOID_SIDE_EFFECTS
);
148 /* Evaluate a subexpression, avoiding all memory references and
149 getting a value whose type alone is correct. */
152 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
154 return evaluate_subexp (nullptr, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
157 /* Find the current value of a watchpoint on EXP. Return the value in
158 *VALP and *RESULTP and the chain of intermediate and final values
159 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
162 If PRESERVE_ERRORS is true, then exceptions are passed through.
163 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
164 occurs while evaluating the expression, *RESULTP will be set to
165 NULL. *RESULTP may be a lazy value, if the result could not be
166 read from memory. It is used to determine whether a value is
167 user-specified (we should watch the whole value) or intermediate
168 (we should watch only the bit used to locate the final value).
170 If the final value, or any intermediate value, could not be read
171 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
172 set to any referenced values. *VALP will never be a lazy value.
173 This is the value which we store in struct breakpoint.
175 If VAL_CHAIN is non-NULL, the values put into *VAL_CHAIN will be
176 released from the value chain. If VAL_CHAIN is NULL, all generated
177 values will be left on the value chain. */
180 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
181 struct value
**resultp
,
182 std::vector
<value_ref_ptr
> *val_chain
,
183 bool preserve_errors
)
185 struct value
*mark
, *new_mark
, *result
;
193 /* Evaluate the expression. */
194 mark
= value_mark ();
199 result
= evaluate_subexp (nullptr, exp
, pc
, EVAL_NORMAL
);
201 catch (const gdb_exception
&ex
)
203 /* Ignore memory errors if we want watchpoints pointing at
204 inaccessible memory to still be created; otherwise, throw the
205 error to some higher catcher. */
209 if (!preserve_errors
)
218 new_mark
= value_mark ();
219 if (mark
== new_mark
)
224 /* Make sure it's not lazy, so that after the target stops again we
225 have a non-lazy previous value to compare with. */
228 if (!value_lazy (result
))
235 value_fetch_lazy (result
);
238 catch (const gdb_exception_error
&except
)
246 /* Return the chain of intermediate values. We use this to
247 decide which addresses to watch. */
248 *val_chain
= value_release_to_mark (mark
);
252 /* Extract a field operation from an expression. If the subexpression
253 of EXP starting at *SUBEXP is not a structure dereference
254 operation, return NULL. Otherwise, return the name of the
255 dereferenced field, and advance *SUBEXP to point to the
256 subexpression of the left-hand-side of the dereference. This is
257 used when completing field names. */
260 extract_field_op (struct expression
*exp
, int *subexp
)
265 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
266 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
268 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
269 result
= &exp
->elts
[*subexp
+ 2].string
;
270 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
274 /* This function evaluates brace-initializers (in C/C++) for
277 static struct value
*
278 evaluate_struct_tuple (struct value
*struct_val
,
279 struct expression
*exp
,
280 int *pos
, enum noside noside
, int nargs
)
282 struct type
*struct_type
= check_typedef (value_type (struct_val
));
283 struct type
*field_type
;
288 struct value
*val
= NULL
;
293 /* Skip static fields. */
294 while (fieldno
< struct_type
->num_fields ()
295 && field_is_static (&struct_type
->field (fieldno
)))
297 if (fieldno
>= struct_type
->num_fields ())
298 error (_("too many initializers"));
299 field_type
= struct_type
->field (fieldno
).type ();
300 if (field_type
->code () == TYPE_CODE_UNION
301 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
302 error (_("don't know which variant you want to set"));
304 /* Here, struct_type is the type of the inner struct,
305 while substruct_type is the type of the inner struct.
306 These are the same for normal structures, but a variant struct
307 contains anonymous union fields that contain substruct fields.
308 The value fieldno is the index of the top-level (normal or
309 anonymous union) field in struct_field, while the value
310 subfieldno is the index of the actual real (named inner) field
311 in substruct_type. */
313 field_type
= struct_type
->field (fieldno
).type ();
315 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
317 /* Now actually set the field in struct_val. */
319 /* Assign val to field fieldno. */
320 if (value_type (val
) != field_type
)
321 val
= value_cast (field_type
, val
);
323 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
324 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
325 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
327 modify_field (struct_type
, addr
,
328 value_as_long (val
), bitpos
% 8, bitsize
);
330 memcpy (addr
, value_contents (val
),
331 TYPE_LENGTH (value_type (val
)));
337 /* Promote value ARG1 as appropriate before performing a unary operation
339 If the result is not appropriate for any particular language then it
340 needs to patch this function. */
343 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
348 *arg1
= coerce_ref (*arg1
);
349 type1
= check_typedef (value_type (*arg1
));
351 if (is_integral_type (type1
))
353 switch (language
->la_language
)
356 /* Perform integral promotion for ANSI C/C++.
357 If not appropriate for any particular language
358 it needs to modify this function. */
360 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
362 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
363 *arg1
= value_cast (builtin_int
, *arg1
);
370 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
371 operation on those two operands.
372 If the result is not appropriate for any particular language then it
373 needs to patch this function. */
376 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
377 struct value
**arg1
, struct value
**arg2
)
379 struct type
*promoted_type
= NULL
;
383 *arg1
= coerce_ref (*arg1
);
384 *arg2
= coerce_ref (*arg2
);
386 type1
= check_typedef (value_type (*arg1
));
387 type2
= check_typedef (value_type (*arg2
));
389 if ((type1
->code () != TYPE_CODE_FLT
390 && type1
->code () != TYPE_CODE_DECFLOAT
391 && !is_integral_type (type1
))
392 || (type2
->code () != TYPE_CODE_FLT
393 && type2
->code () != TYPE_CODE_DECFLOAT
394 && !is_integral_type (type2
)))
397 if (is_fixed_point_type (type1
) || is_fixed_point_type (type2
))
400 if (type1
->code () == TYPE_CODE_DECFLOAT
401 || type2
->code () == TYPE_CODE_DECFLOAT
)
403 /* No promotion required. */
405 else if (type1
->code () == TYPE_CODE_FLT
406 || type2
->code () == TYPE_CODE_FLT
)
408 switch (language
->la_language
)
414 case language_opencl
:
415 /* No promotion required. */
419 /* For other languages the result type is unchanged from gdb
420 version 6.7 for backward compatibility.
421 If either arg was long double, make sure that value is also long
422 double. Otherwise use double. */
423 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
424 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
425 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
427 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
431 else if (type1
->code () == TYPE_CODE_BOOL
432 && type2
->code () == TYPE_CODE_BOOL
)
434 /* No promotion required. */
437 /* Integral operations here. */
438 /* FIXME: Also mixed integral/booleans, with result an integer. */
440 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
441 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
442 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
443 int is_unsigned1
= type1
->is_unsigned ();
444 int is_unsigned2
= type2
->is_unsigned ();
445 unsigned int result_len
;
446 int unsigned_operation
;
448 /* Determine type length and signedness after promotion for
450 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
453 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
455 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
458 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
461 if (promoted_len1
> promoted_len2
)
463 unsigned_operation
= is_unsigned1
;
464 result_len
= promoted_len1
;
466 else if (promoted_len2
> promoted_len1
)
468 unsigned_operation
= is_unsigned2
;
469 result_len
= promoted_len2
;
473 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
474 result_len
= promoted_len1
;
477 switch (language
->la_language
)
483 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
485 promoted_type
= (unsigned_operation
486 ? builtin
->builtin_unsigned_int
487 : builtin
->builtin_int
);
489 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
491 promoted_type
= (unsigned_operation
492 ? builtin
->builtin_unsigned_long
493 : builtin
->builtin_long
);
497 promoted_type
= (unsigned_operation
498 ? builtin
->builtin_unsigned_long_long
499 : builtin
->builtin_long_long
);
502 case language_opencl
:
503 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
508 ? lookup_unsigned_typename (language
, "int")
509 : lookup_signed_typename (language
, "int"));
511 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
516 ? lookup_unsigned_typename (language
, "long")
517 : lookup_signed_typename (language
,"long"));
521 /* For other languages the result type is unchanged from gdb
522 version 6.7 for backward compatibility.
523 If either arg was long long, make sure that value is also long
524 long. Otherwise use long. */
525 if (unsigned_operation
)
527 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
528 promoted_type
= builtin
->builtin_unsigned_long_long
;
530 promoted_type
= builtin
->builtin_unsigned_long
;
534 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
535 promoted_type
= builtin
->builtin_long_long
;
537 promoted_type
= builtin
->builtin_long
;
545 /* Promote both operands to common type. */
546 *arg1
= value_cast (promoted_type
, *arg1
);
547 *arg2
= value_cast (promoted_type
, *arg2
);
552 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
554 type
= check_typedef (type
);
555 if (TYPE_IS_REFERENCE (type
))
556 type
= TYPE_TARGET_TYPE (type
);
558 switch (type
->code ())
564 case TYPE_CODE_ARRAY
:
565 return type
->is_vector () ? 0 : lang
->c_style_arrays_p ();
572 /* Represents a fake method with the given parameter types. This is
573 used by the parser to construct a temporary "expected" type for
574 method overload resolution. FLAGS is used as instance flags of the
575 new type, in order to be able to make the new type represent a
576 const/volatile overload. */
581 fake_method (type_instance_flags flags
,
582 int num_types
, struct type
**param_types
);
585 /* The constructed type. */
586 struct type
*type () { return &m_type
; }
589 struct type m_type
{};
590 main_type m_main_type
{};
593 fake_method::fake_method (type_instance_flags flags
,
594 int num_types
, struct type
**param_types
)
596 struct type
*type
= &m_type
;
598 TYPE_MAIN_TYPE (type
) = &m_main_type
;
599 TYPE_LENGTH (type
) = 1;
600 type
->set_code (TYPE_CODE_METHOD
);
601 TYPE_CHAIN (type
) = type
;
602 type
->set_instance_flags (flags
);
605 if (param_types
[num_types
- 1] == NULL
)
608 type
->set_has_varargs (true);
610 else if (check_typedef (param_types
[num_types
- 1])->code ()
614 /* Caller should have ensured this. */
615 gdb_assert (num_types
== 0);
616 type
->set_is_prototyped (true);
620 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
621 neither an objfile nor a gdbarch. As a result we must manually
622 allocate memory for auxiliary fields, and free the memory ourselves
623 when we are done with it. */
624 type
->set_num_fields (num_types
);
626 ((struct field
*) xzalloc (sizeof (struct field
) * num_types
));
628 while (num_types
-- > 0)
629 type
->field (num_types
).set_type (param_types
[num_types
]);
632 fake_method::~fake_method ()
634 xfree (m_type
.fields ());
637 /* Helper for evaluating an OP_VAR_VALUE. */
640 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
642 /* JYG: We used to just return value_zero of the symbol type if
643 we're asked to avoid side effects. Otherwise we return
644 value_of_variable (...). However I'm not sure if
645 value_of_variable () has any side effect. We need a full value
646 object returned here for whatis_exp () to call evaluate_type ()
647 and then pass the full value to value_rtti_target_type () if we
648 are dealing with a pointer or reference to a base class and print
651 struct value
*ret
= NULL
;
655 ret
= value_of_variable (var
, blk
);
658 catch (const gdb_exception_error
&except
)
660 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
663 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
669 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
672 evaluate_var_msym_value (enum noside noside
,
673 struct objfile
*objfile
, minimal_symbol
*msymbol
)
676 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
678 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !the_type
->is_gnu_ifunc ())
679 return value_zero (the_type
, not_lval
);
681 return value_at_lazy (the_type
, address
);
684 /* Helper for returning a value when handling EVAL_SKIP. */
687 eval_skip_value (expression
*exp
)
689 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
692 /* See expression.h. */
695 evaluate_subexp_do_call (expression
*exp
, enum noside noside
,
697 gdb::array_view
<value
*> argvec
,
698 const char *function_name
,
699 type
*default_return_type
)
702 error (_("Cannot evaluate function -- may be inlined"));
703 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
705 /* If the return type doesn't look like a function type,
706 call an error. This can happen if somebody tries to turn
707 a variable into a function call. */
709 type
*ftype
= value_type (callee
);
711 if (ftype
->code () == TYPE_CODE_INTERNAL_FUNCTION
)
713 /* We don't know anything about what the internal
714 function might return, but we have to return
716 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
719 else if (ftype
->code () == TYPE_CODE_XMETHOD
)
721 type
*return_type
= result_type_of_xmethod (callee
, argvec
);
723 if (return_type
== NULL
)
724 error (_("Xmethod is missing return type."));
725 return value_zero (return_type
, not_lval
);
727 else if (ftype
->code () == TYPE_CODE_FUNC
728 || ftype
->code () == TYPE_CODE_METHOD
)
730 if (ftype
->is_gnu_ifunc ())
732 CORE_ADDR address
= value_address (callee
);
733 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
735 if (resolved_type
!= NULL
)
736 ftype
= resolved_type
;
739 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
741 if (return_type
== NULL
)
742 return_type
= default_return_type
;
744 if (return_type
== NULL
)
745 error_call_unknown_return_type (function_name
);
747 return allocate_value (return_type
);
750 error (_("Expression of type other than "
751 "\"Function returning ...\" used as function"));
753 switch (value_type (callee
)->code ())
755 case TYPE_CODE_INTERNAL_FUNCTION
:
756 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
757 callee
, argvec
.size (), argvec
.data ());
758 case TYPE_CODE_XMETHOD
:
759 return call_xmethod (callee
, argvec
);
761 return call_function_by_hand (callee
, default_return_type
, argvec
);
765 /* Helper for evaluating an OP_FUNCALL. */
768 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
776 symbol
*function
= NULL
;
777 char *function_name
= NULL
;
778 const char *var_func_name
= NULL
;
783 exp_opcode op
= exp
->elts
[*pos
].opcode
;
784 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
785 /* Allocate arg vector, including space for the function to be
786 called in argvec[0], a potential `this', and a terminating
788 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
789 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
791 /* First, evaluate the structure into arg2. */
794 if (op
== STRUCTOP_MEMBER
)
796 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
800 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
803 /* If the function is a virtual function, then the aggregate
804 value (providing the structure) plays its part by providing
805 the vtable. Otherwise, it is just along for the ride: call
806 the function directly. */
808 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
810 type
*a1_type
= check_typedef (value_type (arg1
));
811 if (noside
== EVAL_SKIP
)
812 tem
= 1; /* Set it to the right arg index so that all
813 arguments can also be skipped. */
814 else if (a1_type
->code () == TYPE_CODE_METHODPTR
)
816 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
817 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
819 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
821 /* Now, say which argument to start evaluating from. */
826 else if (a1_type
->code () == TYPE_CODE_MEMBERPTR
)
828 struct type
*type_ptr
829 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
830 struct type
*target_type_ptr
831 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
833 /* Now, convert these values to an address. */
834 arg2
= value_cast (type_ptr
, arg2
);
836 long mem_offset
= value_as_long (arg1
);
838 arg1
= value_from_pointer (target_type_ptr
,
839 value_as_long (arg2
) + mem_offset
);
840 arg1
= value_ind (arg1
);
844 error (_("Non-pointer-to-member value used in pointer-to-member "
847 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
849 /* Hair for method invocations. */
853 /* First, evaluate the structure into arg2. */
855 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
856 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
858 if (op
== STRUCTOP_STRUCT
)
860 /* If v is a variable in a register, and the user types
861 v.method (), this will produce an error, because v has no
864 A possible way around this would be to allocate a copy of
865 the variable on the stack, copy in the contents, call the
866 function, and copy out the contents. I.e. convert this
867 from call by reference to call by copy-return (or
868 whatever it's called). However, this does not work
869 because it is not the same: the method being called could
870 stash a copy of the address, and then future uses through
871 that address (after the method returns) would be expected
872 to use the variable itself, not some copy of it. */
873 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
877 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
879 /* Check to see if the operator '->' has been overloaded.
880 If the operator has been overloaded replace arg2 with the
881 value returned by the custom operator and continue
883 while (unop_user_defined_p (op
, arg2
))
885 struct value
*value
= NULL
;
888 value
= value_x_unop (arg2
, op
, noside
);
891 catch (const gdb_exception_error
&except
)
893 if (except
.error
== NOT_FOUND_ERROR
)
902 /* Now, say which argument to start evaluating from. */
905 else if (op
== OP_SCOPE
906 && overload_resolution
907 && (exp
->language_defn
->la_language
== language_cplus
))
909 /* Unpack it locally so we can properly handle overload
915 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
916 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
917 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
918 name
= &exp
->elts
[pc2
+ 3].string
;
921 function_name
= NULL
;
922 if (type
->code () == TYPE_CODE_NAMESPACE
)
924 function
= cp_lookup_symbol_namespace (type
->name (),
926 get_selected_block (0),
928 if (function
== NULL
)
929 error (_("No symbol \"%s\" in namespace \"%s\"."),
930 name
, type
->name ());
933 /* arg2 is left as NULL on purpose. */
937 gdb_assert (type
->code () == TYPE_CODE_STRUCT
938 || type
->code () == TYPE_CODE_UNION
);
939 function_name
= name
;
941 /* We need a properly typed value for method lookup. For
942 static methods arg2 is otherwise unused. */
943 arg2
= value_zero (type
, lval_memory
);
948 else if (op
== OP_ADL_FUNC
)
950 /* Save the function position and move pos so that the arguments
957 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
958 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
962 /* Non-method function call. */
966 /* If this is a C++ function wait until overload resolution. */
967 if (op
== OP_VAR_VALUE
968 && overload_resolution
969 && (exp
->language_defn
->la_language
== language_cplus
))
971 (*pos
) += 4; /* Skip the evaluation of the symbol. */
976 if (op
== OP_VAR_MSYM_VALUE
)
978 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
979 var_func_name
= msym
->print_name ();
981 else if (op
== OP_VAR_VALUE
)
983 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
984 var_func_name
= sym
->print_name ();
987 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
988 type
*type
= value_type (argvec
[0]);
989 if (type
&& type
->code () == TYPE_CODE_PTR
)
990 type
= TYPE_TARGET_TYPE (type
);
991 if (type
&& type
->code () == TYPE_CODE_FUNC
)
993 for (; tem
<= nargs
&& tem
<= type
->num_fields (); tem
++)
995 argvec
[tem
] = evaluate_subexp (type
->field (tem
- 1).type (),
1002 /* Evaluate arguments (if not already done, e.g., namespace::func()
1003 and overload-resolution is off). */
1004 for (; tem
<= nargs
; tem
++)
1006 /* Ensure that array expressions are coerced into pointer
1008 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1011 /* Signal end of arglist. */
1014 if (noside
== EVAL_SKIP
)
1015 return eval_skip_value (exp
);
1017 if (op
== OP_ADL_FUNC
)
1019 struct symbol
*symp
;
1022 int string_pc
= save_pos1
+ 3;
1024 /* Extract the function name. */
1025 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1026 func_name
= (char *) alloca (name_len
+ 1);
1027 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1029 find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1031 NON_METHOD
, /* not method */
1032 NULL
, NULL
, /* pass NULL symbol since
1033 symbol is unknown */
1034 NULL
, &symp
, NULL
, 0, noside
);
1036 /* Now fix the expression being evaluated. */
1037 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1038 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1041 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1042 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1044 int static_memfuncp
;
1047 /* Method invocation: stuff "this" as first parameter. If the
1048 method turns out to be static we undo this below. */
1053 /* Name of method from expression. */
1054 tstr
= &exp
->elts
[pc2
+ 2].string
;
1057 tstr
= function_name
;
1059 if (overload_resolution
&& (exp
->language_defn
->la_language
1062 /* Language is C++, do some overload resolution before
1064 struct value
*valp
= NULL
;
1066 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1068 METHOD
, /* method */
1069 &arg2
, /* the object */
1071 &static_memfuncp
, 0, noside
);
1073 if (op
== OP_SCOPE
&& !static_memfuncp
)
1075 /* For the time being, we don't handle this. */
1076 error (_("Call to overloaded function %s requires "
1080 argvec
[1] = arg2
; /* the ``this'' pointer */
1081 argvec
[0] = valp
; /* Use the method found after overload
1085 /* Non-C++ case -- or no overload resolution. */
1087 struct value
*temp
= arg2
;
1089 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1091 op
== STRUCTOP_STRUCT
1092 ? "structure" : "structure pointer");
1093 /* value_struct_elt updates temp with the correct value of
1094 the ``this'' pointer if necessary, so modify argvec[1] to
1095 reflect any ``this'' changes. */
1097 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1098 value_address (temp
)
1099 + value_embedded_offset (temp
));
1100 argvec
[1] = arg2
; /* the ``this'' pointer */
1103 /* Take out `this' if needed. */
1104 if (static_memfuncp
)
1106 argvec
[1] = argvec
[0];
1111 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1113 /* Pointer to member. argvec[1] is already set up. */
1116 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1118 /* Non-member function being called. */
1119 /* fn: This can only be done for C++ functions. A C-style
1120 function in a C++ program, for instance, does not have the
1121 fields that are expected here. */
1123 if (overload_resolution
&& (exp
->language_defn
->la_language
1126 /* Language is C++, do some overload resolution before
1128 struct symbol
*symp
;
1131 /* If a scope has been specified disable ADL. */
1135 if (op
== OP_VAR_VALUE
)
1136 function
= exp
->elts
[save_pos1
+2].symbol
;
1138 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1139 NULL
, /* no need for name */
1140 NON_METHOD
, /* not method */
1141 NULL
, function
, /* the function */
1142 NULL
, &symp
, NULL
, no_adl
, noside
);
1144 if (op
== OP_VAR_VALUE
)
1146 /* Now fix the expression being evaluated. */
1147 exp
->elts
[save_pos1
+2].symbol
= symp
;
1148 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1152 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1156 /* Not C++, or no overload resolution allowed. */
1157 /* Nothing to be done; argvec already correctly set up. */
1162 /* It is probably a C-style function. */
1163 /* Nothing to be done; argvec already correctly set up. */
1166 return evaluate_subexp_do_call (exp
, noside
, argvec
[0],
1167 gdb::make_array_view (argvec
+ 1, nargs
),
1168 var_func_name
, expect_type
);
1171 /* Return true if type is integral or reference to integral */
1174 is_integral_or_integral_reference (struct type
*type
)
1176 if (is_integral_type (type
))
1179 type
= check_typedef (type
);
1180 return (type
!= nullptr
1181 && TYPE_IS_REFERENCE (type
)
1182 && is_integral_type (TYPE_TARGET_TYPE (type
)));
1185 /* Helper function that implements the body of OP_SCOPE. */
1187 static struct value
*
1188 eval_op_scope (struct type
*expect_type
, struct expression
*exp
,
1190 struct type
*type
, const char *string
)
1192 if (noside
== EVAL_SKIP
)
1193 return eval_skip_value (exp
);
1194 struct value
*arg1
= value_aggregate_elt (type
, string
, expect_type
,
1197 error (_("There is no field named %s"), string
);
1201 /* Helper function that implements the body of OP_VAR_ENTRY_VALUE. */
1203 static struct value
*
1204 eval_op_var_entry_value (struct type
*expect_type
, struct expression
*exp
,
1205 enum noside noside
, symbol
*sym
)
1207 if (noside
== EVAL_SKIP
)
1208 return eval_skip_value (exp
);
1209 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1210 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1212 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1213 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1214 error (_("Symbol \"%s\" does not have any specific entry value"),
1215 sym
->print_name ());
1217 struct frame_info
*frame
= get_selected_frame (NULL
);
1218 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1221 /* Helper function that implements the body of OP_VAR_MSYM_VALUE. */
1223 static struct value
*
1224 eval_op_var_msym_value (struct type
*expect_type
, struct expression
*exp
,
1225 enum noside noside
, bool outermost_p
,
1226 minimal_symbol
*msymbol
, struct objfile
*objfile
)
1228 value
*val
= evaluate_var_msym_value (noside
, objfile
, msymbol
);
1230 struct type
*type
= value_type (val
);
1231 if (type
->code () == TYPE_CODE_ERROR
1232 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| !outermost_p
))
1233 error_unknown_type (msymbol
->print_name ());
1238 evaluate_subexp_standard (struct type
*expect_type
,
1239 struct expression
*exp
, int *pos
,
1243 int tem
, tem2
, tem3
;
1245 struct value
*arg1
= NULL
;
1246 struct value
*arg2
= NULL
;
1250 struct value
**argvec
;
1253 struct type
**arg_types
;
1256 op
= exp
->elts
[pc
].opcode
;
1261 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1262 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1263 return eval_op_scope (expect_type
, exp
, noside
,
1264 exp
->elts
[pc
+ 1].type
,
1265 &exp
->elts
[pc
+ 3].string
);
1269 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1270 exp
->elts
[pc
+ 2].longconst
);
1274 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1275 exp
->elts
[pc
+ 2].floatconst
);
1281 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1282 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
1283 error_unknown_type (var
->print_name ());
1284 if (noside
!= EVAL_SKIP
)
1285 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1288 /* Return a dummy value of the correct type when skipping, so
1289 that parent functions know what is to be skipped. */
1290 return allocate_value (SYMBOL_TYPE (var
));
1294 case OP_VAR_MSYM_VALUE
:
1298 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1299 return eval_op_var_msym_value (expect_type
, exp
, noside
,
1301 exp
->elts
[pc
+ 1].objfile
);
1304 case OP_VAR_ENTRY_VALUE
:
1308 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1310 return eval_op_var_entry_value (expect_type
, exp
, noside
, sym
);
1313 case OP_FUNC_STATIC_VAR
:
1314 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1315 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1316 if (noside
== EVAL_SKIP
)
1317 return eval_skip_value (exp
);
1320 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1321 CORE_ADDR addr
= value_address (func
);
1323 const block
*blk
= block_for_pc (addr
);
1324 const char *var
= &exp
->elts
[pc
+ 2].string
;
1326 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1328 if (sym
.symbol
== NULL
)
1329 error (_("No symbol \"%s\" in specified context."), var
);
1331 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1337 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1341 const char *name
= &exp
->elts
[pc
+ 2].string
;
1345 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1346 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1347 name
, strlen (name
));
1349 error (_("Register $%s not available."), name
);
1351 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1352 a value with the appropriate register type. Unfortunately,
1353 we don't have easy access to the type of user registers.
1354 So for these registers, we fetch the register value regardless
1355 of the evaluation mode. */
1356 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1357 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1358 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1360 val
= value_of_register (regno
, get_selected_frame (NULL
));
1362 error (_("Value of register %s not available."), name
);
1368 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1369 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1371 case OP_INTERNALVAR
:
1373 return value_of_internalvar (exp
->gdbarch
,
1374 exp
->elts
[pc
+ 1].internalvar
);
1377 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1378 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1379 if (noside
== EVAL_SKIP
)
1380 return eval_skip_value (exp
);
1381 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1382 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1384 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1385 NSString constant. */
1386 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1387 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1388 if (noside
== EVAL_SKIP
)
1389 return eval_skip_value (exp
);
1390 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1394 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1395 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1396 nargs
= tem3
- tem2
+ 1;
1397 type
= expect_type
? check_typedef (expect_type
) : nullptr;
1399 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1400 && type
->code () == TYPE_CODE_STRUCT
)
1402 struct value
*rec
= allocate_value (expect_type
);
1404 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1405 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1408 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1409 && type
->code () == TYPE_CODE_ARRAY
)
1411 struct type
*range_type
= type
->index_type ();
1412 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1413 struct value
*array
= allocate_value (expect_type
);
1414 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1415 LONGEST low_bound
, high_bound
, index
;
1417 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
1420 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1423 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1424 for (tem
= nargs
; --nargs
>= 0;)
1426 struct value
*element
;
1428 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1429 if (value_type (element
) != element_type
)
1430 element
= value_cast (element_type
, element
);
1431 if (index
> high_bound
)
1432 /* To avoid memory corruption. */
1433 error (_("Too many array elements"));
1434 memcpy (value_contents_raw (array
)
1435 + (index
- low_bound
) * element_size
,
1436 value_contents (element
),
1443 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1444 && type
->code () == TYPE_CODE_SET
)
1446 struct value
*set
= allocate_value (expect_type
);
1447 gdb_byte
*valaddr
= value_contents_raw (set
);
1448 struct type
*element_type
= type
->index_type ();
1449 struct type
*check_type
= element_type
;
1450 LONGEST low_bound
, high_bound
;
1452 /* Get targettype of elementtype. */
1453 while (check_type
->code () == TYPE_CODE_RANGE
1454 || check_type
->code () == TYPE_CODE_TYPEDEF
)
1455 check_type
= TYPE_TARGET_TYPE (check_type
);
1457 if (!get_discrete_bounds (element_type
, &low_bound
, &high_bound
))
1458 error (_("(power)set type with unknown size"));
1459 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1460 for (tem
= 0; tem
< nargs
; tem
++)
1462 LONGEST range_low
, range_high
;
1463 struct type
*range_low_type
, *range_high_type
;
1464 struct value
*elem_val
;
1466 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1467 range_low_type
= range_high_type
= value_type (elem_val
);
1468 range_low
= range_high
= value_as_long (elem_val
);
1470 /* Check types of elements to avoid mixture of elements from
1471 different types. Also check if type of element is "compatible"
1472 with element type of powerset. */
1473 if (range_low_type
->code () == TYPE_CODE_RANGE
)
1474 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1475 if (range_high_type
->code () == TYPE_CODE_RANGE
)
1476 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1477 if ((range_low_type
->code () != range_high_type
->code ())
1478 || (range_low_type
->code () == TYPE_CODE_ENUM
1479 && (range_low_type
!= range_high_type
)))
1480 /* different element modes. */
1481 error (_("POWERSET tuple elements of different mode"));
1482 if ((check_type
->code () != range_low_type
->code ())
1483 || (check_type
->code () == TYPE_CODE_ENUM
1484 && range_low_type
!= check_type
))
1485 error (_("incompatible POWERSET tuple elements"));
1486 if (range_low
> range_high
)
1488 warning (_("empty POWERSET tuple range"));
1491 if (range_low
< low_bound
|| range_high
> high_bound
)
1492 error (_("POWERSET tuple element out of range"));
1493 range_low
-= low_bound
;
1494 range_high
-= low_bound
;
1495 for (; range_low
<= range_high
; range_low
++)
1497 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1499 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1500 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1501 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1508 argvec
= XALLOCAVEC (struct value
*, nargs
);
1509 for (tem
= 0; tem
< nargs
; tem
++)
1511 /* Ensure that array expressions are coerced into pointer
1513 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1515 if (noside
== EVAL_SKIP
)
1516 return eval_skip_value (exp
);
1517 return value_array (tem2
, tem3
, argvec
);
1521 struct value
*array
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1523 = value_as_long (evaluate_subexp (nullptr, exp
, pos
, noside
));
1524 int upper
= value_as_long (evaluate_subexp (nullptr, exp
, pos
, noside
));
1526 if (noside
== EVAL_SKIP
)
1527 return eval_skip_value (exp
);
1528 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1532 /* Skip third and second args to evaluate the first one. */
1533 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1534 if (value_logical_not (arg1
))
1536 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
1537 return evaluate_subexp (nullptr, exp
, pos
, noside
);
1541 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1542 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
1546 case OP_OBJC_SELECTOR
:
1547 { /* Objective C @selector operator. */
1548 char *sel
= &exp
->elts
[pc
+ 2].string
;
1549 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1550 struct type
*selector_type
;
1552 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1553 if (noside
== EVAL_SKIP
)
1554 return eval_skip_value (exp
);
1557 sel
[len
] = 0; /* Make sure it's terminated. */
1559 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1560 return value_from_longest (selector_type
,
1561 lookup_child_selector (exp
->gdbarch
, sel
));
1564 case OP_OBJC_MSGCALL
:
1565 { /* Objective C message (method) call. */
1567 CORE_ADDR responds_selector
= 0;
1568 CORE_ADDR method_selector
= 0;
1570 CORE_ADDR selector
= 0;
1572 int struct_return
= 0;
1573 enum noside sub_no_side
= EVAL_NORMAL
;
1575 struct value
*msg_send
= NULL
;
1576 struct value
*msg_send_stret
= NULL
;
1577 int gnu_runtime
= 0;
1579 struct value
*target
= NULL
;
1580 struct value
*method
= NULL
;
1581 struct value
*called_method
= NULL
;
1583 struct type
*selector_type
= NULL
;
1584 struct type
*long_type
;
1586 struct value
*ret
= NULL
;
1589 selector
= exp
->elts
[pc
+ 1].longconst
;
1590 nargs
= exp
->elts
[pc
+ 2].longconst
;
1591 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1595 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1596 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1598 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1599 sub_no_side
= EVAL_NORMAL
;
1601 sub_no_side
= noside
;
1603 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1605 if (value_as_long (target
) == 0)
1606 return value_from_longest (long_type
, 0);
1608 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1611 /* Find the method dispatch (Apple runtime) or method lookup
1612 (GNU runtime) function for Objective-C. These will be used
1613 to lookup the symbol information for the method. If we
1614 can't find any symbol information, then we'll use these to
1615 call the method, otherwise we can call the method
1616 directly. The msg_send_stret function is used in the special
1617 case of a method that returns a structure (Apple runtime
1621 type
= selector_type
;
1623 type
= lookup_function_type (type
);
1624 type
= lookup_pointer_type (type
);
1625 type
= lookup_function_type (type
);
1626 type
= lookup_pointer_type (type
);
1628 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1630 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1632 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1633 msg_send_stret
= value_from_pointer (type
,
1634 value_as_address (msg_send_stret
));
1638 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1639 /* Special dispatcher for methods returning structs. */
1641 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1644 /* Verify the target object responds to this method. The
1645 standard top-level 'Object' class uses a different name for
1646 the verification method than the non-standard, but more
1647 often used, 'NSObject' class. Make sure we check for both. */
1650 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1651 if (responds_selector
== 0)
1653 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1655 if (responds_selector
== 0)
1656 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1659 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1660 if (method_selector
== 0)
1662 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1664 if (method_selector
== 0)
1665 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1667 /* Call the verification method, to make sure that the target
1668 class implements the desired method. */
1670 argvec
[0] = msg_send
;
1672 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1673 argvec
[3] = value_from_longest (long_type
, selector
);
1676 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1679 /* Function objc_msg_lookup returns a pointer. */
1681 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1683 if (value_as_long (ret
) == 0)
1684 error (_("Target does not respond to this message selector."));
1686 /* Call "methodForSelector:" method, to get the address of a
1687 function method that implements this selector for this
1688 class. If we can find a symbol at that address, then we
1689 know the return type, parameter types etc. (that's a good
1692 argvec
[0] = msg_send
;
1694 argvec
[2] = value_from_longest (long_type
, method_selector
);
1695 argvec
[3] = value_from_longest (long_type
, selector
);
1698 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1702 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1705 /* ret should now be the selector. */
1707 addr
= value_as_long (ret
);
1710 struct symbol
*sym
= NULL
;
1712 /* The address might point to a function descriptor;
1713 resolve it to the actual code address instead. */
1714 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1715 current_top_target ());
1717 /* Is it a high_level symbol? */
1718 sym
= find_pc_function (addr
);
1720 method
= value_of_variable (sym
, 0);
1723 /* If we found a method with symbol information, check to see
1724 if it returns a struct. Otherwise assume it doesn't. */
1729 struct type
*val_type
;
1731 funaddr
= find_function_addr (method
, &val_type
);
1733 block_for_pc (funaddr
);
1735 val_type
= check_typedef (val_type
);
1737 if ((val_type
== NULL
)
1738 || (val_type
->code () == TYPE_CODE_ERROR
))
1740 if (expect_type
!= NULL
)
1741 val_type
= expect_type
;
1744 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1747 else if (expect_type
!= NULL
)
1749 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1750 check_typedef (expect_type
));
1753 /* Found a function symbol. Now we will substitute its
1754 value in place of the message dispatcher (obj_msgSend),
1755 so that we call the method directly instead of thru
1756 the dispatcher. The main reason for doing this is that
1757 we can now evaluate the return value and parameter values
1758 according to their known data types, in case we need to
1759 do things like promotion, dereferencing, special handling
1760 of structs and doubles, etc.
1762 We want to use the type signature of 'method', but still
1763 jump to objc_msgSend() or objc_msgSend_stret() to better
1764 mimic the behavior of the runtime. */
1768 if (value_type (method
)->code () != TYPE_CODE_FUNC
)
1769 error (_("method address has symbol information "
1770 "with non-function type; skipping"));
1772 /* Create a function pointer of the appropriate type, and
1773 replace its value with the value of msg_send or
1774 msg_send_stret. We must use a pointer here, as
1775 msg_send and msg_send_stret are of pointer type, and
1776 the representation may be different on systems that use
1777 function descriptors. */
1780 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1781 value_as_address (msg_send_stret
));
1784 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1785 value_as_address (msg_send
));
1790 called_method
= msg_send_stret
;
1792 called_method
= msg_send
;
1795 if (noside
== EVAL_SKIP
)
1796 return eval_skip_value (exp
);
1798 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1800 /* If the return type doesn't look like a function type,
1801 call an error. This can happen if somebody tries to
1802 turn a variable into a function call. This is here
1803 because people often want to call, eg, strcmp, which
1804 gdb doesn't know is a function. If gdb isn't asked for
1805 it's opinion (ie. through "whatis"), it won't offer
1808 struct type
*callee_type
= value_type (called_method
);
1810 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
1811 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1812 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1816 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
1817 return allocate_value (expect_type
);
1819 return allocate_value (callee_type
);
1822 error (_("Expression of type other than "
1823 "\"method returning ...\" used as a method"));
1826 /* Now depending on whether we found a symbol for the method,
1827 we will either call the runtime dispatcher or the method
1830 argvec
[0] = called_method
;
1832 argvec
[2] = value_from_longest (long_type
, selector
);
1833 /* User-supplied arguments. */
1834 for (tem
= 0; tem
< nargs
; tem
++)
1835 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1836 argvec
[tem
+ 3] = 0;
1838 auto call_args
= gdb::make_array_view (argvec
+ 1, nargs
+ 2);
1840 if (gnu_runtime
&& (method
!= NULL
))
1842 /* Function objc_msg_lookup returns a pointer. */
1843 deprecated_set_value_type (argvec
[0],
1844 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1845 argvec
[0] = call_function_by_hand (argvec
[0], NULL
, call_args
);
1848 return call_function_by_hand (argvec
[0], NULL
, call_args
);
1853 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1856 /* We have a complex number, There should be 2 floating
1857 point numbers that compose it. */
1859 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1860 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1862 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1864 case STRUCTOP_STRUCT
:
1865 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1866 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1867 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1868 if (noside
== EVAL_SKIP
)
1869 return eval_skip_value (exp
);
1870 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1872 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1873 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1877 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1878 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1879 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1880 if (noside
== EVAL_SKIP
)
1881 return eval_skip_value (exp
);
1883 /* Check to see if operator '->' has been overloaded. If so replace
1884 arg1 with the value returned by evaluating operator->(). */
1885 while (unop_user_defined_p (op
, arg1
))
1887 struct value
*value
= NULL
;
1890 value
= value_x_unop (arg1
, op
, noside
);
1893 catch (const gdb_exception_error
&except
)
1895 if (except
.error
== NOT_FOUND_ERROR
)
1904 /* JYG: if print object is on we need to replace the base type
1905 with rtti type in order to continue on with successful
1906 lookup of member / method only available in the rtti type. */
1908 struct type
*arg_type
= value_type (arg1
);
1909 struct type
*real_type
;
1910 int full
, using_enc
;
1912 struct value_print_options opts
;
1914 get_user_print_options (&opts
);
1915 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
1916 && (TYPE_TARGET_TYPE (arg_type
)->code () == TYPE_CODE_STRUCT
))
1918 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1921 arg1
= value_cast (real_type
, arg1
);
1925 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1926 NULL
, "structure pointer");
1927 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1928 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1931 case STRUCTOP_MEMBER
:
1933 if (op
== STRUCTOP_MEMBER
)
1934 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1936 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1938 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1940 if (noside
== EVAL_SKIP
)
1941 return eval_skip_value (exp
);
1943 type
= check_typedef (value_type (arg2
));
1944 switch (type
->code ())
1946 case TYPE_CODE_METHODPTR
:
1947 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1948 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1951 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1952 gdb_assert (value_type (arg2
)->code () == TYPE_CODE_PTR
);
1953 return value_ind (arg2
);
1956 case TYPE_CODE_MEMBERPTR
:
1957 /* Now, convert these values to an address. */
1958 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1961 mem_offset
= value_as_long (arg2
);
1963 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1964 value_as_long (arg1
) + mem_offset
);
1965 return value_ind (arg3
);
1968 error (_("non-pointer-to-member value used "
1969 "in pointer-to-member construct"));
1974 type_instance_flags flags
1975 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1976 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1977 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1978 for (ix
= 0; ix
< nargs
; ++ix
)
1979 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
1981 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
1982 *(pos
) += 4 + nargs
;
1983 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
1988 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1989 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1990 if (noside
== EVAL_SKIP
)
1991 return eval_skip_value (exp
);
1992 if (binop_user_defined_p (op
, arg1
, arg2
))
1993 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1995 return value_concat (arg1
, arg2
);
1998 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1999 /* Special-case assignments where the left-hand-side is a
2000 convenience variable -- in these, don't bother setting an
2001 expected type. This avoids a weird case where re-assigning a
2002 string or array to an internal variable could error with "Too
2003 many array elements". */
2004 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
2006 : value_type (arg1
),
2009 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2011 if (binop_user_defined_p (op
, arg1
, arg2
))
2012 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2014 return value_assign (arg1
, arg2
);
2016 case BINOP_ASSIGN_MODIFY
:
2018 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2019 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2020 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2022 op
= exp
->elts
[pc
+ 1].opcode
;
2023 if (binop_user_defined_p (op
, arg1
, arg2
))
2024 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2025 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2027 && is_integral_type (value_type (arg2
)))
2028 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2029 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2031 && is_integral_type (value_type (arg2
)))
2032 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2035 struct value
*tmp
= arg1
;
2037 /* For shift and integer exponentiation operations,
2038 only promote the first argument. */
2039 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2040 && is_integral_type (value_type (arg2
)))
2041 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2043 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2045 arg2
= value_binop (tmp
, arg2
, op
);
2047 return value_assign (arg1
, arg2
);
2050 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2051 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2052 if (noside
== EVAL_SKIP
)
2053 return eval_skip_value (exp
);
2054 if (binop_user_defined_p (op
, arg1
, arg2
))
2055 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2056 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2057 && is_integral_or_integral_reference (value_type (arg2
)))
2058 return value_ptradd (arg1
, value_as_long (arg2
));
2059 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2060 && is_integral_or_integral_reference (value_type (arg1
)))
2061 return value_ptradd (arg2
, value_as_long (arg1
));
2064 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2065 return value_binop (arg1
, arg2
, BINOP_ADD
);
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 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2078 /* FIXME -- should be ptrdiff_t */
2079 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2080 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2082 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2083 && is_integral_or_integral_reference (value_type (arg2
)))
2084 return value_ptradd (arg1
, - value_as_long (arg2
));
2087 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2088 return value_binop (arg1
, arg2
, BINOP_SUB
);
2099 case BINOP_BITWISE_AND
:
2100 case BINOP_BITWISE_IOR
:
2101 case BINOP_BITWISE_XOR
:
2102 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2103 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2104 if (noside
== EVAL_SKIP
)
2105 return eval_skip_value (exp
);
2106 if (binop_user_defined_p (op
, arg1
, arg2
))
2107 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2110 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2111 fudge arg2 to avoid division-by-zero, the caller is
2112 (theoretically) only looking for the type of the result. */
2113 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2114 /* ??? Do we really want to test for BINOP_MOD here?
2115 The implementation of value_binop gives it a well-defined
2118 || op
== BINOP_INTDIV
2121 && value_logical_not (arg2
))
2123 struct value
*v_one
;
2125 v_one
= value_one (value_type (arg2
));
2126 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2127 return value_binop (arg1
, v_one
, op
);
2131 /* For shift and integer exponentiation operations,
2132 only promote the first argument. */
2133 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2134 && is_integral_type (value_type (arg2
)))
2135 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2137 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2139 return value_binop (arg1
, arg2
, op
);
2143 case BINOP_SUBSCRIPT
:
2144 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2145 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2146 if (noside
== EVAL_SKIP
)
2147 return eval_skip_value (exp
);
2148 if (binop_user_defined_p (op
, arg1
, arg2
))
2149 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2152 /* If the user attempts to subscript something that is not an
2153 array or pointer type (like a plain int variable for example),
2154 then report this as an error. */
2156 arg1
= coerce_ref (arg1
);
2157 type
= check_typedef (value_type (arg1
));
2158 if (type
->code () != TYPE_CODE_ARRAY
2159 && type
->code () != TYPE_CODE_PTR
)
2162 error (_("cannot subscript something of type `%s'"),
2165 error (_("cannot subscript requested type"));
2168 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2169 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2171 return value_subscript (arg1
, value_as_long (arg2
));
2173 case MULTI_SUBSCRIPT
:
2175 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2176 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2177 argvec
= XALLOCAVEC (struct value
*, nargs
);
2178 for (ix
= 0; ix
< nargs
; ++ix
)
2179 argvec
[ix
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
2180 if (noside
== EVAL_SKIP
)
2182 for (ix
= 0; ix
< nargs
; ++ix
)
2186 if (binop_user_defined_p (op
, arg1
, arg2
))
2188 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2192 arg1
= coerce_ref (arg1
);
2193 type
= check_typedef (value_type (arg1
));
2195 switch (type
->code ())
2198 case TYPE_CODE_ARRAY
:
2199 case TYPE_CODE_STRING
:
2200 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2205 error (_("cannot subscript something of type `%s'"),
2208 error (_("cannot subscript requested type"));
2214 case BINOP_LOGICAL_AND
:
2215 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2216 if (noside
== EVAL_SKIP
)
2218 evaluate_subexp (nullptr, exp
, pos
, noside
);
2219 return eval_skip_value (exp
);
2223 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2226 if (binop_user_defined_p (op
, arg1
, arg2
))
2228 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2229 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2233 tem
= value_logical_not (arg1
);
2235 = evaluate_subexp (nullptr, exp
, pos
, (tem
? EVAL_SKIP
: noside
));
2236 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2237 return value_from_longest (type
,
2238 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2241 case BINOP_LOGICAL_OR
:
2242 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2243 if (noside
== EVAL_SKIP
)
2245 evaluate_subexp (nullptr, exp
, pos
, noside
);
2246 return eval_skip_value (exp
);
2250 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2253 if (binop_user_defined_p (op
, arg1
, arg2
))
2255 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2256 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2260 tem
= value_logical_not (arg1
);
2262 = evaluate_subexp (nullptr, exp
, pos
, (!tem
? EVAL_SKIP
: noside
));
2263 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2264 return value_from_longest (type
,
2265 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2269 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2270 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2271 if (noside
== EVAL_SKIP
)
2272 return eval_skip_value (exp
);
2273 if (binop_user_defined_p (op
, arg1
, arg2
))
2275 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2279 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2280 tem
= value_equal (arg1
, arg2
);
2281 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2282 return value_from_longest (type
, (LONGEST
) tem
);
2285 case BINOP_NOTEQUAL
:
2286 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2287 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2288 if (noside
== EVAL_SKIP
)
2289 return eval_skip_value (exp
);
2290 if (binop_user_defined_p (op
, arg1
, arg2
))
2292 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2296 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2297 tem
= value_equal (arg1
, arg2
);
2298 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2299 return value_from_longest (type
, (LONGEST
) ! tem
);
2303 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2304 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2305 if (noside
== EVAL_SKIP
)
2306 return eval_skip_value (exp
);
2307 if (binop_user_defined_p (op
, arg1
, arg2
))
2309 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2313 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2314 tem
= value_less (arg1
, arg2
);
2315 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2316 return value_from_longest (type
, (LONGEST
) tem
);
2320 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2321 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2322 if (noside
== EVAL_SKIP
)
2323 return eval_skip_value (exp
);
2324 if (binop_user_defined_p (op
, arg1
, arg2
))
2326 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2330 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2331 tem
= value_less (arg2
, arg1
);
2332 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2333 return value_from_longest (type
, (LONGEST
) tem
);
2337 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2338 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2339 if (noside
== EVAL_SKIP
)
2340 return eval_skip_value (exp
);
2341 if (binop_user_defined_p (op
, arg1
, arg2
))
2343 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2347 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2348 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2349 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2350 return value_from_longest (type
, (LONGEST
) tem
);
2354 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2355 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2356 if (noside
== EVAL_SKIP
)
2357 return eval_skip_value (exp
);
2358 if (binop_user_defined_p (op
, arg1
, arg2
))
2360 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2364 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2365 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2366 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2367 return value_from_longest (type
, (LONGEST
) tem
);
2371 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2372 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2373 if (noside
== EVAL_SKIP
)
2374 return eval_skip_value (exp
);
2375 type
= check_typedef (value_type (arg2
));
2376 if (type
->code () != TYPE_CODE_INT
2377 && type
->code () != TYPE_CODE_ENUM
)
2378 error (_("Non-integral right operand for \"@\" operator."));
2379 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2381 return allocate_repeat_value (value_type (arg1
),
2382 longest_to_int (value_as_long (arg2
)));
2385 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2388 evaluate_subexp (nullptr, exp
, pos
, noside
);
2389 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2392 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2393 if (noside
== EVAL_SKIP
)
2394 return eval_skip_value (exp
);
2395 if (unop_user_defined_p (op
, arg1
))
2396 return value_x_unop (arg1
, op
, noside
);
2399 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2400 return value_pos (arg1
);
2404 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2405 if (noside
== EVAL_SKIP
)
2406 return eval_skip_value (exp
);
2407 if (unop_user_defined_p (op
, arg1
))
2408 return value_x_unop (arg1
, op
, noside
);
2411 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2412 return value_neg (arg1
);
2415 case UNOP_COMPLEMENT
:
2416 /* C++: check for and handle destructor names. */
2418 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2419 if (noside
== EVAL_SKIP
)
2420 return eval_skip_value (exp
);
2421 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2422 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2425 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2426 return value_complement (arg1
);
2429 case UNOP_LOGICAL_NOT
:
2430 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2431 if (noside
== EVAL_SKIP
)
2432 return eval_skip_value (exp
);
2433 if (unop_user_defined_p (op
, arg1
))
2434 return value_x_unop (arg1
, op
, noside
);
2437 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2438 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2442 if (expect_type
&& expect_type
->code () == TYPE_CODE_PTR
)
2443 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2444 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2445 type
= check_typedef (value_type (arg1
));
2446 if (type
->code () == TYPE_CODE_METHODPTR
2447 || type
->code () == TYPE_CODE_MEMBERPTR
)
2448 error (_("Attempt to dereference pointer "
2449 "to member without an object"));
2450 if (noside
== EVAL_SKIP
)
2451 return eval_skip_value (exp
);
2452 if (unop_user_defined_p (op
, arg1
))
2453 return value_x_unop (arg1
, op
, noside
);
2454 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2456 type
= check_typedef (value_type (arg1
));
2458 /* If the type pointed to is dynamic then in order to resolve the
2459 dynamic properties we must actually dereference the pointer.
2460 There is a risk that this dereference will have side-effects
2461 in the inferior, but being able to print accurate type
2462 information seems worth the risk. */
2463 if ((type
->code () != TYPE_CODE_PTR
2464 && !TYPE_IS_REFERENCE (type
))
2465 || !is_dynamic_type (TYPE_TARGET_TYPE (type
)))
2467 if (type
->code () == TYPE_CODE_PTR
2468 || TYPE_IS_REFERENCE (type
)
2469 /* In C you can dereference an array to get the 1st elt. */
2470 || type
->code () == TYPE_CODE_ARRAY
)
2471 return value_zero (TYPE_TARGET_TYPE (type
),
2473 else if (type
->code () == TYPE_CODE_INT
)
2474 /* GDB allows dereferencing an int. */
2475 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2478 error (_("Attempt to take contents of a non-pointer value."));
2482 /* Allow * on an integer so we can cast it to whatever we want.
2483 This returns an int, which seems like the most C-like thing to
2484 do. "long long" variables are rare enough that
2485 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2486 if (type
->code () == TYPE_CODE_INT
)
2487 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2488 (CORE_ADDR
) value_as_address (arg1
));
2489 return value_ind (arg1
);
2492 /* C++: check for and handle pointer to members. */
2494 if (noside
== EVAL_SKIP
)
2496 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2497 return eval_skip_value (exp
);
2500 return evaluate_subexp_for_address (exp
, pos
, noside
);
2503 if (noside
== EVAL_SKIP
)
2505 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2506 return eval_skip_value (exp
);
2508 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2513 evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
));
2514 /* FIXME: This should be size_t. */
2515 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2516 ULONGEST align
= type_align (type
);
2518 error (_("could not determine alignment of type"));
2519 return value_from_longest (size_type
, align
);
2524 type
= exp
->elts
[pc
+ 1].type
;
2525 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2527 case UNOP_CAST_TYPE
:
2528 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2529 type
= value_type (arg1
);
2530 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2532 case UNOP_DYNAMIC_CAST
:
2533 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2534 type
= value_type (arg1
);
2535 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2536 if (noside
== EVAL_SKIP
)
2537 return eval_skip_value (exp
);
2538 return value_dynamic_cast (type
, arg1
);
2540 case UNOP_REINTERPRET_CAST
:
2541 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2542 type
= value_type (arg1
);
2543 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2544 if (noside
== EVAL_SKIP
)
2545 return eval_skip_value (exp
);
2546 return value_reinterpret_cast (type
, arg1
);
2550 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2551 if (noside
== EVAL_SKIP
)
2552 return eval_skip_value (exp
);
2553 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2554 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2556 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2557 value_as_address (arg1
));
2559 case UNOP_MEMVAL_TYPE
:
2560 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2561 type
= value_type (arg1
);
2562 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2563 if (noside
== EVAL_SKIP
)
2564 return eval_skip_value (exp
);
2565 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2566 return value_zero (type
, lval_memory
);
2568 return value_at_lazy (type
, value_as_address (arg1
));
2570 case UNOP_PREINCREMENT
:
2571 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2572 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2574 else if (unop_user_defined_p (op
, arg1
))
2576 return value_x_unop (arg1
, op
, noside
);
2580 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2581 arg2
= value_ptradd (arg1
, 1);
2584 struct value
*tmp
= arg1
;
2586 arg2
= value_one (value_type (arg1
));
2587 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2588 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2591 return value_assign (arg1
, arg2
);
2594 case UNOP_PREDECREMENT
:
2595 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2596 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2598 else if (unop_user_defined_p (op
, arg1
))
2600 return value_x_unop (arg1
, op
, noside
);
2604 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2605 arg2
= value_ptradd (arg1
, -1);
2608 struct value
*tmp
= arg1
;
2610 arg2
= value_one (value_type (arg1
));
2611 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2612 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2615 return value_assign (arg1
, arg2
);
2618 case UNOP_POSTINCREMENT
:
2619 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2620 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2622 else if (unop_user_defined_p (op
, arg1
))
2624 return value_x_unop (arg1
, op
, noside
);
2628 arg3
= value_non_lval (arg1
);
2630 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2631 arg2
= value_ptradd (arg1
, 1);
2634 struct value
*tmp
= arg1
;
2636 arg2
= value_one (value_type (arg1
));
2637 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2638 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2641 value_assign (arg1
, arg2
);
2645 case UNOP_POSTDECREMENT
:
2646 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2647 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2649 else if (unop_user_defined_p (op
, arg1
))
2651 return value_x_unop (arg1
, op
, noside
);
2655 arg3
= value_non_lval (arg1
);
2657 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2658 arg2
= value_ptradd (arg1
, -1);
2661 struct value
*tmp
= arg1
;
2663 arg2
= value_one (value_type (arg1
));
2664 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2665 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2668 value_assign (arg1
, arg2
);
2674 return value_of_this (exp
->language_defn
);
2677 /* The value is not supposed to be used. This is here to make it
2678 easier to accommodate expressions that contain types. */
2680 if (noside
== EVAL_SKIP
)
2681 return eval_skip_value (exp
);
2682 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2683 return allocate_value (exp
->elts
[pc
+ 1].type
);
2685 error (_("Attempt to use a type name as an expression"));
2689 if (noside
== EVAL_SKIP
)
2691 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2692 return eval_skip_value (exp
);
2694 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2696 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2697 struct value
*result
;
2699 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2701 /* 'decltype' has special semantics for lvalues. */
2702 if (op
== OP_DECLTYPE
2703 && (sub_op
== BINOP_SUBSCRIPT
2704 || sub_op
== STRUCTOP_MEMBER
2705 || sub_op
== STRUCTOP_MPTR
2706 || sub_op
== UNOP_IND
2707 || sub_op
== STRUCTOP_STRUCT
2708 || sub_op
== STRUCTOP_PTR
2709 || sub_op
== OP_SCOPE
))
2711 type
= value_type (result
);
2713 if (!TYPE_IS_REFERENCE (type
))
2715 type
= lookup_lvalue_reference_type (type
);
2716 result
= allocate_value (type
);
2723 error (_("Attempt to use a type as an expression"));
2727 struct value
*result
;
2728 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2730 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2731 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2733 result
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2735 if (noside
!= EVAL_NORMAL
)
2736 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2738 return cplus_typeid (result
);
2742 /* Removing this case and compiling with gcc -Wall reveals that
2743 a lot of cases are hitting this case. Some of these should
2744 probably be removed from expression.h; others are legitimate
2745 expressions which are (apparently) not fully implemented.
2747 If there are any cases landing here which mean a user error,
2748 then they should be separate cases, with more descriptive
2751 error (_("GDB does not (yet) know how to "
2752 "evaluate that kind of expression"));
2755 gdb_assert_not_reached ("missed return?");
2758 /* Evaluate a subexpression of EXP, at index *POS,
2759 and return the address of that subexpression.
2760 Advance *POS over the subexpression.
2761 If the subexpression isn't an lvalue, get an error.
2762 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2763 then only the type of the result need be correct. */
2765 static struct value
*
2766 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2776 op
= exp
->elts
[pc
].opcode
;
2782 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2784 /* We can't optimize out "&*" if there's a user-defined operator*. */
2785 if (unop_user_defined_p (op
, x
))
2787 x
= value_x_unop (x
, op
, noside
);
2788 goto default_case_after_eval
;
2791 return coerce_array (x
);
2795 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2796 evaluate_subexp (nullptr, exp
, pos
, noside
));
2798 case UNOP_MEMVAL_TYPE
:
2803 x
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2804 type
= value_type (x
);
2805 return value_cast (lookup_pointer_type (type
),
2806 evaluate_subexp (nullptr, exp
, pos
, noside
));
2810 var
= exp
->elts
[pc
+ 2].symbol
;
2812 /* C++: The "address" of a reference should yield the address
2813 * of the object pointed to. Let value_addr() deal with it. */
2814 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
2818 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2821 lookup_pointer_type (SYMBOL_TYPE (var
));
2822 enum address_class sym_class
= SYMBOL_CLASS (var
);
2824 if (sym_class
== LOC_CONST
2825 || sym_class
== LOC_CONST_BYTES
2826 || sym_class
== LOC_REGISTER
)
2827 error (_("Attempt to take address of register or constant."));
2830 value_zero (type
, not_lval
);
2833 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2835 case OP_VAR_MSYM_VALUE
:
2839 value
*val
= evaluate_var_msym_value (noside
,
2840 exp
->elts
[pc
+ 1].objfile
,
2841 exp
->elts
[pc
+ 2].msymbol
);
2842 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2844 struct type
*type
= lookup_pointer_type (value_type (val
));
2845 return value_zero (type
, not_lval
);
2848 return value_addr (val
);
2852 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2853 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2854 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2855 &exp
->elts
[pc
+ 3].string
,
2858 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2863 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2864 default_case_after_eval
:
2865 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2867 struct type
*type
= check_typedef (value_type (x
));
2869 if (TYPE_IS_REFERENCE (type
))
2870 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2872 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2873 return value_zero (lookup_pointer_type (value_type (x
)),
2876 error (_("Attempt to take address of "
2877 "value not located in memory."));
2879 return value_addr (x
);
2883 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2884 When used in contexts where arrays will be coerced anyway, this is
2885 equivalent to `evaluate_subexp' but much faster because it avoids
2886 actually fetching array contents (perhaps obsolete now that we have
2889 Note that we currently only do the coercion for C expressions, where
2890 arrays are zero based and the coercion is correct. For other languages,
2891 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2892 to decide if coercion is appropriate. */
2895 evaluate_subexp_with_coercion (struct expression
*exp
,
2896 int *pos
, enum noside noside
)
2905 op
= exp
->elts
[pc
].opcode
;
2910 var
= exp
->elts
[pc
+ 2].symbol
;
2911 type
= check_typedef (SYMBOL_TYPE (var
));
2912 if (type
->code () == TYPE_CODE_ARRAY
2913 && !type
->is_vector ()
2914 && CAST_IS_CONVERSION (exp
->language_defn
))
2917 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2918 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2924 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2928 /* Evaluate a subexpression of EXP, at index *POS,
2929 and return a value for the size of that subexpression.
2930 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2931 we allow side-effects on the operand if its type is a variable
2934 static struct value
*
2935 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
2938 /* FIXME: This should be size_t. */
2939 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2946 op
= exp
->elts
[pc
].opcode
;
2950 /* This case is handled specially
2951 so that we avoid creating a value for the result type.
2952 If the result type is very big, it's desirable not to
2953 create a value unnecessarily. */
2956 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2957 type
= check_typedef (value_type (val
));
2958 if (type
->code () != TYPE_CODE_PTR
2959 && !TYPE_IS_REFERENCE (type
)
2960 && type
->code () != TYPE_CODE_ARRAY
)
2961 error (_("Attempt to take contents of a non-pointer value."));
2962 type
= TYPE_TARGET_TYPE (type
);
2963 if (is_dynamic_type (type
))
2964 type
= value_type (value_ind (val
));
2965 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2969 type
= exp
->elts
[pc
+ 1].type
;
2972 case UNOP_MEMVAL_TYPE
:
2974 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2975 type
= value_type (val
);
2979 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
2980 if (is_dynamic_type (type
))
2982 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
2983 type
= value_type (val
);
2984 if (type
->code () == TYPE_CODE_ARRAY
)
2986 if (type_not_allocated (type
) || type_not_associated (type
))
2987 return value_zero (size_type
, not_lval
);
2988 else if (is_dynamic_type (type
->index_type ())
2989 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
2990 return allocate_optimized_out_value (size_type
);
2997 case OP_VAR_MSYM_VALUE
:
3001 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3002 value
*mval
= evaluate_var_msym_value (noside
,
3003 exp
->elts
[pc
+ 1].objfile
,
3006 type
= value_type (mval
);
3007 if (type
->code () == TYPE_CODE_ERROR
)
3008 error_unknown_type (msymbol
->print_name ());
3010 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3014 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3015 type of the subscript is a variable length array type. In this case we
3016 must re-evaluate the right hand side of the subscription to allow
3018 case BINOP_SUBSCRIPT
:
3019 if (noside
== EVAL_NORMAL
)
3021 int npc
= (*pos
) + 1;
3023 val
= evaluate_subexp (nullptr, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3024 type
= check_typedef (value_type (val
));
3025 if (type
->code () == TYPE_CODE_ARRAY
)
3027 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3028 if (type
->code () == TYPE_CODE_ARRAY
)
3030 type
= type
->index_type ();
3031 /* Only re-evaluate the right hand side if the resulting type
3032 is a variable length type. */
3033 if (type
->bounds ()->flag_bound_evaluated
)
3035 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3036 return value_from_longest
3037 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3046 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3047 type
= value_type (val
);
3051 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3052 "When applied to a reference or a reference type, the result is
3053 the size of the referenced type." */
3054 type
= check_typedef (type
);
3055 if (exp
->language_defn
->la_language
== language_cplus
3056 && (TYPE_IS_REFERENCE (type
)))
3057 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3058 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3061 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3062 for that subexpression cast to TO_TYPE. Advance *POS over the
3066 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3068 struct type
*to_type
)
3072 /* Don't let symbols be evaluated with evaluate_subexp because that
3073 throws an "unknown type" error for no-debug data symbols.
3074 Instead, we want the cast to reinterpret the symbol. */
3075 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3076 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3081 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3083 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3084 return value_zero (to_type
, not_lval
);
3086 val
= evaluate_var_msym_value (noside
,
3087 exp
->elts
[pc
+ 1].objfile
,
3088 exp
->elts
[pc
+ 2].msymbol
);
3091 val
= evaluate_var_value (noside
,
3092 exp
->elts
[pc
+ 1].block
,
3093 exp
->elts
[pc
+ 2].symbol
);
3095 if (noside
== EVAL_SKIP
)
3096 return eval_skip_value (exp
);
3098 val
= value_cast (to_type
, val
);
3100 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3101 if (VALUE_LVAL (val
) == lval_memory
)
3103 if (value_lazy (val
))
3104 value_fetch_lazy (val
);
3105 VALUE_LVAL (val
) = not_lval
;
3110 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3111 if (noside
== EVAL_SKIP
)
3112 return eval_skip_value (exp
);
3113 return value_cast (to_type
, val
);
3116 /* Parse a type expression in the string [P..P+LENGTH). */
3119 parse_and_eval_type (const char *p
, int length
)
3121 char *tmp
= (char *) alloca (length
+ 4);
3124 memcpy (tmp
+ 1, p
, length
);
3125 tmp
[length
+ 1] = ')';
3126 tmp
[length
+ 2] = '0';
3127 tmp
[length
+ 3] = '\0';
3128 expression_up expr
= parse_expression (tmp
);
3129 if (expr
->first_opcode () != UNOP_CAST
)
3130 error (_("Internal error in eval_type."));
3131 return expr
->elts
[1].type
;