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
);
1222 evaluate_subexp_standard (struct type
*expect_type
,
1223 struct expression
*exp
, int *pos
,
1227 int tem
, tem2
, tem3
;
1229 struct value
*arg1
= NULL
;
1230 struct value
*arg2
= NULL
;
1234 struct value
**argvec
;
1237 struct type
**arg_types
;
1240 op
= exp
->elts
[pc
].opcode
;
1245 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1246 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1247 return eval_op_scope (expect_type
, exp
, noside
,
1248 exp
->elts
[pc
+ 1].type
,
1249 &exp
->elts
[pc
+ 3].string
);
1253 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1254 exp
->elts
[pc
+ 2].longconst
);
1258 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1259 exp
->elts
[pc
+ 2].floatconst
);
1265 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1266 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
1267 error_unknown_type (var
->print_name ());
1268 if (noside
!= EVAL_SKIP
)
1269 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1272 /* Return a dummy value of the correct type when skipping, so
1273 that parent functions know what is to be skipped. */
1274 return allocate_value (SYMBOL_TYPE (var
));
1278 case OP_VAR_MSYM_VALUE
:
1282 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1283 value
*val
= evaluate_var_msym_value (noside
,
1284 exp
->elts
[pc
+ 1].objfile
,
1287 type
= value_type (val
);
1288 if (type
->code () == TYPE_CODE_ERROR
1289 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| pc
!= 0))
1290 error_unknown_type (msymbol
->print_name ());
1294 case OP_VAR_ENTRY_VALUE
:
1298 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1300 return eval_op_var_entry_value (expect_type
, exp
, noside
, sym
);
1303 case OP_FUNC_STATIC_VAR
:
1304 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1305 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1306 if (noside
== EVAL_SKIP
)
1307 return eval_skip_value (exp
);
1310 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1311 CORE_ADDR addr
= value_address (func
);
1313 const block
*blk
= block_for_pc (addr
);
1314 const char *var
= &exp
->elts
[pc
+ 2].string
;
1316 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1318 if (sym
.symbol
== NULL
)
1319 error (_("No symbol \"%s\" in specified context."), var
);
1321 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1327 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1331 const char *name
= &exp
->elts
[pc
+ 2].string
;
1335 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1336 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1337 name
, strlen (name
));
1339 error (_("Register $%s not available."), name
);
1341 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1342 a value with the appropriate register type. Unfortunately,
1343 we don't have easy access to the type of user registers.
1344 So for these registers, we fetch the register value regardless
1345 of the evaluation mode. */
1346 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1347 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1348 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1350 val
= value_of_register (regno
, get_selected_frame (NULL
));
1352 error (_("Value of register %s not available."), name
);
1358 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1359 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1361 case OP_INTERNALVAR
:
1363 return value_of_internalvar (exp
->gdbarch
,
1364 exp
->elts
[pc
+ 1].internalvar
);
1367 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1368 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1369 if (noside
== EVAL_SKIP
)
1370 return eval_skip_value (exp
);
1371 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1372 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1374 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1375 NSString constant. */
1376 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1377 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1378 if (noside
== EVAL_SKIP
)
1379 return eval_skip_value (exp
);
1380 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1384 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1385 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1386 nargs
= tem3
- tem2
+ 1;
1387 type
= expect_type
? check_typedef (expect_type
) : nullptr;
1389 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1390 && type
->code () == TYPE_CODE_STRUCT
)
1392 struct value
*rec
= allocate_value (expect_type
);
1394 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1395 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1398 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1399 && type
->code () == TYPE_CODE_ARRAY
)
1401 struct type
*range_type
= type
->index_type ();
1402 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1403 struct value
*array
= allocate_value (expect_type
);
1404 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1405 LONGEST low_bound
, high_bound
, index
;
1407 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
1410 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1413 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1414 for (tem
= nargs
; --nargs
>= 0;)
1416 struct value
*element
;
1418 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1419 if (value_type (element
) != element_type
)
1420 element
= value_cast (element_type
, element
);
1421 if (index
> high_bound
)
1422 /* To avoid memory corruption. */
1423 error (_("Too many array elements"));
1424 memcpy (value_contents_raw (array
)
1425 + (index
- low_bound
) * element_size
,
1426 value_contents (element
),
1433 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1434 && type
->code () == TYPE_CODE_SET
)
1436 struct value
*set
= allocate_value (expect_type
);
1437 gdb_byte
*valaddr
= value_contents_raw (set
);
1438 struct type
*element_type
= type
->index_type ();
1439 struct type
*check_type
= element_type
;
1440 LONGEST low_bound
, high_bound
;
1442 /* Get targettype of elementtype. */
1443 while (check_type
->code () == TYPE_CODE_RANGE
1444 || check_type
->code () == TYPE_CODE_TYPEDEF
)
1445 check_type
= TYPE_TARGET_TYPE (check_type
);
1447 if (!get_discrete_bounds (element_type
, &low_bound
, &high_bound
))
1448 error (_("(power)set type with unknown size"));
1449 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1450 for (tem
= 0; tem
< nargs
; tem
++)
1452 LONGEST range_low
, range_high
;
1453 struct type
*range_low_type
, *range_high_type
;
1454 struct value
*elem_val
;
1456 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1457 range_low_type
= range_high_type
= value_type (elem_val
);
1458 range_low
= range_high
= value_as_long (elem_val
);
1460 /* Check types of elements to avoid mixture of elements from
1461 different types. Also check if type of element is "compatible"
1462 with element type of powerset. */
1463 if (range_low_type
->code () == TYPE_CODE_RANGE
)
1464 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1465 if (range_high_type
->code () == TYPE_CODE_RANGE
)
1466 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1467 if ((range_low_type
->code () != range_high_type
->code ())
1468 || (range_low_type
->code () == TYPE_CODE_ENUM
1469 && (range_low_type
!= range_high_type
)))
1470 /* different element modes. */
1471 error (_("POWERSET tuple elements of different mode"));
1472 if ((check_type
->code () != range_low_type
->code ())
1473 || (check_type
->code () == TYPE_CODE_ENUM
1474 && range_low_type
!= check_type
))
1475 error (_("incompatible POWERSET tuple elements"));
1476 if (range_low
> range_high
)
1478 warning (_("empty POWERSET tuple range"));
1481 if (range_low
< low_bound
|| range_high
> high_bound
)
1482 error (_("POWERSET tuple element out of range"));
1483 range_low
-= low_bound
;
1484 range_high
-= low_bound
;
1485 for (; range_low
<= range_high
; range_low
++)
1487 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1489 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1490 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1491 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1498 argvec
= XALLOCAVEC (struct value
*, nargs
);
1499 for (tem
= 0; tem
< nargs
; tem
++)
1501 /* Ensure that array expressions are coerced into pointer
1503 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1505 if (noside
== EVAL_SKIP
)
1506 return eval_skip_value (exp
);
1507 return value_array (tem2
, tem3
, argvec
);
1511 struct value
*array
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1513 = value_as_long (evaluate_subexp (nullptr, exp
, pos
, noside
));
1514 int upper
= value_as_long (evaluate_subexp (nullptr, exp
, pos
, noside
));
1516 if (noside
== EVAL_SKIP
)
1517 return eval_skip_value (exp
);
1518 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1522 /* Skip third and second args to evaluate the first one. */
1523 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1524 if (value_logical_not (arg1
))
1526 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
1527 return evaluate_subexp (nullptr, exp
, pos
, noside
);
1531 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1532 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
1536 case OP_OBJC_SELECTOR
:
1537 { /* Objective C @selector operator. */
1538 char *sel
= &exp
->elts
[pc
+ 2].string
;
1539 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1540 struct type
*selector_type
;
1542 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1543 if (noside
== EVAL_SKIP
)
1544 return eval_skip_value (exp
);
1547 sel
[len
] = 0; /* Make sure it's terminated. */
1549 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1550 return value_from_longest (selector_type
,
1551 lookup_child_selector (exp
->gdbarch
, sel
));
1554 case OP_OBJC_MSGCALL
:
1555 { /* Objective C message (method) call. */
1557 CORE_ADDR responds_selector
= 0;
1558 CORE_ADDR method_selector
= 0;
1560 CORE_ADDR selector
= 0;
1562 int struct_return
= 0;
1563 enum noside sub_no_side
= EVAL_NORMAL
;
1565 struct value
*msg_send
= NULL
;
1566 struct value
*msg_send_stret
= NULL
;
1567 int gnu_runtime
= 0;
1569 struct value
*target
= NULL
;
1570 struct value
*method
= NULL
;
1571 struct value
*called_method
= NULL
;
1573 struct type
*selector_type
= NULL
;
1574 struct type
*long_type
;
1576 struct value
*ret
= NULL
;
1579 selector
= exp
->elts
[pc
+ 1].longconst
;
1580 nargs
= exp
->elts
[pc
+ 2].longconst
;
1581 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1585 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1586 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1588 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1589 sub_no_side
= EVAL_NORMAL
;
1591 sub_no_side
= noside
;
1593 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1595 if (value_as_long (target
) == 0)
1596 return value_from_longest (long_type
, 0);
1598 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1601 /* Find the method dispatch (Apple runtime) or method lookup
1602 (GNU runtime) function for Objective-C. These will be used
1603 to lookup the symbol information for the method. If we
1604 can't find any symbol information, then we'll use these to
1605 call the method, otherwise we can call the method
1606 directly. The msg_send_stret function is used in the special
1607 case of a method that returns a structure (Apple runtime
1611 type
= selector_type
;
1613 type
= lookup_function_type (type
);
1614 type
= lookup_pointer_type (type
);
1615 type
= lookup_function_type (type
);
1616 type
= lookup_pointer_type (type
);
1618 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1620 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1622 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1623 msg_send_stret
= value_from_pointer (type
,
1624 value_as_address (msg_send_stret
));
1628 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1629 /* Special dispatcher for methods returning structs. */
1631 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1634 /* Verify the target object responds to this method. The
1635 standard top-level 'Object' class uses a different name for
1636 the verification method than the non-standard, but more
1637 often used, 'NSObject' class. Make sure we check for both. */
1640 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1641 if (responds_selector
== 0)
1643 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1645 if (responds_selector
== 0)
1646 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1649 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1650 if (method_selector
== 0)
1652 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1654 if (method_selector
== 0)
1655 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1657 /* Call the verification method, to make sure that the target
1658 class implements the desired method. */
1660 argvec
[0] = msg_send
;
1662 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1663 argvec
[3] = value_from_longest (long_type
, selector
);
1666 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1669 /* Function objc_msg_lookup returns a pointer. */
1671 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1673 if (value_as_long (ret
) == 0)
1674 error (_("Target does not respond to this message selector."));
1676 /* Call "methodForSelector:" method, to get the address of a
1677 function method that implements this selector for this
1678 class. If we can find a symbol at that address, then we
1679 know the return type, parameter types etc. (that's a good
1682 argvec
[0] = msg_send
;
1684 argvec
[2] = value_from_longest (long_type
, method_selector
);
1685 argvec
[3] = value_from_longest (long_type
, selector
);
1688 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1692 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1695 /* ret should now be the selector. */
1697 addr
= value_as_long (ret
);
1700 struct symbol
*sym
= NULL
;
1702 /* The address might point to a function descriptor;
1703 resolve it to the actual code address instead. */
1704 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1705 current_top_target ());
1707 /* Is it a high_level symbol? */
1708 sym
= find_pc_function (addr
);
1710 method
= value_of_variable (sym
, 0);
1713 /* If we found a method with symbol information, check to see
1714 if it returns a struct. Otherwise assume it doesn't. */
1719 struct type
*val_type
;
1721 funaddr
= find_function_addr (method
, &val_type
);
1723 block_for_pc (funaddr
);
1725 val_type
= check_typedef (val_type
);
1727 if ((val_type
== NULL
)
1728 || (val_type
->code () == TYPE_CODE_ERROR
))
1730 if (expect_type
!= NULL
)
1731 val_type
= expect_type
;
1734 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1737 else if (expect_type
!= NULL
)
1739 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1740 check_typedef (expect_type
));
1743 /* Found a function symbol. Now we will substitute its
1744 value in place of the message dispatcher (obj_msgSend),
1745 so that we call the method directly instead of thru
1746 the dispatcher. The main reason for doing this is that
1747 we can now evaluate the return value and parameter values
1748 according to their known data types, in case we need to
1749 do things like promotion, dereferencing, special handling
1750 of structs and doubles, etc.
1752 We want to use the type signature of 'method', but still
1753 jump to objc_msgSend() or objc_msgSend_stret() to better
1754 mimic the behavior of the runtime. */
1758 if (value_type (method
)->code () != TYPE_CODE_FUNC
)
1759 error (_("method address has symbol information "
1760 "with non-function type; skipping"));
1762 /* Create a function pointer of the appropriate type, and
1763 replace its value with the value of msg_send or
1764 msg_send_stret. We must use a pointer here, as
1765 msg_send and msg_send_stret are of pointer type, and
1766 the representation may be different on systems that use
1767 function descriptors. */
1770 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1771 value_as_address (msg_send_stret
));
1774 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1775 value_as_address (msg_send
));
1780 called_method
= msg_send_stret
;
1782 called_method
= msg_send
;
1785 if (noside
== EVAL_SKIP
)
1786 return eval_skip_value (exp
);
1788 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1790 /* If the return type doesn't look like a function type,
1791 call an error. This can happen if somebody tries to
1792 turn a variable into a function call. This is here
1793 because people often want to call, eg, strcmp, which
1794 gdb doesn't know is a function. If gdb isn't asked for
1795 it's opinion (ie. through "whatis"), it won't offer
1798 struct type
*callee_type
= value_type (called_method
);
1800 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
1801 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1802 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1806 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
1807 return allocate_value (expect_type
);
1809 return allocate_value (callee_type
);
1812 error (_("Expression of type other than "
1813 "\"method returning ...\" used as a method"));
1816 /* Now depending on whether we found a symbol for the method,
1817 we will either call the runtime dispatcher or the method
1820 argvec
[0] = called_method
;
1822 argvec
[2] = value_from_longest (long_type
, selector
);
1823 /* User-supplied arguments. */
1824 for (tem
= 0; tem
< nargs
; tem
++)
1825 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1826 argvec
[tem
+ 3] = 0;
1828 auto call_args
= gdb::make_array_view (argvec
+ 1, nargs
+ 2);
1830 if (gnu_runtime
&& (method
!= NULL
))
1832 /* Function objc_msg_lookup returns a pointer. */
1833 deprecated_set_value_type (argvec
[0],
1834 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1835 argvec
[0] = call_function_by_hand (argvec
[0], NULL
, call_args
);
1838 return call_function_by_hand (argvec
[0], NULL
, call_args
);
1843 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1846 /* We have a complex number, There should be 2 floating
1847 point numbers that compose it. */
1849 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1850 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1852 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1854 case STRUCTOP_STRUCT
:
1855 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1856 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1857 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1858 if (noside
== EVAL_SKIP
)
1859 return eval_skip_value (exp
);
1860 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1862 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1863 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1867 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1868 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1869 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1870 if (noside
== EVAL_SKIP
)
1871 return eval_skip_value (exp
);
1873 /* Check to see if operator '->' has been overloaded. If so replace
1874 arg1 with the value returned by evaluating operator->(). */
1875 while (unop_user_defined_p (op
, arg1
))
1877 struct value
*value
= NULL
;
1880 value
= value_x_unop (arg1
, op
, noside
);
1883 catch (const gdb_exception_error
&except
)
1885 if (except
.error
== NOT_FOUND_ERROR
)
1894 /* JYG: if print object is on we need to replace the base type
1895 with rtti type in order to continue on with successful
1896 lookup of member / method only available in the rtti type. */
1898 struct type
*arg_type
= value_type (arg1
);
1899 struct type
*real_type
;
1900 int full
, using_enc
;
1902 struct value_print_options opts
;
1904 get_user_print_options (&opts
);
1905 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
1906 && (TYPE_TARGET_TYPE (arg_type
)->code () == TYPE_CODE_STRUCT
))
1908 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1911 arg1
= value_cast (real_type
, arg1
);
1915 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1916 NULL
, "structure pointer");
1917 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1918 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1921 case STRUCTOP_MEMBER
:
1923 if (op
== STRUCTOP_MEMBER
)
1924 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1926 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1928 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1930 if (noside
== EVAL_SKIP
)
1931 return eval_skip_value (exp
);
1933 type
= check_typedef (value_type (arg2
));
1934 switch (type
->code ())
1936 case TYPE_CODE_METHODPTR
:
1937 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1938 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1941 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1942 gdb_assert (value_type (arg2
)->code () == TYPE_CODE_PTR
);
1943 return value_ind (arg2
);
1946 case TYPE_CODE_MEMBERPTR
:
1947 /* Now, convert these values to an address. */
1948 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1951 mem_offset
= value_as_long (arg2
);
1953 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1954 value_as_long (arg1
) + mem_offset
);
1955 return value_ind (arg3
);
1958 error (_("non-pointer-to-member value used "
1959 "in pointer-to-member construct"));
1964 type_instance_flags flags
1965 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1966 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1967 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1968 for (ix
= 0; ix
< nargs
; ++ix
)
1969 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
1971 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
1972 *(pos
) += 4 + nargs
;
1973 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
1978 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1979 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1980 if (noside
== EVAL_SKIP
)
1981 return eval_skip_value (exp
);
1982 if (binop_user_defined_p (op
, arg1
, arg2
))
1983 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1985 return value_concat (arg1
, arg2
);
1988 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1989 /* Special-case assignments where the left-hand-side is a
1990 convenience variable -- in these, don't bother setting an
1991 expected type. This avoids a weird case where re-assigning a
1992 string or array to an internal variable could error with "Too
1993 many array elements". */
1994 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
1996 : value_type (arg1
),
1999 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2001 if (binop_user_defined_p (op
, arg1
, arg2
))
2002 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2004 return value_assign (arg1
, arg2
);
2006 case BINOP_ASSIGN_MODIFY
:
2008 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2009 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2010 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2012 op
= exp
->elts
[pc
+ 1].opcode
;
2013 if (binop_user_defined_p (op
, arg1
, arg2
))
2014 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2015 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2017 && is_integral_type (value_type (arg2
)))
2018 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2019 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2021 && is_integral_type (value_type (arg2
)))
2022 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2025 struct value
*tmp
= arg1
;
2027 /* For shift and integer exponentiation operations,
2028 only promote the first argument. */
2029 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2030 && is_integral_type (value_type (arg2
)))
2031 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2033 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2035 arg2
= value_binop (tmp
, arg2
, op
);
2037 return value_assign (arg1
, arg2
);
2040 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2041 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2042 if (noside
== EVAL_SKIP
)
2043 return eval_skip_value (exp
);
2044 if (binop_user_defined_p (op
, arg1
, arg2
))
2045 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2046 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2047 && is_integral_or_integral_reference (value_type (arg2
)))
2048 return value_ptradd (arg1
, value_as_long (arg2
));
2049 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2050 && is_integral_or_integral_reference (value_type (arg1
)))
2051 return value_ptradd (arg2
, value_as_long (arg1
));
2054 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2055 return value_binop (arg1
, arg2
, BINOP_ADD
);
2059 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2060 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2061 if (noside
== EVAL_SKIP
)
2062 return eval_skip_value (exp
);
2063 if (binop_user_defined_p (op
, arg1
, arg2
))
2064 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2065 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2066 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2068 /* FIXME -- should be ptrdiff_t */
2069 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2070 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2072 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2073 && is_integral_or_integral_reference (value_type (arg2
)))
2074 return value_ptradd (arg1
, - value_as_long (arg2
));
2077 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2078 return value_binop (arg1
, arg2
, BINOP_SUB
);
2089 case BINOP_BITWISE_AND
:
2090 case BINOP_BITWISE_IOR
:
2091 case BINOP_BITWISE_XOR
:
2092 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2093 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2094 if (noside
== EVAL_SKIP
)
2095 return eval_skip_value (exp
);
2096 if (binop_user_defined_p (op
, arg1
, arg2
))
2097 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2100 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2101 fudge arg2 to avoid division-by-zero, the caller is
2102 (theoretically) only looking for the type of the result. */
2103 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2104 /* ??? Do we really want to test for BINOP_MOD here?
2105 The implementation of value_binop gives it a well-defined
2108 || op
== BINOP_INTDIV
2111 && value_logical_not (arg2
))
2113 struct value
*v_one
;
2115 v_one
= value_one (value_type (arg2
));
2116 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2117 return value_binop (arg1
, v_one
, op
);
2121 /* For shift and integer exponentiation operations,
2122 only promote the first argument. */
2123 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2124 && is_integral_type (value_type (arg2
)))
2125 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2127 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2129 return value_binop (arg1
, arg2
, op
);
2133 case BINOP_SUBSCRIPT
:
2134 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2135 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2136 if (noside
== EVAL_SKIP
)
2137 return eval_skip_value (exp
);
2138 if (binop_user_defined_p (op
, arg1
, arg2
))
2139 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2142 /* If the user attempts to subscript something that is not an
2143 array or pointer type (like a plain int variable for example),
2144 then report this as an error. */
2146 arg1
= coerce_ref (arg1
);
2147 type
= check_typedef (value_type (arg1
));
2148 if (type
->code () != TYPE_CODE_ARRAY
2149 && type
->code () != TYPE_CODE_PTR
)
2152 error (_("cannot subscript something of type `%s'"),
2155 error (_("cannot subscript requested type"));
2158 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2159 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2161 return value_subscript (arg1
, value_as_long (arg2
));
2163 case MULTI_SUBSCRIPT
:
2165 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2166 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2167 argvec
= XALLOCAVEC (struct value
*, nargs
);
2168 for (ix
= 0; ix
< nargs
; ++ix
)
2169 argvec
[ix
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
2170 if (noside
== EVAL_SKIP
)
2172 for (ix
= 0; ix
< nargs
; ++ix
)
2176 if (binop_user_defined_p (op
, arg1
, arg2
))
2178 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2182 arg1
= coerce_ref (arg1
);
2183 type
= check_typedef (value_type (arg1
));
2185 switch (type
->code ())
2188 case TYPE_CODE_ARRAY
:
2189 case TYPE_CODE_STRING
:
2190 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2195 error (_("cannot subscript something of type `%s'"),
2198 error (_("cannot subscript requested type"));
2204 case BINOP_LOGICAL_AND
:
2205 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2206 if (noside
== EVAL_SKIP
)
2208 evaluate_subexp (nullptr, exp
, pos
, noside
);
2209 return eval_skip_value (exp
);
2213 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2216 if (binop_user_defined_p (op
, arg1
, arg2
))
2218 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2219 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2223 tem
= value_logical_not (arg1
);
2225 = evaluate_subexp (nullptr, exp
, pos
, (tem
? EVAL_SKIP
: noside
));
2226 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2227 return value_from_longest (type
,
2228 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2231 case BINOP_LOGICAL_OR
:
2232 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2233 if (noside
== EVAL_SKIP
)
2235 evaluate_subexp (nullptr, exp
, pos
, noside
);
2236 return eval_skip_value (exp
);
2240 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2243 if (binop_user_defined_p (op
, arg1
, arg2
))
2245 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2246 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2250 tem
= value_logical_not (arg1
);
2252 = evaluate_subexp (nullptr, exp
, pos
, (!tem
? EVAL_SKIP
: noside
));
2253 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2254 return value_from_longest (type
,
2255 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2259 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2260 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2261 if (noside
== EVAL_SKIP
)
2262 return eval_skip_value (exp
);
2263 if (binop_user_defined_p (op
, arg1
, arg2
))
2265 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2269 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2270 tem
= value_equal (arg1
, arg2
);
2271 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2272 return value_from_longest (type
, (LONGEST
) tem
);
2275 case BINOP_NOTEQUAL
:
2276 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2277 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2278 if (noside
== EVAL_SKIP
)
2279 return eval_skip_value (exp
);
2280 if (binop_user_defined_p (op
, arg1
, arg2
))
2282 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2286 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2287 tem
= value_equal (arg1
, arg2
);
2288 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2289 return value_from_longest (type
, (LONGEST
) ! tem
);
2293 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2294 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2295 if (noside
== EVAL_SKIP
)
2296 return eval_skip_value (exp
);
2297 if (binop_user_defined_p (op
, arg1
, arg2
))
2299 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2303 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2304 tem
= value_less (arg1
, arg2
);
2305 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2306 return value_from_longest (type
, (LONGEST
) tem
);
2310 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2311 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2312 if (noside
== EVAL_SKIP
)
2313 return eval_skip_value (exp
);
2314 if (binop_user_defined_p (op
, arg1
, arg2
))
2316 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2320 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2321 tem
= value_less (arg2
, arg1
);
2322 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2323 return value_from_longest (type
, (LONGEST
) tem
);
2327 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2328 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2329 if (noside
== EVAL_SKIP
)
2330 return eval_skip_value (exp
);
2331 if (binop_user_defined_p (op
, arg1
, arg2
))
2333 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2337 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2338 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2339 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2340 return value_from_longest (type
, (LONGEST
) tem
);
2344 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2345 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2346 if (noside
== EVAL_SKIP
)
2347 return eval_skip_value (exp
);
2348 if (binop_user_defined_p (op
, arg1
, arg2
))
2350 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2354 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2355 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2356 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2357 return value_from_longest (type
, (LONGEST
) tem
);
2361 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2362 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2363 if (noside
== EVAL_SKIP
)
2364 return eval_skip_value (exp
);
2365 type
= check_typedef (value_type (arg2
));
2366 if (type
->code () != TYPE_CODE_INT
2367 && type
->code () != TYPE_CODE_ENUM
)
2368 error (_("Non-integral right operand for \"@\" operator."));
2369 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2371 return allocate_repeat_value (value_type (arg1
),
2372 longest_to_int (value_as_long (arg2
)));
2375 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2378 evaluate_subexp (nullptr, exp
, pos
, noside
);
2379 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2382 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2383 if (noside
== EVAL_SKIP
)
2384 return eval_skip_value (exp
);
2385 if (unop_user_defined_p (op
, arg1
))
2386 return value_x_unop (arg1
, op
, noside
);
2389 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2390 return value_pos (arg1
);
2394 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2395 if (noside
== EVAL_SKIP
)
2396 return eval_skip_value (exp
);
2397 if (unop_user_defined_p (op
, arg1
))
2398 return value_x_unop (arg1
, op
, noside
);
2401 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2402 return value_neg (arg1
);
2405 case UNOP_COMPLEMENT
:
2406 /* C++: check for and handle destructor names. */
2408 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2409 if (noside
== EVAL_SKIP
)
2410 return eval_skip_value (exp
);
2411 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2412 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2415 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2416 return value_complement (arg1
);
2419 case UNOP_LOGICAL_NOT
:
2420 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2421 if (noside
== EVAL_SKIP
)
2422 return eval_skip_value (exp
);
2423 if (unop_user_defined_p (op
, arg1
))
2424 return value_x_unop (arg1
, op
, noside
);
2427 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2428 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2432 if (expect_type
&& expect_type
->code () == TYPE_CODE_PTR
)
2433 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2434 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2435 type
= check_typedef (value_type (arg1
));
2436 if (type
->code () == TYPE_CODE_METHODPTR
2437 || type
->code () == TYPE_CODE_MEMBERPTR
)
2438 error (_("Attempt to dereference pointer "
2439 "to member without an object"));
2440 if (noside
== EVAL_SKIP
)
2441 return eval_skip_value (exp
);
2442 if (unop_user_defined_p (op
, arg1
))
2443 return value_x_unop (arg1
, op
, noside
);
2444 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2446 type
= check_typedef (value_type (arg1
));
2448 /* If the type pointed to is dynamic then in order to resolve the
2449 dynamic properties we must actually dereference the pointer.
2450 There is a risk that this dereference will have side-effects
2451 in the inferior, but being able to print accurate type
2452 information seems worth the risk. */
2453 if ((type
->code () != TYPE_CODE_PTR
2454 && !TYPE_IS_REFERENCE (type
))
2455 || !is_dynamic_type (TYPE_TARGET_TYPE (type
)))
2457 if (type
->code () == TYPE_CODE_PTR
2458 || TYPE_IS_REFERENCE (type
)
2459 /* In C you can dereference an array to get the 1st elt. */
2460 || type
->code () == TYPE_CODE_ARRAY
)
2461 return value_zero (TYPE_TARGET_TYPE (type
),
2463 else if (type
->code () == TYPE_CODE_INT
)
2464 /* GDB allows dereferencing an int. */
2465 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2468 error (_("Attempt to take contents of a non-pointer value."));
2472 /* Allow * on an integer so we can cast it to whatever we want.
2473 This returns an int, which seems like the most C-like thing to
2474 do. "long long" variables are rare enough that
2475 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2476 if (type
->code () == TYPE_CODE_INT
)
2477 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2478 (CORE_ADDR
) value_as_address (arg1
));
2479 return value_ind (arg1
);
2482 /* C++: check for and handle pointer to members. */
2484 if (noside
== EVAL_SKIP
)
2486 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2487 return eval_skip_value (exp
);
2490 return evaluate_subexp_for_address (exp
, pos
, noside
);
2493 if (noside
== EVAL_SKIP
)
2495 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2496 return eval_skip_value (exp
);
2498 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2503 evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
));
2504 /* FIXME: This should be size_t. */
2505 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2506 ULONGEST align
= type_align (type
);
2508 error (_("could not determine alignment of type"));
2509 return value_from_longest (size_type
, align
);
2514 type
= exp
->elts
[pc
+ 1].type
;
2515 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2517 case UNOP_CAST_TYPE
:
2518 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2519 type
= value_type (arg1
);
2520 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2522 case UNOP_DYNAMIC_CAST
:
2523 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2524 type
= value_type (arg1
);
2525 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2526 if (noside
== EVAL_SKIP
)
2527 return eval_skip_value (exp
);
2528 return value_dynamic_cast (type
, arg1
);
2530 case UNOP_REINTERPRET_CAST
:
2531 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2532 type
= value_type (arg1
);
2533 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2534 if (noside
== EVAL_SKIP
)
2535 return eval_skip_value (exp
);
2536 return value_reinterpret_cast (type
, arg1
);
2540 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2541 if (noside
== EVAL_SKIP
)
2542 return eval_skip_value (exp
);
2543 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2544 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2546 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2547 value_as_address (arg1
));
2549 case UNOP_MEMVAL_TYPE
:
2550 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2551 type
= value_type (arg1
);
2552 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2553 if (noside
== EVAL_SKIP
)
2554 return eval_skip_value (exp
);
2555 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2556 return value_zero (type
, lval_memory
);
2558 return value_at_lazy (type
, value_as_address (arg1
));
2560 case UNOP_PREINCREMENT
:
2561 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2562 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2564 else if (unop_user_defined_p (op
, arg1
))
2566 return value_x_unop (arg1
, op
, noside
);
2570 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2571 arg2
= value_ptradd (arg1
, 1);
2574 struct value
*tmp
= arg1
;
2576 arg2
= value_one (value_type (arg1
));
2577 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2578 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2581 return value_assign (arg1
, arg2
);
2584 case UNOP_PREDECREMENT
:
2585 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2586 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2588 else if (unop_user_defined_p (op
, arg1
))
2590 return value_x_unop (arg1
, op
, noside
);
2594 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2595 arg2
= value_ptradd (arg1
, -1);
2598 struct value
*tmp
= arg1
;
2600 arg2
= value_one (value_type (arg1
));
2601 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2602 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2605 return value_assign (arg1
, arg2
);
2608 case UNOP_POSTINCREMENT
:
2609 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2610 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2612 else if (unop_user_defined_p (op
, arg1
))
2614 return value_x_unop (arg1
, op
, noside
);
2618 arg3
= value_non_lval (arg1
);
2620 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2621 arg2
= value_ptradd (arg1
, 1);
2624 struct value
*tmp
= arg1
;
2626 arg2
= value_one (value_type (arg1
));
2627 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2628 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2631 value_assign (arg1
, arg2
);
2635 case UNOP_POSTDECREMENT
:
2636 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2637 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2639 else if (unop_user_defined_p (op
, arg1
))
2641 return value_x_unop (arg1
, op
, noside
);
2645 arg3
= value_non_lval (arg1
);
2647 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2648 arg2
= value_ptradd (arg1
, -1);
2651 struct value
*tmp
= arg1
;
2653 arg2
= value_one (value_type (arg1
));
2654 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2655 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2658 value_assign (arg1
, arg2
);
2664 return value_of_this (exp
->language_defn
);
2667 /* The value is not supposed to be used. This is here to make it
2668 easier to accommodate expressions that contain types. */
2670 if (noside
== EVAL_SKIP
)
2671 return eval_skip_value (exp
);
2672 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2673 return allocate_value (exp
->elts
[pc
+ 1].type
);
2675 error (_("Attempt to use a type name as an expression"));
2679 if (noside
== EVAL_SKIP
)
2681 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2682 return eval_skip_value (exp
);
2684 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2686 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2687 struct value
*result
;
2689 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2691 /* 'decltype' has special semantics for lvalues. */
2692 if (op
== OP_DECLTYPE
2693 && (sub_op
== BINOP_SUBSCRIPT
2694 || sub_op
== STRUCTOP_MEMBER
2695 || sub_op
== STRUCTOP_MPTR
2696 || sub_op
== UNOP_IND
2697 || sub_op
== STRUCTOP_STRUCT
2698 || sub_op
== STRUCTOP_PTR
2699 || sub_op
== OP_SCOPE
))
2701 type
= value_type (result
);
2703 if (!TYPE_IS_REFERENCE (type
))
2705 type
= lookup_lvalue_reference_type (type
);
2706 result
= allocate_value (type
);
2713 error (_("Attempt to use a type as an expression"));
2717 struct value
*result
;
2718 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2720 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2721 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2723 result
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2725 if (noside
!= EVAL_NORMAL
)
2726 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2728 return cplus_typeid (result
);
2732 /* Removing this case and compiling with gcc -Wall reveals that
2733 a lot of cases are hitting this case. Some of these should
2734 probably be removed from expression.h; others are legitimate
2735 expressions which are (apparently) not fully implemented.
2737 If there are any cases landing here which mean a user error,
2738 then they should be separate cases, with more descriptive
2741 error (_("GDB does not (yet) know how to "
2742 "evaluate that kind of expression"));
2745 gdb_assert_not_reached ("missed return?");
2748 /* Evaluate a subexpression of EXP, at index *POS,
2749 and return the address of that subexpression.
2750 Advance *POS over the subexpression.
2751 If the subexpression isn't an lvalue, get an error.
2752 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2753 then only the type of the result need be correct. */
2755 static struct value
*
2756 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2766 op
= exp
->elts
[pc
].opcode
;
2772 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2774 /* We can't optimize out "&*" if there's a user-defined operator*. */
2775 if (unop_user_defined_p (op
, x
))
2777 x
= value_x_unop (x
, op
, noside
);
2778 goto default_case_after_eval
;
2781 return coerce_array (x
);
2785 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2786 evaluate_subexp (nullptr, exp
, pos
, noside
));
2788 case UNOP_MEMVAL_TYPE
:
2793 x
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2794 type
= value_type (x
);
2795 return value_cast (lookup_pointer_type (type
),
2796 evaluate_subexp (nullptr, exp
, pos
, noside
));
2800 var
= exp
->elts
[pc
+ 2].symbol
;
2802 /* C++: The "address" of a reference should yield the address
2803 * of the object pointed to. Let value_addr() deal with it. */
2804 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
2808 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2811 lookup_pointer_type (SYMBOL_TYPE (var
));
2812 enum address_class sym_class
= SYMBOL_CLASS (var
);
2814 if (sym_class
== LOC_CONST
2815 || sym_class
== LOC_CONST_BYTES
2816 || sym_class
== LOC_REGISTER
)
2817 error (_("Attempt to take address of register or constant."));
2820 value_zero (type
, not_lval
);
2823 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2825 case OP_VAR_MSYM_VALUE
:
2829 value
*val
= evaluate_var_msym_value (noside
,
2830 exp
->elts
[pc
+ 1].objfile
,
2831 exp
->elts
[pc
+ 2].msymbol
);
2832 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2834 struct type
*type
= lookup_pointer_type (value_type (val
));
2835 return value_zero (type
, not_lval
);
2838 return value_addr (val
);
2842 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2843 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2844 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2845 &exp
->elts
[pc
+ 3].string
,
2848 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2853 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2854 default_case_after_eval
:
2855 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2857 struct type
*type
= check_typedef (value_type (x
));
2859 if (TYPE_IS_REFERENCE (type
))
2860 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2862 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2863 return value_zero (lookup_pointer_type (value_type (x
)),
2866 error (_("Attempt to take address of "
2867 "value not located in memory."));
2869 return value_addr (x
);
2873 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2874 When used in contexts where arrays will be coerced anyway, this is
2875 equivalent to `evaluate_subexp' but much faster because it avoids
2876 actually fetching array contents (perhaps obsolete now that we have
2879 Note that we currently only do the coercion for C expressions, where
2880 arrays are zero based and the coercion is correct. For other languages,
2881 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2882 to decide if coercion is appropriate. */
2885 evaluate_subexp_with_coercion (struct expression
*exp
,
2886 int *pos
, enum noside noside
)
2895 op
= exp
->elts
[pc
].opcode
;
2900 var
= exp
->elts
[pc
+ 2].symbol
;
2901 type
= check_typedef (SYMBOL_TYPE (var
));
2902 if (type
->code () == TYPE_CODE_ARRAY
2903 && !type
->is_vector ()
2904 && CAST_IS_CONVERSION (exp
->language_defn
))
2907 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2908 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2914 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2918 /* Evaluate a subexpression of EXP, at index *POS,
2919 and return a value for the size of that subexpression.
2920 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2921 we allow side-effects on the operand if its type is a variable
2924 static struct value
*
2925 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
2928 /* FIXME: This should be size_t. */
2929 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2936 op
= exp
->elts
[pc
].opcode
;
2940 /* This case is handled specially
2941 so that we avoid creating a value for the result type.
2942 If the result type is very big, it's desirable not to
2943 create a value unnecessarily. */
2946 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2947 type
= check_typedef (value_type (val
));
2948 if (type
->code () != TYPE_CODE_PTR
2949 && !TYPE_IS_REFERENCE (type
)
2950 && type
->code () != TYPE_CODE_ARRAY
)
2951 error (_("Attempt to take contents of a non-pointer value."));
2952 type
= TYPE_TARGET_TYPE (type
);
2953 if (is_dynamic_type (type
))
2954 type
= value_type (value_ind (val
));
2955 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2959 type
= exp
->elts
[pc
+ 1].type
;
2962 case UNOP_MEMVAL_TYPE
:
2964 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2965 type
= value_type (val
);
2969 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
2970 if (is_dynamic_type (type
))
2972 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
2973 type
= value_type (val
);
2974 if (type
->code () == TYPE_CODE_ARRAY
)
2976 if (type_not_allocated (type
) || type_not_associated (type
))
2977 return value_zero (size_type
, not_lval
);
2978 else if (is_dynamic_type (type
->index_type ())
2979 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
2980 return allocate_optimized_out_value (size_type
);
2987 case OP_VAR_MSYM_VALUE
:
2991 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
2992 value
*mval
= evaluate_var_msym_value (noside
,
2993 exp
->elts
[pc
+ 1].objfile
,
2996 type
= value_type (mval
);
2997 if (type
->code () == TYPE_CODE_ERROR
)
2998 error_unknown_type (msymbol
->print_name ());
3000 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3004 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3005 type of the subscript is a variable length array type. In this case we
3006 must re-evaluate the right hand side of the subscription to allow
3008 case BINOP_SUBSCRIPT
:
3009 if (noside
== EVAL_NORMAL
)
3011 int npc
= (*pos
) + 1;
3013 val
= evaluate_subexp (nullptr, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3014 type
= check_typedef (value_type (val
));
3015 if (type
->code () == TYPE_CODE_ARRAY
)
3017 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3018 if (type
->code () == TYPE_CODE_ARRAY
)
3020 type
= type
->index_type ();
3021 /* Only re-evaluate the right hand side if the resulting type
3022 is a variable length type. */
3023 if (type
->bounds ()->flag_bound_evaluated
)
3025 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3026 return value_from_longest
3027 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3036 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3037 type
= value_type (val
);
3041 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3042 "When applied to a reference or a reference type, the result is
3043 the size of the referenced type." */
3044 type
= check_typedef (type
);
3045 if (exp
->language_defn
->la_language
== language_cplus
3046 && (TYPE_IS_REFERENCE (type
)))
3047 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3048 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3051 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3052 for that subexpression cast to TO_TYPE. Advance *POS over the
3056 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3058 struct type
*to_type
)
3062 /* Don't let symbols be evaluated with evaluate_subexp because that
3063 throws an "unknown type" error for no-debug data symbols.
3064 Instead, we want the cast to reinterpret the symbol. */
3065 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3066 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3071 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3073 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3074 return value_zero (to_type
, not_lval
);
3076 val
= evaluate_var_msym_value (noside
,
3077 exp
->elts
[pc
+ 1].objfile
,
3078 exp
->elts
[pc
+ 2].msymbol
);
3081 val
= evaluate_var_value (noside
,
3082 exp
->elts
[pc
+ 1].block
,
3083 exp
->elts
[pc
+ 2].symbol
);
3085 if (noside
== EVAL_SKIP
)
3086 return eval_skip_value (exp
);
3088 val
= value_cast (to_type
, val
);
3090 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3091 if (VALUE_LVAL (val
) == lval_memory
)
3093 if (value_lazy (val
))
3094 value_fetch_lazy (val
);
3095 VALUE_LVAL (val
) = not_lval
;
3100 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3101 if (noside
== EVAL_SKIP
)
3102 return eval_skip_value (exp
);
3103 return value_cast (to_type
, val
);
3106 /* Parse a type expression in the string [P..P+LENGTH). */
3109 parse_and_eval_type (const char *p
, int length
)
3111 char *tmp
= (char *) alloca (length
+ 4);
3114 memcpy (tmp
+ 1, p
, length
);
3115 tmp
[length
+ 1] = ')';
3116 tmp
[length
+ 2] = '0';
3117 tmp
[length
+ 3] = '\0';
3118 expression_up expr
= parse_expression (tmp
);
3119 if (expr
->first_opcode () != UNOP_CAST
)
3120 error (_("Internal error in eval_type."));
3121 return expr
->elts
[1].type
;