1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
27 #include "expression.h"
30 #include "language.h" /* For CAST_IS_CONVERSION */
31 #include "f-lang.h" /* for array bound stuff */
34 #include "objc-lang.h"
36 #include "parser-defs.h"
37 #include "cp-support.h"
39 #include "exceptions.h"
41 #include "user-regs.h"
43 #include "gdb_assert.h"
45 /* This is defined in valops.c */
46 extern int overload_resolution
;
48 /* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
49 on with successful lookup for member/method of the rtti type. */
50 extern int objectprint
;
52 /* Prototypes for local functions. */
54 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
56 static struct value
*evaluate_subexp_for_address (struct expression
*,
59 static struct value
*evaluate_subexp (struct type
*, struct expression
*,
62 static char *get_label (struct expression
*, int *);
64 static struct value
*evaluate_struct_tuple (struct value
*,
65 struct expression
*, int *,
68 static LONGEST
init_array_element (struct value
*, struct value
*,
69 struct expression
*, int *, enum noside
,
73 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
74 int *pos
, enum noside noside
)
76 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
77 (expect_type
, exp
, pos
, noside
);
80 /* Parse the string EXP as a C expression, evaluate it,
81 and return the result as a number. */
84 parse_and_eval_address (char *exp
)
86 struct expression
*expr
= parse_expression (exp
);
88 struct cleanup
*old_chain
=
89 make_cleanup (free_current_contents
, &expr
);
91 addr
= value_as_address (evaluate_expression (expr
));
92 do_cleanups (old_chain
);
96 /* Like parse_and_eval_address but takes a pointer to a char * variable
97 and advanced that variable across the characters parsed. */
100 parse_and_eval_address_1 (char **expptr
)
102 struct expression
*expr
= parse_exp_1 (expptr
, (struct block
*) 0, 0);
104 struct cleanup
*old_chain
=
105 make_cleanup (free_current_contents
, &expr
);
107 addr
= value_as_address (evaluate_expression (expr
));
108 do_cleanups (old_chain
);
112 /* Like parse_and_eval_address, but treats the value of the expression
113 as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
115 parse_and_eval_long (char *exp
)
117 struct expression
*expr
= parse_expression (exp
);
119 struct cleanup
*old_chain
=
120 make_cleanup (free_current_contents
, &expr
);
122 retval
= value_as_long (evaluate_expression (expr
));
123 do_cleanups (old_chain
);
128 parse_and_eval (char *exp
)
130 struct expression
*expr
= parse_expression (exp
);
132 struct cleanup
*old_chain
=
133 make_cleanup (free_current_contents
, &expr
);
135 val
= evaluate_expression (expr
);
136 do_cleanups (old_chain
);
140 /* Parse up to a comma (or to a closeparen)
141 in the string EXPP as an expression, evaluate it, and return the value.
142 EXPP is advanced to point to the comma. */
145 parse_to_comma_and_eval (char **expp
)
147 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
149 struct cleanup
*old_chain
=
150 make_cleanup (free_current_contents
, &expr
);
152 val
= evaluate_expression (expr
);
153 do_cleanups (old_chain
);
157 /* Evaluate an expression in internal prefix form
158 such as is constructed by parse.y.
160 See expression.h for info on the format of an expression. */
163 evaluate_expression (struct expression
*exp
)
166 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
169 /* Evaluate an expression, avoiding all memory references
170 and getting a value whose type alone is correct. */
173 evaluate_type (struct expression
*exp
)
176 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
179 /* Evaluate a subexpression, avoiding all memory references and
180 getting a value whose type alone is correct. */
183 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
185 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
188 /* Extract a field operation from an expression. If the subexpression
189 of EXP starting at *SUBEXP is not a structure dereference
190 operation, return NULL. Otherwise, return the name of the
191 dereferenced field, and advance *SUBEXP to point to the
192 subexpression of the left-hand-side of the dereference. This is
193 used when completing field names. */
196 extract_field_op (struct expression
*exp
, int *subexp
)
200 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
201 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
203 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
204 result
= &exp
->elts
[*subexp
+ 2].string
;
205 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
209 /* If the next expression is an OP_LABELED, skips past it,
210 returning the label. Otherwise, does nothing and returns NULL. */
213 get_label (struct expression
*exp
, int *pos
)
215 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
218 char *name
= &exp
->elts
[pc
+ 2].string
;
219 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
220 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
227 /* This function evaluates tuples (in (the deleted) Chill) or
228 brace-initializers (in C/C++) for structure types. */
230 static struct value
*
231 evaluate_struct_tuple (struct value
*struct_val
,
232 struct expression
*exp
,
233 int *pos
, enum noside noside
, int nargs
)
235 struct type
*struct_type
= check_typedef (value_type (struct_val
));
236 struct type
*substruct_type
= struct_type
;
237 struct type
*field_type
;
244 struct value
*val
= NULL
;
249 /* Skip past the labels, and count them. */
250 while (get_label (exp
, pos
) != NULL
)
255 char *label
= get_label (exp
, &pc
);
258 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
261 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
262 if (field_name
!= NULL
&& strcmp (field_name
, label
) == 0)
265 subfieldno
= fieldno
;
266 substruct_type
= struct_type
;
270 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
273 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
274 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
275 if ((field_name
== 0 || *field_name
== '\0')
276 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
279 for (; variantno
< TYPE_NFIELDS (field_type
);
283 = TYPE_FIELD_TYPE (field_type
, variantno
);
284 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
287 subfieldno
< TYPE_NFIELDS (substruct_type
);
290 if (strcmp(TYPE_FIELD_NAME (substruct_type
,
301 error (_("there is no field named %s"), label
);
307 /* Unlabelled tuple element - go to next field. */
311 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
314 substruct_type
= struct_type
;
320 /* Skip static fields. */
321 while (fieldno
< TYPE_NFIELDS (struct_type
)
322 && TYPE_FIELD_STATIC_KIND (struct_type
, fieldno
))
324 subfieldno
= fieldno
;
325 if (fieldno
>= TYPE_NFIELDS (struct_type
))
326 error (_("too many initializers"));
327 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
328 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
329 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
330 error (_("don't know which variant you want to set"));
334 /* Here, struct_type is the type of the inner struct,
335 while substruct_type is the type of the inner struct.
336 These are the same for normal structures, but a variant struct
337 contains anonymous union fields that contain substruct fields.
338 The value fieldno is the index of the top-level (normal or
339 anonymous union) field in struct_field, while the value
340 subfieldno is the index of the actual real (named inner) field
341 in substruct_type. */
343 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
345 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
347 /* Now actually set the field in struct_val. */
349 /* Assign val to field fieldno. */
350 if (value_type (val
) != field_type
)
351 val
= value_cast (field_type
, val
);
353 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
354 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
356 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
357 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
359 modify_field (addr
, value_as_long (val
),
360 bitpos
% 8, bitsize
);
362 memcpy (addr
, value_contents (val
),
363 TYPE_LENGTH (value_type (val
)));
365 while (--nlabels
> 0);
370 /* Recursive helper function for setting elements of array tuples for
371 (the deleted) Chill. The target is ARRAY (which has bounds
372 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
373 and NOSIDE are as usual. Evaluates index expresions and sets the
374 specified element(s) of ARRAY to ELEMENT. Returns last index
378 init_array_element (struct value
*array
, struct value
*element
,
379 struct expression
*exp
, int *pos
,
380 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
383 int element_size
= TYPE_LENGTH (value_type (element
));
384 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
387 init_array_element (array
, element
, exp
, pos
, noside
,
388 low_bound
, high_bound
);
389 return init_array_element (array
, element
,
390 exp
, pos
, noside
, low_bound
, high_bound
);
392 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
396 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
397 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
398 if (low
< low_bound
|| high
> high_bound
)
399 error (_("tuple range index out of range"));
400 for (index
= low
; index
<= high
; index
++)
402 memcpy (value_contents_raw (array
)
403 + (index
- low_bound
) * element_size
,
404 value_contents (element
), element_size
);
409 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
410 if (index
< low_bound
|| index
> high_bound
)
411 error (_("tuple index out of range"));
412 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
413 value_contents (element
), element_size
);
419 value_f90_subarray (struct value
*array
,
420 struct expression
*exp
, int *pos
, enum noside noside
)
423 LONGEST low_bound
, high_bound
;
424 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
425 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
429 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
430 low_bound
= TYPE_LOW_BOUND (range
);
432 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
434 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
435 high_bound
= TYPE_HIGH_BOUND (range
);
437 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
439 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
443 /* Promote value ARG1 as appropriate before performing a unary operation
445 If the result is not appropriate for any particular language then it
446 needs to patch this function. */
449 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
454 *arg1
= coerce_ref (*arg1
);
455 type1
= check_typedef (value_type (*arg1
));
457 if (is_integral_type (type1
))
459 switch (language
->la_language
)
462 /* Perform integral promotion for ANSI C/C++.
463 If not appropropriate for any particular language
464 it needs to modify this function. */
466 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
467 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
468 *arg1
= value_cast (builtin_int
, *arg1
);
475 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
476 operation on those two operands.
477 If the result is not appropriate for any particular language then it
478 needs to patch this function. */
481 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
482 struct value
**arg1
, struct value
**arg2
)
484 struct type
*promoted_type
= NULL
;
488 *arg1
= coerce_ref (*arg1
);
489 *arg2
= coerce_ref (*arg2
);
491 type1
= check_typedef (value_type (*arg1
));
492 type2
= check_typedef (value_type (*arg2
));
494 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
495 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
496 && !is_integral_type (type1
))
497 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
498 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
499 && !is_integral_type (type2
)))
502 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
503 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
505 /* No promotion required. */
507 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
508 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
510 switch (language
->la_language
)
516 /* No promotion required. */
520 /* For other languages the result type is unchanged from gdb
521 version 6.7 for backward compatibility.
522 If either arg was long double, make sure that value is also long
523 double. Otherwise use double. */
524 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
525 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
526 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
528 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
532 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
533 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
535 /* No promotion required. */
538 /* Integral operations here. */
539 /* FIXME: Also mixed integral/booleans, with result an integer. */
541 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
542 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
543 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
544 int is_unsigned1
= TYPE_UNSIGNED (type1
);
545 int is_unsigned2
= TYPE_UNSIGNED (type2
);
546 unsigned int result_len
;
547 int unsigned_operation
;
549 /* Determine type length and signedness after promotion for
551 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
554 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
556 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
559 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
562 if (promoted_len1
> promoted_len2
)
564 unsigned_operation
= is_unsigned1
;
565 result_len
= promoted_len1
;
567 else if (promoted_len2
> promoted_len1
)
569 unsigned_operation
= is_unsigned2
;
570 result_len
= promoted_len2
;
574 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
575 result_len
= promoted_len1
;
578 switch (language
->la_language
)
584 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
586 promoted_type
= (unsigned_operation
587 ? builtin
->builtin_unsigned_int
588 : builtin
->builtin_int
);
590 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
592 promoted_type
= (unsigned_operation
593 ? builtin
->builtin_unsigned_long
594 : builtin
->builtin_long
);
598 promoted_type
= (unsigned_operation
599 ? builtin
->builtin_unsigned_long_long
600 : builtin
->builtin_long_long
);
605 /* For other languages the result type is unchanged from gdb
606 version 6.7 for backward compatibility.
607 If either arg was long long, make sure that value is also long
608 long. Otherwise use long. */
609 if (unsigned_operation
)
611 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
612 promoted_type
= builtin
->builtin_unsigned_long_long
;
614 promoted_type
= builtin
->builtin_unsigned_long
;
618 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
619 promoted_type
= builtin
->builtin_long_long
;
621 promoted_type
= builtin
->builtin_long
;
629 /* Promote both operands to common type. */
630 *arg1
= value_cast (promoted_type
, *arg1
);
631 *arg2
= value_cast (promoted_type
, *arg2
);
636 ptrmath_type_p (struct type
*type
)
638 type
= check_typedef (type
);
639 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
640 type
= TYPE_TARGET_TYPE (type
);
642 switch (TYPE_CODE (type
))
648 case TYPE_CODE_ARRAY
:
649 return current_language
->c_style_arrays
;
657 evaluate_subexp_standard (struct type
*expect_type
,
658 struct expression
*exp
, int *pos
,
663 int pc
, pc2
= 0, oldpos
;
664 struct value
*arg1
= NULL
;
665 struct value
*arg2
= NULL
;
669 struct value
**argvec
;
670 int upper
, lower
, retcode
;
674 struct type
**arg_types
;
678 op
= exp
->elts
[pc
].opcode
;
683 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
684 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
685 if (noside
== EVAL_SKIP
)
687 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
688 &exp
->elts
[pc
+ 3].string
,
691 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
696 return value_from_longest (exp
->elts
[pc
+ 1].type
,
697 exp
->elts
[pc
+ 2].longconst
);
701 return value_from_double (exp
->elts
[pc
+ 1].type
,
702 exp
->elts
[pc
+ 2].doubleconst
);
706 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
707 exp
->elts
[pc
+ 2].decfloatconst
);
711 if (noside
== EVAL_SKIP
)
714 /* JYG: We used to just return value_zero of the symbol type
715 if we're asked to avoid side effects. Otherwise we return
716 value_of_variable (...). However I'm not sure if
717 value_of_variable () has any side effect.
718 We need a full value object returned here for whatis_exp ()
719 to call evaluate_type () and then pass the full value to
720 value_rtti_target_type () if we are dealing with a pointer
721 or reference to a base class and print object is on. */
724 volatile struct gdb_exception except
;
725 struct value
*ret
= NULL
;
727 TRY_CATCH (except
, RETURN_MASK_ERROR
)
729 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
730 exp
->elts
[pc
+ 1].block
);
733 if (except
.reason
< 0)
735 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
736 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
), not_lval
);
738 throw_exception (except
);
747 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
751 const char *name
= &exp
->elts
[pc
+ 2].string
;
755 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
756 regno
= user_reg_map_name_to_regnum (current_gdbarch
,
757 name
, strlen (name
));
759 error (_("Register $%s not available."), name
);
761 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
762 a value with the appropriate register type. Unfortunately,
763 we don't have easy access to the type of user registers.
764 So for these registers, we fetch the register value regardless
765 of the evaluation mode. */
766 if (noside
== EVAL_AVOID_SIDE_EFFECTS
767 && regno
< gdbarch_num_regs (current_gdbarch
)
768 + gdbarch_num_pseudo_regs (current_gdbarch
))
769 val
= value_zero (register_type (current_gdbarch
, regno
), not_lval
);
771 val
= value_of_register (regno
, get_selected_frame (NULL
));
773 error (_("Value of register %s not available."), name
);
779 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
780 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
784 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
787 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
788 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
789 if (noside
== EVAL_SKIP
)
791 return value_string (&exp
->elts
[pc
+ 2].string
, tem
);
793 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
794 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
795 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
796 if (noside
== EVAL_SKIP
)
800 return (struct value
*) value_nsstring (&exp
->elts
[pc
+ 2].string
, tem
+ 1);
803 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
805 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
806 if (noside
== EVAL_SKIP
)
808 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
813 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
814 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
815 nargs
= tem3
- tem2
+ 1;
816 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
818 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
819 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
821 struct value
*rec
= allocate_value (expect_type
);
822 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
823 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
826 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
827 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
829 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
830 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
831 struct value
*array
= allocate_value (expect_type
);
832 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
833 LONGEST low_bound
, high_bound
, index
;
834 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
837 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
840 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
841 for (tem
= nargs
; --nargs
>= 0;)
843 struct value
*element
;
845 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
848 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
850 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
851 if (value_type (element
) != element_type
)
852 element
= value_cast (element_type
, element
);
855 int continue_pc
= *pos
;
857 index
= init_array_element (array
, element
, exp
, pos
, noside
,
858 low_bound
, high_bound
);
863 if (index
> high_bound
)
864 /* to avoid memory corruption */
865 error (_("Too many array elements"));
866 memcpy (value_contents_raw (array
)
867 + (index
- low_bound
) * element_size
,
868 value_contents (element
),
876 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
877 && TYPE_CODE (type
) == TYPE_CODE_SET
)
879 struct value
*set
= allocate_value (expect_type
);
880 gdb_byte
*valaddr
= value_contents_raw (set
);
881 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
882 struct type
*check_type
= element_type
;
883 LONGEST low_bound
, high_bound
;
885 /* get targettype of elementtype */
886 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
||
887 TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
888 check_type
= TYPE_TARGET_TYPE (check_type
);
890 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
891 error (_("(power)set type with unknown size"));
892 memset (valaddr
, '\0', TYPE_LENGTH (type
));
893 for (tem
= 0; tem
< nargs
; tem
++)
895 LONGEST range_low
, range_high
;
896 struct type
*range_low_type
, *range_high_type
;
897 struct value
*elem_val
;
898 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
901 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
902 range_low_type
= value_type (elem_val
);
903 range_low
= value_as_long (elem_val
);
904 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
905 range_high_type
= value_type (elem_val
);
906 range_high
= value_as_long (elem_val
);
910 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
911 range_low_type
= range_high_type
= value_type (elem_val
);
912 range_low
= range_high
= value_as_long (elem_val
);
914 /* check types of elements to avoid mixture of elements from
915 different types. Also check if type of element is "compatible"
916 with element type of powerset */
917 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
918 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
919 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
920 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
921 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
)) ||
922 (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
&&
923 (range_low_type
!= range_high_type
)))
924 /* different element modes */
925 error (_("POWERSET tuple elements of different mode"));
926 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
)) ||
927 (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
&&
928 range_low_type
!= check_type
))
929 error (_("incompatible POWERSET tuple elements"));
930 if (range_low
> range_high
)
932 warning (_("empty POWERSET tuple range"));
935 if (range_low
< low_bound
|| range_high
> high_bound
)
936 error (_("POWERSET tuple element out of range"));
937 range_low
-= low_bound
;
938 range_high
-= low_bound
;
939 for (; range_low
<= range_high
; range_low
++)
941 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
942 if (gdbarch_bits_big_endian (current_gdbarch
))
943 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
944 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
951 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
952 for (tem
= 0; tem
< nargs
; tem
++)
954 /* Ensure that array expressions are coerced into pointer objects. */
955 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
957 if (noside
== EVAL_SKIP
)
959 return value_array (tem2
, tem3
, argvec
);
963 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
965 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
967 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
968 if (noside
== EVAL_SKIP
)
970 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
973 case TERNOP_SLICE_COUNT
:
975 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
977 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
979 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
980 return value_slice (array
, lowbound
, length
);
984 /* Skip third and second args to evaluate the first one. */
985 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
986 if (value_logical_not (arg1
))
988 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
989 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
993 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
994 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
998 case OP_OBJC_SELECTOR
:
999 { /* Objective C @selector operator. */
1000 char *sel
= &exp
->elts
[pc
+ 2].string
;
1001 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1003 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1004 if (noside
== EVAL_SKIP
)
1008 sel
[len
] = 0; /* Make sure it's terminated. */
1009 return value_from_longest (lookup_pointer_type (builtin_type_void
),
1010 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
;
1034 struct value
*ret
= NULL
;
1037 selector
= exp
->elts
[pc
+ 1].longconst
;
1038 nargs
= exp
->elts
[pc
+ 2].longconst
;
1039 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1044 selector_type
= lookup_pointer_type (builtin_type_void
);
1045 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1046 sub_no_side
= EVAL_NORMAL
;
1048 sub_no_side
= noside
;
1050 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1052 if (value_as_long (target
) == 0)
1053 return value_from_longest (builtin_type_long
, 0);
1055 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1058 /* Find the method dispatch (Apple runtime) or method lookup
1059 (GNU runtime) function for Objective-C. These will be used
1060 to lookup the symbol information for the method. If we
1061 can't find any symbol information, then we'll use these to
1062 call the method, otherwise we can call the method
1063 directly. The msg_send_stret function is used in the special
1064 case of a method that returns a structure (Apple runtime
1069 type
= lookup_pointer_type (builtin_type_void
);
1070 type
= lookup_function_type (type
);
1071 type
= lookup_pointer_type (type
);
1072 type
= lookup_function_type (type
);
1073 type
= lookup_pointer_type (type
);
1075 msg_send
= find_function_in_inferior ("objc_msg_lookup");
1076 msg_send_stret
= find_function_in_inferior ("objc_msg_lookup");
1078 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1079 msg_send_stret
= value_from_pointer (type
,
1080 value_as_address (msg_send_stret
));
1084 msg_send
= find_function_in_inferior ("objc_msgSend");
1085 /* Special dispatcher for methods returning structs */
1086 msg_send_stret
= find_function_in_inferior ("objc_msgSend_stret");
1089 /* Verify the target object responds to this method. The
1090 standard top-level 'Object' class uses a different name for
1091 the verification method than the non-standard, but more
1092 often used, 'NSObject' class. Make sure we check for both. */
1094 responds_selector
= lookup_child_selector ("respondsToSelector:");
1095 if (responds_selector
== 0)
1096 responds_selector
= lookup_child_selector ("respondsTo:");
1098 if (responds_selector
== 0)
1099 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1101 method_selector
= lookup_child_selector ("methodForSelector:");
1102 if (method_selector
== 0)
1103 method_selector
= lookup_child_selector ("methodFor:");
1105 if (method_selector
== 0)
1106 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1108 /* Call the verification method, to make sure that the target
1109 class implements the desired method. */
1111 argvec
[0] = msg_send
;
1113 argvec
[2] = value_from_longest (builtin_type_long
, responds_selector
);
1114 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
1117 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1120 /* Function objc_msg_lookup returns a pointer. */
1122 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1124 if (value_as_long (ret
) == 0)
1125 error (_("Target does not respond to this message selector."));
1127 /* Call "methodForSelector:" method, to get the address of a
1128 function method that implements this selector for this
1129 class. If we can find a symbol at that address, then we
1130 know the return type, parameter types etc. (that's a good
1133 argvec
[0] = msg_send
;
1135 argvec
[2] = value_from_longest (builtin_type_long
, method_selector
);
1136 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
1139 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1143 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1146 /* ret should now be the selector. */
1148 addr
= value_as_long (ret
);
1151 struct symbol
*sym
= NULL
;
1152 /* Is it a high_level symbol? */
1154 sym
= find_pc_function (addr
);
1156 method
= value_of_variable (sym
, 0);
1159 /* If we found a method with symbol information, check to see
1160 if it returns a struct. Otherwise assume it doesn't. */
1166 struct type
*val_type
;
1168 funaddr
= find_function_addr (method
, &val_type
);
1170 b
= block_for_pc (funaddr
);
1172 CHECK_TYPEDEF (val_type
);
1174 if ((val_type
== NULL
)
1175 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1177 if (expect_type
!= NULL
)
1178 val_type
= expect_type
;
1181 struct_return
= using_struct_return (value_type (method
), val_type
);
1183 else if (expect_type
!= NULL
)
1185 struct_return
= using_struct_return (NULL
,
1186 check_typedef (expect_type
));
1189 /* Found a function symbol. Now we will substitute its
1190 value in place of the message dispatcher (obj_msgSend),
1191 so that we call the method directly instead of thru
1192 the dispatcher. The main reason for doing this is that
1193 we can now evaluate the return value and parameter values
1194 according to their known data types, in case we need to
1195 do things like promotion, dereferencing, special handling
1196 of structs and doubles, etc.
1198 We want to use the type signature of 'method', but still
1199 jump to objc_msgSend() or objc_msgSend_stret() to better
1200 mimic the behavior of the runtime. */
1204 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1205 error (_("method address has symbol information with non-function type; skipping"));
1207 VALUE_ADDRESS (method
) = value_as_address (msg_send_stret
);
1209 VALUE_ADDRESS (method
) = value_as_address (msg_send
);
1210 called_method
= method
;
1215 called_method
= msg_send_stret
;
1217 called_method
= msg_send
;
1220 if (noside
== EVAL_SKIP
)
1223 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1225 /* If the return type doesn't look like a function type,
1226 call an error. This can happen if somebody tries to
1227 turn a variable into a function call. This is here
1228 because people often want to call, eg, strcmp, which
1229 gdb doesn't know is a function. If gdb isn't asked for
1230 it's opinion (ie. through "whatis"), it won't offer
1233 struct type
*type
= value_type (called_method
);
1234 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1235 type
= TYPE_TARGET_TYPE (type
);
1236 type
= TYPE_TARGET_TYPE (type
);
1240 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1241 return allocate_value (expect_type
);
1243 return allocate_value (type
);
1246 error (_("Expression of type other than \"method returning ...\" used as a method"));
1249 /* Now depending on whether we found a symbol for the method,
1250 we will either call the runtime dispatcher or the method
1253 argvec
[0] = called_method
;
1255 argvec
[2] = value_from_longest (builtin_type_long
, selector
);
1256 /* User-supplied arguments. */
1257 for (tem
= 0; tem
< nargs
; tem
++)
1258 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1259 argvec
[tem
+ 3] = 0;
1261 if (gnu_runtime
&& (method
!= NULL
))
1263 /* Function objc_msg_lookup returns a pointer. */
1264 deprecated_set_value_type (argvec
[0],
1265 lookup_function_type (lookup_pointer_type (value_type (argvec
[0]))));
1266 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1269 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1276 op
= exp
->elts
[*pos
].opcode
;
1277 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1278 /* Allocate arg vector, including space for the function to be
1279 called in argvec[0] and a terminating NULL */
1280 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1281 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1284 /* First, evaluate the structure into arg2 */
1287 if (noside
== EVAL_SKIP
)
1290 if (op
== STRUCTOP_MEMBER
)
1292 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1296 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1299 /* If the function is a virtual function, then the
1300 aggregate value (providing the structure) plays
1301 its part by providing the vtable. Otherwise,
1302 it is just along for the ride: call the function
1305 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1307 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1308 != TYPE_CODE_METHODPTR
)
1309 error (_("Non-pointer-to-member value used in pointer-to-member "
1312 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1314 struct type
*method_type
= check_typedef (value_type (arg1
));
1315 arg1
= value_zero (method_type
, not_lval
);
1318 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1320 /* Now, say which argument to start evaluating from */
1323 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1325 /* Hair for method invocations */
1329 /* First, evaluate the structure into arg2 */
1331 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1332 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1333 if (noside
== EVAL_SKIP
)
1336 if (op
== STRUCTOP_STRUCT
)
1338 /* If v is a variable in a register, and the user types
1339 v.method (), this will produce an error, because v has
1342 A possible way around this would be to allocate a
1343 copy of the variable on the stack, copy in the
1344 contents, call the function, and copy out the
1345 contents. I.e. convert this from call by reference
1346 to call by copy-return (or whatever it's called).
1347 However, this does not work because it is not the
1348 same: the method being called could stash a copy of
1349 the address, and then future uses through that address
1350 (after the method returns) would be expected to
1351 use the variable itself, not some copy of it. */
1352 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1356 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1358 /* Now, say which argument to start evaluating from */
1363 /* Non-method function call */
1365 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1367 type
= value_type (argvec
[0]);
1368 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1369 type
= TYPE_TARGET_TYPE (type
);
1370 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1372 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1374 /* pai: FIXME This seems to be coercing arguments before
1375 * overload resolution has been done! */
1376 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1382 /* Evaluate arguments */
1383 for (; tem
<= nargs
; tem
++)
1385 /* Ensure that array expressions are coerced into pointer objects. */
1386 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1389 /* signal end of arglist */
1392 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1394 int static_memfuncp
;
1397 /* Method invocation : stuff "this" as first parameter */
1399 /* Name of method from expression */
1400 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1402 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1404 /* Language is C++, do some overload resolution before evaluation */
1405 struct value
*valp
= NULL
;
1407 /* Prepare list of argument types for overload resolution */
1408 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1409 for (ix
= 1; ix
<= nargs
; ix
++)
1410 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1412 (void) find_overload_match (arg_types
, nargs
, tstr
,
1413 1 /* method */ , 0 /* strict match */ ,
1414 &arg2
/* the object */ , NULL
,
1415 &valp
, NULL
, &static_memfuncp
);
1418 argvec
[1] = arg2
; /* the ``this'' pointer */
1419 argvec
[0] = valp
; /* use the method found after overload resolution */
1422 /* Non-C++ case -- or no overload resolution */
1424 struct value
*temp
= arg2
;
1425 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1427 op
== STRUCTOP_STRUCT
1428 ? "structure" : "structure pointer");
1429 /* value_struct_elt updates temp with the correct value
1430 of the ``this'' pointer if necessary, so modify argvec[1] to
1431 reflect any ``this'' changes. */
1432 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1433 VALUE_ADDRESS (temp
) + value_offset (temp
)
1434 + value_embedded_offset (temp
));
1435 argvec
[1] = arg2
; /* the ``this'' pointer */
1438 if (static_memfuncp
)
1440 argvec
[1] = argvec
[0];
1445 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1450 else if (op
== OP_VAR_VALUE
)
1452 /* Non-member function being called */
1453 /* fn: This can only be done for C++ functions. A C-style function
1454 in a C++ program, for instance, does not have the fields that
1455 are expected here */
1457 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1459 /* Language is C++, do some overload resolution before evaluation */
1460 struct symbol
*symp
;
1462 /* Prepare list of argument types for overload resolution */
1463 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1464 for (ix
= 1; ix
<= nargs
; ix
++)
1465 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1467 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1468 0 /* not method */ , 0 /* strict match */ ,
1469 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1472 /* Now fix the expression being evaluated */
1473 exp
->elts
[save_pos1
+2].symbol
= symp
;
1474 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1478 /* Not C++, or no overload resolution allowed */
1479 /* nothing to be done; argvec already correctly set up */
1484 /* It is probably a C-style function */
1485 /* nothing to be done; argvec already correctly set up */
1490 if (noside
== EVAL_SKIP
)
1492 if (argvec
[0] == NULL
)
1493 error (_("Cannot evaluate function -- may be inlined"));
1494 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1496 /* If the return type doesn't look like a function type, call an
1497 error. This can happen if somebody tries to turn a variable into
1498 a function call. This is here because people often want to
1499 call, eg, strcmp, which gdb doesn't know is a function. If
1500 gdb isn't asked for it's opinion (ie. through "whatis"),
1501 it won't offer it. */
1503 struct type
*ftype
=
1504 TYPE_TARGET_TYPE (value_type (argvec
[0]));
1507 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec
[0])));
1509 error (_("Expression of type other than \"Function returning ...\" used as function"));
1511 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1512 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1514 case OP_F77_UNDETERMINED_ARGLIST
:
1516 /* Remember that in F77, functions, substring ops and
1517 array subscript operations cannot be disambiguated
1518 at parse time. We have made all array subscript operations,
1519 substring operations as well as function calls come here
1520 and we now have to discover what the heck this thing actually was.
1521 If it is a function, we process just as if we got an OP_FUNCALL. */
1523 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1526 /* First determine the type code we are dealing with. */
1527 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1528 type
= check_typedef (value_type (arg1
));
1529 code
= TYPE_CODE (type
);
1531 if (code
== TYPE_CODE_PTR
)
1533 /* Fortran always passes variable to subroutines as pointer.
1534 So we need to look into its target type to see if it is
1535 array, string or function. If it is, we need to switch
1536 to the target value the original one points to. */
1537 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1539 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1540 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1541 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1543 arg1
= value_ind (arg1
);
1544 type
= check_typedef (value_type (arg1
));
1545 code
= TYPE_CODE (type
);
1551 case TYPE_CODE_ARRAY
:
1552 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1553 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1555 goto multi_f77_subscript
;
1557 case TYPE_CODE_STRING
:
1558 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1559 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1562 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1563 return value_subscript (arg1
, arg2
);
1567 case TYPE_CODE_FUNC
:
1568 /* It's a function call. */
1569 /* Allocate arg vector, including space for the function to be
1570 called in argvec[0] and a terminating NULL */
1571 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1574 for (; tem
<= nargs
; tem
++)
1575 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1576 argvec
[tem
] = 0; /* signal end of arglist */
1580 error (_("Cannot perform substring on this type"));
1584 /* We have a complex number, There should be 2 floating
1585 point numbers that compose it */
1587 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1588 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1590 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1592 case STRUCTOP_STRUCT
:
1593 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1594 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1595 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1596 if (noside
== EVAL_SKIP
)
1598 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1599 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1600 &exp
->elts
[pc
+ 2].string
,
1605 struct value
*temp
= arg1
;
1606 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1611 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1612 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1613 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1614 if (noside
== EVAL_SKIP
)
1617 /* JYG: if print object is on we need to replace the base type
1618 with rtti type in order to continue on with successful
1619 lookup of member / method only available in the rtti type. */
1621 struct type
*type
= value_type (arg1
);
1622 struct type
*real_type
;
1623 int full
, top
, using_enc
;
1625 if (objectprint
&& TYPE_TARGET_TYPE(type
) &&
1626 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1628 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1631 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1632 real_type
= lookup_pointer_type (real_type
);
1634 real_type
= lookup_reference_type (real_type
);
1636 arg1
= value_cast (real_type
, arg1
);
1641 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1642 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1643 &exp
->elts
[pc
+ 2].string
,
1648 struct value
*temp
= arg1
;
1649 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1650 NULL
, "structure pointer");
1653 case STRUCTOP_MEMBER
:
1655 if (op
== STRUCTOP_MEMBER
)
1656 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1658 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1660 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1662 if (noside
== EVAL_SKIP
)
1665 type
= check_typedef (value_type (arg2
));
1666 switch (TYPE_CODE (type
))
1668 case TYPE_CODE_METHODPTR
:
1669 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1670 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1673 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1674 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1675 return value_ind (arg2
);
1678 case TYPE_CODE_MEMBERPTR
:
1679 /* Now, convert these values to an address. */
1680 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1683 mem_offset
= value_as_long (arg2
);
1685 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1686 value_as_long (arg1
) + mem_offset
);
1687 return value_ind (arg3
);
1690 error (_("non-pointer-to-member value used in pointer-to-member construct"));
1694 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1695 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1696 if (noside
== EVAL_SKIP
)
1698 if (binop_user_defined_p (op
, arg1
, arg2
))
1699 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1701 return value_concat (arg1
, arg2
);
1704 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1705 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1707 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1709 if (binop_user_defined_p (op
, arg1
, arg2
))
1710 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1712 return value_assign (arg1
, arg2
);
1714 case BINOP_ASSIGN_MODIFY
:
1716 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1717 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1718 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1720 op
= exp
->elts
[pc
+ 1].opcode
;
1721 if (binop_user_defined_p (op
, arg1
, arg2
))
1722 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1723 else if (op
== BINOP_ADD
&& ptrmath_type_p (value_type (arg1
)))
1724 arg2
= value_ptradd (arg1
, arg2
);
1725 else if (op
== BINOP_SUB
&& ptrmath_type_p (value_type (arg1
)))
1726 arg2
= value_ptrsub (arg1
, arg2
);
1728 arg2
= value_binop (arg1
, arg2
, op
);
1729 return value_assign (arg1
, arg2
);
1732 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1733 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1734 if (noside
== EVAL_SKIP
)
1736 if (binop_user_defined_p (op
, arg1
, arg2
))
1737 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1738 else if (ptrmath_type_p (value_type (arg1
)))
1739 return value_ptradd (arg1
, arg2
);
1740 else if (ptrmath_type_p (value_type (arg2
)))
1741 return value_ptradd (arg2
, arg1
);
1743 return value_binop (arg1
, arg2
, BINOP_ADD
);
1746 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1747 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1748 if (noside
== EVAL_SKIP
)
1750 if (binop_user_defined_p (op
, arg1
, arg2
))
1751 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1752 else if (ptrmath_type_p (value_type (arg1
)))
1754 if (ptrmath_type_p (value_type (arg2
)))
1756 /* FIXME -- should be ptrdiff_t */
1757 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1758 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1761 return value_ptrsub (arg1
, arg2
);
1764 return value_binop (arg1
, arg2
, BINOP_SUB
);
1774 case BINOP_BITWISE_AND
:
1775 case BINOP_BITWISE_IOR
:
1776 case BINOP_BITWISE_XOR
:
1777 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1778 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1779 if (noside
== EVAL_SKIP
)
1781 if (binop_user_defined_p (op
, arg1
, arg2
))
1782 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1785 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1786 fudge arg2 to avoid division-by-zero, the caller is
1787 (theoretically) only looking for the type of the result. */
1788 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1789 /* ??? Do we really want to test for BINOP_MOD here?
1790 The implementation of value_binop gives it a well-defined
1793 || op
== BINOP_INTDIV
1796 && value_logical_not (arg2
))
1798 struct value
*v_one
, *retval
;
1800 v_one
= value_one (value_type (arg2
), not_lval
);
1801 retval
= value_binop (arg1
, v_one
, op
);
1805 return value_binop (arg1
, arg2
, op
);
1809 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1810 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1811 if (noside
== EVAL_SKIP
)
1813 error (_("':' operator used in invalid context"));
1815 case BINOP_SUBSCRIPT
:
1816 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1817 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1818 if (noside
== EVAL_SKIP
)
1820 if (binop_user_defined_p (op
, arg1
, arg2
))
1821 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1824 /* If the user attempts to subscript something that is not an
1825 array or pointer type (like a plain int variable for example),
1826 then report this as an error. */
1828 arg1
= coerce_ref (arg1
);
1829 type
= check_typedef (value_type (arg1
));
1830 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1831 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1833 if (TYPE_NAME (type
))
1834 error (_("cannot subscript something of type `%s'"),
1837 error (_("cannot subscript requested type"));
1840 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1841 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1843 return value_subscript (arg1
, arg2
);
1847 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1848 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1849 if (noside
== EVAL_SKIP
)
1851 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1852 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
1854 case MULTI_SUBSCRIPT
:
1856 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1857 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1860 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1861 /* FIXME: EVAL_SKIP handling may not be correct. */
1862 if (noside
== EVAL_SKIP
)
1873 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1874 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1876 /* If the user attempts to subscript something that has no target
1877 type (like a plain int variable for example), then report this
1880 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
1883 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1889 error (_("cannot subscript something of type `%s'"),
1890 TYPE_NAME (value_type (arg1
)));
1894 if (binop_user_defined_p (op
, arg1
, arg2
))
1896 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1900 arg1
= coerce_ref (arg1
);
1901 type
= check_typedef (value_type (arg1
));
1903 switch (TYPE_CODE (type
))
1906 case TYPE_CODE_ARRAY
:
1907 case TYPE_CODE_STRING
:
1908 arg1
= value_subscript (arg1
, arg2
);
1911 case TYPE_CODE_BITSTRING
:
1912 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1913 arg1
= value_bitstring_subscript (type
, arg1
, arg2
);
1917 if (TYPE_NAME (type
))
1918 error (_("cannot subscript something of type `%s'"),
1921 error (_("cannot subscript requested type"));
1927 multi_f77_subscript
:
1929 int subscript_array
[MAX_FORTRAN_DIMS
];
1930 int array_size_array
[MAX_FORTRAN_DIMS
];
1931 int ndimensions
= 1, i
;
1932 struct type
*tmp_type
;
1933 int offset_item
; /* The array offset where the item lives */
1935 if (nargs
> MAX_FORTRAN_DIMS
)
1936 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
1938 tmp_type
= check_typedef (value_type (arg1
));
1939 ndimensions
= calc_f77_array_dims (type
);
1941 if (nargs
!= ndimensions
)
1942 error (_("Wrong number of subscripts"));
1944 /* Now that we know we have a legal array subscript expression
1945 let us actually find out where this element exists in the array. */
1948 /* Take array indices left to right */
1949 for (i
= 0; i
< nargs
; i
++)
1951 /* Evaluate each subscript, It must be a legal integer in F77 */
1952 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1954 /* Fill in the subscript and array size arrays */
1956 subscript_array
[i
] = value_as_long (arg2
);
1959 /* Internal type of array is arranged right to left */
1960 for (i
= 0; i
< nargs
; i
++)
1962 retcode
= f77_get_dynamic_upperbound (tmp_type
, &upper
);
1963 if (retcode
== BOUND_FETCH_ERROR
)
1964 error (_("Cannot obtain dynamic upper bound"));
1966 retcode
= f77_get_dynamic_lowerbound (tmp_type
, &lower
);
1967 if (retcode
== BOUND_FETCH_ERROR
)
1968 error (_("Cannot obtain dynamic lower bound"));
1970 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
1972 /* Zero-normalize subscripts so that offsetting will work. */
1974 subscript_array
[nargs
- i
- 1] -= lower
;
1976 /* If we are at the bottom of a multidimensional
1977 array type then keep a ptr to the last ARRAY
1978 type around for use when calling value_subscript()
1979 below. This is done because we pretend to value_subscript
1980 that we actually have a one-dimensional array
1981 of base element type that we apply a simple
1985 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
1988 /* Now let us calculate the offset for this item */
1990 offset_item
= subscript_array
[ndimensions
- 1];
1992 for (i
= ndimensions
- 1; i
> 0; --i
)
1994 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
1996 /* Construct a value node with the value of the offset */
1998 arg2
= value_from_longest (builtin_type_f_integer
, offset_item
);
2000 /* Let us now play a dirty trick: we will take arg1
2001 which is a value node pointing to the topmost level
2002 of the multidimensional array-set and pretend
2003 that it is actually a array of the final element
2004 type, this will ensure that value_subscript()
2005 returns the correct type value */
2007 deprecated_set_value_type (arg1
, tmp_type
);
2008 return value_subscripted_rvalue (arg1
, arg2
, 0);
2011 case BINOP_LOGICAL_AND
:
2012 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2013 if (noside
== EVAL_SKIP
)
2015 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2020 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2023 if (binop_user_defined_p (op
, arg1
, arg2
))
2025 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2026 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2030 tem
= value_logical_not (arg1
);
2031 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2032 (tem
? EVAL_SKIP
: noside
));
2033 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2034 return value_from_longest (type
,
2035 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2038 case BINOP_LOGICAL_OR
:
2039 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2040 if (noside
== EVAL_SKIP
)
2042 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2047 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2050 if (binop_user_defined_p (op
, arg1
, arg2
))
2052 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2053 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2057 tem
= value_logical_not (arg1
);
2058 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2059 (!tem
? EVAL_SKIP
: noside
));
2060 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2061 return value_from_longest (type
,
2062 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2066 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2067 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2068 if (noside
== EVAL_SKIP
)
2070 if (binop_user_defined_p (op
, arg1
, arg2
))
2072 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2076 tem
= value_equal (arg1
, arg2
);
2077 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2078 return value_from_longest (type
, (LONGEST
) tem
);
2081 case BINOP_NOTEQUAL
:
2082 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2083 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2084 if (noside
== EVAL_SKIP
)
2086 if (binop_user_defined_p (op
, arg1
, arg2
))
2088 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2092 tem
= value_equal (arg1
, arg2
);
2093 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2094 return value_from_longest (type
, (LONGEST
) ! tem
);
2098 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2099 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2100 if (noside
== EVAL_SKIP
)
2102 if (binop_user_defined_p (op
, arg1
, arg2
))
2104 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2108 tem
= value_less (arg1
, arg2
);
2109 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2110 return value_from_longest (type
, (LONGEST
) tem
);
2114 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2115 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2116 if (noside
== EVAL_SKIP
)
2118 if (binop_user_defined_p (op
, arg1
, arg2
))
2120 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2124 tem
= value_less (arg2
, arg1
);
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 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2141 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2142 return value_from_longest (type
, (LONGEST
) tem
);
2146 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2147 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2148 if (noside
== EVAL_SKIP
)
2150 if (binop_user_defined_p (op
, arg1
, arg2
))
2152 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2156 tem
= value_less (arg1
, arg2
) || value_equal (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 (NULL_TYPE
, exp
, pos
, noside
);
2164 if (noside
== EVAL_SKIP
)
2166 type
= check_typedef (value_type (arg2
));
2167 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2168 error (_("Non-integral right operand for \"@\" operator."));
2169 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2171 return allocate_repeat_value (value_type (arg1
),
2172 longest_to_int (value_as_long (arg2
)));
2175 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2178 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2179 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2182 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2183 if (noside
== EVAL_SKIP
)
2185 if (unop_user_defined_p (op
, arg1
))
2186 return value_x_unop (arg1
, op
, noside
);
2188 return value_pos (arg1
);
2191 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2192 if (noside
== EVAL_SKIP
)
2194 if (unop_user_defined_p (op
, arg1
))
2195 return value_x_unop (arg1
, op
, noside
);
2197 return value_neg (arg1
);
2199 case UNOP_COMPLEMENT
:
2200 /* C++: check for and handle destructor names. */
2201 op
= exp
->elts
[*pos
].opcode
;
2203 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2204 if (noside
== EVAL_SKIP
)
2206 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2207 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2209 return value_complement (arg1
);
2211 case UNOP_LOGICAL_NOT
:
2212 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2213 if (noside
== EVAL_SKIP
)
2215 if (unop_user_defined_p (op
, arg1
))
2216 return value_x_unop (arg1
, op
, noside
);
2219 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2220 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2224 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2225 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2226 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2227 type
= check_typedef (value_type (arg1
));
2228 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2229 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2230 error (_("Attempt to dereference pointer to member without an object"));
2231 if (noside
== EVAL_SKIP
)
2233 if (unop_user_defined_p (op
, arg1
))
2234 return value_x_unop (arg1
, op
, noside
);
2235 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2237 type
= check_typedef (value_type (arg1
));
2238 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2239 || TYPE_CODE (type
) == TYPE_CODE_REF
2240 /* In C you can dereference an array to get the 1st elt. */
2241 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2243 return value_zero (TYPE_TARGET_TYPE (type
),
2245 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2246 /* GDB allows dereferencing an int. */
2247 return value_zero (builtin_type_int
, lval_memory
);
2249 error (_("Attempt to take contents of a non-pointer value."));
2251 return value_ind (arg1
);
2254 /* C++: check for and handle pointer to members. */
2256 op
= exp
->elts
[*pos
].opcode
;
2258 if (noside
== EVAL_SKIP
)
2260 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2265 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
2270 if (noside
== EVAL_SKIP
)
2272 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2275 return evaluate_subexp_for_sizeof (exp
, pos
);
2279 type
= exp
->elts
[pc
+ 1].type
;
2280 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2281 if (noside
== EVAL_SKIP
)
2283 if (type
!= value_type (arg1
))
2284 arg1
= value_cast (type
, arg1
);
2289 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2290 if (noside
== EVAL_SKIP
)
2292 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2293 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2295 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2296 value_as_address (arg1
));
2298 case UNOP_MEMVAL_TLS
:
2300 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2301 if (noside
== EVAL_SKIP
)
2303 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2304 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2308 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2309 value_as_address (arg1
));
2310 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2313 case UNOP_PREINCREMENT
:
2314 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2315 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2317 else if (unop_user_defined_p (op
, arg1
))
2319 return value_x_unop (arg1
, op
, noside
);
2323 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2324 if (ptrmath_type_p (value_type (arg1
)))
2325 arg2
= value_ptradd (arg1
, arg2
);
2327 arg2
= value_binop (arg1
, arg2
, BINOP_ADD
);
2329 return value_assign (arg1
, arg2
);
2332 case UNOP_PREDECREMENT
:
2333 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2334 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2336 else if (unop_user_defined_p (op
, arg1
))
2338 return value_x_unop (arg1
, op
, noside
);
2342 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2343 if (ptrmath_type_p (value_type (arg1
)))
2344 arg2
= value_ptrsub (arg1
, arg2
);
2346 arg2
= value_binop (arg1
, arg2
, BINOP_SUB
);
2348 return value_assign (arg1
, arg2
);
2351 case UNOP_POSTINCREMENT
:
2352 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2353 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2355 else if (unop_user_defined_p (op
, arg1
))
2357 return value_x_unop (arg1
, op
, noside
);
2361 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2362 if (ptrmath_type_p (value_type (arg1
)))
2363 arg2
= value_ptradd (arg1
, arg2
);
2365 arg2
= value_binop (arg1
, arg2
, BINOP_ADD
);
2367 value_assign (arg1
, arg2
);
2371 case UNOP_POSTDECREMENT
:
2372 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2373 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2375 else if (unop_user_defined_p (op
, arg1
))
2377 return value_x_unop (arg1
, op
, noside
);
2381 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2382 if (ptrmath_type_p (value_type (arg1
)))
2383 arg2
= value_ptrsub (arg1
, arg2
);
2385 arg2
= value_binop (arg1
, arg2
, BINOP_SUB
);
2387 value_assign (arg1
, arg2
);
2393 return value_of_this (1);
2397 return value_of_local ("self", 1);
2400 /* The value is not supposed to be used. This is here to make it
2401 easier to accommodate expressions that contain types. */
2403 if (noside
== EVAL_SKIP
)
2405 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2406 return allocate_value (exp
->elts
[pc
+ 1].type
);
2408 error (_("Attempt to use a type name as an expression"));
2411 /* Removing this case and compiling with gcc -Wall reveals that
2412 a lot of cases are hitting this case. Some of these should
2413 probably be removed from expression.h; others are legitimate
2414 expressions which are (apparently) not fully implemented.
2416 If there are any cases landing here which mean a user error,
2417 then they should be separate cases, with more descriptive
2421 GDB does not (yet) know how to evaluate that kind of expression"));
2425 return value_from_longest (builtin_type_long
, (LONGEST
) 1);
2428 /* Evaluate a subexpression of EXP, at index *POS,
2429 and return the address of that subexpression.
2430 Advance *POS over the subexpression.
2431 If the subexpression isn't an lvalue, get an error.
2432 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2433 then only the type of the result need be correct. */
2435 static struct value
*
2436 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2446 op
= exp
->elts
[pc
].opcode
;
2452 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2454 /* We can't optimize out "&*" if there's a user-defined operator*. */
2455 if (unop_user_defined_p (op
, x
))
2457 x
= value_x_unop (x
, op
, noside
);
2458 goto default_case_after_eval
;
2465 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2466 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2469 var
= exp
->elts
[pc
+ 2].symbol
;
2471 /* C++: The "address" of a reference should yield the address
2472 * of the object pointed to. Let value_addr() deal with it. */
2473 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2477 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2480 lookup_pointer_type (SYMBOL_TYPE (var
));
2481 enum address_class sym_class
= SYMBOL_CLASS (var
);
2483 if (sym_class
== LOC_CONST
2484 || sym_class
== LOC_CONST_BYTES
2485 || sym_class
== LOC_REGISTER
)
2486 error (_("Attempt to take address of register or constant."));
2489 value_zero (type
, not_lval
);
2491 else if (symbol_read_needs_frame (var
))
2495 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2497 return locate_var_value (var
, NULL
);
2500 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2501 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2502 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2503 &exp
->elts
[pc
+ 3].string
,
2506 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2511 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2512 default_case_after_eval
:
2513 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2515 struct type
*type
= check_typedef (value_type (x
));
2517 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2518 return value_zero (lookup_pointer_type (value_type (x
)),
2520 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2521 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2524 error (_("Attempt to take address of value not located in memory."));
2526 return value_addr (x
);
2530 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2531 When used in contexts where arrays will be coerced anyway, this is
2532 equivalent to `evaluate_subexp' but much faster because it avoids
2533 actually fetching array contents (perhaps obsolete now that we have
2536 Note that we currently only do the coercion for C expressions, where
2537 arrays are zero based and the coercion is correct. For other languages,
2538 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2539 to decide if coercion is appropriate.
2544 evaluate_subexp_with_coercion (struct expression
*exp
,
2545 int *pos
, enum noside noside
)
2553 op
= exp
->elts
[pc
].opcode
;
2558 var
= exp
->elts
[pc
+ 2].symbol
;
2559 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
2560 && CAST_IS_CONVERSION
)
2565 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2566 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var
)))),
2572 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2576 /* Evaluate a subexpression of EXP, at index *POS,
2577 and return a value for the size of that subexpression.
2578 Advance *POS over the subexpression. */
2580 static struct value
*
2581 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
2583 /* FIXME: This should be size_t. */
2584 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2591 op
= exp
->elts
[pc
].opcode
;
2595 /* This case is handled specially
2596 so that we avoid creating a value for the result type.
2597 If the result type is very big, it's desirable not to
2598 create a value unnecessarily. */
2601 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2602 type
= check_typedef (value_type (val
));
2603 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2604 && TYPE_CODE (type
) != TYPE_CODE_REF
2605 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2606 error (_("Attempt to take contents of a non-pointer value."));
2607 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2608 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2612 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2613 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2617 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2619 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2622 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2623 return value_from_longest (size_type
,
2624 (LONGEST
) TYPE_LENGTH (value_type (val
)));
2628 /* Parse a type expression in the string [P..P+LENGTH). */
2631 parse_and_eval_type (char *p
, int length
)
2633 char *tmp
= (char *) alloca (length
+ 4);
2634 struct expression
*expr
;
2636 memcpy (tmp
+ 1, p
, length
);
2637 tmp
[length
+ 1] = ')';
2638 tmp
[length
+ 2] = '0';
2639 tmp
[length
+ 3] = '\0';
2640 expr
= parse_expression (tmp
);
2641 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2642 error (_("Internal error in eval_type."));
2643 return expr
->elts
[1].type
;
2647 calc_f77_array_dims (struct type
*array_type
)
2650 struct type
*tmp_type
;
2652 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2653 error (_("Can't get dimensions for a non-array type"));
2655 tmp_type
= array_type
;
2657 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2659 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)