1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
27 #include "expression.h"
30 #include "language.h" /* For CAST_IS_CONVERSION */
31 #include "f-lang.h" /* for array bound stuff */
34 #include "objc-lang.h"
36 #include "parser-defs.h"
37 #include "cp-support.h"
39 #include "exceptions.h"
41 #include "user-regs.h"
44 #include "gdb_assert.h"
46 /* This is defined in valops.c */
47 extern int overload_resolution
;
49 /* Prototypes for local functions. */
51 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
53 static struct value
*evaluate_subexp_for_address (struct expression
*,
56 static struct value
*evaluate_subexp (struct type
*, struct expression
*,
59 static char *get_label (struct expression
*, int *);
61 static struct value
*evaluate_struct_tuple (struct value
*,
62 struct expression
*, int *,
65 static LONGEST
init_array_element (struct value
*, struct value
*,
66 struct expression
*, int *, enum noside
,
70 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
71 int *pos
, enum noside noside
)
73 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
74 (expect_type
, exp
, pos
, noside
);
77 /* Parse the string EXP as a C expression, evaluate it,
78 and return the result as a number. */
81 parse_and_eval_address (char *exp
)
83 struct expression
*expr
= parse_expression (exp
);
85 struct cleanup
*old_chain
=
86 make_cleanup (free_current_contents
, &expr
);
88 addr
= value_as_address (evaluate_expression (expr
));
89 do_cleanups (old_chain
);
93 /* Like parse_and_eval_address but takes a pointer to a char * variable
94 and advanced that variable across the characters parsed. */
97 parse_and_eval_address_1 (char **expptr
)
99 struct expression
*expr
= parse_exp_1 (expptr
, (struct block
*) 0, 0);
101 struct cleanup
*old_chain
=
102 make_cleanup (free_current_contents
, &expr
);
104 addr
= value_as_address (evaluate_expression (expr
));
105 do_cleanups (old_chain
);
109 /* Like parse_and_eval_address, but treats the value of the expression
110 as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
112 parse_and_eval_long (char *exp
)
114 struct expression
*expr
= parse_expression (exp
);
116 struct cleanup
*old_chain
=
117 make_cleanup (free_current_contents
, &expr
);
119 retval
= value_as_long (evaluate_expression (expr
));
120 do_cleanups (old_chain
);
125 parse_and_eval (char *exp
)
127 struct expression
*expr
= parse_expression (exp
);
129 struct cleanup
*old_chain
=
130 make_cleanup (free_current_contents
, &expr
);
132 val
= evaluate_expression (expr
);
133 do_cleanups (old_chain
);
137 /* Parse up to a comma (or to a closeparen)
138 in the string EXPP as an expression, evaluate it, and return the value.
139 EXPP is advanced to point to the comma. */
142 parse_to_comma_and_eval (char **expp
)
144 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
146 struct cleanup
*old_chain
=
147 make_cleanup (free_current_contents
, &expr
);
149 val
= evaluate_expression (expr
);
150 do_cleanups (old_chain
);
154 /* Evaluate an expression in internal prefix form
155 such as is constructed by parse.y.
157 See expression.h for info on the format of an expression. */
160 evaluate_expression (struct expression
*exp
)
163 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
166 /* Evaluate an expression, avoiding all memory references
167 and getting a value whose type alone is correct. */
170 evaluate_type (struct expression
*exp
)
173 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
176 /* Evaluate a subexpression, avoiding all memory references and
177 getting a value whose type alone is correct. */
180 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
182 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
185 /* Extract a field operation from an expression. If the subexpression
186 of EXP starting at *SUBEXP is not a structure dereference
187 operation, return NULL. Otherwise, return the name of the
188 dereferenced field, and advance *SUBEXP to point to the
189 subexpression of the left-hand-side of the dereference. This is
190 used when completing field names. */
193 extract_field_op (struct expression
*exp
, int *subexp
)
197 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
198 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
200 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
201 result
= &exp
->elts
[*subexp
+ 2].string
;
202 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
206 /* If the next expression is an OP_LABELED, skips past it,
207 returning the label. Otherwise, does nothing and returns NULL. */
210 get_label (struct expression
*exp
, int *pos
)
212 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
215 char *name
= &exp
->elts
[pc
+ 2].string
;
216 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
217 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
224 /* This function evaluates tuples (in (the deleted) Chill) or
225 brace-initializers (in C/C++) for structure types. */
227 static struct value
*
228 evaluate_struct_tuple (struct value
*struct_val
,
229 struct expression
*exp
,
230 int *pos
, enum noside noside
, int nargs
)
232 struct type
*struct_type
= check_typedef (value_type (struct_val
));
233 struct type
*substruct_type
= struct_type
;
234 struct type
*field_type
;
241 struct value
*val
= NULL
;
246 /* Skip past the labels, and count them. */
247 while (get_label (exp
, pos
) != NULL
)
252 char *label
= get_label (exp
, &pc
);
255 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
258 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
259 if (field_name
!= NULL
&& strcmp (field_name
, label
) == 0)
262 subfieldno
= fieldno
;
263 substruct_type
= struct_type
;
267 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
270 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
271 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
272 if ((field_name
== 0 || *field_name
== '\0')
273 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
276 for (; variantno
< TYPE_NFIELDS (field_type
);
280 = TYPE_FIELD_TYPE (field_type
, variantno
);
281 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
284 subfieldno
< TYPE_NFIELDS (substruct_type
);
287 if (strcmp(TYPE_FIELD_NAME (substruct_type
,
298 error (_("there is no field named %s"), label
);
304 /* Unlabelled tuple element - go to next field. */
308 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
311 substruct_type
= struct_type
;
317 /* Skip static fields. */
318 while (fieldno
< TYPE_NFIELDS (struct_type
)
319 && field_is_static (&TYPE_FIELD (struct_type
,
322 subfieldno
= fieldno
;
323 if (fieldno
>= TYPE_NFIELDS (struct_type
))
324 error (_("too many initializers"));
325 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
326 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
327 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
328 error (_("don't know which variant you want to set"));
332 /* Here, struct_type is the type of the inner struct,
333 while substruct_type is the type of the inner struct.
334 These are the same for normal structures, but a variant struct
335 contains anonymous union fields that contain substruct fields.
336 The value fieldno is the index of the top-level (normal or
337 anonymous union) field in struct_field, while the value
338 subfieldno is the index of the actual real (named inner) field
339 in substruct_type. */
341 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
343 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
345 /* Now actually set the field in struct_val. */
347 /* Assign val to field fieldno. */
348 if (value_type (val
) != field_type
)
349 val
= value_cast (field_type
, val
);
351 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
352 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
354 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
355 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
357 modify_field (addr
, value_as_long (val
),
358 bitpos
% 8, bitsize
);
360 memcpy (addr
, value_contents (val
),
361 TYPE_LENGTH (value_type (val
)));
363 while (--nlabels
> 0);
368 /* Recursive helper function for setting elements of array tuples for
369 (the deleted) Chill. The target is ARRAY (which has bounds
370 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
371 and NOSIDE are as usual. Evaluates index expresions and sets the
372 specified element(s) of ARRAY to ELEMENT. Returns last index
376 init_array_element (struct value
*array
, struct value
*element
,
377 struct expression
*exp
, int *pos
,
378 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
381 int element_size
= TYPE_LENGTH (value_type (element
));
382 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
385 init_array_element (array
, element
, exp
, pos
, noside
,
386 low_bound
, high_bound
);
387 return init_array_element (array
, element
,
388 exp
, pos
, noside
, low_bound
, high_bound
);
390 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
394 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
395 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
396 if (low
< low_bound
|| high
> high_bound
)
397 error (_("tuple range index out of range"));
398 for (index
= low
; index
<= high
; index
++)
400 memcpy (value_contents_raw (array
)
401 + (index
- low_bound
) * element_size
,
402 value_contents (element
), element_size
);
407 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
408 if (index
< low_bound
|| index
> high_bound
)
409 error (_("tuple index out of range"));
410 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
411 value_contents (element
), element_size
);
417 value_f90_subarray (struct value
*array
,
418 struct expression
*exp
, int *pos
, enum noside noside
)
421 LONGEST low_bound
, high_bound
;
422 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
423 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
427 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
428 low_bound
= TYPE_LOW_BOUND (range
);
430 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
432 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
433 high_bound
= TYPE_HIGH_BOUND (range
);
435 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
437 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
441 /* Promote value ARG1 as appropriate before performing a unary operation
443 If the result is not appropriate for any particular language then it
444 needs to patch this function. */
447 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
452 *arg1
= coerce_ref (*arg1
);
453 type1
= check_typedef (value_type (*arg1
));
455 if (is_integral_type (type1
))
457 switch (language
->la_language
)
460 /* Perform integral promotion for ANSI C/C++.
461 If not appropropriate for any particular language
462 it needs to modify this function. */
464 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
465 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
466 *arg1
= value_cast (builtin_int
, *arg1
);
473 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
474 operation on those two operands.
475 If the result is not appropriate for any particular language then it
476 needs to patch this function. */
479 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
480 struct value
**arg1
, struct value
**arg2
)
482 struct type
*promoted_type
= NULL
;
486 *arg1
= coerce_ref (*arg1
);
487 *arg2
= coerce_ref (*arg2
);
489 type1
= check_typedef (value_type (*arg1
));
490 type2
= check_typedef (value_type (*arg2
));
492 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
493 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
494 && !is_integral_type (type1
))
495 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
496 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
497 && !is_integral_type (type2
)))
500 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
501 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
503 /* No promotion required. */
505 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
506 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
508 switch (language
->la_language
)
514 /* No promotion required. */
518 /* For other languages the result type is unchanged from gdb
519 version 6.7 for backward compatibility.
520 If either arg was long double, make sure that value is also long
521 double. Otherwise use double. */
522 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
523 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
524 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
526 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
530 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
531 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
533 /* No promotion required. */
536 /* Integral operations here. */
537 /* FIXME: Also mixed integral/booleans, with result an integer. */
539 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
540 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
541 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
542 int is_unsigned1
= TYPE_UNSIGNED (type1
);
543 int is_unsigned2
= TYPE_UNSIGNED (type2
);
544 unsigned int result_len
;
545 int unsigned_operation
;
547 /* Determine type length and signedness after promotion for
549 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
552 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
554 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
557 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
560 if (promoted_len1
> promoted_len2
)
562 unsigned_operation
= is_unsigned1
;
563 result_len
= promoted_len1
;
565 else if (promoted_len2
> promoted_len1
)
567 unsigned_operation
= is_unsigned2
;
568 result_len
= promoted_len2
;
572 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
573 result_len
= promoted_len1
;
576 switch (language
->la_language
)
582 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
584 promoted_type
= (unsigned_operation
585 ? builtin
->builtin_unsigned_int
586 : builtin
->builtin_int
);
588 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
590 promoted_type
= (unsigned_operation
591 ? builtin
->builtin_unsigned_long
592 : builtin
->builtin_long
);
596 promoted_type
= (unsigned_operation
597 ? builtin
->builtin_unsigned_long_long
598 : builtin
->builtin_long_long
);
603 /* For other languages the result type is unchanged from gdb
604 version 6.7 for backward compatibility.
605 If either arg was long long, make sure that value is also long
606 long. Otherwise use long. */
607 if (unsigned_operation
)
609 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
610 promoted_type
= builtin
->builtin_unsigned_long_long
;
612 promoted_type
= builtin
->builtin_unsigned_long
;
616 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
617 promoted_type
= builtin
->builtin_long_long
;
619 promoted_type
= builtin
->builtin_long
;
627 /* Promote both operands to common type. */
628 *arg1
= value_cast (promoted_type
, *arg1
);
629 *arg2
= value_cast (promoted_type
, *arg2
);
634 ptrmath_type_p (struct type
*type
)
636 type
= check_typedef (type
);
637 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
638 type
= TYPE_TARGET_TYPE (type
);
640 switch (TYPE_CODE (type
))
646 case TYPE_CODE_ARRAY
:
647 return current_language
->c_style_arrays
;
655 evaluate_subexp_standard (struct type
*expect_type
,
656 struct expression
*exp
, int *pos
,
661 int pc
, pc2
= 0, oldpos
;
662 struct value
*arg1
= NULL
;
663 struct value
*arg2
= NULL
;
667 struct value
**argvec
;
668 int upper
, lower
, retcode
;
672 struct type
**arg_types
;
676 op
= exp
->elts
[pc
].opcode
;
681 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
682 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
683 if (noside
== EVAL_SKIP
)
685 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
686 &exp
->elts
[pc
+ 3].string
,
689 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
694 return value_from_longest (exp
->elts
[pc
+ 1].type
,
695 exp
->elts
[pc
+ 2].longconst
);
699 return value_from_double (exp
->elts
[pc
+ 1].type
,
700 exp
->elts
[pc
+ 2].doubleconst
);
704 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
705 exp
->elts
[pc
+ 2].decfloatconst
);
709 if (noside
== EVAL_SKIP
)
712 /* JYG: We used to just return value_zero of the symbol type
713 if we're asked to avoid side effects. Otherwise we return
714 value_of_variable (...). However I'm not sure if
715 value_of_variable () has any side effect.
716 We need a full value object returned here for whatis_exp ()
717 to call evaluate_type () and then pass the full value to
718 value_rtti_target_type () if we are dealing with a pointer
719 or reference to a base class and print object is on. */
722 volatile struct gdb_exception except
;
723 struct value
*ret
= NULL
;
725 TRY_CATCH (except
, RETURN_MASK_ERROR
)
727 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
728 exp
->elts
[pc
+ 1].block
);
731 if (except
.reason
< 0)
733 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
734 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
), not_lval
);
736 throw_exception (except
);
745 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
749 const char *name
= &exp
->elts
[pc
+ 2].string
;
753 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
754 regno
= user_reg_map_name_to_regnum (current_gdbarch
,
755 name
, strlen (name
));
757 error (_("Register $%s not available."), name
);
759 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
760 a value with the appropriate register type. Unfortunately,
761 we don't have easy access to the type of user registers.
762 So for these registers, we fetch the register value regardless
763 of the evaluation mode. */
764 if (noside
== EVAL_AVOID_SIDE_EFFECTS
765 && regno
< gdbarch_num_regs (current_gdbarch
)
766 + gdbarch_num_pseudo_regs (current_gdbarch
))
767 val
= value_zero (register_type (current_gdbarch
, regno
), not_lval
);
769 val
= value_of_register (regno
, get_selected_frame (NULL
));
771 error (_("Value of register %s not available."), name
);
777 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
778 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
782 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
785 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
786 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
787 if (noside
== EVAL_SKIP
)
789 return value_string (&exp
->elts
[pc
+ 2].string
, tem
);
791 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
792 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
793 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
794 if (noside
== EVAL_SKIP
)
798 return (struct value
*) value_nsstring (&exp
->elts
[pc
+ 2].string
, tem
+ 1);
801 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
803 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
804 if (noside
== EVAL_SKIP
)
806 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
811 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
812 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
813 nargs
= tem3
- tem2
+ 1;
814 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
816 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
817 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
819 struct value
*rec
= allocate_value (expect_type
);
820 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
821 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
824 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
825 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
827 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
828 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
829 struct value
*array
= allocate_value (expect_type
);
830 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
831 LONGEST low_bound
, high_bound
, index
;
832 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
835 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
838 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
839 for (tem
= nargs
; --nargs
>= 0;)
841 struct value
*element
;
843 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
846 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
848 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
849 if (value_type (element
) != element_type
)
850 element
= value_cast (element_type
, element
);
853 int continue_pc
= *pos
;
855 index
= init_array_element (array
, element
, exp
, pos
, noside
,
856 low_bound
, high_bound
);
861 if (index
> high_bound
)
862 /* to avoid memory corruption */
863 error (_("Too many array elements"));
864 memcpy (value_contents_raw (array
)
865 + (index
- low_bound
) * element_size
,
866 value_contents (element
),
874 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
875 && TYPE_CODE (type
) == TYPE_CODE_SET
)
877 struct value
*set
= allocate_value (expect_type
);
878 gdb_byte
*valaddr
= value_contents_raw (set
);
879 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
880 struct type
*check_type
= element_type
;
881 LONGEST low_bound
, high_bound
;
883 /* get targettype of elementtype */
884 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
||
885 TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
886 check_type
= TYPE_TARGET_TYPE (check_type
);
888 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
889 error (_("(power)set type with unknown size"));
890 memset (valaddr
, '\0', TYPE_LENGTH (type
));
891 for (tem
= 0; tem
< nargs
; tem
++)
893 LONGEST range_low
, range_high
;
894 struct type
*range_low_type
, *range_high_type
;
895 struct value
*elem_val
;
896 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
899 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
900 range_low_type
= value_type (elem_val
);
901 range_low
= value_as_long (elem_val
);
902 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
903 range_high_type
= value_type (elem_val
);
904 range_high
= value_as_long (elem_val
);
908 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
909 range_low_type
= range_high_type
= value_type (elem_val
);
910 range_low
= range_high
= value_as_long (elem_val
);
912 /* check types of elements to avoid mixture of elements from
913 different types. Also check if type of element is "compatible"
914 with element type of powerset */
915 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
916 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
917 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
918 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
919 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
)) ||
920 (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
&&
921 (range_low_type
!= range_high_type
)))
922 /* different element modes */
923 error (_("POWERSET tuple elements of different mode"));
924 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
)) ||
925 (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
&&
926 range_low_type
!= check_type
))
927 error (_("incompatible POWERSET tuple elements"));
928 if (range_low
> range_high
)
930 warning (_("empty POWERSET tuple range"));
933 if (range_low
< low_bound
|| range_high
> high_bound
)
934 error (_("POWERSET tuple element out of range"));
935 range_low
-= low_bound
;
936 range_high
-= low_bound
;
937 for (; range_low
<= range_high
; range_low
++)
939 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
940 if (gdbarch_bits_big_endian (current_gdbarch
))
941 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
942 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
949 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
950 for (tem
= 0; tem
< nargs
; tem
++)
952 /* Ensure that array expressions are coerced into pointer objects. */
953 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
955 if (noside
== EVAL_SKIP
)
957 return value_array (tem2
, tem3
, argvec
);
961 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
963 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
965 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
966 if (noside
== EVAL_SKIP
)
968 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
971 case TERNOP_SLICE_COUNT
:
973 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
975 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
977 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
978 return value_slice (array
, lowbound
, length
);
982 /* Skip third and second args to evaluate the first one. */
983 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
984 if (value_logical_not (arg1
))
986 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
987 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
991 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
992 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
996 case OP_OBJC_SELECTOR
:
997 { /* Objective C @selector operator. */
998 char *sel
= &exp
->elts
[pc
+ 2].string
;
999 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1000 struct type
*selector_type
;
1002 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1003 if (noside
== EVAL_SKIP
)
1007 sel
[len
] = 0; /* Make sure it's terminated. */
1009 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1010 return value_from_longest (selector_type
, lookup_child_selector (sel
));
1013 case OP_OBJC_MSGCALL
:
1014 { /* Objective C message (method) call. */
1016 static CORE_ADDR responds_selector
= 0;
1017 static CORE_ADDR method_selector
= 0;
1019 CORE_ADDR selector
= 0;
1021 int struct_return
= 0;
1022 int sub_no_side
= 0;
1024 static struct value
*msg_send
= NULL
;
1025 static struct value
*msg_send_stret
= NULL
;
1026 static int gnu_runtime
= 0;
1028 struct value
*target
= NULL
;
1029 struct value
*method
= NULL
;
1030 struct value
*called_method
= NULL
;
1032 struct type
*selector_type
= NULL
;
1033 struct type
*long_type
;
1035 struct value
*ret
= NULL
;
1038 selector
= exp
->elts
[pc
+ 1].longconst
;
1039 nargs
= exp
->elts
[pc
+ 2].longconst
;
1040 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1045 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1046 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1048 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1049 sub_no_side
= EVAL_NORMAL
;
1051 sub_no_side
= noside
;
1053 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1055 if (value_as_long (target
) == 0)
1056 return value_from_longest (long_type
, 0);
1058 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1061 /* Find the method dispatch (Apple runtime) or method lookup
1062 (GNU runtime) function for Objective-C. These will be used
1063 to lookup the symbol information for the method. If we
1064 can't find any symbol information, then we'll use these to
1065 call the method, otherwise we can call the method
1066 directly. The msg_send_stret function is used in the special
1067 case of a method that returns a structure (Apple runtime
1071 struct type
*type
= selector_type
;
1072 type
= lookup_function_type (type
);
1073 type
= lookup_pointer_type (type
);
1074 type
= lookup_function_type (type
);
1075 type
= lookup_pointer_type (type
);
1077 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1079 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1081 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1082 msg_send_stret
= value_from_pointer (type
,
1083 value_as_address (msg_send_stret
));
1087 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1088 /* Special dispatcher for methods returning structs */
1090 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1093 /* Verify the target object responds to this method. The
1094 standard top-level 'Object' class uses a different name for
1095 the verification method than the non-standard, but more
1096 often used, 'NSObject' class. Make sure we check for both. */
1098 responds_selector
= lookup_child_selector ("respondsToSelector:");
1099 if (responds_selector
== 0)
1100 responds_selector
= lookup_child_selector ("respondsTo:");
1102 if (responds_selector
== 0)
1103 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1105 method_selector
= lookup_child_selector ("methodForSelector:");
1106 if (method_selector
== 0)
1107 method_selector
= lookup_child_selector ("methodFor:");
1109 if (method_selector
== 0)
1110 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1112 /* Call the verification method, to make sure that the target
1113 class implements the desired method. */
1115 argvec
[0] = msg_send
;
1117 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1118 argvec
[3] = value_from_longest (long_type
, selector
);
1121 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1124 /* Function objc_msg_lookup returns a pointer. */
1126 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1128 if (value_as_long (ret
) == 0)
1129 error (_("Target does not respond to this message selector."));
1131 /* Call "methodForSelector:" method, to get the address of a
1132 function method that implements this selector for this
1133 class. If we can find a symbol at that address, then we
1134 know the return type, parameter types etc. (that's a good
1137 argvec
[0] = msg_send
;
1139 argvec
[2] = value_from_longest (long_type
, method_selector
);
1140 argvec
[3] = value_from_longest (long_type
, selector
);
1143 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1147 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1150 /* ret should now be the selector. */
1152 addr
= value_as_long (ret
);
1155 struct symbol
*sym
= NULL
;
1156 /* Is it a high_level symbol? */
1158 sym
= find_pc_function (addr
);
1160 method
= value_of_variable (sym
, 0);
1163 /* If we found a method with symbol information, check to see
1164 if it returns a struct. Otherwise assume it doesn't. */
1170 struct type
*val_type
;
1172 funaddr
= find_function_addr (method
, &val_type
);
1174 b
= block_for_pc (funaddr
);
1176 CHECK_TYPEDEF (val_type
);
1178 if ((val_type
== NULL
)
1179 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1181 if (expect_type
!= NULL
)
1182 val_type
= expect_type
;
1185 struct_return
= using_struct_return (value_type (method
), val_type
);
1187 else if (expect_type
!= NULL
)
1189 struct_return
= using_struct_return (NULL
,
1190 check_typedef (expect_type
));
1193 /* Found a function symbol. Now we will substitute its
1194 value in place of the message dispatcher (obj_msgSend),
1195 so that we call the method directly instead of thru
1196 the dispatcher. The main reason for doing this is that
1197 we can now evaluate the return value and parameter values
1198 according to their known data types, in case we need to
1199 do things like promotion, dereferencing, special handling
1200 of structs and doubles, etc.
1202 We want to use the type signature of 'method', but still
1203 jump to objc_msgSend() or objc_msgSend_stret() to better
1204 mimic the behavior of the runtime. */
1208 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1209 error (_("method address has symbol information with non-function type; skipping"));
1211 VALUE_ADDRESS (method
) = value_as_address (msg_send_stret
);
1213 VALUE_ADDRESS (method
) = value_as_address (msg_send
);
1214 called_method
= method
;
1219 called_method
= msg_send_stret
;
1221 called_method
= msg_send
;
1224 if (noside
== EVAL_SKIP
)
1227 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1229 /* If the return type doesn't look like a function type,
1230 call an error. This can happen if somebody tries to
1231 turn a variable into a function call. This is here
1232 because people often want to call, eg, strcmp, which
1233 gdb doesn't know is a function. If gdb isn't asked for
1234 it's opinion (ie. through "whatis"), it won't offer
1237 struct type
*type
= value_type (called_method
);
1238 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1239 type
= TYPE_TARGET_TYPE (type
);
1240 type
= TYPE_TARGET_TYPE (type
);
1244 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1245 return allocate_value (expect_type
);
1247 return allocate_value (type
);
1250 error (_("Expression of type other than \"method returning ...\" used as a method"));
1253 /* Now depending on whether we found a symbol for the method,
1254 we will either call the runtime dispatcher or the method
1257 argvec
[0] = called_method
;
1259 argvec
[2] = value_from_longest (long_type
, selector
);
1260 /* User-supplied arguments. */
1261 for (tem
= 0; tem
< nargs
; tem
++)
1262 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1263 argvec
[tem
+ 3] = 0;
1265 if (gnu_runtime
&& (method
!= NULL
))
1267 /* Function objc_msg_lookup returns a pointer. */
1268 deprecated_set_value_type (argvec
[0],
1269 lookup_function_type (lookup_pointer_type (value_type (argvec
[0]))));
1270 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1273 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1280 op
= exp
->elts
[*pos
].opcode
;
1281 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1282 /* Allocate arg vector, including space for the function to be
1283 called in argvec[0] and a terminating NULL */
1284 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1285 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1288 /* First, evaluate the structure into arg2 */
1291 if (noside
== EVAL_SKIP
)
1294 if (op
== STRUCTOP_MEMBER
)
1296 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1300 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1303 /* If the function is a virtual function, then the
1304 aggregate value (providing the structure) plays
1305 its part by providing the vtable. Otherwise,
1306 it is just along for the ride: call the function
1309 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1311 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1312 != TYPE_CODE_METHODPTR
)
1313 error (_("Non-pointer-to-member value used in pointer-to-member "
1316 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1318 struct type
*method_type
= check_typedef (value_type (arg1
));
1319 arg1
= value_zero (method_type
, not_lval
);
1322 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1324 /* Now, say which argument to start evaluating from */
1327 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1329 /* Hair for method invocations */
1333 /* First, evaluate the structure into arg2 */
1335 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1336 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1337 if (noside
== EVAL_SKIP
)
1340 if (op
== STRUCTOP_STRUCT
)
1342 /* If v is a variable in a register, and the user types
1343 v.method (), this will produce an error, because v has
1346 A possible way around this would be to allocate a
1347 copy of the variable on the stack, copy in the
1348 contents, call the function, and copy out the
1349 contents. I.e. convert this from call by reference
1350 to call by copy-return (or whatever it's called).
1351 However, this does not work because it is not the
1352 same: the method being called could stash a copy of
1353 the address, and then future uses through that address
1354 (after the method returns) would be expected to
1355 use the variable itself, not some copy of it. */
1356 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1360 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1362 /* Now, say which argument to start evaluating from */
1367 /* Non-method function call */
1369 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1371 type
= value_type (argvec
[0]);
1372 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1373 type
= TYPE_TARGET_TYPE (type
);
1374 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1376 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1378 /* pai: FIXME This seems to be coercing arguments before
1379 * overload resolution has been done! */
1380 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1386 /* Evaluate arguments */
1387 for (; tem
<= nargs
; tem
++)
1389 /* Ensure that array expressions are coerced into pointer objects. */
1390 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1393 /* signal end of arglist */
1396 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1398 int static_memfuncp
;
1401 /* Method invocation : stuff "this" as first parameter */
1403 /* Name of method from expression */
1404 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1406 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1408 /* Language is C++, do some overload resolution before evaluation */
1409 struct value
*valp
= NULL
;
1411 /* Prepare list of argument types for overload resolution */
1412 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1413 for (ix
= 1; ix
<= nargs
; ix
++)
1414 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1416 (void) find_overload_match (arg_types
, nargs
, tstr
,
1417 1 /* method */ , 0 /* strict match */ ,
1418 &arg2
/* the object */ , NULL
,
1419 &valp
, NULL
, &static_memfuncp
);
1422 argvec
[1] = arg2
; /* the ``this'' pointer */
1423 argvec
[0] = valp
; /* use the method found after overload resolution */
1426 /* Non-C++ case -- or no overload resolution */
1428 struct value
*temp
= arg2
;
1429 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1431 op
== STRUCTOP_STRUCT
1432 ? "structure" : "structure pointer");
1433 /* value_struct_elt updates temp with the correct value
1434 of the ``this'' pointer if necessary, so modify argvec[1] to
1435 reflect any ``this'' changes. */
1436 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1437 VALUE_ADDRESS (temp
) + value_offset (temp
)
1438 + value_embedded_offset (temp
));
1439 argvec
[1] = arg2
; /* the ``this'' pointer */
1442 if (static_memfuncp
)
1444 argvec
[1] = argvec
[0];
1449 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1454 else if (op
== OP_VAR_VALUE
)
1456 /* Non-member function being called */
1457 /* fn: This can only be done for C++ functions. A C-style function
1458 in a C++ program, for instance, does not have the fields that
1459 are expected here */
1461 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1463 /* Language is C++, do some overload resolution before evaluation */
1464 struct symbol
*symp
;
1466 /* Prepare list of argument types for overload resolution */
1467 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1468 for (ix
= 1; ix
<= nargs
; ix
++)
1469 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1471 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1472 0 /* not method */ , 0 /* strict match */ ,
1473 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1476 /* Now fix the expression being evaluated */
1477 exp
->elts
[save_pos1
+2].symbol
= symp
;
1478 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1482 /* Not C++, or no overload resolution allowed */
1483 /* nothing to be done; argvec already correctly set up */
1488 /* It is probably a C-style function */
1489 /* nothing to be done; argvec already correctly set up */
1494 if (noside
== EVAL_SKIP
)
1496 if (argvec
[0] == NULL
)
1497 error (_("Cannot evaluate function -- may be inlined"));
1498 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1500 /* If the return type doesn't look like a function type, call an
1501 error. This can happen if somebody tries to turn a variable into
1502 a function call. This is here because people often want to
1503 call, eg, strcmp, which gdb doesn't know is a function. If
1504 gdb isn't asked for it's opinion (ie. through "whatis"),
1505 it won't offer it. */
1507 struct type
*ftype
=
1508 TYPE_TARGET_TYPE (value_type (argvec
[0]));
1511 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec
[0])));
1513 error (_("Expression of type other than \"Function returning ...\" used as function"));
1515 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1516 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1518 case OP_F77_UNDETERMINED_ARGLIST
:
1520 /* Remember that in F77, functions, substring ops and
1521 array subscript operations cannot be disambiguated
1522 at parse time. We have made all array subscript operations,
1523 substring operations as well as function calls come here
1524 and we now have to discover what the heck this thing actually was.
1525 If it is a function, we process just as if we got an OP_FUNCALL. */
1527 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1530 /* First determine the type code we are dealing with. */
1531 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1532 type
= check_typedef (value_type (arg1
));
1533 code
= TYPE_CODE (type
);
1535 if (code
== TYPE_CODE_PTR
)
1537 /* Fortran always passes variable to subroutines as pointer.
1538 So we need to look into its target type to see if it is
1539 array, string or function. If it is, we need to switch
1540 to the target value the original one points to. */
1541 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1543 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1544 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1545 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1547 arg1
= value_ind (arg1
);
1548 type
= check_typedef (value_type (arg1
));
1549 code
= TYPE_CODE (type
);
1555 case TYPE_CODE_ARRAY
:
1556 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1557 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1559 goto multi_f77_subscript
;
1561 case TYPE_CODE_STRING
:
1562 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1563 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1566 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1567 return value_subscript (arg1
, arg2
);
1571 case TYPE_CODE_FUNC
:
1572 /* It's a function call. */
1573 /* Allocate arg vector, including space for the function to be
1574 called in argvec[0] and a terminating NULL */
1575 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1578 for (; tem
<= nargs
; tem
++)
1579 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1580 argvec
[tem
] = 0; /* signal end of arglist */
1584 error (_("Cannot perform substring on this type"));
1588 /* We have a complex number, There should be 2 floating
1589 point numbers that compose it */
1591 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1592 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1594 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1596 case STRUCTOP_STRUCT
:
1597 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1598 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1599 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1600 if (noside
== EVAL_SKIP
)
1602 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1603 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1604 &exp
->elts
[pc
+ 2].string
,
1609 struct value
*temp
= arg1
;
1610 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1615 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1616 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1617 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1618 if (noside
== EVAL_SKIP
)
1621 /* JYG: if print object is on we need to replace the base type
1622 with rtti type in order to continue on with successful
1623 lookup of member / method only available in the rtti type. */
1625 struct type
*type
= value_type (arg1
);
1626 struct type
*real_type
;
1627 int full
, top
, using_enc
;
1628 struct value_print_options opts
;
1630 get_user_print_options (&opts
);
1631 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
) &&
1632 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1634 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1637 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1638 real_type
= lookup_pointer_type (real_type
);
1640 real_type
= lookup_reference_type (real_type
);
1642 arg1
= value_cast (real_type
, arg1
);
1647 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1648 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1649 &exp
->elts
[pc
+ 2].string
,
1654 struct value
*temp
= arg1
;
1655 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1656 NULL
, "structure pointer");
1659 case STRUCTOP_MEMBER
:
1661 if (op
== STRUCTOP_MEMBER
)
1662 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1664 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1666 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1668 if (noside
== EVAL_SKIP
)
1671 type
= check_typedef (value_type (arg2
));
1672 switch (TYPE_CODE (type
))
1674 case TYPE_CODE_METHODPTR
:
1675 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1676 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1679 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1680 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1681 return value_ind (arg2
);
1684 case TYPE_CODE_MEMBERPTR
:
1685 /* Now, convert these values to an address. */
1686 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1689 mem_offset
= value_as_long (arg2
);
1691 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1692 value_as_long (arg1
) + mem_offset
);
1693 return value_ind (arg3
);
1696 error (_("non-pointer-to-member value used in pointer-to-member construct"));
1700 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1701 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1702 if (noside
== EVAL_SKIP
)
1704 if (binop_user_defined_p (op
, arg1
, arg2
))
1705 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1707 return value_concat (arg1
, arg2
);
1710 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1711 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1713 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1715 if (binop_user_defined_p (op
, arg1
, arg2
))
1716 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1718 return value_assign (arg1
, arg2
);
1720 case BINOP_ASSIGN_MODIFY
:
1722 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1723 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1724 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1726 op
= exp
->elts
[pc
+ 1].opcode
;
1727 if (binop_user_defined_p (op
, arg1
, arg2
))
1728 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1729 else if (op
== BINOP_ADD
&& ptrmath_type_p (value_type (arg1
)))
1730 arg2
= value_ptradd (arg1
, arg2
);
1731 else if (op
== BINOP_SUB
&& ptrmath_type_p (value_type (arg1
)))
1732 arg2
= value_ptrsub (arg1
, arg2
);
1735 struct value
*tmp
= arg1
;
1737 /* For shift and integer exponentiation operations,
1738 only promote the first argument. */
1739 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1740 && is_integral_type (value_type (arg2
)))
1741 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
1743 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1745 arg2
= value_binop (tmp
, arg2
, op
);
1747 return value_assign (arg1
, arg2
);
1750 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1751 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1752 if (noside
== EVAL_SKIP
)
1754 if (binop_user_defined_p (op
, arg1
, arg2
))
1755 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1756 else if (ptrmath_type_p (value_type (arg1
)))
1757 return value_ptradd (arg1
, arg2
);
1758 else if (ptrmath_type_p (value_type (arg2
)))
1759 return value_ptradd (arg2
, arg1
);
1762 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1763 return value_binop (arg1
, arg2
, BINOP_ADD
);
1767 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1768 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1769 if (noside
== EVAL_SKIP
)
1771 if (binop_user_defined_p (op
, arg1
, arg2
))
1772 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1773 else if (ptrmath_type_p (value_type (arg1
)))
1775 if (ptrmath_type_p (value_type (arg2
)))
1777 /* FIXME -- should be ptrdiff_t */
1778 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1779 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1782 return value_ptrsub (arg1
, arg2
);
1786 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1787 return value_binop (arg1
, arg2
, BINOP_SUB
);
1798 case BINOP_BITWISE_AND
:
1799 case BINOP_BITWISE_IOR
:
1800 case BINOP_BITWISE_XOR
:
1801 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1802 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1803 if (noside
== EVAL_SKIP
)
1805 if (binop_user_defined_p (op
, arg1
, arg2
))
1806 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1809 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1810 fudge arg2 to avoid division-by-zero, the caller is
1811 (theoretically) only looking for the type of the result. */
1812 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1813 /* ??? Do we really want to test for BINOP_MOD here?
1814 The implementation of value_binop gives it a well-defined
1817 || op
== BINOP_INTDIV
1820 && value_logical_not (arg2
))
1822 struct value
*v_one
, *retval
;
1824 v_one
= value_one (value_type (arg2
), not_lval
);
1825 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1826 retval
= value_binop (arg1
, v_one
, op
);
1831 /* For shift and integer exponentiation operations,
1832 only promote the first argument. */
1833 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1834 && is_integral_type (value_type (arg2
)))
1835 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1837 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1839 return value_binop (arg1
, arg2
, op
);
1844 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1845 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1846 if (noside
== EVAL_SKIP
)
1848 error (_("':' operator used in invalid context"));
1850 case BINOP_SUBSCRIPT
:
1851 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1852 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1853 if (noside
== EVAL_SKIP
)
1855 if (binop_user_defined_p (op
, arg1
, arg2
))
1856 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1859 /* If the user attempts to subscript something that is not an
1860 array or pointer type (like a plain int variable for example),
1861 then report this as an error. */
1863 arg1
= coerce_ref (arg1
);
1864 type
= check_typedef (value_type (arg1
));
1865 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1866 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1868 if (TYPE_NAME (type
))
1869 error (_("cannot subscript something of type `%s'"),
1872 error (_("cannot subscript requested type"));
1875 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1876 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1878 return value_subscript (arg1
, arg2
);
1882 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1883 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1884 if (noside
== EVAL_SKIP
)
1886 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1887 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
1889 case MULTI_SUBSCRIPT
:
1891 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1892 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1895 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1896 /* FIXME: EVAL_SKIP handling may not be correct. */
1897 if (noside
== EVAL_SKIP
)
1908 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1909 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1911 /* If the user attempts to subscript something that has no target
1912 type (like a plain int variable for example), then report this
1915 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
1918 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1924 error (_("cannot subscript something of type `%s'"),
1925 TYPE_NAME (value_type (arg1
)));
1929 if (binop_user_defined_p (op
, arg1
, arg2
))
1931 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1935 arg1
= coerce_ref (arg1
);
1936 type
= check_typedef (value_type (arg1
));
1938 switch (TYPE_CODE (type
))
1941 case TYPE_CODE_ARRAY
:
1942 case TYPE_CODE_STRING
:
1943 arg1
= value_subscript (arg1
, arg2
);
1946 case TYPE_CODE_BITSTRING
:
1947 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1948 arg1
= value_bitstring_subscript (type
, arg1
, arg2
);
1952 if (TYPE_NAME (type
))
1953 error (_("cannot subscript something of type `%s'"),
1956 error (_("cannot subscript requested type"));
1962 multi_f77_subscript
:
1964 int subscript_array
[MAX_FORTRAN_DIMS
];
1965 int array_size_array
[MAX_FORTRAN_DIMS
];
1966 int ndimensions
= 1, i
;
1967 struct type
*tmp_type
;
1968 int offset_item
; /* The array offset where the item lives */
1970 if (nargs
> MAX_FORTRAN_DIMS
)
1971 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
1973 tmp_type
= check_typedef (value_type (arg1
));
1974 ndimensions
= calc_f77_array_dims (type
);
1976 if (nargs
!= ndimensions
)
1977 error (_("Wrong number of subscripts"));
1979 /* Now that we know we have a legal array subscript expression
1980 let us actually find out where this element exists in the array. */
1983 /* Take array indices left to right */
1984 for (i
= 0; i
< nargs
; i
++)
1986 /* Evaluate each subscript, It must be a legal integer in F77 */
1987 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1989 /* Fill in the subscript and array size arrays */
1991 subscript_array
[i
] = value_as_long (arg2
);
1994 /* Internal type of array is arranged right to left */
1995 for (i
= 0; i
< nargs
; i
++)
1997 upper
= f77_get_upperbound (tmp_type
);
1998 lower
= f77_get_lowerbound (tmp_type
);
2000 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
2002 /* Zero-normalize subscripts so that offsetting will work. */
2004 subscript_array
[nargs
- i
- 1] -= lower
;
2006 /* If we are at the bottom of a multidimensional
2007 array type then keep a ptr to the last ARRAY
2008 type around for use when calling value_subscript()
2009 below. This is done because we pretend to value_subscript
2010 that we actually have a one-dimensional array
2011 of base element type that we apply a simple
2015 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
2018 /* Now let us calculate the offset for this item */
2020 offset_item
= subscript_array
[ndimensions
- 1];
2022 for (i
= ndimensions
- 1; i
> 0; --i
)
2024 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
2026 /* Construct a value node with the value of the offset */
2028 arg2
= value_from_longest (builtin_type_int32
, offset_item
);
2030 /* Let us now play a dirty trick: we will take arg1
2031 which is a value node pointing to the topmost level
2032 of the multidimensional array-set and pretend
2033 that it is actually a array of the final element
2034 type, this will ensure that value_subscript()
2035 returns the correct type value */
2037 deprecated_set_value_type (arg1
, tmp_type
);
2038 return value_subscripted_rvalue (arg1
, arg2
, 0);
2041 case BINOP_LOGICAL_AND
:
2042 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2043 if (noside
== EVAL_SKIP
)
2045 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2050 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2053 if (binop_user_defined_p (op
, arg1
, arg2
))
2055 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2056 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2060 tem
= value_logical_not (arg1
);
2061 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2062 (tem
? EVAL_SKIP
: noside
));
2063 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2064 return value_from_longest (type
,
2065 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2068 case BINOP_LOGICAL_OR
:
2069 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2070 if (noside
== EVAL_SKIP
)
2072 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2077 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2080 if (binop_user_defined_p (op
, arg1
, arg2
))
2082 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2083 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2087 tem
= value_logical_not (arg1
);
2088 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2089 (!tem
? EVAL_SKIP
: noside
));
2090 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2091 return value_from_longest (type
,
2092 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2096 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2097 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2098 if (noside
== EVAL_SKIP
)
2100 if (binop_user_defined_p (op
, arg1
, arg2
))
2102 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2106 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2107 tem
= value_equal (arg1
, arg2
);
2108 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2109 return value_from_longest (type
, (LONGEST
) tem
);
2112 case BINOP_NOTEQUAL
:
2113 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2114 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2115 if (noside
== EVAL_SKIP
)
2117 if (binop_user_defined_p (op
, arg1
, arg2
))
2119 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2123 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2124 tem
= value_equal (arg1
, arg2
);
2125 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2126 return value_from_longest (type
, (LONGEST
) ! tem
);
2130 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2131 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2132 if (noside
== EVAL_SKIP
)
2134 if (binop_user_defined_p (op
, arg1
, arg2
))
2136 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2140 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2141 tem
= value_less (arg1
, arg2
);
2142 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2143 return value_from_longest (type
, (LONGEST
) tem
);
2147 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2148 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2149 if (noside
== EVAL_SKIP
)
2151 if (binop_user_defined_p (op
, arg1
, arg2
))
2153 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2157 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2158 tem
= value_less (arg2
, arg1
);
2159 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2160 return value_from_longest (type
, (LONGEST
) tem
);
2164 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2165 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2166 if (noside
== EVAL_SKIP
)
2168 if (binop_user_defined_p (op
, arg1
, arg2
))
2170 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2174 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2175 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2176 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2177 return value_from_longest (type
, (LONGEST
) tem
);
2181 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2182 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2183 if (noside
== EVAL_SKIP
)
2185 if (binop_user_defined_p (op
, arg1
, arg2
))
2187 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2191 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2192 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2193 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2194 return value_from_longest (type
, (LONGEST
) tem
);
2198 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2199 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2200 if (noside
== EVAL_SKIP
)
2202 type
= check_typedef (value_type (arg2
));
2203 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2204 error (_("Non-integral right operand for \"@\" operator."));
2205 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2207 return allocate_repeat_value (value_type (arg1
),
2208 longest_to_int (value_as_long (arg2
)));
2211 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2214 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2215 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2218 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2219 if (noside
== EVAL_SKIP
)
2221 if (unop_user_defined_p (op
, arg1
))
2222 return value_x_unop (arg1
, op
, noside
);
2225 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2226 return value_pos (arg1
);
2230 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2231 if (noside
== EVAL_SKIP
)
2233 if (unop_user_defined_p (op
, arg1
))
2234 return value_x_unop (arg1
, op
, noside
);
2237 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2238 return value_neg (arg1
);
2241 case UNOP_COMPLEMENT
:
2242 /* C++: check for and handle destructor names. */
2243 op
= exp
->elts
[*pos
].opcode
;
2245 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2246 if (noside
== EVAL_SKIP
)
2248 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2249 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2252 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2253 return value_complement (arg1
);
2256 case UNOP_LOGICAL_NOT
:
2257 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2258 if (noside
== EVAL_SKIP
)
2260 if (unop_user_defined_p (op
, arg1
))
2261 return value_x_unop (arg1
, op
, noside
);
2264 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2265 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2269 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2270 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2271 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2272 type
= check_typedef (value_type (arg1
));
2273 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2274 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2275 error (_("Attempt to dereference pointer to member without an object"));
2276 if (noside
== EVAL_SKIP
)
2278 if (unop_user_defined_p (op
, arg1
))
2279 return value_x_unop (arg1
, op
, noside
);
2280 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2282 type
= check_typedef (value_type (arg1
));
2283 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2284 || TYPE_CODE (type
) == TYPE_CODE_REF
2285 /* In C you can dereference an array to get the 1st elt. */
2286 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2288 return value_zero (TYPE_TARGET_TYPE (type
),
2290 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2291 /* GDB allows dereferencing an int. */
2292 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2295 error (_("Attempt to take contents of a non-pointer value."));
2298 /* Allow * on an integer so we can cast it to whatever we want.
2299 This returns an int, which seems like the most C-like thing to
2300 do. "long long" variables are rare enough that
2301 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2302 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2303 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2304 (CORE_ADDR
) value_as_address (arg1
));
2305 return value_ind (arg1
);
2308 /* C++: check for and handle pointer to members. */
2310 op
= exp
->elts
[*pos
].opcode
;
2312 if (noside
== EVAL_SKIP
)
2314 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2319 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
2324 if (noside
== EVAL_SKIP
)
2326 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2329 return evaluate_subexp_for_sizeof (exp
, pos
);
2333 type
= exp
->elts
[pc
+ 1].type
;
2334 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2335 if (noside
== EVAL_SKIP
)
2337 if (type
!= value_type (arg1
))
2338 arg1
= value_cast (type
, arg1
);
2343 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2344 if (noside
== EVAL_SKIP
)
2346 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2347 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2349 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2350 value_as_address (arg1
));
2352 case UNOP_MEMVAL_TLS
:
2354 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2355 if (noside
== EVAL_SKIP
)
2357 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2358 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2362 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2363 value_as_address (arg1
));
2364 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2367 case UNOP_PREINCREMENT
:
2368 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2369 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2371 else if (unop_user_defined_p (op
, arg1
))
2373 return value_x_unop (arg1
, op
, noside
);
2377 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2378 if (ptrmath_type_p (value_type (arg1
)))
2379 arg2
= value_ptradd (arg1
, arg2
);
2382 struct value
*tmp
= arg1
;
2383 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2384 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2387 return value_assign (arg1
, arg2
);
2390 case UNOP_PREDECREMENT
:
2391 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2392 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2394 else if (unop_user_defined_p (op
, arg1
))
2396 return value_x_unop (arg1
, op
, noside
);
2400 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2401 if (ptrmath_type_p (value_type (arg1
)))
2402 arg2
= value_ptrsub (arg1
, arg2
);
2405 struct value
*tmp
= arg1
;
2406 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2407 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2410 return value_assign (arg1
, arg2
);
2413 case UNOP_POSTINCREMENT
:
2414 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2415 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2417 else if (unop_user_defined_p (op
, arg1
))
2419 return value_x_unop (arg1
, op
, noside
);
2423 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2424 if (ptrmath_type_p (value_type (arg1
)))
2425 arg2
= value_ptradd (arg1
, arg2
);
2428 struct value
*tmp
= arg1
;
2429 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2430 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2433 value_assign (arg1
, arg2
);
2437 case UNOP_POSTDECREMENT
:
2438 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2439 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2441 else if (unop_user_defined_p (op
, arg1
))
2443 return value_x_unop (arg1
, op
, noside
);
2447 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2448 if (ptrmath_type_p (value_type (arg1
)))
2449 arg2
= value_ptrsub (arg1
, arg2
);
2452 struct value
*tmp
= arg1
;
2453 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2454 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2457 value_assign (arg1
, arg2
);
2463 return value_of_this (1);
2467 return value_of_local ("self", 1);
2470 /* The value is not supposed to be used. This is here to make it
2471 easier to accommodate expressions that contain types. */
2473 if (noside
== EVAL_SKIP
)
2475 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2476 return allocate_value (exp
->elts
[pc
+ 1].type
);
2478 error (_("Attempt to use a type name as an expression"));
2481 /* Removing this case and compiling with gcc -Wall reveals that
2482 a lot of cases are hitting this case. Some of these should
2483 probably be removed from expression.h; others are legitimate
2484 expressions which are (apparently) not fully implemented.
2486 If there are any cases landing here which mean a user error,
2487 then they should be separate cases, with more descriptive
2491 GDB does not (yet) know how to evaluate that kind of expression"));
2495 return value_from_longest (builtin_type_int8
, (LONGEST
) 1);
2498 /* Evaluate a subexpression of EXP, at index *POS,
2499 and return the address of that subexpression.
2500 Advance *POS over the subexpression.
2501 If the subexpression isn't an lvalue, get an error.
2502 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2503 then only the type of the result need be correct. */
2505 static struct value
*
2506 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2516 op
= exp
->elts
[pc
].opcode
;
2522 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2524 /* We can't optimize out "&*" if there's a user-defined operator*. */
2525 if (unop_user_defined_p (op
, x
))
2527 x
= value_x_unop (x
, op
, noside
);
2528 goto default_case_after_eval
;
2535 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2536 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2539 var
= exp
->elts
[pc
+ 2].symbol
;
2541 /* C++: The "address" of a reference should yield the address
2542 * of the object pointed to. Let value_addr() deal with it. */
2543 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2547 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2550 lookup_pointer_type (SYMBOL_TYPE (var
));
2551 enum address_class sym_class
= SYMBOL_CLASS (var
);
2553 if (sym_class
== LOC_CONST
2554 || sym_class
== LOC_CONST_BYTES
2555 || sym_class
== LOC_REGISTER
)
2556 error (_("Attempt to take address of register or constant."));
2559 value_zero (type
, not_lval
);
2561 else if (symbol_read_needs_frame (var
))
2565 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2567 return locate_var_value (var
, NULL
);
2570 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2571 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2572 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2573 &exp
->elts
[pc
+ 3].string
,
2576 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2581 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2582 default_case_after_eval
:
2583 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2585 struct type
*type
= check_typedef (value_type (x
));
2587 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2588 return value_zero (lookup_pointer_type (value_type (x
)),
2590 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2591 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2594 error (_("Attempt to take address of value not located in memory."));
2596 return value_addr (x
);
2600 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2601 When used in contexts where arrays will be coerced anyway, this is
2602 equivalent to `evaluate_subexp' but much faster because it avoids
2603 actually fetching array contents (perhaps obsolete now that we have
2606 Note that we currently only do the coercion for C expressions, where
2607 arrays are zero based and the coercion is correct. For other languages,
2608 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2609 to decide if coercion is appropriate.
2614 evaluate_subexp_with_coercion (struct expression
*exp
,
2615 int *pos
, enum noside noside
)
2623 op
= exp
->elts
[pc
].opcode
;
2628 var
= exp
->elts
[pc
+ 2].symbol
;
2629 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
2630 && CAST_IS_CONVERSION
)
2635 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2636 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var
)))),
2642 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2646 /* Evaluate a subexpression of EXP, at index *POS,
2647 and return a value for the size of that subexpression.
2648 Advance *POS over the subexpression. */
2650 static struct value
*
2651 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
2653 /* FIXME: This should be size_t. */
2654 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2661 op
= exp
->elts
[pc
].opcode
;
2665 /* This case is handled specially
2666 so that we avoid creating a value for the result type.
2667 If the result type is very big, it's desirable not to
2668 create a value unnecessarily. */
2671 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2672 type
= check_typedef (value_type (val
));
2673 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2674 && TYPE_CODE (type
) != TYPE_CODE_REF
2675 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2676 error (_("Attempt to take contents of a non-pointer value."));
2677 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2678 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2682 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2683 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2687 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2689 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2692 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2693 return value_from_longest (size_type
,
2694 (LONGEST
) TYPE_LENGTH (value_type (val
)));
2698 /* Parse a type expression in the string [P..P+LENGTH). */
2701 parse_and_eval_type (char *p
, int length
)
2703 char *tmp
= (char *) alloca (length
+ 4);
2704 struct expression
*expr
;
2706 memcpy (tmp
+ 1, p
, length
);
2707 tmp
[length
+ 1] = ')';
2708 tmp
[length
+ 2] = '0';
2709 tmp
[length
+ 3] = '\0';
2710 expr
= parse_expression (tmp
);
2711 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2712 error (_("Internal error in eval_type."));
2713 return expr
->elts
[1].type
;
2717 calc_f77_array_dims (struct type
*array_type
)
2720 struct type
*tmp_type
;
2722 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2723 error (_("Can't get dimensions for a non-array type"));
2725 tmp_type
= array_type
;
2727 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2729 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)