1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
27 #include "gdbthread.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
29 #include "f-lang.h" /* For array bound stuff. */
32 #include "objc-lang.h"
34 #include "parser-defs.h"
35 #include "cp-support.h"
38 #include "user-regs.h"
40 #include "gdb_obstack.h"
42 #include "typeprint.h"
45 /* Prototypes for local functions. */
47 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
50 static struct value
*evaluate_subexp_for_address (struct expression
*,
53 static value
*evaluate_subexp_for_cast (expression
*exp
, int *pos
,
57 static struct value
*evaluate_struct_tuple (struct value
*,
58 struct expression
*, int *,
61 static LONGEST
init_array_element (struct value
*, struct value
*,
62 struct expression
*, int *, enum noside
,
66 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
67 int *pos
, enum noside noside
)
71 gdb::optional
<enable_thread_stack_temporaries
> stack_temporaries
;
72 if (*pos
== 0 && target_has_execution
73 && exp
->language_defn
->la_language
== language_cplus
74 && !thread_stack_temporaries_enabled_p (inferior_thread ()))
75 stack_temporaries
.emplace (inferior_thread ());
77 retval
= (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
78 (expect_type
, exp
, pos
, noside
);
80 if (stack_temporaries
.has_value ()
81 && value_in_thread_stack_temporaries (retval
, inferior_thread ()))
82 retval
= value_non_lval (retval
);
87 /* Parse the string EXP as a C expression, evaluate it,
88 and return the result as a number. */
91 parse_and_eval_address (const char *exp
)
93 expression_up expr
= parse_expression (exp
);
95 return value_as_address (evaluate_expression (expr
.get ()));
98 /* Like parse_and_eval_address, but treats the value of the expression
99 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
101 parse_and_eval_long (const char *exp
)
103 expression_up expr
= parse_expression (exp
);
105 return value_as_long (evaluate_expression (expr
.get ()));
109 parse_and_eval (const char *exp
)
111 expression_up expr
= parse_expression (exp
);
113 return evaluate_expression (expr
.get ());
116 /* Parse up to a comma (or to a closeparen)
117 in the string EXPP as an expression, evaluate it, and return the value.
118 EXPP is advanced to point to the comma. */
121 parse_to_comma_and_eval (const char **expp
)
123 expression_up expr
= parse_exp_1 (expp
, 0, nullptr, 1);
125 return evaluate_expression (expr
.get ());
128 /* Evaluate an expression in internal prefix form
129 such as is constructed by parse.y.
131 See expression.h for info on the format of an expression. */
134 evaluate_expression (struct expression
*exp
)
138 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
141 /* Evaluate an expression, avoiding all memory references
142 and getting a value whose type alone is correct. */
145 evaluate_type (struct expression
*exp
)
149 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
152 /* Evaluate a subexpression, avoiding all memory references and
153 getting a value whose type alone is correct. */
156 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
158 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
161 /* Find the current value of a watchpoint on EXP. Return the value in
162 *VALP and *RESULTP and the chain of intermediate and final values
163 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
166 If PRESERVE_ERRORS is true, then exceptions are passed through.
167 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
168 occurs while evaluating the expression, *RESULTP will be set to
169 NULL. *RESULTP may be a lazy value, if the result could not be
170 read from memory. It is used to determine whether a value is
171 user-specified (we should watch the whole value) or intermediate
172 (we should watch only the bit used to locate the final value).
174 If the final value, or any intermediate value, could not be read
175 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
176 set to any referenced values. *VALP will never be a lazy value.
177 This is the value which we store in struct breakpoint.
179 If VAL_CHAIN is non-NULL, the values put into *VAL_CHAIN will be
180 released from the value chain. If VAL_CHAIN is NULL, all generated
181 values will be left on the value chain. */
184 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
185 struct value
**resultp
,
186 std::vector
<value_ref_ptr
> *val_chain
,
189 struct value
*mark
, *new_mark
, *result
;
197 /* Evaluate the expression. */
198 mark
= value_mark ();
203 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
205 catch (const gdb_exception
&ex
)
207 /* Ignore memory errors if we want watchpoints pointing at
208 inaccessible memory to still be created; otherwise, throw the
209 error to some higher catcher. */
213 if (!preserve_errors
)
222 new_mark
= value_mark ();
223 if (mark
== new_mark
)
228 /* Make sure it's not lazy, so that after the target stops again we
229 have a non-lazy previous value to compare with. */
232 if (!value_lazy (result
))
239 value_fetch_lazy (result
);
242 catch (const gdb_exception_error
&except
)
250 /* Return the chain of intermediate values. We use this to
251 decide which addresses to watch. */
252 *val_chain
= value_release_to_mark (mark
);
256 /* Extract a field operation from an expression. If the subexpression
257 of EXP starting at *SUBEXP is not a structure dereference
258 operation, return NULL. Otherwise, return the name of the
259 dereferenced field, and advance *SUBEXP to point to the
260 subexpression of the left-hand-side of the dereference. This is
261 used when completing field names. */
264 extract_field_op (struct expression
*exp
, int *subexp
)
269 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
270 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
272 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
273 result
= &exp
->elts
[*subexp
+ 2].string
;
274 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
278 /* This function evaluates brace-initializers (in C/C++) for
281 static struct value
*
282 evaluate_struct_tuple (struct value
*struct_val
,
283 struct expression
*exp
,
284 int *pos
, enum noside noside
, int nargs
)
286 struct type
*struct_type
= check_typedef (value_type (struct_val
));
287 struct type
*field_type
;
292 struct value
*val
= NULL
;
297 /* Skip static fields. */
298 while (fieldno
< struct_type
->num_fields ()
299 && field_is_static (&struct_type
->field (fieldno
)))
301 if (fieldno
>= struct_type
->num_fields ())
302 error (_("too many initializers"));
303 field_type
= struct_type
->field (fieldno
).type ();
304 if (field_type
->code () == TYPE_CODE_UNION
305 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
306 error (_("don't know which variant you want to set"));
308 /* Here, struct_type is the type of the inner struct,
309 while substruct_type is the type of the inner struct.
310 These are the same for normal structures, but a variant struct
311 contains anonymous union fields that contain substruct fields.
312 The value fieldno is the index of the top-level (normal or
313 anonymous union) field in struct_field, while the value
314 subfieldno is the index of the actual real (named inner) field
315 in substruct_type. */
317 field_type
= struct_type
->field (fieldno
).type ();
319 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
321 /* Now actually set the field in struct_val. */
323 /* Assign val to field fieldno. */
324 if (value_type (val
) != field_type
)
325 val
= value_cast (field_type
, val
);
327 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
328 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
329 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
331 modify_field (struct_type
, addr
,
332 value_as_long (val
), bitpos
% 8, bitsize
);
334 memcpy (addr
, value_contents (val
),
335 TYPE_LENGTH (value_type (val
)));
341 /* Recursive helper function for setting elements of array tuples.
342 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
343 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
344 Evaluates index expressions and sets the specified element(s) of
345 ARRAY to ELEMENT. Returns last index value. */
348 init_array_element (struct value
*array
, struct value
*element
,
349 struct expression
*exp
, int *pos
,
350 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
353 int element_size
= TYPE_LENGTH (value_type (element
));
355 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
358 init_array_element (array
, element
, exp
, pos
, noside
,
359 low_bound
, high_bound
);
360 return init_array_element (array
, element
,
361 exp
, pos
, noside
, low_bound
, high_bound
);
365 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
366 if (index
< low_bound
|| index
> high_bound
)
367 error (_("tuple index out of range"));
368 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
369 value_contents (element
), element_size
);
374 static struct value
*
375 value_f90_subarray (struct value
*array
,
376 struct expression
*exp
, int *pos
, enum noside noside
)
379 LONGEST low_bound
, high_bound
;
380 struct type
*range
= check_typedef (value_type (array
)->index_type ());
381 enum range_type range_type
382 = (enum range_type
) longest_to_int (exp
->elts
[pc
].longconst
);
386 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
387 low_bound
= TYPE_LOW_BOUND (range
);
389 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
391 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
392 high_bound
= TYPE_HIGH_BOUND (range
);
394 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
396 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
400 /* Promote value ARG1 as appropriate before performing a unary operation
402 If the result is not appropriate for any particular language then it
403 needs to patch this function. */
406 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
411 *arg1
= coerce_ref (*arg1
);
412 type1
= check_typedef (value_type (*arg1
));
414 if (is_integral_type (type1
))
416 switch (language
->la_language
)
419 /* Perform integral promotion for ANSI C/C++.
420 If not appropriate for any particular language
421 it needs to modify this function. */
423 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
425 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
426 *arg1
= value_cast (builtin_int
, *arg1
);
433 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
434 operation on those two operands.
435 If the result is not appropriate for any particular language then it
436 needs to patch this function. */
439 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
440 struct value
**arg1
, struct value
**arg2
)
442 struct type
*promoted_type
= NULL
;
446 *arg1
= coerce_ref (*arg1
);
447 *arg2
= coerce_ref (*arg2
);
449 type1
= check_typedef (value_type (*arg1
));
450 type2
= check_typedef (value_type (*arg2
));
452 if ((type1
->code () != TYPE_CODE_FLT
453 && type1
->code () != TYPE_CODE_DECFLOAT
454 && !is_integral_type (type1
))
455 || (type2
->code () != TYPE_CODE_FLT
456 && type2
->code () != TYPE_CODE_DECFLOAT
457 && !is_integral_type (type2
)))
460 if (type1
->code () == TYPE_CODE_DECFLOAT
461 || type2
->code () == TYPE_CODE_DECFLOAT
)
463 /* No promotion required. */
465 else if (type1
->code () == TYPE_CODE_FLT
466 || type2
->code () == TYPE_CODE_FLT
)
468 switch (language
->la_language
)
474 case language_opencl
:
475 /* No promotion required. */
479 /* For other languages the result type is unchanged from gdb
480 version 6.7 for backward compatibility.
481 If either arg was long double, make sure that value is also long
482 double. Otherwise use double. */
483 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
484 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
485 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
487 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
491 else if (type1
->code () == TYPE_CODE_BOOL
492 && type2
->code () == TYPE_CODE_BOOL
)
494 /* No promotion required. */
497 /* Integral operations here. */
498 /* FIXME: Also mixed integral/booleans, with result an integer. */
500 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
501 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
502 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
503 int is_unsigned1
= TYPE_UNSIGNED (type1
);
504 int is_unsigned2
= TYPE_UNSIGNED (type2
);
505 unsigned int result_len
;
506 int unsigned_operation
;
508 /* Determine type length and signedness after promotion for
510 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
513 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
515 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
518 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
521 if (promoted_len1
> promoted_len2
)
523 unsigned_operation
= is_unsigned1
;
524 result_len
= promoted_len1
;
526 else if (promoted_len2
> promoted_len1
)
528 unsigned_operation
= is_unsigned2
;
529 result_len
= promoted_len2
;
533 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
534 result_len
= promoted_len1
;
537 switch (language
->la_language
)
543 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
545 promoted_type
= (unsigned_operation
546 ? builtin
->builtin_unsigned_int
547 : builtin
->builtin_int
);
549 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
551 promoted_type
= (unsigned_operation
552 ? builtin
->builtin_unsigned_long
553 : builtin
->builtin_long
);
557 promoted_type
= (unsigned_operation
558 ? builtin
->builtin_unsigned_long_long
559 : builtin
->builtin_long_long
);
562 case language_opencl
:
563 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
568 ? lookup_unsigned_typename (language
, "int")
569 : lookup_signed_typename (language
, "int"));
571 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
576 ? lookup_unsigned_typename (language
, "long")
577 : lookup_signed_typename (language
,"long"));
581 /* For other languages the result type is unchanged from gdb
582 version 6.7 for backward compatibility.
583 If either arg was long long, make sure that value is also long
584 long. Otherwise use long. */
585 if (unsigned_operation
)
587 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
588 promoted_type
= builtin
->builtin_unsigned_long_long
;
590 promoted_type
= builtin
->builtin_unsigned_long
;
594 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
595 promoted_type
= builtin
->builtin_long_long
;
597 promoted_type
= builtin
->builtin_long
;
605 /* Promote both operands to common type. */
606 *arg1
= value_cast (promoted_type
, *arg1
);
607 *arg2
= value_cast (promoted_type
, *arg2
);
612 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
614 type
= check_typedef (type
);
615 if (TYPE_IS_REFERENCE (type
))
616 type
= TYPE_TARGET_TYPE (type
);
618 switch (type
->code ())
624 case TYPE_CODE_ARRAY
:
625 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
632 /* Represents a fake method with the given parameter types. This is
633 used by the parser to construct a temporary "expected" type for
634 method overload resolution. FLAGS is used as instance flags of the
635 new type, in order to be able to make the new type represent a
636 const/volatile overload. */
641 fake_method (type_instance_flags flags
,
642 int num_types
, struct type
**param_types
);
645 /* The constructed type. */
646 struct type
*type () { return &m_type
; }
649 struct type m_type
{};
650 main_type m_main_type
{};
653 fake_method::fake_method (type_instance_flags flags
,
654 int num_types
, struct type
**param_types
)
656 struct type
*type
= &m_type
;
658 TYPE_MAIN_TYPE (type
) = &m_main_type
;
659 TYPE_LENGTH (type
) = 1;
660 type
->set_code (TYPE_CODE_METHOD
);
661 TYPE_CHAIN (type
) = type
;
662 TYPE_INSTANCE_FLAGS (type
) = flags
;
665 if (param_types
[num_types
- 1] == NULL
)
668 TYPE_VARARGS (type
) = 1;
670 else if (check_typedef (param_types
[num_types
- 1])->code ()
674 /* Caller should have ensured this. */
675 gdb_assert (num_types
== 0);
676 TYPE_PROTOTYPED (type
) = 1;
680 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
681 neither an objfile nor a gdbarch. As a result we must manually
682 allocate memory for auxiliary fields, and free the memory ourselves
683 when we are done with it. */
684 type
->set_num_fields (num_types
);
686 ((struct field
*) xzalloc (sizeof (struct field
) * num_types
));
688 while (num_types
-- > 0)
689 type
->field (num_types
).set_type (param_types
[num_types
]);
692 fake_method::~fake_method ()
694 xfree (m_type
.fields ());
697 /* Helper for evaluating an OP_VAR_VALUE. */
700 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
702 /* JYG: We used to just return value_zero of the symbol type if
703 we're asked to avoid side effects. Otherwise we return
704 value_of_variable (...). However I'm not sure if
705 value_of_variable () has any side effect. We need a full value
706 object returned here for whatis_exp () to call evaluate_type ()
707 and then pass the full value to value_rtti_target_type () if we
708 are dealing with a pointer or reference to a base class and print
711 struct value
*ret
= NULL
;
715 ret
= value_of_variable (var
, blk
);
718 catch (const gdb_exception_error
&except
)
720 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
723 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
729 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
732 evaluate_var_msym_value (enum noside noside
,
733 struct objfile
*objfile
, minimal_symbol
*msymbol
)
736 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
738 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !TYPE_GNU_IFUNC (the_type
))
739 return value_zero (the_type
, not_lval
);
741 return value_at_lazy (the_type
, address
);
744 /* Helper for returning a value when handling EVAL_SKIP. */
747 eval_skip_value (expression
*exp
)
749 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
752 /* Evaluate a function call. The function to be called is in
753 ARGVEC[0] and the arguments passed to the function are in
754 ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
755 known. DEFAULT_RETURN_TYPE is used as the function's return type
756 if the return type is unknown. */
759 eval_call (expression
*exp
, enum noside noside
,
760 int nargs
, value
**argvec
,
761 const char *function_name
,
762 type
*default_return_type
)
764 if (argvec
[0] == NULL
)
765 error (_("Cannot evaluate function -- may be inlined"));
766 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
768 /* If the return type doesn't look like a function type,
769 call an error. This can happen if somebody tries to turn
770 a variable into a function call. */
772 type
*ftype
= value_type (argvec
[0]);
774 if (ftype
->code () == TYPE_CODE_INTERNAL_FUNCTION
)
776 /* We don't know anything about what the internal
777 function might return, but we have to return
779 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
782 else if (ftype
->code () == TYPE_CODE_XMETHOD
)
785 = result_type_of_xmethod (argvec
[0],
786 gdb::make_array_view (argvec
+ 1,
789 if (return_type
== NULL
)
790 error (_("Xmethod is missing return type."));
791 return value_zero (return_type
, not_lval
);
793 else if (ftype
->code () == TYPE_CODE_FUNC
794 || ftype
->code () == TYPE_CODE_METHOD
)
796 if (TYPE_GNU_IFUNC (ftype
))
798 CORE_ADDR address
= value_address (argvec
[0]);
799 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
801 if (resolved_type
!= NULL
)
802 ftype
= resolved_type
;
805 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
807 if (return_type
== NULL
)
808 return_type
= default_return_type
;
810 if (return_type
== NULL
)
811 error_call_unknown_return_type (function_name
);
813 return allocate_value (return_type
);
816 error (_("Expression of type other than "
817 "\"Function returning ...\" used as function"));
819 switch (value_type (argvec
[0])->code ())
821 case TYPE_CODE_INTERNAL_FUNCTION
:
822 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
823 argvec
[0], nargs
, argvec
+ 1);
824 case TYPE_CODE_XMETHOD
:
825 return call_xmethod (argvec
[0], gdb::make_array_view (argvec
+ 1, nargs
));
827 return call_function_by_hand (argvec
[0], default_return_type
,
828 gdb::make_array_view (argvec
+ 1, nargs
));
832 /* Helper for evaluating an OP_FUNCALL. */
835 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
843 symbol
*function
= NULL
;
844 char *function_name
= NULL
;
845 const char *var_func_name
= NULL
;
850 exp_opcode op
= exp
->elts
[*pos
].opcode
;
851 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
852 /* Allocate arg vector, including space for the function to be
853 called in argvec[0], a potential `this', and a terminating
855 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
856 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
858 /* First, evaluate the structure into arg2. */
861 if (op
== STRUCTOP_MEMBER
)
863 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
867 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
870 /* If the function is a virtual function, then the aggregate
871 value (providing the structure) plays its part by providing
872 the vtable. Otherwise, it is just along for the ride: call
873 the function directly. */
875 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
877 type
*a1_type
= check_typedef (value_type (arg1
));
878 if (noside
== EVAL_SKIP
)
879 tem
= 1; /* Set it to the right arg index so that all
880 arguments can also be skipped. */
881 else if (a1_type
->code () == TYPE_CODE_METHODPTR
)
883 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
884 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
886 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
888 /* Now, say which argument to start evaluating from. */
893 else if (a1_type
->code () == TYPE_CODE_MEMBERPTR
)
895 struct type
*type_ptr
896 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
897 struct type
*target_type_ptr
898 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
900 /* Now, convert these values to an address. */
901 arg2
= value_cast (type_ptr
, arg2
);
903 long mem_offset
= value_as_long (arg1
);
905 arg1
= value_from_pointer (target_type_ptr
,
906 value_as_long (arg2
) + mem_offset
);
907 arg1
= value_ind (arg1
);
911 error (_("Non-pointer-to-member value used in pointer-to-member "
914 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
916 /* Hair for method invocations. */
920 /* First, evaluate the structure into arg2. */
922 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
923 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
925 if (op
== STRUCTOP_STRUCT
)
927 /* If v is a variable in a register, and the user types
928 v.method (), this will produce an error, because v has no
931 A possible way around this would be to allocate a copy of
932 the variable on the stack, copy in the contents, call the
933 function, and copy out the contents. I.e. convert this
934 from call by reference to call by copy-return (or
935 whatever it's called). However, this does not work
936 because it is not the same: the method being called could
937 stash a copy of the address, and then future uses through
938 that address (after the method returns) would be expected
939 to use the variable itself, not some copy of it. */
940 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
944 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
946 /* Check to see if the operator '->' has been overloaded.
947 If the operator has been overloaded replace arg2 with the
948 value returned by the custom operator and continue
950 while (unop_user_defined_p (op
, arg2
))
952 struct value
*value
= NULL
;
955 value
= value_x_unop (arg2
, op
, noside
);
958 catch (const gdb_exception_error
&except
)
960 if (except
.error
== NOT_FOUND_ERROR
)
969 /* Now, say which argument to start evaluating from. */
972 else if (op
== OP_SCOPE
973 && overload_resolution
974 && (exp
->language_defn
->la_language
== language_cplus
))
976 /* Unpack it locally so we can properly handle overload
982 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
983 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
984 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
985 name
= &exp
->elts
[pc2
+ 3].string
;
988 function_name
= NULL
;
989 if (type
->code () == TYPE_CODE_NAMESPACE
)
991 function
= cp_lookup_symbol_namespace (type
->name (),
993 get_selected_block (0),
995 if (function
== NULL
)
996 error (_("No symbol \"%s\" in namespace \"%s\"."),
997 name
, type
->name ());
1000 /* arg2 is left as NULL on purpose. */
1004 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1005 || type
->code () == TYPE_CODE_UNION
);
1006 function_name
= name
;
1008 /* We need a properly typed value for method lookup. For
1009 static methods arg2 is otherwise unused. */
1010 arg2
= value_zero (type
, lval_memory
);
1015 else if (op
== OP_ADL_FUNC
)
1017 /* Save the function position and move pos so that the arguments
1018 can be evaluated. */
1024 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1025 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1029 /* Non-method function call. */
1033 /* If this is a C++ function wait until overload resolution. */
1034 if (op
== OP_VAR_VALUE
1035 && overload_resolution
1036 && (exp
->language_defn
->la_language
== language_cplus
))
1038 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1043 if (op
== OP_VAR_MSYM_VALUE
)
1045 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1046 var_func_name
= msym
->print_name ();
1048 else if (op
== OP_VAR_VALUE
)
1050 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1051 var_func_name
= sym
->print_name ();
1054 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1055 type
*type
= value_type (argvec
[0]);
1056 if (type
&& type
->code () == TYPE_CODE_PTR
)
1057 type
= TYPE_TARGET_TYPE (type
);
1058 if (type
&& type
->code () == TYPE_CODE_FUNC
)
1060 for (; tem
<= nargs
&& tem
<= type
->num_fields (); tem
++)
1062 argvec
[tem
] = evaluate_subexp (type
->field (tem
- 1).type (),
1069 /* Evaluate arguments (if not already done, e.g., namespace::func()
1070 and overload-resolution is off). */
1071 for (; tem
<= nargs
; tem
++)
1073 /* Ensure that array expressions are coerced into pointer
1075 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1078 /* Signal end of arglist. */
1081 if (noside
== EVAL_SKIP
)
1082 return eval_skip_value (exp
);
1084 if (op
== OP_ADL_FUNC
)
1086 struct symbol
*symp
;
1089 int string_pc
= save_pos1
+ 3;
1091 /* Extract the function name. */
1092 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1093 func_name
= (char *) alloca (name_len
+ 1);
1094 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1096 find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1098 NON_METHOD
, /* not method */
1099 NULL
, NULL
, /* pass NULL symbol since
1100 symbol is unknown */
1101 NULL
, &symp
, NULL
, 0, noside
);
1103 /* Now fix the expression being evaluated. */
1104 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1105 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1108 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1109 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1111 int static_memfuncp
;
1114 /* Method invocation: stuff "this" as first parameter. If the
1115 method turns out to be static we undo this below. */
1120 /* Name of method from expression. */
1121 tstr
= &exp
->elts
[pc2
+ 2].string
;
1124 tstr
= function_name
;
1126 if (overload_resolution
&& (exp
->language_defn
->la_language
1129 /* Language is C++, do some overload resolution before
1131 struct value
*valp
= NULL
;
1133 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1135 METHOD
, /* method */
1136 &arg2
, /* the object */
1138 &static_memfuncp
, 0, noside
);
1140 if (op
== OP_SCOPE
&& !static_memfuncp
)
1142 /* For the time being, we don't handle this. */
1143 error (_("Call to overloaded function %s requires "
1147 argvec
[1] = arg2
; /* the ``this'' pointer */
1148 argvec
[0] = valp
; /* Use the method found after overload
1152 /* Non-C++ case -- or no overload resolution. */
1154 struct value
*temp
= arg2
;
1156 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1158 op
== STRUCTOP_STRUCT
1159 ? "structure" : "structure pointer");
1160 /* value_struct_elt updates temp with the correct value of
1161 the ``this'' pointer if necessary, so modify argvec[1] to
1162 reflect any ``this'' changes. */
1164 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1165 value_address (temp
)
1166 + value_embedded_offset (temp
));
1167 argvec
[1] = arg2
; /* the ``this'' pointer */
1170 /* Take out `this' if needed. */
1171 if (static_memfuncp
)
1173 argvec
[1] = argvec
[0];
1178 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1180 /* Pointer to member. argvec[1] is already set up. */
1183 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1185 /* Non-member function being called. */
1186 /* fn: This can only be done for C++ functions. A C-style
1187 function in a C++ program, for instance, does not have the
1188 fields that are expected here. */
1190 if (overload_resolution
&& (exp
->language_defn
->la_language
1193 /* Language is C++, do some overload resolution before
1195 struct symbol
*symp
;
1198 /* If a scope has been specified disable ADL. */
1202 if (op
== OP_VAR_VALUE
)
1203 function
= exp
->elts
[save_pos1
+2].symbol
;
1205 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1206 NULL
, /* no need for name */
1207 NON_METHOD
, /* not method */
1208 NULL
, function
, /* the function */
1209 NULL
, &symp
, NULL
, no_adl
, noside
);
1211 if (op
== OP_VAR_VALUE
)
1213 /* Now fix the expression being evaluated. */
1214 exp
->elts
[save_pos1
+2].symbol
= symp
;
1215 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1219 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1223 /* Not C++, or no overload resolution allowed. */
1224 /* Nothing to be done; argvec already correctly set up. */
1229 /* It is probably a C-style function. */
1230 /* Nothing to be done; argvec already correctly set up. */
1233 return eval_call (exp
, noside
, nargs
, argvec
, var_func_name
, expect_type
);
1236 /* Helper for skipping all the arguments in an undetermined argument list.
1237 This function was designed for use in the OP_F77_UNDETERMINED_ARGLIST
1238 case of evaluate_subexp_standard as multiple, but not all, code paths
1239 require a generic skip. */
1242 skip_undetermined_arglist (int nargs
, struct expression
*exp
, int *pos
,
1245 for (int i
= 0; i
< nargs
; ++i
)
1246 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1249 /* Return true if type is integral or reference to integral */
1252 is_integral_or_integral_reference (struct type
*type
)
1254 if (is_integral_type (type
))
1257 type
= check_typedef (type
);
1258 return (type
!= nullptr
1259 && TYPE_IS_REFERENCE (type
)
1260 && is_integral_type (TYPE_TARGET_TYPE (type
)));
1264 evaluate_subexp_standard (struct type
*expect_type
,
1265 struct expression
*exp
, int *pos
,
1269 int tem
, tem2
, tem3
;
1271 struct value
*arg1
= NULL
;
1272 struct value
*arg2
= NULL
;
1276 struct value
**argvec
;
1280 struct type
**arg_types
;
1283 op
= exp
->elts
[pc
].opcode
;
1288 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1289 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1290 if (noside
== EVAL_SKIP
)
1291 return eval_skip_value (exp
);
1292 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
1293 &exp
->elts
[pc
+ 3].string
,
1294 expect_type
, 0, noside
);
1296 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
1301 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1302 exp
->elts
[pc
+ 2].longconst
);
1306 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1307 exp
->elts
[pc
+ 2].floatconst
);
1313 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1314 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
1315 error_unknown_type (var
->print_name ());
1316 if (noside
!= EVAL_SKIP
)
1317 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1320 /* Return a dummy value of the correct type when skipping, so
1321 that parent functions know what is to be skipped. */
1322 return allocate_value (SYMBOL_TYPE (var
));
1326 case OP_VAR_MSYM_VALUE
:
1330 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1331 value
*val
= evaluate_var_msym_value (noside
,
1332 exp
->elts
[pc
+ 1].objfile
,
1335 type
= value_type (val
);
1336 if (type
->code () == TYPE_CODE_ERROR
1337 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| pc
!= 0))
1338 error_unknown_type (msymbol
->print_name ());
1342 case OP_VAR_ENTRY_VALUE
:
1344 if (noside
== EVAL_SKIP
)
1345 return eval_skip_value (exp
);
1348 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1349 struct frame_info
*frame
;
1351 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1352 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1354 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1355 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1356 error (_("Symbol \"%s\" does not have any specific entry value"),
1357 sym
->print_name ());
1359 frame
= get_selected_frame (NULL
);
1360 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1363 case OP_FUNC_STATIC_VAR
:
1364 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1365 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1366 if (noside
== EVAL_SKIP
)
1367 return eval_skip_value (exp
);
1370 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1371 CORE_ADDR addr
= value_address (func
);
1373 const block
*blk
= block_for_pc (addr
);
1374 const char *var
= &exp
->elts
[pc
+ 2].string
;
1376 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1378 if (sym
.symbol
== NULL
)
1379 error (_("No symbol \"%s\" in specified context."), var
);
1381 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1387 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1391 const char *name
= &exp
->elts
[pc
+ 2].string
;
1395 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1396 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1397 name
, strlen (name
));
1399 error (_("Register $%s not available."), name
);
1401 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1402 a value with the appropriate register type. Unfortunately,
1403 we don't have easy access to the type of user registers.
1404 So for these registers, we fetch the register value regardless
1405 of the evaluation mode. */
1406 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1407 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1408 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1410 val
= value_of_register (regno
, get_selected_frame (NULL
));
1412 error (_("Value of register %s not available."), name
);
1418 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1419 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1421 case OP_INTERNALVAR
:
1423 return value_of_internalvar (exp
->gdbarch
,
1424 exp
->elts
[pc
+ 1].internalvar
);
1427 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1428 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1429 if (noside
== EVAL_SKIP
)
1430 return eval_skip_value (exp
);
1431 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1432 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1434 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1435 NSString constant. */
1436 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1437 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1438 if (noside
== EVAL_SKIP
)
1439 return eval_skip_value (exp
);
1440 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1444 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1445 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1446 nargs
= tem3
- tem2
+ 1;
1447 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
1449 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1450 && type
->code () == TYPE_CODE_STRUCT
)
1452 struct value
*rec
= allocate_value (expect_type
);
1454 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1455 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1458 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1459 && type
->code () == TYPE_CODE_ARRAY
)
1461 struct type
*range_type
= type
->index_type ();
1462 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1463 struct value
*array
= allocate_value (expect_type
);
1464 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1465 LONGEST low_bound
, high_bound
, index
;
1467 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1470 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1473 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1474 for (tem
= nargs
; --nargs
>= 0;)
1476 struct value
*element
;
1479 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1480 if (value_type (element
) != element_type
)
1481 element
= value_cast (element_type
, element
);
1484 int continue_pc
= *pos
;
1487 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1488 low_bound
, high_bound
);
1493 if (index
> high_bound
)
1494 /* To avoid memory corruption. */
1495 error (_("Too many array elements"));
1496 memcpy (value_contents_raw (array
)
1497 + (index
- low_bound
) * element_size
,
1498 value_contents (element
),
1506 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1507 && type
->code () == TYPE_CODE_SET
)
1509 struct value
*set
= allocate_value (expect_type
);
1510 gdb_byte
*valaddr
= value_contents_raw (set
);
1511 struct type
*element_type
= type
->index_type ();
1512 struct type
*check_type
= element_type
;
1513 LONGEST low_bound
, high_bound
;
1515 /* Get targettype of elementtype. */
1516 while (check_type
->code () == TYPE_CODE_RANGE
1517 || check_type
->code () == TYPE_CODE_TYPEDEF
)
1518 check_type
= TYPE_TARGET_TYPE (check_type
);
1520 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1521 error (_("(power)set type with unknown size"));
1522 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1523 for (tem
= 0; tem
< nargs
; tem
++)
1525 LONGEST range_low
, range_high
;
1526 struct type
*range_low_type
, *range_high_type
;
1527 struct value
*elem_val
;
1529 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1530 range_low_type
= range_high_type
= value_type (elem_val
);
1531 range_low
= range_high
= value_as_long (elem_val
);
1533 /* Check types of elements to avoid mixture of elements from
1534 different types. Also check if type of element is "compatible"
1535 with element type of powerset. */
1536 if (range_low_type
->code () == TYPE_CODE_RANGE
)
1537 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1538 if (range_high_type
->code () == TYPE_CODE_RANGE
)
1539 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1540 if ((range_low_type
->code () != range_high_type
->code ())
1541 || (range_low_type
->code () == TYPE_CODE_ENUM
1542 && (range_low_type
!= range_high_type
)))
1543 /* different element modes. */
1544 error (_("POWERSET tuple elements of different mode"));
1545 if ((check_type
->code () != range_low_type
->code ())
1546 || (check_type
->code () == TYPE_CODE_ENUM
1547 && range_low_type
!= check_type
))
1548 error (_("incompatible POWERSET tuple elements"));
1549 if (range_low
> range_high
)
1551 warning (_("empty POWERSET tuple range"));
1554 if (range_low
< low_bound
|| range_high
> high_bound
)
1555 error (_("POWERSET tuple element out of range"));
1556 range_low
-= low_bound
;
1557 range_high
-= low_bound
;
1558 for (; range_low
<= range_high
; range_low
++)
1560 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1562 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1563 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1564 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1571 argvec
= XALLOCAVEC (struct value
*, nargs
);
1572 for (tem
= 0; tem
< nargs
; tem
++)
1574 /* Ensure that array expressions are coerced into pointer
1576 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1578 if (noside
== EVAL_SKIP
)
1579 return eval_skip_value (exp
);
1580 return value_array (tem2
, tem3
, argvec
);
1584 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1586 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1588 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1590 if (noside
== EVAL_SKIP
)
1591 return eval_skip_value (exp
);
1592 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1596 /* Skip third and second args to evaluate the first one. */
1597 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1598 if (value_logical_not (arg1
))
1600 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1601 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1605 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1606 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1610 case OP_OBJC_SELECTOR
:
1611 { /* Objective C @selector operator. */
1612 char *sel
= &exp
->elts
[pc
+ 2].string
;
1613 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1614 struct type
*selector_type
;
1616 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1617 if (noside
== EVAL_SKIP
)
1618 return eval_skip_value (exp
);
1621 sel
[len
] = 0; /* Make sure it's terminated. */
1623 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1624 return value_from_longest (selector_type
,
1625 lookup_child_selector (exp
->gdbarch
, sel
));
1628 case OP_OBJC_MSGCALL
:
1629 { /* Objective C message (method) call. */
1631 CORE_ADDR responds_selector
= 0;
1632 CORE_ADDR method_selector
= 0;
1634 CORE_ADDR selector
= 0;
1636 int struct_return
= 0;
1637 enum noside sub_no_side
= EVAL_NORMAL
;
1639 struct value
*msg_send
= NULL
;
1640 struct value
*msg_send_stret
= NULL
;
1641 int gnu_runtime
= 0;
1643 struct value
*target
= NULL
;
1644 struct value
*method
= NULL
;
1645 struct value
*called_method
= NULL
;
1647 struct type
*selector_type
= NULL
;
1648 struct type
*long_type
;
1650 struct value
*ret
= NULL
;
1653 selector
= exp
->elts
[pc
+ 1].longconst
;
1654 nargs
= exp
->elts
[pc
+ 2].longconst
;
1655 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1659 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1660 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1662 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1663 sub_no_side
= EVAL_NORMAL
;
1665 sub_no_side
= noside
;
1667 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1669 if (value_as_long (target
) == 0)
1670 return value_from_longest (long_type
, 0);
1672 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1675 /* Find the method dispatch (Apple runtime) or method lookup
1676 (GNU runtime) function for Objective-C. These will be used
1677 to lookup the symbol information for the method. If we
1678 can't find any symbol information, then we'll use these to
1679 call the method, otherwise we can call the method
1680 directly. The msg_send_stret function is used in the special
1681 case of a method that returns a structure (Apple runtime
1685 type
= selector_type
;
1687 type
= lookup_function_type (type
);
1688 type
= lookup_pointer_type (type
);
1689 type
= lookup_function_type (type
);
1690 type
= lookup_pointer_type (type
);
1692 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1694 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1696 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1697 msg_send_stret
= value_from_pointer (type
,
1698 value_as_address (msg_send_stret
));
1702 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1703 /* Special dispatcher for methods returning structs. */
1705 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1708 /* Verify the target object responds to this method. The
1709 standard top-level 'Object' class uses a different name for
1710 the verification method than the non-standard, but more
1711 often used, 'NSObject' class. Make sure we check for both. */
1714 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1715 if (responds_selector
== 0)
1717 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1719 if (responds_selector
== 0)
1720 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1723 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1724 if (method_selector
== 0)
1726 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1728 if (method_selector
== 0)
1729 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1731 /* Call the verification method, to make sure that the target
1732 class implements the desired method. */
1734 argvec
[0] = msg_send
;
1736 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1737 argvec
[3] = value_from_longest (long_type
, selector
);
1740 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1743 /* Function objc_msg_lookup returns a pointer. */
1745 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1747 if (value_as_long (ret
) == 0)
1748 error (_("Target does not respond to this message selector."));
1750 /* Call "methodForSelector:" method, to get the address of a
1751 function method that implements this selector for this
1752 class. If we can find a symbol at that address, then we
1753 know the return type, parameter types etc. (that's a good
1756 argvec
[0] = msg_send
;
1758 argvec
[2] = value_from_longest (long_type
, method_selector
);
1759 argvec
[3] = value_from_longest (long_type
, selector
);
1762 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1766 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1769 /* ret should now be the selector. */
1771 addr
= value_as_long (ret
);
1774 struct symbol
*sym
= NULL
;
1776 /* The address might point to a function descriptor;
1777 resolve it to the actual code address instead. */
1778 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1779 current_top_target ());
1781 /* Is it a high_level symbol? */
1782 sym
= find_pc_function (addr
);
1784 method
= value_of_variable (sym
, 0);
1787 /* If we found a method with symbol information, check to see
1788 if it returns a struct. Otherwise assume it doesn't. */
1793 struct type
*val_type
;
1795 funaddr
= find_function_addr (method
, &val_type
);
1797 block_for_pc (funaddr
);
1799 val_type
= check_typedef (val_type
);
1801 if ((val_type
== NULL
)
1802 || (val_type
->code () == TYPE_CODE_ERROR
))
1804 if (expect_type
!= NULL
)
1805 val_type
= expect_type
;
1808 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1811 else if (expect_type
!= NULL
)
1813 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1814 check_typedef (expect_type
));
1817 /* Found a function symbol. Now we will substitute its
1818 value in place of the message dispatcher (obj_msgSend),
1819 so that we call the method directly instead of thru
1820 the dispatcher. The main reason for doing this is that
1821 we can now evaluate the return value and parameter values
1822 according to their known data types, in case we need to
1823 do things like promotion, dereferencing, special handling
1824 of structs and doubles, etc.
1826 We want to use the type signature of 'method', but still
1827 jump to objc_msgSend() or objc_msgSend_stret() to better
1828 mimic the behavior of the runtime. */
1832 if (value_type (method
)->code () != TYPE_CODE_FUNC
)
1833 error (_("method address has symbol information "
1834 "with non-function type; skipping"));
1836 /* Create a function pointer of the appropriate type, and
1837 replace its value with the value of msg_send or
1838 msg_send_stret. We must use a pointer here, as
1839 msg_send and msg_send_stret are of pointer type, and
1840 the representation may be different on systems that use
1841 function descriptors. */
1844 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1845 value_as_address (msg_send_stret
));
1848 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1849 value_as_address (msg_send
));
1854 called_method
= msg_send_stret
;
1856 called_method
= msg_send
;
1859 if (noside
== EVAL_SKIP
)
1860 return eval_skip_value (exp
);
1862 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1864 /* If the return type doesn't look like a function type,
1865 call an error. This can happen if somebody tries to
1866 turn a variable into a function call. This is here
1867 because people often want to call, eg, strcmp, which
1868 gdb doesn't know is a function. If gdb isn't asked for
1869 it's opinion (ie. through "whatis"), it won't offer
1872 struct type
*callee_type
= value_type (called_method
);
1874 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
1875 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1876 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1880 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
1881 return allocate_value (expect_type
);
1883 return allocate_value (callee_type
);
1886 error (_("Expression of type other than "
1887 "\"method returning ...\" used as a method"));
1890 /* Now depending on whether we found a symbol for the method,
1891 we will either call the runtime dispatcher or the method
1894 argvec
[0] = called_method
;
1896 argvec
[2] = value_from_longest (long_type
, selector
);
1897 /* User-supplied arguments. */
1898 for (tem
= 0; tem
< nargs
; tem
++)
1899 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1900 argvec
[tem
+ 3] = 0;
1902 auto call_args
= gdb::make_array_view (argvec
+ 1, nargs
+ 2);
1904 if (gnu_runtime
&& (method
!= NULL
))
1906 /* Function objc_msg_lookup returns a pointer. */
1907 deprecated_set_value_type (argvec
[0],
1908 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1909 argvec
[0] = call_function_by_hand (argvec
[0], NULL
, call_args
);
1912 return call_function_by_hand (argvec
[0], NULL
, call_args
);
1917 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1919 case OP_F77_UNDETERMINED_ARGLIST
:
1921 /* Remember that in F77, functions, substring ops and
1922 array subscript operations cannot be disambiguated
1923 at parse time. We have made all array subscript operations,
1924 substring operations as well as function calls come here
1925 and we now have to discover what the heck this thing actually was.
1926 If it is a function, we process just as if we got an OP_FUNCALL. */
1928 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1931 /* First determine the type code we are dealing with. */
1932 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1933 type
= check_typedef (value_type (arg1
));
1934 code
= type
->code ();
1936 if (code
== TYPE_CODE_PTR
)
1938 /* Fortran always passes variable to subroutines as pointer.
1939 So we need to look into its target type to see if it is
1940 array, string or function. If it is, we need to switch
1941 to the target value the original one points to. */
1942 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1944 if (target_type
->code () == TYPE_CODE_ARRAY
1945 || target_type
->code () == TYPE_CODE_STRING
1946 || target_type
->code () == TYPE_CODE_FUNC
)
1948 arg1
= value_ind (arg1
);
1949 type
= check_typedef (value_type (arg1
));
1950 code
= type
->code ();
1956 case TYPE_CODE_ARRAY
:
1957 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1958 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1961 if (noside
== EVAL_SKIP
)
1963 skip_undetermined_arglist (nargs
, exp
, pos
, noside
);
1964 /* Return the dummy value with the correct type. */
1967 goto multi_f77_subscript
;
1970 case TYPE_CODE_STRING
:
1971 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1972 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1975 if (noside
== EVAL_SKIP
)
1977 skip_undetermined_arglist (nargs
, exp
, pos
, noside
);
1978 /* Return the dummy value with the correct type. */
1981 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1982 return value_subscript (arg1
, value_as_long (arg2
));
1986 case TYPE_CODE_FUNC
:
1987 case TYPE_CODE_INTERNAL_FUNCTION
:
1988 /* It's a function call. */
1989 /* Allocate arg vector, including space for the function to be
1990 called in argvec[0] and a terminating NULL. */
1991 argvec
= (struct value
**)
1992 alloca (sizeof (struct value
*) * (nargs
+ 2));
1995 for (; tem
<= nargs
; tem
++)
1997 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1998 /* Arguments in Fortran are passed by address. Coerce the
1999 arguments here rather than in value_arg_coerce as otherwise
2000 the call to malloc to place the non-lvalue parameters in
2001 target memory is hit by this Fortran specific logic. This
2002 results in malloc being called with a pointer to an integer
2003 followed by an attempt to malloc the arguments to malloc in
2004 target memory. Infinite recursion ensues. */
2005 if (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
)
2008 = TYPE_FIELD_ARTIFICIAL (value_type (arg1
), tem
- 1);
2009 argvec
[tem
] = fortran_argument_convert (argvec
[tem
],
2013 argvec
[tem
] = 0; /* signal end of arglist */
2014 if (noside
== EVAL_SKIP
)
2015 return eval_skip_value (exp
);
2016 return eval_call (exp
, noside
, nargs
, argvec
, NULL
, expect_type
);
2019 error (_("Cannot perform substring on this type"));
2023 /* We have a complex number, There should be 2 floating
2024 point numbers that compose it. */
2026 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2027 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2029 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
2031 case STRUCTOP_STRUCT
:
2032 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2033 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2034 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2035 if (noside
== EVAL_SKIP
)
2036 return eval_skip_value (exp
);
2037 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2039 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2040 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2044 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2045 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2046 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2047 if (noside
== EVAL_SKIP
)
2048 return eval_skip_value (exp
);
2050 /* Check to see if operator '->' has been overloaded. If so replace
2051 arg1 with the value returned by evaluating operator->(). */
2052 while (unop_user_defined_p (op
, arg1
))
2054 struct value
*value
= NULL
;
2057 value
= value_x_unop (arg1
, op
, noside
);
2060 catch (const gdb_exception_error
&except
)
2062 if (except
.error
== NOT_FOUND_ERROR
)
2071 /* JYG: if print object is on we need to replace the base type
2072 with rtti type in order to continue on with successful
2073 lookup of member / method only available in the rtti type. */
2075 struct type
*arg_type
= value_type (arg1
);
2076 struct type
*real_type
;
2077 int full
, using_enc
;
2079 struct value_print_options opts
;
2081 get_user_print_options (&opts
);
2082 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
2083 && (TYPE_TARGET_TYPE (arg_type
)->code () == TYPE_CODE_STRUCT
))
2085 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
2088 arg1
= value_cast (real_type
, arg1
);
2092 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2093 NULL
, "structure pointer");
2094 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2095 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2098 case STRUCTOP_MEMBER
:
2100 if (op
== STRUCTOP_MEMBER
)
2101 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2103 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2105 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2107 if (noside
== EVAL_SKIP
)
2108 return eval_skip_value (exp
);
2110 type
= check_typedef (value_type (arg2
));
2111 switch (type
->code ())
2113 case TYPE_CODE_METHODPTR
:
2114 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2115 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2118 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2119 gdb_assert (value_type (arg2
)->code () == TYPE_CODE_PTR
);
2120 return value_ind (arg2
);
2123 case TYPE_CODE_MEMBERPTR
:
2124 /* Now, convert these values to an address. */
2125 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
2128 mem_offset
= value_as_long (arg2
);
2130 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2131 value_as_long (arg1
) + mem_offset
);
2132 return value_ind (arg3
);
2135 error (_("non-pointer-to-member value used "
2136 "in pointer-to-member construct"));
2141 type_instance_flags flags
2142 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2143 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2144 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2145 for (ix
= 0; ix
< nargs
; ++ix
)
2146 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2148 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
2149 *(pos
) += 4 + nargs
;
2150 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
2155 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2156 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2157 if (noside
== EVAL_SKIP
)
2158 return eval_skip_value (exp
);
2159 if (binop_user_defined_p (op
, arg1
, arg2
))
2160 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2162 return value_concat (arg1
, arg2
);
2165 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2166 /* Special-case assignments where the left-hand-side is a
2167 convenience variable -- in these, don't bother setting an
2168 expected type. This avoids a weird case where re-assigning a
2169 string or array to an internal variable could error with "Too
2170 many array elements". */
2171 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
2172 ? NULL_TYPE
: value_type (arg1
),
2175 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2177 if (binop_user_defined_p (op
, arg1
, arg2
))
2178 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2180 return value_assign (arg1
, arg2
);
2182 case BINOP_ASSIGN_MODIFY
:
2184 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2185 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2186 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2188 op
= exp
->elts
[pc
+ 1].opcode
;
2189 if (binop_user_defined_p (op
, arg1
, arg2
))
2190 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2191 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2193 && is_integral_type (value_type (arg2
)))
2194 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2195 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2197 && is_integral_type (value_type (arg2
)))
2198 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2201 struct value
*tmp
= arg1
;
2203 /* For shift and integer exponentiation operations,
2204 only promote the first argument. */
2205 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2206 && is_integral_type (value_type (arg2
)))
2207 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2209 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2211 arg2
= value_binop (tmp
, arg2
, op
);
2213 return value_assign (arg1
, arg2
);
2216 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2217 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2218 if (noside
== EVAL_SKIP
)
2219 return eval_skip_value (exp
);
2220 if (binop_user_defined_p (op
, arg1
, arg2
))
2221 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2222 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2223 && is_integral_or_integral_reference (value_type (arg2
)))
2224 return value_ptradd (arg1
, value_as_long (arg2
));
2225 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2226 && is_integral_or_integral_reference (value_type (arg1
)))
2227 return value_ptradd (arg2
, value_as_long (arg1
));
2230 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2231 return value_binop (arg1
, arg2
, BINOP_ADD
);
2235 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2236 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2237 if (noside
== EVAL_SKIP
)
2238 return eval_skip_value (exp
);
2239 if (binop_user_defined_p (op
, arg1
, arg2
))
2240 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2241 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2242 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2244 /* FIXME -- should be ptrdiff_t */
2245 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2246 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2248 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2249 && is_integral_or_integral_reference (value_type (arg2
)))
2250 return value_ptradd (arg1
, - value_as_long (arg2
));
2253 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2254 return value_binop (arg1
, arg2
, BINOP_SUB
);
2265 case BINOP_BITWISE_AND
:
2266 case BINOP_BITWISE_IOR
:
2267 case BINOP_BITWISE_XOR
:
2268 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2269 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2270 if (noside
== EVAL_SKIP
)
2271 return eval_skip_value (exp
);
2272 if (binop_user_defined_p (op
, arg1
, arg2
))
2273 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2276 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2277 fudge arg2 to avoid division-by-zero, the caller is
2278 (theoretically) only looking for the type of the result. */
2279 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2280 /* ??? Do we really want to test for BINOP_MOD here?
2281 The implementation of value_binop gives it a well-defined
2284 || op
== BINOP_INTDIV
2287 && value_logical_not (arg2
))
2289 struct value
*v_one
, *retval
;
2291 v_one
= value_one (value_type (arg2
));
2292 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2293 retval
= value_binop (arg1
, v_one
, op
);
2298 /* For shift and integer exponentiation operations,
2299 only promote the first argument. */
2300 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2301 && is_integral_type (value_type (arg2
)))
2302 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2304 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2306 return value_binop (arg1
, arg2
, op
);
2310 case BINOP_SUBSCRIPT
:
2311 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2312 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2313 if (noside
== EVAL_SKIP
)
2314 return eval_skip_value (exp
);
2315 if (binop_user_defined_p (op
, arg1
, arg2
))
2316 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2319 /* If the user attempts to subscript something that is not an
2320 array or pointer type (like a plain int variable for example),
2321 then report this as an error. */
2323 arg1
= coerce_ref (arg1
);
2324 type
= check_typedef (value_type (arg1
));
2325 if (type
->code () != TYPE_CODE_ARRAY
2326 && type
->code () != TYPE_CODE_PTR
)
2329 error (_("cannot subscript something of type `%s'"),
2332 error (_("cannot subscript requested type"));
2335 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2336 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2338 return value_subscript (arg1
, value_as_long (arg2
));
2340 case MULTI_SUBSCRIPT
:
2342 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2343 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2346 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2347 /* FIXME: EVAL_SKIP handling may not be correct. */
2348 if (noside
== EVAL_SKIP
)
2352 return eval_skip_value (exp
);
2354 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2355 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2357 /* If the user attempts to subscript something that has no target
2358 type (like a plain int variable for example), then report this
2361 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2364 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2370 error (_("cannot subscript something of type `%s'"),
2371 value_type (arg1
)->name ());
2375 if (binop_user_defined_p (op
, arg1
, arg2
))
2377 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2381 arg1
= coerce_ref (arg1
);
2382 type
= check_typedef (value_type (arg1
));
2384 switch (type
->code ())
2387 case TYPE_CODE_ARRAY
:
2388 case TYPE_CODE_STRING
:
2389 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2394 error (_("cannot subscript something of type `%s'"),
2397 error (_("cannot subscript requested type"));
2403 multi_f77_subscript
:
2405 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2406 int ndimensions
= 1, i
;
2407 struct value
*array
= arg1
;
2409 if (nargs
> MAX_FORTRAN_DIMS
)
2410 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2412 ndimensions
= calc_f77_array_dims (type
);
2414 if (nargs
!= ndimensions
)
2415 error (_("Wrong number of subscripts"));
2417 gdb_assert (nargs
> 0);
2419 /* Now that we know we have a legal array subscript expression
2420 let us actually find out where this element exists in the array. */
2422 /* Take array indices left to right. */
2423 for (i
= 0; i
< nargs
; i
++)
2425 /* Evaluate each subscript; it must be a legal integer in F77. */
2426 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2428 /* Fill in the subscript array. */
2430 subscript_array
[i
] = value_as_long (arg2
);
2433 /* Internal type of array is arranged right to left. */
2434 for (i
= nargs
; i
> 0; i
--)
2436 struct type
*array_type
= check_typedef (value_type (array
));
2437 LONGEST index
= subscript_array
[i
- 1];
2439 array
= value_subscripted_rvalue (array
, index
,
2440 f77_get_lowerbound (array_type
));
2446 case BINOP_LOGICAL_AND
:
2447 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2448 if (noside
== EVAL_SKIP
)
2450 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2451 return eval_skip_value (exp
);
2455 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2458 if (binop_user_defined_p (op
, arg1
, arg2
))
2460 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2461 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2465 tem
= value_logical_not (arg1
);
2466 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2467 (tem
? EVAL_SKIP
: noside
));
2468 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2469 return value_from_longest (type
,
2470 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2473 case BINOP_LOGICAL_OR
:
2474 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2475 if (noside
== EVAL_SKIP
)
2477 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2478 return eval_skip_value (exp
);
2482 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2485 if (binop_user_defined_p (op
, arg1
, arg2
))
2487 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2488 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2492 tem
= value_logical_not (arg1
);
2493 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2494 (!tem
? EVAL_SKIP
: noside
));
2495 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2496 return value_from_longest (type
,
2497 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2501 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2502 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2503 if (noside
== EVAL_SKIP
)
2504 return eval_skip_value (exp
);
2505 if (binop_user_defined_p (op
, arg1
, arg2
))
2507 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2511 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2512 tem
= value_equal (arg1
, arg2
);
2513 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2514 return value_from_longest (type
, (LONGEST
) tem
);
2517 case BINOP_NOTEQUAL
:
2518 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2519 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2520 if (noside
== EVAL_SKIP
)
2521 return eval_skip_value (exp
);
2522 if (binop_user_defined_p (op
, arg1
, arg2
))
2524 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2528 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2529 tem
= value_equal (arg1
, arg2
);
2530 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2531 return value_from_longest (type
, (LONGEST
) ! tem
);
2535 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2536 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2537 if (noside
== EVAL_SKIP
)
2538 return eval_skip_value (exp
);
2539 if (binop_user_defined_p (op
, arg1
, arg2
))
2541 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2545 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2546 tem
= value_less (arg1
, arg2
);
2547 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2548 return value_from_longest (type
, (LONGEST
) tem
);
2552 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2553 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2554 if (noside
== EVAL_SKIP
)
2555 return eval_skip_value (exp
);
2556 if (binop_user_defined_p (op
, arg1
, arg2
))
2558 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2562 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2563 tem
= value_less (arg2
, arg1
);
2564 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2565 return value_from_longest (type
, (LONGEST
) tem
);
2569 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2570 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2571 if (noside
== EVAL_SKIP
)
2572 return eval_skip_value (exp
);
2573 if (binop_user_defined_p (op
, arg1
, arg2
))
2575 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2579 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2580 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2581 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2582 return value_from_longest (type
, (LONGEST
) tem
);
2586 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2587 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2588 if (noside
== EVAL_SKIP
)
2589 return eval_skip_value (exp
);
2590 if (binop_user_defined_p (op
, arg1
, arg2
))
2592 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2596 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2597 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2598 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2599 return value_from_longest (type
, (LONGEST
) tem
);
2603 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2604 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2605 if (noside
== EVAL_SKIP
)
2606 return eval_skip_value (exp
);
2607 type
= check_typedef (value_type (arg2
));
2608 if (type
->code () != TYPE_CODE_INT
2609 && type
->code () != TYPE_CODE_ENUM
)
2610 error (_("Non-integral right operand for \"@\" operator."));
2611 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2613 return allocate_repeat_value (value_type (arg1
),
2614 longest_to_int (value_as_long (arg2
)));
2617 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2620 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2621 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2624 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2625 if (noside
== EVAL_SKIP
)
2626 return eval_skip_value (exp
);
2627 if (unop_user_defined_p (op
, arg1
))
2628 return value_x_unop (arg1
, op
, noside
);
2631 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2632 return value_pos (arg1
);
2636 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2637 if (noside
== EVAL_SKIP
)
2638 return eval_skip_value (exp
);
2639 if (unop_user_defined_p (op
, arg1
))
2640 return value_x_unop (arg1
, op
, noside
);
2643 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2644 return value_neg (arg1
);
2647 case UNOP_COMPLEMENT
:
2648 /* C++: check for and handle destructor names. */
2650 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2651 if (noside
== EVAL_SKIP
)
2652 return eval_skip_value (exp
);
2653 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2654 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2657 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2658 return value_complement (arg1
);
2661 case UNOP_LOGICAL_NOT
:
2662 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2663 if (noside
== EVAL_SKIP
)
2664 return eval_skip_value (exp
);
2665 if (unop_user_defined_p (op
, arg1
))
2666 return value_x_unop (arg1
, op
, noside
);
2669 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2670 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2674 if (expect_type
&& expect_type
->code () == TYPE_CODE_PTR
)
2675 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2676 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2677 type
= check_typedef (value_type (arg1
));
2678 if (type
->code () == TYPE_CODE_METHODPTR
2679 || type
->code () == TYPE_CODE_MEMBERPTR
)
2680 error (_("Attempt to dereference pointer "
2681 "to member without an object"));
2682 if (noside
== EVAL_SKIP
)
2683 return eval_skip_value (exp
);
2684 if (unop_user_defined_p (op
, arg1
))
2685 return value_x_unop (arg1
, op
, noside
);
2686 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2688 type
= check_typedef (value_type (arg1
));
2689 if (type
->code () == TYPE_CODE_PTR
2690 || TYPE_IS_REFERENCE (type
)
2691 /* In C you can dereference an array to get the 1st elt. */
2692 || type
->code () == TYPE_CODE_ARRAY
2694 return value_zero (TYPE_TARGET_TYPE (type
),
2696 else if (type
->code () == TYPE_CODE_INT
)
2697 /* GDB allows dereferencing an int. */
2698 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2701 error (_("Attempt to take contents of a non-pointer value."));
2704 /* Allow * on an integer so we can cast it to whatever we want.
2705 This returns an int, which seems like the most C-like thing to
2706 do. "long long" variables are rare enough that
2707 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2708 if (type
->code () == TYPE_CODE_INT
)
2709 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2710 (CORE_ADDR
) value_as_address (arg1
));
2711 return value_ind (arg1
);
2714 /* C++: check for and handle pointer to members. */
2716 if (noside
== EVAL_SKIP
)
2718 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2719 return eval_skip_value (exp
);
2723 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2730 if (noside
== EVAL_SKIP
)
2732 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2733 return eval_skip_value (exp
);
2735 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2739 type
= value_type (evaluate_subexp (NULL_TYPE
, exp
, pos
,
2740 EVAL_AVOID_SIDE_EFFECTS
));
2741 /* FIXME: This should be size_t. */
2742 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2743 ULONGEST align
= type_align (type
);
2745 error (_("could not determine alignment of type"));
2746 return value_from_longest (size_type
, align
);
2751 type
= exp
->elts
[pc
+ 1].type
;
2752 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2754 case UNOP_CAST_TYPE
:
2755 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2756 type
= value_type (arg1
);
2757 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2759 case UNOP_DYNAMIC_CAST
:
2760 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2761 type
= value_type (arg1
);
2762 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2763 if (noside
== EVAL_SKIP
)
2764 return eval_skip_value (exp
);
2765 return value_dynamic_cast (type
, arg1
);
2767 case UNOP_REINTERPRET_CAST
:
2768 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2769 type
= value_type (arg1
);
2770 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2771 if (noside
== EVAL_SKIP
)
2772 return eval_skip_value (exp
);
2773 return value_reinterpret_cast (type
, arg1
);
2777 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2778 if (noside
== EVAL_SKIP
)
2779 return eval_skip_value (exp
);
2780 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2781 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2783 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2784 value_as_address (arg1
));
2786 case UNOP_MEMVAL_TYPE
:
2787 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2788 type
= value_type (arg1
);
2789 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2790 if (noside
== EVAL_SKIP
)
2791 return eval_skip_value (exp
);
2792 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2793 return value_zero (type
, lval_memory
);
2795 return value_at_lazy (type
, value_as_address (arg1
));
2797 case UNOP_PREINCREMENT
:
2798 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2799 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2801 else if (unop_user_defined_p (op
, arg1
))
2803 return value_x_unop (arg1
, op
, noside
);
2807 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2808 arg2
= value_ptradd (arg1
, 1);
2811 struct value
*tmp
= arg1
;
2813 arg2
= value_one (value_type (arg1
));
2814 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2815 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2818 return value_assign (arg1
, arg2
);
2821 case UNOP_PREDECREMENT
:
2822 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2823 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2825 else if (unop_user_defined_p (op
, arg1
))
2827 return value_x_unop (arg1
, op
, noside
);
2831 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2832 arg2
= value_ptradd (arg1
, -1);
2835 struct value
*tmp
= arg1
;
2837 arg2
= value_one (value_type (arg1
));
2838 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2839 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2842 return value_assign (arg1
, arg2
);
2845 case UNOP_POSTINCREMENT
:
2846 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2847 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2849 else if (unop_user_defined_p (op
, arg1
))
2851 return value_x_unop (arg1
, op
, noside
);
2855 arg3
= value_non_lval (arg1
);
2857 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2858 arg2
= value_ptradd (arg1
, 1);
2861 struct value
*tmp
= arg1
;
2863 arg2
= value_one (value_type (arg1
));
2864 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2865 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2868 value_assign (arg1
, arg2
);
2872 case UNOP_POSTDECREMENT
:
2873 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2874 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2876 else if (unop_user_defined_p (op
, arg1
))
2878 return value_x_unop (arg1
, op
, noside
);
2882 arg3
= value_non_lval (arg1
);
2884 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2885 arg2
= value_ptradd (arg1
, -1);
2888 struct value
*tmp
= arg1
;
2890 arg2
= value_one (value_type (arg1
));
2891 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2892 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2895 value_assign (arg1
, arg2
);
2901 return value_of_this (exp
->language_defn
);
2904 /* The value is not supposed to be used. This is here to make it
2905 easier to accommodate expressions that contain types. */
2907 if (noside
== EVAL_SKIP
)
2908 return eval_skip_value (exp
);
2909 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2910 return allocate_value (exp
->elts
[pc
+ 1].type
);
2912 error (_("Attempt to use a type name as an expression"));
2916 if (noside
== EVAL_SKIP
)
2918 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2919 return eval_skip_value (exp
);
2921 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2923 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2924 struct value
*result
;
2926 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2927 EVAL_AVOID_SIDE_EFFECTS
);
2929 /* 'decltype' has special semantics for lvalues. */
2930 if (op
== OP_DECLTYPE
2931 && (sub_op
== BINOP_SUBSCRIPT
2932 || sub_op
== STRUCTOP_MEMBER
2933 || sub_op
== STRUCTOP_MPTR
2934 || sub_op
== UNOP_IND
2935 || sub_op
== STRUCTOP_STRUCT
2936 || sub_op
== STRUCTOP_PTR
2937 || sub_op
== OP_SCOPE
))
2939 type
= value_type (result
);
2941 if (!TYPE_IS_REFERENCE (type
))
2943 type
= lookup_lvalue_reference_type (type
);
2944 result
= allocate_value (type
);
2951 error (_("Attempt to use a type as an expression"));
2955 struct value
*result
;
2956 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2958 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2959 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2960 EVAL_AVOID_SIDE_EFFECTS
);
2962 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2964 if (noside
!= EVAL_NORMAL
)
2965 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2967 return cplus_typeid (result
);
2971 /* Removing this case and compiling with gcc -Wall reveals that
2972 a lot of cases are hitting this case. Some of these should
2973 probably be removed from expression.h; others are legitimate
2974 expressions which are (apparently) not fully implemented.
2976 If there are any cases landing here which mean a user error,
2977 then they should be separate cases, with more descriptive
2980 error (_("GDB does not (yet) know how to "
2981 "evaluate that kind of expression"));
2984 gdb_assert_not_reached ("missed return?");
2987 /* Evaluate a subexpression of EXP, at index *POS,
2988 and return the address of that subexpression.
2989 Advance *POS over the subexpression.
2990 If the subexpression isn't an lvalue, get an error.
2991 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2992 then only the type of the result need be correct. */
2994 static struct value
*
2995 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
3005 op
= exp
->elts
[pc
].opcode
;
3011 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3013 /* We can't optimize out "&*" if there's a user-defined operator*. */
3014 if (unop_user_defined_p (op
, x
))
3016 x
= value_x_unop (x
, op
, noside
);
3017 goto default_case_after_eval
;
3020 return coerce_array (x
);
3024 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
3025 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
3027 case UNOP_MEMVAL_TYPE
:
3032 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3033 type
= value_type (x
);
3034 return value_cast (lookup_pointer_type (type
),
3035 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
3039 var
= exp
->elts
[pc
+ 2].symbol
;
3041 /* C++: The "address" of a reference should yield the address
3042 * of the object pointed to. Let value_addr() deal with it. */
3043 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
3047 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3050 lookup_pointer_type (SYMBOL_TYPE (var
));
3051 enum address_class sym_class
= SYMBOL_CLASS (var
);
3053 if (sym_class
== LOC_CONST
3054 || sym_class
== LOC_CONST_BYTES
3055 || sym_class
== LOC_REGISTER
)
3056 error (_("Attempt to take address of register or constant."));
3059 value_zero (type
, not_lval
);
3062 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3064 case OP_VAR_MSYM_VALUE
:
3068 value
*val
= evaluate_var_msym_value (noside
,
3069 exp
->elts
[pc
+ 1].objfile
,
3070 exp
->elts
[pc
+ 2].msymbol
);
3071 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3073 struct type
*type
= lookup_pointer_type (value_type (val
));
3074 return value_zero (type
, not_lval
);
3077 return value_addr (val
);
3081 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3082 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3083 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3084 &exp
->elts
[pc
+ 3].string
,
3087 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3092 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3093 default_case_after_eval
:
3094 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3096 struct type
*type
= check_typedef (value_type (x
));
3098 if (TYPE_IS_REFERENCE (type
))
3099 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3101 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3102 return value_zero (lookup_pointer_type (value_type (x
)),
3105 error (_("Attempt to take address of "
3106 "value not located in memory."));
3108 return value_addr (x
);
3112 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3113 When used in contexts where arrays will be coerced anyway, this is
3114 equivalent to `evaluate_subexp' but much faster because it avoids
3115 actually fetching array contents (perhaps obsolete now that we have
3118 Note that we currently only do the coercion for C expressions, where
3119 arrays are zero based and the coercion is correct. For other languages,
3120 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3121 to decide if coercion is appropriate. */
3124 evaluate_subexp_with_coercion (struct expression
*exp
,
3125 int *pos
, enum noside noside
)
3134 op
= exp
->elts
[pc
].opcode
;
3139 var
= exp
->elts
[pc
+ 2].symbol
;
3140 type
= check_typedef (SYMBOL_TYPE (var
));
3141 if (type
->code () == TYPE_CODE_ARRAY
3142 && !TYPE_VECTOR (type
)
3143 && CAST_IS_CONVERSION (exp
->language_defn
))
3146 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3147 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3153 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3157 /* Evaluate a subexpression of EXP, at index *POS,
3158 and return a value for the size of that subexpression.
3159 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3160 we allow side-effects on the operand if its type is a variable
3163 static struct value
*
3164 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3167 /* FIXME: This should be size_t. */
3168 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3175 op
= exp
->elts
[pc
].opcode
;
3179 /* This case is handled specially
3180 so that we avoid creating a value for the result type.
3181 If the result type is very big, it's desirable not to
3182 create a value unnecessarily. */
3185 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3186 type
= check_typedef (value_type (val
));
3187 if (type
->code () != TYPE_CODE_PTR
3188 && !TYPE_IS_REFERENCE (type
)
3189 && type
->code () != TYPE_CODE_ARRAY
)
3190 error (_("Attempt to take contents of a non-pointer value."));
3191 type
= TYPE_TARGET_TYPE (type
);
3192 if (is_dynamic_type (type
))
3193 type
= value_type (value_ind (val
));
3194 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3198 type
= exp
->elts
[pc
+ 1].type
;
3201 case UNOP_MEMVAL_TYPE
:
3203 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3204 type
= value_type (val
);
3208 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3209 if (is_dynamic_type (type
))
3211 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3212 type
= value_type (val
);
3213 if (type
->code () == TYPE_CODE_ARRAY
3214 && is_dynamic_type (type
->index_type ())
3215 && TYPE_HIGH_BOUND_UNDEFINED (type
->index_type ()))
3216 return allocate_optimized_out_value (size_type
);
3222 case OP_VAR_MSYM_VALUE
:
3226 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3227 value
*mval
= evaluate_var_msym_value (noside
,
3228 exp
->elts
[pc
+ 1].objfile
,
3231 type
= value_type (mval
);
3232 if (type
->code () == TYPE_CODE_ERROR
)
3233 error_unknown_type (msymbol
->print_name ());
3235 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3239 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3240 type of the subscript is a variable length array type. In this case we
3241 must re-evaluate the right hand side of the subscription to allow
3243 case BINOP_SUBSCRIPT
:
3244 if (noside
== EVAL_NORMAL
)
3246 int npc
= (*pos
) + 1;
3248 val
= evaluate_subexp (NULL_TYPE
, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3249 type
= check_typedef (value_type (val
));
3250 if (type
->code () == TYPE_CODE_ARRAY
)
3252 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3253 if (type
->code () == TYPE_CODE_ARRAY
)
3255 type
= type
->index_type ();
3256 /* Only re-evaluate the right hand side if the resulting type
3257 is a variable length type. */
3258 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3260 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3261 return value_from_longest
3262 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3271 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3272 type
= value_type (val
);
3276 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3277 "When applied to a reference or a reference type, the result is
3278 the size of the referenced type." */
3279 type
= check_typedef (type
);
3280 if (exp
->language_defn
->la_language
== language_cplus
3281 && (TYPE_IS_REFERENCE (type
)))
3282 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3283 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3286 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3287 for that subexpression cast to TO_TYPE. Advance *POS over the
3291 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3293 struct type
*to_type
)
3297 /* Don't let symbols be evaluated with evaluate_subexp because that
3298 throws an "unknown type" error for no-debug data symbols.
3299 Instead, we want the cast to reinterpret the symbol. */
3300 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3301 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3306 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3308 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3309 return value_zero (to_type
, not_lval
);
3311 val
= evaluate_var_msym_value (noside
,
3312 exp
->elts
[pc
+ 1].objfile
,
3313 exp
->elts
[pc
+ 2].msymbol
);
3316 val
= evaluate_var_value (noside
,
3317 exp
->elts
[pc
+ 1].block
,
3318 exp
->elts
[pc
+ 2].symbol
);
3320 if (noside
== EVAL_SKIP
)
3321 return eval_skip_value (exp
);
3323 val
= value_cast (to_type
, val
);
3325 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3326 if (VALUE_LVAL (val
) == lval_memory
)
3328 if (value_lazy (val
))
3329 value_fetch_lazy (val
);
3330 VALUE_LVAL (val
) = not_lval
;
3335 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3336 if (noside
== EVAL_SKIP
)
3337 return eval_skip_value (exp
);
3338 return value_cast (to_type
, val
);
3341 /* Parse a type expression in the string [P..P+LENGTH). */
3344 parse_and_eval_type (char *p
, int length
)
3346 char *tmp
= (char *) alloca (length
+ 4);
3349 memcpy (tmp
+ 1, p
, length
);
3350 tmp
[length
+ 1] = ')';
3351 tmp
[length
+ 2] = '0';
3352 tmp
[length
+ 3] = '\0';
3353 expression_up expr
= parse_expression (tmp
);
3354 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3355 error (_("Internal error in eval_type."));
3356 return expr
->elts
[1].type
;
3360 calc_f77_array_dims (struct type
*array_type
)
3363 struct type
*tmp_type
;
3365 if ((array_type
->code () != TYPE_CODE_ARRAY
))
3366 error (_("Can't get dimensions for a non-array type"));
3368 tmp_type
= array_type
;
3370 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3372 if (tmp_type
->code () == TYPE_CODE_ARRAY
)