1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2018 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 /* This is defined in valops.c */
46 extern int overload_resolution
;
48 /* Prototypes for local functions. */
50 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
53 static struct value
*evaluate_subexp_for_address (struct expression
*,
56 static value
*evaluate_subexp_for_cast (expression
*exp
, int *pos
,
60 static struct value
*evaluate_struct_tuple (struct value
*,
61 struct expression
*, int *,
64 static LONGEST
init_array_element (struct value
*, struct value
*,
65 struct expression
*, int *, enum noside
,
69 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
70 int *pos
, enum noside noside
)
74 gdb::optional
<enable_thread_stack_temporaries
> stack_temporaries
;
75 if (*pos
== 0 && target_has_execution
76 && exp
->language_defn
->la_language
== language_cplus
77 && !thread_stack_temporaries_enabled_p (inferior_thread ()))
78 stack_temporaries
.emplace (inferior_thread ());
80 retval
= (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
81 (expect_type
, exp
, pos
, noside
);
83 if (stack_temporaries
.has_value ()
84 && value_in_thread_stack_temporaries (retval
, inferior_thread ()))
85 retval
= value_non_lval (retval
);
90 /* Parse the string EXP as a C expression, evaluate it,
91 and return the result as a number. */
94 parse_and_eval_address (const char *exp
)
96 expression_up expr
= parse_expression (exp
);
98 return value_as_address (evaluate_expression (expr
.get ()));
101 /* Like parse_and_eval_address, but treats the value of the expression
102 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
104 parse_and_eval_long (const char *exp
)
106 expression_up expr
= parse_expression (exp
);
108 return value_as_long (evaluate_expression (expr
.get ()));
112 parse_and_eval (const char *exp
)
114 expression_up expr
= parse_expression (exp
);
116 return evaluate_expression (expr
.get ());
119 /* Parse up to a comma (or to a closeparen)
120 in the string EXPP as an expression, evaluate it, and return the value.
121 EXPP is advanced to point to the comma. */
124 parse_to_comma_and_eval (const char **expp
)
126 expression_up expr
= parse_exp_1 (expp
, 0, (struct block
*) 0, 1);
128 return evaluate_expression (expr
.get ());
131 /* Evaluate an expression in internal prefix form
132 such as is constructed by parse.y.
134 See expression.h for info on the format of an expression. */
137 evaluate_expression (struct expression
*exp
)
141 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
144 /* Evaluate an expression, avoiding all memory references
145 and getting a value whose type alone is correct. */
148 evaluate_type (struct expression
*exp
)
152 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
155 /* Evaluate a subexpression, avoiding all memory references and
156 getting a value whose type alone is correct. */
159 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
161 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
164 /* Find the current value of a watchpoint on EXP. Return the value in
165 *VALP and *RESULTP and the chain of intermediate and final values
166 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
169 If PRESERVE_ERRORS is true, then exceptions are passed through.
170 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
171 occurs while evaluating the expression, *RESULTP will be set to
172 NULL. *RESULTP may be a lazy value, if the result could not be
173 read from memory. It is used to determine whether a value is
174 user-specified (we should watch the whole value) or intermediate
175 (we should watch only the bit used to locate the final value).
177 If the final value, or any intermediate value, could not be read
178 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
179 set to any referenced values. *VALP will never be a lazy value.
180 This is the value which we store in struct breakpoint.
182 If VAL_CHAIN is non-NULL, the values put into *VAL_CHAIN will be
183 released from the value chain. If VAL_CHAIN is NULL, all generated
184 values will be left on the value chain. */
187 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
188 struct value
**resultp
,
189 std::vector
<value_ref_ptr
> *val_chain
,
192 struct value
*mark
, *new_mark
, *result
;
200 /* Evaluate the expression. */
201 mark
= value_mark ();
206 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
208 CATCH (ex
, RETURN_MASK_ALL
)
210 /* Ignore memory errors if we want watchpoints pointing at
211 inaccessible memory to still be created; otherwise, throw the
212 error to some higher catcher. */
216 if (!preserve_errors
)
220 throw_exception (ex
);
226 new_mark
= value_mark ();
227 if (mark
== new_mark
)
232 /* Make sure it's not lazy, so that after the target stops again we
233 have a non-lazy previous value to compare with. */
236 if (!value_lazy (result
))
243 value_fetch_lazy (result
);
246 CATCH (except
, RETURN_MASK_ERROR
)
255 /* Return the chain of intermediate values. We use this to
256 decide which addresses to watch. */
257 *val_chain
= value_release_to_mark (mark
);
261 /* Extract a field operation from an expression. If the subexpression
262 of EXP starting at *SUBEXP is not a structure dereference
263 operation, return NULL. Otherwise, return the name of the
264 dereferenced field, and advance *SUBEXP to point to the
265 subexpression of the left-hand-side of the dereference. This is
266 used when completing field names. */
269 extract_field_op (struct expression
*exp
, int *subexp
)
274 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
275 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
277 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
278 result
= &exp
->elts
[*subexp
+ 2].string
;
279 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
283 /* This function evaluates brace-initializers (in C/C++) for
286 static struct value
*
287 evaluate_struct_tuple (struct value
*struct_val
,
288 struct expression
*exp
,
289 int *pos
, enum noside noside
, int nargs
)
291 struct type
*struct_type
= check_typedef (value_type (struct_val
));
292 struct type
*field_type
;
297 struct value
*val
= NULL
;
302 /* Skip static fields. */
303 while (fieldno
< TYPE_NFIELDS (struct_type
)
304 && field_is_static (&TYPE_FIELD (struct_type
,
307 if (fieldno
>= TYPE_NFIELDS (struct_type
))
308 error (_("too many initializers"));
309 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
310 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
311 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
312 error (_("don't know which variant you want to set"));
314 /* Here, struct_type is the type of the inner struct,
315 while substruct_type is the type of the inner struct.
316 These are the same for normal structures, but a variant struct
317 contains anonymous union fields that contain substruct fields.
318 The value fieldno is the index of the top-level (normal or
319 anonymous union) field in struct_field, while the value
320 subfieldno is the index of the actual real (named inner) field
321 in substruct_type. */
323 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
325 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
327 /* Now actually set the field in struct_val. */
329 /* Assign val to field fieldno. */
330 if (value_type (val
) != field_type
)
331 val
= value_cast (field_type
, val
);
333 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
334 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
335 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
337 modify_field (struct_type
, addr
,
338 value_as_long (val
), bitpos
% 8, bitsize
);
340 memcpy (addr
, value_contents (val
),
341 TYPE_LENGTH (value_type (val
)));
347 /* Recursive helper function for setting elements of array tuples.
348 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
349 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
350 Evaluates index expresions and sets the specified element(s) of
351 ARRAY to ELEMENT. Returns last index value. */
354 init_array_element (struct value
*array
, struct value
*element
,
355 struct expression
*exp
, int *pos
,
356 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
359 int element_size
= TYPE_LENGTH (value_type (element
));
361 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
364 init_array_element (array
, element
, exp
, pos
, noside
,
365 low_bound
, high_bound
);
366 return init_array_element (array
, element
,
367 exp
, pos
, noside
, low_bound
, high_bound
);
371 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
372 if (index
< low_bound
|| index
> high_bound
)
373 error (_("tuple index out of range"));
374 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
375 value_contents (element
), element_size
);
380 static struct value
*
381 value_f90_subarray (struct value
*array
,
382 struct expression
*exp
, int *pos
, enum noside noside
)
385 LONGEST low_bound
, high_bound
;
386 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
387 enum range_type range_type
388 = (enum range_type
) longest_to_int (exp
->elts
[pc
].longconst
);
392 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
393 low_bound
= TYPE_LOW_BOUND (range
);
395 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
397 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
398 high_bound
= TYPE_HIGH_BOUND (range
);
400 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
402 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
406 /* Promote value ARG1 as appropriate before performing a unary operation
408 If the result is not appropriate for any particular language then it
409 needs to patch this function. */
412 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
417 *arg1
= coerce_ref (*arg1
);
418 type1
= check_typedef (value_type (*arg1
));
420 if (is_integral_type (type1
))
422 switch (language
->la_language
)
425 /* Perform integral promotion for ANSI C/C++.
426 If not appropropriate for any particular language
427 it needs to modify this function. */
429 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
431 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
432 *arg1
= value_cast (builtin_int
, *arg1
);
439 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
440 operation on those two operands.
441 If the result is not appropriate for any particular language then it
442 needs to patch this function. */
445 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
446 struct value
**arg1
, struct value
**arg2
)
448 struct type
*promoted_type
= NULL
;
452 *arg1
= coerce_ref (*arg1
);
453 *arg2
= coerce_ref (*arg2
);
455 type1
= check_typedef (value_type (*arg1
));
456 type2
= check_typedef (value_type (*arg2
));
458 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
459 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
460 && !is_integral_type (type1
))
461 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
462 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
463 && !is_integral_type (type2
)))
466 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
467 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
469 /* No promotion required. */
471 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
472 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
474 switch (language
->la_language
)
480 case language_opencl
:
481 /* No promotion required. */
485 /* For other languages the result type is unchanged from gdb
486 version 6.7 for backward compatibility.
487 If either arg was long double, make sure that value is also long
488 double. Otherwise use double. */
489 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
490 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
491 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
493 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
497 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
498 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
500 /* No promotion required. */
503 /* Integral operations here. */
504 /* FIXME: Also mixed integral/booleans, with result an integer. */
506 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
507 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
508 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
509 int is_unsigned1
= TYPE_UNSIGNED (type1
);
510 int is_unsigned2
= TYPE_UNSIGNED (type2
);
511 unsigned int result_len
;
512 int unsigned_operation
;
514 /* Determine type length and signedness after promotion for
516 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
519 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
521 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
524 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
527 if (promoted_len1
> promoted_len2
)
529 unsigned_operation
= is_unsigned1
;
530 result_len
= promoted_len1
;
532 else if (promoted_len2
> promoted_len1
)
534 unsigned_operation
= is_unsigned2
;
535 result_len
= promoted_len2
;
539 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
540 result_len
= promoted_len1
;
543 switch (language
->la_language
)
549 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
551 promoted_type
= (unsigned_operation
552 ? builtin
->builtin_unsigned_int
553 : builtin
->builtin_int
);
555 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
557 promoted_type
= (unsigned_operation
558 ? builtin
->builtin_unsigned_long
559 : builtin
->builtin_long
);
563 promoted_type
= (unsigned_operation
564 ? builtin
->builtin_unsigned_long_long
565 : builtin
->builtin_long_long
);
568 case language_opencl
:
569 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
570 (language
, gdbarch
, "int")))
574 ? lookup_unsigned_typename (language
, gdbarch
, "int")
575 : lookup_signed_typename (language
, gdbarch
, "int"));
577 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
578 (language
, gdbarch
, "long")))
582 ? lookup_unsigned_typename (language
, gdbarch
, "long")
583 : lookup_signed_typename (language
, gdbarch
,"long"));
587 /* For other languages the result type is unchanged from gdb
588 version 6.7 for backward compatibility.
589 If either arg was long long, make sure that value is also long
590 long. Otherwise use long. */
591 if (unsigned_operation
)
593 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
594 promoted_type
= builtin
->builtin_unsigned_long_long
;
596 promoted_type
= builtin
->builtin_unsigned_long
;
600 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
601 promoted_type
= builtin
->builtin_long_long
;
603 promoted_type
= builtin
->builtin_long
;
611 /* Promote both operands to common type. */
612 *arg1
= value_cast (promoted_type
, *arg1
);
613 *arg2
= value_cast (promoted_type
, *arg2
);
618 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
620 type
= check_typedef (type
);
621 if (TYPE_IS_REFERENCE (type
))
622 type
= TYPE_TARGET_TYPE (type
);
624 switch (TYPE_CODE (type
))
630 case TYPE_CODE_ARRAY
:
631 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
638 /* Represents a fake method with the given parameter types. This is
639 used by the parser to construct a temporary "expected" type for
640 method overload resolution. FLAGS is used as instance flags of the
641 new type, in order to be able to make the new type represent a
642 const/volatile overload. */
647 fake_method (type_instance_flags flags
,
648 int num_types
, struct type
**param_types
);
651 /* The constructed type. */
652 struct type
*type () { return &m_type
; }
655 struct type m_type
{};
656 main_type m_main_type
{};
659 fake_method::fake_method (type_instance_flags flags
,
660 int num_types
, struct type
**param_types
)
662 struct type
*type
= &m_type
;
664 TYPE_MAIN_TYPE (type
) = &m_main_type
;
665 TYPE_LENGTH (type
) = 1;
666 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
667 TYPE_CHAIN (type
) = type
;
668 TYPE_INSTANCE_FLAGS (type
) = flags
;
671 if (param_types
[num_types
- 1] == NULL
)
674 TYPE_VARARGS (type
) = 1;
676 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
680 /* Caller should have ensured this. */
681 gdb_assert (num_types
== 0);
682 TYPE_PROTOTYPED (type
) = 1;
686 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
687 neither an objfile nor a gdbarch. As a result we must manually
688 allocate memory for auxiliary fields, and free the memory ourselves
689 when we are done with it. */
690 TYPE_NFIELDS (type
) = num_types
;
691 TYPE_FIELDS (type
) = (struct field
*)
692 xzalloc (sizeof (struct field
) * num_types
);
694 while (num_types
-- > 0)
695 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
698 fake_method::~fake_method ()
700 xfree (TYPE_FIELDS (&m_type
));
703 /* Helper for evaluating an OP_VAR_VALUE. */
706 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
708 /* JYG: We used to just return value_zero of the symbol type if
709 we're asked to avoid side effects. Otherwise we return
710 value_of_variable (...). However I'm not sure if
711 value_of_variable () has any side effect. We need a full value
712 object returned here for whatis_exp () to call evaluate_type ()
713 and then pass the full value to value_rtti_target_type () if we
714 are dealing with a pointer or reference to a base class and print
717 struct value
*ret
= NULL
;
721 ret
= value_of_variable (var
, blk
);
724 CATCH (except
, RETURN_MASK_ERROR
)
726 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
727 throw_exception (except
);
729 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
736 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
739 evaluate_var_msym_value (enum noside noside
,
740 struct objfile
*objfile
, minimal_symbol
*msymbol
)
743 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
745 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !TYPE_GNU_IFUNC (the_type
))
746 return value_zero (the_type
, not_lval
);
748 return value_at_lazy (the_type
, address
);
751 /* Helper for returning a value when handling EVAL_SKIP. */
754 eval_skip_value (expression
*exp
)
756 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
759 /* Evaluate a function call. The function to be called is in
760 ARGVEC[0] and the arguments passed to the function are in
761 ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
762 known. DEFAULT_RETURN_TYPE is used as the function's return type
763 if the return type is unknown. */
766 eval_call (expression
*exp
, enum noside noside
,
767 int nargs
, value
**argvec
,
768 const char *function_name
,
769 type
*default_return_type
)
771 if (argvec
[0] == NULL
)
772 error (_("Cannot evaluate function -- may be inlined"));
773 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
775 /* If the return type doesn't look like a function type,
776 call an error. This can happen if somebody tries to turn
777 a variable into a function call. */
779 type
*ftype
= value_type (argvec
[0]);
781 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
783 /* We don't know anything about what the internal
784 function might return, but we have to return
786 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
789 else if (TYPE_CODE (ftype
) == TYPE_CODE_XMETHOD
)
792 = result_type_of_xmethod (argvec
[0], nargs
, argvec
+ 1);
794 if (return_type
== NULL
)
795 error (_("Xmethod is missing return type."));
796 return value_zero (return_type
, not_lval
);
798 else if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
799 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
801 if (TYPE_GNU_IFUNC (ftype
))
803 CORE_ADDR address
= value_address (argvec
[0]);
804 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
806 if (resolved_type
!= NULL
)
807 ftype
= resolved_type
;
810 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
812 if (return_type
== NULL
)
813 return_type
= default_return_type
;
815 if (return_type
== NULL
)
816 error_call_unknown_return_type (function_name
);
818 return allocate_value (return_type
);
821 error (_("Expression of type other than "
822 "\"Function returning ...\" used as function"));
824 switch (TYPE_CODE (value_type (argvec
[0])))
826 case TYPE_CODE_INTERNAL_FUNCTION
:
827 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
828 argvec
[0], nargs
, argvec
+ 1);
829 case TYPE_CODE_XMETHOD
:
830 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
832 return call_function_by_hand (argvec
[0], default_return_type
,
837 /* Helper for evaluating an OP_FUNCALL. */
840 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
848 symbol
*function
= NULL
;
849 char *function_name
= NULL
;
850 const char *var_func_name
= NULL
;
855 exp_opcode op
= exp
->elts
[*pos
].opcode
;
856 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
857 /* Allocate arg vector, including space for the function to be
858 called in argvec[0], a potential `this', and a terminating
860 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
861 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
863 /* First, evaluate the structure into arg2. */
866 if (op
== STRUCTOP_MEMBER
)
868 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
872 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
875 /* If the function is a virtual function, then the aggregate
876 value (providing the structure) plays its part by providing
877 the vtable. Otherwise, it is just along for the ride: call
878 the function directly. */
880 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
882 type
*a1_type
= check_typedef (value_type (arg1
));
883 if (noside
== EVAL_SKIP
)
884 tem
= 1; /* Set it to the right arg index so that all
885 arguments can also be skipped. */
886 else if (TYPE_CODE (a1_type
) == TYPE_CODE_METHODPTR
)
888 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
889 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
891 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
893 /* Now, say which argument to start evaluating from. */
898 else if (TYPE_CODE (a1_type
) == TYPE_CODE_MEMBERPTR
)
900 struct type
*type_ptr
901 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
902 struct type
*target_type_ptr
903 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
905 /* Now, convert these values to an address. */
906 arg2
= value_cast (type_ptr
, arg2
);
908 long mem_offset
= value_as_long (arg1
);
910 arg1
= value_from_pointer (target_type_ptr
,
911 value_as_long (arg2
) + mem_offset
);
912 arg1
= value_ind (arg1
);
916 error (_("Non-pointer-to-member value used in pointer-to-member "
919 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
921 /* Hair for method invocations. */
925 /* First, evaluate the structure into arg2. */
927 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
928 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
930 if (op
== STRUCTOP_STRUCT
)
932 /* If v is a variable in a register, and the user types
933 v.method (), this will produce an error, because v has no
936 A possible way around this would be to allocate a copy of
937 the variable on the stack, copy in the contents, call the
938 function, and copy out the contents. I.e. convert this
939 from call by reference to call by copy-return (or
940 whatever it's called). However, this does not work
941 because it is not the same: the method being called could
942 stash a copy of the address, and then future uses through
943 that address (after the method returns) would be expected
944 to use the variable itself, not some copy of it. */
945 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
949 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
951 /* Check to see if the operator '->' has been overloaded.
952 If the operator has been overloaded replace arg2 with the
953 value returned by the custom operator and continue
955 while (unop_user_defined_p (op
, arg2
))
957 struct value
*value
= NULL
;
960 value
= value_x_unop (arg2
, op
, noside
);
963 CATCH (except
, RETURN_MASK_ERROR
)
965 if (except
.error
== NOT_FOUND_ERROR
)
968 throw_exception (except
);
975 /* Now, say which argument to start evaluating from. */
978 else if (op
== OP_SCOPE
979 && overload_resolution
980 && (exp
->language_defn
->la_language
== language_cplus
))
982 /* Unpack it locally so we can properly handle overload
988 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
989 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
990 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
991 name
= &exp
->elts
[pc2
+ 3].string
;
994 function_name
= NULL
;
995 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
997 function
= cp_lookup_symbol_namespace (TYPE_NAME (type
),
999 get_selected_block (0),
1001 if (function
== NULL
)
1002 error (_("No symbol \"%s\" in namespace \"%s\"."),
1003 name
, TYPE_NAME (type
));
1006 /* arg2 is left as NULL on purpose. */
1010 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1011 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1012 function_name
= name
;
1014 /* We need a properly typed value for method lookup. For
1015 static methods arg2 is otherwise unused. */
1016 arg2
= value_zero (type
, lval_memory
);
1021 else if (op
== OP_ADL_FUNC
)
1023 /* Save the function position and move pos so that the arguments
1024 can be evaluated. */
1030 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1031 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1035 /* Non-method function call. */
1039 /* If this is a C++ function wait until overload resolution. */
1040 if (op
== OP_VAR_VALUE
1041 && overload_resolution
1042 && (exp
->language_defn
->la_language
== language_cplus
))
1044 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1049 if (op
== OP_VAR_MSYM_VALUE
)
1051 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1052 var_func_name
= MSYMBOL_PRINT_NAME (msym
);
1054 else if (op
== OP_VAR_VALUE
)
1056 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1057 var_func_name
= SYMBOL_PRINT_NAME (sym
);
1060 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1061 type
*type
= value_type (argvec
[0]);
1062 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1063 type
= TYPE_TARGET_TYPE (type
);
1064 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1066 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1068 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1076 /* Evaluate arguments (if not already done, e.g., namespace::func()
1077 and overload-resolution is off). */
1078 for (; tem
<= nargs
; tem
++)
1080 /* Ensure that array expressions are coerced into pointer
1082 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1085 /* Signal end of arglist. */
1088 if (noside
== EVAL_SKIP
)
1089 return eval_skip_value (exp
);
1091 if (op
== OP_ADL_FUNC
)
1093 struct symbol
*symp
;
1096 int string_pc
= save_pos1
+ 3;
1098 /* Extract the function name. */
1099 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1100 func_name
= (char *) alloca (name_len
+ 1);
1101 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1103 find_overload_match (&argvec
[1], nargs
, func_name
,
1104 NON_METHOD
, /* not method */
1105 NULL
, NULL
, /* pass NULL symbol since
1106 symbol is unknown */
1107 NULL
, &symp
, NULL
, 0, noside
);
1109 /* Now fix the expression being evaluated. */
1110 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1111 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1114 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1115 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1117 int static_memfuncp
;
1120 /* Method invocation: stuff "this" as first parameter. If the
1121 method turns out to be static we undo this below. */
1126 /* Name of method from expression. */
1127 tstr
= &exp
->elts
[pc2
+ 2].string
;
1130 tstr
= function_name
;
1132 if (overload_resolution
&& (exp
->language_defn
->la_language
1135 /* Language is C++, do some overload resolution before
1137 struct value
*valp
= NULL
;
1139 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1140 METHOD
, /* method */
1141 &arg2
, /* the object */
1143 &static_memfuncp
, 0, noside
);
1145 if (op
== OP_SCOPE
&& !static_memfuncp
)
1147 /* For the time being, we don't handle this. */
1148 error (_("Call to overloaded function %s requires "
1152 argvec
[1] = arg2
; /* the ``this'' pointer */
1153 argvec
[0] = valp
; /* Use the method found after overload
1157 /* Non-C++ case -- or no overload resolution. */
1159 struct value
*temp
= arg2
;
1161 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1163 op
== STRUCTOP_STRUCT
1164 ? "structure" : "structure pointer");
1165 /* value_struct_elt updates temp with the correct value of
1166 the ``this'' pointer if necessary, so modify argvec[1] to
1167 reflect any ``this'' changes. */
1169 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1170 value_address (temp
)
1171 + value_embedded_offset (temp
));
1172 argvec
[1] = arg2
; /* the ``this'' pointer */
1175 /* Take out `this' if needed. */
1176 if (static_memfuncp
)
1178 argvec
[1] = argvec
[0];
1183 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1185 /* Pointer to member. argvec[1] is already set up. */
1188 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1190 /* Non-member function being called. */
1191 /* fn: This can only be done for C++ functions. A C-style
1192 function in a C++ program, for instance, does not have the
1193 fields that are expected here. */
1195 if (overload_resolution
&& (exp
->language_defn
->la_language
1198 /* Language is C++, do some overload resolution before
1200 struct symbol
*symp
;
1203 /* If a scope has been specified disable ADL. */
1207 if (op
== OP_VAR_VALUE
)
1208 function
= exp
->elts
[save_pos1
+2].symbol
;
1210 (void) find_overload_match (&argvec
[1], nargs
,
1211 NULL
, /* no need for name */
1212 NON_METHOD
, /* not method */
1213 NULL
, function
, /* the function */
1214 NULL
, &symp
, NULL
, no_adl
, noside
);
1216 if (op
== OP_VAR_VALUE
)
1218 /* Now fix the expression being evaluated. */
1219 exp
->elts
[save_pos1
+2].symbol
= symp
;
1220 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1224 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1228 /* Not C++, or no overload resolution allowed. */
1229 /* Nothing to be done; argvec already correctly set up. */
1234 /* It is probably a C-style function. */
1235 /* Nothing to be done; argvec already correctly set up. */
1238 return eval_call (exp
, noside
, nargs
, argvec
, var_func_name
, expect_type
);
1241 /* Helper for skipping all the arguments in an undetermined argument list.
1242 This function was designed for use in the OP_F77_UNDETERMINED_ARGLIST
1243 case of evaluate_subexp_standard as multiple, but not all, code paths
1244 require a generic skip. */
1247 skip_undetermined_arglist (int nargs
, struct expression
*exp
, int *pos
,
1250 for (int i
= 0; i
< nargs
; ++i
)
1251 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1255 evaluate_subexp_standard (struct type
*expect_type
,
1256 struct expression
*exp
, int *pos
,
1260 int tem
, tem2
, tem3
;
1262 struct value
*arg1
= NULL
;
1263 struct value
*arg2
= NULL
;
1267 struct value
**argvec
;
1271 struct type
**arg_types
;
1274 op
= exp
->elts
[pc
].opcode
;
1279 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1280 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1281 if (noside
== EVAL_SKIP
)
1282 return eval_skip_value (exp
);
1283 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
1284 &exp
->elts
[pc
+ 3].string
,
1285 expect_type
, 0, noside
);
1287 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
1292 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1293 exp
->elts
[pc
+ 2].longconst
);
1297 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1298 exp
->elts
[pc
+ 2].floatconst
);
1304 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1305 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_ERROR
)
1306 error_unknown_type (SYMBOL_PRINT_NAME (var
));
1307 if (noside
!= EVAL_SKIP
)
1308 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1311 /* Return a dummy value of the correct type when skipping, so
1312 that parent functions know what is to be skipped. */
1313 return allocate_value (SYMBOL_TYPE (var
));
1317 case OP_VAR_MSYM_VALUE
:
1321 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1322 value
*val
= evaluate_var_msym_value (noside
,
1323 exp
->elts
[pc
+ 1].objfile
,
1326 type
= value_type (val
);
1327 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
1328 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| pc
!= 0))
1329 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol
));
1333 case OP_VAR_ENTRY_VALUE
:
1335 if (noside
== EVAL_SKIP
)
1336 return eval_skip_value (exp
);
1339 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1340 struct frame_info
*frame
;
1342 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1343 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1345 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1346 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1347 error (_("Symbol \"%s\" does not have any specific entry value"),
1348 SYMBOL_PRINT_NAME (sym
));
1350 frame
= get_selected_frame (NULL
);
1351 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1354 case OP_FUNC_STATIC_VAR
:
1355 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1356 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1357 if (noside
== EVAL_SKIP
)
1358 return eval_skip_value (exp
);
1361 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1362 CORE_ADDR addr
= value_address (func
);
1364 const block
*blk
= block_for_pc (addr
);
1365 const char *var
= &exp
->elts
[pc
+ 2].string
;
1367 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1369 if (sym
.symbol
== NULL
)
1370 error (_("No symbol \"%s\" in specified context."), var
);
1372 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1378 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1382 const char *name
= &exp
->elts
[pc
+ 2].string
;
1386 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1387 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1388 name
, strlen (name
));
1390 error (_("Register $%s not available."), name
);
1392 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1393 a value with the appropriate register type. Unfortunately,
1394 we don't have easy access to the type of user registers.
1395 So for these registers, we fetch the register value regardless
1396 of the evaluation mode. */
1397 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1398 && regno
< gdbarch_num_regs (exp
->gdbarch
)
1399 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
1400 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1402 val
= value_of_register (regno
, get_selected_frame (NULL
));
1404 error (_("Value of register %s not available."), name
);
1410 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1411 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1413 case OP_INTERNALVAR
:
1415 return value_of_internalvar (exp
->gdbarch
,
1416 exp
->elts
[pc
+ 1].internalvar
);
1419 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1420 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1421 if (noside
== EVAL_SKIP
)
1422 return eval_skip_value (exp
);
1423 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1424 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1426 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1427 NSString constant. */
1428 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1429 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1430 if (noside
== EVAL_SKIP
)
1431 return eval_skip_value (exp
);
1432 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1436 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1437 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1438 nargs
= tem3
- tem2
+ 1;
1439 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
1441 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1442 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1444 struct value
*rec
= allocate_value (expect_type
);
1446 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1447 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1450 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1451 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1453 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
1454 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1455 struct value
*array
= allocate_value (expect_type
);
1456 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1457 LONGEST low_bound
, high_bound
, index
;
1459 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1462 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1465 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1466 for (tem
= nargs
; --nargs
>= 0;)
1468 struct value
*element
;
1471 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1472 if (value_type (element
) != element_type
)
1473 element
= value_cast (element_type
, element
);
1476 int continue_pc
= *pos
;
1479 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1480 low_bound
, high_bound
);
1485 if (index
> high_bound
)
1486 /* To avoid memory corruption. */
1487 error (_("Too many array elements"));
1488 memcpy (value_contents_raw (array
)
1489 + (index
- low_bound
) * element_size
,
1490 value_contents (element
),
1498 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1499 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1501 struct value
*set
= allocate_value (expect_type
);
1502 gdb_byte
*valaddr
= value_contents_raw (set
);
1503 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1504 struct type
*check_type
= element_type
;
1505 LONGEST low_bound
, high_bound
;
1507 /* Get targettype of elementtype. */
1508 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1509 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1510 check_type
= TYPE_TARGET_TYPE (check_type
);
1512 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1513 error (_("(power)set type with unknown size"));
1514 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1515 for (tem
= 0; tem
< nargs
; tem
++)
1517 LONGEST range_low
, range_high
;
1518 struct type
*range_low_type
, *range_high_type
;
1519 struct value
*elem_val
;
1521 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1522 range_low_type
= range_high_type
= value_type (elem_val
);
1523 range_low
= range_high
= value_as_long (elem_val
);
1525 /* Check types of elements to avoid mixture of elements from
1526 different types. Also check if type of element is "compatible"
1527 with element type of powerset. */
1528 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1529 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1530 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1531 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1532 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1533 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1534 && (range_low_type
!= range_high_type
)))
1535 /* different element modes. */
1536 error (_("POWERSET tuple elements of different mode"));
1537 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1538 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1539 && range_low_type
!= check_type
))
1540 error (_("incompatible POWERSET tuple elements"));
1541 if (range_low
> range_high
)
1543 warning (_("empty POWERSET tuple range"));
1546 if (range_low
< low_bound
|| range_high
> high_bound
)
1547 error (_("POWERSET tuple element out of range"));
1548 range_low
-= low_bound
;
1549 range_high
-= low_bound
;
1550 for (; range_low
<= range_high
; range_low
++)
1552 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1554 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1555 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1556 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1563 argvec
= XALLOCAVEC (struct value
*, nargs
);
1564 for (tem
= 0; tem
< nargs
; tem
++)
1566 /* Ensure that array expressions are coerced into pointer
1568 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1570 if (noside
== EVAL_SKIP
)
1571 return eval_skip_value (exp
);
1572 return value_array (tem2
, tem3
, argvec
);
1576 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1578 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1580 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1582 if (noside
== EVAL_SKIP
)
1583 return eval_skip_value (exp
);
1584 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1588 /* Skip third and second args to evaluate the first one. */
1589 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1590 if (value_logical_not (arg1
))
1592 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1593 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1597 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1598 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1602 case OP_OBJC_SELECTOR
:
1603 { /* Objective C @selector operator. */
1604 char *sel
= &exp
->elts
[pc
+ 2].string
;
1605 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1606 struct type
*selector_type
;
1608 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1609 if (noside
== EVAL_SKIP
)
1610 return eval_skip_value (exp
);
1613 sel
[len
] = 0; /* Make sure it's terminated. */
1615 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1616 return value_from_longest (selector_type
,
1617 lookup_child_selector (exp
->gdbarch
, sel
));
1620 case OP_OBJC_MSGCALL
:
1621 { /* Objective C message (method) call. */
1623 CORE_ADDR responds_selector
= 0;
1624 CORE_ADDR method_selector
= 0;
1626 CORE_ADDR selector
= 0;
1628 int struct_return
= 0;
1629 enum noside sub_no_side
= EVAL_NORMAL
;
1631 struct value
*msg_send
= NULL
;
1632 struct value
*msg_send_stret
= NULL
;
1633 int gnu_runtime
= 0;
1635 struct value
*target
= NULL
;
1636 struct value
*method
= NULL
;
1637 struct value
*called_method
= NULL
;
1639 struct type
*selector_type
= NULL
;
1640 struct type
*long_type
;
1642 struct value
*ret
= NULL
;
1645 selector
= exp
->elts
[pc
+ 1].longconst
;
1646 nargs
= exp
->elts
[pc
+ 2].longconst
;
1647 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1651 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1652 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1654 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1655 sub_no_side
= EVAL_NORMAL
;
1657 sub_no_side
= noside
;
1659 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1661 if (value_as_long (target
) == 0)
1662 return value_from_longest (long_type
, 0);
1664 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1667 /* Find the method dispatch (Apple runtime) or method lookup
1668 (GNU runtime) function for Objective-C. These will be used
1669 to lookup the symbol information for the method. If we
1670 can't find any symbol information, then we'll use these to
1671 call the method, otherwise we can call the method
1672 directly. The msg_send_stret function is used in the special
1673 case of a method that returns a structure (Apple runtime
1677 type
= selector_type
;
1679 type
= lookup_function_type (type
);
1680 type
= lookup_pointer_type (type
);
1681 type
= lookup_function_type (type
);
1682 type
= lookup_pointer_type (type
);
1684 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1686 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1688 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1689 msg_send_stret
= value_from_pointer (type
,
1690 value_as_address (msg_send_stret
));
1694 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1695 /* Special dispatcher for methods returning structs. */
1697 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1700 /* Verify the target object responds to this method. The
1701 standard top-level 'Object' class uses a different name for
1702 the verification method than the non-standard, but more
1703 often used, 'NSObject' class. Make sure we check for both. */
1706 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1707 if (responds_selector
== 0)
1709 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1711 if (responds_selector
== 0)
1712 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1715 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1716 if (method_selector
== 0)
1718 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1720 if (method_selector
== 0)
1721 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1723 /* Call the verification method, to make sure that the target
1724 class implements the desired method. */
1726 argvec
[0] = msg_send
;
1728 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1729 argvec
[3] = value_from_longest (long_type
, selector
);
1732 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1735 /* Function objc_msg_lookup returns a pointer. */
1737 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1739 if (value_as_long (ret
) == 0)
1740 error (_("Target does not respond to this message selector."));
1742 /* Call "methodForSelector:" method, to get the address of a
1743 function method that implements this selector for this
1744 class. If we can find a symbol at that address, then we
1745 know the return type, parameter types etc. (that's a good
1748 argvec
[0] = msg_send
;
1750 argvec
[2] = value_from_longest (long_type
, method_selector
);
1751 argvec
[3] = value_from_longest (long_type
, selector
);
1754 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1758 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1761 /* ret should now be the selector. */
1763 addr
= value_as_long (ret
);
1766 struct symbol
*sym
= NULL
;
1768 /* The address might point to a function descriptor;
1769 resolve it to the actual code address instead. */
1770 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1771 current_top_target ());
1773 /* Is it a high_level symbol? */
1774 sym
= find_pc_function (addr
);
1776 method
= value_of_variable (sym
, 0);
1779 /* If we found a method with symbol information, check to see
1780 if it returns a struct. Otherwise assume it doesn't. */
1785 struct type
*val_type
;
1787 funaddr
= find_function_addr (method
, &val_type
);
1789 block_for_pc (funaddr
);
1791 val_type
= check_typedef (val_type
);
1793 if ((val_type
== NULL
)
1794 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1796 if (expect_type
!= NULL
)
1797 val_type
= expect_type
;
1800 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1803 else if (expect_type
!= NULL
)
1805 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1806 check_typedef (expect_type
));
1809 /* Found a function symbol. Now we will substitute its
1810 value in place of the message dispatcher (obj_msgSend),
1811 so that we call the method directly instead of thru
1812 the dispatcher. The main reason for doing this is that
1813 we can now evaluate the return value and parameter values
1814 according to their known data types, in case we need to
1815 do things like promotion, dereferencing, special handling
1816 of structs and doubles, etc.
1818 We want to use the type signature of 'method', but still
1819 jump to objc_msgSend() or objc_msgSend_stret() to better
1820 mimic the behavior of the runtime. */
1824 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1825 error (_("method address has symbol information "
1826 "with non-function type; skipping"));
1828 /* Create a function pointer of the appropriate type, and
1829 replace its value with the value of msg_send or
1830 msg_send_stret. We must use a pointer here, as
1831 msg_send and msg_send_stret are of pointer type, and
1832 the representation may be different on systems that use
1833 function descriptors. */
1836 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1837 value_as_address (msg_send_stret
));
1840 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1841 value_as_address (msg_send
));
1846 called_method
= msg_send_stret
;
1848 called_method
= msg_send
;
1851 if (noside
== EVAL_SKIP
)
1852 return eval_skip_value (exp
);
1854 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1856 /* If the return type doesn't look like a function type,
1857 call an error. This can happen if somebody tries to
1858 turn a variable into a function call. This is here
1859 because people often want to call, eg, strcmp, which
1860 gdb doesn't know is a function. If gdb isn't asked for
1861 it's opinion (ie. through "whatis"), it won't offer
1864 struct type
*callee_type
= value_type (called_method
);
1866 if (callee_type
&& TYPE_CODE (callee_type
) == TYPE_CODE_PTR
)
1867 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1868 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1872 if ((TYPE_CODE (callee_type
) == TYPE_CODE_ERROR
) && expect_type
)
1873 return allocate_value (expect_type
);
1875 return allocate_value (callee_type
);
1878 error (_("Expression of type other than "
1879 "\"method returning ...\" used as a method"));
1882 /* Now depending on whether we found a symbol for the method,
1883 we will either call the runtime dispatcher or the method
1886 argvec
[0] = called_method
;
1888 argvec
[2] = value_from_longest (long_type
, selector
);
1889 /* User-supplied arguments. */
1890 for (tem
= 0; tem
< nargs
; tem
++)
1891 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1892 argvec
[tem
+ 3] = 0;
1894 if (gnu_runtime
&& (method
!= NULL
))
1896 /* Function objc_msg_lookup returns a pointer. */
1897 deprecated_set_value_type (argvec
[0],
1898 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1900 = call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1903 ret
= call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1909 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1911 case OP_F77_UNDETERMINED_ARGLIST
:
1913 /* Remember that in F77, functions, substring ops and
1914 array subscript operations cannot be disambiguated
1915 at parse time. We have made all array subscript operations,
1916 substring operations as well as function calls come here
1917 and we now have to discover what the heck this thing actually was.
1918 If it is a function, we process just as if we got an OP_FUNCALL. */
1920 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1923 /* First determine the type code we are dealing with. */
1924 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1925 type
= check_typedef (value_type (arg1
));
1926 code
= TYPE_CODE (type
);
1928 if (code
== TYPE_CODE_PTR
)
1930 /* Fortran always passes variable to subroutines as pointer.
1931 So we need to look into its target type to see if it is
1932 array, string or function. If it is, we need to switch
1933 to the target value the original one points to. */
1934 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1936 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1937 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1938 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1940 arg1
= value_ind (arg1
);
1941 type
= check_typedef (value_type (arg1
));
1942 code
= TYPE_CODE (type
);
1948 case TYPE_CODE_ARRAY
:
1949 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1950 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1953 if (noside
== EVAL_SKIP
)
1955 skip_undetermined_arglist (nargs
, exp
, pos
, noside
);
1956 /* Return the dummy value with the correct type. */
1959 goto multi_f77_subscript
;
1962 case TYPE_CODE_STRING
:
1963 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1964 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1967 if (noside
== EVAL_SKIP
)
1969 skip_undetermined_arglist (nargs
, exp
, pos
, noside
);
1970 /* Return the dummy value with the correct type. */
1973 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1974 return value_subscript (arg1
, value_as_long (arg2
));
1978 case TYPE_CODE_FUNC
:
1979 /* It's a function call. */
1980 /* Allocate arg vector, including space for the function to be
1981 called in argvec[0] and a terminating NULL. */
1982 argvec
= (struct value
**)
1983 alloca (sizeof (struct value
*) * (nargs
+ 2));
1986 for (; tem
<= nargs
; tem
++)
1987 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1988 argvec
[tem
] = 0; /* signal end of arglist */
1989 if (noside
== EVAL_SKIP
)
1990 return eval_skip_value (exp
);
1991 return eval_call (exp
, noside
, nargs
, argvec
, NULL
, expect_type
);
1994 error (_("Cannot perform substring on this type"));
1998 /* We have a complex number, There should be 2 floating
1999 point numbers that compose it. */
2001 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2002 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2004 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
2006 case STRUCTOP_STRUCT
:
2007 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2008 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2009 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2010 if (noside
== EVAL_SKIP
)
2011 return eval_skip_value (exp
);
2012 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2014 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2015 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2019 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2020 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2021 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2022 if (noside
== EVAL_SKIP
)
2023 return eval_skip_value (exp
);
2025 /* Check to see if operator '->' has been overloaded. If so replace
2026 arg1 with the value returned by evaluating operator->(). */
2027 while (unop_user_defined_p (op
, arg1
))
2029 struct value
*value
= NULL
;
2032 value
= value_x_unop (arg1
, op
, noside
);
2035 CATCH (except
, RETURN_MASK_ERROR
)
2037 if (except
.error
== NOT_FOUND_ERROR
)
2040 throw_exception (except
);
2047 /* JYG: if print object is on we need to replace the base type
2048 with rtti type in order to continue on with successful
2049 lookup of member / method only available in the rtti type. */
2051 struct type
*arg_type
= value_type (arg1
);
2052 struct type
*real_type
;
2053 int full
, using_enc
;
2055 struct value_print_options opts
;
2057 get_user_print_options (&opts
);
2058 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
2059 && (TYPE_CODE (TYPE_TARGET_TYPE (arg_type
)) == TYPE_CODE_STRUCT
))
2061 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
2064 arg1
= value_cast (real_type
, arg1
);
2068 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2069 NULL
, "structure pointer");
2070 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2071 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2074 case STRUCTOP_MEMBER
:
2076 if (op
== STRUCTOP_MEMBER
)
2077 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2079 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2081 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2083 if (noside
== EVAL_SKIP
)
2084 return eval_skip_value (exp
);
2086 type
= check_typedef (value_type (arg2
));
2087 switch (TYPE_CODE (type
))
2089 case TYPE_CODE_METHODPTR
:
2090 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2091 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2094 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2095 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2096 return value_ind (arg2
);
2099 case TYPE_CODE_MEMBERPTR
:
2100 /* Now, convert these values to an address. */
2101 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
2104 mem_offset
= value_as_long (arg2
);
2106 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2107 value_as_long (arg1
) + mem_offset
);
2108 return value_ind (arg3
);
2111 error (_("non-pointer-to-member value used "
2112 "in pointer-to-member construct"));
2117 type_instance_flags flags
2118 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2119 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2120 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2121 for (ix
= 0; ix
< nargs
; ++ix
)
2122 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2124 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
2125 *(pos
) += 4 + nargs
;
2126 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
2131 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2132 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2133 if (noside
== EVAL_SKIP
)
2134 return eval_skip_value (exp
);
2135 if (binop_user_defined_p (op
, arg1
, arg2
))
2136 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2138 return value_concat (arg1
, arg2
);
2141 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2142 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2144 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2146 if (binop_user_defined_p (op
, arg1
, arg2
))
2147 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2149 return value_assign (arg1
, arg2
);
2151 case BINOP_ASSIGN_MODIFY
:
2153 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2154 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2155 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2157 op
= exp
->elts
[pc
+ 1].opcode
;
2158 if (binop_user_defined_p (op
, arg1
, arg2
))
2159 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2160 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2162 && is_integral_type (value_type (arg2
)))
2163 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2164 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2166 && is_integral_type (value_type (arg2
)))
2167 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2170 struct value
*tmp
= arg1
;
2172 /* For shift and integer exponentiation operations,
2173 only promote the first argument. */
2174 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2175 && is_integral_type (value_type (arg2
)))
2176 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2178 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2180 arg2
= value_binop (tmp
, arg2
, op
);
2182 return value_assign (arg1
, arg2
);
2185 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2186 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2187 if (noside
== EVAL_SKIP
)
2188 return eval_skip_value (exp
);
2189 if (binop_user_defined_p (op
, arg1
, arg2
))
2190 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2191 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2192 && is_integral_type (value_type (arg2
)))
2193 return value_ptradd (arg1
, value_as_long (arg2
));
2194 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2195 && is_integral_type (value_type (arg1
)))
2196 return value_ptradd (arg2
, value_as_long (arg1
));
2199 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2200 return value_binop (arg1
, arg2
, BINOP_ADD
);
2204 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2205 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2206 if (noside
== EVAL_SKIP
)
2207 return eval_skip_value (exp
);
2208 if (binop_user_defined_p (op
, arg1
, arg2
))
2209 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2210 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2211 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2213 /* FIXME -- should be ptrdiff_t */
2214 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2215 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2217 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2218 && is_integral_type (value_type (arg2
)))
2219 return value_ptradd (arg1
, - value_as_long (arg2
));
2222 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2223 return value_binop (arg1
, arg2
, BINOP_SUB
);
2234 case BINOP_BITWISE_AND
:
2235 case BINOP_BITWISE_IOR
:
2236 case BINOP_BITWISE_XOR
:
2237 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2238 arg2
= evaluate_subexp (NULL_TYPE
, 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
);
2245 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2246 fudge arg2 to avoid division-by-zero, the caller is
2247 (theoretically) only looking for the type of the result. */
2248 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2249 /* ??? Do we really want to test for BINOP_MOD here?
2250 The implementation of value_binop gives it a well-defined
2253 || op
== BINOP_INTDIV
2256 && value_logical_not (arg2
))
2258 struct value
*v_one
, *retval
;
2260 v_one
= value_one (value_type (arg2
));
2261 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2262 retval
= value_binop (arg1
, v_one
, op
);
2267 /* For shift and integer exponentiation operations,
2268 only promote the first argument. */
2269 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2270 && is_integral_type (value_type (arg2
)))
2271 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2273 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2275 return value_binop (arg1
, arg2
, op
);
2279 case BINOP_SUBSCRIPT
:
2280 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2281 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2282 if (noside
== EVAL_SKIP
)
2283 return eval_skip_value (exp
);
2284 if (binop_user_defined_p (op
, arg1
, arg2
))
2285 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2288 /* If the user attempts to subscript something that is not an
2289 array or pointer type (like a plain int variable for example),
2290 then report this as an error. */
2292 arg1
= coerce_ref (arg1
);
2293 type
= check_typedef (value_type (arg1
));
2294 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2295 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2297 if (TYPE_NAME (type
))
2298 error (_("cannot subscript something of type `%s'"),
2301 error (_("cannot subscript requested type"));
2304 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2305 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2307 return value_subscript (arg1
, value_as_long (arg2
));
2309 case MULTI_SUBSCRIPT
:
2311 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2312 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2315 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2316 /* FIXME: EVAL_SKIP handling may not be correct. */
2317 if (noside
== EVAL_SKIP
)
2321 return eval_skip_value (exp
);
2323 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2324 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2326 /* If the user attempts to subscript something that has no target
2327 type (like a plain int variable for example), then report this
2330 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2333 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2339 error (_("cannot subscript something of type `%s'"),
2340 TYPE_NAME (value_type (arg1
)));
2344 if (binop_user_defined_p (op
, arg1
, arg2
))
2346 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2350 arg1
= coerce_ref (arg1
);
2351 type
= check_typedef (value_type (arg1
));
2353 switch (TYPE_CODE (type
))
2356 case TYPE_CODE_ARRAY
:
2357 case TYPE_CODE_STRING
:
2358 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2362 if (TYPE_NAME (type
))
2363 error (_("cannot subscript something of type `%s'"),
2366 error (_("cannot subscript requested type"));
2372 multi_f77_subscript
:
2374 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2375 int ndimensions
= 1, i
;
2376 struct value
*array
= arg1
;
2378 if (nargs
> MAX_FORTRAN_DIMS
)
2379 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2381 ndimensions
= calc_f77_array_dims (type
);
2383 if (nargs
!= ndimensions
)
2384 error (_("Wrong number of subscripts"));
2386 gdb_assert (nargs
> 0);
2388 /* Now that we know we have a legal array subscript expression
2389 let us actually find out where this element exists in the array. */
2391 /* Take array indices left to right. */
2392 for (i
= 0; i
< nargs
; i
++)
2394 /* Evaluate each subscript; it must be a legal integer in F77. */
2395 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2397 /* Fill in the subscript array. */
2399 subscript_array
[i
] = value_as_long (arg2
);
2402 /* Internal type of array is arranged right to left. */
2403 for (i
= nargs
; i
> 0; i
--)
2405 struct type
*array_type
= check_typedef (value_type (array
));
2406 LONGEST index
= subscript_array
[i
- 1];
2408 array
= value_subscripted_rvalue (array
, index
,
2409 f77_get_lowerbound (array_type
));
2415 case BINOP_LOGICAL_AND
:
2416 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2417 if (noside
== EVAL_SKIP
)
2419 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2420 return eval_skip_value (exp
);
2424 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2427 if (binop_user_defined_p (op
, arg1
, arg2
))
2429 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2430 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2434 tem
= value_logical_not (arg1
);
2435 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2436 (tem
? EVAL_SKIP
: noside
));
2437 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2438 return value_from_longest (type
,
2439 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2442 case BINOP_LOGICAL_OR
:
2443 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2444 if (noside
== EVAL_SKIP
)
2446 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2447 return eval_skip_value (exp
);
2451 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2454 if (binop_user_defined_p (op
, arg1
, arg2
))
2456 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2457 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2461 tem
= value_logical_not (arg1
);
2462 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2463 (!tem
? EVAL_SKIP
: noside
));
2464 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2465 return value_from_longest (type
,
2466 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2470 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2471 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2472 if (noside
== EVAL_SKIP
)
2473 return eval_skip_value (exp
);
2474 if (binop_user_defined_p (op
, arg1
, arg2
))
2476 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2480 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2481 tem
= value_equal (arg1
, arg2
);
2482 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2483 return value_from_longest (type
, (LONGEST
) tem
);
2486 case BINOP_NOTEQUAL
:
2487 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2488 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2489 if (noside
== EVAL_SKIP
)
2490 return eval_skip_value (exp
);
2491 if (binop_user_defined_p (op
, arg1
, arg2
))
2493 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2497 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2498 tem
= value_equal (arg1
, arg2
);
2499 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2500 return value_from_longest (type
, (LONGEST
) ! tem
);
2504 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2505 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2506 if (noside
== EVAL_SKIP
)
2507 return eval_skip_value (exp
);
2508 if (binop_user_defined_p (op
, arg1
, arg2
))
2510 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2514 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2515 tem
= value_less (arg1
, arg2
);
2516 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2517 return value_from_longest (type
, (LONGEST
) tem
);
2521 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2522 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2523 if (noside
== EVAL_SKIP
)
2524 return eval_skip_value (exp
);
2525 if (binop_user_defined_p (op
, arg1
, arg2
))
2527 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2531 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2532 tem
= value_less (arg2
, arg1
);
2533 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2534 return value_from_longest (type
, (LONGEST
) tem
);
2538 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2539 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2540 if (noside
== EVAL_SKIP
)
2541 return eval_skip_value (exp
);
2542 if (binop_user_defined_p (op
, arg1
, arg2
))
2544 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2548 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2549 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2550 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2551 return value_from_longest (type
, (LONGEST
) tem
);
2555 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2556 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2557 if (noside
== EVAL_SKIP
)
2558 return eval_skip_value (exp
);
2559 if (binop_user_defined_p (op
, arg1
, arg2
))
2561 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2565 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2566 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2567 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2568 return value_from_longest (type
, (LONGEST
) tem
);
2572 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2573 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2574 if (noside
== EVAL_SKIP
)
2575 return eval_skip_value (exp
);
2576 type
= check_typedef (value_type (arg2
));
2577 if (TYPE_CODE (type
) != TYPE_CODE_INT
2578 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
2579 error (_("Non-integral right operand for \"@\" operator."));
2580 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2582 return allocate_repeat_value (value_type (arg1
),
2583 longest_to_int (value_as_long (arg2
)));
2586 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2589 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2590 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2593 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2594 if (noside
== EVAL_SKIP
)
2595 return eval_skip_value (exp
);
2596 if (unop_user_defined_p (op
, arg1
))
2597 return value_x_unop (arg1
, op
, noside
);
2600 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2601 return value_pos (arg1
);
2605 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2606 if (noside
== EVAL_SKIP
)
2607 return eval_skip_value (exp
);
2608 if (unop_user_defined_p (op
, arg1
))
2609 return value_x_unop (arg1
, op
, noside
);
2612 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2613 return value_neg (arg1
);
2616 case UNOP_COMPLEMENT
:
2617 /* C++: check for and handle destructor names. */
2619 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2620 if (noside
== EVAL_SKIP
)
2621 return eval_skip_value (exp
);
2622 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2623 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2626 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2627 return value_complement (arg1
);
2630 case UNOP_LOGICAL_NOT
:
2631 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2632 if (noside
== EVAL_SKIP
)
2633 return eval_skip_value (exp
);
2634 if (unop_user_defined_p (op
, arg1
))
2635 return value_x_unop (arg1
, op
, noside
);
2638 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2639 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2643 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2644 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2645 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2646 type
= check_typedef (value_type (arg1
));
2647 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2648 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2649 error (_("Attempt to dereference pointer "
2650 "to member without an object"));
2651 if (noside
== EVAL_SKIP
)
2652 return eval_skip_value (exp
);
2653 if (unop_user_defined_p (op
, arg1
))
2654 return value_x_unop (arg1
, op
, noside
);
2655 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2657 type
= check_typedef (value_type (arg1
));
2658 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2659 || TYPE_IS_REFERENCE (type
)
2660 /* In C you can dereference an array to get the 1st elt. */
2661 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2663 return value_zero (TYPE_TARGET_TYPE (type
),
2665 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2666 /* GDB allows dereferencing an int. */
2667 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2670 error (_("Attempt to take contents of a non-pointer value."));
2673 /* Allow * on an integer so we can cast it to whatever we want.
2674 This returns an int, which seems like the most C-like thing to
2675 do. "long long" variables are rare enough that
2676 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2677 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2678 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2679 (CORE_ADDR
) value_as_address (arg1
));
2680 return value_ind (arg1
);
2683 /* C++: check for and handle pointer to members. */
2685 if (noside
== EVAL_SKIP
)
2687 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2688 return eval_skip_value (exp
);
2692 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2699 if (noside
== EVAL_SKIP
)
2701 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2702 return eval_skip_value (exp
);
2704 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2708 type
= value_type (evaluate_subexp (NULL_TYPE
, exp
, pos
,
2709 EVAL_AVOID_SIDE_EFFECTS
));
2710 /* FIXME: This should be size_t. */
2711 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2712 ULONGEST align
= type_align (type
);
2714 error (_("could not determine alignment of type"));
2715 return value_from_longest (size_type
, align
);
2720 type
= exp
->elts
[pc
+ 1].type
;
2721 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2723 case UNOP_CAST_TYPE
:
2724 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2725 type
= value_type (arg1
);
2726 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2728 case UNOP_DYNAMIC_CAST
:
2729 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2730 type
= value_type (arg1
);
2731 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2732 if (noside
== EVAL_SKIP
)
2733 return eval_skip_value (exp
);
2734 return value_dynamic_cast (type
, arg1
);
2736 case UNOP_REINTERPRET_CAST
:
2737 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2738 type
= value_type (arg1
);
2739 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2740 if (noside
== EVAL_SKIP
)
2741 return eval_skip_value (exp
);
2742 return value_reinterpret_cast (type
, arg1
);
2746 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2747 if (noside
== EVAL_SKIP
)
2748 return eval_skip_value (exp
);
2749 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2750 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2752 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2753 value_as_address (arg1
));
2755 case UNOP_MEMVAL_TYPE
:
2756 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2757 type
= value_type (arg1
);
2758 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2759 if (noside
== EVAL_SKIP
)
2760 return eval_skip_value (exp
);
2761 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2762 return value_zero (type
, lval_memory
);
2764 return value_at_lazy (type
, value_as_address (arg1
));
2766 case UNOP_PREINCREMENT
:
2767 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2768 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2770 else if (unop_user_defined_p (op
, arg1
))
2772 return value_x_unop (arg1
, op
, noside
);
2776 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2777 arg2
= value_ptradd (arg1
, 1);
2780 struct value
*tmp
= arg1
;
2782 arg2
= value_one (value_type (arg1
));
2783 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2784 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2787 return value_assign (arg1
, arg2
);
2790 case UNOP_PREDECREMENT
:
2791 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2792 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2794 else if (unop_user_defined_p (op
, arg1
))
2796 return value_x_unop (arg1
, op
, noside
);
2800 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2801 arg2
= value_ptradd (arg1
, -1);
2804 struct value
*tmp
= arg1
;
2806 arg2
= value_one (value_type (arg1
));
2807 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2808 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2811 return value_assign (arg1
, arg2
);
2814 case UNOP_POSTINCREMENT
:
2815 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2816 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2818 else if (unop_user_defined_p (op
, arg1
))
2820 return value_x_unop (arg1
, op
, noside
);
2824 arg3
= value_non_lval (arg1
);
2826 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2827 arg2
= value_ptradd (arg1
, 1);
2830 struct value
*tmp
= arg1
;
2832 arg2
= value_one (value_type (arg1
));
2833 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2834 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2837 value_assign (arg1
, arg2
);
2841 case UNOP_POSTDECREMENT
:
2842 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2843 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2845 else if (unop_user_defined_p (op
, arg1
))
2847 return value_x_unop (arg1
, op
, noside
);
2851 arg3
= value_non_lval (arg1
);
2853 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2854 arg2
= value_ptradd (arg1
, -1);
2857 struct value
*tmp
= arg1
;
2859 arg2
= value_one (value_type (arg1
));
2860 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2861 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2864 value_assign (arg1
, arg2
);
2870 return value_of_this (exp
->language_defn
);
2873 /* The value is not supposed to be used. This is here to make it
2874 easier to accommodate expressions that contain types. */
2876 if (noside
== EVAL_SKIP
)
2877 return eval_skip_value (exp
);
2878 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2879 return allocate_value (exp
->elts
[pc
+ 1].type
);
2881 error (_("Attempt to use a type name as an expression"));
2885 if (noside
== EVAL_SKIP
)
2887 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2888 return eval_skip_value (exp
);
2890 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2892 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2893 struct value
*result
;
2895 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2896 EVAL_AVOID_SIDE_EFFECTS
);
2898 /* 'decltype' has special semantics for lvalues. */
2899 if (op
== OP_DECLTYPE
2900 && (sub_op
== BINOP_SUBSCRIPT
2901 || sub_op
== STRUCTOP_MEMBER
2902 || sub_op
== STRUCTOP_MPTR
2903 || sub_op
== UNOP_IND
2904 || sub_op
== STRUCTOP_STRUCT
2905 || sub_op
== STRUCTOP_PTR
2906 || sub_op
== OP_SCOPE
))
2908 type
= value_type (result
);
2910 if (!TYPE_IS_REFERENCE (type
))
2912 type
= lookup_lvalue_reference_type (type
);
2913 result
= allocate_value (type
);
2920 error (_("Attempt to use a type as an expression"));
2924 struct value
*result
;
2925 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2927 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2928 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2929 EVAL_AVOID_SIDE_EFFECTS
);
2931 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2933 if (noside
!= EVAL_NORMAL
)
2934 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2936 return cplus_typeid (result
);
2940 /* Removing this case and compiling with gcc -Wall reveals that
2941 a lot of cases are hitting this case. Some of these should
2942 probably be removed from expression.h; others are legitimate
2943 expressions which are (apparently) not fully implemented.
2945 If there are any cases landing here which mean a user error,
2946 then they should be separate cases, with more descriptive
2949 error (_("GDB does not (yet) know how to "
2950 "evaluate that kind of expression"));
2953 gdb_assert_not_reached ("missed return?");
2956 /* Evaluate a subexpression of EXP, at index *POS,
2957 and return the address of that subexpression.
2958 Advance *POS over the subexpression.
2959 If the subexpression isn't an lvalue, get an error.
2960 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2961 then only the type of the result need be correct. */
2963 static struct value
*
2964 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2974 op
= exp
->elts
[pc
].opcode
;
2980 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2982 /* We can't optimize out "&*" if there's a user-defined operator*. */
2983 if (unop_user_defined_p (op
, x
))
2985 x
= value_x_unop (x
, op
, noside
);
2986 goto default_case_after_eval
;
2989 return coerce_array (x
);
2993 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2994 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2996 case UNOP_MEMVAL_TYPE
:
3001 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3002 type
= value_type (x
);
3003 return value_cast (lookup_pointer_type (type
),
3004 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
3008 var
= exp
->elts
[pc
+ 2].symbol
;
3010 /* C++: The "address" of a reference should yield the address
3011 * of the object pointed to. Let value_addr() deal with it. */
3012 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
3016 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3019 lookup_pointer_type (SYMBOL_TYPE (var
));
3020 enum address_class sym_class
= SYMBOL_CLASS (var
);
3022 if (sym_class
== LOC_CONST
3023 || sym_class
== LOC_CONST_BYTES
3024 || sym_class
== LOC_REGISTER
)
3025 error (_("Attempt to take address of register or constant."));
3028 value_zero (type
, not_lval
);
3031 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3033 case OP_VAR_MSYM_VALUE
:
3037 value
*val
= evaluate_var_msym_value (noside
,
3038 exp
->elts
[pc
+ 1].objfile
,
3039 exp
->elts
[pc
+ 2].msymbol
);
3040 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3042 struct type
*type
= lookup_pointer_type (value_type (val
));
3043 return value_zero (type
, not_lval
);
3046 return value_addr (val
);
3050 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3051 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3052 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3053 &exp
->elts
[pc
+ 3].string
,
3056 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3061 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3062 default_case_after_eval
:
3063 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3065 struct type
*type
= check_typedef (value_type (x
));
3067 if (TYPE_IS_REFERENCE (type
))
3068 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3070 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3071 return value_zero (lookup_pointer_type (value_type (x
)),
3074 error (_("Attempt to take address of "
3075 "value not located in memory."));
3077 return value_addr (x
);
3081 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3082 When used in contexts where arrays will be coerced anyway, this is
3083 equivalent to `evaluate_subexp' but much faster because it avoids
3084 actually fetching array contents (perhaps obsolete now that we have
3087 Note that we currently only do the coercion for C expressions, where
3088 arrays are zero based and the coercion is correct. For other languages,
3089 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3090 to decide if coercion is appropriate. */
3093 evaluate_subexp_with_coercion (struct expression
*exp
,
3094 int *pos
, enum noside noside
)
3103 op
= exp
->elts
[pc
].opcode
;
3108 var
= exp
->elts
[pc
+ 2].symbol
;
3109 type
= check_typedef (SYMBOL_TYPE (var
));
3110 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3111 && !TYPE_VECTOR (type
)
3112 && CAST_IS_CONVERSION (exp
->language_defn
))
3115 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3116 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3122 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3126 /* Evaluate a subexpression of EXP, at index *POS,
3127 and return a value for the size of that subexpression.
3128 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3129 we allow side-effects on the operand if its type is a variable
3132 static struct value
*
3133 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3136 /* FIXME: This should be size_t. */
3137 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3144 op
= exp
->elts
[pc
].opcode
;
3148 /* This case is handled specially
3149 so that we avoid creating a value for the result type.
3150 If the result type is very big, it's desirable not to
3151 create a value unnecessarily. */
3154 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3155 type
= check_typedef (value_type (val
));
3156 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3157 && !TYPE_IS_REFERENCE (type
)
3158 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3159 error (_("Attempt to take contents of a non-pointer value."));
3160 type
= TYPE_TARGET_TYPE (type
);
3161 if (is_dynamic_type (type
))
3162 type
= value_type (value_ind (val
));
3163 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3167 type
= exp
->elts
[pc
+ 1].type
;
3170 case UNOP_MEMVAL_TYPE
:
3172 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3173 type
= value_type (val
);
3177 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3178 if (is_dynamic_type (type
))
3180 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3181 type
= value_type (val
);
3182 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3183 && is_dynamic_type (TYPE_INDEX_TYPE (type
))
3184 && TYPE_HIGH_BOUND_UNDEFINED (TYPE_INDEX_TYPE (type
)))
3185 return allocate_optimized_out_value (size_type
);
3191 case OP_VAR_MSYM_VALUE
:
3195 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3196 value
*mval
= evaluate_var_msym_value (noside
,
3197 exp
->elts
[pc
+ 1].objfile
,
3200 type
= value_type (mval
);
3201 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
)
3202 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol
));
3204 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3208 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3209 type of the subscript is a variable length array type. In this case we
3210 must re-evaluate the right hand side of the subcription to allow
3212 case BINOP_SUBSCRIPT
:
3213 if (noside
== EVAL_NORMAL
)
3215 int npc
= (*pos
) + 1;
3217 val
= evaluate_subexp (NULL_TYPE
, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3218 type
= check_typedef (value_type (val
));
3219 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3221 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3222 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3224 type
= TYPE_INDEX_TYPE (type
);
3225 /* Only re-evaluate the right hand side if the resulting type
3226 is a variable length type. */
3227 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3229 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3230 return value_from_longest
3231 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3240 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3241 type
= value_type (val
);
3245 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3246 "When applied to a reference or a reference type, the result is
3247 the size of the referenced type." */
3248 type
= check_typedef (type
);
3249 if (exp
->language_defn
->la_language
== language_cplus
3250 && (TYPE_IS_REFERENCE (type
)))
3251 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3252 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3255 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3256 for that subexpression cast to TO_TYPE. Advance *POS over the
3260 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3262 struct type
*to_type
)
3266 /* Don't let symbols be evaluated with evaluate_subexp because that
3267 throws an "unknown type" error for no-debug data symbols.
3268 Instead, we want the cast to reinterpret the symbol. */
3269 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3270 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3275 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3277 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3278 return value_zero (to_type
, not_lval
);
3280 val
= evaluate_var_msym_value (noside
,
3281 exp
->elts
[pc
+ 1].objfile
,
3282 exp
->elts
[pc
+ 2].msymbol
);
3285 val
= evaluate_var_value (noside
,
3286 exp
->elts
[pc
+ 1].block
,
3287 exp
->elts
[pc
+ 2].symbol
);
3289 if (noside
== EVAL_SKIP
)
3290 return eval_skip_value (exp
);
3292 val
= value_cast (to_type
, val
);
3294 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3295 if (VALUE_LVAL (val
) == lval_memory
)
3297 if (value_lazy (val
))
3298 value_fetch_lazy (val
);
3299 VALUE_LVAL (val
) = not_lval
;
3304 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3305 if (noside
== EVAL_SKIP
)
3306 return eval_skip_value (exp
);
3307 return value_cast (to_type
, val
);
3310 /* Parse a type expression in the string [P..P+LENGTH). */
3313 parse_and_eval_type (char *p
, int length
)
3315 char *tmp
= (char *) alloca (length
+ 4);
3318 memcpy (tmp
+ 1, p
, length
);
3319 tmp
[length
+ 1] = ')';
3320 tmp
[length
+ 2] = '0';
3321 tmp
[length
+ 3] = '\0';
3322 expression_up expr
= parse_expression (tmp
);
3323 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3324 error (_("Internal error in eval_type."));
3325 return expr
->elts
[1].type
;
3329 calc_f77_array_dims (struct type
*array_type
)
3332 struct type
*tmp_type
;
3334 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3335 error (_("Can't get dimensions for a non-array type"));
3337 tmp_type
= array_type
;
3339 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3341 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)