1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
27 #include "expression.h"
30 #include "language.h" /* For CAST_IS_CONVERSION */
31 #include "f-lang.h" /* for array bound stuff */
34 #include "objc-lang.h"
36 #include "parser-defs.h"
37 #include "cp-support.h"
39 #include "exceptions.h"
41 #include "user-regs.h"
43 #include "gdb_assert.h"
45 /* This is defined in valops.c */
46 extern int overload_resolution
;
48 /* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
49 on with successful lookup for member/method of the rtti type. */
50 extern int objectprint
;
52 /* Prototypes for local functions. */
54 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
56 static struct value
*evaluate_subexp_for_address (struct expression
*,
59 static struct value
*evaluate_subexp (struct type
*, struct expression
*,
62 static char *get_label (struct expression
*, int *);
64 static struct value
*evaluate_struct_tuple (struct value
*,
65 struct expression
*, int *,
68 static LONGEST
init_array_element (struct value
*, struct value
*,
69 struct expression
*, int *, enum noside
,
73 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
74 int *pos
, enum noside noside
)
76 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
77 (expect_type
, exp
, pos
, noside
);
80 /* Parse the string EXP as a C expression, evaluate it,
81 and return the result as a number. */
84 parse_and_eval_address (char *exp
)
86 struct expression
*expr
= parse_expression (exp
);
88 struct cleanup
*old_chain
=
89 make_cleanup (free_current_contents
, &expr
);
91 addr
= value_as_address (evaluate_expression (expr
));
92 do_cleanups (old_chain
);
96 /* Like parse_and_eval_address but takes a pointer to a char * variable
97 and advanced that variable across the characters parsed. */
100 parse_and_eval_address_1 (char **expptr
)
102 struct expression
*expr
= parse_exp_1 (expptr
, (struct block
*) 0, 0);
104 struct cleanup
*old_chain
=
105 make_cleanup (free_current_contents
, &expr
);
107 addr
= value_as_address (evaluate_expression (expr
));
108 do_cleanups (old_chain
);
112 /* Like parse_and_eval_address, but treats the value of the expression
113 as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
115 parse_and_eval_long (char *exp
)
117 struct expression
*expr
= parse_expression (exp
);
119 struct cleanup
*old_chain
=
120 make_cleanup (free_current_contents
, &expr
);
122 retval
= value_as_long (evaluate_expression (expr
));
123 do_cleanups (old_chain
);
128 parse_and_eval (char *exp
)
130 struct expression
*expr
= parse_expression (exp
);
132 struct cleanup
*old_chain
=
133 make_cleanup (free_current_contents
, &expr
);
135 val
= evaluate_expression (expr
);
136 do_cleanups (old_chain
);
140 /* Parse up to a comma (or to a closeparen)
141 in the string EXPP as an expression, evaluate it, and return the value.
142 EXPP is advanced to point to the comma. */
145 parse_to_comma_and_eval (char **expp
)
147 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
149 struct cleanup
*old_chain
=
150 make_cleanup (free_current_contents
, &expr
);
152 val
= evaluate_expression (expr
);
153 do_cleanups (old_chain
);
157 /* Evaluate an expression in internal prefix form
158 such as is constructed by parse.y.
160 See expression.h for info on the format of an expression. */
163 evaluate_expression (struct expression
*exp
)
166 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
169 /* Evaluate an expression, avoiding all memory references
170 and getting a value whose type alone is correct. */
173 evaluate_type (struct expression
*exp
)
176 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
179 /* Evaluate a subexpression, avoiding all memory references and
180 getting a value whose type alone is correct. */
183 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
185 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
188 /* Extract a field operation from an expression. If the subexpression
189 of EXP starting at *SUBEXP is not a structure dereference
190 operation, return NULL. Otherwise, return the name of the
191 dereferenced field, and advance *SUBEXP to point to the
192 subexpression of the left-hand-side of the dereference. This is
193 used when completing field names. */
196 extract_field_op (struct expression
*exp
, int *subexp
)
200 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
201 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
203 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
204 result
= &exp
->elts
[*subexp
+ 2].string
;
205 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
209 /* If the next expression is an OP_LABELED, skips past it,
210 returning the label. Otherwise, does nothing and returns NULL. */
213 get_label (struct expression
*exp
, int *pos
)
215 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
218 char *name
= &exp
->elts
[pc
+ 2].string
;
219 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
220 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
227 /* This function evaluates tuples (in (the deleted) Chill) or
228 brace-initializers (in C/C++) for structure types. */
230 static struct value
*
231 evaluate_struct_tuple (struct value
*struct_val
,
232 struct expression
*exp
,
233 int *pos
, enum noside noside
, int nargs
)
235 struct type
*struct_type
= check_typedef (value_type (struct_val
));
236 struct type
*substruct_type
= struct_type
;
237 struct type
*field_type
;
244 struct value
*val
= NULL
;
249 /* Skip past the labels, and count them. */
250 while (get_label (exp
, pos
) != NULL
)
255 char *label
= get_label (exp
, &pc
);
258 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
261 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
262 if (field_name
!= NULL
&& strcmp (field_name
, label
) == 0)
265 subfieldno
= fieldno
;
266 substruct_type
= struct_type
;
270 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
273 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
274 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
275 if ((field_name
== 0 || *field_name
== '\0')
276 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
279 for (; variantno
< TYPE_NFIELDS (field_type
);
283 = TYPE_FIELD_TYPE (field_type
, variantno
);
284 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
287 subfieldno
< TYPE_NFIELDS (substruct_type
);
290 if (strcmp(TYPE_FIELD_NAME (substruct_type
,
301 error (_("there is no field named %s"), label
);
307 /* Unlabelled tuple element - go to next field. */
311 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
314 substruct_type
= struct_type
;
320 /* Skip static fields. */
321 while (fieldno
< TYPE_NFIELDS (struct_type
)
322 && field_is_static (&TYPE_FIELD (struct_type
,
325 subfieldno
= fieldno
;
326 if (fieldno
>= TYPE_NFIELDS (struct_type
))
327 error (_("too many initializers"));
328 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
329 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
330 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
331 error (_("don't know which variant you want to set"));
335 /* Here, struct_type is the type of the inner struct,
336 while substruct_type is the type of the inner struct.
337 These are the same for normal structures, but a variant struct
338 contains anonymous union fields that contain substruct fields.
339 The value fieldno is the index of the top-level (normal or
340 anonymous union) field in struct_field, while the value
341 subfieldno is the index of the actual real (named inner) field
342 in substruct_type. */
344 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
346 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
348 /* Now actually set the field in struct_val. */
350 /* Assign val to field fieldno. */
351 if (value_type (val
) != field_type
)
352 val
= value_cast (field_type
, val
);
354 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
355 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
357 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
358 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
360 modify_field (addr
, value_as_long (val
),
361 bitpos
% 8, bitsize
);
363 memcpy (addr
, value_contents (val
),
364 TYPE_LENGTH (value_type (val
)));
366 while (--nlabels
> 0);
371 /* Recursive helper function for setting elements of array tuples for
372 (the deleted) Chill. The target is ARRAY (which has bounds
373 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
374 and NOSIDE are as usual. Evaluates index expresions and sets the
375 specified element(s) of ARRAY to ELEMENT. Returns last index
379 init_array_element (struct value
*array
, struct value
*element
,
380 struct expression
*exp
, int *pos
,
381 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
384 int element_size
= TYPE_LENGTH (value_type (element
));
385 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
388 init_array_element (array
, element
, exp
, pos
, noside
,
389 low_bound
, high_bound
);
390 return init_array_element (array
, element
,
391 exp
, pos
, noside
, low_bound
, high_bound
);
393 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
397 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
398 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
399 if (low
< low_bound
|| high
> high_bound
)
400 error (_("tuple range index out of range"));
401 for (index
= low
; index
<= high
; index
++)
403 memcpy (value_contents_raw (array
)
404 + (index
- low_bound
) * element_size
,
405 value_contents (element
), element_size
);
410 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
411 if (index
< low_bound
|| index
> high_bound
)
412 error (_("tuple index out of range"));
413 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
414 value_contents (element
), element_size
);
420 value_f90_subarray (struct value
*array
,
421 struct expression
*exp
, int *pos
, enum noside noside
)
424 LONGEST low_bound
, high_bound
;
425 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
426 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
430 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
431 low_bound
= TYPE_LOW_BOUND (range
);
433 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
435 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
436 high_bound
= TYPE_HIGH_BOUND (range
);
438 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
440 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
444 /* Promote value ARG1 as appropriate before performing a unary operation
446 If the result is not appropriate for any particular language then it
447 needs to patch this function. */
450 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
455 *arg1
= coerce_ref (*arg1
);
456 type1
= check_typedef (value_type (*arg1
));
458 if (is_integral_type (type1
))
460 switch (language
->la_language
)
463 /* Perform integral promotion for ANSI C/C++.
464 If not appropropriate for any particular language
465 it needs to modify this function. */
467 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
468 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
469 *arg1
= value_cast (builtin_int
, *arg1
);
476 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
477 operation on those two operands.
478 If the result is not appropriate for any particular language then it
479 needs to patch this function. */
482 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
483 struct value
**arg1
, struct value
**arg2
)
485 struct type
*promoted_type
= NULL
;
489 *arg1
= coerce_ref (*arg1
);
490 *arg2
= coerce_ref (*arg2
);
492 type1
= check_typedef (value_type (*arg1
));
493 type2
= check_typedef (value_type (*arg2
));
495 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
496 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
497 && !is_integral_type (type1
))
498 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
499 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
500 && !is_integral_type (type2
)))
503 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
504 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
506 /* No promotion required. */
508 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
509 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
511 switch (language
->la_language
)
517 /* No promotion required. */
521 /* For other languages the result type is unchanged from gdb
522 version 6.7 for backward compatibility.
523 If either arg was long double, make sure that value is also long
524 double. Otherwise use double. */
525 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
526 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
527 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
529 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
533 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
534 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
536 /* No promotion required. */
539 /* Integral operations here. */
540 /* FIXME: Also mixed integral/booleans, with result an integer. */
542 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
543 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
544 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
545 int is_unsigned1
= TYPE_UNSIGNED (type1
);
546 int is_unsigned2
= TYPE_UNSIGNED (type2
);
547 unsigned int result_len
;
548 int unsigned_operation
;
550 /* Determine type length and signedness after promotion for
552 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
555 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
557 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
560 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
563 if (promoted_len1
> promoted_len2
)
565 unsigned_operation
= is_unsigned1
;
566 result_len
= promoted_len1
;
568 else if (promoted_len2
> promoted_len1
)
570 unsigned_operation
= is_unsigned2
;
571 result_len
= promoted_len2
;
575 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
576 result_len
= promoted_len1
;
579 switch (language
->la_language
)
585 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
587 promoted_type
= (unsigned_operation
588 ? builtin
->builtin_unsigned_int
589 : builtin
->builtin_int
);
591 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
593 promoted_type
= (unsigned_operation
594 ? builtin
->builtin_unsigned_long
595 : builtin
->builtin_long
);
599 promoted_type
= (unsigned_operation
600 ? builtin
->builtin_unsigned_long_long
601 : builtin
->builtin_long_long
);
606 /* For other languages the result type is unchanged from gdb
607 version 6.7 for backward compatibility.
608 If either arg was long long, make sure that value is also long
609 long. Otherwise use long. */
610 if (unsigned_operation
)
612 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
613 promoted_type
= builtin
->builtin_unsigned_long_long
;
615 promoted_type
= builtin
->builtin_unsigned_long
;
619 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
620 promoted_type
= builtin
->builtin_long_long
;
622 promoted_type
= builtin
->builtin_long
;
630 /* Promote both operands to common type. */
631 *arg1
= value_cast (promoted_type
, *arg1
);
632 *arg2
= value_cast (promoted_type
, *arg2
);
637 ptrmath_type_p (struct type
*type
)
639 type
= check_typedef (type
);
640 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
641 type
= TYPE_TARGET_TYPE (type
);
643 switch (TYPE_CODE (type
))
649 case TYPE_CODE_ARRAY
:
650 return current_language
->c_style_arrays
;
658 evaluate_subexp_standard (struct type
*expect_type
,
659 struct expression
*exp
, int *pos
,
664 int pc
, pc2
= 0, oldpos
;
665 struct value
*arg1
= NULL
;
666 struct value
*arg2
= NULL
;
670 struct value
**argvec
;
671 int upper
, lower
, retcode
;
675 struct type
**arg_types
;
679 op
= exp
->elts
[pc
].opcode
;
684 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
685 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
686 if (noside
== EVAL_SKIP
)
688 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
689 &exp
->elts
[pc
+ 3].string
,
692 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
697 return value_from_longest (exp
->elts
[pc
+ 1].type
,
698 exp
->elts
[pc
+ 2].longconst
);
702 return value_from_double (exp
->elts
[pc
+ 1].type
,
703 exp
->elts
[pc
+ 2].doubleconst
);
707 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
708 exp
->elts
[pc
+ 2].decfloatconst
);
712 if (noside
== EVAL_SKIP
)
715 /* JYG: We used to just return value_zero of the symbol type
716 if we're asked to avoid side effects. Otherwise we return
717 value_of_variable (...). However I'm not sure if
718 value_of_variable () has any side effect.
719 We need a full value object returned here for whatis_exp ()
720 to call evaluate_type () and then pass the full value to
721 value_rtti_target_type () if we are dealing with a pointer
722 or reference to a base class and print object is on. */
725 volatile struct gdb_exception except
;
726 struct value
*ret
= NULL
;
728 TRY_CATCH (except
, RETURN_MASK_ERROR
)
730 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
731 exp
->elts
[pc
+ 1].block
);
734 if (except
.reason
< 0)
736 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
737 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
), not_lval
);
739 throw_exception (except
);
748 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
752 const char *name
= &exp
->elts
[pc
+ 2].string
;
756 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
757 regno
= user_reg_map_name_to_regnum (current_gdbarch
,
758 name
, strlen (name
));
760 error (_("Register $%s not available."), name
);
762 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
763 a value with the appropriate register type. Unfortunately,
764 we don't have easy access to the type of user registers.
765 So for these registers, we fetch the register value regardless
766 of the evaluation mode. */
767 if (noside
== EVAL_AVOID_SIDE_EFFECTS
768 && regno
< gdbarch_num_regs (current_gdbarch
)
769 + gdbarch_num_pseudo_regs (current_gdbarch
))
770 val
= value_zero (register_type (current_gdbarch
, regno
), not_lval
);
772 val
= value_of_register (regno
, get_selected_frame (NULL
));
774 error (_("Value of register %s not available."), name
);
780 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
781 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
785 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
788 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
789 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
790 if (noside
== EVAL_SKIP
)
792 return value_string (&exp
->elts
[pc
+ 2].string
, tem
);
794 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
795 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
796 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
797 if (noside
== EVAL_SKIP
)
801 return (struct value
*) value_nsstring (&exp
->elts
[pc
+ 2].string
, tem
+ 1);
804 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
806 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
807 if (noside
== EVAL_SKIP
)
809 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
814 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
815 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
816 nargs
= tem3
- tem2
+ 1;
817 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
819 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
820 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
822 struct value
*rec
= allocate_value (expect_type
);
823 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
824 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
827 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
828 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
830 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
831 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
832 struct value
*array
= allocate_value (expect_type
);
833 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
834 LONGEST low_bound
, high_bound
, index
;
835 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
838 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
841 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
842 for (tem
= nargs
; --nargs
>= 0;)
844 struct value
*element
;
846 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
849 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
851 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
852 if (value_type (element
) != element_type
)
853 element
= value_cast (element_type
, element
);
856 int continue_pc
= *pos
;
858 index
= init_array_element (array
, element
, exp
, pos
, noside
,
859 low_bound
, high_bound
);
864 if (index
> high_bound
)
865 /* to avoid memory corruption */
866 error (_("Too many array elements"));
867 memcpy (value_contents_raw (array
)
868 + (index
- low_bound
) * element_size
,
869 value_contents (element
),
877 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
878 && TYPE_CODE (type
) == TYPE_CODE_SET
)
880 struct value
*set
= allocate_value (expect_type
);
881 gdb_byte
*valaddr
= value_contents_raw (set
);
882 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
883 struct type
*check_type
= element_type
;
884 LONGEST low_bound
, high_bound
;
886 /* get targettype of elementtype */
887 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
||
888 TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
889 check_type
= TYPE_TARGET_TYPE (check_type
);
891 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
892 error (_("(power)set type with unknown size"));
893 memset (valaddr
, '\0', TYPE_LENGTH (type
));
894 for (tem
= 0; tem
< nargs
; tem
++)
896 LONGEST range_low
, range_high
;
897 struct type
*range_low_type
, *range_high_type
;
898 struct value
*elem_val
;
899 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
902 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
903 range_low_type
= value_type (elem_val
);
904 range_low
= value_as_long (elem_val
);
905 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
906 range_high_type
= value_type (elem_val
);
907 range_high
= value_as_long (elem_val
);
911 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
912 range_low_type
= range_high_type
= value_type (elem_val
);
913 range_low
= range_high
= value_as_long (elem_val
);
915 /* check types of elements to avoid mixture of elements from
916 different types. Also check if type of element is "compatible"
917 with element type of powerset */
918 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
919 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
920 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
921 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
922 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
)) ||
923 (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
&&
924 (range_low_type
!= range_high_type
)))
925 /* different element modes */
926 error (_("POWERSET tuple elements of different mode"));
927 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
)) ||
928 (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
&&
929 range_low_type
!= check_type
))
930 error (_("incompatible POWERSET tuple elements"));
931 if (range_low
> range_high
)
933 warning (_("empty POWERSET tuple range"));
936 if (range_low
< low_bound
|| range_high
> high_bound
)
937 error (_("POWERSET tuple element out of range"));
938 range_low
-= low_bound
;
939 range_high
-= low_bound
;
940 for (; range_low
<= range_high
; range_low
++)
942 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
943 if (gdbarch_bits_big_endian (current_gdbarch
))
944 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
945 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
952 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
953 for (tem
= 0; tem
< nargs
; tem
++)
955 /* Ensure that array expressions are coerced into pointer objects. */
956 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
958 if (noside
== EVAL_SKIP
)
960 return value_array (tem2
, tem3
, argvec
);
964 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
966 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
968 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
969 if (noside
== EVAL_SKIP
)
971 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
974 case TERNOP_SLICE_COUNT
:
976 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
978 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
980 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
981 return value_slice (array
, lowbound
, length
);
985 /* Skip third and second args to evaluate the first one. */
986 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
987 if (value_logical_not (arg1
))
989 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
990 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
994 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
995 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
999 case OP_OBJC_SELECTOR
:
1000 { /* Objective C @selector operator. */
1001 char *sel
= &exp
->elts
[pc
+ 2].string
;
1002 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1003 struct type
*selector_type
;
1005 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1006 if (noside
== EVAL_SKIP
)
1010 sel
[len
] = 0; /* Make sure it's terminated. */
1012 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1013 return value_from_longest (selector_type
, lookup_child_selector (sel
));
1016 case OP_OBJC_MSGCALL
:
1017 { /* Objective C message (method) call. */
1019 static CORE_ADDR responds_selector
= 0;
1020 static CORE_ADDR method_selector
= 0;
1022 CORE_ADDR selector
= 0;
1024 int struct_return
= 0;
1025 int sub_no_side
= 0;
1027 static struct value
*msg_send
= NULL
;
1028 static struct value
*msg_send_stret
= NULL
;
1029 static int gnu_runtime
= 0;
1031 struct value
*target
= NULL
;
1032 struct value
*method
= NULL
;
1033 struct value
*called_method
= NULL
;
1035 struct type
*selector_type
= NULL
;
1036 struct type
*long_type
;
1038 struct value
*ret
= NULL
;
1041 selector
= exp
->elts
[pc
+ 1].longconst
;
1042 nargs
= exp
->elts
[pc
+ 2].longconst
;
1043 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1048 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1049 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1051 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1052 sub_no_side
= EVAL_NORMAL
;
1054 sub_no_side
= noside
;
1056 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1058 if (value_as_long (target
) == 0)
1059 return value_from_longest (long_type
, 0);
1061 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1064 /* Find the method dispatch (Apple runtime) or method lookup
1065 (GNU runtime) function for Objective-C. These will be used
1066 to lookup the symbol information for the method. If we
1067 can't find any symbol information, then we'll use these to
1068 call the method, otherwise we can call the method
1069 directly. The msg_send_stret function is used in the special
1070 case of a method that returns a structure (Apple runtime
1074 struct type
*type
= selector_type
;
1075 type
= lookup_function_type (type
);
1076 type
= lookup_pointer_type (type
);
1077 type
= lookup_function_type (type
);
1078 type
= lookup_pointer_type (type
);
1080 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1082 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1084 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1085 msg_send_stret
= value_from_pointer (type
,
1086 value_as_address (msg_send_stret
));
1090 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1091 /* Special dispatcher for methods returning structs */
1093 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1096 /* Verify the target object responds to this method. The
1097 standard top-level 'Object' class uses a different name for
1098 the verification method than the non-standard, but more
1099 often used, 'NSObject' class. Make sure we check for both. */
1101 responds_selector
= lookup_child_selector ("respondsToSelector:");
1102 if (responds_selector
== 0)
1103 responds_selector
= lookup_child_selector ("respondsTo:");
1105 if (responds_selector
== 0)
1106 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1108 method_selector
= lookup_child_selector ("methodForSelector:");
1109 if (method_selector
== 0)
1110 method_selector
= lookup_child_selector ("methodFor:");
1112 if (method_selector
== 0)
1113 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1115 /* Call the verification method, to make sure that the target
1116 class implements the desired method. */
1118 argvec
[0] = msg_send
;
1120 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1121 argvec
[3] = value_from_longest (long_type
, selector
);
1124 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1127 /* Function objc_msg_lookup returns a pointer. */
1129 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1131 if (value_as_long (ret
) == 0)
1132 error (_("Target does not respond to this message selector."));
1134 /* Call "methodForSelector:" method, to get the address of a
1135 function method that implements this selector for this
1136 class. If we can find a symbol at that address, then we
1137 know the return type, parameter types etc. (that's a good
1140 argvec
[0] = msg_send
;
1142 argvec
[2] = value_from_longest (long_type
, method_selector
);
1143 argvec
[3] = value_from_longest (long_type
, selector
);
1146 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1150 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1153 /* ret should now be the selector. */
1155 addr
= value_as_long (ret
);
1158 struct symbol
*sym
= NULL
;
1159 /* Is it a high_level symbol? */
1161 sym
= find_pc_function (addr
);
1163 method
= value_of_variable (sym
, 0);
1166 /* If we found a method with symbol information, check to see
1167 if it returns a struct. Otherwise assume it doesn't. */
1173 struct type
*val_type
;
1175 funaddr
= find_function_addr (method
, &val_type
);
1177 b
= block_for_pc (funaddr
);
1179 CHECK_TYPEDEF (val_type
);
1181 if ((val_type
== NULL
)
1182 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1184 if (expect_type
!= NULL
)
1185 val_type
= expect_type
;
1188 struct_return
= using_struct_return (value_type (method
), val_type
);
1190 else if (expect_type
!= NULL
)
1192 struct_return
= using_struct_return (NULL
,
1193 check_typedef (expect_type
));
1196 /* Found a function symbol. Now we will substitute its
1197 value in place of the message dispatcher (obj_msgSend),
1198 so that we call the method directly instead of thru
1199 the dispatcher. The main reason for doing this is that
1200 we can now evaluate the return value and parameter values
1201 according to their known data types, in case we need to
1202 do things like promotion, dereferencing, special handling
1203 of structs and doubles, etc.
1205 We want to use the type signature of 'method', but still
1206 jump to objc_msgSend() or objc_msgSend_stret() to better
1207 mimic the behavior of the runtime. */
1211 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1212 error (_("method address has symbol information with non-function type; skipping"));
1214 VALUE_ADDRESS (method
) = value_as_address (msg_send_stret
);
1216 VALUE_ADDRESS (method
) = value_as_address (msg_send
);
1217 called_method
= method
;
1222 called_method
= msg_send_stret
;
1224 called_method
= msg_send
;
1227 if (noside
== EVAL_SKIP
)
1230 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1232 /* If the return type doesn't look like a function type,
1233 call an error. This can happen if somebody tries to
1234 turn a variable into a function call. This is here
1235 because people often want to call, eg, strcmp, which
1236 gdb doesn't know is a function. If gdb isn't asked for
1237 it's opinion (ie. through "whatis"), it won't offer
1240 struct type
*type
= value_type (called_method
);
1241 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1242 type
= TYPE_TARGET_TYPE (type
);
1243 type
= TYPE_TARGET_TYPE (type
);
1247 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1248 return allocate_value (expect_type
);
1250 return allocate_value (type
);
1253 error (_("Expression of type other than \"method returning ...\" used as a method"));
1256 /* Now depending on whether we found a symbol for the method,
1257 we will either call the runtime dispatcher or the method
1260 argvec
[0] = called_method
;
1262 argvec
[2] = value_from_longest (long_type
, selector
);
1263 /* User-supplied arguments. */
1264 for (tem
= 0; tem
< nargs
; tem
++)
1265 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1266 argvec
[tem
+ 3] = 0;
1268 if (gnu_runtime
&& (method
!= NULL
))
1270 /* Function objc_msg_lookup returns a pointer. */
1271 deprecated_set_value_type (argvec
[0],
1272 lookup_function_type (lookup_pointer_type (value_type (argvec
[0]))));
1273 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1276 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1283 op
= exp
->elts
[*pos
].opcode
;
1284 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1285 /* Allocate arg vector, including space for the function to be
1286 called in argvec[0] and a terminating NULL */
1287 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1288 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1291 /* First, evaluate the structure into arg2 */
1294 if (noside
== EVAL_SKIP
)
1297 if (op
== STRUCTOP_MEMBER
)
1299 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1303 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1306 /* If the function is a virtual function, then the
1307 aggregate value (providing the structure) plays
1308 its part by providing the vtable. Otherwise,
1309 it is just along for the ride: call the function
1312 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1314 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1315 != TYPE_CODE_METHODPTR
)
1316 error (_("Non-pointer-to-member value used in pointer-to-member "
1319 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1321 struct type
*method_type
= check_typedef (value_type (arg1
));
1322 arg1
= value_zero (method_type
, not_lval
);
1325 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1327 /* Now, say which argument to start evaluating from */
1330 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1332 /* Hair for method invocations */
1336 /* First, evaluate the structure into arg2 */
1338 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1339 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1340 if (noside
== EVAL_SKIP
)
1343 if (op
== STRUCTOP_STRUCT
)
1345 /* If v is a variable in a register, and the user types
1346 v.method (), this will produce an error, because v has
1349 A possible way around this would be to allocate a
1350 copy of the variable on the stack, copy in the
1351 contents, call the function, and copy out the
1352 contents. I.e. convert this from call by reference
1353 to call by copy-return (or whatever it's called).
1354 However, this does not work because it is not the
1355 same: the method being called could stash a copy of
1356 the address, and then future uses through that address
1357 (after the method returns) would be expected to
1358 use the variable itself, not some copy of it. */
1359 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1363 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1365 /* Now, say which argument to start evaluating from */
1370 /* Non-method function call */
1372 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1374 type
= value_type (argvec
[0]);
1375 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1376 type
= TYPE_TARGET_TYPE (type
);
1377 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1379 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1381 /* pai: FIXME This seems to be coercing arguments before
1382 * overload resolution has been done! */
1383 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1389 /* Evaluate arguments */
1390 for (; tem
<= nargs
; tem
++)
1392 /* Ensure that array expressions are coerced into pointer objects. */
1393 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1396 /* signal end of arglist */
1399 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1401 int static_memfuncp
;
1404 /* Method invocation : stuff "this" as first parameter */
1406 /* Name of method from expression */
1407 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1409 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1411 /* Language is C++, do some overload resolution before evaluation */
1412 struct value
*valp
= NULL
;
1414 /* Prepare list of argument types for overload resolution */
1415 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1416 for (ix
= 1; ix
<= nargs
; ix
++)
1417 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1419 (void) find_overload_match (arg_types
, nargs
, tstr
,
1420 1 /* method */ , 0 /* strict match */ ,
1421 &arg2
/* the object */ , NULL
,
1422 &valp
, NULL
, &static_memfuncp
);
1425 argvec
[1] = arg2
; /* the ``this'' pointer */
1426 argvec
[0] = valp
; /* use the method found after overload resolution */
1429 /* Non-C++ case -- or no overload resolution */
1431 struct value
*temp
= arg2
;
1432 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1434 op
== STRUCTOP_STRUCT
1435 ? "structure" : "structure pointer");
1436 /* value_struct_elt updates temp with the correct value
1437 of the ``this'' pointer if necessary, so modify argvec[1] to
1438 reflect any ``this'' changes. */
1439 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1440 VALUE_ADDRESS (temp
) + value_offset (temp
)
1441 + value_embedded_offset (temp
));
1442 argvec
[1] = arg2
; /* the ``this'' pointer */
1445 if (static_memfuncp
)
1447 argvec
[1] = argvec
[0];
1452 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1457 else if (op
== OP_VAR_VALUE
)
1459 /* Non-member function being called */
1460 /* fn: This can only be done for C++ functions. A C-style function
1461 in a C++ program, for instance, does not have the fields that
1462 are expected here */
1464 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1466 /* Language is C++, do some overload resolution before evaluation */
1467 struct symbol
*symp
;
1469 /* Prepare list of argument types for overload resolution */
1470 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1471 for (ix
= 1; ix
<= nargs
; ix
++)
1472 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1474 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1475 0 /* not method */ , 0 /* strict match */ ,
1476 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1479 /* Now fix the expression being evaluated */
1480 exp
->elts
[save_pos1
+2].symbol
= symp
;
1481 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1485 /* Not C++, or no overload resolution allowed */
1486 /* nothing to be done; argvec already correctly set up */
1491 /* It is probably a C-style function */
1492 /* nothing to be done; argvec already correctly set up */
1497 if (noside
== EVAL_SKIP
)
1499 if (argvec
[0] == NULL
)
1500 error (_("Cannot evaluate function -- may be inlined"));
1501 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1503 /* If the return type doesn't look like a function type, call an
1504 error. This can happen if somebody tries to turn a variable into
1505 a function call. This is here because people often want to
1506 call, eg, strcmp, which gdb doesn't know is a function. If
1507 gdb isn't asked for it's opinion (ie. through "whatis"),
1508 it won't offer it. */
1510 struct type
*ftype
=
1511 TYPE_TARGET_TYPE (value_type (argvec
[0]));
1514 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec
[0])));
1516 error (_("Expression of type other than \"Function returning ...\" used as function"));
1518 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1519 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1521 case OP_F77_UNDETERMINED_ARGLIST
:
1523 /* Remember that in F77, functions, substring ops and
1524 array subscript operations cannot be disambiguated
1525 at parse time. We have made all array subscript operations,
1526 substring operations as well as function calls come here
1527 and we now have to discover what the heck this thing actually was.
1528 If it is a function, we process just as if we got an OP_FUNCALL. */
1530 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1533 /* First determine the type code we are dealing with. */
1534 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1535 type
= check_typedef (value_type (arg1
));
1536 code
= TYPE_CODE (type
);
1538 if (code
== TYPE_CODE_PTR
)
1540 /* Fortran always passes variable to subroutines as pointer.
1541 So we need to look into its target type to see if it is
1542 array, string or function. If it is, we need to switch
1543 to the target value the original one points to. */
1544 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1546 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1547 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1548 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1550 arg1
= value_ind (arg1
);
1551 type
= check_typedef (value_type (arg1
));
1552 code
= TYPE_CODE (type
);
1558 case TYPE_CODE_ARRAY
:
1559 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1560 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1562 goto multi_f77_subscript
;
1564 case TYPE_CODE_STRING
:
1565 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1566 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1569 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1570 return value_subscript (arg1
, arg2
);
1574 case TYPE_CODE_FUNC
:
1575 /* It's a function call. */
1576 /* Allocate arg vector, including space for the function to be
1577 called in argvec[0] and a terminating NULL */
1578 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1581 for (; tem
<= nargs
; tem
++)
1582 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1583 argvec
[tem
] = 0; /* signal end of arglist */
1587 error (_("Cannot perform substring on this type"));
1591 /* We have a complex number, There should be 2 floating
1592 point numbers that compose it */
1594 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1595 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1597 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1599 case STRUCTOP_STRUCT
:
1600 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1601 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1602 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1603 if (noside
== EVAL_SKIP
)
1605 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1606 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1607 &exp
->elts
[pc
+ 2].string
,
1612 struct value
*temp
= arg1
;
1613 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1618 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1619 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1620 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1621 if (noside
== EVAL_SKIP
)
1624 /* JYG: if print object is on we need to replace the base type
1625 with rtti type in order to continue on with successful
1626 lookup of member / method only available in the rtti type. */
1628 struct type
*type
= value_type (arg1
);
1629 struct type
*real_type
;
1630 int full
, top
, using_enc
;
1632 if (objectprint
&& TYPE_TARGET_TYPE(type
) &&
1633 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1635 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1638 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1639 real_type
= lookup_pointer_type (real_type
);
1641 real_type
= lookup_reference_type (real_type
);
1643 arg1
= value_cast (real_type
, arg1
);
1648 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1649 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1650 &exp
->elts
[pc
+ 2].string
,
1655 struct value
*temp
= arg1
;
1656 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1657 NULL
, "structure pointer");
1660 case STRUCTOP_MEMBER
:
1662 if (op
== STRUCTOP_MEMBER
)
1663 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1665 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1667 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1669 if (noside
== EVAL_SKIP
)
1672 type
= check_typedef (value_type (arg2
));
1673 switch (TYPE_CODE (type
))
1675 case TYPE_CODE_METHODPTR
:
1676 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1677 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1680 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1681 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1682 return value_ind (arg2
);
1685 case TYPE_CODE_MEMBERPTR
:
1686 /* Now, convert these values to an address. */
1687 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1690 mem_offset
= value_as_long (arg2
);
1692 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1693 value_as_long (arg1
) + mem_offset
);
1694 return value_ind (arg3
);
1697 error (_("non-pointer-to-member value used in pointer-to-member construct"));
1701 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1702 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1703 if (noside
== EVAL_SKIP
)
1705 if (binop_user_defined_p (op
, arg1
, arg2
))
1706 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1708 return value_concat (arg1
, arg2
);
1711 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1712 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1714 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1716 if (binop_user_defined_p (op
, arg1
, arg2
))
1717 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1719 return value_assign (arg1
, arg2
);
1721 case BINOP_ASSIGN_MODIFY
:
1723 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1724 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1725 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1727 op
= exp
->elts
[pc
+ 1].opcode
;
1728 if (binop_user_defined_p (op
, arg1
, arg2
))
1729 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1730 else if (op
== BINOP_ADD
&& ptrmath_type_p (value_type (arg1
)))
1731 arg2
= value_ptradd (arg1
, arg2
);
1732 else if (op
== BINOP_SUB
&& ptrmath_type_p (value_type (arg1
)))
1733 arg2
= value_ptrsub (arg1
, arg2
);
1736 struct value
*tmp
= arg1
;
1738 /* For shift and integer exponentiation operations,
1739 only promote the first argument. */
1740 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1741 && is_integral_type (value_type (arg2
)))
1742 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
1744 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1746 arg2
= value_binop (tmp
, arg2
, op
);
1748 return value_assign (arg1
, arg2
);
1751 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1752 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1753 if (noside
== EVAL_SKIP
)
1755 if (binop_user_defined_p (op
, arg1
, arg2
))
1756 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1757 else if (ptrmath_type_p (value_type (arg1
)))
1758 return value_ptradd (arg1
, arg2
);
1759 else if (ptrmath_type_p (value_type (arg2
)))
1760 return value_ptradd (arg2
, arg1
);
1763 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1764 return value_binop (arg1
, arg2
, BINOP_ADD
);
1768 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1769 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1770 if (noside
== EVAL_SKIP
)
1772 if (binop_user_defined_p (op
, arg1
, arg2
))
1773 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1774 else if (ptrmath_type_p (value_type (arg1
)))
1776 if (ptrmath_type_p (value_type (arg2
)))
1778 /* FIXME -- should be ptrdiff_t */
1779 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1780 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1783 return value_ptrsub (arg1
, arg2
);
1787 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1788 return value_binop (arg1
, arg2
, BINOP_SUB
);
1799 case BINOP_BITWISE_AND
:
1800 case BINOP_BITWISE_IOR
:
1801 case BINOP_BITWISE_XOR
:
1802 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1803 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1804 if (noside
== EVAL_SKIP
)
1806 if (binop_user_defined_p (op
, arg1
, arg2
))
1807 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1810 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1811 fudge arg2 to avoid division-by-zero, the caller is
1812 (theoretically) only looking for the type of the result. */
1813 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1814 /* ??? Do we really want to test for BINOP_MOD here?
1815 The implementation of value_binop gives it a well-defined
1818 || op
== BINOP_INTDIV
1821 && value_logical_not (arg2
))
1823 struct value
*v_one
, *retval
;
1825 v_one
= value_one (value_type (arg2
), not_lval
);
1826 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1827 retval
= value_binop (arg1
, v_one
, op
);
1832 /* For shift and integer exponentiation operations,
1833 only promote the first argument. */
1834 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1835 && is_integral_type (value_type (arg2
)))
1836 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1838 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1840 return value_binop (arg1
, arg2
, op
);
1845 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1846 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1847 if (noside
== EVAL_SKIP
)
1849 error (_("':' operator used in invalid context"));
1851 case BINOP_SUBSCRIPT
:
1852 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1853 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1854 if (noside
== EVAL_SKIP
)
1856 if (binop_user_defined_p (op
, arg1
, arg2
))
1857 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1860 /* If the user attempts to subscript something that is not an
1861 array or pointer type (like a plain int variable for example),
1862 then report this as an error. */
1864 arg1
= coerce_ref (arg1
);
1865 type
= check_typedef (value_type (arg1
));
1866 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1867 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1869 if (TYPE_NAME (type
))
1870 error (_("cannot subscript something of type `%s'"),
1873 error (_("cannot subscript requested type"));
1876 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1877 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1879 return value_subscript (arg1
, arg2
);
1883 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1884 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1885 if (noside
== EVAL_SKIP
)
1887 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1888 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
1890 case MULTI_SUBSCRIPT
:
1892 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1893 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1896 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1897 /* FIXME: EVAL_SKIP handling may not be correct. */
1898 if (noside
== EVAL_SKIP
)
1909 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1910 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1912 /* If the user attempts to subscript something that has no target
1913 type (like a plain int variable for example), then report this
1916 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
1919 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1925 error (_("cannot subscript something of type `%s'"),
1926 TYPE_NAME (value_type (arg1
)));
1930 if (binop_user_defined_p (op
, arg1
, arg2
))
1932 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1936 arg1
= coerce_ref (arg1
);
1937 type
= check_typedef (value_type (arg1
));
1939 switch (TYPE_CODE (type
))
1942 case TYPE_CODE_ARRAY
:
1943 case TYPE_CODE_STRING
:
1944 arg1
= value_subscript (arg1
, arg2
);
1947 case TYPE_CODE_BITSTRING
:
1948 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1949 arg1
= value_bitstring_subscript (type
, arg1
, arg2
);
1953 if (TYPE_NAME (type
))
1954 error (_("cannot subscript something of type `%s'"),
1957 error (_("cannot subscript requested type"));
1963 multi_f77_subscript
:
1965 int subscript_array
[MAX_FORTRAN_DIMS
];
1966 int array_size_array
[MAX_FORTRAN_DIMS
];
1967 int ndimensions
= 1, i
;
1968 struct type
*tmp_type
;
1969 int offset_item
; /* The array offset where the item lives */
1971 if (nargs
> MAX_FORTRAN_DIMS
)
1972 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
1974 tmp_type
= check_typedef (value_type (arg1
));
1975 ndimensions
= calc_f77_array_dims (type
);
1977 if (nargs
!= ndimensions
)
1978 error (_("Wrong number of subscripts"));
1980 /* Now that we know we have a legal array subscript expression
1981 let us actually find out where this element exists in the array. */
1984 /* Take array indices left to right */
1985 for (i
= 0; i
< nargs
; i
++)
1987 /* Evaluate each subscript, It must be a legal integer in F77 */
1988 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1990 /* Fill in the subscript and array size arrays */
1992 subscript_array
[i
] = value_as_long (arg2
);
1995 /* Internal type of array is arranged right to left */
1996 for (i
= 0; i
< nargs
; i
++)
1998 upper
= f77_get_upperbound (tmp_type
);
1999 lower
= f77_get_lowerbound (tmp_type
);
2001 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
2003 /* Zero-normalize subscripts so that offsetting will work. */
2005 subscript_array
[nargs
- i
- 1] -= lower
;
2007 /* If we are at the bottom of a multidimensional
2008 array type then keep a ptr to the last ARRAY
2009 type around for use when calling value_subscript()
2010 below. This is done because we pretend to value_subscript
2011 that we actually have a one-dimensional array
2012 of base element type that we apply a simple
2016 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
2019 /* Now let us calculate the offset for this item */
2021 offset_item
= subscript_array
[ndimensions
- 1];
2023 for (i
= ndimensions
- 1; i
> 0; --i
)
2025 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
2027 /* Construct a value node with the value of the offset */
2029 arg2
= value_from_longest (builtin_type_int32
, offset_item
);
2031 /* Let us now play a dirty trick: we will take arg1
2032 which is a value node pointing to the topmost level
2033 of the multidimensional array-set and pretend
2034 that it is actually a array of the final element
2035 type, this will ensure that value_subscript()
2036 returns the correct type value */
2038 deprecated_set_value_type (arg1
, tmp_type
);
2039 return value_subscripted_rvalue (arg1
, arg2
, 0);
2042 case BINOP_LOGICAL_AND
:
2043 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2044 if (noside
== EVAL_SKIP
)
2046 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2051 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2054 if (binop_user_defined_p (op
, arg1
, arg2
))
2056 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2057 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2061 tem
= value_logical_not (arg1
);
2062 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2063 (tem
? EVAL_SKIP
: noside
));
2064 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2065 return value_from_longest (type
,
2066 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2069 case BINOP_LOGICAL_OR
:
2070 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2071 if (noside
== EVAL_SKIP
)
2073 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2078 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2081 if (binop_user_defined_p (op
, arg1
, arg2
))
2083 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2084 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2088 tem
= value_logical_not (arg1
);
2089 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2090 (!tem
? EVAL_SKIP
: noside
));
2091 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2092 return value_from_longest (type
,
2093 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2097 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2098 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2099 if (noside
== EVAL_SKIP
)
2101 if (binop_user_defined_p (op
, arg1
, arg2
))
2103 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2107 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2108 tem
= value_equal (arg1
, arg2
);
2109 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2110 return value_from_longest (type
, (LONGEST
) tem
);
2113 case BINOP_NOTEQUAL
:
2114 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2115 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2116 if (noside
== EVAL_SKIP
)
2118 if (binop_user_defined_p (op
, arg1
, arg2
))
2120 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2124 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2125 tem
= value_equal (arg1
, arg2
);
2126 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2127 return value_from_longest (type
, (LONGEST
) ! tem
);
2131 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2132 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2133 if (noside
== EVAL_SKIP
)
2135 if (binop_user_defined_p (op
, arg1
, arg2
))
2137 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2141 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2142 tem
= value_less (arg1
, arg2
);
2143 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2144 return value_from_longest (type
, (LONGEST
) tem
);
2148 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2149 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2150 if (noside
== EVAL_SKIP
)
2152 if (binop_user_defined_p (op
, arg1
, arg2
))
2154 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2158 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2159 tem
= value_less (arg2
, arg1
);
2160 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2161 return value_from_longest (type
, (LONGEST
) tem
);
2165 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2166 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2167 if (noside
== EVAL_SKIP
)
2169 if (binop_user_defined_p (op
, arg1
, arg2
))
2171 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2175 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2176 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2177 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2178 return value_from_longest (type
, (LONGEST
) tem
);
2182 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2183 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2184 if (noside
== EVAL_SKIP
)
2186 if (binop_user_defined_p (op
, arg1
, arg2
))
2188 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2192 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2193 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2194 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2195 return value_from_longest (type
, (LONGEST
) tem
);
2199 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2200 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2201 if (noside
== EVAL_SKIP
)
2203 type
= check_typedef (value_type (arg2
));
2204 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2205 error (_("Non-integral right operand for \"@\" operator."));
2206 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2208 return allocate_repeat_value (value_type (arg1
),
2209 longest_to_int (value_as_long (arg2
)));
2212 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2215 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2216 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2219 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2220 if (noside
== EVAL_SKIP
)
2222 if (unop_user_defined_p (op
, arg1
))
2223 return value_x_unop (arg1
, op
, noside
);
2226 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2227 return value_pos (arg1
);
2231 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2232 if (noside
== EVAL_SKIP
)
2234 if (unop_user_defined_p (op
, arg1
))
2235 return value_x_unop (arg1
, op
, noside
);
2238 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2239 return value_neg (arg1
);
2242 case UNOP_COMPLEMENT
:
2243 /* C++: check for and handle destructor names. */
2244 op
= exp
->elts
[*pos
].opcode
;
2246 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2247 if (noside
== EVAL_SKIP
)
2249 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2250 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2253 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2254 return value_complement (arg1
);
2257 case UNOP_LOGICAL_NOT
:
2258 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2259 if (noside
== EVAL_SKIP
)
2261 if (unop_user_defined_p (op
, arg1
))
2262 return value_x_unop (arg1
, op
, noside
);
2265 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2266 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2270 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2271 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2272 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2273 type
= check_typedef (value_type (arg1
));
2274 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2275 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2276 error (_("Attempt to dereference pointer to member without an object"));
2277 if (noside
== EVAL_SKIP
)
2279 if (unop_user_defined_p (op
, arg1
))
2280 return value_x_unop (arg1
, op
, noside
);
2281 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2283 type
= check_typedef (value_type (arg1
));
2284 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2285 || TYPE_CODE (type
) == TYPE_CODE_REF
2286 /* In C you can dereference an array to get the 1st elt. */
2287 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2289 return value_zero (TYPE_TARGET_TYPE (type
),
2291 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2292 /* GDB allows dereferencing an int. */
2293 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2296 error (_("Attempt to take contents of a non-pointer value."));
2299 /* Allow * on an integer so we can cast it to whatever we want.
2300 This returns an int, which seems like the most C-like thing to
2301 do. "long long" variables are rare enough that
2302 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2303 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2304 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2305 (CORE_ADDR
) value_as_address (arg1
));
2306 return value_ind (arg1
);
2309 /* C++: check for and handle pointer to members. */
2311 op
= exp
->elts
[*pos
].opcode
;
2313 if (noside
== EVAL_SKIP
)
2315 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2320 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
2325 if (noside
== EVAL_SKIP
)
2327 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2330 return evaluate_subexp_for_sizeof (exp
, pos
);
2334 type
= exp
->elts
[pc
+ 1].type
;
2335 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2336 if (noside
== EVAL_SKIP
)
2338 if (type
!= value_type (arg1
))
2339 arg1
= value_cast (type
, arg1
);
2344 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2345 if (noside
== EVAL_SKIP
)
2347 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2348 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2350 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2351 value_as_address (arg1
));
2353 case UNOP_MEMVAL_TLS
:
2355 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2356 if (noside
== EVAL_SKIP
)
2358 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2359 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2363 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2364 value_as_address (arg1
));
2365 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2368 case UNOP_PREINCREMENT
:
2369 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2370 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2372 else if (unop_user_defined_p (op
, arg1
))
2374 return value_x_unop (arg1
, op
, noside
);
2378 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2379 if (ptrmath_type_p (value_type (arg1
)))
2380 arg2
= value_ptradd (arg1
, arg2
);
2383 struct value
*tmp
= arg1
;
2384 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2385 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2388 return value_assign (arg1
, arg2
);
2391 case UNOP_PREDECREMENT
:
2392 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2393 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2395 else if (unop_user_defined_p (op
, arg1
))
2397 return value_x_unop (arg1
, op
, noside
);
2401 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2402 if (ptrmath_type_p (value_type (arg1
)))
2403 arg2
= value_ptrsub (arg1
, arg2
);
2406 struct value
*tmp
= arg1
;
2407 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2408 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2411 return value_assign (arg1
, arg2
);
2414 case UNOP_POSTINCREMENT
:
2415 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2416 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2418 else if (unop_user_defined_p (op
, arg1
))
2420 return value_x_unop (arg1
, op
, noside
);
2424 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2425 if (ptrmath_type_p (value_type (arg1
)))
2426 arg2
= value_ptradd (arg1
, arg2
);
2429 struct value
*tmp
= arg1
;
2430 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2431 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2434 value_assign (arg1
, arg2
);
2438 case UNOP_POSTDECREMENT
:
2439 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2440 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2442 else if (unop_user_defined_p (op
, arg1
))
2444 return value_x_unop (arg1
, op
, noside
);
2448 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2449 if (ptrmath_type_p (value_type (arg1
)))
2450 arg2
= value_ptrsub (arg1
, arg2
);
2453 struct value
*tmp
= arg1
;
2454 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2455 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2458 value_assign (arg1
, arg2
);
2464 return value_of_this (1);
2468 return value_of_local ("self", 1);
2471 /* The value is not supposed to be used. This is here to make it
2472 easier to accommodate expressions that contain types. */
2474 if (noside
== EVAL_SKIP
)
2476 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2477 return allocate_value (exp
->elts
[pc
+ 1].type
);
2479 error (_("Attempt to use a type name as an expression"));
2482 /* Removing this case and compiling with gcc -Wall reveals that
2483 a lot of cases are hitting this case. Some of these should
2484 probably be removed from expression.h; others are legitimate
2485 expressions which are (apparently) not fully implemented.
2487 If there are any cases landing here which mean a user error,
2488 then they should be separate cases, with more descriptive
2492 GDB does not (yet) know how to evaluate that kind of expression"));
2496 return value_from_longest (builtin_type_int8
, (LONGEST
) 1);
2499 /* Evaluate a subexpression of EXP, at index *POS,
2500 and return the address of that subexpression.
2501 Advance *POS over the subexpression.
2502 If the subexpression isn't an lvalue, get an error.
2503 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2504 then only the type of the result need be correct. */
2506 static struct value
*
2507 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2517 op
= exp
->elts
[pc
].opcode
;
2523 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2525 /* We can't optimize out "&*" if there's a user-defined operator*. */
2526 if (unop_user_defined_p (op
, x
))
2528 x
= value_x_unop (x
, op
, noside
);
2529 goto default_case_after_eval
;
2536 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2537 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2540 var
= exp
->elts
[pc
+ 2].symbol
;
2542 /* C++: The "address" of a reference should yield the address
2543 * of the object pointed to. Let value_addr() deal with it. */
2544 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2548 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2551 lookup_pointer_type (SYMBOL_TYPE (var
));
2552 enum address_class sym_class
= SYMBOL_CLASS (var
);
2554 if (sym_class
== LOC_CONST
2555 || sym_class
== LOC_CONST_BYTES
2556 || sym_class
== LOC_REGISTER
)
2557 error (_("Attempt to take address of register or constant."));
2560 value_zero (type
, not_lval
);
2562 else if (symbol_read_needs_frame (var
))
2566 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2568 return locate_var_value (var
, NULL
);
2571 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2572 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2573 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2574 &exp
->elts
[pc
+ 3].string
,
2577 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2582 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2583 default_case_after_eval
:
2584 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2586 struct type
*type
= check_typedef (value_type (x
));
2588 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2589 return value_zero (lookup_pointer_type (value_type (x
)),
2591 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2592 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2595 error (_("Attempt to take address of value not located in memory."));
2597 return value_addr (x
);
2601 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2602 When used in contexts where arrays will be coerced anyway, this is
2603 equivalent to `evaluate_subexp' but much faster because it avoids
2604 actually fetching array contents (perhaps obsolete now that we have
2607 Note that we currently only do the coercion for C expressions, where
2608 arrays are zero based and the coercion is correct. For other languages,
2609 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2610 to decide if coercion is appropriate.
2615 evaluate_subexp_with_coercion (struct expression
*exp
,
2616 int *pos
, enum noside noside
)
2624 op
= exp
->elts
[pc
].opcode
;
2629 var
= exp
->elts
[pc
+ 2].symbol
;
2630 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
2631 && CAST_IS_CONVERSION
)
2636 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2637 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var
)))),
2643 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2647 /* Evaluate a subexpression of EXP, at index *POS,
2648 and return a value for the size of that subexpression.
2649 Advance *POS over the subexpression. */
2651 static struct value
*
2652 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
2654 /* FIXME: This should be size_t. */
2655 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2662 op
= exp
->elts
[pc
].opcode
;
2666 /* This case is handled specially
2667 so that we avoid creating a value for the result type.
2668 If the result type is very big, it's desirable not to
2669 create a value unnecessarily. */
2672 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2673 type
= check_typedef (value_type (val
));
2674 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2675 && TYPE_CODE (type
) != TYPE_CODE_REF
2676 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2677 error (_("Attempt to take contents of a non-pointer value."));
2678 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2679 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2683 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2684 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2688 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2690 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2693 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2694 return value_from_longest (size_type
,
2695 (LONGEST
) TYPE_LENGTH (value_type (val
)));
2699 /* Parse a type expression in the string [P..P+LENGTH). */
2702 parse_and_eval_type (char *p
, int length
)
2704 char *tmp
= (char *) alloca (length
+ 4);
2705 struct expression
*expr
;
2707 memcpy (tmp
+ 1, p
, length
);
2708 tmp
[length
+ 1] = ')';
2709 tmp
[length
+ 2] = '0';
2710 tmp
[length
+ 3] = '\0';
2711 expr
= parse_expression (tmp
);
2712 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2713 error (_("Internal error in eval_type."));
2714 return expr
->elts
[1].type
;
2718 calc_f77_array_dims (struct type
*array_type
)
2721 struct type
*tmp_type
;
2723 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2724 error (_("Can't get dimensions for a non-array type"));
2726 tmp_type
= array_type
;
2728 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2730 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)