1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
27 #include "gdbthread.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
31 #include "objc-lang.h"
33 #include "parser-defs.h"
34 #include "cp-support.h"
37 #include "user-regs.h"
39 #include "gdb_obstack.h"
41 #include "typeprint.h"
46 /* Prototypes for local functions. */
48 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
51 static struct value
*evaluate_subexp_for_address (struct expression
*,
54 static value
*evaluate_subexp_for_cast (expression
*exp
, int *pos
,
58 static struct value
*evaluate_struct_tuple (struct value
*,
59 struct expression
*, int *,
63 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
64 int *pos
, enum noside noside
)
66 return ((*exp
->language_defn
->expression_ops ()->evaluate_exp
)
67 (expect_type
, exp
, pos
, noside
));
70 /* Parse the string EXP as a C expression, evaluate it,
71 and return the result as a number. */
74 parse_and_eval_address (const char *exp
)
76 expression_up expr
= parse_expression (exp
);
78 return value_as_address (evaluate_expression (expr
.get ()));
81 /* Like parse_and_eval_address, but treats the value of the expression
82 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
84 parse_and_eval_long (const char *exp
)
86 expression_up expr
= parse_expression (exp
);
88 return value_as_long (evaluate_expression (expr
.get ()));
92 parse_and_eval (const char *exp
)
94 expression_up expr
= parse_expression (exp
);
96 return evaluate_expression (expr
.get ());
99 /* Parse up to a comma (or to a closeparen)
100 in the string EXPP as an expression, evaluate it, and return the value.
101 EXPP is advanced to point to the comma. */
104 parse_to_comma_and_eval (const char **expp
)
106 expression_up expr
= parse_exp_1 (expp
, 0, nullptr, 1);
108 return evaluate_expression (expr
.get ());
112 /* See expression.h. */
115 expression::evaluate (struct type
*expect_type
, enum noside noside
)
117 gdb::optional
<enable_thread_stack_temporaries
> stack_temporaries
;
118 if (target_has_execution ()
119 && language_defn
->la_language
== language_cplus
120 && !thread_stack_temporaries_enabled_p (inferior_thread ()))
121 stack_temporaries
.emplace (inferior_thread ());
124 struct value
*retval
= evaluate_subexp (expect_type
, this, &pos
, noside
);
126 if (stack_temporaries
.has_value ()
127 && value_in_thread_stack_temporaries (retval
, inferior_thread ()))
128 retval
= value_non_lval (retval
);
136 evaluate_expression (struct expression
*exp
, struct type
*expect_type
)
138 return exp
->evaluate (expect_type
, EVAL_NORMAL
);
141 /* Evaluate an expression, avoiding all memory references
142 and getting a value whose type alone is correct. */
145 evaluate_type (struct expression
*exp
)
147 return exp
->evaluate (nullptr, EVAL_AVOID_SIDE_EFFECTS
);
150 /* Evaluate a subexpression, avoiding all memory references and
151 getting a value whose type alone is correct. */
154 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
156 return evaluate_subexp (nullptr, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
159 /* Find the current value of a watchpoint on EXP. Return the value in
160 *VALP and *RESULTP and the chain of intermediate and final values
161 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
164 If PRESERVE_ERRORS is true, then exceptions are passed through.
165 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
166 occurs while evaluating the expression, *RESULTP will be set to
167 NULL. *RESULTP may be a lazy value, if the result could not be
168 read from memory. It is used to determine whether a value is
169 user-specified (we should watch the whole value) or intermediate
170 (we should watch only the bit used to locate the final value).
172 If the final value, or any intermediate value, could not be read
173 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
174 set to any referenced values. *VALP will never be a lazy value.
175 This is the value which we store in struct breakpoint.
177 If VAL_CHAIN is non-NULL, the values put into *VAL_CHAIN will be
178 released from the value chain. If VAL_CHAIN is NULL, all generated
179 values will be left on the value chain. */
182 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
183 struct value
**resultp
,
184 std::vector
<value_ref_ptr
> *val_chain
,
185 bool preserve_errors
)
187 struct value
*mark
, *new_mark
, *result
;
195 /* Evaluate the expression. */
196 mark
= value_mark ();
201 result
= evaluate_subexp (nullptr, exp
, pc
, EVAL_NORMAL
);
203 catch (const gdb_exception
&ex
)
205 /* Ignore memory errors if we want watchpoints pointing at
206 inaccessible memory to still be created; otherwise, throw the
207 error to some higher catcher. */
211 if (!preserve_errors
)
220 new_mark
= value_mark ();
221 if (mark
== new_mark
)
226 /* Make sure it's not lazy, so that after the target stops again we
227 have a non-lazy previous value to compare with. */
230 if (!value_lazy (result
))
237 value_fetch_lazy (result
);
240 catch (const gdb_exception_error
&except
)
248 /* Return the chain of intermediate values. We use this to
249 decide which addresses to watch. */
250 *val_chain
= value_release_to_mark (mark
);
254 /* Extract a field operation from an expression. If the subexpression
255 of EXP starting at *SUBEXP is not a structure dereference
256 operation, return NULL. Otherwise, return the name of the
257 dereferenced field, and advance *SUBEXP to point to the
258 subexpression of the left-hand-side of the dereference. This is
259 used when completing field names. */
262 extract_field_op (struct expression
*exp
, int *subexp
)
267 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
268 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
270 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
271 result
= &exp
->elts
[*subexp
+ 2].string
;
272 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
276 /* This function evaluates brace-initializers (in C/C++) for
279 static struct value
*
280 evaluate_struct_tuple (struct value
*struct_val
,
281 struct expression
*exp
,
282 int *pos
, enum noside noside
, int nargs
)
284 struct type
*struct_type
= check_typedef (value_type (struct_val
));
285 struct type
*field_type
;
290 struct value
*val
= NULL
;
295 /* Skip static fields. */
296 while (fieldno
< struct_type
->num_fields ()
297 && field_is_static (&struct_type
->field (fieldno
)))
299 if (fieldno
>= struct_type
->num_fields ())
300 error (_("too many initializers"));
301 field_type
= struct_type
->field (fieldno
).type ();
302 if (field_type
->code () == TYPE_CODE_UNION
303 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
304 error (_("don't know which variant you want to set"));
306 /* Here, struct_type is the type of the inner struct,
307 while substruct_type is the type of the inner struct.
308 These are the same for normal structures, but a variant struct
309 contains anonymous union fields that contain substruct fields.
310 The value fieldno is the index of the top-level (normal or
311 anonymous union) field in struct_field, while the value
312 subfieldno is the index of the actual real (named inner) field
313 in substruct_type. */
315 field_type
= struct_type
->field (fieldno
).type ();
317 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
319 /* Now actually set the field in struct_val. */
321 /* Assign val to field fieldno. */
322 if (value_type (val
) != field_type
)
323 val
= value_cast (field_type
, val
);
325 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
326 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
327 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
329 modify_field (struct_type
, addr
,
330 value_as_long (val
), bitpos
% 8, bitsize
);
332 memcpy (addr
, value_contents (val
),
333 TYPE_LENGTH (value_type (val
)));
339 /* Promote value ARG1 as appropriate before performing a unary operation
341 If the result is not appropriate for any particular language then it
342 needs to patch this function. */
345 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
350 *arg1
= coerce_ref (*arg1
);
351 type1
= check_typedef (value_type (*arg1
));
353 if (is_integral_type (type1
))
355 switch (language
->la_language
)
358 /* Perform integral promotion for ANSI C/C++.
359 If not appropriate for any particular language
360 it needs to modify this function. */
362 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
364 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
365 *arg1
= value_cast (builtin_int
, *arg1
);
372 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
373 operation on those two operands.
374 If the result is not appropriate for any particular language then it
375 needs to patch this function. */
378 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
379 struct value
**arg1
, struct value
**arg2
)
381 struct type
*promoted_type
= NULL
;
385 *arg1
= coerce_ref (*arg1
);
386 *arg2
= coerce_ref (*arg2
);
388 type1
= check_typedef (value_type (*arg1
));
389 type2
= check_typedef (value_type (*arg2
));
391 if ((type1
->code () != TYPE_CODE_FLT
392 && type1
->code () != TYPE_CODE_DECFLOAT
393 && !is_integral_type (type1
))
394 || (type2
->code () != TYPE_CODE_FLT
395 && type2
->code () != TYPE_CODE_DECFLOAT
396 && !is_integral_type (type2
)))
399 if (is_fixed_point_type (type1
) || is_fixed_point_type (type2
))
402 if (type1
->code () == TYPE_CODE_DECFLOAT
403 || type2
->code () == TYPE_CODE_DECFLOAT
)
405 /* No promotion required. */
407 else if (type1
->code () == TYPE_CODE_FLT
408 || type2
->code () == TYPE_CODE_FLT
)
410 switch (language
->la_language
)
416 case language_opencl
:
417 /* No promotion required. */
421 /* For other languages the result type is unchanged from gdb
422 version 6.7 for backward compatibility.
423 If either arg was long double, make sure that value is also long
424 double. Otherwise use double. */
425 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
426 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
427 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
429 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
433 else if (type1
->code () == TYPE_CODE_BOOL
434 && type2
->code () == TYPE_CODE_BOOL
)
436 /* No promotion required. */
439 /* Integral operations here. */
440 /* FIXME: Also mixed integral/booleans, with result an integer. */
442 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
443 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
444 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
445 int is_unsigned1
= type1
->is_unsigned ();
446 int is_unsigned2
= type2
->is_unsigned ();
447 unsigned int result_len
;
448 int unsigned_operation
;
450 /* Determine type length and signedness after promotion for
452 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
455 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
457 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
460 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
463 if (promoted_len1
> promoted_len2
)
465 unsigned_operation
= is_unsigned1
;
466 result_len
= promoted_len1
;
468 else if (promoted_len2
> promoted_len1
)
470 unsigned_operation
= is_unsigned2
;
471 result_len
= promoted_len2
;
475 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
476 result_len
= promoted_len1
;
479 switch (language
->la_language
)
485 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
487 promoted_type
= (unsigned_operation
488 ? builtin
->builtin_unsigned_int
489 : builtin
->builtin_int
);
491 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
493 promoted_type
= (unsigned_operation
494 ? builtin
->builtin_unsigned_long
495 : builtin
->builtin_long
);
499 promoted_type
= (unsigned_operation
500 ? builtin
->builtin_unsigned_long_long
501 : builtin
->builtin_long_long
);
504 case language_opencl
:
505 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
510 ? lookup_unsigned_typename (language
, "int")
511 : lookup_signed_typename (language
, "int"));
513 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
518 ? lookup_unsigned_typename (language
, "long")
519 : lookup_signed_typename (language
,"long"));
523 /* For other languages the result type is unchanged from gdb
524 version 6.7 for backward compatibility.
525 If either arg was long long, make sure that value is also long
526 long. Otherwise use long. */
527 if (unsigned_operation
)
529 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
530 promoted_type
= builtin
->builtin_unsigned_long_long
;
532 promoted_type
= builtin
->builtin_unsigned_long
;
536 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
537 promoted_type
= builtin
->builtin_long_long
;
539 promoted_type
= builtin
->builtin_long
;
547 /* Promote both operands to common type. */
548 *arg1
= value_cast (promoted_type
, *arg1
);
549 *arg2
= value_cast (promoted_type
, *arg2
);
554 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
556 type
= check_typedef (type
);
557 if (TYPE_IS_REFERENCE (type
))
558 type
= TYPE_TARGET_TYPE (type
);
560 switch (type
->code ())
566 case TYPE_CODE_ARRAY
:
567 return type
->is_vector () ? 0 : lang
->c_style_arrays_p ();
574 /* Represents a fake method with the given parameter types. This is
575 used by the parser to construct a temporary "expected" type for
576 method overload resolution. FLAGS is used as instance flags of the
577 new type, in order to be able to make the new type represent a
578 const/volatile overload. */
583 fake_method (type_instance_flags flags
,
584 int num_types
, struct type
**param_types
);
587 /* The constructed type. */
588 struct type
*type () { return &m_type
; }
591 struct type m_type
{};
592 main_type m_main_type
{};
595 fake_method::fake_method (type_instance_flags flags
,
596 int num_types
, struct type
**param_types
)
598 struct type
*type
= &m_type
;
600 TYPE_MAIN_TYPE (type
) = &m_main_type
;
601 TYPE_LENGTH (type
) = 1;
602 type
->set_code (TYPE_CODE_METHOD
);
603 TYPE_CHAIN (type
) = type
;
604 type
->set_instance_flags (flags
);
607 if (param_types
[num_types
- 1] == NULL
)
610 type
->set_has_varargs (true);
612 else if (check_typedef (param_types
[num_types
- 1])->code ()
616 /* Caller should have ensured this. */
617 gdb_assert (num_types
== 0);
618 type
->set_is_prototyped (true);
622 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
623 neither an objfile nor a gdbarch. As a result we must manually
624 allocate memory for auxiliary fields, and free the memory ourselves
625 when we are done with it. */
626 type
->set_num_fields (num_types
);
628 ((struct field
*) xzalloc (sizeof (struct field
) * num_types
));
630 while (num_types
-- > 0)
631 type
->field (num_types
).set_type (param_types
[num_types
]);
634 fake_method::~fake_method ()
636 xfree (m_type
.fields ());
639 /* Helper for evaluating an OP_VAR_VALUE. */
642 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
644 /* JYG: We used to just return value_zero of the symbol type if
645 we're asked to avoid side effects. Otherwise we return
646 value_of_variable (...). However I'm not sure if
647 value_of_variable () has any side effect. We need a full value
648 object returned here for whatis_exp () to call evaluate_type ()
649 and then pass the full value to value_rtti_target_type () if we
650 are dealing with a pointer or reference to a base class and print
653 struct value
*ret
= NULL
;
657 ret
= value_of_variable (var
, blk
);
660 catch (const gdb_exception_error
&except
)
662 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
665 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
671 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
674 evaluate_var_msym_value (enum noside noside
,
675 struct objfile
*objfile
, minimal_symbol
*msymbol
)
678 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
680 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !the_type
->is_gnu_ifunc ())
681 return value_zero (the_type
, not_lval
);
683 return value_at_lazy (the_type
, address
);
686 /* Helper for returning a value when handling EVAL_SKIP. */
689 eval_skip_value (expression
*exp
)
691 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
694 /* See expression.h. */
697 evaluate_subexp_do_call (expression
*exp
, enum noside noside
,
699 gdb::array_view
<value
*> argvec
,
700 const char *function_name
,
701 type
*default_return_type
)
704 error (_("Cannot evaluate function -- may be inlined"));
705 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
707 /* If the return type doesn't look like a function type,
708 call an error. This can happen if somebody tries to turn
709 a variable into a function call. */
711 type
*ftype
= value_type (callee
);
713 if (ftype
->code () == TYPE_CODE_INTERNAL_FUNCTION
)
715 /* We don't know anything about what the internal
716 function might return, but we have to return
718 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
721 else if (ftype
->code () == TYPE_CODE_XMETHOD
)
723 type
*return_type
= result_type_of_xmethod (callee
, argvec
);
725 if (return_type
== NULL
)
726 error (_("Xmethod is missing return type."));
727 return value_zero (return_type
, not_lval
);
729 else if (ftype
->code () == TYPE_CODE_FUNC
730 || ftype
->code () == TYPE_CODE_METHOD
)
732 if (ftype
->is_gnu_ifunc ())
734 CORE_ADDR address
= value_address (callee
);
735 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
737 if (resolved_type
!= NULL
)
738 ftype
= resolved_type
;
741 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
743 if (return_type
== NULL
)
744 return_type
= default_return_type
;
746 if (return_type
== NULL
)
747 error_call_unknown_return_type (function_name
);
749 return allocate_value (return_type
);
752 error (_("Expression of type other than "
753 "\"Function returning ...\" used as function"));
755 switch (value_type (callee
)->code ())
757 case TYPE_CODE_INTERNAL_FUNCTION
:
758 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
759 callee
, argvec
.size (), argvec
.data ());
760 case TYPE_CODE_XMETHOD
:
761 return call_xmethod (callee
, argvec
);
763 return call_function_by_hand (callee
, default_return_type
, argvec
);
767 /* Helper for evaluating an OP_FUNCALL. */
770 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
778 symbol
*function
= NULL
;
779 char *function_name
= NULL
;
780 const char *var_func_name
= NULL
;
785 exp_opcode op
= exp
->elts
[*pos
].opcode
;
786 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
787 /* Allocate arg vector, including space for the function to be
788 called in argvec[0], a potential `this', and a terminating
790 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
791 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
793 /* First, evaluate the structure into arg2. */
796 if (op
== STRUCTOP_MEMBER
)
798 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
802 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
805 /* If the function is a virtual function, then the aggregate
806 value (providing the structure) plays its part by providing
807 the vtable. Otherwise, it is just along for the ride: call
808 the function directly. */
810 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
812 type
*a1_type
= check_typedef (value_type (arg1
));
813 if (noside
== EVAL_SKIP
)
814 tem
= 1; /* Set it to the right arg index so that all
815 arguments can also be skipped. */
816 else if (a1_type
->code () == TYPE_CODE_METHODPTR
)
818 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
819 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
821 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
823 /* Now, say which argument to start evaluating from. */
828 else if (a1_type
->code () == TYPE_CODE_MEMBERPTR
)
830 struct type
*type_ptr
831 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
832 struct type
*target_type_ptr
833 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
835 /* Now, convert these values to an address. */
836 arg2
= value_cast (type_ptr
, arg2
);
838 long mem_offset
= value_as_long (arg1
);
840 arg1
= value_from_pointer (target_type_ptr
,
841 value_as_long (arg2
) + mem_offset
);
842 arg1
= value_ind (arg1
);
846 error (_("Non-pointer-to-member value used in pointer-to-member "
849 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
851 /* Hair for method invocations. */
855 /* First, evaluate the structure into arg2. */
857 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
858 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
860 if (op
== STRUCTOP_STRUCT
)
862 /* If v is a variable in a register, and the user types
863 v.method (), this will produce an error, because v has no
866 A possible way around this would be to allocate a copy of
867 the variable on the stack, copy in the contents, call the
868 function, and copy out the contents. I.e. convert this
869 from call by reference to call by copy-return (or
870 whatever it's called). However, this does not work
871 because it is not the same: the method being called could
872 stash a copy of the address, and then future uses through
873 that address (after the method returns) would be expected
874 to use the variable itself, not some copy of it. */
875 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
879 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
881 /* Check to see if the operator '->' has been overloaded.
882 If the operator has been overloaded replace arg2 with the
883 value returned by the custom operator and continue
885 while (unop_user_defined_p (op
, arg2
))
887 struct value
*value
= NULL
;
890 value
= value_x_unop (arg2
, op
, noside
);
893 catch (const gdb_exception_error
&except
)
895 if (except
.error
== NOT_FOUND_ERROR
)
904 /* Now, say which argument to start evaluating from. */
907 else if (op
== OP_SCOPE
908 && overload_resolution
909 && (exp
->language_defn
->la_language
== language_cplus
))
911 /* Unpack it locally so we can properly handle overload
917 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
918 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
919 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
920 name
= &exp
->elts
[pc2
+ 3].string
;
923 function_name
= NULL
;
924 if (type
->code () == TYPE_CODE_NAMESPACE
)
926 function
= cp_lookup_symbol_namespace (type
->name (),
928 get_selected_block (0),
930 if (function
== NULL
)
931 error (_("No symbol \"%s\" in namespace \"%s\"."),
932 name
, type
->name ());
935 /* arg2 is left as NULL on purpose. */
939 gdb_assert (type
->code () == TYPE_CODE_STRUCT
940 || type
->code () == TYPE_CODE_UNION
);
941 function_name
= name
;
943 /* We need a properly typed value for method lookup. For
944 static methods arg2 is otherwise unused. */
945 arg2
= value_zero (type
, lval_memory
);
950 else if (op
== OP_ADL_FUNC
)
952 /* Save the function position and move pos so that the arguments
959 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
960 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
964 /* Non-method function call. */
968 /* If this is a C++ function wait until overload resolution. */
969 if (op
== OP_VAR_VALUE
970 && overload_resolution
971 && (exp
->language_defn
->la_language
== language_cplus
))
973 (*pos
) += 4; /* Skip the evaluation of the symbol. */
978 if (op
== OP_VAR_MSYM_VALUE
)
980 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
981 var_func_name
= msym
->print_name ();
983 else if (op
== OP_VAR_VALUE
)
985 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
986 var_func_name
= sym
->print_name ();
989 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
990 type
*type
= value_type (argvec
[0]);
991 if (type
&& type
->code () == TYPE_CODE_PTR
)
992 type
= TYPE_TARGET_TYPE (type
);
993 if (type
&& type
->code () == TYPE_CODE_FUNC
)
995 for (; tem
<= nargs
&& tem
<= type
->num_fields (); tem
++)
997 argvec
[tem
] = evaluate_subexp (type
->field (tem
- 1).type (),
1004 /* Evaluate arguments (if not already done, e.g., namespace::func()
1005 and overload-resolution is off). */
1006 for (; tem
<= nargs
; tem
++)
1008 /* Ensure that array expressions are coerced into pointer
1010 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1013 /* Signal end of arglist. */
1016 if (noside
== EVAL_SKIP
)
1017 return eval_skip_value (exp
);
1019 if (op
== OP_ADL_FUNC
)
1021 struct symbol
*symp
;
1024 int string_pc
= save_pos1
+ 3;
1026 /* Extract the function name. */
1027 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1028 func_name
= (char *) alloca (name_len
+ 1);
1029 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1031 find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1033 NON_METHOD
, /* not method */
1034 NULL
, NULL
, /* pass NULL symbol since
1035 symbol is unknown */
1036 NULL
, &symp
, NULL
, 0, noside
);
1038 /* Now fix the expression being evaluated. */
1039 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1040 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1043 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1044 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1046 int static_memfuncp
;
1049 /* Method invocation: stuff "this" as first parameter. If the
1050 method turns out to be static we undo this below. */
1055 /* Name of method from expression. */
1056 tstr
= &exp
->elts
[pc2
+ 2].string
;
1059 tstr
= function_name
;
1061 if (overload_resolution
&& (exp
->language_defn
->la_language
1064 /* Language is C++, do some overload resolution before
1066 struct value
*valp
= NULL
;
1068 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1070 METHOD
, /* method */
1071 &arg2
, /* the object */
1073 &static_memfuncp
, 0, noside
);
1075 if (op
== OP_SCOPE
&& !static_memfuncp
)
1077 /* For the time being, we don't handle this. */
1078 error (_("Call to overloaded function %s requires "
1082 argvec
[1] = arg2
; /* the ``this'' pointer */
1083 argvec
[0] = valp
; /* Use the method found after overload
1087 /* Non-C++ case -- or no overload resolution. */
1089 struct value
*temp
= arg2
;
1091 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1093 op
== STRUCTOP_STRUCT
1094 ? "structure" : "structure pointer");
1095 /* value_struct_elt updates temp with the correct value of
1096 the ``this'' pointer if necessary, so modify argvec[1] to
1097 reflect any ``this'' changes. */
1099 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1100 value_address (temp
)
1101 + value_embedded_offset (temp
));
1102 argvec
[1] = arg2
; /* the ``this'' pointer */
1105 /* Take out `this' if needed. */
1106 if (static_memfuncp
)
1108 argvec
[1] = argvec
[0];
1113 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1115 /* Pointer to member. argvec[1] is already set up. */
1118 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1120 /* Non-member function being called. */
1121 /* fn: This can only be done for C++ functions. A C-style
1122 function in a C++ program, for instance, does not have the
1123 fields that are expected here. */
1125 if (overload_resolution
&& (exp
->language_defn
->la_language
1128 /* Language is C++, do some overload resolution before
1130 struct symbol
*symp
;
1133 /* If a scope has been specified disable ADL. */
1137 if (op
== OP_VAR_VALUE
)
1138 function
= exp
->elts
[save_pos1
+2].symbol
;
1140 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1141 NULL
, /* no need for name */
1142 NON_METHOD
, /* not method */
1143 NULL
, function
, /* the function */
1144 NULL
, &symp
, NULL
, no_adl
, noside
);
1146 if (op
== OP_VAR_VALUE
)
1148 /* Now fix the expression being evaluated. */
1149 exp
->elts
[save_pos1
+2].symbol
= symp
;
1150 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1154 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1158 /* Not C++, or no overload resolution allowed. */
1159 /* Nothing to be done; argvec already correctly set up. */
1164 /* It is probably a C-style function. */
1165 /* Nothing to be done; argvec already correctly set up. */
1168 return evaluate_subexp_do_call (exp
, noside
, argvec
[0],
1169 gdb::make_array_view (argvec
+ 1, nargs
),
1170 var_func_name
, expect_type
);
1173 /* Return true if type is integral or reference to integral */
1176 is_integral_or_integral_reference (struct type
*type
)
1178 if (is_integral_type (type
))
1181 type
= check_typedef (type
);
1182 return (type
!= nullptr
1183 && TYPE_IS_REFERENCE (type
)
1184 && is_integral_type (TYPE_TARGET_TYPE (type
)));
1187 /* Helper function that implements the body of OP_SCOPE. */
1190 eval_op_scope (struct type
*expect_type
, struct expression
*exp
,
1192 struct type
*type
, const char *string
)
1194 if (noside
== EVAL_SKIP
)
1195 return eval_skip_value (exp
);
1196 struct value
*arg1
= value_aggregate_elt (type
, string
, expect_type
,
1199 error (_("There is no field named %s"), string
);
1203 /* Helper function that implements the body of OP_VAR_ENTRY_VALUE. */
1206 eval_op_var_entry_value (struct type
*expect_type
, struct expression
*exp
,
1207 enum noside noside
, symbol
*sym
)
1209 if (noside
== EVAL_SKIP
)
1210 return eval_skip_value (exp
);
1211 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1212 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1214 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1215 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1216 error (_("Symbol \"%s\" does not have any specific entry value"),
1217 sym
->print_name ());
1219 struct frame_info
*frame
= get_selected_frame (NULL
);
1220 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1223 /* Helper function that implements the body of OP_VAR_MSYM_VALUE. */
1226 eval_op_var_msym_value (struct type
*expect_type
, struct expression
*exp
,
1227 enum noside noside
, bool outermost_p
,
1228 minimal_symbol
*msymbol
, struct objfile
*objfile
)
1230 value
*val
= evaluate_var_msym_value (noside
, objfile
, msymbol
);
1232 struct type
*type
= value_type (val
);
1233 if (type
->code () == TYPE_CODE_ERROR
1234 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| !outermost_p
))
1235 error_unknown_type (msymbol
->print_name ());
1239 /* Helper function that implements the body of OP_FUNC_STATIC_VAR. */
1242 eval_op_func_static_var (struct type
*expect_type
, struct expression
*exp
,
1244 value
*func
, const char *var
)
1246 if (noside
== EVAL_SKIP
)
1247 return eval_skip_value (exp
);
1248 CORE_ADDR addr
= value_address (func
);
1249 const block
*blk
= block_for_pc (addr
);
1250 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1251 if (sym
.symbol
== NULL
)
1252 error (_("No symbol \"%s\" in specified context."), var
);
1253 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1256 /* Helper function that implements the body of OP_REGISTER. */
1259 eval_op_register (struct type
*expect_type
, struct expression
*exp
,
1260 enum noside noside
, const char *name
)
1265 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1266 name
, strlen (name
));
1268 error (_("Register $%s not available."), name
);
1270 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1271 a value with the appropriate register type. Unfortunately,
1272 we don't have easy access to the type of user registers.
1273 So for these registers, we fetch the register value regardless
1274 of the evaluation mode. */
1275 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1276 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1277 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1279 val
= value_of_register (regno
, get_selected_frame (NULL
));
1281 error (_("Value of register %s not available."), name
);
1286 /* Helper function that implements the body of OP_STRING. */
1289 eval_op_string (struct type
*expect_type
, struct expression
*exp
,
1290 enum noside noside
, int len
, const char *string
)
1292 if (noside
== EVAL_SKIP
)
1293 return eval_skip_value (exp
);
1294 struct type
*type
= language_string_char_type (exp
->language_defn
,
1296 return value_string (string
, len
, type
);
1299 /* Helper function that implements the body of OP_OBJC_SELECTOR. */
1302 eval_op_objc_selector (struct type
*expect_type
, struct expression
*exp
,
1306 if (noside
== EVAL_SKIP
)
1307 return eval_skip_value (exp
);
1309 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1310 return value_from_longest (selector_type
,
1311 lookup_child_selector (exp
->gdbarch
, sel
));
1314 /* Helper function that implements the body of BINOP_CONCAT. */
1316 static struct value
*
1317 eval_op_concat (struct type
*expect_type
, struct expression
*exp
,
1319 enum exp_opcode op
, struct value
*arg1
, struct value
*arg2
)
1321 if (noside
== EVAL_SKIP
)
1322 return eval_skip_value (exp
);
1323 if (binop_user_defined_p (op
, arg1
, arg2
))
1324 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1326 return value_concat (arg1
, arg2
);
1329 /* A helper function for TERNOP_SLICE. */
1332 eval_op_ternop (struct type
*expect_type
, struct expression
*exp
,
1334 struct value
*array
, struct value
*low
, struct value
*upper
)
1336 if (noside
== EVAL_SKIP
)
1337 return eval_skip_value (exp
);
1338 int lowbound
= value_as_long (low
);
1339 int upperbound
= value_as_long (upper
);
1340 return value_slice (array
, lowbound
, upperbound
- lowbound
+ 1);
1343 /* A helper function for STRUCTOP_STRUCT. */
1345 static struct value
*
1346 eval_op_structop_struct (struct type
*expect_type
, struct expression
*exp
,
1348 struct value
*arg1
, const char *string
)
1350 if (noside
== EVAL_SKIP
)
1351 return eval_skip_value (exp
);
1352 struct value
*arg3
= value_struct_elt (&arg1
, NULL
, string
,
1354 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1355 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1359 /* A helper function for STRUCTOP_PTR. */
1361 static struct value
*
1362 eval_op_structop_ptr (struct type
*expect_type
, struct expression
*exp
,
1363 enum noside noside
, enum exp_opcode op
,
1364 struct value
*arg1
, const char *string
)
1366 if (noside
== EVAL_SKIP
)
1367 return eval_skip_value (exp
);
1369 /* Check to see if operator '->' has been overloaded. If so replace
1370 arg1 with the value returned by evaluating operator->(). */
1371 while (unop_user_defined_p (op
, arg1
))
1373 struct value
*value
= NULL
;
1376 value
= value_x_unop (arg1
, op
, noside
);
1379 catch (const gdb_exception_error
&except
)
1381 if (except
.error
== NOT_FOUND_ERROR
)
1390 /* JYG: if print object is on we need to replace the base type
1391 with rtti type in order to continue on with successful
1392 lookup of member / method only available in the rtti type. */
1394 struct type
*arg_type
= value_type (arg1
);
1395 struct type
*real_type
;
1396 int full
, using_enc
;
1398 struct value_print_options opts
;
1400 get_user_print_options (&opts
);
1401 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
1402 && (TYPE_TARGET_TYPE (arg_type
)->code () == TYPE_CODE_STRUCT
))
1404 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1407 arg1
= value_cast (real_type
, arg1
);
1411 struct value
*arg3
= value_struct_elt (&arg1
, NULL
, string
,
1412 NULL
, "structure pointer");
1413 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1414 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1418 /* A helper function for STRUCTOP_MEMBER. */
1420 static struct value
*
1421 eval_op_member (struct type
*expect_type
, struct expression
*exp
,
1423 struct value
*arg1
, struct value
*arg2
)
1427 if (noside
== EVAL_SKIP
)
1428 return eval_skip_value (exp
);
1431 struct type
*type
= check_typedef (value_type (arg2
));
1432 switch (type
->code ())
1434 case TYPE_CODE_METHODPTR
:
1435 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1436 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1439 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1440 gdb_assert (value_type (arg2
)->code () == TYPE_CODE_PTR
);
1441 return value_ind (arg2
);
1444 case TYPE_CODE_MEMBERPTR
:
1445 /* Now, convert these values to an address. */
1446 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1449 mem_offset
= value_as_long (arg2
);
1451 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1452 value_as_long (arg1
) + mem_offset
);
1453 return value_ind (arg3
);
1456 error (_("non-pointer-to-member value used "
1457 "in pointer-to-member construct"));
1461 /* A helper function for BINOP_ADD. */
1463 static struct value
*
1464 eval_op_add (struct type
*expect_type
, struct expression
*exp
,
1465 enum noside noside
, enum exp_opcode op
,
1466 struct value
*arg1
, struct value
*arg2
)
1468 if (noside
== EVAL_SKIP
)
1469 return eval_skip_value (exp
);
1470 if (binop_user_defined_p (op
, arg1
, arg2
))
1471 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1472 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1473 && is_integral_or_integral_reference (value_type (arg2
)))
1474 return value_ptradd (arg1
, value_as_long (arg2
));
1475 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
1476 && is_integral_or_integral_reference (value_type (arg1
)))
1477 return value_ptradd (arg2
, value_as_long (arg1
));
1480 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1481 return value_binop (arg1
, arg2
, BINOP_ADD
);
1485 /* A helper function for BINOP_SUB. */
1487 static struct value
*
1488 eval_op_sub (struct type
*expect_type
, struct expression
*exp
,
1489 enum noside noside
, enum exp_opcode op
,
1490 struct value
*arg1
, struct value
*arg2
)
1492 if (noside
== EVAL_SKIP
)
1493 return eval_skip_value (exp
);
1494 if (binop_user_defined_p (op
, arg1
, arg2
))
1495 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1496 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1497 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
1499 /* FIXME -- should be ptrdiff_t */
1500 struct type
*type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1501 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1503 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1504 && is_integral_or_integral_reference (value_type (arg2
)))
1505 return value_ptradd (arg1
, - value_as_long (arg2
));
1508 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1509 return value_binop (arg1
, arg2
, BINOP_SUB
);
1513 /* Helper function for several different binary operations. */
1515 static struct value
*
1516 eval_op_binary (struct type
*expect_type
, struct expression
*exp
,
1517 enum noside noside
, enum exp_opcode op
,
1518 struct value
*arg1
, struct value
*arg2
)
1520 if (noside
== EVAL_SKIP
)
1521 return eval_skip_value (exp
);
1522 if (binop_user_defined_p (op
, arg1
, arg2
))
1523 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1526 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1527 fudge arg2 to avoid division-by-zero, the caller is
1528 (theoretically) only looking for the type of the result. */
1529 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1530 /* ??? Do we really want to test for BINOP_MOD here?
1531 The implementation of value_binop gives it a well-defined
1534 || op
== BINOP_INTDIV
1537 && value_logical_not (arg2
))
1539 struct value
*v_one
;
1541 v_one
= value_one (value_type (arg2
));
1542 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1543 return value_binop (arg1
, v_one
, op
);
1547 /* For shift and integer exponentiation operations,
1548 only promote the first argument. */
1549 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1550 && is_integral_type (value_type (arg2
)))
1551 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1553 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1555 return value_binop (arg1
, arg2
, op
);
1560 /* A helper function for BINOP_SUBSCRIPT. */
1562 static struct value
*
1563 eval_op_subscript (struct type
*expect_type
, struct expression
*exp
,
1564 enum noside noside
, enum exp_opcode op
,
1565 struct value
*arg1
, struct value
*arg2
)
1567 if (noside
== EVAL_SKIP
)
1568 return eval_skip_value (exp
);
1569 if (binop_user_defined_p (op
, arg1
, arg2
))
1570 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1573 /* If the user attempts to subscript something that is not an
1574 array or pointer type (like a plain int variable for example),
1575 then report this as an error. */
1577 arg1
= coerce_ref (arg1
);
1578 struct type
*type
= check_typedef (value_type (arg1
));
1579 if (type
->code () != TYPE_CODE_ARRAY
1580 && type
->code () != TYPE_CODE_PTR
)
1583 error (_("cannot subscript something of type `%s'"),
1586 error (_("cannot subscript requested type"));
1589 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1590 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1592 return value_subscript (arg1
, value_as_long (arg2
));
1596 /* A helper function for BINOP_EQUAL. */
1598 static struct value
*
1599 eval_op_equal (struct type
*expect_type
, struct expression
*exp
,
1600 enum noside noside
, enum exp_opcode op
,
1601 struct value
*arg1
, struct value
*arg2
)
1603 if (noside
== EVAL_SKIP
)
1604 return eval_skip_value (exp
);
1605 if (binop_user_defined_p (op
, arg1
, arg2
))
1607 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1611 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1612 int tem
= value_equal (arg1
, arg2
);
1613 struct type
*type
= language_bool_type (exp
->language_defn
,
1615 return value_from_longest (type
, (LONGEST
) tem
);
1619 /* A helper function for BINOP_NOTEQUAL. */
1621 static struct value
*
1622 eval_op_notequal (struct type
*expect_type
, struct expression
*exp
,
1623 enum noside noside
, enum exp_opcode op
,
1624 struct value
*arg1
, struct value
*arg2
)
1626 if (noside
== EVAL_SKIP
)
1627 return eval_skip_value (exp
);
1628 if (binop_user_defined_p (op
, arg1
, arg2
))
1630 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1634 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1635 int tem
= value_equal (arg1
, arg2
);
1636 struct type
*type
= language_bool_type (exp
->language_defn
,
1638 return value_from_longest (type
, (LONGEST
) ! tem
);
1642 /* A helper function for BINOP_LESS. */
1644 static struct value
*
1645 eval_op_less (struct type
*expect_type
, struct expression
*exp
,
1646 enum noside noside
, enum exp_opcode op
,
1647 struct value
*arg1
, struct value
*arg2
)
1649 if (noside
== EVAL_SKIP
)
1650 return eval_skip_value (exp
);
1651 if (binop_user_defined_p (op
, arg1
, arg2
))
1653 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1657 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1658 int tem
= value_less (arg1
, arg2
);
1659 struct type
*type
= language_bool_type (exp
->language_defn
,
1661 return value_from_longest (type
, (LONGEST
) tem
);
1665 /* A helper function for BINOP_GTR. */
1667 static struct value
*
1668 eval_op_gtr (struct type
*expect_type
, struct expression
*exp
,
1669 enum noside noside
, enum exp_opcode op
,
1670 struct value
*arg1
, struct value
*arg2
)
1672 if (noside
== EVAL_SKIP
)
1673 return eval_skip_value (exp
);
1674 if (binop_user_defined_p (op
, arg1
, arg2
))
1676 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1680 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1681 int tem
= value_less (arg2
, arg1
);
1682 struct type
*type
= language_bool_type (exp
->language_defn
,
1684 return value_from_longest (type
, (LONGEST
) tem
);
1688 /* A helper function for BINOP_GEQ. */
1690 static struct value
*
1691 eval_op_geq (struct type
*expect_type
, struct expression
*exp
,
1692 enum noside noside
, enum exp_opcode op
,
1693 struct value
*arg1
, struct value
*arg2
)
1695 if (noside
== EVAL_SKIP
)
1696 return eval_skip_value (exp
);
1697 if (binop_user_defined_p (op
, arg1
, arg2
))
1699 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1703 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1704 int tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1705 struct type
*type
= language_bool_type (exp
->language_defn
,
1707 return value_from_longest (type
, (LONGEST
) tem
);
1711 /* A helper function for BINOP_LEQ. */
1713 static struct value
*
1714 eval_op_leq (struct type
*expect_type
, struct expression
*exp
,
1715 enum noside noside
, enum exp_opcode op
,
1716 struct value
*arg1
, struct value
*arg2
)
1718 if (noside
== EVAL_SKIP
)
1719 return eval_skip_value (exp
);
1720 if (binop_user_defined_p (op
, arg1
, arg2
))
1722 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1726 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1727 int tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1728 struct type
*type
= language_bool_type (exp
->language_defn
,
1730 return value_from_longest (type
, (LONGEST
) tem
);
1734 /* A helper function for BINOP_REPEAT. */
1736 static struct value
*
1737 eval_op_repeat (struct type
*expect_type
, struct expression
*exp
,
1739 struct value
*arg1
, struct value
*arg2
)
1741 if (noside
== EVAL_SKIP
)
1742 return eval_skip_value (exp
);
1743 struct type
*type
= check_typedef (value_type (arg2
));
1744 if (type
->code () != TYPE_CODE_INT
1745 && type
->code () != TYPE_CODE_ENUM
)
1746 error (_("Non-integral right operand for \"@\" operator."));
1747 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1749 return allocate_repeat_value (value_type (arg1
),
1750 longest_to_int (value_as_long (arg2
)));
1753 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1756 /* A helper function for UNOP_PLUS. */
1758 static struct value
*
1759 eval_op_plus (struct type
*expect_type
, struct expression
*exp
,
1760 enum noside noside
, enum exp_opcode op
,
1763 if (noside
== EVAL_SKIP
)
1764 return eval_skip_value (exp
);
1765 if (unop_user_defined_p (op
, arg1
))
1766 return value_x_unop (arg1
, op
, noside
);
1769 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1770 return value_pos (arg1
);
1774 /* A helper function for UNOP_NEG. */
1776 static struct value
*
1777 eval_op_neg (struct type
*expect_type
, struct expression
*exp
,
1778 enum noside noside
, enum exp_opcode op
,
1781 if (noside
== EVAL_SKIP
)
1782 return eval_skip_value (exp
);
1783 if (unop_user_defined_p (op
, arg1
))
1784 return value_x_unop (arg1
, op
, noside
);
1787 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1788 return value_neg (arg1
);
1792 /* A helper function for UNOP_COMPLEMENT. */
1794 static struct value
*
1795 eval_op_complement (struct type
*expect_type
, struct expression
*exp
,
1796 enum noside noside
, enum exp_opcode op
,
1799 if (noside
== EVAL_SKIP
)
1800 return eval_skip_value (exp
);
1801 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1802 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1805 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1806 return value_complement (arg1
);
1810 /* A helper function for UNOP_LOGICAL_NOT. */
1812 static struct value
*
1813 eval_op_lognot (struct type
*expect_type
, struct expression
*exp
,
1814 enum noside noside
, enum exp_opcode op
,
1817 if (noside
== EVAL_SKIP
)
1818 return eval_skip_value (exp
);
1819 if (unop_user_defined_p (op
, arg1
))
1820 return value_x_unop (arg1
, op
, noside
);
1823 struct type
*type
= language_bool_type (exp
->language_defn
,
1825 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
1829 /* A helper function for UNOP_IND. */
1831 static struct value
*
1832 eval_op_ind (struct type
*expect_type
, struct expression
*exp
,
1833 enum noside noside
, enum exp_opcode op
,
1836 struct type
*type
= check_typedef (value_type (arg1
));
1837 if (type
->code () == TYPE_CODE_METHODPTR
1838 || type
->code () == TYPE_CODE_MEMBERPTR
)
1839 error (_("Attempt to dereference pointer "
1840 "to member without an object"));
1841 if (noside
== EVAL_SKIP
)
1842 return eval_skip_value (exp
);
1843 if (unop_user_defined_p (op
, arg1
))
1844 return value_x_unop (arg1
, op
, noside
);
1845 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1847 type
= check_typedef (value_type (arg1
));
1849 /* If the type pointed to is dynamic then in order to resolve the
1850 dynamic properties we must actually dereference the pointer.
1851 There is a risk that this dereference will have side-effects
1852 in the inferior, but being able to print accurate type
1853 information seems worth the risk. */
1854 if ((type
->code () != TYPE_CODE_PTR
1855 && !TYPE_IS_REFERENCE (type
))
1856 || !is_dynamic_type (TYPE_TARGET_TYPE (type
)))
1858 if (type
->code () == TYPE_CODE_PTR
1859 || TYPE_IS_REFERENCE (type
)
1860 /* In C you can dereference an array to get the 1st elt. */
1861 || type
->code () == TYPE_CODE_ARRAY
)
1862 return value_zero (TYPE_TARGET_TYPE (type
),
1864 else if (type
->code () == TYPE_CODE_INT
)
1865 /* GDB allows dereferencing an int. */
1866 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1869 error (_("Attempt to take contents of a non-pointer value."));
1873 /* Allow * on an integer so we can cast it to whatever we want.
1874 This returns an int, which seems like the most C-like thing to
1875 do. "long long" variables are rare enough that
1876 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
1877 if (type
->code () == TYPE_CODE_INT
)
1878 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
1879 (CORE_ADDR
) value_as_address (arg1
));
1880 return value_ind (arg1
);
1883 /* A helper function for UNOP_ALIGNOF. */
1885 static struct value
*
1886 eval_op_alignof (struct type
*expect_type
, struct expression
*exp
,
1890 struct type
*type
= value_type (arg1
);
1891 /* FIXME: This should be size_t. */
1892 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
1893 ULONGEST align
= type_align (type
);
1895 error (_("could not determine alignment of type"));
1896 return value_from_longest (size_type
, align
);
1899 /* A helper function for UNOP_MEMVAL. */
1901 static struct value
*
1902 eval_op_memval (struct type
*expect_type
, struct expression
*exp
,
1904 struct value
*arg1
, struct type
*type
)
1906 if (noside
== EVAL_SKIP
)
1907 return eval_skip_value (exp
);
1908 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1909 return value_zero (type
, lval_memory
);
1911 return value_at_lazy (type
, value_as_address (arg1
));
1914 /* A helper function for UNOP_PREINCREMENT. */
1916 static struct value
*
1917 eval_op_preinc (struct type
*expect_type
, struct expression
*exp
,
1918 enum noside noside
, enum exp_opcode op
,
1921 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1923 else if (unop_user_defined_p (op
, arg1
))
1925 return value_x_unop (arg1
, op
, noside
);
1930 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
1931 arg2
= value_ptradd (arg1
, 1);
1934 struct value
*tmp
= arg1
;
1936 arg2
= value_one (value_type (arg1
));
1937 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1938 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
1941 return value_assign (arg1
, arg2
);
1945 /* A helper function for UNOP_PREDECREMENT. */
1947 static struct value
*
1948 eval_op_predec (struct type
*expect_type
, struct expression
*exp
,
1949 enum noside noside
, enum exp_opcode op
,
1952 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1954 else if (unop_user_defined_p (op
, arg1
))
1956 return value_x_unop (arg1
, op
, noside
);
1961 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
1962 arg2
= value_ptradd (arg1
, -1);
1965 struct value
*tmp
= arg1
;
1967 arg2
= value_one (value_type (arg1
));
1968 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1969 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
1972 return value_assign (arg1
, arg2
);
1976 /* A helper function for UNOP_POSTINCREMENT. */
1978 static struct value
*
1979 eval_op_postinc (struct type
*expect_type
, struct expression
*exp
,
1980 enum noside noside
, enum exp_opcode op
,
1983 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1985 else if (unop_user_defined_p (op
, arg1
))
1987 return value_x_unop (arg1
, op
, noside
);
1991 struct value
*arg3
= value_non_lval (arg1
);
1994 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
1995 arg2
= value_ptradd (arg1
, 1);
1998 struct value
*tmp
= arg1
;
2000 arg2
= value_one (value_type (arg1
));
2001 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2002 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2005 value_assign (arg1
, arg2
);
2010 /* A helper function for UNOP_POSTDECREMENT. */
2012 static struct value
*
2013 eval_op_postdec (struct type
*expect_type
, struct expression
*exp
,
2014 enum noside noside
, enum exp_opcode op
,
2017 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2019 else if (unop_user_defined_p (op
, arg1
))
2021 return value_x_unop (arg1
, op
, noside
);
2025 struct value
*arg3
= value_non_lval (arg1
);
2028 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2029 arg2
= value_ptradd (arg1
, -1);
2032 struct value
*tmp
= arg1
;
2034 arg2
= value_one (value_type (arg1
));
2035 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2036 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2039 value_assign (arg1
, arg2
);
2044 /* A helper function for OP_TYPE. */
2046 static struct value
*
2047 eval_op_type (struct type
*expect_type
, struct expression
*exp
,
2048 enum noside noside
, struct type
*type
)
2050 if (noside
== EVAL_SKIP
)
2051 return eval_skip_value (exp
);
2052 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2053 return allocate_value (type
);
2055 error (_("Attempt to use a type name as an expression"));
2058 /* A helper function for BINOP_ASSIGN_MODIFY. */
2060 static struct value
*
2061 eval_binop_assign_modify (struct type
*expect_type
, struct expression
*exp
,
2062 enum noside noside
, enum exp_opcode op
,
2063 struct value
*arg1
, struct value
*arg2
)
2065 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2067 if (binop_user_defined_p (op
, arg1
, arg2
))
2068 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2069 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2071 && is_integral_type (value_type (arg2
)))
2072 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2073 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2075 && is_integral_type (value_type (arg2
)))
2076 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2079 struct value
*tmp
= arg1
;
2081 /* For shift and integer exponentiation operations,
2082 only promote the first argument. */
2083 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2084 && is_integral_type (value_type (arg2
)))
2085 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2087 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2089 arg2
= value_binop (tmp
, arg2
, op
);
2091 return value_assign (arg1
, arg2
);
2094 /* Note that ARGS needs 2 empty slots up front and must end with a
2096 static struct value
*
2097 eval_op_objc_msgcall (struct type
*expect_type
, struct expression
*exp
,
2098 enum noside noside
, CORE_ADDR selector
,
2099 value
*target
, gdb::array_view
<value
*> args
)
2101 CORE_ADDR responds_selector
= 0;
2102 CORE_ADDR method_selector
= 0;
2104 int struct_return
= 0;
2106 struct value
*msg_send
= NULL
;
2107 struct value
*msg_send_stret
= NULL
;
2108 int gnu_runtime
= 0;
2110 struct value
*method
= NULL
;
2111 struct value
*called_method
= NULL
;
2113 struct type
*selector_type
= NULL
;
2114 struct type
*long_type
;
2117 struct value
*ret
= NULL
;
2122 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2123 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2125 if (value_as_long (target
) == 0)
2126 return value_from_longest (long_type
, 0);
2128 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
2131 /* Find the method dispatch (Apple runtime) or method lookup
2132 (GNU runtime) function for Objective-C. These will be used
2133 to lookup the symbol information for the method. If we
2134 can't find any symbol information, then we'll use these to
2135 call the method, otherwise we can call the method
2136 directly. The msg_send_stret function is used in the special
2137 case of a method that returns a structure (Apple runtime
2141 type
= selector_type
;
2143 type
= lookup_function_type (type
);
2144 type
= lookup_pointer_type (type
);
2145 type
= lookup_function_type (type
);
2146 type
= lookup_pointer_type (type
);
2148 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
2150 = find_function_in_inferior ("objc_msg_lookup", NULL
);
2152 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
2153 msg_send_stret
= value_from_pointer (type
,
2154 value_as_address (msg_send_stret
));
2158 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
2159 /* Special dispatcher for methods returning structs. */
2161 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
2164 /* Verify the target object responds to this method. The
2165 standard top-level 'Object' class uses a different name for
2166 the verification method than the non-standard, but more
2167 often used, 'NSObject' class. Make sure we check for both. */
2170 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
2171 if (responds_selector
== 0)
2173 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
2175 if (responds_selector
== 0)
2176 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
2179 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
2180 if (method_selector
== 0)
2182 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
2184 if (method_selector
== 0)
2185 error (_("no 'methodFor:' or 'methodForSelector:' method"));
2187 /* Call the verification method, to make sure that the target
2188 class implements the desired method. */
2190 argvec
[0] = msg_send
;
2192 argvec
[2] = value_from_longest (long_type
, responds_selector
);
2193 argvec
[3] = value_from_longest (long_type
, selector
);
2196 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2199 /* Function objc_msg_lookup returns a pointer. */
2201 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2203 if (value_as_long (ret
) == 0)
2204 error (_("Target does not respond to this message selector."));
2206 /* Call "methodForSelector:" method, to get the address of a
2207 function method that implements this selector for this
2208 class. If we can find a symbol at that address, then we
2209 know the return type, parameter types etc. (that's a good
2212 argvec
[0] = msg_send
;
2214 argvec
[2] = value_from_longest (long_type
, method_selector
);
2215 argvec
[3] = value_from_longest (long_type
, selector
);
2218 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2222 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2225 /* ret should now be the selector. */
2227 addr
= value_as_long (ret
);
2230 struct symbol
*sym
= NULL
;
2232 /* The address might point to a function descriptor;
2233 resolve it to the actual code address instead. */
2234 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
2235 current_top_target ());
2237 /* Is it a high_level symbol? */
2238 sym
= find_pc_function (addr
);
2240 method
= value_of_variable (sym
, 0);
2243 /* If we found a method with symbol information, check to see
2244 if it returns a struct. Otherwise assume it doesn't. */
2249 struct type
*val_type
;
2251 funaddr
= find_function_addr (method
, &val_type
);
2253 block_for_pc (funaddr
);
2255 val_type
= check_typedef (val_type
);
2257 if ((val_type
== NULL
)
2258 || (val_type
->code () == TYPE_CODE_ERROR
))
2260 if (expect_type
!= NULL
)
2261 val_type
= expect_type
;
2264 struct_return
= using_struct_return (exp
->gdbarch
, method
,
2267 else if (expect_type
!= NULL
)
2269 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
2270 check_typedef (expect_type
));
2273 /* Found a function symbol. Now we will substitute its
2274 value in place of the message dispatcher (obj_msgSend),
2275 so that we call the method directly instead of thru
2276 the dispatcher. The main reason for doing this is that
2277 we can now evaluate the return value and parameter values
2278 according to their known data types, in case we need to
2279 do things like promotion, dereferencing, special handling
2280 of structs and doubles, etc.
2282 We want to use the type signature of 'method', but still
2283 jump to objc_msgSend() or objc_msgSend_stret() to better
2284 mimic the behavior of the runtime. */
2288 if (value_type (method
)->code () != TYPE_CODE_FUNC
)
2289 error (_("method address has symbol information "
2290 "with non-function type; skipping"));
2292 /* Create a function pointer of the appropriate type, and
2293 replace its value with the value of msg_send or
2294 msg_send_stret. We must use a pointer here, as
2295 msg_send and msg_send_stret are of pointer type, and
2296 the representation may be different on systems that use
2297 function descriptors. */
2300 = value_from_pointer (lookup_pointer_type (value_type (method
)),
2301 value_as_address (msg_send_stret
));
2304 = value_from_pointer (lookup_pointer_type (value_type (method
)),
2305 value_as_address (msg_send
));
2310 called_method
= msg_send_stret
;
2312 called_method
= msg_send
;
2315 if (noside
== EVAL_SKIP
)
2316 return eval_skip_value (exp
);
2318 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2320 /* If the return type doesn't look like a function type,
2321 call an error. This can happen if somebody tries to
2322 turn a variable into a function call. This is here
2323 because people often want to call, eg, strcmp, which
2324 gdb doesn't know is a function. If gdb isn't asked for
2325 it's opinion (ie. through "whatis"), it won't offer
2328 struct type
*callee_type
= value_type (called_method
);
2330 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
2331 callee_type
= TYPE_TARGET_TYPE (callee_type
);
2332 callee_type
= TYPE_TARGET_TYPE (callee_type
);
2336 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
2337 return allocate_value (expect_type
);
2339 return allocate_value (callee_type
);
2342 error (_("Expression of type other than "
2343 "\"method returning ...\" used as a method"));
2346 /* Now depending on whether we found a symbol for the method,
2347 we will either call the runtime dispatcher or the method
2351 args
[1] = value_from_longest (long_type
, selector
);
2353 if (gnu_runtime
&& (method
!= NULL
))
2355 /* Function objc_msg_lookup returns a pointer. */
2356 struct type
*tem_type
= value_type (called_method
);
2357 tem_type
= lookup_pointer_type (lookup_function_type (tem_type
));
2358 deprecated_set_value_type (called_method
, tem_type
);
2359 called_method
= call_function_by_hand (called_method
, NULL
, args
);
2362 return call_function_by_hand (called_method
, NULL
, args
);
2365 /* Helper function for MULTI_SUBSCRIPT. */
2367 static struct value
*
2368 eval_multi_subscript (struct type
*expect_type
, struct expression
*exp
,
2369 enum noside noside
, value
*arg1
,
2370 gdb::array_view
<value
*> args
)
2372 if (noside
== EVAL_SKIP
)
2374 for (value
*arg2
: args
)
2376 if (binop_user_defined_p (MULTI_SUBSCRIPT
, arg1
, arg2
))
2378 arg1
= value_x_binop (arg1
, arg2
, MULTI_SUBSCRIPT
, OP_NULL
, noside
);
2382 arg1
= coerce_ref (arg1
);
2383 struct type
*type
= check_typedef (value_type (arg1
));
2385 switch (type
->code ())
2388 case TYPE_CODE_ARRAY
:
2389 case TYPE_CODE_STRING
:
2390 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2395 error (_("cannot subscript something of type `%s'"),
2398 error (_("cannot subscript requested type"));
2406 evaluate_subexp_standard (struct type
*expect_type
,
2407 struct expression
*exp
, int *pos
,
2411 int tem
, tem2
, tem3
;
2413 struct value
*arg1
= NULL
;
2414 struct value
*arg2
= NULL
;
2417 struct value
**argvec
;
2419 struct type
**arg_types
;
2422 op
= exp
->elts
[pc
].opcode
;
2427 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2428 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
2429 return eval_op_scope (expect_type
, exp
, noside
,
2430 exp
->elts
[pc
+ 1].type
,
2431 &exp
->elts
[pc
+ 3].string
);
2435 return value_from_longest (exp
->elts
[pc
+ 1].type
,
2436 exp
->elts
[pc
+ 2].longconst
);
2440 return value_from_contents (exp
->elts
[pc
+ 1].type
,
2441 exp
->elts
[pc
+ 2].floatconst
);
2447 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
2448 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
2449 error_unknown_type (var
->print_name ());
2450 if (noside
!= EVAL_SKIP
)
2451 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
2454 /* Return a dummy value of the correct type when skipping, so
2455 that parent functions know what is to be skipped. */
2456 return allocate_value (SYMBOL_TYPE (var
));
2460 case OP_VAR_MSYM_VALUE
:
2464 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
2465 return eval_op_var_msym_value (expect_type
, exp
, noside
,
2467 exp
->elts
[pc
+ 1].objfile
);
2470 case OP_VAR_ENTRY_VALUE
:
2474 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
2476 return eval_op_var_entry_value (expect_type
, exp
, noside
, sym
);
2479 case OP_FUNC_STATIC_VAR
:
2480 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2481 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2482 if (noside
== EVAL_SKIP
)
2483 return eval_skip_value (exp
);
2486 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
2488 return eval_op_func_static_var (expect_type
, exp
, noside
, func
,
2489 &exp
->elts
[pc
+ 2].string
);
2495 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
2499 const char *name
= &exp
->elts
[pc
+ 2].string
;
2501 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
2502 return eval_op_register (expect_type
, exp
, noside
, name
);
2506 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2507 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
2509 case OP_INTERNALVAR
:
2511 return value_of_internalvar (exp
->gdbarch
,
2512 exp
->elts
[pc
+ 1].internalvar
);
2515 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2516 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2517 return eval_op_string (expect_type
, exp
, noside
, tem
,
2518 &exp
->elts
[pc
+ 2].string
);
2520 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
2521 NSString constant. */
2522 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2523 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2524 if (noside
== EVAL_SKIP
)
2525 return eval_skip_value (exp
);
2526 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
2530 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2531 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2532 nargs
= tem3
- tem2
+ 1;
2533 type
= expect_type
? check_typedef (expect_type
) : nullptr;
2535 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2536 && type
->code () == TYPE_CODE_STRUCT
)
2538 struct value
*rec
= allocate_value (expect_type
);
2540 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
2541 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
2544 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2545 && type
->code () == TYPE_CODE_ARRAY
)
2547 struct type
*range_type
= type
->index_type ();
2548 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
2549 struct value
*array
= allocate_value (expect_type
);
2550 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
2551 LONGEST low_bound
, high_bound
, index
;
2553 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
2556 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
2559 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
2560 for (tem
= nargs
; --nargs
>= 0;)
2562 struct value
*element
;
2564 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
2565 if (value_type (element
) != element_type
)
2566 element
= value_cast (element_type
, element
);
2567 if (index
> high_bound
)
2568 /* To avoid memory corruption. */
2569 error (_("Too many array elements"));
2570 memcpy (value_contents_raw (array
)
2571 + (index
- low_bound
) * element_size
,
2572 value_contents (element
),
2579 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2580 && type
->code () == TYPE_CODE_SET
)
2582 struct value
*set
= allocate_value (expect_type
);
2583 gdb_byte
*valaddr
= value_contents_raw (set
);
2584 struct type
*element_type
= type
->index_type ();
2585 struct type
*check_type
= element_type
;
2586 LONGEST low_bound
, high_bound
;
2588 /* Get targettype of elementtype. */
2589 while (check_type
->code () == TYPE_CODE_RANGE
2590 || check_type
->code () == TYPE_CODE_TYPEDEF
)
2591 check_type
= TYPE_TARGET_TYPE (check_type
);
2593 if (!get_discrete_bounds (element_type
, &low_bound
, &high_bound
))
2594 error (_("(power)set type with unknown size"));
2595 memset (valaddr
, '\0', TYPE_LENGTH (type
));
2596 for (tem
= 0; tem
< nargs
; tem
++)
2598 LONGEST range_low
, range_high
;
2599 struct type
*range_low_type
, *range_high_type
;
2600 struct value
*elem_val
;
2602 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
2603 range_low_type
= range_high_type
= value_type (elem_val
);
2604 range_low
= range_high
= value_as_long (elem_val
);
2606 /* Check types of elements to avoid mixture of elements from
2607 different types. Also check if type of element is "compatible"
2608 with element type of powerset. */
2609 if (range_low_type
->code () == TYPE_CODE_RANGE
)
2610 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
2611 if (range_high_type
->code () == TYPE_CODE_RANGE
)
2612 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
2613 if ((range_low_type
->code () != range_high_type
->code ())
2614 || (range_low_type
->code () == TYPE_CODE_ENUM
2615 && (range_low_type
!= range_high_type
)))
2616 /* different element modes. */
2617 error (_("POWERSET tuple elements of different mode"));
2618 if ((check_type
->code () != range_low_type
->code ())
2619 || (check_type
->code () == TYPE_CODE_ENUM
2620 && range_low_type
!= check_type
))
2621 error (_("incompatible POWERSET tuple elements"));
2622 if (range_low
> range_high
)
2624 warning (_("empty POWERSET tuple range"));
2627 if (range_low
< low_bound
|| range_high
> high_bound
)
2628 error (_("POWERSET tuple element out of range"));
2629 range_low
-= low_bound
;
2630 range_high
-= low_bound
;
2631 for (; range_low
<= range_high
; range_low
++)
2633 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
2635 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
2636 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
2637 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
2644 argvec
= XALLOCAVEC (struct value
*, nargs
);
2645 for (tem
= 0; tem
< nargs
; tem
++)
2647 /* Ensure that array expressions are coerced into pointer
2649 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
2651 if (noside
== EVAL_SKIP
)
2652 return eval_skip_value (exp
);
2653 return value_array (tem2
, tem3
, argvec
);
2657 struct value
*array
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2658 struct value
*low
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2659 struct value
*upper
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2660 return eval_op_ternop (expect_type
, exp
, noside
, array
, low
, upper
);
2664 /* Skip third and second args to evaluate the first one. */
2665 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2666 if (value_logical_not (arg1
))
2668 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2669 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2673 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2674 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2678 case OP_OBJC_SELECTOR
:
2679 { /* Objective C @selector operator. */
2680 char *sel
= &exp
->elts
[pc
+ 2].string
;
2681 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2683 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
2685 sel
[len
] = 0; /* Make sure it's terminated. */
2687 return eval_op_objc_selector (expect_type
, exp
, noside
, sel
);
2690 case OP_OBJC_MSGCALL
:
2691 { /* Objective C message (method) call. */
2692 CORE_ADDR selector
= 0;
2694 enum noside sub_no_side
= EVAL_NORMAL
;
2696 struct value
*target
= NULL
;
2698 struct type
*selector_type
= NULL
;
2700 selector
= exp
->elts
[pc
+ 1].longconst
;
2701 nargs
= exp
->elts
[pc
+ 2].longconst
;
2702 argvec
= XALLOCAVEC (struct value
*, nargs
+ 3);
2706 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2708 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2709 sub_no_side
= EVAL_NORMAL
;
2711 sub_no_side
= noside
;
2713 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
2715 if (value_as_long (target
) == 0)
2716 sub_no_side
= EVAL_SKIP
;
2718 sub_no_side
= noside
;
2720 /* Now depending on whether we found a symbol for the method,
2721 we will either call the runtime dispatcher or the method
2724 argvec
[0] = nullptr;
2725 argvec
[1] = nullptr;
2726 /* User-supplied arguments. */
2727 for (tem
= 0; tem
< nargs
; tem
++)
2728 argvec
[tem
+ 2] = evaluate_subexp_with_coercion (exp
, pos
,
2730 argvec
[tem
+ 3] = 0;
2732 auto call_args
= gdb::make_array_view (argvec
, nargs
+ 3);
2734 return eval_op_objc_msgcall (expect_type
, exp
, noside
, selector
,
2740 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
2743 /* We have a complex number, There should be 2 floating
2744 point numbers that compose it. */
2746 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2747 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2749 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
2751 case STRUCTOP_STRUCT
:
2752 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2753 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2754 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2755 return eval_op_structop_struct (expect_type
, exp
, noside
, arg1
,
2756 &exp
->elts
[pc
+ 2].string
);
2759 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2760 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2761 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2762 return eval_op_structop_ptr (expect_type
, exp
, noside
, op
, arg1
,
2763 &exp
->elts
[pc
+ 2].string
);
2765 case STRUCTOP_MEMBER
:
2767 if (op
== STRUCTOP_MEMBER
)
2768 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2770 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2772 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2774 return eval_op_member (expect_type
, exp
, noside
, arg1
, arg2
);
2778 type_instance_flags flags
2779 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2780 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2781 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2782 for (ix
= 0; ix
< nargs
; ++ix
)
2783 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2785 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
2786 *(pos
) += 4 + nargs
;
2787 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
2792 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2793 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2794 return eval_op_concat (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2797 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2798 /* Special-case assignments where the left-hand-side is a
2799 convenience variable -- in these, don't bother setting an
2800 expected type. This avoids a weird case where re-assigning a
2801 string or array to an internal variable could error with "Too
2802 many array elements". */
2803 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
2805 : value_type (arg1
),
2808 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2810 if (binop_user_defined_p (op
, arg1
, arg2
))
2811 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2813 return value_assign (arg1
, arg2
);
2815 case BINOP_ASSIGN_MODIFY
:
2817 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2818 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2819 op
= exp
->elts
[pc
+ 1].opcode
;
2820 return eval_binop_assign_modify (expect_type
, exp
, noside
, op
,
2824 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2825 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2826 return eval_op_add (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2829 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2830 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2831 return eval_op_sub (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2841 case BINOP_BITWISE_AND
:
2842 case BINOP_BITWISE_IOR
:
2843 case BINOP_BITWISE_XOR
:
2844 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2845 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2846 return eval_op_binary (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2848 case BINOP_SUBSCRIPT
:
2849 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2850 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2851 return eval_op_subscript (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2853 case MULTI_SUBSCRIPT
:
2855 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2856 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2857 argvec
= XALLOCAVEC (struct value
*, nargs
);
2858 for (ix
= 0; ix
< nargs
; ++ix
)
2859 argvec
[ix
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
2860 return eval_multi_subscript (expect_type
, exp
, noside
, arg1
,
2861 gdb::make_array_view (argvec
, nargs
));
2863 case BINOP_LOGICAL_AND
:
2864 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2865 if (noside
== EVAL_SKIP
)
2867 evaluate_subexp (nullptr, exp
, pos
, noside
);
2868 return eval_skip_value (exp
);
2872 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2875 if (binop_user_defined_p (op
, arg1
, arg2
))
2877 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2878 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2882 tem
= value_logical_not (arg1
);
2884 = evaluate_subexp (nullptr, exp
, pos
, (tem
? EVAL_SKIP
: noside
));
2885 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2886 return value_from_longest (type
,
2887 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2890 case BINOP_LOGICAL_OR
:
2891 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2892 if (noside
== EVAL_SKIP
)
2894 evaluate_subexp (nullptr, exp
, pos
, noside
);
2895 return eval_skip_value (exp
);
2899 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2902 if (binop_user_defined_p (op
, arg1
, arg2
))
2904 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2905 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2909 tem
= value_logical_not (arg1
);
2911 = evaluate_subexp (nullptr, exp
, pos
, (!tem
? EVAL_SKIP
: noside
));
2912 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2913 return value_from_longest (type
,
2914 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2918 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2919 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2920 return eval_op_equal (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2922 case BINOP_NOTEQUAL
:
2923 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2924 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2925 return eval_op_notequal (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2928 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2929 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2930 return eval_op_less (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2933 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2934 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2935 return eval_op_gtr (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2938 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2939 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2940 return eval_op_geq (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2943 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2944 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2945 return eval_op_leq (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2948 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2949 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2950 return eval_op_repeat (expect_type
, exp
, noside
, arg1
, arg2
);
2953 evaluate_subexp (nullptr, exp
, pos
, noside
);
2954 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2957 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2958 return eval_op_plus (expect_type
, exp
, noside
, op
, arg1
);
2961 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2962 return eval_op_neg (expect_type
, exp
, noside
, op
, arg1
);
2964 case UNOP_COMPLEMENT
:
2965 /* C++: check for and handle destructor names. */
2967 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2968 return eval_op_complement (expect_type
, exp
, noside
, op
, arg1
);
2970 case UNOP_LOGICAL_NOT
:
2971 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2972 return eval_op_lognot (expect_type
, exp
, noside
, op
, arg1
);
2975 if (expect_type
&& expect_type
->code () == TYPE_CODE_PTR
)
2976 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2977 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2978 return eval_op_ind (expect_type
, exp
, noside
, op
, arg1
);
2981 /* C++: check for and handle pointer to members. */
2983 if (noside
== EVAL_SKIP
)
2985 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2986 return eval_skip_value (exp
);
2989 return evaluate_subexp_for_address (exp
, pos
, noside
);
2992 if (noside
== EVAL_SKIP
)
2994 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2995 return eval_skip_value (exp
);
2997 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
3000 arg1
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3001 return eval_op_alignof (expect_type
, exp
, noside
, arg1
);
3005 type
= exp
->elts
[pc
+ 1].type
;
3006 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
3008 case UNOP_CAST_TYPE
:
3009 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3010 type
= value_type (arg1
);
3011 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
3013 case UNOP_DYNAMIC_CAST
:
3014 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3015 type
= value_type (arg1
);
3016 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
3017 if (noside
== EVAL_SKIP
)
3018 return eval_skip_value (exp
);
3019 return value_dynamic_cast (type
, arg1
);
3021 case UNOP_REINTERPRET_CAST
:
3022 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3023 type
= value_type (arg1
);
3024 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
3025 if (noside
== EVAL_SKIP
)
3026 return eval_skip_value (exp
);
3027 return value_reinterpret_cast (type
, arg1
);
3031 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3032 return eval_op_memval (expect_type
, exp
, noside
, arg1
,
3033 exp
->elts
[pc
+ 1].type
);
3035 case UNOP_MEMVAL_TYPE
:
3036 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3037 type
= value_type (arg1
);
3038 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3039 return eval_op_memval (expect_type
, exp
, noside
, arg1
, type
);
3041 case UNOP_PREINCREMENT
:
3042 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3043 return eval_op_preinc (expect_type
, exp
, noside
, op
, arg1
);
3045 case UNOP_PREDECREMENT
:
3046 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3047 return eval_op_predec (expect_type
, exp
, noside
, op
, arg1
);
3049 case UNOP_POSTINCREMENT
:
3050 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3051 return eval_op_postinc (expect_type
, exp
, noside
, op
, arg1
);
3053 case UNOP_POSTDECREMENT
:
3054 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3055 return eval_op_postdec (expect_type
, exp
, noside
, op
, arg1
);
3059 return value_of_this (exp
->language_defn
);
3062 /* The value is not supposed to be used. This is here to make it
3063 easier to accommodate expressions that contain types. */
3065 return eval_op_type (expect_type
, exp
, noside
, exp
->elts
[pc
+ 1].type
);
3069 if (noside
== EVAL_SKIP
)
3071 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
3072 return eval_skip_value (exp
);
3074 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3076 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
3077 struct value
*result
;
3079 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3081 /* 'decltype' has special semantics for lvalues. */
3082 if (op
== OP_DECLTYPE
3083 && (sub_op
== BINOP_SUBSCRIPT
3084 || sub_op
== STRUCTOP_MEMBER
3085 || sub_op
== STRUCTOP_MPTR
3086 || sub_op
== UNOP_IND
3087 || sub_op
== STRUCTOP_STRUCT
3088 || sub_op
== STRUCTOP_PTR
3089 || sub_op
== OP_SCOPE
))
3091 type
= value_type (result
);
3093 if (!TYPE_IS_REFERENCE (type
))
3095 type
= lookup_lvalue_reference_type (type
);
3096 result
= allocate_value (type
);
3103 error (_("Attempt to use a type as an expression"));
3107 struct value
*result
;
3108 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
3110 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
3111 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3113 result
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3115 if (noside
!= EVAL_NORMAL
)
3116 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
3118 return cplus_typeid (result
);
3122 /* Removing this case and compiling with gcc -Wall reveals that
3123 a lot of cases are hitting this case. Some of these should
3124 probably be removed from expression.h; others are legitimate
3125 expressions which are (apparently) not fully implemented.
3127 If there are any cases landing here which mean a user error,
3128 then they should be separate cases, with more descriptive
3131 error (_("GDB does not (yet) know how to "
3132 "evaluate that kind of expression"));
3135 gdb_assert_not_reached ("missed return?");
3138 /* Helper for evaluate_subexp_for_address. */
3141 evaluate_subexp_for_address_base (struct expression
*exp
, enum noside noside
,
3144 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3146 struct type
*type
= check_typedef (value_type (x
));
3148 if (TYPE_IS_REFERENCE (type
))
3149 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3151 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3152 return value_zero (lookup_pointer_type (value_type (x
)),
3155 error (_("Attempt to take address of "
3156 "value not located in memory."));
3158 return value_addr (x
);
3161 /* Evaluate a subexpression of EXP, at index *POS,
3162 and return the address of that subexpression.
3163 Advance *POS over the subexpression.
3164 If the subexpression isn't an lvalue, get an error.
3165 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
3166 then only the type of the result need be correct. */
3168 static struct value
*
3169 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
3179 op
= exp
->elts
[pc
].opcode
;
3185 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3187 /* We can't optimize out "&*" if there's a user-defined operator*. */
3188 if (unop_user_defined_p (op
, x
))
3190 x
= value_x_unop (x
, op
, noside
);
3191 goto default_case_after_eval
;
3194 return coerce_array (x
);
3198 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
3199 evaluate_subexp (nullptr, exp
, pos
, noside
));
3201 case UNOP_MEMVAL_TYPE
:
3206 x
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3207 type
= value_type (x
);
3208 return value_cast (lookup_pointer_type (type
),
3209 evaluate_subexp (nullptr, exp
, pos
, noside
));
3213 var
= exp
->elts
[pc
+ 2].symbol
;
3215 /* C++: The "address" of a reference should yield the address
3216 * of the object pointed to. Let value_addr() deal with it. */
3217 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
3221 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3224 lookup_pointer_type (SYMBOL_TYPE (var
));
3225 enum address_class sym_class
= SYMBOL_CLASS (var
);
3227 if (sym_class
== LOC_CONST
3228 || sym_class
== LOC_CONST_BYTES
3229 || sym_class
== LOC_REGISTER
)
3230 error (_("Attempt to take address of register or constant."));
3233 value_zero (type
, not_lval
);
3236 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3238 case OP_VAR_MSYM_VALUE
:
3242 value
*val
= evaluate_var_msym_value (noside
,
3243 exp
->elts
[pc
+ 1].objfile
,
3244 exp
->elts
[pc
+ 2].msymbol
);
3245 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3247 struct type
*type
= lookup_pointer_type (value_type (val
));
3248 return value_zero (type
, not_lval
);
3251 return value_addr (val
);
3255 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3256 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3257 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3258 &exp
->elts
[pc
+ 3].string
,
3261 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3266 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3267 default_case_after_eval
:
3268 return evaluate_subexp_for_address_base (exp
, noside
, x
);
3276 operation::evaluate_for_cast (struct type
*expect_type
,
3277 struct expression
*exp
,
3280 value
*val
= evaluate (expect_type
, exp
, noside
);
3281 if (noside
== EVAL_SKIP
)
3282 return eval_skip_value (exp
);
3283 return value_cast (expect_type
, val
);
3287 operation::evaluate_for_address (struct expression
*exp
, enum noside noside
)
3289 value
*val
= evaluate (nullptr, exp
, noside
);
3290 return evaluate_subexp_for_address_base (exp
, noside
, val
);
3294 scope_operation::evaluate_for_address (struct expression
*exp
,
3297 value
*x
= value_aggregate_elt (std::get
<0> (m_storage
),
3298 std::get
<1> (m_storage
).c_str (),
3301 error (_("There is no field named %s"), std::get
<1> (m_storage
).c_str ());
3306 var_msym_value_operation::evaluate_for_address (struct expression
*exp
,
3309 value
*val
= evaluate_var_msym_value (noside
,
3310 std::get
<1> (m_storage
),
3311 std::get
<0> (m_storage
));
3312 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3314 struct type
*type
= lookup_pointer_type (value_type (val
));
3315 return value_zero (type
, not_lval
);
3318 return value_addr (val
);
3323 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3324 When used in contexts where arrays will be coerced anyway, this is
3325 equivalent to `evaluate_subexp' but much faster because it avoids
3326 actually fetching array contents (perhaps obsolete now that we have
3329 Note that we currently only do the coercion for C expressions, where
3330 arrays are zero based and the coercion is correct. For other languages,
3331 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3332 to decide if coercion is appropriate. */
3335 evaluate_subexp_with_coercion (struct expression
*exp
,
3336 int *pos
, enum noside noside
)
3345 op
= exp
->elts
[pc
].opcode
;
3350 var
= exp
->elts
[pc
+ 2].symbol
;
3351 type
= check_typedef (SYMBOL_TYPE (var
));
3352 if (type
->code () == TYPE_CODE_ARRAY
3353 && !type
->is_vector ()
3354 && CAST_IS_CONVERSION (exp
->language_defn
))
3357 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3358 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3364 return evaluate_subexp (nullptr, exp
, pos
, noside
);
3368 /* Helper function for evaluating the size of a type. */
3371 evaluate_subexp_for_sizeof_base (struct expression
*exp
, struct type
*type
)
3373 /* FIXME: This should be size_t. */
3374 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3375 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3376 "When applied to a reference or a reference type, the result is
3377 the size of the referenced type." */
3378 type
= check_typedef (type
);
3379 if (exp
->language_defn
->la_language
== language_cplus
3380 && (TYPE_IS_REFERENCE (type
)))
3381 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3382 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3385 /* Evaluate a subexpression of EXP, at index *POS,
3386 and return a value for the size of that subexpression.
3387 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3388 we allow side-effects on the operand if its type is a variable
3391 static struct value
*
3392 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3395 /* FIXME: This should be size_t. */
3396 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3403 op
= exp
->elts
[pc
].opcode
;
3407 /* This case is handled specially
3408 so that we avoid creating a value for the result type.
3409 If the result type is very big, it's desirable not to
3410 create a value unnecessarily. */
3413 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3414 type
= check_typedef (value_type (val
));
3415 if (type
->code () != TYPE_CODE_PTR
3416 && !TYPE_IS_REFERENCE (type
)
3417 && type
->code () != TYPE_CODE_ARRAY
)
3418 error (_("Attempt to take contents of a non-pointer value."));
3419 type
= TYPE_TARGET_TYPE (type
);
3420 if (is_dynamic_type (type
))
3421 type
= value_type (value_ind (val
));
3422 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3426 type
= exp
->elts
[pc
+ 1].type
;
3429 case UNOP_MEMVAL_TYPE
:
3431 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3432 type
= value_type (val
);
3436 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3437 if (is_dynamic_type (type
))
3439 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3440 type
= value_type (val
);
3441 if (type
->code () == TYPE_CODE_ARRAY
)
3443 if (type_not_allocated (type
) || type_not_associated (type
))
3444 return value_zero (size_type
, not_lval
);
3445 else if (is_dynamic_type (type
->index_type ())
3446 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
3447 return allocate_optimized_out_value (size_type
);
3454 case OP_VAR_MSYM_VALUE
:
3458 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3459 value
*mval
= evaluate_var_msym_value (noside
,
3460 exp
->elts
[pc
+ 1].objfile
,
3463 type
= value_type (mval
);
3464 if (type
->code () == TYPE_CODE_ERROR
)
3465 error_unknown_type (msymbol
->print_name ());
3467 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3471 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3472 type of the subscript is a variable length array type. In this case we
3473 must re-evaluate the right hand side of the subscription to allow
3475 case BINOP_SUBSCRIPT
:
3476 if (noside
== EVAL_NORMAL
)
3478 int npc
= (*pos
) + 1;
3480 val
= evaluate_subexp (nullptr, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3481 type
= check_typedef (value_type (val
));
3482 if (type
->code () == TYPE_CODE_ARRAY
)
3484 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3485 if (type
->code () == TYPE_CODE_ARRAY
)
3487 type
= type
->index_type ();
3488 /* Only re-evaluate the right hand side if the resulting type
3489 is a variable length type. */
3490 if (type
->bounds ()->flag_bound_evaluated
)
3492 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3493 return value_from_longest
3494 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3503 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3504 type
= value_type (val
);
3508 return evaluate_subexp_for_sizeof_base (exp
, type
);
3515 operation::evaluate_for_sizeof (struct expression
*exp
, enum noside noside
)
3517 value
*val
= evaluate (nullptr, exp
, EVAL_AVOID_SIDE_EFFECTS
);
3518 return evaluate_subexp_for_sizeof_base (exp
, value_type (val
));
3522 var_msym_value_operation::evaluate_for_sizeof (struct expression
*exp
,
3526 minimal_symbol
*msymbol
= std::get
<0> (m_storage
);
3527 value
*mval
= evaluate_var_msym_value (noside
,
3528 std::get
<1> (m_storage
),
3531 struct type
*type
= value_type (mval
);
3532 if (type
->code () == TYPE_CODE_ERROR
)
3533 error_unknown_type (msymbol
->print_name ());
3535 /* FIXME: This should be size_t. */
3536 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3537 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3542 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3543 for that subexpression cast to TO_TYPE. Advance *POS over the
3547 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3549 struct type
*to_type
)
3553 /* Don't let symbols be evaluated with evaluate_subexp because that
3554 throws an "unknown type" error for no-debug data symbols.
3555 Instead, we want the cast to reinterpret the symbol. */
3556 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3557 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3562 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3564 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3565 return value_zero (to_type
, not_lval
);
3567 val
= evaluate_var_msym_value (noside
,
3568 exp
->elts
[pc
+ 1].objfile
,
3569 exp
->elts
[pc
+ 2].msymbol
);
3572 val
= evaluate_var_value (noside
,
3573 exp
->elts
[pc
+ 1].block
,
3574 exp
->elts
[pc
+ 2].symbol
);
3576 if (noside
== EVAL_SKIP
)
3577 return eval_skip_value (exp
);
3579 val
= value_cast (to_type
, val
);
3581 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3582 if (VALUE_LVAL (val
) == lval_memory
)
3584 if (value_lazy (val
))
3585 value_fetch_lazy (val
);
3586 VALUE_LVAL (val
) = not_lval
;
3591 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3592 if (noside
== EVAL_SKIP
)
3593 return eval_skip_value (exp
);
3594 return value_cast (to_type
, val
);
3601 var_msym_value_operation::evaluate_for_cast (struct type
*to_type
,
3602 struct expression
*exp
,
3605 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3606 return value_zero (to_type
, not_lval
);
3608 value
*val
= evaluate_var_msym_value (noside
,
3609 std::get
<1> (m_storage
),
3610 std::get
<0> (m_storage
));
3612 if (noside
== EVAL_SKIP
)
3613 return eval_skip_value (exp
);
3615 val
= value_cast (to_type
, val
);
3617 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3618 if (VALUE_LVAL (val
) == lval_memory
)
3620 if (value_lazy (val
))
3621 value_fetch_lazy (val
);
3622 VALUE_LVAL (val
) = not_lval
;
3629 /* Parse a type expression in the string [P..P+LENGTH). */
3632 parse_and_eval_type (const char *p
, int length
)
3634 char *tmp
= (char *) alloca (length
+ 4);
3637 memcpy (tmp
+ 1, p
, length
);
3638 tmp
[length
+ 1] = ')';
3639 tmp
[length
+ 2] = '0';
3640 tmp
[length
+ 3] = '\0';
3641 expression_up expr
= parse_expression (tmp
);
3642 if (expr
->first_opcode () != UNOP_CAST
)
3643 error (_("Internal error in eval_type."));
3644 return expr
->elts
[1].type
;