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 ());
643 type_instance_operation::evaluate (struct type
*expect_type
,
644 struct expression
*exp
,
647 type_instance_flags flags
= std::get
<0> (m_storage
);
648 std::vector
<type
*> &types
= std::get
<1> (m_storage
);
650 fake_method
fake_expect_type (flags
, types
.size (), types
.data ());
651 return std::get
<2> (m_storage
)->evaluate (fake_expect_type
.type (),
657 /* Helper for evaluating an OP_VAR_VALUE. */
660 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
662 /* JYG: We used to just return value_zero of the symbol type if
663 we're asked to avoid side effects. Otherwise we return
664 value_of_variable (...). However I'm not sure if
665 value_of_variable () has any side effect. We need a full value
666 object returned here for whatis_exp () to call evaluate_type ()
667 and then pass the full value to value_rtti_target_type () if we
668 are dealing with a pointer or reference to a base class and print
671 struct value
*ret
= NULL
;
675 ret
= value_of_variable (var
, blk
);
678 catch (const gdb_exception_error
&except
)
680 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
683 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
694 var_value_operation::evaluate (struct type
*expect_type
,
695 struct expression
*exp
,
698 symbol
*var
= std::get
<0> (m_storage
);
699 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
700 error_unknown_type (var
->print_name ());
701 return evaluate_var_value (noside
, std::get
<1> (m_storage
), var
);
704 } /* namespace expr */
706 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
709 evaluate_var_msym_value (enum noside noside
,
710 struct objfile
*objfile
, minimal_symbol
*msymbol
)
713 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
715 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !the_type
->is_gnu_ifunc ())
716 return value_zero (the_type
, not_lval
);
718 return value_at_lazy (the_type
, address
);
721 /* Helper for returning a value when handling EVAL_SKIP. */
724 eval_skip_value (expression
*exp
)
726 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
729 /* See expression.h. */
732 evaluate_subexp_do_call (expression
*exp
, enum noside noside
,
734 gdb::array_view
<value
*> argvec
,
735 const char *function_name
,
736 type
*default_return_type
)
739 error (_("Cannot evaluate function -- may be inlined"));
740 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
742 /* If the return type doesn't look like a function type,
743 call an error. This can happen if somebody tries to turn
744 a variable into a function call. */
746 type
*ftype
= value_type (callee
);
748 if (ftype
->code () == TYPE_CODE_INTERNAL_FUNCTION
)
750 /* We don't know anything about what the internal
751 function might return, but we have to return
753 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
756 else if (ftype
->code () == TYPE_CODE_XMETHOD
)
758 type
*return_type
= result_type_of_xmethod (callee
, argvec
);
760 if (return_type
== NULL
)
761 error (_("Xmethod is missing return type."));
762 return value_zero (return_type
, not_lval
);
764 else if (ftype
->code () == TYPE_CODE_FUNC
765 || ftype
->code () == TYPE_CODE_METHOD
)
767 if (ftype
->is_gnu_ifunc ())
769 CORE_ADDR address
= value_address (callee
);
770 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
772 if (resolved_type
!= NULL
)
773 ftype
= resolved_type
;
776 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
778 if (return_type
== NULL
)
779 return_type
= default_return_type
;
781 if (return_type
== NULL
)
782 error_call_unknown_return_type (function_name
);
784 return allocate_value (return_type
);
787 error (_("Expression of type other than "
788 "\"Function returning ...\" used as function"));
790 switch (value_type (callee
)->code ())
792 case TYPE_CODE_INTERNAL_FUNCTION
:
793 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
794 callee
, argvec
.size (), argvec
.data ());
795 case TYPE_CODE_XMETHOD
:
796 return call_xmethod (callee
, argvec
);
798 return call_function_by_hand (callee
, default_return_type
, argvec
);
802 /* Helper for evaluating an OP_FUNCALL. */
805 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
813 symbol
*function
= NULL
;
814 char *function_name
= NULL
;
815 const char *var_func_name
= NULL
;
820 exp_opcode op
= exp
->elts
[*pos
].opcode
;
821 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
822 /* Allocate arg vector, including space for the function to be
823 called in argvec[0], a potential `this', and a terminating
825 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
826 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
828 /* First, evaluate the structure into arg2. */
831 if (op
== STRUCTOP_MEMBER
)
833 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
837 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
840 /* If the function is a virtual function, then the aggregate
841 value (providing the structure) plays its part by providing
842 the vtable. Otherwise, it is just along for the ride: call
843 the function directly. */
845 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
847 type
*a1_type
= check_typedef (value_type (arg1
));
848 if (noside
== EVAL_SKIP
)
849 tem
= 1; /* Set it to the right arg index so that all
850 arguments can also be skipped. */
851 else if (a1_type
->code () == TYPE_CODE_METHODPTR
)
853 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
854 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
856 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
858 /* Now, say which argument to start evaluating from. */
863 else if (a1_type
->code () == TYPE_CODE_MEMBERPTR
)
865 struct type
*type_ptr
866 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
867 struct type
*target_type_ptr
868 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
870 /* Now, convert these values to an address. */
871 arg2
= value_cast (type_ptr
, arg2
);
873 long mem_offset
= value_as_long (arg1
);
875 arg1
= value_from_pointer (target_type_ptr
,
876 value_as_long (arg2
) + mem_offset
);
877 arg1
= value_ind (arg1
);
881 error (_("Non-pointer-to-member value used in pointer-to-member "
884 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
886 /* Hair for method invocations. */
890 /* First, evaluate the structure into arg2. */
892 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
893 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
895 if (op
== STRUCTOP_STRUCT
)
897 /* If v is a variable in a register, and the user types
898 v.method (), this will produce an error, because v has no
901 A possible way around this would be to allocate a copy of
902 the variable on the stack, copy in the contents, call the
903 function, and copy out the contents. I.e. convert this
904 from call by reference to call by copy-return (or
905 whatever it's called). However, this does not work
906 because it is not the same: the method being called could
907 stash a copy of the address, and then future uses through
908 that address (after the method returns) would be expected
909 to use the variable itself, not some copy of it. */
910 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
914 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
916 /* Check to see if the operator '->' has been overloaded.
917 If the operator has been overloaded replace arg2 with the
918 value returned by the custom operator and continue
920 while (unop_user_defined_p (op
, arg2
))
922 struct value
*value
= NULL
;
925 value
= value_x_unop (arg2
, op
, noside
);
928 catch (const gdb_exception_error
&except
)
930 if (except
.error
== NOT_FOUND_ERROR
)
939 /* Now, say which argument to start evaluating from. */
942 else if (op
== OP_SCOPE
943 && overload_resolution
944 && (exp
->language_defn
->la_language
== language_cplus
))
946 /* Unpack it locally so we can properly handle overload
952 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
953 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
954 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
955 name
= &exp
->elts
[pc2
+ 3].string
;
958 function_name
= NULL
;
959 if (type
->code () == TYPE_CODE_NAMESPACE
)
961 function
= cp_lookup_symbol_namespace (type
->name (),
963 get_selected_block (0),
965 if (function
== NULL
)
966 error (_("No symbol \"%s\" in namespace \"%s\"."),
967 name
, type
->name ());
970 /* arg2 is left as NULL on purpose. */
974 gdb_assert (type
->code () == TYPE_CODE_STRUCT
975 || type
->code () == TYPE_CODE_UNION
);
976 function_name
= name
;
978 /* We need a properly typed value for method lookup. For
979 static methods arg2 is otherwise unused. */
980 arg2
= value_zero (type
, lval_memory
);
985 else if (op
== OP_ADL_FUNC
)
987 /* Save the function position and move pos so that the arguments
994 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
995 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
999 /* Non-method function call. */
1003 /* If this is a C++ function wait until overload resolution. */
1004 if (op
== OP_VAR_VALUE
1005 && overload_resolution
1006 && (exp
->language_defn
->la_language
== language_cplus
))
1008 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1013 if (op
== OP_VAR_MSYM_VALUE
)
1015 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1016 var_func_name
= msym
->print_name ();
1018 else if (op
== OP_VAR_VALUE
)
1020 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1021 var_func_name
= sym
->print_name ();
1024 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1025 type
*type
= value_type (argvec
[0]);
1026 if (type
&& type
->code () == TYPE_CODE_PTR
)
1027 type
= TYPE_TARGET_TYPE (type
);
1028 if (type
&& type
->code () == TYPE_CODE_FUNC
)
1030 for (; tem
<= nargs
&& tem
<= type
->num_fields (); tem
++)
1032 argvec
[tem
] = evaluate_subexp (type
->field (tem
- 1).type (),
1039 /* Evaluate arguments (if not already done, e.g., namespace::func()
1040 and overload-resolution is off). */
1041 for (; tem
<= nargs
; tem
++)
1043 /* Ensure that array expressions are coerced into pointer
1045 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1048 /* Signal end of arglist. */
1051 if (noside
== EVAL_SKIP
)
1052 return eval_skip_value (exp
);
1054 if (op
== OP_ADL_FUNC
)
1056 struct symbol
*symp
;
1059 int string_pc
= save_pos1
+ 3;
1061 /* Extract the function name. */
1062 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1063 func_name
= (char *) alloca (name_len
+ 1);
1064 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1066 find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1068 NON_METHOD
, /* not method */
1069 NULL
, NULL
, /* pass NULL symbol since
1070 symbol is unknown */
1071 NULL
, &symp
, NULL
, 0, noside
);
1073 /* Now fix the expression being evaluated. */
1074 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1075 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1078 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1079 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1081 int static_memfuncp
;
1084 /* Method invocation: stuff "this" as first parameter. If the
1085 method turns out to be static we undo this below. */
1090 /* Name of method from expression. */
1091 tstr
= &exp
->elts
[pc2
+ 2].string
;
1094 tstr
= function_name
;
1096 if (overload_resolution
&& (exp
->language_defn
->la_language
1099 /* Language is C++, do some overload resolution before
1101 struct value
*valp
= NULL
;
1103 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1105 METHOD
, /* method */
1106 &arg2
, /* the object */
1108 &static_memfuncp
, 0, noside
);
1110 if (op
== OP_SCOPE
&& !static_memfuncp
)
1112 /* For the time being, we don't handle this. */
1113 error (_("Call to overloaded function %s requires "
1117 argvec
[1] = arg2
; /* the ``this'' pointer */
1118 argvec
[0] = valp
; /* Use the method found after overload
1122 /* Non-C++ case -- or no overload resolution. */
1124 struct value
*temp
= arg2
;
1126 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1128 op
== STRUCTOP_STRUCT
1129 ? "structure" : "structure pointer");
1130 /* value_struct_elt updates temp with the correct value of
1131 the ``this'' pointer if necessary, so modify argvec[1] to
1132 reflect any ``this'' changes. */
1134 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1135 value_address (temp
)
1136 + value_embedded_offset (temp
));
1137 argvec
[1] = arg2
; /* the ``this'' pointer */
1140 /* Take out `this' if needed. */
1141 if (static_memfuncp
)
1143 argvec
[1] = argvec
[0];
1148 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1150 /* Pointer to member. argvec[1] is already set up. */
1153 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1155 /* Non-member function being called. */
1156 /* fn: This can only be done for C++ functions. A C-style
1157 function in a C++ program, for instance, does not have the
1158 fields that are expected here. */
1160 if (overload_resolution
&& (exp
->language_defn
->la_language
1163 /* Language is C++, do some overload resolution before
1165 struct symbol
*symp
;
1168 /* If a scope has been specified disable ADL. */
1172 if (op
== OP_VAR_VALUE
)
1173 function
= exp
->elts
[save_pos1
+2].symbol
;
1175 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1176 NULL
, /* no need for name */
1177 NON_METHOD
, /* not method */
1178 NULL
, function
, /* the function */
1179 NULL
, &symp
, NULL
, no_adl
, noside
);
1181 if (op
== OP_VAR_VALUE
)
1183 /* Now fix the expression being evaluated. */
1184 exp
->elts
[save_pos1
+2].symbol
= symp
;
1185 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1189 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1193 /* Not C++, or no overload resolution allowed. */
1194 /* Nothing to be done; argvec already correctly set up. */
1199 /* It is probably a C-style function. */
1200 /* Nothing to be done; argvec already correctly set up. */
1203 return evaluate_subexp_do_call (exp
, noside
, argvec
[0],
1204 gdb::make_array_view (argvec
+ 1, nargs
),
1205 var_func_name
, expect_type
);
1208 /* Return true if type is integral or reference to integral */
1211 is_integral_or_integral_reference (struct type
*type
)
1213 if (is_integral_type (type
))
1216 type
= check_typedef (type
);
1217 return (type
!= nullptr
1218 && TYPE_IS_REFERENCE (type
)
1219 && is_integral_type (TYPE_TARGET_TYPE (type
)));
1222 /* Helper function that implements the body of OP_SCOPE. */
1225 eval_op_scope (struct type
*expect_type
, struct expression
*exp
,
1227 struct type
*type
, const char *string
)
1229 if (noside
== EVAL_SKIP
)
1230 return eval_skip_value (exp
);
1231 struct value
*arg1
= value_aggregate_elt (type
, string
, expect_type
,
1234 error (_("There is no field named %s"), string
);
1238 /* Helper function that implements the body of OP_VAR_ENTRY_VALUE. */
1241 eval_op_var_entry_value (struct type
*expect_type
, struct expression
*exp
,
1242 enum noside noside
, symbol
*sym
)
1244 if (noside
== EVAL_SKIP
)
1245 return eval_skip_value (exp
);
1246 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1247 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1249 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1250 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1251 error (_("Symbol \"%s\" does not have any specific entry value"),
1252 sym
->print_name ());
1254 struct frame_info
*frame
= get_selected_frame (NULL
);
1255 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1258 /* Helper function that implements the body of OP_VAR_MSYM_VALUE. */
1261 eval_op_var_msym_value (struct type
*expect_type
, struct expression
*exp
,
1262 enum noside noside
, bool outermost_p
,
1263 minimal_symbol
*msymbol
, struct objfile
*objfile
)
1265 value
*val
= evaluate_var_msym_value (noside
, objfile
, msymbol
);
1267 struct type
*type
= value_type (val
);
1268 if (type
->code () == TYPE_CODE_ERROR
1269 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| !outermost_p
))
1270 error_unknown_type (msymbol
->print_name ());
1274 /* Helper function that implements the body of OP_FUNC_STATIC_VAR. */
1277 eval_op_func_static_var (struct type
*expect_type
, struct expression
*exp
,
1279 value
*func
, const char *var
)
1281 if (noside
== EVAL_SKIP
)
1282 return eval_skip_value (exp
);
1283 CORE_ADDR addr
= value_address (func
);
1284 const block
*blk
= block_for_pc (addr
);
1285 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1286 if (sym
.symbol
== NULL
)
1287 error (_("No symbol \"%s\" in specified context."), var
);
1288 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1291 /* Helper function that implements the body of OP_REGISTER. */
1294 eval_op_register (struct type
*expect_type
, struct expression
*exp
,
1295 enum noside noside
, const char *name
)
1300 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1301 name
, strlen (name
));
1303 error (_("Register $%s not available."), name
);
1305 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1306 a value with the appropriate register type. Unfortunately,
1307 we don't have easy access to the type of user registers.
1308 So for these registers, we fetch the register value regardless
1309 of the evaluation mode. */
1310 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1311 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1312 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1314 val
= value_of_register (regno
, get_selected_frame (NULL
));
1316 error (_("Value of register %s not available."), name
);
1321 /* Helper function that implements the body of OP_STRING. */
1324 eval_op_string (struct type
*expect_type
, struct expression
*exp
,
1325 enum noside noside
, int len
, const char *string
)
1327 if (noside
== EVAL_SKIP
)
1328 return eval_skip_value (exp
);
1329 struct type
*type
= language_string_char_type (exp
->language_defn
,
1331 return value_string (string
, len
, type
);
1334 /* Helper function that implements the body of OP_OBJC_SELECTOR. */
1337 eval_op_objc_selector (struct type
*expect_type
, struct expression
*exp
,
1341 if (noside
== EVAL_SKIP
)
1342 return eval_skip_value (exp
);
1344 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1345 return value_from_longest (selector_type
,
1346 lookup_child_selector (exp
->gdbarch
, sel
));
1349 /* Helper function that implements the body of BINOP_CONCAT. */
1352 eval_op_concat (struct type
*expect_type
, struct expression
*exp
,
1353 enum noside noside
, struct value
*arg1
, struct value
*arg2
)
1355 if (noside
== EVAL_SKIP
)
1356 return eval_skip_value (exp
);
1357 if (binop_user_defined_p (BINOP_CONCAT
, arg1
, arg2
))
1358 return value_x_binop (arg1
, arg2
, BINOP_CONCAT
, OP_NULL
, noside
);
1360 return value_concat (arg1
, arg2
);
1363 /* A helper function for TERNOP_SLICE. */
1366 eval_op_ternop (struct type
*expect_type
, struct expression
*exp
,
1368 struct value
*array
, struct value
*low
, struct value
*upper
)
1370 if (noside
== EVAL_SKIP
)
1371 return eval_skip_value (exp
);
1372 int lowbound
= value_as_long (low
);
1373 int upperbound
= value_as_long (upper
);
1374 return value_slice (array
, lowbound
, upperbound
- lowbound
+ 1);
1377 /* A helper function for STRUCTOP_STRUCT. */
1380 eval_op_structop_struct (struct type
*expect_type
, struct expression
*exp
,
1382 struct value
*arg1
, const char *string
)
1384 if (noside
== EVAL_SKIP
)
1385 return eval_skip_value (exp
);
1386 struct value
*arg3
= value_struct_elt (&arg1
, NULL
, string
,
1388 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1389 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1393 /* A helper function for STRUCTOP_PTR. */
1396 eval_op_structop_ptr (struct type
*expect_type
, struct expression
*exp
,
1398 struct value
*arg1
, const char *string
)
1400 if (noside
== EVAL_SKIP
)
1401 return eval_skip_value (exp
);
1403 /* Check to see if operator '->' has been overloaded. If so replace
1404 arg1 with the value returned by evaluating operator->(). */
1405 while (unop_user_defined_p (STRUCTOP_PTR
, arg1
))
1407 struct value
*value
= NULL
;
1410 value
= value_x_unop (arg1
, STRUCTOP_PTR
, noside
);
1413 catch (const gdb_exception_error
&except
)
1415 if (except
.error
== NOT_FOUND_ERROR
)
1424 /* JYG: if print object is on we need to replace the base type
1425 with rtti type in order to continue on with successful
1426 lookup of member / method only available in the rtti type. */
1428 struct type
*arg_type
= value_type (arg1
);
1429 struct type
*real_type
;
1430 int full
, using_enc
;
1432 struct value_print_options opts
;
1434 get_user_print_options (&opts
);
1435 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
1436 && (TYPE_TARGET_TYPE (arg_type
)->code () == TYPE_CODE_STRUCT
))
1438 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1441 arg1
= value_cast (real_type
, arg1
);
1445 struct value
*arg3
= value_struct_elt (&arg1
, NULL
, string
,
1446 NULL
, "structure pointer");
1447 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1448 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1452 /* A helper function for STRUCTOP_MEMBER. */
1455 eval_op_member (struct type
*expect_type
, struct expression
*exp
,
1457 struct value
*arg1
, struct value
*arg2
)
1461 if (noside
== EVAL_SKIP
)
1462 return eval_skip_value (exp
);
1465 struct type
*type
= check_typedef (value_type (arg2
));
1466 switch (type
->code ())
1468 case TYPE_CODE_METHODPTR
:
1469 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1470 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1473 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1474 gdb_assert (value_type (arg2
)->code () == TYPE_CODE_PTR
);
1475 return value_ind (arg2
);
1478 case TYPE_CODE_MEMBERPTR
:
1479 /* Now, convert these values to an address. */
1480 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1483 mem_offset
= value_as_long (arg2
);
1485 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1486 value_as_long (arg1
) + mem_offset
);
1487 return value_ind (arg3
);
1490 error (_("non-pointer-to-member value used "
1491 "in pointer-to-member construct"));
1495 /* A helper function for BINOP_ADD. */
1498 eval_op_add (struct type
*expect_type
, struct expression
*exp
,
1500 struct value
*arg1
, struct value
*arg2
)
1502 if (noside
== EVAL_SKIP
)
1503 return eval_skip_value (exp
);
1504 if (binop_user_defined_p (BINOP_ADD
, arg1
, arg2
))
1505 return value_x_binop (arg1
, arg2
, BINOP_ADD
, OP_NULL
, noside
);
1506 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1507 && is_integral_or_integral_reference (value_type (arg2
)))
1508 return value_ptradd (arg1
, value_as_long (arg2
));
1509 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
1510 && is_integral_or_integral_reference (value_type (arg1
)))
1511 return value_ptradd (arg2
, value_as_long (arg1
));
1514 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1515 return value_binop (arg1
, arg2
, BINOP_ADD
);
1519 /* A helper function for BINOP_SUB. */
1522 eval_op_sub (struct type
*expect_type
, struct expression
*exp
,
1524 struct value
*arg1
, struct value
*arg2
)
1526 if (noside
== EVAL_SKIP
)
1527 return eval_skip_value (exp
);
1528 if (binop_user_defined_p (BINOP_SUB
, arg1
, arg2
))
1529 return value_x_binop (arg1
, arg2
, BINOP_SUB
, OP_NULL
, noside
);
1530 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1531 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
1533 /* FIXME -- should be ptrdiff_t */
1534 struct type
*type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1535 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1537 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
1538 && is_integral_or_integral_reference (value_type (arg2
)))
1539 return value_ptradd (arg1
, - value_as_long (arg2
));
1542 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1543 return value_binop (arg1
, arg2
, BINOP_SUB
);
1547 /* Helper function for several different binary operations. */
1550 eval_op_binary (struct type
*expect_type
, struct expression
*exp
,
1551 enum noside noside
, enum exp_opcode op
,
1552 struct value
*arg1
, struct value
*arg2
)
1554 if (noside
== EVAL_SKIP
)
1555 return eval_skip_value (exp
);
1556 if (binop_user_defined_p (op
, arg1
, arg2
))
1557 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1560 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1561 fudge arg2 to avoid division-by-zero, the caller is
1562 (theoretically) only looking for the type of the result. */
1563 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1564 /* ??? Do we really want to test for BINOP_MOD here?
1565 The implementation of value_binop gives it a well-defined
1568 || op
== BINOP_INTDIV
1571 && value_logical_not (arg2
))
1573 struct value
*v_one
;
1575 v_one
= value_one (value_type (arg2
));
1576 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1577 return value_binop (arg1
, v_one
, op
);
1581 /* For shift and integer exponentiation operations,
1582 only promote the first argument. */
1583 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1584 && is_integral_type (value_type (arg2
)))
1585 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1587 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1589 return value_binop (arg1
, arg2
, op
);
1594 /* A helper function for BINOP_SUBSCRIPT. */
1597 eval_op_subscript (struct type
*expect_type
, struct expression
*exp
,
1598 enum noside noside
, enum exp_opcode op
,
1599 struct value
*arg1
, struct value
*arg2
)
1601 if (noside
== EVAL_SKIP
)
1602 return eval_skip_value (exp
);
1603 if (binop_user_defined_p (op
, arg1
, arg2
))
1604 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1607 /* If the user attempts to subscript something that is not an
1608 array or pointer type (like a plain int variable for example),
1609 then report this as an error. */
1611 arg1
= coerce_ref (arg1
);
1612 struct type
*type
= check_typedef (value_type (arg1
));
1613 if (type
->code () != TYPE_CODE_ARRAY
1614 && type
->code () != TYPE_CODE_PTR
)
1617 error (_("cannot subscript something of type `%s'"),
1620 error (_("cannot subscript requested type"));
1623 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1624 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1626 return value_subscript (arg1
, value_as_long (arg2
));
1630 /* A helper function for BINOP_EQUAL. */
1633 eval_op_equal (struct type
*expect_type
, struct expression
*exp
,
1634 enum noside noside
, enum exp_opcode op
,
1635 struct value
*arg1
, struct value
*arg2
)
1637 if (noside
== EVAL_SKIP
)
1638 return eval_skip_value (exp
);
1639 if (binop_user_defined_p (op
, arg1
, arg2
))
1641 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1645 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1646 int tem
= value_equal (arg1
, arg2
);
1647 struct type
*type
= language_bool_type (exp
->language_defn
,
1649 return value_from_longest (type
, (LONGEST
) tem
);
1653 /* A helper function for BINOP_NOTEQUAL. */
1656 eval_op_notequal (struct type
*expect_type
, struct expression
*exp
,
1657 enum noside noside
, enum exp_opcode op
,
1658 struct value
*arg1
, struct value
*arg2
)
1660 if (noside
== EVAL_SKIP
)
1661 return eval_skip_value (exp
);
1662 if (binop_user_defined_p (op
, arg1
, arg2
))
1664 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1668 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1669 int tem
= value_equal (arg1
, arg2
);
1670 struct type
*type
= language_bool_type (exp
->language_defn
,
1672 return value_from_longest (type
, (LONGEST
) ! tem
);
1676 /* A helper function for BINOP_LESS. */
1679 eval_op_less (struct type
*expect_type
, struct expression
*exp
,
1680 enum noside noside
, enum exp_opcode op
,
1681 struct value
*arg1
, struct value
*arg2
)
1683 if (noside
== EVAL_SKIP
)
1684 return eval_skip_value (exp
);
1685 if (binop_user_defined_p (op
, arg1
, arg2
))
1687 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1691 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1692 int tem
= value_less (arg1
, arg2
);
1693 struct type
*type
= language_bool_type (exp
->language_defn
,
1695 return value_from_longest (type
, (LONGEST
) tem
);
1699 /* A helper function for BINOP_GTR. */
1702 eval_op_gtr (struct type
*expect_type
, struct expression
*exp
,
1703 enum noside noside
, enum exp_opcode op
,
1704 struct value
*arg1
, struct value
*arg2
)
1706 if (noside
== EVAL_SKIP
)
1707 return eval_skip_value (exp
);
1708 if (binop_user_defined_p (op
, arg1
, arg2
))
1710 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1714 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1715 int tem
= value_less (arg2
, arg1
);
1716 struct type
*type
= language_bool_type (exp
->language_defn
,
1718 return value_from_longest (type
, (LONGEST
) tem
);
1722 /* A helper function for BINOP_GEQ. */
1725 eval_op_geq (struct type
*expect_type
, struct expression
*exp
,
1726 enum noside noside
, enum exp_opcode op
,
1727 struct value
*arg1
, struct value
*arg2
)
1729 if (noside
== EVAL_SKIP
)
1730 return eval_skip_value (exp
);
1731 if (binop_user_defined_p (op
, arg1
, arg2
))
1733 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1737 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1738 int tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1739 struct type
*type
= language_bool_type (exp
->language_defn
,
1741 return value_from_longest (type
, (LONGEST
) tem
);
1745 /* A helper function for BINOP_LEQ. */
1748 eval_op_leq (struct type
*expect_type
, struct expression
*exp
,
1749 enum noside noside
, enum exp_opcode op
,
1750 struct value
*arg1
, struct value
*arg2
)
1752 if (noside
== EVAL_SKIP
)
1753 return eval_skip_value (exp
);
1754 if (binop_user_defined_p (op
, arg1
, arg2
))
1756 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1760 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1761 int tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1762 struct type
*type
= language_bool_type (exp
->language_defn
,
1764 return value_from_longest (type
, (LONGEST
) tem
);
1768 /* A helper function for BINOP_REPEAT. */
1771 eval_op_repeat (struct type
*expect_type
, struct expression
*exp
,
1772 enum noside noside
, enum exp_opcode op
,
1773 struct value
*arg1
, struct value
*arg2
)
1775 if (noside
== EVAL_SKIP
)
1776 return eval_skip_value (exp
);
1777 struct type
*type
= check_typedef (value_type (arg2
));
1778 if (type
->code () != TYPE_CODE_INT
1779 && type
->code () != TYPE_CODE_ENUM
)
1780 error (_("Non-integral right operand for \"@\" operator."));
1781 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1783 return allocate_repeat_value (value_type (arg1
),
1784 longest_to_int (value_as_long (arg2
)));
1787 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1790 /* A helper function for UNOP_PLUS. */
1793 eval_op_plus (struct type
*expect_type
, struct expression
*exp
,
1794 enum noside noside
, enum exp_opcode op
,
1797 if (noside
== EVAL_SKIP
)
1798 return eval_skip_value (exp
);
1799 if (unop_user_defined_p (op
, arg1
))
1800 return value_x_unop (arg1
, op
, noside
);
1803 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1804 return value_pos (arg1
);
1808 /* A helper function for UNOP_NEG. */
1811 eval_op_neg (struct type
*expect_type
, struct expression
*exp
,
1812 enum noside noside
, enum exp_opcode op
,
1815 if (noside
== EVAL_SKIP
)
1816 return eval_skip_value (exp
);
1817 if (unop_user_defined_p (op
, arg1
))
1818 return value_x_unop (arg1
, op
, noside
);
1821 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1822 return value_neg (arg1
);
1826 /* A helper function for UNOP_COMPLEMENT. */
1829 eval_op_complement (struct type
*expect_type
, struct expression
*exp
,
1830 enum noside noside
, enum exp_opcode op
,
1833 if (noside
== EVAL_SKIP
)
1834 return eval_skip_value (exp
);
1835 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1836 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1839 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1840 return value_complement (arg1
);
1844 /* A helper function for UNOP_LOGICAL_NOT. */
1847 eval_op_lognot (struct type
*expect_type
, struct expression
*exp
,
1848 enum noside noside
, enum exp_opcode op
,
1851 if (noside
== EVAL_SKIP
)
1852 return eval_skip_value (exp
);
1853 if (unop_user_defined_p (op
, arg1
))
1854 return value_x_unop (arg1
, op
, noside
);
1857 struct type
*type
= language_bool_type (exp
->language_defn
,
1859 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
1863 /* A helper function for UNOP_IND. */
1866 eval_op_ind (struct type
*expect_type
, struct expression
*exp
,
1870 struct type
*type
= check_typedef (value_type (arg1
));
1871 if (type
->code () == TYPE_CODE_METHODPTR
1872 || type
->code () == TYPE_CODE_MEMBERPTR
)
1873 error (_("Attempt to dereference pointer "
1874 "to member without an object"));
1875 if (noside
== EVAL_SKIP
)
1876 return eval_skip_value (exp
);
1877 if (unop_user_defined_p (UNOP_IND
, arg1
))
1878 return value_x_unop (arg1
, UNOP_IND
, noside
);
1879 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1881 type
= check_typedef (value_type (arg1
));
1883 /* If the type pointed to is dynamic then in order to resolve the
1884 dynamic properties we must actually dereference the pointer.
1885 There is a risk that this dereference will have side-effects
1886 in the inferior, but being able to print accurate type
1887 information seems worth the risk. */
1888 if ((type
->code () != TYPE_CODE_PTR
1889 && !TYPE_IS_REFERENCE (type
))
1890 || !is_dynamic_type (TYPE_TARGET_TYPE (type
)))
1892 if (type
->code () == TYPE_CODE_PTR
1893 || TYPE_IS_REFERENCE (type
)
1894 /* In C you can dereference an array to get the 1st elt. */
1895 || type
->code () == TYPE_CODE_ARRAY
)
1896 return value_zero (TYPE_TARGET_TYPE (type
),
1898 else if (type
->code () == TYPE_CODE_INT
)
1899 /* GDB allows dereferencing an int. */
1900 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1903 error (_("Attempt to take contents of a non-pointer value."));
1907 /* Allow * on an integer so we can cast it to whatever we want.
1908 This returns an int, which seems like the most C-like thing to
1909 do. "long long" variables are rare enough that
1910 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
1911 if (type
->code () == TYPE_CODE_INT
)
1912 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
1913 (CORE_ADDR
) value_as_address (arg1
));
1914 return value_ind (arg1
);
1917 /* A helper function for UNOP_ALIGNOF. */
1920 eval_op_alignof (struct type
*expect_type
, struct expression
*exp
,
1924 struct type
*type
= value_type (arg1
);
1925 /* FIXME: This should be size_t. */
1926 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
1927 ULONGEST align
= type_align (type
);
1929 error (_("could not determine alignment of type"));
1930 return value_from_longest (size_type
, align
);
1933 /* A helper function for UNOP_MEMVAL. */
1936 eval_op_memval (struct type
*expect_type
, struct expression
*exp
,
1938 struct value
*arg1
, struct type
*type
)
1940 if (noside
== EVAL_SKIP
)
1941 return eval_skip_value (exp
);
1942 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1943 return value_zero (type
, lval_memory
);
1945 return value_at_lazy (type
, value_as_address (arg1
));
1948 /* A helper function for UNOP_PREINCREMENT. */
1951 eval_op_preinc (struct type
*expect_type
, struct expression
*exp
,
1952 enum noside noside
, enum exp_opcode op
,
1955 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1957 else if (unop_user_defined_p (op
, arg1
))
1959 return value_x_unop (arg1
, op
, noside
);
1964 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
1965 arg2
= value_ptradd (arg1
, 1);
1968 struct value
*tmp
= arg1
;
1970 arg2
= value_one (value_type (arg1
));
1971 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1972 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
1975 return value_assign (arg1
, arg2
);
1979 /* A helper function for UNOP_PREDECREMENT. */
1982 eval_op_predec (struct type
*expect_type
, struct expression
*exp
,
1983 enum noside noside
, enum exp_opcode op
,
1986 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1988 else if (unop_user_defined_p (op
, arg1
))
1990 return value_x_unop (arg1
, op
, noside
);
1995 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
1996 arg2
= value_ptradd (arg1
, -1);
1999 struct value
*tmp
= arg1
;
2001 arg2
= value_one (value_type (arg1
));
2002 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2003 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2006 return value_assign (arg1
, arg2
);
2010 /* A helper function for UNOP_POSTINCREMENT. */
2013 eval_op_postinc (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_ADD
);
2039 value_assign (arg1
, arg2
);
2044 /* A helper function for UNOP_POSTDECREMENT. */
2047 eval_op_postdec (struct type
*expect_type
, struct expression
*exp
,
2048 enum noside noside
, enum exp_opcode op
,
2051 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2053 else if (unop_user_defined_p (op
, arg1
))
2055 return value_x_unop (arg1
, op
, noside
);
2059 struct value
*arg3
= value_non_lval (arg1
);
2062 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2063 arg2
= value_ptradd (arg1
, -1);
2066 struct value
*tmp
= arg1
;
2068 arg2
= value_one (value_type (arg1
));
2069 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2070 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2073 value_assign (arg1
, arg2
);
2078 /* A helper function for OP_TYPE. */
2081 eval_op_type (struct type
*expect_type
, struct expression
*exp
,
2082 enum noside noside
, struct type
*type
)
2084 if (noside
== EVAL_SKIP
)
2085 return eval_skip_value (exp
);
2086 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2087 return allocate_value (type
);
2089 error (_("Attempt to use a type name as an expression"));
2092 /* A helper function for BINOP_ASSIGN_MODIFY. */
2095 eval_binop_assign_modify (struct type
*expect_type
, struct expression
*exp
,
2096 enum noside noside
, enum exp_opcode op
,
2097 struct value
*arg1
, struct value
*arg2
)
2099 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2101 if (binop_user_defined_p (op
, arg1
, arg2
))
2102 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2103 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2105 && is_integral_type (value_type (arg2
)))
2106 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2107 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2109 && is_integral_type (value_type (arg2
)))
2110 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2113 struct value
*tmp
= arg1
;
2115 /* For shift and integer exponentiation operations,
2116 only promote the first argument. */
2117 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2118 && is_integral_type (value_type (arg2
)))
2119 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2121 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2123 arg2
= value_binop (tmp
, arg2
, op
);
2125 return value_assign (arg1
, arg2
);
2128 /* Note that ARGS needs 2 empty slots up front and must end with a
2130 static struct value
*
2131 eval_op_objc_msgcall (struct type
*expect_type
, struct expression
*exp
,
2132 enum noside noside
, CORE_ADDR selector
,
2133 value
*target
, gdb::array_view
<value
*> args
)
2135 CORE_ADDR responds_selector
= 0;
2136 CORE_ADDR method_selector
= 0;
2138 int struct_return
= 0;
2140 struct value
*msg_send
= NULL
;
2141 struct value
*msg_send_stret
= NULL
;
2142 int gnu_runtime
= 0;
2144 struct value
*method
= NULL
;
2145 struct value
*called_method
= NULL
;
2147 struct type
*selector_type
= NULL
;
2148 struct type
*long_type
;
2151 struct value
*ret
= NULL
;
2156 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2157 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2159 if (value_as_long (target
) == 0)
2160 return value_from_longest (long_type
, 0);
2162 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
2165 /* Find the method dispatch (Apple runtime) or method lookup
2166 (GNU runtime) function for Objective-C. These will be used
2167 to lookup the symbol information for the method. If we
2168 can't find any symbol information, then we'll use these to
2169 call the method, otherwise we can call the method
2170 directly. The msg_send_stret function is used in the special
2171 case of a method that returns a structure (Apple runtime
2175 type
= selector_type
;
2177 type
= lookup_function_type (type
);
2178 type
= lookup_pointer_type (type
);
2179 type
= lookup_function_type (type
);
2180 type
= lookup_pointer_type (type
);
2182 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
2184 = find_function_in_inferior ("objc_msg_lookup", NULL
);
2186 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
2187 msg_send_stret
= value_from_pointer (type
,
2188 value_as_address (msg_send_stret
));
2192 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
2193 /* Special dispatcher for methods returning structs. */
2195 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
2198 /* Verify the target object responds to this method. The
2199 standard top-level 'Object' class uses a different name for
2200 the verification method than the non-standard, but more
2201 often used, 'NSObject' class. Make sure we check for both. */
2204 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
2205 if (responds_selector
== 0)
2207 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
2209 if (responds_selector
== 0)
2210 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
2213 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
2214 if (method_selector
== 0)
2216 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
2218 if (method_selector
== 0)
2219 error (_("no 'methodFor:' or 'methodForSelector:' method"));
2221 /* Call the verification method, to make sure that the target
2222 class implements the desired method. */
2224 argvec
[0] = msg_send
;
2226 argvec
[2] = value_from_longest (long_type
, responds_selector
);
2227 argvec
[3] = value_from_longest (long_type
, selector
);
2230 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2233 /* Function objc_msg_lookup returns a pointer. */
2235 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2237 if (value_as_long (ret
) == 0)
2238 error (_("Target does not respond to this message selector."));
2240 /* Call "methodForSelector:" method, to get the address of a
2241 function method that implements this selector for this
2242 class. If we can find a symbol at that address, then we
2243 know the return type, parameter types etc. (that's a good
2246 argvec
[0] = msg_send
;
2248 argvec
[2] = value_from_longest (long_type
, method_selector
);
2249 argvec
[3] = value_from_longest (long_type
, selector
);
2252 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2256 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2259 /* ret should now be the selector. */
2261 addr
= value_as_long (ret
);
2264 struct symbol
*sym
= NULL
;
2266 /* The address might point to a function descriptor;
2267 resolve it to the actual code address instead. */
2268 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
2269 current_top_target ());
2271 /* Is it a high_level symbol? */
2272 sym
= find_pc_function (addr
);
2274 method
= value_of_variable (sym
, 0);
2277 /* If we found a method with symbol information, check to see
2278 if it returns a struct. Otherwise assume it doesn't. */
2283 struct type
*val_type
;
2285 funaddr
= find_function_addr (method
, &val_type
);
2287 block_for_pc (funaddr
);
2289 val_type
= check_typedef (val_type
);
2291 if ((val_type
== NULL
)
2292 || (val_type
->code () == TYPE_CODE_ERROR
))
2294 if (expect_type
!= NULL
)
2295 val_type
= expect_type
;
2298 struct_return
= using_struct_return (exp
->gdbarch
, method
,
2301 else if (expect_type
!= NULL
)
2303 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
2304 check_typedef (expect_type
));
2307 /* Found a function symbol. Now we will substitute its
2308 value in place of the message dispatcher (obj_msgSend),
2309 so that we call the method directly instead of thru
2310 the dispatcher. The main reason for doing this is that
2311 we can now evaluate the return value and parameter values
2312 according to their known data types, in case we need to
2313 do things like promotion, dereferencing, special handling
2314 of structs and doubles, etc.
2316 We want to use the type signature of 'method', but still
2317 jump to objc_msgSend() or objc_msgSend_stret() to better
2318 mimic the behavior of the runtime. */
2322 if (value_type (method
)->code () != TYPE_CODE_FUNC
)
2323 error (_("method address has symbol information "
2324 "with non-function type; skipping"));
2326 /* Create a function pointer of the appropriate type, and
2327 replace its value with the value of msg_send or
2328 msg_send_stret. We must use a pointer here, as
2329 msg_send and msg_send_stret are of pointer type, and
2330 the representation may be different on systems that use
2331 function descriptors. */
2334 = value_from_pointer (lookup_pointer_type (value_type (method
)),
2335 value_as_address (msg_send_stret
));
2338 = value_from_pointer (lookup_pointer_type (value_type (method
)),
2339 value_as_address (msg_send
));
2344 called_method
= msg_send_stret
;
2346 called_method
= msg_send
;
2349 if (noside
== EVAL_SKIP
)
2350 return eval_skip_value (exp
);
2352 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2354 /* If the return type doesn't look like a function type,
2355 call an error. This can happen if somebody tries to
2356 turn a variable into a function call. This is here
2357 because people often want to call, eg, strcmp, which
2358 gdb doesn't know is a function. If gdb isn't asked for
2359 it's opinion (ie. through "whatis"), it won't offer
2362 struct type
*callee_type
= value_type (called_method
);
2364 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
2365 callee_type
= TYPE_TARGET_TYPE (callee_type
);
2366 callee_type
= TYPE_TARGET_TYPE (callee_type
);
2370 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
2371 return allocate_value (expect_type
);
2373 return allocate_value (callee_type
);
2376 error (_("Expression of type other than "
2377 "\"method returning ...\" used as a method"));
2380 /* Now depending on whether we found a symbol for the method,
2381 we will either call the runtime dispatcher or the method
2385 args
[1] = value_from_longest (long_type
, selector
);
2387 if (gnu_runtime
&& (method
!= NULL
))
2389 /* Function objc_msg_lookup returns a pointer. */
2390 struct type
*tem_type
= value_type (called_method
);
2391 tem_type
= lookup_pointer_type (lookup_function_type (tem_type
));
2392 deprecated_set_value_type (called_method
, tem_type
);
2393 called_method
= call_function_by_hand (called_method
, NULL
, args
);
2396 return call_function_by_hand (called_method
, NULL
, args
);
2399 /* Helper function for MULTI_SUBSCRIPT. */
2401 static struct value
*
2402 eval_multi_subscript (struct type
*expect_type
, struct expression
*exp
,
2403 enum noside noside
, value
*arg1
,
2404 gdb::array_view
<value
*> args
)
2406 if (noside
== EVAL_SKIP
)
2408 for (value
*arg2
: args
)
2410 if (binop_user_defined_p (MULTI_SUBSCRIPT
, arg1
, arg2
))
2412 arg1
= value_x_binop (arg1
, arg2
, MULTI_SUBSCRIPT
, OP_NULL
, noside
);
2416 arg1
= coerce_ref (arg1
);
2417 struct type
*type
= check_typedef (value_type (arg1
));
2419 switch (type
->code ())
2422 case TYPE_CODE_ARRAY
:
2423 case TYPE_CODE_STRING
:
2424 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2429 error (_("cannot subscript something of type `%s'"),
2432 error (_("cannot subscript requested type"));
2443 objc_msgcall_operation::evaluate (struct type
*expect_type
,
2444 struct expression
*exp
,
2447 enum noside sub_no_side
= EVAL_NORMAL
;
2448 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2450 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2451 sub_no_side
= EVAL_NORMAL
;
2453 sub_no_side
= noside
;
2455 = std::get
<1> (m_storage
)->evaluate (selector_type
, exp
, sub_no_side
);
2457 if (value_as_long (target
) == 0)
2458 sub_no_side
= EVAL_AVOID_SIDE_EFFECTS
;
2460 sub_no_side
= noside
;
2461 std::vector
<operation_up
> &args
= std::get
<2> (m_storage
);
2462 value
**argvec
= XALLOCAVEC (struct value
*, args
.size () + 3);
2463 argvec
[0] = nullptr;
2464 argvec
[1] = nullptr;
2465 for (int i
= 0; i
< args
.size (); ++i
)
2466 argvec
[i
+ 2] = args
[i
]->evaluate_with_coercion (exp
, sub_no_side
);
2467 argvec
[args
.size () + 2] = nullptr;
2469 return eval_op_objc_msgcall (expect_type
, exp
, noside
, std::
2470 get
<0> (m_storage
), target
,
2471 gdb::make_array_view (argvec
,
2476 multi_subscript_operation::evaluate (struct type
*expect_type
,
2477 struct expression
*exp
,
2480 value
*arg1
= std::get
<0> (m_storage
)->evaluate_with_coercion (exp
, noside
);
2481 std::vector
<operation_up
> &values
= std::get
<1> (m_storage
);
2482 value
**argvec
= XALLOCAVEC (struct value
*, values
.size ());
2483 for (int ix
= 0; ix
< values
.size (); ++ix
)
2484 argvec
[ix
] = values
[ix
]->evaluate_with_coercion (exp
, noside
);
2485 return eval_multi_subscript (expect_type
, exp
, noside
, arg1
,
2486 gdb::make_array_view (argvec
, values
.size ()));
2490 logical_and_operation::evaluate (struct type
*expect_type
,
2491 struct expression
*exp
,
2494 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2495 if (noside
== EVAL_SKIP
)
2496 return eval_skip_value (exp
);
2498 value
*arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
,
2499 EVAL_AVOID_SIDE_EFFECTS
);
2501 if (binop_user_defined_p (BINOP_LOGICAL_AND
, arg1
, arg2
))
2503 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2504 return value_x_binop (arg1
, arg2
, BINOP_LOGICAL_AND
, OP_NULL
, noside
);
2508 int tem
= value_logical_not (arg1
);
2511 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2512 tem
= value_logical_not (arg2
);
2514 struct type
*type
= language_bool_type (exp
->language_defn
,
2516 return value_from_longest (type
, !tem
);
2521 logical_or_operation::evaluate (struct type
*expect_type
,
2522 struct expression
*exp
,
2525 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2526 if (noside
== EVAL_SKIP
)
2527 return eval_skip_value (exp
);
2529 value
*arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
,
2530 EVAL_AVOID_SIDE_EFFECTS
);
2532 if (binop_user_defined_p (BINOP_LOGICAL_OR
, arg1
, arg2
))
2534 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2535 return value_x_binop (arg1
, arg2
, BINOP_LOGICAL_OR
, OP_NULL
, noside
);
2539 int tem
= value_logical_not (arg1
);
2542 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2543 tem
= value_logical_not (arg2
);
2546 struct type
*type
= language_bool_type (exp
->language_defn
,
2548 return value_from_longest (type
, !tem
);
2555 evaluate_subexp_standard (struct type
*expect_type
,
2556 struct expression
*exp
, int *pos
,
2560 int tem
, tem2
, tem3
;
2562 struct value
*arg1
= NULL
;
2563 struct value
*arg2
= NULL
;
2566 struct value
**argvec
;
2568 struct type
**arg_types
;
2571 op
= exp
->elts
[pc
].opcode
;
2576 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2577 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
2578 return eval_op_scope (expect_type
, exp
, noside
,
2579 exp
->elts
[pc
+ 1].type
,
2580 &exp
->elts
[pc
+ 3].string
);
2584 return value_from_longest (exp
->elts
[pc
+ 1].type
,
2585 exp
->elts
[pc
+ 2].longconst
);
2589 return value_from_contents (exp
->elts
[pc
+ 1].type
,
2590 exp
->elts
[pc
+ 2].floatconst
);
2596 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
2597 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
2598 error_unknown_type (var
->print_name ());
2599 if (noside
!= EVAL_SKIP
)
2600 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
2603 /* Return a dummy value of the correct type when skipping, so
2604 that parent functions know what is to be skipped. */
2605 return allocate_value (SYMBOL_TYPE (var
));
2609 case OP_VAR_MSYM_VALUE
:
2613 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
2614 return eval_op_var_msym_value (expect_type
, exp
, noside
,
2616 exp
->elts
[pc
+ 1].objfile
);
2619 case OP_VAR_ENTRY_VALUE
:
2623 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
2625 return eval_op_var_entry_value (expect_type
, exp
, noside
, sym
);
2628 case OP_FUNC_STATIC_VAR
:
2629 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2630 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2631 if (noside
== EVAL_SKIP
)
2632 return eval_skip_value (exp
);
2635 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
2637 return eval_op_func_static_var (expect_type
, exp
, noside
, func
,
2638 &exp
->elts
[pc
+ 2].string
);
2644 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
2648 const char *name
= &exp
->elts
[pc
+ 2].string
;
2650 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
2651 return eval_op_register (expect_type
, exp
, noside
, name
);
2655 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2656 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
2658 case OP_INTERNALVAR
:
2660 return value_of_internalvar (exp
->gdbarch
,
2661 exp
->elts
[pc
+ 1].internalvar
);
2664 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2665 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2666 return eval_op_string (expect_type
, exp
, noside
, tem
,
2667 &exp
->elts
[pc
+ 2].string
);
2669 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
2670 NSString constant. */
2671 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2672 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2673 if (noside
== EVAL_SKIP
)
2674 return eval_skip_value (exp
);
2675 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
2679 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2680 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2681 nargs
= tem3
- tem2
+ 1;
2682 type
= expect_type
? check_typedef (expect_type
) : nullptr;
2684 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2685 && type
->code () == TYPE_CODE_STRUCT
)
2687 struct value
*rec
= allocate_value (expect_type
);
2689 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
2690 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
2693 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2694 && type
->code () == TYPE_CODE_ARRAY
)
2696 struct type
*range_type
= type
->index_type ();
2697 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
2698 struct value
*array
= allocate_value (expect_type
);
2699 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
2700 LONGEST low_bound
, high_bound
, index
;
2702 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
2705 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
2708 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
2709 for (tem
= nargs
; --nargs
>= 0;)
2711 struct value
*element
;
2713 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
2714 if (value_type (element
) != element_type
)
2715 element
= value_cast (element_type
, element
);
2716 if (index
> high_bound
)
2717 /* To avoid memory corruption. */
2718 error (_("Too many array elements"));
2719 memcpy (value_contents_raw (array
)
2720 + (index
- low_bound
) * element_size
,
2721 value_contents (element
),
2728 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
2729 && type
->code () == TYPE_CODE_SET
)
2731 struct value
*set
= allocate_value (expect_type
);
2732 gdb_byte
*valaddr
= value_contents_raw (set
);
2733 struct type
*element_type
= type
->index_type ();
2734 struct type
*check_type
= element_type
;
2735 LONGEST low_bound
, high_bound
;
2737 /* Get targettype of elementtype. */
2738 while (check_type
->code () == TYPE_CODE_RANGE
2739 || check_type
->code () == TYPE_CODE_TYPEDEF
)
2740 check_type
= TYPE_TARGET_TYPE (check_type
);
2742 if (!get_discrete_bounds (element_type
, &low_bound
, &high_bound
))
2743 error (_("(power)set type with unknown size"));
2744 memset (valaddr
, '\0', TYPE_LENGTH (type
));
2745 for (tem
= 0; tem
< nargs
; tem
++)
2747 LONGEST range_low
, range_high
;
2748 struct type
*range_low_type
, *range_high_type
;
2749 struct value
*elem_val
;
2751 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
2752 range_low_type
= range_high_type
= value_type (elem_val
);
2753 range_low
= range_high
= value_as_long (elem_val
);
2755 /* Check types of elements to avoid mixture of elements from
2756 different types. Also check if type of element is "compatible"
2757 with element type of powerset. */
2758 if (range_low_type
->code () == TYPE_CODE_RANGE
)
2759 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
2760 if (range_high_type
->code () == TYPE_CODE_RANGE
)
2761 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
2762 if ((range_low_type
->code () != range_high_type
->code ())
2763 || (range_low_type
->code () == TYPE_CODE_ENUM
2764 && (range_low_type
!= range_high_type
)))
2765 /* different element modes. */
2766 error (_("POWERSET tuple elements of different mode"));
2767 if ((check_type
->code () != range_low_type
->code ())
2768 || (check_type
->code () == TYPE_CODE_ENUM
2769 && range_low_type
!= check_type
))
2770 error (_("incompatible POWERSET tuple elements"));
2771 if (range_low
> range_high
)
2773 warning (_("empty POWERSET tuple range"));
2776 if (range_low
< low_bound
|| range_high
> high_bound
)
2777 error (_("POWERSET tuple element out of range"));
2778 range_low
-= low_bound
;
2779 range_high
-= low_bound
;
2780 for (; range_low
<= range_high
; range_low
++)
2782 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
2784 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
2785 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
2786 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
2793 argvec
= XALLOCAVEC (struct value
*, nargs
);
2794 for (tem
= 0; tem
< nargs
; tem
++)
2796 /* Ensure that array expressions are coerced into pointer
2798 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
2800 if (noside
== EVAL_SKIP
)
2801 return eval_skip_value (exp
);
2802 return value_array (tem2
, tem3
, argvec
);
2806 struct value
*array
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2807 struct value
*low
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2808 struct value
*upper
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2809 return eval_op_ternop (expect_type
, exp
, noside
, array
, low
, upper
);
2813 /* Skip third and second args to evaluate the first one. */
2814 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2815 if (value_logical_not (arg1
))
2817 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2818 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2822 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2823 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2827 case OP_OBJC_SELECTOR
:
2828 { /* Objective C @selector operator. */
2829 char *sel
= &exp
->elts
[pc
+ 2].string
;
2830 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2832 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
2834 sel
[len
] = 0; /* Make sure it's terminated. */
2836 return eval_op_objc_selector (expect_type
, exp
, noside
, sel
);
2839 case OP_OBJC_MSGCALL
:
2840 { /* Objective C message (method) call. */
2841 CORE_ADDR selector
= 0;
2843 enum noside sub_no_side
= EVAL_NORMAL
;
2845 struct value
*target
= NULL
;
2847 struct type
*selector_type
= NULL
;
2849 selector
= exp
->elts
[pc
+ 1].longconst
;
2850 nargs
= exp
->elts
[pc
+ 2].longconst
;
2851 argvec
= XALLOCAVEC (struct value
*, nargs
+ 3);
2855 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2857 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2858 sub_no_side
= EVAL_NORMAL
;
2860 sub_no_side
= noside
;
2862 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
2864 if (value_as_long (target
) == 0)
2865 sub_no_side
= EVAL_SKIP
;
2867 sub_no_side
= noside
;
2869 /* Now depending on whether we found a symbol for the method,
2870 we will either call the runtime dispatcher or the method
2873 argvec
[0] = nullptr;
2874 argvec
[1] = nullptr;
2875 /* User-supplied arguments. */
2876 for (tem
= 0; tem
< nargs
; tem
++)
2877 argvec
[tem
+ 2] = evaluate_subexp_with_coercion (exp
, pos
,
2879 argvec
[tem
+ 3] = 0;
2881 auto call_args
= gdb::make_array_view (argvec
, nargs
+ 3);
2883 return eval_op_objc_msgcall (expect_type
, exp
, noside
, selector
,
2889 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
2892 /* We have a complex number, There should be 2 floating
2893 point numbers that compose it. */
2895 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2896 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2898 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
2900 case STRUCTOP_STRUCT
:
2901 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2902 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2903 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2904 return eval_op_structop_struct (expect_type
, exp
, noside
, arg1
,
2905 &exp
->elts
[pc
+ 2].string
);
2908 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2909 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2910 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2911 return eval_op_structop_ptr (expect_type
, exp
, noside
, arg1
,
2912 &exp
->elts
[pc
+ 2].string
);
2914 case STRUCTOP_MEMBER
:
2916 if (op
== STRUCTOP_MEMBER
)
2917 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2919 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2921 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2923 return eval_op_member (expect_type
, exp
, noside
, arg1
, arg2
);
2927 type_instance_flags flags
2928 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2929 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2930 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2931 for (ix
= 0; ix
< nargs
; ++ix
)
2932 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2934 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
2935 *(pos
) += 4 + nargs
;
2936 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
2941 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2942 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2943 return eval_op_concat (expect_type
, exp
, noside
, arg1
, arg2
);
2946 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2947 /* Special-case assignments where the left-hand-side is a
2948 convenience variable -- in these, don't bother setting an
2949 expected type. This avoids a weird case where re-assigning a
2950 string or array to an internal variable could error with "Too
2951 many array elements". */
2952 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
2954 : value_type (arg1
),
2957 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2959 if (binop_user_defined_p (op
, arg1
, arg2
))
2960 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2962 return value_assign (arg1
, arg2
);
2964 case BINOP_ASSIGN_MODIFY
:
2966 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2967 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2968 op
= exp
->elts
[pc
+ 1].opcode
;
2969 return eval_binop_assign_modify (expect_type
, exp
, noside
, op
,
2973 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2974 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2975 return eval_op_add (expect_type
, exp
, noside
, arg1
, arg2
);
2978 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2979 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2980 return eval_op_sub (expect_type
, exp
, noside
, arg1
, arg2
);
2990 case BINOP_BITWISE_AND
:
2991 case BINOP_BITWISE_IOR
:
2992 case BINOP_BITWISE_XOR
:
2993 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2994 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2995 return eval_op_binary (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2997 case BINOP_SUBSCRIPT
:
2998 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2999 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3000 return eval_op_subscript (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3002 case MULTI_SUBSCRIPT
:
3004 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
3005 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
3006 argvec
= XALLOCAVEC (struct value
*, nargs
);
3007 for (ix
= 0; ix
< nargs
; ++ix
)
3008 argvec
[ix
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
3009 return eval_multi_subscript (expect_type
, exp
, noside
, arg1
,
3010 gdb::make_array_view (argvec
, nargs
));
3012 case BINOP_LOGICAL_AND
:
3013 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3014 if (noside
== EVAL_SKIP
)
3016 evaluate_subexp (nullptr, exp
, pos
, noside
);
3017 return eval_skip_value (exp
);
3021 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3024 if (binop_user_defined_p (op
, arg1
, arg2
))
3026 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3027 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
3031 tem
= value_logical_not (arg1
);
3033 = evaluate_subexp (nullptr, exp
, pos
, (tem
? EVAL_SKIP
: noside
));
3034 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
3035 return value_from_longest (type
,
3036 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
3039 case BINOP_LOGICAL_OR
:
3040 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3041 if (noside
== EVAL_SKIP
)
3043 evaluate_subexp (nullptr, exp
, pos
, noside
);
3044 return eval_skip_value (exp
);
3048 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3051 if (binop_user_defined_p (op
, arg1
, arg2
))
3053 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3054 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
3058 tem
= value_logical_not (arg1
);
3060 = evaluate_subexp (nullptr, exp
, pos
, (!tem
? EVAL_SKIP
: noside
));
3061 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
3062 return value_from_longest (type
,
3063 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
3067 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3068 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3069 return eval_op_equal (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3071 case BINOP_NOTEQUAL
:
3072 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3073 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3074 return eval_op_notequal (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3077 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3078 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3079 return eval_op_less (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3082 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3083 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3084 return eval_op_gtr (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3087 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3088 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3089 return eval_op_geq (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3092 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3093 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
3094 return eval_op_leq (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3097 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3098 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3099 return eval_op_repeat (expect_type
, exp
, noside
, op
, arg1
, arg2
);
3102 evaluate_subexp (nullptr, exp
, pos
, noside
);
3103 return evaluate_subexp (nullptr, exp
, pos
, noside
);
3106 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3107 return eval_op_plus (expect_type
, exp
, noside
, op
, arg1
);
3110 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3111 return eval_op_neg (expect_type
, exp
, noside
, op
, arg1
);
3113 case UNOP_COMPLEMENT
:
3114 /* C++: check for and handle destructor names. */
3116 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3117 return eval_op_complement (expect_type
, exp
, noside
, op
, arg1
);
3119 case UNOP_LOGICAL_NOT
:
3120 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3121 return eval_op_lognot (expect_type
, exp
, noside
, op
, arg1
);
3124 if (expect_type
&& expect_type
->code () == TYPE_CODE_PTR
)
3125 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
3126 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3127 return eval_op_ind (expect_type
, exp
, noside
, arg1
);
3130 /* C++: check for and handle pointer to members. */
3132 if (noside
== EVAL_SKIP
)
3134 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
3135 return eval_skip_value (exp
);
3138 return evaluate_subexp_for_address (exp
, pos
, noside
);
3141 if (noside
== EVAL_SKIP
)
3143 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
3144 return eval_skip_value (exp
);
3146 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
3149 arg1
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3150 return eval_op_alignof (expect_type
, exp
, noside
, arg1
);
3154 type
= exp
->elts
[pc
+ 1].type
;
3155 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
3157 case UNOP_CAST_TYPE
:
3158 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3159 type
= value_type (arg1
);
3160 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
3162 case UNOP_DYNAMIC_CAST
:
3163 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3164 type
= value_type (arg1
);
3165 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
3166 if (noside
== EVAL_SKIP
)
3167 return eval_skip_value (exp
);
3168 return value_dynamic_cast (type
, arg1
);
3170 case UNOP_REINTERPRET_CAST
:
3171 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3172 type
= value_type (arg1
);
3173 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
3174 if (noside
== EVAL_SKIP
)
3175 return eval_skip_value (exp
);
3176 return value_reinterpret_cast (type
, arg1
);
3180 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3181 return eval_op_memval (expect_type
, exp
, noside
, arg1
,
3182 exp
->elts
[pc
+ 1].type
);
3184 case UNOP_MEMVAL_TYPE
:
3185 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3186 type
= value_type (arg1
);
3187 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3188 return eval_op_memval (expect_type
, exp
, noside
, arg1
, type
);
3190 case UNOP_PREINCREMENT
:
3191 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3192 return eval_op_preinc (expect_type
, exp
, noside
, op
, arg1
);
3194 case UNOP_PREDECREMENT
:
3195 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3196 return eval_op_predec (expect_type
, exp
, noside
, op
, arg1
);
3198 case UNOP_POSTINCREMENT
:
3199 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3200 return eval_op_postinc (expect_type
, exp
, noside
, op
, arg1
);
3202 case UNOP_POSTDECREMENT
:
3203 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
3204 return eval_op_postdec (expect_type
, exp
, noside
, op
, arg1
);
3208 return value_of_this (exp
->language_defn
);
3211 /* The value is not supposed to be used. This is here to make it
3212 easier to accommodate expressions that contain types. */
3214 return eval_op_type (expect_type
, exp
, noside
, exp
->elts
[pc
+ 1].type
);
3218 if (noside
== EVAL_SKIP
)
3220 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
3221 return eval_skip_value (exp
);
3223 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3225 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
3226 struct value
*result
;
3228 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3230 /* 'decltype' has special semantics for lvalues. */
3231 if (op
== OP_DECLTYPE
3232 && (sub_op
== BINOP_SUBSCRIPT
3233 || sub_op
== STRUCTOP_MEMBER
3234 || sub_op
== STRUCTOP_MPTR
3235 || sub_op
== UNOP_IND
3236 || sub_op
== STRUCTOP_STRUCT
3237 || sub_op
== STRUCTOP_PTR
3238 || sub_op
== OP_SCOPE
))
3240 type
= value_type (result
);
3242 if (!TYPE_IS_REFERENCE (type
))
3244 type
= lookup_lvalue_reference_type (type
);
3245 result
= allocate_value (type
);
3252 error (_("Attempt to use a type as an expression"));
3256 struct value
*result
;
3257 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
3259 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
3260 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3262 result
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3264 if (noside
!= EVAL_NORMAL
)
3265 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
3267 return cplus_typeid (result
);
3271 /* Removing this case and compiling with gcc -Wall reveals that
3272 a lot of cases are hitting this case. Some of these should
3273 probably be removed from expression.h; others are legitimate
3274 expressions which are (apparently) not fully implemented.
3276 If there are any cases landing here which mean a user error,
3277 then they should be separate cases, with more descriptive
3280 error (_("GDB does not (yet) know how to "
3281 "evaluate that kind of expression"));
3284 gdb_assert_not_reached ("missed return?");
3287 /* Helper for evaluate_subexp_for_address. */
3290 evaluate_subexp_for_address_base (struct expression
*exp
, enum noside noside
,
3293 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3295 struct type
*type
= check_typedef (value_type (x
));
3297 if (TYPE_IS_REFERENCE (type
))
3298 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3300 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3301 return value_zero (lookup_pointer_type (value_type (x
)),
3304 error (_("Attempt to take address of "
3305 "value not located in memory."));
3307 return value_addr (x
);
3310 /* Evaluate a subexpression of EXP, at index *POS,
3311 and return the address of that subexpression.
3312 Advance *POS over the subexpression.
3313 If the subexpression isn't an lvalue, get an error.
3314 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
3315 then only the type of the result need be correct. */
3317 static struct value
*
3318 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
3328 op
= exp
->elts
[pc
].opcode
;
3334 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3336 /* We can't optimize out "&*" if there's a user-defined operator*. */
3337 if (unop_user_defined_p (op
, x
))
3339 x
= value_x_unop (x
, op
, noside
);
3340 goto default_case_after_eval
;
3343 return coerce_array (x
);
3347 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
3348 evaluate_subexp (nullptr, exp
, pos
, noside
));
3350 case UNOP_MEMVAL_TYPE
:
3355 x
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3356 type
= value_type (x
);
3357 return value_cast (lookup_pointer_type (type
),
3358 evaluate_subexp (nullptr, exp
, pos
, noside
));
3362 var
= exp
->elts
[pc
+ 2].symbol
;
3364 /* C++: The "address" of a reference should yield the address
3365 * of the object pointed to. Let value_addr() deal with it. */
3366 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
3370 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3373 lookup_pointer_type (SYMBOL_TYPE (var
));
3374 enum address_class sym_class
= SYMBOL_CLASS (var
);
3376 if (sym_class
== LOC_CONST
3377 || sym_class
== LOC_CONST_BYTES
3378 || sym_class
== LOC_REGISTER
)
3379 error (_("Attempt to take address of register or constant."));
3382 value_zero (type
, not_lval
);
3385 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3387 case OP_VAR_MSYM_VALUE
:
3391 value
*val
= evaluate_var_msym_value (noside
,
3392 exp
->elts
[pc
+ 1].objfile
,
3393 exp
->elts
[pc
+ 2].msymbol
);
3394 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3396 struct type
*type
= lookup_pointer_type (value_type (val
));
3397 return value_zero (type
, not_lval
);
3400 return value_addr (val
);
3404 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3405 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3406 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3407 &exp
->elts
[pc
+ 3].string
,
3410 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3415 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
3416 default_case_after_eval
:
3417 return evaluate_subexp_for_address_base (exp
, noside
, x
);
3425 operation::evaluate_for_cast (struct type
*expect_type
,
3426 struct expression
*exp
,
3429 value
*val
= evaluate (expect_type
, exp
, noside
);
3430 if (noside
== EVAL_SKIP
)
3431 return eval_skip_value (exp
);
3432 return value_cast (expect_type
, val
);
3436 operation::evaluate_for_address (struct expression
*exp
, enum noside noside
)
3438 value
*val
= evaluate (nullptr, exp
, noside
);
3439 return evaluate_subexp_for_address_base (exp
, noside
, val
);
3443 scope_operation::evaluate_for_address (struct expression
*exp
,
3446 value
*x
= value_aggregate_elt (std::get
<0> (m_storage
),
3447 std::get
<1> (m_storage
).c_str (),
3450 error (_("There is no field named %s"), std::get
<1> (m_storage
).c_str ());
3455 unop_ind_base_operation::evaluate_for_address (struct expression
*exp
,
3458 value
*x
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
3460 /* We can't optimize out "&*" if there's a user-defined operator*. */
3461 if (unop_user_defined_p (UNOP_IND
, x
))
3463 x
= value_x_unop (x
, UNOP_IND
, noside
);
3464 return evaluate_subexp_for_address_base (exp
, noside
, x
);
3467 return coerce_array (x
);
3471 var_msym_value_operation::evaluate_for_address (struct expression
*exp
,
3474 value
*val
= evaluate_var_msym_value (noside
,
3475 std::get
<1> (m_storage
),
3476 std::get
<0> (m_storage
));
3477 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3479 struct type
*type
= lookup_pointer_type (value_type (val
));
3480 return value_zero (type
, not_lval
);
3483 return value_addr (val
);
3487 unop_memval_operation::evaluate_for_address (struct expression
*exp
,
3490 return value_cast (lookup_pointer_type (std::get
<1> (m_storage
)),
3491 std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
));
3495 unop_memval_type_operation::evaluate_for_address (struct expression
*exp
,
3498 value
*typeval
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
3499 EVAL_AVOID_SIDE_EFFECTS
);
3500 struct type
*type
= value_type (typeval
);
3501 return value_cast (lookup_pointer_type (type
),
3502 std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
));
3507 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3508 When used in contexts where arrays will be coerced anyway, this is
3509 equivalent to `evaluate_subexp' but much faster because it avoids
3510 actually fetching array contents (perhaps obsolete now that we have
3513 Note that we currently only do the coercion for C expressions, where
3514 arrays are zero based and the coercion is correct. For other languages,
3515 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3516 to decide if coercion is appropriate. */
3519 evaluate_subexp_with_coercion (struct expression
*exp
,
3520 int *pos
, enum noside noside
)
3529 op
= exp
->elts
[pc
].opcode
;
3534 var
= exp
->elts
[pc
+ 2].symbol
;
3535 type
= check_typedef (SYMBOL_TYPE (var
));
3536 if (type
->code () == TYPE_CODE_ARRAY
3537 && !type
->is_vector ()
3538 && CAST_IS_CONVERSION (exp
->language_defn
))
3541 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3542 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3548 return evaluate_subexp (nullptr, exp
, pos
, noside
);
3556 var_value_operation::evaluate_for_address (struct expression
*exp
,
3559 symbol
*var
= std::get
<0> (m_storage
);
3561 /* C++: The "address" of a reference should yield the address
3562 * of the object pointed to. Let value_addr() deal with it. */
3563 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
3564 return operation::evaluate_for_address (exp
, noside
);
3566 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3568 struct type
*type
= lookup_pointer_type (SYMBOL_TYPE (var
));
3569 enum address_class sym_class
= SYMBOL_CLASS (var
);
3571 if (sym_class
== LOC_CONST
3572 || sym_class
== LOC_CONST_BYTES
3573 || sym_class
== LOC_REGISTER
)
3574 error (_("Attempt to take address of register or constant."));
3576 return value_zero (type
, not_lval
);
3579 return address_of_variable (var
, std::get
<1> (m_storage
));
3583 var_value_operation::evaluate_with_coercion (struct expression
*exp
,
3586 struct symbol
*var
= std::get
<0> (m_storage
);
3587 struct type
*type
= check_typedef (SYMBOL_TYPE (var
));
3588 if (type
->code () == TYPE_CODE_ARRAY
3589 && !type
->is_vector ()
3590 && CAST_IS_CONVERSION (exp
->language_defn
))
3592 struct value
*val
= address_of_variable (var
, std::get
<1> (m_storage
));
3593 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)), val
);
3595 return evaluate (nullptr, exp
, noside
);
3600 /* Helper function for evaluating the size of a type. */
3603 evaluate_subexp_for_sizeof_base (struct expression
*exp
, struct type
*type
)
3605 /* FIXME: This should be size_t. */
3606 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3607 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3608 "When applied to a reference or a reference type, the result is
3609 the size of the referenced type." */
3610 type
= check_typedef (type
);
3611 if (exp
->language_defn
->la_language
== language_cplus
3612 && (TYPE_IS_REFERENCE (type
)))
3613 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3614 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3617 /* Evaluate a subexpression of EXP, at index *POS,
3618 and return a value for the size of that subexpression.
3619 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3620 we allow side-effects on the operand if its type is a variable
3623 static struct value
*
3624 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3627 /* FIXME: This should be size_t. */
3628 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3635 op
= exp
->elts
[pc
].opcode
;
3639 /* This case is handled specially
3640 so that we avoid creating a value for the result type.
3641 If the result type is very big, it's desirable not to
3642 create a value unnecessarily. */
3645 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3646 type
= check_typedef (value_type (val
));
3647 if (type
->code () != TYPE_CODE_PTR
3648 && !TYPE_IS_REFERENCE (type
)
3649 && type
->code () != TYPE_CODE_ARRAY
)
3650 error (_("Attempt to take contents of a non-pointer value."));
3651 type
= TYPE_TARGET_TYPE (type
);
3652 if (is_dynamic_type (type
))
3653 type
= value_type (value_ind (val
));
3654 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3658 type
= exp
->elts
[pc
+ 1].type
;
3661 case UNOP_MEMVAL_TYPE
:
3663 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3664 type
= value_type (val
);
3668 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3669 if (is_dynamic_type (type
))
3671 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3672 type
= value_type (val
);
3673 if (type
->code () == TYPE_CODE_ARRAY
)
3675 if (type_not_allocated (type
) || type_not_associated (type
))
3676 return value_zero (size_type
, not_lval
);
3677 else if (is_dynamic_type (type
->index_type ())
3678 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
3679 return allocate_optimized_out_value (size_type
);
3686 case OP_VAR_MSYM_VALUE
:
3690 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3691 value
*mval
= evaluate_var_msym_value (noside
,
3692 exp
->elts
[pc
+ 1].objfile
,
3695 type
= value_type (mval
);
3696 if (type
->code () == TYPE_CODE_ERROR
)
3697 error_unknown_type (msymbol
->print_name ());
3699 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3703 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3704 type of the subscript is a variable length array type. In this case we
3705 must re-evaluate the right hand side of the subscription to allow
3707 case BINOP_SUBSCRIPT
:
3708 if (noside
== EVAL_NORMAL
)
3710 int npc
= (*pos
) + 1;
3712 val
= evaluate_subexp (nullptr, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3713 type
= check_typedef (value_type (val
));
3714 if (type
->code () == TYPE_CODE_ARRAY
)
3716 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3717 if (type
->code () == TYPE_CODE_ARRAY
)
3719 type
= type
->index_type ();
3720 /* Only re-evaluate the right hand side if the resulting type
3721 is a variable length type. */
3722 if (type
->bounds ()->flag_bound_evaluated
)
3724 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3725 return value_from_longest
3726 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3735 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3736 type
= value_type (val
);
3740 return evaluate_subexp_for_sizeof_base (exp
, type
);
3747 operation::evaluate_for_sizeof (struct expression
*exp
, enum noside noside
)
3749 value
*val
= evaluate (nullptr, exp
, EVAL_AVOID_SIDE_EFFECTS
);
3750 return evaluate_subexp_for_sizeof_base (exp
, value_type (val
));
3754 var_msym_value_operation::evaluate_for_sizeof (struct expression
*exp
,
3758 minimal_symbol
*msymbol
= std::get
<0> (m_storage
);
3759 value
*mval
= evaluate_var_msym_value (noside
,
3760 std::get
<1> (m_storage
),
3763 struct type
*type
= value_type (mval
);
3764 if (type
->code () == TYPE_CODE_ERROR
)
3765 error_unknown_type (msymbol
->print_name ());
3767 /* FIXME: This should be size_t. */
3768 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3769 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3773 subscript_operation::evaluate_for_sizeof (struct expression
*exp
,
3776 if (noside
== EVAL_NORMAL
)
3778 value
*val
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
3779 EVAL_AVOID_SIDE_EFFECTS
);
3780 struct type
*type
= check_typedef (value_type (val
));
3781 if (type
->code () == TYPE_CODE_ARRAY
)
3783 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3784 if (type
->code () == TYPE_CODE_ARRAY
)
3786 type
= type
->index_type ();
3787 /* Only re-evaluate the right hand side if the resulting type
3788 is a variable length type. */
3789 if (type
->bounds ()->flag_bound_evaluated
)
3791 val
= evaluate (nullptr, exp
, EVAL_NORMAL
);
3792 /* FIXME: This should be size_t. */
3793 struct type
*size_type
3794 = builtin_type (exp
->gdbarch
)->builtin_int
;
3795 return value_from_longest
3796 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3802 return operation::evaluate_for_sizeof (exp
, noside
);
3806 unop_ind_base_operation::evaluate_for_sizeof (struct expression
*exp
,
3809 value
*val
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
3810 EVAL_AVOID_SIDE_EFFECTS
);
3811 struct type
*type
= check_typedef (value_type (val
));
3812 if (type
->code () != TYPE_CODE_PTR
3813 && !TYPE_IS_REFERENCE (type
)
3814 && type
->code () != TYPE_CODE_ARRAY
)
3815 error (_("Attempt to take contents of a non-pointer value."));
3816 type
= TYPE_TARGET_TYPE (type
);
3817 if (is_dynamic_type (type
))
3818 type
= value_type (value_ind (val
));
3819 /* FIXME: This should be size_t. */
3820 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3821 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3825 unop_memval_operation::evaluate_for_sizeof (struct expression
*exp
,
3828 return evaluate_subexp_for_sizeof_base (exp
, std::get
<1> (m_storage
));
3832 unop_memval_type_operation::evaluate_for_sizeof (struct expression
*exp
,
3835 value
*typeval
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
3836 EVAL_AVOID_SIDE_EFFECTS
);
3837 return evaluate_subexp_for_sizeof_base (exp
, value_type (typeval
));
3841 var_value_operation::evaluate_for_sizeof (struct expression
*exp
,
3844 struct type
*type
= SYMBOL_TYPE (std::get
<0> (m_storage
));
3845 if (is_dynamic_type (type
))
3847 value
*val
= evaluate (nullptr, exp
, EVAL_NORMAL
);
3848 type
= value_type (val
);
3849 if (type
->code () == TYPE_CODE_ARRAY
)
3851 /* FIXME: This should be size_t. */
3852 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3853 if (type_not_allocated (type
) || type_not_associated (type
))
3854 return value_zero (size_type
, not_lval
);
3855 else if (is_dynamic_type (type
->index_type ())
3856 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
3857 return allocate_optimized_out_value (size_type
);
3860 return evaluate_subexp_for_sizeof_base (exp
, type
);
3865 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3866 for that subexpression cast to TO_TYPE. Advance *POS over the
3870 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3872 struct type
*to_type
)
3876 /* Don't let symbols be evaluated with evaluate_subexp because that
3877 throws an "unknown type" error for no-debug data symbols.
3878 Instead, we want the cast to reinterpret the symbol. */
3879 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3880 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3885 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3887 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3888 return value_zero (to_type
, not_lval
);
3890 val
= evaluate_var_msym_value (noside
,
3891 exp
->elts
[pc
+ 1].objfile
,
3892 exp
->elts
[pc
+ 2].msymbol
);
3895 val
= evaluate_var_value (noside
,
3896 exp
->elts
[pc
+ 1].block
,
3897 exp
->elts
[pc
+ 2].symbol
);
3899 if (noside
== EVAL_SKIP
)
3900 return eval_skip_value (exp
);
3902 val
= value_cast (to_type
, val
);
3904 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3905 if (VALUE_LVAL (val
) == lval_memory
)
3907 if (value_lazy (val
))
3908 value_fetch_lazy (val
);
3909 VALUE_LVAL (val
) = not_lval
;
3914 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3915 if (noside
== EVAL_SKIP
)
3916 return eval_skip_value (exp
);
3917 return value_cast (to_type
, val
);
3924 var_msym_value_operation::evaluate_for_cast (struct type
*to_type
,
3925 struct expression
*exp
,
3928 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3929 return value_zero (to_type
, not_lval
);
3931 value
*val
= evaluate_var_msym_value (noside
,
3932 std::get
<1> (m_storage
),
3933 std::get
<0> (m_storage
));
3935 if (noside
== EVAL_SKIP
)
3936 return eval_skip_value (exp
);
3938 val
= value_cast (to_type
, val
);
3940 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3941 if (VALUE_LVAL (val
) == lval_memory
)
3943 if (value_lazy (val
))
3944 value_fetch_lazy (val
);
3945 VALUE_LVAL (val
) = not_lval
;
3951 var_value_operation::evaluate_for_cast (struct type
*to_type
,
3952 struct expression
*exp
,
3955 value
*val
= evaluate_var_value (noside
,
3956 std::get
<1> (m_storage
),
3957 std::get
<0> (m_storage
));
3959 if (noside
== EVAL_SKIP
)
3960 return eval_skip_value (exp
);
3962 val
= value_cast (to_type
, val
);
3964 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3965 if (VALUE_LVAL (val
) == lval_memory
)
3967 if (value_lazy (val
))
3968 value_fetch_lazy (val
);
3969 VALUE_LVAL (val
) = not_lval
;
3976 /* Parse a type expression in the string [P..P+LENGTH). */
3979 parse_and_eval_type (const char *p
, int length
)
3981 char *tmp
= (char *) alloca (length
+ 4);
3984 memcpy (tmp
+ 1, p
, length
);
3985 tmp
[length
+ 1] = ')';
3986 tmp
[length
+ 2] = '0';
3987 tmp
[length
+ 3] = '\0';
3988 expression_up expr
= parse_expression (tmp
);
3989 if (expr
->first_opcode () != UNOP_CAST
)
3990 error (_("Internal error in eval_type."));
3991 return expr
->elts
[1].type
;