1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2019 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],
793 gdb::make_array_view (argvec
+ 1,
796 if (return_type
== NULL
)
797 error (_("Xmethod is missing return type."));
798 return value_zero (return_type
, not_lval
);
800 else if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
801 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
803 if (TYPE_GNU_IFUNC (ftype
))
805 CORE_ADDR address
= value_address (argvec
[0]);
806 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
808 if (resolved_type
!= NULL
)
809 ftype
= resolved_type
;
812 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
814 if (return_type
== NULL
)
815 return_type
= default_return_type
;
817 if (return_type
== NULL
)
818 error_call_unknown_return_type (function_name
);
820 return allocate_value (return_type
);
823 error (_("Expression of type other than "
824 "\"Function returning ...\" used as function"));
826 switch (TYPE_CODE (value_type (argvec
[0])))
828 case TYPE_CODE_INTERNAL_FUNCTION
:
829 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
830 argvec
[0], nargs
, argvec
+ 1);
831 case TYPE_CODE_XMETHOD
:
832 return call_xmethod (argvec
[0], gdb::make_array_view (argvec
+ 1, nargs
));
834 return call_function_by_hand (argvec
[0], default_return_type
,
835 gdb::make_array_view (argvec
+ 1, nargs
));
839 /* Helper for evaluating an OP_FUNCALL. */
842 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
850 symbol
*function
= NULL
;
851 char *function_name
= NULL
;
852 const char *var_func_name
= NULL
;
857 exp_opcode op
= exp
->elts
[*pos
].opcode
;
858 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
859 /* Allocate arg vector, including space for the function to be
860 called in argvec[0], a potential `this', and a terminating
862 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
863 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
865 /* First, evaluate the structure into arg2. */
868 if (op
== STRUCTOP_MEMBER
)
870 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
874 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
877 /* If the function is a virtual function, then the aggregate
878 value (providing the structure) plays its part by providing
879 the vtable. Otherwise, it is just along for the ride: call
880 the function directly. */
882 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
884 type
*a1_type
= check_typedef (value_type (arg1
));
885 if (noside
== EVAL_SKIP
)
886 tem
= 1; /* Set it to the right arg index so that all
887 arguments can also be skipped. */
888 else if (TYPE_CODE (a1_type
) == TYPE_CODE_METHODPTR
)
890 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
891 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
893 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
895 /* Now, say which argument to start evaluating from. */
900 else if (TYPE_CODE (a1_type
) == TYPE_CODE_MEMBERPTR
)
902 struct type
*type_ptr
903 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
904 struct type
*target_type_ptr
905 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
907 /* Now, convert these values to an address. */
908 arg2
= value_cast (type_ptr
, arg2
);
910 long mem_offset
= value_as_long (arg1
);
912 arg1
= value_from_pointer (target_type_ptr
,
913 value_as_long (arg2
) + mem_offset
);
914 arg1
= value_ind (arg1
);
918 error (_("Non-pointer-to-member value used in pointer-to-member "
921 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
923 /* Hair for method invocations. */
927 /* First, evaluate the structure into arg2. */
929 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
930 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
932 if (op
== STRUCTOP_STRUCT
)
934 /* If v is a variable in a register, and the user types
935 v.method (), this will produce an error, because v has no
938 A possible way around this would be to allocate a copy of
939 the variable on the stack, copy in the contents, call the
940 function, and copy out the contents. I.e. convert this
941 from call by reference to call by copy-return (or
942 whatever it's called). However, this does not work
943 because it is not the same: the method being called could
944 stash a copy of the address, and then future uses through
945 that address (after the method returns) would be expected
946 to use the variable itself, not some copy of it. */
947 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
951 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
953 /* Check to see if the operator '->' has been overloaded.
954 If the operator has been overloaded replace arg2 with the
955 value returned by the custom operator and continue
957 while (unop_user_defined_p (op
, arg2
))
959 struct value
*value
= NULL
;
962 value
= value_x_unop (arg2
, op
, noside
);
965 CATCH (except
, RETURN_MASK_ERROR
)
967 if (except
.error
== NOT_FOUND_ERROR
)
970 throw_exception (except
);
977 /* Now, say which argument to start evaluating from. */
980 else if (op
== OP_SCOPE
981 && overload_resolution
982 && (exp
->language_defn
->la_language
== language_cplus
))
984 /* Unpack it locally so we can properly handle overload
990 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
991 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
992 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
993 name
= &exp
->elts
[pc2
+ 3].string
;
996 function_name
= NULL
;
997 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
999 function
= cp_lookup_symbol_namespace (TYPE_NAME (type
),
1001 get_selected_block (0),
1003 if (function
== NULL
)
1004 error (_("No symbol \"%s\" in namespace \"%s\"."),
1005 name
, TYPE_NAME (type
));
1008 /* arg2 is left as NULL on purpose. */
1012 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1013 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1014 function_name
= name
;
1016 /* We need a properly typed value for method lookup. For
1017 static methods arg2 is otherwise unused. */
1018 arg2
= value_zero (type
, lval_memory
);
1023 else if (op
== OP_ADL_FUNC
)
1025 /* Save the function position and move pos so that the arguments
1026 can be evaluated. */
1032 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1033 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1037 /* Non-method function call. */
1041 /* If this is a C++ function wait until overload resolution. */
1042 if (op
== OP_VAR_VALUE
1043 && overload_resolution
1044 && (exp
->language_defn
->la_language
== language_cplus
))
1046 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1051 if (op
== OP_VAR_MSYM_VALUE
)
1053 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1054 var_func_name
= MSYMBOL_PRINT_NAME (msym
);
1056 else if (op
== OP_VAR_VALUE
)
1058 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1059 var_func_name
= SYMBOL_PRINT_NAME (sym
);
1062 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1063 type
*type
= value_type (argvec
[0]);
1064 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1065 type
= TYPE_TARGET_TYPE (type
);
1066 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1068 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1070 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1078 /* Evaluate arguments (if not already done, e.g., namespace::func()
1079 and overload-resolution is off). */
1080 for (; tem
<= nargs
; tem
++)
1082 /* Ensure that array expressions are coerced into pointer
1084 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1087 /* Signal end of arglist. */
1090 if (noside
== EVAL_SKIP
)
1091 return eval_skip_value (exp
);
1093 if (op
== OP_ADL_FUNC
)
1095 struct symbol
*symp
;
1098 int string_pc
= save_pos1
+ 3;
1100 /* Extract the function name. */
1101 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1102 func_name
= (char *) alloca (name_len
+ 1);
1103 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1105 find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1107 NON_METHOD
, /* not method */
1108 NULL
, NULL
, /* pass NULL symbol since
1109 symbol is unknown */
1110 NULL
, &symp
, NULL
, 0, noside
);
1112 /* Now fix the expression being evaluated. */
1113 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1114 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1117 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1118 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1120 int static_memfuncp
;
1123 /* Method invocation: stuff "this" as first parameter. If the
1124 method turns out to be static we undo this below. */
1129 /* Name of method from expression. */
1130 tstr
= &exp
->elts
[pc2
+ 2].string
;
1133 tstr
= function_name
;
1135 if (overload_resolution
&& (exp
->language_defn
->la_language
1138 /* Language is C++, do some overload resolution before
1140 struct value
*valp
= NULL
;
1142 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1144 METHOD
, /* method */
1145 &arg2
, /* the object */
1147 &static_memfuncp
, 0, noside
);
1149 if (op
== OP_SCOPE
&& !static_memfuncp
)
1151 /* For the time being, we don't handle this. */
1152 error (_("Call to overloaded function %s requires "
1156 argvec
[1] = arg2
; /* the ``this'' pointer */
1157 argvec
[0] = valp
; /* Use the method found after overload
1161 /* Non-C++ case -- or no overload resolution. */
1163 struct value
*temp
= arg2
;
1165 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1167 op
== STRUCTOP_STRUCT
1168 ? "structure" : "structure pointer");
1169 /* value_struct_elt updates temp with the correct value of
1170 the ``this'' pointer if necessary, so modify argvec[1] to
1171 reflect any ``this'' changes. */
1173 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1174 value_address (temp
)
1175 + value_embedded_offset (temp
));
1176 argvec
[1] = arg2
; /* the ``this'' pointer */
1179 /* Take out `this' if needed. */
1180 if (static_memfuncp
)
1182 argvec
[1] = argvec
[0];
1187 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1189 /* Pointer to member. argvec[1] is already set up. */
1192 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1194 /* Non-member function being called. */
1195 /* fn: This can only be done for C++ functions. A C-style
1196 function in a C++ program, for instance, does not have the
1197 fields that are expected here. */
1199 if (overload_resolution
&& (exp
->language_defn
->la_language
1202 /* Language is C++, do some overload resolution before
1204 struct symbol
*symp
;
1207 /* If a scope has been specified disable ADL. */
1211 if (op
== OP_VAR_VALUE
)
1212 function
= exp
->elts
[save_pos1
+2].symbol
;
1214 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1215 NULL
, /* no need for name */
1216 NON_METHOD
, /* not method */
1217 NULL
, function
, /* the function */
1218 NULL
, &symp
, NULL
, no_adl
, noside
);
1220 if (op
== OP_VAR_VALUE
)
1222 /* Now fix the expression being evaluated. */
1223 exp
->elts
[save_pos1
+2].symbol
= symp
;
1224 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1228 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1232 /* Not C++, or no overload resolution allowed. */
1233 /* Nothing to be done; argvec already correctly set up. */
1238 /* It is probably a C-style function. */
1239 /* Nothing to be done; argvec already correctly set up. */
1242 return eval_call (exp
, noside
, nargs
, argvec
, var_func_name
, expect_type
);
1245 /* Helper for skipping all the arguments in an undetermined argument list.
1246 This function was designed for use in the OP_F77_UNDETERMINED_ARGLIST
1247 case of evaluate_subexp_standard as multiple, but not all, code paths
1248 require a generic skip. */
1251 skip_undetermined_arglist (int nargs
, struct expression
*exp
, int *pos
,
1254 for (int i
= 0; i
< nargs
; ++i
)
1255 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1259 evaluate_subexp_standard (struct type
*expect_type
,
1260 struct expression
*exp
, int *pos
,
1264 int tem
, tem2
, tem3
;
1266 struct value
*arg1
= NULL
;
1267 struct value
*arg2
= NULL
;
1271 struct value
**argvec
;
1275 struct type
**arg_types
;
1278 op
= exp
->elts
[pc
].opcode
;
1283 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1284 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1285 if (noside
== EVAL_SKIP
)
1286 return eval_skip_value (exp
);
1287 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
1288 &exp
->elts
[pc
+ 3].string
,
1289 expect_type
, 0, noside
);
1291 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
1296 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1297 exp
->elts
[pc
+ 2].longconst
);
1301 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1302 exp
->elts
[pc
+ 2].floatconst
);
1308 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1309 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_ERROR
)
1310 error_unknown_type (SYMBOL_PRINT_NAME (var
));
1311 if (noside
!= EVAL_SKIP
)
1312 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1315 /* Return a dummy value of the correct type when skipping, so
1316 that parent functions know what is to be skipped. */
1317 return allocate_value (SYMBOL_TYPE (var
));
1321 case OP_VAR_MSYM_VALUE
:
1325 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1326 value
*val
= evaluate_var_msym_value (noside
,
1327 exp
->elts
[pc
+ 1].objfile
,
1330 type
= value_type (val
);
1331 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
1332 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| pc
!= 0))
1333 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol
));
1337 case OP_VAR_ENTRY_VALUE
:
1339 if (noside
== EVAL_SKIP
)
1340 return eval_skip_value (exp
);
1343 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1344 struct frame_info
*frame
;
1346 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1347 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1349 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1350 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1351 error (_("Symbol \"%s\" does not have any specific entry value"),
1352 SYMBOL_PRINT_NAME (sym
));
1354 frame
= get_selected_frame (NULL
);
1355 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1358 case OP_FUNC_STATIC_VAR
:
1359 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1360 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1361 if (noside
== EVAL_SKIP
)
1362 return eval_skip_value (exp
);
1365 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1366 CORE_ADDR addr
= value_address (func
);
1368 const block
*blk
= block_for_pc (addr
);
1369 const char *var
= &exp
->elts
[pc
+ 2].string
;
1371 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1373 if (sym
.symbol
== NULL
)
1374 error (_("No symbol \"%s\" in specified context."), var
);
1376 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1382 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1386 const char *name
= &exp
->elts
[pc
+ 2].string
;
1390 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1391 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1392 name
, strlen (name
));
1394 error (_("Register $%s not available."), name
);
1396 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1397 a value with the appropriate register type. Unfortunately,
1398 we don't have easy access to the type of user registers.
1399 So for these registers, we fetch the register value regardless
1400 of the evaluation mode. */
1401 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1402 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1403 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1405 val
= value_of_register (regno
, get_selected_frame (NULL
));
1407 error (_("Value of register %s not available."), name
);
1413 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1414 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1416 case OP_INTERNALVAR
:
1418 return value_of_internalvar (exp
->gdbarch
,
1419 exp
->elts
[pc
+ 1].internalvar
);
1422 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1423 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1424 if (noside
== EVAL_SKIP
)
1425 return eval_skip_value (exp
);
1426 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1427 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1429 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1430 NSString constant. */
1431 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1432 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1433 if (noside
== EVAL_SKIP
)
1434 return eval_skip_value (exp
);
1435 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1439 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1440 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1441 nargs
= tem3
- tem2
+ 1;
1442 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
1444 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1445 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1447 struct value
*rec
= allocate_value (expect_type
);
1449 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1450 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1453 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1454 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1456 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
1457 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1458 struct value
*array
= allocate_value (expect_type
);
1459 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1460 LONGEST low_bound
, high_bound
, index
;
1462 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1465 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1468 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1469 for (tem
= nargs
; --nargs
>= 0;)
1471 struct value
*element
;
1474 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1475 if (value_type (element
) != element_type
)
1476 element
= value_cast (element_type
, element
);
1479 int continue_pc
= *pos
;
1482 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1483 low_bound
, high_bound
);
1488 if (index
> high_bound
)
1489 /* To avoid memory corruption. */
1490 error (_("Too many array elements"));
1491 memcpy (value_contents_raw (array
)
1492 + (index
- low_bound
) * element_size
,
1493 value_contents (element
),
1501 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1502 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1504 struct value
*set
= allocate_value (expect_type
);
1505 gdb_byte
*valaddr
= value_contents_raw (set
);
1506 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1507 struct type
*check_type
= element_type
;
1508 LONGEST low_bound
, high_bound
;
1510 /* Get targettype of elementtype. */
1511 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1512 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1513 check_type
= TYPE_TARGET_TYPE (check_type
);
1515 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1516 error (_("(power)set type with unknown size"));
1517 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1518 for (tem
= 0; tem
< nargs
; tem
++)
1520 LONGEST range_low
, range_high
;
1521 struct type
*range_low_type
, *range_high_type
;
1522 struct value
*elem_val
;
1524 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1525 range_low_type
= range_high_type
= value_type (elem_val
);
1526 range_low
= range_high
= value_as_long (elem_val
);
1528 /* Check types of elements to avoid mixture of elements from
1529 different types. Also check if type of element is "compatible"
1530 with element type of powerset. */
1531 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1532 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1533 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1534 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1535 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1536 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1537 && (range_low_type
!= range_high_type
)))
1538 /* different element modes. */
1539 error (_("POWERSET tuple elements of different mode"));
1540 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1541 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1542 && range_low_type
!= check_type
))
1543 error (_("incompatible POWERSET tuple elements"));
1544 if (range_low
> range_high
)
1546 warning (_("empty POWERSET tuple range"));
1549 if (range_low
< low_bound
|| range_high
> high_bound
)
1550 error (_("POWERSET tuple element out of range"));
1551 range_low
-= low_bound
;
1552 range_high
-= low_bound
;
1553 for (; range_low
<= range_high
; range_low
++)
1555 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1557 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1558 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1559 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1566 argvec
= XALLOCAVEC (struct value
*, nargs
);
1567 for (tem
= 0; tem
< nargs
; tem
++)
1569 /* Ensure that array expressions are coerced into pointer
1571 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1573 if (noside
== EVAL_SKIP
)
1574 return eval_skip_value (exp
);
1575 return value_array (tem2
, tem3
, argvec
);
1579 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1581 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1583 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1585 if (noside
== EVAL_SKIP
)
1586 return eval_skip_value (exp
);
1587 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1591 /* Skip third and second args to evaluate the first one. */
1592 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1593 if (value_logical_not (arg1
))
1595 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1596 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1600 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1601 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1605 case OP_OBJC_SELECTOR
:
1606 { /* Objective C @selector operator. */
1607 char *sel
= &exp
->elts
[pc
+ 2].string
;
1608 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1609 struct type
*selector_type
;
1611 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1612 if (noside
== EVAL_SKIP
)
1613 return eval_skip_value (exp
);
1616 sel
[len
] = 0; /* Make sure it's terminated. */
1618 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1619 return value_from_longest (selector_type
,
1620 lookup_child_selector (exp
->gdbarch
, sel
));
1623 case OP_OBJC_MSGCALL
:
1624 { /* Objective C message (method) call. */
1626 CORE_ADDR responds_selector
= 0;
1627 CORE_ADDR method_selector
= 0;
1629 CORE_ADDR selector
= 0;
1631 int struct_return
= 0;
1632 enum noside sub_no_side
= EVAL_NORMAL
;
1634 struct value
*msg_send
= NULL
;
1635 struct value
*msg_send_stret
= NULL
;
1636 int gnu_runtime
= 0;
1638 struct value
*target
= NULL
;
1639 struct value
*method
= NULL
;
1640 struct value
*called_method
= NULL
;
1642 struct type
*selector_type
= NULL
;
1643 struct type
*long_type
;
1645 struct value
*ret
= NULL
;
1648 selector
= exp
->elts
[pc
+ 1].longconst
;
1649 nargs
= exp
->elts
[pc
+ 2].longconst
;
1650 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1654 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1655 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1657 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1658 sub_no_side
= EVAL_NORMAL
;
1660 sub_no_side
= noside
;
1662 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1664 if (value_as_long (target
) == 0)
1665 return value_from_longest (long_type
, 0);
1667 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1670 /* Find the method dispatch (Apple runtime) or method lookup
1671 (GNU runtime) function for Objective-C. These will be used
1672 to lookup the symbol information for the method. If we
1673 can't find any symbol information, then we'll use these to
1674 call the method, otherwise we can call the method
1675 directly. The msg_send_stret function is used in the special
1676 case of a method that returns a structure (Apple runtime
1680 type
= selector_type
;
1682 type
= lookup_function_type (type
);
1683 type
= lookup_pointer_type (type
);
1684 type
= lookup_function_type (type
);
1685 type
= lookup_pointer_type (type
);
1687 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1689 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1691 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1692 msg_send_stret
= value_from_pointer (type
,
1693 value_as_address (msg_send_stret
));
1697 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1698 /* Special dispatcher for methods returning structs. */
1700 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1703 /* Verify the target object responds to this method. The
1704 standard top-level 'Object' class uses a different name for
1705 the verification method than the non-standard, but more
1706 often used, 'NSObject' class. Make sure we check for both. */
1709 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1710 if (responds_selector
== 0)
1712 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1714 if (responds_selector
== 0)
1715 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1718 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1719 if (method_selector
== 0)
1721 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1723 if (method_selector
== 0)
1724 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1726 /* Call the verification method, to make sure that the target
1727 class implements the desired method. */
1729 argvec
[0] = msg_send
;
1731 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1732 argvec
[3] = value_from_longest (long_type
, selector
);
1735 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1738 /* Function objc_msg_lookup returns a pointer. */
1740 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1742 if (value_as_long (ret
) == 0)
1743 error (_("Target does not respond to this message selector."));
1745 /* Call "methodForSelector:" method, to get the address of a
1746 function method that implements this selector for this
1747 class. If we can find a symbol at that address, then we
1748 know the return type, parameter types etc. (that's a good
1751 argvec
[0] = msg_send
;
1753 argvec
[2] = value_from_longest (long_type
, method_selector
);
1754 argvec
[3] = value_from_longest (long_type
, selector
);
1757 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1761 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1764 /* ret should now be the selector. */
1766 addr
= value_as_long (ret
);
1769 struct symbol
*sym
= NULL
;
1771 /* The address might point to a function descriptor;
1772 resolve it to the actual code address instead. */
1773 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1774 current_top_target ());
1776 /* Is it a high_level symbol? */
1777 sym
= find_pc_function (addr
);
1779 method
= value_of_variable (sym
, 0);
1782 /* If we found a method with symbol information, check to see
1783 if it returns a struct. Otherwise assume it doesn't. */
1788 struct type
*val_type
;
1790 funaddr
= find_function_addr (method
, &val_type
);
1792 block_for_pc (funaddr
);
1794 val_type
= check_typedef (val_type
);
1796 if ((val_type
== NULL
)
1797 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1799 if (expect_type
!= NULL
)
1800 val_type
= expect_type
;
1803 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1806 else if (expect_type
!= NULL
)
1808 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1809 check_typedef (expect_type
));
1812 /* Found a function symbol. Now we will substitute its
1813 value in place of the message dispatcher (obj_msgSend),
1814 so that we call the method directly instead of thru
1815 the dispatcher. The main reason for doing this is that
1816 we can now evaluate the return value and parameter values
1817 according to their known data types, in case we need to
1818 do things like promotion, dereferencing, special handling
1819 of structs and doubles, etc.
1821 We want to use the type signature of 'method', but still
1822 jump to objc_msgSend() or objc_msgSend_stret() to better
1823 mimic the behavior of the runtime. */
1827 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1828 error (_("method address has symbol information "
1829 "with non-function type; skipping"));
1831 /* Create a function pointer of the appropriate type, and
1832 replace its value with the value of msg_send or
1833 msg_send_stret. We must use a pointer here, as
1834 msg_send and msg_send_stret are of pointer type, and
1835 the representation may be different on systems that use
1836 function descriptors. */
1839 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1840 value_as_address (msg_send_stret
));
1843 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1844 value_as_address (msg_send
));
1849 called_method
= msg_send_stret
;
1851 called_method
= msg_send
;
1854 if (noside
== EVAL_SKIP
)
1855 return eval_skip_value (exp
);
1857 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1859 /* If the return type doesn't look like a function type,
1860 call an error. This can happen if somebody tries to
1861 turn a variable into a function call. This is here
1862 because people often want to call, eg, strcmp, which
1863 gdb doesn't know is a function. If gdb isn't asked for
1864 it's opinion (ie. through "whatis"), it won't offer
1867 struct type
*callee_type
= value_type (called_method
);
1869 if (callee_type
&& TYPE_CODE (callee_type
) == TYPE_CODE_PTR
)
1870 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1871 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1875 if ((TYPE_CODE (callee_type
) == TYPE_CODE_ERROR
) && expect_type
)
1876 return allocate_value (expect_type
);
1878 return allocate_value (callee_type
);
1881 error (_("Expression of type other than "
1882 "\"method returning ...\" used as a method"));
1885 /* Now depending on whether we found a symbol for the method,
1886 we will either call the runtime dispatcher or the method
1889 argvec
[0] = called_method
;
1891 argvec
[2] = value_from_longest (long_type
, selector
);
1892 /* User-supplied arguments. */
1893 for (tem
= 0; tem
< nargs
; tem
++)
1894 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1895 argvec
[tem
+ 3] = 0;
1897 auto call_args
= gdb::make_array_view (argvec
+ 1, nargs
+ 2);
1899 if (gnu_runtime
&& (method
!= NULL
))
1901 /* Function objc_msg_lookup returns a pointer. */
1902 deprecated_set_value_type (argvec
[0],
1903 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1904 argvec
[0] = call_function_by_hand (argvec
[0], NULL
, call_args
);
1907 return call_function_by_hand (argvec
[0], NULL
, call_args
);
1912 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1914 case OP_F77_UNDETERMINED_ARGLIST
:
1916 /* Remember that in F77, functions, substring ops and
1917 array subscript operations cannot be disambiguated
1918 at parse time. We have made all array subscript operations,
1919 substring operations as well as function calls come here
1920 and we now have to discover what the heck this thing actually was.
1921 If it is a function, we process just as if we got an OP_FUNCALL. */
1923 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1926 /* First determine the type code we are dealing with. */
1927 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1928 type
= check_typedef (value_type (arg1
));
1929 code
= TYPE_CODE (type
);
1931 if (code
== TYPE_CODE_PTR
)
1933 /* Fortran always passes variable to subroutines as pointer.
1934 So we need to look into its target type to see if it is
1935 array, string or function. If it is, we need to switch
1936 to the target value the original one points to. */
1937 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1939 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1940 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1941 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1943 arg1
= value_ind (arg1
);
1944 type
= check_typedef (value_type (arg1
));
1945 code
= TYPE_CODE (type
);
1951 case TYPE_CODE_ARRAY
:
1952 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1953 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1956 if (noside
== EVAL_SKIP
)
1958 skip_undetermined_arglist (nargs
, exp
, pos
, noside
);
1959 /* Return the dummy value with the correct type. */
1962 goto multi_f77_subscript
;
1965 case TYPE_CODE_STRING
:
1966 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1967 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1970 if (noside
== EVAL_SKIP
)
1972 skip_undetermined_arglist (nargs
, exp
, pos
, noside
);
1973 /* Return the dummy value with the correct type. */
1976 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1977 return value_subscript (arg1
, value_as_long (arg2
));
1981 case TYPE_CODE_FUNC
:
1982 /* It's a function call. */
1983 /* Allocate arg vector, including space for the function to be
1984 called in argvec[0] and a terminating NULL. */
1985 argvec
= (struct value
**)
1986 alloca (sizeof (struct value
*) * (nargs
+ 2));
1989 for (; tem
<= nargs
; tem
++)
1990 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1991 argvec
[tem
] = 0; /* signal end of arglist */
1992 if (noside
== EVAL_SKIP
)
1993 return eval_skip_value (exp
);
1994 return eval_call (exp
, noside
, nargs
, argvec
, NULL
, expect_type
);
1997 error (_("Cannot perform substring on this type"));
2001 /* We have a complex number, There should be 2 floating
2002 point numbers that compose it. */
2004 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2005 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2007 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
2009 case STRUCTOP_STRUCT
:
2010 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2011 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2012 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2013 if (noside
== EVAL_SKIP
)
2014 return eval_skip_value (exp
);
2015 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2017 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2018 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2022 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2023 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2024 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2025 if (noside
== EVAL_SKIP
)
2026 return eval_skip_value (exp
);
2028 /* Check to see if operator '->' has been overloaded. If so replace
2029 arg1 with the value returned by evaluating operator->(). */
2030 while (unop_user_defined_p (op
, arg1
))
2032 struct value
*value
= NULL
;
2035 value
= value_x_unop (arg1
, op
, noside
);
2038 CATCH (except
, RETURN_MASK_ERROR
)
2040 if (except
.error
== NOT_FOUND_ERROR
)
2043 throw_exception (except
);
2050 /* JYG: if print object is on we need to replace the base type
2051 with rtti type in order to continue on with successful
2052 lookup of member / method only available in the rtti type. */
2054 struct type
*arg_type
= value_type (arg1
);
2055 struct type
*real_type
;
2056 int full
, using_enc
;
2058 struct value_print_options opts
;
2060 get_user_print_options (&opts
);
2061 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
2062 && (TYPE_CODE (TYPE_TARGET_TYPE (arg_type
)) == TYPE_CODE_STRUCT
))
2064 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
2067 arg1
= value_cast (real_type
, arg1
);
2071 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2072 NULL
, "structure pointer");
2073 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2074 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2077 case STRUCTOP_MEMBER
:
2079 if (op
== STRUCTOP_MEMBER
)
2080 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2082 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2084 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2086 if (noside
== EVAL_SKIP
)
2087 return eval_skip_value (exp
);
2089 type
= check_typedef (value_type (arg2
));
2090 switch (TYPE_CODE (type
))
2092 case TYPE_CODE_METHODPTR
:
2093 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2094 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2097 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2098 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2099 return value_ind (arg2
);
2102 case TYPE_CODE_MEMBERPTR
:
2103 /* Now, convert these values to an address. */
2104 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
2107 mem_offset
= value_as_long (arg2
);
2109 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2110 value_as_long (arg1
) + mem_offset
);
2111 return value_ind (arg3
);
2114 error (_("non-pointer-to-member value used "
2115 "in pointer-to-member construct"));
2120 type_instance_flags flags
2121 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2122 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2123 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2124 for (ix
= 0; ix
< nargs
; ++ix
)
2125 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2127 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
2128 *(pos
) += 4 + nargs
;
2129 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
2134 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2135 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2136 if (noside
== EVAL_SKIP
)
2137 return eval_skip_value (exp
);
2138 if (binop_user_defined_p (op
, arg1
, arg2
))
2139 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2141 return value_concat (arg1
, arg2
);
2144 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2145 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2147 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2149 if (binop_user_defined_p (op
, arg1
, arg2
))
2150 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2152 return value_assign (arg1
, arg2
);
2154 case BINOP_ASSIGN_MODIFY
:
2156 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2157 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2158 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2160 op
= exp
->elts
[pc
+ 1].opcode
;
2161 if (binop_user_defined_p (op
, arg1
, arg2
))
2162 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2163 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2165 && is_integral_type (value_type (arg2
)))
2166 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2167 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2169 && is_integral_type (value_type (arg2
)))
2170 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2173 struct value
*tmp
= arg1
;
2175 /* For shift and integer exponentiation operations,
2176 only promote the first argument. */
2177 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2178 && is_integral_type (value_type (arg2
)))
2179 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2181 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2183 arg2
= value_binop (tmp
, arg2
, op
);
2185 return value_assign (arg1
, arg2
);
2188 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2189 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2190 if (noside
== EVAL_SKIP
)
2191 return eval_skip_value (exp
);
2192 if (binop_user_defined_p (op
, arg1
, arg2
))
2193 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2194 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2195 && is_integral_type (value_type (arg2
)))
2196 return value_ptradd (arg1
, value_as_long (arg2
));
2197 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2198 && is_integral_type (value_type (arg1
)))
2199 return value_ptradd (arg2
, value_as_long (arg1
));
2202 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2203 return value_binop (arg1
, arg2
, BINOP_ADD
);
2207 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2208 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2209 if (noside
== EVAL_SKIP
)
2210 return eval_skip_value (exp
);
2211 if (binop_user_defined_p (op
, arg1
, arg2
))
2212 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2213 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2214 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2216 /* FIXME -- should be ptrdiff_t */
2217 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2218 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2220 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2221 && is_integral_type (value_type (arg2
)))
2222 return value_ptradd (arg1
, - value_as_long (arg2
));
2225 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2226 return value_binop (arg1
, arg2
, BINOP_SUB
);
2237 case BINOP_BITWISE_AND
:
2238 case BINOP_BITWISE_IOR
:
2239 case BINOP_BITWISE_XOR
:
2240 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2241 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2242 if (noside
== EVAL_SKIP
)
2243 return eval_skip_value (exp
);
2244 if (binop_user_defined_p (op
, arg1
, arg2
))
2245 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2248 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2249 fudge arg2 to avoid division-by-zero, the caller is
2250 (theoretically) only looking for the type of the result. */
2251 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2252 /* ??? Do we really want to test for BINOP_MOD here?
2253 The implementation of value_binop gives it a well-defined
2256 || op
== BINOP_INTDIV
2259 && value_logical_not (arg2
))
2261 struct value
*v_one
, *retval
;
2263 v_one
= value_one (value_type (arg2
));
2264 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2265 retval
= value_binop (arg1
, v_one
, op
);
2270 /* For shift and integer exponentiation operations,
2271 only promote the first argument. */
2272 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2273 && is_integral_type (value_type (arg2
)))
2274 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2276 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2278 return value_binop (arg1
, arg2
, op
);
2282 case BINOP_SUBSCRIPT
:
2283 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2284 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2285 if (noside
== EVAL_SKIP
)
2286 return eval_skip_value (exp
);
2287 if (binop_user_defined_p (op
, arg1
, arg2
))
2288 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2291 /* If the user attempts to subscript something that is not an
2292 array or pointer type (like a plain int variable for example),
2293 then report this as an error. */
2295 arg1
= coerce_ref (arg1
);
2296 type
= check_typedef (value_type (arg1
));
2297 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2298 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2300 if (TYPE_NAME (type
))
2301 error (_("cannot subscript something of type `%s'"),
2304 error (_("cannot subscript requested type"));
2307 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2308 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2310 return value_subscript (arg1
, value_as_long (arg2
));
2312 case MULTI_SUBSCRIPT
:
2314 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2315 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2318 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2319 /* FIXME: EVAL_SKIP handling may not be correct. */
2320 if (noside
== EVAL_SKIP
)
2324 return eval_skip_value (exp
);
2326 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2327 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2329 /* If the user attempts to subscript something that has no target
2330 type (like a plain int variable for example), then report this
2333 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2336 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2342 error (_("cannot subscript something of type `%s'"),
2343 TYPE_NAME (value_type (arg1
)));
2347 if (binop_user_defined_p (op
, arg1
, arg2
))
2349 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2353 arg1
= coerce_ref (arg1
);
2354 type
= check_typedef (value_type (arg1
));
2356 switch (TYPE_CODE (type
))
2359 case TYPE_CODE_ARRAY
:
2360 case TYPE_CODE_STRING
:
2361 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2365 if (TYPE_NAME (type
))
2366 error (_("cannot subscript something of type `%s'"),
2369 error (_("cannot subscript requested type"));
2375 multi_f77_subscript
:
2377 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2378 int ndimensions
= 1, i
;
2379 struct value
*array
= arg1
;
2381 if (nargs
> MAX_FORTRAN_DIMS
)
2382 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2384 ndimensions
= calc_f77_array_dims (type
);
2386 if (nargs
!= ndimensions
)
2387 error (_("Wrong number of subscripts"));
2389 gdb_assert (nargs
> 0);
2391 /* Now that we know we have a legal array subscript expression
2392 let us actually find out where this element exists in the array. */
2394 /* Take array indices left to right. */
2395 for (i
= 0; i
< nargs
; i
++)
2397 /* Evaluate each subscript; it must be a legal integer in F77. */
2398 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2400 /* Fill in the subscript array. */
2402 subscript_array
[i
] = value_as_long (arg2
);
2405 /* Internal type of array is arranged right to left. */
2406 for (i
= nargs
; i
> 0; i
--)
2408 struct type
*array_type
= check_typedef (value_type (array
));
2409 LONGEST index
= subscript_array
[i
- 1];
2411 array
= value_subscripted_rvalue (array
, index
,
2412 f77_get_lowerbound (array_type
));
2418 case BINOP_LOGICAL_AND
:
2419 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2420 if (noside
== EVAL_SKIP
)
2422 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2423 return eval_skip_value (exp
);
2427 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2430 if (binop_user_defined_p (op
, arg1
, arg2
))
2432 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2433 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2437 tem
= value_logical_not (arg1
);
2438 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2439 (tem
? EVAL_SKIP
: noside
));
2440 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2441 return value_from_longest (type
,
2442 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2445 case BINOP_LOGICAL_OR
:
2446 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2447 if (noside
== EVAL_SKIP
)
2449 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2450 return eval_skip_value (exp
);
2454 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2457 if (binop_user_defined_p (op
, arg1
, arg2
))
2459 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2460 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2464 tem
= value_logical_not (arg1
);
2465 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2466 (!tem
? EVAL_SKIP
: noside
));
2467 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2468 return value_from_longest (type
,
2469 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2473 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2474 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2475 if (noside
== EVAL_SKIP
)
2476 return eval_skip_value (exp
);
2477 if (binop_user_defined_p (op
, arg1
, arg2
))
2479 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2483 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2484 tem
= value_equal (arg1
, arg2
);
2485 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2486 return value_from_longest (type
, (LONGEST
) tem
);
2489 case BINOP_NOTEQUAL
:
2490 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2491 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2492 if (noside
== EVAL_SKIP
)
2493 return eval_skip_value (exp
);
2494 if (binop_user_defined_p (op
, arg1
, arg2
))
2496 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2500 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2501 tem
= value_equal (arg1
, arg2
);
2502 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2503 return value_from_longest (type
, (LONGEST
) ! tem
);
2507 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2508 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2509 if (noside
== EVAL_SKIP
)
2510 return eval_skip_value (exp
);
2511 if (binop_user_defined_p (op
, arg1
, arg2
))
2513 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2517 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2518 tem
= value_less (arg1
, arg2
);
2519 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2520 return value_from_longest (type
, (LONGEST
) tem
);
2524 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2525 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2526 if (noside
== EVAL_SKIP
)
2527 return eval_skip_value (exp
);
2528 if (binop_user_defined_p (op
, arg1
, arg2
))
2530 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2534 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2535 tem
= value_less (arg2
, arg1
);
2536 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2537 return value_from_longest (type
, (LONGEST
) tem
);
2541 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2542 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2543 if (noside
== EVAL_SKIP
)
2544 return eval_skip_value (exp
);
2545 if (binop_user_defined_p (op
, arg1
, arg2
))
2547 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2551 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2552 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2553 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2554 return value_from_longest (type
, (LONGEST
) tem
);
2558 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2559 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2560 if (noside
== EVAL_SKIP
)
2561 return eval_skip_value (exp
);
2562 if (binop_user_defined_p (op
, arg1
, arg2
))
2564 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2568 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2569 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2570 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2571 return value_from_longest (type
, (LONGEST
) tem
);
2575 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2576 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2577 if (noside
== EVAL_SKIP
)
2578 return eval_skip_value (exp
);
2579 type
= check_typedef (value_type (arg2
));
2580 if (TYPE_CODE (type
) != TYPE_CODE_INT
2581 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
2582 error (_("Non-integral right operand for \"@\" operator."));
2583 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2585 return allocate_repeat_value (value_type (arg1
),
2586 longest_to_int (value_as_long (arg2
)));
2589 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2592 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2593 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2596 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2597 if (noside
== EVAL_SKIP
)
2598 return eval_skip_value (exp
);
2599 if (unop_user_defined_p (op
, arg1
))
2600 return value_x_unop (arg1
, op
, noside
);
2603 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2604 return value_pos (arg1
);
2608 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2609 if (noside
== EVAL_SKIP
)
2610 return eval_skip_value (exp
);
2611 if (unop_user_defined_p (op
, arg1
))
2612 return value_x_unop (arg1
, op
, noside
);
2615 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2616 return value_neg (arg1
);
2619 case UNOP_COMPLEMENT
:
2620 /* C++: check for and handle destructor names. */
2622 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2623 if (noside
== EVAL_SKIP
)
2624 return eval_skip_value (exp
);
2625 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2626 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2629 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2630 return value_complement (arg1
);
2633 case UNOP_LOGICAL_NOT
:
2634 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2635 if (noside
== EVAL_SKIP
)
2636 return eval_skip_value (exp
);
2637 if (unop_user_defined_p (op
, arg1
))
2638 return value_x_unop (arg1
, op
, noside
);
2641 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2642 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2646 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2647 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2648 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2649 type
= check_typedef (value_type (arg1
));
2650 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2651 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2652 error (_("Attempt to dereference pointer "
2653 "to member without an object"));
2654 if (noside
== EVAL_SKIP
)
2655 return eval_skip_value (exp
);
2656 if (unop_user_defined_p (op
, arg1
))
2657 return value_x_unop (arg1
, op
, noside
);
2658 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2660 type
= check_typedef (value_type (arg1
));
2661 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2662 || TYPE_IS_REFERENCE (type
)
2663 /* In C you can dereference an array to get the 1st elt. */
2664 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2666 return value_zero (TYPE_TARGET_TYPE (type
),
2668 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2669 /* GDB allows dereferencing an int. */
2670 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2673 error (_("Attempt to take contents of a non-pointer value."));
2676 /* Allow * on an integer so we can cast it to whatever we want.
2677 This returns an int, which seems like the most C-like thing to
2678 do. "long long" variables are rare enough that
2679 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2680 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2681 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2682 (CORE_ADDR
) value_as_address (arg1
));
2683 return value_ind (arg1
);
2686 /* C++: check for and handle pointer to members. */
2688 if (noside
== EVAL_SKIP
)
2690 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2691 return eval_skip_value (exp
);
2695 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2702 if (noside
== EVAL_SKIP
)
2704 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2705 return eval_skip_value (exp
);
2707 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2711 type
= value_type (evaluate_subexp (NULL_TYPE
, exp
, pos
,
2712 EVAL_AVOID_SIDE_EFFECTS
));
2713 /* FIXME: This should be size_t. */
2714 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2715 ULONGEST align
= type_align (type
);
2717 error (_("could not determine alignment of type"));
2718 return value_from_longest (size_type
, align
);
2723 type
= exp
->elts
[pc
+ 1].type
;
2724 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2726 case UNOP_CAST_TYPE
:
2727 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2728 type
= value_type (arg1
);
2729 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2731 case UNOP_DYNAMIC_CAST
:
2732 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2733 type
= value_type (arg1
);
2734 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2735 if (noside
== EVAL_SKIP
)
2736 return eval_skip_value (exp
);
2737 return value_dynamic_cast (type
, arg1
);
2739 case UNOP_REINTERPRET_CAST
:
2740 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2741 type
= value_type (arg1
);
2742 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2743 if (noside
== EVAL_SKIP
)
2744 return eval_skip_value (exp
);
2745 return value_reinterpret_cast (type
, arg1
);
2749 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2750 if (noside
== EVAL_SKIP
)
2751 return eval_skip_value (exp
);
2752 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2753 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2755 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2756 value_as_address (arg1
));
2758 case UNOP_MEMVAL_TYPE
:
2759 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2760 type
= value_type (arg1
);
2761 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2762 if (noside
== EVAL_SKIP
)
2763 return eval_skip_value (exp
);
2764 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2765 return value_zero (type
, lval_memory
);
2767 return value_at_lazy (type
, value_as_address (arg1
));
2769 case UNOP_PREINCREMENT
:
2770 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2771 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2773 else if (unop_user_defined_p (op
, arg1
))
2775 return value_x_unop (arg1
, op
, noside
);
2779 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2780 arg2
= value_ptradd (arg1
, 1);
2783 struct value
*tmp
= arg1
;
2785 arg2
= value_one (value_type (arg1
));
2786 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2787 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2790 return value_assign (arg1
, arg2
);
2793 case UNOP_PREDECREMENT
:
2794 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2795 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2797 else if (unop_user_defined_p (op
, arg1
))
2799 return value_x_unop (arg1
, op
, noside
);
2803 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2804 arg2
= value_ptradd (arg1
, -1);
2807 struct value
*tmp
= arg1
;
2809 arg2
= value_one (value_type (arg1
));
2810 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2811 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2814 return value_assign (arg1
, arg2
);
2817 case UNOP_POSTINCREMENT
:
2818 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2819 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2821 else if (unop_user_defined_p (op
, arg1
))
2823 return value_x_unop (arg1
, op
, noside
);
2827 arg3
= value_non_lval (arg1
);
2829 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2830 arg2
= value_ptradd (arg1
, 1);
2833 struct value
*tmp
= arg1
;
2835 arg2
= value_one (value_type (arg1
));
2836 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2837 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2840 value_assign (arg1
, arg2
);
2844 case UNOP_POSTDECREMENT
:
2845 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2846 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2848 else if (unop_user_defined_p (op
, arg1
))
2850 return value_x_unop (arg1
, op
, noside
);
2854 arg3
= value_non_lval (arg1
);
2856 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2857 arg2
= value_ptradd (arg1
, -1);
2860 struct value
*tmp
= arg1
;
2862 arg2
= value_one (value_type (arg1
));
2863 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2864 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2867 value_assign (arg1
, arg2
);
2873 return value_of_this (exp
->language_defn
);
2876 /* The value is not supposed to be used. This is here to make it
2877 easier to accommodate expressions that contain types. */
2879 if (noside
== EVAL_SKIP
)
2880 return eval_skip_value (exp
);
2881 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2882 return allocate_value (exp
->elts
[pc
+ 1].type
);
2884 error (_("Attempt to use a type name as an expression"));
2888 if (noside
== EVAL_SKIP
)
2890 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2891 return eval_skip_value (exp
);
2893 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2895 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2896 struct value
*result
;
2898 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2899 EVAL_AVOID_SIDE_EFFECTS
);
2901 /* 'decltype' has special semantics for lvalues. */
2902 if (op
== OP_DECLTYPE
2903 && (sub_op
== BINOP_SUBSCRIPT
2904 || sub_op
== STRUCTOP_MEMBER
2905 || sub_op
== STRUCTOP_MPTR
2906 || sub_op
== UNOP_IND
2907 || sub_op
== STRUCTOP_STRUCT
2908 || sub_op
== STRUCTOP_PTR
2909 || sub_op
== OP_SCOPE
))
2911 type
= value_type (result
);
2913 if (!TYPE_IS_REFERENCE (type
))
2915 type
= lookup_lvalue_reference_type (type
);
2916 result
= allocate_value (type
);
2923 error (_("Attempt to use a type as an expression"));
2927 struct value
*result
;
2928 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2930 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2931 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2932 EVAL_AVOID_SIDE_EFFECTS
);
2934 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2936 if (noside
!= EVAL_NORMAL
)
2937 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2939 return cplus_typeid (result
);
2943 /* Removing this case and compiling with gcc -Wall reveals that
2944 a lot of cases are hitting this case. Some of these should
2945 probably be removed from expression.h; others are legitimate
2946 expressions which are (apparently) not fully implemented.
2948 If there are any cases landing here which mean a user error,
2949 then they should be separate cases, with more descriptive
2952 error (_("GDB does not (yet) know how to "
2953 "evaluate that kind of expression"));
2956 gdb_assert_not_reached ("missed return?");
2959 /* Evaluate a subexpression of EXP, at index *POS,
2960 and return the address of that subexpression.
2961 Advance *POS over the subexpression.
2962 If the subexpression isn't an lvalue, get an error.
2963 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2964 then only the type of the result need be correct. */
2966 static struct value
*
2967 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2977 op
= exp
->elts
[pc
].opcode
;
2983 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2985 /* We can't optimize out "&*" if there's a user-defined operator*. */
2986 if (unop_user_defined_p (op
, x
))
2988 x
= value_x_unop (x
, op
, noside
);
2989 goto default_case_after_eval
;
2992 return coerce_array (x
);
2996 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2997 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2999 case UNOP_MEMVAL_TYPE
:
3004 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3005 type
= value_type (x
);
3006 return value_cast (lookup_pointer_type (type
),
3007 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
3011 var
= exp
->elts
[pc
+ 2].symbol
;
3013 /* C++: The "address" of a reference should yield the address
3014 * of the object pointed to. Let value_addr() deal with it. */
3015 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
3019 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3022 lookup_pointer_type (SYMBOL_TYPE (var
));
3023 enum address_class sym_class
= SYMBOL_CLASS (var
);
3025 if (sym_class
== LOC_CONST
3026 || sym_class
== LOC_CONST_BYTES
3027 || sym_class
== LOC_REGISTER
)
3028 error (_("Attempt to take address of register or constant."));
3031 value_zero (type
, not_lval
);
3034 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3036 case OP_VAR_MSYM_VALUE
:
3040 value
*val
= evaluate_var_msym_value (noside
,
3041 exp
->elts
[pc
+ 1].objfile
,
3042 exp
->elts
[pc
+ 2].msymbol
);
3043 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3045 struct type
*type
= lookup_pointer_type (value_type (val
));
3046 return value_zero (type
, not_lval
);
3049 return value_addr (val
);
3053 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3054 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3055 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3056 &exp
->elts
[pc
+ 3].string
,
3059 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3064 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3065 default_case_after_eval
:
3066 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3068 struct type
*type
= check_typedef (value_type (x
));
3070 if (TYPE_IS_REFERENCE (type
))
3071 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3073 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3074 return value_zero (lookup_pointer_type (value_type (x
)),
3077 error (_("Attempt to take address of "
3078 "value not located in memory."));
3080 return value_addr (x
);
3084 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3085 When used in contexts where arrays will be coerced anyway, this is
3086 equivalent to `evaluate_subexp' but much faster because it avoids
3087 actually fetching array contents (perhaps obsolete now that we have
3090 Note that we currently only do the coercion for C expressions, where
3091 arrays are zero based and the coercion is correct. For other languages,
3092 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3093 to decide if coercion is appropriate. */
3096 evaluate_subexp_with_coercion (struct expression
*exp
,
3097 int *pos
, enum noside noside
)
3106 op
= exp
->elts
[pc
].opcode
;
3111 var
= exp
->elts
[pc
+ 2].symbol
;
3112 type
= check_typedef (SYMBOL_TYPE (var
));
3113 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3114 && !TYPE_VECTOR (type
)
3115 && CAST_IS_CONVERSION (exp
->language_defn
))
3118 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3119 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3125 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3129 /* Evaluate a subexpression of EXP, at index *POS,
3130 and return a value for the size of that subexpression.
3131 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3132 we allow side-effects on the operand if its type is a variable
3135 static struct value
*
3136 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3139 /* FIXME: This should be size_t. */
3140 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3147 op
= exp
->elts
[pc
].opcode
;
3151 /* This case is handled specially
3152 so that we avoid creating a value for the result type.
3153 If the result type is very big, it's desirable not to
3154 create a value unnecessarily. */
3157 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3158 type
= check_typedef (value_type (val
));
3159 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3160 && !TYPE_IS_REFERENCE (type
)
3161 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3162 error (_("Attempt to take contents of a non-pointer value."));
3163 type
= TYPE_TARGET_TYPE (type
);
3164 if (is_dynamic_type (type
))
3165 type
= value_type (value_ind (val
));
3166 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3170 type
= exp
->elts
[pc
+ 1].type
;
3173 case UNOP_MEMVAL_TYPE
:
3175 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3176 type
= value_type (val
);
3180 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3181 if (is_dynamic_type (type
))
3183 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3184 type
= value_type (val
);
3185 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3186 && is_dynamic_type (TYPE_INDEX_TYPE (type
))
3187 && TYPE_HIGH_BOUND_UNDEFINED (TYPE_INDEX_TYPE (type
)))
3188 return allocate_optimized_out_value (size_type
);
3194 case OP_VAR_MSYM_VALUE
:
3198 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3199 value
*mval
= evaluate_var_msym_value (noside
,
3200 exp
->elts
[pc
+ 1].objfile
,
3203 type
= value_type (mval
);
3204 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
)
3205 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol
));
3207 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3211 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3212 type of the subscript is a variable length array type. In this case we
3213 must re-evaluate the right hand side of the subcription to allow
3215 case BINOP_SUBSCRIPT
:
3216 if (noside
== EVAL_NORMAL
)
3218 int npc
= (*pos
) + 1;
3220 val
= evaluate_subexp (NULL_TYPE
, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3221 type
= check_typedef (value_type (val
));
3222 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3224 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3225 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3227 type
= TYPE_INDEX_TYPE (type
);
3228 /* Only re-evaluate the right hand side if the resulting type
3229 is a variable length type. */
3230 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3232 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3233 return value_from_longest
3234 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3243 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3244 type
= value_type (val
);
3248 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3249 "When applied to a reference or a reference type, the result is
3250 the size of the referenced type." */
3251 type
= check_typedef (type
);
3252 if (exp
->language_defn
->la_language
== language_cplus
3253 && (TYPE_IS_REFERENCE (type
)))
3254 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3255 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3258 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3259 for that subexpression cast to TO_TYPE. Advance *POS over the
3263 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3265 struct type
*to_type
)
3269 /* Don't let symbols be evaluated with evaluate_subexp because that
3270 throws an "unknown type" error for no-debug data symbols.
3271 Instead, we want the cast to reinterpret the symbol. */
3272 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3273 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3278 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3280 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3281 return value_zero (to_type
, not_lval
);
3283 val
= evaluate_var_msym_value (noside
,
3284 exp
->elts
[pc
+ 1].objfile
,
3285 exp
->elts
[pc
+ 2].msymbol
);
3288 val
= evaluate_var_value (noside
,
3289 exp
->elts
[pc
+ 1].block
,
3290 exp
->elts
[pc
+ 2].symbol
);
3292 if (noside
== EVAL_SKIP
)
3293 return eval_skip_value (exp
);
3295 val
= value_cast (to_type
, val
);
3297 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3298 if (VALUE_LVAL (val
) == lval_memory
)
3300 if (value_lazy (val
))
3301 value_fetch_lazy (val
);
3302 VALUE_LVAL (val
) = not_lval
;
3307 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3308 if (noside
== EVAL_SKIP
)
3309 return eval_skip_value (exp
);
3310 return value_cast (to_type
, val
);
3313 /* Parse a type expression in the string [P..P+LENGTH). */
3316 parse_and_eval_type (char *p
, int length
)
3318 char *tmp
= (char *) alloca (length
+ 4);
3321 memcpy (tmp
+ 1, p
, length
);
3322 tmp
[length
+ 1] = ')';
3323 tmp
[length
+ 2] = '0';
3324 tmp
[length
+ 3] = '\0';
3325 expression_up expr
= parse_expression (tmp
);
3326 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3327 error (_("Internal error in eval_type."));
3328 return expr
->elts
[1].type
;
3332 calc_f77_array_dims (struct type
*array_type
)
3335 struct type
*tmp_type
;
3337 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3338 error (_("Can't get dimensions for a non-array type"));
3340 tmp_type
= array_type
;
3342 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3344 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)