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 2009 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 "python/python.h"
45 #include "gdb_assert.h"
49 /* This is defined in valops.c */
50 extern int overload_resolution
;
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
);
419 static struct value
*
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 (exp
->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 (exp
->gdbarch
)
769 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
770 val
= value_zero (register_type (exp
->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_INDEX_TYPE (type
);
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 CORE_ADDR responds_selector
= 0;
1020 CORE_ADDR method_selector
= 0;
1022 CORE_ADDR selector
= 0;
1024 int struct_return
= 0;
1025 int sub_no_side
= 0;
1027 struct value
*msg_send
= NULL
;
1028 struct value
*msg_send_stret
= NULL
;
1029 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 (exp
->gdbarch
,
1189 value_type (method
), val_type
);
1191 else if (expect_type
!= NULL
)
1193 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1194 check_typedef (expect_type
));
1197 /* Found a function symbol. Now we will substitute its
1198 value in place of the message dispatcher (obj_msgSend),
1199 so that we call the method directly instead of thru
1200 the dispatcher. The main reason for doing this is that
1201 we can now evaluate the return value and parameter values
1202 according to their known data types, in case we need to
1203 do things like promotion, dereferencing, special handling
1204 of structs and doubles, etc.
1206 We want to use the type signature of 'method', but still
1207 jump to objc_msgSend() or objc_msgSend_stret() to better
1208 mimic the behavior of the runtime. */
1212 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1213 error (_("method address has symbol information with non-function type; skipping"));
1215 set_value_address (method
, value_as_address (msg_send_stret
));
1217 set_value_address (method
, value_as_address (msg_send
));
1218 called_method
= method
;
1223 called_method
= msg_send_stret
;
1225 called_method
= msg_send
;
1228 if (noside
== EVAL_SKIP
)
1231 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1233 /* If the return type doesn't look like a function type,
1234 call an error. This can happen if somebody tries to
1235 turn a variable into a function call. This is here
1236 because people often want to call, eg, strcmp, which
1237 gdb doesn't know is a function. If gdb isn't asked for
1238 it's opinion (ie. through "whatis"), it won't offer
1241 struct type
*type
= value_type (called_method
);
1242 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1243 type
= TYPE_TARGET_TYPE (type
);
1244 type
= TYPE_TARGET_TYPE (type
);
1248 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1249 return allocate_value (expect_type
);
1251 return allocate_value (type
);
1254 error (_("Expression of type other than \"method returning ...\" used as a method"));
1257 /* Now depending on whether we found a symbol for the method,
1258 we will either call the runtime dispatcher or the method
1261 argvec
[0] = called_method
;
1263 argvec
[2] = value_from_longest (long_type
, selector
);
1264 /* User-supplied arguments. */
1265 for (tem
= 0; tem
< nargs
; tem
++)
1266 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1267 argvec
[tem
+ 3] = 0;
1269 if (gnu_runtime
&& (method
!= NULL
))
1271 /* Function objc_msg_lookup returns a pointer. */
1272 deprecated_set_value_type (argvec
[0],
1273 lookup_function_type (lookup_pointer_type (value_type (argvec
[0]))));
1274 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1277 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1284 op
= exp
->elts
[*pos
].opcode
;
1285 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1286 /* Allocate arg vector, including space for the function to be
1287 called in argvec[0] and a terminating NULL */
1288 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1289 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1292 /* First, evaluate the structure into arg2 */
1295 if (noside
== EVAL_SKIP
)
1298 if (op
== STRUCTOP_MEMBER
)
1300 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1304 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1307 /* If the function is a virtual function, then the
1308 aggregate value (providing the structure) plays
1309 its part by providing the vtable. Otherwise,
1310 it is just along for the ride: call the function
1313 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1315 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1316 != TYPE_CODE_METHODPTR
)
1317 error (_("Non-pointer-to-member value used in pointer-to-member "
1320 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1322 struct type
*method_type
= check_typedef (value_type (arg1
));
1323 arg1
= value_zero (method_type
, not_lval
);
1326 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1328 /* Now, say which argument to start evaluating from */
1331 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1333 /* Hair for method invocations */
1337 /* First, evaluate the structure into arg2 */
1339 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1340 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1341 if (noside
== EVAL_SKIP
)
1344 if (op
== STRUCTOP_STRUCT
)
1346 /* If v is a variable in a register, and the user types
1347 v.method (), this will produce an error, because v has
1350 A possible way around this would be to allocate a
1351 copy of the variable on the stack, copy in the
1352 contents, call the function, and copy out the
1353 contents. I.e. convert this from call by reference
1354 to call by copy-return (or whatever it's called).
1355 However, this does not work because it is not the
1356 same: the method being called could stash a copy of
1357 the address, and then future uses through that address
1358 (after the method returns) would be expected to
1359 use the variable itself, not some copy of it. */
1360 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1364 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1366 /* Now, say which argument to start evaluating from */
1371 /* Non-method function call */
1373 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1375 type
= value_type (argvec
[0]);
1376 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1377 type
= TYPE_TARGET_TYPE (type
);
1378 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1380 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1382 /* pai: FIXME This seems to be coercing arguments before
1383 * overload resolution has been done! */
1384 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1390 /* Evaluate arguments */
1391 for (; tem
<= nargs
; tem
++)
1393 /* Ensure that array expressions are coerced into pointer objects. */
1394 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1397 /* signal end of arglist */
1400 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1402 int static_memfuncp
;
1405 /* Method invocation : stuff "this" as first parameter */
1407 /* Name of method from expression */
1408 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1410 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1412 /* Language is C++, do some overload resolution before evaluation */
1413 struct value
*valp
= NULL
;
1415 /* Prepare list of argument types for overload resolution */
1416 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1417 for (ix
= 1; ix
<= nargs
; ix
++)
1418 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1420 (void) find_overload_match (arg_types
, nargs
, tstr
,
1421 1 /* method */ , 0 /* strict match */ ,
1422 &arg2
/* the object */ , NULL
,
1423 &valp
, NULL
, &static_memfuncp
);
1426 argvec
[1] = arg2
; /* the ``this'' pointer */
1427 argvec
[0] = valp
; /* use the method found after overload resolution */
1430 /* Non-C++ case -- or no overload resolution */
1432 struct value
*temp
= arg2
;
1433 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1435 op
== STRUCTOP_STRUCT
1436 ? "structure" : "structure pointer");
1437 /* value_struct_elt updates temp with the correct value
1438 of the ``this'' pointer if necessary, so modify argvec[1] to
1439 reflect any ``this'' changes. */
1440 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1441 value_address (temp
)
1442 + value_embedded_offset (temp
));
1443 argvec
[1] = arg2
; /* the ``this'' pointer */
1446 if (static_memfuncp
)
1448 argvec
[1] = argvec
[0];
1453 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1458 else if (op
== OP_VAR_VALUE
)
1460 /* Non-member function being called */
1461 /* fn: This can only be done for C++ functions. A C-style function
1462 in a C++ program, for instance, does not have the fields that
1463 are expected here */
1465 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1467 /* Language is C++, do some overload resolution before evaluation */
1468 struct symbol
*symp
;
1470 /* Prepare list of argument types for overload resolution */
1471 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1472 for (ix
= 1; ix
<= nargs
; ix
++)
1473 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1475 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1476 0 /* not method */ , 0 /* strict match */ ,
1477 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1480 /* Now fix the expression being evaluated */
1481 exp
->elts
[save_pos1
+2].symbol
= symp
;
1482 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1486 /* Not C++, or no overload resolution allowed */
1487 /* nothing to be done; argvec already correctly set up */
1492 /* It is probably a C-style function */
1493 /* nothing to be done; argvec already correctly set up */
1498 if (noside
== EVAL_SKIP
)
1500 if (argvec
[0] == NULL
)
1501 error (_("Cannot evaluate function -- may be inlined"));
1502 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1504 /* If the return type doesn't look like a function type, call an
1505 error. This can happen if somebody tries to turn a variable into
1506 a function call. This is here because people often want to
1507 call, eg, strcmp, which gdb doesn't know is a function. If
1508 gdb isn't asked for it's opinion (ie. through "whatis"),
1509 it won't offer it. */
1511 struct type
*ftype
=
1512 TYPE_TARGET_TYPE (value_type (argvec
[0]));
1515 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec
[0])));
1517 error (_("Expression of type other than \"Function returning ...\" used as function"));
1519 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1520 return call_internal_function (argvec
[0], nargs
, argvec
+ 1);
1522 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1523 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1525 case OP_F77_UNDETERMINED_ARGLIST
:
1527 /* Remember that in F77, functions, substring ops and
1528 array subscript operations cannot be disambiguated
1529 at parse time. We have made all array subscript operations,
1530 substring operations as well as function calls come here
1531 and we now have to discover what the heck this thing actually was.
1532 If it is a function, we process just as if we got an OP_FUNCALL. */
1534 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1537 /* First determine the type code we are dealing with. */
1538 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1539 type
= check_typedef (value_type (arg1
));
1540 code
= TYPE_CODE (type
);
1542 if (code
== TYPE_CODE_PTR
)
1544 /* Fortran always passes variable to subroutines as pointer.
1545 So we need to look into its target type to see if it is
1546 array, string or function. If it is, we need to switch
1547 to the target value the original one points to. */
1548 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1550 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1551 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1552 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1554 arg1
= value_ind (arg1
);
1555 type
= check_typedef (value_type (arg1
));
1556 code
= TYPE_CODE (type
);
1562 case TYPE_CODE_ARRAY
:
1563 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1564 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1566 goto multi_f77_subscript
;
1568 case TYPE_CODE_STRING
:
1569 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1570 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1573 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1574 return value_subscript (arg1
, arg2
);
1578 case TYPE_CODE_FUNC
:
1579 /* It's a function call. */
1580 /* Allocate arg vector, including space for the function to be
1581 called in argvec[0] and a terminating NULL */
1582 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1585 for (; tem
<= nargs
; tem
++)
1586 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1587 argvec
[tem
] = 0; /* signal end of arglist */
1591 error (_("Cannot perform substring on this type"));
1595 /* We have a complex number, There should be 2 floating
1596 point numbers that compose it */
1598 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1599 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1601 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1603 case STRUCTOP_STRUCT
:
1604 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1605 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1606 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1607 if (noside
== EVAL_SKIP
)
1609 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1610 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1611 &exp
->elts
[pc
+ 2].string
,
1616 struct value
*temp
= arg1
;
1617 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1622 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1623 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1624 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1625 if (noside
== EVAL_SKIP
)
1628 /* JYG: if print object is on we need to replace the base type
1629 with rtti type in order to continue on with successful
1630 lookup of member / method only available in the rtti type. */
1632 struct type
*type
= value_type (arg1
);
1633 struct type
*real_type
;
1634 int full
, top
, using_enc
;
1635 struct value_print_options opts
;
1637 get_user_print_options (&opts
);
1638 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
) &&
1639 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1641 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1644 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1645 real_type
= lookup_pointer_type (real_type
);
1647 real_type
= lookup_reference_type (real_type
);
1649 arg1
= value_cast (real_type
, arg1
);
1654 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1655 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1656 &exp
->elts
[pc
+ 2].string
,
1661 struct value
*temp
= arg1
;
1662 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1663 NULL
, "structure pointer");
1666 case STRUCTOP_MEMBER
:
1668 if (op
== STRUCTOP_MEMBER
)
1669 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1671 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1673 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1675 if (noside
== EVAL_SKIP
)
1678 type
= check_typedef (value_type (arg2
));
1679 switch (TYPE_CODE (type
))
1681 case TYPE_CODE_METHODPTR
:
1682 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1683 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1686 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1687 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1688 return value_ind (arg2
);
1691 case TYPE_CODE_MEMBERPTR
:
1692 /* Now, convert these values to an address. */
1693 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1696 mem_offset
= value_as_long (arg2
);
1698 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1699 value_as_long (arg1
) + mem_offset
);
1700 return value_ind (arg3
);
1703 error (_("non-pointer-to-member value used in pointer-to-member construct"));
1707 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1708 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1709 if (noside
== EVAL_SKIP
)
1711 if (binop_user_defined_p (op
, arg1
, arg2
))
1712 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1714 return value_concat (arg1
, arg2
);
1717 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1718 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1720 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1722 if (binop_user_defined_p (op
, arg1
, arg2
))
1723 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1725 return value_assign (arg1
, arg2
);
1727 case BINOP_ASSIGN_MODIFY
:
1729 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1730 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1731 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1733 op
= exp
->elts
[pc
+ 1].opcode
;
1734 if (binop_user_defined_p (op
, arg1
, arg2
))
1735 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1736 else if (op
== BINOP_ADD
&& ptrmath_type_p (value_type (arg1
)))
1737 arg2
= value_ptradd (arg1
, arg2
);
1738 else if (op
== BINOP_SUB
&& ptrmath_type_p (value_type (arg1
)))
1739 arg2
= value_ptrsub (arg1
, arg2
);
1742 struct value
*tmp
= arg1
;
1744 /* For shift and integer exponentiation operations,
1745 only promote the first argument. */
1746 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1747 && is_integral_type (value_type (arg2
)))
1748 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
1750 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1752 arg2
= value_binop (tmp
, arg2
, op
);
1754 return value_assign (arg1
, arg2
);
1757 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1758 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1759 if (noside
== EVAL_SKIP
)
1761 if (binop_user_defined_p (op
, arg1
, arg2
))
1762 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1763 else if (ptrmath_type_p (value_type (arg1
)))
1764 return value_ptradd (arg1
, arg2
);
1765 else if (ptrmath_type_p (value_type (arg2
)))
1766 return value_ptradd (arg2
, arg1
);
1769 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1770 return value_binop (arg1
, arg2
, BINOP_ADD
);
1774 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1775 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1776 if (noside
== EVAL_SKIP
)
1778 if (binop_user_defined_p (op
, arg1
, arg2
))
1779 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1780 else if (ptrmath_type_p (value_type (arg1
)))
1782 if (ptrmath_type_p (value_type (arg2
)))
1784 /* FIXME -- should be ptrdiff_t */
1785 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1786 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1789 return value_ptrsub (arg1
, arg2
);
1793 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1794 return value_binop (arg1
, arg2
, BINOP_SUB
);
1805 case BINOP_BITWISE_AND
:
1806 case BINOP_BITWISE_IOR
:
1807 case BINOP_BITWISE_XOR
:
1808 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1809 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1810 if (noside
== EVAL_SKIP
)
1812 if (binop_user_defined_p (op
, arg1
, arg2
))
1813 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1816 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1817 fudge arg2 to avoid division-by-zero, the caller is
1818 (theoretically) only looking for the type of the result. */
1819 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1820 /* ??? Do we really want to test for BINOP_MOD here?
1821 The implementation of value_binop gives it a well-defined
1824 || op
== BINOP_INTDIV
1827 && value_logical_not (arg2
))
1829 struct value
*v_one
, *retval
;
1831 v_one
= value_one (value_type (arg2
), not_lval
);
1832 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1833 retval
= value_binop (arg1
, v_one
, op
);
1838 /* For shift and integer exponentiation operations,
1839 only promote the first argument. */
1840 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1841 && is_integral_type (value_type (arg2
)))
1842 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1844 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1846 return value_binop (arg1
, arg2
, op
);
1851 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1852 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1853 if (noside
== EVAL_SKIP
)
1855 error (_("':' operator used in invalid context"));
1857 case BINOP_SUBSCRIPT
:
1858 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1859 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1860 if (noside
== EVAL_SKIP
)
1862 if (binop_user_defined_p (op
, arg1
, arg2
))
1863 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1866 /* If the user attempts to subscript something that is not an
1867 array or pointer type (like a plain int variable for example),
1868 then report this as an error. */
1870 arg1
= coerce_ref (arg1
);
1871 type
= check_typedef (value_type (arg1
));
1872 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1873 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1875 if (TYPE_NAME (type
))
1876 error (_("cannot subscript something of type `%s'"),
1879 error (_("cannot subscript requested type"));
1882 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1883 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1885 return value_subscript (arg1
, arg2
);
1889 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1890 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1891 if (noside
== EVAL_SKIP
)
1893 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1894 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
1896 case MULTI_SUBSCRIPT
:
1898 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1899 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1902 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1903 /* FIXME: EVAL_SKIP handling may not be correct. */
1904 if (noside
== EVAL_SKIP
)
1915 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1916 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1918 /* If the user attempts to subscript something that has no target
1919 type (like a plain int variable for example), then report this
1922 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
1925 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1931 error (_("cannot subscript something of type `%s'"),
1932 TYPE_NAME (value_type (arg1
)));
1936 if (binop_user_defined_p (op
, arg1
, arg2
))
1938 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1942 arg1
= coerce_ref (arg1
);
1943 type
= check_typedef (value_type (arg1
));
1945 switch (TYPE_CODE (type
))
1948 case TYPE_CODE_ARRAY
:
1949 case TYPE_CODE_STRING
:
1950 arg1
= value_subscript (arg1
, arg2
);
1953 case TYPE_CODE_BITSTRING
:
1954 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1955 arg1
= value_bitstring_subscript (type
, arg1
, arg2
);
1959 if (TYPE_NAME (type
))
1960 error (_("cannot subscript something of type `%s'"),
1963 error (_("cannot subscript requested type"));
1969 multi_f77_subscript
:
1971 int subscript_array
[MAX_FORTRAN_DIMS
];
1972 int array_size_array
[MAX_FORTRAN_DIMS
];
1973 int ndimensions
= 1, i
;
1974 struct type
*tmp_type
;
1975 int offset_item
; /* The array offset where the item lives */
1977 if (nargs
> MAX_FORTRAN_DIMS
)
1978 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
1980 tmp_type
= check_typedef (value_type (arg1
));
1981 ndimensions
= calc_f77_array_dims (type
);
1983 if (nargs
!= ndimensions
)
1984 error (_("Wrong number of subscripts"));
1986 gdb_assert (nargs
> 0);
1988 /* Now that we know we have a legal array subscript expression
1989 let us actually find out where this element exists in the array. */
1992 /* Take array indices left to right */
1993 for (i
= 0; i
< nargs
; i
++)
1995 /* Evaluate each subscript, It must be a legal integer in F77 */
1996 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1998 /* Fill in the subscript and array size arrays */
2000 subscript_array
[i
] = value_as_long (arg2
);
2003 /* Internal type of array is arranged right to left */
2004 for (i
= 0; i
< nargs
; i
++)
2006 upper
= f77_get_upperbound (tmp_type
);
2007 lower
= f77_get_lowerbound (tmp_type
);
2009 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
2011 /* Zero-normalize subscripts so that offsetting will work. */
2013 subscript_array
[nargs
- i
- 1] -= lower
;
2015 /* If we are at the bottom of a multidimensional
2016 array type then keep a ptr to the last ARRAY
2017 type around for use when calling value_subscript()
2018 below. This is done because we pretend to value_subscript
2019 that we actually have a one-dimensional array
2020 of base element type that we apply a simple
2024 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
2027 /* Now let us calculate the offset for this item */
2029 offset_item
= subscript_array
[ndimensions
- 1];
2031 for (i
= ndimensions
- 1; i
> 0; --i
)
2033 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
2035 /* Construct a value node with the value of the offset */
2037 arg2
= value_from_longest (builtin_type_int32
, offset_item
);
2039 /* Let us now play a dirty trick: we will take arg1
2040 which is a value node pointing to the topmost level
2041 of the multidimensional array-set and pretend
2042 that it is actually a array of the final element
2043 type, this will ensure that value_subscript()
2044 returns the correct type value */
2046 deprecated_set_value_type (arg1
, tmp_type
);
2047 return value_subscripted_rvalue (arg1
, arg2
, 0);
2050 case BINOP_LOGICAL_AND
:
2051 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2052 if (noside
== EVAL_SKIP
)
2054 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2059 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2062 if (binop_user_defined_p (op
, arg1
, arg2
))
2064 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2065 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2069 tem
= value_logical_not (arg1
);
2070 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2071 (tem
? EVAL_SKIP
: noside
));
2072 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2073 return value_from_longest (type
,
2074 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2077 case BINOP_LOGICAL_OR
:
2078 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2079 if (noside
== EVAL_SKIP
)
2081 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2086 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2089 if (binop_user_defined_p (op
, arg1
, arg2
))
2091 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2092 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2096 tem
= value_logical_not (arg1
);
2097 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2098 (!tem
? EVAL_SKIP
: noside
));
2099 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2100 return value_from_longest (type
,
2101 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2105 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2106 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2107 if (noside
== EVAL_SKIP
)
2109 if (binop_user_defined_p (op
, arg1
, arg2
))
2111 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2115 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2116 tem
= value_equal (arg1
, arg2
);
2117 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2118 return value_from_longest (type
, (LONGEST
) tem
);
2121 case BINOP_NOTEQUAL
:
2122 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2123 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2124 if (noside
== EVAL_SKIP
)
2126 if (binop_user_defined_p (op
, arg1
, arg2
))
2128 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2132 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2133 tem
= value_equal (arg1
, arg2
);
2134 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2135 return value_from_longest (type
, (LONGEST
) ! tem
);
2139 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2140 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2141 if (noside
== EVAL_SKIP
)
2143 if (binop_user_defined_p (op
, arg1
, arg2
))
2145 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2149 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2150 tem
= value_less (arg1
, arg2
);
2151 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2152 return value_from_longest (type
, (LONGEST
) tem
);
2156 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2157 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2158 if (noside
== EVAL_SKIP
)
2160 if (binop_user_defined_p (op
, arg1
, arg2
))
2162 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2166 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2167 tem
= value_less (arg2
, arg1
);
2168 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2169 return value_from_longest (type
, (LONGEST
) tem
);
2173 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2174 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2175 if (noside
== EVAL_SKIP
)
2177 if (binop_user_defined_p (op
, arg1
, arg2
))
2179 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2183 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2184 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2185 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2186 return value_from_longest (type
, (LONGEST
) tem
);
2190 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2191 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2192 if (noside
== EVAL_SKIP
)
2194 if (binop_user_defined_p (op
, arg1
, arg2
))
2196 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2200 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2201 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2202 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2203 return value_from_longest (type
, (LONGEST
) tem
);
2207 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2208 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2209 if (noside
== EVAL_SKIP
)
2211 type
= check_typedef (value_type (arg2
));
2212 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2213 error (_("Non-integral right operand for \"@\" operator."));
2214 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2216 return allocate_repeat_value (value_type (arg1
),
2217 longest_to_int (value_as_long (arg2
)));
2220 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2223 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2224 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2227 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2228 if (noside
== EVAL_SKIP
)
2230 if (unop_user_defined_p (op
, arg1
))
2231 return value_x_unop (arg1
, op
, noside
);
2234 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2235 return value_pos (arg1
);
2239 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2240 if (noside
== EVAL_SKIP
)
2242 if (unop_user_defined_p (op
, arg1
))
2243 return value_x_unop (arg1
, op
, noside
);
2246 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2247 return value_neg (arg1
);
2250 case UNOP_COMPLEMENT
:
2251 /* C++: check for and handle destructor names. */
2252 op
= exp
->elts
[*pos
].opcode
;
2254 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2255 if (noside
== EVAL_SKIP
)
2257 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2258 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2261 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2262 return value_complement (arg1
);
2265 case UNOP_LOGICAL_NOT
:
2266 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2267 if (noside
== EVAL_SKIP
)
2269 if (unop_user_defined_p (op
, arg1
))
2270 return value_x_unop (arg1
, op
, noside
);
2273 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2274 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2278 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2279 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2280 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2281 type
= check_typedef (value_type (arg1
));
2282 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2283 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2284 error (_("Attempt to dereference pointer to member without an object"));
2285 if (noside
== EVAL_SKIP
)
2287 if (unop_user_defined_p (op
, arg1
))
2288 return value_x_unop (arg1
, op
, noside
);
2289 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2291 type
= check_typedef (value_type (arg1
));
2292 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2293 || TYPE_CODE (type
) == TYPE_CODE_REF
2294 /* In C you can dereference an array to get the 1st elt. */
2295 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2297 return value_zero (TYPE_TARGET_TYPE (type
),
2299 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2300 /* GDB allows dereferencing an int. */
2301 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2304 error (_("Attempt to take contents of a non-pointer value."));
2307 /* Allow * on an integer so we can cast it to whatever we want.
2308 This returns an int, which seems like the most C-like thing to
2309 do. "long long" variables are rare enough that
2310 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2311 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2312 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2313 (CORE_ADDR
) value_as_address (arg1
));
2314 return value_ind (arg1
);
2317 /* C++: check for and handle pointer to members. */
2319 op
= exp
->elts
[*pos
].opcode
;
2321 if (noside
== EVAL_SKIP
)
2323 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2328 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
2333 if (noside
== EVAL_SKIP
)
2335 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2338 return evaluate_subexp_for_sizeof (exp
, pos
);
2342 type
= exp
->elts
[pc
+ 1].type
;
2343 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2344 if (noside
== EVAL_SKIP
)
2346 if (type
!= value_type (arg1
))
2347 arg1
= value_cast (type
, arg1
);
2352 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2353 if (noside
== EVAL_SKIP
)
2355 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2356 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2358 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2359 value_as_address (arg1
));
2361 case UNOP_MEMVAL_TLS
:
2363 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2364 if (noside
== EVAL_SKIP
)
2366 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2367 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2371 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2372 value_as_address (arg1
));
2373 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2376 case UNOP_PREINCREMENT
:
2377 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2378 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2380 else if (unop_user_defined_p (op
, arg1
))
2382 return value_x_unop (arg1
, op
, noside
);
2386 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2387 if (ptrmath_type_p (value_type (arg1
)))
2388 arg2
= value_ptradd (arg1
, arg2
);
2391 struct value
*tmp
= arg1
;
2392 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2393 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2396 return value_assign (arg1
, arg2
);
2399 case UNOP_PREDECREMENT
:
2400 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2401 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2403 else if (unop_user_defined_p (op
, arg1
))
2405 return value_x_unop (arg1
, op
, noside
);
2409 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2410 if (ptrmath_type_p (value_type (arg1
)))
2411 arg2
= value_ptrsub (arg1
, arg2
);
2414 struct value
*tmp
= arg1
;
2415 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2416 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2419 return value_assign (arg1
, arg2
);
2422 case UNOP_POSTINCREMENT
:
2423 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2424 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2426 else if (unop_user_defined_p (op
, arg1
))
2428 return value_x_unop (arg1
, op
, noside
);
2432 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2433 if (ptrmath_type_p (value_type (arg1
)))
2434 arg2
= value_ptradd (arg1
, arg2
);
2437 struct value
*tmp
= arg1
;
2438 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2439 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2442 value_assign (arg1
, arg2
);
2446 case UNOP_POSTDECREMENT
:
2447 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2448 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2450 else if (unop_user_defined_p (op
, arg1
))
2452 return value_x_unop (arg1
, op
, noside
);
2456 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2457 if (ptrmath_type_p (value_type (arg1
)))
2458 arg2
= value_ptrsub (arg1
, arg2
);
2461 struct value
*tmp
= arg1
;
2462 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2463 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2466 value_assign (arg1
, arg2
);
2472 return value_of_this (1);
2476 return value_of_local ("self", 1);
2479 /* The value is not supposed to be used. This is here to make it
2480 easier to accommodate expressions that contain types. */
2482 if (noside
== EVAL_SKIP
)
2484 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2486 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2487 /* If this is a typedef, then find its immediate target. We
2488 use check_typedef to resolve stubs, but we ignore its
2489 result because we do not want to dig past all
2491 check_typedef (type
);
2492 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2493 type
= TYPE_TARGET_TYPE (type
);
2494 return allocate_value (type
);
2497 error (_("Attempt to use a type name as an expression"));
2500 /* Removing this case and compiling with gcc -Wall reveals that
2501 a lot of cases are hitting this case. Some of these should
2502 probably be removed from expression.h; others are legitimate
2503 expressions which are (apparently) not fully implemented.
2505 If there are any cases landing here which mean a user error,
2506 then they should be separate cases, with more descriptive
2510 GDB does not (yet) know how to evaluate that kind of expression"));
2514 return value_from_longest (builtin_type_int8
, (LONGEST
) 1);
2517 /* Evaluate a subexpression of EXP, at index *POS,
2518 and return the address of that subexpression.
2519 Advance *POS over the subexpression.
2520 If the subexpression isn't an lvalue, get an error.
2521 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2522 then only the type of the result need be correct. */
2524 static struct value
*
2525 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2535 op
= exp
->elts
[pc
].opcode
;
2541 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2543 /* We can't optimize out "&*" if there's a user-defined operator*. */
2544 if (unop_user_defined_p (op
, x
))
2546 x
= value_x_unop (x
, op
, noside
);
2547 goto default_case_after_eval
;
2554 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2555 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2558 var
= exp
->elts
[pc
+ 2].symbol
;
2560 /* C++: The "address" of a reference should yield the address
2561 * of the object pointed to. Let value_addr() deal with it. */
2562 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2566 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2569 lookup_pointer_type (SYMBOL_TYPE (var
));
2570 enum address_class sym_class
= SYMBOL_CLASS (var
);
2572 if (sym_class
== LOC_CONST
2573 || sym_class
== LOC_CONST_BYTES
2574 || sym_class
== LOC_REGISTER
)
2575 error (_("Attempt to take address of register or constant."));
2578 value_zero (type
, not_lval
);
2581 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2584 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2585 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2586 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2587 &exp
->elts
[pc
+ 3].string
,
2590 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2595 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2596 default_case_after_eval
:
2597 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2599 struct type
*type
= check_typedef (value_type (x
));
2601 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2602 return value_zero (lookup_pointer_type (value_type (x
)),
2604 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2605 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2608 error (_("Attempt to take address of value not located in memory."));
2610 return value_addr (x
);
2614 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2615 When used in contexts where arrays will be coerced anyway, this is
2616 equivalent to `evaluate_subexp' but much faster because it avoids
2617 actually fetching array contents (perhaps obsolete now that we have
2620 Note that we currently only do the coercion for C expressions, where
2621 arrays are zero based and the coercion is correct. For other languages,
2622 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2623 to decide if coercion is appropriate.
2628 evaluate_subexp_with_coercion (struct expression
*exp
,
2629 int *pos
, enum noside noside
)
2638 op
= exp
->elts
[pc
].opcode
;
2643 var
= exp
->elts
[pc
+ 2].symbol
;
2644 type
= check_typedef (SYMBOL_TYPE (var
));
2645 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2646 && CAST_IS_CONVERSION
)
2649 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2650 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2656 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2660 /* Evaluate a subexpression of EXP, at index *POS,
2661 and return a value for the size of that subexpression.
2662 Advance *POS over the subexpression. */
2664 static struct value
*
2665 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
2667 /* FIXME: This should be size_t. */
2668 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2675 op
= exp
->elts
[pc
].opcode
;
2679 /* This case is handled specially
2680 so that we avoid creating a value for the result type.
2681 If the result type is very big, it's desirable not to
2682 create a value unnecessarily. */
2685 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2686 type
= check_typedef (value_type (val
));
2687 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2688 && TYPE_CODE (type
) != TYPE_CODE_REF
2689 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2690 error (_("Attempt to take contents of a non-pointer value."));
2691 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2692 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2696 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2697 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2701 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2703 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2706 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2707 return value_from_longest (size_type
,
2708 (LONGEST
) TYPE_LENGTH (value_type (val
)));
2712 /* Parse a type expression in the string [P..P+LENGTH). */
2715 parse_and_eval_type (char *p
, int length
)
2717 char *tmp
= (char *) alloca (length
+ 4);
2718 struct expression
*expr
;
2720 memcpy (tmp
+ 1, p
, length
);
2721 tmp
[length
+ 1] = ')';
2722 tmp
[length
+ 2] = '0';
2723 tmp
[length
+ 3] = '\0';
2724 expr
= parse_expression (tmp
);
2725 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2726 error (_("Internal error in eval_type."));
2727 return expr
->elts
[1].type
;
2731 calc_f77_array_dims (struct type
*array_type
)
2734 struct type
*tmp_type
;
2736 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2737 error (_("Can't get dimensions for a non-array type"));
2739 tmp_type
= array_type
;
2741 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2743 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)