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 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
793 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
795 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
796 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
797 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
798 if (noside
== EVAL_SKIP
)
802 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
805 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
807 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
808 if (noside
== EVAL_SKIP
)
810 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
815 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
816 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
817 nargs
= tem3
- tem2
+ 1;
818 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
820 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
821 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
823 struct value
*rec
= allocate_value (expect_type
);
824 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
825 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
828 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
829 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
831 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
832 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
833 struct value
*array
= allocate_value (expect_type
);
834 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
835 LONGEST low_bound
, high_bound
, index
;
836 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
839 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
842 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
843 for (tem
= nargs
; --nargs
>= 0;)
845 struct value
*element
;
847 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
850 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
852 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
853 if (value_type (element
) != element_type
)
854 element
= value_cast (element_type
, element
);
857 int continue_pc
= *pos
;
859 index
= init_array_element (array
, element
, exp
, pos
, noside
,
860 low_bound
, high_bound
);
865 if (index
> high_bound
)
866 /* to avoid memory corruption */
867 error (_("Too many array elements"));
868 memcpy (value_contents_raw (array
)
869 + (index
- low_bound
) * element_size
,
870 value_contents (element
),
878 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
879 && TYPE_CODE (type
) == TYPE_CODE_SET
)
881 struct value
*set
= allocate_value (expect_type
);
882 gdb_byte
*valaddr
= value_contents_raw (set
);
883 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
884 struct type
*check_type
= element_type
;
885 LONGEST low_bound
, high_bound
;
887 /* get targettype of elementtype */
888 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
||
889 TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
890 check_type
= TYPE_TARGET_TYPE (check_type
);
892 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
893 error (_("(power)set type with unknown size"));
894 memset (valaddr
, '\0', TYPE_LENGTH (type
));
895 for (tem
= 0; tem
< nargs
; tem
++)
897 LONGEST range_low
, range_high
;
898 struct type
*range_low_type
, *range_high_type
;
899 struct value
*elem_val
;
900 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
903 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
904 range_low_type
= value_type (elem_val
);
905 range_low
= value_as_long (elem_val
);
906 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
907 range_high_type
= value_type (elem_val
);
908 range_high
= value_as_long (elem_val
);
912 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
913 range_low_type
= range_high_type
= value_type (elem_val
);
914 range_low
= range_high
= value_as_long (elem_val
);
916 /* check types of elements to avoid mixture of elements from
917 different types. Also check if type of element is "compatible"
918 with element type of powerset */
919 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
920 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
921 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
922 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
923 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
)) ||
924 (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
&&
925 (range_low_type
!= range_high_type
)))
926 /* different element modes */
927 error (_("POWERSET tuple elements of different mode"));
928 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
)) ||
929 (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
&&
930 range_low_type
!= check_type
))
931 error (_("incompatible POWERSET tuple elements"));
932 if (range_low
> range_high
)
934 warning (_("empty POWERSET tuple range"));
937 if (range_low
< low_bound
|| range_high
> high_bound
)
938 error (_("POWERSET tuple element out of range"));
939 range_low
-= low_bound
;
940 range_high
-= low_bound
;
941 for (; range_low
<= range_high
; range_low
++)
943 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
944 if (gdbarch_bits_big_endian (current_gdbarch
))
945 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
946 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
953 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
954 for (tem
= 0; tem
< nargs
; tem
++)
956 /* Ensure that array expressions are coerced into pointer objects. */
957 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
959 if (noside
== EVAL_SKIP
)
961 return value_array (tem2
, tem3
, argvec
);
965 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
967 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
969 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
970 if (noside
== EVAL_SKIP
)
972 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
975 case TERNOP_SLICE_COUNT
:
977 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
979 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
981 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
982 return value_slice (array
, lowbound
, length
);
986 /* Skip third and second args to evaluate the first one. */
987 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
988 if (value_logical_not (arg1
))
990 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
991 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
995 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
996 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1000 case OP_OBJC_SELECTOR
:
1001 { /* Objective C @selector operator. */
1002 char *sel
= &exp
->elts
[pc
+ 2].string
;
1003 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1004 struct type
*selector_type
;
1006 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1007 if (noside
== EVAL_SKIP
)
1011 sel
[len
] = 0; /* Make sure it's terminated. */
1013 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1014 return value_from_longest (selector_type
,
1015 lookup_child_selector (exp
->gdbarch
, sel
));
1018 case OP_OBJC_MSGCALL
:
1019 { /* Objective C message (method) call. */
1021 CORE_ADDR responds_selector
= 0;
1022 CORE_ADDR method_selector
= 0;
1024 CORE_ADDR selector
= 0;
1026 int struct_return
= 0;
1027 int sub_no_side
= 0;
1029 struct value
*msg_send
= NULL
;
1030 struct value
*msg_send_stret
= NULL
;
1031 int gnu_runtime
= 0;
1033 struct value
*target
= NULL
;
1034 struct value
*method
= NULL
;
1035 struct value
*called_method
= NULL
;
1037 struct type
*selector_type
= NULL
;
1038 struct type
*long_type
;
1040 struct value
*ret
= NULL
;
1043 selector
= exp
->elts
[pc
+ 1].longconst
;
1044 nargs
= exp
->elts
[pc
+ 2].longconst
;
1045 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1050 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1051 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1053 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1054 sub_no_side
= EVAL_NORMAL
;
1056 sub_no_side
= noside
;
1058 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1060 if (value_as_long (target
) == 0)
1061 return value_from_longest (long_type
, 0);
1063 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1066 /* Find the method dispatch (Apple runtime) or method lookup
1067 (GNU runtime) function for Objective-C. These will be used
1068 to lookup the symbol information for the method. If we
1069 can't find any symbol information, then we'll use these to
1070 call the method, otherwise we can call the method
1071 directly. The msg_send_stret function is used in the special
1072 case of a method that returns a structure (Apple runtime
1076 struct type
*type
= selector_type
;
1077 type
= lookup_function_type (type
);
1078 type
= lookup_pointer_type (type
);
1079 type
= lookup_function_type (type
);
1080 type
= lookup_pointer_type (type
);
1082 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1084 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1086 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1087 msg_send_stret
= value_from_pointer (type
,
1088 value_as_address (msg_send_stret
));
1092 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1093 /* Special dispatcher for methods returning structs */
1095 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1098 /* Verify the target object responds to this method. The
1099 standard top-level 'Object' class uses a different name for
1100 the verification method than the non-standard, but more
1101 often used, 'NSObject' class. Make sure we check for both. */
1104 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1105 if (responds_selector
== 0)
1107 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1109 if (responds_selector
== 0)
1110 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1113 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1114 if (method_selector
== 0)
1116 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1118 if (method_selector
== 0)
1119 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1121 /* Call the verification method, to make sure that the target
1122 class implements the desired method. */
1124 argvec
[0] = msg_send
;
1126 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1127 argvec
[3] = value_from_longest (long_type
, selector
);
1130 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1133 /* Function objc_msg_lookup returns a pointer. */
1135 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1137 if (value_as_long (ret
) == 0)
1138 error (_("Target does not respond to this message selector."));
1140 /* Call "methodForSelector:" method, to get the address of a
1141 function method that implements this selector for this
1142 class. If we can find a symbol at that address, then we
1143 know the return type, parameter types etc. (that's a good
1146 argvec
[0] = msg_send
;
1148 argvec
[2] = value_from_longest (long_type
, method_selector
);
1149 argvec
[3] = value_from_longest (long_type
, selector
);
1152 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1156 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1159 /* ret should now be the selector. */
1161 addr
= value_as_long (ret
);
1164 struct symbol
*sym
= NULL
;
1165 /* Is it a high_level symbol? */
1167 sym
= find_pc_function (addr
);
1169 method
= value_of_variable (sym
, 0);
1172 /* If we found a method with symbol information, check to see
1173 if it returns a struct. Otherwise assume it doesn't. */
1179 struct type
*val_type
;
1181 funaddr
= find_function_addr (method
, &val_type
);
1183 b
= block_for_pc (funaddr
);
1185 CHECK_TYPEDEF (val_type
);
1187 if ((val_type
== NULL
)
1188 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1190 if (expect_type
!= NULL
)
1191 val_type
= expect_type
;
1194 struct_return
= using_struct_return (exp
->gdbarch
,
1195 value_type (method
), val_type
);
1197 else if (expect_type
!= NULL
)
1199 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1200 check_typedef (expect_type
));
1203 /* Found a function symbol. Now we will substitute its
1204 value in place of the message dispatcher (obj_msgSend),
1205 so that we call the method directly instead of thru
1206 the dispatcher. The main reason for doing this is that
1207 we can now evaluate the return value and parameter values
1208 according to their known data types, in case we need to
1209 do things like promotion, dereferencing, special handling
1210 of structs and doubles, etc.
1212 We want to use the type signature of 'method', but still
1213 jump to objc_msgSend() or objc_msgSend_stret() to better
1214 mimic the behavior of the runtime. */
1218 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1219 error (_("method address has symbol information with non-function type; skipping"));
1221 set_value_address (method
, value_as_address (msg_send_stret
));
1223 set_value_address (method
, value_as_address (msg_send
));
1224 called_method
= method
;
1229 called_method
= msg_send_stret
;
1231 called_method
= msg_send
;
1234 if (noside
== EVAL_SKIP
)
1237 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1239 /* If the return type doesn't look like a function type,
1240 call an error. This can happen if somebody tries to
1241 turn a variable into a function call. This is here
1242 because people often want to call, eg, strcmp, which
1243 gdb doesn't know is a function. If gdb isn't asked for
1244 it's opinion (ie. through "whatis"), it won't offer
1247 struct type
*type
= value_type (called_method
);
1248 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1249 type
= TYPE_TARGET_TYPE (type
);
1250 type
= TYPE_TARGET_TYPE (type
);
1254 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1255 return allocate_value (expect_type
);
1257 return allocate_value (type
);
1260 error (_("Expression of type other than \"method returning ...\" used as a method"));
1263 /* Now depending on whether we found a symbol for the method,
1264 we will either call the runtime dispatcher or the method
1267 argvec
[0] = called_method
;
1269 argvec
[2] = value_from_longest (long_type
, selector
);
1270 /* User-supplied arguments. */
1271 for (tem
= 0; tem
< nargs
; tem
++)
1272 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1273 argvec
[tem
+ 3] = 0;
1275 if (gnu_runtime
&& (method
!= NULL
))
1277 /* Function objc_msg_lookup returns a pointer. */
1278 deprecated_set_value_type (argvec
[0],
1279 lookup_function_type (lookup_pointer_type (value_type (argvec
[0]))));
1280 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1283 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1290 op
= exp
->elts
[*pos
].opcode
;
1291 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1292 /* Allocate arg vector, including space for the function to be
1293 called in argvec[0] and a terminating NULL */
1294 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1295 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1298 /* First, evaluate the structure into arg2 */
1301 if (noside
== EVAL_SKIP
)
1304 if (op
== STRUCTOP_MEMBER
)
1306 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1310 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1313 /* If the function is a virtual function, then the
1314 aggregate value (providing the structure) plays
1315 its part by providing the vtable. Otherwise,
1316 it is just along for the ride: call the function
1319 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1321 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1322 != TYPE_CODE_METHODPTR
)
1323 error (_("Non-pointer-to-member value used in pointer-to-member "
1326 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1328 struct type
*method_type
= check_typedef (value_type (arg1
));
1329 arg1
= value_zero (method_type
, not_lval
);
1332 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1334 /* Now, say which argument to start evaluating from */
1337 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1339 /* Hair for method invocations */
1343 /* First, evaluate the structure into arg2 */
1345 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1346 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1347 if (noside
== EVAL_SKIP
)
1350 if (op
== STRUCTOP_STRUCT
)
1352 /* If v is a variable in a register, and the user types
1353 v.method (), this will produce an error, because v has
1356 A possible way around this would be to allocate a
1357 copy of the variable on the stack, copy in the
1358 contents, call the function, and copy out the
1359 contents. I.e. convert this from call by reference
1360 to call by copy-return (or whatever it's called).
1361 However, this does not work because it is not the
1362 same: the method being called could stash a copy of
1363 the address, and then future uses through that address
1364 (after the method returns) would be expected to
1365 use the variable itself, not some copy of it. */
1366 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1370 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1372 /* Now, say which argument to start evaluating from */
1377 /* Non-method function call */
1379 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1381 type
= value_type (argvec
[0]);
1382 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1383 type
= TYPE_TARGET_TYPE (type
);
1384 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1386 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1388 /* pai: FIXME This seems to be coercing arguments before
1389 * overload resolution has been done! */
1390 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1396 /* Evaluate arguments */
1397 for (; tem
<= nargs
; tem
++)
1399 /* Ensure that array expressions are coerced into pointer objects. */
1400 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1403 /* signal end of arglist */
1406 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1408 int static_memfuncp
;
1411 /* Method invocation : stuff "this" as first parameter */
1413 /* Name of method from expression */
1414 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1416 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1418 /* Language is C++, do some overload resolution before evaluation */
1419 struct value
*valp
= NULL
;
1421 /* Prepare list of argument types for overload resolution */
1422 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1423 for (ix
= 1; ix
<= nargs
; ix
++)
1424 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1426 (void) find_overload_match (arg_types
, nargs
, tstr
,
1427 1 /* method */ , 0 /* strict match */ ,
1428 &arg2
/* the object */ , NULL
,
1429 &valp
, NULL
, &static_memfuncp
);
1432 argvec
[1] = arg2
; /* the ``this'' pointer */
1433 argvec
[0] = valp
; /* use the method found after overload resolution */
1436 /* Non-C++ case -- or no overload resolution */
1438 struct value
*temp
= arg2
;
1439 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1441 op
== STRUCTOP_STRUCT
1442 ? "structure" : "structure pointer");
1443 /* value_struct_elt updates temp with the correct value
1444 of the ``this'' pointer if necessary, so modify argvec[1] to
1445 reflect any ``this'' changes. */
1446 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1447 value_address (temp
)
1448 + value_embedded_offset (temp
));
1449 argvec
[1] = arg2
; /* the ``this'' pointer */
1452 if (static_memfuncp
)
1454 argvec
[1] = argvec
[0];
1459 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1464 else if (op
== OP_VAR_VALUE
)
1466 /* Non-member function being called */
1467 /* fn: This can only be done for C++ functions. A C-style function
1468 in a C++ program, for instance, does not have the fields that
1469 are expected here */
1471 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1473 /* Language is C++, do some overload resolution before evaluation */
1474 struct symbol
*symp
;
1476 /* Prepare list of argument types for overload resolution */
1477 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1478 for (ix
= 1; ix
<= nargs
; ix
++)
1479 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1481 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1482 0 /* not method */ , 0 /* strict match */ ,
1483 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1486 /* Now fix the expression being evaluated */
1487 exp
->elts
[save_pos1
+2].symbol
= symp
;
1488 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1492 /* Not C++, or no overload resolution allowed */
1493 /* nothing to be done; argvec already correctly set up */
1498 /* It is probably a C-style function */
1499 /* nothing to be done; argvec already correctly set up */
1504 if (noside
== EVAL_SKIP
)
1506 if (argvec
[0] == NULL
)
1507 error (_("Cannot evaluate function -- may be inlined"));
1508 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1510 /* If the return type doesn't look like a function type, call an
1511 error. This can happen if somebody tries to turn a variable into
1512 a function call. This is here because people often want to
1513 call, eg, strcmp, which gdb doesn't know is a function. If
1514 gdb isn't asked for it's opinion (ie. through "whatis"),
1515 it won't offer it. */
1517 struct type
*ftype
=
1518 TYPE_TARGET_TYPE (value_type (argvec
[0]));
1521 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec
[0])));
1523 error (_("Expression of type other than \"Function returning ...\" used as function"));
1525 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1526 return call_internal_function (argvec
[0], nargs
, argvec
+ 1);
1528 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1529 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1531 case OP_F77_UNDETERMINED_ARGLIST
:
1533 /* Remember that in F77, functions, substring ops and
1534 array subscript operations cannot be disambiguated
1535 at parse time. We have made all array subscript operations,
1536 substring operations as well as function calls come here
1537 and we now have to discover what the heck this thing actually was.
1538 If it is a function, we process just as if we got an OP_FUNCALL. */
1540 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1543 /* First determine the type code we are dealing with. */
1544 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1545 type
= check_typedef (value_type (arg1
));
1546 code
= TYPE_CODE (type
);
1548 if (code
== TYPE_CODE_PTR
)
1550 /* Fortran always passes variable to subroutines as pointer.
1551 So we need to look into its target type to see if it is
1552 array, string or function. If it is, we need to switch
1553 to the target value the original one points to. */
1554 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1556 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1557 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1558 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1560 arg1
= value_ind (arg1
);
1561 type
= check_typedef (value_type (arg1
));
1562 code
= TYPE_CODE (type
);
1568 case TYPE_CODE_ARRAY
:
1569 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1570 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1572 goto multi_f77_subscript
;
1574 case TYPE_CODE_STRING
:
1575 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1576 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1579 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1580 return value_subscript (arg1
, arg2
);
1584 case TYPE_CODE_FUNC
:
1585 /* It's a function call. */
1586 /* Allocate arg vector, including space for the function to be
1587 called in argvec[0] and a terminating NULL */
1588 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1591 for (; tem
<= nargs
; tem
++)
1592 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1593 argvec
[tem
] = 0; /* signal end of arglist */
1597 error (_("Cannot perform substring on this type"));
1601 /* We have a complex number, There should be 2 floating
1602 point numbers that compose it */
1604 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1605 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1607 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1609 case STRUCTOP_STRUCT
:
1610 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1611 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1612 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1613 if (noside
== EVAL_SKIP
)
1615 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1616 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1617 &exp
->elts
[pc
+ 2].string
,
1622 struct value
*temp
= arg1
;
1623 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1628 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1629 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1630 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1631 if (noside
== EVAL_SKIP
)
1634 /* JYG: if print object is on we need to replace the base type
1635 with rtti type in order to continue on with successful
1636 lookup of member / method only available in the rtti type. */
1638 struct type
*type
= value_type (arg1
);
1639 struct type
*real_type
;
1640 int full
, top
, using_enc
;
1641 struct value_print_options opts
;
1643 get_user_print_options (&opts
);
1644 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
) &&
1645 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1647 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1650 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1651 real_type
= lookup_pointer_type (real_type
);
1653 real_type
= lookup_reference_type (real_type
);
1655 arg1
= value_cast (real_type
, arg1
);
1660 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1661 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1662 &exp
->elts
[pc
+ 2].string
,
1667 struct value
*temp
= arg1
;
1668 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1669 NULL
, "structure pointer");
1672 case STRUCTOP_MEMBER
:
1674 if (op
== STRUCTOP_MEMBER
)
1675 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1677 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1679 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1681 if (noside
== EVAL_SKIP
)
1684 type
= check_typedef (value_type (arg2
));
1685 switch (TYPE_CODE (type
))
1687 case TYPE_CODE_METHODPTR
:
1688 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1689 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1692 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1693 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1694 return value_ind (arg2
);
1697 case TYPE_CODE_MEMBERPTR
:
1698 /* Now, convert these values to an address. */
1699 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1702 mem_offset
= value_as_long (arg2
);
1704 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1705 value_as_long (arg1
) + mem_offset
);
1706 return value_ind (arg3
);
1709 error (_("non-pointer-to-member value used in pointer-to-member construct"));
1713 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1714 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1715 if (noside
== EVAL_SKIP
)
1717 if (binop_user_defined_p (op
, arg1
, arg2
))
1718 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1720 return value_concat (arg1
, arg2
);
1723 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1724 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1726 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1728 if (binop_user_defined_p (op
, arg1
, arg2
))
1729 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1731 return value_assign (arg1
, arg2
);
1733 case BINOP_ASSIGN_MODIFY
:
1735 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1736 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1737 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1739 op
= exp
->elts
[pc
+ 1].opcode
;
1740 if (binop_user_defined_p (op
, arg1
, arg2
))
1741 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1742 else if (op
== BINOP_ADD
&& ptrmath_type_p (value_type (arg1
)))
1743 arg2
= value_ptradd (arg1
, arg2
);
1744 else if (op
== BINOP_SUB
&& ptrmath_type_p (value_type (arg1
)))
1745 arg2
= value_ptrsub (arg1
, arg2
);
1748 struct value
*tmp
= arg1
;
1750 /* For shift and integer exponentiation operations,
1751 only promote the first argument. */
1752 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1753 && is_integral_type (value_type (arg2
)))
1754 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
1756 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1758 arg2
= value_binop (tmp
, arg2
, op
);
1760 return value_assign (arg1
, arg2
);
1763 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1764 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1765 if (noside
== EVAL_SKIP
)
1767 if (binop_user_defined_p (op
, arg1
, arg2
))
1768 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1769 else if (ptrmath_type_p (value_type (arg1
)))
1770 return value_ptradd (arg1
, arg2
);
1771 else if (ptrmath_type_p (value_type (arg2
)))
1772 return value_ptradd (arg2
, arg1
);
1775 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1776 return value_binop (arg1
, arg2
, BINOP_ADD
);
1780 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1781 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1782 if (noside
== EVAL_SKIP
)
1784 if (binop_user_defined_p (op
, arg1
, arg2
))
1785 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1786 else if (ptrmath_type_p (value_type (arg1
)))
1788 if (ptrmath_type_p (value_type (arg2
)))
1790 /* FIXME -- should be ptrdiff_t */
1791 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1792 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1795 return value_ptrsub (arg1
, arg2
);
1799 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1800 return value_binop (arg1
, arg2
, BINOP_SUB
);
1811 case BINOP_BITWISE_AND
:
1812 case BINOP_BITWISE_IOR
:
1813 case BINOP_BITWISE_XOR
:
1814 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1815 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1816 if (noside
== EVAL_SKIP
)
1818 if (binop_user_defined_p (op
, arg1
, arg2
))
1819 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1822 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1823 fudge arg2 to avoid division-by-zero, the caller is
1824 (theoretically) only looking for the type of the result. */
1825 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1826 /* ??? Do we really want to test for BINOP_MOD here?
1827 The implementation of value_binop gives it a well-defined
1830 || op
== BINOP_INTDIV
1833 && value_logical_not (arg2
))
1835 struct value
*v_one
, *retval
;
1837 v_one
= value_one (value_type (arg2
), not_lval
);
1838 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1839 retval
= value_binop (arg1
, v_one
, op
);
1844 /* For shift and integer exponentiation operations,
1845 only promote the first argument. */
1846 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1847 && is_integral_type (value_type (arg2
)))
1848 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1850 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1852 return value_binop (arg1
, arg2
, op
);
1857 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1858 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1859 if (noside
== EVAL_SKIP
)
1861 error (_("':' operator used in invalid context"));
1863 case BINOP_SUBSCRIPT
:
1864 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1865 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1866 if (noside
== EVAL_SKIP
)
1868 if (binop_user_defined_p (op
, arg1
, arg2
))
1869 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1872 /* If the user attempts to subscript something that is not an
1873 array or pointer type (like a plain int variable for example),
1874 then report this as an error. */
1876 arg1
= coerce_ref (arg1
);
1877 type
= check_typedef (value_type (arg1
));
1878 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1879 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1881 if (TYPE_NAME (type
))
1882 error (_("cannot subscript something of type `%s'"),
1885 error (_("cannot subscript requested type"));
1888 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1889 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1891 return value_subscript (arg1
, arg2
);
1895 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1896 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1897 if (noside
== EVAL_SKIP
)
1899 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1900 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
1902 case MULTI_SUBSCRIPT
:
1904 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1905 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1908 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1909 /* FIXME: EVAL_SKIP handling may not be correct. */
1910 if (noside
== EVAL_SKIP
)
1921 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1922 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1924 /* If the user attempts to subscript something that has no target
1925 type (like a plain int variable for example), then report this
1928 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
1931 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1937 error (_("cannot subscript something of type `%s'"),
1938 TYPE_NAME (value_type (arg1
)));
1942 if (binop_user_defined_p (op
, arg1
, arg2
))
1944 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1948 arg1
= coerce_ref (arg1
);
1949 type
= check_typedef (value_type (arg1
));
1951 switch (TYPE_CODE (type
))
1954 case TYPE_CODE_ARRAY
:
1955 case TYPE_CODE_STRING
:
1956 arg1
= value_subscript (arg1
, arg2
);
1959 case TYPE_CODE_BITSTRING
:
1960 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1961 arg1
= value_bitstring_subscript (type
, arg1
, arg2
);
1965 if (TYPE_NAME (type
))
1966 error (_("cannot subscript something of type `%s'"),
1969 error (_("cannot subscript requested type"));
1975 multi_f77_subscript
:
1977 int subscript_array
[MAX_FORTRAN_DIMS
];
1978 int array_size_array
[MAX_FORTRAN_DIMS
];
1979 int ndimensions
= 1, i
;
1980 struct type
*tmp_type
;
1981 int offset_item
; /* The array offset where the item lives */
1983 if (nargs
> MAX_FORTRAN_DIMS
)
1984 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
1986 tmp_type
= check_typedef (value_type (arg1
));
1987 ndimensions
= calc_f77_array_dims (type
);
1989 if (nargs
!= ndimensions
)
1990 error (_("Wrong number of subscripts"));
1992 gdb_assert (nargs
> 0);
1994 /* Now that we know we have a legal array subscript expression
1995 let us actually find out where this element exists in the array. */
1998 /* Take array indices left to right */
1999 for (i
= 0; i
< nargs
; i
++)
2001 /* Evaluate each subscript, It must be a legal integer in F77 */
2002 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2004 /* Fill in the subscript and array size arrays */
2006 subscript_array
[i
] = value_as_long (arg2
);
2009 /* Internal type of array is arranged right to left */
2010 for (i
= 0; i
< nargs
; i
++)
2012 upper
= f77_get_upperbound (tmp_type
);
2013 lower
= f77_get_lowerbound (tmp_type
);
2015 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
2017 /* Zero-normalize subscripts so that offsetting will work. */
2019 subscript_array
[nargs
- i
- 1] -= lower
;
2021 /* If we are at the bottom of a multidimensional
2022 array type then keep a ptr to the last ARRAY
2023 type around for use when calling value_subscript()
2024 below. This is done because we pretend to value_subscript
2025 that we actually have a one-dimensional array
2026 of base element type that we apply a simple
2030 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
2033 /* Now let us calculate the offset for this item */
2035 offset_item
= subscript_array
[ndimensions
- 1];
2037 for (i
= ndimensions
- 1; i
> 0; --i
)
2039 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
2041 /* Construct a value node with the value of the offset */
2043 arg2
= value_from_longest (builtin_type_int32
, offset_item
);
2045 /* Let us now play a dirty trick: we will take arg1
2046 which is a value node pointing to the topmost level
2047 of the multidimensional array-set and pretend
2048 that it is actually a array of the final element
2049 type, this will ensure that value_subscript()
2050 returns the correct type value */
2052 deprecated_set_value_type (arg1
, tmp_type
);
2053 return value_subscripted_rvalue (arg1
, arg2
, 0);
2056 case BINOP_LOGICAL_AND
:
2057 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2058 if (noside
== EVAL_SKIP
)
2060 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2065 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2068 if (binop_user_defined_p (op
, arg1
, arg2
))
2070 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2071 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2075 tem
= value_logical_not (arg1
);
2076 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2077 (tem
? EVAL_SKIP
: noside
));
2078 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2079 return value_from_longest (type
,
2080 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2083 case BINOP_LOGICAL_OR
:
2084 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2085 if (noside
== EVAL_SKIP
)
2087 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2092 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2095 if (binop_user_defined_p (op
, arg1
, arg2
))
2097 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2098 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2102 tem
= value_logical_not (arg1
);
2103 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2104 (!tem
? EVAL_SKIP
: noside
));
2105 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2106 return value_from_longest (type
,
2107 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2111 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2112 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2113 if (noside
== EVAL_SKIP
)
2115 if (binop_user_defined_p (op
, arg1
, arg2
))
2117 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2121 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2122 tem
= value_equal (arg1
, arg2
);
2123 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2124 return value_from_longest (type
, (LONGEST
) tem
);
2127 case BINOP_NOTEQUAL
:
2128 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2129 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2130 if (noside
== EVAL_SKIP
)
2132 if (binop_user_defined_p (op
, arg1
, arg2
))
2134 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2138 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2139 tem
= value_equal (arg1
, arg2
);
2140 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2141 return value_from_longest (type
, (LONGEST
) ! tem
);
2145 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2146 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2147 if (noside
== EVAL_SKIP
)
2149 if (binop_user_defined_p (op
, arg1
, arg2
))
2151 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2155 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2156 tem
= value_less (arg1
, arg2
);
2157 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2158 return value_from_longest (type
, (LONGEST
) tem
);
2162 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2163 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2164 if (noside
== EVAL_SKIP
)
2166 if (binop_user_defined_p (op
, arg1
, arg2
))
2168 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2172 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2173 tem
= value_less (arg2
, arg1
);
2174 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2175 return value_from_longest (type
, (LONGEST
) tem
);
2179 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2180 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2181 if (noside
== EVAL_SKIP
)
2183 if (binop_user_defined_p (op
, arg1
, arg2
))
2185 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2189 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2190 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2191 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2192 return value_from_longest (type
, (LONGEST
) tem
);
2196 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2197 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2198 if (noside
== EVAL_SKIP
)
2200 if (binop_user_defined_p (op
, arg1
, arg2
))
2202 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2206 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2207 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2208 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2209 return value_from_longest (type
, (LONGEST
) tem
);
2213 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2214 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2215 if (noside
== EVAL_SKIP
)
2217 type
= check_typedef (value_type (arg2
));
2218 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2219 error (_("Non-integral right operand for \"@\" operator."));
2220 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2222 return allocate_repeat_value (value_type (arg1
),
2223 longest_to_int (value_as_long (arg2
)));
2226 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2229 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2230 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2233 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2234 if (noside
== EVAL_SKIP
)
2236 if (unop_user_defined_p (op
, arg1
))
2237 return value_x_unop (arg1
, op
, noside
);
2240 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2241 return value_pos (arg1
);
2245 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2246 if (noside
== EVAL_SKIP
)
2248 if (unop_user_defined_p (op
, arg1
))
2249 return value_x_unop (arg1
, op
, noside
);
2252 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2253 return value_neg (arg1
);
2256 case UNOP_COMPLEMENT
:
2257 /* C++: check for and handle destructor names. */
2258 op
= exp
->elts
[*pos
].opcode
;
2260 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2261 if (noside
== EVAL_SKIP
)
2263 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2264 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2267 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2268 return value_complement (arg1
);
2271 case UNOP_LOGICAL_NOT
:
2272 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2273 if (noside
== EVAL_SKIP
)
2275 if (unop_user_defined_p (op
, arg1
))
2276 return value_x_unop (arg1
, op
, noside
);
2279 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2280 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2284 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2285 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2286 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2287 type
= check_typedef (value_type (arg1
));
2288 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2289 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2290 error (_("Attempt to dereference pointer to member without an object"));
2291 if (noside
== EVAL_SKIP
)
2293 if (unop_user_defined_p (op
, arg1
))
2294 return value_x_unop (arg1
, op
, noside
);
2295 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2297 type
= check_typedef (value_type (arg1
));
2298 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2299 || TYPE_CODE (type
) == TYPE_CODE_REF
2300 /* In C you can dereference an array to get the 1st elt. */
2301 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2303 return value_zero (TYPE_TARGET_TYPE (type
),
2305 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2306 /* GDB allows dereferencing an int. */
2307 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2310 error (_("Attempt to take contents of a non-pointer value."));
2313 /* Allow * on an integer so we can cast it to whatever we want.
2314 This returns an int, which seems like the most C-like thing to
2315 do. "long long" variables are rare enough that
2316 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2317 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2318 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2319 (CORE_ADDR
) value_as_address (arg1
));
2320 return value_ind (arg1
);
2323 /* C++: check for and handle pointer to members. */
2325 op
= exp
->elts
[*pos
].opcode
;
2327 if (noside
== EVAL_SKIP
)
2329 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2334 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
2339 if (noside
== EVAL_SKIP
)
2341 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2344 return evaluate_subexp_for_sizeof (exp
, pos
);
2348 type
= exp
->elts
[pc
+ 1].type
;
2349 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2350 if (noside
== EVAL_SKIP
)
2352 if (type
!= value_type (arg1
))
2353 arg1
= value_cast (type
, arg1
);
2358 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2359 if (noside
== EVAL_SKIP
)
2361 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2362 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2364 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2365 value_as_address (arg1
));
2367 case UNOP_MEMVAL_TLS
:
2369 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2370 if (noside
== EVAL_SKIP
)
2372 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2373 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2377 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2378 value_as_address (arg1
));
2379 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2382 case UNOP_PREINCREMENT
:
2383 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2384 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2386 else if (unop_user_defined_p (op
, arg1
))
2388 return value_x_unop (arg1
, op
, noside
);
2392 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2393 if (ptrmath_type_p (value_type (arg1
)))
2394 arg2
= value_ptradd (arg1
, arg2
);
2397 struct value
*tmp
= arg1
;
2398 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2399 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2402 return value_assign (arg1
, arg2
);
2405 case UNOP_PREDECREMENT
:
2406 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2407 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2409 else if (unop_user_defined_p (op
, arg1
))
2411 return value_x_unop (arg1
, op
, noside
);
2415 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2416 if (ptrmath_type_p (value_type (arg1
)))
2417 arg2
= value_ptrsub (arg1
, arg2
);
2420 struct value
*tmp
= arg1
;
2421 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2422 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2425 return value_assign (arg1
, arg2
);
2428 case UNOP_POSTINCREMENT
:
2429 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2430 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2432 else if (unop_user_defined_p (op
, arg1
))
2434 return value_x_unop (arg1
, op
, noside
);
2438 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2439 if (ptrmath_type_p (value_type (arg1
)))
2440 arg2
= value_ptradd (arg1
, arg2
);
2443 struct value
*tmp
= arg1
;
2444 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2445 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2448 value_assign (arg1
, arg2
);
2452 case UNOP_POSTDECREMENT
:
2453 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2454 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2456 else if (unop_user_defined_p (op
, arg1
))
2458 return value_x_unop (arg1
, op
, noside
);
2462 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2463 if (ptrmath_type_p (value_type (arg1
)))
2464 arg2
= value_ptrsub (arg1
, arg2
);
2467 struct value
*tmp
= arg1
;
2468 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2469 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2472 value_assign (arg1
, arg2
);
2478 return value_of_this (1);
2482 return value_of_local ("self", 1);
2485 /* The value is not supposed to be used. This is here to make it
2486 easier to accommodate expressions that contain types. */
2488 if (noside
== EVAL_SKIP
)
2490 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2492 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2493 /* If this is a typedef, then find its immediate target. We
2494 use check_typedef to resolve stubs, but we ignore its
2495 result because we do not want to dig past all
2497 check_typedef (type
);
2498 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2499 type
= TYPE_TARGET_TYPE (type
);
2500 return allocate_value (type
);
2503 error (_("Attempt to use a type name as an expression"));
2506 /* Removing this case and compiling with gcc -Wall reveals that
2507 a lot of cases are hitting this case. Some of these should
2508 probably be removed from expression.h; others are legitimate
2509 expressions which are (apparently) not fully implemented.
2511 If there are any cases landing here which mean a user error,
2512 then they should be separate cases, with more descriptive
2516 GDB does not (yet) know how to evaluate that kind of expression"));
2520 return value_from_longest (builtin_type_int8
, (LONGEST
) 1);
2523 /* Evaluate a subexpression of EXP, at index *POS,
2524 and return the address of that subexpression.
2525 Advance *POS over the subexpression.
2526 If the subexpression isn't an lvalue, get an error.
2527 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2528 then only the type of the result need be correct. */
2530 static struct value
*
2531 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2541 op
= exp
->elts
[pc
].opcode
;
2547 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2549 /* We can't optimize out "&*" if there's a user-defined operator*. */
2550 if (unop_user_defined_p (op
, x
))
2552 x
= value_x_unop (x
, op
, noside
);
2553 goto default_case_after_eval
;
2560 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2561 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2564 var
= exp
->elts
[pc
+ 2].symbol
;
2566 /* C++: The "address" of a reference should yield the address
2567 * of the object pointed to. Let value_addr() deal with it. */
2568 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2572 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2575 lookup_pointer_type (SYMBOL_TYPE (var
));
2576 enum address_class sym_class
= SYMBOL_CLASS (var
);
2578 if (sym_class
== LOC_CONST
2579 || sym_class
== LOC_CONST_BYTES
2580 || sym_class
== LOC_REGISTER
)
2581 error (_("Attempt to take address of register or constant."));
2584 value_zero (type
, not_lval
);
2587 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2590 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2591 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2592 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2593 &exp
->elts
[pc
+ 3].string
,
2596 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2601 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2602 default_case_after_eval
:
2603 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2605 struct type
*type
= check_typedef (value_type (x
));
2607 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2608 return value_zero (lookup_pointer_type (value_type (x
)),
2610 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2611 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2614 error (_("Attempt to take address of value not located in memory."));
2616 return value_addr (x
);
2620 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2621 When used in contexts where arrays will be coerced anyway, this is
2622 equivalent to `evaluate_subexp' but much faster because it avoids
2623 actually fetching array contents (perhaps obsolete now that we have
2626 Note that we currently only do the coercion for C expressions, where
2627 arrays are zero based and the coercion is correct. For other languages,
2628 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2629 to decide if coercion is appropriate.
2634 evaluate_subexp_with_coercion (struct expression
*exp
,
2635 int *pos
, enum noside noside
)
2644 op
= exp
->elts
[pc
].opcode
;
2649 var
= exp
->elts
[pc
+ 2].symbol
;
2650 type
= check_typedef (SYMBOL_TYPE (var
));
2651 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2652 && CAST_IS_CONVERSION
)
2655 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2656 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2662 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2666 /* Evaluate a subexpression of EXP, at index *POS,
2667 and return a value for the size of that subexpression.
2668 Advance *POS over the subexpression. */
2670 static struct value
*
2671 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
2673 /* FIXME: This should be size_t. */
2674 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2681 op
= exp
->elts
[pc
].opcode
;
2685 /* This case is handled specially
2686 so that we avoid creating a value for the result type.
2687 If the result type is very big, it's desirable not to
2688 create a value unnecessarily. */
2691 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2692 type
= check_typedef (value_type (val
));
2693 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2694 && TYPE_CODE (type
) != TYPE_CODE_REF
2695 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2696 error (_("Attempt to take contents of a non-pointer value."));
2697 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2698 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2702 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2703 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2707 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2709 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2712 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2713 return value_from_longest (size_type
,
2714 (LONGEST
) TYPE_LENGTH (value_type (val
)));
2718 /* Parse a type expression in the string [P..P+LENGTH). */
2721 parse_and_eval_type (char *p
, int length
)
2723 char *tmp
= (char *) alloca (length
+ 4);
2724 struct expression
*expr
;
2726 memcpy (tmp
+ 1, p
, length
);
2727 tmp
[length
+ 1] = ')';
2728 tmp
[length
+ 2] = '0';
2729 tmp
[length
+ 3] = '\0';
2730 expr
= parse_expression (tmp
);
2731 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2732 error (_("Internal error in eval_type."));
2733 return expr
->elts
[1].type
;
2737 calc_f77_array_dims (struct type
*array_type
)
2740 struct type
*tmp_type
;
2742 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2743 error (_("Can't get dimensions for a non-array type"));
2745 tmp_type
= array_type
;
2747 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2749 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)