1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008,
5 2009 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
27 #include "expression.h"
30 #include "language.h" /* For CAST_IS_CONVERSION */
31 #include "f-lang.h" /* for array bound stuff */
34 #include "objc-lang.h"
36 #include "parser-defs.h"
37 #include "cp-support.h"
39 #include "exceptions.h"
41 #include "user-regs.h"
43 #include "python/python.h"
45 #include "gdb_assert.h"
49 /* This is defined in valops.c */
50 extern int overload_resolution
;
52 /* Prototypes for local functions. */
54 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
56 static struct value
*evaluate_subexp_for_address (struct expression
*,
59 static 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
);
416 static struct value
*
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 (exp
->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 (exp
->gdbarch
)
766 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
767 val
= value_zero (register_type (exp
->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 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
790 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
792 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
793 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
794 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
795 if (noside
== EVAL_SKIP
)
799 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
802 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
804 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
805 if (noside
== EVAL_SKIP
)
807 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
812 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
813 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
814 nargs
= tem3
- tem2
+ 1;
815 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
817 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
818 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
820 struct value
*rec
= allocate_value (expect_type
);
821 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
822 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
825 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
826 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
828 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
829 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
830 struct value
*array
= allocate_value (expect_type
);
831 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
832 LONGEST low_bound
, high_bound
, index
;
833 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
836 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
839 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
840 for (tem
= nargs
; --nargs
>= 0;)
842 struct value
*element
;
844 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
847 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
849 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
850 if (value_type (element
) != element_type
)
851 element
= value_cast (element_type
, element
);
854 int continue_pc
= *pos
;
856 index
= init_array_element (array
, element
, exp
, pos
, noside
,
857 low_bound
, high_bound
);
862 if (index
> high_bound
)
863 /* to avoid memory corruption */
864 error (_("Too many array elements"));
865 memcpy (value_contents_raw (array
)
866 + (index
- low_bound
) * element_size
,
867 value_contents (element
),
875 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
876 && TYPE_CODE (type
) == TYPE_CODE_SET
)
878 struct value
*set
= allocate_value (expect_type
);
879 gdb_byte
*valaddr
= value_contents_raw (set
);
880 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
881 struct type
*check_type
= element_type
;
882 LONGEST low_bound
, high_bound
;
884 /* get targettype of elementtype */
885 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
||
886 TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
887 check_type
= TYPE_TARGET_TYPE (check_type
);
889 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
890 error (_("(power)set type with unknown size"));
891 memset (valaddr
, '\0', TYPE_LENGTH (type
));
892 for (tem
= 0; tem
< nargs
; tem
++)
894 LONGEST range_low
, range_high
;
895 struct type
*range_low_type
, *range_high_type
;
896 struct value
*elem_val
;
897 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
900 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
901 range_low_type
= value_type (elem_val
);
902 range_low
= value_as_long (elem_val
);
903 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
904 range_high_type
= value_type (elem_val
);
905 range_high
= value_as_long (elem_val
);
909 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
910 range_low_type
= range_high_type
= value_type (elem_val
);
911 range_low
= range_high
= value_as_long (elem_val
);
913 /* check types of elements to avoid mixture of elements from
914 different types. Also check if type of element is "compatible"
915 with element type of powerset */
916 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
917 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
918 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
919 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
920 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
)) ||
921 (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
&&
922 (range_low_type
!= range_high_type
)))
923 /* different element modes */
924 error (_("POWERSET tuple elements of different mode"));
925 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
)) ||
926 (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
&&
927 range_low_type
!= check_type
))
928 error (_("incompatible POWERSET tuple elements"));
929 if (range_low
> range_high
)
931 warning (_("empty POWERSET tuple range"));
934 if (range_low
< low_bound
|| range_high
> high_bound
)
935 error (_("POWERSET tuple element out of range"));
936 range_low
-= low_bound
;
937 range_high
-= low_bound
;
938 for (; range_low
<= range_high
; range_low
++)
940 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
941 if (gdbarch_bits_big_endian (current_gdbarch
))
942 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
943 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
950 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
951 for (tem
= 0; tem
< nargs
; tem
++)
953 /* Ensure that array expressions are coerced into pointer objects. */
954 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
956 if (noside
== EVAL_SKIP
)
958 return value_array (tem2
, tem3
, argvec
);
962 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
964 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
966 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
967 if (noside
== EVAL_SKIP
)
969 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
972 case TERNOP_SLICE_COUNT
:
974 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
976 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
978 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
979 return value_slice (array
, lowbound
, length
);
983 /* Skip third and second args to evaluate the first one. */
984 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
985 if (value_logical_not (arg1
))
987 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
988 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
992 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
993 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
997 case OP_OBJC_SELECTOR
:
998 { /* Objective C @selector operator. */
999 char *sel
= &exp
->elts
[pc
+ 2].string
;
1000 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1001 struct type
*selector_type
;
1003 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1004 if (noside
== EVAL_SKIP
)
1008 sel
[len
] = 0; /* Make sure it's terminated. */
1010 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1011 return value_from_longest (selector_type
,
1012 lookup_child_selector (exp
->gdbarch
, sel
));
1015 case OP_OBJC_MSGCALL
:
1016 { /* Objective C message (method) call. */
1018 CORE_ADDR responds_selector
= 0;
1019 CORE_ADDR method_selector
= 0;
1021 CORE_ADDR selector
= 0;
1023 int struct_return
= 0;
1024 int sub_no_side
= 0;
1026 struct value
*msg_send
= NULL
;
1027 struct value
*msg_send_stret
= NULL
;
1028 int gnu_runtime
= 0;
1030 struct value
*target
= NULL
;
1031 struct value
*method
= NULL
;
1032 struct value
*called_method
= NULL
;
1034 struct type
*selector_type
= NULL
;
1035 struct type
*long_type
;
1037 struct value
*ret
= NULL
;
1040 selector
= exp
->elts
[pc
+ 1].longconst
;
1041 nargs
= exp
->elts
[pc
+ 2].longconst
;
1042 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1047 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1048 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1050 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1051 sub_no_side
= EVAL_NORMAL
;
1053 sub_no_side
= noside
;
1055 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1057 if (value_as_long (target
) == 0)
1058 return value_from_longest (long_type
, 0);
1060 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1063 /* Find the method dispatch (Apple runtime) or method lookup
1064 (GNU runtime) function for Objective-C. These will be used
1065 to lookup the symbol information for the method. If we
1066 can't find any symbol information, then we'll use these to
1067 call the method, otherwise we can call the method
1068 directly. The msg_send_stret function is used in the special
1069 case of a method that returns a structure (Apple runtime
1073 struct type
*type
= selector_type
;
1074 type
= lookup_function_type (type
);
1075 type
= lookup_pointer_type (type
);
1076 type
= lookup_function_type (type
);
1077 type
= lookup_pointer_type (type
);
1079 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1081 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1083 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1084 msg_send_stret
= value_from_pointer (type
,
1085 value_as_address (msg_send_stret
));
1089 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1090 /* Special dispatcher for methods returning structs */
1092 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1095 /* Verify the target object responds to this method. The
1096 standard top-level 'Object' class uses a different name for
1097 the verification method than the non-standard, but more
1098 often used, 'NSObject' class. Make sure we check for both. */
1101 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1102 if (responds_selector
== 0)
1104 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1106 if (responds_selector
== 0)
1107 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1110 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1111 if (method_selector
== 0)
1113 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1115 if (method_selector
== 0)
1116 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1118 /* Call the verification method, to make sure that the target
1119 class implements the desired method. */
1121 argvec
[0] = msg_send
;
1123 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1124 argvec
[3] = value_from_longest (long_type
, selector
);
1127 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1130 /* Function objc_msg_lookup returns a pointer. */
1132 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1134 if (value_as_long (ret
) == 0)
1135 error (_("Target does not respond to this message selector."));
1137 /* Call "methodForSelector:" method, to get the address of a
1138 function method that implements this selector for this
1139 class. If we can find a symbol at that address, then we
1140 know the return type, parameter types etc. (that's a good
1143 argvec
[0] = msg_send
;
1145 argvec
[2] = value_from_longest (long_type
, method_selector
);
1146 argvec
[3] = value_from_longest (long_type
, selector
);
1149 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1153 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1156 /* ret should now be the selector. */
1158 addr
= value_as_long (ret
);
1161 struct symbol
*sym
= NULL
;
1162 /* Is it a high_level symbol? */
1164 sym
= find_pc_function (addr
);
1166 method
= value_of_variable (sym
, 0);
1169 /* If we found a method with symbol information, check to see
1170 if it returns a struct. Otherwise assume it doesn't. */
1176 struct type
*val_type
;
1178 funaddr
= find_function_addr (method
, &val_type
);
1180 b
= block_for_pc (funaddr
);
1182 CHECK_TYPEDEF (val_type
);
1184 if ((val_type
== NULL
)
1185 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1187 if (expect_type
!= NULL
)
1188 val_type
= expect_type
;
1191 struct_return
= using_struct_return (exp
->gdbarch
,
1192 value_type (method
), val_type
);
1194 else if (expect_type
!= NULL
)
1196 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1197 check_typedef (expect_type
));
1200 /* Found a function symbol. Now we will substitute its
1201 value in place of the message dispatcher (obj_msgSend),
1202 so that we call the method directly instead of thru
1203 the dispatcher. The main reason for doing this is that
1204 we can now evaluate the return value and parameter values
1205 according to their known data types, in case we need to
1206 do things like promotion, dereferencing, special handling
1207 of structs and doubles, etc.
1209 We want to use the type signature of 'method', but still
1210 jump to objc_msgSend() or objc_msgSend_stret() to better
1211 mimic the behavior of the runtime. */
1215 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1216 error (_("method address has symbol information with non-function type; skipping"));
1218 set_value_address (method
, value_as_address (msg_send_stret
));
1220 set_value_address (method
, value_as_address (msg_send
));
1221 called_method
= method
;
1226 called_method
= msg_send_stret
;
1228 called_method
= msg_send
;
1231 if (noside
== EVAL_SKIP
)
1234 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1236 /* If the return type doesn't look like a function type,
1237 call an error. This can happen if somebody tries to
1238 turn a variable into a function call. This is here
1239 because people often want to call, eg, strcmp, which
1240 gdb doesn't know is a function. If gdb isn't asked for
1241 it's opinion (ie. through "whatis"), it won't offer
1244 struct type
*type
= value_type (called_method
);
1245 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1246 type
= TYPE_TARGET_TYPE (type
);
1247 type
= TYPE_TARGET_TYPE (type
);
1251 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1252 return allocate_value (expect_type
);
1254 return allocate_value (type
);
1257 error (_("Expression of type other than \"method returning ...\" used as a method"));
1260 /* Now depending on whether we found a symbol for the method,
1261 we will either call the runtime dispatcher or the method
1264 argvec
[0] = called_method
;
1266 argvec
[2] = value_from_longest (long_type
, selector
);
1267 /* User-supplied arguments. */
1268 for (tem
= 0; tem
< nargs
; tem
++)
1269 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1270 argvec
[tem
+ 3] = 0;
1272 if (gnu_runtime
&& (method
!= NULL
))
1274 /* Function objc_msg_lookup returns a pointer. */
1275 deprecated_set_value_type (argvec
[0],
1276 lookup_function_type (lookup_pointer_type (value_type (argvec
[0]))));
1277 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1280 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1287 op
= exp
->elts
[*pos
].opcode
;
1288 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1289 /* Allocate arg vector, including space for the function to be
1290 called in argvec[0] and a terminating NULL */
1291 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1292 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1295 /* First, evaluate the structure into arg2 */
1298 if (noside
== EVAL_SKIP
)
1301 if (op
== STRUCTOP_MEMBER
)
1303 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1307 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1310 /* If the function is a virtual function, then the
1311 aggregate value (providing the structure) plays
1312 its part by providing the vtable. Otherwise,
1313 it is just along for the ride: call the function
1316 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1318 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1319 != TYPE_CODE_METHODPTR
)
1320 error (_("Non-pointer-to-member value used in pointer-to-member "
1323 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1325 struct type
*method_type
= check_typedef (value_type (arg1
));
1326 arg1
= value_zero (method_type
, not_lval
);
1329 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1331 /* Now, say which argument to start evaluating from */
1334 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1336 /* Hair for method invocations */
1340 /* First, evaluate the structure into arg2 */
1342 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1343 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1344 if (noside
== EVAL_SKIP
)
1347 if (op
== STRUCTOP_STRUCT
)
1349 /* If v is a variable in a register, and the user types
1350 v.method (), this will produce an error, because v has
1353 A possible way around this would be to allocate a
1354 copy of the variable on the stack, copy in the
1355 contents, call the function, and copy out the
1356 contents. I.e. convert this from call by reference
1357 to call by copy-return (or whatever it's called).
1358 However, this does not work because it is not the
1359 same: the method being called could stash a copy of
1360 the address, and then future uses through that address
1361 (after the method returns) would be expected to
1362 use the variable itself, not some copy of it. */
1363 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1367 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1369 /* Now, say which argument to start evaluating from */
1374 /* Non-method function call */
1376 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1378 type
= value_type (argvec
[0]);
1379 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1380 type
= TYPE_TARGET_TYPE (type
);
1381 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1383 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1385 /* pai: FIXME This seems to be coercing arguments before
1386 * overload resolution has been done! */
1387 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1393 /* Evaluate arguments */
1394 for (; tem
<= nargs
; tem
++)
1396 /* Ensure that array expressions are coerced into pointer objects. */
1397 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1400 /* signal end of arglist */
1403 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1405 int static_memfuncp
;
1408 /* Method invocation : stuff "this" as first parameter */
1410 /* Name of method from expression */
1411 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1413 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1415 /* Language is C++, do some overload resolution before evaluation */
1416 struct value
*valp
= NULL
;
1418 /* Prepare list of argument types for overload resolution */
1419 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1420 for (ix
= 1; ix
<= nargs
; ix
++)
1421 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1423 (void) find_overload_match (arg_types
, nargs
, tstr
,
1424 1 /* method */ , 0 /* strict match */ ,
1425 &arg2
/* the object */ , NULL
,
1426 &valp
, NULL
, &static_memfuncp
);
1429 argvec
[1] = arg2
; /* the ``this'' pointer */
1430 argvec
[0] = valp
; /* use the method found after overload resolution */
1433 /* Non-C++ case -- or no overload resolution */
1435 struct value
*temp
= arg2
;
1436 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1438 op
== STRUCTOP_STRUCT
1439 ? "structure" : "structure pointer");
1440 /* value_struct_elt updates temp with the correct value
1441 of the ``this'' pointer if necessary, so modify argvec[1] to
1442 reflect any ``this'' changes. */
1443 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1444 value_address (temp
)
1445 + value_embedded_offset (temp
));
1446 argvec
[1] = arg2
; /* the ``this'' pointer */
1449 if (static_memfuncp
)
1451 argvec
[1] = argvec
[0];
1456 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1461 else if (op
== OP_VAR_VALUE
)
1463 /* Non-member function being called */
1464 /* fn: This can only be done for C++ functions. A C-style function
1465 in a C++ program, for instance, does not have the fields that
1466 are expected here */
1468 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1470 /* Language is C++, do some overload resolution before evaluation */
1471 struct symbol
*symp
;
1473 /* Prepare list of argument types for overload resolution */
1474 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1475 for (ix
= 1; ix
<= nargs
; ix
++)
1476 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1478 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1479 0 /* not method */ , 0 /* strict match */ ,
1480 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1483 /* Now fix the expression being evaluated */
1484 exp
->elts
[save_pos1
+2].symbol
= symp
;
1485 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1489 /* Not C++, or no overload resolution allowed */
1490 /* nothing to be done; argvec already correctly set up */
1495 /* It is probably a C-style function */
1496 /* nothing to be done; argvec already correctly set up */
1501 if (noside
== EVAL_SKIP
)
1503 if (argvec
[0] == NULL
)
1504 error (_("Cannot evaluate function -- may be inlined"));
1505 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1507 /* If the return type doesn't look like a function type, call an
1508 error. This can happen if somebody tries to turn a variable into
1509 a function call. This is here because people often want to
1510 call, eg, strcmp, which gdb doesn't know is a function. If
1511 gdb isn't asked for it's opinion (ie. through "whatis"),
1512 it won't offer it. */
1514 struct type
*ftype
=
1515 TYPE_TARGET_TYPE (value_type (argvec
[0]));
1518 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec
[0])));
1520 error (_("Expression of type other than \"Function returning ...\" used as function"));
1522 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1523 return call_internal_function (argvec
[0], nargs
, argvec
+ 1);
1525 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1526 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1528 case OP_F77_UNDETERMINED_ARGLIST
:
1530 /* Remember that in F77, functions, substring ops and
1531 array subscript operations cannot be disambiguated
1532 at parse time. We have made all array subscript operations,
1533 substring operations as well as function calls come here
1534 and we now have to discover what the heck this thing actually was.
1535 If it is a function, we process just as if we got an OP_FUNCALL. */
1537 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1540 /* First determine the type code we are dealing with. */
1541 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1542 type
= check_typedef (value_type (arg1
));
1543 code
= TYPE_CODE (type
);
1545 if (code
== TYPE_CODE_PTR
)
1547 /* Fortran always passes variable to subroutines as pointer.
1548 So we need to look into its target type to see if it is
1549 array, string or function. If it is, we need to switch
1550 to the target value the original one points to. */
1551 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1553 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1554 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1555 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1557 arg1
= value_ind (arg1
);
1558 type
= check_typedef (value_type (arg1
));
1559 code
= TYPE_CODE (type
);
1565 case TYPE_CODE_ARRAY
:
1566 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1567 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1569 goto multi_f77_subscript
;
1571 case TYPE_CODE_STRING
:
1572 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1573 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1576 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1577 return value_subscript (arg1
, arg2
);
1581 case TYPE_CODE_FUNC
:
1582 /* It's a function call. */
1583 /* Allocate arg vector, including space for the function to be
1584 called in argvec[0] and a terminating NULL */
1585 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1588 for (; tem
<= nargs
; tem
++)
1589 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1590 argvec
[tem
] = 0; /* signal end of arglist */
1594 error (_("Cannot perform substring on this type"));
1598 /* We have a complex number, There should be 2 floating
1599 point numbers that compose it */
1601 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1602 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1604 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1606 case STRUCTOP_STRUCT
:
1607 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1608 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1609 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1610 if (noside
== EVAL_SKIP
)
1612 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1613 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1614 &exp
->elts
[pc
+ 2].string
,
1619 struct value
*temp
= arg1
;
1620 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1625 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1626 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1627 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1628 if (noside
== EVAL_SKIP
)
1631 /* JYG: if print object is on we need to replace the base type
1632 with rtti type in order to continue on with successful
1633 lookup of member / method only available in the rtti type. */
1635 struct type
*type
= value_type (arg1
);
1636 struct type
*real_type
;
1637 int full
, top
, using_enc
;
1638 struct value_print_options opts
;
1640 get_user_print_options (&opts
);
1641 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
) &&
1642 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1644 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1647 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1648 real_type
= lookup_pointer_type (real_type
);
1650 real_type
= lookup_reference_type (real_type
);
1652 arg1
= value_cast (real_type
, arg1
);
1657 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1658 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1659 &exp
->elts
[pc
+ 2].string
,
1664 struct value
*temp
= arg1
;
1665 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1666 NULL
, "structure pointer");
1669 case STRUCTOP_MEMBER
:
1671 if (op
== STRUCTOP_MEMBER
)
1672 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1674 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1676 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1678 if (noside
== EVAL_SKIP
)
1681 type
= check_typedef (value_type (arg2
));
1682 switch (TYPE_CODE (type
))
1684 case TYPE_CODE_METHODPTR
:
1685 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1686 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1689 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1690 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1691 return value_ind (arg2
);
1694 case TYPE_CODE_MEMBERPTR
:
1695 /* Now, convert these values to an address. */
1696 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1699 mem_offset
= value_as_long (arg2
);
1701 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1702 value_as_long (arg1
) + mem_offset
);
1703 return value_ind (arg3
);
1706 error (_("non-pointer-to-member value used in pointer-to-member construct"));
1710 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1711 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1712 if (noside
== EVAL_SKIP
)
1714 if (binop_user_defined_p (op
, arg1
, arg2
))
1715 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1717 return value_concat (arg1
, arg2
);
1720 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1721 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1723 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1725 if (binop_user_defined_p (op
, arg1
, arg2
))
1726 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1728 return value_assign (arg1
, arg2
);
1730 case BINOP_ASSIGN_MODIFY
:
1732 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1733 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1734 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1736 op
= exp
->elts
[pc
+ 1].opcode
;
1737 if (binop_user_defined_p (op
, arg1
, arg2
))
1738 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1739 else if (op
== BINOP_ADD
&& ptrmath_type_p (value_type (arg1
)))
1740 arg2
= value_ptradd (arg1
, arg2
);
1741 else if (op
== BINOP_SUB
&& ptrmath_type_p (value_type (arg1
)))
1742 arg2
= value_ptrsub (arg1
, arg2
);
1745 struct value
*tmp
= arg1
;
1747 /* For shift and integer exponentiation operations,
1748 only promote the first argument. */
1749 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1750 && is_integral_type (value_type (arg2
)))
1751 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
1753 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1755 arg2
= value_binop (tmp
, arg2
, op
);
1757 return value_assign (arg1
, arg2
);
1760 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1761 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1762 if (noside
== EVAL_SKIP
)
1764 if (binop_user_defined_p (op
, arg1
, arg2
))
1765 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1766 else if (ptrmath_type_p (value_type (arg1
)))
1767 return value_ptradd (arg1
, arg2
);
1768 else if (ptrmath_type_p (value_type (arg2
)))
1769 return value_ptradd (arg2
, arg1
);
1772 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1773 return value_binop (arg1
, arg2
, BINOP_ADD
);
1777 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1778 arg2
= evaluate_subexp_with_coercion (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
);
1783 else if (ptrmath_type_p (value_type (arg1
)))
1785 if (ptrmath_type_p (value_type (arg2
)))
1787 /* FIXME -- should be ptrdiff_t */
1788 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1789 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
1792 return value_ptrsub (arg1
, arg2
);
1796 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1797 return value_binop (arg1
, arg2
, BINOP_SUB
);
1808 case BINOP_BITWISE_AND
:
1809 case BINOP_BITWISE_IOR
:
1810 case BINOP_BITWISE_XOR
:
1811 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1812 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1813 if (noside
== EVAL_SKIP
)
1815 if (binop_user_defined_p (op
, arg1
, arg2
))
1816 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1819 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1820 fudge arg2 to avoid division-by-zero, the caller is
1821 (theoretically) only looking for the type of the result. */
1822 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1823 /* ??? Do we really want to test for BINOP_MOD here?
1824 The implementation of value_binop gives it a well-defined
1827 || op
== BINOP_INTDIV
1830 && value_logical_not (arg2
))
1832 struct value
*v_one
, *retval
;
1834 v_one
= value_one (value_type (arg2
), not_lval
);
1835 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
1836 retval
= value_binop (arg1
, v_one
, op
);
1841 /* For shift and integer exponentiation operations,
1842 only promote the first argument. */
1843 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1844 && is_integral_type (value_type (arg2
)))
1845 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
1847 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
1849 return value_binop (arg1
, arg2
, op
);
1854 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1855 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1856 if (noside
== EVAL_SKIP
)
1858 error (_("':' operator used in invalid context"));
1860 case BINOP_SUBSCRIPT
:
1861 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1862 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1863 if (noside
== EVAL_SKIP
)
1865 if (binop_user_defined_p (op
, arg1
, arg2
))
1866 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1869 /* If the user attempts to subscript something that is not an
1870 array or pointer type (like a plain int variable for example),
1871 then report this as an error. */
1873 arg1
= coerce_ref (arg1
);
1874 type
= check_typedef (value_type (arg1
));
1875 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1876 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1878 if (TYPE_NAME (type
))
1879 error (_("cannot subscript something of type `%s'"),
1882 error (_("cannot subscript requested type"));
1885 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1886 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1888 return value_subscript (arg1
, arg2
);
1892 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1893 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1894 if (noside
== EVAL_SKIP
)
1896 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1897 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
1899 case MULTI_SUBSCRIPT
:
1901 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1902 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1905 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1906 /* FIXME: EVAL_SKIP handling may not be correct. */
1907 if (noside
== EVAL_SKIP
)
1918 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1919 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1921 /* If the user attempts to subscript something that has no target
1922 type (like a plain int variable for example), then report this
1925 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
1928 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1934 error (_("cannot subscript something of type `%s'"),
1935 TYPE_NAME (value_type (arg1
)));
1939 if (binop_user_defined_p (op
, arg1
, arg2
))
1941 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1945 arg1
= coerce_ref (arg1
);
1946 type
= check_typedef (value_type (arg1
));
1948 switch (TYPE_CODE (type
))
1951 case TYPE_CODE_ARRAY
:
1952 case TYPE_CODE_STRING
:
1953 arg1
= value_subscript (arg1
, arg2
);
1956 case TYPE_CODE_BITSTRING
:
1957 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1958 arg1
= value_bitstring_subscript (type
, arg1
, arg2
);
1962 if (TYPE_NAME (type
))
1963 error (_("cannot subscript something of type `%s'"),
1966 error (_("cannot subscript requested type"));
1972 multi_f77_subscript
:
1974 int subscript_array
[MAX_FORTRAN_DIMS
];
1975 int array_size_array
[MAX_FORTRAN_DIMS
];
1976 int ndimensions
= 1, i
;
1977 struct type
*tmp_type
;
1978 int offset_item
; /* The array offset where the item lives */
1980 if (nargs
> MAX_FORTRAN_DIMS
)
1981 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
1983 tmp_type
= check_typedef (value_type (arg1
));
1984 ndimensions
= calc_f77_array_dims (type
);
1986 if (nargs
!= ndimensions
)
1987 error (_("Wrong number of subscripts"));
1989 gdb_assert (nargs
> 0);
1991 /* Now that we know we have a legal array subscript expression
1992 let us actually find out where this element exists in the array. */
1995 /* Take array indices left to right */
1996 for (i
= 0; i
< nargs
; i
++)
1998 /* Evaluate each subscript, It must be a legal integer in F77 */
1999 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2001 /* Fill in the subscript and array size arrays */
2003 subscript_array
[i
] = value_as_long (arg2
);
2006 /* Internal type of array is arranged right to left */
2007 for (i
= 0; i
< nargs
; i
++)
2009 upper
= f77_get_upperbound (tmp_type
);
2010 lower
= f77_get_lowerbound (tmp_type
);
2012 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
2014 /* Zero-normalize subscripts so that offsetting will work. */
2016 subscript_array
[nargs
- i
- 1] -= lower
;
2018 /* If we are at the bottom of a multidimensional
2019 array type then keep a ptr to the last ARRAY
2020 type around for use when calling value_subscript()
2021 below. This is done because we pretend to value_subscript
2022 that we actually have a one-dimensional array
2023 of base element type that we apply a simple
2027 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
2030 /* Now let us calculate the offset for this item */
2032 offset_item
= subscript_array
[ndimensions
- 1];
2034 for (i
= ndimensions
- 1; i
> 0; --i
)
2036 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
2038 /* Construct a value node with the value of the offset */
2040 arg2
= value_from_longest (builtin_type_int32
, offset_item
);
2042 /* Let us now play a dirty trick: we will take arg1
2043 which is a value node pointing to the topmost level
2044 of the multidimensional array-set and pretend
2045 that it is actually a array of the final element
2046 type, this will ensure that value_subscript()
2047 returns the correct type value */
2049 deprecated_set_value_type (arg1
, tmp_type
);
2050 return value_subscripted_rvalue (arg1
, arg2
, 0);
2053 case BINOP_LOGICAL_AND
:
2054 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2055 if (noside
== EVAL_SKIP
)
2057 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2062 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2065 if (binop_user_defined_p (op
, arg1
, arg2
))
2067 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2068 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2072 tem
= value_logical_not (arg1
);
2073 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2074 (tem
? EVAL_SKIP
: noside
));
2075 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2076 return value_from_longest (type
,
2077 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2080 case BINOP_LOGICAL_OR
:
2081 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2082 if (noside
== EVAL_SKIP
)
2084 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2089 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2092 if (binop_user_defined_p (op
, arg1
, arg2
))
2094 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2095 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2099 tem
= value_logical_not (arg1
);
2100 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2101 (!tem
? EVAL_SKIP
: noside
));
2102 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2103 return value_from_longest (type
,
2104 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2108 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2109 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2110 if (noside
== EVAL_SKIP
)
2112 if (binop_user_defined_p (op
, arg1
, arg2
))
2114 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2118 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2119 tem
= value_equal (arg1
, arg2
);
2120 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2121 return value_from_longest (type
, (LONGEST
) tem
);
2124 case BINOP_NOTEQUAL
:
2125 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2126 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2127 if (noside
== EVAL_SKIP
)
2129 if (binop_user_defined_p (op
, arg1
, arg2
))
2131 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2135 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2136 tem
= value_equal (arg1
, arg2
);
2137 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2138 return value_from_longest (type
, (LONGEST
) ! tem
);
2142 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2143 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2144 if (noside
== EVAL_SKIP
)
2146 if (binop_user_defined_p (op
, arg1
, arg2
))
2148 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2152 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2153 tem
= value_less (arg1
, arg2
);
2154 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2155 return value_from_longest (type
, (LONGEST
) tem
);
2159 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2160 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2161 if (noside
== EVAL_SKIP
)
2163 if (binop_user_defined_p (op
, arg1
, arg2
))
2165 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2169 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2170 tem
= value_less (arg2
, arg1
);
2171 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2172 return value_from_longest (type
, (LONGEST
) tem
);
2176 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2177 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2178 if (noside
== EVAL_SKIP
)
2180 if (binop_user_defined_p (op
, arg1
, arg2
))
2182 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2186 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2187 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2188 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2189 return value_from_longest (type
, (LONGEST
) tem
);
2193 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2194 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2195 if (noside
== EVAL_SKIP
)
2197 if (binop_user_defined_p (op
, arg1
, arg2
))
2199 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2203 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2204 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2205 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2206 return value_from_longest (type
, (LONGEST
) tem
);
2210 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2211 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2212 if (noside
== EVAL_SKIP
)
2214 type
= check_typedef (value_type (arg2
));
2215 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2216 error (_("Non-integral right operand for \"@\" operator."));
2217 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2219 return allocate_repeat_value (value_type (arg1
),
2220 longest_to_int (value_as_long (arg2
)));
2223 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2226 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2227 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
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_pos (arg1
);
2242 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2243 if (noside
== EVAL_SKIP
)
2245 if (unop_user_defined_p (op
, arg1
))
2246 return value_x_unop (arg1
, op
, noside
);
2249 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2250 return value_neg (arg1
);
2253 case UNOP_COMPLEMENT
:
2254 /* C++: check for and handle destructor names. */
2255 op
= exp
->elts
[*pos
].opcode
;
2257 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2258 if (noside
== EVAL_SKIP
)
2260 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2261 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2264 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2265 return value_complement (arg1
);
2268 case UNOP_LOGICAL_NOT
:
2269 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2270 if (noside
== EVAL_SKIP
)
2272 if (unop_user_defined_p (op
, arg1
))
2273 return value_x_unop (arg1
, op
, noside
);
2276 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2277 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2281 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2282 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2283 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2284 type
= check_typedef (value_type (arg1
));
2285 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2286 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2287 error (_("Attempt to dereference pointer to member without an object"));
2288 if (noside
== EVAL_SKIP
)
2290 if (unop_user_defined_p (op
, arg1
))
2291 return value_x_unop (arg1
, op
, noside
);
2292 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2294 type
= check_typedef (value_type (arg1
));
2295 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2296 || TYPE_CODE (type
) == TYPE_CODE_REF
2297 /* In C you can dereference an array to get the 1st elt. */
2298 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2300 return value_zero (TYPE_TARGET_TYPE (type
),
2302 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2303 /* GDB allows dereferencing an int. */
2304 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2307 error (_("Attempt to take contents of a non-pointer value."));
2310 /* Allow * on an integer so we can cast it to whatever we want.
2311 This returns an int, which seems like the most C-like thing to
2312 do. "long long" variables are rare enough that
2313 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2314 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2315 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2316 (CORE_ADDR
) value_as_address (arg1
));
2317 return value_ind (arg1
);
2320 /* C++: check for and handle pointer to members. */
2322 op
= exp
->elts
[*pos
].opcode
;
2324 if (noside
== EVAL_SKIP
)
2326 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2331 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
2336 if (noside
== EVAL_SKIP
)
2338 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2341 return evaluate_subexp_for_sizeof (exp
, pos
);
2345 type
= exp
->elts
[pc
+ 1].type
;
2346 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2347 if (noside
== EVAL_SKIP
)
2349 if (type
!= value_type (arg1
))
2350 arg1
= value_cast (type
, arg1
);
2355 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2356 if (noside
== EVAL_SKIP
)
2358 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2359 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2361 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2362 value_as_address (arg1
));
2364 case UNOP_MEMVAL_TLS
:
2366 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2367 if (noside
== EVAL_SKIP
)
2369 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2370 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2374 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2375 value_as_address (arg1
));
2376 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2379 case UNOP_PREINCREMENT
:
2380 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2381 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2383 else if (unop_user_defined_p (op
, arg1
))
2385 return value_x_unop (arg1
, op
, noside
);
2389 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2390 if (ptrmath_type_p (value_type (arg1
)))
2391 arg2
= value_ptradd (arg1
, arg2
);
2394 struct value
*tmp
= arg1
;
2395 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2396 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2399 return value_assign (arg1
, arg2
);
2402 case UNOP_PREDECREMENT
:
2403 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2404 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2406 else if (unop_user_defined_p (op
, arg1
))
2408 return value_x_unop (arg1
, op
, noside
);
2412 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2413 if (ptrmath_type_p (value_type (arg1
)))
2414 arg2
= value_ptrsub (arg1
, arg2
);
2417 struct value
*tmp
= arg1
;
2418 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2419 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2422 return value_assign (arg1
, arg2
);
2425 case UNOP_POSTINCREMENT
:
2426 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2427 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2429 else if (unop_user_defined_p (op
, arg1
))
2431 return value_x_unop (arg1
, op
, noside
);
2435 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2436 if (ptrmath_type_p (value_type (arg1
)))
2437 arg2
= value_ptradd (arg1
, arg2
);
2440 struct value
*tmp
= arg1
;
2441 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2442 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2445 value_assign (arg1
, arg2
);
2449 case UNOP_POSTDECREMENT
:
2450 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2451 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2453 else if (unop_user_defined_p (op
, arg1
))
2455 return value_x_unop (arg1
, op
, noside
);
2459 arg2
= value_from_longest (builtin_type_uint8
, (LONGEST
) 1);
2460 if (ptrmath_type_p (value_type (arg1
)))
2461 arg2
= value_ptrsub (arg1
, arg2
);
2464 struct value
*tmp
= arg1
;
2465 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2466 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2469 value_assign (arg1
, arg2
);
2475 return value_of_this (1);
2479 return value_of_local ("self", 1);
2482 /* The value is not supposed to be used. This is here to make it
2483 easier to accommodate expressions that contain types. */
2485 if (noside
== EVAL_SKIP
)
2487 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2489 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2490 /* If this is a typedef, then find its immediate target. We
2491 use check_typedef to resolve stubs, but we ignore its
2492 result because we do not want to dig past all
2494 check_typedef (type
);
2495 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2496 type
= TYPE_TARGET_TYPE (type
);
2497 return allocate_value (type
);
2500 error (_("Attempt to use a type name as an expression"));
2503 /* Removing this case and compiling with gcc -Wall reveals that
2504 a lot of cases are hitting this case. Some of these should
2505 probably be removed from expression.h; others are legitimate
2506 expressions which are (apparently) not fully implemented.
2508 If there are any cases landing here which mean a user error,
2509 then they should be separate cases, with more descriptive
2513 GDB does not (yet) know how to evaluate that kind of expression"));
2517 return value_from_longest (builtin_type_int8
, (LONGEST
) 1);
2520 /* Evaluate a subexpression of EXP, at index *POS,
2521 and return the address of that subexpression.
2522 Advance *POS over the subexpression.
2523 If the subexpression isn't an lvalue, get an error.
2524 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2525 then only the type of the result need be correct. */
2527 static struct value
*
2528 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2538 op
= exp
->elts
[pc
].opcode
;
2544 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2546 /* We can't optimize out "&*" if there's a user-defined operator*. */
2547 if (unop_user_defined_p (op
, x
))
2549 x
= value_x_unop (x
, op
, noside
);
2550 goto default_case_after_eval
;
2557 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2558 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2561 var
= exp
->elts
[pc
+ 2].symbol
;
2563 /* C++: The "address" of a reference should yield the address
2564 * of the object pointed to. Let value_addr() deal with it. */
2565 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2569 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2572 lookup_pointer_type (SYMBOL_TYPE (var
));
2573 enum address_class sym_class
= SYMBOL_CLASS (var
);
2575 if (sym_class
== LOC_CONST
2576 || sym_class
== LOC_CONST_BYTES
2577 || sym_class
== LOC_REGISTER
)
2578 error (_("Attempt to take address of register or constant."));
2581 value_zero (type
, not_lval
);
2584 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2587 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2588 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2589 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2590 &exp
->elts
[pc
+ 3].string
,
2593 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2598 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2599 default_case_after_eval
:
2600 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2602 struct type
*type
= check_typedef (value_type (x
));
2604 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2605 return value_zero (lookup_pointer_type (value_type (x
)),
2607 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2608 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2611 error (_("Attempt to take address of value not located in memory."));
2613 return value_addr (x
);
2617 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2618 When used in contexts where arrays will be coerced anyway, this is
2619 equivalent to `evaluate_subexp' but much faster because it avoids
2620 actually fetching array contents (perhaps obsolete now that we have
2623 Note that we currently only do the coercion for C expressions, where
2624 arrays are zero based and the coercion is correct. For other languages,
2625 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2626 to decide if coercion is appropriate.
2631 evaluate_subexp_with_coercion (struct expression
*exp
,
2632 int *pos
, enum noside noside
)
2641 op
= exp
->elts
[pc
].opcode
;
2646 var
= exp
->elts
[pc
+ 2].symbol
;
2647 type
= check_typedef (SYMBOL_TYPE (var
));
2648 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2649 && CAST_IS_CONVERSION
)
2652 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2653 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2659 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2663 /* Evaluate a subexpression of EXP, at index *POS,
2664 and return a value for the size of that subexpression.
2665 Advance *POS over the subexpression. */
2667 static struct value
*
2668 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
2670 /* FIXME: This should be size_t. */
2671 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2678 op
= exp
->elts
[pc
].opcode
;
2682 /* This case is handled specially
2683 so that we avoid creating a value for the result type.
2684 If the result type is very big, it's desirable not to
2685 create a value unnecessarily. */
2688 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2689 type
= check_typedef (value_type (val
));
2690 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2691 && TYPE_CODE (type
) != TYPE_CODE_REF
2692 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2693 error (_("Attempt to take contents of a non-pointer value."));
2694 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2695 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2699 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2700 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2704 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2706 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2709 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2710 return value_from_longest (size_type
,
2711 (LONGEST
) TYPE_LENGTH (value_type (val
)));
2715 /* Parse a type expression in the string [P..P+LENGTH). */
2718 parse_and_eval_type (char *p
, int length
)
2720 char *tmp
= (char *) alloca (length
+ 4);
2721 struct expression
*expr
;
2723 memcpy (tmp
+ 1, p
, length
);
2724 tmp
[length
+ 1] = ')';
2725 tmp
[length
+ 2] = '0';
2726 tmp
[length
+ 3] = '\0';
2727 expr
= parse_expression (tmp
);
2728 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2729 error (_("Internal error in eval_type."));
2730 return expr
->elts
[1].type
;
2734 calc_f77_array_dims (struct type
*array_type
)
2737 struct type
*tmp_type
;
2739 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2740 error (_("Can't get dimensions for a non-array type"));
2742 tmp_type
= array_type
;
2744 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2746 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)