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 std::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
1138 (regno
, get_next_frame_sentinel_okay (get_selected_frame ()));
1140 error (_("Value of register %s not available."), name
);
1149 string_operation::evaluate (struct type
*expect_type
,
1150 struct expression
*exp
,
1153 const std::string
&str
= std::get
<0> (m_storage
);
1154 struct type
*type
= language_string_char_type (exp
->language_defn
,
1156 return value_string (str
.c_str (), str
.size (), type
);
1160 ternop_slice_operation::evaluate (struct type
*expect_type
,
1161 struct expression
*exp
,
1165 = std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
1167 = std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
1169 = std::get
<2> (m_storage
)->evaluate (nullptr, exp
, noside
);
1171 int lowbound
= value_as_long (low
);
1172 int upperbound
= value_as_long (upper
);
1173 return value_slice (array
, lowbound
, upperbound
- lowbound
+ 1);
1176 } /* namespace expr */
1178 /* Helper function that implements the body of OP_OBJC_SELECTOR. */
1181 eval_op_objc_selector (struct type
*expect_type
, struct expression
*exp
,
1185 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1186 return value_from_longest (selector_type
,
1187 lookup_child_selector (exp
->gdbarch
, sel
));
1190 /* A helper function for STRUCTOP_STRUCT. */
1193 eval_op_structop_struct (struct type
*expect_type
, struct expression
*exp
,
1195 struct value
*arg1
, const char *string
)
1197 struct value
*arg3
= value_struct_elt (&arg1
, {}, string
,
1199 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1200 arg3
= value::zero (arg3
->type (), arg3
->lval ());
1204 /* A helper function for STRUCTOP_PTR. */
1207 eval_op_structop_ptr (struct type
*expect_type
, struct expression
*exp
,
1209 struct value
*arg1
, const char *string
)
1211 /* Check to see if operator '->' has been overloaded. If so replace
1212 arg1 with the value returned by evaluating operator->(). */
1213 while (unop_user_defined_p (STRUCTOP_PTR
, arg1
))
1215 struct value
*value
= NULL
;
1218 value
= value_x_unop (arg1
, STRUCTOP_PTR
, noside
);
1221 catch (const gdb_exception_error
&except
)
1223 if (except
.error
== NOT_FOUND_ERROR
)
1232 /* JYG: if print object is on we need to replace the base type
1233 with rtti type in order to continue on with successful
1234 lookup of member / method only available in the rtti type. */
1236 struct type
*arg_type
= arg1
->type ();
1237 struct type
*real_type
;
1238 int full
, using_enc
;
1240 struct value_print_options opts
;
1242 get_user_print_options (&opts
);
1243 if (opts
.objectprint
&& arg_type
->target_type ()
1244 && (arg_type
->target_type ()->code () == TYPE_CODE_STRUCT
))
1246 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1249 arg1
= value_cast (real_type
, arg1
);
1253 struct value
*arg3
= value_struct_elt (&arg1
, {}, string
,
1254 NULL
, "structure pointer");
1255 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1256 arg3
= value::zero (arg3
->type (), arg3
->lval ());
1260 /* A helper function for STRUCTOP_MEMBER. */
1263 eval_op_member (struct type
*expect_type
, struct expression
*exp
,
1265 struct value
*arg1
, struct value
*arg2
)
1270 struct type
*type
= check_typedef (arg2
->type ());
1271 switch (type
->code ())
1273 case TYPE_CODE_METHODPTR
:
1274 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1275 return value::zero (type
->target_type (), not_lval
);
1278 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1279 gdb_assert (arg2
->type ()->code () == TYPE_CODE_PTR
);
1280 return value_ind (arg2
);
1283 case TYPE_CODE_MEMBERPTR
:
1284 /* Now, convert these values to an address. */
1285 if (check_typedef (arg1
->type ())->code () != TYPE_CODE_PTR
)
1286 arg1
= value_addr (arg1
);
1287 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1290 mem_offset
= value_as_long (arg2
);
1292 arg3
= value_from_pointer (lookup_pointer_type (type
->target_type ()),
1293 value_as_long (arg1
) + mem_offset
);
1294 return value_ind (arg3
);
1297 error (_("non-pointer-to-member value used "
1298 "in pointer-to-member construct"));
1302 /* A helper function for BINOP_ADD. */
1305 eval_op_add (struct type
*expect_type
, struct expression
*exp
,
1307 struct value
*arg1
, struct value
*arg2
)
1309 if (binop_user_defined_p (BINOP_ADD
, arg1
, arg2
))
1310 return value_x_binop (arg1
, arg2
, BINOP_ADD
, OP_NULL
, noside
);
1311 else if (ptrmath_type_p (exp
->language_defn
, arg1
->type ())
1312 && is_integral_or_integral_reference (arg2
->type ()))
1313 return value_ptradd (arg1
, value_as_long (arg2
));
1314 else if (ptrmath_type_p (exp
->language_defn
, arg2
->type ())
1315 && is_integral_or_integral_reference (arg1
->type ()))
1316 return value_ptradd (arg2
, value_as_long (arg1
));
1319 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1320 return value_binop (arg1
, arg2
, BINOP_ADD
);
1324 /* A helper function for BINOP_SUB. */
1327 eval_op_sub (struct type
*expect_type
, struct expression
*exp
,
1329 struct value
*arg1
, struct value
*arg2
)
1331 if (binop_user_defined_p (BINOP_SUB
, arg1
, arg2
))
1332 return value_x_binop (arg1
, arg2
, BINOP_SUB
, OP_NULL
, noside
);
1333 else if (ptrmath_type_p (exp
->language_defn
, arg1
->type ())
1334 && ptrmath_type_p (exp
->language_defn
, arg2
->type ()))
1336 /* FIXME -- should be ptrdiff_t */
1337 struct type
*type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1338 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1340 else if (ptrmath_type_p (exp
->language_defn
, arg1
->type ())
1341 && is_integral_or_integral_reference (arg2
->type ()))
1342 return value_ptradd (arg1
, - value_as_long (arg2
));
1345 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1346 return value_binop (arg1
, arg2
, BINOP_SUB
);
1350 /* Helper function for several different binary operations. */
1353 eval_op_binary (struct type
*expect_type
, struct expression
*exp
,
1354 enum noside noside
, enum exp_opcode op
,
1355 struct value
*arg1
, struct value
*arg2
)
1357 if (binop_user_defined_p (op
, arg1
, arg2
))
1358 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1361 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1362 fudge arg2 to avoid division-by-zero, the caller is
1363 (theoretically) only looking for the type of the result. */
1364 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1365 /* ??? Do we really want to test for BINOP_MOD here?
1366 The implementation of value_binop gives it a well-defined
1369 || op
== BINOP_INTDIV
1372 && value_logical_not (arg2
))
1374 struct value
*v_one
;
1376 v_one
= value_one (arg2
->type ());
1377 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1378 return value_binop (arg1
, v_one
, op
);
1382 /* For shift and integer exponentiation operations,
1383 only promote the first argument. */
1384 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1385 && is_integral_type (arg2
->type ()))
1386 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1388 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1390 return value_binop (arg1
, arg2
, op
);
1395 /* A helper function for BINOP_SUBSCRIPT. */
1398 eval_op_subscript (struct type
*expect_type
, struct expression
*exp
,
1399 enum noside noside
, enum exp_opcode op
,
1400 struct value
*arg1
, struct value
*arg2
)
1402 if (binop_user_defined_p (op
, arg1
, arg2
))
1403 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1406 /* If the user attempts to subscript something that is not an
1407 array or pointer type (like a plain int variable for example),
1408 then report this as an error. */
1410 arg1
= coerce_ref (arg1
);
1411 struct type
*type
= check_typedef (arg1
->type ());
1412 if (type
->code () != TYPE_CODE_ARRAY
1413 && type
->code () != TYPE_CODE_PTR
)
1416 error (_("cannot subscript something of type `%s'"),
1419 error (_("cannot subscript requested type"));
1422 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1423 return value::zero (type
->target_type (), arg1
->lval ());
1425 return value_subscript (arg1
, value_as_long (arg2
));
1429 /* A helper function for BINOP_EQUAL. */
1432 eval_op_equal (struct type
*expect_type
, struct expression
*exp
,
1433 enum noside noside
, enum exp_opcode op
,
1434 struct value
*arg1
, struct value
*arg2
)
1436 if (binop_user_defined_p (op
, arg1
, arg2
))
1438 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1442 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1443 int tem
= value_equal (arg1
, arg2
);
1444 struct type
*type
= language_bool_type (exp
->language_defn
,
1446 return value_from_longest (type
, (LONGEST
) tem
);
1450 /* A helper function for BINOP_NOTEQUAL. */
1453 eval_op_notequal (struct type
*expect_type
, struct expression
*exp
,
1454 enum noside noside
, enum exp_opcode op
,
1455 struct value
*arg1
, struct value
*arg2
)
1457 if (binop_user_defined_p (op
, arg1
, arg2
))
1459 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1463 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1464 int tem
= value_equal (arg1
, arg2
);
1465 struct type
*type
= language_bool_type (exp
->language_defn
,
1467 return value_from_longest (type
, (LONGEST
) ! tem
);
1471 /* A helper function for BINOP_LESS. */
1474 eval_op_less (struct type
*expect_type
, struct expression
*exp
,
1475 enum noside noside
, enum exp_opcode op
,
1476 struct value
*arg1
, struct value
*arg2
)
1478 if (binop_user_defined_p (op
, arg1
, arg2
))
1480 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1484 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1485 int tem
= value_less (arg1
, arg2
);
1486 struct type
*type
= language_bool_type (exp
->language_defn
,
1488 return value_from_longest (type
, (LONGEST
) tem
);
1492 /* A helper function for BINOP_GTR. */
1495 eval_op_gtr (struct type
*expect_type
, struct expression
*exp
,
1496 enum noside noside
, enum exp_opcode op
,
1497 struct value
*arg1
, struct value
*arg2
)
1499 if (binop_user_defined_p (op
, arg1
, arg2
))
1501 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1505 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1506 int tem
= value_less (arg2
, arg1
);
1507 struct type
*type
= language_bool_type (exp
->language_defn
,
1509 return value_from_longest (type
, (LONGEST
) tem
);
1513 /* A helper function for BINOP_GEQ. */
1516 eval_op_geq (struct type
*expect_type
, struct expression
*exp
,
1517 enum noside noside
, enum exp_opcode op
,
1518 struct value
*arg1
, struct value
*arg2
)
1520 if (binop_user_defined_p (op
, arg1
, arg2
))
1522 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1526 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1527 int tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1528 struct type
*type
= language_bool_type (exp
->language_defn
,
1530 return value_from_longest (type
, (LONGEST
) tem
);
1534 /* A helper function for BINOP_LEQ. */
1537 eval_op_leq (struct type
*expect_type
, struct expression
*exp
,
1538 enum noside noside
, enum exp_opcode op
,
1539 struct value
*arg1
, struct value
*arg2
)
1541 if (binop_user_defined_p (op
, arg1
, arg2
))
1543 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1547 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1548 int tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1549 struct type
*type
= language_bool_type (exp
->language_defn
,
1551 return value_from_longest (type
, (LONGEST
) tem
);
1555 /* A helper function for BINOP_REPEAT. */
1558 eval_op_repeat (struct type
*expect_type
, struct expression
*exp
,
1559 enum noside noside
, enum exp_opcode op
,
1560 struct value
*arg1
, struct value
*arg2
)
1562 struct type
*type
= check_typedef (arg2
->type ());
1563 if (type
->code () != TYPE_CODE_INT
1564 && type
->code () != TYPE_CODE_ENUM
)
1565 error (_("Non-integral right operand for \"@\" operator."));
1566 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1568 return allocate_repeat_value (arg1
->type (),
1569 longest_to_int (value_as_long (arg2
)));
1572 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1575 /* A helper function for UNOP_PLUS. */
1578 eval_op_plus (struct type
*expect_type
, struct expression
*exp
,
1579 enum noside noside
, enum exp_opcode op
,
1582 if (unop_user_defined_p (op
, arg1
))
1583 return value_x_unop (arg1
, op
, noside
);
1586 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1587 return value_pos (arg1
);
1591 /* A helper function for UNOP_NEG. */
1594 eval_op_neg (struct type
*expect_type
, struct expression
*exp
,
1595 enum noside noside
, enum exp_opcode op
,
1598 if (unop_user_defined_p (op
, arg1
))
1599 return value_x_unop (arg1
, op
, noside
);
1602 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1603 return value_neg (arg1
);
1607 /* A helper function for UNOP_COMPLEMENT. */
1610 eval_op_complement (struct type
*expect_type
, struct expression
*exp
,
1611 enum noside noside
, enum exp_opcode op
,
1614 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1615 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1618 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1619 return value_complement (arg1
);
1623 /* A helper function for UNOP_LOGICAL_NOT. */
1626 eval_op_lognot (struct type
*expect_type
, struct expression
*exp
,
1627 enum noside noside
, enum exp_opcode op
,
1630 if (unop_user_defined_p (op
, arg1
))
1631 return value_x_unop (arg1
, op
, noside
);
1634 struct type
*type
= language_bool_type (exp
->language_defn
,
1636 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
1640 /* A helper function for UNOP_IND. */
1643 eval_op_ind (struct type
*expect_type
, struct expression
*exp
,
1647 struct type
*type
= check_typedef (arg1
->type ());
1648 if (type
->code () == TYPE_CODE_METHODPTR
1649 || type
->code () == TYPE_CODE_MEMBERPTR
)
1650 error (_("Attempt to dereference pointer "
1651 "to member without an object"));
1652 if (unop_user_defined_p (UNOP_IND
, arg1
))
1653 return value_x_unop (arg1
, UNOP_IND
, noside
);
1654 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1656 type
= check_typedef (arg1
->type ());
1658 /* If the type pointed to is dynamic then in order to resolve the
1659 dynamic properties we must actually dereference the pointer.
1660 There is a risk that this dereference will have side-effects
1661 in the inferior, but being able to print accurate type
1662 information seems worth the risk. */
1663 if (!type
->is_pointer_or_reference ()
1664 || !is_dynamic_type (type
->target_type ()))
1666 if (type
->is_pointer_or_reference ()
1667 /* In C you can dereference an array to get the 1st elt. */
1668 || type
->code () == TYPE_CODE_ARRAY
)
1669 return value::zero (type
->target_type (),
1671 else if (type
->code () == TYPE_CODE_INT
)
1672 /* GDB allows dereferencing an int. */
1673 return value::zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1676 error (_("Attempt to take contents of a non-pointer value."));
1680 /* Allow * on an integer so we can cast it to whatever we want.
1681 This returns an int, which seems like the most C-like thing to
1682 do. "long long" variables are rare enough that
1683 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
1684 if (type
->code () == TYPE_CODE_INT
)
1685 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
1686 (CORE_ADDR
) value_as_address (arg1
));
1687 return value_ind (arg1
);
1690 /* A helper function for UNOP_ALIGNOF. */
1693 eval_op_alignof (struct type
*expect_type
, struct expression
*exp
,
1697 struct type
*type
= arg1
->type ();
1698 /* FIXME: This should be size_t. */
1699 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
1700 ULONGEST align
= type_align (type
);
1702 error (_("could not determine alignment of type"));
1703 return value_from_longest (size_type
, align
);
1706 /* A helper function for UNOP_MEMVAL. */
1709 eval_op_memval (struct type
*expect_type
, struct expression
*exp
,
1711 struct value
*arg1
, struct type
*type
)
1713 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1714 return value::zero (type
, lval_memory
);
1716 return value_at_lazy (type
, value_as_address (arg1
));
1719 /* A helper function for UNOP_PREINCREMENT. */
1722 eval_op_preinc (struct type
*expect_type
, struct expression
*exp
,
1723 enum noside noside
, enum exp_opcode op
,
1726 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1728 else if (unop_user_defined_p (op
, arg1
))
1730 return value_x_unop (arg1
, op
, noside
);
1735 if (ptrmath_type_p (exp
->language_defn
, arg1
->type ()))
1736 arg2
= value_ptradd (arg1
, 1);
1739 struct value
*tmp
= arg1
;
1741 arg2
= value_one (arg1
->type ());
1742 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1743 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
1746 return value_assign (arg1
, arg2
);
1750 /* A helper function for UNOP_PREDECREMENT. */
1753 eval_op_predec (struct type
*expect_type
, struct expression
*exp
,
1754 enum noside noside
, enum exp_opcode op
,
1757 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1759 else if (unop_user_defined_p (op
, arg1
))
1761 return value_x_unop (arg1
, op
, noside
);
1766 if (ptrmath_type_p (exp
->language_defn
, arg1
->type ()))
1767 arg2
= value_ptradd (arg1
, -1);
1770 struct value
*tmp
= arg1
;
1772 arg2
= value_one (arg1
->type ());
1773 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1774 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
1777 return value_assign (arg1
, arg2
);
1781 /* A helper function for UNOP_POSTINCREMENT. */
1784 eval_op_postinc (struct type
*expect_type
, struct expression
*exp
,
1785 enum noside noside
, enum exp_opcode op
,
1788 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1790 else if (unop_user_defined_p (op
, arg1
))
1792 return value_x_unop (arg1
, op
, noside
);
1796 struct value
*arg3
= arg1
->non_lval ();
1799 if (ptrmath_type_p (exp
->language_defn
, arg1
->type ()))
1800 arg2
= value_ptradd (arg1
, 1);
1803 struct value
*tmp
= arg1
;
1805 arg2
= value_one (arg1
->type ());
1806 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1807 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
1810 value_assign (arg1
, arg2
);
1815 /* A helper function for UNOP_POSTDECREMENT. */
1818 eval_op_postdec (struct type
*expect_type
, struct expression
*exp
,
1819 enum noside noside
, enum exp_opcode op
,
1822 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1824 else if (unop_user_defined_p (op
, arg1
))
1826 return value_x_unop (arg1
, op
, noside
);
1830 struct value
*arg3
= arg1
->non_lval ();
1833 if (ptrmath_type_p (exp
->language_defn
, arg1
->type ()))
1834 arg2
= value_ptradd (arg1
, -1);
1837 struct value
*tmp
= arg1
;
1839 arg2
= value_one (arg1
->type ());
1840 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1841 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
1844 value_assign (arg1
, arg2
);
1849 /* A helper function for OP_TYPE. */
1852 eval_op_type (struct type
*expect_type
, struct expression
*exp
,
1853 enum noside noside
, struct type
*type
)
1855 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1856 return value::allocate (type
);
1858 error (_("Attempt to use a type name as an expression"));
1861 /* A helper function for BINOP_ASSIGN_MODIFY. */
1864 eval_binop_assign_modify (struct type
*expect_type
, struct expression
*exp
,
1865 enum noside noside
, enum exp_opcode op
,
1866 struct value
*arg1
, struct value
*arg2
)
1868 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1870 if (binop_user_defined_p (op
, arg1
, arg2
))
1871 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1872 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
1874 && is_integral_type (arg2
->type ()))
1875 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
1876 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
1878 && is_integral_type (arg2
->type ()))
1879 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
1882 struct value
*tmp
= arg1
;
1884 /* For shift and integer exponentiation operations,
1885 only promote the first argument. */
1886 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1887 && is_integral_type (arg2
->type ()))
1888 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
1890 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1892 arg2
= value_binop (tmp
, arg2
, op
);
1894 return value_assign (arg1
, arg2
);
1897 /* Note that ARGS needs 2 empty slots up front and must end with a
1899 static struct value
*
1900 eval_op_objc_msgcall (struct type
*expect_type
, struct expression
*exp
,
1901 enum noside noside
, CORE_ADDR selector
,
1902 value
*target
, gdb::array_view
<value
*> args
)
1904 CORE_ADDR responds_selector
= 0;
1905 CORE_ADDR method_selector
= 0;
1907 int struct_return
= 0;
1909 struct value
*msg_send
= NULL
;
1910 struct value
*msg_send_stret
= NULL
;
1911 int gnu_runtime
= 0;
1913 struct value
*method
= NULL
;
1914 struct value
*called_method
= NULL
;
1916 struct type
*selector_type
= NULL
;
1917 struct type
*long_type
;
1920 struct value
*ret
= NULL
;
1925 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1926 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1928 if (value_as_long (target
) == 0)
1929 return value_from_longest (long_type
, 0);
1931 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1934 /* Find the method dispatch (Apple runtime) or method lookup
1935 (GNU runtime) function for Objective-C. These will be used
1936 to lookup the symbol information for the method. If we
1937 can't find any symbol information, then we'll use these to
1938 call the method, otherwise we can call the method
1939 directly. The msg_send_stret function is used in the special
1940 case of a method that returns a structure (Apple runtime
1944 type
= selector_type
;
1946 type
= lookup_function_type (type
);
1947 type
= lookup_pointer_type (type
);
1948 type
= lookup_function_type (type
);
1949 type
= lookup_pointer_type (type
);
1951 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1953 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1955 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1956 msg_send_stret
= value_from_pointer (type
,
1957 value_as_address (msg_send_stret
));
1961 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1962 /* Special dispatcher for methods returning structs. */
1964 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1967 /* Verify the target object responds to this method. The
1968 standard top-level 'Object' class uses a different name for
1969 the verification method than the non-standard, but more
1970 often used, 'NSObject' class. Make sure we check for both. */
1973 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1974 if (responds_selector
== 0)
1976 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1978 if (responds_selector
== 0)
1979 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1982 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1983 if (method_selector
== 0)
1985 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1987 if (method_selector
== 0)
1988 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1990 /* Call the verification method, to make sure that the target
1991 class implements the desired method. */
1993 argvec
[0] = msg_send
;
1995 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1996 argvec
[3] = value_from_longest (long_type
, selector
);
1999 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2002 /* Function objc_msg_lookup returns a pointer. */
2004 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2006 if (value_as_long (ret
) == 0)
2007 error (_("Target does not respond to this message selector."));
2009 /* Call "methodForSelector:" method, to get the address of a
2010 function method that implements this selector for this
2011 class. If we can find a symbol at that address, then we
2012 know the return type, parameter types etc. (that's a good
2015 argvec
[0] = msg_send
;
2017 argvec
[2] = value_from_longest (long_type
, method_selector
);
2018 argvec
[3] = value_from_longest (long_type
, selector
);
2021 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2025 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
2028 /* ret should now be the selector. */
2030 addr
= value_as_long (ret
);
2033 struct symbol
*sym
= NULL
;
2035 /* The address might point to a function descriptor;
2036 resolve it to the actual code address instead. */
2037 addr
= gdbarch_convert_from_func_ptr_addr
2038 (exp
->gdbarch
, addr
, current_inferior ()->top_target ());
2040 /* Is it a high_level symbol? */
2041 sym
= find_pc_function (addr
);
2043 method
= value_of_variable (sym
, 0);
2046 /* If we found a method with symbol information, check to see
2047 if it returns a struct. Otherwise assume it doesn't. */
2052 struct type
*val_type
;
2054 funaddr
= find_function_addr (method
, &val_type
);
2056 block_for_pc (funaddr
);
2058 val_type
= check_typedef (val_type
);
2060 if ((val_type
== NULL
)
2061 || (val_type
->code () == TYPE_CODE_ERROR
))
2063 if (expect_type
!= NULL
)
2064 val_type
= expect_type
;
2067 struct_return
= using_struct_return (exp
->gdbarch
, method
,
2070 else if (expect_type
!= NULL
)
2072 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
2073 check_typedef (expect_type
));
2076 /* Found a function symbol. Now we will substitute its
2077 value in place of the message dispatcher (obj_msgSend),
2078 so that we call the method directly instead of thru
2079 the dispatcher. The main reason for doing this is that
2080 we can now evaluate the return value and parameter values
2081 according to their known data types, in case we need to
2082 do things like promotion, dereferencing, special handling
2083 of structs and doubles, etc.
2085 We want to use the type signature of 'method', but still
2086 jump to objc_msgSend() or objc_msgSend_stret() to better
2087 mimic the behavior of the runtime. */
2091 if (method
->type ()->code () != TYPE_CODE_FUNC
)
2092 error (_("method address has symbol information "
2093 "with non-function type; skipping"));
2095 /* Create a function pointer of the appropriate type, and
2096 replace its value with the value of msg_send or
2097 msg_send_stret. We must use a pointer here, as
2098 msg_send and msg_send_stret are of pointer type, and
2099 the representation may be different on systems that use
2100 function descriptors. */
2103 = value_from_pointer (lookup_pointer_type (method
->type ()),
2104 value_as_address (msg_send_stret
));
2107 = value_from_pointer (lookup_pointer_type (method
->type ()),
2108 value_as_address (msg_send
));
2113 called_method
= msg_send_stret
;
2115 called_method
= msg_send
;
2119 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2121 /* If the return type doesn't look like a function type,
2122 call an error. This can happen if somebody tries to
2123 turn a variable into a function call. This is here
2124 because people often want to call, eg, strcmp, which
2125 gdb doesn't know is a function. If gdb isn't asked for
2126 it's opinion (ie. through "whatis"), it won't offer
2129 struct type
*callee_type
= called_method
->type ();
2131 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
2132 callee_type
= callee_type
->target_type ();
2133 callee_type
= callee_type
->target_type ();
2137 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
2138 return value::allocate (expect_type
);
2140 return value::allocate (callee_type
);
2143 error (_("Expression of type other than "
2144 "\"method returning ...\" used as a method"));
2147 /* Now depending on whether we found a symbol for the method,
2148 we will either call the runtime dispatcher or the method
2152 args
[1] = value_from_longest (long_type
, selector
);
2154 if (gnu_runtime
&& (method
!= NULL
))
2156 /* Function objc_msg_lookup returns a pointer. */
2157 struct type
*tem_type
= called_method
->type ();
2158 tem_type
= lookup_pointer_type (lookup_function_type (tem_type
));
2159 called_method
->deprecated_set_type (tem_type
);
2160 called_method
= call_function_by_hand (called_method
, NULL
, args
);
2163 return call_function_by_hand (called_method
, NULL
, args
);
2166 /* Helper function for MULTI_SUBSCRIPT. */
2168 static struct value
*
2169 eval_multi_subscript (struct type
*expect_type
, struct expression
*exp
,
2170 enum noside noside
, value
*arg1
,
2171 gdb::array_view
<value
*> args
)
2173 for (value
*arg2
: args
)
2175 if (binop_user_defined_p (MULTI_SUBSCRIPT
, arg1
, arg2
))
2177 arg1
= value_x_binop (arg1
, arg2
, MULTI_SUBSCRIPT
, OP_NULL
, noside
);
2181 arg1
= coerce_ref (arg1
);
2182 struct type
*type
= check_typedef (arg1
->type ());
2184 switch (type
->code ())
2187 case TYPE_CODE_ARRAY
:
2188 case TYPE_CODE_STRING
:
2189 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2194 error (_("cannot subscript something of type `%s'"),
2197 error (_("cannot subscript requested type"));
2208 objc_msgcall_operation::evaluate (struct type
*expect_type
,
2209 struct expression
*exp
,
2212 enum noside sub_no_side
= EVAL_NORMAL
;
2213 struct type
*selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
2215 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2216 sub_no_side
= EVAL_NORMAL
;
2218 sub_no_side
= noside
;
2220 = std::get
<1> (m_storage
)->evaluate (selector_type
, exp
, sub_no_side
);
2222 if (value_as_long (target
) == 0)
2223 sub_no_side
= EVAL_AVOID_SIDE_EFFECTS
;
2225 sub_no_side
= noside
;
2226 std::vector
<operation_up
> &args
= std::get
<2> (m_storage
);
2227 value
**argvec
= XALLOCAVEC (struct value
*, args
.size () + 3);
2228 argvec
[0] = nullptr;
2229 argvec
[1] = nullptr;
2230 for (int i
= 0; i
< args
.size (); ++i
)
2231 argvec
[i
+ 2] = args
[i
]->evaluate_with_coercion (exp
, sub_no_side
);
2232 argvec
[args
.size () + 2] = nullptr;
2234 return eval_op_objc_msgcall (expect_type
, exp
, noside
, std::
2235 get
<0> (m_storage
), target
,
2236 gdb::make_array_view (argvec
,
2241 multi_subscript_operation::evaluate (struct type
*expect_type
,
2242 struct expression
*exp
,
2245 value
*arg1
= std::get
<0> (m_storage
)->evaluate_with_coercion (exp
, noside
);
2246 std::vector
<operation_up
> &values
= std::get
<1> (m_storage
);
2247 value
**argvec
= XALLOCAVEC (struct value
*, values
.size ());
2248 for (int ix
= 0; ix
< values
.size (); ++ix
)
2249 argvec
[ix
] = values
[ix
]->evaluate_with_coercion (exp
, noside
);
2250 return eval_multi_subscript (expect_type
, exp
, noside
, arg1
,
2251 gdb::make_array_view (argvec
, values
.size ()));
2255 logical_and_operation::evaluate (struct type
*expect_type
,
2256 struct expression
*exp
,
2259 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2261 value
*arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
,
2262 EVAL_AVOID_SIDE_EFFECTS
);
2264 if (binop_user_defined_p (BINOP_LOGICAL_AND
, arg1
, arg2
))
2266 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2267 return value_x_binop (arg1
, arg2
, BINOP_LOGICAL_AND
, OP_NULL
, noside
);
2271 bool tem
= value_logical_not (arg1
);
2274 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2275 tem
= value_logical_not (arg2
);
2277 struct type
*type
= language_bool_type (exp
->language_defn
,
2279 return value_from_longest (type
, !tem
);
2284 logical_or_operation::evaluate (struct type
*expect_type
,
2285 struct expression
*exp
,
2288 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2290 value
*arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
,
2291 EVAL_AVOID_SIDE_EFFECTS
);
2293 if (binop_user_defined_p (BINOP_LOGICAL_OR
, arg1
, arg2
))
2295 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2296 return value_x_binop (arg1
, arg2
, BINOP_LOGICAL_OR
, OP_NULL
, noside
);
2300 bool tem
= value_logical_not (arg1
);
2303 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
2304 tem
= value_logical_not (arg2
);
2307 struct type
*type
= language_bool_type (exp
->language_defn
,
2309 return value_from_longest (type
, !tem
);
2314 adl_func_operation::evaluate (struct type
*expect_type
,
2315 struct expression
*exp
,
2318 std::vector
<operation_up
> &arg_ops
= std::get
<2> (m_storage
);
2319 std::vector
<value
*> args (arg_ops
.size ());
2320 for (int i
= 0; i
< arg_ops
.size (); ++i
)
2321 args
[i
] = arg_ops
[i
]->evaluate_with_coercion (exp
, noside
);
2323 struct symbol
*symp
;
2324 find_overload_match (args
, std::get
<0> (m_storage
).c_str (),
2327 nullptr, &symp
, nullptr, 0, noside
);
2328 if (symp
->type ()->code () == TYPE_CODE_ERROR
)
2329 error_unknown_type (symp
->print_name ());
2330 value
*callee
= evaluate_var_value (noside
, std::get
<1> (m_storage
), symp
);
2331 return evaluate_subexp_do_call (exp
, noside
, callee
, args
,
2332 nullptr, expect_type
);
2336 /* This function evaluates brace-initializers (in C/C++) for
2340 array_operation::evaluate_struct_tuple (struct value
*struct_val
,
2341 struct expression
*exp
,
2342 enum noside noside
, int nargs
)
2344 const std::vector
<operation_up
> &in_args
= std::get
<2> (m_storage
);
2345 struct type
*struct_type
= check_typedef (struct_val
->type ());
2346 struct type
*field_type
;
2350 while (--nargs
>= 0)
2352 struct value
*val
= NULL
;
2353 int bitpos
, bitsize
;
2357 /* Skip static fields. */
2358 while (fieldno
< struct_type
->num_fields ()
2359 && struct_type
->field (fieldno
).is_static ())
2361 if (fieldno
>= struct_type
->num_fields ())
2362 error (_("too many initializers"));
2363 field_type
= struct_type
->field (fieldno
).type ();
2364 if (field_type
->code () == TYPE_CODE_UNION
2365 && struct_type
->field (fieldno
).name ()[0] == '0')
2366 error (_("don't know which variant you want to set"));
2368 /* Here, struct_type is the type of the inner struct,
2369 while substruct_type is the type of the inner struct.
2370 These are the same for normal structures, but a variant struct
2371 contains anonymous union fields that contain substruct fields.
2372 The value fieldno is the index of the top-level (normal or
2373 anonymous union) field in struct_field, while the value
2374 subfieldno is the index of the actual real (named inner) field
2375 in substruct_type. */
2377 field_type
= struct_type
->field (fieldno
).type ();
2379 val
= in_args
[idx
++]->evaluate (field_type
, exp
, noside
);
2381 /* Now actually set the field in struct_val. */
2383 /* Assign val to field fieldno. */
2384 if (val
->type () != field_type
)
2385 val
= value_cast (field_type
, val
);
2387 bitsize
= struct_type
->field (fieldno
).bitsize ();
2388 bitpos
= struct_type
->field (fieldno
).loc_bitpos ();
2389 addr
= struct_val
->contents_writeable ().data () + bitpos
/ 8;
2391 modify_field (struct_type
, addr
,
2392 value_as_long (val
), bitpos
% 8, bitsize
);
2394 memcpy (addr
, val
->contents ().data (),
2395 val
->type ()->length ());
2402 array_operation::evaluate (struct type
*expect_type
,
2403 struct expression
*exp
,
2406 const int provided_low_bound
= std::get
<0> (m_storage
);
2407 const std::vector
<operation_up
> &in_args
= std::get
<2> (m_storage
);
2408 const int nargs
= std::get
<1> (m_storage
) - provided_low_bound
+ 1;
2409 struct type
*type
= expect_type
? check_typedef (expect_type
) : nullptr;
2411 if (expect_type
!= nullptr
2412 && type
->code () == TYPE_CODE_STRUCT
)
2414 struct value
*rec
= value::allocate (expect_type
);
2416 memset (rec
->contents_raw ().data (), '\0', type
->length ());
2417 return evaluate_struct_tuple (rec
, exp
, noside
, nargs
);
2420 if (expect_type
!= nullptr
2421 && type
->code () == TYPE_CODE_ARRAY
)
2423 struct type
*range_type
= type
->index_type ();
2424 struct type
*element_type
= type
->target_type ();
2425 struct value
*array
= value::allocate (expect_type
);
2426 int element_size
= check_typedef (element_type
)->length ();
2427 LONGEST low_bound
, high_bound
;
2429 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
2432 high_bound
= (type
->length () / element_size
) - 1;
2434 if (low_bound
+ nargs
- 1 > high_bound
)
2435 error (_("Too many array elements"));
2436 memset (array
->contents_raw ().data (), 0, expect_type
->length ());
2437 for (int idx
= 0; idx
< nargs
; ++idx
)
2439 struct value
*element
;
2441 element
= in_args
[idx
]->evaluate (element_type
, exp
, noside
);
2442 if (element
->type () != element_type
)
2443 element
= value_cast (element_type
, element
);
2444 memcpy (array
->contents_raw ().data () + idx
* element_size
,
2445 element
->contents ().data (),
2451 if (expect_type
!= nullptr
2452 && type
->code () == TYPE_CODE_SET
)
2454 struct value
*set
= value::allocate (expect_type
);
2455 gdb_byte
*valaddr
= set
->contents_raw ().data ();
2456 struct type
*element_type
= type
->index_type ();
2457 struct type
*check_type
= element_type
;
2458 LONGEST low_bound
, high_bound
;
2460 /* Get targettype of elementtype. */
2461 while (check_type
->code () == TYPE_CODE_RANGE
2462 || check_type
->code () == TYPE_CODE_TYPEDEF
)
2463 check_type
= check_type
->target_type ();
2465 if (!get_discrete_bounds (element_type
, &low_bound
, &high_bound
))
2466 error (_("(power)set type with unknown size"));
2467 memset (valaddr
, '\0', type
->length ());
2468 for (int idx
= 0; idx
< nargs
; idx
++)
2470 LONGEST range_low
, range_high
;
2471 struct type
*range_low_type
, *range_high_type
;
2472 struct value
*elem_val
;
2474 elem_val
= in_args
[idx
]->evaluate (element_type
, exp
, noside
);
2475 range_low_type
= range_high_type
= elem_val
->type ();
2476 range_low
= range_high
= value_as_long (elem_val
);
2478 /* Check types of elements to avoid mixture of elements from
2479 different types. Also check if type of element is "compatible"
2480 with element type of powerset. */
2481 if (range_low_type
->code () == TYPE_CODE_RANGE
)
2482 range_low_type
= range_low_type
->target_type ();
2483 if (range_high_type
->code () == TYPE_CODE_RANGE
)
2484 range_high_type
= range_high_type
->target_type ();
2485 if ((range_low_type
->code () != range_high_type
->code ())
2486 || (range_low_type
->code () == TYPE_CODE_ENUM
2487 && (range_low_type
!= range_high_type
)))
2488 /* different element modes. */
2489 error (_("POWERSET tuple elements of different mode"));
2490 if ((check_type
->code () != range_low_type
->code ())
2491 || (check_type
->code () == TYPE_CODE_ENUM
2492 && range_low_type
!= check_type
))
2493 error (_("incompatible POWERSET tuple elements"));
2494 if (range_low
> range_high
)
2496 warning (_("empty POWERSET tuple range"));
2499 if (range_low
< low_bound
|| range_high
> high_bound
)
2500 error (_("POWERSET tuple element out of range"));
2501 range_low
-= low_bound
;
2502 range_high
-= low_bound
;
2503 for (; range_low
<= range_high
; range_low
++)
2505 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
2507 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
2508 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
2509 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
2516 std::vector
<value
*> argvec (nargs
);
2517 for (int tem
= 0; tem
< nargs
; tem
++)
2519 /* Ensure that array expressions are coerced into pointer
2521 argvec
[tem
] = in_args
[tem
]->evaluate_with_coercion (exp
, noside
);
2523 return value_array (provided_low_bound
, argvec
);
2527 unop_extract_operation::evaluate (struct type
*expect_type
,
2528 struct expression
*exp
,
2531 value
*old_value
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2532 struct type
*type
= get_type ();
2534 if (type
->length () > old_value
->type ()->length ())
2535 error (_("length type is larger than the value type"));
2537 struct value
*result
= value::allocate (type
);
2538 old_value
->contents_copy (result
, 0, 0, type
->length ());
2545 /* Helper for evaluate_subexp_for_address. */
2548 evaluate_subexp_for_address_base (struct expression
*exp
, enum noside noside
,
2551 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2553 struct type
*type
= check_typedef (x
->type ());
2555 if (TYPE_IS_REFERENCE (type
))
2556 return value::zero (lookup_pointer_type (type
->target_type ()),
2558 else if (x
->lval () == lval_memory
|| value_must_coerce_to_target (x
))
2559 return value::zero (lookup_pointer_type (x
->type ()),
2562 error (_("Attempt to take address of "
2563 "value not located in memory."));
2565 return value_addr (x
);
2572 operation::evaluate_for_cast (struct type
*expect_type
,
2573 struct expression
*exp
,
2576 value
*val
= evaluate (expect_type
, exp
, noside
);
2577 return value_cast (expect_type
, val
);
2581 operation::evaluate_for_address (struct expression
*exp
, enum noside noside
)
2583 value
*val
= evaluate (nullptr, exp
, noside
);
2584 return evaluate_subexp_for_address_base (exp
, noside
, val
);
2588 scope_operation::evaluate_for_address (struct expression
*exp
,
2591 value
*x
= value_aggregate_elt (std::get
<0> (m_storage
),
2592 std::get
<1> (m_storage
).c_str (),
2595 error (_("There is no field named %s"), std::get
<1> (m_storage
).c_str ());
2600 unop_ind_base_operation::evaluate_for_address (struct expression
*exp
,
2603 value
*x
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
2605 /* We can't optimize out "&*" if there's a user-defined operator*. */
2606 if (unop_user_defined_p (UNOP_IND
, x
))
2608 x
= value_x_unop (x
, UNOP_IND
, noside
);
2609 return evaluate_subexp_for_address_base (exp
, noside
, x
);
2612 return coerce_array (x
);
2616 var_msym_value_operation::evaluate_for_address (struct expression
*exp
,
2619 const bound_minimal_symbol
&b
= std::get
<0> (m_storage
);
2620 value
*val
= evaluate_var_msym_value (noside
, b
.objfile
, b
.minsym
);
2621 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2623 struct type
*type
= lookup_pointer_type (val
->type ());
2624 return value::zero (type
, not_lval
);
2627 return value_addr (val
);
2631 unop_memval_operation::evaluate_for_address (struct expression
*exp
,
2634 return value_cast (lookup_pointer_type (std::get
<1> (m_storage
)),
2635 std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
));
2639 unop_memval_type_operation::evaluate_for_address (struct expression
*exp
,
2642 value
*typeval
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
2643 EVAL_AVOID_SIDE_EFFECTS
);
2644 struct type
*type
= typeval
->type ();
2645 return value_cast (lookup_pointer_type (type
),
2646 std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
));
2650 var_value_operation::evaluate_for_address (struct expression
*exp
,
2653 symbol
*var
= std::get
<0> (m_storage
).symbol
;
2655 /* C++: The "address" of a reference should yield the address
2656 * of the object pointed to. Let value_addr() deal with it. */
2657 if (TYPE_IS_REFERENCE (var
->type ()))
2658 return operation::evaluate_for_address (exp
, noside
);
2660 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2662 struct type
*type
= lookup_pointer_type (var
->type ());
2663 enum address_class sym_class
= var
->aclass ();
2665 if (sym_class
== LOC_CONST
2666 || sym_class
== LOC_CONST_BYTES
2667 || sym_class
== LOC_REGISTER
)
2668 error (_("Attempt to take address of register or constant."));
2670 return value::zero (type
, not_lval
);
2673 return address_of_variable (var
, std::get
<0> (m_storage
).block
);
2677 var_value_operation::evaluate_with_coercion (struct expression
*exp
,
2680 struct symbol
*var
= std::get
<0> (m_storage
).symbol
;
2681 struct type
*type
= check_typedef (var
->type ());
2682 if (type
->code () == TYPE_CODE_ARRAY
2683 && !type
->is_vector ()
2684 && CAST_IS_CONVERSION (exp
->language_defn
))
2686 struct value
*val
= address_of_variable (var
,
2687 std::get
<0> (m_storage
).block
);
2688 return value_cast (lookup_pointer_type (type
->target_type ()), val
);
2690 return evaluate (nullptr, exp
, noside
);
2695 /* Helper function for evaluating the size of a type. */
2698 evaluate_subexp_for_sizeof_base (struct expression
*exp
, struct type
*type
)
2700 /* FIXME: This should be size_t. */
2701 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2702 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
2703 "When applied to a reference or a reference type, the result is
2704 the size of the referenced type." */
2705 type
= check_typedef (type
);
2706 if (exp
->language_defn
->la_language
== language_cplus
2707 && (TYPE_IS_REFERENCE (type
)))
2708 type
= check_typedef (type
->target_type ());
2709 return value_from_longest (size_type
, (LONGEST
) type
->length ());
2716 operation::evaluate_for_sizeof (struct expression
*exp
, enum noside noside
)
2718 value
*val
= evaluate (nullptr, exp
, EVAL_AVOID_SIDE_EFFECTS
);
2719 return evaluate_subexp_for_sizeof_base (exp
, val
->type ());
2723 var_msym_value_operation::evaluate_for_sizeof (struct expression
*exp
,
2727 const bound_minimal_symbol
&b
= std::get
<0> (m_storage
);
2728 value
*mval
= evaluate_var_msym_value (noside
, b
.objfile
, b
.minsym
);
2730 struct type
*type
= mval
->type ();
2731 if (type
->code () == TYPE_CODE_ERROR
)
2732 error_unknown_type (b
.minsym
->print_name ());
2734 /* FIXME: This should be size_t. */
2735 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2736 return value_from_longest (size_type
, type
->length ());
2740 subscript_operation::evaluate_for_sizeof (struct expression
*exp
,
2743 if (noside
== EVAL_NORMAL
)
2745 value
*val
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
2746 EVAL_AVOID_SIDE_EFFECTS
);
2747 struct type
*type
= check_typedef (val
->type ());
2748 if (type
->code () == TYPE_CODE_ARRAY
)
2750 type
= check_typedef (type
->target_type ());
2751 if (type
->code () == TYPE_CODE_ARRAY
)
2753 type
= type
->index_type ();
2754 /* Only re-evaluate the right hand side if the resulting type
2755 is a variable length type. */
2756 if (type
->bounds ()->flag_bound_evaluated
)
2758 val
= evaluate (nullptr, exp
, EVAL_NORMAL
);
2759 /* FIXME: This should be size_t. */
2760 struct type
*size_type
2761 = builtin_type (exp
->gdbarch
)->builtin_int
;
2762 return value_from_longest
2763 (size_type
, (LONGEST
) val
->type ()->length ());
2769 return operation::evaluate_for_sizeof (exp
, noside
);
2773 unop_ind_base_operation::evaluate_for_sizeof (struct expression
*exp
,
2776 value
*val
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
2777 EVAL_AVOID_SIDE_EFFECTS
);
2778 struct type
*type
= check_typedef (val
->type ());
2779 if (!type
->is_pointer_or_reference ()
2780 && type
->code () != TYPE_CODE_ARRAY
)
2781 error (_("Attempt to take contents of a non-pointer value."));
2782 type
= type
->target_type ();
2783 if (is_dynamic_type (type
))
2784 type
= value_ind (val
)->type ();
2785 /* FIXME: This should be size_t. */
2786 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2787 return value_from_longest (size_type
, (LONGEST
) type
->length ());
2791 unop_memval_operation::evaluate_for_sizeof (struct expression
*exp
,
2794 return evaluate_subexp_for_sizeof_base (exp
, std::get
<1> (m_storage
));
2798 unop_memval_type_operation::evaluate_for_sizeof (struct expression
*exp
,
2801 value
*typeval
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
,
2802 EVAL_AVOID_SIDE_EFFECTS
);
2803 return evaluate_subexp_for_sizeof_base (exp
, typeval
->type ());
2807 var_value_operation::evaluate_for_sizeof (struct expression
*exp
,
2810 struct type
*type
= std::get
<0> (m_storage
).symbol
->type ();
2811 if (is_dynamic_type (type
))
2813 value
*val
= evaluate (nullptr, exp
, EVAL_NORMAL
);
2814 type
= val
->type ();
2815 if (type
->code () == TYPE_CODE_ARRAY
)
2817 /* FIXME: This should be size_t. */
2818 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2819 if (type_not_allocated (type
) || type_not_associated (type
))
2820 return value::zero (size_type
, not_lval
);
2821 else if (is_dynamic_type (type
->index_type ())
2822 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
2823 return value::allocate_optimized_out (size_type
);
2826 return evaluate_subexp_for_sizeof_base (exp
, type
);
2830 var_msym_value_operation::evaluate_for_cast (struct type
*to_type
,
2831 struct expression
*exp
,
2834 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2835 return value::zero (to_type
, not_lval
);
2837 const bound_minimal_symbol
&b
= std::get
<0> (m_storage
);
2838 value
*val
= evaluate_var_msym_value (noside
, b
.objfile
, b
.minsym
);
2840 val
= value_cast (to_type
, val
);
2842 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
2843 if (val
->lval () == lval_memory
)
2847 val
->set_lval (not_lval
);
2853 var_value_operation::evaluate_for_cast (struct type
*to_type
,
2854 struct expression
*exp
,
2857 value
*val
= evaluate_var_value (noside
,
2858 std::get
<0> (m_storage
).block
,
2859 std::get
<0> (m_storage
).symbol
);
2861 val
= value_cast (to_type
, val
);
2863 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
2864 if (val
->lval () == lval_memory
)
2868 val
->set_lval (not_lval
);
2875 /* Parse a type expression in the string [P..P+LENGTH). */
2878 parse_and_eval_type (const char *p
, int length
)
2880 char *tmp
= (char *) alloca (length
+ 4);
2883 memcpy (tmp
+ 1, p
, length
);
2884 tmp
[length
+ 1] = ')';
2885 tmp
[length
+ 2] = '0';
2886 tmp
[length
+ 3] = '\0';
2887 expression_up expr
= parse_expression (tmp
);
2888 expr::unop_cast_operation
*op
2889 = dynamic_cast<expr::unop_cast_operation
*> (expr
->op
.get ());
2891 error (_("Internal error in eval_type."));
2892 return op
->get_type ();