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, 2010 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_obstack.h"
45 #include "python/python.h"
48 #include "gdb_assert.h"
52 /* This is defined in valops.c */
53 extern int overload_resolution
;
55 /* Prototypes for local functions. */
57 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
59 static struct value
*evaluate_subexp_for_address (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
)
167 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
170 /* Evaluate an expression, avoiding all memory references
171 and getting a value whose type alone is correct. */
174 evaluate_type (struct expression
*exp
)
178 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
181 /* Evaluate a subexpression, avoiding all memory references and
182 getting a value whose type alone is correct. */
185 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
187 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
190 /* Find the current value of a watchpoint on EXP. Return the value in
191 *VALP and *RESULTP and the chain of intermediate and final values
192 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
195 If a memory error occurs while evaluating the expression, *RESULTP will
196 be set to NULL. *RESULTP may be a lazy value, if the result could
197 not be read from memory. It is used to determine whether a value
198 is user-specified (we should watch the whole value) or intermediate
199 (we should watch only the bit used to locate the final value).
201 If the final value, or any intermediate value, could not be read
202 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
203 set to any referenced values. *VALP will never be a lazy value.
204 This is the value which we store in struct breakpoint.
206 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
207 value chain. The caller must free the values individually. If
208 VAL_CHAIN is NULL, all generated values will be left on the value
212 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
213 struct value
**resultp
, struct value
**val_chain
)
215 struct value
*mark
, *new_mark
, *result
;
216 volatile struct gdb_exception ex
;
224 /* Evaluate the expression. */
225 mark
= value_mark ();
228 TRY_CATCH (ex
, RETURN_MASK_ALL
)
230 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
234 /* Ignore memory errors, we want watchpoints pointing at
235 inaccessible memory to still be created; otherwise, throw the
236 error to some higher catcher. */
242 throw_exception (ex
);
247 new_mark
= value_mark ();
248 if (mark
== new_mark
)
253 /* Make sure it's not lazy, so that after the target stops again we
254 have a non-lazy previous value to compare with. */
256 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
261 /* Return the chain of intermediate values. We use this to
262 decide which addresses to watch. */
263 *val_chain
= new_mark
;
264 value_release_to_mark (mark
);
268 /* Extract a field operation from an expression. If the subexpression
269 of EXP starting at *SUBEXP is not a structure dereference
270 operation, return NULL. Otherwise, return the name of the
271 dereferenced field, and advance *SUBEXP to point to the
272 subexpression of the left-hand-side of the dereference. This is
273 used when completing field names. */
276 extract_field_op (struct expression
*exp
, int *subexp
)
281 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
282 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
284 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
285 result
= &exp
->elts
[*subexp
+ 2].string
;
286 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
290 /* If the next expression is an OP_LABELED, skips past it,
291 returning the label. Otherwise, does nothing and returns NULL. */
294 get_label (struct expression
*exp
, int *pos
)
296 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
299 char *name
= &exp
->elts
[pc
+ 2].string
;
300 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
302 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
309 /* This function evaluates tuples (in (the deleted) Chill) or
310 brace-initializers (in C/C++) for structure types. */
312 static struct value
*
313 evaluate_struct_tuple (struct value
*struct_val
,
314 struct expression
*exp
,
315 int *pos
, enum noside noside
, int nargs
)
317 struct type
*struct_type
= check_typedef (value_type (struct_val
));
318 struct type
*substruct_type
= struct_type
;
319 struct type
*field_type
;
327 struct value
*val
= NULL
;
332 /* Skip past the labels, and count them. */
333 while (get_label (exp
, pos
) != NULL
)
338 char *label
= get_label (exp
, &pc
);
342 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
345 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
347 if (field_name
!= NULL
&& strcmp (field_name
, label
) == 0)
350 subfieldno
= fieldno
;
351 substruct_type
= struct_type
;
355 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
358 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
360 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
361 if ((field_name
== 0 || *field_name
== '\0')
362 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
365 for (; variantno
< TYPE_NFIELDS (field_type
);
369 = TYPE_FIELD_TYPE (field_type
, variantno
);
370 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
373 subfieldno
< TYPE_NFIELDS (substruct_type
);
376 if (strcmp(TYPE_FIELD_NAME (substruct_type
,
387 error (_("there is no field named %s"), label
);
393 /* Unlabelled tuple element - go to next field. */
397 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
400 substruct_type
= struct_type
;
406 /* Skip static fields. */
407 while (fieldno
< TYPE_NFIELDS (struct_type
)
408 && field_is_static (&TYPE_FIELD (struct_type
,
411 subfieldno
= fieldno
;
412 if (fieldno
>= TYPE_NFIELDS (struct_type
))
413 error (_("too many initializers"));
414 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
415 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
416 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
417 error (_("don't know which variant you want to set"));
421 /* Here, struct_type is the type of the inner struct,
422 while substruct_type is the type of the inner struct.
423 These are the same for normal structures, but a variant struct
424 contains anonymous union fields that contain substruct fields.
425 The value fieldno is the index of the top-level (normal or
426 anonymous union) field in struct_field, while the value
427 subfieldno is the index of the actual real (named inner) field
428 in substruct_type. */
430 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
432 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
434 /* Now actually set the field in struct_val. */
436 /* Assign val to field fieldno. */
437 if (value_type (val
) != field_type
)
438 val
= value_cast (field_type
, val
);
440 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
441 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
443 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
444 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
446 modify_field (struct_type
, addr
,
447 value_as_long (val
), bitpos
% 8, bitsize
);
449 memcpy (addr
, value_contents (val
),
450 TYPE_LENGTH (value_type (val
)));
452 while (--nlabels
> 0);
457 /* Recursive helper function for setting elements of array tuples for
458 (the deleted) Chill. The target is ARRAY (which has bounds
459 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
460 and NOSIDE are as usual. Evaluates index expresions and sets the
461 specified element(s) of ARRAY to ELEMENT. Returns last index
465 init_array_element (struct value
*array
, struct value
*element
,
466 struct expression
*exp
, int *pos
,
467 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
470 int element_size
= TYPE_LENGTH (value_type (element
));
472 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
475 init_array_element (array
, element
, exp
, pos
, noside
,
476 low_bound
, high_bound
);
477 return init_array_element (array
, element
,
478 exp
, pos
, noside
, low_bound
, high_bound
);
480 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
485 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
486 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
487 if (low
< low_bound
|| high
> high_bound
)
488 error (_("tuple range index out of range"));
489 for (index
= low
; index
<= high
; index
++)
491 memcpy (value_contents_raw (array
)
492 + (index
- low_bound
) * element_size
,
493 value_contents (element
), element_size
);
498 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
499 if (index
< low_bound
|| index
> high_bound
)
500 error (_("tuple index out of range"));
501 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
502 value_contents (element
), element_size
);
507 static struct value
*
508 value_f90_subarray (struct value
*array
,
509 struct expression
*exp
, int *pos
, enum noside noside
)
512 LONGEST low_bound
, high_bound
;
513 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
514 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
518 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
519 low_bound
= TYPE_LOW_BOUND (range
);
521 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
523 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
524 high_bound
= TYPE_HIGH_BOUND (range
);
526 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
528 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
532 /* Promote value ARG1 as appropriate before performing a unary operation
534 If the result is not appropriate for any particular language then it
535 needs to patch this function. */
538 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
543 *arg1
= coerce_ref (*arg1
);
544 type1
= check_typedef (value_type (*arg1
));
546 if (is_integral_type (type1
))
548 switch (language
->la_language
)
551 /* Perform integral promotion for ANSI C/C++.
552 If not appropropriate for any particular language
553 it needs to modify this function. */
555 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
557 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
558 *arg1
= value_cast (builtin_int
, *arg1
);
565 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
566 operation on those two operands.
567 If the result is not appropriate for any particular language then it
568 needs to patch this function. */
571 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
572 struct value
**arg1
, struct value
**arg2
)
574 struct type
*promoted_type
= NULL
;
578 *arg1
= coerce_ref (*arg1
);
579 *arg2
= coerce_ref (*arg2
);
581 type1
= check_typedef (value_type (*arg1
));
582 type2
= check_typedef (value_type (*arg2
));
584 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
585 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
586 && !is_integral_type (type1
))
587 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
588 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
589 && !is_integral_type (type2
)))
592 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
593 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
595 /* No promotion required. */
597 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
598 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
600 switch (language
->la_language
)
606 case language_opencl
:
607 /* No promotion required. */
611 /* For other languages the result type is unchanged from gdb
612 version 6.7 for backward compatibility.
613 If either arg was long double, make sure that value is also long
614 double. Otherwise use double. */
615 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
616 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
617 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
619 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
623 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
624 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
626 /* No promotion required. */
629 /* Integral operations here. */
630 /* FIXME: Also mixed integral/booleans, with result an integer. */
632 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
633 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
634 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
635 int is_unsigned1
= TYPE_UNSIGNED (type1
);
636 int is_unsigned2
= TYPE_UNSIGNED (type2
);
637 unsigned int result_len
;
638 int unsigned_operation
;
640 /* Determine type length and signedness after promotion for
642 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
645 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
647 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
650 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
653 if (promoted_len1
> promoted_len2
)
655 unsigned_operation
= is_unsigned1
;
656 result_len
= promoted_len1
;
658 else if (promoted_len2
> promoted_len1
)
660 unsigned_operation
= is_unsigned2
;
661 result_len
= promoted_len2
;
665 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
666 result_len
= promoted_len1
;
669 switch (language
->la_language
)
675 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
677 promoted_type
= (unsigned_operation
678 ? builtin
->builtin_unsigned_int
679 : builtin
->builtin_int
);
681 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
683 promoted_type
= (unsigned_operation
684 ? builtin
->builtin_unsigned_long
685 : builtin
->builtin_long
);
689 promoted_type
= (unsigned_operation
690 ? builtin
->builtin_unsigned_long_long
691 : builtin
->builtin_long_long
);
694 case language_opencl
:
695 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
696 (language
, gdbarch
, "int")))
700 ? lookup_unsigned_typename (language
, gdbarch
, "int")
701 : lookup_signed_typename (language
, gdbarch
, "int"));
703 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
704 (language
, gdbarch
, "long")))
708 ? lookup_unsigned_typename (language
, gdbarch
, "long")
709 : lookup_signed_typename (language
, gdbarch
,"long"));
713 /* For other languages the result type is unchanged from gdb
714 version 6.7 for backward compatibility.
715 If either arg was long long, make sure that value is also long
716 long. Otherwise use long. */
717 if (unsigned_operation
)
719 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
720 promoted_type
= builtin
->builtin_unsigned_long_long
;
722 promoted_type
= builtin
->builtin_unsigned_long
;
726 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
727 promoted_type
= builtin
->builtin_long_long
;
729 promoted_type
= builtin
->builtin_long
;
737 /* Promote both operands to common type. */
738 *arg1
= value_cast (promoted_type
, *arg1
);
739 *arg2
= value_cast (promoted_type
, *arg2
);
744 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
746 type
= check_typedef (type
);
747 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
748 type
= TYPE_TARGET_TYPE (type
);
750 switch (TYPE_CODE (type
))
756 case TYPE_CODE_ARRAY
:
757 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
764 /* Constructs a fake method with the given parameter types.
765 This function is used by the parser to construct an "expected"
766 type for method overload resolution. */
769 make_params (int num_types
, struct type
**param_types
)
771 struct type
*type
= XZALLOC (struct type
);
772 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
773 TYPE_LENGTH (type
) = 1;
774 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
775 TYPE_VPTR_FIELDNO (type
) = -1;
776 TYPE_CHAIN (type
) = type
;
777 TYPE_NFIELDS (type
) = num_types
;
778 TYPE_FIELDS (type
) = (struct field
*)
779 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
781 while (num_types
-- > 0)
782 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
788 evaluate_subexp_standard (struct type
*expect_type
,
789 struct expression
*exp
, int *pos
,
794 int pc
, pc2
= 0, oldpos
;
795 struct value
*arg1
= NULL
;
796 struct value
*arg2
= NULL
;
800 struct value
**argvec
;
805 struct type
**arg_types
;
807 struct symbol
*function
= NULL
;
808 char *function_name
= NULL
;
811 op
= exp
->elts
[pc
].opcode
;
816 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
817 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
818 if (noside
== EVAL_SKIP
)
820 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
821 &exp
->elts
[pc
+ 3].string
,
822 expect_type
, 0, noside
);
824 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
829 return value_from_longest (exp
->elts
[pc
+ 1].type
,
830 exp
->elts
[pc
+ 2].longconst
);
834 return value_from_double (exp
->elts
[pc
+ 1].type
,
835 exp
->elts
[pc
+ 2].doubleconst
);
839 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
840 exp
->elts
[pc
+ 2].decfloatconst
);
845 if (noside
== EVAL_SKIP
)
848 /* JYG: We used to just return value_zero of the symbol type
849 if we're asked to avoid side effects. Otherwise we return
850 value_of_variable (...). However I'm not sure if
851 value_of_variable () has any side effect.
852 We need a full value object returned here for whatis_exp ()
853 to call evaluate_type () and then pass the full value to
854 value_rtti_target_type () if we are dealing with a pointer
855 or reference to a base class and print object is on. */
858 volatile struct gdb_exception except
;
859 struct value
*ret
= NULL
;
861 TRY_CATCH (except
, RETURN_MASK_ERROR
)
863 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
864 exp
->elts
[pc
+ 1].block
);
867 if (except
.reason
< 0)
869 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
870 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
), not_lval
);
872 throw_exception (except
);
881 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
885 const char *name
= &exp
->elts
[pc
+ 2].string
;
889 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
890 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
891 name
, strlen (name
));
893 error (_("Register $%s not available."), name
);
895 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
896 a value with the appropriate register type. Unfortunately,
897 we don't have easy access to the type of user registers.
898 So for these registers, we fetch the register value regardless
899 of the evaluation mode. */
900 if (noside
== EVAL_AVOID_SIDE_EFFECTS
901 && regno
< gdbarch_num_regs (exp
->gdbarch
)
902 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
903 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
905 val
= value_of_register (regno
, get_selected_frame (NULL
));
907 error (_("Value of register %s not available."), name
);
913 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
914 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
918 return value_of_internalvar (exp
->gdbarch
,
919 exp
->elts
[pc
+ 1].internalvar
);
922 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
923 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
924 if (noside
== EVAL_SKIP
)
926 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
927 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
929 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
930 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
931 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
932 if (noside
== EVAL_SKIP
)
936 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
939 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
941 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
942 if (noside
== EVAL_SKIP
)
944 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
,
945 builtin_type (exp
->gdbarch
)->builtin_int
);
950 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
951 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
952 nargs
= tem3
- tem2
+ 1;
953 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
955 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
956 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
958 struct value
*rec
= allocate_value (expect_type
);
960 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
961 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
964 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
965 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
967 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
968 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
969 struct value
*array
= allocate_value (expect_type
);
970 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
971 LONGEST low_bound
, high_bound
, index
;
973 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
976 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
979 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
980 for (tem
= nargs
; --nargs
>= 0;)
982 struct value
*element
;
985 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
988 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
990 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
991 if (value_type (element
) != element_type
)
992 element
= value_cast (element_type
, element
);
995 int continue_pc
= *pos
;
998 index
= init_array_element (array
, element
, exp
, pos
, noside
,
999 low_bound
, high_bound
);
1004 if (index
> high_bound
)
1005 /* to avoid memory corruption */
1006 error (_("Too many array elements"));
1007 memcpy (value_contents_raw (array
)
1008 + (index
- low_bound
) * element_size
,
1009 value_contents (element
),
1017 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1018 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1020 struct value
*set
= allocate_value (expect_type
);
1021 gdb_byte
*valaddr
= value_contents_raw (set
);
1022 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1023 struct type
*check_type
= element_type
;
1024 LONGEST low_bound
, high_bound
;
1026 /* get targettype of elementtype */
1027 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1028 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1029 check_type
= TYPE_TARGET_TYPE (check_type
);
1031 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1032 error (_("(power)set type with unknown size"));
1033 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1034 for (tem
= 0; tem
< nargs
; tem
++)
1036 LONGEST range_low
, range_high
;
1037 struct type
*range_low_type
, *range_high_type
;
1038 struct value
*elem_val
;
1040 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
1043 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1044 range_low_type
= value_type (elem_val
);
1045 range_low
= value_as_long (elem_val
);
1046 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1047 range_high_type
= value_type (elem_val
);
1048 range_high
= value_as_long (elem_val
);
1052 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1053 range_low_type
= range_high_type
= value_type (elem_val
);
1054 range_low
= range_high
= value_as_long (elem_val
);
1056 /* check types of elements to avoid mixture of elements from
1057 different types. Also check if type of element is "compatible"
1058 with element type of powerset */
1059 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1060 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1061 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1062 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1063 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1064 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1065 && (range_low_type
!= range_high_type
)))
1066 /* different element modes */
1067 error (_("POWERSET tuple elements of different mode"));
1068 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1069 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1070 && range_low_type
!= check_type
))
1071 error (_("incompatible POWERSET tuple elements"));
1072 if (range_low
> range_high
)
1074 warning (_("empty POWERSET tuple range"));
1077 if (range_low
< low_bound
|| range_high
> high_bound
)
1078 error (_("POWERSET tuple element out of range"));
1079 range_low
-= low_bound
;
1080 range_high
-= low_bound
;
1081 for (; range_low
<= range_high
; range_low
++)
1083 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1085 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1086 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1087 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1094 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1095 for (tem
= 0; tem
< nargs
; tem
++)
1097 /* Ensure that array expressions are coerced into pointer objects. */
1098 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1100 if (noside
== EVAL_SKIP
)
1102 return value_array (tem2
, tem3
, argvec
);
1106 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1108 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1110 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1112 if (noside
== EVAL_SKIP
)
1114 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1117 case TERNOP_SLICE_COUNT
:
1119 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1121 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1123 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1125 return value_slice (array
, lowbound
, length
);
1129 /* Skip third and second args to evaluate the first one. */
1130 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1131 if (value_logical_not (arg1
))
1133 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1134 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1138 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1139 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1143 case OP_OBJC_SELECTOR
:
1144 { /* Objective C @selector operator. */
1145 char *sel
= &exp
->elts
[pc
+ 2].string
;
1146 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1147 struct type
*selector_type
;
1149 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1150 if (noside
== EVAL_SKIP
)
1154 sel
[len
] = 0; /* Make sure it's terminated. */
1156 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1157 return value_from_longest (selector_type
,
1158 lookup_child_selector (exp
->gdbarch
, sel
));
1161 case OP_OBJC_MSGCALL
:
1162 { /* Objective C message (method) call. */
1164 CORE_ADDR responds_selector
= 0;
1165 CORE_ADDR method_selector
= 0;
1167 CORE_ADDR selector
= 0;
1169 int struct_return
= 0;
1170 int sub_no_side
= 0;
1172 struct value
*msg_send
= NULL
;
1173 struct value
*msg_send_stret
= NULL
;
1174 int gnu_runtime
= 0;
1176 struct value
*target
= NULL
;
1177 struct value
*method
= NULL
;
1178 struct value
*called_method
= NULL
;
1180 struct type
*selector_type
= NULL
;
1181 struct type
*long_type
;
1183 struct value
*ret
= NULL
;
1186 selector
= exp
->elts
[pc
+ 1].longconst
;
1187 nargs
= exp
->elts
[pc
+ 2].longconst
;
1188 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1193 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1194 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1196 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1197 sub_no_side
= EVAL_NORMAL
;
1199 sub_no_side
= noside
;
1201 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1203 if (value_as_long (target
) == 0)
1204 return value_from_longest (long_type
, 0);
1206 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1209 /* Find the method dispatch (Apple runtime) or method lookup
1210 (GNU runtime) function for Objective-C. These will be used
1211 to lookup the symbol information for the method. If we
1212 can't find any symbol information, then we'll use these to
1213 call the method, otherwise we can call the method
1214 directly. The msg_send_stret function is used in the special
1215 case of a method that returns a structure (Apple runtime
1219 struct type
*type
= selector_type
;
1221 type
= lookup_function_type (type
);
1222 type
= lookup_pointer_type (type
);
1223 type
= lookup_function_type (type
);
1224 type
= lookup_pointer_type (type
);
1226 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1228 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1230 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1231 msg_send_stret
= value_from_pointer (type
,
1232 value_as_address (msg_send_stret
));
1236 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1237 /* Special dispatcher for methods returning structs */
1239 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1242 /* Verify the target object responds to this method. The
1243 standard top-level 'Object' class uses a different name for
1244 the verification method than the non-standard, but more
1245 often used, 'NSObject' class. Make sure we check for both. */
1248 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1249 if (responds_selector
== 0)
1251 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1253 if (responds_selector
== 0)
1254 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1257 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1258 if (method_selector
== 0)
1260 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1262 if (method_selector
== 0)
1263 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1265 /* Call the verification method, to make sure that the target
1266 class implements the desired method. */
1268 argvec
[0] = msg_send
;
1270 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1271 argvec
[3] = value_from_longest (long_type
, selector
);
1274 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1277 /* Function objc_msg_lookup returns a pointer. */
1279 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1281 if (value_as_long (ret
) == 0)
1282 error (_("Target does not respond to this message selector."));
1284 /* Call "methodForSelector:" method, to get the address of a
1285 function method that implements this selector for this
1286 class. If we can find a symbol at that address, then we
1287 know the return type, parameter types etc. (that's a good
1290 argvec
[0] = msg_send
;
1292 argvec
[2] = value_from_longest (long_type
, method_selector
);
1293 argvec
[3] = value_from_longest (long_type
, selector
);
1296 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1300 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1303 /* ret should now be the selector. */
1305 addr
= value_as_long (ret
);
1308 struct symbol
*sym
= NULL
;
1310 /* The address might point to a function descriptor;
1311 resolve it to the actual code address instead. */
1312 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1315 /* Is it a high_level symbol? */
1316 sym
= find_pc_function (addr
);
1318 method
= value_of_variable (sym
, 0);
1321 /* If we found a method with symbol information, check to see
1322 if it returns a struct. Otherwise assume it doesn't. */
1328 struct type
*val_type
;
1330 funaddr
= find_function_addr (method
, &val_type
);
1332 b
= block_for_pc (funaddr
);
1334 CHECK_TYPEDEF (val_type
);
1336 if ((val_type
== NULL
)
1337 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1339 if (expect_type
!= NULL
)
1340 val_type
= expect_type
;
1343 struct_return
= using_struct_return (exp
->gdbarch
,
1344 value_type (method
), val_type
);
1346 else if (expect_type
!= NULL
)
1348 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1349 check_typedef (expect_type
));
1352 /* Found a function symbol. Now we will substitute its
1353 value in place of the message dispatcher (obj_msgSend),
1354 so that we call the method directly instead of thru
1355 the dispatcher. The main reason for doing this is that
1356 we can now evaluate the return value and parameter values
1357 according to their known data types, in case we need to
1358 do things like promotion, dereferencing, special handling
1359 of structs and doubles, etc.
1361 We want to use the type signature of 'method', but still
1362 jump to objc_msgSend() or objc_msgSend_stret() to better
1363 mimic the behavior of the runtime. */
1367 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1368 error (_("method address has symbol information with non-function type; skipping"));
1370 /* Create a function pointer of the appropriate type, and replace
1371 its value with the value of msg_send or msg_send_stret. We must
1372 use a pointer here, as msg_send and msg_send_stret are of pointer
1373 type, and the representation may be different on systems that use
1374 function descriptors. */
1377 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1378 value_as_address (msg_send_stret
));
1381 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1382 value_as_address (msg_send
));
1387 called_method
= msg_send_stret
;
1389 called_method
= msg_send
;
1392 if (noside
== EVAL_SKIP
)
1395 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1397 /* If the return type doesn't look like a function type,
1398 call an error. This can happen if somebody tries to
1399 turn a variable into a function call. This is here
1400 because people often want to call, eg, strcmp, which
1401 gdb doesn't know is a function. If gdb isn't asked for
1402 it's opinion (ie. through "whatis"), it won't offer
1405 struct type
*type
= value_type (called_method
);
1407 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1408 type
= TYPE_TARGET_TYPE (type
);
1409 type
= TYPE_TARGET_TYPE (type
);
1413 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1414 return allocate_value (expect_type
);
1416 return allocate_value (type
);
1419 error (_("Expression of type other than \"method returning ...\" used as a method"));
1422 /* Now depending on whether we found a symbol for the method,
1423 we will either call the runtime dispatcher or the method
1426 argvec
[0] = called_method
;
1428 argvec
[2] = value_from_longest (long_type
, selector
);
1429 /* User-supplied arguments. */
1430 for (tem
= 0; tem
< nargs
; tem
++)
1431 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1432 argvec
[tem
+ 3] = 0;
1434 if (gnu_runtime
&& (method
!= NULL
))
1436 /* Function objc_msg_lookup returns a pointer. */
1437 deprecated_set_value_type (argvec
[0],
1438 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1439 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1442 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1449 op
= exp
->elts
[*pos
].opcode
;
1450 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1451 /* Allocate arg vector, including space for the function to be
1452 called in argvec[0] and a terminating NULL */
1453 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1454 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1457 /* First, evaluate the structure into arg2 */
1460 if (noside
== EVAL_SKIP
)
1463 if (op
== STRUCTOP_MEMBER
)
1465 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1469 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1472 /* If the function is a virtual function, then the
1473 aggregate value (providing the structure) plays
1474 its part by providing the vtable. Otherwise,
1475 it is just along for the ride: call the function
1478 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1480 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1481 != TYPE_CODE_METHODPTR
)
1482 error (_("Non-pointer-to-member value used in pointer-to-member "
1485 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1487 struct type
*method_type
= check_typedef (value_type (arg1
));
1489 arg1
= value_zero (method_type
, not_lval
);
1492 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1494 /* Now, say which argument to start evaluating from */
1497 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1499 /* Hair for method invocations */
1503 /* First, evaluate the structure into arg2 */
1505 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1506 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1507 if (noside
== EVAL_SKIP
)
1510 if (op
== STRUCTOP_STRUCT
)
1512 /* If v is a variable in a register, and the user types
1513 v.method (), this will produce an error, because v has
1516 A possible way around this would be to allocate a
1517 copy of the variable on the stack, copy in the
1518 contents, call the function, and copy out the
1519 contents. I.e. convert this from call by reference
1520 to call by copy-return (or whatever it's called).
1521 However, this does not work because it is not the
1522 same: the method being called could stash a copy of
1523 the address, and then future uses through that address
1524 (after the method returns) would be expected to
1525 use the variable itself, not some copy of it. */
1526 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1530 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1532 /* Check to see if the operator '->' has been overloaded. If the operator
1533 has been overloaded replace arg2 with the value returned by the custom
1534 operator and continue evaluation. */
1535 while (unop_user_defined_p (op
, arg2
))
1537 volatile struct gdb_exception except
;
1538 struct value
*value
= NULL
;
1539 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1541 value
= value_x_unop (arg2
, op
, noside
);
1544 if (except
.reason
< 0)
1546 if (except
.error
== NOT_FOUND_ERROR
)
1549 throw_exception (except
);
1554 /* Now, say which argument to start evaluating from */
1557 else if (op
== OP_SCOPE
1558 && overload_resolution
1559 && (exp
->language_defn
->la_language
== language_cplus
))
1561 /* Unpack it locally so we can properly handle overload
1567 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1568 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1569 type
= exp
->elts
[pc2
+ 1].type
;
1570 name
= &exp
->elts
[pc2
+ 3].string
;
1573 function_name
= NULL
;
1574 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1576 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1578 get_selected_block (0),
1580 if (function
== NULL
)
1581 error (_("No symbol \"%s\" in namespace \"%s\"."),
1582 name
, TYPE_TAG_NAME (type
));
1588 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1589 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1590 function_name
= name
;
1592 arg2
= value_zero (type
, lval_memory
);
1597 else if (op
== OP_ADL_FUNC
)
1599 /* Save the function position and move pos so that the arguments
1600 can be evaluated. */
1606 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1607 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1611 /* Non-method function call */
1615 /* If this is a C++ function wait until overload resolution. */
1616 if (op
== OP_VAR_VALUE
1617 && overload_resolution
1618 && (exp
->language_defn
->la_language
== language_cplus
))
1620 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1625 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1626 type
= value_type (argvec
[0]);
1627 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1628 type
= TYPE_TARGET_TYPE (type
);
1629 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1631 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1633 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1640 /* Evaluate arguments */
1641 for (; tem
<= nargs
; tem
++)
1643 /* Ensure that array expressions are coerced into pointer objects. */
1644 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1647 /* signal end of arglist */
1649 if (op
== OP_ADL_FUNC
)
1651 struct symbol
*symp
;
1654 int string_pc
= save_pos1
+ 3;
1656 /* Extract the function name. */
1657 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1658 func_name
= (char *) alloca (name_len
+ 1);
1659 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1661 /* Prepare list of argument types for overload resolution */
1662 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1663 for (ix
= 1; ix
<= nargs
; ix
++)
1664 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1666 find_overload_match (arg_types
, nargs
, func_name
,
1667 NON_METHOD
/* not method */ , 0 /* strict match */ ,
1668 NULL
, NULL
/* pass NULL symbol since symbol is unknown */ ,
1669 NULL
, &symp
, NULL
, 0);
1671 /* Now fix the expression being evaluated. */
1672 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1673 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1676 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1677 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1679 int static_memfuncp
;
1682 /* Method invocation : stuff "this" as first parameter */
1687 /* Name of method from expression */
1688 tstr
= &exp
->elts
[pc2
+ 2].string
;
1691 tstr
= function_name
;
1693 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1695 /* Language is C++, do some overload resolution before evaluation */
1696 struct value
*valp
= NULL
;
1698 /* Prepare list of argument types for overload resolution */
1699 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1700 for (ix
= 1; ix
<= nargs
; ix
++)
1701 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1703 (void) find_overload_match (arg_types
, nargs
, tstr
,
1704 METHOD
/* method */ , 0 /* strict match */ ,
1705 &arg2
/* the object */ , NULL
,
1706 &valp
, NULL
, &static_memfuncp
, 0);
1708 if (op
== OP_SCOPE
&& !static_memfuncp
)
1710 /* For the time being, we don't handle this. */
1711 error (_("Call to overloaded function %s requires "
1715 argvec
[1] = arg2
; /* the ``this'' pointer */
1716 argvec
[0] = valp
; /* use the method found after overload resolution */
1719 /* Non-C++ case -- or no overload resolution */
1721 struct value
*temp
= arg2
;
1723 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1725 op
== STRUCTOP_STRUCT
1726 ? "structure" : "structure pointer");
1727 /* value_struct_elt updates temp with the correct value
1728 of the ``this'' pointer if necessary, so modify argvec[1] to
1729 reflect any ``this'' changes. */
1730 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1731 value_address (temp
)
1732 + value_embedded_offset (temp
));
1733 argvec
[1] = arg2
; /* the ``this'' pointer */
1736 if (static_memfuncp
)
1738 argvec
[1] = argvec
[0];
1743 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1748 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1750 /* Non-member function being called */
1751 /* fn: This can only be done for C++ functions. A C-style function
1752 in a C++ program, for instance, does not have the fields that
1753 are expected here */
1755 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1757 /* Language is C++, do some overload resolution before evaluation */
1758 struct symbol
*symp
;
1761 /* If a scope has been specified disable ADL. */
1765 if (op
== OP_VAR_VALUE
)
1766 function
= exp
->elts
[save_pos1
+2].symbol
;
1768 /* Prepare list of argument types for overload resolution */
1769 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1770 for (ix
= 1; ix
<= nargs
; ix
++)
1771 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1773 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1774 NON_METHOD
/* not method */ , 0 /* strict match */ ,
1775 NULL
, function
/* the function */ ,
1776 NULL
, &symp
, NULL
, no_adl
);
1778 if (op
== OP_VAR_VALUE
)
1780 /* Now fix the expression being evaluated */
1781 exp
->elts
[save_pos1
+2].symbol
= symp
;
1782 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1786 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1790 /* Not C++, or no overload resolution allowed */
1791 /* nothing to be done; argvec already correctly set up */
1796 /* It is probably a C-style function */
1797 /* nothing to be done; argvec already correctly set up */
1802 if (noside
== EVAL_SKIP
)
1804 if (argvec
[0] == NULL
)
1805 error (_("Cannot evaluate function -- may be inlined"));
1806 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1808 /* If the return type doesn't look like a function type, call an
1809 error. This can happen if somebody tries to turn a variable into
1810 a function call. This is here because people often want to
1811 call, eg, strcmp, which gdb doesn't know is a function. If
1812 gdb isn't asked for it's opinion (ie. through "whatis"),
1813 it won't offer it. */
1815 struct type
*ftype
= value_type (argvec
[0]);
1817 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1819 /* We don't know anything about what the internal
1820 function might return, but we have to return
1822 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1825 else if (TYPE_TARGET_TYPE (ftype
))
1826 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1828 error (_("Expression of type other than \"Function returning ...\" used as function"));
1830 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1831 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1832 argvec
[0], nargs
, argvec
+ 1);
1834 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1835 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1837 case OP_F77_UNDETERMINED_ARGLIST
:
1839 /* Remember that in F77, functions, substring ops and
1840 array subscript operations cannot be disambiguated
1841 at parse time. We have made all array subscript operations,
1842 substring operations as well as function calls come here
1843 and we now have to discover what the heck this thing actually was.
1844 If it is a function, we process just as if we got an OP_FUNCALL. */
1846 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1849 /* First determine the type code we are dealing with. */
1850 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1851 type
= check_typedef (value_type (arg1
));
1852 code
= TYPE_CODE (type
);
1854 if (code
== TYPE_CODE_PTR
)
1856 /* Fortran always passes variable to subroutines as pointer.
1857 So we need to look into its target type to see if it is
1858 array, string or function. If it is, we need to switch
1859 to the target value the original one points to. */
1860 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1862 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1863 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1864 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1866 arg1
= value_ind (arg1
);
1867 type
= check_typedef (value_type (arg1
));
1868 code
= TYPE_CODE (type
);
1874 case TYPE_CODE_ARRAY
:
1875 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1876 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1878 goto multi_f77_subscript
;
1880 case TYPE_CODE_STRING
:
1881 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1882 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1885 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1886 return value_subscript (arg1
, value_as_long (arg2
));
1890 case TYPE_CODE_FUNC
:
1891 /* It's a function call. */
1892 /* Allocate arg vector, including space for the function to be
1893 called in argvec[0] and a terminating NULL */
1894 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1897 for (; tem
<= nargs
; tem
++)
1898 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1899 argvec
[tem
] = 0; /* signal end of arglist */
1903 error (_("Cannot perform substring on this type"));
1907 /* We have a complex number, There should be 2 floating
1908 point numbers that compose it */
1910 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1911 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1913 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1915 case STRUCTOP_STRUCT
:
1916 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1917 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1918 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1919 if (noside
== EVAL_SKIP
)
1921 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1922 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1923 &exp
->elts
[pc
+ 2].string
,
1928 struct value
*temp
= arg1
;
1930 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1935 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1936 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1937 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1938 if (noside
== EVAL_SKIP
)
1941 /* Check to see if operator '->' has been overloaded. If so replace
1942 arg1 with the value returned by evaluating operator->(). */
1943 while (unop_user_defined_p (op
, arg1
))
1945 volatile struct gdb_exception except
;
1946 struct value
*value
= NULL
;
1947 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1949 value
= value_x_unop (arg1
, op
, noside
);
1952 if (except
.reason
< 0)
1954 if (except
.error
== NOT_FOUND_ERROR
)
1957 throw_exception (except
);
1962 /* JYG: if print object is on we need to replace the base type
1963 with rtti type in order to continue on with successful
1964 lookup of member / method only available in the rtti type. */
1966 struct type
*type
= value_type (arg1
);
1967 struct type
*real_type
;
1968 int full
, top
, using_enc
;
1969 struct value_print_options opts
;
1971 get_user_print_options (&opts
);
1972 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1973 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1975 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1978 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1979 real_type
= lookup_pointer_type (real_type
);
1981 real_type
= lookup_reference_type (real_type
);
1983 arg1
= value_cast (real_type
, arg1
);
1988 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1989 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1990 &exp
->elts
[pc
+ 2].string
,
1995 struct value
*temp
= arg1
;
1997 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1998 NULL
, "structure pointer");
2001 case STRUCTOP_MEMBER
:
2003 if (op
== STRUCTOP_MEMBER
)
2004 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2006 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2008 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2010 if (noside
== EVAL_SKIP
)
2013 type
= check_typedef (value_type (arg2
));
2014 switch (TYPE_CODE (type
))
2016 case TYPE_CODE_METHODPTR
:
2017 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2018 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2021 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2022 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2023 return value_ind (arg2
);
2026 case TYPE_CODE_MEMBERPTR
:
2027 /* Now, convert these values to an address. */
2028 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
2031 mem_offset
= value_as_long (arg2
);
2033 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2034 value_as_long (arg1
) + mem_offset
);
2035 return value_ind (arg3
);
2038 error (_("non-pointer-to-member value used in pointer-to-member construct"));
2042 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2043 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2044 for (ix
= 0; ix
< nargs
; ++ix
)
2045 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
2047 expect_type
= make_params (nargs
, arg_types
);
2048 *(pos
) += 3 + nargs
;
2049 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
2050 xfree (TYPE_FIELDS (expect_type
));
2051 xfree (TYPE_MAIN_TYPE (expect_type
));
2052 xfree (expect_type
);
2056 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2057 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2058 if (noside
== EVAL_SKIP
)
2060 if (binop_user_defined_p (op
, arg1
, arg2
))
2061 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2063 return value_concat (arg1
, arg2
);
2066 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2067 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2069 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2071 if (binop_user_defined_p (op
, arg1
, arg2
))
2072 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2074 return value_assign (arg1
, arg2
);
2076 case BINOP_ASSIGN_MODIFY
:
2078 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2079 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2080 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2082 op
= exp
->elts
[pc
+ 1].opcode
;
2083 if (binop_user_defined_p (op
, arg1
, arg2
))
2084 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2085 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2087 && is_integral_type (value_type (arg2
)))
2088 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2089 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2091 && is_integral_type (value_type (arg2
)))
2092 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2095 struct value
*tmp
= arg1
;
2097 /* For shift and integer exponentiation operations,
2098 only promote the first argument. */
2099 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2100 && is_integral_type (value_type (arg2
)))
2101 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2103 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2105 arg2
= value_binop (tmp
, arg2
, op
);
2107 return value_assign (arg1
, arg2
);
2110 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2111 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2112 if (noside
== EVAL_SKIP
)
2114 if (binop_user_defined_p (op
, arg1
, arg2
))
2115 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2116 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2117 && is_integral_type (value_type (arg2
)))
2118 return value_ptradd (arg1
, value_as_long (arg2
));
2119 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2120 && is_integral_type (value_type (arg1
)))
2121 return value_ptradd (arg2
, value_as_long (arg1
));
2124 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2125 return value_binop (arg1
, arg2
, BINOP_ADD
);
2129 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2130 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2131 if (noside
== EVAL_SKIP
)
2133 if (binop_user_defined_p (op
, arg1
, arg2
))
2134 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2135 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2136 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2138 /* FIXME -- should be ptrdiff_t */
2139 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2140 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2142 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2143 && is_integral_type (value_type (arg2
)))
2144 return value_ptradd (arg1
, - value_as_long (arg2
));
2147 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2148 return value_binop (arg1
, arg2
, BINOP_SUB
);
2159 case BINOP_BITWISE_AND
:
2160 case BINOP_BITWISE_IOR
:
2161 case BINOP_BITWISE_XOR
:
2162 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2163 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2164 if (noside
== EVAL_SKIP
)
2166 if (binop_user_defined_p (op
, arg1
, arg2
))
2167 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2170 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2171 fudge arg2 to avoid division-by-zero, the caller is
2172 (theoretically) only looking for the type of the result. */
2173 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2174 /* ??? Do we really want to test for BINOP_MOD here?
2175 The implementation of value_binop gives it a well-defined
2178 || op
== BINOP_INTDIV
2181 && value_logical_not (arg2
))
2183 struct value
*v_one
, *retval
;
2185 v_one
= value_one (value_type (arg2
), not_lval
);
2186 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2187 retval
= value_binop (arg1
, v_one
, op
);
2192 /* For shift and integer exponentiation operations,
2193 only promote the first argument. */
2194 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2195 && is_integral_type (value_type (arg2
)))
2196 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2198 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2200 return value_binop (arg1
, arg2
, op
);
2205 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2206 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2207 if (noside
== EVAL_SKIP
)
2209 error (_("':' operator used in invalid context"));
2211 case BINOP_SUBSCRIPT
:
2212 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2213 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2214 if (noside
== EVAL_SKIP
)
2216 if (binop_user_defined_p (op
, arg1
, arg2
))
2217 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2220 /* If the user attempts to subscript something that is not an
2221 array or pointer type (like a plain int variable for example),
2222 then report this as an error. */
2224 arg1
= coerce_ref (arg1
);
2225 type
= check_typedef (value_type (arg1
));
2226 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2227 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2229 if (TYPE_NAME (type
))
2230 error (_("cannot subscript something of type `%s'"),
2233 error (_("cannot subscript requested type"));
2236 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2237 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2239 return value_subscript (arg1
, value_as_long (arg2
));
2243 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2244 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2245 if (noside
== EVAL_SKIP
)
2247 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2248 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
2250 case MULTI_SUBSCRIPT
:
2252 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2253 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2256 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2257 /* FIXME: EVAL_SKIP handling may not be correct. */
2258 if (noside
== EVAL_SKIP
)
2269 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2270 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2272 /* If the user attempts to subscript something that has no target
2273 type (like a plain int variable for example), then report this
2276 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2279 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2285 error (_("cannot subscript something of type `%s'"),
2286 TYPE_NAME (value_type (arg1
)));
2290 if (binop_user_defined_p (op
, arg1
, arg2
))
2292 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2296 arg1
= coerce_ref (arg1
);
2297 type
= check_typedef (value_type (arg1
));
2299 switch (TYPE_CODE (type
))
2302 case TYPE_CODE_ARRAY
:
2303 case TYPE_CODE_STRING
:
2304 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2307 case TYPE_CODE_BITSTRING
:
2308 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2309 arg1
= value_bitstring_subscript (type
, arg1
,
2310 value_as_long (arg2
));
2314 if (TYPE_NAME (type
))
2315 error (_("cannot subscript something of type `%s'"),
2318 error (_("cannot subscript requested type"));
2324 multi_f77_subscript
:
2326 int subscript_array
[MAX_FORTRAN_DIMS
];
2327 int array_size_array
[MAX_FORTRAN_DIMS
];
2328 int ndimensions
= 1, i
;
2329 struct type
*tmp_type
;
2330 int offset_item
; /* The array offset where the item lives */
2332 if (nargs
> MAX_FORTRAN_DIMS
)
2333 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2335 tmp_type
= check_typedef (value_type (arg1
));
2336 ndimensions
= calc_f77_array_dims (type
);
2338 if (nargs
!= ndimensions
)
2339 error (_("Wrong number of subscripts"));
2341 gdb_assert (nargs
> 0);
2343 /* Now that we know we have a legal array subscript expression
2344 let us actually find out where this element exists in the array. */
2347 /* Take array indices left to right */
2348 for (i
= 0; i
< nargs
; i
++)
2350 /* Evaluate each subscript, It must be a legal integer in F77 */
2351 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2353 /* Fill in the subscript and array size arrays */
2355 subscript_array
[i
] = value_as_long (arg2
);
2358 /* Internal type of array is arranged right to left */
2359 for (i
= 0; i
< nargs
; i
++)
2361 upper
= f77_get_upperbound (tmp_type
);
2362 lower
= f77_get_lowerbound (tmp_type
);
2364 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
2366 /* Zero-normalize subscripts so that offsetting will work. */
2368 subscript_array
[nargs
- i
- 1] -= lower
;
2370 /* If we are at the bottom of a multidimensional
2371 array type then keep a ptr to the last ARRAY
2372 type around for use when calling value_subscript()
2373 below. This is done because we pretend to value_subscript
2374 that we actually have a one-dimensional array
2375 of base element type that we apply a simple
2379 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
2382 /* Now let us calculate the offset for this item */
2384 offset_item
= subscript_array
[ndimensions
- 1];
2386 for (i
= ndimensions
- 1; i
> 0; --i
)
2388 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
2390 /* Let us now play a dirty trick: we will take arg1
2391 which is a value node pointing to the topmost level
2392 of the multidimensional array-set and pretend
2393 that it is actually a array of the final element
2394 type, this will ensure that value_subscript()
2395 returns the correct type value */
2397 deprecated_set_value_type (arg1
, tmp_type
);
2398 return value_subscripted_rvalue (arg1
, offset_item
, 0);
2401 case BINOP_LOGICAL_AND
:
2402 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2403 if (noside
== EVAL_SKIP
)
2405 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2410 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2413 if (binop_user_defined_p (op
, arg1
, arg2
))
2415 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2416 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2420 tem
= value_logical_not (arg1
);
2421 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2422 (tem
? EVAL_SKIP
: noside
));
2423 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2424 return value_from_longest (type
,
2425 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2428 case BINOP_LOGICAL_OR
:
2429 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2430 if (noside
== EVAL_SKIP
)
2432 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2437 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2440 if (binop_user_defined_p (op
, arg1
, arg2
))
2442 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2443 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2447 tem
= value_logical_not (arg1
);
2448 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2449 (!tem
? EVAL_SKIP
: noside
));
2450 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2451 return value_from_longest (type
,
2452 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2456 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2457 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2458 if (noside
== EVAL_SKIP
)
2460 if (binop_user_defined_p (op
, arg1
, arg2
))
2462 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2466 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2467 tem
= value_equal (arg1
, arg2
);
2468 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2469 return value_from_longest (type
, (LONGEST
) tem
);
2472 case BINOP_NOTEQUAL
:
2473 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2474 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2475 if (noside
== EVAL_SKIP
)
2477 if (binop_user_defined_p (op
, arg1
, arg2
))
2479 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2483 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2484 tem
= value_equal (arg1
, arg2
);
2485 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2486 return value_from_longest (type
, (LONGEST
) ! tem
);
2490 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2491 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2492 if (noside
== EVAL_SKIP
)
2494 if (binop_user_defined_p (op
, arg1
, arg2
))
2496 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2500 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2501 tem
= value_less (arg1
, arg2
);
2502 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2503 return value_from_longest (type
, (LONGEST
) tem
);
2507 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2508 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2509 if (noside
== EVAL_SKIP
)
2511 if (binop_user_defined_p (op
, arg1
, arg2
))
2513 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2517 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2518 tem
= value_less (arg2
, arg1
);
2519 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2520 return value_from_longest (type
, (LONGEST
) tem
);
2524 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2525 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2526 if (noside
== EVAL_SKIP
)
2528 if (binop_user_defined_p (op
, arg1
, arg2
))
2530 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2534 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2535 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2536 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2537 return value_from_longest (type
, (LONGEST
) tem
);
2541 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2542 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2543 if (noside
== EVAL_SKIP
)
2545 if (binop_user_defined_p (op
, arg1
, arg2
))
2547 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2551 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2552 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2553 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2554 return value_from_longest (type
, (LONGEST
) tem
);
2558 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2559 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2560 if (noside
== EVAL_SKIP
)
2562 type
= check_typedef (value_type (arg2
));
2563 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2564 error (_("Non-integral right operand for \"@\" operator."));
2565 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2567 return allocate_repeat_value (value_type (arg1
),
2568 longest_to_int (value_as_long (arg2
)));
2571 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2574 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2575 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2578 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2579 if (noside
== EVAL_SKIP
)
2581 if (unop_user_defined_p (op
, arg1
))
2582 return value_x_unop (arg1
, op
, noside
);
2585 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2586 return value_pos (arg1
);
2590 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2591 if (noside
== EVAL_SKIP
)
2593 if (unop_user_defined_p (op
, arg1
))
2594 return value_x_unop (arg1
, op
, noside
);
2597 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2598 return value_neg (arg1
);
2601 case UNOP_COMPLEMENT
:
2602 /* C++: check for and handle destructor names. */
2603 op
= exp
->elts
[*pos
].opcode
;
2605 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2606 if (noside
== EVAL_SKIP
)
2608 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2609 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2612 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2613 return value_complement (arg1
);
2616 case UNOP_LOGICAL_NOT
:
2617 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2618 if (noside
== EVAL_SKIP
)
2620 if (unop_user_defined_p (op
, arg1
))
2621 return value_x_unop (arg1
, op
, noside
);
2624 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2625 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2629 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2630 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2631 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2632 type
= check_typedef (value_type (arg1
));
2633 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2634 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2635 error (_("Attempt to dereference pointer to member without an object"));
2636 if (noside
== EVAL_SKIP
)
2638 if (unop_user_defined_p (op
, arg1
))
2639 return value_x_unop (arg1
, op
, noside
);
2640 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2642 type
= check_typedef (value_type (arg1
));
2643 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2644 || TYPE_CODE (type
) == TYPE_CODE_REF
2645 /* In C you can dereference an array to get the 1st elt. */
2646 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2648 return value_zero (TYPE_TARGET_TYPE (type
),
2650 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2651 /* GDB allows dereferencing an int. */
2652 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2655 error (_("Attempt to take contents of a non-pointer value."));
2658 /* Allow * on an integer so we can cast it to whatever we want.
2659 This returns an int, which seems like the most C-like thing to
2660 do. "long long" variables are rare enough that
2661 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2662 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2663 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2664 (CORE_ADDR
) value_as_address (arg1
));
2665 return value_ind (arg1
);
2668 /* C++: check for and handle pointer to members. */
2670 op
= exp
->elts
[*pos
].opcode
;
2672 if (noside
== EVAL_SKIP
)
2674 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2679 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
2685 if (noside
== EVAL_SKIP
)
2687 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2690 return evaluate_subexp_for_sizeof (exp
, pos
);
2694 type
= exp
->elts
[pc
+ 1].type
;
2695 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2696 if (noside
== EVAL_SKIP
)
2698 if (type
!= value_type (arg1
))
2699 arg1
= value_cast (type
, arg1
);
2702 case UNOP_DYNAMIC_CAST
:
2704 type
= exp
->elts
[pc
+ 1].type
;
2705 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2706 if (noside
== EVAL_SKIP
)
2708 return value_dynamic_cast (type
, arg1
);
2710 case UNOP_REINTERPRET_CAST
:
2712 type
= exp
->elts
[pc
+ 1].type
;
2713 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2714 if (noside
== EVAL_SKIP
)
2716 return value_reinterpret_cast (type
, arg1
);
2720 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2721 if (noside
== EVAL_SKIP
)
2723 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2724 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2726 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2727 value_as_address (arg1
));
2729 case UNOP_MEMVAL_TLS
:
2731 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2732 if (noside
== EVAL_SKIP
)
2734 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2735 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2740 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2741 value_as_address (arg1
));
2742 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2745 case UNOP_PREINCREMENT
:
2746 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2747 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2749 else if (unop_user_defined_p (op
, arg1
))
2751 return value_x_unop (arg1
, op
, noside
);
2755 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2756 arg2
= value_ptradd (arg1
, 1);
2759 struct value
*tmp
= arg1
;
2761 arg2
= value_one (value_type (arg1
), not_lval
);
2762 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2763 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2766 return value_assign (arg1
, arg2
);
2769 case UNOP_PREDECREMENT
:
2770 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2771 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2773 else if (unop_user_defined_p (op
, arg1
))
2775 return value_x_unop (arg1
, op
, noside
);
2779 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2780 arg2
= value_ptradd (arg1
, -1);
2783 struct value
*tmp
= arg1
;
2785 arg2
= value_one (value_type (arg1
), not_lval
);
2786 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2787 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2790 return value_assign (arg1
, arg2
);
2793 case UNOP_POSTINCREMENT
:
2794 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2795 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2797 else if (unop_user_defined_p (op
, arg1
))
2799 return value_x_unop (arg1
, op
, noside
);
2803 arg3
= value_non_lval (arg1
);
2805 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2806 arg2
= value_ptradd (arg1
, 1);
2809 struct value
*tmp
= arg1
;
2811 arg2
= value_one (value_type (arg1
), not_lval
);
2812 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2813 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2816 value_assign (arg1
, arg2
);
2820 case UNOP_POSTDECREMENT
:
2821 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2822 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2824 else if (unop_user_defined_p (op
, arg1
))
2826 return value_x_unop (arg1
, op
, noside
);
2830 arg3
= value_non_lval (arg1
);
2832 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2833 arg2
= value_ptradd (arg1
, -1);
2836 struct value
*tmp
= arg1
;
2838 arg2
= value_one (value_type (arg1
), not_lval
);
2839 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2840 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2843 value_assign (arg1
, arg2
);
2849 return value_of_this (1);
2853 return value_of_local ("self", 1);
2856 /* The value is not supposed to be used. This is here to make it
2857 easier to accommodate expressions that contain types. */
2859 if (noside
== EVAL_SKIP
)
2861 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2863 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2865 /* If this is a typedef, then find its immediate target. We
2866 use check_typedef to resolve stubs, but we ignore its
2867 result because we do not want to dig past all
2869 check_typedef (type
);
2870 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2871 type
= TYPE_TARGET_TYPE (type
);
2872 return allocate_value (type
);
2875 error (_("Attempt to use a type name as an expression"));
2878 /* Removing this case and compiling with gcc -Wall reveals that
2879 a lot of cases are hitting this case. Some of these should
2880 probably be removed from expression.h; others are legitimate
2881 expressions which are (apparently) not fully implemented.
2883 If there are any cases landing here which mean a user error,
2884 then they should be separate cases, with more descriptive
2888 GDB does not (yet) know how to evaluate that kind of expression"));
2892 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2895 /* Evaluate a subexpression of EXP, at index *POS,
2896 and return the address of that subexpression.
2897 Advance *POS over the subexpression.
2898 If the subexpression isn't an lvalue, get an error.
2899 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2900 then only the type of the result need be correct. */
2902 static struct value
*
2903 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2913 op
= exp
->elts
[pc
].opcode
;
2919 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2921 /* We can't optimize out "&*" if there's a user-defined operator*. */
2922 if (unop_user_defined_p (op
, x
))
2924 x
= value_x_unop (x
, op
, noside
);
2925 goto default_case_after_eval
;
2928 return coerce_array (x
);
2932 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2933 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2936 var
= exp
->elts
[pc
+ 2].symbol
;
2938 /* C++: The "address" of a reference should yield the address
2939 * of the object pointed to. Let value_addr() deal with it. */
2940 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2944 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2947 lookup_pointer_type (SYMBOL_TYPE (var
));
2948 enum address_class sym_class
= SYMBOL_CLASS (var
);
2950 if (sym_class
== LOC_CONST
2951 || sym_class
== LOC_CONST_BYTES
2952 || sym_class
== LOC_REGISTER
)
2953 error (_("Attempt to take address of register or constant."));
2956 value_zero (type
, not_lval
);
2959 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2962 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2963 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2964 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2965 &exp
->elts
[pc
+ 3].string
,
2968 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2973 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2974 default_case_after_eval
:
2975 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2977 struct type
*type
= check_typedef (value_type (x
));
2979 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2980 return value_zero (lookup_pointer_type (value_type (x
)),
2982 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2983 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2986 error (_("Attempt to take address of value not located in memory."));
2988 return value_addr (x
);
2992 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2993 When used in contexts where arrays will be coerced anyway, this is
2994 equivalent to `evaluate_subexp' but much faster because it avoids
2995 actually fetching array contents (perhaps obsolete now that we have
2998 Note that we currently only do the coercion for C expressions, where
2999 arrays are zero based and the coercion is correct. For other languages,
3000 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3001 to decide if coercion is appropriate.
3006 evaluate_subexp_with_coercion (struct expression
*exp
,
3007 int *pos
, enum noside noside
)
3016 op
= exp
->elts
[pc
].opcode
;
3021 var
= exp
->elts
[pc
+ 2].symbol
;
3022 type
= check_typedef (SYMBOL_TYPE (var
));
3023 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3024 && !TYPE_VECTOR (type
)
3025 && CAST_IS_CONVERSION (exp
->language_defn
))
3028 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3029 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3035 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3039 /* Evaluate a subexpression of EXP, at index *POS,
3040 and return a value for the size of that subexpression.
3041 Advance *POS over the subexpression. */
3043 static struct value
*
3044 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
3046 /* FIXME: This should be size_t. */
3047 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3054 op
= exp
->elts
[pc
].opcode
;
3058 /* This case is handled specially
3059 so that we avoid creating a value for the result type.
3060 If the result type is very big, it's desirable not to
3061 create a value unnecessarily. */
3064 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3065 type
= check_typedef (value_type (val
));
3066 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3067 && TYPE_CODE (type
) != TYPE_CODE_REF
3068 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3069 error (_("Attempt to take contents of a non-pointer value."));
3070 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3071 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3075 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
3076 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3080 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
3082 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3085 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3086 return value_from_longest (size_type
,
3087 (LONGEST
) TYPE_LENGTH (value_type (val
)));
3091 /* Parse a type expression in the string [P..P+LENGTH). */
3094 parse_and_eval_type (char *p
, int length
)
3096 char *tmp
= (char *) alloca (length
+ 4);
3097 struct expression
*expr
;
3100 memcpy (tmp
+ 1, p
, length
);
3101 tmp
[length
+ 1] = ')';
3102 tmp
[length
+ 2] = '0';
3103 tmp
[length
+ 3] = '\0';
3104 expr
= parse_expression (tmp
);
3105 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3106 error (_("Internal error in eval_type."));
3107 return expr
->elts
[1].type
;
3111 calc_f77_array_dims (struct type
*array_type
)
3114 struct type
*tmp_type
;
3116 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3117 error (_("Can't get dimensions for a non-array type"));
3119 tmp_type
= array_type
;
3121 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3123 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)