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 ());
1237 /* Helper function that implements the body of OP_FUNC_STATIC_VAR. */
1239 static struct value
*
1240 eval_op_func_static_var (struct type
*expect_type
, struct expression
*exp
,
1242 value
*func
, const char *var
)
1244 if (noside
== EVAL_SKIP
)
1245 return eval_skip_value (exp
);
1246 CORE_ADDR addr
= value_address (func
);
1247 const block
*blk
= block_for_pc (addr
);
1248 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1249 if (sym
.symbol
== NULL
)
1250 error (_("No symbol \"%s\" in specified context."), var
);
1251 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1254 /* Helper function that implements the body of OP_REGISTER. */
1256 static struct value
*
1257 eval_op_register (struct type
*expect_type
, struct expression
*exp
,
1258 enum noside noside
, const char *name
)
1263 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1264 name
, strlen (name
));
1266 error (_("Register $%s not available."), name
);
1268 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1269 a value with the appropriate register type. Unfortunately,
1270 we don't have easy access to the type of user registers.
1271 So for these registers, we fetch the register value regardless
1272 of the evaluation mode. */
1273 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1274 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1275 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1277 val
= value_of_register (regno
, get_selected_frame (NULL
));
1279 error (_("Value of register %s not available."), name
);
1284 /* Helper function that implements the body of OP_STRING. */
1286 static struct value
*
1287 eval_op_string (struct type
*expect_type
, struct expression
*exp
,
1288 enum noside noside
, int len
, const char *string
)
1290 if (noside
== EVAL_SKIP
)
1291 return eval_skip_value (exp
);
1292 struct type
*type
= language_string_char_type (exp
->language_defn
,
1294 return value_string (string
, len
, type
);
1297 /* Helper function that implements the body of OP_OBJC_SELECTOR. */
1299 static struct value
*
1300 eval_op_objc_selector (struct type
*expect_type
, struct expression
*exp
,
1304 if (noside
== EVAL_SKIP
)
1305 return eval_skip_value (exp
);
1307 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1308 return value_from_longest (selector_type
,
1309 lookup_child_selector (exp
->gdbarch
, sel
));
1312 /* Helper function that implements the body of BINOP_CONCAT. */
1314 static struct value
*
1315 eval_op_concat (struct type
*expect_type
, struct expression
*exp
,
1317 enum exp_opcode op
, struct value
*arg1
, struct value
*arg2
)
1319 if (noside
== EVAL_SKIP
)
1320 return eval_skip_value (exp
);
1321 if (binop_user_defined_p (op
, arg1
, arg2
))
1322 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1324 return value_concat (arg1
, arg2
);
1327 /* A helper function for TERNOP_SLICE. */
1329 static struct value
*
1330 eval_op_ternop (struct type
*expect_type
, struct expression
*exp
,
1332 struct value
*array
, struct value
*low
, struct value
*upper
)
1334 if (noside
== EVAL_SKIP
)
1335 return eval_skip_value (exp
);
1336 int lowbound
= value_as_long (low
);
1337 int upperbound
= value_as_long (upper
);
1338 return value_slice (array
, lowbound
, upperbound
- lowbound
+ 1);
1341 /* A helper function for STRUCTOP_STRUCT. */
1343 static struct value
*
1344 eval_op_structop_struct (struct type
*expect_type
, struct expression
*exp
,
1346 struct value
*arg1
, const char *string
)
1348 if (noside
== EVAL_SKIP
)
1349 return eval_skip_value (exp
);
1350 struct value
*arg3
= value_struct_elt (&arg1
, NULL
, string
,
1352 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1353 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1357 /* A helper function for STRUCTOP_PTR. */
1359 static struct value
*
1360 eval_op_structop_ptr (struct type
*expect_type
, struct expression
*exp
,
1361 enum noside noside
, enum exp_opcode op
,
1362 struct value
*arg1
, const char *string
)
1364 if (noside
== EVAL_SKIP
)
1365 return eval_skip_value (exp
);
1367 /* Check to see if operator '->' has been overloaded. If so replace
1368 arg1 with the value returned by evaluating operator->(). */
1369 while (unop_user_defined_p (op
, arg1
))
1371 struct value
*value
= NULL
;
1374 value
= value_x_unop (arg1
, op
, noside
);
1377 catch (const gdb_exception_error
&except
)
1379 if (except
.error
== NOT_FOUND_ERROR
)
1388 /* JYG: if print object is on we need to replace the base type
1389 with rtti type in order to continue on with successful
1390 lookup of member / method only available in the rtti type. */
1392 struct type
*arg_type
= value_type (arg1
);
1393 struct type
*real_type
;
1394 int full
, using_enc
;
1396 struct value_print_options opts
;
1398 get_user_print_options (&opts
);
1399 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
1400 && (TYPE_TARGET_TYPE (arg_type
)->code () == TYPE_CODE_STRUCT
))
1402 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1405 arg1
= value_cast (real_type
, arg1
);
1409 struct value
*arg3
= value_struct_elt (&arg1
, NULL
, string
,
1410 NULL
, "structure pointer");
1411 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1412 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1416 /* A helper function for STRUCTOP_MEMBER. */
1418 static struct value
*
1419 eval_op_member (struct type
*expect_type
, struct expression
*exp
,
1421 struct value
*arg1
, struct value
*arg2
)
1425 if (noside
== EVAL_SKIP
)
1426 return eval_skip_value (exp
);
1429 struct type
*type
= check_typedef (value_type (arg2
));
1430 switch (type
->code ())
1432 case TYPE_CODE_METHODPTR
:
1433 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1434 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1437 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1438 gdb_assert (value_type (arg2
)->code () == TYPE_CODE_PTR
);
1439 return value_ind (arg2
);
1442 case TYPE_CODE_MEMBERPTR
:
1443 /* Now, convert these values to an address. */
1444 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1447 mem_offset
= value_as_long (arg2
);
1449 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1450 value_as_long (arg1
) + mem_offset
);
1451 return value_ind (arg3
);
1454 error (_("non-pointer-to-member value used "
1455 "in pointer-to-member construct"));
1459 /* A helper function for BINOP_ADD. */
1461 static struct value
*
1462 eval_op_add (struct type
*expect_type
, struct expression
*exp
,
1463 enum noside noside
, enum exp_opcode op
,
1464 struct value
*arg1
, struct value
*arg2
)
1466 if (noside
== EVAL_SKIP
)
1467 return eval_skip_value (exp
);
1468 if (binop_user_defined_p (op
, arg1
, arg2
))
1469 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1470 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1471 && is_integral_or_integral_reference (value_type (arg2
)))
1472 return value_ptradd (arg1
, value_as_long (arg2
));
1473 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
1474 && is_integral_or_integral_reference (value_type (arg1
)))
1475 return value_ptradd (arg2
, value_as_long (arg1
));
1478 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1479 return value_binop (arg1
, arg2
, BINOP_ADD
);
1483 /* A helper function for BINOP_SUB. */
1485 static struct value
*
1486 eval_op_sub (struct type
*expect_type
, struct expression
*exp
,
1487 enum noside noside
, enum exp_opcode op
,
1488 struct value
*arg1
, struct value
*arg2
)
1490 if (noside
== EVAL_SKIP
)
1491 return eval_skip_value (exp
);
1492 if (binop_user_defined_p (op
, arg1
, arg2
))
1493 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1494 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1495 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
1497 /* FIXME -- should be ptrdiff_t */
1498 struct type
*type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1499 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1501 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1502 && is_integral_or_integral_reference (value_type (arg2
)))
1503 return value_ptradd (arg1
, - value_as_long (arg2
));
1506 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1507 return value_binop (arg1
, arg2
, BINOP_SUB
);
1511 /* Helper function for several different binary operations. */
1513 static struct value
*
1514 eval_op_binary (struct type
*expect_type
, struct expression
*exp
,
1515 enum noside noside
, enum exp_opcode op
,
1516 struct value
*arg1
, struct value
*arg2
)
1518 if (noside
== EVAL_SKIP
)
1519 return eval_skip_value (exp
);
1520 if (binop_user_defined_p (op
, arg1
, arg2
))
1521 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1524 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1525 fudge arg2 to avoid division-by-zero, the caller is
1526 (theoretically) only looking for the type of the result. */
1527 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1528 /* ??? Do we really want to test for BINOP_MOD here?
1529 The implementation of value_binop gives it a well-defined
1532 || op
== BINOP_INTDIV
1535 && value_logical_not (arg2
))
1537 struct value
*v_one
;
1539 v_one
= value_one (value_type (arg2
));
1540 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1541 return value_binop (arg1
, v_one
, op
);
1545 /* For shift and integer exponentiation operations,
1546 only promote the first argument. */
1547 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1548 && is_integral_type (value_type (arg2
)))
1549 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1551 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1553 return value_binop (arg1
, arg2
, op
);
1558 /* A helper function for BINOP_SUBSCRIPT. */
1560 static struct value
*
1561 eval_op_subscript (struct type
*expect_type
, struct expression
*exp
,
1562 enum noside noside
, enum exp_opcode op
,
1563 struct value
*arg1
, struct value
*arg2
)
1565 if (noside
== EVAL_SKIP
)
1566 return eval_skip_value (exp
);
1567 if (binop_user_defined_p (op
, arg1
, arg2
))
1568 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1571 /* If the user attempts to subscript something that is not an
1572 array or pointer type (like a plain int variable for example),
1573 then report this as an error. */
1575 arg1
= coerce_ref (arg1
);
1576 struct type
*type
= check_typedef (value_type (arg1
));
1577 if (type
->code () != TYPE_CODE_ARRAY
1578 && type
->code () != TYPE_CODE_PTR
)
1581 error (_("cannot subscript something of type `%s'"),
1584 error (_("cannot subscript requested type"));
1587 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1588 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1590 return value_subscript (arg1
, value_as_long (arg2
));
1594 /* A helper function for BINOP_EQUAL. */
1596 static struct value
*
1597 eval_op_equal (struct type
*expect_type
, struct expression
*exp
,
1598 enum noside noside
, enum exp_opcode op
,
1599 struct value
*arg1
, struct value
*arg2
)
1601 if (noside
== EVAL_SKIP
)
1602 return eval_skip_value (exp
);
1603 if (binop_user_defined_p (op
, arg1
, arg2
))
1605 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1609 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1610 int tem
= value_equal (arg1
, arg2
);
1611 struct type
*type
= language_bool_type (exp
->language_defn
,
1613 return value_from_longest (type
, (LONGEST
) tem
);
1617 /* A helper function for BINOP_NOTEQUAL. */
1619 static struct value
*
1620 eval_op_notequal (struct type
*expect_type
, struct expression
*exp
,
1621 enum noside noside
, enum exp_opcode op
,
1622 struct value
*arg1
, struct value
*arg2
)
1624 if (noside
== EVAL_SKIP
)
1625 return eval_skip_value (exp
);
1626 if (binop_user_defined_p (op
, arg1
, arg2
))
1628 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1632 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1633 int tem
= value_equal (arg1
, arg2
);
1634 struct type
*type
= language_bool_type (exp
->language_defn
,
1636 return value_from_longest (type
, (LONGEST
) ! tem
);
1640 /* A helper function for BINOP_LESS. */
1642 static struct value
*
1643 eval_op_less (struct type
*expect_type
, struct expression
*exp
,
1644 enum noside noside
, enum exp_opcode op
,
1645 struct value
*arg1
, struct value
*arg2
)
1647 if (noside
== EVAL_SKIP
)
1648 return eval_skip_value (exp
);
1649 if (binop_user_defined_p (op
, arg1
, arg2
))
1651 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1655 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1656 int tem
= value_less (arg1
, arg2
);
1657 struct type
*type
= language_bool_type (exp
->language_defn
,
1659 return value_from_longest (type
, (LONGEST
) tem
);
1663 /* A helper function for BINOP_GTR. */
1665 static struct value
*
1666 eval_op_gtr (struct type
*expect_type
, struct expression
*exp
,
1667 enum noside noside
, enum exp_opcode op
,
1668 struct value
*arg1
, struct value
*arg2
)
1670 if (noside
== EVAL_SKIP
)
1671 return eval_skip_value (exp
);
1672 if (binop_user_defined_p (op
, arg1
, arg2
))
1674 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1678 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1679 int tem
= value_less (arg2
, arg1
);
1680 struct type
*type
= language_bool_type (exp
->language_defn
,
1682 return value_from_longest (type
, (LONGEST
) tem
);
1686 /* A helper function for BINOP_GEQ. */
1688 static struct value
*
1689 eval_op_geq (struct type
*expect_type
, struct expression
*exp
,
1690 enum noside noside
, enum exp_opcode op
,
1691 struct value
*arg1
, struct value
*arg2
)
1693 if (noside
== EVAL_SKIP
)
1694 return eval_skip_value (exp
);
1695 if (binop_user_defined_p (op
, arg1
, arg2
))
1697 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1701 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1702 int tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1703 struct type
*type
= language_bool_type (exp
->language_defn
,
1705 return value_from_longest (type
, (LONGEST
) tem
);
1709 /* A helper function for BINOP_LEQ. */
1711 static struct value
*
1712 eval_op_leq (struct type
*expect_type
, struct expression
*exp
,
1713 enum noside noside
, enum exp_opcode op
,
1714 struct value
*arg1
, struct value
*arg2
)
1716 if (noside
== EVAL_SKIP
)
1717 return eval_skip_value (exp
);
1718 if (binop_user_defined_p (op
, arg1
, arg2
))
1720 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1724 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1725 int tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1726 struct type
*type
= language_bool_type (exp
->language_defn
,
1728 return value_from_longest (type
, (LONGEST
) tem
);
1732 /* A helper function for BINOP_REPEAT. */
1734 static struct value
*
1735 eval_op_repeat (struct type
*expect_type
, struct expression
*exp
,
1737 struct value
*arg1
, struct value
*arg2
)
1739 if (noside
== EVAL_SKIP
)
1740 return eval_skip_value (exp
);
1741 struct type
*type
= check_typedef (value_type (arg2
));
1742 if (type
->code () != TYPE_CODE_INT
1743 && type
->code () != TYPE_CODE_ENUM
)
1744 error (_("Non-integral right operand for \"@\" operator."));
1745 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1747 return allocate_repeat_value (value_type (arg1
),
1748 longest_to_int (value_as_long (arg2
)));
1751 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1754 /* A helper function for UNOP_PLUS. */
1756 static struct value
*
1757 eval_op_plus (struct type
*expect_type
, struct expression
*exp
,
1758 enum noside noside
, enum exp_opcode op
,
1761 if (noside
== EVAL_SKIP
)
1762 return eval_skip_value (exp
);
1763 if (unop_user_defined_p (op
, arg1
))
1764 return value_x_unop (arg1
, op
, noside
);
1767 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1768 return value_pos (arg1
);
1772 /* A helper function for UNOP_NEG. */
1774 static struct value
*
1775 eval_op_neg (struct type
*expect_type
, struct expression
*exp
,
1776 enum noside noside
, enum exp_opcode op
,
1779 if (noside
== EVAL_SKIP
)
1780 return eval_skip_value (exp
);
1781 if (unop_user_defined_p (op
, arg1
))
1782 return value_x_unop (arg1
, op
, noside
);
1785 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1786 return value_neg (arg1
);
1790 /* A helper function for UNOP_COMPLEMENT. */
1792 static struct value
*
1793 eval_op_complement (struct type
*expect_type
, struct expression
*exp
,
1794 enum noside noside
, enum exp_opcode op
,
1797 if (noside
== EVAL_SKIP
)
1798 return eval_skip_value (exp
);
1799 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1800 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1803 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1804 return value_complement (arg1
);
1808 /* A helper function for UNOP_LOGICAL_NOT. */
1810 static struct value
*
1811 eval_op_lognot (struct type
*expect_type
, struct expression
*exp
,
1812 enum noside noside
, enum exp_opcode op
,
1815 if (noside
== EVAL_SKIP
)
1816 return eval_skip_value (exp
);
1817 if (unop_user_defined_p (op
, arg1
))
1818 return value_x_unop (arg1
, op
, noside
);
1821 struct type
*type
= language_bool_type (exp
->language_defn
,
1823 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
1827 /* A helper function for UNOP_IND. */
1829 static struct value
*
1830 eval_op_ind (struct type
*expect_type
, struct expression
*exp
,
1831 enum noside noside
, enum exp_opcode op
,
1834 struct type
*type
= check_typedef (value_type (arg1
));
1835 if (type
->code () == TYPE_CODE_METHODPTR
1836 || type
->code () == TYPE_CODE_MEMBERPTR
)
1837 error (_("Attempt to dereference pointer "
1838 "to member without an object"));
1839 if (noside
== EVAL_SKIP
)
1840 return eval_skip_value (exp
);
1841 if (unop_user_defined_p (op
, arg1
))
1842 return value_x_unop (arg1
, op
, noside
);
1843 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1845 type
= check_typedef (value_type (arg1
));
1847 /* If the type pointed to is dynamic then in order to resolve the
1848 dynamic properties we must actually dereference the pointer.
1849 There is a risk that this dereference will have side-effects
1850 in the inferior, but being able to print accurate type
1851 information seems worth the risk. */
1852 if ((type
->code () != TYPE_CODE_PTR
1853 && !TYPE_IS_REFERENCE (type
))
1854 || !is_dynamic_type (TYPE_TARGET_TYPE (type
)))
1856 if (type
->code () == TYPE_CODE_PTR
1857 || TYPE_IS_REFERENCE (type
)
1858 /* In C you can dereference an array to get the 1st elt. */
1859 || type
->code () == TYPE_CODE_ARRAY
)
1860 return value_zero (TYPE_TARGET_TYPE (type
),
1862 else if (type
->code () == TYPE_CODE_INT
)
1863 /* GDB allows dereferencing an int. */
1864 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1867 error (_("Attempt to take contents of a non-pointer value."));
1871 /* Allow * on an integer so we can cast it to whatever we want.
1872 This returns an int, which seems like the most C-like thing to
1873 do. "long long" variables are rare enough that
1874 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
1875 if (type
->code () == TYPE_CODE_INT
)
1876 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
1877 (CORE_ADDR
) value_as_address (arg1
));
1878 return value_ind (arg1
);
1881 /* A helper function for UNOP_ALIGNOF. */
1883 static struct value
*
1884 eval_op_alignof (struct type
*expect_type
, struct expression
*exp
,
1888 struct type
*type
= value_type (arg1
);
1889 /* FIXME: This should be size_t. */
1890 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
1891 ULONGEST align
= type_align (type
);
1893 error (_("could not determine alignment of type"));
1894 return value_from_longest (size_type
, align
);
1897 /* A helper function for UNOP_MEMVAL. */
1899 static struct value
*
1900 eval_op_memval (struct type
*expect_type
, struct expression
*exp
,
1902 struct value
*arg1
, struct type
*type
)
1904 if (noside
== EVAL_SKIP
)
1905 return eval_skip_value (exp
);
1906 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1907 return value_zero (type
, lval_memory
);
1909 return value_at_lazy (type
, value_as_address (arg1
));
1912 /* A helper function for UNOP_PREINCREMENT. */
1914 static struct value
*
1915 eval_op_preinc (struct type
*expect_type
, struct expression
*exp
,
1916 enum noside noside
, enum exp_opcode op
,
1919 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1921 else if (unop_user_defined_p (op
, arg1
))
1923 return value_x_unop (arg1
, op
, noside
);
1928 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
1929 arg2
= value_ptradd (arg1
, 1);
1932 struct value
*tmp
= arg1
;
1934 arg2
= value_one (value_type (arg1
));
1935 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1936 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
1939 return value_assign (arg1
, arg2
);
1943 /* A helper function for UNOP_PREDECREMENT. */
1945 static struct value
*
1946 eval_op_predec (struct type
*expect_type
, struct expression
*exp
,
1947 enum noside noside
, enum exp_opcode op
,
1950 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1952 else if (unop_user_defined_p (op
, arg1
))
1954 return value_x_unop (arg1
, op
, noside
);
1959 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
1960 arg2
= value_ptradd (arg1
, -1);
1963 struct value
*tmp
= arg1
;
1965 arg2
= value_one (value_type (arg1
));
1966 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1967 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
1970 return value_assign (arg1
, arg2
);
1974 /* A helper function for UNOP_POSTINCREMENT. */
1976 static struct value
*
1977 eval_op_postinc (struct type
*expect_type
, struct expression
*exp
,
1978 enum noside noside
, enum exp_opcode op
,
1981 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1983 else if (unop_user_defined_p (op
, arg1
))
1985 return value_x_unop (arg1
, op
, noside
);
1989 struct value
*arg3
= value_non_lval (arg1
);
1992 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
1993 arg2
= value_ptradd (arg1
, 1);
1996 struct value
*tmp
= arg1
;
1998 arg2
= value_one (value_type (arg1
));
1999 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2000 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2003 value_assign (arg1
, arg2
);
2008 /* A helper function for UNOP_POSTDECREMENT. */
2010 static struct value
*
2011 eval_op_postdec (struct type
*expect_type
, struct expression
*exp
,
2012 enum noside noside
, enum exp_opcode op
,
2015 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2017 else if (unop_user_defined_p (op
, arg1
))
2019 return value_x_unop (arg1
, op
, noside
);
2023 struct value
*arg3
= value_non_lval (arg1
);
2026 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2027 arg2
= value_ptradd (arg1
, -1);
2030 struct value
*tmp
= arg1
;
2032 arg2
= value_one (value_type (arg1
));
2033 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2034 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2037 value_assign (arg1
, arg2
);
2042 /* A helper function for OP_TYPE. */
2044 static struct value
*
2045 eval_op_type (struct type
*expect_type
, struct expression
*exp
,
2046 enum noside noside
, struct type
*type
)
2048 if (noside
== EVAL_SKIP
)
2049 return eval_skip_value (exp
);
2050 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2051 return allocate_value (type
);
2053 error (_("Attempt to use a type name as an expression"));
2056 /* A helper function for BINOP_ASSIGN_MODIFY. */
2058 static struct value
*
2059 eval_binop_assign_modify (struct type
*expect_type
, struct expression
*exp
,
2060 enum noside noside
, enum exp_opcode op
,
2061 struct value
*arg1
, struct value
*arg2
)
2063 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2065 if (binop_user_defined_p (op
, arg1
, arg2
))
2066 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2067 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2069 && is_integral_type (value_type (arg2
)))
2070 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2071 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2073 && is_integral_type (value_type (arg2
)))
2074 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2077 struct value
*tmp
= arg1
;
2079 /* For shift and integer exponentiation operations,
2080 only promote the first argument. */
2081 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2082 && is_integral_type (value_type (arg2
)))
2083 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2085 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2087 arg2
= value_binop (tmp
, arg2
, op
);
2089 return value_assign (arg1
, arg2
);
2092 /* Note that ARGS needs 2 empty slots up front and must end with a
2094 static struct value
*
2095 eval_op_objc_msgcall (struct type
*expect_type
, struct expression
*exp
,
2096 enum noside noside
, CORE_ADDR selector
,
2097 value
*target
, gdb::array_view
<value
*> args
)
2099 CORE_ADDR responds_selector
= 0;
2100 CORE_ADDR method_selector
= 0;
2102 int struct_return
= 0;
2104 struct value
*msg_send
= NULL
;
2105 struct value
*msg_send_stret
= NULL
;
2106 int gnu_runtime
= 0;
2108 struct value
*method
= NULL
;
2109 struct value
*called_method
= NULL
;
2111 struct type
*selector_type
= NULL
;
2112 struct type
*long_type
;
2115 struct value
*ret
= NULL
;
2120 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2121 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2123 if (value_as_long (target
) == 0)
2124 return value_from_longest (long_type
, 0);
2126 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
2129 /* Find the method dispatch (Apple runtime) or method lookup
2130 (GNU runtime) function for Objective-C. These will be used
2131 to lookup the symbol information for the method. If we
2132 can't find any symbol information, then we'll use these to
2133 call the method, otherwise we can call the method
2134 directly. The msg_send_stret function is used in the special
2135 case of a method that returns a structure (Apple runtime
2139 type
= selector_type
;
2141 type
= lookup_function_type (type
);
2142 type
= lookup_pointer_type (type
);
2143 type
= lookup_function_type (type
);
2144 type
= lookup_pointer_type (type
);
2146 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
2148 = find_function_in_inferior ("objc_msg_lookup", NULL
);
2150 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
2151 msg_send_stret
= value_from_pointer (type
,
2152 value_as_address (msg_send_stret
));
2156 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
2157 /* Special dispatcher for methods returning structs. */
2159 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
2162 /* Verify the target object responds to this method. The
2163 standard top-level 'Object' class uses a different name for
2164 the verification method than the non-standard, but more
2165 often used, 'NSObject' class. Make sure we check for both. */
2168 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
2169 if (responds_selector
== 0)
2171 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
2173 if (responds_selector
== 0)
2174 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
2177 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
2178 if (method_selector
== 0)
2180 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
2182 if (method_selector
== 0)
2183 error (_("no 'methodFor:' or 'methodForSelector:' method"));
2185 /* Call the verification method, to make sure that the target
2186 class implements the desired method. */
2188 argvec
[0] = msg_send
;
2190 argvec
[2] = value_from_longest (long_type
, responds_selector
);
2191 argvec
[3] = value_from_longest (long_type
, selector
);
2194 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2197 /* Function objc_msg_lookup returns a pointer. */
2199 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2201 if (value_as_long (ret
) == 0)
2202 error (_("Target does not respond to this message selector."));
2204 /* Call "methodForSelector:" method, to get the address of a
2205 function method that implements this selector for this
2206 class. If we can find a symbol at that address, then we
2207 know the return type, parameter types etc. (that's a good
2210 argvec
[0] = msg_send
;
2212 argvec
[2] = value_from_longest (long_type
, method_selector
);
2213 argvec
[3] = value_from_longest (long_type
, selector
);
2216 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2220 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2223 /* ret should now be the selector. */
2225 addr
= value_as_long (ret
);
2228 struct symbol
*sym
= NULL
;
2230 /* The address might point to a function descriptor;
2231 resolve it to the actual code address instead. */
2232 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
2233 current_top_target ());
2235 /* Is it a high_level symbol? */
2236 sym
= find_pc_function (addr
);
2238 method
= value_of_variable (sym
, 0);
2241 /* If we found a method with symbol information, check to see
2242 if it returns a struct. Otherwise assume it doesn't. */
2247 struct type
*val_type
;
2249 funaddr
= find_function_addr (method
, &val_type
);
2251 block_for_pc (funaddr
);
2253 val_type
= check_typedef (val_type
);
2255 if ((val_type
== NULL
)
2256 || (val_type
->code () == TYPE_CODE_ERROR
))
2258 if (expect_type
!= NULL
)
2259 val_type
= expect_type
;
2262 struct_return
= using_struct_return (exp
->gdbarch
, method
,
2265 else if (expect_type
!= NULL
)
2267 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
2268 check_typedef (expect_type
));
2271 /* Found a function symbol. Now we will substitute its
2272 value in place of the message dispatcher (obj_msgSend),
2273 so that we call the method directly instead of thru
2274 the dispatcher. The main reason for doing this is that
2275 we can now evaluate the return value and parameter values
2276 according to their known data types, in case we need to
2277 do things like promotion, dereferencing, special handling
2278 of structs and doubles, etc.
2280 We want to use the type signature of 'method', but still
2281 jump to objc_msgSend() or objc_msgSend_stret() to better
2282 mimic the behavior of the runtime. */
2286 if (value_type (method
)->code () != TYPE_CODE_FUNC
)
2287 error (_("method address has symbol information "
2288 "with non-function type; skipping"));
2290 /* Create a function pointer of the appropriate type, and
2291 replace its value with the value of msg_send or
2292 msg_send_stret. We must use a pointer here, as
2293 msg_send and msg_send_stret are of pointer type, and
2294 the representation may be different on systems that use
2295 function descriptors. */
2298 = value_from_pointer (lookup_pointer_type (value_type (method
)),
2299 value_as_address (msg_send_stret
));
2302 = value_from_pointer (lookup_pointer_type (value_type (method
)),
2303 value_as_address (msg_send
));
2308 called_method
= msg_send_stret
;
2310 called_method
= msg_send
;
2313 if (noside
== EVAL_SKIP
)
2314 return eval_skip_value (exp
);
2316 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2318 /* If the return type doesn't look like a function type,
2319 call an error. This can happen if somebody tries to
2320 turn a variable into a function call. This is here
2321 because people often want to call, eg, strcmp, which
2322 gdb doesn't know is a function. If gdb isn't asked for
2323 it's opinion (ie. through "whatis"), it won't offer
2326 struct type
*callee_type
= value_type (called_method
);
2328 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
2329 callee_type
= TYPE_TARGET_TYPE (callee_type
);
2330 callee_type
= TYPE_TARGET_TYPE (callee_type
);
2334 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
2335 return allocate_value (expect_type
);
2337 return allocate_value (callee_type
);
2340 error (_("Expression of type other than "
2341 "\"method returning ...\" used as a method"));
2344 /* Now depending on whether we found a symbol for the method,
2345 we will either call the runtime dispatcher or the method
2349 args
[1] = value_from_longest (long_type
, selector
);
2351 if (gnu_runtime
&& (method
!= NULL
))
2353 /* Function objc_msg_lookup returns a pointer. */
2354 struct type
*tem_type
= value_type (called_method
);
2355 tem_type
= lookup_pointer_type (lookup_function_type (tem_type
));
2356 deprecated_set_value_type (called_method
, tem_type
);
2357 called_method
= call_function_by_hand (called_method
, NULL
, args
);
2360 return call_function_by_hand (called_method
, NULL
, args
);
2363 /* Helper function for MULTI_SUBSCRIPT. */
2365 static struct value
*
2366 eval_multi_subscript (struct type
*expect_type
, struct expression
*exp
,
2367 enum noside noside
, value
*arg1
,
2368 gdb::array_view
<value
*> args
)
2370 if (noside
== EVAL_SKIP
)
2372 for (value
*arg2
: args
)
2374 if (binop_user_defined_p (MULTI_SUBSCRIPT
, arg1
, arg2
))
2376 arg1
= value_x_binop (arg1
, arg2
, MULTI_SUBSCRIPT
, OP_NULL
, noside
);
2380 arg1
= coerce_ref (arg1
);
2381 struct type
*type
= check_typedef (value_type (arg1
));
2383 switch (type
->code ())
2386 case TYPE_CODE_ARRAY
:
2387 case TYPE_CODE_STRING
:
2388 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2393 error (_("cannot subscript something of type `%s'"),
2396 error (_("cannot subscript requested type"));
2404 evaluate_subexp_standard (struct type
*expect_type
,
2405 struct expression
*exp
, int *pos
,
2409 int tem
, tem2
, tem3
;
2411 struct value
*arg1
= NULL
;
2412 struct value
*arg2
= NULL
;
2415 struct value
**argvec
;
2417 struct type
**arg_types
;
2420 op
= exp
->elts
[pc
].opcode
;
2425 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2426 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
2427 return eval_op_scope (expect_type
, exp
, noside
,
2428 exp
->elts
[pc
+ 1].type
,
2429 &exp
->elts
[pc
+ 3].string
);
2433 return value_from_longest (exp
->elts
[pc
+ 1].type
,
2434 exp
->elts
[pc
+ 2].longconst
);
2438 return value_from_contents (exp
->elts
[pc
+ 1].type
,
2439 exp
->elts
[pc
+ 2].floatconst
);
2445 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
2446 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
2447 error_unknown_type (var
->print_name ());
2448 if (noside
!= EVAL_SKIP
)
2449 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
2452 /* Return a dummy value of the correct type when skipping, so
2453 that parent functions know what is to be skipped. */
2454 return allocate_value (SYMBOL_TYPE (var
));
2458 case OP_VAR_MSYM_VALUE
:
2462 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
2463 return eval_op_var_msym_value (expect_type
, exp
, noside
,
2465 exp
->elts
[pc
+ 1].objfile
);
2468 case OP_VAR_ENTRY_VALUE
:
2472 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
2474 return eval_op_var_entry_value (expect_type
, exp
, noside
, sym
);
2477 case OP_FUNC_STATIC_VAR
:
2478 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2479 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2480 if (noside
== EVAL_SKIP
)
2481 return eval_skip_value (exp
);
2484 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
2486 return eval_op_func_static_var (expect_type
, exp
, noside
, func
,
2487 &exp
->elts
[pc
+ 2].string
);
2493 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
2497 const char *name
= &exp
->elts
[pc
+ 2].string
;
2499 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
2500 return eval_op_register (expect_type
, exp
, noside
, name
);
2504 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2505 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
2507 case OP_INTERNALVAR
:
2509 return value_of_internalvar (exp
->gdbarch
,
2510 exp
->elts
[pc
+ 1].internalvar
);
2513 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2514 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2515 return eval_op_string (expect_type
, exp
, noside
, tem
,
2516 &exp
->elts
[pc
+ 2].string
);
2518 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
2519 NSString constant. */
2520 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2521 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2522 if (noside
== EVAL_SKIP
)
2523 return eval_skip_value (exp
);
2524 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
2528 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2529 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2530 nargs
= tem3
- tem2
+ 1;
2531 type
= expect_type
? check_typedef (expect_type
) : nullptr;
2533 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2534 && type
->code () == TYPE_CODE_STRUCT
)
2536 struct value
*rec
= allocate_value (expect_type
);
2538 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
2539 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
2542 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2543 && type
->code () == TYPE_CODE_ARRAY
)
2545 struct type
*range_type
= type
->index_type ();
2546 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
2547 struct value
*array
= allocate_value (expect_type
);
2548 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
2549 LONGEST low_bound
, high_bound
, index
;
2551 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
2554 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
2557 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
2558 for (tem
= nargs
; --nargs
>= 0;)
2560 struct value
*element
;
2562 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
2563 if (value_type (element
) != element_type
)
2564 element
= value_cast (element_type
, element
);
2565 if (index
> high_bound
)
2566 /* To avoid memory corruption. */
2567 error (_("Too many array elements"));
2568 memcpy (value_contents_raw (array
)
2569 + (index
- low_bound
) * element_size
,
2570 value_contents (element
),
2577 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2578 && type
->code () == TYPE_CODE_SET
)
2580 struct value
*set
= allocate_value (expect_type
);
2581 gdb_byte
*valaddr
= value_contents_raw (set
);
2582 struct type
*element_type
= type
->index_type ();
2583 struct type
*check_type
= element_type
;
2584 LONGEST low_bound
, high_bound
;
2586 /* Get targettype of elementtype. */
2587 while (check_type
->code () == TYPE_CODE_RANGE
2588 || check_type
->code () == TYPE_CODE_TYPEDEF
)
2589 check_type
= TYPE_TARGET_TYPE (check_type
);
2591 if (!get_discrete_bounds (element_type
, &low_bound
, &high_bound
))
2592 error (_("(power)set type with unknown size"));
2593 memset (valaddr
, '\0', TYPE_LENGTH (type
));
2594 for (tem
= 0; tem
< nargs
; tem
++)
2596 LONGEST range_low
, range_high
;
2597 struct type
*range_low_type
, *range_high_type
;
2598 struct value
*elem_val
;
2600 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
2601 range_low_type
= range_high_type
= value_type (elem_val
);
2602 range_low
= range_high
= value_as_long (elem_val
);
2604 /* Check types of elements to avoid mixture of elements from
2605 different types. Also check if type of element is "compatible"
2606 with element type of powerset. */
2607 if (range_low_type
->code () == TYPE_CODE_RANGE
)
2608 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
2609 if (range_high_type
->code () == TYPE_CODE_RANGE
)
2610 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
2611 if ((range_low_type
->code () != range_high_type
->code ())
2612 || (range_low_type
->code () == TYPE_CODE_ENUM
2613 && (range_low_type
!= range_high_type
)))
2614 /* different element modes. */
2615 error (_("POWERSET tuple elements of different mode"));
2616 if ((check_type
->code () != range_low_type
->code ())
2617 || (check_type
->code () == TYPE_CODE_ENUM
2618 && range_low_type
!= check_type
))
2619 error (_("incompatible POWERSET tuple elements"));
2620 if (range_low
> range_high
)
2622 warning (_("empty POWERSET tuple range"));
2625 if (range_low
< low_bound
|| range_high
> high_bound
)
2626 error (_("POWERSET tuple element out of range"));
2627 range_low
-= low_bound
;
2628 range_high
-= low_bound
;
2629 for (; range_low
<= range_high
; range_low
++)
2631 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
2633 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
2634 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
2635 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
2642 argvec
= XALLOCAVEC (struct value
*, nargs
);
2643 for (tem
= 0; tem
< nargs
; tem
++)
2645 /* Ensure that array expressions are coerced into pointer
2647 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
2649 if (noside
== EVAL_SKIP
)
2650 return eval_skip_value (exp
);
2651 return value_array (tem2
, tem3
, argvec
);
2655 struct value
*array
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2656 struct value
*low
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2657 struct value
*upper
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2658 return eval_op_ternop (expect_type
, exp
, noside
, array
, low
, upper
);
2662 /* Skip third and second args to evaluate the first one. */
2663 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2664 if (value_logical_not (arg1
))
2666 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2667 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2671 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2672 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2676 case OP_OBJC_SELECTOR
:
2677 { /* Objective C @selector operator. */
2678 char *sel
= &exp
->elts
[pc
+ 2].string
;
2679 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2681 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
2683 sel
[len
] = 0; /* Make sure it's terminated. */
2685 return eval_op_objc_selector (expect_type
, exp
, noside
, sel
);
2688 case OP_OBJC_MSGCALL
:
2689 { /* Objective C message (method) call. */
2690 CORE_ADDR selector
= 0;
2692 enum noside sub_no_side
= EVAL_NORMAL
;
2694 struct value
*target
= NULL
;
2696 struct type
*selector_type
= NULL
;
2698 selector
= exp
->elts
[pc
+ 1].longconst
;
2699 nargs
= exp
->elts
[pc
+ 2].longconst
;
2700 argvec
= XALLOCAVEC (struct value
*, nargs
+ 3);
2704 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2706 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2707 sub_no_side
= EVAL_NORMAL
;
2709 sub_no_side
= noside
;
2711 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
2713 if (value_as_long (target
) == 0)
2714 sub_no_side
= EVAL_SKIP
;
2716 sub_no_side
= noside
;
2718 /* Now depending on whether we found a symbol for the method,
2719 we will either call the runtime dispatcher or the method
2722 argvec
[0] = nullptr;
2723 argvec
[1] = nullptr;
2724 /* User-supplied arguments. */
2725 for (tem
= 0; tem
< nargs
; tem
++)
2726 argvec
[tem
+ 2] = evaluate_subexp_with_coercion (exp
, pos
,
2728 argvec
[tem
+ 3] = 0;
2730 auto call_args
= gdb::make_array_view (argvec
, nargs
+ 3);
2732 return eval_op_objc_msgcall (expect_type
, exp
, noside
, selector
,
2738 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
2741 /* We have a complex number, There should be 2 floating
2742 point numbers that compose it. */
2744 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2745 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2747 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
2749 case STRUCTOP_STRUCT
:
2750 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2751 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2752 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2753 return eval_op_structop_struct (expect_type
, exp
, noside
, arg1
,
2754 &exp
->elts
[pc
+ 2].string
);
2757 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2758 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2759 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2760 return eval_op_structop_ptr (expect_type
, exp
, noside
, op
, arg1
,
2761 &exp
->elts
[pc
+ 2].string
);
2763 case STRUCTOP_MEMBER
:
2765 if (op
== STRUCTOP_MEMBER
)
2766 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2768 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2770 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2772 return eval_op_member (expect_type
, exp
, noside
, arg1
, arg2
);
2776 type_instance_flags flags
2777 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2778 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2779 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2780 for (ix
= 0; ix
< nargs
; ++ix
)
2781 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2783 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
2784 *(pos
) += 4 + nargs
;
2785 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
2790 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2791 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2792 return eval_op_concat (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2795 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2796 /* Special-case assignments where the left-hand-side is a
2797 convenience variable -- in these, don't bother setting an
2798 expected type. This avoids a weird case where re-assigning a
2799 string or array to an internal variable could error with "Too
2800 many array elements". */
2801 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
2803 : value_type (arg1
),
2806 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2808 if (binop_user_defined_p (op
, arg1
, arg2
))
2809 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2811 return value_assign (arg1
, arg2
);
2813 case BINOP_ASSIGN_MODIFY
:
2815 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2816 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2817 op
= exp
->elts
[pc
+ 1].opcode
;
2818 return eval_binop_assign_modify (expect_type
, exp
, noside
, op
,
2822 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2823 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2824 return eval_op_add (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2827 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2828 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2829 return eval_op_sub (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2839 case BINOP_BITWISE_AND
:
2840 case BINOP_BITWISE_IOR
:
2841 case BINOP_BITWISE_XOR
:
2842 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2843 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2844 return eval_op_binary (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2846 case BINOP_SUBSCRIPT
:
2847 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2848 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2849 return eval_op_subscript (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2851 case MULTI_SUBSCRIPT
:
2853 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2854 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2855 argvec
= XALLOCAVEC (struct value
*, nargs
);
2856 for (ix
= 0; ix
< nargs
; ++ix
)
2857 argvec
[ix
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
2858 return eval_multi_subscript (expect_type
, exp
, noside
, arg1
,
2859 gdb::make_array_view (argvec
, nargs
));
2861 case BINOP_LOGICAL_AND
:
2862 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2863 if (noside
== EVAL_SKIP
)
2865 evaluate_subexp (nullptr, exp
, pos
, noside
);
2866 return eval_skip_value (exp
);
2870 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2873 if (binop_user_defined_p (op
, arg1
, arg2
))
2875 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2876 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2880 tem
= value_logical_not (arg1
);
2882 = evaluate_subexp (nullptr, exp
, pos
, (tem
? EVAL_SKIP
: noside
));
2883 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2884 return value_from_longest (type
,
2885 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2888 case BINOP_LOGICAL_OR
:
2889 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2890 if (noside
== EVAL_SKIP
)
2892 evaluate_subexp (nullptr, exp
, pos
, noside
);
2893 return eval_skip_value (exp
);
2897 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2900 if (binop_user_defined_p (op
, arg1
, arg2
))
2902 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2903 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2907 tem
= value_logical_not (arg1
);
2909 = evaluate_subexp (nullptr, exp
, pos
, (!tem
? EVAL_SKIP
: noside
));
2910 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2911 return value_from_longest (type
,
2912 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2916 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2917 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2918 return eval_op_equal (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2920 case BINOP_NOTEQUAL
:
2921 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2922 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2923 return eval_op_notequal (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2926 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2927 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2928 return eval_op_less (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2931 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2932 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2933 return eval_op_gtr (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2936 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2937 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2938 return eval_op_geq (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2941 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2942 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2943 return eval_op_leq (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2946 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2947 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2948 return eval_op_repeat (expect_type
, exp
, noside
, arg1
, arg2
);
2951 evaluate_subexp (nullptr, exp
, pos
, noside
);
2952 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2955 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2956 return eval_op_plus (expect_type
, exp
, noside
, op
, arg1
);
2959 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2960 return eval_op_neg (expect_type
, exp
, noside
, op
, arg1
);
2962 case UNOP_COMPLEMENT
:
2963 /* C++: check for and handle destructor names. */
2965 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2966 return eval_op_complement (expect_type
, exp
, noside
, op
, arg1
);
2968 case UNOP_LOGICAL_NOT
:
2969 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2970 return eval_op_lognot (expect_type
, exp
, noside
, op
, arg1
);
2973 if (expect_type
&& expect_type
->code () == TYPE_CODE_PTR
)
2974 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2975 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2976 return eval_op_ind (expect_type
, exp
, noside
, op
, arg1
);
2979 /* C++: check for and handle pointer to members. */
2981 if (noside
== EVAL_SKIP
)
2983 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2984 return eval_skip_value (exp
);
2987 return evaluate_subexp_for_address (exp
, pos
, noside
);
2990 if (noside
== EVAL_SKIP
)
2992 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2993 return eval_skip_value (exp
);
2995 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2998 arg1
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2999 return eval_op_alignof (expect_type
, exp
, noside
, arg1
);
3003 type
= exp
->elts
[pc
+ 1].type
;
3004 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
3006 case UNOP_CAST_TYPE
:
3007 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3008 type
= value_type (arg1
);
3009 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
3011 case UNOP_DYNAMIC_CAST
:
3012 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3013 type
= value_type (arg1
);
3014 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
3015 if (noside
== EVAL_SKIP
)
3016 return eval_skip_value (exp
);
3017 return value_dynamic_cast (type
, arg1
);
3019 case UNOP_REINTERPRET_CAST
:
3020 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3021 type
= value_type (arg1
);
3022 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
3023 if (noside
== EVAL_SKIP
)
3024 return eval_skip_value (exp
);
3025 return value_reinterpret_cast (type
, arg1
);
3029 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3030 return eval_op_memval (expect_type
, exp
, noside
, arg1
,
3031 exp
->elts
[pc
+ 1].type
);
3033 case UNOP_MEMVAL_TYPE
:
3034 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3035 type
= value_type (arg1
);
3036 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3037 return eval_op_memval (expect_type
, exp
, noside
, arg1
, type
);
3039 case UNOP_PREINCREMENT
:
3040 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3041 return eval_op_preinc (expect_type
, exp
, noside
, op
, arg1
);
3043 case UNOP_PREDECREMENT
:
3044 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3045 return eval_op_predec (expect_type
, exp
, noside
, op
, arg1
);
3047 case UNOP_POSTINCREMENT
:
3048 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3049 return eval_op_postinc (expect_type
, exp
, noside
, op
, arg1
);
3051 case UNOP_POSTDECREMENT
:
3052 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3053 return eval_op_postdec (expect_type
, exp
, noside
, op
, arg1
);
3057 return value_of_this (exp
->language_defn
);
3060 /* The value is not supposed to be used. This is here to make it
3061 easier to accommodate expressions that contain types. */
3063 return eval_op_type (expect_type
, exp
, noside
, exp
->elts
[pc
+ 1].type
);
3067 if (noside
== EVAL_SKIP
)
3069 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
3070 return eval_skip_value (exp
);
3072 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3074 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
3075 struct value
*result
;
3077 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3079 /* 'decltype' has special semantics for lvalues. */
3080 if (op
== OP_DECLTYPE
3081 && (sub_op
== BINOP_SUBSCRIPT
3082 || sub_op
== STRUCTOP_MEMBER
3083 || sub_op
== STRUCTOP_MPTR
3084 || sub_op
== UNOP_IND
3085 || sub_op
== STRUCTOP_STRUCT
3086 || sub_op
== STRUCTOP_PTR
3087 || sub_op
== OP_SCOPE
))
3089 type
= value_type (result
);
3091 if (!TYPE_IS_REFERENCE (type
))
3093 type
= lookup_lvalue_reference_type (type
);
3094 result
= allocate_value (type
);
3101 error (_("Attempt to use a type as an expression"));
3105 struct value
*result
;
3106 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
3108 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
3109 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3111 result
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3113 if (noside
!= EVAL_NORMAL
)
3114 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
3116 return cplus_typeid (result
);
3120 /* Removing this case and compiling with gcc -Wall reveals that
3121 a lot of cases are hitting this case. Some of these should
3122 probably be removed from expression.h; others are legitimate
3123 expressions which are (apparently) not fully implemented.
3125 If there are any cases landing here which mean a user error,
3126 then they should be separate cases, with more descriptive
3129 error (_("GDB does not (yet) know how to "
3130 "evaluate that kind of expression"));
3133 gdb_assert_not_reached ("missed return?");
3136 /* Helper for evaluate_subexp_for_address. */
3139 evaluate_subexp_for_address_base (struct expression
*exp
, enum noside noside
,
3142 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3144 struct type
*type
= check_typedef (value_type (x
));
3146 if (TYPE_IS_REFERENCE (type
))
3147 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3149 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3150 return value_zero (lookup_pointer_type (value_type (x
)),
3153 error (_("Attempt to take address of "
3154 "value not located in memory."));
3156 return value_addr (x
);
3159 /* Evaluate a subexpression of EXP, at index *POS,
3160 and return the address of that subexpression.
3161 Advance *POS over the subexpression.
3162 If the subexpression isn't an lvalue, get an error.
3163 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
3164 then only the type of the result need be correct. */
3166 static struct value
*
3167 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
3177 op
= exp
->elts
[pc
].opcode
;
3183 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3185 /* We can't optimize out "&*" if there's a user-defined operator*. */
3186 if (unop_user_defined_p (op
, x
))
3188 x
= value_x_unop (x
, op
, noside
);
3189 goto default_case_after_eval
;
3192 return coerce_array (x
);
3196 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
3197 evaluate_subexp (nullptr, exp
, pos
, noside
));
3199 case UNOP_MEMVAL_TYPE
:
3204 x
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3205 type
= value_type (x
);
3206 return value_cast (lookup_pointer_type (type
),
3207 evaluate_subexp (nullptr, exp
, pos
, noside
));
3211 var
= exp
->elts
[pc
+ 2].symbol
;
3213 /* C++: The "address" of a reference should yield the address
3214 * of the object pointed to. Let value_addr() deal with it. */
3215 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
3219 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3222 lookup_pointer_type (SYMBOL_TYPE (var
));
3223 enum address_class sym_class
= SYMBOL_CLASS (var
);
3225 if (sym_class
== LOC_CONST
3226 || sym_class
== LOC_CONST_BYTES
3227 || sym_class
== LOC_REGISTER
)
3228 error (_("Attempt to take address of register or constant."));
3231 value_zero (type
, not_lval
);
3234 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3236 case OP_VAR_MSYM_VALUE
:
3240 value
*val
= evaluate_var_msym_value (noside
,
3241 exp
->elts
[pc
+ 1].objfile
,
3242 exp
->elts
[pc
+ 2].msymbol
);
3243 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3245 struct type
*type
= lookup_pointer_type (value_type (val
));
3246 return value_zero (type
, not_lval
);
3249 return value_addr (val
);
3253 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3254 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3255 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3256 &exp
->elts
[pc
+ 3].string
,
3259 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3264 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3265 default_case_after_eval
:
3266 return evaluate_subexp_for_address_base (exp
, noside
, x
);
3270 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3271 When used in contexts where arrays will be coerced anyway, this is
3272 equivalent to `evaluate_subexp' but much faster because it avoids
3273 actually fetching array contents (perhaps obsolete now that we have
3276 Note that we currently only do the coercion for C expressions, where
3277 arrays are zero based and the coercion is correct. For other languages,
3278 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3279 to decide if coercion is appropriate. */
3282 evaluate_subexp_with_coercion (struct expression
*exp
,
3283 int *pos
, enum noside noside
)
3292 op
= exp
->elts
[pc
].opcode
;
3297 var
= exp
->elts
[pc
+ 2].symbol
;
3298 type
= check_typedef (SYMBOL_TYPE (var
));
3299 if (type
->code () == TYPE_CODE_ARRAY
3300 && !type
->is_vector ()
3301 && CAST_IS_CONVERSION (exp
->language_defn
))
3304 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3305 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3311 return evaluate_subexp (nullptr, exp
, pos
, noside
);
3315 /* Helper function for evaluating the size of a type. */
3318 evaluate_subexp_for_sizeof_base (struct expression
*exp
, struct type
*type
)
3320 /* FIXME: This should be size_t. */
3321 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3322 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3323 "When applied to a reference or a reference type, the result is
3324 the size of the referenced type." */
3325 type
= check_typedef (type
);
3326 if (exp
->language_defn
->la_language
== language_cplus
3327 && (TYPE_IS_REFERENCE (type
)))
3328 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3329 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3332 /* Evaluate a subexpression of EXP, at index *POS,
3333 and return a value for the size of that subexpression.
3334 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3335 we allow side-effects on the operand if its type is a variable
3338 static struct value
*
3339 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3342 /* FIXME: This should be size_t. */
3343 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3350 op
= exp
->elts
[pc
].opcode
;
3354 /* This case is handled specially
3355 so that we avoid creating a value for the result type.
3356 If the result type is very big, it's desirable not to
3357 create a value unnecessarily. */
3360 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3361 type
= check_typedef (value_type (val
));
3362 if (type
->code () != TYPE_CODE_PTR
3363 && !TYPE_IS_REFERENCE (type
)
3364 && type
->code () != TYPE_CODE_ARRAY
)
3365 error (_("Attempt to take contents of a non-pointer value."));
3366 type
= TYPE_TARGET_TYPE (type
);
3367 if (is_dynamic_type (type
))
3368 type
= value_type (value_ind (val
));
3369 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3373 type
= exp
->elts
[pc
+ 1].type
;
3376 case UNOP_MEMVAL_TYPE
:
3378 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3379 type
= value_type (val
);
3383 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3384 if (is_dynamic_type (type
))
3386 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3387 type
= value_type (val
);
3388 if (type
->code () == TYPE_CODE_ARRAY
)
3390 if (type_not_allocated (type
) || type_not_associated (type
))
3391 return value_zero (size_type
, not_lval
);
3392 else if (is_dynamic_type (type
->index_type ())
3393 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
3394 return allocate_optimized_out_value (size_type
);
3401 case OP_VAR_MSYM_VALUE
:
3405 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3406 value
*mval
= evaluate_var_msym_value (noside
,
3407 exp
->elts
[pc
+ 1].objfile
,
3410 type
= value_type (mval
);
3411 if (type
->code () == TYPE_CODE_ERROR
)
3412 error_unknown_type (msymbol
->print_name ());
3414 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3418 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3419 type of the subscript is a variable length array type. In this case we
3420 must re-evaluate the right hand side of the subscription to allow
3422 case BINOP_SUBSCRIPT
:
3423 if (noside
== EVAL_NORMAL
)
3425 int npc
= (*pos
) + 1;
3427 val
= evaluate_subexp (nullptr, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3428 type
= check_typedef (value_type (val
));
3429 if (type
->code () == TYPE_CODE_ARRAY
)
3431 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3432 if (type
->code () == TYPE_CODE_ARRAY
)
3434 type
= type
->index_type ();
3435 /* Only re-evaluate the right hand side if the resulting type
3436 is a variable length type. */
3437 if (type
->bounds ()->flag_bound_evaluated
)
3439 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3440 return value_from_longest
3441 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3450 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3451 type
= value_type (val
);
3455 return evaluate_subexp_for_sizeof_base (exp
, type
);
3458 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3459 for that subexpression cast to TO_TYPE. Advance *POS over the
3463 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3465 struct type
*to_type
)
3469 /* Don't let symbols be evaluated with evaluate_subexp because that
3470 throws an "unknown type" error for no-debug data symbols.
3471 Instead, we want the cast to reinterpret the symbol. */
3472 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3473 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3478 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3480 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3481 return value_zero (to_type
, not_lval
);
3483 val
= evaluate_var_msym_value (noside
,
3484 exp
->elts
[pc
+ 1].objfile
,
3485 exp
->elts
[pc
+ 2].msymbol
);
3488 val
= evaluate_var_value (noside
,
3489 exp
->elts
[pc
+ 1].block
,
3490 exp
->elts
[pc
+ 2].symbol
);
3492 if (noside
== EVAL_SKIP
)
3493 return eval_skip_value (exp
);
3495 val
= value_cast (to_type
, val
);
3497 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3498 if (VALUE_LVAL (val
) == lval_memory
)
3500 if (value_lazy (val
))
3501 value_fetch_lazy (val
);
3502 VALUE_LVAL (val
) = not_lval
;
3507 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3508 if (noside
== EVAL_SKIP
)
3509 return eval_skip_value (exp
);
3510 return value_cast (to_type
, val
);
3513 /* Parse a type expression in the string [P..P+LENGTH). */
3516 parse_and_eval_type (const char *p
, int length
)
3518 char *tmp
= (char *) alloca (length
+ 4);
3521 memcpy (tmp
+ 1, p
, length
);
3522 tmp
[length
+ 1] = ')';
3523 tmp
[length
+ 2] = '0';
3524 tmp
[length
+ 3] = '\0';
3525 expression_up expr
= parse_expression (tmp
);
3526 if (expr
->first_opcode () != UNOP_CAST
)
3527 error (_("Internal error in eval_type."));
3528 return expr
->elts
[1].type
;