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
< TYPE_NFIELDS (struct_type
)
299 && field_is_static (&TYPE_FIELD (struct_type
,
302 if (fieldno
>= TYPE_NFIELDS (struct_type
))
303 error (_("too many initializers"));
304 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
305 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
306 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
307 error (_("don't know which variant you want to set"));
309 /* Here, struct_type is the type of the inner struct,
310 while substruct_type is the type of the inner struct.
311 These are the same for normal structures, but a variant struct
312 contains anonymous union fields that contain substruct fields.
313 The value fieldno is the index of the top-level (normal or
314 anonymous union) field in struct_field, while the value
315 subfieldno is the index of the actual real (named inner) field
316 in substruct_type. */
318 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
320 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
322 /* Now actually set the field in struct_val. */
324 /* Assign val to field fieldno. */
325 if (value_type (val
) != field_type
)
326 val
= value_cast (field_type
, val
);
328 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
329 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
330 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
332 modify_field (struct_type
, addr
,
333 value_as_long (val
), bitpos
% 8, bitsize
);
335 memcpy (addr
, value_contents (val
),
336 TYPE_LENGTH (value_type (val
)));
342 /* Recursive helper function for setting elements of array tuples.
343 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
344 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
345 Evaluates index expressions and sets the specified element(s) of
346 ARRAY to ELEMENT. Returns last index value. */
349 init_array_element (struct value
*array
, struct value
*element
,
350 struct expression
*exp
, int *pos
,
351 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
354 int element_size
= TYPE_LENGTH (value_type (element
));
356 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
359 init_array_element (array
, element
, exp
, pos
, noside
,
360 low_bound
, high_bound
);
361 return init_array_element (array
, element
,
362 exp
, pos
, noside
, low_bound
, high_bound
);
366 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
367 if (index
< low_bound
|| index
> high_bound
)
368 error (_("tuple index out of range"));
369 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
370 value_contents (element
), element_size
);
375 static struct value
*
376 value_f90_subarray (struct value
*array
,
377 struct expression
*exp
, int *pos
, enum noside noside
)
380 LONGEST low_bound
, high_bound
;
381 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
382 enum range_type range_type
383 = (enum range_type
) longest_to_int (exp
->elts
[pc
].longconst
);
387 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
388 low_bound
= TYPE_LOW_BOUND (range
);
390 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
392 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
393 high_bound
= TYPE_HIGH_BOUND (range
);
395 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
397 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
401 /* Promote value ARG1 as appropriate before performing a unary operation
403 If the result is not appropriate for any particular language then it
404 needs to patch this function. */
407 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
412 *arg1
= coerce_ref (*arg1
);
413 type1
= check_typedef (value_type (*arg1
));
415 if (is_integral_type (type1
))
417 switch (language
->la_language
)
420 /* Perform integral promotion for ANSI C/C++.
421 If not appropriate for any particular language
422 it needs to modify this function. */
424 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
426 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
427 *arg1
= value_cast (builtin_int
, *arg1
);
434 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
435 operation on those two operands.
436 If the result is not appropriate for any particular language then it
437 needs to patch this function. */
440 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
441 struct value
**arg1
, struct value
**arg2
)
443 struct type
*promoted_type
= NULL
;
447 *arg1
= coerce_ref (*arg1
);
448 *arg2
= coerce_ref (*arg2
);
450 type1
= check_typedef (value_type (*arg1
));
451 type2
= check_typedef (value_type (*arg2
));
453 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
454 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
455 && !is_integral_type (type1
))
456 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
457 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
458 && !is_integral_type (type2
)))
461 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
462 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
464 /* No promotion required. */
466 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
467 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
469 switch (language
->la_language
)
475 case language_opencl
:
476 /* No promotion required. */
480 /* For other languages the result type is unchanged from gdb
481 version 6.7 for backward compatibility.
482 If either arg was long double, make sure that value is also long
483 double. Otherwise use double. */
484 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
485 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
486 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
488 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
492 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
493 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
495 /* No promotion required. */
498 /* Integral operations here. */
499 /* FIXME: Also mixed integral/booleans, with result an integer. */
501 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
502 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
503 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
504 int is_unsigned1
= TYPE_UNSIGNED (type1
);
505 int is_unsigned2
= TYPE_UNSIGNED (type2
);
506 unsigned int result_len
;
507 int unsigned_operation
;
509 /* Determine type length and signedness after promotion for
511 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
514 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
516 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
519 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
522 if (promoted_len1
> promoted_len2
)
524 unsigned_operation
= is_unsigned1
;
525 result_len
= promoted_len1
;
527 else if (promoted_len2
> promoted_len1
)
529 unsigned_operation
= is_unsigned2
;
530 result_len
= promoted_len2
;
534 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
535 result_len
= promoted_len1
;
538 switch (language
->la_language
)
544 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
546 promoted_type
= (unsigned_operation
547 ? builtin
->builtin_unsigned_int
548 : builtin
->builtin_int
);
550 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
552 promoted_type
= (unsigned_operation
553 ? builtin
->builtin_unsigned_long
554 : builtin
->builtin_long
);
558 promoted_type
= (unsigned_operation
559 ? builtin
->builtin_unsigned_long_long
560 : builtin
->builtin_long_long
);
563 case language_opencl
:
564 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
569 ? lookup_unsigned_typename (language
, "int")
570 : lookup_signed_typename (language
, "int"));
572 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
577 ? lookup_unsigned_typename (language
, "long")
578 : lookup_signed_typename (language
,"long"));
582 /* For other languages the result type is unchanged from gdb
583 version 6.7 for backward compatibility.
584 If either arg was long long, make sure that value is also long
585 long. Otherwise use long. */
586 if (unsigned_operation
)
588 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
589 promoted_type
= builtin
->builtin_unsigned_long_long
;
591 promoted_type
= builtin
->builtin_unsigned_long
;
595 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
596 promoted_type
= builtin
->builtin_long_long
;
598 promoted_type
= builtin
->builtin_long
;
606 /* Promote both operands to common type. */
607 *arg1
= value_cast (promoted_type
, *arg1
);
608 *arg2
= value_cast (promoted_type
, *arg2
);
613 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
615 type
= check_typedef (type
);
616 if (TYPE_IS_REFERENCE (type
))
617 type
= TYPE_TARGET_TYPE (type
);
619 switch (TYPE_CODE (type
))
625 case TYPE_CODE_ARRAY
:
626 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
633 /* Represents a fake method with the given parameter types. This is
634 used by the parser to construct a temporary "expected" type for
635 method overload resolution. FLAGS is used as instance flags of the
636 new type, in order to be able to make the new type represent a
637 const/volatile overload. */
642 fake_method (type_instance_flags flags
,
643 int num_types
, struct type
**param_types
);
646 /* The constructed type. */
647 struct type
*type () { return &m_type
; }
650 struct type m_type
{};
651 main_type m_main_type
{};
654 fake_method::fake_method (type_instance_flags flags
,
655 int num_types
, struct type
**param_types
)
657 struct type
*type
= &m_type
;
659 TYPE_MAIN_TYPE (type
) = &m_main_type
;
660 TYPE_LENGTH (type
) = 1;
661 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
662 TYPE_CHAIN (type
) = type
;
663 TYPE_INSTANCE_FLAGS (type
) = flags
;
666 if (param_types
[num_types
- 1] == NULL
)
669 TYPE_VARARGS (type
) = 1;
671 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
675 /* Caller should have ensured this. */
676 gdb_assert (num_types
== 0);
677 TYPE_PROTOTYPED (type
) = 1;
681 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
682 neither an objfile nor a gdbarch. As a result we must manually
683 allocate memory for auxiliary fields, and free the memory ourselves
684 when we are done with it. */
685 TYPE_NFIELDS (type
) = num_types
;
686 TYPE_FIELDS (type
) = (struct field
*)
687 xzalloc (sizeof (struct field
) * num_types
);
689 while (num_types
-- > 0)
690 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
693 fake_method::~fake_method ()
695 xfree (TYPE_FIELDS (&m_type
));
698 /* Helper for evaluating an OP_VAR_VALUE. */
701 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
703 /* JYG: We used to just return value_zero of the symbol type if
704 we're asked to avoid side effects. Otherwise we return
705 value_of_variable (...). However I'm not sure if
706 value_of_variable () has any side effect. We need a full value
707 object returned here for whatis_exp () to call evaluate_type ()
708 and then pass the full value to value_rtti_target_type () if we
709 are dealing with a pointer or reference to a base class and print
712 struct value
*ret
= NULL
;
716 ret
= value_of_variable (var
, blk
);
719 catch (const gdb_exception_error
&except
)
721 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
724 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
730 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
733 evaluate_var_msym_value (enum noside noside
,
734 struct objfile
*objfile
, minimal_symbol
*msymbol
)
737 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
739 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !TYPE_GNU_IFUNC (the_type
))
740 return value_zero (the_type
, not_lval
);
742 return value_at_lazy (the_type
, address
);
745 /* Helper for returning a value when handling EVAL_SKIP. */
748 eval_skip_value (expression
*exp
)
750 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
753 /* Evaluate a function call. The function to be called is in
754 ARGVEC[0] and the arguments passed to the function are in
755 ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
756 known. DEFAULT_RETURN_TYPE is used as the function's return type
757 if the return type is unknown. */
760 eval_call (expression
*exp
, enum noside noside
,
761 int nargs
, value
**argvec
,
762 const char *function_name
,
763 type
*default_return_type
)
765 if (argvec
[0] == NULL
)
766 error (_("Cannot evaluate function -- may be inlined"));
767 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
769 /* If the return type doesn't look like a function type,
770 call an error. This can happen if somebody tries to turn
771 a variable into a function call. */
773 type
*ftype
= value_type (argvec
[0]);
775 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
777 /* We don't know anything about what the internal
778 function might return, but we have to return
780 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
783 else if (TYPE_CODE (ftype
) == TYPE_CODE_XMETHOD
)
786 = result_type_of_xmethod (argvec
[0],
787 gdb::make_array_view (argvec
+ 1,
790 if (return_type
== NULL
)
791 error (_("Xmethod is missing return type."));
792 return value_zero (return_type
, not_lval
);
794 else if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
795 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
797 if (TYPE_GNU_IFUNC (ftype
))
799 CORE_ADDR address
= value_address (argvec
[0]);
800 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
802 if (resolved_type
!= NULL
)
803 ftype
= resolved_type
;
806 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
808 if (return_type
== NULL
)
809 return_type
= default_return_type
;
811 if (return_type
== NULL
)
812 error_call_unknown_return_type (function_name
);
814 return allocate_value (return_type
);
817 error (_("Expression of type other than "
818 "\"Function returning ...\" used as function"));
820 switch (TYPE_CODE (value_type (argvec
[0])))
822 case TYPE_CODE_INTERNAL_FUNCTION
:
823 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
824 argvec
[0], nargs
, argvec
+ 1);
825 case TYPE_CODE_XMETHOD
:
826 return call_xmethod (argvec
[0], gdb::make_array_view (argvec
+ 1, nargs
));
828 return call_function_by_hand (argvec
[0], default_return_type
,
829 gdb::make_array_view (argvec
+ 1, nargs
));
833 /* Helper for evaluating an OP_FUNCALL. */
836 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
844 symbol
*function
= NULL
;
845 char *function_name
= NULL
;
846 const char *var_func_name
= NULL
;
851 exp_opcode op
= exp
->elts
[*pos
].opcode
;
852 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
853 /* Allocate arg vector, including space for the function to be
854 called in argvec[0], a potential `this', and a terminating
856 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
857 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
859 /* First, evaluate the structure into arg2. */
862 if (op
== STRUCTOP_MEMBER
)
864 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
868 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
871 /* If the function is a virtual function, then the aggregate
872 value (providing the structure) plays its part by providing
873 the vtable. Otherwise, it is just along for the ride: call
874 the function directly. */
876 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
878 type
*a1_type
= check_typedef (value_type (arg1
));
879 if (noside
== EVAL_SKIP
)
880 tem
= 1; /* Set it to the right arg index so that all
881 arguments can also be skipped. */
882 else if (TYPE_CODE (a1_type
) == TYPE_CODE_METHODPTR
)
884 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
885 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
887 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
889 /* Now, say which argument to start evaluating from. */
894 else if (TYPE_CODE (a1_type
) == TYPE_CODE_MEMBERPTR
)
896 struct type
*type_ptr
897 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
898 struct type
*target_type_ptr
899 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
901 /* Now, convert these values to an address. */
902 arg2
= value_cast (type_ptr
, arg2
);
904 long mem_offset
= value_as_long (arg1
);
906 arg1
= value_from_pointer (target_type_ptr
,
907 value_as_long (arg2
) + mem_offset
);
908 arg1
= value_ind (arg1
);
912 error (_("Non-pointer-to-member value used in pointer-to-member "
915 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
917 /* Hair for method invocations. */
921 /* First, evaluate the structure into arg2. */
923 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
924 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
926 if (op
== STRUCTOP_STRUCT
)
928 /* If v is a variable in a register, and the user types
929 v.method (), this will produce an error, because v has no
932 A possible way around this would be to allocate a copy of
933 the variable on the stack, copy in the contents, call the
934 function, and copy out the contents. I.e. convert this
935 from call by reference to call by copy-return (or
936 whatever it's called). However, this does not work
937 because it is not the same: the method being called could
938 stash a copy of the address, and then future uses through
939 that address (after the method returns) would be expected
940 to use the variable itself, not some copy of it. */
941 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
945 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
947 /* Check to see if the operator '->' has been overloaded.
948 If the operator has been overloaded replace arg2 with the
949 value returned by the custom operator and continue
951 while (unop_user_defined_p (op
, arg2
))
953 struct value
*value
= NULL
;
956 value
= value_x_unop (arg2
, op
, noside
);
959 catch (const gdb_exception_error
&except
)
961 if (except
.error
== NOT_FOUND_ERROR
)
970 /* Now, say which argument to start evaluating from. */
973 else if (op
== OP_SCOPE
974 && overload_resolution
975 && (exp
->language_defn
->la_language
== language_cplus
))
977 /* Unpack it locally so we can properly handle overload
983 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
984 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
985 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
986 name
= &exp
->elts
[pc2
+ 3].string
;
989 function_name
= NULL
;
990 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
992 function
= cp_lookup_symbol_namespace (TYPE_NAME (type
),
994 get_selected_block (0),
996 if (function
== NULL
)
997 error (_("No symbol \"%s\" in namespace \"%s\"."),
998 name
, TYPE_NAME (type
));
1001 /* arg2 is left as NULL on purpose. */
1005 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1006 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1007 function_name
= name
;
1009 /* We need a properly typed value for method lookup. For
1010 static methods arg2 is otherwise unused. */
1011 arg2
= value_zero (type
, lval_memory
);
1016 else if (op
== OP_ADL_FUNC
)
1018 /* Save the function position and move pos so that the arguments
1019 can be evaluated. */
1025 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1026 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1030 /* Non-method function call. */
1034 /* If this is a C++ function wait until overload resolution. */
1035 if (op
== OP_VAR_VALUE
1036 && overload_resolution
1037 && (exp
->language_defn
->la_language
== language_cplus
))
1039 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1044 if (op
== OP_VAR_MSYM_VALUE
)
1046 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1047 var_func_name
= msym
->print_name ();
1049 else if (op
== OP_VAR_VALUE
)
1051 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1052 var_func_name
= sym
->print_name ();
1055 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1056 type
*type
= value_type (argvec
[0]);
1057 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1058 type
= TYPE_TARGET_TYPE (type
);
1059 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1061 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1063 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1071 /* Evaluate arguments (if not already done, e.g., namespace::func()
1072 and overload-resolution is off). */
1073 for (; tem
<= nargs
; tem
++)
1075 /* Ensure that array expressions are coerced into pointer
1077 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1080 /* Signal end of arglist. */
1083 if (noside
== EVAL_SKIP
)
1084 return eval_skip_value (exp
);
1086 if (op
== OP_ADL_FUNC
)
1088 struct symbol
*symp
;
1091 int string_pc
= save_pos1
+ 3;
1093 /* Extract the function name. */
1094 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1095 func_name
= (char *) alloca (name_len
+ 1);
1096 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1098 find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1100 NON_METHOD
, /* not method */
1101 NULL
, NULL
, /* pass NULL symbol since
1102 symbol is unknown */
1103 NULL
, &symp
, NULL
, 0, noside
);
1105 /* Now fix the expression being evaluated. */
1106 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1107 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1110 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1111 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1113 int static_memfuncp
;
1116 /* Method invocation: stuff "this" as first parameter. If the
1117 method turns out to be static we undo this below. */
1122 /* Name of method from expression. */
1123 tstr
= &exp
->elts
[pc2
+ 2].string
;
1126 tstr
= function_name
;
1128 if (overload_resolution
&& (exp
->language_defn
->la_language
1131 /* Language is C++, do some overload resolution before
1133 struct value
*valp
= NULL
;
1135 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1137 METHOD
, /* method */
1138 &arg2
, /* the object */
1140 &static_memfuncp
, 0, noside
);
1142 if (op
== OP_SCOPE
&& !static_memfuncp
)
1144 /* For the time being, we don't handle this. */
1145 error (_("Call to overloaded function %s requires "
1149 argvec
[1] = arg2
; /* the ``this'' pointer */
1150 argvec
[0] = valp
; /* Use the method found after overload
1154 /* Non-C++ case -- or no overload resolution. */
1156 struct value
*temp
= arg2
;
1158 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1160 op
== STRUCTOP_STRUCT
1161 ? "structure" : "structure pointer");
1162 /* value_struct_elt updates temp with the correct value of
1163 the ``this'' pointer if necessary, so modify argvec[1] to
1164 reflect any ``this'' changes. */
1166 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1167 value_address (temp
)
1168 + value_embedded_offset (temp
));
1169 argvec
[1] = arg2
; /* the ``this'' pointer */
1172 /* Take out `this' if needed. */
1173 if (static_memfuncp
)
1175 argvec
[1] = argvec
[0];
1180 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1182 /* Pointer to member. argvec[1] is already set up. */
1185 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1187 /* Non-member function being called. */
1188 /* fn: This can only be done for C++ functions. A C-style
1189 function in a C++ program, for instance, does not have the
1190 fields that are expected here. */
1192 if (overload_resolution
&& (exp
->language_defn
->la_language
1195 /* Language is C++, do some overload resolution before
1197 struct symbol
*symp
;
1200 /* If a scope has been specified disable ADL. */
1204 if (op
== OP_VAR_VALUE
)
1205 function
= exp
->elts
[save_pos1
+2].symbol
;
1207 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1208 NULL
, /* no need for name */
1209 NON_METHOD
, /* not method */
1210 NULL
, function
, /* the function */
1211 NULL
, &symp
, NULL
, no_adl
, noside
);
1213 if (op
== OP_VAR_VALUE
)
1215 /* Now fix the expression being evaluated. */
1216 exp
->elts
[save_pos1
+2].symbol
= symp
;
1217 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1221 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1225 /* Not C++, or no overload resolution allowed. */
1226 /* Nothing to be done; argvec already correctly set up. */
1231 /* It is probably a C-style function. */
1232 /* Nothing to be done; argvec already correctly set up. */
1235 return eval_call (exp
, noside
, nargs
, argvec
, var_func_name
, expect_type
);
1238 /* Helper for skipping all the arguments in an undetermined argument list.
1239 This function was designed for use in the OP_F77_UNDETERMINED_ARGLIST
1240 case of evaluate_subexp_standard as multiple, but not all, code paths
1241 require a generic skip. */
1244 skip_undetermined_arglist (int nargs
, struct expression
*exp
, int *pos
,
1247 for (int i
= 0; i
< nargs
; ++i
)
1248 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1251 /* Return true if type is integral or reference to integral */
1254 is_integral_or_integral_reference (struct type
*type
)
1256 if (is_integral_type (type
))
1259 type
= check_typedef (type
);
1260 return (type
!= nullptr
1261 && TYPE_IS_REFERENCE (type
)
1262 && is_integral_type (TYPE_TARGET_TYPE (type
)));
1266 evaluate_subexp_standard (struct type
*expect_type
,
1267 struct expression
*exp
, int *pos
,
1271 int tem
, tem2
, tem3
;
1273 struct value
*arg1
= NULL
;
1274 struct value
*arg2
= NULL
;
1278 struct value
**argvec
;
1282 struct type
**arg_types
;
1285 op
= exp
->elts
[pc
].opcode
;
1290 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1291 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1292 if (noside
== EVAL_SKIP
)
1293 return eval_skip_value (exp
);
1294 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
1295 &exp
->elts
[pc
+ 3].string
,
1296 expect_type
, 0, noside
);
1298 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
1303 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1304 exp
->elts
[pc
+ 2].longconst
);
1308 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1309 exp
->elts
[pc
+ 2].floatconst
);
1315 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1316 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_ERROR
)
1317 error_unknown_type (var
->print_name ());
1318 if (noside
!= EVAL_SKIP
)
1319 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1322 /* Return a dummy value of the correct type when skipping, so
1323 that parent functions know what is to be skipped. */
1324 return allocate_value (SYMBOL_TYPE (var
));
1328 case OP_VAR_MSYM_VALUE
:
1332 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1333 value
*val
= evaluate_var_msym_value (noside
,
1334 exp
->elts
[pc
+ 1].objfile
,
1337 type
= value_type (val
);
1338 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
1339 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| pc
!= 0))
1340 error_unknown_type (msymbol
->print_name ());
1344 case OP_VAR_ENTRY_VALUE
:
1346 if (noside
== EVAL_SKIP
)
1347 return eval_skip_value (exp
);
1350 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1351 struct frame_info
*frame
;
1353 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1354 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1356 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1357 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1358 error (_("Symbol \"%s\" does not have any specific entry value"),
1359 sym
->print_name ());
1361 frame
= get_selected_frame (NULL
);
1362 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1365 case OP_FUNC_STATIC_VAR
:
1366 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1367 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1368 if (noside
== EVAL_SKIP
)
1369 return eval_skip_value (exp
);
1372 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1373 CORE_ADDR addr
= value_address (func
);
1375 const block
*blk
= block_for_pc (addr
);
1376 const char *var
= &exp
->elts
[pc
+ 2].string
;
1378 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1380 if (sym
.symbol
== NULL
)
1381 error (_("No symbol \"%s\" in specified context."), var
);
1383 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1389 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1393 const char *name
= &exp
->elts
[pc
+ 2].string
;
1397 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1398 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1399 name
, strlen (name
));
1401 error (_("Register $%s not available."), name
);
1403 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1404 a value with the appropriate register type. Unfortunately,
1405 we don't have easy access to the type of user registers.
1406 So for these registers, we fetch the register value regardless
1407 of the evaluation mode. */
1408 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1409 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1410 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1412 val
= value_of_register (regno
, get_selected_frame (NULL
));
1414 error (_("Value of register %s not available."), name
);
1420 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1421 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1423 case OP_INTERNALVAR
:
1425 return value_of_internalvar (exp
->gdbarch
,
1426 exp
->elts
[pc
+ 1].internalvar
);
1429 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1430 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1431 if (noside
== EVAL_SKIP
)
1432 return eval_skip_value (exp
);
1433 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1434 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1436 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1437 NSString constant. */
1438 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1439 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1440 if (noside
== EVAL_SKIP
)
1441 return eval_skip_value (exp
);
1442 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1446 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1447 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1448 nargs
= tem3
- tem2
+ 1;
1449 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
1451 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1452 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1454 struct value
*rec
= allocate_value (expect_type
);
1456 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1457 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1460 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1461 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1463 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
1464 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1465 struct value
*array
= allocate_value (expect_type
);
1466 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1467 LONGEST low_bound
, high_bound
, index
;
1469 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1472 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1475 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1476 for (tem
= nargs
; --nargs
>= 0;)
1478 struct value
*element
;
1481 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1482 if (value_type (element
) != element_type
)
1483 element
= value_cast (element_type
, element
);
1486 int continue_pc
= *pos
;
1489 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1490 low_bound
, high_bound
);
1495 if (index
> high_bound
)
1496 /* To avoid memory corruption. */
1497 error (_("Too many array elements"));
1498 memcpy (value_contents_raw (array
)
1499 + (index
- low_bound
) * element_size
,
1500 value_contents (element
),
1508 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1509 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1511 struct value
*set
= allocate_value (expect_type
);
1512 gdb_byte
*valaddr
= value_contents_raw (set
);
1513 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1514 struct type
*check_type
= element_type
;
1515 LONGEST low_bound
, high_bound
;
1517 /* Get targettype of elementtype. */
1518 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1519 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1520 check_type
= TYPE_TARGET_TYPE (check_type
);
1522 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1523 error (_("(power)set type with unknown size"));
1524 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1525 for (tem
= 0; tem
< nargs
; tem
++)
1527 LONGEST range_low
, range_high
;
1528 struct type
*range_low_type
, *range_high_type
;
1529 struct value
*elem_val
;
1531 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1532 range_low_type
= range_high_type
= value_type (elem_val
);
1533 range_low
= range_high
= value_as_long (elem_val
);
1535 /* Check types of elements to avoid mixture of elements from
1536 different types. Also check if type of element is "compatible"
1537 with element type of powerset. */
1538 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1539 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1540 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1541 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1542 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1543 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1544 && (range_low_type
!= range_high_type
)))
1545 /* different element modes. */
1546 error (_("POWERSET tuple elements of different mode"));
1547 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1548 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1549 && range_low_type
!= check_type
))
1550 error (_("incompatible POWERSET tuple elements"));
1551 if (range_low
> range_high
)
1553 warning (_("empty POWERSET tuple range"));
1556 if (range_low
< low_bound
|| range_high
> high_bound
)
1557 error (_("POWERSET tuple element out of range"));
1558 range_low
-= low_bound
;
1559 range_high
-= low_bound
;
1560 for (; range_low
<= range_high
; range_low
++)
1562 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1564 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1565 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1566 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1573 argvec
= XALLOCAVEC (struct value
*, nargs
);
1574 for (tem
= 0; tem
< nargs
; tem
++)
1576 /* Ensure that array expressions are coerced into pointer
1578 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1580 if (noside
== EVAL_SKIP
)
1581 return eval_skip_value (exp
);
1582 return value_array (tem2
, tem3
, argvec
);
1586 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1588 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1590 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1592 if (noside
== EVAL_SKIP
)
1593 return eval_skip_value (exp
);
1594 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1598 /* Skip third and second args to evaluate the first one. */
1599 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1600 if (value_logical_not (arg1
))
1602 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1603 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1607 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1608 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1612 case OP_OBJC_SELECTOR
:
1613 { /* Objective C @selector operator. */
1614 char *sel
= &exp
->elts
[pc
+ 2].string
;
1615 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1616 struct type
*selector_type
;
1618 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1619 if (noside
== EVAL_SKIP
)
1620 return eval_skip_value (exp
);
1623 sel
[len
] = 0; /* Make sure it's terminated. */
1625 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1626 return value_from_longest (selector_type
,
1627 lookup_child_selector (exp
->gdbarch
, sel
));
1630 case OP_OBJC_MSGCALL
:
1631 { /* Objective C message (method) call. */
1633 CORE_ADDR responds_selector
= 0;
1634 CORE_ADDR method_selector
= 0;
1636 CORE_ADDR selector
= 0;
1638 int struct_return
= 0;
1639 enum noside sub_no_side
= EVAL_NORMAL
;
1641 struct value
*msg_send
= NULL
;
1642 struct value
*msg_send_stret
= NULL
;
1643 int gnu_runtime
= 0;
1645 struct value
*target
= NULL
;
1646 struct value
*method
= NULL
;
1647 struct value
*called_method
= NULL
;
1649 struct type
*selector_type
= NULL
;
1650 struct type
*long_type
;
1652 struct value
*ret
= NULL
;
1655 selector
= exp
->elts
[pc
+ 1].longconst
;
1656 nargs
= exp
->elts
[pc
+ 2].longconst
;
1657 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1661 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1662 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1664 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1665 sub_no_side
= EVAL_NORMAL
;
1667 sub_no_side
= noside
;
1669 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1671 if (value_as_long (target
) == 0)
1672 return value_from_longest (long_type
, 0);
1674 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1677 /* Find the method dispatch (Apple runtime) or method lookup
1678 (GNU runtime) function for Objective-C. These will be used
1679 to lookup the symbol information for the method. If we
1680 can't find any symbol information, then we'll use these to
1681 call the method, otherwise we can call the method
1682 directly. The msg_send_stret function is used in the special
1683 case of a method that returns a structure (Apple runtime
1687 type
= selector_type
;
1689 type
= lookup_function_type (type
);
1690 type
= lookup_pointer_type (type
);
1691 type
= lookup_function_type (type
);
1692 type
= lookup_pointer_type (type
);
1694 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1696 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1698 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1699 msg_send_stret
= value_from_pointer (type
,
1700 value_as_address (msg_send_stret
));
1704 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1705 /* Special dispatcher for methods returning structs. */
1707 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1710 /* Verify the target object responds to this method. The
1711 standard top-level 'Object' class uses a different name for
1712 the verification method than the non-standard, but more
1713 often used, 'NSObject' class. Make sure we check for both. */
1716 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1717 if (responds_selector
== 0)
1719 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1721 if (responds_selector
== 0)
1722 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1725 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1726 if (method_selector
== 0)
1728 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1730 if (method_selector
== 0)
1731 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1733 /* Call the verification method, to make sure that the target
1734 class implements the desired method. */
1736 argvec
[0] = msg_send
;
1738 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1739 argvec
[3] = value_from_longest (long_type
, selector
);
1742 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1745 /* Function objc_msg_lookup returns a pointer. */
1747 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1749 if (value_as_long (ret
) == 0)
1750 error (_("Target does not respond to this message selector."));
1752 /* Call "methodForSelector:" method, to get the address of a
1753 function method that implements this selector for this
1754 class. If we can find a symbol at that address, then we
1755 know the return type, parameter types etc. (that's a good
1758 argvec
[0] = msg_send
;
1760 argvec
[2] = value_from_longest (long_type
, method_selector
);
1761 argvec
[3] = value_from_longest (long_type
, selector
);
1764 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1768 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1771 /* ret should now be the selector. */
1773 addr
= value_as_long (ret
);
1776 struct symbol
*sym
= NULL
;
1778 /* The address might point to a function descriptor;
1779 resolve it to the actual code address instead. */
1780 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1781 current_top_target ());
1783 /* Is it a high_level symbol? */
1784 sym
= find_pc_function (addr
);
1786 method
= value_of_variable (sym
, 0);
1789 /* If we found a method with symbol information, check to see
1790 if it returns a struct. Otherwise assume it doesn't. */
1795 struct type
*val_type
;
1797 funaddr
= find_function_addr (method
, &val_type
);
1799 block_for_pc (funaddr
);
1801 val_type
= check_typedef (val_type
);
1803 if ((val_type
== NULL
)
1804 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1806 if (expect_type
!= NULL
)
1807 val_type
= expect_type
;
1810 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1813 else if (expect_type
!= NULL
)
1815 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1816 check_typedef (expect_type
));
1819 /* Found a function symbol. Now we will substitute its
1820 value in place of the message dispatcher (obj_msgSend),
1821 so that we call the method directly instead of thru
1822 the dispatcher. The main reason for doing this is that
1823 we can now evaluate the return value and parameter values
1824 according to their known data types, in case we need to
1825 do things like promotion, dereferencing, special handling
1826 of structs and doubles, etc.
1828 We want to use the type signature of 'method', but still
1829 jump to objc_msgSend() or objc_msgSend_stret() to better
1830 mimic the behavior of the runtime. */
1834 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1835 error (_("method address has symbol information "
1836 "with non-function type; skipping"));
1838 /* Create a function pointer of the appropriate type, and
1839 replace its value with the value of msg_send or
1840 msg_send_stret. We must use a pointer here, as
1841 msg_send and msg_send_stret are of pointer type, and
1842 the representation may be different on systems that use
1843 function descriptors. */
1846 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1847 value_as_address (msg_send_stret
));
1850 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1851 value_as_address (msg_send
));
1856 called_method
= msg_send_stret
;
1858 called_method
= msg_send
;
1861 if (noside
== EVAL_SKIP
)
1862 return eval_skip_value (exp
);
1864 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1866 /* If the return type doesn't look like a function type,
1867 call an error. This can happen if somebody tries to
1868 turn a variable into a function call. This is here
1869 because people often want to call, eg, strcmp, which
1870 gdb doesn't know is a function. If gdb isn't asked for
1871 it's opinion (ie. through "whatis"), it won't offer
1874 struct type
*callee_type
= value_type (called_method
);
1876 if (callee_type
&& TYPE_CODE (callee_type
) == TYPE_CODE_PTR
)
1877 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1878 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1882 if ((TYPE_CODE (callee_type
) == TYPE_CODE_ERROR
) && expect_type
)
1883 return allocate_value (expect_type
);
1885 return allocate_value (callee_type
);
1888 error (_("Expression of type other than "
1889 "\"method returning ...\" used as a method"));
1892 /* Now depending on whether we found a symbol for the method,
1893 we will either call the runtime dispatcher or the method
1896 argvec
[0] = called_method
;
1898 argvec
[2] = value_from_longest (long_type
, selector
);
1899 /* User-supplied arguments. */
1900 for (tem
= 0; tem
< nargs
; tem
++)
1901 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1902 argvec
[tem
+ 3] = 0;
1904 auto call_args
= gdb::make_array_view (argvec
+ 1, nargs
+ 2);
1906 if (gnu_runtime
&& (method
!= NULL
))
1908 /* Function objc_msg_lookup returns a pointer. */
1909 deprecated_set_value_type (argvec
[0],
1910 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1911 argvec
[0] = call_function_by_hand (argvec
[0], NULL
, call_args
);
1914 return call_function_by_hand (argvec
[0], NULL
, call_args
);
1919 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1921 case OP_F77_UNDETERMINED_ARGLIST
:
1923 /* Remember that in F77, functions, substring ops and
1924 array subscript operations cannot be disambiguated
1925 at parse time. We have made all array subscript operations,
1926 substring operations as well as function calls come here
1927 and we now have to discover what the heck this thing actually was.
1928 If it is a function, we process just as if we got an OP_FUNCALL. */
1930 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1933 /* First determine the type code we are dealing with. */
1934 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1935 type
= check_typedef (value_type (arg1
));
1936 code
= TYPE_CODE (type
);
1938 if (code
== TYPE_CODE_PTR
)
1940 /* Fortran always passes variable to subroutines as pointer.
1941 So we need to look into its target type to see if it is
1942 array, string or function. If it is, we need to switch
1943 to the target value the original one points to. */
1944 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1946 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1947 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1948 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1950 arg1
= value_ind (arg1
);
1951 type
= check_typedef (value_type (arg1
));
1952 code
= TYPE_CODE (type
);
1958 case TYPE_CODE_ARRAY
:
1959 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1960 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1963 if (noside
== EVAL_SKIP
)
1965 skip_undetermined_arglist (nargs
, exp
, pos
, noside
);
1966 /* Return the dummy value with the correct type. */
1969 goto multi_f77_subscript
;
1972 case TYPE_CODE_STRING
:
1973 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1974 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1977 if (noside
== EVAL_SKIP
)
1979 skip_undetermined_arglist (nargs
, exp
, pos
, noside
);
1980 /* Return the dummy value with the correct type. */
1983 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1984 return value_subscript (arg1
, value_as_long (arg2
));
1988 case TYPE_CODE_FUNC
:
1989 case TYPE_CODE_INTERNAL_FUNCTION
:
1990 /* It's a function call. */
1991 /* Allocate arg vector, including space for the function to be
1992 called in argvec[0] and a terminating NULL. */
1993 argvec
= (struct value
**)
1994 alloca (sizeof (struct value
*) * (nargs
+ 2));
1997 for (; tem
<= nargs
; tem
++)
1999 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
2000 /* Arguments in Fortran are passed by address. Coerce the
2001 arguments here rather than in value_arg_coerce as otherwise
2002 the call to malloc to place the non-lvalue parameters in
2003 target memory is hit by this Fortran specific logic. This
2004 results in malloc being called with a pointer to an integer
2005 followed by an attempt to malloc the arguments to malloc in
2006 target memory. Infinite recursion ensues. */
2007 if (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
)
2010 = TYPE_FIELD_ARTIFICIAL (value_type (arg1
), tem
- 1);
2011 argvec
[tem
] = fortran_argument_convert (argvec
[tem
],
2015 argvec
[tem
] = 0; /* signal end of arglist */
2016 if (noside
== EVAL_SKIP
)
2017 return eval_skip_value (exp
);
2018 return eval_call (exp
, noside
, nargs
, argvec
, NULL
, expect_type
);
2021 error (_("Cannot perform substring on this type"));
2025 /* We have a complex number, There should be 2 floating
2026 point numbers that compose it. */
2028 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2029 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2031 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
2033 case STRUCTOP_STRUCT
:
2034 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2035 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2036 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2037 if (noside
== EVAL_SKIP
)
2038 return eval_skip_value (exp
);
2039 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2041 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2042 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2046 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2047 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2048 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2049 if (noside
== EVAL_SKIP
)
2050 return eval_skip_value (exp
);
2052 /* Check to see if operator '->' has been overloaded. If so replace
2053 arg1 with the value returned by evaluating operator->(). */
2054 while (unop_user_defined_p (op
, arg1
))
2056 struct value
*value
= NULL
;
2059 value
= value_x_unop (arg1
, op
, noside
);
2062 catch (const gdb_exception_error
&except
)
2064 if (except
.error
== NOT_FOUND_ERROR
)
2073 /* JYG: if print object is on we need to replace the base type
2074 with rtti type in order to continue on with successful
2075 lookup of member / method only available in the rtti type. */
2077 struct type
*arg_type
= value_type (arg1
);
2078 struct type
*real_type
;
2079 int full
, using_enc
;
2081 struct value_print_options opts
;
2083 get_user_print_options (&opts
);
2084 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
2085 && (TYPE_CODE (TYPE_TARGET_TYPE (arg_type
)) == TYPE_CODE_STRUCT
))
2087 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
2090 arg1
= value_cast (real_type
, arg1
);
2094 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2095 NULL
, "structure pointer");
2096 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2097 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2100 case STRUCTOP_MEMBER
:
2102 if (op
== STRUCTOP_MEMBER
)
2103 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2105 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2107 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2109 if (noside
== EVAL_SKIP
)
2110 return eval_skip_value (exp
);
2112 type
= check_typedef (value_type (arg2
));
2113 switch (TYPE_CODE (type
))
2115 case TYPE_CODE_METHODPTR
:
2116 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2117 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2120 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2121 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2122 return value_ind (arg2
);
2125 case TYPE_CODE_MEMBERPTR
:
2126 /* Now, convert these values to an address. */
2127 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
2130 mem_offset
= value_as_long (arg2
);
2132 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2133 value_as_long (arg1
) + mem_offset
);
2134 return value_ind (arg3
);
2137 error (_("non-pointer-to-member value used "
2138 "in pointer-to-member construct"));
2143 type_instance_flags flags
2144 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2145 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2146 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2147 for (ix
= 0; ix
< nargs
; ++ix
)
2148 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2150 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
2151 *(pos
) += 4 + nargs
;
2152 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
2157 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2158 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2159 if (noside
== EVAL_SKIP
)
2160 return eval_skip_value (exp
);
2161 if (binop_user_defined_p (op
, arg1
, arg2
))
2162 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2164 return value_concat (arg1
, arg2
);
2167 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2168 /* Special-case assignments where the left-hand-side is a
2169 convenience variable -- in these, don't bother setting an
2170 expected type. This avoids a weird case where re-assigning a
2171 string or array to an internal variable could error with "Too
2172 many array elements". */
2173 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
2174 ? NULL_TYPE
: value_type (arg1
),
2177 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2179 if (binop_user_defined_p (op
, arg1
, arg2
))
2180 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2182 return value_assign (arg1
, arg2
);
2184 case BINOP_ASSIGN_MODIFY
:
2186 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2187 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2188 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2190 op
= exp
->elts
[pc
+ 1].opcode
;
2191 if (binop_user_defined_p (op
, arg1
, arg2
))
2192 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2193 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2195 && is_integral_type (value_type (arg2
)))
2196 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2197 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2199 && is_integral_type (value_type (arg2
)))
2200 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2203 struct value
*tmp
= arg1
;
2205 /* For shift and integer exponentiation operations,
2206 only promote the first argument. */
2207 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2208 && is_integral_type (value_type (arg2
)))
2209 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2211 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2213 arg2
= value_binop (tmp
, arg2
, op
);
2215 return value_assign (arg1
, arg2
);
2218 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2219 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2220 if (noside
== EVAL_SKIP
)
2221 return eval_skip_value (exp
);
2222 if (binop_user_defined_p (op
, arg1
, arg2
))
2223 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2224 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2225 && is_integral_or_integral_reference (value_type (arg2
)))
2226 return value_ptradd (arg1
, value_as_long (arg2
));
2227 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2228 && is_integral_or_integral_reference (value_type (arg1
)))
2229 return value_ptradd (arg2
, value_as_long (arg1
));
2232 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2233 return value_binop (arg1
, arg2
, BINOP_ADD
);
2237 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2238 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2239 if (noside
== EVAL_SKIP
)
2240 return eval_skip_value (exp
);
2241 if (binop_user_defined_p (op
, arg1
, arg2
))
2242 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2243 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2244 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2246 /* FIXME -- should be ptrdiff_t */
2247 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2248 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2250 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2251 && is_integral_or_integral_reference (value_type (arg2
)))
2252 return value_ptradd (arg1
, - value_as_long (arg2
));
2255 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2256 return value_binop (arg1
, arg2
, BINOP_SUB
);
2267 case BINOP_BITWISE_AND
:
2268 case BINOP_BITWISE_IOR
:
2269 case BINOP_BITWISE_XOR
:
2270 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2271 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2272 if (noside
== EVAL_SKIP
)
2273 return eval_skip_value (exp
);
2274 if (binop_user_defined_p (op
, arg1
, arg2
))
2275 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2278 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2279 fudge arg2 to avoid division-by-zero, the caller is
2280 (theoretically) only looking for the type of the result. */
2281 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2282 /* ??? Do we really want to test for BINOP_MOD here?
2283 The implementation of value_binop gives it a well-defined
2286 || op
== BINOP_INTDIV
2289 && value_logical_not (arg2
))
2291 struct value
*v_one
, *retval
;
2293 v_one
= value_one (value_type (arg2
));
2294 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2295 retval
= value_binop (arg1
, v_one
, op
);
2300 /* For shift and integer exponentiation operations,
2301 only promote the first argument. */
2302 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2303 && is_integral_type (value_type (arg2
)))
2304 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2306 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2308 return value_binop (arg1
, arg2
, op
);
2312 case BINOP_SUBSCRIPT
:
2313 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2314 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2315 if (noside
== EVAL_SKIP
)
2316 return eval_skip_value (exp
);
2317 if (binop_user_defined_p (op
, arg1
, arg2
))
2318 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2321 /* If the user attempts to subscript something that is not an
2322 array or pointer type (like a plain int variable for example),
2323 then report this as an error. */
2325 arg1
= coerce_ref (arg1
);
2326 type
= check_typedef (value_type (arg1
));
2327 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2328 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2330 if (TYPE_NAME (type
))
2331 error (_("cannot subscript something of type `%s'"),
2334 error (_("cannot subscript requested type"));
2337 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2338 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2340 return value_subscript (arg1
, value_as_long (arg2
));
2342 case MULTI_SUBSCRIPT
:
2344 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2345 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2348 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2349 /* FIXME: EVAL_SKIP handling may not be correct. */
2350 if (noside
== EVAL_SKIP
)
2354 return eval_skip_value (exp
);
2356 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2357 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2359 /* If the user attempts to subscript something that has no target
2360 type (like a plain int variable for example), then report this
2363 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2366 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2372 error (_("cannot subscript something of type `%s'"),
2373 TYPE_NAME (value_type (arg1
)));
2377 if (binop_user_defined_p (op
, arg1
, arg2
))
2379 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2383 arg1
= coerce_ref (arg1
);
2384 type
= check_typedef (value_type (arg1
));
2386 switch (TYPE_CODE (type
))
2389 case TYPE_CODE_ARRAY
:
2390 case TYPE_CODE_STRING
:
2391 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2395 if (TYPE_NAME (type
))
2396 error (_("cannot subscript something of type `%s'"),
2399 error (_("cannot subscript requested type"));
2405 multi_f77_subscript
:
2407 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2408 int ndimensions
= 1, i
;
2409 struct value
*array
= arg1
;
2411 if (nargs
> MAX_FORTRAN_DIMS
)
2412 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2414 ndimensions
= calc_f77_array_dims (type
);
2416 if (nargs
!= ndimensions
)
2417 error (_("Wrong number of subscripts"));
2419 gdb_assert (nargs
> 0);
2421 /* Now that we know we have a legal array subscript expression
2422 let us actually find out where this element exists in the array. */
2424 /* Take array indices left to right. */
2425 for (i
= 0; i
< nargs
; i
++)
2427 /* Evaluate each subscript; it must be a legal integer in F77. */
2428 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2430 /* Fill in the subscript array. */
2432 subscript_array
[i
] = value_as_long (arg2
);
2435 /* Internal type of array is arranged right to left. */
2436 for (i
= nargs
; i
> 0; i
--)
2438 struct type
*array_type
= check_typedef (value_type (array
));
2439 LONGEST index
= subscript_array
[i
- 1];
2441 array
= value_subscripted_rvalue (array
, index
,
2442 f77_get_lowerbound (array_type
));
2448 case BINOP_LOGICAL_AND
:
2449 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2450 if (noside
== EVAL_SKIP
)
2452 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2453 return eval_skip_value (exp
);
2457 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2460 if (binop_user_defined_p (op
, arg1
, arg2
))
2462 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2463 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2467 tem
= value_logical_not (arg1
);
2468 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2469 (tem
? EVAL_SKIP
: noside
));
2470 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2471 return value_from_longest (type
,
2472 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2475 case BINOP_LOGICAL_OR
:
2476 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2477 if (noside
== EVAL_SKIP
)
2479 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2480 return eval_skip_value (exp
);
2484 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2487 if (binop_user_defined_p (op
, arg1
, arg2
))
2489 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2490 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2494 tem
= value_logical_not (arg1
);
2495 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2496 (!tem
? EVAL_SKIP
: noside
));
2497 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2498 return value_from_longest (type
,
2499 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2503 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2504 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2505 if (noside
== EVAL_SKIP
)
2506 return eval_skip_value (exp
);
2507 if (binop_user_defined_p (op
, arg1
, arg2
))
2509 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2513 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2514 tem
= value_equal (arg1
, arg2
);
2515 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2516 return value_from_longest (type
, (LONGEST
) tem
);
2519 case BINOP_NOTEQUAL
:
2520 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2521 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2522 if (noside
== EVAL_SKIP
)
2523 return eval_skip_value (exp
);
2524 if (binop_user_defined_p (op
, arg1
, arg2
))
2526 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2530 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2531 tem
= value_equal (arg1
, arg2
);
2532 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2533 return value_from_longest (type
, (LONGEST
) ! tem
);
2537 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2538 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2539 if (noside
== EVAL_SKIP
)
2540 return eval_skip_value (exp
);
2541 if (binop_user_defined_p (op
, arg1
, arg2
))
2543 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2547 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2548 tem
= value_less (arg1
, arg2
);
2549 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2550 return value_from_longest (type
, (LONGEST
) tem
);
2554 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2555 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2556 if (noside
== EVAL_SKIP
)
2557 return eval_skip_value (exp
);
2558 if (binop_user_defined_p (op
, arg1
, arg2
))
2560 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2564 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2565 tem
= value_less (arg2
, arg1
);
2566 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2567 return value_from_longest (type
, (LONGEST
) tem
);
2571 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2572 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2573 if (noside
== EVAL_SKIP
)
2574 return eval_skip_value (exp
);
2575 if (binop_user_defined_p (op
, arg1
, arg2
))
2577 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2581 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2582 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2583 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2584 return value_from_longest (type
, (LONGEST
) tem
);
2588 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2589 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2590 if (noside
== EVAL_SKIP
)
2591 return eval_skip_value (exp
);
2592 if (binop_user_defined_p (op
, arg1
, arg2
))
2594 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2598 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2599 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2600 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2601 return value_from_longest (type
, (LONGEST
) tem
);
2605 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2606 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2607 if (noside
== EVAL_SKIP
)
2608 return eval_skip_value (exp
);
2609 type
= check_typedef (value_type (arg2
));
2610 if (TYPE_CODE (type
) != TYPE_CODE_INT
2611 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
2612 error (_("Non-integral right operand for \"@\" operator."));
2613 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2615 return allocate_repeat_value (value_type (arg1
),
2616 longest_to_int (value_as_long (arg2
)));
2619 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2622 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2623 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2626 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2627 if (noside
== EVAL_SKIP
)
2628 return eval_skip_value (exp
);
2629 if (unop_user_defined_p (op
, arg1
))
2630 return value_x_unop (arg1
, op
, noside
);
2633 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2634 return value_pos (arg1
);
2638 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2639 if (noside
== EVAL_SKIP
)
2640 return eval_skip_value (exp
);
2641 if (unop_user_defined_p (op
, arg1
))
2642 return value_x_unop (arg1
, op
, noside
);
2645 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2646 return value_neg (arg1
);
2649 case UNOP_COMPLEMENT
:
2650 /* C++: check for and handle destructor names. */
2652 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2653 if (noside
== EVAL_SKIP
)
2654 return eval_skip_value (exp
);
2655 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2656 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2659 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2660 return value_complement (arg1
);
2663 case UNOP_LOGICAL_NOT
:
2664 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2665 if (noside
== EVAL_SKIP
)
2666 return eval_skip_value (exp
);
2667 if (unop_user_defined_p (op
, arg1
))
2668 return value_x_unop (arg1
, op
, noside
);
2671 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2672 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2676 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2677 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2678 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2679 type
= check_typedef (value_type (arg1
));
2680 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2681 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2682 error (_("Attempt to dereference pointer "
2683 "to member without an object"));
2684 if (noside
== EVAL_SKIP
)
2685 return eval_skip_value (exp
);
2686 if (unop_user_defined_p (op
, arg1
))
2687 return value_x_unop (arg1
, op
, noside
);
2688 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2690 type
= check_typedef (value_type (arg1
));
2691 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2692 || TYPE_IS_REFERENCE (type
)
2693 /* In C you can dereference an array to get the 1st elt. */
2694 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2696 return value_zero (TYPE_TARGET_TYPE (type
),
2698 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2699 /* GDB allows dereferencing an int. */
2700 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2703 error (_("Attempt to take contents of a non-pointer value."));
2706 /* Allow * on an integer so we can cast it to whatever we want.
2707 This returns an int, which seems like the most C-like thing to
2708 do. "long long" variables are rare enough that
2709 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2710 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2711 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2712 (CORE_ADDR
) value_as_address (arg1
));
2713 return value_ind (arg1
);
2716 /* C++: check for and handle pointer to members. */
2718 if (noside
== EVAL_SKIP
)
2720 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2721 return eval_skip_value (exp
);
2725 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2732 if (noside
== EVAL_SKIP
)
2734 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2735 return eval_skip_value (exp
);
2737 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2741 type
= value_type (evaluate_subexp (NULL_TYPE
, exp
, pos
,
2742 EVAL_AVOID_SIDE_EFFECTS
));
2743 /* FIXME: This should be size_t. */
2744 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2745 ULONGEST align
= type_align (type
);
2747 error (_("could not determine alignment of type"));
2748 return value_from_longest (size_type
, align
);
2753 type
= exp
->elts
[pc
+ 1].type
;
2754 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2756 case UNOP_CAST_TYPE
:
2757 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2758 type
= value_type (arg1
);
2759 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2761 case UNOP_DYNAMIC_CAST
:
2762 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2763 type
= value_type (arg1
);
2764 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2765 if (noside
== EVAL_SKIP
)
2766 return eval_skip_value (exp
);
2767 return value_dynamic_cast (type
, arg1
);
2769 case UNOP_REINTERPRET_CAST
:
2770 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2771 type
= value_type (arg1
);
2772 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2773 if (noside
== EVAL_SKIP
)
2774 return eval_skip_value (exp
);
2775 return value_reinterpret_cast (type
, arg1
);
2779 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2780 if (noside
== EVAL_SKIP
)
2781 return eval_skip_value (exp
);
2782 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2783 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2785 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2786 value_as_address (arg1
));
2788 case UNOP_MEMVAL_TYPE
:
2789 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2790 type
= value_type (arg1
);
2791 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2792 if (noside
== EVAL_SKIP
)
2793 return eval_skip_value (exp
);
2794 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2795 return value_zero (type
, lval_memory
);
2797 return value_at_lazy (type
, value_as_address (arg1
));
2799 case UNOP_PREINCREMENT
:
2800 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2801 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2803 else if (unop_user_defined_p (op
, arg1
))
2805 return value_x_unop (arg1
, op
, noside
);
2809 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2810 arg2
= value_ptradd (arg1
, 1);
2813 struct value
*tmp
= arg1
;
2815 arg2
= value_one (value_type (arg1
));
2816 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2817 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2820 return value_assign (arg1
, arg2
);
2823 case UNOP_PREDECREMENT
:
2824 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2825 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2827 else if (unop_user_defined_p (op
, arg1
))
2829 return value_x_unop (arg1
, op
, noside
);
2833 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2834 arg2
= value_ptradd (arg1
, -1);
2837 struct value
*tmp
= arg1
;
2839 arg2
= value_one (value_type (arg1
));
2840 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2841 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2844 return value_assign (arg1
, arg2
);
2847 case UNOP_POSTINCREMENT
:
2848 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2849 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2851 else if (unop_user_defined_p (op
, arg1
))
2853 return value_x_unop (arg1
, op
, noside
);
2857 arg3
= value_non_lval (arg1
);
2859 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2860 arg2
= value_ptradd (arg1
, 1);
2863 struct value
*tmp
= arg1
;
2865 arg2
= value_one (value_type (arg1
));
2866 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2867 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2870 value_assign (arg1
, arg2
);
2874 case UNOP_POSTDECREMENT
:
2875 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2876 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2878 else if (unop_user_defined_p (op
, arg1
))
2880 return value_x_unop (arg1
, op
, noside
);
2884 arg3
= value_non_lval (arg1
);
2886 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2887 arg2
= value_ptradd (arg1
, -1);
2890 struct value
*tmp
= arg1
;
2892 arg2
= value_one (value_type (arg1
));
2893 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2894 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2897 value_assign (arg1
, arg2
);
2903 return value_of_this (exp
->language_defn
);
2906 /* The value is not supposed to be used. This is here to make it
2907 easier to accommodate expressions that contain types. */
2909 if (noside
== EVAL_SKIP
)
2910 return eval_skip_value (exp
);
2911 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2912 return allocate_value (exp
->elts
[pc
+ 1].type
);
2914 error (_("Attempt to use a type name as an expression"));
2918 if (noside
== EVAL_SKIP
)
2920 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2921 return eval_skip_value (exp
);
2923 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2925 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2926 struct value
*result
;
2928 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2929 EVAL_AVOID_SIDE_EFFECTS
);
2931 /* 'decltype' has special semantics for lvalues. */
2932 if (op
== OP_DECLTYPE
2933 && (sub_op
== BINOP_SUBSCRIPT
2934 || sub_op
== STRUCTOP_MEMBER
2935 || sub_op
== STRUCTOP_MPTR
2936 || sub_op
== UNOP_IND
2937 || sub_op
== STRUCTOP_STRUCT
2938 || sub_op
== STRUCTOP_PTR
2939 || sub_op
== OP_SCOPE
))
2941 type
= value_type (result
);
2943 if (!TYPE_IS_REFERENCE (type
))
2945 type
= lookup_lvalue_reference_type (type
);
2946 result
= allocate_value (type
);
2953 error (_("Attempt to use a type as an expression"));
2957 struct value
*result
;
2958 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2960 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2961 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2962 EVAL_AVOID_SIDE_EFFECTS
);
2964 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2966 if (noside
!= EVAL_NORMAL
)
2967 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2969 return cplus_typeid (result
);
2973 /* Removing this case and compiling with gcc -Wall reveals that
2974 a lot of cases are hitting this case. Some of these should
2975 probably be removed from expression.h; others are legitimate
2976 expressions which are (apparently) not fully implemented.
2978 If there are any cases landing here which mean a user error,
2979 then they should be separate cases, with more descriptive
2982 error (_("GDB does not (yet) know how to "
2983 "evaluate that kind of expression"));
2986 gdb_assert_not_reached ("missed return?");
2989 /* Evaluate a subexpression of EXP, at index *POS,
2990 and return the address of that subexpression.
2991 Advance *POS over the subexpression.
2992 If the subexpression isn't an lvalue, get an error.
2993 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2994 then only the type of the result need be correct. */
2996 static struct value
*
2997 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
3007 op
= exp
->elts
[pc
].opcode
;
3013 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3015 /* We can't optimize out "&*" if there's a user-defined operator*. */
3016 if (unop_user_defined_p (op
, x
))
3018 x
= value_x_unop (x
, op
, noside
);
3019 goto default_case_after_eval
;
3022 return coerce_array (x
);
3026 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
3027 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
3029 case UNOP_MEMVAL_TYPE
:
3034 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3035 type
= value_type (x
);
3036 return value_cast (lookup_pointer_type (type
),
3037 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
3041 var
= exp
->elts
[pc
+ 2].symbol
;
3043 /* C++: The "address" of a reference should yield the address
3044 * of the object pointed to. Let value_addr() deal with it. */
3045 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
3049 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3052 lookup_pointer_type (SYMBOL_TYPE (var
));
3053 enum address_class sym_class
= SYMBOL_CLASS (var
);
3055 if (sym_class
== LOC_CONST
3056 || sym_class
== LOC_CONST_BYTES
3057 || sym_class
== LOC_REGISTER
)
3058 error (_("Attempt to take address of register or constant."));
3061 value_zero (type
, not_lval
);
3064 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3066 case OP_VAR_MSYM_VALUE
:
3070 value
*val
= evaluate_var_msym_value (noside
,
3071 exp
->elts
[pc
+ 1].objfile
,
3072 exp
->elts
[pc
+ 2].msymbol
);
3073 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3075 struct type
*type
= lookup_pointer_type (value_type (val
));
3076 return value_zero (type
, not_lval
);
3079 return value_addr (val
);
3083 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3084 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3085 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3086 &exp
->elts
[pc
+ 3].string
,
3089 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3094 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3095 default_case_after_eval
:
3096 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3098 struct type
*type
= check_typedef (value_type (x
));
3100 if (TYPE_IS_REFERENCE (type
))
3101 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3103 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3104 return value_zero (lookup_pointer_type (value_type (x
)),
3107 error (_("Attempt to take address of "
3108 "value not located in memory."));
3110 return value_addr (x
);
3114 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3115 When used in contexts where arrays will be coerced anyway, this is
3116 equivalent to `evaluate_subexp' but much faster because it avoids
3117 actually fetching array contents (perhaps obsolete now that we have
3120 Note that we currently only do the coercion for C expressions, where
3121 arrays are zero based and the coercion is correct. For other languages,
3122 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3123 to decide if coercion is appropriate. */
3126 evaluate_subexp_with_coercion (struct expression
*exp
,
3127 int *pos
, enum noside noside
)
3136 op
= exp
->elts
[pc
].opcode
;
3141 var
= exp
->elts
[pc
+ 2].symbol
;
3142 type
= check_typedef (SYMBOL_TYPE (var
));
3143 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3144 && !TYPE_VECTOR (type
)
3145 && CAST_IS_CONVERSION (exp
->language_defn
))
3148 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3149 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3155 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3159 /* Evaluate a subexpression of EXP, at index *POS,
3160 and return a value for the size of that subexpression.
3161 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3162 we allow side-effects on the operand if its type is a variable
3165 static struct value
*
3166 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3169 /* FIXME: This should be size_t. */
3170 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3177 op
= exp
->elts
[pc
].opcode
;
3181 /* This case is handled specially
3182 so that we avoid creating a value for the result type.
3183 If the result type is very big, it's desirable not to
3184 create a value unnecessarily. */
3187 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3188 type
= check_typedef (value_type (val
));
3189 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3190 && !TYPE_IS_REFERENCE (type
)
3191 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3192 error (_("Attempt to take contents of a non-pointer value."));
3193 type
= TYPE_TARGET_TYPE (type
);
3194 if (is_dynamic_type (type
))
3195 type
= value_type (value_ind (val
));
3196 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3200 type
= exp
->elts
[pc
+ 1].type
;
3203 case UNOP_MEMVAL_TYPE
:
3205 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3206 type
= value_type (val
);
3210 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3211 if (is_dynamic_type (type
))
3213 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3214 type
= value_type (val
);
3215 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3216 && is_dynamic_type (TYPE_INDEX_TYPE (type
))
3217 && TYPE_HIGH_BOUND_UNDEFINED (TYPE_INDEX_TYPE (type
)))
3218 return allocate_optimized_out_value (size_type
);
3224 case OP_VAR_MSYM_VALUE
:
3228 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3229 value
*mval
= evaluate_var_msym_value (noside
,
3230 exp
->elts
[pc
+ 1].objfile
,
3233 type
= value_type (mval
);
3234 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
)
3235 error_unknown_type (msymbol
->print_name ());
3237 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3241 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3242 type of the subscript is a variable length array type. In this case we
3243 must re-evaluate the right hand side of the subscription to allow
3245 case BINOP_SUBSCRIPT
:
3246 if (noside
== EVAL_NORMAL
)
3248 int npc
= (*pos
) + 1;
3250 val
= evaluate_subexp (NULL_TYPE
, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3251 type
= check_typedef (value_type (val
));
3252 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3254 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3255 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3257 type
= TYPE_INDEX_TYPE (type
);
3258 /* Only re-evaluate the right hand side if the resulting type
3259 is a variable length type. */
3260 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3262 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3263 return value_from_longest
3264 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3273 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3274 type
= value_type (val
);
3278 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3279 "When applied to a reference or a reference type, the result is
3280 the size of the referenced type." */
3281 type
= check_typedef (type
);
3282 if (exp
->language_defn
->la_language
== language_cplus
3283 && (TYPE_IS_REFERENCE (type
)))
3284 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3285 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3288 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3289 for that subexpression cast to TO_TYPE. Advance *POS over the
3293 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3295 struct type
*to_type
)
3299 /* Don't let symbols be evaluated with evaluate_subexp because that
3300 throws an "unknown type" error for no-debug data symbols.
3301 Instead, we want the cast to reinterpret the symbol. */
3302 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3303 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3308 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3310 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3311 return value_zero (to_type
, not_lval
);
3313 val
= evaluate_var_msym_value (noside
,
3314 exp
->elts
[pc
+ 1].objfile
,
3315 exp
->elts
[pc
+ 2].msymbol
);
3318 val
= evaluate_var_value (noside
,
3319 exp
->elts
[pc
+ 1].block
,
3320 exp
->elts
[pc
+ 2].symbol
);
3322 if (noside
== EVAL_SKIP
)
3323 return eval_skip_value (exp
);
3325 val
= value_cast (to_type
, val
);
3327 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3328 if (VALUE_LVAL (val
) == lval_memory
)
3330 if (value_lazy (val
))
3331 value_fetch_lazy (val
);
3332 VALUE_LVAL (val
) = not_lval
;
3337 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3338 if (noside
== EVAL_SKIP
)
3339 return eval_skip_value (exp
);
3340 return value_cast (to_type
, val
);
3343 /* Parse a type expression in the string [P..P+LENGTH). */
3346 parse_and_eval_type (char *p
, int length
)
3348 char *tmp
= (char *) alloca (length
+ 4);
3351 memcpy (tmp
+ 1, p
, length
);
3352 tmp
[length
+ 1] = ')';
3353 tmp
[length
+ 2] = '0';
3354 tmp
[length
+ 3] = '\0';
3355 expression_up expr
= parse_expression (tmp
);
3356 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3357 error (_("Internal error in eval_type."));
3358 return expr
->elts
[1].type
;
3362 calc_f77_array_dims (struct type
*array_type
)
3365 struct type
*tmp_type
;
3367 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3368 error (_("Can't get dimensions for a non-array type"));
3370 tmp_type
= array_type
;
3372 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3374 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)