1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
27 #include "gdbthread.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
31 #include "objc-lang.h"
33 #include "parser-defs.h"
34 #include "cp-support.h"
37 #include "user-regs.h"
39 #include "gdb_obstack.h"
41 #include "typeprint.h"
44 /* Prototypes for local functions. */
46 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
49 static struct value
*evaluate_subexp_for_address (struct expression
*,
52 static value
*evaluate_subexp_for_cast (expression
*exp
, int *pos
,
56 static struct value
*evaluate_struct_tuple (struct value
*,
57 struct expression
*, int *,
61 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
62 int *pos
, enum noside noside
)
64 return ((*exp
->language_defn
->expression_ops ()->evaluate_exp
)
65 (expect_type
, exp
, pos
, noside
));
68 /* Parse the string EXP as a C expression, evaluate it,
69 and return the result as a number. */
72 parse_and_eval_address (const char *exp
)
74 expression_up expr
= parse_expression (exp
);
76 return value_as_address (evaluate_expression (expr
.get ()));
79 /* Like parse_and_eval_address, but treats the value of the expression
80 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
82 parse_and_eval_long (const char *exp
)
84 expression_up expr
= parse_expression (exp
);
86 return value_as_long (evaluate_expression (expr
.get ()));
90 parse_and_eval (const char *exp
)
92 expression_up expr
= parse_expression (exp
);
94 return evaluate_expression (expr
.get ());
97 /* Parse up to a comma (or to a closeparen)
98 in the string EXPP as an expression, evaluate it, and return the value.
99 EXPP is advanced to point to the comma. */
102 parse_to_comma_and_eval (const char **expp
)
104 expression_up expr
= parse_exp_1 (expp
, 0, nullptr, 1);
106 return evaluate_expression (expr
.get ());
110 /* See expression.h. */
113 expression::evaluate (struct type
*expect_type
, enum noside noside
)
115 gdb::optional
<enable_thread_stack_temporaries
> stack_temporaries
;
116 if (target_has_execution ()
117 && language_defn
->la_language
== language_cplus
118 && !thread_stack_temporaries_enabled_p (inferior_thread ()))
119 stack_temporaries
.emplace (inferior_thread ());
122 struct value
*retval
= evaluate_subexp (expect_type
, this, &pos
, noside
);
124 if (stack_temporaries
.has_value ()
125 && value_in_thread_stack_temporaries (retval
, inferior_thread ()))
126 retval
= value_non_lval (retval
);
134 evaluate_expression (struct expression
*exp
, struct type
*expect_type
)
136 return exp
->evaluate (expect_type
, EVAL_NORMAL
);
139 /* Evaluate an expression, avoiding all memory references
140 and getting a value whose type alone is correct. */
143 evaluate_type (struct expression
*exp
)
145 return exp
->evaluate (nullptr, EVAL_AVOID_SIDE_EFFECTS
);
148 /* Evaluate a subexpression, avoiding all memory references and
149 getting a value whose type alone is correct. */
152 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
154 return evaluate_subexp (nullptr, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
157 /* Find the current value of a watchpoint on EXP. Return the value in
158 *VALP and *RESULTP and the chain of intermediate and final values
159 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
162 If PRESERVE_ERRORS is true, then exceptions are passed through.
163 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
164 occurs while evaluating the expression, *RESULTP will be set to
165 NULL. *RESULTP may be a lazy value, if the result could not be
166 read from memory. It is used to determine whether a value is
167 user-specified (we should watch the whole value) or intermediate
168 (we should watch only the bit used to locate the final value).
170 If the final value, or any intermediate value, could not be read
171 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
172 set to any referenced values. *VALP will never be a lazy value.
173 This is the value which we store in struct breakpoint.
175 If VAL_CHAIN is non-NULL, the values put into *VAL_CHAIN will be
176 released from the value chain. If VAL_CHAIN is NULL, all generated
177 values will be left on the value chain. */
180 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
181 struct value
**resultp
,
182 std::vector
<value_ref_ptr
> *val_chain
,
183 bool preserve_errors
)
185 struct value
*mark
, *new_mark
, *result
;
193 /* Evaluate the expression. */
194 mark
= value_mark ();
199 result
= evaluate_subexp (nullptr, exp
, pc
, EVAL_NORMAL
);
201 catch (const gdb_exception
&ex
)
203 /* Ignore memory errors if we want watchpoints pointing at
204 inaccessible memory to still be created; otherwise, throw the
205 error to some higher catcher. */
209 if (!preserve_errors
)
218 new_mark
= value_mark ();
219 if (mark
== new_mark
)
224 /* Make sure it's not lazy, so that after the target stops again we
225 have a non-lazy previous value to compare with. */
228 if (!value_lazy (result
))
235 value_fetch_lazy (result
);
238 catch (const gdb_exception_error
&except
)
246 /* Return the chain of intermediate values. We use this to
247 decide which addresses to watch. */
248 *val_chain
= value_release_to_mark (mark
);
252 /* Extract a field operation from an expression. If the subexpression
253 of EXP starting at *SUBEXP is not a structure dereference
254 operation, return NULL. Otherwise, return the name of the
255 dereferenced field, and advance *SUBEXP to point to the
256 subexpression of the left-hand-side of the dereference. This is
257 used when completing field names. */
260 extract_field_op (struct expression
*exp
, int *subexp
)
265 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
266 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
268 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
269 result
= &exp
->elts
[*subexp
+ 2].string
;
270 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
274 /* This function evaluates brace-initializers (in C/C++) for
277 static struct value
*
278 evaluate_struct_tuple (struct value
*struct_val
,
279 struct expression
*exp
,
280 int *pos
, enum noside noside
, int nargs
)
282 struct type
*struct_type
= check_typedef (value_type (struct_val
));
283 struct type
*field_type
;
288 struct value
*val
= NULL
;
293 /* Skip static fields. */
294 while (fieldno
< struct_type
->num_fields ()
295 && field_is_static (&struct_type
->field (fieldno
)))
297 if (fieldno
>= struct_type
->num_fields ())
298 error (_("too many initializers"));
299 field_type
= struct_type
->field (fieldno
).type ();
300 if (field_type
->code () == TYPE_CODE_UNION
301 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
302 error (_("don't know which variant you want to set"));
304 /* Here, struct_type is the type of the inner struct,
305 while substruct_type is the type of the inner struct.
306 These are the same for normal structures, but a variant struct
307 contains anonymous union fields that contain substruct fields.
308 The value fieldno is the index of the top-level (normal or
309 anonymous union) field in struct_field, while the value
310 subfieldno is the index of the actual real (named inner) field
311 in substruct_type. */
313 field_type
= struct_type
->field (fieldno
).type ();
315 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
317 /* Now actually set the field in struct_val. */
319 /* Assign val to field fieldno. */
320 if (value_type (val
) != field_type
)
321 val
= value_cast (field_type
, val
);
323 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
324 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
325 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
327 modify_field (struct_type
, addr
,
328 value_as_long (val
), bitpos
% 8, bitsize
);
330 memcpy (addr
, value_contents (val
),
331 TYPE_LENGTH (value_type (val
)));
337 /* Promote value ARG1 as appropriate before performing a unary operation
339 If the result is not appropriate for any particular language then it
340 needs to patch this function. */
343 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
348 *arg1
= coerce_ref (*arg1
);
349 type1
= check_typedef (value_type (*arg1
));
351 if (is_integral_type (type1
))
353 switch (language
->la_language
)
356 /* Perform integral promotion for ANSI C/C++.
357 If not appropriate for any particular language
358 it needs to modify this function. */
360 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
362 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
363 *arg1
= value_cast (builtin_int
, *arg1
);
370 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
371 operation on those two operands.
372 If the result is not appropriate for any particular language then it
373 needs to patch this function. */
376 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
377 struct value
**arg1
, struct value
**arg2
)
379 struct type
*promoted_type
= NULL
;
383 *arg1
= coerce_ref (*arg1
);
384 *arg2
= coerce_ref (*arg2
);
386 type1
= check_typedef (value_type (*arg1
));
387 type2
= check_typedef (value_type (*arg2
));
389 if ((type1
->code () != TYPE_CODE_FLT
390 && type1
->code () != TYPE_CODE_DECFLOAT
391 && !is_integral_type (type1
))
392 || (type2
->code () != TYPE_CODE_FLT
393 && type2
->code () != TYPE_CODE_DECFLOAT
394 && !is_integral_type (type2
)))
397 if (is_fixed_point_type (type1
) || is_fixed_point_type (type2
))
400 if (type1
->code () == TYPE_CODE_DECFLOAT
401 || type2
->code () == TYPE_CODE_DECFLOAT
)
403 /* No promotion required. */
405 else if (type1
->code () == TYPE_CODE_FLT
406 || type2
->code () == TYPE_CODE_FLT
)
408 switch (language
->la_language
)
414 case language_opencl
:
415 /* No promotion required. */
419 /* For other languages the result type is unchanged from gdb
420 version 6.7 for backward compatibility.
421 If either arg was long double, make sure that value is also long
422 double. Otherwise use double. */
423 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
424 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
425 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
427 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
431 else if (type1
->code () == TYPE_CODE_BOOL
432 && type2
->code () == TYPE_CODE_BOOL
)
434 /* No promotion required. */
437 /* Integral operations here. */
438 /* FIXME: Also mixed integral/booleans, with result an integer. */
440 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
441 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
442 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
443 int is_unsigned1
= type1
->is_unsigned ();
444 int is_unsigned2
= type2
->is_unsigned ();
445 unsigned int result_len
;
446 int unsigned_operation
;
448 /* Determine type length and signedness after promotion for
450 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
453 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
455 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
458 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
461 if (promoted_len1
> promoted_len2
)
463 unsigned_operation
= is_unsigned1
;
464 result_len
= promoted_len1
;
466 else if (promoted_len2
> promoted_len1
)
468 unsigned_operation
= is_unsigned2
;
469 result_len
= promoted_len2
;
473 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
474 result_len
= promoted_len1
;
477 switch (language
->la_language
)
483 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
485 promoted_type
= (unsigned_operation
486 ? builtin
->builtin_unsigned_int
487 : builtin
->builtin_int
);
489 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
491 promoted_type
= (unsigned_operation
492 ? builtin
->builtin_unsigned_long
493 : builtin
->builtin_long
);
497 promoted_type
= (unsigned_operation
498 ? builtin
->builtin_unsigned_long_long
499 : builtin
->builtin_long_long
);
502 case language_opencl
:
503 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
508 ? lookup_unsigned_typename (language
, "int")
509 : lookup_signed_typename (language
, "int"));
511 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
516 ? lookup_unsigned_typename (language
, "long")
517 : lookup_signed_typename (language
,"long"));
521 /* For other languages the result type is unchanged from gdb
522 version 6.7 for backward compatibility.
523 If either arg was long long, make sure that value is also long
524 long. Otherwise use long. */
525 if (unsigned_operation
)
527 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
528 promoted_type
= builtin
->builtin_unsigned_long_long
;
530 promoted_type
= builtin
->builtin_unsigned_long
;
534 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
535 promoted_type
= builtin
->builtin_long_long
;
537 promoted_type
= builtin
->builtin_long
;
545 /* Promote both operands to common type. */
546 *arg1
= value_cast (promoted_type
, *arg1
);
547 *arg2
= value_cast (promoted_type
, *arg2
);
552 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
554 type
= check_typedef (type
);
555 if (TYPE_IS_REFERENCE (type
))
556 type
= TYPE_TARGET_TYPE (type
);
558 switch (type
->code ())
564 case TYPE_CODE_ARRAY
:
565 return type
->is_vector () ? 0 : lang
->c_style_arrays_p ();
572 /* Represents a fake method with the given parameter types. This is
573 used by the parser to construct a temporary "expected" type for
574 method overload resolution. FLAGS is used as instance flags of the
575 new type, in order to be able to make the new type represent a
576 const/volatile overload. */
581 fake_method (type_instance_flags flags
,
582 int num_types
, struct type
**param_types
);
585 /* The constructed type. */
586 struct type
*type () { return &m_type
; }
589 struct type m_type
{};
590 main_type m_main_type
{};
593 fake_method::fake_method (type_instance_flags flags
,
594 int num_types
, struct type
**param_types
)
596 struct type
*type
= &m_type
;
598 TYPE_MAIN_TYPE (type
) = &m_main_type
;
599 TYPE_LENGTH (type
) = 1;
600 type
->set_code (TYPE_CODE_METHOD
);
601 TYPE_CHAIN (type
) = type
;
602 type
->set_instance_flags (flags
);
605 if (param_types
[num_types
- 1] == NULL
)
608 type
->set_has_varargs (true);
610 else if (check_typedef (param_types
[num_types
- 1])->code ()
614 /* Caller should have ensured this. */
615 gdb_assert (num_types
== 0);
616 type
->set_is_prototyped (true);
620 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
621 neither an objfile nor a gdbarch. As a result we must manually
622 allocate memory for auxiliary fields, and free the memory ourselves
623 when we are done with it. */
624 type
->set_num_fields (num_types
);
626 ((struct field
*) xzalloc (sizeof (struct field
) * num_types
));
628 while (num_types
-- > 0)
629 type
->field (num_types
).set_type (param_types
[num_types
]);
632 fake_method::~fake_method ()
634 xfree (m_type
.fields ());
637 /* Helper for evaluating an OP_VAR_VALUE. */
640 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
642 /* JYG: We used to just return value_zero of the symbol type if
643 we're asked to avoid side effects. Otherwise we return
644 value_of_variable (...). However I'm not sure if
645 value_of_variable () has any side effect. We need a full value
646 object returned here for whatis_exp () to call evaluate_type ()
647 and then pass the full value to value_rtti_target_type () if we
648 are dealing with a pointer or reference to a base class and print
651 struct value
*ret
= NULL
;
655 ret
= value_of_variable (var
, blk
);
658 catch (const gdb_exception_error
&except
)
660 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
663 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
669 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
672 evaluate_var_msym_value (enum noside noside
,
673 struct objfile
*objfile
, minimal_symbol
*msymbol
)
676 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
678 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !the_type
->is_gnu_ifunc ())
679 return value_zero (the_type
, not_lval
);
681 return value_at_lazy (the_type
, address
);
684 /* Helper for returning a value when handling EVAL_SKIP. */
687 eval_skip_value (expression
*exp
)
689 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
692 /* See expression.h. */
695 evaluate_subexp_do_call (expression
*exp
, enum noside noside
,
697 gdb::array_view
<value
*> argvec
,
698 const char *function_name
,
699 type
*default_return_type
)
702 error (_("Cannot evaluate function -- may be inlined"));
703 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
705 /* If the return type doesn't look like a function type,
706 call an error. This can happen if somebody tries to turn
707 a variable into a function call. */
709 type
*ftype
= value_type (callee
);
711 if (ftype
->code () == TYPE_CODE_INTERNAL_FUNCTION
)
713 /* We don't know anything about what the internal
714 function might return, but we have to return
716 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
719 else if (ftype
->code () == TYPE_CODE_XMETHOD
)
721 type
*return_type
= result_type_of_xmethod (callee
, argvec
);
723 if (return_type
== NULL
)
724 error (_("Xmethod is missing return type."));
725 return value_zero (return_type
, not_lval
);
727 else if (ftype
->code () == TYPE_CODE_FUNC
728 || ftype
->code () == TYPE_CODE_METHOD
)
730 if (ftype
->is_gnu_ifunc ())
732 CORE_ADDR address
= value_address (callee
);
733 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
735 if (resolved_type
!= NULL
)
736 ftype
= resolved_type
;
739 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
741 if (return_type
== NULL
)
742 return_type
= default_return_type
;
744 if (return_type
== NULL
)
745 error_call_unknown_return_type (function_name
);
747 return allocate_value (return_type
);
750 error (_("Expression of type other than "
751 "\"Function returning ...\" used as function"));
753 switch (value_type (callee
)->code ())
755 case TYPE_CODE_INTERNAL_FUNCTION
:
756 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
757 callee
, argvec
.size (), argvec
.data ());
758 case TYPE_CODE_XMETHOD
:
759 return call_xmethod (callee
, argvec
);
761 return call_function_by_hand (callee
, default_return_type
, argvec
);
765 /* Helper for evaluating an OP_FUNCALL. */
768 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
776 symbol
*function
= NULL
;
777 char *function_name
= NULL
;
778 const char *var_func_name
= NULL
;
783 exp_opcode op
= exp
->elts
[*pos
].opcode
;
784 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
785 /* Allocate arg vector, including space for the function to be
786 called in argvec[0], a potential `this', and a terminating
788 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
789 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
791 /* First, evaluate the structure into arg2. */
794 if (op
== STRUCTOP_MEMBER
)
796 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
800 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
803 /* If the function is a virtual function, then the aggregate
804 value (providing the structure) plays its part by providing
805 the vtable. Otherwise, it is just along for the ride: call
806 the function directly. */
808 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
810 type
*a1_type
= check_typedef (value_type (arg1
));
811 if (noside
== EVAL_SKIP
)
812 tem
= 1; /* Set it to the right arg index so that all
813 arguments can also be skipped. */
814 else if (a1_type
->code () == TYPE_CODE_METHODPTR
)
816 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
817 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
819 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
821 /* Now, say which argument to start evaluating from. */
826 else if (a1_type
->code () == TYPE_CODE_MEMBERPTR
)
828 struct type
*type_ptr
829 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
830 struct type
*target_type_ptr
831 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
833 /* Now, convert these values to an address. */
834 arg2
= value_cast (type_ptr
, arg2
);
836 long mem_offset
= value_as_long (arg1
);
838 arg1
= value_from_pointer (target_type_ptr
,
839 value_as_long (arg2
) + mem_offset
);
840 arg1
= value_ind (arg1
);
844 error (_("Non-pointer-to-member value used in pointer-to-member "
847 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
849 /* Hair for method invocations. */
853 /* First, evaluate the structure into arg2. */
855 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
856 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
858 if (op
== STRUCTOP_STRUCT
)
860 /* If v is a variable in a register, and the user types
861 v.method (), this will produce an error, because v has no
864 A possible way around this would be to allocate a copy of
865 the variable on the stack, copy in the contents, call the
866 function, and copy out the contents. I.e. convert this
867 from call by reference to call by copy-return (or
868 whatever it's called). However, this does not work
869 because it is not the same: the method being called could
870 stash a copy of the address, and then future uses through
871 that address (after the method returns) would be expected
872 to use the variable itself, not some copy of it. */
873 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
877 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
879 /* Check to see if the operator '->' has been overloaded.
880 If the operator has been overloaded replace arg2 with the
881 value returned by the custom operator and continue
883 while (unop_user_defined_p (op
, arg2
))
885 struct value
*value
= NULL
;
888 value
= value_x_unop (arg2
, op
, noside
);
891 catch (const gdb_exception_error
&except
)
893 if (except
.error
== NOT_FOUND_ERROR
)
902 /* Now, say which argument to start evaluating from. */
905 else if (op
== OP_SCOPE
906 && overload_resolution
907 && (exp
->language_defn
->la_language
== language_cplus
))
909 /* Unpack it locally so we can properly handle overload
915 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
916 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
917 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
918 name
= &exp
->elts
[pc2
+ 3].string
;
921 function_name
= NULL
;
922 if (type
->code () == TYPE_CODE_NAMESPACE
)
924 function
= cp_lookup_symbol_namespace (type
->name (),
926 get_selected_block (0),
928 if (function
== NULL
)
929 error (_("No symbol \"%s\" in namespace \"%s\"."),
930 name
, type
->name ());
933 /* arg2 is left as NULL on purpose. */
937 gdb_assert (type
->code () == TYPE_CODE_STRUCT
938 || type
->code () == TYPE_CODE_UNION
);
939 function_name
= name
;
941 /* We need a properly typed value for method lookup. For
942 static methods arg2 is otherwise unused. */
943 arg2
= value_zero (type
, lval_memory
);
948 else if (op
== OP_ADL_FUNC
)
950 /* Save the function position and move pos so that the arguments
957 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
958 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
962 /* Non-method function call. */
966 /* If this is a C++ function wait until overload resolution. */
967 if (op
== OP_VAR_VALUE
968 && overload_resolution
969 && (exp
->language_defn
->la_language
== language_cplus
))
971 (*pos
) += 4; /* Skip the evaluation of the symbol. */
976 if (op
== OP_VAR_MSYM_VALUE
)
978 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
979 var_func_name
= msym
->print_name ();
981 else if (op
== OP_VAR_VALUE
)
983 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
984 var_func_name
= sym
->print_name ();
987 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
988 type
*type
= value_type (argvec
[0]);
989 if (type
&& type
->code () == TYPE_CODE_PTR
)
990 type
= TYPE_TARGET_TYPE (type
);
991 if (type
&& type
->code () == TYPE_CODE_FUNC
)
993 for (; tem
<= nargs
&& tem
<= type
->num_fields (); tem
++)
995 argvec
[tem
] = evaluate_subexp (type
->field (tem
- 1).type (),
1002 /* Evaluate arguments (if not already done, e.g., namespace::func()
1003 and overload-resolution is off). */
1004 for (; tem
<= nargs
; tem
++)
1006 /* Ensure that array expressions are coerced into pointer
1008 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1011 /* Signal end of arglist. */
1014 if (noside
== EVAL_SKIP
)
1015 return eval_skip_value (exp
);
1017 if (op
== OP_ADL_FUNC
)
1019 struct symbol
*symp
;
1022 int string_pc
= save_pos1
+ 3;
1024 /* Extract the function name. */
1025 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1026 func_name
= (char *) alloca (name_len
+ 1);
1027 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1029 find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1031 NON_METHOD
, /* not method */
1032 NULL
, NULL
, /* pass NULL symbol since
1033 symbol is unknown */
1034 NULL
, &symp
, NULL
, 0, noside
);
1036 /* Now fix the expression being evaluated. */
1037 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1038 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1041 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1042 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1044 int static_memfuncp
;
1047 /* Method invocation: stuff "this" as first parameter. If the
1048 method turns out to be static we undo this below. */
1053 /* Name of method from expression. */
1054 tstr
= &exp
->elts
[pc2
+ 2].string
;
1057 tstr
= function_name
;
1059 if (overload_resolution
&& (exp
->language_defn
->la_language
1062 /* Language is C++, do some overload resolution before
1064 struct value
*valp
= NULL
;
1066 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1068 METHOD
, /* method */
1069 &arg2
, /* the object */
1071 &static_memfuncp
, 0, noside
);
1073 if (op
== OP_SCOPE
&& !static_memfuncp
)
1075 /* For the time being, we don't handle this. */
1076 error (_("Call to overloaded function %s requires "
1080 argvec
[1] = arg2
; /* the ``this'' pointer */
1081 argvec
[0] = valp
; /* Use the method found after overload
1085 /* Non-C++ case -- or no overload resolution. */
1087 struct value
*temp
= arg2
;
1089 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1091 op
== STRUCTOP_STRUCT
1092 ? "structure" : "structure pointer");
1093 /* value_struct_elt updates temp with the correct value of
1094 the ``this'' pointer if necessary, so modify argvec[1] to
1095 reflect any ``this'' changes. */
1097 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1098 value_address (temp
)
1099 + value_embedded_offset (temp
));
1100 argvec
[1] = arg2
; /* the ``this'' pointer */
1103 /* Take out `this' if needed. */
1104 if (static_memfuncp
)
1106 argvec
[1] = argvec
[0];
1111 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1113 /* Pointer to member. argvec[1] is already set up. */
1116 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1118 /* Non-member function being called. */
1119 /* fn: This can only be done for C++ functions. A C-style
1120 function in a C++ program, for instance, does not have the
1121 fields that are expected here. */
1123 if (overload_resolution
&& (exp
->language_defn
->la_language
1126 /* Language is C++, do some overload resolution before
1128 struct symbol
*symp
;
1131 /* If a scope has been specified disable ADL. */
1135 if (op
== OP_VAR_VALUE
)
1136 function
= exp
->elts
[save_pos1
+2].symbol
;
1138 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1139 NULL
, /* no need for name */
1140 NON_METHOD
, /* not method */
1141 NULL
, function
, /* the function */
1142 NULL
, &symp
, NULL
, no_adl
, noside
);
1144 if (op
== OP_VAR_VALUE
)
1146 /* Now fix the expression being evaluated. */
1147 exp
->elts
[save_pos1
+2].symbol
= symp
;
1148 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1152 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1156 /* Not C++, or no overload resolution allowed. */
1157 /* Nothing to be done; argvec already correctly set up. */
1162 /* It is probably a C-style function. */
1163 /* Nothing to be done; argvec already correctly set up. */
1166 return evaluate_subexp_do_call (exp
, noside
, argvec
[0],
1167 gdb::make_array_view (argvec
+ 1, nargs
),
1168 var_func_name
, expect_type
);
1171 /* Return true if type is integral or reference to integral */
1174 is_integral_or_integral_reference (struct type
*type
)
1176 if (is_integral_type (type
))
1179 type
= check_typedef (type
);
1180 return (type
!= nullptr
1181 && TYPE_IS_REFERENCE (type
)
1182 && is_integral_type (TYPE_TARGET_TYPE (type
)));
1185 /* Helper function that implements the body of OP_SCOPE. */
1187 static struct value
*
1188 eval_op_scope (struct type
*expect_type
, struct expression
*exp
,
1190 struct type
*type
, const char *string
)
1192 if (noside
== EVAL_SKIP
)
1193 return eval_skip_value (exp
);
1194 struct value
*arg1
= value_aggregate_elt (type
, string
, expect_type
,
1197 error (_("There is no field named %s"), string
);
1201 /* Helper function that implements the body of OP_VAR_ENTRY_VALUE. */
1203 static struct value
*
1204 eval_op_var_entry_value (struct type
*expect_type
, struct expression
*exp
,
1205 enum noside noside
, symbol
*sym
)
1207 if (noside
== EVAL_SKIP
)
1208 return eval_skip_value (exp
);
1209 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1210 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1212 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1213 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1214 error (_("Symbol \"%s\" does not have any specific entry value"),
1215 sym
->print_name ());
1217 struct frame_info
*frame
= get_selected_frame (NULL
);
1218 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1221 /* Helper function that implements the body of OP_VAR_MSYM_VALUE. */
1223 static struct value
*
1224 eval_op_var_msym_value (struct type
*expect_type
, struct expression
*exp
,
1225 enum noside noside
, bool outermost_p
,
1226 minimal_symbol
*msymbol
, struct objfile
*objfile
)
1228 value
*val
= evaluate_var_msym_value (noside
, objfile
, msymbol
);
1230 struct type
*type
= value_type (val
);
1231 if (type
->code () == TYPE_CODE_ERROR
1232 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| !outermost_p
))
1233 error_unknown_type (msymbol
->print_name ());
1237 /* Helper function that implements the body of OP_FUNC_STATIC_VAR. */
1239 static struct value
*
1240 eval_op_func_static_var (struct type
*expect_type
, struct expression
*exp
,
1242 value
*func
, const char *var
)
1244 if (noside
== EVAL_SKIP
)
1245 return eval_skip_value (exp
);
1246 CORE_ADDR addr
= value_address (func
);
1247 const block
*blk
= block_for_pc (addr
);
1248 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1249 if (sym
.symbol
== NULL
)
1250 error (_("No symbol \"%s\" in specified context."), var
);
1251 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1254 /* Helper function that implements the body of OP_REGISTER. */
1256 static struct value
*
1257 eval_op_register (struct type
*expect_type
, struct expression
*exp
,
1258 enum noside noside
, const char *name
)
1263 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1264 name
, strlen (name
));
1266 error (_("Register $%s not available."), name
);
1268 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1269 a value with the appropriate register type. Unfortunately,
1270 we don't have easy access to the type of user registers.
1271 So for these registers, we fetch the register value regardless
1272 of the evaluation mode. */
1273 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1274 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1275 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1277 val
= value_of_register (regno
, get_selected_frame (NULL
));
1279 error (_("Value of register %s not available."), name
);
1284 /* Helper function that implements the body of OP_STRING. */
1286 static struct value
*
1287 eval_op_string (struct type
*expect_type
, struct expression
*exp
,
1288 enum noside noside
, int len
, const char *string
)
1290 if (noside
== EVAL_SKIP
)
1291 return eval_skip_value (exp
);
1292 struct type
*type
= language_string_char_type (exp
->language_defn
,
1294 return value_string (string
, len
, type
);
1297 /* Helper function that implements the body of OP_OBJC_SELECTOR. */
1299 static struct value
*
1300 eval_op_objc_selector (struct type
*expect_type
, struct expression
*exp
,
1304 if (noside
== EVAL_SKIP
)
1305 return eval_skip_value (exp
);
1307 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1308 return value_from_longest (selector_type
,
1309 lookup_child_selector (exp
->gdbarch
, sel
));
1312 /* Helper function that implements the body of BINOP_CONCAT. */
1314 static struct value
*
1315 eval_op_concat (struct type
*expect_type
, struct expression
*exp
,
1317 enum exp_opcode op
, struct value
*arg1
, struct value
*arg2
)
1319 if (noside
== EVAL_SKIP
)
1320 return eval_skip_value (exp
);
1321 if (binop_user_defined_p (op
, arg1
, arg2
))
1322 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1324 return value_concat (arg1
, arg2
);
1327 /* A helper function for TERNOP_SLICE. */
1329 static struct value
*
1330 eval_op_ternop (struct type
*expect_type
, struct expression
*exp
,
1332 struct value
*array
, struct value
*low
, struct value
*upper
)
1334 if (noside
== EVAL_SKIP
)
1335 return eval_skip_value (exp
);
1336 int lowbound
= value_as_long (low
);
1337 int upperbound
= value_as_long (upper
);
1338 return value_slice (array
, lowbound
, upperbound
- lowbound
+ 1);
1342 evaluate_subexp_standard (struct type
*expect_type
,
1343 struct expression
*exp
, int *pos
,
1347 int tem
, tem2
, tem3
;
1349 struct value
*arg1
= NULL
;
1350 struct value
*arg2
= NULL
;
1354 struct value
**argvec
;
1357 struct type
**arg_types
;
1360 op
= exp
->elts
[pc
].opcode
;
1365 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1366 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1367 return eval_op_scope (expect_type
, exp
, noside
,
1368 exp
->elts
[pc
+ 1].type
,
1369 &exp
->elts
[pc
+ 3].string
);
1373 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1374 exp
->elts
[pc
+ 2].longconst
);
1378 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1379 exp
->elts
[pc
+ 2].floatconst
);
1385 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1386 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
1387 error_unknown_type (var
->print_name ());
1388 if (noside
!= EVAL_SKIP
)
1389 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1392 /* Return a dummy value of the correct type when skipping, so
1393 that parent functions know what is to be skipped. */
1394 return allocate_value (SYMBOL_TYPE (var
));
1398 case OP_VAR_MSYM_VALUE
:
1402 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1403 return eval_op_var_msym_value (expect_type
, exp
, noside
,
1405 exp
->elts
[pc
+ 1].objfile
);
1408 case OP_VAR_ENTRY_VALUE
:
1412 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1414 return eval_op_var_entry_value (expect_type
, exp
, noside
, sym
);
1417 case OP_FUNC_STATIC_VAR
:
1418 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1419 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1420 if (noside
== EVAL_SKIP
)
1421 return eval_skip_value (exp
);
1424 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1426 return eval_op_func_static_var (expect_type
, exp
, noside
, func
,
1427 &exp
->elts
[pc
+ 2].string
);
1433 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1437 const char *name
= &exp
->elts
[pc
+ 2].string
;
1439 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1440 return eval_op_register (expect_type
, exp
, noside
, name
);
1444 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1445 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1447 case OP_INTERNALVAR
:
1449 return value_of_internalvar (exp
->gdbarch
,
1450 exp
->elts
[pc
+ 1].internalvar
);
1453 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1454 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1455 return eval_op_string (expect_type
, exp
, noside
, tem
,
1456 &exp
->elts
[pc
+ 2].string
);
1458 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1459 NSString constant. */
1460 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1461 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1462 if (noside
== EVAL_SKIP
)
1463 return eval_skip_value (exp
);
1464 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1468 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1469 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1470 nargs
= tem3
- tem2
+ 1;
1471 type
= expect_type
? check_typedef (expect_type
) : nullptr;
1473 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1474 && type
->code () == TYPE_CODE_STRUCT
)
1476 struct value
*rec
= allocate_value (expect_type
);
1478 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1479 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1482 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1483 && type
->code () == TYPE_CODE_ARRAY
)
1485 struct type
*range_type
= type
->index_type ();
1486 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1487 struct value
*array
= allocate_value (expect_type
);
1488 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1489 LONGEST low_bound
, high_bound
, index
;
1491 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
1494 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1497 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1498 for (tem
= nargs
; --nargs
>= 0;)
1500 struct value
*element
;
1502 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1503 if (value_type (element
) != element_type
)
1504 element
= value_cast (element_type
, element
);
1505 if (index
> high_bound
)
1506 /* To avoid memory corruption. */
1507 error (_("Too many array elements"));
1508 memcpy (value_contents_raw (array
)
1509 + (index
- low_bound
) * element_size
,
1510 value_contents (element
),
1517 if (expect_type
!= nullptr && noside
!= EVAL_SKIP
1518 && type
->code () == TYPE_CODE_SET
)
1520 struct value
*set
= allocate_value (expect_type
);
1521 gdb_byte
*valaddr
= value_contents_raw (set
);
1522 struct type
*element_type
= type
->index_type ();
1523 struct type
*check_type
= element_type
;
1524 LONGEST low_bound
, high_bound
;
1526 /* Get targettype of elementtype. */
1527 while (check_type
->code () == TYPE_CODE_RANGE
1528 || check_type
->code () == TYPE_CODE_TYPEDEF
)
1529 check_type
= TYPE_TARGET_TYPE (check_type
);
1531 if (!get_discrete_bounds (element_type
, &low_bound
, &high_bound
))
1532 error (_("(power)set type with unknown size"));
1533 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1534 for (tem
= 0; tem
< nargs
; tem
++)
1536 LONGEST range_low
, range_high
;
1537 struct type
*range_low_type
, *range_high_type
;
1538 struct value
*elem_val
;
1540 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1541 range_low_type
= range_high_type
= value_type (elem_val
);
1542 range_low
= range_high
= value_as_long (elem_val
);
1544 /* Check types of elements to avoid mixture of elements from
1545 different types. Also check if type of element is "compatible"
1546 with element type of powerset. */
1547 if (range_low_type
->code () == TYPE_CODE_RANGE
)
1548 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1549 if (range_high_type
->code () == TYPE_CODE_RANGE
)
1550 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1551 if ((range_low_type
->code () != range_high_type
->code ())
1552 || (range_low_type
->code () == TYPE_CODE_ENUM
1553 && (range_low_type
!= range_high_type
)))
1554 /* different element modes. */
1555 error (_("POWERSET tuple elements of different mode"));
1556 if ((check_type
->code () != range_low_type
->code ())
1557 || (check_type
->code () == TYPE_CODE_ENUM
1558 && range_low_type
!= check_type
))
1559 error (_("incompatible POWERSET tuple elements"));
1560 if (range_low
> range_high
)
1562 warning (_("empty POWERSET tuple range"));
1565 if (range_low
< low_bound
|| range_high
> high_bound
)
1566 error (_("POWERSET tuple element out of range"));
1567 range_low
-= low_bound
;
1568 range_high
-= low_bound
;
1569 for (; range_low
<= range_high
; range_low
++)
1571 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1573 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1574 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1575 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1582 argvec
= XALLOCAVEC (struct value
*, nargs
);
1583 for (tem
= 0; tem
< nargs
; tem
++)
1585 /* Ensure that array expressions are coerced into pointer
1587 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1589 if (noside
== EVAL_SKIP
)
1590 return eval_skip_value (exp
);
1591 return value_array (tem2
, tem3
, argvec
);
1595 struct value
*array
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1596 struct value
*low
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1597 struct value
*upper
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1598 return eval_op_ternop (expect_type
, exp
, noside
, array
, low
, upper
);
1602 /* Skip third and second args to evaluate the first one. */
1603 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1604 if (value_logical_not (arg1
))
1606 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
1607 return evaluate_subexp (nullptr, exp
, pos
, noside
);
1611 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1612 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
1616 case OP_OBJC_SELECTOR
:
1617 { /* Objective C @selector operator. */
1618 char *sel
= &exp
->elts
[pc
+ 2].string
;
1619 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1621 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1623 sel
[len
] = 0; /* Make sure it's terminated. */
1625 return eval_op_objc_selector (expect_type
, exp
, noside
, sel
);
1628 case OP_OBJC_MSGCALL
:
1629 { /* Objective C message (method) call. */
1631 CORE_ADDR responds_selector
= 0;
1632 CORE_ADDR method_selector
= 0;
1634 CORE_ADDR selector
= 0;
1636 int struct_return
= 0;
1637 enum noside sub_no_side
= EVAL_NORMAL
;
1639 struct value
*msg_send
= NULL
;
1640 struct value
*msg_send_stret
= NULL
;
1641 int gnu_runtime
= 0;
1643 struct value
*target
= NULL
;
1644 struct value
*method
= NULL
;
1645 struct value
*called_method
= NULL
;
1647 struct type
*selector_type
= NULL
;
1648 struct type
*long_type
;
1650 struct value
*ret
= NULL
;
1653 selector
= exp
->elts
[pc
+ 1].longconst
;
1654 nargs
= exp
->elts
[pc
+ 2].longconst
;
1655 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1659 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1660 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1662 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1663 sub_no_side
= EVAL_NORMAL
;
1665 sub_no_side
= noside
;
1667 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1669 if (value_as_long (target
) == 0)
1670 return value_from_longest (long_type
, 0);
1672 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1675 /* Find the method dispatch (Apple runtime) or method lookup
1676 (GNU runtime) function for Objective-C. These will be used
1677 to lookup the symbol information for the method. If we
1678 can't find any symbol information, then we'll use these to
1679 call the method, otherwise we can call the method
1680 directly. The msg_send_stret function is used in the special
1681 case of a method that returns a structure (Apple runtime
1685 type
= selector_type
;
1687 type
= lookup_function_type (type
);
1688 type
= lookup_pointer_type (type
);
1689 type
= lookup_function_type (type
);
1690 type
= lookup_pointer_type (type
);
1692 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1694 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1696 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1697 msg_send_stret
= value_from_pointer (type
,
1698 value_as_address (msg_send_stret
));
1702 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1703 /* Special dispatcher for methods returning structs. */
1705 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1708 /* Verify the target object responds to this method. The
1709 standard top-level 'Object' class uses a different name for
1710 the verification method than the non-standard, but more
1711 often used, 'NSObject' class. Make sure we check for both. */
1714 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1715 if (responds_selector
== 0)
1717 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1719 if (responds_selector
== 0)
1720 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1723 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1724 if (method_selector
== 0)
1726 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1728 if (method_selector
== 0)
1729 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1731 /* Call the verification method, to make sure that the target
1732 class implements the desired method. */
1734 argvec
[0] = msg_send
;
1736 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1737 argvec
[3] = value_from_longest (long_type
, selector
);
1740 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1743 /* Function objc_msg_lookup returns a pointer. */
1745 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1747 if (value_as_long (ret
) == 0)
1748 error (_("Target does not respond to this message selector."));
1750 /* Call "methodForSelector:" method, to get the address of a
1751 function method that implements this selector for this
1752 class. If we can find a symbol at that address, then we
1753 know the return type, parameter types etc. (that's a good
1756 argvec
[0] = msg_send
;
1758 argvec
[2] = value_from_longest (long_type
, method_selector
);
1759 argvec
[3] = value_from_longest (long_type
, selector
);
1762 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1766 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1769 /* ret should now be the selector. */
1771 addr
= value_as_long (ret
);
1774 struct symbol
*sym
= NULL
;
1776 /* The address might point to a function descriptor;
1777 resolve it to the actual code address instead. */
1778 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1779 current_top_target ());
1781 /* Is it a high_level symbol? */
1782 sym
= find_pc_function (addr
);
1784 method
= value_of_variable (sym
, 0);
1787 /* If we found a method with symbol information, check to see
1788 if it returns a struct. Otherwise assume it doesn't. */
1793 struct type
*val_type
;
1795 funaddr
= find_function_addr (method
, &val_type
);
1797 block_for_pc (funaddr
);
1799 val_type
= check_typedef (val_type
);
1801 if ((val_type
== NULL
)
1802 || (val_type
->code () == TYPE_CODE_ERROR
))
1804 if (expect_type
!= NULL
)
1805 val_type
= expect_type
;
1808 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1811 else if (expect_type
!= NULL
)
1813 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1814 check_typedef (expect_type
));
1817 /* Found a function symbol. Now we will substitute its
1818 value in place of the message dispatcher (obj_msgSend),
1819 so that we call the method directly instead of thru
1820 the dispatcher. The main reason for doing this is that
1821 we can now evaluate the return value and parameter values
1822 according to their known data types, in case we need to
1823 do things like promotion, dereferencing, special handling
1824 of structs and doubles, etc.
1826 We want to use the type signature of 'method', but still
1827 jump to objc_msgSend() or objc_msgSend_stret() to better
1828 mimic the behavior of the runtime. */
1832 if (value_type (method
)->code () != TYPE_CODE_FUNC
)
1833 error (_("method address has symbol information "
1834 "with non-function type; skipping"));
1836 /* Create a function pointer of the appropriate type, and
1837 replace its value with the value of msg_send or
1838 msg_send_stret. We must use a pointer here, as
1839 msg_send and msg_send_stret are of pointer type, and
1840 the representation may be different on systems that use
1841 function descriptors. */
1844 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1845 value_as_address (msg_send_stret
));
1848 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1849 value_as_address (msg_send
));
1854 called_method
= msg_send_stret
;
1856 called_method
= msg_send
;
1859 if (noside
== EVAL_SKIP
)
1860 return eval_skip_value (exp
);
1862 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1864 /* If the return type doesn't look like a function type,
1865 call an error. This can happen if somebody tries to
1866 turn a variable into a function call. This is here
1867 because people often want to call, eg, strcmp, which
1868 gdb doesn't know is a function. If gdb isn't asked for
1869 it's opinion (ie. through "whatis"), it won't offer
1872 struct type
*callee_type
= value_type (called_method
);
1874 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
1875 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1876 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1880 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
1881 return allocate_value (expect_type
);
1883 return allocate_value (callee_type
);
1886 error (_("Expression of type other than "
1887 "\"method returning ...\" used as a method"));
1890 /* Now depending on whether we found a symbol for the method,
1891 we will either call the runtime dispatcher or the method
1894 argvec
[0] = called_method
;
1896 argvec
[2] = value_from_longest (long_type
, selector
);
1897 /* User-supplied arguments. */
1898 for (tem
= 0; tem
< nargs
; tem
++)
1899 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1900 argvec
[tem
+ 3] = 0;
1902 auto call_args
= gdb::make_array_view (argvec
+ 1, nargs
+ 2);
1904 if (gnu_runtime
&& (method
!= NULL
))
1906 /* Function objc_msg_lookup returns a pointer. */
1907 deprecated_set_value_type (argvec
[0],
1908 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1909 argvec
[0] = call_function_by_hand (argvec
[0], NULL
, call_args
);
1912 return call_function_by_hand (argvec
[0], NULL
, call_args
);
1917 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1920 /* We have a complex number, There should be 2 floating
1921 point numbers that compose it. */
1923 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1924 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1926 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1928 case STRUCTOP_STRUCT
:
1929 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1930 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1931 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1932 if (noside
== EVAL_SKIP
)
1933 return eval_skip_value (exp
);
1934 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1936 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1937 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1941 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1942 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1943 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1944 if (noside
== EVAL_SKIP
)
1945 return eval_skip_value (exp
);
1947 /* Check to see if operator '->' has been overloaded. If so replace
1948 arg1 with the value returned by evaluating operator->(). */
1949 while (unop_user_defined_p (op
, arg1
))
1951 struct value
*value
= NULL
;
1954 value
= value_x_unop (arg1
, op
, noside
);
1957 catch (const gdb_exception_error
&except
)
1959 if (except
.error
== NOT_FOUND_ERROR
)
1968 /* JYG: if print object is on we need to replace the base type
1969 with rtti type in order to continue on with successful
1970 lookup of member / method only available in the rtti type. */
1972 struct type
*arg_type
= value_type (arg1
);
1973 struct type
*real_type
;
1974 int full
, using_enc
;
1976 struct value_print_options opts
;
1978 get_user_print_options (&opts
);
1979 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
1980 && (TYPE_TARGET_TYPE (arg_type
)->code () == TYPE_CODE_STRUCT
))
1982 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1985 arg1
= value_cast (real_type
, arg1
);
1989 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1990 NULL
, "structure pointer");
1991 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1992 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1995 case STRUCTOP_MEMBER
:
1997 if (op
== STRUCTOP_MEMBER
)
1998 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2000 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2002 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2004 if (noside
== EVAL_SKIP
)
2005 return eval_skip_value (exp
);
2007 type
= check_typedef (value_type (arg2
));
2008 switch (type
->code ())
2010 case TYPE_CODE_METHODPTR
:
2011 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2012 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2015 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2016 gdb_assert (value_type (arg2
)->code () == TYPE_CODE_PTR
);
2017 return value_ind (arg2
);
2020 case TYPE_CODE_MEMBERPTR
:
2021 /* Now, convert these values to an address. */
2022 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
2025 mem_offset
= value_as_long (arg2
);
2027 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2028 value_as_long (arg1
) + mem_offset
);
2029 return value_ind (arg3
);
2032 error (_("non-pointer-to-member value used "
2033 "in pointer-to-member construct"));
2038 type_instance_flags flags
2039 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2040 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2041 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2042 for (ix
= 0; ix
< nargs
; ++ix
)
2043 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2045 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
2046 *(pos
) += 4 + nargs
;
2047 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
2052 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2053 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2054 return eval_op_concat (expect_type
, exp
, noside
, op
, arg1
, arg2
);
2057 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2058 /* Special-case assignments where the left-hand-side is a
2059 convenience variable -- in these, don't bother setting an
2060 expected type. This avoids a weird case where re-assigning a
2061 string or array to an internal variable could error with "Too
2062 many array elements". */
2063 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
2065 : value_type (arg1
),
2068 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2070 if (binop_user_defined_p (op
, arg1
, arg2
))
2071 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2073 return value_assign (arg1
, arg2
);
2075 case BINOP_ASSIGN_MODIFY
:
2077 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2078 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2079 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2081 op
= exp
->elts
[pc
+ 1].opcode
;
2082 if (binop_user_defined_p (op
, arg1
, arg2
))
2083 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2084 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2086 && is_integral_type (value_type (arg2
)))
2087 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2088 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2090 && is_integral_type (value_type (arg2
)))
2091 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2094 struct value
*tmp
= arg1
;
2096 /* For shift and integer exponentiation operations,
2097 only promote the first argument. */
2098 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2099 && is_integral_type (value_type (arg2
)))
2100 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2102 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2104 arg2
= value_binop (tmp
, arg2
, op
);
2106 return value_assign (arg1
, arg2
);
2109 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2110 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2111 if (noside
== EVAL_SKIP
)
2112 return eval_skip_value (exp
);
2113 if (binop_user_defined_p (op
, arg1
, arg2
))
2114 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2115 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2116 && is_integral_or_integral_reference (value_type (arg2
)))
2117 return value_ptradd (arg1
, value_as_long (arg2
));
2118 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2119 && is_integral_or_integral_reference (value_type (arg1
)))
2120 return value_ptradd (arg2
, value_as_long (arg1
));
2123 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2124 return value_binop (arg1
, arg2
, BINOP_ADD
);
2128 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2129 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2130 if (noside
== EVAL_SKIP
)
2131 return eval_skip_value (exp
);
2132 if (binop_user_defined_p (op
, arg1
, arg2
))
2133 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2134 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2135 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2137 /* FIXME -- should be ptrdiff_t */
2138 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2139 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2141 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2142 && is_integral_or_integral_reference (value_type (arg2
)))
2143 return value_ptradd (arg1
, - value_as_long (arg2
));
2146 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2147 return value_binop (arg1
, arg2
, BINOP_SUB
);
2158 case BINOP_BITWISE_AND
:
2159 case BINOP_BITWISE_IOR
:
2160 case BINOP_BITWISE_XOR
:
2161 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2162 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2163 if (noside
== EVAL_SKIP
)
2164 return eval_skip_value (exp
);
2165 if (binop_user_defined_p (op
, arg1
, arg2
))
2166 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2169 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2170 fudge arg2 to avoid division-by-zero, the caller is
2171 (theoretically) only looking for the type of the result. */
2172 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2173 /* ??? Do we really want to test for BINOP_MOD here?
2174 The implementation of value_binop gives it a well-defined
2177 || op
== BINOP_INTDIV
2180 && value_logical_not (arg2
))
2182 struct value
*v_one
;
2184 v_one
= value_one (value_type (arg2
));
2185 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2186 return value_binop (arg1
, v_one
, op
);
2190 /* For shift and integer exponentiation operations,
2191 only promote the first argument. */
2192 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2193 && is_integral_type (value_type (arg2
)))
2194 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2196 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2198 return value_binop (arg1
, arg2
, op
);
2202 case BINOP_SUBSCRIPT
:
2203 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2204 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2205 if (noside
== EVAL_SKIP
)
2206 return eval_skip_value (exp
);
2207 if (binop_user_defined_p (op
, arg1
, arg2
))
2208 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2211 /* If the user attempts to subscript something that is not an
2212 array or pointer type (like a plain int variable for example),
2213 then report this as an error. */
2215 arg1
= coerce_ref (arg1
);
2216 type
= check_typedef (value_type (arg1
));
2217 if (type
->code () != TYPE_CODE_ARRAY
2218 && type
->code () != TYPE_CODE_PTR
)
2221 error (_("cannot subscript something of type `%s'"),
2224 error (_("cannot subscript requested type"));
2227 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2228 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2230 return value_subscript (arg1
, value_as_long (arg2
));
2232 case MULTI_SUBSCRIPT
:
2234 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2235 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2236 argvec
= XALLOCAVEC (struct value
*, nargs
);
2237 for (ix
= 0; ix
< nargs
; ++ix
)
2238 argvec
[ix
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
2239 if (noside
== EVAL_SKIP
)
2241 for (ix
= 0; ix
< nargs
; ++ix
)
2245 if (binop_user_defined_p (op
, arg1
, arg2
))
2247 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2251 arg1
= coerce_ref (arg1
);
2252 type
= check_typedef (value_type (arg1
));
2254 switch (type
->code ())
2257 case TYPE_CODE_ARRAY
:
2258 case TYPE_CODE_STRING
:
2259 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2264 error (_("cannot subscript something of type `%s'"),
2267 error (_("cannot subscript requested type"));
2273 case BINOP_LOGICAL_AND
:
2274 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2275 if (noside
== EVAL_SKIP
)
2277 evaluate_subexp (nullptr, exp
, pos
, noside
);
2278 return eval_skip_value (exp
);
2282 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2285 if (binop_user_defined_p (op
, arg1
, arg2
))
2287 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2288 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2292 tem
= value_logical_not (arg1
);
2294 = evaluate_subexp (nullptr, exp
, pos
, (tem
? EVAL_SKIP
: noside
));
2295 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2296 return value_from_longest (type
,
2297 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2300 case BINOP_LOGICAL_OR
:
2301 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2302 if (noside
== EVAL_SKIP
)
2304 evaluate_subexp (nullptr, exp
, pos
, noside
);
2305 return eval_skip_value (exp
);
2309 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2312 if (binop_user_defined_p (op
, arg1
, arg2
))
2314 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2315 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2319 tem
= value_logical_not (arg1
);
2321 = evaluate_subexp (nullptr, exp
, pos
, (!tem
? EVAL_SKIP
: noside
));
2322 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2323 return value_from_longest (type
,
2324 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2328 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2329 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2330 if (noside
== EVAL_SKIP
)
2331 return eval_skip_value (exp
);
2332 if (binop_user_defined_p (op
, arg1
, arg2
))
2334 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2338 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2339 tem
= value_equal (arg1
, arg2
);
2340 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2341 return value_from_longest (type
, (LONGEST
) tem
);
2344 case BINOP_NOTEQUAL
:
2345 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2346 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2347 if (noside
== EVAL_SKIP
)
2348 return eval_skip_value (exp
);
2349 if (binop_user_defined_p (op
, arg1
, arg2
))
2351 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2355 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2356 tem
= value_equal (arg1
, arg2
);
2357 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2358 return value_from_longest (type
, (LONGEST
) ! tem
);
2362 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2363 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2364 if (noside
== EVAL_SKIP
)
2365 return eval_skip_value (exp
);
2366 if (binop_user_defined_p (op
, arg1
, arg2
))
2368 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2372 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2373 tem
= value_less (arg1
, arg2
);
2374 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2375 return value_from_longest (type
, (LONGEST
) tem
);
2379 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2380 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2381 if (noside
== EVAL_SKIP
)
2382 return eval_skip_value (exp
);
2383 if (binop_user_defined_p (op
, arg1
, arg2
))
2385 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2389 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2390 tem
= value_less (arg2
, arg1
);
2391 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2392 return value_from_longest (type
, (LONGEST
) tem
);
2396 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2397 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2398 if (noside
== EVAL_SKIP
)
2399 return eval_skip_value (exp
);
2400 if (binop_user_defined_p (op
, arg1
, arg2
))
2402 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2406 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2407 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2408 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2409 return value_from_longest (type
, (LONGEST
) tem
);
2413 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2414 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2415 if (noside
== EVAL_SKIP
)
2416 return eval_skip_value (exp
);
2417 if (binop_user_defined_p (op
, arg1
, arg2
))
2419 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2423 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2424 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2425 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2426 return value_from_longest (type
, (LONGEST
) tem
);
2430 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2431 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2432 if (noside
== EVAL_SKIP
)
2433 return eval_skip_value (exp
);
2434 type
= check_typedef (value_type (arg2
));
2435 if (type
->code () != TYPE_CODE_INT
2436 && type
->code () != TYPE_CODE_ENUM
)
2437 error (_("Non-integral right operand for \"@\" operator."));
2438 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2440 return allocate_repeat_value (value_type (arg1
),
2441 longest_to_int (value_as_long (arg2
)));
2444 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2447 evaluate_subexp (nullptr, exp
, pos
, noside
);
2448 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2451 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2452 if (noside
== EVAL_SKIP
)
2453 return eval_skip_value (exp
);
2454 if (unop_user_defined_p (op
, arg1
))
2455 return value_x_unop (arg1
, op
, noside
);
2458 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2459 return value_pos (arg1
);
2463 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2464 if (noside
== EVAL_SKIP
)
2465 return eval_skip_value (exp
);
2466 if (unop_user_defined_p (op
, arg1
))
2467 return value_x_unop (arg1
, op
, noside
);
2470 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2471 return value_neg (arg1
);
2474 case UNOP_COMPLEMENT
:
2475 /* C++: check for and handle destructor names. */
2477 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2478 if (noside
== EVAL_SKIP
)
2479 return eval_skip_value (exp
);
2480 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2481 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2484 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2485 return value_complement (arg1
);
2488 case UNOP_LOGICAL_NOT
:
2489 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2490 if (noside
== EVAL_SKIP
)
2491 return eval_skip_value (exp
);
2492 if (unop_user_defined_p (op
, arg1
))
2493 return value_x_unop (arg1
, op
, noside
);
2496 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2497 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2501 if (expect_type
&& expect_type
->code () == TYPE_CODE_PTR
)
2502 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2503 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2504 type
= check_typedef (value_type (arg1
));
2505 if (type
->code () == TYPE_CODE_METHODPTR
2506 || type
->code () == TYPE_CODE_MEMBERPTR
)
2507 error (_("Attempt to dereference pointer "
2508 "to member without an object"));
2509 if (noside
== EVAL_SKIP
)
2510 return eval_skip_value (exp
);
2511 if (unop_user_defined_p (op
, arg1
))
2512 return value_x_unop (arg1
, op
, noside
);
2513 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2515 type
= check_typedef (value_type (arg1
));
2517 /* If the type pointed to is dynamic then in order to resolve the
2518 dynamic properties we must actually dereference the pointer.
2519 There is a risk that this dereference will have side-effects
2520 in the inferior, but being able to print accurate type
2521 information seems worth the risk. */
2522 if ((type
->code () != TYPE_CODE_PTR
2523 && !TYPE_IS_REFERENCE (type
))
2524 || !is_dynamic_type (TYPE_TARGET_TYPE (type
)))
2526 if (type
->code () == TYPE_CODE_PTR
2527 || TYPE_IS_REFERENCE (type
)
2528 /* In C you can dereference an array to get the 1st elt. */
2529 || type
->code () == TYPE_CODE_ARRAY
)
2530 return value_zero (TYPE_TARGET_TYPE (type
),
2532 else if (type
->code () == TYPE_CODE_INT
)
2533 /* GDB allows dereferencing an int. */
2534 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2537 error (_("Attempt to take contents of a non-pointer value."));
2541 /* Allow * on an integer so we can cast it to whatever we want.
2542 This returns an int, which seems like the most C-like thing to
2543 do. "long long" variables are rare enough that
2544 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2545 if (type
->code () == TYPE_CODE_INT
)
2546 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2547 (CORE_ADDR
) value_as_address (arg1
));
2548 return value_ind (arg1
);
2551 /* C++: check for and handle pointer to members. */
2553 if (noside
== EVAL_SKIP
)
2555 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2556 return eval_skip_value (exp
);
2559 return evaluate_subexp_for_address (exp
, pos
, noside
);
2562 if (noside
== EVAL_SKIP
)
2564 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2565 return eval_skip_value (exp
);
2567 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2572 evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
));
2573 /* FIXME: This should be size_t. */
2574 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2575 ULONGEST align
= type_align (type
);
2577 error (_("could not determine alignment of type"));
2578 return value_from_longest (size_type
, align
);
2583 type
= exp
->elts
[pc
+ 1].type
;
2584 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2586 case UNOP_CAST_TYPE
:
2587 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2588 type
= value_type (arg1
);
2589 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2591 case UNOP_DYNAMIC_CAST
:
2592 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2593 type
= value_type (arg1
);
2594 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2595 if (noside
== EVAL_SKIP
)
2596 return eval_skip_value (exp
);
2597 return value_dynamic_cast (type
, arg1
);
2599 case UNOP_REINTERPRET_CAST
:
2600 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2601 type
= value_type (arg1
);
2602 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2603 if (noside
== EVAL_SKIP
)
2604 return eval_skip_value (exp
);
2605 return value_reinterpret_cast (type
, arg1
);
2609 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2610 if (noside
== EVAL_SKIP
)
2611 return eval_skip_value (exp
);
2612 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2613 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2615 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2616 value_as_address (arg1
));
2618 case UNOP_MEMVAL_TYPE
:
2619 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2620 type
= value_type (arg1
);
2621 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2622 if (noside
== EVAL_SKIP
)
2623 return eval_skip_value (exp
);
2624 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2625 return value_zero (type
, lval_memory
);
2627 return value_at_lazy (type
, value_as_address (arg1
));
2629 case UNOP_PREINCREMENT
:
2630 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2631 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2633 else if (unop_user_defined_p (op
, arg1
))
2635 return value_x_unop (arg1
, op
, noside
);
2639 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2640 arg2
= value_ptradd (arg1
, 1);
2643 struct value
*tmp
= arg1
;
2645 arg2
= value_one (value_type (arg1
));
2646 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2647 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2650 return value_assign (arg1
, arg2
);
2653 case UNOP_PREDECREMENT
:
2654 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2655 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2657 else if (unop_user_defined_p (op
, arg1
))
2659 return value_x_unop (arg1
, op
, noside
);
2663 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2664 arg2
= value_ptradd (arg1
, -1);
2667 struct value
*tmp
= arg1
;
2669 arg2
= value_one (value_type (arg1
));
2670 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2671 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2674 return value_assign (arg1
, arg2
);
2677 case UNOP_POSTINCREMENT
:
2678 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2679 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2681 else if (unop_user_defined_p (op
, arg1
))
2683 return value_x_unop (arg1
, op
, noside
);
2687 arg3
= value_non_lval (arg1
);
2689 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2690 arg2
= value_ptradd (arg1
, 1);
2693 struct value
*tmp
= arg1
;
2695 arg2
= value_one (value_type (arg1
));
2696 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2697 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2700 value_assign (arg1
, arg2
);
2704 case UNOP_POSTDECREMENT
:
2705 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2706 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2708 else if (unop_user_defined_p (op
, arg1
))
2710 return value_x_unop (arg1
, op
, noside
);
2714 arg3
= value_non_lval (arg1
);
2716 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2717 arg2
= value_ptradd (arg1
, -1);
2720 struct value
*tmp
= arg1
;
2722 arg2
= value_one (value_type (arg1
));
2723 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2724 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2727 value_assign (arg1
, arg2
);
2733 return value_of_this (exp
->language_defn
);
2736 /* The value is not supposed to be used. This is here to make it
2737 easier to accommodate expressions that contain types. */
2739 if (noside
== EVAL_SKIP
)
2740 return eval_skip_value (exp
);
2741 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2742 return allocate_value (exp
->elts
[pc
+ 1].type
);
2744 error (_("Attempt to use a type name as an expression"));
2748 if (noside
== EVAL_SKIP
)
2750 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
2751 return eval_skip_value (exp
);
2753 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2755 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2756 struct value
*result
;
2758 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2760 /* 'decltype' has special semantics for lvalues. */
2761 if (op
== OP_DECLTYPE
2762 && (sub_op
== BINOP_SUBSCRIPT
2763 || sub_op
== STRUCTOP_MEMBER
2764 || sub_op
== STRUCTOP_MPTR
2765 || sub_op
== UNOP_IND
2766 || sub_op
== STRUCTOP_STRUCT
2767 || sub_op
== STRUCTOP_PTR
2768 || sub_op
== OP_SCOPE
))
2770 type
= value_type (result
);
2772 if (!TYPE_IS_REFERENCE (type
))
2774 type
= lookup_lvalue_reference_type (type
);
2775 result
= allocate_value (type
);
2782 error (_("Attempt to use a type as an expression"));
2786 struct value
*result
;
2787 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2789 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2790 result
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2792 result
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2794 if (noside
!= EVAL_NORMAL
)
2795 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2797 return cplus_typeid (result
);
2801 /* Removing this case and compiling with gcc -Wall reveals that
2802 a lot of cases are hitting this case. Some of these should
2803 probably be removed from expression.h; others are legitimate
2804 expressions which are (apparently) not fully implemented.
2806 If there are any cases landing here which mean a user error,
2807 then they should be separate cases, with more descriptive
2810 error (_("GDB does not (yet) know how to "
2811 "evaluate that kind of expression"));
2814 gdb_assert_not_reached ("missed return?");
2817 /* Evaluate a subexpression of EXP, at index *POS,
2818 and return the address of that subexpression.
2819 Advance *POS over the subexpression.
2820 If the subexpression isn't an lvalue, get an error.
2821 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2822 then only the type of the result need be correct. */
2824 static struct value
*
2825 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2835 op
= exp
->elts
[pc
].opcode
;
2841 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2843 /* We can't optimize out "&*" if there's a user-defined operator*. */
2844 if (unop_user_defined_p (op
, x
))
2846 x
= value_x_unop (x
, op
, noside
);
2847 goto default_case_after_eval
;
2850 return coerce_array (x
);
2854 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2855 evaluate_subexp (nullptr, exp
, pos
, noside
));
2857 case UNOP_MEMVAL_TYPE
:
2862 x
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2863 type
= value_type (x
);
2864 return value_cast (lookup_pointer_type (type
),
2865 evaluate_subexp (nullptr, exp
, pos
, noside
));
2869 var
= exp
->elts
[pc
+ 2].symbol
;
2871 /* C++: The "address" of a reference should yield the address
2872 * of the object pointed to. Let value_addr() deal with it. */
2873 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
2877 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2880 lookup_pointer_type (SYMBOL_TYPE (var
));
2881 enum address_class sym_class
= SYMBOL_CLASS (var
);
2883 if (sym_class
== LOC_CONST
2884 || sym_class
== LOC_CONST_BYTES
2885 || sym_class
== LOC_REGISTER
)
2886 error (_("Attempt to take address of register or constant."));
2889 value_zero (type
, not_lval
);
2892 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2894 case OP_VAR_MSYM_VALUE
:
2898 value
*val
= evaluate_var_msym_value (noside
,
2899 exp
->elts
[pc
+ 1].objfile
,
2900 exp
->elts
[pc
+ 2].msymbol
);
2901 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2903 struct type
*type
= lookup_pointer_type (value_type (val
));
2904 return value_zero (type
, not_lval
);
2907 return value_addr (val
);
2911 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2912 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2913 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2914 &exp
->elts
[pc
+ 3].string
,
2917 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2922 x
= evaluate_subexp (nullptr, exp
, pos
, noside
);
2923 default_case_after_eval
:
2924 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2926 struct type
*type
= check_typedef (value_type (x
));
2928 if (TYPE_IS_REFERENCE (type
))
2929 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2931 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2932 return value_zero (lookup_pointer_type (value_type (x
)),
2935 error (_("Attempt to take address of "
2936 "value not located in memory."));
2938 return value_addr (x
);
2942 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2943 When used in contexts where arrays will be coerced anyway, this is
2944 equivalent to `evaluate_subexp' but much faster because it avoids
2945 actually fetching array contents (perhaps obsolete now that we have
2948 Note that we currently only do the coercion for C expressions, where
2949 arrays are zero based and the coercion is correct. For other languages,
2950 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2951 to decide if coercion is appropriate. */
2954 evaluate_subexp_with_coercion (struct expression
*exp
,
2955 int *pos
, enum noside noside
)
2964 op
= exp
->elts
[pc
].opcode
;
2969 var
= exp
->elts
[pc
+ 2].symbol
;
2970 type
= check_typedef (SYMBOL_TYPE (var
));
2971 if (type
->code () == TYPE_CODE_ARRAY
2972 && !type
->is_vector ()
2973 && CAST_IS_CONVERSION (exp
->language_defn
))
2976 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2977 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2983 return evaluate_subexp (nullptr, exp
, pos
, noside
);
2987 /* Evaluate a subexpression of EXP, at index *POS,
2988 and return a value for the size of that subexpression.
2989 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2990 we allow side-effects on the operand if its type is a variable
2993 static struct value
*
2994 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
2997 /* FIXME: This should be size_t. */
2998 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3005 op
= exp
->elts
[pc
].opcode
;
3009 /* This case is handled specially
3010 so that we avoid creating a value for the result type.
3011 If the result type is very big, it's desirable not to
3012 create a value unnecessarily. */
3015 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3016 type
= check_typedef (value_type (val
));
3017 if (type
->code () != TYPE_CODE_PTR
3018 && !TYPE_IS_REFERENCE (type
)
3019 && type
->code () != TYPE_CODE_ARRAY
)
3020 error (_("Attempt to take contents of a non-pointer value."));
3021 type
= TYPE_TARGET_TYPE (type
);
3022 if (is_dynamic_type (type
))
3023 type
= value_type (value_ind (val
));
3024 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3028 type
= exp
->elts
[pc
+ 1].type
;
3031 case UNOP_MEMVAL_TYPE
:
3033 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3034 type
= value_type (val
);
3038 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3039 if (is_dynamic_type (type
))
3041 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3042 type
= value_type (val
);
3043 if (type
->code () == TYPE_CODE_ARRAY
)
3045 if (type_not_allocated (type
) || type_not_associated (type
))
3046 return value_zero (size_type
, not_lval
);
3047 else if (is_dynamic_type (type
->index_type ())
3048 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
3049 return allocate_optimized_out_value (size_type
);
3056 case OP_VAR_MSYM_VALUE
:
3060 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3061 value
*mval
= evaluate_var_msym_value (noside
,
3062 exp
->elts
[pc
+ 1].objfile
,
3065 type
= value_type (mval
);
3066 if (type
->code () == TYPE_CODE_ERROR
)
3067 error_unknown_type (msymbol
->print_name ());
3069 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3073 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3074 type of the subscript is a variable length array type. In this case we
3075 must re-evaluate the right hand side of the subscription to allow
3077 case BINOP_SUBSCRIPT
:
3078 if (noside
== EVAL_NORMAL
)
3080 int npc
= (*pos
) + 1;
3082 val
= evaluate_subexp (nullptr, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3083 type
= check_typedef (value_type (val
));
3084 if (type
->code () == TYPE_CODE_ARRAY
)
3086 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3087 if (type
->code () == TYPE_CODE_ARRAY
)
3089 type
= type
->index_type ();
3090 /* Only re-evaluate the right hand side if the resulting type
3091 is a variable length type. */
3092 if (type
->bounds ()->flag_bound_evaluated
)
3094 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_NORMAL
);
3095 return value_from_longest
3096 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3105 val
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3106 type
= value_type (val
);
3110 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3111 "When applied to a reference or a reference type, the result is
3112 the size of the referenced type." */
3113 type
= check_typedef (type
);
3114 if (exp
->language_defn
->la_language
== language_cplus
3115 && (TYPE_IS_REFERENCE (type
)))
3116 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3117 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3120 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3121 for that subexpression cast to TO_TYPE. Advance *POS over the
3125 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3127 struct type
*to_type
)
3131 /* Don't let symbols be evaluated with evaluate_subexp because that
3132 throws an "unknown type" error for no-debug data symbols.
3133 Instead, we want the cast to reinterpret the symbol. */
3134 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3135 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3140 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3142 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3143 return value_zero (to_type
, not_lval
);
3145 val
= evaluate_var_msym_value (noside
,
3146 exp
->elts
[pc
+ 1].objfile
,
3147 exp
->elts
[pc
+ 2].msymbol
);
3150 val
= evaluate_var_value (noside
,
3151 exp
->elts
[pc
+ 1].block
,
3152 exp
->elts
[pc
+ 2].symbol
);
3154 if (noside
== EVAL_SKIP
)
3155 return eval_skip_value (exp
);
3157 val
= value_cast (to_type
, val
);
3159 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3160 if (VALUE_LVAL (val
) == lval_memory
)
3162 if (value_lazy (val
))
3163 value_fetch_lazy (val
);
3164 VALUE_LVAL (val
) = not_lval
;
3169 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3170 if (noside
== EVAL_SKIP
)
3171 return eval_skip_value (exp
);
3172 return value_cast (to_type
, val
);
3175 /* Parse a type expression in the string [P..P+LENGTH). */
3178 parse_and_eval_type (const char *p
, int length
)
3180 char *tmp
= (char *) alloca (length
+ 4);
3183 memcpy (tmp
+ 1, p
, length
);
3184 tmp
[length
+ 1] = ')';
3185 tmp
[length
+ 2] = '0';
3186 tmp
[length
+ 3] = '\0';
3187 expression_up expr
= parse_expression (tmp
);
3188 if (expr
->first_opcode () != UNOP_CAST
)
3189 error (_("Internal error in eval_type."));
3190 return expr
->elts
[1].type
;