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
)
738 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
740 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !TYPE_GNU_IFUNC (the_type
))
741 return value_zero (the_type
, not_lval
);
743 return value_at_lazy (the_type
, address
);
746 /* Helper for returning a value when handling EVAL_SKIP. */
749 eval_skip_value (expression
*exp
)
751 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
754 /* Evaluate a function call. The function to be called is in
755 ARGVEC[0] and the arguments passed to the function are in
756 ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
757 known. DEFAULT_RETURN_TYPE is used as the function's return type
758 if the return type is unknown. */
761 eval_call (expression
*exp
, enum noside noside
,
762 int nargs
, value
**argvec
,
763 const char *function_name
,
764 type
*default_return_type
)
766 if (argvec
[0] == NULL
)
767 error (_("Cannot evaluate function -- may be inlined"));
768 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
770 /* If the return type doesn't look like a function type,
771 call an error. This can happen if somebody tries to turn
772 a variable into a function call. */
774 type
*ftype
= value_type (argvec
[0]);
776 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
778 /* We don't know anything about what the internal
779 function might return, but we have to return
781 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
784 else if (TYPE_CODE (ftype
) == TYPE_CODE_XMETHOD
)
787 = result_type_of_xmethod (argvec
[0], nargs
, argvec
+ 1);
789 if (return_type
== NULL
)
790 error (_("Xmethod is missing return type."));
791 return value_zero (return_type
, not_lval
);
793 else if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
794 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
796 if (TYPE_GNU_IFUNC (ftype
))
798 CORE_ADDR address
= value_address (argvec
[0]);
799 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
801 if (resolved_type
!= NULL
)
802 ftype
= resolved_type
;
805 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
807 if (return_type
== NULL
)
808 return_type
= default_return_type
;
810 if (return_type
== NULL
)
811 error_call_unknown_return_type (function_name
);
813 return allocate_value (return_type
);
816 error (_("Expression of type other than "
817 "\"Function returning ...\" used as function"));
819 switch (TYPE_CODE (value_type (argvec
[0])))
821 case TYPE_CODE_INTERNAL_FUNCTION
:
822 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
823 argvec
[0], nargs
, argvec
+ 1);
824 case TYPE_CODE_XMETHOD
:
825 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
827 return call_function_by_hand (argvec
[0], default_return_type
,
832 /* Helper for evaluating an OP_FUNCALL. */
835 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
843 symbol
*function
= NULL
;
844 char *function_name
= NULL
;
845 const char *var_func_name
= NULL
;
850 exp_opcode op
= exp
->elts
[*pos
].opcode
;
851 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
852 /* Allocate arg vector, including space for the function to be
853 called in argvec[0], a potential `this', and a terminating
855 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
856 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
858 /* First, evaluate the structure into arg2. */
861 if (op
== STRUCTOP_MEMBER
)
863 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
867 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
870 /* If the function is a virtual function, then the aggregate
871 value (providing the structure) plays its part by providing
872 the vtable. Otherwise, it is just along for the ride: call
873 the function directly. */
875 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
877 type
*a1_type
= check_typedef (value_type (arg1
));
878 if (noside
== EVAL_SKIP
)
879 tem
= 1; /* Set it to the right arg index so that all
880 arguments can also be skipped. */
881 else if (TYPE_CODE (a1_type
) == TYPE_CODE_METHODPTR
)
883 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
884 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
886 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
888 /* Now, say which argument to start evaluating from. */
893 else if (TYPE_CODE (a1_type
) == TYPE_CODE_MEMBERPTR
)
895 struct type
*type_ptr
896 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
897 struct type
*target_type_ptr
898 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
900 /* Now, convert these values to an address. */
901 arg2
= value_cast (type_ptr
, arg2
);
903 long mem_offset
= value_as_long (arg1
);
905 arg1
= value_from_pointer (target_type_ptr
,
906 value_as_long (arg2
) + mem_offset
);
907 arg1
= value_ind (arg1
);
911 error (_("Non-pointer-to-member value used in pointer-to-member "
914 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
916 /* Hair for method invocations. */
920 /* First, evaluate the structure into arg2. */
922 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
923 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
925 if (op
== STRUCTOP_STRUCT
)
927 /* If v is a variable in a register, and the user types
928 v.method (), this will produce an error, because v has no
931 A possible way around this would be to allocate a copy of
932 the variable on the stack, copy in the contents, call the
933 function, and copy out the contents. I.e. convert this
934 from call by reference to call by copy-return (or
935 whatever it's called). However, this does not work
936 because it is not the same: the method being called could
937 stash a copy of the address, and then future uses through
938 that address (after the method returns) would be expected
939 to use the variable itself, not some copy of it. */
940 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
944 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
946 /* Check to see if the operator '->' has been overloaded.
947 If the operator has been overloaded replace arg2 with the
948 value returned by the custom operator and continue
950 while (unop_user_defined_p (op
, arg2
))
952 struct value
*value
= NULL
;
955 value
= value_x_unop (arg2
, op
, noside
);
958 CATCH (except
, RETURN_MASK_ERROR
)
960 if (except
.error
== NOT_FOUND_ERROR
)
963 throw_exception (except
);
970 /* Now, say which argument to start evaluating from. */
973 else if (op
== OP_SCOPE
974 && overload_resolution
975 && (exp
->language_defn
->la_language
== language_cplus
))
977 /* Unpack it locally so we can properly handle overload
983 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
984 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
985 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
986 name
= &exp
->elts
[pc2
+ 3].string
;
989 function_name
= NULL
;
990 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
992 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
994 get_selected_block (0),
996 if (function
== NULL
)
997 error (_("No symbol \"%s\" in namespace \"%s\"."),
998 name
, TYPE_TAG_NAME (type
));
1001 /* arg2 is left as NULL on purpose. */
1005 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1006 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1007 function_name
= name
;
1009 /* We need a properly typed value for method lookup. For
1010 static methods arg2 is otherwise unused. */
1011 arg2
= value_zero (type
, lval_memory
);
1016 else if (op
== OP_ADL_FUNC
)
1018 /* Save the function position and move pos so that the arguments
1019 can be evaluated. */
1025 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1026 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1030 /* Non-method function call. */
1034 /* If this is a C++ function wait until overload resolution. */
1035 if (op
== OP_VAR_VALUE
1036 && overload_resolution
1037 && (exp
->language_defn
->la_language
== language_cplus
))
1039 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1044 if (op
== OP_VAR_MSYM_VALUE
)
1046 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1047 var_func_name
= MSYMBOL_PRINT_NAME (msym
);
1049 else if (op
== OP_VAR_VALUE
)
1051 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1052 var_func_name
= SYMBOL_PRINT_NAME (sym
);
1055 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1056 type
*type
= value_type (argvec
[0]);
1057 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1058 type
= TYPE_TARGET_TYPE (type
);
1059 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1061 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1063 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1071 /* Evaluate arguments (if not already done, e.g., namespace::func()
1072 and overload-resolution is off). */
1073 for (; tem
<= nargs
; tem
++)
1075 /* Ensure that array expressions are coerced into pointer
1077 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1080 /* Signal end of arglist. */
1083 if (noside
== EVAL_SKIP
)
1084 return eval_skip_value (exp
);
1086 if (op
== OP_ADL_FUNC
)
1088 struct symbol
*symp
;
1091 int string_pc
= save_pos1
+ 3;
1093 /* Extract the function name. */
1094 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1095 func_name
= (char *) alloca (name_len
+ 1);
1096 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1098 find_overload_match (&argvec
[1], nargs
, func_name
,
1099 NON_METHOD
, /* not method */
1100 NULL
, NULL
, /* pass NULL symbol since
1101 symbol is unknown */
1102 NULL
, &symp
, NULL
, 0, noside
);
1104 /* Now fix the expression being evaluated. */
1105 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1106 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1109 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1110 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1112 int static_memfuncp
;
1115 /* Method invocation: stuff "this" as first parameter. If the
1116 method turns out to be static we undo this below. */
1121 /* Name of method from expression. */
1122 tstr
= &exp
->elts
[pc2
+ 2].string
;
1125 tstr
= function_name
;
1127 if (overload_resolution
&& (exp
->language_defn
->la_language
1130 /* Language is C++, do some overload resolution before
1132 struct value
*valp
= NULL
;
1134 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1135 METHOD
, /* method */
1136 &arg2
, /* the object */
1138 &static_memfuncp
, 0, noside
);
1140 if (op
== OP_SCOPE
&& !static_memfuncp
)
1142 /* For the time being, we don't handle this. */
1143 error (_("Call to overloaded function %s requires "
1147 argvec
[1] = arg2
; /* the ``this'' pointer */
1148 argvec
[0] = valp
; /* Use the method found after overload
1152 /* Non-C++ case -- or no overload resolution. */
1154 struct value
*temp
= arg2
;
1156 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1158 op
== STRUCTOP_STRUCT
1159 ? "structure" : "structure pointer");
1160 /* value_struct_elt updates temp with the correct value of
1161 the ``this'' pointer if necessary, so modify argvec[1] to
1162 reflect any ``this'' changes. */
1164 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1165 value_address (temp
)
1166 + value_embedded_offset (temp
));
1167 argvec
[1] = arg2
; /* the ``this'' pointer */
1170 /* Take out `this' if needed. */
1171 if (static_memfuncp
)
1173 argvec
[1] = argvec
[0];
1178 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1180 /* Pointer to member. argvec[1] is already set up. */
1183 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1185 /* Non-member function being called. */
1186 /* fn: This can only be done for C++ functions. A C-style
1187 function in a C++ program, for instance, does not have the
1188 fields that are expected here. */
1190 if (overload_resolution
&& (exp
->language_defn
->la_language
1193 /* Language is C++, do some overload resolution before
1195 struct symbol
*symp
;
1198 /* If a scope has been specified disable ADL. */
1202 if (op
== OP_VAR_VALUE
)
1203 function
= exp
->elts
[save_pos1
+2].symbol
;
1205 (void) find_overload_match (&argvec
[1], nargs
,
1206 NULL
, /* no need for name */
1207 NON_METHOD
, /* not method */
1208 NULL
, function
, /* the function */
1209 NULL
, &symp
, NULL
, no_adl
, noside
);
1211 if (op
== OP_VAR_VALUE
)
1213 /* Now fix the expression being evaluated. */
1214 exp
->elts
[save_pos1
+2].symbol
= symp
;
1215 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1219 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1223 /* Not C++, or no overload resolution allowed. */
1224 /* Nothing to be done; argvec already correctly set up. */
1229 /* It is probably a C-style function. */
1230 /* Nothing to be done; argvec already correctly set up. */
1233 return eval_call (exp
, noside
, nargs
, argvec
, var_func_name
, expect_type
);
1237 evaluate_subexp_standard (struct type
*expect_type
,
1238 struct expression
*exp
, int *pos
,
1242 int tem
, tem2
, tem3
;
1244 struct value
*arg1
= NULL
;
1245 struct value
*arg2
= NULL
;
1249 struct value
**argvec
;
1253 struct type
**arg_types
;
1256 op
= exp
->elts
[pc
].opcode
;
1261 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1262 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1263 if (noside
== EVAL_SKIP
)
1264 return eval_skip_value (exp
);
1265 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
1266 &exp
->elts
[pc
+ 3].string
,
1267 expect_type
, 0, noside
);
1269 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
1274 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1275 exp
->elts
[pc
+ 2].longconst
);
1279 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1280 exp
->elts
[pc
+ 2].floatconst
);
1285 if (noside
== EVAL_SKIP
)
1286 return eval_skip_value (exp
);
1289 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1290 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_ERROR
)
1291 error_unknown_type (SYMBOL_PRINT_NAME (var
));
1293 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1296 case OP_VAR_MSYM_VALUE
:
1300 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1301 value
*val
= evaluate_var_msym_value (noside
,
1302 exp
->elts
[pc
+ 1].objfile
,
1305 type
= value_type (val
);
1306 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
1307 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| pc
!= 0))
1308 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol
));
1312 case OP_VAR_ENTRY_VALUE
:
1314 if (noside
== EVAL_SKIP
)
1315 return eval_skip_value (exp
);
1318 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1319 struct frame_info
*frame
;
1321 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1322 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1324 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1325 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1326 error (_("Symbol \"%s\" does not have any specific entry value"),
1327 SYMBOL_PRINT_NAME (sym
));
1329 frame
= get_selected_frame (NULL
);
1330 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1333 case OP_FUNC_STATIC_VAR
:
1334 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1335 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1336 if (noside
== EVAL_SKIP
)
1337 return eval_skip_value (exp
);
1340 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1341 CORE_ADDR addr
= value_address (func
);
1343 const block
*blk
= block_for_pc (addr
);
1344 const char *var
= &exp
->elts
[pc
+ 2].string
;
1346 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1348 if (sym
.symbol
== NULL
)
1349 error (_("No symbol \"%s\" in specified context."), var
);
1351 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1357 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1361 const char *name
= &exp
->elts
[pc
+ 2].string
;
1365 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1366 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1367 name
, strlen (name
));
1369 error (_("Register $%s not available."), name
);
1371 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1372 a value with the appropriate register type. Unfortunately,
1373 we don't have easy access to the type of user registers.
1374 So for these registers, we fetch the register value regardless
1375 of the evaluation mode. */
1376 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1377 && regno
< gdbarch_num_regs (exp
->gdbarch
)
1378 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
1379 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1381 val
= value_of_register (regno
, get_selected_frame (NULL
));
1383 error (_("Value of register %s not available."), name
);
1389 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1390 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1392 case OP_INTERNALVAR
:
1394 return value_of_internalvar (exp
->gdbarch
,
1395 exp
->elts
[pc
+ 1].internalvar
);
1398 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1399 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1400 if (noside
== EVAL_SKIP
)
1401 return eval_skip_value (exp
);
1402 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1403 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1405 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1406 NSString constant. */
1407 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1408 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1409 if (noside
== EVAL_SKIP
)
1410 return eval_skip_value (exp
);
1411 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1415 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1416 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1417 nargs
= tem3
- tem2
+ 1;
1418 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
1420 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1421 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1423 struct value
*rec
= allocate_value (expect_type
);
1425 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1426 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1429 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1430 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1432 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
1433 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1434 struct value
*array
= allocate_value (expect_type
);
1435 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1436 LONGEST low_bound
, high_bound
, index
;
1438 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1441 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1444 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1445 for (tem
= nargs
; --nargs
>= 0;)
1447 struct value
*element
;
1450 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1451 if (value_type (element
) != element_type
)
1452 element
= value_cast (element_type
, element
);
1455 int continue_pc
= *pos
;
1458 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1459 low_bound
, high_bound
);
1464 if (index
> high_bound
)
1465 /* To avoid memory corruption. */
1466 error (_("Too many array elements"));
1467 memcpy (value_contents_raw (array
)
1468 + (index
- low_bound
) * element_size
,
1469 value_contents (element
),
1477 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1478 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1480 struct value
*set
= allocate_value (expect_type
);
1481 gdb_byte
*valaddr
= value_contents_raw (set
);
1482 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1483 struct type
*check_type
= element_type
;
1484 LONGEST low_bound
, high_bound
;
1486 /* Get targettype of elementtype. */
1487 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1488 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1489 check_type
= TYPE_TARGET_TYPE (check_type
);
1491 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1492 error (_("(power)set type with unknown size"));
1493 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1494 for (tem
= 0; tem
< nargs
; tem
++)
1496 LONGEST range_low
, range_high
;
1497 struct type
*range_low_type
, *range_high_type
;
1498 struct value
*elem_val
;
1500 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1501 range_low_type
= range_high_type
= value_type (elem_val
);
1502 range_low
= range_high
= value_as_long (elem_val
);
1504 /* Check types of elements to avoid mixture of elements from
1505 different types. Also check if type of element is "compatible"
1506 with element type of powerset. */
1507 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1508 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1509 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1510 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1511 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1512 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1513 && (range_low_type
!= range_high_type
)))
1514 /* different element modes. */
1515 error (_("POWERSET tuple elements of different mode"));
1516 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1517 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1518 && range_low_type
!= check_type
))
1519 error (_("incompatible POWERSET tuple elements"));
1520 if (range_low
> range_high
)
1522 warning (_("empty POWERSET tuple range"));
1525 if (range_low
< low_bound
|| range_high
> high_bound
)
1526 error (_("POWERSET tuple element out of range"));
1527 range_low
-= low_bound
;
1528 range_high
-= low_bound
;
1529 for (; range_low
<= range_high
; range_low
++)
1531 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1533 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1534 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1535 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1542 argvec
= XALLOCAVEC (struct value
*, nargs
);
1543 for (tem
= 0; tem
< nargs
; tem
++)
1545 /* Ensure that array expressions are coerced into pointer
1547 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1549 if (noside
== EVAL_SKIP
)
1550 return eval_skip_value (exp
);
1551 return value_array (tem2
, tem3
, argvec
);
1555 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1557 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1559 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1561 if (noside
== EVAL_SKIP
)
1562 return eval_skip_value (exp
);
1563 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1567 /* Skip third and second args to evaluate the first one. */
1568 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1569 if (value_logical_not (arg1
))
1571 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1572 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1576 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1577 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1581 case OP_OBJC_SELECTOR
:
1582 { /* Objective C @selector operator. */
1583 char *sel
= &exp
->elts
[pc
+ 2].string
;
1584 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1585 struct type
*selector_type
;
1587 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1588 if (noside
== EVAL_SKIP
)
1589 return eval_skip_value (exp
);
1592 sel
[len
] = 0; /* Make sure it's terminated. */
1594 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1595 return value_from_longest (selector_type
,
1596 lookup_child_selector (exp
->gdbarch
, sel
));
1599 case OP_OBJC_MSGCALL
:
1600 { /* Objective C message (method) call. */
1602 CORE_ADDR responds_selector
= 0;
1603 CORE_ADDR method_selector
= 0;
1605 CORE_ADDR selector
= 0;
1607 int struct_return
= 0;
1608 enum noside sub_no_side
= EVAL_NORMAL
;
1610 struct value
*msg_send
= NULL
;
1611 struct value
*msg_send_stret
= NULL
;
1612 int gnu_runtime
= 0;
1614 struct value
*target
= NULL
;
1615 struct value
*method
= NULL
;
1616 struct value
*called_method
= NULL
;
1618 struct type
*selector_type
= NULL
;
1619 struct type
*long_type
;
1621 struct value
*ret
= NULL
;
1624 selector
= exp
->elts
[pc
+ 1].longconst
;
1625 nargs
= exp
->elts
[pc
+ 2].longconst
;
1626 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1630 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1631 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1633 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1634 sub_no_side
= EVAL_NORMAL
;
1636 sub_no_side
= noside
;
1638 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1640 if (value_as_long (target
) == 0)
1641 return value_from_longest (long_type
, 0);
1643 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1646 /* Find the method dispatch (Apple runtime) or method lookup
1647 (GNU runtime) function for Objective-C. These will be used
1648 to lookup the symbol information for the method. If we
1649 can't find any symbol information, then we'll use these to
1650 call the method, otherwise we can call the method
1651 directly. The msg_send_stret function is used in the special
1652 case of a method that returns a structure (Apple runtime
1656 struct type
*type
= selector_type
;
1658 type
= lookup_function_type (type
);
1659 type
= lookup_pointer_type (type
);
1660 type
= lookup_function_type (type
);
1661 type
= lookup_pointer_type (type
);
1663 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1665 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1667 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1668 msg_send_stret
= value_from_pointer (type
,
1669 value_as_address (msg_send_stret
));
1673 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1674 /* Special dispatcher for methods returning structs. */
1676 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1679 /* Verify the target object responds to this method. The
1680 standard top-level 'Object' class uses a different name for
1681 the verification method than the non-standard, but more
1682 often used, 'NSObject' class. Make sure we check for both. */
1685 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1686 if (responds_selector
== 0)
1688 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1690 if (responds_selector
== 0)
1691 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1694 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1695 if (method_selector
== 0)
1697 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1699 if (method_selector
== 0)
1700 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1702 /* Call the verification method, to make sure that the target
1703 class implements the desired method. */
1705 argvec
[0] = msg_send
;
1707 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1708 argvec
[3] = value_from_longest (long_type
, selector
);
1711 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1714 /* Function objc_msg_lookup returns a pointer. */
1716 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1718 if (value_as_long (ret
) == 0)
1719 error (_("Target does not respond to this message selector."));
1721 /* Call "methodForSelector:" method, to get the address of a
1722 function method that implements this selector for this
1723 class. If we can find a symbol at that address, then we
1724 know the return type, parameter types etc. (that's a good
1727 argvec
[0] = msg_send
;
1729 argvec
[2] = value_from_longest (long_type
, method_selector
);
1730 argvec
[3] = value_from_longest (long_type
, selector
);
1733 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1737 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1740 /* ret should now be the selector. */
1742 addr
= value_as_long (ret
);
1745 struct symbol
*sym
= NULL
;
1747 /* The address might point to a function descriptor;
1748 resolve it to the actual code address instead. */
1749 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1752 /* Is it a high_level symbol? */
1753 sym
= find_pc_function (addr
);
1755 method
= value_of_variable (sym
, 0);
1758 /* If we found a method with symbol information, check to see
1759 if it returns a struct. Otherwise assume it doesn't. */
1764 struct type
*val_type
;
1766 funaddr
= find_function_addr (method
, &val_type
);
1768 block_for_pc (funaddr
);
1770 val_type
= check_typedef (val_type
);
1772 if ((val_type
== NULL
)
1773 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1775 if (expect_type
!= NULL
)
1776 val_type
= expect_type
;
1779 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1782 else if (expect_type
!= NULL
)
1784 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1785 check_typedef (expect_type
));
1788 /* Found a function symbol. Now we will substitute its
1789 value in place of the message dispatcher (obj_msgSend),
1790 so that we call the method directly instead of thru
1791 the dispatcher. The main reason for doing this is that
1792 we can now evaluate the return value and parameter values
1793 according to their known data types, in case we need to
1794 do things like promotion, dereferencing, special handling
1795 of structs and doubles, etc.
1797 We want to use the type signature of 'method', but still
1798 jump to objc_msgSend() or objc_msgSend_stret() to better
1799 mimic the behavior of the runtime. */
1803 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1804 error (_("method address has symbol information "
1805 "with non-function type; skipping"));
1807 /* Create a function pointer of the appropriate type, and
1808 replace its value with the value of msg_send or
1809 msg_send_stret. We must use a pointer here, as
1810 msg_send and msg_send_stret are of pointer type, and
1811 the representation may be different on systems that use
1812 function descriptors. */
1815 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1816 value_as_address (msg_send_stret
));
1819 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1820 value_as_address (msg_send
));
1825 called_method
= msg_send_stret
;
1827 called_method
= msg_send
;
1830 if (noside
== EVAL_SKIP
)
1831 return eval_skip_value (exp
);
1833 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1835 /* If the return type doesn't look like a function type,
1836 call an error. This can happen if somebody tries to
1837 turn a variable into a function call. This is here
1838 because people often want to call, eg, strcmp, which
1839 gdb doesn't know is a function. If gdb isn't asked for
1840 it's opinion (ie. through "whatis"), it won't offer
1843 struct type
*type
= value_type (called_method
);
1845 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1846 type
= TYPE_TARGET_TYPE (type
);
1847 type
= TYPE_TARGET_TYPE (type
);
1851 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1852 return allocate_value (expect_type
);
1854 return allocate_value (type
);
1857 error (_("Expression of type other than "
1858 "\"method returning ...\" used as a method"));
1861 /* Now depending on whether we found a symbol for the method,
1862 we will either call the runtime dispatcher or the method
1865 argvec
[0] = called_method
;
1867 argvec
[2] = value_from_longest (long_type
, selector
);
1868 /* User-supplied arguments. */
1869 for (tem
= 0; tem
< nargs
; tem
++)
1870 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1871 argvec
[tem
+ 3] = 0;
1873 if (gnu_runtime
&& (method
!= NULL
))
1875 /* Function objc_msg_lookup returns a pointer. */
1876 deprecated_set_value_type (argvec
[0],
1877 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1879 = call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1882 ret
= call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1888 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1890 case OP_F77_UNDETERMINED_ARGLIST
:
1892 /* Remember that in F77, functions, substring ops and
1893 array subscript operations cannot be disambiguated
1894 at parse time. We have made all array subscript operations,
1895 substring operations as well as function calls come here
1896 and we now have to discover what the heck this thing actually was.
1897 If it is a function, we process just as if we got an OP_FUNCALL. */
1899 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1902 /* First determine the type code we are dealing with. */
1903 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1904 type
= check_typedef (value_type (arg1
));
1905 code
= TYPE_CODE (type
);
1907 if (code
== TYPE_CODE_PTR
)
1909 /* Fortran always passes variable to subroutines as pointer.
1910 So we need to look into its target type to see if it is
1911 array, string or function. If it is, we need to switch
1912 to the target value the original one points to. */
1913 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1915 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1916 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1917 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1919 arg1
= value_ind (arg1
);
1920 type
= check_typedef (value_type (arg1
));
1921 code
= TYPE_CODE (type
);
1927 case TYPE_CODE_ARRAY
:
1928 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1929 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1931 goto multi_f77_subscript
;
1933 case TYPE_CODE_STRING
:
1934 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1935 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1938 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1939 return value_subscript (arg1
, value_as_long (arg2
));
1943 case TYPE_CODE_FUNC
:
1944 /* It's a function call. */
1945 /* Allocate arg vector, including space for the function to be
1946 called in argvec[0] and a terminating NULL. */
1947 argvec
= (struct value
**)
1948 alloca (sizeof (struct value
*) * (nargs
+ 2));
1951 for (; tem
<= nargs
; tem
++)
1952 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1953 argvec
[tem
] = 0; /* signal end of arglist */
1954 if (noside
== EVAL_SKIP
)
1955 return eval_skip_value (exp
);
1956 return eval_call (exp
, noside
, nargs
, argvec
, NULL
, expect_type
);
1959 error (_("Cannot perform substring on this type"));
1963 /* We have a complex number, There should be 2 floating
1964 point numbers that compose it. */
1966 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1967 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1969 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1971 case STRUCTOP_STRUCT
:
1972 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1973 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1974 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1975 if (noside
== EVAL_SKIP
)
1976 return eval_skip_value (exp
);
1977 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1979 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1980 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1984 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1985 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1986 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1987 if (noside
== EVAL_SKIP
)
1988 return eval_skip_value (exp
);
1990 /* Check to see if operator '->' has been overloaded. If so replace
1991 arg1 with the value returned by evaluating operator->(). */
1992 while (unop_user_defined_p (op
, arg1
))
1994 struct value
*value
= NULL
;
1997 value
= value_x_unop (arg1
, op
, noside
);
2000 CATCH (except
, RETURN_MASK_ERROR
)
2002 if (except
.error
== NOT_FOUND_ERROR
)
2005 throw_exception (except
);
2012 /* JYG: if print object is on we need to replace the base type
2013 with rtti type in order to continue on with successful
2014 lookup of member / method only available in the rtti type. */
2016 struct type
*type
= value_type (arg1
);
2017 struct type
*real_type
;
2018 int full
, using_enc
;
2020 struct value_print_options opts
;
2022 get_user_print_options (&opts
);
2023 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
2024 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
2026 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
2029 arg1
= value_cast (real_type
, arg1
);
2033 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2034 NULL
, "structure pointer");
2035 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2036 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2039 case STRUCTOP_MEMBER
:
2041 if (op
== STRUCTOP_MEMBER
)
2042 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2044 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2046 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2048 if (noside
== EVAL_SKIP
)
2049 return eval_skip_value (exp
);
2051 type
= check_typedef (value_type (arg2
));
2052 switch (TYPE_CODE (type
))
2054 case TYPE_CODE_METHODPTR
:
2055 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2056 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2059 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2060 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2061 return value_ind (arg2
);
2064 case TYPE_CODE_MEMBERPTR
:
2065 /* Now, convert these values to an address. */
2066 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
2069 mem_offset
= value_as_long (arg2
);
2071 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2072 value_as_long (arg1
) + mem_offset
);
2073 return value_ind (arg3
);
2076 error (_("non-pointer-to-member value used "
2077 "in pointer-to-member construct"));
2082 type_instance_flags flags
2083 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2084 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2085 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2086 for (ix
= 0; ix
< nargs
; ++ix
)
2087 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2089 fake_method
expect_type (flags
, nargs
, arg_types
);
2090 *(pos
) += 4 + nargs
;
2091 return evaluate_subexp_standard (expect_type
.type (), exp
, pos
, noside
);
2095 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2096 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2097 if (noside
== EVAL_SKIP
)
2098 return eval_skip_value (exp
);
2099 if (binop_user_defined_p (op
, arg1
, arg2
))
2100 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2102 return value_concat (arg1
, arg2
);
2105 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2106 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2108 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2110 if (binop_user_defined_p (op
, arg1
, arg2
))
2111 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2113 return value_assign (arg1
, arg2
);
2115 case BINOP_ASSIGN_MODIFY
:
2117 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2118 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2119 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2121 op
= exp
->elts
[pc
+ 1].opcode
;
2122 if (binop_user_defined_p (op
, arg1
, arg2
))
2123 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2124 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2126 && is_integral_type (value_type (arg2
)))
2127 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2128 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2130 && is_integral_type (value_type (arg2
)))
2131 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2134 struct value
*tmp
= arg1
;
2136 /* For shift and integer exponentiation operations,
2137 only promote the first argument. */
2138 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2139 && is_integral_type (value_type (arg2
)))
2140 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2142 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2144 arg2
= value_binop (tmp
, arg2
, op
);
2146 return value_assign (arg1
, arg2
);
2149 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2150 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2151 if (noside
== EVAL_SKIP
)
2152 return eval_skip_value (exp
);
2153 if (binop_user_defined_p (op
, arg1
, arg2
))
2154 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2155 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2156 && is_integral_type (value_type (arg2
)))
2157 return value_ptradd (arg1
, value_as_long (arg2
));
2158 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2159 && is_integral_type (value_type (arg1
)))
2160 return value_ptradd (arg2
, value_as_long (arg1
));
2163 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2164 return value_binop (arg1
, arg2
, BINOP_ADD
);
2168 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2169 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2170 if (noside
== EVAL_SKIP
)
2171 return eval_skip_value (exp
);
2172 if (binop_user_defined_p (op
, arg1
, arg2
))
2173 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2174 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2175 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2177 /* FIXME -- should be ptrdiff_t */
2178 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2179 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2181 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2182 && is_integral_type (value_type (arg2
)))
2183 return value_ptradd (arg1
, - value_as_long (arg2
));
2186 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2187 return value_binop (arg1
, arg2
, BINOP_SUB
);
2198 case BINOP_BITWISE_AND
:
2199 case BINOP_BITWISE_IOR
:
2200 case BINOP_BITWISE_XOR
:
2201 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2202 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2203 if (noside
== EVAL_SKIP
)
2204 return eval_skip_value (exp
);
2205 if (binop_user_defined_p (op
, arg1
, arg2
))
2206 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2209 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2210 fudge arg2 to avoid division-by-zero, the caller is
2211 (theoretically) only looking for the type of the result. */
2212 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2213 /* ??? Do we really want to test for BINOP_MOD here?
2214 The implementation of value_binop gives it a well-defined
2217 || op
== BINOP_INTDIV
2220 && value_logical_not (arg2
))
2222 struct value
*v_one
, *retval
;
2224 v_one
= value_one (value_type (arg2
));
2225 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2226 retval
= value_binop (arg1
, v_one
, op
);
2231 /* For shift and integer exponentiation operations,
2232 only promote the first argument. */
2233 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2234 && is_integral_type (value_type (arg2
)))
2235 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2237 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2239 return value_binop (arg1
, arg2
, op
);
2243 case BINOP_SUBSCRIPT
:
2244 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2245 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2246 if (noside
== EVAL_SKIP
)
2247 return eval_skip_value (exp
);
2248 if (binop_user_defined_p (op
, arg1
, arg2
))
2249 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2252 /* If the user attempts to subscript something that is not an
2253 array or pointer type (like a plain int variable for example),
2254 then report this as an error. */
2256 arg1
= coerce_ref (arg1
);
2257 type
= check_typedef (value_type (arg1
));
2258 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2259 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2261 if (TYPE_NAME (type
))
2262 error (_("cannot subscript something of type `%s'"),
2265 error (_("cannot subscript requested type"));
2268 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2269 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2271 return value_subscript (arg1
, value_as_long (arg2
));
2273 case MULTI_SUBSCRIPT
:
2275 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2276 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2279 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2280 /* FIXME: EVAL_SKIP handling may not be correct. */
2281 if (noside
== EVAL_SKIP
)
2285 return eval_skip_value (exp
);
2287 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2288 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2290 /* If the user attempts to subscript something that has no target
2291 type (like a plain int variable for example), then report this
2294 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2297 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2303 error (_("cannot subscript something of type `%s'"),
2304 TYPE_NAME (value_type (arg1
)));
2308 if (binop_user_defined_p (op
, arg1
, arg2
))
2310 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2314 arg1
= coerce_ref (arg1
);
2315 type
= check_typedef (value_type (arg1
));
2317 switch (TYPE_CODE (type
))
2320 case TYPE_CODE_ARRAY
:
2321 case TYPE_CODE_STRING
:
2322 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2326 if (TYPE_NAME (type
))
2327 error (_("cannot subscript something of type `%s'"),
2330 error (_("cannot subscript requested type"));
2336 multi_f77_subscript
:
2338 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2339 int ndimensions
= 1, i
;
2340 struct value
*array
= arg1
;
2342 if (nargs
> MAX_FORTRAN_DIMS
)
2343 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2345 ndimensions
= calc_f77_array_dims (type
);
2347 if (nargs
!= ndimensions
)
2348 error (_("Wrong number of subscripts"));
2350 gdb_assert (nargs
> 0);
2352 /* Now that we know we have a legal array subscript expression
2353 let us actually find out where this element exists in the array. */
2355 /* Take array indices left to right. */
2356 for (i
= 0; i
< nargs
; i
++)
2358 /* Evaluate each subscript; it must be a legal integer in F77. */
2359 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2361 /* Fill in the subscript array. */
2363 subscript_array
[i
] = value_as_long (arg2
);
2366 /* Internal type of array is arranged right to left. */
2367 for (i
= nargs
; i
> 0; i
--)
2369 struct type
*array_type
= check_typedef (value_type (array
));
2370 LONGEST index
= subscript_array
[i
- 1];
2372 array
= value_subscripted_rvalue (array
, index
,
2373 f77_get_lowerbound (array_type
));
2379 case BINOP_LOGICAL_AND
:
2380 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2381 if (noside
== EVAL_SKIP
)
2383 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2384 return eval_skip_value (exp
);
2388 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2391 if (binop_user_defined_p (op
, arg1
, arg2
))
2393 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2394 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2398 tem
= value_logical_not (arg1
);
2399 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2400 (tem
? EVAL_SKIP
: noside
));
2401 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2402 return value_from_longest (type
,
2403 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2406 case BINOP_LOGICAL_OR
:
2407 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2408 if (noside
== EVAL_SKIP
)
2410 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2411 return eval_skip_value (exp
);
2415 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2418 if (binop_user_defined_p (op
, arg1
, arg2
))
2420 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2421 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2425 tem
= value_logical_not (arg1
);
2426 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2427 (!tem
? EVAL_SKIP
: noside
));
2428 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2429 return value_from_longest (type
,
2430 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2434 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2435 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2436 if (noside
== EVAL_SKIP
)
2437 return eval_skip_value (exp
);
2438 if (binop_user_defined_p (op
, arg1
, arg2
))
2440 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2444 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2445 tem
= value_equal (arg1
, arg2
);
2446 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2447 return value_from_longest (type
, (LONGEST
) tem
);
2450 case BINOP_NOTEQUAL
:
2451 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2452 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2453 if (noside
== EVAL_SKIP
)
2454 return eval_skip_value (exp
);
2455 if (binop_user_defined_p (op
, arg1
, arg2
))
2457 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2461 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2462 tem
= value_equal (arg1
, arg2
);
2463 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2464 return value_from_longest (type
, (LONGEST
) ! tem
);
2468 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2469 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2470 if (noside
== EVAL_SKIP
)
2471 return eval_skip_value (exp
);
2472 if (binop_user_defined_p (op
, arg1
, arg2
))
2474 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2478 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2479 tem
= value_less (arg1
, arg2
);
2480 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2481 return value_from_longest (type
, (LONGEST
) tem
);
2485 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2486 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2487 if (noside
== EVAL_SKIP
)
2488 return eval_skip_value (exp
);
2489 if (binop_user_defined_p (op
, arg1
, arg2
))
2491 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2495 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2496 tem
= value_less (arg2
, arg1
);
2497 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2498 return value_from_longest (type
, (LONGEST
) tem
);
2502 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2503 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2504 if (noside
== EVAL_SKIP
)
2505 return eval_skip_value (exp
);
2506 if (binop_user_defined_p (op
, arg1
, arg2
))
2508 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2512 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2513 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2514 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2515 return value_from_longest (type
, (LONGEST
) tem
);
2519 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2520 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2521 if (noside
== EVAL_SKIP
)
2522 return eval_skip_value (exp
);
2523 if (binop_user_defined_p (op
, arg1
, arg2
))
2525 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2529 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2530 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2531 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2532 return value_from_longest (type
, (LONGEST
) tem
);
2536 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2537 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2538 if (noside
== EVAL_SKIP
)
2539 return eval_skip_value (exp
);
2540 type
= check_typedef (value_type (arg2
));
2541 if (TYPE_CODE (type
) != TYPE_CODE_INT
2542 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
2543 error (_("Non-integral right operand for \"@\" operator."));
2544 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2546 return allocate_repeat_value (value_type (arg1
),
2547 longest_to_int (value_as_long (arg2
)));
2550 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2553 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2554 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2557 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2558 if (noside
== EVAL_SKIP
)
2559 return eval_skip_value (exp
);
2560 if (unop_user_defined_p (op
, arg1
))
2561 return value_x_unop (arg1
, op
, noside
);
2564 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2565 return value_pos (arg1
);
2569 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2570 if (noside
== EVAL_SKIP
)
2571 return eval_skip_value (exp
);
2572 if (unop_user_defined_p (op
, arg1
))
2573 return value_x_unop (arg1
, op
, noside
);
2576 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2577 return value_neg (arg1
);
2580 case UNOP_COMPLEMENT
:
2581 /* C++: check for and handle destructor names. */
2583 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2584 if (noside
== EVAL_SKIP
)
2585 return eval_skip_value (exp
);
2586 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2587 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2590 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2591 return value_complement (arg1
);
2594 case UNOP_LOGICAL_NOT
:
2595 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2596 if (noside
== EVAL_SKIP
)
2597 return eval_skip_value (exp
);
2598 if (unop_user_defined_p (op
, arg1
))
2599 return value_x_unop (arg1
, op
, noside
);
2602 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2603 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2607 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2608 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2609 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2610 type
= check_typedef (value_type (arg1
));
2611 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2612 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2613 error (_("Attempt to dereference pointer "
2614 "to member without an object"));
2615 if (noside
== EVAL_SKIP
)
2616 return eval_skip_value (exp
);
2617 if (unop_user_defined_p (op
, arg1
))
2618 return value_x_unop (arg1
, op
, noside
);
2619 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2621 type
= check_typedef (value_type (arg1
));
2622 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2623 || TYPE_IS_REFERENCE (type
)
2624 /* In C you can dereference an array to get the 1st elt. */
2625 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2627 return value_zero (TYPE_TARGET_TYPE (type
),
2629 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2630 /* GDB allows dereferencing an int. */
2631 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2634 error (_("Attempt to take contents of a non-pointer value."));
2637 /* Allow * on an integer so we can cast it to whatever we want.
2638 This returns an int, which seems like the most C-like thing to
2639 do. "long long" variables are rare enough that
2640 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2641 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2642 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2643 (CORE_ADDR
) value_as_address (arg1
));
2644 return value_ind (arg1
);
2647 /* C++: check for and handle pointer to members. */
2649 if (noside
== EVAL_SKIP
)
2651 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2652 return eval_skip_value (exp
);
2656 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2663 if (noside
== EVAL_SKIP
)
2665 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2666 return eval_skip_value (exp
);
2668 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2673 = value_type (evaluate_subexp (NULL_TYPE
, exp
, pos
,
2674 EVAL_AVOID_SIDE_EFFECTS
));
2675 /* FIXME: This should be size_t. */
2676 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2677 ULONGEST align
= type_align (type
);
2679 error (_("could not determine alignment of type"));
2680 return value_from_longest (size_type
, align
);
2685 type
= exp
->elts
[pc
+ 1].type
;
2686 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2688 case UNOP_CAST_TYPE
:
2689 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2690 type
= value_type (arg1
);
2691 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2693 case UNOP_DYNAMIC_CAST
:
2694 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2695 type
= value_type (arg1
);
2696 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2697 if (noside
== EVAL_SKIP
)
2698 return eval_skip_value (exp
);
2699 return value_dynamic_cast (type
, arg1
);
2701 case UNOP_REINTERPRET_CAST
:
2702 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2703 type
= value_type (arg1
);
2704 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2705 if (noside
== EVAL_SKIP
)
2706 return eval_skip_value (exp
);
2707 return value_reinterpret_cast (type
, arg1
);
2711 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2712 if (noside
== EVAL_SKIP
)
2713 return eval_skip_value (exp
);
2714 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2715 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2717 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2718 value_as_address (arg1
));
2720 case UNOP_MEMVAL_TYPE
:
2721 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2722 type
= value_type (arg1
);
2723 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2724 if (noside
== EVAL_SKIP
)
2725 return eval_skip_value (exp
);
2726 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2727 return value_zero (type
, lval_memory
);
2729 return value_at_lazy (type
, value_as_address (arg1
));
2731 case UNOP_PREINCREMENT
:
2732 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2733 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2735 else if (unop_user_defined_p (op
, arg1
))
2737 return value_x_unop (arg1
, op
, noside
);
2741 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2742 arg2
= value_ptradd (arg1
, 1);
2745 struct value
*tmp
= arg1
;
2747 arg2
= value_one (value_type (arg1
));
2748 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2749 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2752 return value_assign (arg1
, arg2
);
2755 case UNOP_PREDECREMENT
:
2756 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2757 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2759 else if (unop_user_defined_p (op
, arg1
))
2761 return value_x_unop (arg1
, op
, noside
);
2765 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2766 arg2
= value_ptradd (arg1
, -1);
2769 struct value
*tmp
= arg1
;
2771 arg2
= value_one (value_type (arg1
));
2772 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2773 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2776 return value_assign (arg1
, arg2
);
2779 case UNOP_POSTINCREMENT
:
2780 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2781 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2783 else if (unop_user_defined_p (op
, arg1
))
2785 return value_x_unop (arg1
, op
, noside
);
2789 arg3
= value_non_lval (arg1
);
2791 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2792 arg2
= value_ptradd (arg1
, 1);
2795 struct value
*tmp
= arg1
;
2797 arg2
= value_one (value_type (arg1
));
2798 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2799 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2802 value_assign (arg1
, arg2
);
2806 case UNOP_POSTDECREMENT
:
2807 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2808 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2810 else if (unop_user_defined_p (op
, arg1
))
2812 return value_x_unop (arg1
, op
, noside
);
2816 arg3
= value_non_lval (arg1
);
2818 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2819 arg2
= value_ptradd (arg1
, -1);
2822 struct value
*tmp
= arg1
;
2824 arg2
= value_one (value_type (arg1
));
2825 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2826 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2829 value_assign (arg1
, arg2
);
2835 return value_of_this (exp
->language_defn
);
2838 /* The value is not supposed to be used. This is here to make it
2839 easier to accommodate expressions that contain types. */
2841 if (noside
== EVAL_SKIP
)
2842 return eval_skip_value (exp
);
2843 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2844 return allocate_value (exp
->elts
[pc
+ 1].type
);
2846 error (_("Attempt to use a type name as an expression"));
2850 if (noside
== EVAL_SKIP
)
2852 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2853 return eval_skip_value (exp
);
2855 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2857 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2858 struct value
*result
;
2860 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2861 EVAL_AVOID_SIDE_EFFECTS
);
2863 /* 'decltype' has special semantics for lvalues. */
2864 if (op
== OP_DECLTYPE
2865 && (sub_op
== BINOP_SUBSCRIPT
2866 || sub_op
== STRUCTOP_MEMBER
2867 || sub_op
== STRUCTOP_MPTR
2868 || sub_op
== UNOP_IND
2869 || sub_op
== STRUCTOP_STRUCT
2870 || sub_op
== STRUCTOP_PTR
2871 || sub_op
== OP_SCOPE
))
2873 struct type
*type
= value_type (result
);
2875 if (!TYPE_IS_REFERENCE (type
))
2877 type
= lookup_lvalue_reference_type (type
);
2878 result
= allocate_value (type
);
2885 error (_("Attempt to use a type as an expression"));
2889 struct value
*result
;
2890 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2892 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2893 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2894 EVAL_AVOID_SIDE_EFFECTS
);
2896 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2898 if (noside
!= EVAL_NORMAL
)
2899 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2901 return cplus_typeid (result
);
2905 /* Removing this case and compiling with gcc -Wall reveals that
2906 a lot of cases are hitting this case. Some of these should
2907 probably be removed from expression.h; others are legitimate
2908 expressions which are (apparently) not fully implemented.
2910 If there are any cases landing here which mean a user error,
2911 then they should be separate cases, with more descriptive
2914 error (_("GDB does not (yet) know how to "
2915 "evaluate that kind of expression"));
2918 gdb_assert_not_reached ("missed return?");
2921 /* Evaluate a subexpression of EXP, at index *POS,
2922 and return the address of that subexpression.
2923 Advance *POS over the subexpression.
2924 If the subexpression isn't an lvalue, get an error.
2925 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2926 then only the type of the result need be correct. */
2928 static struct value
*
2929 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2939 op
= exp
->elts
[pc
].opcode
;
2945 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2947 /* We can't optimize out "&*" if there's a user-defined operator*. */
2948 if (unop_user_defined_p (op
, x
))
2950 x
= value_x_unop (x
, op
, noside
);
2951 goto default_case_after_eval
;
2954 return coerce_array (x
);
2958 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2959 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2961 case UNOP_MEMVAL_TYPE
:
2966 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2967 type
= value_type (x
);
2968 return value_cast (lookup_pointer_type (type
),
2969 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2973 var
= exp
->elts
[pc
+ 2].symbol
;
2975 /* C++: The "address" of a reference should yield the address
2976 * of the object pointed to. Let value_addr() deal with it. */
2977 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
2981 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2984 lookup_pointer_type (SYMBOL_TYPE (var
));
2985 enum address_class sym_class
= SYMBOL_CLASS (var
);
2987 if (sym_class
== LOC_CONST
2988 || sym_class
== LOC_CONST_BYTES
2989 || sym_class
== LOC_REGISTER
)
2990 error (_("Attempt to take address of register or constant."));
2993 value_zero (type
, not_lval
);
2996 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2998 case OP_VAR_MSYM_VALUE
:
3002 value
*val
= evaluate_var_msym_value (noside
,
3003 exp
->elts
[pc
+ 1].objfile
,
3004 exp
->elts
[pc
+ 2].msymbol
);
3005 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3007 struct type
*type
= lookup_pointer_type (value_type (val
));
3008 return value_zero (type
, not_lval
);
3011 return value_addr (val
);
3015 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3016 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3017 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3018 &exp
->elts
[pc
+ 3].string
,
3021 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3026 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3027 default_case_after_eval
:
3028 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3030 struct type
*type
= check_typedef (value_type (x
));
3032 if (TYPE_IS_REFERENCE (type
))
3033 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3035 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3036 return value_zero (lookup_pointer_type (value_type (x
)),
3039 error (_("Attempt to take address of "
3040 "value not located in memory."));
3042 return value_addr (x
);
3046 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3047 When used in contexts where arrays will be coerced anyway, this is
3048 equivalent to `evaluate_subexp' but much faster because it avoids
3049 actually fetching array contents (perhaps obsolete now that we have
3052 Note that we currently only do the coercion for C expressions, where
3053 arrays are zero based and the coercion is correct. For other languages,
3054 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3055 to decide if coercion is appropriate. */
3058 evaluate_subexp_with_coercion (struct expression
*exp
,
3059 int *pos
, enum noside noside
)
3068 op
= exp
->elts
[pc
].opcode
;
3073 var
= exp
->elts
[pc
+ 2].symbol
;
3074 type
= check_typedef (SYMBOL_TYPE (var
));
3075 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3076 && !TYPE_VECTOR (type
)
3077 && CAST_IS_CONVERSION (exp
->language_defn
))
3080 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3081 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3087 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3091 /* Evaluate a subexpression of EXP, at index *POS,
3092 and return a value for the size of that subexpression.
3093 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3094 we allow side-effects on the operand if its type is a variable
3097 static struct value
*
3098 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3101 /* FIXME: This should be size_t. */
3102 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3109 op
= exp
->elts
[pc
].opcode
;
3113 /* This case is handled specially
3114 so that we avoid creating a value for the result type.
3115 If the result type is very big, it's desirable not to
3116 create a value unnecessarily. */
3119 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3120 type
= check_typedef (value_type (val
));
3121 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3122 && !TYPE_IS_REFERENCE (type
)
3123 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3124 error (_("Attempt to take contents of a non-pointer value."));
3125 type
= TYPE_TARGET_TYPE (type
);
3126 if (is_dynamic_type (type
))
3127 type
= value_type (value_ind (val
));
3128 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3132 type
= exp
->elts
[pc
+ 1].type
;
3135 case UNOP_MEMVAL_TYPE
:
3137 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3138 type
= value_type (val
);
3142 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3143 if (is_dynamic_type (type
))
3145 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3146 type
= value_type (val
);
3152 case OP_VAR_MSYM_VALUE
:
3156 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3157 value
*val
= evaluate_var_msym_value (noside
,
3158 exp
->elts
[pc
+ 1].objfile
,
3161 type
= value_type (val
);
3162 if (TYPE_CODE (type
) == TYPE_CODE_ERROR
)
3163 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol
));
3165 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3169 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3170 type of the subscript is a variable length array type. In this case we
3171 must re-evaluate the right hand side of the subcription to allow
3173 case BINOP_SUBSCRIPT
:
3174 if (noside
== EVAL_NORMAL
)
3176 int pc
= (*pos
) + 1;
3178 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3179 type
= check_typedef (value_type (val
));
3180 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3182 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3183 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3185 type
= TYPE_INDEX_TYPE (type
);
3186 /* Only re-evaluate the right hand side if the resulting type
3187 is a variable length type. */
3188 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3190 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3191 return value_from_longest
3192 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3201 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3202 type
= value_type (val
);
3206 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3207 "When applied to a reference or a reference type, the result is
3208 the size of the referenced type." */
3209 type
= check_typedef (type
);
3210 if (exp
->language_defn
->la_language
== language_cplus
3211 && (TYPE_IS_REFERENCE (type
)))
3212 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3213 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3216 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3217 for that subexpression cast to TO_TYPE. Advance *POS over the
3221 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3223 struct type
*to_type
)
3227 /* Don't let symbols be evaluated with evaluate_subexp because that
3228 throws an "unknown type" error for no-debug data symbols.
3229 Instead, we want the cast to reinterpret the symbol. */
3230 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3231 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3236 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3238 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3239 return value_zero (to_type
, not_lval
);
3241 val
= evaluate_var_msym_value (noside
,
3242 exp
->elts
[pc
+ 1].objfile
,
3243 exp
->elts
[pc
+ 2].msymbol
);
3246 val
= evaluate_var_value (noside
,
3247 exp
->elts
[pc
+ 1].block
,
3248 exp
->elts
[pc
+ 2].symbol
);
3250 if (noside
== EVAL_SKIP
)
3251 return eval_skip_value (exp
);
3253 val
= value_cast (to_type
, val
);
3255 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3256 if (VALUE_LVAL (val
) == lval_memory
)
3258 if (value_lazy (val
))
3259 value_fetch_lazy (val
);
3260 VALUE_LVAL (val
) = not_lval
;
3265 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3266 if (noside
== EVAL_SKIP
)
3267 return eval_skip_value (exp
);
3268 return value_cast (to_type
, val
);
3271 /* Parse a type expression in the string [P..P+LENGTH). */
3274 parse_and_eval_type (char *p
, int length
)
3276 char *tmp
= (char *) alloca (length
+ 4);
3279 memcpy (tmp
+ 1, p
, length
);
3280 tmp
[length
+ 1] = ')';
3281 tmp
[length
+ 2] = '0';
3282 tmp
[length
+ 3] = '\0';
3283 expression_up expr
= parse_expression (tmp
);
3284 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3285 error (_("Internal error in eval_type."));
3286 return expr
->elts
[1].type
;
3290 calc_f77_array_dims (struct type
*array_type
)
3293 struct type
*tmp_type
;
3295 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3296 error (_("Can't get dimensions for a non-array type"));
3298 tmp_type
= array_type
;
3300 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3302 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)