1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2023 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"
31 #include "objc-lang.h"
33 #include "parser-defs.h"
34 #include "cp-support.h"
37 #include "user-regs.h"
39 #include "gdbsupport/gdb_obstack.h"
41 #include "typeprint.h"
48 /* Parse the string EXP as a C expression, evaluate it,
49 and return the result as a number. */
52 parse_and_eval_address (const char *exp
)
54 expression_up expr
= parse_expression (exp
);
56 return value_as_address (expr
->evaluate ());
59 /* Like parse_and_eval_address, but treats the value of the expression
60 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
62 parse_and_eval_long (const char *exp
)
64 expression_up expr
= parse_expression (exp
);
66 return value_as_long (expr
->evaluate ());
70 parse_and_eval (const char *exp
, parser_flags flags
)
72 expression_up expr
= parse_expression (exp
, nullptr, flags
);
74 return expr
->evaluate ();
77 /* Parse up to a comma (or to a closeparen)
78 in the string EXPP as an expression, evaluate it, and return the value.
79 EXPP is advanced to point to the comma. */
82 parse_to_comma_and_eval (const char **expp
)
84 expression_up expr
= parse_exp_1 (expp
, 0, nullptr,
85 PARSER_COMMA_TERMINATES
);
87 return expr
->evaluate ();
91 /* See expression.h. */
94 expression::uses_objfile (struct objfile
*objfile
) const
96 gdb_assert (objfile
->separate_debug_objfile_backlink
== nullptr);
97 return op
->uses_objfile (objfile
);
100 /* See expression.h. */
103 expression::evaluate (struct type
*expect_type
, enum noside noside
)
105 gdb::optional
<enable_thread_stack_temporaries
> stack_temporaries
;
106 if (target_has_execution () && inferior_ptid
!= null_ptid
107 && language_defn
->la_language
== language_cplus
108 && !thread_stack_temporaries_enabled_p (inferior_thread ()))
109 stack_temporaries
.emplace (inferior_thread ());
111 struct value
*retval
= op
->evaluate (expect_type
, this, noside
);
113 if (stack_temporaries
.has_value ()
114 && value_in_thread_stack_temporaries (retval
, inferior_thread ()))
115 retval
= retval
->non_lval ();
120 /* Find the current value of a watchpoint on EXP. Return the value in
121 *VALP and *RESULTP and the chain of intermediate and final values
122 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
125 If PRESERVE_ERRORS is true, then exceptions are passed through.
126 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
127 occurs while evaluating the expression, *RESULTP will be set to
128 NULL. *RESULTP may be a lazy value, if the result could not be
129 read from memory. It is used to determine whether a value is
130 user-specified (we should watch the whole value) or intermediate
131 (we should watch only the bit used to locate the final value).
133 If the final value, or any intermediate value, could not be read
134 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
135 set to any referenced values. *VALP will never be a lazy value.
136 This is the value which we store in struct breakpoint.
138 If VAL_CHAIN is non-NULL, the values put into *VAL_CHAIN will be
139 released from the value chain. If VAL_CHAIN is NULL, all generated
140 values will be left on the value chain. */
143 fetch_subexp_value (struct expression
*exp
,
145 struct value
**valp
, struct value
**resultp
,
146 std::vector
<value_ref_ptr
> *val_chain
,
147 bool preserve_errors
)
149 struct value
*mark
, *new_mark
, *result
;
157 /* Evaluate the expression. */
158 mark
= value_mark ();
163 result
= op
->evaluate (nullptr, exp
, EVAL_NORMAL
);
165 catch (const gdb_exception
&ex
)
167 /* Ignore memory errors if we want watchpoints pointing at
168 inaccessible memory to still be created; otherwise, throw the
169 error to some higher catcher. */
173 if (!preserve_errors
)
182 new_mark
= value_mark ();
183 if (mark
== new_mark
)
188 /* Make sure it's not lazy, so that after the target stops again we
189 have a non-lazy previous value to compare with. */
192 if (!result
->lazy ())
199 result
->fetch_lazy ();
202 catch (const gdb_exception_error
&except
)
210 /* Return the chain of intermediate values. We use this to
211 decide which addresses to watch. */
212 *val_chain
= value_release_to_mark (mark
);
216 /* Promote value ARG1 as appropriate before performing a unary operation
218 If the result is not appropriate for any particular language then it
219 needs to patch this function. */
222 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
227 *arg1
= coerce_ref (*arg1
);
228 type1
= check_typedef ((*arg1
)->type ());
230 if (is_integral_type (type1
))
232 switch (language
->la_language
)
235 /* Perform integral promotion for ANSI C/C++.
236 If not appropriate for any particular language
237 it needs to modify this function. */
239 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
241 if (type1
->length () < builtin_int
->length ())
242 *arg1
= value_cast (builtin_int
, *arg1
);
249 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
250 operation on those two operands.
251 If the result is not appropriate for any particular language then it
252 needs to patch this function. */
255 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
256 struct value
**arg1
, struct value
**arg2
)
258 struct type
*promoted_type
= NULL
;
262 *arg1
= coerce_ref (*arg1
);
263 *arg2
= coerce_ref (*arg2
);
265 type1
= check_typedef ((*arg1
)->type ());
266 type2
= check_typedef ((*arg2
)->type ());
268 if ((type1
->code () != TYPE_CODE_FLT
269 && type1
->code () != TYPE_CODE_DECFLOAT
270 && !is_integral_type (type1
))
271 || (type2
->code () != TYPE_CODE_FLT
272 && type2
->code () != TYPE_CODE_DECFLOAT
273 && !is_integral_type (type2
)))
276 if (is_fixed_point_type (type1
) || is_fixed_point_type (type2
))
279 if (type1
->code () == TYPE_CODE_DECFLOAT
280 || type2
->code () == TYPE_CODE_DECFLOAT
)
282 /* No promotion required. */
284 else if (type1
->code () == TYPE_CODE_FLT
285 || type2
->code () == TYPE_CODE_FLT
)
287 switch (language
->la_language
)
293 case language_opencl
:
294 /* No promotion required. */
298 /* For other languages the result type is unchanged from gdb
299 version 6.7 for backward compatibility.
300 If either arg was long double, make sure that value is also long
301 double. Otherwise use double. */
302 if (type1
->length () * 8 > gdbarch_double_bit (gdbarch
)
303 || type2
->length () * 8 > gdbarch_double_bit (gdbarch
))
304 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
306 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
310 else if (type1
->code () == TYPE_CODE_BOOL
311 && type2
->code () == TYPE_CODE_BOOL
)
313 /* No promotion required. */
316 /* Integral operations here. */
317 /* FIXME: Also mixed integral/booleans, with result an integer. */
319 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
320 unsigned int promoted_len1
= type1
->length ();
321 unsigned int promoted_len2
= type2
->length ();
322 int is_unsigned1
= type1
->is_unsigned ();
323 int is_unsigned2
= type2
->is_unsigned ();
324 unsigned int result_len
;
325 int unsigned_operation
;
327 /* Determine type length and signedness after promotion for
329 if (promoted_len1
< builtin
->builtin_int
->length ())
332 promoted_len1
= builtin
->builtin_int
->length ();
334 if (promoted_len2
< builtin
->builtin_int
->length ())
337 promoted_len2
= builtin
->builtin_int
->length ();
340 if (promoted_len1
> promoted_len2
)
342 unsigned_operation
= is_unsigned1
;
343 result_len
= promoted_len1
;
345 else if (promoted_len2
> promoted_len1
)
347 unsigned_operation
= is_unsigned2
;
348 result_len
= promoted_len2
;
352 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
353 result_len
= promoted_len1
;
356 switch (language
->la_language
)
358 case language_opencl
:
360 <= lookup_signed_typename (language
, "int")->length())
364 ? lookup_unsigned_typename (language
, "int")
365 : lookup_signed_typename (language
, "int"));
368 <= lookup_signed_typename (language
, "long")->length())
372 ? lookup_unsigned_typename (language
, "long")
373 : lookup_signed_typename (language
,"long"));
377 if (result_len
<= builtin
->builtin_int
->length ())
379 promoted_type
= (unsigned_operation
380 ? builtin
->builtin_unsigned_int
381 : builtin
->builtin_int
);
383 else if (result_len
<= builtin
->builtin_long
->length ())
385 promoted_type
= (unsigned_operation
386 ? builtin
->builtin_unsigned_long
387 : builtin
->builtin_long
);
389 else if (result_len
<= builtin
->builtin_long_long
->length ())
391 promoted_type
= (unsigned_operation
392 ? builtin
->builtin_unsigned_long_long
393 : builtin
->builtin_long_long
);
397 promoted_type
= (unsigned_operation
398 ? builtin
->builtin_uint128
399 : builtin
->builtin_int128
);
407 /* Promote both operands to common type. */
408 *arg1
= value_cast (promoted_type
, *arg1
);
409 *arg2
= value_cast (promoted_type
, *arg2
);
414 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
416 type
= check_typedef (type
);
417 if (TYPE_IS_REFERENCE (type
))
418 type
= type
->target_type ();
420 switch (type
->code ())
426 case TYPE_CODE_ARRAY
:
427 return type
->is_vector () ? 0 : lang
->c_style_arrays_p ();
434 /* Represents a fake method with the given parameter types. This is
435 used by the parser to construct a temporary "expected" type for
436 method overload resolution. FLAGS is used as instance flags of the
437 new type, in order to be able to make the new type represent a
438 const/volatile overload. */
443 fake_method (type_instance_flags flags
,
444 int num_types
, struct type
**param_types
);
447 /* The constructed type. */
448 struct type
*type () { return &m_type
; }
451 struct type m_type
{};
452 main_type m_main_type
{};
455 fake_method::fake_method (type_instance_flags flags
,
456 int num_types
, struct type
**param_types
)
458 struct type
*type
= &m_type
;
460 TYPE_MAIN_TYPE (type
) = &m_main_type
;
461 type
->set_length (1);
462 type
->set_code (TYPE_CODE_METHOD
);
463 TYPE_CHAIN (type
) = type
;
464 type
->set_instance_flags (flags
);
467 if (param_types
[num_types
- 1] == NULL
)
470 type
->set_has_varargs (true);
472 else if (check_typedef (param_types
[num_types
- 1])->code ()
476 /* Caller should have ensured this. */
477 gdb_assert (num_types
== 0);
478 type
->set_is_prototyped (true);
482 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
483 neither an objfile nor a gdbarch. As a result we must manually
484 allocate memory for auxiliary fields, and free the memory ourselves
485 when we are done with it. */
486 type
->set_num_fields (num_types
);
488 ((struct field
*) xzalloc (sizeof (struct field
) * num_types
));
490 while (num_types
-- > 0)
491 type
->field (num_types
).set_type (param_types
[num_types
]);
494 fake_method::~fake_method ()
496 xfree (m_type
.fields ());
503 type_instance_operation::evaluate (struct type
*expect_type
,
504 struct expression
*exp
,
507 type_instance_flags flags
= std::get
<0> (m_storage
);
508 std::vector
<type
*> &types
= std::get
<1> (m_storage
);
510 fake_method
fake_expect_type (flags
, types
.size (), types
.data ());
511 return std::get
<2> (m_storage
)->evaluate (fake_expect_type
.type (),
517 /* Helper for evaluating an OP_VAR_VALUE. */
520 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
522 /* JYG: We used to just return value::zero of the symbol type if
523 we're asked to avoid side effects. Otherwise we return
524 value_of_variable (...). However I'm not sure if
525 value_of_variable () has any side effect. We need a full value
526 object returned here for whatis_exp () to call evaluate_type ()
527 and then pass the full value to value_rtti_target_type () if we
528 are dealing with a pointer or reference to a base class and print
531 struct value
*ret
= NULL
;
535 ret
= value_of_variable (var
, blk
);
538 catch (const gdb_exception_error
&except
)
540 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
543 ret
= value::zero (var
->type (), not_lval
);
554 var_value_operation::evaluate (struct type
*expect_type
,
555 struct expression
*exp
,
558 symbol
*var
= std::get
<0> (m_storage
).symbol
;
559 if (var
->type ()->code () == TYPE_CODE_ERROR
)
560 error_unknown_type (var
->print_name ());
561 return evaluate_var_value (noside
, std::get
<0> (m_storage
).block
, var
);
564 } /* namespace expr */
566 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
569 evaluate_var_msym_value (enum noside noside
,
570 struct objfile
*objfile
, minimal_symbol
*msymbol
)
573 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
575 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !the_type
->is_gnu_ifunc ())
576 return value::zero (the_type
, not_lval
);
578 return value_at_lazy (the_type
, address
);
581 /* See expression.h. */
584 evaluate_subexp_do_call (expression
*exp
, enum noside noside
,
586 gdb::array_view
<value
*> argvec
,
587 const char *function_name
,
588 type
*default_return_type
)
591 error (_("Cannot evaluate function -- may be inlined"));
592 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
594 /* If the return type doesn't look like a function type,
595 call an error. This can happen if somebody tries to turn
596 a variable into a function call. */
598 type
*ftype
= callee
->type ();
600 if (ftype
->code () == TYPE_CODE_INTERNAL_FUNCTION
)
602 /* We don't know anything about what the internal
603 function might return, but we have to return
605 return value::zero (builtin_type (exp
->gdbarch
)->builtin_int
,
608 else if (ftype
->code () == TYPE_CODE_XMETHOD
)
610 type
*return_type
= callee
->result_type_of_xmethod (argvec
);
612 if (return_type
== NULL
)
613 error (_("Xmethod is missing return type."));
614 return value::zero (return_type
, not_lval
);
616 else if (ftype
->code () == TYPE_CODE_FUNC
617 || ftype
->code () == TYPE_CODE_METHOD
)
619 if (ftype
->is_gnu_ifunc ())
621 CORE_ADDR address
= callee
->address ();
622 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
624 if (resolved_type
!= NULL
)
625 ftype
= resolved_type
;
628 type
*return_type
= ftype
->target_type ();
630 if (return_type
== NULL
)
631 return_type
= default_return_type
;
633 if (return_type
== NULL
)
634 error_call_unknown_return_type (function_name
);
636 return value::allocate (return_type
);
639 error (_("Expression of type other than "
640 "\"Function returning ...\" used as function"));
642 switch (callee
->type ()->code ())
644 case TYPE_CODE_INTERNAL_FUNCTION
:
645 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
646 callee
, argvec
.size (), argvec
.data ());
647 case TYPE_CODE_XMETHOD
:
648 return callee
->call_xmethod (argvec
);
650 return call_function_by_hand (callee
, default_return_type
, argvec
);
658 operation::evaluate_funcall (struct type
*expect_type
,
659 struct expression
*exp
,
661 const char *function_name
,
662 const std::vector
<operation_up
> &args
)
664 std::vector
<value
*> vals (args
.size ());
666 value
*callee
= evaluate_with_coercion (exp
, noside
);
667 struct type
*type
= callee
->type ();
668 if (type
->code () == TYPE_CODE_PTR
)
669 type
= type
->target_type ();
670 for (int i
= 0; i
< args
.size (); ++i
)
672 if (i
< type
->num_fields ())
673 vals
[i
] = args
[i
]->evaluate (type
->field (i
).type (), exp
, noside
);
675 vals
[i
] = args
[i
]->evaluate_with_coercion (exp
, noside
);
678 return evaluate_subexp_do_call (exp
, noside
, callee
, vals
,
679 function_name
, expect_type
);
683 var_value_operation::evaluate_funcall (struct type
*expect_type
,
684 struct expression
*exp
,
686 const std::vector
<operation_up
> &args
)
688 if (!overload_resolution
689 || exp
->language_defn
->la_language
!= language_cplus
)
690 return operation::evaluate_funcall (expect_type
, exp
, noside
, args
);
692 std::vector
<value
*> argvec (args
.size ());
693 for (int i
= 0; i
< args
.size (); ++i
)
694 argvec
[i
] = args
[i
]->evaluate_with_coercion (exp
, noside
);
697 find_overload_match (argvec
, NULL
, NON_METHOD
,
698 NULL
, std::get
<0> (m_storage
).symbol
,
699 NULL
, &symp
, NULL
, 0, noside
);
701 if (symp
->type ()->code () == TYPE_CODE_ERROR
)
702 error_unknown_type (symp
->print_name ());
703 value
*callee
= evaluate_var_value (noside
, std::get
<0> (m_storage
).block
,
706 return evaluate_subexp_do_call (exp
, noside
, callee
, argvec
,
707 nullptr, expect_type
);
711 scope_operation::evaluate_funcall (struct type
*expect_type
,
712 struct expression
*exp
,
714 const std::vector
<operation_up
> &args
)
716 if (!overload_resolution
717 || exp
->language_defn
->la_language
!= language_cplus
)
718 return operation::evaluate_funcall (expect_type
, exp
, noside
, args
);
720 /* Unpack it locally so we can properly handle overload
722 const std::string
&name
= std::get
<1> (m_storage
);
723 struct type
*type
= std::get
<0> (m_storage
);
725 symbol
*function
= NULL
;
726 const char *function_name
= NULL
;
727 std::vector
<value
*> argvec (1 + args
.size ());
728 if (type
->code () == TYPE_CODE_NAMESPACE
)
730 function
= cp_lookup_symbol_namespace (type
->name (),
732 get_selected_block (0),
734 if (function
== NULL
)
735 error (_("No symbol \"%s\" in namespace \"%s\"."),
736 name
.c_str (), type
->name ());
740 gdb_assert (type
->code () == TYPE_CODE_STRUCT
741 || type
->code () == TYPE_CODE_UNION
);
742 function_name
= name
.c_str ();
744 /* We need a properly typed value for method lookup. */
745 argvec
[0] = value::zero (type
, lval_memory
);
748 for (int i
= 0; i
< args
.size (); ++i
)
749 argvec
[i
+ 1] = args
[i
]->evaluate_with_coercion (exp
, noside
);
750 gdb::array_view
<value
*> arg_view
= argvec
;
752 value
*callee
= nullptr;
753 if (function_name
!= nullptr)
757 find_overload_match (arg_view
, function_name
, METHOD
,
758 &argvec
[0], nullptr, &callee
, nullptr,
759 &static_memfuncp
, 0, noside
);
760 if (!static_memfuncp
)
762 /* For the time being, we don't handle this. */
763 error (_("Call to overloaded function %s requires "
768 arg_view
= arg_view
.slice (1);
773 arg_view
= arg_view
.slice (1);
774 find_overload_match (arg_view
, nullptr,
775 NON_METHOD
, nullptr, function
,
776 nullptr, &symp
, nullptr, 1, noside
);
777 callee
= value_of_variable (symp
, get_selected_block (0));
780 return evaluate_subexp_do_call (exp
, noside
, callee
, arg_view
,
781 nullptr, expect_type
);
785 structop_member_base::evaluate_funcall (struct type
*expect_type
,
786 struct expression
*exp
,
788 const std::vector
<operation_up
> &args
)
790 /* First, evaluate the structure into lhs. */
792 if (opcode () == STRUCTOP_MEMBER
)
793 lhs
= std::get
<0> (m_storage
)->evaluate_for_address (exp
, noside
);
795 lhs
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
797 std::vector
<value
*> vals (args
.size () + 1);
798 gdb::array_view
<value
*> val_view
= vals
;
799 /* If the function is a virtual function, then the aggregate
800 value (providing the structure) plays its part by providing
801 the vtable. Otherwise, it is just along for the ride: call
802 the function directly. */
803 value
*rhs
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
806 type
*a1_type
= check_typedef (rhs
->type ());
807 if (a1_type
->code () == TYPE_CODE_METHODPTR
)
809 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
810 callee
= value::zero (a1_type
->target_type (), not_lval
);
812 callee
= cplus_method_ptr_to_value (&lhs
, rhs
);
816 else if (a1_type
->code () == TYPE_CODE_MEMBERPTR
)
818 struct type
*type_ptr
819 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
820 struct type
*target_type_ptr
821 = lookup_pointer_type (a1_type
->target_type ());
823 /* Now, convert this value to an address. */
824 lhs
= value_cast (type_ptr
, lhs
);
826 long mem_offset
= value_as_long (rhs
);
828 callee
= value_from_pointer (target_type_ptr
,
829 value_as_long (lhs
) + mem_offset
);
830 callee
= value_ind (callee
);
832 val_view
= val_view
.slice (1);
835 error (_("Non-pointer-to-member value used in pointer-to-member "
838 for (int i
= 0; i
< args
.size (); ++i
)
839 vals
[i
+ 1] = args
[i
]->evaluate_with_coercion (exp
, noside
);
841 return evaluate_subexp_do_call (exp
, noside
, callee
, val_view
,
842 nullptr, expect_type
);
847 structop_base_operation::evaluate_funcall
848 (struct type
*expect_type
, struct expression
*exp
, enum noside noside
,
849 const std::vector
<operation_up
> &args
)
851 /* Allocate space for the function call arguments, Including space for a
852 `this' pointer at the start. */
853 std::vector
<value
*> vals (args
.size () + 1);
854 /* First, evaluate the structure into vals[0]. */
855 enum exp_opcode op
= opcode ();
856 if (op
== STRUCTOP_STRUCT
)
858 /* If v is a variable in a register, and the user types
859 v.method (), this will produce an error, because v has no
862 A possible way around this would be to allocate a copy of
863 the variable on the stack, copy in the contents, call the
864 function, and copy out the contents. I.e. convert this
865 from call by reference to call by copy-return (or
866 whatever it's called). However, this does not work
867 because it is not the same: the method being called could
868 stash a copy of the address, and then future uses through
869 that address (after the method returns) would be expected
870 to use the variable itself, not some copy of it. */
871 vals
[0] = std::get
<0> (m_storage
)->evaluate_for_address (exp
, noside
);
875 vals
[0] = std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
876 /* Check to see if the operator '->' has been overloaded.
877 If the operator has been overloaded replace vals[0] with the
878 value returned by the custom operator and continue
880 while (unop_user_defined_p (op
, vals
[0]))
882 struct value
*value
= nullptr;
885 value
= value_x_unop (vals
[0], op
, noside
);
887 catch (const gdb_exception_error
&except
)
889 if (except
.error
== NOT_FOUND_ERROR
)
899 /* Evaluate the arguments. The '+ 1' here is to allow for the `this'
900 pointer we placed into vals[0]. */
901 for (int i
= 0; i
< args
.size (); ++i
)
902 vals
[i
+ 1] = args
[i
]->evaluate_with_coercion (exp
, noside
);
904 /* The array view includes the `this' pointer. */
905 gdb::array_view
<value
*> arg_view (vals
);
909 const char *tstr
= std::get
<1> (m_storage
).c_str ();
910 if (overload_resolution
911 && exp
->language_defn
->la_language
== language_cplus
)
913 /* Language is C++, do some overload resolution before
915 value
*val0
= vals
[0];
916 find_overload_match (arg_view
, tstr
, METHOD
,
917 &val0
, nullptr, &callee
, nullptr,
918 &static_memfuncp
, 0, noside
);
922 /* Non-C++ case -- or no overload resolution. */
924 struct value
*temp
= vals
[0];
926 callee
= value_struct_elt (&temp
, arg_view
, tstr
,
928 op
== STRUCTOP_STRUCT
929 ? "structure" : "structure pointer");
930 /* value_struct_elt updates temp with the correct value of the
931 ``this'' pointer if necessary, so modify it to reflect any
933 vals
[0] = value_from_longest (lookup_pointer_type (temp
->type ()),
935 + temp
->embedded_offset ());
938 /* Take out `this' if needed. */
940 arg_view
= arg_view
.slice (1);
942 return evaluate_subexp_do_call (exp
, noside
, callee
, arg_view
,
943 nullptr, expect_type
);
946 /* Helper for structop_base_operation::complete which recursively adds
947 field and method names from TYPE, a struct or union type, to the
948 OUTPUT list. PREFIX is prepended to each result. */
951 add_struct_fields (struct type
*type
, completion_list
&output
,
952 const char *fieldname
, int namelen
, const char *prefix
)
955 int computed_type_name
= 0;
956 const char *type_name
= NULL
;
958 type
= check_typedef (type
);
959 for (i
= 0; i
< type
->num_fields (); ++i
)
961 if (i
< TYPE_N_BASECLASSES (type
))
962 add_struct_fields (TYPE_BASECLASS (type
, i
),
963 output
, fieldname
, namelen
, prefix
);
964 else if (type
->field (i
).name ())
966 if (type
->field (i
).name ()[0] != '\0')
968 if (! strncmp (type
->field (i
).name (),
970 output
.emplace_back (concat (prefix
, type
->field (i
).name (),
973 else if (type
->field (i
).type ()->code () == TYPE_CODE_UNION
)
975 /* Recurse into anonymous unions. */
976 add_struct_fields (type
->field (i
).type (),
977 output
, fieldname
, namelen
, prefix
);
982 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
984 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
986 if (name
&& ! strncmp (name
, fieldname
, namelen
))
988 if (!computed_type_name
)
990 type_name
= type
->name ();
991 computed_type_name
= 1;
993 /* Omit constructors from the completion list. */
994 if (!type_name
|| strcmp (type_name
, name
))
995 output
.emplace_back (concat (prefix
, name
, nullptr));
1003 structop_base_operation::complete (struct expression
*exp
,
1004 completion_tracker
&tracker
,
1007 const std::string
&fieldname
= std::get
<1> (m_storage
);
1009 value
*lhs
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
1010 EVAL_AVOID_SIDE_EFFECTS
);
1011 struct type
*type
= lhs
->type ();
1014 type
= check_typedef (type
);
1015 if (!type
->is_pointer_or_reference ())
1017 type
= type
->target_type ();
1020 if (type
->code () == TYPE_CODE_UNION
1021 || type
->code () == TYPE_CODE_STRUCT
)
1023 completion_list result
;
1025 add_struct_fields (type
, result
, fieldname
.c_str (),
1026 fieldname
.length (), prefix
);
1027 tracker
.add_completions (std::move (result
));
1034 } /* namespace expr */
1036 /* Return true if type is integral or reference to integral */
1039 is_integral_or_integral_reference (struct type
*type
)
1041 if (is_integral_type (type
))
1044 type
= check_typedef (type
);
1045 return (type
!= nullptr
1046 && TYPE_IS_REFERENCE (type
)
1047 && is_integral_type (type
->target_type ()));
1050 /* Helper function that implements the body of OP_SCOPE. */
1053 eval_op_scope (struct type
*expect_type
, struct expression
*exp
,
1055 struct type
*type
, const char *string
)
1057 struct value
*arg1
= value_aggregate_elt (type
, string
, expect_type
,
1060 error (_("There is no field named %s"), string
);
1064 /* Helper function that implements the body of OP_VAR_ENTRY_VALUE. */
1067 eval_op_var_entry_value (struct type
*expect_type
, struct expression
*exp
,
1068 enum noside noside
, symbol
*sym
)
1070 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1071 return value::zero (sym
->type (), not_lval
);
1073 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1074 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1075 error (_("Symbol \"%s\" does not have any specific entry value"),
1076 sym
->print_name ());
1078 frame_info_ptr frame
= get_selected_frame (NULL
);
1079 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1082 /* Helper function that implements the body of OP_VAR_MSYM_VALUE. */
1085 eval_op_var_msym_value (struct type
*expect_type
, struct expression
*exp
,
1086 enum noside noside
, bool outermost_p
,
1087 bound_minimal_symbol msymbol
)
1089 value
*val
= evaluate_var_msym_value (noside
, msymbol
.objfile
,
1092 struct type
*type
= val
->type ();
1093 if (type
->code () == TYPE_CODE_ERROR
1094 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| !outermost_p
))
1095 error_unknown_type (msymbol
.minsym
->print_name ());
1099 /* Helper function that implements the body of OP_FUNC_STATIC_VAR. */
1102 eval_op_func_static_var (struct type
*expect_type
, struct expression
*exp
,
1104 value
*func
, const char *var
)
1106 CORE_ADDR addr
= func
->address ();
1107 const block
*blk
= block_for_pc (addr
);
1108 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1109 if (sym
.symbol
== NULL
)
1110 error (_("No symbol \"%s\" in specified context."), var
);
1111 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1114 /* Helper function that implements the body of OP_REGISTER. */
1117 eval_op_register (struct type
*expect_type
, struct expression
*exp
,
1118 enum noside noside
, const char *name
)
1123 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1124 name
, strlen (name
));
1126 error (_("Register $%s not available."), name
);
1128 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1129 a value with the appropriate register type. Unfortunately,
1130 we don't have easy access to the type of user registers.
1131 So for these registers, we fetch the register value regardless
1132 of the evaluation mode. */
1133 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1134 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1135 val
= value::zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1137 val
= value_of_register (regno
, get_selected_frame (NULL
));
1139 error (_("Value of register %s not available."), name
);
1148 string_operation::evaluate (struct type
*expect_type
,
1149 struct expression
*exp
,
1152 const std::string
&str
= std::get
<0> (m_storage
);
1153 struct type
*type
= language_string_char_type (exp
->language_defn
,
1155 return value_string (str
.c_str (), str
.size (), type
);
1159 ternop_slice_operation::evaluate (struct type
*expect_type
,
1160 struct expression
*exp
,
1164 = std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
1166 = std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
1168 = std::get
<2> (m_storage
)->evaluate (nullptr, exp
, noside
);
1170 int lowbound
= value_as_long (low
);
1171 int upperbound
= value_as_long (upper
);
1172 return value_slice (array
, lowbound
, upperbound
- lowbound
+ 1);
1175 } /* namespace expr */
1177 /* Helper function that implements the body of OP_OBJC_SELECTOR. */
1180 eval_op_objc_selector (struct type
*expect_type
, struct expression
*exp
,
1184 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1185 return value_from_longest (selector_type
,
1186 lookup_child_selector (exp
->gdbarch
, sel
));
1189 /* A helper function for STRUCTOP_STRUCT. */
1192 eval_op_structop_struct (struct type
*expect_type
, struct expression
*exp
,
1194 struct value
*arg1
, const char *string
)
1196 struct value
*arg3
= value_struct_elt (&arg1
, {}, string
,
1198 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1199 arg3
= value::zero (arg3
->type (), arg3
->lval ());
1203 /* A helper function for STRUCTOP_PTR. */
1206 eval_op_structop_ptr (struct type
*expect_type
, struct expression
*exp
,
1208 struct value
*arg1
, const char *string
)
1210 /* Check to see if operator '->' has been overloaded. If so replace
1211 arg1 with the value returned by evaluating operator->(). */
1212 while (unop_user_defined_p (STRUCTOP_PTR
, arg1
))
1214 struct value
*value
= NULL
;
1217 value
= value_x_unop (arg1
, STRUCTOP_PTR
, noside
);
1220 catch (const gdb_exception_error
&except
)
1222 if (except
.error
== NOT_FOUND_ERROR
)
1231 /* JYG: if print object is on we need to replace the base type
1232 with rtti type in order to continue on with successful
1233 lookup of member / method only available in the rtti type. */
1235 struct type
*arg_type
= arg1
->type ();
1236 struct type
*real_type
;
1237 int full
, using_enc
;
1239 struct value_print_options opts
;
1241 get_user_print_options (&opts
);
1242 if (opts
.objectprint
&& arg_type
->target_type ()
1243 && (arg_type
->target_type ()->code () == TYPE_CODE_STRUCT
))
1245 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1248 arg1
= value_cast (real_type
, arg1
);
1252 struct value
*arg3
= value_struct_elt (&arg1
, {}, string
,
1253 NULL
, "structure pointer");
1254 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1255 arg3
= value::zero (arg3
->type (), arg3
->lval ());
1259 /* A helper function for STRUCTOP_MEMBER. */
1262 eval_op_member (struct type
*expect_type
, struct expression
*exp
,
1264 struct value
*arg1
, struct value
*arg2
)
1269 struct type
*type
= check_typedef (arg2
->type ());
1270 switch (type
->code ())
1272 case TYPE_CODE_METHODPTR
:
1273 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1274 return value::zero (type
->target_type (), not_lval
);
1277 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1278 gdb_assert (arg2
->type ()->code () == TYPE_CODE_PTR
);
1279 return value_ind (arg2
);
1282 case TYPE_CODE_MEMBERPTR
:
1283 /* Now, convert these values to an address. */
1284 if (check_typedef (arg1
->type ())->code () != TYPE_CODE_PTR
)
1285 arg1
= value_addr (arg1
);
1286 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1289 mem_offset
= value_as_long (arg2
);
1291 arg3
= value_from_pointer (lookup_pointer_type (type
->target_type ()),
1292 value_as_long (arg1
) + mem_offset
);
1293 return value_ind (arg3
);
1296 error (_("non-pointer-to-member value used "
1297 "in pointer-to-member construct"));
1301 /* A helper function for BINOP_ADD. */
1304 eval_op_add (struct type
*expect_type
, struct expression
*exp
,
1306 struct value
*arg1
, struct value
*arg2
)
1308 if (binop_user_defined_p (BINOP_ADD
, arg1
, arg2
))
1309 return value_x_binop (arg1
, arg2
, BINOP_ADD
, OP_NULL
, noside
);
1310 else if (ptrmath_type_p (exp
->language_defn
, arg1
->type ())
1311 && is_integral_or_integral_reference (arg2
->type ()))
1312 return value_ptradd (arg1
, value_as_long (arg2
));
1313 else if (ptrmath_type_p (exp
->language_defn
, arg2
->type ())
1314 && is_integral_or_integral_reference (arg1
->type ()))
1315 return value_ptradd (arg2
, value_as_long (arg1
));
1318 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1319 return value_binop (arg1
, arg2
, BINOP_ADD
);
1323 /* A helper function for BINOP_SUB. */
1326 eval_op_sub (struct type
*expect_type
, struct expression
*exp
,
1328 struct value
*arg1
, struct value
*arg2
)
1330 if (binop_user_defined_p (BINOP_SUB
, arg1
, arg2
))
1331 return value_x_binop (arg1
, arg2
, BINOP_SUB
, OP_NULL
, noside
);
1332 else if (ptrmath_type_p (exp
->language_defn
, arg1
->type ())
1333 && ptrmath_type_p (exp
->language_defn
, arg2
->type ()))
1335 /* FIXME -- should be ptrdiff_t */
1336 struct type
*type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1337 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1339 else if (ptrmath_type_p (exp
->language_defn
, arg1
->type ())
1340 && is_integral_or_integral_reference (arg2
->type ()))
1341 return value_ptradd (arg1
, - value_as_long (arg2
));
1344 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1345 return value_binop (arg1
, arg2
, BINOP_SUB
);
1349 /* Helper function for several different binary operations. */
1352 eval_op_binary (struct type
*expect_type
, struct expression
*exp
,
1353 enum noside noside
, enum exp_opcode op
,
1354 struct value
*arg1
, struct value
*arg2
)
1356 if (binop_user_defined_p (op
, arg1
, arg2
))
1357 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1360 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1361 fudge arg2 to avoid division-by-zero, the caller is
1362 (theoretically) only looking for the type of the result. */
1363 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1364 /* ??? Do we really want to test for BINOP_MOD here?
1365 The implementation of value_binop gives it a well-defined
1368 || op
== BINOP_INTDIV
1371 && value_logical_not (arg2
))
1373 struct value
*v_one
;
1375 v_one
= value_one (arg2
->type ());
1376 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1377 return value_binop (arg1
, v_one
, op
);
1381 /* For shift and integer exponentiation operations,
1382 only promote the first argument. */
1383 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1384 && is_integral_type (arg2
->type ()))
1385 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1387 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1389 return value_binop (arg1
, arg2
, op
);
1394 /* A helper function for BINOP_SUBSCRIPT. */
1397 eval_op_subscript (struct type
*expect_type
, struct expression
*exp
,
1398 enum noside noside
, enum exp_opcode op
,
1399 struct value
*arg1
, struct value
*arg2
)
1401 if (binop_user_defined_p (op
, arg1
, arg2
))
1402 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1405 /* If the user attempts to subscript something that is not an
1406 array or pointer type (like a plain int variable for example),
1407 then report this as an error. */
1409 arg1
= coerce_ref (arg1
);
1410 struct type
*type
= check_typedef (arg1
->type ());
1411 if (type
->code () != TYPE_CODE_ARRAY
1412 && type
->code () != TYPE_CODE_PTR
)
1415 error (_("cannot subscript something of type `%s'"),
1418 error (_("cannot subscript requested type"));
1421 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1422 return value::zero (type
->target_type (), arg1
->lval ());
1424 return value_subscript (arg1
, value_as_long (arg2
));
1428 /* A helper function for BINOP_EQUAL. */
1431 eval_op_equal (struct type
*expect_type
, struct expression
*exp
,
1432 enum noside noside
, enum exp_opcode op
,
1433 struct value
*arg1
, struct value
*arg2
)
1435 if (binop_user_defined_p (op
, arg1
, arg2
))
1437 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1441 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1442 int tem
= value_equal (arg1
, arg2
);
1443 struct type
*type
= language_bool_type (exp
->language_defn
,
1445 return value_from_longest (type
, (LONGEST
) tem
);
1449 /* A helper function for BINOP_NOTEQUAL. */
1452 eval_op_notequal (struct type
*expect_type
, struct expression
*exp
,
1453 enum noside noside
, enum exp_opcode op
,
1454 struct value
*arg1
, struct value
*arg2
)
1456 if (binop_user_defined_p (op
, arg1
, arg2
))
1458 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1462 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1463 int tem
= value_equal (arg1
, arg2
);
1464 struct type
*type
= language_bool_type (exp
->language_defn
,
1466 return value_from_longest (type
, (LONGEST
) ! tem
);
1470 /* A helper function for BINOP_LESS. */
1473 eval_op_less (struct type
*expect_type
, struct expression
*exp
,
1474 enum noside noside
, enum exp_opcode op
,
1475 struct value
*arg1
, struct value
*arg2
)
1477 if (binop_user_defined_p (op
, arg1
, arg2
))
1479 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1483 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1484 int tem
= value_less (arg1
, arg2
);
1485 struct type
*type
= language_bool_type (exp
->language_defn
,
1487 return value_from_longest (type
, (LONGEST
) tem
);
1491 /* A helper function for BINOP_GTR. */
1494 eval_op_gtr (struct type
*expect_type
, struct expression
*exp
,
1495 enum noside noside
, enum exp_opcode op
,
1496 struct value
*arg1
, struct value
*arg2
)
1498 if (binop_user_defined_p (op
, arg1
, arg2
))
1500 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1504 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1505 int tem
= value_less (arg2
, arg1
);
1506 struct type
*type
= language_bool_type (exp
->language_defn
,
1508 return value_from_longest (type
, (LONGEST
) tem
);
1512 /* A helper function for BINOP_GEQ. */
1515 eval_op_geq (struct type
*expect_type
, struct expression
*exp
,
1516 enum noside noside
, enum exp_opcode op
,
1517 struct value
*arg1
, struct value
*arg2
)
1519 if (binop_user_defined_p (op
, arg1
, arg2
))
1521 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1525 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1526 int tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1527 struct type
*type
= language_bool_type (exp
->language_defn
,
1529 return value_from_longest (type
, (LONGEST
) tem
);
1533 /* A helper function for BINOP_LEQ. */
1536 eval_op_leq (struct type
*expect_type
, struct expression
*exp
,
1537 enum noside noside
, enum exp_opcode op
,
1538 struct value
*arg1
, struct value
*arg2
)
1540 if (binop_user_defined_p (op
, arg1
, arg2
))
1542 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1546 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1547 int tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1548 struct type
*type
= language_bool_type (exp
->language_defn
,
1550 return value_from_longest (type
, (LONGEST
) tem
);
1554 /* A helper function for BINOP_REPEAT. */
1557 eval_op_repeat (struct type
*expect_type
, struct expression
*exp
,
1558 enum noside noside
, enum exp_opcode op
,
1559 struct value
*arg1
, struct value
*arg2
)
1561 struct type
*type
= check_typedef (arg2
->type ());
1562 if (type
->code () != TYPE_CODE_INT
1563 && type
->code () != TYPE_CODE_ENUM
)
1564 error (_("Non-integral right operand for \"@\" operator."));
1565 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1567 return allocate_repeat_value (arg1
->type (),
1568 longest_to_int (value_as_long (arg2
)));
1571 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1574 /* A helper function for UNOP_PLUS. */
1577 eval_op_plus (struct type
*expect_type
, struct expression
*exp
,
1578 enum noside noside
, enum exp_opcode op
,
1581 if (unop_user_defined_p (op
, arg1
))
1582 return value_x_unop (arg1
, op
, noside
);
1585 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1586 return value_pos (arg1
);
1590 /* A helper function for UNOP_NEG. */
1593 eval_op_neg (struct type
*expect_type
, struct expression
*exp
,
1594 enum noside noside
, enum exp_opcode op
,
1597 if (unop_user_defined_p (op
, arg1
))
1598 return value_x_unop (arg1
, op
, noside
);
1601 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1602 return value_neg (arg1
);
1606 /* A helper function for UNOP_COMPLEMENT. */
1609 eval_op_complement (struct type
*expect_type
, struct expression
*exp
,
1610 enum noside noside
, enum exp_opcode op
,
1613 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1614 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1617 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1618 return value_complement (arg1
);
1622 /* A helper function for UNOP_LOGICAL_NOT. */
1625 eval_op_lognot (struct type
*expect_type
, struct expression
*exp
,
1626 enum noside noside
, enum exp_opcode op
,
1629 if (unop_user_defined_p (op
, arg1
))
1630 return value_x_unop (arg1
, op
, noside
);
1633 struct type
*type
= language_bool_type (exp
->language_defn
,
1635 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
1639 /* A helper function for UNOP_IND. */
1642 eval_op_ind (struct type
*expect_type
, struct expression
*exp
,
1646 struct type
*type
= check_typedef (arg1
->type ());
1647 if (type
->code () == TYPE_CODE_METHODPTR
1648 || type
->code () == TYPE_CODE_MEMBERPTR
)
1649 error (_("Attempt to dereference pointer "
1650 "to member without an object"));
1651 if (unop_user_defined_p (UNOP_IND
, arg1
))
1652 return value_x_unop (arg1
, UNOP_IND
, noside
);
1653 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1655 type
= check_typedef (arg1
->type ());
1657 /* If the type pointed to is dynamic then in order to resolve the
1658 dynamic properties we must actually dereference the pointer.
1659 There is a risk that this dereference will have side-effects
1660 in the inferior, but being able to print accurate type
1661 information seems worth the risk. */
1662 if (!type
->is_pointer_or_reference ()
1663 || !is_dynamic_type (type
->target_type ()))
1665 if (type
->is_pointer_or_reference ()
1666 /* In C you can dereference an array to get the 1st elt. */
1667 || type
->code () == TYPE_CODE_ARRAY
)
1668 return value::zero (type
->target_type (),
1670 else if (type
->code () == TYPE_CODE_INT
)
1671 /* GDB allows dereferencing an int. */
1672 return value::zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1675 error (_("Attempt to take contents of a non-pointer value."));
1679 /* Allow * on an integer so we can cast it to whatever we want.
1680 This returns an int, which seems like the most C-like thing to
1681 do. "long long" variables are rare enough that
1682 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
1683 if (type
->code () == TYPE_CODE_INT
)
1684 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
1685 (CORE_ADDR
) value_as_address (arg1
));
1686 return value_ind (arg1
);
1689 /* A helper function for UNOP_ALIGNOF. */
1692 eval_op_alignof (struct type
*expect_type
, struct expression
*exp
,
1696 struct type
*type
= arg1
->type ();
1697 /* FIXME: This should be size_t. */
1698 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
1699 ULONGEST align
= type_align (type
);
1701 error (_("could not determine alignment of type"));
1702 return value_from_longest (size_type
, align
);
1705 /* A helper function for UNOP_MEMVAL. */
1708 eval_op_memval (struct type
*expect_type
, struct expression
*exp
,
1710 struct value
*arg1
, struct type
*type
)
1712 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1713 return value::zero (type
, lval_memory
);
1715 return value_at_lazy (type
, value_as_address (arg1
));
1718 /* A helper function for UNOP_PREINCREMENT. */
1721 eval_op_preinc (struct type
*expect_type
, struct expression
*exp
,
1722 enum noside noside
, enum exp_opcode op
,
1725 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1727 else if (unop_user_defined_p (op
, arg1
))
1729 return value_x_unop (arg1
, op
, noside
);
1734 if (ptrmath_type_p (exp
->language_defn
, arg1
->type ()))
1735 arg2
= value_ptradd (arg1
, 1);
1738 struct value
*tmp
= arg1
;
1740 arg2
= value_one (arg1
->type ());
1741 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1742 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
1745 return value_assign (arg1
, arg2
);
1749 /* A helper function for UNOP_PREDECREMENT. */
1752 eval_op_predec (struct type
*expect_type
, struct expression
*exp
,
1753 enum noside noside
, enum exp_opcode op
,
1756 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1758 else if (unop_user_defined_p (op
, arg1
))
1760 return value_x_unop (arg1
, op
, noside
);
1765 if (ptrmath_type_p (exp
->language_defn
, arg1
->type ()))
1766 arg2
= value_ptradd (arg1
, -1);
1769 struct value
*tmp
= arg1
;
1771 arg2
= value_one (arg1
->type ());
1772 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1773 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
1776 return value_assign (arg1
, arg2
);
1780 /* A helper function for UNOP_POSTINCREMENT. */
1783 eval_op_postinc (struct type
*expect_type
, struct expression
*exp
,
1784 enum noside noside
, enum exp_opcode op
,
1787 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1789 else if (unop_user_defined_p (op
, arg1
))
1791 return value_x_unop (arg1
, op
, noside
);
1795 struct value
*arg3
= arg1
->non_lval ();
1798 if (ptrmath_type_p (exp
->language_defn
, arg1
->type ()))
1799 arg2
= value_ptradd (arg1
, 1);
1802 struct value
*tmp
= arg1
;
1804 arg2
= value_one (arg1
->type ());
1805 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1806 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
1809 value_assign (arg1
, arg2
);
1814 /* A helper function for UNOP_POSTDECREMENT. */
1817 eval_op_postdec (struct type
*expect_type
, struct expression
*exp
,
1818 enum noside noside
, enum exp_opcode op
,
1821 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1823 else if (unop_user_defined_p (op
, arg1
))
1825 return value_x_unop (arg1
, op
, noside
);
1829 struct value
*arg3
= arg1
->non_lval ();
1832 if (ptrmath_type_p (exp
->language_defn
, arg1
->type ()))
1833 arg2
= value_ptradd (arg1
, -1);
1836 struct value
*tmp
= arg1
;
1838 arg2
= value_one (arg1
->type ());
1839 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1840 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
1843 value_assign (arg1
, arg2
);
1848 /* A helper function for OP_TYPE. */
1851 eval_op_type (struct type
*expect_type
, struct expression
*exp
,
1852 enum noside noside
, struct type
*type
)
1854 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1855 return value::allocate (type
);
1857 error (_("Attempt to use a type name as an expression"));
1860 /* A helper function for BINOP_ASSIGN_MODIFY. */
1863 eval_binop_assign_modify (struct type
*expect_type
, struct expression
*exp
,
1864 enum noside noside
, enum exp_opcode op
,
1865 struct value
*arg1
, struct value
*arg2
)
1867 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1869 if (binop_user_defined_p (op
, arg1
, arg2
))
1870 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1871 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
1873 && is_integral_type (arg2
->type ()))
1874 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
1875 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
1877 && is_integral_type (arg2
->type ()))
1878 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
1881 struct value
*tmp
= arg1
;
1883 /* For shift and integer exponentiation operations,
1884 only promote the first argument. */
1885 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1886 && is_integral_type (arg2
->type ()))
1887 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
1889 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1891 arg2
= value_binop (tmp
, arg2
, op
);
1893 return value_assign (arg1
, arg2
);
1896 /* Note that ARGS needs 2 empty slots up front and must end with a
1898 static struct value
*
1899 eval_op_objc_msgcall (struct type
*expect_type
, struct expression
*exp
,
1900 enum noside noside
, CORE_ADDR selector
,
1901 value
*target
, gdb::array_view
<value
*> args
)
1903 CORE_ADDR responds_selector
= 0;
1904 CORE_ADDR method_selector
= 0;
1906 int struct_return
= 0;
1908 struct value
*msg_send
= NULL
;
1909 struct value
*msg_send_stret
= NULL
;
1910 int gnu_runtime
= 0;
1912 struct value
*method
= NULL
;
1913 struct value
*called_method
= NULL
;
1915 struct type
*selector_type
= NULL
;
1916 struct type
*long_type
;
1919 struct value
*ret
= NULL
;
1924 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1925 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1927 if (value_as_long (target
) == 0)
1928 return value_from_longest (long_type
, 0);
1930 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1933 /* Find the method dispatch (Apple runtime) or method lookup
1934 (GNU runtime) function for Objective-C. These will be used
1935 to lookup the symbol information for the method. If we
1936 can't find any symbol information, then we'll use these to
1937 call the method, otherwise we can call the method
1938 directly. The msg_send_stret function is used in the special
1939 case of a method that returns a structure (Apple runtime
1943 type
= selector_type
;
1945 type
= lookup_function_type (type
);
1946 type
= lookup_pointer_type (type
);
1947 type
= lookup_function_type (type
);
1948 type
= lookup_pointer_type (type
);
1950 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1952 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1954 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1955 msg_send_stret
= value_from_pointer (type
,
1956 value_as_address (msg_send_stret
));
1960 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1961 /* Special dispatcher for methods returning structs. */
1963 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1966 /* Verify the target object responds to this method. The
1967 standard top-level 'Object' class uses a different name for
1968 the verification method than the non-standard, but more
1969 often used, 'NSObject' class. Make sure we check for both. */
1972 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1973 if (responds_selector
== 0)
1975 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1977 if (responds_selector
== 0)
1978 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1981 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1982 if (method_selector
== 0)
1984 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1986 if (method_selector
== 0)
1987 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1989 /* Call the verification method, to make sure that the target
1990 class implements the desired method. */
1992 argvec
[0] = msg_send
;
1994 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1995 argvec
[3] = value_from_longest (long_type
, selector
);
1998 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2001 /* Function objc_msg_lookup returns a pointer. */
2003 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2005 if (value_as_long (ret
) == 0)
2006 error (_("Target does not respond to this message selector."));
2008 /* Call "methodForSelector:" method, to get the address of a
2009 function method that implements this selector for this
2010 class. If we can find a symbol at that address, then we
2011 know the return type, parameter types etc. (that's a good
2014 argvec
[0] = msg_send
;
2016 argvec
[2] = value_from_longest (long_type
, method_selector
);
2017 argvec
[3] = value_from_longest (long_type
, selector
);
2020 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2024 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2027 /* ret should now be the selector. */
2029 addr
= value_as_long (ret
);
2032 struct symbol
*sym
= NULL
;
2034 /* The address might point to a function descriptor;
2035 resolve it to the actual code address instead. */
2036 addr
= gdbarch_convert_from_func_ptr_addr
2037 (exp
->gdbarch
, addr
, current_inferior ()->top_target ());
2039 /* Is it a high_level symbol? */
2040 sym
= find_pc_function (addr
);
2042 method
= value_of_variable (sym
, 0);
2045 /* If we found a method with symbol information, check to see
2046 if it returns a struct. Otherwise assume it doesn't. */
2051 struct type
*val_type
;
2053 funaddr
= find_function_addr (method
, &val_type
);
2055 block_for_pc (funaddr
);
2057 val_type
= check_typedef (val_type
);
2059 if ((val_type
== NULL
)
2060 || (val_type
->code () == TYPE_CODE_ERROR
))
2062 if (expect_type
!= NULL
)
2063 val_type
= expect_type
;
2066 struct_return
= using_struct_return (exp
->gdbarch
, method
,
2069 else if (expect_type
!= NULL
)
2071 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
2072 check_typedef (expect_type
));
2075 /* Found a function symbol. Now we will substitute its
2076 value in place of the message dispatcher (obj_msgSend),
2077 so that we call the method directly instead of thru
2078 the dispatcher. The main reason for doing this is that
2079 we can now evaluate the return value and parameter values
2080 according to their known data types, in case we need to
2081 do things like promotion, dereferencing, special handling
2082 of structs and doubles, etc.
2084 We want to use the type signature of 'method', but still
2085 jump to objc_msgSend() or objc_msgSend_stret() to better
2086 mimic the behavior of the runtime. */
2090 if (method
->type ()->code () != TYPE_CODE_FUNC
)
2091 error (_("method address has symbol information "
2092 "with non-function type; skipping"));
2094 /* Create a function pointer of the appropriate type, and
2095 replace its value with the value of msg_send or
2096 msg_send_stret. We must use a pointer here, as
2097 msg_send and msg_send_stret are of pointer type, and
2098 the representation may be different on systems that use
2099 function descriptors. */
2102 = value_from_pointer (lookup_pointer_type (method
->type ()),
2103 value_as_address (msg_send_stret
));
2106 = value_from_pointer (lookup_pointer_type (method
->type ()),
2107 value_as_address (msg_send
));
2112 called_method
= msg_send_stret
;
2114 called_method
= msg_send
;
2118 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2120 /* If the return type doesn't look like a function type,
2121 call an error. This can happen if somebody tries to
2122 turn a variable into a function call. This is here
2123 because people often want to call, eg, strcmp, which
2124 gdb doesn't know is a function. If gdb isn't asked for
2125 it's opinion (ie. through "whatis"), it won't offer
2128 struct type
*callee_type
= called_method
->type ();
2130 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
2131 callee_type
= callee_type
->target_type ();
2132 callee_type
= callee_type
->target_type ();
2136 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
2137 return value::allocate (expect_type
);
2139 return value::allocate (callee_type
);
2142 error (_("Expression of type other than "
2143 "\"method returning ...\" used as a method"));
2146 /* Now depending on whether we found a symbol for the method,
2147 we will either call the runtime dispatcher or the method
2151 args
[1] = value_from_longest (long_type
, selector
);
2153 if (gnu_runtime
&& (method
!= NULL
))
2155 /* Function objc_msg_lookup returns a pointer. */
2156 struct type
*tem_type
= called_method
->type ();
2157 tem_type
= lookup_pointer_type (lookup_function_type (tem_type
));
2158 called_method
->deprecated_set_type (tem_type
);
2159 called_method
= call_function_by_hand (called_method
, NULL
, args
);
2162 return call_function_by_hand (called_method
, NULL
, args
);
2165 /* Helper function for MULTI_SUBSCRIPT. */
2167 static struct value
*
2168 eval_multi_subscript (struct type
*expect_type
, struct expression
*exp
,
2169 enum noside noside
, value
*arg1
,
2170 gdb::array_view
<value
*> args
)
2172 for (value
*arg2
: args
)
2174 if (binop_user_defined_p (MULTI_SUBSCRIPT
, arg1
, arg2
))
2176 arg1
= value_x_binop (arg1
, arg2
, MULTI_SUBSCRIPT
, OP_NULL
, noside
);
2180 arg1
= coerce_ref (arg1
);
2181 struct type
*type
= check_typedef (arg1
->type ());
2183 switch (type
->code ())
2186 case TYPE_CODE_ARRAY
:
2187 case TYPE_CODE_STRING
:
2188 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2193 error (_("cannot subscript something of type `%s'"),
2196 error (_("cannot subscript requested type"));
2207 objc_msgcall_operation::evaluate (struct type
*expect_type
,
2208 struct expression
*exp
,
2211 enum noside sub_no_side
= EVAL_NORMAL
;
2212 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2214 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2215 sub_no_side
= EVAL_NORMAL
;
2217 sub_no_side
= noside
;
2219 = std::get
<1> (m_storage
)->evaluate (selector_type
, exp
, sub_no_side
);
2221 if (value_as_long (target
) == 0)
2222 sub_no_side
= EVAL_AVOID_SIDE_EFFECTS
;
2224 sub_no_side
= noside
;
2225 std::vector
<operation_up
> &args
= std::get
<2> (m_storage
);
2226 value
**argvec
= XALLOCAVEC (struct value
*, args
.size () + 3);
2227 argvec
[0] = nullptr;
2228 argvec
[1] = nullptr;
2229 for (int i
= 0; i
< args
.size (); ++i
)
2230 argvec
[i
+ 2] = args
[i
]->evaluate_with_coercion (exp
, sub_no_side
);
2231 argvec
[args
.size () + 2] = nullptr;
2233 return eval_op_objc_msgcall (expect_type
, exp
, noside
, std::
2234 get
<0> (m_storage
), target
,
2235 gdb::make_array_view (argvec
,
2240 multi_subscript_operation::evaluate (struct type
*expect_type
,
2241 struct expression
*exp
,
2244 value
*arg1
= std::get
<0> (m_storage
)->evaluate_with_coercion (exp
, noside
);
2245 std::vector
<operation_up
> &values
= std::get
<1> (m_storage
);
2246 value
**argvec
= XALLOCAVEC (struct value
*, values
.size ());
2247 for (int ix
= 0; ix
< values
.size (); ++ix
)
2248 argvec
[ix
] = values
[ix
]->evaluate_with_coercion (exp
, noside
);
2249 return eval_multi_subscript (expect_type
, exp
, noside
, arg1
,
2250 gdb::make_array_view (argvec
, values
.size ()));
2254 logical_and_operation::evaluate (struct type
*expect_type
,
2255 struct expression
*exp
,
2258 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2260 value
*arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
,
2261 EVAL_AVOID_SIDE_EFFECTS
);
2263 if (binop_user_defined_p (BINOP_LOGICAL_AND
, arg1
, arg2
))
2265 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2266 return value_x_binop (arg1
, arg2
, BINOP_LOGICAL_AND
, OP_NULL
, noside
);
2270 bool tem
= value_logical_not (arg1
);
2273 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2274 tem
= value_logical_not (arg2
);
2276 struct type
*type
= language_bool_type (exp
->language_defn
,
2278 return value_from_longest (type
, !tem
);
2283 logical_or_operation::evaluate (struct type
*expect_type
,
2284 struct expression
*exp
,
2287 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2289 value
*arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
,
2290 EVAL_AVOID_SIDE_EFFECTS
);
2292 if (binop_user_defined_p (BINOP_LOGICAL_OR
, arg1
, arg2
))
2294 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2295 return value_x_binop (arg1
, arg2
, BINOP_LOGICAL_OR
, OP_NULL
, noside
);
2299 bool tem
= value_logical_not (arg1
);
2302 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2303 tem
= value_logical_not (arg2
);
2306 struct type
*type
= language_bool_type (exp
->language_defn
,
2308 return value_from_longest (type
, !tem
);
2313 adl_func_operation::evaluate (struct type
*expect_type
,
2314 struct expression
*exp
,
2317 std::vector
<operation_up
> &arg_ops
= std::get
<2> (m_storage
);
2318 std::vector
<value
*> args (arg_ops
.size ());
2319 for (int i
= 0; i
< arg_ops
.size (); ++i
)
2320 args
[i
] = arg_ops
[i
]->evaluate_with_coercion (exp
, noside
);
2322 struct symbol
*symp
;
2323 find_overload_match (args
, std::get
<0> (m_storage
).c_str (),
2326 nullptr, &symp
, nullptr, 0, noside
);
2327 if (symp
->type ()->code () == TYPE_CODE_ERROR
)
2328 error_unknown_type (symp
->print_name ());
2329 value
*callee
= evaluate_var_value (noside
, std::get
<1> (m_storage
), symp
);
2330 return evaluate_subexp_do_call (exp
, noside
, callee
, args
,
2331 nullptr, expect_type
);
2335 /* This function evaluates brace-initializers (in C/C++) for
2339 array_operation::evaluate_struct_tuple (struct value
*struct_val
,
2340 struct expression
*exp
,
2341 enum noside noside
, int nargs
)
2343 const std::vector
<operation_up
> &in_args
= std::get
<2> (m_storage
);
2344 struct type
*struct_type
= check_typedef (struct_val
->type ());
2345 struct type
*field_type
;
2349 while (--nargs
>= 0)
2351 struct value
*val
= NULL
;
2352 int bitpos
, bitsize
;
2356 /* Skip static fields. */
2357 while (fieldno
< struct_type
->num_fields ()
2358 && struct_type
->field (fieldno
).is_static ())
2360 if (fieldno
>= struct_type
->num_fields ())
2361 error (_("too many initializers"));
2362 field_type
= struct_type
->field (fieldno
).type ();
2363 if (field_type
->code () == TYPE_CODE_UNION
2364 && struct_type
->field (fieldno
).name ()[0] == '0')
2365 error (_("don't know which variant you want to set"));
2367 /* Here, struct_type is the type of the inner struct,
2368 while substruct_type is the type of the inner struct.
2369 These are the same for normal structures, but a variant struct
2370 contains anonymous union fields that contain substruct fields.
2371 The value fieldno is the index of the top-level (normal or
2372 anonymous union) field in struct_field, while the value
2373 subfieldno is the index of the actual real (named inner) field
2374 in substruct_type. */
2376 field_type
= struct_type
->field (fieldno
).type ();
2378 val
= in_args
[idx
++]->evaluate (field_type
, exp
, noside
);
2380 /* Now actually set the field in struct_val. */
2382 /* Assign val to field fieldno. */
2383 if (val
->type () != field_type
)
2384 val
= value_cast (field_type
, val
);
2386 bitsize
= struct_type
->field (fieldno
).bitsize ();
2387 bitpos
= struct_type
->field (fieldno
).loc_bitpos ();
2388 addr
= struct_val
->contents_writeable ().data () + bitpos
/ 8;
2390 modify_field (struct_type
, addr
,
2391 value_as_long (val
), bitpos
% 8, bitsize
);
2393 memcpy (addr
, val
->contents ().data (),
2394 val
->type ()->length ());
2401 array_operation::evaluate (struct type
*expect_type
,
2402 struct expression
*exp
,
2405 const int provided_low_bound
= std::get
<0> (m_storage
);
2406 const std::vector
<operation_up
> &in_args
= std::get
<2> (m_storage
);
2407 const int nargs
= std::get
<1> (m_storage
) - provided_low_bound
+ 1;
2408 struct type
*type
= expect_type
? check_typedef (expect_type
) : nullptr;
2410 if (expect_type
!= nullptr
2411 && type
->code () == TYPE_CODE_STRUCT
)
2413 struct value
*rec
= value::allocate (expect_type
);
2415 memset (rec
->contents_raw ().data (), '\0', type
->length ());
2416 return evaluate_struct_tuple (rec
, exp
, noside
, nargs
);
2419 if (expect_type
!= nullptr
2420 && type
->code () == TYPE_CODE_ARRAY
)
2422 struct type
*range_type
= type
->index_type ();
2423 struct type
*element_type
= type
->target_type ();
2424 struct value
*array
= value::allocate (expect_type
);
2425 int element_size
= check_typedef (element_type
)->length ();
2426 LONGEST low_bound
, high_bound
;
2428 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
2431 high_bound
= (type
->length () / element_size
) - 1;
2433 if (low_bound
+ nargs
- 1 > high_bound
)
2434 error (_("Too many array elements"));
2435 memset (array
->contents_raw ().data (), 0, expect_type
->length ());
2436 for (int idx
= 0; idx
< nargs
; ++idx
)
2438 struct value
*element
;
2440 element
= in_args
[idx
]->evaluate (element_type
, exp
, noside
);
2441 if (element
->type () != element_type
)
2442 element
= value_cast (element_type
, element
);
2443 memcpy (array
->contents_raw ().data () + idx
* element_size
,
2444 element
->contents ().data (),
2450 if (expect_type
!= nullptr
2451 && type
->code () == TYPE_CODE_SET
)
2453 struct value
*set
= value::allocate (expect_type
);
2454 gdb_byte
*valaddr
= set
->contents_raw ().data ();
2455 struct type
*element_type
= type
->index_type ();
2456 struct type
*check_type
= element_type
;
2457 LONGEST low_bound
, high_bound
;
2459 /* Get targettype of elementtype. */
2460 while (check_type
->code () == TYPE_CODE_RANGE
2461 || check_type
->code () == TYPE_CODE_TYPEDEF
)
2462 check_type
= check_type
->target_type ();
2464 if (!get_discrete_bounds (element_type
, &low_bound
, &high_bound
))
2465 error (_("(power)set type with unknown size"));
2466 memset (valaddr
, '\0', type
->length ());
2467 for (int idx
= 0; idx
< nargs
; idx
++)
2469 LONGEST range_low
, range_high
;
2470 struct type
*range_low_type
, *range_high_type
;
2471 struct value
*elem_val
;
2473 elem_val
= in_args
[idx
]->evaluate (element_type
, exp
, noside
);
2474 range_low_type
= range_high_type
= elem_val
->type ();
2475 range_low
= range_high
= value_as_long (elem_val
);
2477 /* Check types of elements to avoid mixture of elements from
2478 different types. Also check if type of element is "compatible"
2479 with element type of powerset. */
2480 if (range_low_type
->code () == TYPE_CODE_RANGE
)
2481 range_low_type
= range_low_type
->target_type ();
2482 if (range_high_type
->code () == TYPE_CODE_RANGE
)
2483 range_high_type
= range_high_type
->target_type ();
2484 if ((range_low_type
->code () != range_high_type
->code ())
2485 || (range_low_type
->code () == TYPE_CODE_ENUM
2486 && (range_low_type
!= range_high_type
)))
2487 /* different element modes. */
2488 error (_("POWERSET tuple elements of different mode"));
2489 if ((check_type
->code () != range_low_type
->code ())
2490 || (check_type
->code () == TYPE_CODE_ENUM
2491 && range_low_type
!= check_type
))
2492 error (_("incompatible POWERSET tuple elements"));
2493 if (range_low
> range_high
)
2495 warning (_("empty POWERSET tuple range"));
2498 if (range_low
< low_bound
|| range_high
> high_bound
)
2499 error (_("POWERSET tuple element out of range"));
2500 range_low
-= low_bound
;
2501 range_high
-= low_bound
;
2502 for (; range_low
<= range_high
; range_low
++)
2504 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
2506 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
2507 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
2508 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
2515 std::vector
<value
*> argvec (nargs
);
2516 for (int tem
= 0; tem
< nargs
; tem
++)
2518 /* Ensure that array expressions are coerced into pointer
2520 argvec
[tem
] = in_args
[tem
]->evaluate_with_coercion (exp
, noside
);
2522 return value_array (provided_low_bound
, argvec
);
2526 unop_extract_operation::evaluate (struct type
*expect_type
,
2527 struct expression
*exp
,
2530 value
*old_value
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2531 struct type
*type
= get_type ();
2533 if (type
->length () > old_value
->type ()->length ())
2534 error (_("length type is larger than the value type"));
2536 struct value
*result
= value::allocate (type
);
2537 old_value
->contents_copy (result
, 0, 0, type
->length ());
2544 /* Helper for evaluate_subexp_for_address. */
2547 evaluate_subexp_for_address_base (struct expression
*exp
, enum noside noside
,
2550 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2552 struct type
*type
= check_typedef (x
->type ());
2554 if (TYPE_IS_REFERENCE (type
))
2555 return value::zero (lookup_pointer_type (type
->target_type ()),
2557 else if (x
->lval () == lval_memory
|| value_must_coerce_to_target (x
))
2558 return value::zero (lookup_pointer_type (x
->type ()),
2561 error (_("Attempt to take address of "
2562 "value not located in memory."));
2564 return value_addr (x
);
2571 operation::evaluate_for_cast (struct type
*expect_type
,
2572 struct expression
*exp
,
2575 value
*val
= evaluate (expect_type
, exp
, noside
);
2576 return value_cast (expect_type
, val
);
2580 operation::evaluate_for_address (struct expression
*exp
, enum noside noside
)
2582 value
*val
= evaluate (nullptr, exp
, noside
);
2583 return evaluate_subexp_for_address_base (exp
, noside
, val
);
2587 scope_operation::evaluate_for_address (struct expression
*exp
,
2590 value
*x
= value_aggregate_elt (std::get
<0> (m_storage
),
2591 std::get
<1> (m_storage
).c_str (),
2594 error (_("There is no field named %s"), std::get
<1> (m_storage
).c_str ());
2599 unop_ind_base_operation::evaluate_for_address (struct expression
*exp
,
2602 value
*x
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2604 /* We can't optimize out "&*" if there's a user-defined operator*. */
2605 if (unop_user_defined_p (UNOP_IND
, x
))
2607 x
= value_x_unop (x
, UNOP_IND
, noside
);
2608 return evaluate_subexp_for_address_base (exp
, noside
, x
);
2611 return coerce_array (x
);
2615 var_msym_value_operation::evaluate_for_address (struct expression
*exp
,
2618 const bound_minimal_symbol
&b
= std::get
<0> (m_storage
);
2619 value
*val
= evaluate_var_msym_value (noside
, b
.objfile
, b
.minsym
);
2620 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2622 struct type
*type
= lookup_pointer_type (val
->type ());
2623 return value::zero (type
, not_lval
);
2626 return value_addr (val
);
2630 unop_memval_operation::evaluate_for_address (struct expression
*exp
,
2633 return value_cast (lookup_pointer_type (std::get
<1> (m_storage
)),
2634 std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
));
2638 unop_memval_type_operation::evaluate_for_address (struct expression
*exp
,
2641 value
*typeval
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
2642 EVAL_AVOID_SIDE_EFFECTS
);
2643 struct type
*type
= typeval
->type ();
2644 return value_cast (lookup_pointer_type (type
),
2645 std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
));
2649 var_value_operation::evaluate_for_address (struct expression
*exp
,
2652 symbol
*var
= std::get
<0> (m_storage
).symbol
;
2654 /* C++: The "address" of a reference should yield the address
2655 * of the object pointed to. Let value_addr() deal with it. */
2656 if (TYPE_IS_REFERENCE (var
->type ()))
2657 return operation::evaluate_for_address (exp
, noside
);
2659 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2661 struct type
*type
= lookup_pointer_type (var
->type ());
2662 enum address_class sym_class
= var
->aclass ();
2664 if (sym_class
== LOC_CONST
2665 || sym_class
== LOC_CONST_BYTES
2666 || sym_class
== LOC_REGISTER
)
2667 error (_("Attempt to take address of register or constant."));
2669 return value::zero (type
, not_lval
);
2672 return address_of_variable (var
, std::get
<0> (m_storage
).block
);
2676 var_value_operation::evaluate_with_coercion (struct expression
*exp
,
2679 struct symbol
*var
= std::get
<0> (m_storage
).symbol
;
2680 struct type
*type
= check_typedef (var
->type ());
2681 if (type
->code () == TYPE_CODE_ARRAY
2682 && !type
->is_vector ()
2683 && CAST_IS_CONVERSION (exp
->language_defn
))
2685 struct value
*val
= address_of_variable (var
,
2686 std::get
<0> (m_storage
).block
);
2687 return value_cast (lookup_pointer_type (type
->target_type ()), val
);
2689 return evaluate (nullptr, exp
, noside
);
2694 /* Helper function for evaluating the size of a type. */
2697 evaluate_subexp_for_sizeof_base (struct expression
*exp
, struct type
*type
)
2699 /* FIXME: This should be size_t. */
2700 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2701 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
2702 "When applied to a reference or a reference type, the result is
2703 the size of the referenced type." */
2704 type
= check_typedef (type
);
2705 if (exp
->language_defn
->la_language
== language_cplus
2706 && (TYPE_IS_REFERENCE (type
)))
2707 type
= check_typedef (type
->target_type ());
2708 return value_from_longest (size_type
, (LONGEST
) type
->length ());
2715 operation::evaluate_for_sizeof (struct expression
*exp
, enum noside noside
)
2717 value
*val
= evaluate (nullptr, exp
, EVAL_AVOID_SIDE_EFFECTS
);
2718 return evaluate_subexp_for_sizeof_base (exp
, val
->type ());
2722 var_msym_value_operation::evaluate_for_sizeof (struct expression
*exp
,
2726 const bound_minimal_symbol
&b
= std::get
<0> (m_storage
);
2727 value
*mval
= evaluate_var_msym_value (noside
, b
.objfile
, b
.minsym
);
2729 struct type
*type
= mval
->type ();
2730 if (type
->code () == TYPE_CODE_ERROR
)
2731 error_unknown_type (b
.minsym
->print_name ());
2733 /* FIXME: This should be size_t. */
2734 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2735 return value_from_longest (size_type
, type
->length ());
2739 subscript_operation::evaluate_for_sizeof (struct expression
*exp
,
2742 if (noside
== EVAL_NORMAL
)
2744 value
*val
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
2745 EVAL_AVOID_SIDE_EFFECTS
);
2746 struct type
*type
= check_typedef (val
->type ());
2747 if (type
->code () == TYPE_CODE_ARRAY
)
2749 type
= check_typedef (type
->target_type ());
2750 if (type
->code () == TYPE_CODE_ARRAY
)
2752 type
= type
->index_type ();
2753 /* Only re-evaluate the right hand side if the resulting type
2754 is a variable length type. */
2755 if (type
->bounds ()->flag_bound_evaluated
)
2757 val
= evaluate (nullptr, exp
, EVAL_NORMAL
);
2758 /* FIXME: This should be size_t. */
2759 struct type
*size_type
2760 = builtin_type (exp
->gdbarch
)->builtin_int
;
2761 return value_from_longest
2762 (size_type
, (LONGEST
) val
->type ()->length ());
2768 return operation::evaluate_for_sizeof (exp
, noside
);
2772 unop_ind_base_operation::evaluate_for_sizeof (struct expression
*exp
,
2775 value
*val
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
2776 EVAL_AVOID_SIDE_EFFECTS
);
2777 struct type
*type
= check_typedef (val
->type ());
2778 if (!type
->is_pointer_or_reference ()
2779 && type
->code () != TYPE_CODE_ARRAY
)
2780 error (_("Attempt to take contents of a non-pointer value."));
2781 type
= type
->target_type ();
2782 if (is_dynamic_type (type
))
2783 type
= value_ind (val
)->type ();
2784 /* FIXME: This should be size_t. */
2785 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2786 return value_from_longest (size_type
, (LONGEST
) type
->length ());
2790 unop_memval_operation::evaluate_for_sizeof (struct expression
*exp
,
2793 return evaluate_subexp_for_sizeof_base (exp
, std::get
<1> (m_storage
));
2797 unop_memval_type_operation::evaluate_for_sizeof (struct expression
*exp
,
2800 value
*typeval
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
2801 EVAL_AVOID_SIDE_EFFECTS
);
2802 return evaluate_subexp_for_sizeof_base (exp
, typeval
->type ());
2806 var_value_operation::evaluate_for_sizeof (struct expression
*exp
,
2809 struct type
*type
= std::get
<0> (m_storage
).symbol
->type ();
2810 if (is_dynamic_type (type
))
2812 value
*val
= evaluate (nullptr, exp
, EVAL_NORMAL
);
2813 type
= val
->type ();
2814 if (type
->code () == TYPE_CODE_ARRAY
)
2816 /* FIXME: This should be size_t. */
2817 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2818 if (type_not_allocated (type
) || type_not_associated (type
))
2819 return value::zero (size_type
, not_lval
);
2820 else if (is_dynamic_type (type
->index_type ())
2821 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
2822 return value::allocate_optimized_out (size_type
);
2825 return evaluate_subexp_for_sizeof_base (exp
, type
);
2829 var_msym_value_operation::evaluate_for_cast (struct type
*to_type
,
2830 struct expression
*exp
,
2833 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2834 return value::zero (to_type
, not_lval
);
2836 const bound_minimal_symbol
&b
= std::get
<0> (m_storage
);
2837 value
*val
= evaluate_var_msym_value (noside
, b
.objfile
, b
.minsym
);
2839 val
= value_cast (to_type
, val
);
2841 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
2842 if (val
->lval () == lval_memory
)
2846 val
->set_lval (not_lval
);
2852 var_value_operation::evaluate_for_cast (struct type
*to_type
,
2853 struct expression
*exp
,
2856 value
*val
= evaluate_var_value (noside
,
2857 std::get
<0> (m_storage
).block
,
2858 std::get
<0> (m_storage
).symbol
);
2860 val
= value_cast (to_type
, val
);
2862 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
2863 if (val
->lval () == lval_memory
)
2867 val
->set_lval (not_lval
);
2874 /* Parse a type expression in the string [P..P+LENGTH). */
2877 parse_and_eval_type (const char *p
, int length
)
2879 char *tmp
= (char *) alloca (length
+ 4);
2882 memcpy (tmp
+ 1, p
, length
);
2883 tmp
[length
+ 1] = ')';
2884 tmp
[length
+ 2] = '0';
2885 tmp
[length
+ 3] = '\0';
2886 expression_up expr
= parse_expression (tmp
);
2887 expr::unop_cast_operation
*op
2888 = dynamic_cast<expr::unop_cast_operation
*> (expr
->op
.get ());
2890 error (_("Internal error in eval_type."));
2891 return op
->get_type ();