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, 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
)
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
= value_release_to_mark (mark
);
260 /* Extract a field operation from an expression. If the subexpression
261 of EXP starting at *SUBEXP is not a structure dereference
262 operation, return NULL. Otherwise, return the name of the
263 dereferenced field, and advance *SUBEXP to point to the
264 subexpression of the left-hand-side of the dereference. This is
265 used when completing field names. */
268 extract_field_op (struct expression
*exp
, int *subexp
)
273 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
274 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
276 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
277 result
= &exp
->elts
[*subexp
+ 2].string
;
278 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
282 /* This function evaluates brace-initializers (in C/C++) for
285 static struct value
*
286 evaluate_struct_tuple (struct value
*struct_val
,
287 struct expression
*exp
,
288 int *pos
, enum noside noside
, int nargs
)
290 struct type
*struct_type
= check_typedef (value_type (struct_val
));
291 struct type
*field_type
;
296 struct value
*val
= NULL
;
301 /* Skip static fields. */
302 while (fieldno
< TYPE_NFIELDS (struct_type
)
303 && field_is_static (&TYPE_FIELD (struct_type
,
306 if (fieldno
>= TYPE_NFIELDS (struct_type
))
307 error (_("too many initializers"));
308 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
309 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
310 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
311 error (_("don't know which variant you want to set"));
313 /* Here, struct_type is the type of the inner struct,
314 while substruct_type is the type of the inner struct.
315 These are the same for normal structures, but a variant struct
316 contains anonymous union fields that contain substruct fields.
317 The value fieldno is the index of the top-level (normal or
318 anonymous union) field in struct_field, while the value
319 subfieldno is the index of the actual real (named inner) field
320 in substruct_type. */
322 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
324 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
326 /* Now actually set the field in struct_val. */
328 /* Assign val to field fieldno. */
329 if (value_type (val
) != field_type
)
330 val
= value_cast (field_type
, val
);
332 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
333 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
334 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
336 modify_field (struct_type
, addr
,
337 value_as_long (val
), bitpos
% 8, bitsize
);
339 memcpy (addr
, value_contents (val
),
340 TYPE_LENGTH (value_type (val
)));
346 /* Recursive helper function for setting elements of array tuples.
347 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
348 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
349 Evaluates index expresions and sets the specified element(s) of
350 ARRAY to ELEMENT. Returns last index value. */
353 init_array_element (struct value
*array
, struct value
*element
,
354 struct expression
*exp
, int *pos
,
355 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
358 int element_size
= TYPE_LENGTH (value_type (element
));
360 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
363 init_array_element (array
, element
, exp
, pos
, noside
,
364 low_bound
, high_bound
);
365 return init_array_element (array
, element
,
366 exp
, pos
, noside
, low_bound
, high_bound
);
370 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
371 if (index
< low_bound
|| index
> high_bound
)
372 error (_("tuple index out of range"));
373 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
374 value_contents (element
), element_size
);
379 static struct value
*
380 value_f90_subarray (struct value
*array
,
381 struct expression
*exp
, int *pos
, enum noside noside
)
384 LONGEST low_bound
, high_bound
;
385 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
386 enum range_type range_type
387 = (enum range_type
) longest_to_int (exp
->elts
[pc
].longconst
);
391 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
392 low_bound
= TYPE_LOW_BOUND (range
);
394 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
396 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
397 high_bound
= TYPE_HIGH_BOUND (range
);
399 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
401 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
405 /* Promote value ARG1 as appropriate before performing a unary operation
407 If the result is not appropriate for any particular language then it
408 needs to patch this function. */
411 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
416 *arg1
= coerce_ref (*arg1
);
417 type1
= check_typedef (value_type (*arg1
));
419 if (is_integral_type (type1
))
421 switch (language
->la_language
)
424 /* Perform integral promotion for ANSI C/C++.
425 If not appropropriate for any particular language
426 it needs to modify this function. */
428 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
430 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
431 *arg1
= value_cast (builtin_int
, *arg1
);
438 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
439 operation on those two operands.
440 If the result is not appropriate for any particular language then it
441 needs to patch this function. */
444 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
445 struct value
**arg1
, struct value
**arg2
)
447 struct type
*promoted_type
= NULL
;
451 *arg1
= coerce_ref (*arg1
);
452 *arg2
= coerce_ref (*arg2
);
454 type1
= check_typedef (value_type (*arg1
));
455 type2
= check_typedef (value_type (*arg2
));
457 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
458 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
459 && !is_integral_type (type1
))
460 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
461 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
462 && !is_integral_type (type2
)))
465 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
466 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
468 /* No promotion required. */
470 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
471 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
473 switch (language
->la_language
)
479 case language_opencl
:
480 /* No promotion required. */
484 /* For other languages the result type is unchanged from gdb
485 version 6.7 for backward compatibility.
486 If either arg was long double, make sure that value is also long
487 double. Otherwise use double. */
488 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
489 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
490 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
492 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
496 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
497 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
499 /* No promotion required. */
502 /* Integral operations here. */
503 /* FIXME: Also mixed integral/booleans, with result an integer. */
505 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
506 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
507 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
508 int is_unsigned1
= TYPE_UNSIGNED (type1
);
509 int is_unsigned2
= TYPE_UNSIGNED (type2
);
510 unsigned int result_len
;
511 int unsigned_operation
;
513 /* Determine type length and signedness after promotion for
515 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
518 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
520 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
523 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
526 if (promoted_len1
> promoted_len2
)
528 unsigned_operation
= is_unsigned1
;
529 result_len
= promoted_len1
;
531 else if (promoted_len2
> promoted_len1
)
533 unsigned_operation
= is_unsigned2
;
534 result_len
= promoted_len2
;
538 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
539 result_len
= promoted_len1
;
542 switch (language
->la_language
)
548 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
550 promoted_type
= (unsigned_operation
551 ? builtin
->builtin_unsigned_int
552 : builtin
->builtin_int
);
554 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
556 promoted_type
= (unsigned_operation
557 ? builtin
->builtin_unsigned_long
558 : builtin
->builtin_long
);
562 promoted_type
= (unsigned_operation
563 ? builtin
->builtin_unsigned_long_long
564 : builtin
->builtin_long_long
);
567 case language_opencl
:
568 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
569 (language
, gdbarch
, "int")))
573 ? lookup_unsigned_typename (language
, gdbarch
, "int")
574 : lookup_signed_typename (language
, gdbarch
, "int"));
576 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
577 (language
, gdbarch
, "long")))
581 ? lookup_unsigned_typename (language
, gdbarch
, "long")
582 : lookup_signed_typename (language
, gdbarch
,"long"));
586 /* For other languages the result type is unchanged from gdb
587 version 6.7 for backward compatibility.
588 If either arg was long long, make sure that value is also long
589 long. Otherwise use long. */
590 if (unsigned_operation
)
592 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
593 promoted_type
= builtin
->builtin_unsigned_long_long
;
595 promoted_type
= builtin
->builtin_unsigned_long
;
599 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
600 promoted_type
= builtin
->builtin_long_long
;
602 promoted_type
= builtin
->builtin_long
;
610 /* Promote both operands to common type. */
611 *arg1
= value_cast (promoted_type
, *arg1
);
612 *arg2
= value_cast (promoted_type
, *arg2
);
617 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
619 type
= check_typedef (type
);
620 if (TYPE_IS_REFERENCE (type
))
621 type
= TYPE_TARGET_TYPE (type
);
623 switch (TYPE_CODE (type
))
629 case TYPE_CODE_ARRAY
:
630 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
637 /* Represents a fake method with the given parameter types. This is
638 used by the parser to construct a temporary "expected" type for
639 method overload resolution. FLAGS is used as instance flags of the
640 new type, in order to be able to make the new type represent a
641 const/volatile overload. */
646 fake_method (type_instance_flags flags
,
647 int num_types
, struct type
**param_types
);
650 /* The constructed type. */
651 struct type
*type () { return &m_type
; }
654 struct type m_type
{};
655 main_type m_main_type
{};
658 fake_method::fake_method (type_instance_flags flags
,
659 int num_types
, struct type
**param_types
)
661 struct type
*type
= &m_type
;
663 TYPE_MAIN_TYPE (type
) = &m_main_type
;
664 TYPE_LENGTH (type
) = 1;
665 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
666 TYPE_CHAIN (type
) = type
;
667 TYPE_INSTANCE_FLAGS (type
) = flags
;
670 if (param_types
[num_types
- 1] == NULL
)
673 TYPE_VARARGS (type
) = 1;
675 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
679 /* Caller should have ensured this. */
680 gdb_assert (num_types
== 0);
681 TYPE_PROTOTYPED (type
) = 1;
685 TYPE_NFIELDS (type
) = num_types
;
686 TYPE_FIELDS (type
) = (struct field
*)
687 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
689 while (num_types
-- > 0)
690 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
693 fake_method::~fake_method ()
695 xfree (TYPE_FIELDS (&m_type
));
698 /* Helper for evaluating an OP_VAR_VALUE. */
701 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
703 /* JYG: We used to just return value_zero of the symbol type if
704 we're asked to avoid side effects. Otherwise we return
705 value_of_variable (...). However I'm not sure if
706 value_of_variable () has any side effect. We need a full value
707 object returned here for whatis_exp () to call evaluate_type ()
708 and then pass the full value to value_rtti_target_type () if we
709 are dealing with a pointer or reference to a base class and print
712 struct value
*ret
= NULL
;
716 ret
= value_of_variable (var
, blk
);
719 CATCH (except
, RETURN_MASK_ERROR
)
721 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
722 throw_exception (except
);
724 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
731 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
734 evaluate_var_msym_value (enum noside noside
,
735 struct objfile
*objfile
, minimal_symbol
*msymbol
)
737 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
739 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, NULL
);
740 return value_zero (the_type
, not_lval
);
745 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
746 return value_at_lazy (the_type
, address
);
750 /* Helper for returning a value when handling EVAL_SKIP. */
753 eval_skip_value (expression
*exp
)
755 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
758 /* Evaluate a function call. The function to be called is in
759 ARGVEC[0] and the arguments passed to the function are in
760 ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
761 known. DEFAULT_RETURN_TYPE is used as the function's return type
762 if the return type is unknown. */
765 eval_call (expression
*exp
, enum noside noside
,
766 int nargs
, value
**argvec
,
767 const char *function_name
,
768 type
*default_return_type
)
770 if (argvec
[0] == NULL
)
771 error (_("Cannot evaluate function -- may be inlined"));
772 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
774 /* If the return type doesn't look like a function type,
775 call an error. This can happen if somebody tries to turn
776 a variable into a function call. */
778 type
*ftype
= value_type (argvec
[0]);
780 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
782 /* We don't know anything about what the internal
783 function might return, but we have to return
785 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
788 else if (TYPE_CODE (ftype
) == TYPE_CODE_XMETHOD
)
791 = result_type_of_xmethod (argvec
[0], nargs
, argvec
+ 1);
793 if (return_type
== NULL
)
794 error (_("Xmethod is missing return type."));
795 return value_zero (return_type
, not_lval
);
797 else if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
798 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
800 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
802 if (return_type
== NULL
)
803 return_type
= default_return_type
;
805 if (return_type
== NULL
)
806 error_call_unknown_return_type (function_name
);
808 return allocate_value (return_type
);
811 error (_("Expression of type other than "
812 "\"Function returning ...\" used as function"));
814 switch (TYPE_CODE (value_type (argvec
[0])))
816 case TYPE_CODE_INTERNAL_FUNCTION
:
817 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
818 argvec
[0], nargs
, argvec
+ 1);
819 case TYPE_CODE_XMETHOD
:
820 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
822 return call_function_by_hand (argvec
[0], default_return_type
,
827 /* Helper for evaluating an OP_FUNCALL. */
830 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
838 symbol
*function
= NULL
;
839 char *function_name
= NULL
;
840 const char *var_func_name
= NULL
;
845 exp_opcode op
= exp
->elts
[*pos
].opcode
;
846 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
847 /* Allocate arg vector, including space for the function to be
848 called in argvec[0], a potential `this', and a terminating
850 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
851 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
853 /* First, evaluate the structure into arg2. */
856 if (op
== STRUCTOP_MEMBER
)
858 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
862 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
865 /* If the function is a virtual function, then the aggregate
866 value (providing the structure) plays its part by providing
867 the vtable. Otherwise, it is just along for the ride: call
868 the function directly. */
870 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
872 type
*a1_type
= check_typedef (value_type (arg1
));
873 if (noside
== EVAL_SKIP
)
874 tem
= 1; /* Set it to the right arg index so that all
875 arguments can also be skipped. */
876 else if (TYPE_CODE (a1_type
) == TYPE_CODE_METHODPTR
)
878 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
879 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
881 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
883 /* Now, say which argument to start evaluating from. */
888 else if (TYPE_CODE (a1_type
) == TYPE_CODE_MEMBERPTR
)
890 struct type
*type_ptr
891 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
892 struct type
*target_type_ptr
893 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
895 /* Now, convert these values to an address. */
896 arg2
= value_cast (type_ptr
, arg2
);
898 long mem_offset
= value_as_long (arg1
);
900 arg1
= value_from_pointer (target_type_ptr
,
901 value_as_long (arg2
) + mem_offset
);
902 arg1
= value_ind (arg1
);
906 error (_("Non-pointer-to-member value used in pointer-to-member "
909 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
911 /* Hair for method invocations. */
915 /* First, evaluate the structure into arg2. */
917 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
918 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
920 if (op
== STRUCTOP_STRUCT
)
922 /* If v is a variable in a register, and the user types
923 v.method (), this will produce an error, because v has no
926 A possible way around this would be to allocate a copy of
927 the variable on the stack, copy in the contents, call the
928 function, and copy out the contents. I.e. convert this
929 from call by reference to call by copy-return (or
930 whatever it's called). However, this does not work
931 because it is not the same: the method being called could
932 stash a copy of the address, and then future uses through
933 that address (after the method returns) would be expected
934 to use the variable itself, not some copy of it. */
935 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
939 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
941 /* Check to see if the operator '->' has been overloaded.
942 If the operator has been overloaded replace arg2 with the
943 value returned by the custom operator and continue
945 while (unop_user_defined_p (op
, arg2
))
947 struct value
*value
= NULL
;
950 value
= value_x_unop (arg2
, op
, noside
);
953 CATCH (except
, RETURN_MASK_ERROR
)
955 if (except
.error
== NOT_FOUND_ERROR
)
958 throw_exception (except
);
965 /* Now, say which argument to start evaluating from. */
968 else if (op
== OP_SCOPE
969 && overload_resolution
970 && (exp
->language_defn
->la_language
== language_cplus
))
972 /* Unpack it locally so we can properly handle overload
978 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
979 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
980 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
981 name
= &exp
->elts
[pc2
+ 3].string
;
984 function_name
= NULL
;
985 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
987 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
989 get_selected_block (0),
991 if (function
== NULL
)
992 error (_("No symbol \"%s\" in namespace \"%s\"."),
993 name
, TYPE_TAG_NAME (type
));
996 /* arg2 is left as NULL on purpose. */
1000 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1001 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1002 function_name
= name
;
1004 /* We need a properly typed value for method lookup. For
1005 static methods arg2 is otherwise unused. */
1006 arg2
= value_zero (type
, lval_memory
);
1011 else if (op
== OP_ADL_FUNC
)
1013 /* Save the function position and move pos so that the arguments
1014 can be evaluated. */
1020 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1021 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1025 /* Non-method function call. */
1029 /* If this is a C++ function wait until overload resolution. */
1030 if (op
== OP_VAR_VALUE
1031 && overload_resolution
1032 && (exp
->language_defn
->la_language
== language_cplus
))
1034 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1039 if (op
== OP_VAR_MSYM_VALUE
)
1041 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1042 var_func_name
= MSYMBOL_PRINT_NAME (msym
);
1044 else if (op
== OP_VAR_VALUE
)
1046 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1047 var_func_name
= SYMBOL_PRINT_NAME (sym
);
1050 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1051 type
*type
= value_type (argvec
[0]);
1052 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1053 type
= TYPE_TARGET_TYPE (type
);
1054 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1056 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1058 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1066 /* Evaluate arguments (if not already done, e.g., namespace::func()
1067 and overload-resolution is off). */
1068 for (; tem
<= nargs
; tem
++)
1070 /* Ensure that array expressions are coerced into pointer
1072 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1075 /* Signal end of arglist. */
1078 if (noside
== EVAL_SKIP
)
1079 return eval_skip_value (exp
);
1081 if (op
== OP_ADL_FUNC
)
1083 struct symbol
*symp
;
1086 int string_pc
= save_pos1
+ 3;
1088 /* Extract the function name. */
1089 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1090 func_name
= (char *) alloca (name_len
+ 1);
1091 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1093 find_overload_match (&argvec
[1], nargs
, func_name
,
1094 NON_METHOD
, /* not method */
1095 NULL
, NULL
, /* pass NULL symbol since
1096 symbol is unknown */
1097 NULL
, &symp
, NULL
, 0, noside
);
1099 /* Now fix the expression being evaluated. */
1100 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1101 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1104 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1105 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1107 int static_memfuncp
;
1110 /* Method invocation: stuff "this" as first parameter. If the
1111 method turns out to be static we undo this below. */
1116 /* Name of method from expression. */
1117 tstr
= &exp
->elts
[pc2
+ 2].string
;
1120 tstr
= function_name
;
1122 if (overload_resolution
&& (exp
->language_defn
->la_language
1125 /* Language is C++, do some overload resolution before
1127 struct value
*valp
= NULL
;
1129 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1130 METHOD
, /* method */
1131 &arg2
, /* the object */
1133 &static_memfuncp
, 0, noside
);
1135 if (op
== OP_SCOPE
&& !static_memfuncp
)
1137 /* For the time being, we don't handle this. */
1138 error (_("Call to overloaded function %s requires "
1142 argvec
[1] = arg2
; /* the ``this'' pointer */
1143 argvec
[0] = valp
; /* Use the method found after overload
1147 /* Non-C++ case -- or no overload resolution. */
1149 struct value
*temp
= arg2
;
1151 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1153 op
== STRUCTOP_STRUCT
1154 ? "structure" : "structure pointer");
1155 /* value_struct_elt updates temp with the correct value of
1156 the ``this'' pointer if necessary, so modify argvec[1] to
1157 reflect any ``this'' changes. */
1159 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1160 value_address (temp
)
1161 + value_embedded_offset (temp
));
1162 argvec
[1] = arg2
; /* the ``this'' pointer */
1165 /* Take out `this' if needed. */
1166 if (static_memfuncp
)
1168 argvec
[1] = argvec
[0];
1173 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1175 /* Pointer to member. argvec[1] is already set up. */
1178 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1180 /* Non-member function being called. */
1181 /* fn: This can only be done for C++ functions. A C-style
1182 function in a C++ program, for instance, does not have the
1183 fields that are expected here. */
1185 if (overload_resolution
&& (exp
->language_defn
->la_language
1188 /* Language is C++, do some overload resolution before
1190 struct symbol
*symp
;
1193 /* If a scope has been specified disable ADL. */
1197 if (op
== OP_VAR_VALUE
)
1198 function
= exp
->elts
[save_pos1
+2].symbol
;
1200 (void) find_overload_match (&argvec
[1], nargs
,
1201 NULL
, /* no need for name */
1202 NON_METHOD
, /* not method */
1203 NULL
, function
, /* the function */
1204 NULL
, &symp
, NULL
, no_adl
, noside
);
1206 if (op
== OP_VAR_VALUE
)
1208 /* Now fix the expression being evaluated. */
1209 exp
->elts
[save_pos1
+2].symbol
= symp
;
1210 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1214 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1218 /* Not C++, or no overload resolution allowed. */
1219 /* Nothing to be done; argvec already correctly set up. */
1224 /* It is probably a C-style function. */
1225 /* Nothing to be done; argvec already correctly set up. */
1228 return eval_call (exp
, noside
, nargs
, argvec
, var_func_name
, expect_type
);
1232 evaluate_subexp_standard (struct type
*expect_type
,
1233 struct expression
*exp
, int *pos
,
1237 int tem
, tem2
, tem3
;
1239 struct value
*arg1
= NULL
;
1240 struct value
*arg2
= NULL
;
1244 struct value
**argvec
;
1248 struct type
**arg_types
;
1251 op
= exp
->elts
[pc
].opcode
;
1256 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1257 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1258 if (noside
== EVAL_SKIP
)
1259 return eval_skip_value (exp
);
1260 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
1261 &exp
->elts
[pc
+ 3].string
,
1262 expect_type
, 0, noside
);
1264 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
1269 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1270 exp
->elts
[pc
+ 2].longconst
);
1274 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1275 exp
->elts
[pc
+ 2].floatconst
);
1280 if (noside
== EVAL_SKIP
)
1281 return eval_skip_value (exp
);
1284 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1285 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_ERROR
)
1286 error_unknown_type (SYMBOL_PRINT_NAME (var
));
1288 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1291 case OP_VAR_MSYM_VALUE
:
1295 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1296 value
*val
= evaluate_var_msym_value (noside
,
1297 exp
->elts
[pc
+ 1].objfile
,
1300 type
= value_type (val
);
1301 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
1302 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| pc
!= 0))
1303 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol
));
1307 case OP_VAR_ENTRY_VALUE
:
1309 if (noside
== EVAL_SKIP
)
1310 return eval_skip_value (exp
);
1313 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1314 struct frame_info
*frame
;
1316 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1317 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1319 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1320 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1321 error (_("Symbol \"%s\" does not have any specific entry value"),
1322 SYMBOL_PRINT_NAME (sym
));
1324 frame
= get_selected_frame (NULL
);
1325 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1328 case OP_FUNC_STATIC_VAR
:
1329 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1330 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1331 if (noside
== EVAL_SKIP
)
1332 return eval_skip_value (exp
);
1335 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1336 CORE_ADDR addr
= value_address (func
);
1338 const block
*blk
= block_for_pc (addr
);
1339 const char *var
= &exp
->elts
[pc
+ 2].string
;
1341 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1343 if (sym
.symbol
== NULL
)
1344 error (_("No symbol \"%s\" in specified context."), var
);
1346 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1352 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1356 const char *name
= &exp
->elts
[pc
+ 2].string
;
1360 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1361 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1362 name
, strlen (name
));
1364 error (_("Register $%s not available."), name
);
1366 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1367 a value with the appropriate register type. Unfortunately,
1368 we don't have easy access to the type of user registers.
1369 So for these registers, we fetch the register value regardless
1370 of the evaluation mode. */
1371 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1372 && regno
< gdbarch_num_regs (exp
->gdbarch
)
1373 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
1374 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1376 val
= value_of_register (regno
, get_selected_frame (NULL
));
1378 error (_("Value of register %s not available."), name
);
1384 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1385 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1387 case OP_INTERNALVAR
:
1389 return value_of_internalvar (exp
->gdbarch
,
1390 exp
->elts
[pc
+ 1].internalvar
);
1393 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1394 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1395 if (noside
== EVAL_SKIP
)
1396 return eval_skip_value (exp
);
1397 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1398 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1400 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1401 NSString constant. */
1402 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1403 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1404 if (noside
== EVAL_SKIP
)
1405 return eval_skip_value (exp
);
1406 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1410 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1411 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1412 nargs
= tem3
- tem2
+ 1;
1413 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
1415 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1416 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1418 struct value
*rec
= allocate_value (expect_type
);
1420 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1421 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1424 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1425 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1427 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
1428 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1429 struct value
*array
= allocate_value (expect_type
);
1430 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1431 LONGEST low_bound
, high_bound
, index
;
1433 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1436 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1439 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1440 for (tem
= nargs
; --nargs
>= 0;)
1442 struct value
*element
;
1445 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1446 if (value_type (element
) != element_type
)
1447 element
= value_cast (element_type
, element
);
1450 int continue_pc
= *pos
;
1453 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1454 low_bound
, high_bound
);
1459 if (index
> high_bound
)
1460 /* To avoid memory corruption. */
1461 error (_("Too many array elements"));
1462 memcpy (value_contents_raw (array
)
1463 + (index
- low_bound
) * element_size
,
1464 value_contents (element
),
1472 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1473 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1475 struct value
*set
= allocate_value (expect_type
);
1476 gdb_byte
*valaddr
= value_contents_raw (set
);
1477 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1478 struct type
*check_type
= element_type
;
1479 LONGEST low_bound
, high_bound
;
1481 /* Get targettype of elementtype. */
1482 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1483 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1484 check_type
= TYPE_TARGET_TYPE (check_type
);
1486 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1487 error (_("(power)set type with unknown size"));
1488 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1489 for (tem
= 0; tem
< nargs
; tem
++)
1491 LONGEST range_low
, range_high
;
1492 struct type
*range_low_type
, *range_high_type
;
1493 struct value
*elem_val
;
1495 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1496 range_low_type
= range_high_type
= value_type (elem_val
);
1497 range_low
= range_high
= value_as_long (elem_val
);
1499 /* Check types of elements to avoid mixture of elements from
1500 different types. Also check if type of element is "compatible"
1501 with element type of powerset. */
1502 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1503 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1504 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1505 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1506 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1507 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1508 && (range_low_type
!= range_high_type
)))
1509 /* different element modes. */
1510 error (_("POWERSET tuple elements of different mode"));
1511 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1512 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1513 && range_low_type
!= check_type
))
1514 error (_("incompatible POWERSET tuple elements"));
1515 if (range_low
> range_high
)
1517 warning (_("empty POWERSET tuple range"));
1520 if (range_low
< low_bound
|| range_high
> high_bound
)
1521 error (_("POWERSET tuple element out of range"));
1522 range_low
-= low_bound
;
1523 range_high
-= low_bound
;
1524 for (; range_low
<= range_high
; range_low
++)
1526 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1528 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1529 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1530 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1537 argvec
= XALLOCAVEC (struct value
*, nargs
);
1538 for (tem
= 0; tem
< nargs
; tem
++)
1540 /* Ensure that array expressions are coerced into pointer
1542 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1544 if (noside
== EVAL_SKIP
)
1545 return eval_skip_value (exp
);
1546 return value_array (tem2
, tem3
, argvec
);
1550 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1552 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1554 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1556 if (noside
== EVAL_SKIP
)
1557 return eval_skip_value (exp
);
1558 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1562 /* Skip third and second args to evaluate the first one. */
1563 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1564 if (value_logical_not (arg1
))
1566 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1567 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1571 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1572 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1576 case OP_OBJC_SELECTOR
:
1577 { /* Objective C @selector operator. */
1578 char *sel
= &exp
->elts
[pc
+ 2].string
;
1579 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1580 struct type
*selector_type
;
1582 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1583 if (noside
== EVAL_SKIP
)
1584 return eval_skip_value (exp
);
1587 sel
[len
] = 0; /* Make sure it's terminated. */
1589 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1590 return value_from_longest (selector_type
,
1591 lookup_child_selector (exp
->gdbarch
, sel
));
1594 case OP_OBJC_MSGCALL
:
1595 { /* Objective C message (method) call. */
1597 CORE_ADDR responds_selector
= 0;
1598 CORE_ADDR method_selector
= 0;
1600 CORE_ADDR selector
= 0;
1602 int struct_return
= 0;
1603 enum noside sub_no_side
= EVAL_NORMAL
;
1605 struct value
*msg_send
= NULL
;
1606 struct value
*msg_send_stret
= NULL
;
1607 int gnu_runtime
= 0;
1609 struct value
*target
= NULL
;
1610 struct value
*method
= NULL
;
1611 struct value
*called_method
= NULL
;
1613 struct type
*selector_type
= NULL
;
1614 struct type
*long_type
;
1616 struct value
*ret
= NULL
;
1619 selector
= exp
->elts
[pc
+ 1].longconst
;
1620 nargs
= exp
->elts
[pc
+ 2].longconst
;
1621 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1625 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1626 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1628 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1629 sub_no_side
= EVAL_NORMAL
;
1631 sub_no_side
= noside
;
1633 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1635 if (value_as_long (target
) == 0)
1636 return value_from_longest (long_type
, 0);
1638 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1641 /* Find the method dispatch (Apple runtime) or method lookup
1642 (GNU runtime) function for Objective-C. These will be used
1643 to lookup the symbol information for the method. If we
1644 can't find any symbol information, then we'll use these to
1645 call the method, otherwise we can call the method
1646 directly. The msg_send_stret function is used in the special
1647 case of a method that returns a structure (Apple runtime
1651 struct type
*type
= selector_type
;
1653 type
= lookup_function_type (type
);
1654 type
= lookup_pointer_type (type
);
1655 type
= lookup_function_type (type
);
1656 type
= lookup_pointer_type (type
);
1658 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1660 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1662 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1663 msg_send_stret
= value_from_pointer (type
,
1664 value_as_address (msg_send_stret
));
1668 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1669 /* Special dispatcher for methods returning structs. */
1671 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1674 /* Verify the target object responds to this method. The
1675 standard top-level 'Object' class uses a different name for
1676 the verification method than the non-standard, but more
1677 often used, 'NSObject' class. Make sure we check for both. */
1680 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1681 if (responds_selector
== 0)
1683 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1685 if (responds_selector
== 0)
1686 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1689 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1690 if (method_selector
== 0)
1692 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1694 if (method_selector
== 0)
1695 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1697 /* Call the verification method, to make sure that the target
1698 class implements the desired method. */
1700 argvec
[0] = msg_send
;
1702 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1703 argvec
[3] = value_from_longest (long_type
, selector
);
1706 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1709 /* Function objc_msg_lookup returns a pointer. */
1711 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1713 if (value_as_long (ret
) == 0)
1714 error (_("Target does not respond to this message selector."));
1716 /* Call "methodForSelector:" method, to get the address of a
1717 function method that implements this selector for this
1718 class. If we can find a symbol at that address, then we
1719 know the return type, parameter types etc. (that's a good
1722 argvec
[0] = msg_send
;
1724 argvec
[2] = value_from_longest (long_type
, method_selector
);
1725 argvec
[3] = value_from_longest (long_type
, selector
);
1728 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1732 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1735 /* ret should now be the selector. */
1737 addr
= value_as_long (ret
);
1740 struct symbol
*sym
= NULL
;
1742 /* The address might point to a function descriptor;
1743 resolve it to the actual code address instead. */
1744 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1747 /* Is it a high_level symbol? */
1748 sym
= find_pc_function (addr
);
1750 method
= value_of_variable (sym
, 0);
1753 /* If we found a method with symbol information, check to see
1754 if it returns a struct. Otherwise assume it doesn't. */
1759 struct type
*val_type
;
1761 funaddr
= find_function_addr (method
, &val_type
);
1763 block_for_pc (funaddr
);
1765 val_type
= check_typedef (val_type
);
1767 if ((val_type
== NULL
)
1768 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1770 if (expect_type
!= NULL
)
1771 val_type
= expect_type
;
1774 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1777 else if (expect_type
!= NULL
)
1779 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1780 check_typedef (expect_type
));
1783 /* Found a function symbol. Now we will substitute its
1784 value in place of the message dispatcher (obj_msgSend),
1785 so that we call the method directly instead of thru
1786 the dispatcher. The main reason for doing this is that
1787 we can now evaluate the return value and parameter values
1788 according to their known data types, in case we need to
1789 do things like promotion, dereferencing, special handling
1790 of structs and doubles, etc.
1792 We want to use the type signature of 'method', but still
1793 jump to objc_msgSend() or objc_msgSend_stret() to better
1794 mimic the behavior of the runtime. */
1798 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1799 error (_("method address has symbol information "
1800 "with non-function type; skipping"));
1802 /* Create a function pointer of the appropriate type, and
1803 replace its value with the value of msg_send or
1804 msg_send_stret. We must use a pointer here, as
1805 msg_send and msg_send_stret are of pointer type, and
1806 the representation may be different on systems that use
1807 function descriptors. */
1810 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1811 value_as_address (msg_send_stret
));
1814 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1815 value_as_address (msg_send
));
1820 called_method
= msg_send_stret
;
1822 called_method
= msg_send
;
1825 if (noside
== EVAL_SKIP
)
1826 return eval_skip_value (exp
);
1828 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1830 /* If the return type doesn't look like a function type,
1831 call an error. This can happen if somebody tries to
1832 turn a variable into a function call. This is here
1833 because people often want to call, eg, strcmp, which
1834 gdb doesn't know is a function. If gdb isn't asked for
1835 it's opinion (ie. through "whatis"), it won't offer
1838 struct type
*type
= value_type (called_method
);
1840 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1841 type
= TYPE_TARGET_TYPE (type
);
1842 type
= TYPE_TARGET_TYPE (type
);
1846 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1847 return allocate_value (expect_type
);
1849 return allocate_value (type
);
1852 error (_("Expression of type other than "
1853 "\"method returning ...\" used as a method"));
1856 /* Now depending on whether we found a symbol for the method,
1857 we will either call the runtime dispatcher or the method
1860 argvec
[0] = called_method
;
1862 argvec
[2] = value_from_longest (long_type
, selector
);
1863 /* User-supplied arguments. */
1864 for (tem
= 0; tem
< nargs
; tem
++)
1865 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1866 argvec
[tem
+ 3] = 0;
1868 if (gnu_runtime
&& (method
!= NULL
))
1870 /* Function objc_msg_lookup returns a pointer. */
1871 deprecated_set_value_type (argvec
[0],
1872 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1874 = call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1877 ret
= call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1883 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1885 case OP_F77_UNDETERMINED_ARGLIST
:
1887 /* Remember that in F77, functions, substring ops and
1888 array subscript operations cannot be disambiguated
1889 at parse time. We have made all array subscript operations,
1890 substring operations as well as function calls come here
1891 and we now have to discover what the heck this thing actually was.
1892 If it is a function, we process just as if we got an OP_FUNCALL. */
1894 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1897 /* First determine the type code we are dealing with. */
1898 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1899 type
= check_typedef (value_type (arg1
));
1900 code
= TYPE_CODE (type
);
1902 if (code
== TYPE_CODE_PTR
)
1904 /* Fortran always passes variable to subroutines as pointer.
1905 So we need to look into its target type to see if it is
1906 array, string or function. If it is, we need to switch
1907 to the target value the original one points to. */
1908 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1910 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1911 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1912 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1914 arg1
= value_ind (arg1
);
1915 type
= check_typedef (value_type (arg1
));
1916 code
= TYPE_CODE (type
);
1922 case TYPE_CODE_ARRAY
:
1923 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1924 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1926 goto multi_f77_subscript
;
1928 case TYPE_CODE_STRING
:
1929 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1930 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1933 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1934 return value_subscript (arg1
, value_as_long (arg2
));
1938 case TYPE_CODE_FUNC
:
1939 /* It's a function call. */
1940 /* Allocate arg vector, including space for the function to be
1941 called in argvec[0] and a terminating NULL. */
1942 argvec
= (struct value
**)
1943 alloca (sizeof (struct value
*) * (nargs
+ 2));
1946 for (; tem
<= nargs
; tem
++)
1947 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1948 argvec
[tem
] = 0; /* signal end of arglist */
1949 if (noside
== EVAL_SKIP
)
1950 return eval_skip_value (exp
);
1951 return eval_call (exp
, noside
, nargs
, argvec
, NULL
, expect_type
);
1954 error (_("Cannot perform substring on this type"));
1958 /* We have a complex number, There should be 2 floating
1959 point numbers that compose it. */
1961 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1962 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1964 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1966 case STRUCTOP_STRUCT
:
1967 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1968 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1969 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1970 if (noside
== EVAL_SKIP
)
1971 return eval_skip_value (exp
);
1972 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1974 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1975 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1979 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1980 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1981 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1982 if (noside
== EVAL_SKIP
)
1983 return eval_skip_value (exp
);
1985 /* Check to see if operator '->' has been overloaded. If so replace
1986 arg1 with the value returned by evaluating operator->(). */
1987 while (unop_user_defined_p (op
, arg1
))
1989 struct value
*value
= NULL
;
1992 value
= value_x_unop (arg1
, op
, noside
);
1995 CATCH (except
, RETURN_MASK_ERROR
)
1997 if (except
.error
== NOT_FOUND_ERROR
)
2000 throw_exception (except
);
2007 /* JYG: if print object is on we need to replace the base type
2008 with rtti type in order to continue on with successful
2009 lookup of member / method only available in the rtti type. */
2011 struct type
*type
= value_type (arg1
);
2012 struct type
*real_type
;
2013 int full
, using_enc
;
2015 struct value_print_options opts
;
2017 get_user_print_options (&opts
);
2018 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
2019 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
2021 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
2024 arg1
= value_cast (real_type
, arg1
);
2028 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2029 NULL
, "structure pointer");
2030 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2031 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2034 case STRUCTOP_MEMBER
:
2036 if (op
== STRUCTOP_MEMBER
)
2037 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2039 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2041 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2043 if (noside
== EVAL_SKIP
)
2044 return eval_skip_value (exp
);
2046 type
= check_typedef (value_type (arg2
));
2047 switch (TYPE_CODE (type
))
2049 case TYPE_CODE_METHODPTR
:
2050 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2051 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2054 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2055 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2056 return value_ind (arg2
);
2059 case TYPE_CODE_MEMBERPTR
:
2060 /* Now, convert these values to an address. */
2061 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
2064 mem_offset
= value_as_long (arg2
);
2066 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2067 value_as_long (arg1
) + mem_offset
);
2068 return value_ind (arg3
);
2071 error (_("non-pointer-to-member value used "
2072 "in pointer-to-member construct"));
2077 type_instance_flags flags
2078 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2079 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2080 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2081 for (ix
= 0; ix
< nargs
; ++ix
)
2082 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2084 fake_method
expect_type (flags
, nargs
, arg_types
);
2085 *(pos
) += 4 + nargs
;
2086 return evaluate_subexp_standard (expect_type
.type (), exp
, pos
, noside
);
2090 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2091 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2092 if (noside
== EVAL_SKIP
)
2093 return eval_skip_value (exp
);
2094 if (binop_user_defined_p (op
, arg1
, arg2
))
2095 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2097 return value_concat (arg1
, arg2
);
2100 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2101 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2103 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2105 if (binop_user_defined_p (op
, arg1
, arg2
))
2106 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2108 return value_assign (arg1
, arg2
);
2110 case BINOP_ASSIGN_MODIFY
:
2112 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2113 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2114 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2116 op
= exp
->elts
[pc
+ 1].opcode
;
2117 if (binop_user_defined_p (op
, arg1
, arg2
))
2118 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2119 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2121 && is_integral_type (value_type (arg2
)))
2122 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2123 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2125 && is_integral_type (value_type (arg2
)))
2126 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2129 struct value
*tmp
= arg1
;
2131 /* For shift and integer exponentiation operations,
2132 only promote the first argument. */
2133 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2134 && is_integral_type (value_type (arg2
)))
2135 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2137 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2139 arg2
= value_binop (tmp
, arg2
, op
);
2141 return value_assign (arg1
, arg2
);
2144 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2145 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2146 if (noside
== EVAL_SKIP
)
2147 return eval_skip_value (exp
);
2148 if (binop_user_defined_p (op
, arg1
, arg2
))
2149 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2150 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2151 && is_integral_type (value_type (arg2
)))
2152 return value_ptradd (arg1
, value_as_long (arg2
));
2153 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2154 && is_integral_type (value_type (arg1
)))
2155 return value_ptradd (arg2
, value_as_long (arg1
));
2158 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2159 return value_binop (arg1
, arg2
, BINOP_ADD
);
2163 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2164 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2165 if (noside
== EVAL_SKIP
)
2166 return eval_skip_value (exp
);
2167 if (binop_user_defined_p (op
, arg1
, arg2
))
2168 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2169 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2170 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2172 /* FIXME -- should be ptrdiff_t */
2173 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2174 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2176 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2177 && is_integral_type (value_type (arg2
)))
2178 return value_ptradd (arg1
, - value_as_long (arg2
));
2181 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2182 return value_binop (arg1
, arg2
, BINOP_SUB
);
2193 case BINOP_BITWISE_AND
:
2194 case BINOP_BITWISE_IOR
:
2195 case BINOP_BITWISE_XOR
:
2196 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2197 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2198 if (noside
== EVAL_SKIP
)
2199 return eval_skip_value (exp
);
2200 if (binop_user_defined_p (op
, arg1
, arg2
))
2201 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2204 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2205 fudge arg2 to avoid division-by-zero, the caller is
2206 (theoretically) only looking for the type of the result. */
2207 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2208 /* ??? Do we really want to test for BINOP_MOD here?
2209 The implementation of value_binop gives it a well-defined
2212 || op
== BINOP_INTDIV
2215 && value_logical_not (arg2
))
2217 struct value
*v_one
, *retval
;
2219 v_one
= value_one (value_type (arg2
));
2220 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2221 retval
= value_binop (arg1
, v_one
, op
);
2226 /* For shift and integer exponentiation operations,
2227 only promote the first argument. */
2228 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2229 && is_integral_type (value_type (arg2
)))
2230 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2232 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2234 return value_binop (arg1
, arg2
, op
);
2238 case BINOP_SUBSCRIPT
:
2239 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2240 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2241 if (noside
== EVAL_SKIP
)
2242 return eval_skip_value (exp
);
2243 if (binop_user_defined_p (op
, arg1
, arg2
))
2244 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2247 /* If the user attempts to subscript something that is not an
2248 array or pointer type (like a plain int variable for example),
2249 then report this as an error. */
2251 arg1
= coerce_ref (arg1
);
2252 type
= check_typedef (value_type (arg1
));
2253 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2254 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2256 if (TYPE_NAME (type
))
2257 error (_("cannot subscript something of type `%s'"),
2260 error (_("cannot subscript requested type"));
2263 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2264 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2266 return value_subscript (arg1
, value_as_long (arg2
));
2268 case MULTI_SUBSCRIPT
:
2270 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2271 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2274 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2275 /* FIXME: EVAL_SKIP handling may not be correct. */
2276 if (noside
== EVAL_SKIP
)
2280 return eval_skip_value (exp
);
2282 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2283 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2285 /* If the user attempts to subscript something that has no target
2286 type (like a plain int variable for example), then report this
2289 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2292 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2298 error (_("cannot subscript something of type `%s'"),
2299 TYPE_NAME (value_type (arg1
)));
2303 if (binop_user_defined_p (op
, arg1
, arg2
))
2305 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2309 arg1
= coerce_ref (arg1
);
2310 type
= check_typedef (value_type (arg1
));
2312 switch (TYPE_CODE (type
))
2315 case TYPE_CODE_ARRAY
:
2316 case TYPE_CODE_STRING
:
2317 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2321 if (TYPE_NAME (type
))
2322 error (_("cannot subscript something of type `%s'"),
2325 error (_("cannot subscript requested type"));
2331 multi_f77_subscript
:
2333 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2334 int ndimensions
= 1, i
;
2335 struct value
*array
= arg1
;
2337 if (nargs
> MAX_FORTRAN_DIMS
)
2338 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2340 ndimensions
= calc_f77_array_dims (type
);
2342 if (nargs
!= ndimensions
)
2343 error (_("Wrong number of subscripts"));
2345 gdb_assert (nargs
> 0);
2347 /* Now that we know we have a legal array subscript expression
2348 let us actually find out where this element exists in the array. */
2350 /* Take array indices left to right. */
2351 for (i
= 0; i
< nargs
; i
++)
2353 /* Evaluate each subscript; it must be a legal integer in F77. */
2354 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2356 /* Fill in the subscript array. */
2358 subscript_array
[i
] = value_as_long (arg2
);
2361 /* Internal type of array is arranged right to left. */
2362 for (i
= nargs
; i
> 0; i
--)
2364 struct type
*array_type
= check_typedef (value_type (array
));
2365 LONGEST index
= subscript_array
[i
- 1];
2367 array
= value_subscripted_rvalue (array
, index
,
2368 f77_get_lowerbound (array_type
));
2374 case BINOP_LOGICAL_AND
:
2375 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2376 if (noside
== EVAL_SKIP
)
2378 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2379 return eval_skip_value (exp
);
2383 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2386 if (binop_user_defined_p (op
, arg1
, arg2
))
2388 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2389 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2393 tem
= value_logical_not (arg1
);
2394 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2395 (tem
? EVAL_SKIP
: noside
));
2396 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2397 return value_from_longest (type
,
2398 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2401 case BINOP_LOGICAL_OR
:
2402 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2403 if (noside
== EVAL_SKIP
)
2405 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2406 return eval_skip_value (exp
);
2410 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2413 if (binop_user_defined_p (op
, arg1
, arg2
))
2415 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2416 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2420 tem
= value_logical_not (arg1
);
2421 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2422 (!tem
? EVAL_SKIP
: noside
));
2423 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2424 return value_from_longest (type
,
2425 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2429 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2430 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2431 if (noside
== EVAL_SKIP
)
2432 return eval_skip_value (exp
);
2433 if (binop_user_defined_p (op
, arg1
, arg2
))
2435 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2439 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2440 tem
= value_equal (arg1
, arg2
);
2441 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2442 return value_from_longest (type
, (LONGEST
) tem
);
2445 case BINOP_NOTEQUAL
:
2446 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2447 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2448 if (noside
== EVAL_SKIP
)
2449 return eval_skip_value (exp
);
2450 if (binop_user_defined_p (op
, arg1
, arg2
))
2452 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2456 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2457 tem
= value_equal (arg1
, arg2
);
2458 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2459 return value_from_longest (type
, (LONGEST
) ! tem
);
2463 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2464 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2465 if (noside
== EVAL_SKIP
)
2466 return eval_skip_value (exp
);
2467 if (binop_user_defined_p (op
, arg1
, arg2
))
2469 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2473 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2474 tem
= value_less (arg1
, arg2
);
2475 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2476 return value_from_longest (type
, (LONGEST
) tem
);
2480 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2481 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2482 if (noside
== EVAL_SKIP
)
2483 return eval_skip_value (exp
);
2484 if (binop_user_defined_p (op
, arg1
, arg2
))
2486 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2490 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2491 tem
= value_less (arg2
, arg1
);
2492 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2493 return value_from_longest (type
, (LONGEST
) tem
);
2497 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2498 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2499 if (noside
== EVAL_SKIP
)
2500 return eval_skip_value (exp
);
2501 if (binop_user_defined_p (op
, arg1
, arg2
))
2503 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2507 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2508 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2509 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2510 return value_from_longest (type
, (LONGEST
) tem
);
2514 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2515 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2516 if (noside
== EVAL_SKIP
)
2517 return eval_skip_value (exp
);
2518 if (binop_user_defined_p (op
, arg1
, arg2
))
2520 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2524 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2525 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2526 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2527 return value_from_longest (type
, (LONGEST
) tem
);
2531 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2532 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2533 if (noside
== EVAL_SKIP
)
2534 return eval_skip_value (exp
);
2535 type
= check_typedef (value_type (arg2
));
2536 if (TYPE_CODE (type
) != TYPE_CODE_INT
2537 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
2538 error (_("Non-integral right operand for \"@\" operator."));
2539 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2541 return allocate_repeat_value (value_type (arg1
),
2542 longest_to_int (value_as_long (arg2
)));
2545 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2548 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2549 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2552 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2553 if (noside
== EVAL_SKIP
)
2554 return eval_skip_value (exp
);
2555 if (unop_user_defined_p (op
, arg1
))
2556 return value_x_unop (arg1
, op
, noside
);
2559 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2560 return value_pos (arg1
);
2564 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2565 if (noside
== EVAL_SKIP
)
2566 return eval_skip_value (exp
);
2567 if (unop_user_defined_p (op
, arg1
))
2568 return value_x_unop (arg1
, op
, noside
);
2571 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2572 return value_neg (arg1
);
2575 case UNOP_COMPLEMENT
:
2576 /* C++: check for and handle destructor names. */
2578 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2579 if (noside
== EVAL_SKIP
)
2580 return eval_skip_value (exp
);
2581 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2582 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2585 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2586 return value_complement (arg1
);
2589 case UNOP_LOGICAL_NOT
:
2590 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2591 if (noside
== EVAL_SKIP
)
2592 return eval_skip_value (exp
);
2593 if (unop_user_defined_p (op
, arg1
))
2594 return value_x_unop (arg1
, op
, noside
);
2597 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2598 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2602 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2603 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2604 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2605 type
= check_typedef (value_type (arg1
));
2606 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2607 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2608 error (_("Attempt to dereference pointer "
2609 "to member without an object"));
2610 if (noside
== EVAL_SKIP
)
2611 return eval_skip_value (exp
);
2612 if (unop_user_defined_p (op
, arg1
))
2613 return value_x_unop (arg1
, op
, noside
);
2614 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2616 type
= check_typedef (value_type (arg1
));
2617 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2618 || TYPE_IS_REFERENCE (type
)
2619 /* In C you can dereference an array to get the 1st elt. */
2620 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2622 return value_zero (TYPE_TARGET_TYPE (type
),
2624 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2625 /* GDB allows dereferencing an int. */
2626 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2629 error (_("Attempt to take contents of a non-pointer value."));
2632 /* Allow * on an integer so we can cast it to whatever we want.
2633 This returns an int, which seems like the most C-like thing to
2634 do. "long long" variables are rare enough that
2635 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2636 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2637 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2638 (CORE_ADDR
) value_as_address (arg1
));
2639 return value_ind (arg1
);
2642 /* C++: check for and handle pointer to members. */
2644 if (noside
== EVAL_SKIP
)
2646 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2647 return eval_skip_value (exp
);
2651 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2658 if (noside
== EVAL_SKIP
)
2660 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2661 return eval_skip_value (exp
);
2663 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2667 type
= exp
->elts
[pc
+ 1].type
;
2668 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2670 case UNOP_CAST_TYPE
:
2671 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2672 type
= value_type (arg1
);
2673 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2675 case UNOP_DYNAMIC_CAST
:
2676 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2677 type
= value_type (arg1
);
2678 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2679 if (noside
== EVAL_SKIP
)
2680 return eval_skip_value (exp
);
2681 return value_dynamic_cast (type
, arg1
);
2683 case UNOP_REINTERPRET_CAST
:
2684 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2685 type
= value_type (arg1
);
2686 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2687 if (noside
== EVAL_SKIP
)
2688 return eval_skip_value (exp
);
2689 return value_reinterpret_cast (type
, arg1
);
2693 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2694 if (noside
== EVAL_SKIP
)
2695 return eval_skip_value (exp
);
2696 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2697 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2699 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2700 value_as_address (arg1
));
2702 case UNOP_MEMVAL_TYPE
:
2703 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2704 type
= value_type (arg1
);
2705 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2706 if (noside
== EVAL_SKIP
)
2707 return eval_skip_value (exp
);
2708 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2709 return value_zero (type
, lval_memory
);
2711 return value_at_lazy (type
, value_as_address (arg1
));
2713 case UNOP_PREINCREMENT
:
2714 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2715 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2717 else if (unop_user_defined_p (op
, arg1
))
2719 return value_x_unop (arg1
, op
, noside
);
2723 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2724 arg2
= value_ptradd (arg1
, 1);
2727 struct value
*tmp
= arg1
;
2729 arg2
= value_one (value_type (arg1
));
2730 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2731 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2734 return value_assign (arg1
, arg2
);
2737 case UNOP_PREDECREMENT
:
2738 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2739 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2741 else if (unop_user_defined_p (op
, arg1
))
2743 return value_x_unop (arg1
, op
, noside
);
2747 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2748 arg2
= value_ptradd (arg1
, -1);
2751 struct value
*tmp
= arg1
;
2753 arg2
= value_one (value_type (arg1
));
2754 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2755 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2758 return value_assign (arg1
, arg2
);
2761 case UNOP_POSTINCREMENT
:
2762 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2763 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2765 else if (unop_user_defined_p (op
, arg1
))
2767 return value_x_unop (arg1
, op
, noside
);
2771 arg3
= value_non_lval (arg1
);
2773 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2774 arg2
= value_ptradd (arg1
, 1);
2777 struct value
*tmp
= arg1
;
2779 arg2
= value_one (value_type (arg1
));
2780 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2781 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2784 value_assign (arg1
, arg2
);
2788 case UNOP_POSTDECREMENT
:
2789 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2790 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2792 else if (unop_user_defined_p (op
, arg1
))
2794 return value_x_unop (arg1
, op
, noside
);
2798 arg3
= value_non_lval (arg1
);
2800 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2801 arg2
= value_ptradd (arg1
, -1);
2804 struct value
*tmp
= arg1
;
2806 arg2
= value_one (value_type (arg1
));
2807 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2808 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2811 value_assign (arg1
, arg2
);
2817 return value_of_this (exp
->language_defn
);
2820 /* The value is not supposed to be used. This is here to make it
2821 easier to accommodate expressions that contain types. */
2823 if (noside
== EVAL_SKIP
)
2824 return eval_skip_value (exp
);
2825 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2826 return allocate_value (exp
->elts
[pc
+ 1].type
);
2828 error (_("Attempt to use a type name as an expression"));
2832 if (noside
== EVAL_SKIP
)
2834 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2835 return eval_skip_value (exp
);
2837 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2839 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2840 struct value
*result
;
2842 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2843 EVAL_AVOID_SIDE_EFFECTS
);
2845 /* 'decltype' has special semantics for lvalues. */
2846 if (op
== OP_DECLTYPE
2847 && (sub_op
== BINOP_SUBSCRIPT
2848 || sub_op
== STRUCTOP_MEMBER
2849 || sub_op
== STRUCTOP_MPTR
2850 || sub_op
== UNOP_IND
2851 || sub_op
== STRUCTOP_STRUCT
2852 || sub_op
== STRUCTOP_PTR
2853 || sub_op
== OP_SCOPE
))
2855 struct type
*type
= value_type (result
);
2857 if (!TYPE_IS_REFERENCE (type
))
2859 type
= lookup_lvalue_reference_type (type
);
2860 result
= allocate_value (type
);
2867 error (_("Attempt to use a type as an expression"));
2871 struct value
*result
;
2872 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2874 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2875 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2876 EVAL_AVOID_SIDE_EFFECTS
);
2878 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2880 if (noside
!= EVAL_NORMAL
)
2881 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2883 return cplus_typeid (result
);
2887 /* Removing this case and compiling with gcc -Wall reveals that
2888 a lot of cases are hitting this case. Some of these should
2889 probably be removed from expression.h; others are legitimate
2890 expressions which are (apparently) not fully implemented.
2892 If there are any cases landing here which mean a user error,
2893 then they should be separate cases, with more descriptive
2896 error (_("GDB does not (yet) know how to "
2897 "evaluate that kind of expression"));
2900 gdb_assert_not_reached ("missed return?");
2903 /* Evaluate a subexpression of EXP, at index *POS,
2904 and return the address of that subexpression.
2905 Advance *POS over the subexpression.
2906 If the subexpression isn't an lvalue, get an error.
2907 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2908 then only the type of the result need be correct. */
2910 static struct value
*
2911 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2921 op
= exp
->elts
[pc
].opcode
;
2927 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2929 /* We can't optimize out "&*" if there's a user-defined operator*. */
2930 if (unop_user_defined_p (op
, x
))
2932 x
= value_x_unop (x
, op
, noside
);
2933 goto default_case_after_eval
;
2936 return coerce_array (x
);
2940 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2941 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2943 case UNOP_MEMVAL_TYPE
:
2948 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2949 type
= value_type (x
);
2950 return value_cast (lookup_pointer_type (type
),
2951 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2955 var
= exp
->elts
[pc
+ 2].symbol
;
2957 /* C++: The "address" of a reference should yield the address
2958 * of the object pointed to. Let value_addr() deal with it. */
2959 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
2963 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2966 lookup_pointer_type (SYMBOL_TYPE (var
));
2967 enum address_class sym_class
= SYMBOL_CLASS (var
);
2969 if (sym_class
== LOC_CONST
2970 || sym_class
== LOC_CONST_BYTES
2971 || sym_class
== LOC_REGISTER
)
2972 error (_("Attempt to take address of register or constant."));
2975 value_zero (type
, not_lval
);
2978 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2980 case OP_VAR_MSYM_VALUE
:
2984 value
*val
= evaluate_var_msym_value (noside
,
2985 exp
->elts
[pc
+ 1].objfile
,
2986 exp
->elts
[pc
+ 2].msymbol
);
2987 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2989 struct type
*type
= lookup_pointer_type (value_type (val
));
2990 return value_zero (type
, not_lval
);
2993 return value_addr (val
);
2997 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2998 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2999 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3000 &exp
->elts
[pc
+ 3].string
,
3003 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3008 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3009 default_case_after_eval
:
3010 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3012 struct type
*type
= check_typedef (value_type (x
));
3014 if (TYPE_IS_REFERENCE (type
))
3015 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3017 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3018 return value_zero (lookup_pointer_type (value_type (x
)),
3021 error (_("Attempt to take address of "
3022 "value not located in memory."));
3024 return value_addr (x
);
3028 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3029 When used in contexts where arrays will be coerced anyway, this is
3030 equivalent to `evaluate_subexp' but much faster because it avoids
3031 actually fetching array contents (perhaps obsolete now that we have
3034 Note that we currently only do the coercion for C expressions, where
3035 arrays are zero based and the coercion is correct. For other languages,
3036 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3037 to decide if coercion is appropriate. */
3040 evaluate_subexp_with_coercion (struct expression
*exp
,
3041 int *pos
, enum noside noside
)
3050 op
= exp
->elts
[pc
].opcode
;
3055 var
= exp
->elts
[pc
+ 2].symbol
;
3056 type
= check_typedef (SYMBOL_TYPE (var
));
3057 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3058 && !TYPE_VECTOR (type
)
3059 && CAST_IS_CONVERSION (exp
->language_defn
))
3062 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3063 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3069 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3073 /* Evaluate a subexpression of EXP, at index *POS,
3074 and return a value for the size of that subexpression.
3075 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3076 we allow side-effects on the operand if its type is a variable
3079 static struct value
*
3080 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3083 /* FIXME: This should be size_t. */
3084 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3091 op
= exp
->elts
[pc
].opcode
;
3095 /* This case is handled specially
3096 so that we avoid creating a value for the result type.
3097 If the result type is very big, it's desirable not to
3098 create a value unnecessarily. */
3101 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3102 type
= check_typedef (value_type (val
));
3103 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3104 && !TYPE_IS_REFERENCE (type
)
3105 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3106 error (_("Attempt to take contents of a non-pointer value."));
3107 type
= TYPE_TARGET_TYPE (type
);
3108 if (is_dynamic_type (type
))
3109 type
= value_type (value_ind (val
));
3110 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3114 type
= exp
->elts
[pc
+ 1].type
;
3117 case UNOP_MEMVAL_TYPE
:
3119 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3120 type
= value_type (val
);
3124 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3125 if (is_dynamic_type (type
))
3127 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3128 type
= value_type (val
);
3134 case OP_VAR_MSYM_VALUE
:
3138 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3139 value
*val
= evaluate_var_msym_value (noside
,
3140 exp
->elts
[pc
+ 1].objfile
,
3143 type
= value_type (val
);
3144 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
)
3145 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol
));
3147 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3151 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3152 type of the subscript is a variable length array type. In this case we
3153 must re-evaluate the right hand side of the subcription to allow
3155 case BINOP_SUBSCRIPT
:
3156 if (noside
== EVAL_NORMAL
)
3158 int pc
= (*pos
) + 1;
3160 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3161 type
= check_typedef (value_type (val
));
3162 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3164 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3165 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3167 type
= TYPE_INDEX_TYPE (type
);
3168 /* Only re-evaluate the right hand side if the resulting type
3169 is a variable length type. */
3170 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3172 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3173 return value_from_longest
3174 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3183 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3184 type
= value_type (val
);
3188 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3189 "When applied to a reference or a reference type, the result is
3190 the size of the referenced type." */
3191 type
= check_typedef (type
);
3192 if (exp
->language_defn
->la_language
== language_cplus
3193 && (TYPE_IS_REFERENCE (type
)))
3194 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3195 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3198 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3199 for that subexpression cast to TO_TYPE. Advance *POS over the
3203 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3205 struct type
*to_type
)
3209 /* Don't let symbols be evaluated with evaluate_subexp because that
3210 throws an "unknown type" error for no-debug data symbols.
3211 Instead, we want the cast to reinterpret the symbol. */
3212 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3213 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3218 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3220 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3221 return value_zero (to_type
, not_lval
);
3223 val
= evaluate_var_msym_value (noside
,
3224 exp
->elts
[pc
+ 1].objfile
,
3225 exp
->elts
[pc
+ 2].msymbol
);
3228 val
= evaluate_var_value (noside
,
3229 exp
->elts
[pc
+ 1].block
,
3230 exp
->elts
[pc
+ 2].symbol
);
3232 if (noside
== EVAL_SKIP
)
3233 return eval_skip_value (exp
);
3235 val
= value_cast (to_type
, val
);
3237 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3238 if (VALUE_LVAL (val
) == lval_memory
)
3240 if (value_lazy (val
))
3241 value_fetch_lazy (val
);
3242 VALUE_LVAL (val
) = not_lval
;
3247 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3248 if (noside
== EVAL_SKIP
)
3249 return eval_skip_value (exp
);
3250 return value_cast (to_type
, val
);
3253 /* Parse a type expression in the string [P..P+LENGTH). */
3256 parse_and_eval_type (char *p
, int length
)
3258 char *tmp
= (char *) alloca (length
+ 4);
3261 memcpy (tmp
+ 1, p
, length
);
3262 tmp
[length
+ 1] = ')';
3263 tmp
[length
+ 2] = '0';
3264 tmp
[length
+ 3] = '\0';
3265 expression_up expr
= parse_expression (tmp
);
3266 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3267 error (_("Internal error in eval_type."));
3268 return expr
->elts
[1].type
;
3272 calc_f77_array_dims (struct type
*array_type
)
3275 struct type
*tmp_type
;
3277 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3278 error (_("Can't get dimensions for a non-array type"));
3280 tmp_type
= array_type
;
3282 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3284 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)