1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
27 #include "gdbthread.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
29 #include "f-lang.h" /* For array bound stuff. */
32 #include "objc-lang.h"
34 #include "parser-defs.h"
35 #include "cp-support.h"
38 #include "user-regs.h"
40 #include "gdb_obstack.h"
42 #include "typeprint.h"
45 /* This is defined in valops.c */
46 extern int overload_resolution
;
48 /* Prototypes for local functions. */
50 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
53 static struct value
*evaluate_subexp_for_address (struct expression
*,
56 static value
*evaluate_subexp_for_cast (expression
*exp
, int *pos
,
60 static struct value
*evaluate_struct_tuple (struct value
*,
61 struct expression
*, int *,
64 static LONGEST
init_array_element (struct value
*, struct value
*,
65 struct expression
*, int *, enum noside
,
69 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
70 int *pos
, enum noside noside
)
74 gdb::optional
<enable_thread_stack_temporaries
> stack_temporaries
;
75 if (*pos
== 0 && target_has_execution
76 && exp
->language_defn
->la_language
== language_cplus
77 && !thread_stack_temporaries_enabled_p (inferior_ptid
))
78 stack_temporaries
.emplace (inferior_ptid
);
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_ptid
))
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, *VAL_CHAIN will be released from the
183 value chain. The caller must free the values individually. If
184 VAL_CHAIN is NULL, all generated values will be left on the value
188 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
189 struct value
**resultp
, struct value
**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
)
219 throw_exception (ex
);
225 new_mark
= value_mark ();
226 if (mark
== new_mark
)
231 /* Make sure it's not lazy, so that after the target stops again we
232 have a non-lazy previous value to compare with. */
235 if (!value_lazy (result
))
242 value_fetch_lazy (result
);
245 CATCH (except
, RETURN_MASK_ERROR
)
254 /* Return the chain of intermediate values. We use this to
255 decide which addresses to watch. */
256 *val_chain
= new_mark
;
257 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 TYPE_NFIELDS (type
) = num_types
;
687 TYPE_FIELDS (type
) = (struct field
*)
688 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
690 while (num_types
-- > 0)
691 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
694 fake_method::~fake_method ()
696 xfree (TYPE_FIELDS (&m_type
));
699 /* Helper for evaluating an OP_VAR_VALUE. */
702 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
704 /* JYG: We used to just return value_zero of the symbol type if
705 we're asked to avoid side effects. Otherwise we return
706 value_of_variable (...). However I'm not sure if
707 value_of_variable () has any side effect. We need a full value
708 object returned here for whatis_exp () to call evaluate_type ()
709 and then pass the full value to value_rtti_target_type () if we
710 are dealing with a pointer or reference to a base class and print
713 struct value
*ret
= NULL
;
717 ret
= value_of_variable (var
, blk
);
720 CATCH (except
, RETURN_MASK_ERROR
)
722 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
723 throw_exception (except
);
725 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
732 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
735 evaluate_var_msym_value (enum noside noside
,
736 struct objfile
*objfile
, minimal_symbol
*msymbol
)
738 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
740 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, NULL
);
741 return value_zero (the_type
, not_lval
);
746 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
747 return value_at_lazy (the_type
, address
);
751 /* Helper for returning a value when handling EVAL_SKIP. */
754 eval_skip_value (expression
*exp
)
756 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
759 /* Evaluate a function call. The function to be called is in
760 ARGVEC[0] and the arguments passed to the function are in
761 ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
762 known. DEFAULT_RETURN_TYPE is used as the function's return type
763 if the return type is unknown. */
766 eval_call (expression
*exp
, enum noside noside
,
767 int nargs
, value
**argvec
,
768 const char *function_name
,
769 type
*default_return_type
)
771 if (argvec
[0] == NULL
)
772 error (_("Cannot evaluate function -- may be inlined"));
773 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
775 /* If the return type doesn't look like a function type,
776 call an error. This can happen if somebody tries to turn
777 a variable into a function call. */
779 type
*ftype
= value_type (argvec
[0]);
781 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
783 /* We don't know anything about what the internal
784 function might return, but we have to return
786 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
789 else if (TYPE_CODE (ftype
) == TYPE_CODE_XMETHOD
)
792 = result_type_of_xmethod (argvec
[0], nargs
, argvec
+ 1);
794 if (return_type
== NULL
)
795 error (_("Xmethod is missing return type."));
796 return value_zero (return_type
, not_lval
);
798 else if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
799 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
801 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
803 if (return_type
== NULL
)
804 return_type
= default_return_type
;
806 if (return_type
== NULL
)
807 error_call_unknown_return_type (function_name
);
809 return allocate_value (return_type
);
812 error (_("Expression of type other than "
813 "\"Function returning ...\" used as function"));
815 switch (TYPE_CODE (value_type (argvec
[0])))
817 case TYPE_CODE_INTERNAL_FUNCTION
:
818 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
819 argvec
[0], nargs
, argvec
+ 1);
820 case TYPE_CODE_XMETHOD
:
821 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
823 return call_function_by_hand (argvec
[0], default_return_type
,
828 /* Helper for evaluating an OP_FUNCALL. */
831 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
839 symbol
*function
= NULL
;
840 char *function_name
= NULL
;
841 const char *var_func_name
= NULL
;
846 exp_opcode op
= exp
->elts
[*pos
].opcode
;
847 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
848 /* Allocate arg vector, including space for the function to be
849 called in argvec[0], a potential `this', and a terminating
851 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
852 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
854 /* First, evaluate the structure into arg2. */
857 if (op
== STRUCTOP_MEMBER
)
859 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
863 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
866 /* If the function is a virtual function, then the aggregate
867 value (providing the structure) plays its part by providing
868 the vtable. Otherwise, it is just along for the ride: call
869 the function directly. */
871 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
873 type
*a1_type
= check_typedef (value_type (arg1
));
874 if (noside
== EVAL_SKIP
)
875 tem
= 1; /* Set it to the right arg index so that all
876 arguments can also be skipped. */
877 else if (TYPE_CODE (a1_type
) == TYPE_CODE_METHODPTR
)
879 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
880 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
882 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
884 /* Now, say which argument to start evaluating from. */
889 else if (TYPE_CODE (a1_type
) == TYPE_CODE_MEMBERPTR
)
891 struct type
*type_ptr
892 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
893 struct type
*target_type_ptr
894 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
896 /* Now, convert these values to an address. */
897 arg2
= value_cast (type_ptr
, arg2
);
899 long mem_offset
= value_as_long (arg1
);
901 arg1
= value_from_pointer (target_type_ptr
,
902 value_as_long (arg2
) + mem_offset
);
903 arg1
= value_ind (arg1
);
907 error (_("Non-pointer-to-member value used in pointer-to-member "
910 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
912 /* Hair for method invocations. */
916 /* First, evaluate the structure into arg2. */
918 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
919 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
921 if (op
== STRUCTOP_STRUCT
)
923 /* If v is a variable in a register, and the user types
924 v.method (), this will produce an error, because v has no
927 A possible way around this would be to allocate a copy of
928 the variable on the stack, copy in the contents, call the
929 function, and copy out the contents. I.e. convert this
930 from call by reference to call by copy-return (or
931 whatever it's called). However, this does not work
932 because it is not the same: the method being called could
933 stash a copy of the address, and then future uses through
934 that address (after the method returns) would be expected
935 to use the variable itself, not some copy of it. */
936 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
940 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
942 /* Check to see if the operator '->' has been overloaded.
943 If the operator has been overloaded replace arg2 with the
944 value returned by the custom operator and continue
946 while (unop_user_defined_p (op
, arg2
))
948 struct value
*value
= NULL
;
951 value
= value_x_unop (arg2
, op
, noside
);
954 CATCH (except
, RETURN_MASK_ERROR
)
956 if (except
.error
== NOT_FOUND_ERROR
)
959 throw_exception (except
);
966 /* Now, say which argument to start evaluating from. */
969 else if (op
== OP_SCOPE
970 && overload_resolution
971 && (exp
->language_defn
->la_language
== language_cplus
))
973 /* Unpack it locally so we can properly handle overload
979 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
980 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
981 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
982 name
= &exp
->elts
[pc2
+ 3].string
;
985 function_name
= NULL
;
986 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
988 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
990 get_selected_block (0),
992 if (function
== NULL
)
993 error (_("No symbol \"%s\" in namespace \"%s\"."),
994 name
, TYPE_TAG_NAME (type
));
997 /* arg2 is left as NULL on purpose. */
1001 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1002 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1003 function_name
= name
;
1005 /* We need a properly typed value for method lookup. For
1006 static methods arg2 is otherwise unused. */
1007 arg2
= value_zero (type
, lval_memory
);
1012 else if (op
== OP_ADL_FUNC
)
1014 /* Save the function position and move pos so that the arguments
1015 can be evaluated. */
1021 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1022 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1026 /* Non-method function call. */
1030 /* If this is a C++ function wait until overload resolution. */
1031 if (op
== OP_VAR_VALUE
1032 && overload_resolution
1033 && (exp
->language_defn
->la_language
== language_cplus
))
1035 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1040 if (op
== OP_VAR_MSYM_VALUE
)
1042 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1043 var_func_name
= SYMBOL_PRINT_NAME (sym
);
1045 else if (op
== OP_VAR_VALUE
)
1047 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1048 var_func_name
= MSYMBOL_PRINT_NAME (msym
);
1051 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1052 type
*type
= value_type (argvec
[0]);
1053 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1054 type
= TYPE_TARGET_TYPE (type
);
1055 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1057 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1059 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1067 /* Evaluate arguments (if not already done, e.g., namespace::func()
1068 and overload-resolution is off). */
1069 for (; tem
<= nargs
; tem
++)
1071 /* Ensure that array expressions are coerced into pointer
1073 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1076 /* Signal end of arglist. */
1079 if (noside
== EVAL_SKIP
)
1080 return eval_skip_value (exp
);
1082 if (op
== OP_ADL_FUNC
)
1084 struct symbol
*symp
;
1087 int string_pc
= save_pos1
+ 3;
1089 /* Extract the function name. */
1090 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1091 func_name
= (char *) alloca (name_len
+ 1);
1092 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1094 find_overload_match (&argvec
[1], nargs
, func_name
,
1095 NON_METHOD
, /* not method */
1096 NULL
, NULL
, /* pass NULL symbol since
1097 symbol is unknown */
1098 NULL
, &symp
, NULL
, 0, noside
);
1100 /* Now fix the expression being evaluated. */
1101 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1102 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1105 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1106 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1108 int static_memfuncp
;
1111 /* Method invocation: stuff "this" as first parameter. If the
1112 method turns out to be static we undo this below. */
1117 /* Name of method from expression. */
1118 tstr
= &exp
->elts
[pc2
+ 2].string
;
1121 tstr
= function_name
;
1123 if (overload_resolution
&& (exp
->language_defn
->la_language
1126 /* Language is C++, do some overload resolution before
1128 struct value
*valp
= NULL
;
1130 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1131 METHOD
, /* method */
1132 &arg2
, /* the object */
1134 &static_memfuncp
, 0, noside
);
1136 if (op
== OP_SCOPE
&& !static_memfuncp
)
1138 /* For the time being, we don't handle this. */
1139 error (_("Call to overloaded function %s requires "
1143 argvec
[1] = arg2
; /* the ``this'' pointer */
1144 argvec
[0] = valp
; /* Use the method found after overload
1148 /* Non-C++ case -- or no overload resolution. */
1150 struct value
*temp
= arg2
;
1152 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1154 op
== STRUCTOP_STRUCT
1155 ? "structure" : "structure pointer");
1156 /* value_struct_elt updates temp with the correct value of
1157 the ``this'' pointer if necessary, so modify argvec[1] to
1158 reflect any ``this'' changes. */
1160 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1161 value_address (temp
)
1162 + value_embedded_offset (temp
));
1163 argvec
[1] = arg2
; /* the ``this'' pointer */
1166 /* Take out `this' if needed. */
1167 if (static_memfuncp
)
1169 argvec
[1] = argvec
[0];
1174 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1176 /* Pointer to member. argvec[1] is already set up. */
1179 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1181 /* Non-member function being called. */
1182 /* fn: This can only be done for C++ functions. A C-style
1183 function in a C++ program, for instance, does not have the
1184 fields that are expected here. */
1186 if (overload_resolution
&& (exp
->language_defn
->la_language
1189 /* Language is C++, do some overload resolution before
1191 struct symbol
*symp
;
1194 /* If a scope has been specified disable ADL. */
1198 if (op
== OP_VAR_VALUE
)
1199 function
= exp
->elts
[save_pos1
+2].symbol
;
1201 (void) find_overload_match (&argvec
[1], nargs
,
1202 NULL
, /* no need for name */
1203 NON_METHOD
, /* not method */
1204 NULL
, function
, /* the function */
1205 NULL
, &symp
, NULL
, no_adl
, noside
);
1207 if (op
== OP_VAR_VALUE
)
1209 /* Now fix the expression being evaluated. */
1210 exp
->elts
[save_pos1
+2].symbol
= symp
;
1211 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1215 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1219 /* Not C++, or no overload resolution allowed. */
1220 /* Nothing to be done; argvec already correctly set up. */
1225 /* It is probably a C-style function. */
1226 /* Nothing to be done; argvec already correctly set up. */
1229 return eval_call (exp
, noside
, nargs
, argvec
, var_func_name
, expect_type
);
1233 evaluate_subexp_standard (struct type
*expect_type
,
1234 struct expression
*exp
, int *pos
,
1238 int tem
, tem2
, tem3
;
1240 struct value
*arg1
= NULL
;
1241 struct value
*arg2
= NULL
;
1245 struct value
**argvec
;
1249 struct type
**arg_types
;
1252 op
= exp
->elts
[pc
].opcode
;
1257 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1258 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1259 if (noside
== EVAL_SKIP
)
1260 return eval_skip_value (exp
);
1261 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
1262 &exp
->elts
[pc
+ 3].string
,
1263 expect_type
, 0, noside
);
1265 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
1270 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1271 exp
->elts
[pc
+ 2].longconst
);
1275 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1276 exp
->elts
[pc
+ 2].floatconst
);
1281 if (noside
== EVAL_SKIP
)
1282 return eval_skip_value (exp
);
1285 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1286 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_ERROR
)
1287 error_unknown_type (SYMBOL_PRINT_NAME (var
));
1289 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1292 case OP_VAR_MSYM_VALUE
:
1296 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1297 value
*val
= evaluate_var_msym_value (noside
,
1298 exp
->elts
[pc
+ 1].objfile
,
1301 type
= value_type (val
);
1302 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
1303 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| pc
!= 0))
1304 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol
));
1308 case OP_VAR_ENTRY_VALUE
:
1310 if (noside
== EVAL_SKIP
)
1311 return eval_skip_value (exp
);
1314 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1315 struct frame_info
*frame
;
1317 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1318 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1320 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1321 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1322 error (_("Symbol \"%s\" does not have any specific entry value"),
1323 SYMBOL_PRINT_NAME (sym
));
1325 frame
= get_selected_frame (NULL
);
1326 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1329 case OP_FUNC_STATIC_VAR
:
1330 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1331 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1332 if (noside
== EVAL_SKIP
)
1333 return eval_skip_value (exp
);
1336 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1337 CORE_ADDR addr
= value_address (func
);
1339 const block
*blk
= block_for_pc (addr
);
1340 const char *var
= &exp
->elts
[pc
+ 2].string
;
1342 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1344 if (sym
.symbol
== NULL
)
1345 error (_("No symbol \"%s\" in specified context."), var
);
1347 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1353 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1357 const char *name
= &exp
->elts
[pc
+ 2].string
;
1361 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1362 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1363 name
, strlen (name
));
1365 error (_("Register $%s not available."), name
);
1367 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1368 a value with the appropriate register type. Unfortunately,
1369 we don't have easy access to the type of user registers.
1370 So for these registers, we fetch the register value regardless
1371 of the evaluation mode. */
1372 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1373 && regno
< gdbarch_num_regs (exp
->gdbarch
)
1374 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
1375 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1377 val
= value_of_register (regno
, get_selected_frame (NULL
));
1379 error (_("Value of register %s not available."), name
);
1385 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1386 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1388 case OP_INTERNALVAR
:
1390 return value_of_internalvar (exp
->gdbarch
,
1391 exp
->elts
[pc
+ 1].internalvar
);
1394 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1395 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1396 if (noside
== EVAL_SKIP
)
1397 return eval_skip_value (exp
);
1398 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1399 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1401 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1402 NSString constant. */
1403 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1404 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1405 if (noside
== EVAL_SKIP
)
1406 return eval_skip_value (exp
);
1407 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1411 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1412 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1413 nargs
= tem3
- tem2
+ 1;
1414 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
1416 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1417 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1419 struct value
*rec
= allocate_value (expect_type
);
1421 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1422 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1425 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1426 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1428 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
1429 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1430 struct value
*array
= allocate_value (expect_type
);
1431 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1432 LONGEST low_bound
, high_bound
, index
;
1434 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1437 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1440 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1441 for (tem
= nargs
; --nargs
>= 0;)
1443 struct value
*element
;
1446 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1447 if (value_type (element
) != element_type
)
1448 element
= value_cast (element_type
, element
);
1451 int continue_pc
= *pos
;
1454 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1455 low_bound
, high_bound
);
1460 if (index
> high_bound
)
1461 /* To avoid memory corruption. */
1462 error (_("Too many array elements"));
1463 memcpy (value_contents_raw (array
)
1464 + (index
- low_bound
) * element_size
,
1465 value_contents (element
),
1473 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1474 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1476 struct value
*set
= allocate_value (expect_type
);
1477 gdb_byte
*valaddr
= value_contents_raw (set
);
1478 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1479 struct type
*check_type
= element_type
;
1480 LONGEST low_bound
, high_bound
;
1482 /* Get targettype of elementtype. */
1483 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1484 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1485 check_type
= TYPE_TARGET_TYPE (check_type
);
1487 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1488 error (_("(power)set type with unknown size"));
1489 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1490 for (tem
= 0; tem
< nargs
; tem
++)
1492 LONGEST range_low
, range_high
;
1493 struct type
*range_low_type
, *range_high_type
;
1494 struct value
*elem_val
;
1496 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1497 range_low_type
= range_high_type
= value_type (elem_val
);
1498 range_low
= range_high
= value_as_long (elem_val
);
1500 /* Check types of elements to avoid mixture of elements from
1501 different types. Also check if type of element is "compatible"
1502 with element type of powerset. */
1503 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1504 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1505 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1506 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1507 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1508 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1509 && (range_low_type
!= range_high_type
)))
1510 /* different element modes. */
1511 error (_("POWERSET tuple elements of different mode"));
1512 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1513 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1514 && range_low_type
!= check_type
))
1515 error (_("incompatible POWERSET tuple elements"));
1516 if (range_low
> range_high
)
1518 warning (_("empty POWERSET tuple range"));
1521 if (range_low
< low_bound
|| range_high
> high_bound
)
1522 error (_("POWERSET tuple element out of range"));
1523 range_low
-= low_bound
;
1524 range_high
-= low_bound
;
1525 for (; range_low
<= range_high
; range_low
++)
1527 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1529 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1530 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1531 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1538 argvec
= XALLOCAVEC (struct value
*, nargs
);
1539 for (tem
= 0; tem
< nargs
; tem
++)
1541 /* Ensure that array expressions are coerced into pointer
1543 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1545 if (noside
== EVAL_SKIP
)
1546 return eval_skip_value (exp
);
1547 return value_array (tem2
, tem3
, argvec
);
1551 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1553 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1555 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1557 if (noside
== EVAL_SKIP
)
1558 return eval_skip_value (exp
);
1559 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1563 /* Skip third and second args to evaluate the first one. */
1564 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1565 if (value_logical_not (arg1
))
1567 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1568 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1572 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1573 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1577 case OP_OBJC_SELECTOR
:
1578 { /* Objective C @selector operator. */
1579 char *sel
= &exp
->elts
[pc
+ 2].string
;
1580 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1581 struct type
*selector_type
;
1583 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1584 if (noside
== EVAL_SKIP
)
1585 return eval_skip_value (exp
);
1588 sel
[len
] = 0; /* Make sure it's terminated. */
1590 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1591 return value_from_longest (selector_type
,
1592 lookup_child_selector (exp
->gdbarch
, sel
));
1595 case OP_OBJC_MSGCALL
:
1596 { /* Objective C message (method) call. */
1598 CORE_ADDR responds_selector
= 0;
1599 CORE_ADDR method_selector
= 0;
1601 CORE_ADDR selector
= 0;
1603 int struct_return
= 0;
1604 enum noside sub_no_side
= EVAL_NORMAL
;
1606 struct value
*msg_send
= NULL
;
1607 struct value
*msg_send_stret
= NULL
;
1608 int gnu_runtime
= 0;
1610 struct value
*target
= NULL
;
1611 struct value
*method
= NULL
;
1612 struct value
*called_method
= NULL
;
1614 struct type
*selector_type
= NULL
;
1615 struct type
*long_type
;
1617 struct value
*ret
= NULL
;
1620 selector
= exp
->elts
[pc
+ 1].longconst
;
1621 nargs
= exp
->elts
[pc
+ 2].longconst
;
1622 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1626 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1627 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1629 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1630 sub_no_side
= EVAL_NORMAL
;
1632 sub_no_side
= noside
;
1634 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1636 if (value_as_long (target
) == 0)
1637 return value_from_longest (long_type
, 0);
1639 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1642 /* Find the method dispatch (Apple runtime) or method lookup
1643 (GNU runtime) function for Objective-C. These will be used
1644 to lookup the symbol information for the method. If we
1645 can't find any symbol information, then we'll use these to
1646 call the method, otherwise we can call the method
1647 directly. The msg_send_stret function is used in the special
1648 case of a method that returns a structure (Apple runtime
1652 struct type
*type
= selector_type
;
1654 type
= lookup_function_type (type
);
1655 type
= lookup_pointer_type (type
);
1656 type
= lookup_function_type (type
);
1657 type
= lookup_pointer_type (type
);
1659 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1661 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1663 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1664 msg_send_stret
= value_from_pointer (type
,
1665 value_as_address (msg_send_stret
));
1669 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1670 /* Special dispatcher for methods returning structs. */
1672 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1675 /* Verify the target object responds to this method. The
1676 standard top-level 'Object' class uses a different name for
1677 the verification method than the non-standard, but more
1678 often used, 'NSObject' class. Make sure we check for both. */
1681 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1682 if (responds_selector
== 0)
1684 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1686 if (responds_selector
== 0)
1687 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1690 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1691 if (method_selector
== 0)
1693 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1695 if (method_selector
== 0)
1696 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1698 /* Call the verification method, to make sure that the target
1699 class implements the desired method. */
1701 argvec
[0] = msg_send
;
1703 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1704 argvec
[3] = value_from_longest (long_type
, selector
);
1707 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1710 /* Function objc_msg_lookup returns a pointer. */
1712 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1714 if (value_as_long (ret
) == 0)
1715 error (_("Target does not respond to this message selector."));
1717 /* Call "methodForSelector:" method, to get the address of a
1718 function method that implements this selector for this
1719 class. If we can find a symbol at that address, then we
1720 know the return type, parameter types etc. (that's a good
1723 argvec
[0] = msg_send
;
1725 argvec
[2] = value_from_longest (long_type
, method_selector
);
1726 argvec
[3] = value_from_longest (long_type
, selector
);
1729 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1733 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1736 /* ret should now be the selector. */
1738 addr
= value_as_long (ret
);
1741 struct symbol
*sym
= NULL
;
1743 /* The address might point to a function descriptor;
1744 resolve it to the actual code address instead. */
1745 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1748 /* Is it a high_level symbol? */
1749 sym
= find_pc_function (addr
);
1751 method
= value_of_variable (sym
, 0);
1754 /* If we found a method with symbol information, check to see
1755 if it returns a struct. Otherwise assume it doesn't. */
1760 struct type
*val_type
;
1762 funaddr
= find_function_addr (method
, &val_type
);
1764 block_for_pc (funaddr
);
1766 val_type
= check_typedef (val_type
);
1768 if ((val_type
== NULL
)
1769 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1771 if (expect_type
!= NULL
)
1772 val_type
= expect_type
;
1775 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1778 else if (expect_type
!= NULL
)
1780 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1781 check_typedef (expect_type
));
1784 /* Found a function symbol. Now we will substitute its
1785 value in place of the message dispatcher (obj_msgSend),
1786 so that we call the method directly instead of thru
1787 the dispatcher. The main reason for doing this is that
1788 we can now evaluate the return value and parameter values
1789 according to their known data types, in case we need to
1790 do things like promotion, dereferencing, special handling
1791 of structs and doubles, etc.
1793 We want to use the type signature of 'method', but still
1794 jump to objc_msgSend() or objc_msgSend_stret() to better
1795 mimic the behavior of the runtime. */
1799 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1800 error (_("method address has symbol information "
1801 "with non-function type; skipping"));
1803 /* Create a function pointer of the appropriate type, and
1804 replace its value with the value of msg_send or
1805 msg_send_stret. We must use a pointer here, as
1806 msg_send and msg_send_stret are of pointer type, and
1807 the representation may be different on systems that use
1808 function descriptors. */
1811 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1812 value_as_address (msg_send_stret
));
1815 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1816 value_as_address (msg_send
));
1821 called_method
= msg_send_stret
;
1823 called_method
= msg_send
;
1826 if (noside
== EVAL_SKIP
)
1827 return eval_skip_value (exp
);
1829 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1831 /* If the return type doesn't look like a function type,
1832 call an error. This can happen if somebody tries to
1833 turn a variable into a function call. This is here
1834 because people often want to call, eg, strcmp, which
1835 gdb doesn't know is a function. If gdb isn't asked for
1836 it's opinion (ie. through "whatis"), it won't offer
1839 struct type
*type
= value_type (called_method
);
1841 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1842 type
= TYPE_TARGET_TYPE (type
);
1843 type
= TYPE_TARGET_TYPE (type
);
1847 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1848 return allocate_value (expect_type
);
1850 return allocate_value (type
);
1853 error (_("Expression of type other than "
1854 "\"method returning ...\" used as a method"));
1857 /* Now depending on whether we found a symbol for the method,
1858 we will either call the runtime dispatcher or the method
1861 argvec
[0] = called_method
;
1863 argvec
[2] = value_from_longest (long_type
, selector
);
1864 /* User-supplied arguments. */
1865 for (tem
= 0; tem
< nargs
; tem
++)
1866 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1867 argvec
[tem
+ 3] = 0;
1869 if (gnu_runtime
&& (method
!= NULL
))
1871 /* Function objc_msg_lookup returns a pointer. */
1872 deprecated_set_value_type (argvec
[0],
1873 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1875 = call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1878 ret
= call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1884 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1886 case OP_F77_UNDETERMINED_ARGLIST
:
1888 /* Remember that in F77, functions, substring ops and
1889 array subscript operations cannot be disambiguated
1890 at parse time. We have made all array subscript operations,
1891 substring operations as well as function calls come here
1892 and we now have to discover what the heck this thing actually was.
1893 If it is a function, we process just as if we got an OP_FUNCALL. */
1895 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1898 /* First determine the type code we are dealing with. */
1899 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1900 type
= check_typedef (value_type (arg1
));
1901 code
= TYPE_CODE (type
);
1903 if (code
== TYPE_CODE_PTR
)
1905 /* Fortran always passes variable to subroutines as pointer.
1906 So we need to look into its target type to see if it is
1907 array, string or function. If it is, we need to switch
1908 to the target value the original one points to. */
1909 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1911 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1912 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1913 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1915 arg1
= value_ind (arg1
);
1916 type
= check_typedef (value_type (arg1
));
1917 code
= TYPE_CODE (type
);
1923 case TYPE_CODE_ARRAY
:
1924 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1925 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1927 goto multi_f77_subscript
;
1929 case TYPE_CODE_STRING
:
1930 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1931 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1934 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1935 return value_subscript (arg1
, value_as_long (arg2
));
1939 case TYPE_CODE_FUNC
:
1940 /* It's a function call. */
1941 /* Allocate arg vector, including space for the function to be
1942 called in argvec[0] and a terminating NULL. */
1943 argvec
= (struct value
**)
1944 alloca (sizeof (struct value
*) * (nargs
+ 2));
1947 for (; tem
<= nargs
; tem
++)
1948 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1949 argvec
[tem
] = 0; /* signal end of arglist */
1950 if (noside
== EVAL_SKIP
)
1951 return eval_skip_value (exp
);
1952 return eval_call (exp
, noside
, nargs
, argvec
, NULL
, expect_type
);
1955 error (_("Cannot perform substring on this type"));
1959 /* We have a complex number, There should be 2 floating
1960 point numbers that compose it. */
1962 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1963 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1965 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1967 case STRUCTOP_STRUCT
:
1968 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1969 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1970 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1971 if (noside
== EVAL_SKIP
)
1972 return eval_skip_value (exp
);
1973 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1975 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1976 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1980 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1981 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1982 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1983 if (noside
== EVAL_SKIP
)
1984 return eval_skip_value (exp
);
1986 /* Check to see if operator '->' has been overloaded. If so replace
1987 arg1 with the value returned by evaluating operator->(). */
1988 while (unop_user_defined_p (op
, arg1
))
1990 struct value
*value
= NULL
;
1993 value
= value_x_unop (arg1
, op
, noside
);
1996 CATCH (except
, RETURN_MASK_ERROR
)
1998 if (except
.error
== NOT_FOUND_ERROR
)
2001 throw_exception (except
);
2008 /* JYG: if print object is on we need to replace the base type
2009 with rtti type in order to continue on with successful
2010 lookup of member / method only available in the rtti type. */
2012 struct type
*type
= value_type (arg1
);
2013 struct type
*real_type
;
2014 int full
, using_enc
;
2016 struct value_print_options opts
;
2018 get_user_print_options (&opts
);
2019 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
2020 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
2022 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
2025 arg1
= value_cast (real_type
, arg1
);
2029 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2030 NULL
, "structure pointer");
2031 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2032 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2035 case STRUCTOP_MEMBER
:
2037 if (op
== STRUCTOP_MEMBER
)
2038 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2040 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2042 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2044 if (noside
== EVAL_SKIP
)
2045 return eval_skip_value (exp
);
2047 type
= check_typedef (value_type (arg2
));
2048 switch (TYPE_CODE (type
))
2050 case TYPE_CODE_METHODPTR
:
2051 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2052 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2055 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2056 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2057 return value_ind (arg2
);
2060 case TYPE_CODE_MEMBERPTR
:
2061 /* Now, convert these values to an address. */
2062 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
2065 mem_offset
= value_as_long (arg2
);
2067 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2068 value_as_long (arg1
) + mem_offset
);
2069 return value_ind (arg3
);
2072 error (_("non-pointer-to-member value used "
2073 "in pointer-to-member construct"));
2078 type_instance_flags flags
2079 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2080 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2081 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2082 for (ix
= 0; ix
< nargs
; ++ix
)
2083 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2085 fake_method
expect_type (flags
, nargs
, arg_types
);
2086 *(pos
) += 4 + nargs
;
2087 return evaluate_subexp_standard (expect_type
.type (), exp
, pos
, noside
);
2091 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2092 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2093 if (noside
== EVAL_SKIP
)
2094 return eval_skip_value (exp
);
2095 if (binop_user_defined_p (op
, arg1
, arg2
))
2096 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2098 return value_concat (arg1
, arg2
);
2101 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2102 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2104 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2106 if (binop_user_defined_p (op
, arg1
, arg2
))
2107 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2109 return value_assign (arg1
, arg2
);
2111 case BINOP_ASSIGN_MODIFY
:
2113 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2114 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2115 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2117 op
= exp
->elts
[pc
+ 1].opcode
;
2118 if (binop_user_defined_p (op
, arg1
, arg2
))
2119 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2120 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2122 && is_integral_type (value_type (arg2
)))
2123 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2124 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2126 && is_integral_type (value_type (arg2
)))
2127 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2130 struct value
*tmp
= arg1
;
2132 /* For shift and integer exponentiation operations,
2133 only promote the first argument. */
2134 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2135 && is_integral_type (value_type (arg2
)))
2136 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2138 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2140 arg2
= value_binop (tmp
, arg2
, op
);
2142 return value_assign (arg1
, arg2
);
2145 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2146 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2147 if (noside
== EVAL_SKIP
)
2148 return eval_skip_value (exp
);
2149 if (binop_user_defined_p (op
, arg1
, arg2
))
2150 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2151 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2152 && is_integral_type (value_type (arg2
)))
2153 return value_ptradd (arg1
, value_as_long (arg2
));
2154 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2155 && is_integral_type (value_type (arg1
)))
2156 return value_ptradd (arg2
, value_as_long (arg1
));
2159 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2160 return value_binop (arg1
, arg2
, BINOP_ADD
);
2164 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2165 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2166 if (noside
== EVAL_SKIP
)
2167 return eval_skip_value (exp
);
2168 if (binop_user_defined_p (op
, arg1
, arg2
))
2169 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2170 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2171 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2173 /* FIXME -- should be ptrdiff_t */
2174 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2175 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2177 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2178 && is_integral_type (value_type (arg2
)))
2179 return value_ptradd (arg1
, - value_as_long (arg2
));
2182 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2183 return value_binop (arg1
, arg2
, BINOP_SUB
);
2194 case BINOP_BITWISE_AND
:
2195 case BINOP_BITWISE_IOR
:
2196 case BINOP_BITWISE_XOR
:
2197 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2198 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2199 if (noside
== EVAL_SKIP
)
2200 return eval_skip_value (exp
);
2201 if (binop_user_defined_p (op
, arg1
, arg2
))
2202 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2205 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2206 fudge arg2 to avoid division-by-zero, the caller is
2207 (theoretically) only looking for the type of the result. */
2208 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2209 /* ??? Do we really want to test for BINOP_MOD here?
2210 The implementation of value_binop gives it a well-defined
2213 || op
== BINOP_INTDIV
2216 && value_logical_not (arg2
))
2218 struct value
*v_one
, *retval
;
2220 v_one
= value_one (value_type (arg2
));
2221 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2222 retval
= value_binop (arg1
, v_one
, op
);
2227 /* For shift and integer exponentiation operations,
2228 only promote the first argument. */
2229 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2230 && is_integral_type (value_type (arg2
)))
2231 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2233 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2235 return value_binop (arg1
, arg2
, op
);
2239 case BINOP_SUBSCRIPT
:
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 the user attempts to subscript something that is not an
2249 array or pointer type (like a plain int variable for example),
2250 then report this as an error. */
2252 arg1
= coerce_ref (arg1
);
2253 type
= check_typedef (value_type (arg1
));
2254 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2255 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2257 if (TYPE_NAME (type
))
2258 error (_("cannot subscript something of type `%s'"),
2261 error (_("cannot subscript requested type"));
2264 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2265 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2267 return value_subscript (arg1
, value_as_long (arg2
));
2269 case MULTI_SUBSCRIPT
:
2271 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2272 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2275 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2276 /* FIXME: EVAL_SKIP handling may not be correct. */
2277 if (noside
== EVAL_SKIP
)
2281 return eval_skip_value (exp
);
2283 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2284 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2286 /* If the user attempts to subscript something that has no target
2287 type (like a plain int variable for example), then report this
2290 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2293 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2299 error (_("cannot subscript something of type `%s'"),
2300 TYPE_NAME (value_type (arg1
)));
2304 if (binop_user_defined_p (op
, arg1
, arg2
))
2306 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2310 arg1
= coerce_ref (arg1
);
2311 type
= check_typedef (value_type (arg1
));
2313 switch (TYPE_CODE (type
))
2316 case TYPE_CODE_ARRAY
:
2317 case TYPE_CODE_STRING
:
2318 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2322 if (TYPE_NAME (type
))
2323 error (_("cannot subscript something of type `%s'"),
2326 error (_("cannot subscript requested type"));
2332 multi_f77_subscript
:
2334 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2335 int ndimensions
= 1, i
;
2336 struct value
*array
= arg1
;
2338 if (nargs
> MAX_FORTRAN_DIMS
)
2339 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2341 ndimensions
= calc_f77_array_dims (type
);
2343 if (nargs
!= ndimensions
)
2344 error (_("Wrong number of subscripts"));
2346 gdb_assert (nargs
> 0);
2348 /* Now that we know we have a legal array subscript expression
2349 let us actually find out where this element exists in the array. */
2351 /* Take array indices left to right. */
2352 for (i
= 0; i
< nargs
; i
++)
2354 /* Evaluate each subscript; it must be a legal integer in F77. */
2355 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2357 /* Fill in the subscript array. */
2359 subscript_array
[i
] = value_as_long (arg2
);
2362 /* Internal type of array is arranged right to left. */
2363 for (i
= nargs
; i
> 0; i
--)
2365 struct type
*array_type
= check_typedef (value_type (array
));
2366 LONGEST index
= subscript_array
[i
- 1];
2368 array
= value_subscripted_rvalue (array
, index
,
2369 f77_get_lowerbound (array_type
));
2375 case BINOP_LOGICAL_AND
:
2376 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2377 if (noside
== EVAL_SKIP
)
2379 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2380 return eval_skip_value (exp
);
2384 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2387 if (binop_user_defined_p (op
, arg1
, arg2
))
2389 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2390 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2394 tem
= value_logical_not (arg1
);
2395 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2396 (tem
? EVAL_SKIP
: noside
));
2397 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2398 return value_from_longest (type
,
2399 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2402 case BINOP_LOGICAL_OR
:
2403 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2404 if (noside
== EVAL_SKIP
)
2406 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2407 return eval_skip_value (exp
);
2411 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2414 if (binop_user_defined_p (op
, arg1
, arg2
))
2416 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2417 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2421 tem
= value_logical_not (arg1
);
2422 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2423 (!tem
? EVAL_SKIP
: noside
));
2424 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2425 return value_from_longest (type
,
2426 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2430 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2431 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2432 if (noside
== EVAL_SKIP
)
2433 return eval_skip_value (exp
);
2434 if (binop_user_defined_p (op
, arg1
, arg2
))
2436 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2440 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2441 tem
= value_equal (arg1
, arg2
);
2442 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2443 return value_from_longest (type
, (LONGEST
) tem
);
2446 case BINOP_NOTEQUAL
:
2447 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2448 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2449 if (noside
== EVAL_SKIP
)
2450 return eval_skip_value (exp
);
2451 if (binop_user_defined_p (op
, arg1
, arg2
))
2453 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2457 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2458 tem
= value_equal (arg1
, arg2
);
2459 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2460 return value_from_longest (type
, (LONGEST
) ! tem
);
2464 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2465 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2466 if (noside
== EVAL_SKIP
)
2467 return eval_skip_value (exp
);
2468 if (binop_user_defined_p (op
, arg1
, arg2
))
2470 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2474 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2475 tem
= value_less (arg1
, arg2
);
2476 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2477 return value_from_longest (type
, (LONGEST
) tem
);
2481 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2482 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2483 if (noside
== EVAL_SKIP
)
2484 return eval_skip_value (exp
);
2485 if (binop_user_defined_p (op
, arg1
, arg2
))
2487 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2491 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2492 tem
= value_less (arg2
, arg1
);
2493 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2494 return value_from_longest (type
, (LONGEST
) tem
);
2498 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2499 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2500 if (noside
== EVAL_SKIP
)
2501 return eval_skip_value (exp
);
2502 if (binop_user_defined_p (op
, arg1
, arg2
))
2504 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2508 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2509 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2510 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2511 return value_from_longest (type
, (LONGEST
) tem
);
2515 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2516 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2517 if (noside
== EVAL_SKIP
)
2518 return eval_skip_value (exp
);
2519 if (binop_user_defined_p (op
, arg1
, arg2
))
2521 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2525 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2526 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2527 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2528 return value_from_longest (type
, (LONGEST
) tem
);
2532 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2533 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2534 if (noside
== EVAL_SKIP
)
2535 return eval_skip_value (exp
);
2536 type
= check_typedef (value_type (arg2
));
2537 if (TYPE_CODE (type
) != TYPE_CODE_INT
2538 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
2539 error (_("Non-integral right operand for \"@\" operator."));
2540 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2542 return allocate_repeat_value (value_type (arg1
),
2543 longest_to_int (value_as_long (arg2
)));
2546 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2549 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2550 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2553 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2554 if (noside
== EVAL_SKIP
)
2555 return eval_skip_value (exp
);
2556 if (unop_user_defined_p (op
, arg1
))
2557 return value_x_unop (arg1
, op
, noside
);
2560 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2561 return value_pos (arg1
);
2565 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2566 if (noside
== EVAL_SKIP
)
2567 return eval_skip_value (exp
);
2568 if (unop_user_defined_p (op
, arg1
))
2569 return value_x_unop (arg1
, op
, noside
);
2572 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2573 return value_neg (arg1
);
2576 case UNOP_COMPLEMENT
:
2577 /* C++: check for and handle destructor names. */
2579 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2580 if (noside
== EVAL_SKIP
)
2581 return eval_skip_value (exp
);
2582 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2583 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2586 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2587 return value_complement (arg1
);
2590 case UNOP_LOGICAL_NOT
:
2591 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2592 if (noside
== EVAL_SKIP
)
2593 return eval_skip_value (exp
);
2594 if (unop_user_defined_p (op
, arg1
))
2595 return value_x_unop (arg1
, op
, noside
);
2598 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2599 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2603 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2604 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2605 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2606 type
= check_typedef (value_type (arg1
));
2607 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2608 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2609 error (_("Attempt to dereference pointer "
2610 "to member without an object"));
2611 if (noside
== EVAL_SKIP
)
2612 return eval_skip_value (exp
);
2613 if (unop_user_defined_p (op
, arg1
))
2614 return value_x_unop (arg1
, op
, noside
);
2615 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2617 type
= check_typedef (value_type (arg1
));
2618 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2619 || TYPE_IS_REFERENCE (type
)
2620 /* In C you can dereference an array to get the 1st elt. */
2621 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2623 return value_zero (TYPE_TARGET_TYPE (type
),
2625 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2626 /* GDB allows dereferencing an int. */
2627 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2630 error (_("Attempt to take contents of a non-pointer value."));
2633 /* Allow * on an integer so we can cast it to whatever we want.
2634 This returns an int, which seems like the most C-like thing to
2635 do. "long long" variables are rare enough that
2636 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2637 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2638 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2639 (CORE_ADDR
) value_as_address (arg1
));
2640 return value_ind (arg1
);
2643 /* C++: check for and handle pointer to members. */
2645 if (noside
== EVAL_SKIP
)
2647 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2648 return eval_skip_value (exp
);
2652 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2659 if (noside
== EVAL_SKIP
)
2661 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2662 return eval_skip_value (exp
);
2664 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2668 type
= exp
->elts
[pc
+ 1].type
;
2669 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2671 case UNOP_CAST_TYPE
:
2672 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2673 type
= value_type (arg1
);
2674 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2676 case UNOP_DYNAMIC_CAST
:
2677 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2678 type
= value_type (arg1
);
2679 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2680 if (noside
== EVAL_SKIP
)
2681 return eval_skip_value (exp
);
2682 return value_dynamic_cast (type
, arg1
);
2684 case UNOP_REINTERPRET_CAST
:
2685 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2686 type
= value_type (arg1
);
2687 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2688 if (noside
== EVAL_SKIP
)
2689 return eval_skip_value (exp
);
2690 return value_reinterpret_cast (type
, arg1
);
2694 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2695 if (noside
== EVAL_SKIP
)
2696 return eval_skip_value (exp
);
2697 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2698 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2700 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2701 value_as_address (arg1
));
2703 case UNOP_MEMVAL_TYPE
:
2704 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2705 type
= value_type (arg1
);
2706 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2707 if (noside
== EVAL_SKIP
)
2708 return eval_skip_value (exp
);
2709 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2710 return value_zero (type
, lval_memory
);
2712 return value_at_lazy (type
, value_as_address (arg1
));
2714 case UNOP_PREINCREMENT
:
2715 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2716 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2718 else if (unop_user_defined_p (op
, arg1
))
2720 return value_x_unop (arg1
, op
, noside
);
2724 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2725 arg2
= value_ptradd (arg1
, 1);
2728 struct value
*tmp
= arg1
;
2730 arg2
= value_one (value_type (arg1
));
2731 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2732 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2735 return value_assign (arg1
, arg2
);
2738 case UNOP_PREDECREMENT
:
2739 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2740 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2742 else if (unop_user_defined_p (op
, arg1
))
2744 return value_x_unop (arg1
, op
, noside
);
2748 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2749 arg2
= value_ptradd (arg1
, -1);
2752 struct value
*tmp
= arg1
;
2754 arg2
= value_one (value_type (arg1
));
2755 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2756 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2759 return value_assign (arg1
, arg2
);
2762 case UNOP_POSTINCREMENT
:
2763 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2764 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2766 else if (unop_user_defined_p (op
, arg1
))
2768 return value_x_unop (arg1
, op
, noside
);
2772 arg3
= value_non_lval (arg1
);
2774 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2775 arg2
= value_ptradd (arg1
, 1);
2778 struct value
*tmp
= arg1
;
2780 arg2
= value_one (value_type (arg1
));
2781 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2782 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2785 value_assign (arg1
, arg2
);
2789 case UNOP_POSTDECREMENT
:
2790 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2791 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2793 else if (unop_user_defined_p (op
, arg1
))
2795 return value_x_unop (arg1
, op
, noside
);
2799 arg3
= value_non_lval (arg1
);
2801 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2802 arg2
= value_ptradd (arg1
, -1);
2805 struct value
*tmp
= arg1
;
2807 arg2
= value_one (value_type (arg1
));
2808 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2809 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2812 value_assign (arg1
, arg2
);
2818 return value_of_this (exp
->language_defn
);
2821 /* The value is not supposed to be used. This is here to make it
2822 easier to accommodate expressions that contain types. */
2824 if (noside
== EVAL_SKIP
)
2825 return eval_skip_value (exp
);
2826 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2827 return allocate_value (exp
->elts
[pc
+ 1].type
);
2829 error (_("Attempt to use a type name as an expression"));
2833 if (noside
== EVAL_SKIP
)
2835 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2836 return eval_skip_value (exp
);
2838 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2840 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2841 struct value
*result
;
2843 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2844 EVAL_AVOID_SIDE_EFFECTS
);
2846 /* 'decltype' has special semantics for lvalues. */
2847 if (op
== OP_DECLTYPE
2848 && (sub_op
== BINOP_SUBSCRIPT
2849 || sub_op
== STRUCTOP_MEMBER
2850 || sub_op
== STRUCTOP_MPTR
2851 || sub_op
== UNOP_IND
2852 || sub_op
== STRUCTOP_STRUCT
2853 || sub_op
== STRUCTOP_PTR
2854 || sub_op
== OP_SCOPE
))
2856 struct type
*type
= value_type (result
);
2858 if (!TYPE_IS_REFERENCE (type
))
2860 type
= lookup_lvalue_reference_type (type
);
2861 result
= allocate_value (type
);
2868 error (_("Attempt to use a type as an expression"));
2872 struct value
*result
;
2873 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2875 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2876 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2877 EVAL_AVOID_SIDE_EFFECTS
);
2879 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2881 if (noside
!= EVAL_NORMAL
)
2882 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2884 return cplus_typeid (result
);
2888 /* Removing this case and compiling with gcc -Wall reveals that
2889 a lot of cases are hitting this case. Some of these should
2890 probably be removed from expression.h; others are legitimate
2891 expressions which are (apparently) not fully implemented.
2893 If there are any cases landing here which mean a user error,
2894 then they should be separate cases, with more descriptive
2897 error (_("GDB does not (yet) know how to "
2898 "evaluate that kind of expression"));
2901 gdb_assert_not_reached ("missed return?");
2904 /* Evaluate a subexpression of EXP, at index *POS,
2905 and return the address of that subexpression.
2906 Advance *POS over the subexpression.
2907 If the subexpression isn't an lvalue, get an error.
2908 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2909 then only the type of the result need be correct. */
2911 static struct value
*
2912 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2922 op
= exp
->elts
[pc
].opcode
;
2928 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2930 /* We can't optimize out "&*" if there's a user-defined operator*. */
2931 if (unop_user_defined_p (op
, x
))
2933 x
= value_x_unop (x
, op
, noside
);
2934 goto default_case_after_eval
;
2937 return coerce_array (x
);
2941 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2942 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2944 case UNOP_MEMVAL_TYPE
:
2949 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2950 type
= value_type (x
);
2951 return value_cast (lookup_pointer_type (type
),
2952 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2956 var
= exp
->elts
[pc
+ 2].symbol
;
2958 /* C++: The "address" of a reference should yield the address
2959 * of the object pointed to. Let value_addr() deal with it. */
2960 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
2964 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2967 lookup_pointer_type (SYMBOL_TYPE (var
));
2968 enum address_class sym_class
= SYMBOL_CLASS (var
);
2970 if (sym_class
== LOC_CONST
2971 || sym_class
== LOC_CONST_BYTES
2972 || sym_class
== LOC_REGISTER
)
2973 error (_("Attempt to take address of register or constant."));
2976 value_zero (type
, not_lval
);
2979 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2981 case OP_VAR_MSYM_VALUE
:
2985 value
*val
= evaluate_var_msym_value (noside
,
2986 exp
->elts
[pc
+ 1].objfile
,
2987 exp
->elts
[pc
+ 2].msymbol
);
2988 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2990 struct type
*type
= lookup_pointer_type (value_type (val
));
2991 return value_zero (type
, not_lval
);
2994 return value_addr (val
);
2998 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2999 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3000 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3001 &exp
->elts
[pc
+ 3].string
,
3004 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3009 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3010 default_case_after_eval
:
3011 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3013 struct type
*type
= check_typedef (value_type (x
));
3015 if (TYPE_IS_REFERENCE (type
))
3016 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3018 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3019 return value_zero (lookup_pointer_type (value_type (x
)),
3022 error (_("Attempt to take address of "
3023 "value not located in memory."));
3025 return value_addr (x
);
3029 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3030 When used in contexts where arrays will be coerced anyway, this is
3031 equivalent to `evaluate_subexp' but much faster because it avoids
3032 actually fetching array contents (perhaps obsolete now that we have
3035 Note that we currently only do the coercion for C expressions, where
3036 arrays are zero based and the coercion is correct. For other languages,
3037 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3038 to decide if coercion is appropriate. */
3041 evaluate_subexp_with_coercion (struct expression
*exp
,
3042 int *pos
, enum noside noside
)
3051 op
= exp
->elts
[pc
].opcode
;
3056 var
= exp
->elts
[pc
+ 2].symbol
;
3057 type
= check_typedef (SYMBOL_TYPE (var
));
3058 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3059 && !TYPE_VECTOR (type
)
3060 && CAST_IS_CONVERSION (exp
->language_defn
))
3063 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3064 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3070 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3074 /* Evaluate a subexpression of EXP, at index *POS,
3075 and return a value for the size of that subexpression.
3076 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3077 we allow side-effects on the operand if its type is a variable
3080 static struct value
*
3081 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3084 /* FIXME: This should be size_t. */
3085 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3092 op
= exp
->elts
[pc
].opcode
;
3096 /* This case is handled specially
3097 so that we avoid creating a value for the result type.
3098 If the result type is very big, it's desirable not to
3099 create a value unnecessarily. */
3102 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3103 type
= check_typedef (value_type (val
));
3104 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3105 && !TYPE_IS_REFERENCE (type
)
3106 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3107 error (_("Attempt to take contents of a non-pointer value."));
3108 type
= TYPE_TARGET_TYPE (type
);
3109 if (is_dynamic_type (type
))
3110 type
= value_type (value_ind (val
));
3111 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3115 type
= exp
->elts
[pc
+ 1].type
;
3118 case UNOP_MEMVAL_TYPE
:
3120 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3121 type
= value_type (val
);
3125 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3126 if (is_dynamic_type (type
))
3128 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3129 type
= value_type (val
);
3135 case OP_VAR_MSYM_VALUE
:
3139 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3140 value
*val
= evaluate_var_msym_value (noside
,
3141 exp
->elts
[pc
+ 1].objfile
,
3144 type
= value_type (val
);
3145 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
)
3146 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol
));
3148 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3152 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3153 type of the subscript is a variable length array type. In this case we
3154 must re-evaluate the right hand side of the subcription to allow
3156 case BINOP_SUBSCRIPT
:
3157 if (noside
== EVAL_NORMAL
)
3159 int pc
= (*pos
) + 1;
3161 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3162 type
= check_typedef (value_type (val
));
3163 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3165 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3166 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3168 type
= TYPE_INDEX_TYPE (type
);
3169 /* Only re-evaluate the right hand side if the resulting type
3170 is a variable length type. */
3171 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3173 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3174 return value_from_longest
3175 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3184 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3185 type
= value_type (val
);
3189 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3190 "When applied to a reference or a reference type, the result is
3191 the size of the referenced type." */
3192 type
= check_typedef (type
);
3193 if (exp
->language_defn
->la_language
== language_cplus
3194 && (TYPE_IS_REFERENCE (type
)))
3195 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3196 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3199 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3200 for that subexpression cast to TO_TYPE. Advance *POS over the
3204 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3206 struct type
*to_type
)
3210 /* Don't let symbols be evaluated with evaluate_subexp because that
3211 throws an "unknown type" error for no-debug data symbols.
3212 Instead, we want the cast to reinterpret the symbol. */
3213 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3214 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3219 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3221 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3222 return value_zero (to_type
, not_lval
);
3224 val
= evaluate_var_msym_value (noside
,
3225 exp
->elts
[pc
+ 1].objfile
,
3226 exp
->elts
[pc
+ 2].msymbol
);
3229 val
= evaluate_var_value (noside
,
3230 exp
->elts
[pc
+ 1].block
,
3231 exp
->elts
[pc
+ 2].symbol
);
3233 if (noside
== EVAL_SKIP
)
3234 return eval_skip_value (exp
);
3236 val
= value_cast (to_type
, val
);
3238 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3239 if (VALUE_LVAL (val
) == lval_memory
)
3241 if (value_lazy (val
))
3242 value_fetch_lazy (val
);
3243 VALUE_LVAL (val
) = not_lval
;
3248 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3249 if (noside
== EVAL_SKIP
)
3250 return eval_skip_value (exp
);
3251 return value_cast (to_type
, val
);
3254 /* Parse a type expression in the string [P..P+LENGTH). */
3257 parse_and_eval_type (char *p
, int length
)
3259 char *tmp
= (char *) alloca (length
+ 4);
3262 memcpy (tmp
+ 1, p
, length
);
3263 tmp
[length
+ 1] = ')';
3264 tmp
[length
+ 2] = '0';
3265 tmp
[length
+ 3] = '\0';
3266 expression_up expr
= parse_expression (tmp
);
3267 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3268 error (_("Internal error in eval_type."));
3269 return expr
->elts
[1].type
;
3273 calc_f77_array_dims (struct type
*array_type
)
3276 struct type
*tmp_type
;
3278 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3279 error (_("Can't get dimensions for a non-array type"));
3281 tmp_type
= array_type
;
3283 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3285 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)